Python基础语法 - 面向对象
描述
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
如何创建类
class 类名：
pass
创建方法
构造方法，__init__(self,arg)
obj = 类('a1')
普通方法
obj = 类(‘xxx’)
obj.普通方法名()
1. 面向对象三大特性之一：封装
class Bar: def __init__(self, n,a): self.name = n self.age = a self.xue = 'o' b1 = Bar('alex', 123) b2 = Bar('eric', 456)
适用场景：
如果多个函数中有一些相同参数时，转换成面向对象
class DataBaseHelper: def __init__(self, ip, port, username, pwd): self.ip = ip self.port = port self.username = username self.pwd = pwd def add(self, content): # 利用self中封装的用户名、密码等 链接数据 print('content') # 关闭数据链接 def delete(self, content): # 利用self中封装的用户名、密码等 链接数据 print('content') # 关闭数据链接 def update(self, content): # 利用self中封装的用户名、密码等 链接数据 print('content') # 关闭数据链接 def get(self, content): # 利用self中封装的用户名、密码等 链接数据 print('content') # 关闭数据链接 s1 = DataBaseHelper('1.1.1.1', 3306, 'alex', 'sb')
2. 面向对象三大特性之二：继承
1. 继承
class 父类：
pass
class 子类(父类):
pass
2. 重写
防止执行父类中的方法
3、self永远是执行改方法的调用者
4.
super(子类, self).父类中的方法(...)
父类名.父类中的方法(self,...)
5、Python中支持多继承
a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行
3. 面向对象三大特性之三：多态
====> 原生多态
# Java（伪代码） string v = 'alex' def func(string arg): print(arg) func('alex') func(123) #报错 # Python v = 'alex' def func(arg): print(arg) func(1) func('alex')
类的成员：字段
class Foo: #静态字段 variable = abc def __init__(self, name): # 普通字段 self.name = name # 普通方法 def show(self): print(self.name) obj = Foo('alex') obj.name obj.show()
类成员：
# 字段
- 普通字段，保存在对象中，执行只能通过对象访问
- 静态字段，保存在类中， 执行可以通过对象访问 也可以通过类访问
# 方法
- 普通方法，保存在类中，由对象来调用，self -- > 对象
- 静态方法，保存在类中，由类直接调用
- 类方法，保存在类中，由类直接调用，cls -- > 当前类
应用场景：
1. 如果对象中需要保存一些值，执行某功能时，需要使用对象中的值 －＞ 普通方法
2. 不需要任何对象中的值，静态方法
类的成员：属性
class Foo: @property #obj.per def per(self): return 123 @per.setter #obj.per = 123 def per(self, val): print(val) @per.deleter #del obj.per def per(self): print(666) obj = Foo() obj.per obj.per = 123 del obj.per
示例：页码切换
class Pergination: def __init__(self, current_page): try: p = int(current_page) except Exception as e: p = 1 self.page = p @property def start(self): #定义每页开始方法 val = (self.page-1) * 10 return val @property def end(self): #定义每页结束方法 val = self.page * 10 return val li = [] for i in range(1000): li.append(i) while True: p = input('请输入要查看的页码：') # 1,每页显示10条 obj = Pergination(p) print(li[obj.start:obj.end])
另一种方法，分别对应@property @per.setter @per.deleter ，并与之同理
class Foo: def f1(self): return 123 def f2(self,v): print(v) def f3(self): print('del') per = property(fget=f1,fset=f2,fdel=f3,doc='abc') obj = Foo() ret = obj.per print(ret) #1 obj.per = 123456 #2 del obj.per #3
成员修饰符
共有成员
私有成员，__字段名
无法直接访问，只能间接访问
普通字段 / 静态字段
class Foo: __val = 'abc' def __init__(self,name,age): self.name = name # self.age = age self.__age = age #私有，外部无法直接访问 def show(self): #间接访问 return self.__age def show1(self): return Foo.__val @staticmethod def stat(): return Foo.__val obj = Foo('alex',18) print(obj.name) #alex # print(obj.age) #18 print(obj.__age) #AttributeError: 'Foo' object has no attribute '__age' ret = obj.show() print(ret) #18 ret = obj.show1() print(ret) #abc ret = Foo.stat() print(ret) #abc
普通方法 / 静态方法 / 特殊方法
class Foo: def __f1(self): return 123 def f2(self): return self.__f1() return r obj = Foo() ret = obj.f1() print(ret) #'Foo' object has no attribute 'f1' ret = obj.f2() print(ret) #可以访问
- 不能继承私有字段，不能访问
特殊成员
__init__
__call__
class Foo: def __init__(self): print('init') def __call__(self, *args, **kwargs): print('call') obj = Foo() # Foo()自动执行__init__方法 obj() #相当于 Foo()() #obj()自动执行__call__方法
__str__
__init__
__del__
__add__
__dict__ # 讲对象中封装的所有内容通过字典的形式返回
__getitem__ # 切片（slice类型）或者索引
__setitem__
__delitem__
__iter__
# 如果类中有 __iter__ 方法，对象=》可迭代对象
# 对象.__iter__() 的返回值： 迭代器
# for 循环，迭代器，next
# for 循环，可迭代对象，对象.__iter__()，迭代器，next
# 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
# 2、循环上一步中返回的对象
mataclass
