一、
1.1面向过程编程：过程二字为重点，是指解决问题的步骤。类似一条流水线，机械式的思维方式
优点：复杂的流程流程化，进而简单化。
缺点：可扩展性差
面向对象编程：对象为重点，对象就是”数据“和”功能“的组成。
优点：可扩展性强，
缺点：编程复杂度高
应用场景：用户需求经常变化，互联网应用，游戏，企业
1.2类：是一系列对象相似特征与技能的结合体。强调：站的角度不一样，得到的分类是不一样的。
现实中：是先有类，再有对象。
在程序中：是先定义类，后调用类来产生对象。
类的用途：属性----增、删、改、查、
类的定义：
#先定义类 class LuffyStudent: school='luffycity' #数据属性 def learn(self): #函数属性 print('is learning')
类体内的代码在类定义阶段就会执行！！！，可以使用__dict__来查看。
#__init__方法用来为对象定制对象自己独有的特征 class LuffyStudent: school='luffycity' def __init__(self,name,sex,age): #对象的独有特征 self.Name=name self.Sex=sex self.Age=age def learn(self): # 对象的公共特征 print('is learning') def eat(self): print('is sleeping') #后产生对象 stu1=LuffyStudent('王二丫','女',18) #LuffyStudent.__init__(stu1,'王二丫','女',18) print(stu1.__dict__) >>>>>>{'Name': '王二丫', 'Sex': '女', 'Age': 18} #加上__init__方法后，实例化的步骤 # 1、先产生一个空对象stu1 # 2、LuffyStudent.__init__(stu1,'王二丫','女',18)
类中的数据属性：是所以对象共有的
类中的函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方式时，会把对象本身当作第一个传入，传给self
pyrhon中一切皆对象。
1.3继承：指的是类与类之间的关系，主要功能就是解决代码中用的问题；是一种创建新类的方式，新建的类可以继承一个或者多个父类，新建的类可称为子类和派生类，父类又可称为基类或者超类。
内置属性可以用通过__bases__来查看类继承的所有父类
属性查找：1.对象本身>>>2.对象的类>>>>3.父类
继承多个父类时的属性查找顺序：python会解析顺序(mro)列表，其遵循的原则：1.子类会先于父类被检查；2.多个父类会根据他们在列表中的顺序被检查；3.如果下一个类存在两个合法的选择，会选择第一个父类。
1.4派生：
子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
在子类派生出新的方法中重用父类的方法：
方式一：指名道姓（不依赖继承）【父类名称.方法名称(self,参数)】
方式二：super() （依赖继承） Python2:---【super(对象本身的类名，self).方法名称(具体的数据)】 python3---【super().方法名称(具体的数据)】
1.5组合：在一个类中以另外一个类的对象作为数据属性，称为类的组合
class Date: def __init__(self,year,mon,day): self.year=year self.mon=mon self.day=day def tell_info(self): print('%s-%s-%s' %(self.year,self.mon,self.day))
二、抽象类
import abc class Animal(metaclass=abc.ABCMeta): #只能被继承，不能被实例化 all_type='animal' @abc.abstractmethod def run(self): pass @abc.abstractmethod def eat(self): pass # animal=Animal()
class People(Animal):
def run(self):
print('people is running')
def eat(self):
print('people is eating')
三、多态与多态性
多态指一类事物拥有多种形态
多态性指在不考虑实例类型的情况下使用实例
多态性分为静态多态性和动态多态性
多态性的好处：
1.增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2.增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
四、封装
封装指的是如何进行属性的隐藏
如何进行封装：使用双下划线(__）开头的方式将属性隐藏起来（设置成私有的）
其实所有的双下划线开头的名称都会在类定义阶段变形，且只变形一次。
class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print('from A') def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到. #A._A__N是可以访问到的， #这种，在外部是无法通过__x这个名字访问到。
变形的特点：
1.在类的外部无法直接访问属性；可间接访问_类名__属性。如：_A__foo
2.类的内部可以直接访问；直接访问：__属性
3.子类无法覆盖父类__开头的属性。
封装的意义：
封装的数据属性：明确的区分内外。把数据隐藏起来，然后对外提供操作该数据的接口，在接口内附加上对该数据的限制，已完成对该数据属性操作的严格限制。
封装的方法：目的是隔离复杂度
封装与扩展性：封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
property（特性）：property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值。
如何使用：
class People: def __init__(self,name,weight,height): self.name=name self.weight=weight self.height=height @property def bmi(self): return self.weight / (self.height**2) p1=People('jake',80,1.95) print(p1.bmi)
绑定方法与非绑定方法
一、绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入【自动传值】）：
1. 绑定到类的方法：用classmethod装饰器装饰的方法。
为类量身定制
类.boud_method(),自动将类当作第一个参数传入
（其实对象也可调用，但仍将类当作第一个参数传入）
2. 绑定到对象的方法：在类内定义的没有被任何装饰器装饰的方法。
为对象量身定制
对象.boud_method(),自动将对象当作第一个参数传入
（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）
二：非绑定方法：用staticmethod装饰器装饰的方法
1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说。
反射：通过字符串映射到对象的属性
hasattr(对象名/类,'属性') 判断有没有这个属性
getattr(对象名/类,'属性') 拿到对象的属性
setattr(对象名/类,'属性') 修改对象的属性
delattr(对象名/类,'属性') 删除对象的属性
内置方法介绍：链接
item系列：
class Foo: #Dict def __init__(self,name): self.name=name def __getitem__(self, item): #item='namexxx' # print('getitem...') return self.__dict__.get(item) def __setitem__(self, key, value): # print('setitem...') # print(key,value) self.__dict__[key]=value def __delitem__(self, key): # print('delitem...') # print(key) del self.__dict__[key] obj=Foo('egon') print(obj.__dict__) # 查看属性： obj.属性名 print(obj['namexxx']) #obj.name # 设置属性： obj.sex='male' obj['sex']='male' print(obj.__dict__) print(obj.sex) # 删除属性 del obj.name del obj['name'] print(obj.__dict__)
__str__内置方法：
class People: def __init__(self,name,age): self.name=name self.age=age def __str__(self): # print('====>str') return '<name:%s,age:%s>' %(self.name,self.age) obj=People('egon',18) print(obj) #res=obj.__str__()
__del__内置方法：
class Open: def __init__(self,filename): print('open file.......') self.filename=filename def __del__(self): print('回收操作系统资源：self.close()') f=Open('settings.py') del f #f.__del__() print('----main------') #del f #f.__del__()
一切皆对象，对象可以怎么用？
1.都可以被引用，x=obj
2.都可以当做函数的参数传入
3.都可以当做函数的返回值
4.都可以当做容器类的元素，l = [func,time,obj,1]
exec的用法：
#exec：三个参数 #参数一：包含一系列python代码的字符串 #参数二：全局作用域（字典形式），如果不指定，默认为globals() #参数三：局部作用域（字典形式），如果不指定，默认为locals() #可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中 g={ 'x':1, 'y':2 } l={} exec(''' global x,z x=100 z=200 m=300 ''',g,l) print(g) #{'x': 100, 'y': 2,'z':200,......} print(l) #{'m': 300}
元类：产生类的类称为元类，默认所有用class定义的类的元类是type
# 定义类的两种方式： # 方式一：class class Chinese: # Chinese=type(...) country = 'China' def __init__(self, namem, age): self.name = namem self.age = age def talk(self): print('%s is talking' % self.name) # print(Chinese) obj = Chinese('egon', 18) print(obj, obj.name, obj.age) # 方式二：type # 定义类的三要素:类名，类的基类们，类的名称空间 class_name = 'Chinese' class_bases = (object,) # 默认为object class_body = """ country='China' def __init__(self,namem,age): self.name=namem self.age=age def talk(self): print('%s is talking' %self.name) """ class_dic = {} exec(class_body, globals(), class_dic) print(class_dic)
Chinese = type(class_name,class_bases,class_dic)
如何自定义元类来控制类的创建
class Mymeta(type): def __init__(self, class_name, class_bases, class_dic): if not class_name.istitle(): raise TypeError('类名的首字母必须大写') if '__doc__' not in class_dic or not class_dic['__doc__'].strip(): raise TypeError('必须有注释，且注释不能为空') # 主动抛出异常 super(Mymeta, self).__init__(class_name, class_bases, class_dic) # 继承原来的属性 class Chinese(object, metaclass=Mymeta): # 指定元类 """中文人的类""" country = 'China' def __init__(self, name, age): self.name = name self.age = age def talk(self): print('%s is talking' % self.name) # Chinese=Mymeta(class_name,class_bases,class_dic)
如何自定义元类来控制类的实例化
__call__
class Foo: def __call__(self, *args, **kwargs): print(self) print(args) print(kwargs) obj=Foo() #1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发 #2、调用obj的返回值就是__call__方法的返回值 res=obj(1,2,3,x=1,y=2)
由此可得，调用一个对象，就是在触发对象所在类的__call__方法的执行，同理得类本身也存在一个__call__方法。分析如下：
class Mymeta(type): # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类 def __call__(self, *args, **kwargs): # self=<class '__main__.Foo'> # 1、调用__new__产生一个空对象obj obj = self.__new__(self) # 此处的self是类Foo，必须传参，代表创建一个Foo的对象obj # 2、调用__init__初始化空对象obj self.__init__(obj, *args, **kwargs) # 3、返回初始化好的对象obj return obj class Foo(object, metaclass=Mymeta): school = 'beida' def __init__(self, name, age): self.name = name self.age = age def say(self): print('%s says welcome to the BeiDa to learn Python' % self.name) # 调用Foo就是在调用Foo类中的__call__方法 # 然后将Foo传给self,溢出的位置参数传给*，溢出的关键字参数传给** # 调用Foo的返回值就是调用__call__的返回值 t1 = Foo('jake', 22) print(t1) # 123
默认的在调用Foo时会发生三件事：
1.产生一个空对象
2.调用__init__方法初始化对象obj
3.返回初始化以后的对象obj
异常处理：异常时错误发生的信号，一旦程序出错，并且程序没有处理这个错误，就会抛出异常，并且程序的运行就会终止。
错误的类型，分成两种：
1.语法错误，（在程序运行之前就会检测语法，需要先改正过来才可以运行程序）；
2.逻辑错误
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x IOError 输入/输出异常；基本上是无法打开文件 ImportError 无法引入模块或包；基本上是路径问题或名称错误 IndentationError 语法错误（的子类） ；代码没有正确对齐 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5] KeyError 试图访问字典里不存在的键 KeyboardInterrupt Ctrl+C被按下 NameError 使用一个还未被赋予对象的变量 SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了） TypeError 传入对象类型与要求的不符合 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量， 导致你以为正在访问它 ValueError 传入一个调用者不期望的值，即使值的类型是正确的
异常处理：为了保证程序的容错性，在遇到错误时程序不会奔溃，我们就需要进行异常处理。
1.如果错误发生的条件是可以预知的我们用if进行处理，在错误发生之前进行处理
AGE=10 while True: age=input('>>: ').strip() if age.isdigit(): #只有在age为字符串形式的整数时,下列代码才不会出错,该条件是可预知的 age=int(age) if age == AGE: print('you got it') break
2.如果错误发生的条件是不可以预知的，则需要用try.......except....处理，在错误发生之后进行处理
#基本语法为 try: 被检测的代码块 except 异常类型： try中一旦检测到异常，就执行这个位置的逻辑 #举例 try: f=open('a.txt') g=(line.strip() for line in f) print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) except StopIteration: f.close()
try....except...详细用法：
#1 异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。 s1 = 'hello' try: int(s1) except IndexError as e: # 未捕获到异常，程序直接报错 print e #2 多分支 s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) #3 万能异常Exception s1 = 'hello' try: int(s1) except Exception as e: print(e) #4 多分支异常与万能异常 #4.1 如果你想要的效果是，无论出现什么异常，我们统一丢弃，或者使用同一段代码逻辑去处理他们，那么骚年，大胆的去做吧，只有一个Exception就足够了。 #4.2 如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支了。 #5 也可以在多分支后来一个Exception s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) except Exception as e: print(e) #6 异常的其他机构 s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) #except Exception as e: # print(e) else: print('try内代码块没有异常则执行我') finally: print('无论异常与否,都会执行该模块,通常是进行清理工作') #7 主动触发异常 try: raise TypeError('类型错误') except Exception as e: print(e) #8 自定义异常 class EgonException(BaseException): def __init__(self,msg): self.msg=msg def __str__(self): return self.msg try: raise EgonException('类型错误') except EgonException as e: print(e) #9 断言:assert 条件 assert 1 == 1 assert 1 == 2 #10 总结try..except 1：把错误处理和真正的工作分开来 2：代码更易组织，更清晰，复杂的工作任务更容易实现； 3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；