一.类
1.类成员
2. 类基础
class people:
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender=gender
def kanchai(self):
print('姓名:%s ,年龄:%s岁,性别%s,%s' %(self.name,self.age,self.gender,'砍柴'))
def kaiche(self):
print('姓名:%s ,年龄:%s岁,性别%s,%s' %(self.name,self.age,self.gender,'开车'))
def dabaojian(self):
print('姓名:%s ,年龄:%s岁,性别%s,%s' %(self.name,self.age,self.gender,'大保健'))
li = people('老李',91,'male')
li.dabaojian()
li.kaiche()
li.kanchai()
3. 类的继承
class Animal:
def eat(self):
print("%s 吃 " %self.name)
def drink(self):
print("%s 喝 " %self.name)
def shit(self):
print("%s 拉 " %self.name)
def pee(self):
print("%s 撒 " %self.name)
class cat(Animal):
def __init__(self,name):
self.name = name
self.breed = 'cat'
def cry(self):
print('cat crys!')
cat1 = cat('foolcat')
cat1.cry()
cat1.drink()
cat1.eat()
cat1.pee()
cat1.shit()
3.1 多继承
4.多态
二.类进阶用法
1.字段
字段:普通字段和静态字段
最本质的区别是在内存中保存的位置不同
1、普通字段属于对象
2、静态字段属于类
class Province:
# 静态字段
country = '中国'
def __init__(self, name):
# 普通字段
self.name = name
# 直接访问普通字段
obj = Province('河北省')
print(obj.name)
# 直接访问静态字段
print(Province.country)
2.方法
包括:普通方法,静态方法和类方法
三种方法都归属于类,但是区别在于调用方式不同
1).普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;
2).类方法:由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;
3).静态方法:由类调用;无默认参数;
class Foo:
def __init__(self, name):
self.name = name
def ord_func(self):
""" 定义普通方法,至少有一个self参数 """
# print self.name
print('普通方法')
@classmethod
def class_func(cls):
""" 定义类方法,至少有一个cls参数 """
print('类方法')
@staticmethod
def static_func():
""" 定义静态方法 ,无默认参数"""
print('静态方法')
# 调用普通方法
f = Foo('gg')
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
3.属性
属性就是普通方法的变种
有三个知识点:
1).属性基本使用
2).属性的两种定义方式
1). 属性基本使用
#%% 属性的基本使用
class Foo:
def func(self):
print('This %s'%'come from func')
# 定义属性
@property
def prop(self):
print('This %s'%'come from prop')
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()
foo_obj.prop #调用属性
print('$$'.center(40,'-'))
*注意:
a.属性在定义的时候前面加上 @property 装饰器;
b.定义时属性仅有一个self参数
c.调用时无需加括号:
方法:foo_obj.func()
属性:foo_obj.prop
例:对于主机列表页面,每次请求不可能把数据库中的所有内容都显示到页面上,而是通过分页的功能局部显示,所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据(即:limit m,n),这个分页的功能包括:
根据用户请求的当前页和总数据条数计算出 m 和 n
根据m 和 n 去数据库中请求数据
代码:
# ############### 定义 ###############
class Pager:
def __init__(self, current_page):
# 用户当前请求的页码(第一页、第二页...)
self.current_page = current_page
# 每页默认显示10条数据
self.per_items = 10
@property
def start(self):
val = (self.current_page - 1) * self.per_items
return val
@property
def end(self):
val = self.current_page * self.per_items
return val
# ############### 调用 ###############
p = Pager(1)
p.start 就是起始值,即:m
p.end 就是结束值,即:n
2). 属性定义的两种方式
1).装饰器:在方法上应用装饰器
2).静态字段:在勒种定义值为property对象的静态字段
2-1). 使用装饰器定义属性
经典类和新式类,新式类的属性比经典类的属性丰富。新式类继承object类
# ############### 经典类的属性定义 ###############
class Goods:
@property
def price(self):
return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price # 自动执行 @property 修饰的 price 方法,并获取方法的返回值
# ############### 新式类的属性定义 ###############
class Goods(object):
@property
def price(self):
print('@property')
@price.setter
def price(self, value):
print('@price.setter')
@price.deleter
def price(self):
print('@price.deleter')
# ############### 调用 ###############
obj = Goods()
obj.price # 自动执行 @property 修饰的 price 方法,并获取方法的返回值
obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法,并将 123 赋值给方法的参数
del obj.price # 自动执行 @price.deleter 修饰的 price 方法
由于新式类中具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deleter
def price(self):
del self.original_price
obj = Goods()
print(obj.price) # 获取商品价格
obj.price = 200 # 修改商品原价
print(obj.price)
print(obj.__dict__)
del obj.price # 删除商品原价
print(obj.__dir__())
print(obj.__dict__)
2-2). 静态字段方式
创建值为property对象的静态字段(当使用静态字段的方式创建属性时,经典类和新式类无区别)
class Foo:
def get_bar(self):
return 'something'
BAR = property(get_bar)
obj = Foo()
reuslt = obj.BAR # 自动调用get_bar方法,并获取方法的返回值
print(reuslt)
property的构造方法中有个四个参数:
a.第一个参数是方法名,调用 对象.属性 时自动触发执行方法
b.第二个参数是方法名,调用 对象.属性 = XXX 时自动触发执行方法
c.第三个参数是方法名,调用 del 对象.属性 时自动触发执行方法
d.第四个参数是字符串,调用 对象.属性.doc ,此参数是该属性的描述信息
由于静态字段方式创建属性具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
例:
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
def get_price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
def set_price(self, value):
self.original_price = value
def del_price(self):
del self.original_price
PRICE = property(get_price, set_price, del_price, '价格属性描述...')
obj = Goods()
print(obj.__dict__)
print(obj.PRICE) # 获取商品价格
print(obj.__dict__)
obj.PRICE = 200 # 修改商品原价
print(obj.__dict__)
del obj.PRICE
print(obj.__dict__)
注意:Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性
4.类成员的修饰符
对于每一个类的成员而言都有两种形式:
1)公有成员,任何地方都能访问
2)私有成员,只有在类的内部才能访问
1).两者定义不同
私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:init、call、__dict__等)
class C:
def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"
2).两者访问限制不同
a.对于静态字段来说:
公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
私有静态字段:仅类内部可以访问;
class C:
name = "公有静态字段"
__name = "公有静态字段"
def func(self):
print(C.name)
def func_static(self):
print(C.__name)
class D(C):
def show(self):
print(C.name)
def show_static(self):
print(C.__name)
C.name # 类访问
obj = C()
obj.func() # 类内部可以访问
obj_son = D()
obj_son.show() # 派生类中可以访问
try:
C.__name # 类访问 ==> 错误
except Exception as e:
print(e)
obj = C()
obj.func_static() # 类内部可以访问 ==> 正确
obj_son = D()
try:
obj_son.show_static() # 派生类中可以访问 ==> 错误
except Exception as e:
print(e)
# 强制访问私有字段,可以通过 【对象._类名__私有字段明 】
# 但是不建议强制访问私有成员。
print(D._C__name)
#### b.对于普通字段来说
公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
私有普通字段:仅类内部可以访问;
class C:
def __init__(self):
self.foo = "公有字段"
self.__foo = "私有字段"
def func(self):
print(self.foo)# 类内部访问公有普通字段
def func_private(self):
print(self.__foo)# 类内部访问私有普通字段
class D(C):
def show(self):
print(self.foo)#派生类中访问
def show_private(self):
print(self.__foo)#派生类中访问类私有普通字段
obj = C()
print(C().__dict__)
print(obj.__dict__)
print(obj.foo) # 通过对象访问公有普通字段
try:
obj.__foo # 通过对象访问私有普通字段 出错
except Exception as e:
print(e)
obj.func() # 通过对象调用类内部方法访问公有普通字段
obj.func_private()# 通过对象调用类内部方法访问私有普通字段
obj_son = D()#派生类的对象
print(obj_son.__dict__)
obj_son.show() # 派生类的对象可直接访问原类的公有普通字段
obj_son.func_private()# 派生类的对象通过调用原类内部方法访问原类的私有普通字段
5.类的特殊成员
1.xxx__doc__
class Foo:
""" 描述类信息 """
def func(self):
pass
print(Foo.__doc__)
2.xxx__module__ & xxx__class__
class C:
def __init__(self):
self.name ='gg'
from python_primarylearning.类与面向对象.lib_aa import C
obj = C()
print(obj.__module__) # 输出 lib.aa,即:输出模块
print(obj.__class__) # 输出 lib.aa.C,即:输出类
3.xxx__init__
构造方法,通过类创建对象时,自动触发执行。
4.xxx__del__
析构方法,当对象在内存中被释放时,自动触发执行。
5.xxx__call__
对象后面加括号,触发执行。
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('现在是调用__call__方法')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
6.xxx__dict__
类或对象中的所有成员
类的普通字段属于对象;类中的静态字段和方法等属于类,即:
class Province:
country = 'China'
def __init__(self, name, count):
self.name = name
self.count = count
def func(self, *args, **kwargs):
print('func')
# 获取类的成员,即:静态字段、方法、
print(Province.__dict__)
# 输出:{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}
obj1 = Province('HeBei',10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出:{'count': 10000, 'name': 'HeBei'}
7.xxx__str__
Return str(self)
8. xxx__getitem__、xxx__setitem__和xxx__delitem__
用于索引操作,如字典。以上分别表示获取、设置、删除数据
class Foo(object):
def __getitem__(self, key):
print('__getitem__', key)
def __setitem__(self, key, value):
self.__dict__[key]= value
def __delitem__(self, key):
del self.__dict__[key]
obj = Foo()
print(obj.__dict__)
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'gg' # 自动触发执行 __setitem__
print(obj.__dict__)
a = obj['k2']
print(a) #为空,因为没对__getitem__的return定义
del obj['k2'] # 自动触发执行 __delitem__
print(obj.__dict__)
9.xxx__getslice__、xxx__setslice__、xxx__delslice__
该三个方法用于分片操作,如:列表
10.xxx__iter__
用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了