一、昨日内容回顾
1、面向对象与面向过程
面向过程：以我为中心。按照事物发展的流程顺序来写代码
优点：代码量少，简单
缺点：扩展性差
面向对象：以对象为中心，所有的东西都是独享。操纵的是对象，让独享去完成相应的操作
2、对象是通过类来创建的
类是属性和方法的结合体，归类某一个事物，我们写的每一个类都是一个数据类型
class 类(父类)：
def __init__(self) : 构造方法。在创建对象的时候自动调用
pass
def 方法(self):
pass
a = 类() # 这里调用的是__init__()
# 访问对象 a 的属性
a.属性
# 方法
a.方法()
self: 类的对象
总结：
大项目用面向对象；小脚本用面向过程
3、面向对象的三大特性
封装：
1、对属性的封装
2、对方法的封装
继承：
子类可以自动拥有父类中除了私有内容外的所有内容
多态：
同一个对象拥有多种形态。鸭子模型
二、类的成员
首先，什么是类的成员？在类中书写什么？写的内容就是成员。
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 , "1980")
print(p1.name) # alex
print(p1.country) # 中国
p2 = Person("wusir", 28 , "1982")
print(p2.name) # wusir
print(p2.country) # 中国
我们发现p1 和 p2 的name都是对象自己的。但是country是类的，大家共有一个变量
Person.country = "华夏" # 在这里我们把国家改成了 华夏
p1 = Person("alex", 18 ,"1980")
print(p1.name)
print(p1.country) # alex 是华夏的
p2 = Person("wusir" , 28 , "1982")
print(p2.name)
print(p2.country) # wusir 也是华夏的
从上我们可以发现类变量中的值改变了。所有对象中的该属性也跟着改变(前提是对象属性中无该属性)
通过图我们能发现，实例变量中都隐含着一个创建这个对象的类。通过类就能找到我们类中定义的全部
内容，包括方法和属性信息等
接下来，我们来看一个和类变量嘻嘻相关的坑
p1 = Person("alex", 18 , "1980")
p1.country = "华夏"
print(p1.name)
print(p1.country) # 华夏
p2 = Person("wusir", 28 , "1982")
print(p2.name)
print(p2.country) # 中国
上面是 华夏，下面是中国？ p1.country = "华夏"的时候，气死并没有去改变类中的country，
而是给独享添加了一个实例变量。并且这个实例变量，只有在当前的p1是存在的。在p2中是不存在的。
在图中，我们能清晰的看到，p1.country = "华夏" 并没有改变类变量，只是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、类方法
1、成员方法 -- 对象直接访问的方法叫做成员方法
class Computer:
# 成员方法(实例方法)
def play(self):
print("我的电脑可以玩")
c = Computer()
c.play() # 对象直接去调用成员方法(实例方法)
2、静态方法。静态方法不需要我们给方法传递 self。也就是说，当出现一个方法不需要使用到成员变量的
时候，就可以选择使用静态方法。静态方法需要我们在方法上面添加一个装饰器 @staticmethod
@staticmethod
def fare():
print("我的电脑非常牛逼，可以煎鸡蛋")
静态方法和静态变量一样，一般都是使用类名直接访问和调用的
Computer.fare() # 类名可以直接访问的
c.fare() # 对象也可以直接访问，但最好不要这么干，以便区分静态方法和实例方法
3、类方法
类方法，类方法和静态方法差不多，只不过类方法需要在参数列表中的第一个位置预留一个位置，通常
我们给第一个参数起名字叫 cls，类方法在被调用的时候也不需要传递实例对象。但是，系统会自动把类
传递给第一个参数。类方法在编写的时候，需要在类方法上面添加 @classmethod
class Computer:
def play(self):
print("我的电脑可以玩")
@staticmethod
def fare():
print("我的电脑非常牛逼，可以煎鸡蛋")
@classmethod
def cal(cls, a, b):
print(cls)
return a+b
print(Computer.cal(1,2)) # 此时会自动芭蕾名传递给类方法的第一个参数
4、思考 类方法/静态方法和实例方法有什么区别？
实例方法：
定义：第一个参数必须是实例对象，该参名一般约定为"self",通过它来传递实例的属性和方法(也可传
类的属性和方法);
调用：
只能由实例对象调用
类方法：
定义：使用装饰器 @classmethod。第一个参数必须是当前类的对象，该参数名一般约定为"cls",通过
它来传递类的属性和方法(不能传实例的属性和方法)；
调用： 实例对象和类对象都可以调用
静态方法
定义: 使用装饰器@staticmethod，参数随意，没有"self"和"cls"参数，方法中不能使用类和实例的
任何属性和方法；
调用：实例对象和类对象都可以调用
五、 类的成员-属性
属性其实就是通过方法改造过来的一种变量的写法，在方法上添加一个 @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中，使用 __ 作为方法或者变量的前缀。name这个方法或者变量就是私有的
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是一个成员方法，并且是一个开放的方法，在类外界可以被访问到
注意：私有的内容子类是无法继承的