# 成员
# 本节主要内容：
# 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中是不存在的. 依然画个图来看.
# 好了. 来做个简单的总结:
# 实例变量, 给对象⽤的.
# 类变量, 多个对象共享的. 最好是⽤类名来访问. 这样更加规范.
# 二、类的成员—方法
# 1. 成员⽅法(实例⽅法)
# 2. 静态⽅法
# 3. 类⽅法
# 先说第⼀个成员⽅法. 我们⽤的最多的就是这种. 昨天写的代码中, 所有的⽅法都可以被称
# 之为成员⽅法. 说⽩了就是对象直接访问的⽅法叫成员⽅法.
# class Computer:
# # 实例方法(成员方法)
# def play(self):
# print("我可以电脑打游戏")
# c = Computer()
# c.play() # 对象直接去调用的实例方法
# 静态方法：
# 静态⽅法不需要我们给⽅法传递self. 也就是说. 当出现⼀个⽅法不需要使⽤到
# 成员变量的时候. 就可以选择使⽤静态⽅法. 静态⽅法需要我们在⽅法上⾯添加⼀
# 个@staticmethod
# class Computer:
# def play(self):
# print("我可以电脑打游戏")
# @staticmethod
# def game():
# print("我喜欢玩lol")
# # 静态⽅法和静态变量⼀样. ⼀般都是使⽤类名直接访问和调⽤的.
# c = Computer()
# Computer.game() # 我喜欢玩lol
# c.game() # 我喜欢玩lol 对象也可以访问. 但最好不要这么⼲. 显的很low 以便于区分静态⽅法和实例⽅法
# 类⽅法. 类⽅法和静态⽅法差不多, 只不过类⽅法需要在参数列表中的第⼀个位置预留⼀
# 个位置, 通常我们给第⼀个参数起名字叫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)) # 此时会⾃动的把类名传递给类⽅法的第⼀个参数
# ⾯试题: 类⽅法/静态⽅法和实例⽅法有什么区别?
# 实例方法只能被实例对象调用，静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。
# 实例方法，第一个参数必须要默认传实例对象，一般习惯用self。
# 静态方法，参数没有要求。
# 类方法，第一个参数必须要默认传类，一般习惯用cls。
# 1，实例能直接访问，实例方法，类方法，静态方法，类变量，实例变量
# 2， 类能直接访问，类方法（只能访问类变量），静态方法（在类的作用域下，又貌似跟类没什么关联，不能访问类中任何变量）
# class Hero:
# run = "800码"
# def __init__(self, name, skill, gender, hobby):
# self.name = name
# self.skill = skill
# self.gender = gender
# self.hobby = hobby
# def da(self): # 实例方法只能由实例对象调用 能访问类变量、实例变量 （自身属性变量）
# print("%s大你" %self.name)
# # print(run) # 不能直接访问，需调用类.run去访问
# print(self.name)
# print(Hero.run)
# print(gailun.run)
# @classmethod # 类变量 只能访问类变量
# def chi(cls):
# print(run) # 不能直接访问，需调用类.run去访问
# print(Hero.run)
# # print(self.name) # 类变量不能访问实例变量 （自身属性变量）
# @staticmethod # 静态变量
# def he():
# print(Hero.run)
# # print(self.name) # 静态变量不能访问实例变量 （自身属性变量）
# gailun = Hero("盖伦", "旋风斩", "男", "蹲草丛")
# gailun.da()
# # 结果
# # 盖伦大你
# # 盖伦
# # 800码
# # 800码
# # 实例变量能访问类变量、自身属性
# gailun.chi() # 800码
# gailun.he() # 800码
# 三. 类的成员-属性
# 属性其实就是通过⽅法改造过来的⼀种变量的写法, 在⽅法上添加⼀个@property就可以了
# class Person:
# def __init__(self):
# pass
# @property # 将方法改造为变量
# def age(self):
# return 1
#
# p = Person()
# age = p.age # 这是实例变量的访问方法
# print(age)
# class Person:
# def __init__(self, name, birthday, tel, gender):
# self.name = name
# self.birthday = birthday
# self.tel = tel
# self.gender = gender
# @property
# def age(self):
# return 2019 - self.birthday
# dd = Person("思聪",1993,"12355689","男")
# print(dd.age) # def age()方法直接变成实例变量
# 应⽤场景: 我们⼀般保存数据的时候, 不会保存⼀个⼈的年龄. 因为随着时间的推移. 每个
# ⼈的年龄都时刻在改变着. 那如何保存更加完美呢? 很简单. 保存出⽣年⽉⽇. 然后⽤程序来
# 计算,你当前的年龄. 实时的. 那这个时候就需要进⾏相应的计算了. ⽽计算属于⼀个功能. 当
# 然要写⽅法⾥了. 但是对于年龄这个属性⽽⾔. 他应该是⼀个数值. ⽽不是动作. 所以python
# 就提供了这样⼀种机制. 通过⽅法来描述⼀个属性.
# 注意:
# 1. ⽅法参数只能有⼀个self
# 2. ⽅法上⽅要写@property
# 3. 调⽤的时候, 我们不需要写括号. 直接当成属性变量来⽤就可以了.
# 4. 这种套路只能取值. 不能设置值
# 四. 私有
# 在python中, ⼀般是不提倡设置和使⽤私有信息的. 但有些场景, 我们不得不这么做. 比如,
# 在⼀个公司. 每个⼈的收入情况, 这种内容是绝对不能公开的. 还有, 你的老婆, 也是⼀个私有
# 的. 只能你⼀个⼈使⽤. 别⼈不能碰. 碰了就炸锅了.
# 在python中使⽤__作为⽅法或者变量的前缀. 那么这个⽅法或者变量就是⼀个私有的.
# 私有变量
# 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 sy(self):
# print(self.__laopo)
# alex = Person("wusir", "他俩搞基")
# alex.sy() # wusir
# 记住, 私有的内容不能直接访问. 但是如果对⽅开辟了外界访问的通道(公共⽅法). 那可以
# 通过这个公共的⽅法来获取到私有的内容. 这样做的好处是. 外界, 只能看, 但是改不了.
# 不单单实例变量有私有的. 类变量(静态变量)⼀样拥有这样的属性:
# 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) # 报错
# 私有方法
# 私有⽅法, 顾名思义, 只能⾃⼰访问的⽅法. 别⼈都不能随便调⽤的. 这个更好理解. 你和你
# 女朋友约会. 你希望别⼈来调⽤么? 肯定不啊.
# 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) # 报错
# 补充Python之面向对象：属性
# 一、属性定义：1、类属性、实例属性、局部变量、@porperty 属性装饰器