一，面向对象基础1
c#、Java:只能用面向对象编程
Ruby、python、php:函数编程 + 面向对象
1.面向过程编程2
就是程序最底层的实现过程
2.函数式编程3
就是将最底层的实现过程封装到函数里，调用函数的方法编程
3面向对象编程4
就是将若干函数封装到一个类里，调用类来实现里面的函数方法
注意：面向对象不是所有情况都适用 5
面向对象编程6
需要定义一个类 ，将功能函数写在类里，这样类里面的函数就叫做，实现一个类功能的方法，要使用这个类的方法时，创建这个类的对象赋值给一个变量，通过对象变量找到这个类下面的功能函数来实现（功能）的方法
#!/usr/bin/env python # -*- coding:utf-8 -*- class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self,a): #方法1 return a + 1 def f2(self,b): #方法2 pass def f3(self,c): #方法3 pass a1 = fgjk() #创建类对象赋值给一个变量 a2 = a1.f1(3) #调用类下面的一个函数传入参数，来实现一个功能，叫做方法 print(a2) #打印出这个方法的结果 #输出fgjk类下面的f1()方法 # 4
class关键字，定义一个类7
功能：定义一个类
使用方法：class 类名称:
格式：class fgjk:
#!/usr/bin/env python # -*- coding:utf-8 -*- class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self,a): #方法1 return a + 1 def f2(self,b): #方法2 pass def f3(self,c): #方法3 pass
定义好类后，将功能函数（方法）写在类里，注意：类里面的函数有一个必写值self8
#!/usr/bin/env python # -*- coding:utf-8 -*- class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self,a): #方法1 return a + 1 def f2(self,b): #方法2 pass def f3(self,c): #方法3 pass
self是一个形式参数，这个形式参数是用来，在执行类方法时接收类对象返回值的，9
注意：类对象的返回值是由python自动当做实参，传入类方法函数的self，不需要我们写，由python自动完成
#!/usr/bin/env python # -*- coding:utf-8 -*- """定义类和类的方法""" class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self,a): #方法1 print("打印self接收的类对象值",self) return a #返回值 """创建类的对象和是使用类的方法""" a1 = fgjk() #创建类对象赋值给一个变量 print("打印类对象值",a1) #注意：类对象的值是由python自动当做实参，传入类方法函数的，不需要我们写，由python自动完成，相当于下面写的a1.f1(a1,3) a2 = a1.f1(3) #调用类下面的一个函数传入参数，来实现一个功能，叫做方法 print("打印返回值",a2) #打印出这个方法的结果 # 输出 # 打印类对象值 <__main__.fgjk object at 0x0000006685D37160> # 打印self接收的类对象值 <__main__.fgjk object at 0x0000006685D37160> # 打印返回值 3
定义好类和写好函数方法后，创建这个类的对象赋值给一个变量，通过变量找到这个类下面的功能函数来实现（功能）的方法 ， 创建类对象也叫做（创建Foo类的实列）10
#!/usr/bin/env python # -*- coding:utf-8 -*- """定义类和类的方法""" class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self,a): #方法1 return a + 1 def f2(self,b): #方法2 pass def f3(self,c): #方法3 pass """创建类对象和使用类的方法""" a1 = fgjk() #创建类对象赋值给一个变量 a2 = a1.f1(3) #调用类下面的一个函数传入参数，来实现一个功能，叫做方法 print(a2) #打印出这个方法的结果 #输出fgjk类下面的f1()方法 # 4
面向对象原理图11
封装12
封装就是给对象封装普通字段
面向对象封装之，在类的对象里封装变量和变量值，非主流方法【不推荐】13
就是在类的对象里封装变量和变量值，封装后使用类函数方法时不需要传值，在类函数方法里通过self来获取类对象里的值即可
给类对象添加变量：创建对象变量.要添加的变量名称 = 变量值 如a1.zhi = xx
类方法函数获取对象变量：在方法函数里通过接收对象的self来获取，self.添加的类对象变量名称，这样就可以获取到类对象的值
#!/usr/bin/env python # -*- coding:utf-8 -*- """面向对象封装之，给类对象封装变量和变量值""" class fgjk: #定义一个类,在类里写函数来实现类的方法 def f1(self): #方法1 b = self.zhi + 5 #获取类对象里的zhi变量的值加5 c = b + self.zhi2 #用b结果加类对象里的zhi2变量值 return c """创建类的对象和使用类的方法""" a1 = fgjk() #创建类对象赋值给一个变量 a1.zhi = 5 #给类对象封装一个变量和值 a1.zhi2 = 10 #给类对象封装一个变量和值 a2 = a1.f1() #执行类方法 print(a2) #打印出方法结果 # 输出 # 20
面向对象封装之，在类的对象里封装变量和变量值原理图14
__init__()构造方法，面向对象封装之，给类对象封装变量和变量值，主流方法 15
__init__(self)类方法函数，如果类里有定义__init__(self)类方法函数，创建对象后会自动执行__init__(self)方法函数的
使用方法：__init__(self,后面可以定义变量类接收对象传值然后封装到对象)
就是不在从类对象那里封装变量和值，从类的__init__(self)方法，向对象封装变量和值，因为只要创建对象后，python就会默认执行类的__init__(self)方法，然而对象的返回值是自动通过对象传值给类方法的self形式参数的，所以可以根据这个形式参数接收到的对象，向对象里封装变量和变量值
# -*- coding:utf-8 -*- """面向对象封装之，给类对象封装变量和变量值，主流方法""" class fgjk: #定义一个类,在类里写函数来实现类的方法 def __init__(self): print(self) self.adc = "你好" #通过self接收到的对象，向对象里封装变量和变量值 def f1(self): print(self.adc) """创建类的对象和使用类的方法""" a1 = fgjk() #创建类对象赋值给一个变量,并把类对象返回值传给类里面的方法函数的self形式参数 a1.f1() #执行类的方法函数 # 输出 # <__main__.fgjk object at 0x000000A5E652C518> # 你好
通过类方法的self给对象封装变量原理图16
__init__()构造方法，面向对象封装之，给类对象封装变量和变量值，主流方法2【推荐】17
# -*- coding:utf-8 -*- """面向对象封装之，给类对象封装变量和变量值，主流方法""" a = "变量值" class fgjk: #定义一个类,在类里写函数来实现类的方法 def __init__(self,b): print(self) self.adc = b #通过self接收到的对象，向对象里封装变量和变量值 def f1(self): print(self.adc) """创建类的对象和使用类的方法""" a1 = fgjk(a) #创建类对象赋值给一个变量,并把类对象返回值传给类里面的方法函数的self形式参数 a1.f1() #执行类的方法函数 # 输出 # <__main__.fgjk object at 0x000000A5E652C518> # 变量值
主流方法2【推荐】原理图18
注意:我们一般都是用构造方法2
__del__(self)解释器销毁对象时自动调用，我们只需要知道一些就行，这是python自动完成的，叫做析构方法19
封装总结20
使用场景，当同一类型的方法具有相同参数时，直接封装到对象即可
使用场景2：把类当做模板，创建多个对象（每个对象内封装的数据可以不一样）
创建类对象，和__init__()构造封装对象变量，叫做初始化
给对象封装的变量，叫做给对象创建普通字段
继承21
继承就是在定义类b时，可以在b类名称后面加上()括号里写上另外一个a类的名称，这样b类就会继承a类里的方法22
1.子类（派生类）、继承父类（基类）中的所有功能23
2.Python类可以同时继承多个父类（基类）（c#/Java不可以）24
3.继承的优先级，继承里有相同方法的优先级25
子类（派生类）、和父类（基类）同时存在一个方法是时，优先找子类（派生类），
如果是一个类继承了多个类，而且继承的多个类中有同样的方法是，优先从子类（派生类）()括号里的父类（基类）左边优先
如果是嵌套式继承，也就是一个类继承了多个基类，并且多个基类又继承了多个基类，这时是自己本身类优先，然后是上一级基类左边第一个优先，再者是左边第一个基类的上级基类优先，再者是左边第二基类优先以此类推
也就是说，首先是自身优先，然后是基类左边优先，然后是基类左边深度优先，以此类推的
如果嵌套式继承，最后有两个类都继承了同一个基类，这个被两个类继承的类不在深度查找，是最后查找这个类的
#!/usr/bin/env python # -*- coding:utf-8 -*- class lei: #定义lei类 def __init__(self,wb = ""): #接收定义lei对象里的传值 self.wb = wb #将定义lei对象里的传值封装到lei对象里 def f1(self): print("f1",self.wb) #打印f1和，lei对象里封装的wb变量 def f2(self): print("f2") def f3(self): print("f3") class lei2(lei): #定义lei2类并继承lei类的方法 def __init__(self,wb2 = ""): #接收定义lei2对象里的传值 self.wb2 = wb2 ##将定义lei2对象里的传值封装到lei2对象里 def j1(self): print("j1") def j2(self): print("j2",self.wb2) #打印j2和，lei2对象里封装的wb2变量 def j3(self): print("j3") a = lei("你好") #创建lei类对象，并传值到lei类__init__方法 a.f1() #执行类里的f1()方法 b = lei2("我好") #创建lei2类对象，并传值到lei2类__init__方法 b.f3() #执行lei2类继承的lei里的f3()方法 b.j2() #执行lei2类里的j2()方法 # 输出 # f1 你好 # f3 # j2 我好
继承原理图26
继承优先级说明图27
自身优先图28
基类左边第一个优先图29
左边深度优先图30
最后有两个类都继承了同一个基类，这个被两个类继承的类不在深度查找，是最后查找这个类的31
继承重点，self.XXX()继承容易错点，如果一个类继承了多个基类，并且基类里有self.XXX()方法，self实际就是创建的对象，self.xxx()就是又回到了创建对象的类里去找xxx()方法，如果创建的自身类里没有xxx()方法，就又从继承基类的左边第一个开始查找，在之深度等，以此按照前面说的优先级执行32
#!/usr/bin/env python # -*- coding:utf-8 -*- class a: #定义a类 def __init__(self,zhi = ""): self.zhi = zhi def f1(self): print("a") class b: #定义b类 def __init__(self,zhi = ""): self.zhi = zhi def b1(self): self.f1() class c: #定义c类 def __init__(self,zhi = ""): self.zhi = zhi def f1(self): print("c") class d(b,c,a): #定义d类 def __init__(self,zhi = ""): self.zhi = zhi fsa = d("传值") #创建d类对象 fsa.b1() #执行d类对象的类里面的b1()方法，类里面没有b1方法，就到继承的基类左边第一个b类里去找b1方法，找到b1方法执行，然而b1里是执行的对象里面的f1方法，这样就又回到了d类里去找f1方法 # 输出 # c
self.XXX()继承原理图33
super()内置函数【推荐】，在一个类里获取上一级父类基类的，__init__方法里的对象封装值，注意只能获取上一级基类的__init__方法里的对象封装值34
使用方法：super(子类派生类名称,self).__init__()
格式：super(b,self).__init__()
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") class b(a): #定义b类 def __init__(self): self.zh = "猫" super(b,self).__init__() #获取上一级父类基类的，__init__方法里的对象封装值 print(self.zhi) #打印出获取到的，上一级父类基类的，__init__方法里的对象封装值 def b1(self): print("b") c = b() c.f1() # 输出 # 动物 # a
被获取类名称.__init__(self)在一个类里获取另外一个类的__init__方法里的对象封装值，注意，可以获取有继承关系的，也可以获取无继承关系的类35
使用方法：被获取类名称.__init__(self)
格式：c.__init__(self)
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") class b(a): #定义b类 def __init__(self): self.zh = "猫" c.__init__(self) #在一个类里获取另外一个类的__init__方法里的对象封装值，注意，可以获取有继承关系的，也可以获取无继承关系的类 print(self.zf) #打印获取到的，另外一个类的__init__方法里的对象封装值 def b1(self): print("b") c = b() c.f1() # 输出 # 狗shi # a
多态36
多态就是多种形态
python自身支持多态
多态的简单理解就是，定义一个函数，创建类对象，把类对象当做实际参数传给函数的形式参数，在函数里通过形式参数接收到的类对象来执行对象类里的方法，也就是向函数传不同的对象，就执行不同对象类的方法
#!/usr/bin/env python # -*- coding:utf-8 -*- """多态，多种形态""" class ab: #定义ab类 def __init__(self,zhi = ""): #定义__init__方法接收类对象传的值 self.zhi = zhi #将类对象传值封装到对象里吧，给对象封装一个字段 def f1(self): #定义类方法 print(self.zhi) #打印ab类对象里封装的zhi字段 class cd: #定义cd类 def __init__(self,zhi = ""): #定义__init__方法接收类对象传的值 self.zhi = zhi #将类对象传值封装到对象里吧，给对象封装一个字段 def f1(self): #定义类方法 print(self.zhi) #打印cd类对象里封装的zhi字段 def ef(fang): #定义一个函数，设置一个形式参数接收类对象 fang.f1() #接收对象，并执行对象的类里面的f1()方法 ef(ab("你好")) #执行函数，创建ab类对象当做实参传值给ef函数 ef(cd("我好")) #执行函数，创建cd类对象当做实参传值给ef函数 # 输出 # 你好 # 我好
多态原理图37
面向对象的进阶38
成员39
类下面的方法为类的成员
对象下面的封装字段为对象成员
利用反射来操作类里的成员40
hasattr()内置反射函数，到指定类查找指定方法是否存在，和到指定的对象下查找，对象下的封装变量是否存在，或者到指定对象查找对象类里的指定方法，存在返回True,否则返回False
注意：对象有对象指针指向了类，所有也能用hasattr()函数通过对象来查找类里的方法，所以推荐通过对象来查找，既可以查找类又可以查找对象下的字段
使用方法：hasattr(要查找的类名称或对象名称,字符串形式要查找的方法名称或对象封装名称)41
格式：hasattr(c,"f1")
到指定类查找指定方法是否存在
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") fa = hasattr(c,"f1") #hasattr()内置函数，到指定类查找指定方法是否存在，和到指定的对象下查找，对象下的封装变量是否存在，存在返回True,否则返回False print(fa) # 输出 # True
到指定的对象下查找对象下的封装变量是否存在
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") fa = hasattr(a(),"zhi") #hasattr()内置函数，到指定类查找指定方法是否存在，和到指定的对象下查找，对象下的封装变量是否存在，存在返回True,否则返回False print(fa) # 输出 # True
到指定对象查找对象类里的指定方法
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") fa = hasattr(a(),"f1") #hasattr()内置函数，到指定类查找指定方法是否存在，和到指定的对象下查找，对象下的封装变量是否存在，存在返回True,否则返回False print(fa) # 输出 # True
getattr()内置反射函数，到指定的对象下找到，对象下的封装变量赋值给一个变量，或者到指定对象找到对象类里的指定方法赋值给一个变量42
注意：对象有对象指针指向了类，所有也能用hasattr()函数通过对象来查找类里的方法，所以推荐通过对象来查找，既可以查找类又可以查找对象下的字段
使用方法：getattr(要查找的对象,字符串形式要查找的方法名称或对象封装名称)
格式：fa = getattr(c(),"f1")
到指定对象找到对象类里的指定方法赋值给一个变量，并执行方法
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") fa = getattr(c(),"f1") #getattr()内置反射函数，到指定的对象下找到，对象下的封装变量赋值给一个变量，或者到指定对象找到对象类里的指定方法赋值给一个变量 fa() #执行找到的类方法 # 输出 # c
到指定的对象下找到，对象下的封装变量赋值给一个变量
#!/usr/bin/env python # -*- coding:utf-8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a") fa = getattr(c(),"zf") #getattr()内置反射函数，到指定的对象下找到，对象下的封装变量赋值给一个变量，或者到指定对象找到对象类里的指定方法赋值给一个变量 print(fa) # 输出 # 狗shi
用反射操作面向对象成员43
根据字符串方式的面向对象模块，和字符串方式的类方法，用反射来执行面向对象44
面向对象模块
#!/usr/bin/env python # -*- coding:utf8 -*- class c: #定义a类 def __init__(self): self.zf = "狗shi" def f1(self): print("c") class a: #定义a类 def __init__(self): self.zhi = "动物" def f1(self): print("a222")
反射操作面向对象模块里的成员
#!/usr/bin/env python # -*- coding:utf-8 -*- """根据字符串方式的面向对象模块，和字符串方式的类方法，用反射来执行面向对象""" a = "lib.ska.mk" #面向对象模块路径 b = "f1" #类方法名称 c = __import__(a,fromlist=True) #反射方式导入面向对象模块 d = hasattr(c.a(),b) #查找模块里的a类里是否有f1方法，返回布尔值 if d: #判断模块里的a类里是否有f1方法 f1 = getattr(c.a(),b) #如果有就找到f1方法赋值给一个变量 f1() #执行找到a类里的f1方法 else: print("a类里没有f1方法") # 输出 # a222
静态字段45
静态字段，也就是在类里面定义变量，提供类里的所有方法调用，这样能很好的实现多个类有一个相同数据的情况46
注意：静态字段是通过，类名称.静态字段名称来访问的，对象封装的普通字段，是通过self.普通字段名称来访问的
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 shux = "动物" def __init__(self,zhu): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def f1(self): #定义方法 print(a.shux, self.zhu) #打印类的静态字段和对象封装的普通字段 def f2(self): #定义方法 print(a.shux, self.zhu) #打印类的静态字段和对象封装的普通字段 def f3(self): #定义方法 print(a.shux, self.zhu) #打印类的静态字段和对象封装的普通字段 s = a("猫") #创建对象并传值 s.f1() #执行对象类里的f1()方法 f = a("狗") #创建对象并传值 f.f2() #执行对象类里的f2()方法 b = a("猪") #创建对象并传值 b.f3() #执行对象类里的f3()方法 # 输出 # 动物 猫 # 动物 狗 # 动物 猪
静态字段原理图47
静态方法48
就是在类里定义普通函数，函数上面用上装饰符@staticmethod，静态方法不需要传self参数，静态方法通过类来访问，不需要创建对象就可以访问
@staticmethod在类里声明一个静态方法49
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 @staticmethod #定义静态方法 def f1(): #静态方法 print("静态方法") def f3(self): #定义方法 print(a.shux, self.zhu) a.f1() # 输出 # 静态方法
静态方法原理图50
类方法51
就是在类里定义一个函数，函数上面用上装饰符@classmethod，函数里有一个必写形式参数cls用来接收类名称
@classmethod在类里声明一个类方法52
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 @classmethod #定义类方法 def f1(cls): #自动将类名称传值给cls形参 print(cls) #打印cls接收到的类名称 def f3(self): #定义方法 print(a.shux, self.zhu) a.f1() # 输出 # <class '__main__.a'>
类方法原理图53
特性方法54
@property特性方法55
就是在类里定义一个普通方法函数，函数上面用上装饰符@property，函数里有一个必写形式参数self用来接收对象地址，也可以给方法封装普通字段
特性方法与普通方法的区别：就是执行特性方法函数时不用写()括号，特性方法就是将普通方法伪造成通过对象获取的字段，特殊方法获取到返回值后是可以重新赋值的
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 @property #声明特性方法 def f1(self): #定义特性方法 te = "{}方法".format(self.zhu) print(te) def f3(self): #定义方法 print(a.shux, self.zhu) s = a("特性") s.f1 #执行对象类里的f1特性方法 # 输出 # 特性方法
s.f1 = "重新赋值" #特殊方法获取到返回值后是可以重新赋值的
特性方法原理图56
设置特性方法：就是给特性方法设置值57
@方法名称.setter给特性方法设置值58
就是在类里的特性方法下面，写一个给特性方法名称一样的方法函数，函数上面用上装饰符@方法名称.setter，在方法里设置一个形式参数来接收，执行设置特性方法传值，执行设置特性方法时，将特性方法 = 要设置的值即可
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 @property #声明特性方法 def f1(self): #定义特性方法 te = "{}方法".format(self.zhu) print(te) @f1.setter #设置特性方法 def f1(self,v): #设置特性方法 print(v) #打印设置的特性方法值 self.zhu = v #将设置的特性方法值替换对象封装的普通字段 s = a("特性") s.f1 #执行对象类里的f1特性方法 s.f1 = "设置特性方法值" s.f1 # 输出 # 特性方法 # 设置特性方法值 # 设置特性方法值方法
设置特性方法原理图59
成员修饰符60
修饰成员的使用权限对成员：静态字段、普通字段、普通方法、静态方法、类方法、特性方法，进行成员权限修饰61
公有：就是没加__修饰符的成员，既可以在类里面访问，也可以通过类或者对象外部访问
私有：就是加上__修饰符的成员，通过对象或者类无法外部访问，只能在类内部访问，外部要想访问必须在类的内部定义一个公有方法，在公有方法里执行要想访问的私有成员，通过公有方法来间接的访问私有成员，注意：一个类的私有方法只有类自己内部可以使用， 而且无法被继承。
__类成员修饰符，用于修饰类的成员私有权限，用了__修饰符的私有成员只有类自身内部可以访问。62
静态字段修饰符63
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 __jt = "静态字段" def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def f1(self): print(a.__jt) def f2(self): pass #print(a.__jt) #静态字段加修饰符后外部不可以访问 f = a() #定义对像 f.f1() #可以通过类里的f1方法间接访问 # 输出 # 静态字段
普通字段修饰符64
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.__zhu = zhu #将对象传值封装到对象里，封装普通字段 def f1(self): print(self.__zhu) def f2(self): pass f = a("普通字段") #定义对象 #print(f.zhu) #普通字段加修饰符后外部不可以访问 f.f1() #通过类里的f1方法可以间接访问对象里封装的普通字段 # 输出 # 普通字段
普通方法修饰符65
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.__zhu = zhu #将对象传值封装到对象里，封装普通字段 def __f1(self): print("普通方法") def f2(self): self.__f1() f = a() #定义对象 #f.__f1() #普通方法加修饰符后外部不可以访问 f.f2() #通过类里的f2方法可以间接访问加修饰符的f1普通方法 # 输出 # 普通方法
静态方法修饰符66
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.__zhu = zhu #将对象传值封装到对象里，封装普通字段 @staticmethod #定义静态方法 def __f1(): print("静态方法") def f2(self): a.__f1() #a.__f1() #静态方法加修饰符后外部不可以访问 f = a() #定义对象 f.f2() #通过类里的f2方法可以间接访问加修饰符的f1静态方法 # 输出 # 静态方法
类方法修饰符67
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.__zhu = zhu #将对象传值封装到对象里，封装普通字段 @classmethod #定义类方法 def __f1(cls): print("类方法",cls) def f2(self): a.__f1() #a.__f1() #类方法加修饰符后外部不可以访问 f = a() #定义对象 f.f2() #通过类里的f2方法可以间接访问加修饰符的f1类方法 # 输出 # 类方法 <class '__main__.a'>
特性方法修饰符68
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.__zhu = zhu #将对象传值封装到对象里，封装普通字段 @property #定义特性方法 def __f1(self): print("特性方法") def f2(self): self.__f1 f = a() #定义对象 #f.__f1 #特性方法加修饰符后外部不可以访问 f.f2() #通过类里的f2方法可以间接访问加修饰符的f1特性方法 # 输出 # 特性方法
成员修饰符之特殊手段，外部访问类的私有成员【不到万不得已不使用】69
方法：类名称或者对象名称._类名称__私有字段名称
格式：a._a__jt
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 __jt = "静态字段" def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def f1(self): print(a.__jt) def f2(self): pass print(a._a__jt) #特殊手段外部访问类的私有成员 # 输出 # 静态字段
类成员之特殊方法70
__call__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后在对象后面加上()括号，也可以在对象变量后面加括号是一样的，会自动执行类里的__call__方法71
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __call__(self, args): #定义__call__方法 print(args,self.zhu) def f2(self): pass f = a("方法")("__call__") # 输出 # __call__ 方法
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __call__(self, args): #定义__call__方法 print(args,self.zhu) def f2(self): pass f = a("方法") f("__call__") # 输出 # __call__ 方法
__getitem__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后在对象后面加上[]中括号，会自动执行类里的__getitem__方法，并将[]中括号里的值传给__getitem__方法的形式参数。72
注意：对象后面加上[1:2:3],也是执行类的__getitem__方法
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __getitem__(self, item): #创建__getitem__方法 s = self.zhu + item #将创建对象封装的普通字段，加上执行__getitem__方法时的传值，相加后并返回值 return s #返回值 def f2(self): pass f = a(10) #创建对象传值 b = f[10] #执行__getitem__方法并传值给__getitem__方法 print(b) #打印__getitem__方法返回值 # 输出 # 20
对象后面加上[1:2:3],也是执行类的__getitem__方法 73
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __getitem__(self, item): #创建__getitem__方法,将[]中括号里的数据重新封装成一个slice对象传给item print(item) #打印接收到的slice对象元素 def f2(self): pass f = a() #创建对象传值 b = f[10:12:3] #执行__getitem__方法并传值给__getitem__方法 print(b) #打印__getitem__方法返回值 # 输出 # 20
__setitem__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后在对象后面加上[xxx]=xxx中括号等于，会自动执行类里的__setitem__方法，并将[xxx]=xxx中括号和等于里的值传给__setitem__方法的形式参数74
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __setitem__(self, key, value): #定义__setitem__方法 print(key,value) #打印[xxx] = xxx 传值 def f2(self): pass f = a() #创建对象传值 f["键"] = "值" #执行__setitem__方法并传值给__setitem____方法 # 输出 # 键 值
__delitem__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后在对象后面加上del对象名称[xxx]中括号，会自动执行类里的__delitem__方法，并将[xxx]中括号里的值传给__delitem__方法的形式参数75
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __delitem__(self, key): #定义__delitem__方法 print("删除",key) #操作[xxx]里传来的值 def f2(self): pass f = a() #创建对象传值 del f["键"] #执行__delitem__方法，并传值给__delitem__方法 # 输出 # 删除 键
__iter__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后只要for循环对象，会自动执行类里的__iter__方法，如__iter__方法里是一个生成器，for循环就会循环出生成器里的结果76
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __iter__(self): #定义__iter__方法 yield 1 #生成器 yield 2 yield 3 yield 4 def f1(self): pass s = a() #创建对象 for i in s: #循环对象 print(i) #循环打印出生成器里的数据 # 输出 # 1 # 2 # 3 # 4
__str__方法是类里的一个特殊方法，当类里定义了这个方法时，创建对象后只要print打印对象或者str(对象)时就，会自动执行类里的__str__方法77
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义类 def __init__(self,vas): #定义__init__方法，接收对象传值 self.fds = vas #将对象传值封装成对象普通字段 def __str__(self): #定义__str__方法 return self.fds #返回对象里的普通字段 def f1(self): pass f = a("str方法") print(f) #打印对象时自动执行__str__方法 b = str(f) #str(对象)时也会执行__str__方法 print(b) # 输出 # str方法 # str方法
__dict__查看对象或者类里的成员78
#!/usr/bin/env python # -*- coding:utf8 -*- class a: #定义a类 def __init__(self,zhu = ""): #初始化__init__接收对象传值 self.zhu = zhu #将对象传值封装到对象里 def __getitem__(self, item): #创建__getitem__方法,将[]中括号里的数据重新封装成一个slice对象传给item print(item) #打印接收到的slice对象元素 def f2(self): pass f = a("zhi") #创建对象传值 print(f.__dict__) #查看对象里的成员 print(a.__dict__) #查看类里的成员 # 输出 # {'zhu': 'zhi'} # {'__init__': <function a.__init__ at 0x00000036345AE510>, 'f2': <function a.f2 at 0x00000036345AE620>, '__getitem__': <function a.__getitem__ at 0x00000036345AE598>, '__weakref__': <attribute '__weakref__' of 'a' objects>, '__dict__': <attribute '__dict__' of 'a' objects>, '__module__': '__main__', '__doc__': None}
可以忽略，源码创建类原理79
__new__ python创建类源码方法80
__metaclass__ python创建类源码方法81
阅读以下代码：
class Foo(object): def __init__(self): pass obj = Foo() # obj是通过Foo类实例化的对象
上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
print type(obj) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建 print type(Foo) # 输出：<type 'type'> 表示，Foo类对象由 type 类创建
所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
那么，创建类就可以有两种方式：
普通方式
class Foo(object): def func(self): print 'hello wupeiqi'
特殊方式（type类的构造函数）
def func(self): print 'hello wupeiqi' Foo = type('Foo',(object,), {'func': func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员
＝＝》 类 是由 type 类实例化产生
那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
class MyType(type): def __init__(self, what, bases=None, dict=None): super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 第一阶段：解释器从上到下执行代码创建Foo类 # 第二阶段：通过Foo类创建obj对象 obj = Foo()
重点总结82
面向对象三大特性：83
封装、继承、多态
成员：84
字段：普通字段(每个对象都有一份相同数据时)、静态字段(每个对象都不同的数据时)
方法：静态方法(无需使用对象封装的内容时)、类方法(需要获取对象名称时)、普通方法(使用对象中的数据时)
特性方法：特性方法(将方法伪造成字段时)
特殊方法：对象后写上执行属性，就会自动执行特殊方法
类成员访问方法：85
通过类访问的有：静态字段，静态方法，类方法
通过对象访问的有：普通字段，普通方法，特性方法
一般有self的方法用对象访问，无self的方法用类来访问
成员修饰符：86
修饰成员的使用权限对成员：静态字段、普通字段、普通方法、静态方法、类方法、特性方法，进行成员权限修饰
公有：就是没加__修饰符的成员，既可以在类里面访问，也可以通过类或者对象外部访问
私有：就是加上__修饰符的成员，通过对象或者类无法外部访问，只能在类内部访问，外部要想访问必须在类的内部定义一个公有方法，在公有方法里执行要想访问的私有成员，通过公有方法来间接的访问私有成员
，注意：一个类的私有方法只有类自己内部可以使用，而且无法被继承。
特殊方法对应的执行属性：87
类名称(xxx):创建对象并执行类的__init__方法
对象变量(xxx):执行类的__call__方法
对象变量[xxx]:执行类的__getitem__方法
对象变量[x:x:x]:执行类的__getitem__方法
对象变量[xxx]=xxx:执行类的__setitem__方法
del对象变量[xxx]:执行类的__delitem__方法
for循环对象变量:执行类的__iter__方法