多继承的正确打开方式：mixins机制
mixins机制核心：就是在多继承背景下尽可能地提升多继承的可读性
ps：让多继承满足人的思维习惯=》什么"是"什么
class Vehicle:
pass
class FlyableMixin:
def fly(self):
pass
class CivilAircraft(FlyableMixin,Vehicle): ##### 民航飞机
pass
class Helicopter(FlyableMixin,Vehicle): ##### 直升飞机
pass
class Car(Vehicle): ##### 汽车并不会飞，但按照上述继承关系，汽车也能飞了
pass
import socketserver
补充：通常Mixin结果的类放在左边
在子类派生的新方法中如何重用父类的功能
方式一：指名道姓调用某一个类下的函数=》不依赖于继承关系
class OldboyPeople:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def f1(self):
print('%s say hello' %self.name)
class Teacher(OldboyPeople):
def __init__(self,name,age,sex,level,salary):
OldboyPeople.__init__(self,name,age,sex)
self.level = level
self.salary=salary
tea_obj=Teacher('egon',18,'male',10,3000)
print(tea_obj.__dict__)
方式二：super()调用父类提供给自己的方法=》严格依赖继承关系
调用super()会得到一个特殊的对象，该对象会参照发起属性查找的那个类的mro,去当前类的父类中找属性
class OldboyPeople:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def f1(self):
print('%s say hello' %self.name)
class Teacher(OldboyPeople):
def __init__(self,name,age,sex,level,salary):
##### super(Teacher,self).__init__(name,age,sex)
super().__init__(name,age,sex) ##### 调用的是方法，自动传入对象
self.level = level
self.salary=salary
##### print(Teacher.mro())
tea_obj=Teacher('egon',18,'male',10,3000)
print(tea_obj.__dict__)
super()案例
class A:
def test(self):
print('from A')
super().test()
class B:
def test(self):
print('from B')
class C(A,B):
pass
obj=C()
obj.test()
print(C.mro())
class A:
def test(self):
print('from A')
super().test1()
class B:
def test(self):
print('from B')
class C(A,B):
def test1(self):
print('from C')
obj=C()
obj.test()
print(C.mro())
1、什么多态：同一事物有多种形态
class Animal:
pass
class People(Animal):
pass
class Dog(Animal):
pass
class Pig(Animal):
pass
2、为何要有多态=》多态会带来什么样的特性，多态性
多态性指的是可以在不考虑对象具体类型的情况下而直接使用对象
class Animal: ##### 统一所有子类的方法
def say(self):
print('动物基本的发声频率。。。',end=' ')
class People(Animal):
def say(self):
super().say()
print('嘤嘤嘤嘤嘤嘤嘤')
class Dog(Animal):
def say(self):
super().say()
print('汪汪汪')
class Pig(Animal):
def say(self):
super().say()
print('哼哼哼')
obj1=People()
obj2=Dog()
obj3=Pig()
obj1.say()
obj2.say()
obj3.say()
定义统一的接口，接收传入的动物对象
def animal_say(animal):
animal.say()
animal_say(obj1)
animal_say(obj2)
animal_say(obj3)
print('hello'.__len__())
print([1,2,3].__len__())
print({'a':1,'b':2}.__len__())
def my_len(val):
return val.__len__()
print(my_len('hello'))
print(my_len([1,2,3]))
print(my_len({'a':1,'b':2}))
len('hello')
len([1,2,3])
len({'a':1,'b':2})
python推崇的是鸭子类型
class Cpu:
def read(self):
print('cpu read')
def write(self):
print('cpu write')
class Mem:
def read(self):
print('mem read')
def write(self):
print('mem write')
class Txt:
def read(self):
print('txt read')
def write(self):
print('txt write')
obj1=Cpu()
obj2=Mem()
obj3=Txt()
obj1.read()
obj1.write()
obj2.read()
obj2.write()
obj3.read()
obj3.write()
了解：
import abc
class Animal(metaclass=abc.ABCMeta): ##### 统一所有子类的标准
@abc.abstractmethod
def say(self):
pass
obj=Animal() ##### 不能实例化抽象类自己
class People(Animal):
def say(self):
pass
class Dog(Animal):
def say(self):
pass
class Pig(Animal):
def say(self):
pass
obj1=People()
obj2=Dog()
obj3=Pig()
一：绑定方法：特殊之处在于将调用者本身当做第一个参数自动传入
1、绑定给对象的方法：调用者是对象，自动传入的是对象
2、绑定给类的方法：调用者类，自动传入的是类
import settings
class Mysql:
def __init__(self,ip,port):
self.ip=ip
self.port=port
def func(self):
print('%s:%s' %(self.ip,self.port))
@classmethod ##### 将下面的函数装饰成绑定给类的方法
def from_conf(cls):
print(cls)
return cls(settings.IP, settings.PORT)
##### obj1=Mysql('1.1.1.1',3306)
obj2=Mysql.from_conf()
print(obj2.__dict__)
二：非绑定方法-》静态方法：
没有绑定给任何人：调用者可以是类、对象，没有自动传参的效果
class Mysql:
def __init__(self,ip,port):
self.nid=self.create_id()
self.ip=ip
self.port=port
@staticmethod ##### 将下述函数装饰成一个静态方法
def create_id():
import uuid
return uuid.uuid4()
@classmethod
def f1(cls):
pass
def f2(self):
pass
obj1=Mysql('1.1.1.1',3306)
print(Mysql.create_id)
print(obj1.create_id)
Mysql.create_id(1,2,3)
obj1.create_id(4,5,6)
print(Mysql.create_id)
print(Mysql.f1)
print(obj1.f2)
print(abs(-1))
print(all([1,'aaa','1']))
print(all([]))
print(any([0,None,1]))
print(any([]))
print(bin(11))
print(oct(11))
print(hex(11))
print(bool(''))
def func():
pass
class Foo:
pass
print(callable(Foo)) ##### 方
print(chr(65))
print(ord('A'))
不可变集合
s=frozenset({1,2,3})
hash(不可变类型)
print(round(1.5))
print(round(1.4))
10 ** 2 % 3
print(pow(10,2,3))
s=slice(1,4,2)
l1=['a','b','c','d','e']
l2=['aaa','bbb','ccc','ddd',444]
print(l1[1:4:2]) ##### l1[s]
print(l2[1:4:2]) ##### l2[s]
=================》掌握
v1='hello'
v2=[111,222,333,444,5555,6666]
res=zip(v1,v2)
print(list(res))
=================》掌握
print(divmod(10000,33))
=================》掌握
class Foo:
pass
obj=Foo()
obj.xxx=1111
print(dir(obj)) ##### obj.哪些属性
=================》掌握
for i,v in enumerate(['a','b','c']):
print(i,v)
=================》掌握
res=eval('{"a":1}') ##### 执行字符串中的表达式
print(res,type(res))
=================》掌握
class Foo:
pass
obj=Foo()
print(isinstance(obj,Foo))
print(isinstance([],list)) ##### 类型判断推荐使用isinstance
print(type([]) is list) ##### 不推荐使用
=================》掌握
import 'time' ##### 错误
time=__import__('time')
time.sleep(3)
下个周：反射
setattr
getattr
delattr
hasattr
'''
作业
'''
本周作业:综合应用面向对象
角色:学校、学员、课程、讲师
要求:
-
创建北京、上海 2 所学校
-
创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开
-
课程包含，周期，价格，通过学校创建课程
-
通过学校创建班级， 班级关联课程、讲师
-
创建学员时，选择学校，关联班级
-
创建讲师角色时要关联学校，
-
提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程 -
上面的操作产生的数据都通过pickle序列化保存到文件里