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