一、 一些基础：
1、如何创建类
class 类名：
pass
2、创建方法
构造方法，__init__(self,arg)
obj = 类('a1')
普通方法
obj = 类(‘xxx’)
obj.普通方法名()
3、面向对象三大特性之一：封装
class Bar:
def __init__(self, n,a):
self.name = n
self.age = a
self.xue = 'o'
b1 = Bar('alex', 123)
b2 = Bar('eric', 456)
4、适用场景：
如果多个函数中有一些相同参数时，转换成面向对象
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')
5、面向对象三大特性之二：继承
1、继承
class 父类：
pass
class 子类(父类):
pass
2、重写
防止执行父类中的方法
3、self永远是执行改方法的调用者
4、
super(子类, self).父类中的方法(...)
父类名.父类中的方法(self,...)
5、Python中支持多继承
a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行
6、面向对象三大特性之三：多态
====> 原生多态
# 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 Province:
# 静态字段，属于类
country = '中国'
def __init__(self, name):
# 普通字段，属于对象
self.name = name
# 方法
- 普通方法，保存在类中，由对象来调用，self=》对象
- 静态方法，保存在类中，由类直接调用
- 类方法，保存在类中，由类直接调用，cls=》当前类
class Foo:
def __init__(self):
self.name ='a'
def bar(self): # 普通方法
# self是对象
print('bar')
@staticmethod
def sta(): # 静态方法
print('123')
@staticmethod
def stat(a1,a2):
print(a1,a2)
@classmethod
def classmd(cls): # 类方法
# cls 是类名
print(cls)
print('classmd')
# 静态方法、类方法的调用
Foo.stat(1,2)
Foo.classmd()
# 普通方法的调用
obj = Foo()
obj.bar()
Foo.bar(obj)
# 应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值 －＞ 普通方法
不需要任何对象中的值，静态方法
# 属性，特性
- 不伦不类：调用时不带括号，但是是一个方法（函数）
class Foo:
def __init__(self):
self.name = 'a'
# obj.name
self.name_list = ['alex']
# obj.bar()
def bar(self):
# self是对象
print('bar')
# 用于执行 obj.per
@property
def perr(self):
return 123
# obj.per = 123
@perr.setter
def perr(self, val):
print(val)
@perr.deleter
def perr(self):
print(666)
obj = Foo()
r = obj.perr # return 123
print(r)
obj.perr = 123 # 调用的是@perr.setter 之后的方法
del obj.perr # 调用的是perr.deleter 之后的方法
# property函数
property() 函数的作用是在新式类中返回属性值。
语法
以下是 property() 方法的语法：
class property([fget[, fset[, fdel[, doc]]]])
参数
- fget -- 获取属性值的函数
- fset -- 设置属性值的函数
- fdel -- 删除属性值函数
- doc -- 属性描述信息
定义一个可控属性值 x
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
解析：
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
将 property 函数用作装饰器可以很方便的创建只读属性：
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
## 上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x