python基础知识
类属性和类方法
方法没有重载
在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包括3个部分：方法名、参数数量、参数类型。
python中，放的参数没有声明类型（调用时确定参数的类型），单数的数量也可以由可变参数控制。因此，python中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法重载。
如果我们在类体中定义类多个重名的方法，只有最后一个方法有效。因此不要使用重名方法。
运行结果：
如果这里想要调用第一个say_hi方法，不带参数的话就会报错，因为这个方法是无效的。
运行结果：
方法的动态性
python是动态语言，解释器一行一行的去解释执行。我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。
实例对象的方法调用本质：
a=Student()#new一个student实例对象
a.say_score()#调用对象中的方法解释器翻译：
Student.say_score(a)python一切都是对象，所以函数是对象，方法也是对象。
修改已经定义的方法测试：
运行结果：
私有属性和私有方法（实现封装）
python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有以下要点：
1.通常我们约定，两个下划线开头的属性是私有的（private）。其他为公共的（public）
2.类内部可以访问私有属性（方法）
3.类外部不能直接访问私有属性（方法）
4.类外部可以通过“_类名__私有属性(方法)名”访问私有属性（方法）
注：方法本质上也是属性！只是可以通过（）执行而已。
运行结果：
通过dir()方法，可以看到私有属性的命名是_类名__私有属性(方法)名，所以想要外部调用私有属性（方法），直接调用其存储的名字即可。
但是，私有属性是对外私有，对内（类的内部）是可以调用的。
共享的类变量也可以私有，在类外部调用也要根据命名来调用：
运行结果：
property装饰器
@property可以讲一个方法的调用方式变成“属性调用”。一般用来为属性增加gather、setter方法。
测试私有属性普通调用方式：
运行结果：
现用@property来做测试：
面向对象三大特征介绍
python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。
- 封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。 - 继承
继承可以让子类具有父类的特性，提高了代码的重用性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。 - 多态
多态是指同一个方法调用由于对象不同会产生不同的行为。比如，同样是休息，不同的人休息的方式不同：a是选择睡觉，b是选择打游戏，c是选择出去散步。
继承
继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。如果一个新类继承自一个设计好的类，就直接具备类已有类的特征，就大大降低类工作的难度。已有类，我们称为“父类（基类）”，新的类，我们称为“子类（派生类）”。
面向对象对应的就是现实世界，父类有的子类都有，子类中还可以增加新的属性（方法）。就如同动物世界一样，动物下面又分为爬行动物和哺乳动物，他们都继承类动物的特征，又有属于自己特有的特征。
语法格式
python支持多承继承，一个子类可以继承多个父类，继承的语法格式：
class 子类类名(父类1[,父类2,....])如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类共有的默认实现，比如__new__()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式：父类名.__init__(self,参数列表)。
#测试继承的基本使用
class Person:
def __init__(self,name,age):
self.name=name
self.__age=age#私有属性
def say_age(self):
print("年龄")
class Student(Person):#student类继承person父类
def __init__(self,name,age,score):#继承父类，有父类的属性，还可以有属于自己的属性
Person.__init__(self,name,age)#作为子类，必须显式的的调用父类初始化方法，不然解释器不会去调用
self.score=score
#Student-->Person-->Object类
print(Student.mro())#方法解析的顺序
s=Student('poppy',18,90)#实例对象
s.say_age()
print(s.name)
print(s.score)
#print(s.age)#父类中的私有属性，不能直接调用
print(dir(s))#查对象所有的属性
print(s._Person__age)#想要调用父类中的私有属性，需要这样去调用运行结果：
父类私有的属性和方法，子类能继承，但是不能直接调用，还得通过存储命名调用。
类成员的继承和重写
1.成员继承：子类继承了父类除构造方法之外的所有成员。
2.方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”。
#测试继承和方法的重写
class Person:
def __init__(self,name,age):
self.name=name
self.__age=age#私有属性
def say_age(self):
print("我的年龄：",self.__age)
def say_name(self):
print("我的名字：".format(self.name))
class Student(Person):
def __init__(self,name,age,score):
Person.__init__(self,name,age)#作为子类，必须显式的的调用父类初始化方法，不然解释器不回去调用
self.score=score
def say_name(self):
#重写了父类的方法
print("报告老师，我的名字是：{0}".format(self.name))
def say_score(self):#子类自己的方法
print("分数是：{0}".format(self.score))
s=Student('poppy',18,90)
s.say_age()
s.say_name()
s.say_score()运行结果：
继承包括：属性、方法，私有属性、私有方法（不能直接访问）
方法的重写实在子类中重写，被子类调用。
查看类的继承层次结构
通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。
运行结果：
A是B的父类，B是C的父类，而Object类是A的父类（默认）
Object根类
object类是所有类的父类，因此所有的类都有object类的属性和方法。
dir（）查看对象的属性
内置函数dir（），可以让我们方便的看到指定对象所有的属性。
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def say_age(self):
print(self.name,"年龄是：",self.age)
obj=object()
print(dir(obj))#查看obj对象的所有属性
s2=Person("poppy",19)
print(dir(s2))#查看s2对象的所有属性运行结果：
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'say_age']从上面的结果我们可以看到：
1.Person对象增加了六个属性：__dict__;__module__;__weakref__; age;name;say_age 2.object的所有属性，Person类作为object的子类，显然包含了所有的属性。
3.我们打印age、name、say_age，发现say_age虽然是方法，实际上也是属性，只不过，这个属性的类型是“method”而已。age<class 'int'>name<class 'str'>say_age<class 'method'>
重写__str__()方法
object有一个__str__()方法，用于返回一个对于“对象的描述”，对应与内置函数str()经常用于print（）方法，帮助我们查看对象的信息，__str__()可以重写。
没有方法重写时，打印的是object默认的实现，打印类的信息。
#测试object的__str__()
class Person:#默认继承object类
def __init__(self,name):
self.name=name
p=Person("Poppy")
print(p)运行结果：
#测试重写object的__str__()
class Person:#默认继承object类
def __init__(self,name):
self.name=name
def __str__(self):
return "名字是：{0}".format(self.name)#重写生效，再去调用打印的是重写后的内容
p=Person("Poppy")
print(p)运行结果：
多重继承
python支持多重继承，一个子类可以有多个“直接父类”。这样就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞得异常复杂，因此尽量避免使用。
多重继承好处：类的定义更加灵活；坏处：破坏整体的层次，不便于维护，一般不推荐使用，对于某一个类是有好处，到那时对于整体结构来说，弊大于利。
#多重继承
class A:
def aa(self):
print("aa")
class B:
def bb(self):
print("bb")
class C(B,A):#不仅继承B，还继承A
def cc(self):
print("cc")
c=C()
c.cc()
c.bb()
c.aa()MRO（）
python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左到右”按顺序搜索。
MRO（Method Resolution Order）：方法解析顺序。我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。
#多重继承
class A:
def aa(self):
print("aa")
def say(self):
print("AAA")
class B:
def bb(self):
print("bb")
def say(self):
print("BBB")
class C(B,A):#调用方法会有方法解析的顺序，采用的是广度优先算法
#B在前，调用同名方法，先调用b中的方法
def cc(self):
print("cc")
c=C()
c.cc()
c.bb()
c.aa()
print(C.mro())#打印类的层次结构
c.say()#解释器寻找方法是"从左到右"的方式寻找，此时会执行B中方法运行结果：
super()获得父类定义
在子类中，如果想要获得父类的方法时，我们可以通过super()来做。super()代表父类的定义，不是父类对象。
#测试super（），代表父类的定义，而不是父类的对象
class A:
def say(self):
print("A:",self)
class B(A):
def say(self):
#A.say(self)#第一种调用父类的方法
super().say()#用super的方法获得父类的定义，再通过.say调用父类方法
print("B:",self)
B().say()运行结果：
由运行结果可以发现，A，B两个类对象的地址是一样的，说明super（）获取父类定义只是让B指向A的地址的方法去调用。
多态
多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。
关于多态要注意：
1.多态是方法的多态，属性没有多态。
2.多态的存在有两个必要条件：继承、方法重写。
#多态
class Man:
def eat(self):
print("饿了，吃饭")
class Chinese(Man):#不同的子类重写属于自己的eat方法
def eat(self):
print("中国人用筷子吃饭")
class English(Man):
def eat(self):
print("英国人用叉子吃饭")
class Indian(Man):
def eat(self):
print("印度人用右手吃饭")
def manEat(m):
if isinstance(m,Man):#m是否Man的子类
m.eat()#只要是man的子类都可以，根据传的对象不同，调用的方法也不同。
else:
print("不能吃饭")
manEat(Chinese())
manEat(English())特殊方法和运算符重载
python的运算符实际上是通过调用对象的特殊方法实现的，比如在执行c=a+b时，实际是在执行c=a.__add__(b) 使用运算符的时候，还是在调用对象的方法。每个运算符都定义了对应的方法，可以重写，但是通常不需要重写。
常见的特殊方法：
方法 | 说明 | 例子 |
| 构造方法 | 对象创建：p=Person() |
| 析构方法 | 对象回收 |
| 打印，转换 | print(a) |
| 函数调用 | a() |
| 点号运算 | a.xxx |
| 属性赋值 | a,xxx=value |
| 索引运算 | a[key] |
| 索引赋值 | a[key]=value |
| 长度 | len(a) |
每个运算法实际上都对应了相应的方法：
运算符 | 特殊方法 | 说明 |
运算符+ |
| 加法 |
运算符- |
| 减法 |
<,<=,== |
| 比较运算符 |
>,>=,!= |
| 比较运算符 |
｜,^,& |
| 或，异或，与 |
<<,>> |
| 左移，右移 |
*,/,%,// |
| 乘，浮点除，模运算（取余）、整数除 |
** |
| 指数运算 |
#测试运算符的重载
class Person:
def __init__(self,name):
self.name=name
def __add__(self, other):
if isinstance(other,Person):
return "{0}--{1}".format(self.name,other.name)
else:
return "不是同类对象，不能相加"
def __mul__(self, other):
if isinstance(other,int):
return self.name*other
else:
return "不是同类，不能相乘"
p1=Person("poppy")
p2=Person("pony")
x=p1+p2
print(x)
print(p1*3)特殊属性
python对象中包含了很多双下划线开始和结束的属性，这些都是特殊属性，有特殊用法：
特殊方法 | 含义 |
| 对象的属性字典 |
| 对象所属的类 |
| 类的基类元组（多继承） |
| 类的基类 |
| 类层次结构 |
| 子类列表 |
object代表普通对象，class对象是类对象
#测试特殊属性
class A:
pass
class B:
pass
class C(B,A):
def __init__(self,nn):
self.nn=nn
def cc(self):
print("cc")
c=C(3)
print(dir(c))
print(c.__dict__)#对象属性字典
print(c.__class__)#对象所属类
print(C.__bases__)#对象的基类元组（多继承）
print(C.mro())#类的继承层次结构
print(A.__subclasses__())#子类列表运行结果：
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cc', 'nn']
{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]对象的浅拷贝和深拷贝
变量的赋值操作只是形成两个变量，实际还是指向同一个对象。
浅拷贝 python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此源对象和拷贝对象会引用同一个子对象。
深拷贝 使用copy模块的deepcopy函数，诋毁拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。
#测试对象的浅拷贝和深拷贝
import copy
class MobilePhone:
def __init__(self,cpu,screen):
self.cpu=cpu
self.screen=screen
class CPU:
def calculate(self):
print("计算")
print("cpu对象：",self)
class Screen:
def show(self):
print("显示一个好看的画面")
print("screen对象：",self)
#测试变量赋值
c1=CPU()
c2=c1
print(c1)
print(c2)
print("测试浅复制")
#测试浅复制
s1=Screen()
m1=MobilePhone(c1,s1)
m2=copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)
#测试深复制
print("测试深复制")
m3=copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)运行结果：
<__main__.CPU object at 0x7f9158996410>
<__main__.CPU object at 0x7f9158996410>
测试浅复制
<__main__.MobilePhone object at 0x7f915898fb10> <__main__.CPU object at 0x7f9158996410> <__main__.Screen object at 0x7f915898fb50>
<__main__.MobilePhone object at 0x7f915899c390> <__main__.CPU object at 0x7f9158996410> <__main__.Screen object at 0x7f915898fb50>
测试深复制
<__main__.MobilePhone object at 0x7f915898fb10> <__main__.CPU object at 0x7f9158996410> <__main__.Screen object at 0x7f915898fb50>
<__main__.MobilePhone object at 0x7f915899c290> <__main__.CPU object at 0x7f91589b3350> <__main__.Screen object at 0x7f91589b33d0>变量赋值，只是形成两个变量，实际地址没有发生改变。
浅复制，只复制对象，（地址不一样）子对象的地址没有发生变化。
深复制，所有对象都复制。地址都不一样。
组合
“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，狗类应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。“has-a”关系指的是这样的关系：手机拥有CPU。
组合也起到代码复用的作用，和继承在本质上是一样的。
#测试组合
#用继承实现代码复用
class A1:
def say_a1(self):
print("a1,a1,a1")
class B1(A1):
pass
b1=B1()
b1.say_a1()
#用组合实现代码的复用
class A2:
def say_a2(self):
print("a2,a2,a2")
class B2:
def __init__(self,a):#把a2对象作为b2的属性
self.a=a
a2=A2()
b2=B2(a2)
b2.a.say_a2()设计模式
设计模式是面向对象语言特有的内容，是我们在面临某一类问题时固定的做法。设计模式有很多种，比较流行的是：GOF（Group of Four）23种设计模式。对于初学者，两个最常用的模式：工厂模式和单例模式。
设计模式就是实现分离–>社会分工
工厂模式实现
工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。工厂模式帮助在复杂情况下，更好的对造对象过程和对象的统一管理。
#测试工厂模式
class CarFactory:#首先创造一个工厂类
def create_car(self,brand):
if brand=="奔驰":
return Benz()
elif brand=="宝马":
return BMW()
elif brand=="比亚迪":
return BYD()
else:
return "未知品牌无法创建"
class Benz:
pass
class BMW:
pass
class BYD:
pass
factory=CarFactory()
c1=factory.create_car("奔驰")#想要创建对象，告诉工厂类
c2=factory.create_car("比亚迪")
print(c1)
print(c2)运行结果：
根据运行结果可以看到，两个对象调用的方法都来自同一个地址（统一管理的工厂）。
单例模式
单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他以来对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
定义单例类时，一般要重写new方法。
#测试单例模式
class MySingleton:
_obj=None#类属性
def __new__(cls, *args, **kwargs):#重写new方法，创建单例对象
if cls._obj==None:
cls._obj=object.__new__(cls)
return cls._obj
def __init__(self,name):
print("init...")
self.name=name
a=MySingleton("aa")
b=MySingleton("bb")
print(a)
print(b)运行结果：
运行发现，调用的时候，初始化方法调用了两次，但我们只想调用一次初始化方法，所以需要加一个标记，保证只调用一次初始化方法。
#测试单例模式（优化）
class MySingleton:
_obj=None#类属性
_init_flag=True#标记，只调用一次初始化方法
def __new__(cls, *args, **kwargs):#重写new方法，创建单例对象
if cls._obj==None:
cls._obj=object.__new__(cls)
return cls._obj
def __init__(self,name):
if MySingleton._init_flag:#如果标记为真，还没有调用过初始化方法
print("init...")
self.name=name
MySingleton._init_flag=False#调用一次初始化方法后，将标记置为假
a=MySingleton("aa")
b=MySingleton("bb")
print(a)
print(b)运行结果：
这次初始化方法只调用了一次。
练习-将工厂类改写成单例模式：
#测试工厂模式和单例模式的整合使用
class CarFactory:#工厂类
__obj=None#类属性
__init_flag=True#标记，只调用一次初始化方法
def crate_car(self,brand):
if brand=="奔驰":
return Benz()
elif brand=="宝马":
return BMW()
elif brand=="比亚迪":
return BYD()
else:
return "未知品牌无法创建"
def __new__(cls, *args, **kwargs):#重写new方法，创建单例对象
if cls.__obj==None:
cls.__obj=object.__new__(cls)
return cls.__obj
def __init__(self):
if CarFactory.__init_flag:
print("init CarFactory....")
CarFactory.__init_flag=False#确保只调用一次初始化方法
class Benz():
pass
class BMW():
pass
class BYD():
pass
factory=CarFactory()#创建一个工厂对象
c1=factory.crate_car("奔驰")
c2=factory.crate_car("比亚迪")
print(c1)
print(c2)
factory2=CarFactory()
print(factory)
print(factory2)运行结果：
根据运行结果可知，利用单例模拟，我们只调用了一次初始化方法。而在创建factory和factory2时，发现其地址都一样，说明他们来自同一个工厂类。
