面向对象进阶一（成员（变量、方法、属性），组合或嵌套）
一、类的成员
类的成员共分为三类：变量、方法、属性。下面我们来一一学习。
二、变量
变量分为：
1）实例变量（又称字段）
a）公有实例变量（公有字段）
b）私有实例变量（私有字段）
2）类变量（又称静态字段）
a）公有类变量（公有静态字段）
b）私有类变量（私有静态字段）
分析下面示例，并了解实例变量和类变量：
# ######示例一（类变量和实例变量） class Foo: country = "中国" # 类变量（静态字段） def __init__(self, name): self.name = name # 实例变量（字段） def func(self): pass obj1 = Foo("alex") obj2 = Foo("sylar") print(obj1.name) # alex print(Foo.country) # 或print(obj1.name) 结果为：中国
上述示例一得如下准则：
实例变量（字段）访问时，使用对象访问，即obj1.name
类变量（静态字段）访问时，使用类访问，即Foo.country（实在不方便时，才使用对象访问）
# 易错点--通过类的某个对象改变类变量的值，该类的其他对象不会受影响，通过类改变类变量，该类的所有对象都会跟着改变 obj1.country = "美国" print(obj1.country) # 美国 print(obj2.country) # 中国 Foo.country = "美国" print(obj1.country) # 美国 print(obj2.country) # 美国
问题一：什么时候使用类变量？
当所有对象中有共同的字段，且要改都改，要删都删时，可以将实例变量（字段）提取到类变量（静态变量）。
# ######示例二（私有实例变量（私有字段）） class Foo: def __init__(self,name): # 规则：公有实例变量前加两个下划线（变量成员修饰符）就是私有实例变量 self.__name = name # 私有实例变量(私有字段) self.age = 123 def func(self): print(self.__name) obj = Foo('alex') print(obj.age) # age是公有实例变量 可以访问 结果为：123 # obj.__name # name是私有实例变量 无法直接访问 obj.func() # 找一个内部人:func, 让func帮你执行私有 __name 结果为：alex
# ######示例三（私有类变量（私有静态变量）） class Foo: # 规则：公有类变量前加两个下划线（变量成员修饰符）就是私有类变量 __country = "中国" # 私有类变量（私有静态变量） def func(self): # 内部调用 print(self.__country) print(Foo.__country) # 推荐使用类来使用静态变量 # print(Foo.country) # 报错 外部无法使用私有类变量 obj = Foo() obj.func() # 结果为： # 中国 # 中国
# ######示例四（验证该类的子类也不能访问该类的私有变量） class Base(object): __secret = "受贿" class Foo(Base): def func(self): print(self.__secret) print(Foo.__secret) obj = Foo() obj.func() # 报错 AttributeError: 'Foo' object has no attribute '_Foo__secret'
三、方法
方法分为：
1）实例方法
a）公有实例方法
b）私有实例方法
2）静态方法
a）公有静态方法
b）私有静态方法
3）类方法
a）公有类方法
b）私有类方法
分析下面示例，并了解实例方法、静态方法、类方法：
# ######示例一（实例方法） class Foo(object): def __init__(self, name): self.name = name
# 实例方法 def func(self): print(self.name) # 使用了对象中封装的值 obj = Foo('alex') obj.func()
# ######示例二（静态方法 @staticmethod 参数可有可无） class Foo(object): def __init__(self, name): self.name = name
# 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法 @staticmethod def display(a1,a2): return a1 + a2 print(Foo.display(1,3)) # 4
静态方法总结：
1）定义时：方法上方写@staticmethod、方法参数可有可无；
2）执行时：推荐用 类.方法名()，也可以用对象.方法名()，但是不推荐；
3）什么时候写静态方法：无需调用对象中封装的值时；
# ######示例三（类方法 @classmethod 参数至少有一个cls） class Foo(object):
# 类方法,自动传递cls，cls就是这个类 @classmethod def show(cls, x1, x2): print(cls, x1, x2) # 执行类方法 Foo.show(1, 8) # <class '__main__.Foo'> 1 8
类方法总结：
1）定义时：方法上方写@classmethod、方法至少有一个cls参数；
2）执行时：类名.方法名() 注意：默认会将当前类传到参数中，也可用 对象名.方法名() 但不推荐；
3）什么时候写类方法：如果在方法中会使用到当前类，那么就可以使用类方法；
面试题：静态方法/类方法和实例方法的区别？
定义时：
静态方法/类方法：方法上方分别要加@staticmethod/@classmethod；
实例方法：方法上方不用加东西；
调用时：
静态方法/类方法：通过 类名.方法名() 调用；
实例方法：通过 对象名.方法名() 调用；
应用场景：
静态方法：在方法内部不会用到对象封装的数据时；
类方法：在方法内部不会用到对象封装的数据，且会用到当前类时；
实例方法：在方法内部需要用到对象封装的数据时；
同变量类似，方法也有私有方法，规则分别是在公有方法名前加两个下划线（方法成员修饰符），如下：
# ######示例四（私有实例方法、私有静态方法、私有类方法） class Foo(object): def __init__(self, name): self.name = name def __fun1(self): print("私有实例方法",self.name) @staticmethod def __display(): print('私有静态方法') @classmethod def __func(cls): print(cls, "私有类方法") obj = Foo("alex") # obj.__fun1() # 无法访问 # Foo.__display() # obj.__display() # 类和对象都无法访问 # Foo.__func() # 无法访问
四、属性
属性是通过实例方法改造出来的，属性也分为公有属性和私有属性，看如下有关属性的示例：
# ######示例一 class Foo(object):
@property # 属性 def start(self): return 1 @property # 属性 def end(self): return 10 obj = Foo() print(obj.start) # 调用时不用加括号 结果为：1 print(obj.end) # 调用时不用加括号 结果为：10 # 在公有属性方法名前加两个下划线就是私有属性，不再举例
属性总结：
1）定义时：方法上方写@property、方法参数只有一个self；
2）调用时：无需加括号，直接写 对象.方法 即可；
3）应用场景：对于简单的方法，当无需传参且有返回值时，可以使用@property；
class Pagenation(object): """ 处理分页相关的代码 """ def __init__(self, data_list, page, per_page_num = 10): """ 初始化 :param data_list: 所有的数据 :param page: 当前要查看的页面 :param per_page_num: 每页默认要显示的数据行数 """ self.data_list = data_list self.page = page self.per_page_num = per_page_num @property def start(self): """ 计算索引的起始位置 :return: """ return (self.page-1) * self.per_page_num @property def end(self): """ 计算索引的结束位置 :return: """ return self.page * self.per_page_num def show(self): """ 打印一页的内容 :return: """ result = self.data_list[self.start:self.end] for row in result: print(row) data_list = [] for i in range(1, 901): data_list.append('alex-%s' % i) while True: page = int(input('请输入要查看的页码:')) obj = Pagenation(data_list,page) obj.show()
五、组合或嵌套（建模）
这里的嵌套不是专业的词汇，是我们用大白话解释的。面向对象中的嵌套其实就是对象的相互嵌套，看如下一个对象嵌套的示例：
class School(object): # 定义一个学校类 def __init__(self, name, address): self.name = name self.address = address def speech(self): print('讲课') # 创建三个学校对象 obj1 = School('北京校区', '昌平区') obj2 = School('上海校区', '浦东新区') obj3 = School('深圳校区', '南山区') class Teacher(object): # 定义一个老师类 def __init__(self, name, age, salary): self.name = name self.age = age self.__salary = salary self.school = None # 创建三个老师对象 t1 = Teacher('李杰', 19, 188888) t2 = Teacher('sylar', 18, 60) t3 = Teacher('女神',16, 900000) # 给老师分配校区 t1.school = obj1 # t1对象的school变量是一个obj1对象 t2.school = obj1 t3.school = obj2 # 查看t1老师,所在的校区名称/地址 print(t1.school.name) print(t1.school.address) print(t1.name) print(t1.age) t1.school.speech()
