1.面向对象和面向过程的理解
面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
class Kind:
# 定义类
def sedan(self, name, wheel):
# 方法列表
"""给对象赋初始值，也可以在参数上直接赋值"""
self.name = name
self.wheel = wheel
print（"小汽车的名字：%s\n小汽车的轮子：%s" % (self.name, self.wheel)）
def move(self):
print("车在移动....")
"""返回值"""
kind = Kind()
#把值赋给kind，然后用kind开执行操作
kind.sedan("兰博基尼", 4)
#给sadan里面的参数赋值，然后输出
kind.move()
print(kind)
2.__init__()方法
当创建Car对象后，在没有调用__init__()方法的前提下，BMW就默认拥有了2个属性wheelNum和color，原因是__init__()方法是在创建对象后，就立刻被默认调用了
__init__()方法，在创建一个对象时默认被调用，不需要手动调用
__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
class Dog:
def __init__(self,name,age):
self.name=name
self.age=age
print("狗的名字：%s,狗的年龄%s"%(self.name,self.age))
def meet(self):
print("啃骨头。。。")
dog=Dog("乖乖",5)
print(dog)
3. 定义__str__()方法
在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
作用就是在打印的时候消除这些信息，加上__str__这个方法会直接使用return中的数据 " v:shapes="文本框_x0020_101">class Cat:
def __init__(self,name,age):
self.name=name
self.age=age
def meet(self):
print("吃鱼咯。。。")
def __str__(self):
return "猫的名字是：%s,猫的年龄是%s"%(self.name,self.age)
cat=Cat("乖乖",6)
print(cat)
cat.meet()
4.理解self
1）所谓的self，可以理解为自己
2）可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思
3）某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可
5.私有属性
如果有一个对象，当需要对其进行修改属性时，有2种方法
1）对象名.属性名 = 数据 ---->直接修改
2）对象名.方法名() ---->间接修改
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
1）将属性定义为私有属性
2）添加一个可以调用的方法，供调用
在定义的属性名字前加上两个下划线表示这个是私有的，也就只能在这个类里面调用
class Cat:
def __init__(self, name):
self.name = name
def __move(self):
print("不想走。。。"
def __str__(self):
return "猫的名字是：%s " % (self.name)
def ss(self):
self.__move()
cat = Cat("乖乖")
print(cat)
cat.ss()
5.__del__()方法
创建对象后，python解释器默认调用__init__()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
import time
class Initialize:
def __init__(self,name):
print("方法被调用！")
self.name=name
def __del__(self):
print("__del__方法被调用")
print("对象立刻被pass。。。%s"%(self.name))
initialize=Initialize("小狗")
# del initialize
print("程序5秒钟后结束")
time.sleep(5)
6.函数的继承
1）将共性的内容放在父类中，子类只需要关注自己特有的内容
2）python中所有的内容都是对象，所有的对象都直接或间接继承了object
3）子类在继承的时候，在定义类时，小括号()中为父类的名字
4)父类的属性、方法，会被继承给子类
5)私有的属性，不能通过对象直接访问，但是可以通过方法访问
6)私有的方法，不能通过对象直接访问
7)私有的属性、方法，不会被子类继承，也不能被访问
8)一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
class Inherit:
def __init__(self):
print("aaa")
class one(Inherit):
def Inherit_one(self):
print("bbb")
class two(one):
def Inherit_two(self):
print("ccc")
class three(two,one):
def Inherit_three(self):
print("ddd")
qwe=one()
qwe.Inherit_one()
print(one.__mro__)
print("***********")
sss=two()
sss.Inherit_two()
print(two.__mro__)
print("***********")
ppp=three()
ppp.Inherit_three()
print(three.__mro__)
6.重写/覆盖父类方法与调用父类方法
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
class Cat(object):
def sayHello(self):
print("halou-----1")
class Bosi(Cat):
def sayHello(self):
print("halou-----2")
bosi = Bosi()
bosi.sayHello()
调用父类方法
class Cat(object):
def __init__(self,name):
self.name = name
self.color = 'yellow'
class Bosi(Cat):
def __init__(self,name):
# 调用父类的__init__方法1(python2)
# Cat.__init__(self,name)
# 调用父类的__init__方法2
#super().__init__() #一般用于单继承
# 调用父类的__init__方法3
super(Bosi,self).__init__(name) #一般用这个，多继承的时候按照__mro__方法调用
def getName(self):
return self.name
bosi = Bosi('xiaohua')
print(bosi.name)
print(bosi.color)
7.多态
什么是封装？
类是一种封装，将属性和方法封装。
函数也是一种封装，将具有一定共的逻辑代码封装到一个函数中，使用的时候调用即可
提高代码的扩展性。
什么是继承？
将公共的（共性的）属性和方法放在父类中，子类只关注自己特有的属性和方法。
提高代码的扩展性。
什么是多态？
一个对象在不同的情况下，具有不同的形态，用于强类型语言。是使用在继承和接口中实现。
Python中有两种说法：
1、python支持多态，python是一个弱类型，本身一个变量名，可以存储任何类型的值，可以理解为多种形态
2、python不支持多态，多态本身是用于强类型语言的，python是一个弱类型，所以不支持多态
8.类属性，实例属性
实例属性:通过类创建的对象又称为实例对象，对象属性又称为实例属性，记录对象各自的数据，不同对象的同名实例属性，记录的数据可能不相同，实例属性只能通过实例对象调用。
类属性:类属性就是类对象拥有的属性，它被该类的所有实例对象所共有。类属性可以使用类对象或实例对象访问
class Student:
air_conditioner="on" #定义类属性 两个下划线+类名表示私有属性 ，所以不能在类外通过类对象访问私有的类属性 def __init__(self,name,age): #定义实例属性
self.name=name
self.age=age
s1=Student("张三",20)
s2=Student("李四",22)
print(s1.age) #访问实例属性
print(s1.name) #访问实例属性
print(Student.air_conditioner)#访问类属性
print(s1.air_conditioner)#访问类属性
print(s2.air_conditioner)#访问类属性
Student.air_conditioner="off"#修改类属性
s1.air_conditioner="on-off-on"#增加实例属性
del s1.air_conditioner #删除类属性
9.静态方法和类方法
类方法需要用@classmethod来修饰，第一个参数必须是类对象，一般是cls，
实例方法不需要修饰，但是第一个属性也必须是类对象，一般是self
静态方法也需要用@staticmethod来修饰，可以不用定义参数，也可以自己顶一参数
class Dog:
Dog_die = "no" # 类属性，表示狗是否存活！
def __init__(self, name, coloer): # 实例属性，定义狗的名字和颜色
self.name = name
self.coloer = coloer
def pekingese_1(self): # 实例方法
print("这是一条温顺的狗")
@classmethod
def pekingese_2(cls): # 类方法
print("这是一条不乖的小狗")
return cls.Dog_die
@staticmethod
def pekingese_3(): # 静态方法
print("无奈。。。")
dog = Dog("乖乖", "黑色")
dog.pekingese_1() #实例属性输出
dog.pekingese_2()
dog.pekingese_3()
print(Dog.pekingese_2()) 类方法输出
print(dog.name, dog.coloer)
10.设计模式六大原则
1）设计模式
- 设计模式六大原则（1）：单一职责原则
即一个类只负责一项职责
- 设计模式六大原则（2）：里氏替换原则
所有引用基类的地方必须能透明地使用其子类的对象
- 设计模式六大原则（3）：依赖倒置原则
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。高内聚，低耦合。
- 设计模式六大原则（4）：接口隔离原则
客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
- 设计模式六大原则（5）：迪米特法则
一个对象应该对其他对象保持最少的了解。尽量降低类与类之间的耦合。
- 设计模式六大原则（6）：开闭原则
一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
2）设计分类
- 创建型模式
主要目的：创建对象
共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
- 结构型模式
主要目的：对象的组成和对象的关系
共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
- 行为型模式
主要目的：对象的行为，对象能做什么
共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
3）__new__的使用
class A(object):
def __init__(self):
print("这是 init 方法")
def __new__(cls):
print("这是 new 方法")
return object.__new__(cls)
A()
总结：
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节
注意：本篇文章是个人总结，仅供参考。若出现其他问题，与写者无关，切勿用于商业获取福利！
如果总结有勿，或者交流与学习，请与写着联系！qq：1349176744