谈论新内容之前我们还是应该了解一下它之前的内容
继承：
新式类：继承object类的类就是新式类。(python3x中都是新式类)
经典类：不继承object类就是经典类。
python2x：默认所有类都不继承object，所以默认所以类都是经典类。
单继承，多继承。
单继承：
1.查询顺序
class A: name = 'alex' def func(self): print(666) calss B: age = 12 b1 = B() b1.age b1.name
2.只执行子类的方法
class A: name = 'alex' def func(self): print('IN A') class B: age = 12 def func(self): print('IN B') b1 = B() b1.func() 3.既要执行父类又要执行子类的方法
class A: name = 'alex' def func(self): print('IN A') class B(A): age = 12 def func(self): #super().func() # 第一种 super(B,self).func() A.func(self) # 第二种 print('IN B') b1 = B() b1.func() 4.多继承：
新式类：广度优先。python3x：类名。mor()
经典类：一直找，找到底
好的，接下来我们就来看看接口类个抽象类：
接口类和抽象类在工作中，更多的是代表一种书写规范
python的三大特性：
python多态（鸭子类型）
python不同于java，python中没有多态这一说法，更多的是被叫做鸭子类型，
python封装。
# 第一版,不好,没有统一化设计,第二版解决.# class QQ:# def pay(self,money):# print('您用qq支付了%s元' % money)## class Ali:# def pay(self,money):# print('您用支付宝支付了%s元' % money)## q1 = QQ()# q1.pay(100)# a1 = Ali()# a1.pay(200)
# 第二版 ,相安无事,此时来了一个野生程序员.完成了一个微信功能class QQ: def pay(self,money): print('您用qq支付了%s元' % money)class Ali: def pay(self,money): print('您用支付宝支付了%s元' % money)class Wechat: def wechatpay(self,money): print('您用微信支付了%s元' % money)def pay(obj,money): obj.pay(money) # q1.pay(100)# q1 = QQ()# a1 = Ali()# pay(q1,100) # 统一化设计# pay(a1,200)# w1 = Wechat()# w1.wechatpay(500) # 第三版,重新改版微信支付功能# class QQ:# def pay(self,money):# print('您用qq支付了%s元' % money)## class Ali:# def pay(self,money):# print('您用支付宝支付了%s元' % money)## class Wechat:# def pay(self,money):# print('您用微信支付了%s元' % money)## def pay(obj,money):# obj.pay(money) # q1.pay(100)## q1 = QQ()# a1 = Ali()# pay(q1,100) # 统一化设计# pay(a1,200)# w1 = Wechat()# pay(w1,500) # 第四版,为了避免上述野生程序员可能发生的问题,我要制定一个规范.class Payment: # 抽象类,或者接口类:制定一个规范.def pay(self):passclass QQ(Payment): def pay(self,money): print('您用qq支付了%s元' % money)class Ali(Payment): def pay(self,money): print('您用支付宝支付了%s元' % money)class Wechat(Payment): def pay(self,money): print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money) # a1.pay(200)# q1 = QQ()# a1 = Ali()# pay(q1,100) # 统一化设计# pay(a1,200)# w1 = Wechat()# pay(w1,500) # 第五版 强制制定规范,如果未按照规范执行,就会报错.from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类 @abstractmethoddef pay(self):pass # 抽象方法class QQ(Payment): def pay(self,money): print('您用qq支付了%s元' % money)def ret(self):print('支付失败....')class Ali(Payment): def pay(self,money): print('您用支付宝支付了%s元' % money)class Wechat(Payment): def pay(self,money): print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money) # a1.pay(200)q1 = QQ()a1 = Ali()w1 = Wechat()# q1 = QQ()# a1 = Ali()# pay(q1,100) # 统一化设计# pay(a1,200)# w1 = Wechat()# pay(w1,500) # 用处: 在工作中,如果你要是规定几个类必须有一样的方法,
# 你要抽象类,制定一个规范,强制其有此方法.# python没有多态的概念,但是python崇尚鸭子类型.# 定义变量的方法:#1,java c# 需要定义 类型. int i= 3#2,java c# 没有多继承的概念.# i = 1# i = 'alex'# 鸭子类型: 它看着像鸭子,那么他就是鸭子.
# str list tuplestr.index()s1 = 'alex'class Str: def index(self): passclass List: def index(self): passclass tuple: def index(self): pass
#python中好多不同类但同名的方法不是强制规定,而是约定俗成,像上面这三种类,都同样据有index方法,而且功能相似,
# 则 他们三个互称为鸭子.#封装就是将一些属性或者方法(有用的信息)放置在一个空间中.
1,封装 对象的封装. class Person: def __init__(self,name,age): self.name = name self.age = agep1 = Person('oldboy',1000)p2 = Person('alex',10000)print(p1.name)print(p2.name)
封装
(私有成员.)
类的结构分析:class Person: mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段 __level = '高等动物' # 第一部分:私有静态变量,私有静态字段 def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法,方法(函数) self.name = name # 公有对象属性 self.age = age self.__sex = sex # 私有对象属性 def func(self): # 第二部分:普通方法 print(666) def __func1(self): # 第二部分:私有方法 print(777) @staticmethod # 静态方法 def f2():pass @classmethod # 类方法 def f2(self): pass @property # 属性 def hex(self):pass
# 类整体分类:
# 第一部分: 公有静态字段 mind = '有思想...' ,私有静态字段. __level = '高等动物'# 第二部分: 特殊方法(__init__(公有属性,私有属性),__str__...)# 普通方法 def func(self)# 私有方法 def __func1(self):# 类方法:# @classmethod# def f2(self): pass# 静态方法:# @staticmethod # 静态方法# def f2():pass# 属性:# @property # 属性# def hex(self): pass# 私有成员: 私有静态字段,私有属性,私有方法 在变量前+ __双下划线.
# 私有静态字段
# class Animal:# __cloth = '皮毛' # _Animal__cloth# class Person(Animal):# mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段# __level = '高等动物' # 第一部分:私有静态变量,私有静态字段 # _Person__level## def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)# self.name = name # 公有对象属性# self.age = age# def func(self):# print(self.__level)# print(self._Animal__cloth)# print(self.__cloth)
# 在类的外面访问: 私有静态字段是访问不到的.
# p1 = Person('alex',1000)# print(p1.mind)# print(p1.__level)# print(Person.__level)# print(Person.__dict__)# print(Person._Person__level) # 可以通过对象._类名__变量名 类名._类名__变量名 可以访问到,但是绝对不要这么访问. # 在类的内部: 私有静态字段是可以访问
# p1 = Person('alex',1000)# p1.func() # 父类的私有静态字段,派生类可否访问? 不可访问.
# p1 = Person('alex',10)# print(p1.__cloth)# p1.func()
私有方法
# class Animal:# def __f1(self):print(1111) # _Animal__f1## class Person(Animal):# mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段# def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)# self.name = name # 公有对象属性# self.age = age# self.__sex = sex# def __func(self): # _Person__func()# print(666)# def func1(self):# self.__func() # self._Person__func()# def func2(self):# self.__f1() # self._Person__f1()
# 类外面访问不到.
# p1 = Person('OLDBOY',1000)# p1.__func() # 类内部可以方法.
# p1 = Person('OLDBOY',1000)# p1.func1() # 派生类中也是不能访问的.
# p1.func2()
# 私有属性 也是类外部不能访问,派生类不能访问,只能在类内部访问.
class Animal:def __f1(self):print(1111) # _Animal__f1class Person(Animal): mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段 def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法,方法(函数) self.name = name # 公有对象属性 self.age = age self.__sex = sex def __func(self): # _Person__func() print(666)class A: def __init__(self): self.func() def func(self): print('IN A')class B(A): def func(self): print('IN B')b1 = B()# print(b1.name)# print(b1.func)print(b1.func)print(b1.func())