类的成员

本节主要内容:
1. 类的成员
2. 类的成员-变量
3. 类的成员-⽅法
4. 类的成员-属性
5. 私有

⼀. 类的成员:
⾸先, 什么是类的成员. 很简单. 你能在类中写什么? 写的内容就是成员. 到⽬前为⽌. 我们
已经学过了⼀些成员了.

class 类名:
     # ⽅法
     def __init__(self, 参数1, 参数2....):
         # 属性变量
         self.属性1 = 参数1
         self.属性2 = 参数2
         ....
     # ⽅法
     def method(self):
         pass

　　在上⾯代码中__init__和method都属于类的成员⽅法. ⼜称为实例⽅法. 总之这样的东⻄
需要⽤对象来访问. ⽽上⽅的self.属性1 = 参数1 这个代码的含义是给对象设置属性信息. 含
义是这个对象的xxx属性是xxxx. 这种东⻄⼜被称之为成员变量或者实例变量, 再或者被称之
为字段. 都是⼀个意思.

也就是说在类中, 是存在着实例变量和实例⽅法的. 还有哪些呢? ⼀个⼀个的看. 

⼆. 类的成员-变量
　　在类中变量分成两⼤类:
　　1. 实例变量(字段)
　　2. 类变量(静态变量)

　　先说什么是实例变量. 说⽩了. 就是每个实例都应该拥有的变量. 比如. ⼈的名字, ⼈的爱好,
每个⼈的个⼈信息. 都属于实例变量. 那什么是类变量. 就是这⼀类事物统⼀拥有的变量. 比
如. 在座的各位都是中国⼈. 那⼤家都拥有同⼀个国家. 例:

class Person:
     # 类变量, 表示所有的该类的对象都共享这个变量.
     country = "中国"
 
     def __init__(self, name, num, birthday):
         # 实例变量(字段) 表示你创建的每⼀个⼈都有这三个变量
         self.name = name
         self.num = num
         self.birthday = birthday
p1 = Person("alex", 18, "1840年06⽉01⽇")
print(p1.name) # alex
print(p1.country) #中国
p2 = Person("wusir", 28, "1894年07⽉25⽇")
print(p2.name) # wusir
print(p2.country) # 中国

我们发现对象p1和p2的name都是对象⾃⼰的. 但是country是类的. ⼤家公⽤同⼀个变量.
如何来验证呢?

Person.country = "⼤清" # 在这⾥. 我把国家改成了⼤清
p1 = Person("alex", 18, "1840年06⽉01⽇")
print(p1.name)
print(p1.country) # alex是⼤清的
p2 = Person("wusir", 28, "1894年07⽉25⽇")
print(p2.name)
print(p2.country) # wusir也是⼤清的

　　发现了吧. 我把类变量中的值改了. ⼤家看到的都跟着变了. 为什么呢? 我们要从内存来分
析. 看图.

　　通过图我们能发现, 实例变量中都隐含着⼀个创建这个对象的类. 通过这个类就能找到我
们类中定义的全部内容, 包括⽅法和属性信息等.

接下来让我们看一个坑，和类变量息息相关的坑！！！

p1 = Person("alex", 18, "1840年06⽉01⽇")
p1.country = "⼤清"
print(p1.name)
print(p1.country) # ⼤清
p2 = Person("wusir", 28, "1894年07⽉25⽇")
print(p2.name)
print(p2.country) # 中国

　　上⾯是⼤清. 下⾯是中国. 为什么会这样呢? 注意. 在执⾏p1.country = "⼤清"的时候. 其实
并没有去改变类中的country, ⽽是给对象添加了⼀个实例变量. 并且这个实例变量,只有当前
的p1是存在的. 在p2中是不存在的. 依然画个图来看.

　　在图中我们能清晰的看到. 我们其实并没有改变类变量. 只是在p1中添加了⼀个实例变量,
仅此⽽已. 通过这⾥. 我们应该能发现. 类变量, 最好是⽤类名来访问. 当然, 我们通过对象名
也可以访问. 但只能看, 不能改变它. 想要改变它, 需要⽤类名来改变它。

　　案例. 通过程序来记录当前类被创建了多少个对象. 

class Foo:
     count = 0
     def __init__(self):
         Foo.count += 1
print(Foo.count) # 0
Foo()
Foo()
Foo()
print(Foo.count) # 3

好了. 来做个简单的总结:
实例变量, 给对象⽤的.
类变量, 多个对象共享的. 最好是⽤类名来访问. 这样更加规范

三. 类的成员-⽅法
　　1. 成员⽅法(实例⽅法)
　　2. 静态⽅法
　　3. 类⽅法

先说第⼀个成员⽅法. 我们⽤的最多的就是这种. 昨天写的代码中, 所有的⽅法都可以被称
之为成员⽅法. 说⽩了就是对象直接访问的⽅法叫成员⽅法.

class Computer:
 
     # 实例⽅法(成员⽅法)
     def play(self):
         print("我的电脑可以玩⼉")
c = Computer()
c.play() # 对象直接去调⽤实例⽅法

　　静态⽅法. 静态⽅法不需要我们给⽅法传递self. 也就是说. 当出现⼀个⽅法不需要使⽤到
成员变量的时候. 就可以选择使⽤静态⽅法. 静态⽅法需要我们在⽅法上⾯添加⼀
个@staticmethod

@staticmethod
def fare():
     print("我的电脑⾮常⽜B, 可以煎鸡蛋")

　　静态⽅法和静态变量⼀样. ⼀般都是使⽤类名直接访问和调⽤的. 

Computer.fare() # 类名可以直接访问的
c.fare() # 对象也可以访问. 但最好不要这么⼲. 以便于区分静态⽅法和实例⽅法

