python学习-面向对象

时间：2022-11-28 06:50:37

面向对象

python学习-面向对象

编程方式的区别

  • 过程式编程

  • 函数式编程

  • 面向对象式编程

面向对象编程

对象是类的一个实例

  • 创建
class foo():

    def __init__(self):   #类的构造方法

        pass

    def doing(self):    #类的其他自定义方法

        pass
  • 实例化
    #根据我们创建的类来实例化一个对象

obj_foo = foo()  #实例化了一个对象，所以称对象是类的一个实例化
  • 类的方法调用
 obj_foo.doing()
  • 构造方法__init__,会在对象创建的过程中被自动执行
class foo():

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def doing(self):    #类的其他自定义方法

        pass

    def speak(self):

        print("My name is %s" %(self.name))

obj_foo = foo(“ Leon”,22)

obj_foo.speak()

>>>My name is  Leon
  • 析构方法 __del__会在当对象在内存中被释放时，自动触发执行

三大特性之-封装

  • 构造方法:__init__(self,*args,**kwargs)来接受类实例化过程的中封装传入的参数。构造完成后，每个类的实例都具有这样的的属性，属性的值确定要根据类的实例化过程传入的参数来确定
class foo(object):

    def __init__(self,name,age,sex):

        self.name = name

        self.age = age

        self.sex = sex

    def talk(self):

        print("My name is {name},{age} years old!".format(name=self.name,age=self.age))

    def detail(self):

        print(self.name)

        print(self.age)

        print(self.sex)
  1. 对象实例化,调用类对对象进行实例化,实例化完成后，传入以下参数，那么这个obj_1就会具有对应的属性
  2. 实例化过程中会自动执行对象的构造方法 __init__进行封装
obj_1 = foo("forsaken",22,"man")
  1. 对象实例化完成后，就可以调用被封装的内容
  2. 通过对象直接调用
print(obj_1.name)

print(obj_1.age)

print(obj_1.sex)
  1. 通过类中的方法使用self调用，此处为detail
  • 类中的几种属性
    • 私有属性
    • 公有属性
    • 成员属性
class Role(object): 

    #定义公有属性

    international_organization = "WTO"

    def __init__(self,name,role,weapon,life_value=100,money=15000):

        self.name = name

        self.role = role

        self.weapon = weapon

        self.life_value = life_value

        self.money = money

        self.__heart = "healthy"  #私有属性

    def buy_gun(self, gun_name):

        print(" %s has just bought % s" % (self.name, gun_name) )

        #修改成员属性

        self.weapon = gun_name

    def got_shot(self):

        print("ohh... I got shot...")

        self.__heart = "Died"  #私有属性只能在内部使用

        print(self.__heart)

    def shot(self):

        print("%s is shooting.."%self.name)

    def get_heart(self):

        return self.__heart

1.成员属性，即__init__方法中定义的属性

r1 = Role("Leon","FBI","ak-47")

print(r1.weapon)

>>>ak-47

r1.buy_gun("ak-68")

>>>Leon has just bought ak-68

print(r1.weapon)

>>>ak-68

2.私有属性__private_attr_name = value 通过这种方式定义，只能在内部访问

r1 = Role("Leon","FBI","ak-47")

r1.got_shot()

>>>ohh... I got shot...

>>>Died

2.1. 但是强制在外部访问的方式如下,但是不能更改,_类名__private_attr_name

print(r1._Role__heart)

2.2. 或者通过自己写的方法来return访问获取，如本例子中get_heart方法



print(r1.get_heart())

3.公有属性，需要在类中直接定义的属性即是公有属性，如本例中的international_organization

3.1. 属于本类的对象的实例都可以访问的属性称为公有属性

3.2. 实例化的两个对象都有这个international_organization属性

r2 = Role("Leon","police","shouqiang")

print(r1.international_organization)

>>>WTO

print(r2.international_organization)

>>>WTO

3.3. 程序运行，即使类没有实例化，该类的公有属性也被存放在了内存中，如下

print(Role.international_organization)

>>>WTO

3.4. 修改公有属性

3.4.1. 直接修改

Role.international_organization = "wwc"   #这样修改后类的实例都会更改

print(r1.international_organization)

>>>wwc

print(r2.international_organization)

>>>wwc

3.4.2. 通过实例修改，会在内存中的对象的对应地方创建一个international_organization字段来存新的值，而不会更改公有属性的值



r1.international_organization = "NBA"  #修改r1的值，不会更改r2的，应为r2还是使用共有中定义的

print(r1.international_organization)

>>>NBA

print(r2.international_organization)

>>>wwc

备注

寻找当前类实例的共有变量，会首先寻找该实例内存中是否有，如果没有再去共有属性中寻找

