类
类，就是一种事物，具有共性。比如dict，人，熊猫
对象，类的实例化后所产生的，具有个性，比如{1：‘vf’}，春哥，团团。
申明类：
class 类名: '类的文档字符串'#类的静态属性
def __init__(self,参数）
实例化所需要的参数代码
def 功能
面向对象小结——定义及调用的固定模式
class 类名: def __init__(self,参数1,参数2): self.对象的属性1 = 参数1 self.对象的属性2 = 参数2 def 方法名(self):pass def 方法名2(self):pass 对象名 = 类名(1,2) #对象就是实例，代表一个具体的东西 #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法 #括号里传参数，参数不需要传self，其他与init中的形参一一对应 #结果返回一个对象 对象名.对象的属性1 #查看对象的属性，直接用 对象名.属性名 即可 对象名.方法名() #调用类中的方法，直接用 对象名.方法名() 即可
我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值
特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)
class Person: country = 'China' def __init__(self,name,sex,age,hobby): self.name=name self.sex=sex self.age=age self.hobby=hobby def func(self): print(dir(self)) p1=Person('alex','male',68,'study') print(dir(Person)) print(dir(p1)) print(p1.__dict__) print(Person.__name__) print(Person.__doc__) print(Person.__base__) print(Person.__bases__) print(Person.__module__) print(Person.__class__) print(Person.__dict__) #输出的结果为 '''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'country', 'func'] ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'country', 'func', 'hobby', 'name', 'sex'] {'hobby': 'study', 'sex': 'male', 'name': 'alex', 'age': 68} Person None <class 'object'> (<class 'object'>,) __main__ <class 'type'> {'__init__': <function Person.__init__ at 0x0000000000832620>, 'country': 'China', '__doc__': None, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__', 'func': <function Person.func at 0x00000000008326A8>, '__weakref__': <attribute '__weakref__' of 'Person' objects>} '''
面向对象的组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
面向对象的命名空间
class name_space: code='utf-8' def __init__(self,name,sex,age): self.name=name self.age=age self.sex=sex lhy=name_space('lhy','female',18) dxx=name_space('dxx','male',23) print(name_space.code)#utf-8 print(lhy.code)#utf-8 print(lhy.age)#18 #print(name_space.name)#报错 #name_space.__dict__['code']='unicode'#报错 name_space.code='unicode' print(name_space.code)#unicode print(lhy.code)#unicode lhy.__dict__['code']='gbk' print(lhy.__dict__)#gbk print(lhy.code)#gbk print(name_space.code)#unicode
lhy.__dict__.pop('code')#删除code
print(lhy.code)#unicode
类的静态变量是可以通过 类.属性名来改变的，但是不可以通过类.__dict__来进行改变。同时静态属性的改变影响对象的静态属性，应为这个属性是绑定在类中并指向一个内存地址的
对象，可也以改变静态属性的。对象名.属性来改变，但是不会影响其他对象以及类的这静态属性的，相当于自己在自己的命名空间开了一新的的空间，不再是绑定关系，删除之后，才会恢复绑定关系
再看代码
class group: hobby=['eat','drink','swim'] wjw=group jjs=group print(group.hobby)#print(group.hobby) print(wjw.hobby)#print(group.hobby) print(jjs.hobby)#print(group.hobby) wjw.hobby.pop() print(group.hobby)#['eat', 'drink'] print(wjw.hobby)#['eat', 'drink'] print(jjs.hobby)#['eat', 'drink']
类里的名字有 类变量（静态属性量）+ 方法名（动态属性）
对象里的名字 对象属性
对象 —— > 类
对象找名字 ： 先找自己的 找类的 再找不到就报错
对象修改静态属性的值
对于不可变数据类型来说，类变量最好用类名操作
对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的
面向对象的三大特征：继承，多态，封装
继承
单继承
父类又称超类，基类
子类又称派生类
class A: def fun(self): print('A') pass class B: def fun(self): print('B') pass class A_son(A): def fun(self): print('A_son(A)') pass class AB_son(A,B): def fun(self): print('AB_son(A,B)') pass print(A_son.__bases__)#(<class '__main__.A'>,) 表示A的子类 print(AB_son.__bases__)#(<class '__main__.A'>, <class '__main__.B'>)表示A和B的子类
提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
继承与抽象：向抽象在继承。
请看代码
class People: def eat(self): print('%s eat a bread'%self.name) def sleep(self): print('%s is slepping'%self.name) def look_for_sex(self): print('%s is %s' % (self.name, self.sex)) class Xiaoming(People): def __init__(self,name,sex): self.name=name self.sex=sex class Xiaohong(People): def __init__(self,name,sex): self.name=name self.sex=sex xiaoming=Xiaoming('xiaoming','male') xiaohong=Xiaohong('xiaohong','female') xiaoming.eat()#xiaoming eat a bread xiaohong.look_for_sex()#xiaohong is female
注意：此时的父类定义时没有传参数，故可以直接调用
派生
子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）。
需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
class A: def func(self): print('it is father function') class B(A): def func(self): print('it is son function') b= B() b.func()#it is son function
父类中没有的属性 在子类中出现 叫做派生属性
父类中没有的方法 在子类中出现 叫做派生方法
只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
如果父类 子类都有 用子类的
如果还想用父类的，单独调用父类的:
父类名.方法名 需要自己传self参数
super().方法名 不需要自己传self
在外部调用父类方法是super().方法名 需要自己在（）中填写（子类名，对象名）
内部调用（子类名，self）
注意区分内外掉用区别
super().hahaha() 等价super(B,self).hahaha()，一般用前面的
正常的代码中 单继承 === 减少了代码的重复
继承表达的是一种 子类是父类的关系
关于继承传参数
class A: def __init__(self,name,sex,age): self.name=name self.age= age self.sex=sex print('A传参数完成') class B(A): def __init__(self,name,age,sex,hobby): super().__init__(name,age,sex) # super(B, self).__init__(name, age, sex) #也可以这么写，这样就能统一self self.hobby=hobby print('hobby传参完成') a =B('alex',16,'male','study') #结果 #A传参数完成 #hobby传参完成
多继承：
多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？
经典类中 深度优先
新式类中 广度优先
python2.7 新式类和经典类共存，新式类要继承object
python3 只有新式类，默认继承object
经典类和新式类还有一个区别 mro方法只在新式类中存在
类名.mro() 查找多继承的顺序
super 只在python3中存在
super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的
砖石继承
抽象类与接口类
接口类 ： python原生不支持
抽象类 ： python原生支持
规范 ：接口类或者抽象类都可以
接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java
接口类
from abc import ABCMeta,abstractmethod class start_game(metaclass=ABCMeta): @abstractmethod def start(self,num):pass class LOL(start_game): def start(self,num): print('%s second will be open Lol'%num) class DNF(start_game): def start(self,num): print('%s second will be open DNF' % num) class QQ(start_game): def begin(self,num): print('%s second will be open QQ' % num) lol=LOL() lol.start(5)#5 second will be open Lol dnf=DNF() dnf.start(6)#6 second will be open DNF qq = QQ() qq.begin(5)#TypeError: Can't instantiate abstract class QQ with abstract methods start
解析
接口内的多继承
from abc import abstractmethod,ABCMeta class Swim_Animal(metaclass=ABCMeta): @abstractmethod def swim(self):pass class Walk_Animal(metaclass=ABCMeta): @abstractmethod def walk(self):pass class Fly_Animal(metaclass=ABCMeta): @abstractmethod def fly(self):pass class Tiger(Walk_Animal,Swim_Animal): def walk(self): pass def swim(self): pass class OldYing(Fly_Animal,Walk_Animal):pass class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass
抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案
import abc #利用abc模块实现抽象类 class All_file(metaclass=abc.ABCMeta): all_type='file' @abc.abstractmethod #定义抽象方法，无需实现功能 def read(self): '子类必须定义读功能' with open('filaname') as f: pass @abc.abstractmethod #定义抽象方法，无需实现功能 def write(self): '子类必须定义写功能' pass class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('文本数据的读取方法') def write(self): print('文本数据的读取方法') class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('硬盘数据的读取方法') def write(self): print('硬盘数据的读取方法') class Process(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('进程数据的读取方法') def write(self): print('进程数据的读取方法') wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #这样大家都是被归一化了,也就是一切皆文件的思想 wenbenwenjian.read() yingpanwenjian.write() jinchengwenjian.read() print(wenbenwenjian.all_type) print(yingpanwenjian.all_type) print(jinchengwenjian.all_type)
#输出结果
#文本数据的读取方法
#硬盘数据的读取方法
#进程数据的读取方法
#file
#file
#file
抽象类 ： 规范
一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中
抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
java ：
java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题
python
python中没有接口类 ：
python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类 ： 一般情况下 单继承 不能实例化
且可以实现python代码
多态
python 天生支持多态属于动态强类型语言
鸭子类型
list tuple
不崇尚根据继承所得来的相似
我只是自己实现我自己的代码就可以了。
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉
强类型语言 多态
python 语言 鸭子类型
封装
广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
只让自己的对象能调用自己类中的方法
狭义上的封装 —— 面向对象的三大特性之一
属性 和 方法都藏起来 不让你看见
#其实这仅仅这是一种变形操作 #类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print('from A') def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到. #A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
解析
class conformation: def __init__(self,name,sex,age): self.__name=name self.sex=sex self.__age=age def __func(self): return self.__age+7 def function(self): print(self.__func()) xiaoming = conformation('xiaoming','male',19) print(xiaoming.sex) # print(xiaoming.name)#报错 print(xiaoming._conformation__name) print(xiaoming.__dict__) #{'sex': 'male', '_age': 19, '_conformation__name': 'xiaoming'} print(xiaoming._conformation__func()) xiaoming.function() '''输出结果 male xiaoming {'_conformation__name': 'xiaoming', 'sex': 'male', '_conformation__age': 19} 26 26 '''
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形
在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
#正常情况 >>> class A: ... def fa(self): ... print('from A') ... def test(self): ... self.fa() ... >>> class B(A): ... def fa(self): ... print('from B') ... >>> b=B() >>> b.test() from B #把fa定义成私有的，即__fa >>> class A: ... def __fa(self): #在定义时就变形为_A__fa ... print('from A') ... def test(self): ... self.__fa() #只会与自己所在的类为准,即调用_A__fa ... >>> class B(A): ... def __fa(self): ... print('from B') ... >>> b=B() >>> b.test() from A
会用到私有的这个概念de场景
1.隐藏起一个属性 不想让类的外部调用
2.我想保护这个属性，不想让属性随意被改变
3.我想保护这个属性，不被子类继承