面向对象
面向对象的三大特性是指:封装、继承和多态。
说明: 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)