　　类⽅法. 类⽅法和静态⽅法差不多, 只不过类⽅法需要在参数列表中的第⼀个位置预留⼀
个位置, 通常我们给第⼀个参数起名字叫cls. 类⽅法在被调⽤的时候也不需要传递实例对象.
但是. 系统会⾃动的把类传递给第⼀个参数. 类⽅法在编写的时候, 需要在类⽅法上⾯添
加@classmethod

class Computer:
     def play(self):
         print("我的电脑可以玩⼉")
     @staticmethod
     def fare():
         print("我的电脑⾮常⽜B, 可以煎鸡蛋")
     @classmethod
     def cal(cls, a, b):
         print(cls)
         return a+b
print(Computer.cal(1, 2)) # 此时会⾃动的

　　⾯试题: 类⽅法/静态⽅法和实例⽅法有什么区别?

四. 类的成员-属性
属性其实就是通过⽅法改造过来的⼀种变量的写法, 在⽅法上添加⼀个@property就可以
了

class Person:
     def __init__(self):
         pass
     @property
     def age(self):
         return 1
 
p = Person()
age = p.age
print(age)

　　

　　应⽤场景: 我们⼀般保存数据的时候, 不会保存⼀个⼈的年龄. 因为随着时间的推移. 每个
⼈的年龄都时刻在改变着. 那如何保存更加完美呢? 很简单. 保存出⽣年⽉⽇. 然后⽤程序来
计算,你当前的年龄. 实时的. 那这个时候就需要进⾏相应的计算了. ⽽计算属于⼀个功能. 当
然要写⽅法⾥了. 但是对于年龄这个属性⽽⾔. 他应该是⼀个数值. ⽽不是动作. 所以python
就提供了这样⼀种机制. 通过⽅法来描述⼀个属性. 

注意:
1. ⽅法参数只能有⼀个self
2. ⽅法上⽅要写@property
3. 调⽤的时候, 我们不需要写括号. 直接当成属性变量来⽤就可以了.
4. 这种套路只能取值. 不能设置值

五. 私有
　　在python中, ⼀般是不提倡设置和使⽤私有信息的. 但有些场景, 我们不得不这么做. 比如,
在⼀个公司. 每个⼈的收入情况, 这种内容是绝对不能公开的. 还有, 你的老婆, 也是⼀个私有
的. 只能你⼀个⼈使⽤. 别⼈不能碰. 碰了就炸锅了.
在python中使⽤__作为⽅法或者变量的前缀. 那么这个⽅法或者变量就是⼀个私有的.

1. 私有变量

class Person:
     def __init__(self, laopo, mimi):
         self.__laopo = laopo # 私有的
         self.__mimi = mimi
alex = Person("wusir", "他俩搞基")
print(alex.__mimi) # 私有的. 谁都不能碰
 

　　程序报错. 私有的内容是访问不到的. 但是, 这个访问不到是有⼀定的局限性的. 比如: 

class Person:
     def __init__(self, laopo, mimi):
         self.__laopo = laopo # 私有的
         self.__mimi = mimi
     def gaosuni(self):
         print("⼤喇叭开始⼴播了")
         return self.__mimi # 私有的内容.在他⾃⼰那⾥, 他可以任意的进⾏使⽤
 
alex = Person("wusir", "他俩搞基")
mimi = alex.gaosuni() # 通过⼀个⾮私有的⽅法, 访问到了他的秘密. 
print(mimi)

　　

记住, 私有的内容不能直接访问. 但是如果对⽅开辟了外界访问的通道(公共⽅法). 那可以
通过这个公共的⽅法来获取到私有的内容. 这样做的好处是. 外界, 只能看, 但是改不了.
不单单实例变量有私有的. 类变量(静态变量)⼀样拥有这样的属性:

class Person:
     __zisi = "⼈都是⾃私的" # ⼈都是⾃私的. 但是这个⾃私⼜不希望别⼈知道
     def __init__(self, laopo, mimi):
         self.__laopo = laopo # 私有的
         self.__mimi = mimi
     def gaosuni(self):
         print("⼤喇叭开始⼴播了")
         return self.__mimi
alex = Person("wusir", "他俩搞基")
mimi = alex.gaosuni()
print(mimi)
print(Person.__zisi) # 报错

　　2. 私有⽅法

　　私有⽅法, 顾名思义, 只能⾃⼰访问的⽅法. 别⼈都不能随便调⽤的. 这个更好理解. 你和你
女朋友约会. 你希望别⼈来调⽤么? 肯定不啊.

class Person:
     def __init__(self):
         pass
    def __yue(self):
         print("我要约会")
     def job(self):
         print("我要⼯作")
p = Person()
# p.__yue() # 报错
p.job()

__yue是⼀个私有的⽅法. 只能在类中⾃⼰调⽤. 类外⾯不能访问.
job是⼀个成员⽅法. 并且是⼀个开放的⽅法. 在类外界可以被访问到
同样的. 类中的私有⽅法也是相对⽽⾔的. 我们可以通过其他⽅法来访问到这样的⽅法.

class Person:
     def __init__(self):
         pass
     def __yue(self):
         print("我要约会")
 def job(self):
     print("我要⼯作")
     self.__yue() # 在⾃⼰类中访问⾃⼰的其他⽅法. 哪怕是私有的. 也是⾃⼰在⽤
p = Person()
p.job()

关于类⽅法和静态⽅法, 和成员⽅法⼀样, 就不再赘述了
需要注意的是, 对于私有的内容⽽⾔. ⼦类是⽆法继承的.

class Fu:
     __qingfu = "情妇_⼩潘潘"
class Zi(Fu):
     pass
print(Zi.__qingfu) # 报错