Python面向对象详解
本文深入解析Python中的面向对象编程，涵盖类的创建、构造与析构方法、属性与方法的定义，以及私有成员和特殊字段的使用。通过实例演示不同类型的字段、方法和属性，帮助读者理解Python面向对象的核心概念。
先看看面向对象-----在现如今的编程语言中大部分都已经具备了完善的面向对象思想。例如C++、java这两大主流编程语言。这两个是现如今使用量最大，且将面向对象发挥到极致的语言。面向对象-百度百科
python面向的对象最主要的类--而python类中最主要包括 字段、方法、属性
先来看看如何创建一个python类
class Pager:
def __init__(self, current_page):
# 用户当前请求的页码（第一页、第二页...）
self.current_page = current_page
# 每页默认显示10条数据
self.per_items = 10
def start(self):
val = (self.current_page - 1) * self.per_items
return val
def end(self):
val = self.current_page * self.per_items
return val
tips: python中一个类只能有一个构造函数存在。定义多个构造方法时，实例化类只实例化最后的构造方法，
即后面的构造方法会覆盖前面的构造方法，并且需要更具最后一个构造方法的形式进行实例化
接下来分片看看类中的三大将
- 字段分为------普通字段 和 静态字段
- 普通字段-----(普通字段属于类对象拥有)
- 静态字段-----(静态字段属于当前类,静态字段在内存中只保存一份;普通字段在每个对象中都要保存一份)
class province:
#静态字段
country = "China"
def __init__(self,name):
#普通字段
self.name = name
#访问普通字段方法
obj = province("shan'xi")
print(obj.name)
#访问静态字段方法
print(province.country)
- 方法分为------普通方法、静态方法 和 类方法
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法： 由类调用；至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数
class testFun:
#构造函数
def __init__(self,name):
self.name = name
def orderFunc(self):
"""普通方法，至少一个self参数 """
print("普通方法")
@classmethod
def classFunc(cls):
"""类方法，至少一个cls参数 """
print("类方法")
@staticmethod
def staticmethod():
"""静态方法，没有默认参数 """
print("静态方法")
#1.调用普通方法
test = testFun("xi'an") #创建对象
test.orderFunc()
#2.调用类方法
testFun.classFunc()
#3.调用静态方法
testFun.staticmethod()
- 属性------类的普通方法的变种
1:在普通方法的基础上添加 @property 装饰器;
2:属性仅有一个self参数;
3:调用时，无需括号
属性存在意义：访问属性时可以制造出和访问字段完全相同的假象
class testProtertyFun:
#构造函数
def __init__(self,name):
self.name = name
#定义属性
@property
def propertyFunc(self):
"""属性方法，至少一个self参数 """
print("属性方法")
test = testProtertyFun("xi'an")
#调用属性
test.propertyFunc再来看几个案例，看看属性和方法的区别到底在哪一块
#对某一个数值进行改变，计算其开始与结束后的值。
class Pager:
def __init__(self, current_):
# 用户当前请求的页码（第一页、第二页...）
self.current_ = current_
# 每页默认显示10条数据
self.per_items = 10
@property
def start(self):
val = (self.current_ - 1) * self.per_items
return val
@property
def end(self):
val = self.current_ * self.per_items
return val
# ############### 调用 ###############
p = Pager(1)
p.start #就是起始值，即：m
p.end #就是结束值，即：n属性两种定义方式（装饰器模式、静态字段）
- 装饰器方式：在类的普通方法上应用@property装饰器
tips:Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 )
- 经典类，具有一种@property装饰器
class Goods:
@property
def price(self):
return "wupeiqi"
obj = Goods()
# 自动执行 @property 修饰的 price 方法，并获取方法的返回值
result = obj.price - 新式类，具有三种@property装饰器
#新式类，具有三种@property装饰器
class NewerPropertyClass:
@property
def Func1(self):
print("@property")
@property
def Func2(self):
pass
#设置属性装饰器时，被设置的setter deleter必须有一个被property修饰的函数
@Func2.setter
def Func2(self,value):
newvalue = value
print("@property.setter")
@Func2.deleter
def Func3(self):
print("@property.deleter")
obj = NewerPropertyClass()
obj.Func1 # 自动执行 @property 修饰的 Func1 方法，并获取方法的返回值
obj.Func2 = 123 # 自动执行 @price.setter 修饰的 Func2 方法，并将 123 赋值给方法的参数
del obj.Func3 # 自动执行 @price.deleter 修饰的 Func3 方法tips:综上新式类会将属性设置为对同一个操作分为：获取、修改、删除. 而Setter必须有个参数，保证可以传入参数值。且setter、deleter的函数必须有一个被@property修饰的函数
静态字段模式-------当使用静态字段的方式创建属性时，经典类和新式类无区别
class Foo:
def get_bar(self):
return 'wupeiqi'
#静态字段模式
BAR = property(get_bar)
obj = Foo()
# 自动调用get_bar方法，并获取方法的返回值
reuslt = obj.BAR
print(reuslt)property的构造方法中有个四个参数
- 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
- 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
- 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
- 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
看这个例子：
class TestClass:
def get_bar(self):
print("get_bar")
return ("wupeiqi")
# *必须两个参数
def set_bar(self, value):
print("set_bar:" + value)
return ('set value' + value)
def del_bar(self):
value = 0
print("del_bar:" + str(value))
return (value)
BAR = property(get_bar,set_bar,del_bar,"description...")
obj = TestClass()
obj.BAR # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
print(obj.BAR.__doc__)#调用 对象.属性.__doc__ ，
# 此参数是该属性的描述信息(此处调用需要放在del obj.BAR这句之前)
del obj.BAR # 自动调用第三个参数中定义的方法：del_bar方法
类成员的修饰符 (公有成员---私有成员)
- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能方法;私有成员命名时，前两个字符是下划线 __（特殊成员除外，例如：__init__、__call__、__dict__等）
- 如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
- 静态字段：
- 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
- 私有静态字段：仅类内部可以访问
访问类的公有成员字段
class CClass: name = "公有静态字段" def func(self): print (CClass.name) class DClass(CClass): #DClass继承CClass def show(self): print (CClass.name) CClass.name # 类访问 obj = CClass() obj.func() # 类内部可以访问 obj_son = DClass() obj_son.show() # 派生类中可以访问
访问类的公有成员字段
class CClass: __name = "私有静态字段" def func(self): print (CClass.name) class DClass(CClass): #DClass继承CClass def show(self): print (CClass.name) CClass.name # 类访问==> 错误 obj = CClass() obj.func() # 类内部可以访问 ==> 正确 obj_son = DClass() obj_son.show() # 派生类中可以访问 ==> 错误
- 普通字段
- 公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
- 私有普通字段：仅类内部可以访问；
访问类的公有字段
class AClass: def __init__(self): self.foo="公有字段" def func(self): print (self.foo) # 类内部访问 class BClass(AClass): def show(self): print (self.foo) #派生类中访问 obj = AClass() obj.foo # 通过对象访问 obj.func() # 类内部访问 obj_son = BClass(); obj_son.show() # 派生类中访问class AClass: def __init__(self): self.__foo = "私有字段" def func(self): print (self.foo) # 类内部访问 class BClass(AClass): def show(self): print (self.foo) #派生类中访问 obj = AClass() obj.__foo # 通过对象访问 ==> 错误 obj.func() # 类内部访问 ==> 正确 obj_son = BClass(); obj_son.show() # 派生类中访问 ==> 错误方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用;---非要访问私有属性的话，可以通过 对象._类__属性名
还有几个类的特殊字段需要清楚的
1. __doc__ 表示类的描述信息
class Foo:
""" 描述类信息，这是用于看片的神奇 """def func(self):
passprint (Foo.__doc__)
#输出：类的描述信息2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么#!/usr/bin/env python # -*- coding:utf-8 -*- class C: def __init__(self): self.name = 'wupeiqi' from lib.aa import C obj = C() print (obj.__module__) # 输出 lib.aa，即：输出模块 print (obj.__class__) # 输出 lib.aa.C，即：输出类3. __init__
# 构造方法，通过类创建对象时，自动触发执行。
class Foo: def __init__(self, name): self.name = name self.age = 18 obj = Foo('wupeiqi') # 自动执行类中的 __init__ 方法
4. __del__
析构方法，当对象在内存中被释放时，自动触发执行。
#注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，
#所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:def __del__(self):
pass5. __call__
# 对象后面加括号，触发执行。
#注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print ('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__6. __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'} obj2 = Province('HeNan', 3888) print (obj2.__dict__) # 获取 对象obj1 的成员 # 输出：{'count': 3888, 'name': 'HeNan'}7. __str__
# 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。class Foo: def __str__(self): return 'wupeiqi' obj = Foo() print (obj) # 输出：wupeiqi8、__getitem__、__setitem__、__delitem__
#用于索引操作，如字典。以上分别表示获取、设置、删除数据#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __getitem__(self, key): print ('__getitem__',key) def __setitem__(self, key, value): print ('__setitem__',key,value) def __delitem__(self, key): print ('__delitem__',key) obj = Foo() result = obj['k1'] # 自动触发执行 __getitem__ obj['k2'] = 'wupeiqi' # 自动触发执行 __setitem__ del obj['k1'] # 自动触发执行 __delitem__9、__getslice__、__setslice__、__delslice__
# 该三个方法用于分片操作，如：列表 #!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __getslice__(self, i, j): print ('__getslice__',i,j) def __setslice__(self, i, j, sequence): print ('__setslice__',i,j) def __delslice__(self, i, j): print ('__delslice__',i,j) obj = Foo() obj[-1:1] # 自动触发执行 __getslice__ obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ del obj[0:2] # 自动触发执行 __delslice__10. __iter__
#用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
#第一步class Foo(object): pass obj = Foo() for i in obj: print (i) # 报错：TypeError: 'Foo' object is not iterable#第二步
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __iter__(self): pass obj = Foo() for i in obj: print (i) # 报错：TypeError: iter() returned non-iterator of type 'NoneType'#第三步
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __init__(self, sq): self.sq = sq def __iter__(self): return iter(self.sq) obj = Foo([11,22,33,44]) for i in obj: print (i)#以上步骤可以看出，for循环迭代的其实是 iter([11,22,33,44]) ，所以执行流程可以变更为：
#!/usr/bin/env python
# -*- coding:utf-8 -*-obj = iter([11,22,33,44])
for i in obj:
print (i)#For循环语法内部
#!/usr/bin/env python
# -*- coding:utf-8 -*-obj = iter([11,22,33,44])
while True:
val = obj.next()
print (val)#11. __new__ 和 __metaclass__
#阅读以下代码：
class Foo(object):def __init__(self):
passobj = Foo() # obj是通过Foo类实例化的对象
#上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
#如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
print (type(obj)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print (type(Foo)) # 输出：<type 'type'> 表示，Foo类对象由 type 类创建
#所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
#那么，创建类就可以有两种方式：#a). 普通方式 class Foo(object): def func(self): print ('hello wupeiqi')#b).特殊方式（type类的构造函数）
def func(self): print ('hello wupeiqi') Foo = type('Foo',(object,), {'func': func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员
# 类 是由 type 类实例化产生
#那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
#答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。class MyType(type): def __init__(self, what, bases=None, dict=None): super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 第一阶段：解释器从上到下执行代码创建Foo类 # 第二阶段：通过Foo类创建obj对象 obj = Foo()
扫一扫
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
