22. 面向对象-初始
一、面向对象书写
class Car:
# self表示当前类对象,当前你创建的是谁,谁来访问这个方法,self就是谁
def __init__(self, color, displacement, number):
self.color = color
self.displacement = displacement
self.number = number
def run(self, speed):
print(f"这辆车可以跑{speed}迈")
#实例化:类名加括号就是实例化,会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
car = Car("red", "1.8T", "京A88888")
car.run(100)
1. __new__(cls, *args, **kwargs)
__new__ 负责对象的创建而 __init__ 负责对象的初始化；至少需要传递一个参数cls，必须要有返回值，返回实例化出来的实例。可以return父类通过super(当前类名，cls).__new__出来的实例，或者直接是object的__new__出来的实例。
2. __init__() - 构造方法
__init__()在__new()的基础上完成初始化动作，不需要返回值；有一个参数self,该self参数就是__new__()返回的实例；
3. 实例
class B():
def __new__(cls, *args, **kwargs):
print("__new__方法被执行")
return super(B, cls).__new__(cls)
def __init__(self):
print("__init__方法被执行")
b = B()
二、继承
1、新式类与经典类
- 新式类：继承了object类以及该类的子类都是新式类；Python3中如果没有继承任何类，则默认继承object类。因此Python3中都是新式类（广度优先遍历）
- 经典类：没有继承object类以及该类的子类，都是经典类；在Python2中如果一个类没有继承任何类，不会继承object类（深度优先遍历）
2、抽象与派生
(1) 抽象：通过抽象可以得到类，抽象是一种分析的过程。比如，猪八戒、小猪佩奇可以抽象出一个类，就是猪类；接着还可以从猪类、狗类抽象出动物类。先分析、抽象之后，就可以通过继承，在程序上实现这个结构。
(2) 派生：就是在子类继承父类的属性的基础上，派生出自己的属性。子类有不同于父类的属性，这个子类叫做派生类。
class Animals:
def __init__(self, name):
self.name = name
def walk(self):
print('我会走')
class Dog(Animals):
# Dog类派生出bite功能
# 派生：狗有咬人的技能
def bite(self):
print('我会咬人')
3、组合
class Mobile():
def __init__(self, color):
self.color = color
def call(self):
print("打电话")
class People():
def __init__(self, name, mobile):
self.name = name
self.mobile = mobile
mobile = Mobile("red")
people = People("Tom", mobile)
people.mobile.call()
4、属性查找顺序
对象自己->所在类中->找父类->父类的父类->Object
5、多继承
class ParentOne:
pass
class ParentTwo:
pass
class SubClass(ParentOne, ParentTwo):
pass
#__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
print(SubClass.__bases__)
>(<class '__main__.ParentOne'>, <class '__main__.ParentTwo'>)
MRO顺序
>F.MRO()
>[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
三、覆盖(overrides)
1、子类访问父类内容
注：当子类出现了和父类名称完全一致的属性或方法
方式一
super.(当前类名称, self).你要调用的父类的属性或方法
方式二
super().你要调用的父类的属性或方法
方式三
类名称.你要调用的父类的属性或方法(self)
注：当你继承一个现有的类,并且你覆盖了父类的init方法时,必须在初始化方法的第一行调用父类的初始化方法,并传入父类所需的参数
练习：实现一个可以现在元素类型的容器(字典、列表、元组、集合、字符串)
class MyList(list):
def __init__(self, element_type):
# 调用父类初始化方法来完成基本的初始化
super().__init__()
self.element_type = element_type
def append(self, object):
"""
:param object: 是要存储的元素
:return: 无
"""
if type(object) == self.element_type:
super(MyList, self).append(object)
else:
print(f"sorry, you element type not is {self.element_type}")
m = MyList(int)
m.append(1)
print(m[0])
m.append("11")
四、封装
1、类成员-属性
1. 实例变量（字段）
2. 类变量（静态变量）
每个实例都应该拥有的变量. 比如.在上述事例中电影的的名字,电影的类型, 电影的语言,电影的时长,都是实例变量而类变量就是这一类事物统一拥有的变量,比如上述事例中可以说这些个电影都可以是3D(规定下),类变量最好是用类名来访问
方式一：
class Movie:
film_format="3D"
def __init__(self,genre,language,name,time):
self.genre=genre
self.language=language
self.name=name
self.time=time
def show(self):
print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")
Movie.film_format="2D" #把类变量中的值改了,都跟着变了.
print(M1.film_format) #2D
print(M2.film_format) #2D
方式二：
class Movie:
film_format="3D"
def __init__(self,genre,language,name,time):
self.genre=genre
self.language=language
self.name=name
self.time=time
def show(self):
print("%s在中国上映" %self.name)
M1 = Movie("剧情","国语","少林足球","2H")
M2 = Movie("喜剧","国语","大话西游","2H")
M1.film_format="2D"
print(M1.film_format) #2D
print(M2.film_format) #3D
2、类成员-方法
（1）成员方法 - 对象直接可以访问的方法
class Computer:
# 成员方法
def play(self):
print("play game!")
computer = Computer()
computer.play()
（2）静态方法
不需要给方法传递self;即当出现一个方法不需要用到成员变量时[@staticmethod]
class Person:
def __init__(self):
pass
# 实例方法需要传递类的对象self
def think(self):
print("人能思考")
@staticmethod
def calculate(a, b):
return a + b
# 类名可以访问
person = Person.calculate(1, 2)
print(person)
> 3
（3）类方法
当方法需要传递类名时,需要类方法[@classmethod]
class Person:
def __init__(self):
pass
# cls表示类
@classmethod
def clsMethod(cls):
# 可以动态创建对象
person = cls()
print("我是一个类方法", person)
# 类方法默认第一个参数接受的是类名
Person.clsMethod()
> 我是一个类方法 <__main__.Person object at 0x00000241E7A17358>
3、类成员-属性
应用场景： 我们⼀般保存数据的时候, 不会保存⼀个⼈的年龄. 因为随着时间的推移. 每个人的年年龄都时刻在改变着. 那如何保存更更加完美呢? 很简单. 保存出生年年月日. 然后用程序来 计算,你当前的年龄实时的那这个时候就需要进行行相应的计算了了. 而计算属于⼀个功能. 当然要写方法里了. 但是对于年年龄这个属性而言. 他应该是一个数值. 而不是动作. 所以python 就提供了这样⼀种机制. 通过方法来描述⼀个属性.
注意：
- 方法参数只能有⼀个self
- 方法上方要写@property
- 调用的时候, 我们不需要写括号. 直接当成属性变量量来用就可
- 这种套路只能取值. 不能设置值
class Person:
def __init__(self, name, num, gender, birthday):
self.name = name
self.num = num
self.gender = gender
self.birthday = birthday
# 表示当前方法是一个属性.方法的返回值就是这个属性的值
@property
def age(self):
# 方法只能有一个参数self;可以是计算结果,必须有返回值
return 10 * 9
person = Person("alex", "10086", "不详", "1989-01-02")
print(person.age)
> 90
4、私有
（1）私有变量
私有的内容不能直接访问,但是如果对方开辟了外界访问的通道(公共方法),那可以通过这个公共的方法来获取到私有的内容,这样做的好处是. 外界只能看, 但是改不了.
class Tiger:
def __init__(self, name,figure, money):
self.name = name
self.figure = figure
self.__money = money
def buy(self):
print(f"我有{self.__money}这么多钱")
tiger = Tiger("永康", "正直", "1亿")
tiger.buy()
> 我有1亿这么多钱
（2）私有方法
class Tiger:
def __init__(self,name,figure,style,qingfu,money,fangchan):
self.name = name
self.figure = figure
self.style = style
self.__qingfu = qingfu
self.__money = money
self.__fangchan=fangchan
def buy(self):
print("我有%s这么多钱" % self.__money) #我有10亿这么多钱
self.__sel()
def __sel(self):
print("我要卖掉%s套房" % self.__fangchan)
T1=Tiger("呵呵","正直","廉洁","潘潘","10亿","10")
T1.buy()
>我有10亿这么多钱
>我要卖掉10套房
五、单例模式
import threading
# 多线程情况下需要加锁,因为它们共享一个内存
class Singleton(object):
_instance = None
_lock = threading.RLock()
# cls是当前正在实例化的类;初始化一块内存
def __new__(cls, *args, **kwargs):
# 如果已创建实例,直接返回即可
if cls._instance:
return cls._instance
# 加锁
with cls._lock:
if not cls._instance:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
