python成长之路——第八天

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

 

 
封装
类和对象的关系:
每个对象里都有一个类对象指针,指向类
 

 
继承:支持单继承和多继承
python成长之路——第八天
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有个缺点:查看源码的时候不是很方便
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)
1
2
3
4
 
 
 
 
 
 
上一篇:Windows下Docker承载ASP.NET Core 应用


下一篇:EBS技术开发之返利开发