一、多态
1.概念
一种事物的多种体现形式，函数的重写其实就是多态的一种体现
在Python中，多态指的是父类的引用指向子类的对象
代码演示：
#父类
class Animal(object):
pass
#子类
class Dog(Animal):
pass
class Cat(Animal):
pass
#定义变量
a = [] #a是list类型
b = Animal() #b是Animal类型
c = Cat() #c是Cat类型
#isinstance():判断一个对象是否属于某种类型【系统还是自定义的类型】
print(isinstance(a,list))
print(isinstance(b,Animal))
print(isinstance(c,Cat))
print(isinstance(c,Animal)) #True
print(isinstance(b,Dog)) #False
#结论：子类对象可以是父类类型，但是，父类的对象不能是子类类型
2.使用
案例：人可以喂猫，喂狗
思路：
a.定义动物类【父类】
b.定义子类，继承自动物类
c.定义人类
d.使用多态，优化
代码演示：
duoTaiDemo.py文件
from duotai.person import Person
from duotai.cat import Cat
from duotai.dog import Dog
#1.创建一个Person的对象
p = Person()
#2.创建一个Cat的对象
c = Cat("小白")
#3.人执行自己的行为
p.feedAnimal(c)
d = Dog("旺财")
p.feedAnimal(d)
person.py文件
class Person(object):
"""
def feedCat(self,cat):
print("喂猫:",cat.name)
cat.eat()
def feedDog(self,dog):
print("喂猫:",dog.name)
dog.eat()
"""
#多态
#ani被当做父类的引用 ，当传参的时候，实参是一个子类对象的时候，则体现出了 多态的应用
def feedAnimal(self,ani): #ani = c c = Cat("")
print("喂动物:", ani.name)
ani.eat()
animal.py文件
class Animal(object):
def __init__(self,name):
self.name = name
def eat(self):
print("eating")
cat.py文件
from duotai.animal import Animal
class Cat(Animal):
def __init__(self,name):
super(Cat,self).__init__(name)
dog.py文件
from duotai.animal import Animal
class Dog(Animal):
def __init__(self,name):
super(Dog,self).__init__(name)
总结：
简化代码，提高代码的可读性，可维护性
二、获取对象信息
type() isintance() dir()
代码演示：
#1.type() :判断一个对象所属的类型
num = 10
print(type(num))
print(type("hello"))
class Check(object):
pass
c = Check()
print(type(c))
#使用==判断type返回的结果
print(type(12) == type(57)) #True
print(type(12) == type("57")) #False
#使用type返回的结果和数据类型直接判断
print(type(12) == int)
#2.isintance() :判断一个对象是否属于某种指定的数据类型
#自定义的类中
class Dog(object):
pass
d = Dog()
print(isinstance(d,Dog))
print(isinstance([1,2,4],list))
#特殊用法：可以判断一个对象是否属于多种数据类型中的某一种
print(isinstance([1,2,4],(tuple,list)))
#3.dir() :列出指定对象中所包含的所有的内容【成员变量，成员方法】
dict = {}
print(dir(dict))
print(dir("abc"))
print(dir(d))
三、类中特殊的属性和方法
1.实例属性和类属性
1.1实例属性和类属性的区别【面试题】
a.定义的位置不同，类属性时直接定义在类中，实例属性定义在构造函数中
b.访问的方式不同，类属性使用类名直接访问，实例属性使用对象访问
c.在内存中出现的时机不同，类属性随着类的出现而出现，实例属性随着对象的出现而出现
d.优先级不同，实例属性的优先级高于类属性
代码演示：
class Person(object):
#1.定义位置
#类属性：直接定义在类中
name = "abc"
age = 0
def __init__(self,name):
#实例属性：定义在构造函数中
self.name = name
#2.访问方式
print(Person.name) #类属性：类名.属性 或者 对象.属性
p = Person("hello")
print(p.name) #实例属性：对象.属性
#3.优先级不同：实例属性的优先级高于类属性
print(p.name) #hello
#4.不同对象的类属性在内存中是不是同一块空间？----->不是
p1 = Person("小白")
p2 = Person("小红")
print(p1.age)
print(p2.age)
p1.age = 33
print(p1.age)
print(p2.age)
print(id(p1.age))
print(id(p2.age))
"""
0
0
33
0
1420404832
1420403776
"""
#注意：尽量避免类属性和实例属性的重名
#删除属性【类属性，实例属性】
del p1.age
1.2动态添加属性和方法
代码演示：
from types import MethodType
class Person(object):
#__slots__ = ("name","age")
pass
#1.动态添加属性
per = Person()
str = "fjsgh"
per.name = str
#2.动态添加方法
def say(self):
print("fhsj")
"""
per.test = say
per.test(per)
"""
#弊端：违背了普通函数定义
#解决方案：MethodType类，存在于types模块下
#类似于偏函数
#参数：函数名，对象
#作用：在现有函数的基础上生成了一个对象【新的函数】，赋值给成员变量，则认为给对象添加了一个成员方法
per.test = MethodType(say,per)
per.test()
2.类方法和静态方法
类方法：使用@classmethod装饰器修饰的方法，被称为类方法，可以通过类名调用，也可以通过对象调用，但是一般情况下使用类名调用
静态方法：使用@staticmethod装饰器修饰的方法，被称为静态方法，可以通过类名调用，也可以通过对象调用，但是一般情况下使用类名调用
代码演示：
class Test(object):
#1.类属性
age = 100
def __init__(self,name):
#2.实例属性
self.name = name
#3.成员方法,通过对象调用
#必须有一个参数，这个参数一般情况下为self，self代表是当前对象
def func(self):
print("func")
#4.类方法
"""
a.必须有一个参数，这个参数一般情况下为cls，cls代表的是当前类
b.类方法是属于整个类的，并不是属于某个具体的对象，在类方法中禁止出现self
c.在类方法的内部，可以直接通过cls调用当前类中的属性和方法
d.在类方法的内部，可以通过cls创建对象
"""
@classmethod
def test(cls):
print("类方法")
print(cls) #
print(cls.age)
#6
#注意：cls完全当做当前类使用
c = cls("hello")
c.func()
#7.静态方法
@staticmethod
def show():
print("静态方法")
t = Test("hjfsh")
t.func()
#5,.调用类方法
Test.test() #类名.类方法的名称()
t.test() #对象.类方法的名称()
#7。调用静态方法
Test.show()
t.show()
总结：实例方法【成员方法】、类方法以及静态方法之间的区别
a.语法上
实例方法：第一个参数一般为self，在调用的时候不需要传参，代表的是当前对象【实例】
静态方法：没有特殊要求
类方法：第一个参数必须为cls，代表的是当前类
b.在调用上
实例方法：只能对象
静态方法：对象 或者 类
类方法：对象 或者 类
c.在继承上【相同点】
实例方法、静态方法、类方法：当子类中出现和父类中重名的函数的时候，子类对象调用的是子类中的方法【重写】
代码演示：
class SuperClass(object):
@staticmethod
def show():
print("父类中的静态方法")
@classmethod
def check(cls):
print("父类中的类方法")
class SubClass(SuperClass):
pass
s = SubClass()
s.show()
s.check()
注意：注意区分三种函数的书写形式，在使用，没有绝对的区分
3.类常用属性
__name__
通过类名访问，获取类名字符串
不能通过对象访问，否则报错
__dict__
通过类名访问，获取指定类的信息【类方法，静态方法，成员方法】，返回的是一个字典
通过对象访问，获取的该对象的信息【所有的属性和值】，，返回的是一个字典
__bases__
通过类名访问，查看指定类的所有的父类【基类】
代码演示：
class Animal(object):
def __init__(self,arg):
super(Animal, self).__init__()
self.arg = arg
class Tiger(Animal):
age = 100
height = 200
def __init__(self,name):
#super(Tiger, self).__init__(name)
self.name = name
def haha(self):
print("haha")
@classmethod
def test(cls):
print("cls")
@staticmethod
def show():
print("show")
if __name__ == "__main__":
#1.__name__
print(Tiger.__name__) #Tiger
t = Tiger("")
#print(t.__name__) #AttributeError: 'Tiger' object has no attribute '__name__'
#2.__dict__
print(Tiger.__dict__) #类属性，所有的方法
print(t.__dict__) #实例属性
#3.__bases__，获取指定类的所有的父类，返回的是一个元组
print(Tiger.__bases__)
四、运算符重载【了解】
运算符重载其实就是函数重写
代码演示：
print(1 + 1)
print("1" + "1")
#print("1" + 1)
#不同的数据类型进行加法运算得到的是不同的解释
#思考问题：两个对象相加？
class Person(object):
def __init__(self,num):
self.num = num
def __str__(self):
return "num=" + str(self.num)
def __add__(self, other):
#两个对象相加得到的结果仍然为一个对象
return Person(self.num + other.num) #Peson(30)
p1 = Person(10)
p2 = Person(20)
print(p1) #10
print(p2) #20
print(p1 + p2) #30
#p1 + p2----->p1.__add__(p2),
五、单例设计模式【扩展】
1.概念
什么是设计模式
经过已经总结好的解决问题的方案
23种设计模式，比较常用的是单例设计模式，工厂设计模式，代理模式，装饰模式
什么是单例设计模式
单个实例【对象】
在程序运行的过程中，确保某一个类只能有一个实例【对象】，不管在哪个模块中获取对象，获取到的都是同一个对象
单例设计模式的核心：一个类有且仅有一个实例，并且这个实例需要应用在整个工程中
2.应用场景
实际应用：数据库连接池操作-----》应用程序中多处需要连接到数据库------》只需要创建一个连接池即可，避免资源的浪费
3.实现
3.1模块
Python的模块就是天然的单例设计模式
模块的工作原理：
import xxx,模块被第一次导入的时候，会生成一个.pyc文件，当第二次导入的时候，会直接加载.pyc文件，将不会再去执行模块源代码
3.2使用new【掌握】
__new__（）:实例从无到有的过程【对象的创建过程】
代码演示：
class Singleton(object):
#类属性
instance = None
#类方法
@classmethod
def __new__(cls, *args, **kwargs):
#如果instance的值不为None，说明已经被实例化了，则直接返回；如果为NOne，则需要被实例化
if not cls.instance:
cls.instance = super(Singleton,cls).__new__(*args, **kwargs)
return cls.instance
class MyClass(Singleton):
pass
#当创建对象的时候自动被调用
one = MyClass()
two = MyClass()
print(id(one))
print(id(two))
print(one is two)
3.3装饰器【掌握】
代码演示：
#单例类：将装饰器作用于一个类上
def singleton(cls):
#类属性
instance = {}
#成员方法
def getSingleton(*args, **kwargs):
#思路：如果cls在字典中，则直接返回；如果不存在，则cls作为key，对象作为value，添加到字典中
if cls not in instance:
instance[cls] = cls(*args, **kwargs)
return instance[cls]
return getSingleton
@singleton
class Test(object):
pass
t1 = Test()
t2 = Test()
print(id(t1) == id(t2))
print(t1 is t2)
3.4使用在类中【掌握】
代码演示：
#单例类
class Foo(object):
#1.声明一个变量【类属性】
instance = None
#2.向外界提供一个公开的方法，用于返回当前类唯一的对象
#方法命名格式：defaultInstance,currentInstance ,getInstance
@classmethod
def getInstance(cls):
if cls.instance:
return cls.instance
else:
#实例化
cls.instance = cls()
return cls.instance
obj1 = Foo.getInstance()
obj2 = Foo.getInstance()
print(id(obj1) == id(obj2))
print(obj1 is obj2)