面向对象进阶篇
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中）
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
类的成员
类的成员可以分为三大类：字段、方法和属性
注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。
一、字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
- 普通字段属于对象
- 静态字段属于类
class Proice:
#静态字段
country = "中国"
def __init__(self,name):
#普通字段
self.name = name
ret = Proice("山西")
print(ret.name) #直接访问普通字段
print(ret.country) #直接访问静态字段应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
二、方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数；
class Paric:
def func(self):
#普通方法
print("name")
@classmethod
#类方法 最少有一个参数
def xxoo(cls,arg1,arg2):
print(arg1,arg2)
#静态方法 可也加参数也可以不加参数
@staticmethod
def xo():
print("xo")
ret = Paric() #创建对象
ret.func() #对象调用普通方法
Paric.xxoo(1,2) #类调用类方法
Paric.xo() #类调用静态方法三、属性
如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
对于属性，有以下三个知识点：
- 属性的基本使用
- 属性的两种定义方式
- 调用时，无需括号
class Foo:
def __init__(self,name):
self.name = name
#获取
@property
def func(self):
temp = self.name
return temp
#设置
@func.setter
def func(self,value):
self.name = value
#调用
@func.deleter
def func(self):
del self.name
ret = Foo("Wyc")
r = ret.func #获取
print(r)
del ret.func #删除
ret.func = "nihao" #设置
静态字段方式，创建值为country对象的静态字段
class Foo:
#静态字段
country ="中国"
def func(self):
print("11")
#类调用静态方法
print(Foo.country) 类成员的修饰符
类的所有成员在上一步骤中已经做了详细的介绍，对于每一个类的成员而言都有两种形式：
- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能使用方法
私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
class Foo:
#私有字段
__yer = "Wyc"
def func(self):
#用类调用私有字段，只能在内部调用。
print(Foo.__yer)
ret = Foo()
ret.func()class Foo:
#公有静态字段
name = "中国"
def func(self):
pass
#公有静态字段由类调用
print(Foo.name)类的特殊成员
__doc__
表示类的描述信息
class Foo:
"""
这是__doc__的方法
"""
def func(self):
pass
#由类直接调用，类的注释
print(Foo.__doc__)class Foo:
#构造方法，简称封装
def __init__(self):
self.name = "wyc"
def func(self):
print(self.name)
ret = Foo()
ret.func()__call__
对象后面加括号，触发执行。
class Foo:
def func(self):
pass
def __call__(self, *args, **kwargs):
print("123")
ret = Foo()
ret() #对象后边加括号自动触发__call__方法__dict__
类或对象中的所有成员
class Foo:
def func(self):
pass
ret = Foo.__dict__ #查看类或对象中的所有成员
print(ret)__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo:
#默认输出该↓方法的默认值
def __str__(self):
return "Wyc"
ret = Foo()
print(ret)__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo:
def __setitem__(self,key,value):
print(key,value)
r = Foo()
r["xxx"] = 123
#对象后边加中括号就会执行__setitem__方法，一个key，一个valueclass Foo:
def __delitem__(self,key):
print(key)
r = Foo()
del r["xxx"] #执行__delitem__方法，删除keyclass Foo:
def __getitem__(self, item):
print(item)
r = Foo()
r["123456"]
#对象后边加个中括号就会自动执行__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter_
class Foo(object):
def __init__(self,sq):
self.sq = sq
def __iter__(self):
return iter(self.sq)
obj = Foo([11,22,33,44,55])
for i in obj:
print(i)总结：
成员：
字段 静态字段（每个对象都有一份），普通字段（每个对象都有不同的数据）
方法 静态方法（无需使用对象封装的内容），类方法，普通方法（使用对象中的数据）
特性 普通特性（将方法伪造成字段）
如何快速判断，类执行，或者对象执行：
有self的对象调用
无self的，类调用