通过实例修改r1.international_organization = "NBA"，不会更改原有的公有属性，会在当前实例的队形内存中创建该变量，以便于下次使用

在内存中的解释为，即通过这种方式修改不会访问该变量的引用，而是修改了就会自己在保存一份

跟函数中的局部变量和全局变量的性质一样

4.类中的方法公有，只有一份共享

而类中的各种方法，都是共享的，实例化后不会重新创建某个方法

如果非要将方法私有化，可以使用下面的方法

将shut方法变成私有的方法

def shou4(self):

    print("run shot in my own method",self.name)

r1.shot = shou4

r1.shot(r1)

r2.shot()

三大特性之-继承

class f1(object):

    def show(self):

        print("show")

class f2(f1):

    def bar(self):

        print("bar")

  1. f2中并没有show方法，但是当 f2(f1)写了以后，就代表f2继承f1的方法，f1为f2的父类，f2为f1的子类

  2. 创建子类对象,但是可以执行父类f1中的方法

_obj_f2 = f2()

_obj_f2.show()
  1. python中的类可以有很多个父类

静态方法-类方法-属性方法



class Person(object):

    name = "Rain"

    def __init__(self,name):

        self.name = name

        self.__mes = None

    @staticmethod

    def eat(name,food): #静态方法即不能访问公有属性，也不能访问实例,只是相当于一个单纯的函数，跟类没有什么关系，但是需要类名来调用

        #不能使用实例的属性

        #不需要self

        #类似于* 中国*

        #类似于该类的一个工具包

        print("%s is eating..%s." % (name,food))

    @classmethod

    def walk(self): #类方法 只能访问类的公有属性， 不能访问实例属性

        #类方法可以用于类中的公有属性与成员变量相同时，强制访问公有属性

        print("%s is walking..."%self.name)  #此时的name仍然是公有属性的值

    @property #属性方法， 的作用是把一个方法变成一个静态属性

    def talk(self):

        #使用@property后，该方法变成一个静态属性，不能加括号进行调用，如果调用会NoneType xception

        print("%s says " %(self.name))

    @talk.setter  #通过这种方式为这个静态属性赋值，就可以传入参数

    def talk(self, msg):

        print("old msg:", self.__mes)

        self.__mes = msg   #这样就实现了修改

        print("set msg:", msg)

        print("set msg:", self.__mes)

    @talk.deleter   #正常类的属性，实例的实行可以被删除

    #那么使用这样的方式来删除属性方法

    def talk(self):

        del self.__mes  #删除了就不能再使用了

        print("delet talk...")

p1 = Person("leon")

p1.talk   #>>leon says

p1.talk = "set static attr"  #调用talk来实现talk的静态属性赋值

del p1.talk

类的特殊成员方法

1.__module__和__class__ 

class C:

    def __init__(self):

        self.name = 'wupeiqi'
from lib import C

obj = C()

print(obj.__module__)

  # 输出 lib即：输出模块

print(obj.__class__)

  #<class 'lib.C'>

2.__call__ 对象后面加括号，触发执行,区别于__init__

  • 构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:

    def __init__(self):

        pass

    def __call__(self, *args, **kwargs):

        print

        '__call__'

obj = Foo()  # 执行 __init__

obj()  # 执行 __call__

3.__dict__ 查看类或对象中的所有成员

class Province:

    country = 'China'

    def __init__(self, name, count):

        self.name = name

        self.count = count

    def func(self, *args, **kwargs):

        print('func')

 # 获取类的成员，即：公有属性、方法

print(Province.__dict__)

 #获取 对象obj1 的成员属性

obj1 = Province('HeBei',10000)

print(obj1.__dict__)

4.__str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值

class Foo:

    # def __str__(self):

    #     return 'Leon'

    pass

obj = Foo()

print(obj)

 #如果不定义__str__方法，那么返回该对象的内存地址<__main__.Foo object at 0x10d2c6dd8>

5.__getitem__、__setitem__、__delitem__用于索引操作，如字典。分别表示获取、设置、删除数据

class Foo(object):

    def __getitem__(self, key):

        print('__getitem__', key)

    def __setitem__(self, key, value):

        print('__setitem__', key, value)

    def __delitem__(self, key):

        print('__delitem__', key)

obj = Foo()

result = obj['k1']  # 自动触发执行 __getitem__

obj['k2'] = 'alex'  # 自动触发执行 __setitem__

del obj['k1']

6.__init__和__del__ 被称为构造方法和析构方法 

class SchoolMember(object):

    member = 0

    def __init__(self,name,age,sex):    #构造方法在实例化的过程中运行

        self.name = name

        self.age = age

        self.sex = sex

    def __del__(self):  #析构函数会在程序完成后吧每个对象的实例都删除

        print("把[%s]开除了"%self.name)

        SchoolMember.member -= 1

相关文章