面向对象
面向对象的三大特性是指：封装、继承和多态。
说明： Python可以函数式编程，也可以面向对象编程
l 面向过程：根据业务逻辑从上到下写垒代码
l 函数式 ：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
l 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
面向对象使用场景： 多个函数中，有相同的参数时，考虑面向对象编程【sql连接等】
需要封装一部分内容的时候，就考虑用类解决
函数和面向对象的区别：定义 + 执行的区别
类的创建以及self的含义：self代表调用该方法的执行对象
class Bar:
def foo(self, name, age, gender, content):
print(self.school, self.haha, name, age, gender, content)
z = Bar()
z.school = 'peking'
z.haha = 'hhh'
print(z.school)
z.foo('ftl', 123, 'male', 'hello world')
构造方法
构造方法__init__(self, args): 函数的初始化的时候自动执行
class Bar:
# 构造方法
def __init__(self, name, age, gender, content):
self.name = name
self.age = age
self.gender = gender
self.content = content
self.boold = 'O' # 初始化默认的参数
print('__init__') # __init__
print(name, age, gender, content, self.boold) # hhh 23 male hello world
z = Bar('hhh', 23, 'male', 'hello world') # hhh 23 male hello world O
父类调用
1. super的调用：super(子类函数名， 调用的self), eg, super(Son, self),先认儿子，再找调用者
2. Father.__init__(self): 由父类名直接调用，我们由对象调用方法的时候，Py会自动帮我们传递self参数，但是由Father类直接调用的时候，需要把调用对象z传递过去。
class Father:
def __init__(self):
print('Father')
def hello(self):
print('Father:hello')
class Son(Father):
def __init__(self):
# super(Son, self).__init__()# 这里super(子类名，self)调用父类的init方法
Father.__init__(self) # 这里父类名.方法(self) 调用父类方法
# 父类名调用的时候，缺少参数报错 __init__() missing 1 required positional argument: 'self'
print('Son')
def hello(self):
print('Son:hello')
super(Son, self).hello() # 调用父类的方法
def world(self):
print('son:world')
z = Son()
z.hello()
z.world()
封装性
将内容封装到某个地方，以后再去调用被封装在某处的内容。
特 性：
将内容封装到某处
从某处调用被封装的内容
class Bar:
def foo(self, content):
print(self.name, self.age, self.gender, content)
z = Bar()
z.name = 'ftl'
z.age = 12
z.gender = 'male'
z.foo('hello world') # ftl 12 male hello world
继承性：
子可以继承父的内容。将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
继承：先在子类自己的方法中查找，然后再去父类的方法查找
class Father:
def __init__(self):
print('Father')
def hello(self):
print('Father:hello')
class Son(Father):
# def __init__(self):
# print('Son') # 子类的构造方法没有覆盖父类，则xian执行父类的构造方法
def __init__(self): # 这里的子类覆盖掉了父类的init方法，所以打印子类自己的print
print('Son')
def world(self):
print('son:world')
z = Son() # Son
z.hello() #Father:hello
z.world() # son:world
多继承：
a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行
d. self代表调用的函数对象，遇到self调用函数的时候，确定self是谁的对象，然后一定是回到原点开始往上找方法的
class BaseRequest():
pass
class RequestHandler(BaseRequest):
def server_forver(self):
print('RequestHandler: server_forver')
self.process_request() # 回到起点开始网上找，结果：Minx : process_request
def process_request(self):
print('RequestHandler: process_request')
class Minx:
def process_request(self):
print('Minx : process_request')
class Son(Minx, RequestHandler):
pass
s = Son()
s.process_request() # Minx : process_request
s.server_forver() # RequestHandler: server_forver
多态性
Python自带多态的特性，因为Python会自动判断你传入的参数是什么类型，不用特别声明
def foo(args):
print(args)
foo("hello world") # hello world
foo(1234567) # 1234567
类的一个小程序：
类的成员
类的成员：
字段： 2种
方法: 3种
属性： 1种
特殊成员：
1种
普通字段属于对象，只能通过对象访问
静态字段属于类，可以通过对象，也可以通过类
class province:
country = 'China' #创建全局变量country， 她是类的对象,创建类的时候生成
# def __init__(self, name, country='CHINA'): # 这里的name是对象的字段，类似Java中的属性
def __init__(self, name):
self.name = name
print(self.name, province.country)
henan = province('henan')
print(province.country) # 可以通过类调用，也可以通过类调用
print(henan.country) # 可以通过对象调用，也可以通过类调用
# print(province.name) # 不能通过对象查找类 type object 'province' has no attribute 'name'
方法：方法保存在类中，可以通过类查找，也可以通过对象调用，但是前提是都要先创建一个类的对象
class Province:
country = 'China' # 创建全局变量country， 她是类的对象,创建类的时候生成
# def __init__(self, name, country='CHINA'): # 这里的name是对象的字段，类似Java中的属性
def __init__(self, name):
self.name = name
def fun(self):
print(self.name, Province.country)
henan = Province('henan')
henan.fun() #推荐使用
# Province.fun() #需要传递对象过去 fun() missing 1 required positional argument: 'self'
Province.fun(henan)
静态方法：@ staticmethod装饰器来完成静态方法，此时可以省略self参数，直接由类调用
class Province:
country = 'China' # 创建全局变量country， 她是类的对象,创建类的时候生成
# def __init__(self, name, country='CHINA'): # 这里的name是对象的字段，类似Java中的属性
def __init__(self, name):
self.name = name
@staticmethod
def fun(city, house): # 可以不用传递self参数
print(Province.country, city, house)
henan = Province('henan')
henan.fun('HuNan', 'Chaoyang')
Province.fun('HuNan', 'Chaoyang') # 推荐使用，直接用类调用，此时的self参数可以不用传递
类方法：由类直接调用，必须传递一个形式参数，此时python会自动帮我们传递一个类名过去,所以一般命名为cls
class Province:
@classmethod
def class_method(cls): #必须传递一个形式参数，python自动传递类名过去
# cls 是类名，不依赖对象
print('class_method:', cls) # 此时python会自动帮我们传递一个类名过去
Province.class_method() # 由类直接调用，此时python会自动帮我们传递一个类名过去
# 结果： class_method: <class '__main__.Province'>
属性(@property)：定义的时候像方法，而且也有返回值， 使用的时候像字段
class Province:
@property
def fun(self):
print('hello world')
return 'ok'
obj = Province()
ok = obj.fun
print(ok) # hello world
属性表达一：(@fun.setter/@fun.deleter)：仅仅是对应关系
class Province:
@property # 用于执行obj.fun 接收值
def fun(self):
print('hello world')
return 'ok'
@fun.setter # 用于obj.fun = 123 ,重新赋值
def fun(self, val):
print(val)
@fun.deleter # 仅仅是一个对应关系，不涉及真正的删除
def fun(self):
print('delete')
obj = Province()
ok = obj.fun
print(ok)
obj.fun = 'hello Python' # 查找对应的关系
del obj.fun # 不会真正的执行删除的操作，仅仅只是一个对应关系
属性表达二：(property函数)：仅仅是对应关系
class Page:
def f1(self):
return 'hhh'
def f2(self, val):
print(val)
def f3(self):
print('del')
pp = property(fget=f1, fset=f2, fdel=f3, doc='Property用法二')
p = Page()
# ret = p.f1()
# print(ret)
print(p.pp) # hhh
p.pp='hello' # hello
del p.pp # del
利用属性实现分页
class Page:
def __init__(self, page):
try:
page = int(page)
except Exception as e:
page = 1
self.page = page
@property
def start(self):
page = (self.page - 1) * 10
return page
@property
def end(self):
page = self.page * 10
return page
li = []
for i in range(100):
li.append(i)
while True:
page = input("请输入页码：")
obj = Page(page)
print(li[obj.start:obj.end])
成员修饰符
公有成员 默认公有
私有成员 __小写字段名 不能直接访问，只能间接访问
继承也不能访问父类的私有字段，只能访问共有字段
class Foo:
__school = 'xupt' # 静态私有字段,外部无法直接访问
def __init__(self, name, age):
self.name = name
# self.age = age
self.__age = age # 私有变量，外部无法直接访问
def show(self):
print(self.__age, self.__school) # 从内部简介访问
@staticmethod
def stat():
print(Foo.__school)
def __private(self):
print('privatemethod')
def f(self):
self.__private()
obj = Foo('hhh', 12)
obj.show() # 12 xupt
Foo.stat() # xupt
obj.f() # privatemethod
子类不能访问父类的私有变量
class F:
def __init__(self):
self.f_name = 'Father'
# self.__fage = 54 # 父类的私有变量
class S(F):
def __init__(self, name, age):
F.__init__(self)
self.name = name
self.__age = age
def show(self):
print(self.__age, self.name)
def showFather(self):
print(self.f_name)
print(self.__fage) # 报错，父类的私有变量
obj = S('hhh', 23)
obj.show() # 23 hhh
obj.showFather() # Father
特殊成员
__init__ 类()自动执行
__del__ 析构方法，对象被销毁时自动触发，Py自动执行
__call__ 对象() 类()() 自动执行
__int__ int(对象)
__str__ str()
__add__
__dict__ # 讲对象中封装的所有内容通过字典的形式返回
__getitem__ # 切片（slice类型）或者索引
__setitem__
__delitem__
__iter__
# 如果类中有 __iter__ 方法，对象=》可迭代对象
# 对象.__iter__() 的返回值： 迭代器
# for 循环，迭代器，next
# for 循环，可迭代对象，对象.__iter__()，迭代器，next
# 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
# 2、循环上一步中返回的对象
__call__ 对象() 类()() 自动执行
class F:
def __init__(self, name, age):
self.name = name
self.age = age
print(self.name, self.age)
def __call__(self, *args, **kwargs):
print('Call')
obj = F('hhh', 23)
obj() # 等价于 F('hhh', 23)() 对象也可以添加()来执行
__int__/__str__/__add__
class F:
def __init__(self, name):
self.name = name
def __int__(self):
return 1234
def __str__(self):
return 'Father'
def __add__(self, other): # 对象的重组
# self= f('hello')
# other = ff('world')
return self.name + other.name
f = F('hello')
ff = F('world')
# print(f+ff) # 没有add方法，报错， unsupported operand type(s) for +: 'F' and 'F'
print(f+ff) # helloworld, 2个对象相加时候，会执行第一个对象的__add方法，并且将第二个对象作为参数传递过去
print(int(f)) # 1234, 对象转换为int型
print(str(f)) # Father, 对象转换为str型
__dict__ # 将对象/类中封装的所有内容通过字典的形式返回
class F:
# hello我让ld
def __init__(self, name):
self.name = name
def show(self):
print(self.__dict__)
f = F('hello')
f.show() # 打印对象里面的所有成员
print(F.__dict__) # 打印类里面的所有成员
__getitem__/__setitem__/__delitem__的使用
# 问： li本身也是一个对象，为什么可以直接用下标来取值呢？ # 答； 因为list里面有__getitem__， __setitem__， __delitem__ li = ['hello', 'world', '2017'] print(li[1]) # print(li[1:4:2]) li[1] = 'ftl' del li[1]
# 函数利用使用__ getitem__
lass F:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
if type(item) == 'slice':
print('这里采用切片调用',item.start, item.stop, item.step)
else:
print('这里采用索引调用')
return item
def __setitem__(self, key, value):
print(key, value)
def __delitem__(self, key):
print(key)
obj = F('hello')
print(obj['hello'])
obj['hello']='world'
del obj['hello']
__iter__: 迭代器的原理
class F:
def __init__(self, name, age):
self.name = name
self.age = age
def __iter__(self): # 代表F是一个可迭代对象
return iter([1, 2, 3, 4, 5]) # 返回一个迭代器
f = F('hhh', 23)
for i in f: # for循环循环next()迭代打印
print(i)