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

/ \

C E

| |

B D

\ /

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

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

jack

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

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

123

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

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

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"]

张士杰

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

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

posted @ 2016-07-02 11:28 meitangyanyan 阅读(176) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

meitangyanyan

python成长之路——第八天

公告