python成长之路——第八天

pickle,load :切记：如果load的是个对象的话，必须导入构建这个对象的类

 

---

 

封装

类和对象的关系：

每个对象里都有一个类对象指针，指向类

 

---

 

继承：支持单继承和多继承

print(
'''
继承顺序:ABCDEF 先左后右，深度优先，最后找祖宗
    F
  /   \ 
C       E
|       |
B       D
  \   /
    A
''')
class F:
    def f3(self):
        print("F f3")
class C(F):
    def f1(self):
        print("C f1")
class E(F):
    def f1(self):
        print("E f1")
class B(C):
    def f2(self):
        print("B f2")
class D(E):
    def f2(self):
        print("D f2")
    def f1(self):
        print(“D f1")
    def f3(self):
        print("D f3")
class A(B,D):
    pass
obj=A()
print("B和D继承关系:先左后右")
obj.f2()
print("C和D继承关系:深度优先")
obj.f1()
print("F和D的继承关系:如果有共同的祖宗的话最后找祖宗")
obj.f3()

继承顺序:ABCDEF

    F

  /   \ 

C       E

|         |

B       D

  \   /

    A

 

B和D继承关系:先左后右

B f2

C和D继承关系:深度优先

C f1

F和D的继承关系:如果有共同的祖宗的话最后找祖宗

D f3

 

---

 

多态：多种形态，多种数据类型，python原生支持多态，别的语言不支持

但是这样python有个缺点：查看源码的时候不是很方便

 

 

---

 

面向对象中类成员：

字段：

静态字段：保存在类里  把所有对象里相同的字段放到类里 叫静态字段  在程序加载的时候就会创建

普通字段：保存在对象里  

一般情况：普通字段只能用对象访问，静态字段用类访问，万不得已可以用对象访问（对象里有类对象指针，可以找到类里的字段）

原则：自己访问自己的

 

        

class Province:
    country=“中国"  #静态字段
    def __init__(self,province):
        self.province=province  #普通字段
print("#######一般情况:自己访问自己的字段######")
sx=Province("山西")
print(Province.country)
print(sx.province)
print("#####python不一般:对象里的字段只能用对象访问,静态字段用类访问(万不得已的时候可以用对象访问)#####")
print(sx.country)

#######一般情况:自己访问自己的字段######

中国

山西

#####python不一般:对象里的字段只能用对象访问,静态字段用类访问(万不得已的时候可以用对象访问)#####

中国

 

 

---

 

 

方法：所有方法属于类

   普通方法：由对象调用使用的                                  至少一个self

   静态方法：由类调用使用的   =  python函数     任意参数

   类方法   ： 由类执行                                                至少一个cls

class Province:
    country="中国"
    def __init__(self,province):
        self.province=province
    def show(self):  #普通方法
        print(self.province)
    @staticmethod
    def static():  #静态方法
        print(123)

Province.static()

123

class Province:
    country="中国"
    def __init__(self,province):
        self.province=province
    def show(self):  #普通方法
        print(self.province)
    @classmethod
    def class_func(cls): #类方法 cls是class的缩写,代指类 类似self代指对象
        sx=cls("山西")
        sx.show()

Province.class_func()

 

山西

 

---

 

属性：调用时可以去掉括号，让方法以字段的形式进行访问

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

 

class Province:
    country="中国"
    def __init__(self,province):
        self.province=province
    @property
    def show(self):  #属性
        return  self.province

sx=Province("山西")
province=sx.show
print(province)

山西

class C:
    def __init__(self,total):
        self.total=total
    @property
    def f1(self):
        return self.total
    @f1.setter
    def f1(self,value):
        print(value)
    @f1.deleter
    def f1(self):
        print("i am del")

c=C(101)
ret = c.f1
print(ret)
c.f1=100
del c.f1

101

100

i am del

class C:
    def __init__(self,total):
        self.total=total
    def f1(self):
        return self.total
    def f2(self,value):
        print(value)
    def f3(self):
        print("i am del")
    Foo=property(fget=f1,fset=f2,fdel=f3)
c=C(101)
ret = c.Foo
print(ret)
c.Foo = 100
del c.Foo

101

100

i am del

 

---

 

成员修饰符：

字段：

私有字段: 字段名前加两个下划线（self.__name） 只有自己本身self可以用

私有方法

私有属性

class C1:
    __age=18
    def __init__(self,name):
        self.__name=name
    def f1(self):
        print(self.__name)
    @staticmethod
    def f3():
        print(C1.__age)

class C2(C1):
    def f2(self):
        print(self.__name)

p=C1("jack")
p.f1()
# p2=C2("zy")
# p2.f2() #错误
p.f3()
# print(C1.__age) #错误
# print(p.__name) #错误
print("####以下是非一般情况,尽量别用####")
print(p._C1__name)
print(p._C1__age)

jack

18

####以下是非一般情况,尽量别用####

jack

18

class C1:
    def __f1(self):
        print("123")
    def f2(self):
        self.__f1()

p=C1()
p.f2()
p._C1__f1()  #非一般情况,最后别用
# p.__f1()     #错误

123

123

class C1:
    @property
    def __f1(self):
        print("123")
    def f2(self):
        self.__f1

p=C1()
p.f2()
p._C1__f1  #非一般情况,最后别用
# p.__f1     #错误

123

123

 

特殊方法：

__init__：构造方法                                            类()

__del__：析构方法

__call__:                                              对象()  类()()

__str__:    __str__方法return返回值                    对象

__dict__:  获取对象（或类）中封装的所有数据    

__getitem__ :

__setitem__ :

__delitem__ :

__iter__ :

class C1:
    '''
    这是个使用__str__方法的类
    也是个使用__call__方法的类
    '''
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return self.name
    def __call__(self):
        print("执行call方法")
class C2:
    pass
print(C1.__doc__)
print("#####没有__str__方法#####")
p3=C2()
print(p3)
print("#####__str__第一种方式#####")
p1=C1('alex')
print(p1)
print("#####__str__第二种方式#####")
p2=C1('jack')
ret = str(p2)
print(ret)
print("#####__call__#####")
p1()

    这是个使用__str__方法的类

    也是个使用__call__方法的类

    

#####没有__str__方法#####

<__main__.C2 object at 0x101976d68>

#####__str__第一种方式#####

alex

#####__str__第二种方式#####

jack

#####__call__#####

执行call方法

class C1:
    def __init__(self,name,age):
        self.name = name
        self.age = age

p1=C1('alex',18)
print(p1.__dict__)

{'name': 'alex', 'age': 18}

class C1:
    def __init__(self,name,age):
        self.name = name
        self.age = age

print(C1.__dict__)  #一般不用

{'__weakref__': <attribute '__weakref__' of 'C1' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'C1' objects>, '__init__': <function C1.__init__ at 0x10217a6a8>, '__module__': '__main__'}

dic={}
class C1:
    def __getitem__(self, item):
        print(dic[item])
    def __setitem__(self, key, value):
        dic[key]=value
    def __delitem__(self, key):
        del dic[key]
obj=C1()
obj[0]=00
obj[1]=11
obj[2]=22
obj["jack"]="张士杰"
del obj[1]
obj[0]
obj[2]
obj["jack"]

00

22

张士杰

class Foo:
    def __iter__(self):
        for i in range(5):
            yield i

obj=Foo()
for item in obj:
    print(item)

0

1

2

3

4