Python笔记总结week8

面向对象第二节

要点：

1. 封装，对象中嵌套对象

2. pickle,load,切记，一定要先导入相关的类

回顾上一节：

面向对象三大特性：

封装、继承、多态（多种类型、多种形态）

关于多态，任意参数的函数有如下特性：

def func(arg):
    print(arg)
func(1)
func("Alex")
func([11,22,33])

关于arg参数：

class A:
    pass
class B(A):
    pass
class C(A):
    pass
#arg参数,必须是A类型或是A的子类类型
def func(A arg):
    print(arg)

#obj = B()
#obj = C()
obj = A()
func(obj)

面向对象中类成员

字段：静态字段、普通字段

P.S：静态字段代码加载的时候已经创建

class Foo:
    #字段(静态字段)
    CC = 123

    def __init__(self):
        #字段(普通字段)
        self.name = "Alex"

    def show(self):
        print(self.name)

class province:
    country = "China"
    def __init__(self,name):
        self.name = name
#一般情况,自己访问自己字段
#规则:
#普通字段只能用对象访问
#静态字段用类访问(万不得已时用对象访问)
hn = province("Henan")
hb = province("Hebei")
print(hn.name)   #Henan
print(province.country) #China
print(hn.country) #China

方法：

所有的方法属于类

1.普通方法，至少一个self，对象执行

2.静态方法，任意参数，类执行（对象执行）

3.类方法，至少一个class，类执行（对象执行）

class province:
    country = "China"

    def __init__(self,name):
        self.name = name
        #普通方法,用对象去调用执行(方法属于类)

    def show(self):
        print(123)

    @staticmethod
    def f1(cla,arg1,arg2):
        print(arg1,arg2)
        #静态方法,用类调用执行.(当方法内部不需要对象中封装的值时,可以将方法写成静态方法)

    @classmethod
    def f2(cls):  #class
        cls #类名,()创建对象
        #cls()
        print(cls)

obj = province("Henan")
obj.show() #
province.f1(province,1,2) #1 2
province.f2() #<class '__main__.province'>

class pager:

    def __init__(self,all_count):
        self.all_count = all_count

    @property
    def all_pager(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1 +1

    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print("del all_pager")

p = pager(101)
print(p.all_count) #字段,101
#result = p.all_pager()#方法
ret = p.all_pager
print(ret)    #
p.all_pager = 111 #
del p.all_pager  #del all_pager

属性：

不伦不类的东西

具有方法的写作形式，具有字段的访问形式

class foo:

    __cc = ""

    def __init__(self,name):
        self.name = name

    def f1(self):
        print(self.name)

obj = foo('alex')
print(obj.name) #alex
obj.f1() #alex

class Foo:

    __cc = ""

    def __init__(self,name):
        self.name = name  #定义一个私有的普通字段

    def f1(self):
        print(self.name)

    @staticmethod
    def f3():
        print(Foo.__cc)

#print(Foo.__cc)
obj = Foo("ddd")
obj.f3() #
Foo.f3() #

私有普通方法

class Foo:

    __cc = ""

    def __init__(self,name):
        self.__name = name  #定义一个私有的普通字段

    def f1(self):
        print(self.__name)

class Bar(Foo):

    def f2(self):
        print(self.__name)

obj = Bar("alex")
obj.f1() #alex   #通过调用类中的公有方法来执行私有方法

私有静态法

class Foo:

    def __init__(self,name):
        self.__name = name  #定义一个私有的普通字段

    @staticmethod
    def f2(num):
        print(num)

    @staticmethod
    def f3(num):
        print(num)

Foo.f3(10)  #

class Foo:
    #构造方法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #析构方法
    def __del__(self):
        pass

    def __call__(self):
        print("call")

    def __str__(self):
        return("%s-%d"%(self.name,self.age))

'''obj = Foo()
obj() #对象()执行call
#Foo()()'''

obj1 = Foo('alex',74)
obj2 = Foo('eric',93)
print(obj1,obj2) #alex-74 eric-93

ret =str(obj1)
print(ret)   #alex-74

#获取对象中封装的数据
ret = obj1.__dict__
print(ret)   #{'name': 'alex', 'age': 74}