面向对象
三步: a,在内存中开辟一个对象空间.
b,自动执行__init__方法,将对象空间传给self
c,执行__init__方法,给对象空间封装属性.
为什么要定义init
定义完init后，创建的每个实例都有自己的属性，也方便直接调用类中的函数
函数中有哪些装饰器
静态方法，类方法，实例方法，flask路由
对象
obj = Hunman('宝元',1000)
1),对象查看对象内所有的属性.
obj.__dict__
2),对象操作对象空间的单独属性
增: obj.sex = '男'
删: del obj.name
改:obj.age = 73
查: obj.name
3) ,对象查看类中的属性.
obj.mind
4)对象执行类中的方法.
obj.work()
类空间与对象空间研究类
1)给对象封装属性:在__init__中,在类外面,在累的其他方法中
2) 给类封装属性:类的外部,累的内部
3)有了指针:对象找一个属性:先对象空间找类空间找父类找
类找属性:类空间找父类空间找
以上顺序不可逆
4)依赖关系:将一个类的类名或对象传入到另一个类的方法中
5)关联,组合,聚合关系是一种,:将一个类的对象或类名封装到另一个类的对象属性中
6)实现,继承关系
单继承
好处
减少代码重复率,让类与类 产生关系,增强耦合性(高内聚,低耦合),使代码更规范,清晰化
对象查找属性
对象空间 -----> 类空间 -----> 父类....
类的查找属性
类空间 ------> 父类空间 ----> object.
单继承：对象既要执行父类的方法,又要执行子类的方法.
两种解决方式:
1,类名.方法名(参数(包括self)) 不依赖继承
A.__init__(self,name,age)
2,super().方法名(参数(不包括self)) 依赖继承
super().__init__(name,age)
<a name='1'style='color:black'>Super()
Super（类名,self）是按照mro顺序执行下一个类,跳过指定类名
super() 不是执行父类的,他是严格按照mro的继承顺序执行下一个
python中类的分类:
python2x版本:
python2.2之前,只有经典类,python2.2之后出现了新式类.
经典类: 不继承object类. 多继承遵循深度优先. 深度优先: 从左至右,一条路走到底.
class A:
pass
新式类: 继承object的类. 多继承遵循c3算法,mro的顺序执行.
class A(object):
pass
python3x版本: 所有类都默认继承object.
只有新式类. 新式类的多继承: C3算法.
查看继承顺序 :类名.mro()
obj=D()
print(D.mro())
类的约束
指制定一个强制标准,轻质子类要有父类规定的方法
第一种方式 :Python最常用的方式.
class Payment:
def pay(self,money):
raise Exception('子类要定义pay方法!!!')
方法二 抽象类 接口类
指制定一个规范,强制子类必须有pay方法,如果没有,在你实例化的时候就会报错.
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self,money):
pass
@abstractmethod
def f1(self):
pass
class Alipay(Payment):
异常处理
错误类型:KeyError IndexError ValueError
1)单支:
try:
代码
Except 错误类型:
处理方式
2)多分支:
Try:
代码
Except 错误类型:
处理方式
Except 错误类型:
处理方式
3)万能异常
try:
代码
except Exception:
处理方式
如果 你只想将异常处理掉,对错误信息不关心,用万能异常.
4)多分支 + 万能
try:
语句
Except 错误类型:
Print(‘’)
Except 错误类型:
Print(‘’)
except Exception:
处理方式
else : 如果出现异常,就不执行else 否则执行else语句.
5) try except else:
6)try finally:
finally 出不出现异常都执行,异常出现前执行fianlly.
用途:
1.关闭文件句柄,关闭数据库链接.
2.函数return之前能够执行finally代码.
3.break之前可以执行finally.
-
raise 主动抛出异常
raise IndexError('超出索引范围') -
断言 表示一个强硬的态度,不满足条件直接报错
assert 条件
assert 1 == 2
类的私有成员
私有静态属性,私有对象属性,私有方法 都只能在内部使用
私有成员只是做了一个简单的变相加密,让你直接访问不了
私有成员来说,他们只能在类的内部使用, __age =”32”2个下划线叫私有
def __init__(self):
self.__func() # self._A__func()
方法包括
普通方法（实例方法）、静态方法和类方法,
实例方法
第一个参数为'self', 通过它来传递是实例的属性和方法，（也可以传递类的属性和方法）
通常是通过对象去调用的方法
静态方法
没有'self','cls' 参数，方法体中不能使用类和实例的任何属性和方法
类名和实例对象都可以调用
类方法,
第一个参数为clsf', 通过它来传递是类的属性和方法，（不可以传递实例的属性和方法）
用 类名调用方法(对象也行,最好不用)
1)@classmethod类方法(cls), 第一个参数主动接受类名
2)@staticemethod静态方法:不依赖于类以及对象的方法,他是函数
属性 @property
python的@property是python的一种装饰器，是用来修饰方法的。将方法伪装成了属性，代码级别上没区别，只是看起来更合理
作用：
我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。
例：
class DataSet(object):
@property
def method_with_property(self): ##含有@property
return 15
def method_without_property(self): ##不含@property
return 15
l = DataSet()
print(l.method_with_property) # 加了@property后，这个方法就变成了一个属性,是以 属性的形式 来调用方法,后面不需要加（）。加了（）会报错,那么就是当作函数来调用，而它却不是callable（可调用）的
print(l.method_without_property) # 没有加@property , 必须使用正常的调用方法的形式，即在后面加().没有使用@property修饰，它是一种方法，如果把括号去掉，不会报错输出的就会是方法存放的地址。<bound method DataSet.method_without_property of <__main__.DataSet object at 0x119ad57b8>>
结果都是15
1)类里面加上@property, 调用的时候不加括号
print(p1.bim)
要是不加,调用的时候加括号
print(p1.bim())
property的三个方法
@property @bmi.setter @bmi.getter @bmi.deleter
class A:
def __init__(self):
self.bmi=100
@property
def bmi(self):
print(11)
@bmi.setter
def bmi(self,n):
print(n)
@bmi.deleter
def bmi(self):
print(111)
obj=A()
obj.bmi 触发被property
obj.bmi=22 对bmi这个属性进行更改,就会触发被bmi.setter装饰的函数
del obj.bmi 触发deleter
坑 注:要是对象自己的属性与类的伪装重名时,对对象属性进行修改时,则只会执行@bmi.setter这个方法
例：
class Student(object):
@property
def birth(self):
return self._birth
@birth.setter #设置值
def birth(self, value):
self._birth = value
@birth.getter #获取值
def birth(self)
return self._birth
@birth.deleter
def birth(self):
del self._birth
@property
def age(self):
return 2014 - self._birth
s =Student()
s.birth = 12 #先设置值才能读取
print(s.age)
del s.birth
print(s.age)
@bmi.setter这个方法
class Foo:
def get_AAA(self):
print('get的时候运行我啊')
def set_AAA(self, value):
print('set的时候运行我啊')
def delete_AAA(self):
print('delete的时候运行我啊')
AAA = property(get_AAA, set_AAA, delete_AAA)
# 内置property三个参数与get,set,delete一一对应
f1 = Foo()
f1.AAA
f1.AAA = 'aaa'
del f1.AAA
类与类之间的关系
继承关系：分为单继承，多继承
依赖关系: 将一个对象或者类名封装到另一个类方法中.
组合关系: 将一个对象封住到另一个对象的属性中.
class A:
def func(self, a):
print(a.name)
def func1(self, a):
self.q = a
class B:
def __init__(self):
self.name = 'alex'
# 依赖关系
obj1 = A()
obj2 = B()
obj1.func(obj2)
# 组合
obj1 = A()
obj2 = B()
obj1.func1(obj2)
反射
指通过字符串的形式操作对象相关的属性
对象:实例化对象,类,本模块,其他模块
反射四个方法
检测是否含有某属性hasattr()
获取属性 getattr()
设置属性 setattr()
setattr(foo,'height',12)
print(obj.__dict__)
删除属性 delattr()
用反射写一个登录页面
在本模块中
def foo():
print(11)
import sys
r=sys.modules[__name__]
con=input('>>')
if hasattr(r,con):
getattr(r,con)()
函数与方法的区别
1.1)类中的实例方法只有通过对象调用时才叫方法,其次都是函数
2)类中的类方法,是方法MethodType
3)类中的静态方法,其实是函数FunctionType
2.区别:
函数是显性传参
函数不依赖对象,类
方法是隐性传参
方法依赖对象,类
3.用isinstance判断是方法还是函数
4.isinstance和issubclass的用法
isinstance(obj,A) obj 是否是A或A的派生类的对象
issubclass(B,A) 判断B是否是A的子类或孙类
Iterable: list,str,tuple,dict等都是Iterable的子类(派生类)
from collections import Iterable
print(isinstance(list,Iterable)) #False
print(isinstance([1,2,3],Iterable))#True
print(issubclass(list,Iterable))#True
type
type 元类,也叫构建类,type产出了python的大量的内类(object,str等等)以及自建类(自己建的类)，python中一切皆对象
callable 判断可调用
双下方法
__new__和__init__区别
__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
1) new
也叫构造方法 new(cls)
类名()触发new方法 产生并返回对象的地方得有return
写一个单例模式
class A :
def __init__(self):
print(11)
def __new__(cls, *args, **kwargs):
print(22)
return object.__new__(cls)
obj = A()
print(obj)
先执行__new__再执行__init__
class A:
a = None
def __new__(cls, *args, **kwargs):
if not cls.a:
obj = object.__new__(cls)
cls.a = obj
return cls.a
d1 = A()
d2 = A()
print(d1,d2)
因为创建对象时__new__方法执行，并且必须return 返回实例化出来的对象所cls.__instance是否存在，不存在的话就创建对象，存在的话就返回该对象，来保证只有一个实例对象存在（单列），打印ID，值一样，说明对象同一个
2） call
对象() 或者 类()()时触发__call__
3)item系列 :
类似于字典的操作
Getitem(获取): obj[‘name’]就会触发getitem
setitem(修改): obj[‘name’]=’fd’就会触发setitem, 不写return这个单词
delitem(删除):del obj[‘name’] 不需要返回值 没有真删,把值传给了key
class A:
def __init__(self,n):
self.name=n
def __getitem__(self, item):
print(12)
return self.__dict__[item]
def __setitem__(self, key, value):
print(45)
self.__dict__[key]=value
def __delitem__(self, key):
print(12)
obj =A('xiaoh')
print(obj['name']) #结果12 xiaoh
obj['name']='df'
print(obj.__dict__)#{'name': 'df'}
del obj['name']
print(obj.__dict__) 没有真删,把值传给了key
还有一个attr的操作，跟item类似
它是点的操作
getattr(获取): obj.name 就会触发getitem
setattr(修改): obj.name=’fd’就会触发setitem, 不写return这个单词
delattr(删除):del obj.name 不需要返回值 没有真删,把值传给了key
举个例子
class foo(object):
def __setitem__(self, key, value):
print(1)
print(key,value)
def __setattr__(self, key, value):
print(2)
print(key,value)
f = foo()
f.num=666
f['name'] = 888
结果是
2 num 666 1 name 888
4)len
只要对 对象len+(),就会触发对象从属于的类中的__len__方法 有return
写上len(obj)就会触发__len__ 不执行return结果
Print(len(obj)) 执行return结果
class A:
def __init__(self,n,m,l):
self.name=n
self.m=m
self.p = l
def __len__(self):
print(55)
return len(self.__dict__)
obj=A('bbn','hj','dasd')
print(len(obj))
print(obj.__dict__)
结果是
55 3 {'name': 'bbn', 'm': 'hj', 'p': 'dasd'}
5） 上下问管理
enter exit
对一个对象类似于with的操作
class A:
def __init__(self,a):
self.a=a
def __enter__(self):
self.b=self.a+'小花'
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.c='小兰字'
with A('小兰') as f: #开始执行
print(f.b)
print(f.c) #结束执行
6) hash
父类中有,所以不写也能触发__hash__
7) str
对象触发__str__ return后边是字符串
Print(obj) 触发__str__
class A:
def __init__(self,n):
self.name=n
def __str__(self):
return str(self.__dict__)
obj =A('cbv')
print(obj) #结果{'name': 'cbv'}
8) repr
return后边也是字符串
9) eq
同一个类的两个对象比较,就会触发__eq__方法
不写return 返回的是None
class A:
def __eq__(self, other):
print(12)
return 456
obj =A()
a=A()
print(obj==a)
10)析构方法 del
当对象在内存中释放时,自动触发执行,此方法一般无需执行
11）iter 和__next__
class A:
def __iter__(self):
yield 1
yield 2
obj = A()
# print(next(obj)) 会报错 因为obj是可迭代对象
obj1 = iter(obj)
print(next(obj1))
print(next(obj1))
结果是 1 2
或者
for i in obj:
print(i) # 11 22
或者
print(list(obj)) #[11, 22]
