python基础06面向对象、设计模式

1 面向对象的编程基础

面向对象的思考方式：先从问题中找名词（面向过程更多的是找动词），然后确认这些名词哪些可以作为类，再根据问题需求确定类的属性和方法，确定类之间的关系

1.1 类

在python中一切皆对象，类也是对象，只不过他是可以生成对象的对象。

class 类名
	类体

注意点：
1 类名一般首字母大写，多个单词使用驼峰原则
2 类体中我们可以定义属性和方法
3 属性用来描述数据，方法即函数来描述这些数据相关的操作

class Student:
    def __init__(self,name,age):
        self.name = name #实例属性
        self.age = age
    def print_score(self): #实例方法
        print('{}的年龄是{}'.format(self.name,self.age))
        
xiaoming = Student('小明',17) #创建实例对象
xiaoming.print_score()

1.2 __init__构造方法

用来初始化实例对象，即对象创建后，初始化当前对象的相关属性，无返回值。
要点如下：
1 名称固定，必须为__init__
2 第二个参数固定，必须为self。self指的是刚刚创建好的实例对象
3 构造函数通常用来初始化示例对象的实例属性
4 通过类名(参数列表)来调用构造函数。调用后，将创建好的对象返回给相应的变量
5. init()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
6. new()方法: 用于创建对象，但我们一般无需重定义该方法。
7. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参的__init__方法，系统不创建默认的__init__方法。

1.3 实例属性和实例方法

1 实例属性
实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

1. 实例属性一般在__init__()方法中通过如下代码定义：
   self.实例属性名 = 初始值
2. 在本类的其他实例方法中，也是通过 self 进行访问：
   self.实例属性名
3. 创建实例对象后，通过实例对象访问：
   obj01 = 类名() #创建对象，调用__init__()初始化属性
   obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属
   
   从图中可以看出虽然s1增加了age和salary实例属性，但是s2创建后没有age和salary实例属性，因为s2引用对象的地址和s1不同，你对s1进行的修改不会影响s2

2 实例方法
实例方法是从属于实例对象的方法

def 方法名(self [,形参列表]):
	函数体
方法的调用格式如下：
	对象.方法名([实参列表])

要点：
1. 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
2. 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参

函数和方法的区别
1. 都是用来完成一个功能的语句块，本质一样。
2. 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。
3. 直观上看，方法定义时需要传递 self，函数不需要

其它操作：
1. dir(obj)可以获得对象的所有属性、方法
2. obj.dict 对象的属性字典
3. pass 空语句，没想好怎么写代码先用pass占一下位子，后期再补上
4. isinstance（对象,类型） 判断“对象”是不是“指定类型”，是不是这个类的实例对象

1.4 类对象

类也是对象，属于type类

class Student:
	pass #空语句
print(type(Student)) #<class 'type'>
print(id(Student)) # 51686328
Stu2 = Student
s1 = Stu2()
print(s1) #<__main__.Student object at 0x0000000002B5FDD8>

1.4.1 类属性

类属性从属于类对象，可以被所有实例对象共享

class 类名:
	类变量名 = 初始值

在类中或者类的外面，我们可以通过：’'类名.变量名’来读写。

class Student:
	company = "SXT" #类属性
	count = 0 #类属性
	def __init__(self,name,score):
		self.name = name #实例属性
		self.score = score
		Student.count = Student.count+1
	def say_score(self): #实例方法
		print("我的公司是：",Student.company)
		print(self.name,'的分数是：',self.score)
s1 = Student('高淇',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()
print('一共创建{0}个 Student 对象'.format(Student.count))

1.4.2 类方法

类方法是从属于’‘类对象’'的方法，类方法通过装饰器@classmethod来定义，格式如下：

@classmethod
def 类方法名(cls [,形参列表])：
	函数体

要点如下：

1. @classmethod 必须位于方法上面一行
2. 第一个 cls 必须有；cls 指的就是“类对象”本身；
3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传
   值。
4. 类方法中访问实例属性和实例方法会导致错误，’‘有了膜具不一定有了饼干’’
5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象
   

1.4.3 静态方法

义与“类对象”无关的方法，称为“静态方法”
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空
间里面”，需要通过“类调用”。

@staticmethod
def 静态方法名([形参列表]) ：
	函数体

要点如下：
1. @staticmethod 必须位于方法上面一行
2. 调用静态方法格式：“类名.静态方法名(参数列表)”。
3. 静态方法中访问实例属性和实例方法会导致错误

1.5 __del__方法(析构函数)和垃圾回收机制

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源，例如：打开的文件资源、网络连接等。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。
我们也可以通过 del 语句删除对象，从而保证调用__del__方法。
系统会自动提供__del__方法，一般不需要自定义析构方法。

class Person:
	def __del__(self):
	print("销毁对象：{0}".format(self))
p1 = Person()
p2 = Person()
del p2
print("程序结束")

1.6 __call__方法和可调用对象

定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用，即对象名()

class SalaryAccount: 
	'''工资计算类''' 
	def __call__(self, salary):
		yearSalary = salary*12
		daySalary = salary//30
		hourSalary = daySalary//8
		return dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)
s = SalaryAccount()
print(s(5000)) #可以像调用函数一样调用对象的__call__方法

1.7 方法没有重载

Python 中没有方法的重载。定义多个同名方法，只有最后一个有效

1.8 方法的动态性

Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法

class Person:
    def work(self):
        print("努力上班！")
        
def play_game(self):
    print("{0}玩游戏".format(self))
def work2(s):
    print("好好工作，努力上班！")

p = Person()
# 新增方法
Person.play = play_game
# 修改方法
Person.work = work2
p.work()

1.9 私有属性和私有方法

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有
属性和私有方法，有如下要点：

1. 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)

class Emp:
	__company = 'xx' #私有类属性
	def __init__(self,name,age):
		self.name = name
		self.__age = age #私有实例属性
	def say_company(self):
		print('我的公司是：',Emp.__company) #类内部可以访问私有属性
		print('我的名字是：',self.name)
		self.work()
	def work(self):
		print('work')
p1 = Emp('gao',32)
print(p1.name)
print(dir(p1))
p1.say_company()
print(p1._Employee__age) #通过这种方法可以直接访问私有属性

1.10 @property装饰器

@property可以将一个方法的调用方式变成属性调用。

class Employee:
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary
    @property #相当于 salary 属性的 getter 方法
    def salary(self):
        print("月薪为{0},年薪为{1}".format(self.__salary,(12*self.__salary)))
        return self.__salary;
    @salary.setter
    def salary(self,salary): #相当于 salary 属性的 setter 方法
        if(0<salary<1000000):
            self.__salary = salary
        else:
            print("薪水录入错误！只能在 0-1000000 之间")

emp1 = Employee("高淇",-100)
emp1.salary #按照属性调用

1.11 set和get方法

class Salary:
	def __init__(self,salary):
		self.__salary = salary
	def get_salary(self):
		return self.__salary
	def set_salary(self,salary):
		if 0<salary<100000:
			self.__salary = salary
		else:
			print('请重新输入')
em = Salary(2000)
em.set_salry(-2000) # 请重新输入

2 面向对象进阶

面向对象编程三大特性：继承、封装和多态

• 封装：
  隐藏对象的属性和实现细节，只对外提供必要的方法。可通过私有属性和私有方法实现
• 继承：
  让子类具有父类的特性，提高代码的重用性
• 多态：
  同一个方法调用会由于不同对象产生不同行为。比如同样是休息方法，你是睡觉，我是打游戏

2.1 继承

子类继承了父类除构造方法之外的所有成员
语法：

class 子类类名(父类1[,父类2,...]):
	类体

如果类定义中没有指定父类，则默认父类是object类，即object类是所有类的父类，里面定义了一些所有类共有的默认实现，比如：new()
定义子类时，必须在其构造方法中调用父类的构造函数，格式为父类名.int(self,参数列表)

class Person:
	def __init__(self,name,age):
		self.name = name
		self.__age = age
	def say_age(self):
		print(self.name,'的年龄是：',self.__age)

class Student(Person): #继承Person
	def __init__(self,name,age,score)
		self.score =]=[]
		score
		Person.__init__(self,name,age) #显式调用父类的构造函数

s1 = Student('张三',15,85)
s1.say_age()
print(dir(s1))

1 方法重写

子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

class Father():
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def say_name(self):
		print('我是',self.name)
class Student(Person):
	def say_name(self):
		print('老师你好！') #不改变父类的say_name方法

运算符重载

运算符也是对象，也是调用对象的特殊方法实现的：

我们也可以重写上面的特殊方法，实现运算符的重载

class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        if isinstance(other,Person):
            return "{0}--{1}".format(self.name,other.name)
        else:
            return "不是同类对象，不能相加"
    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            return "不是同类对象，不能相乘"

2 object类

查看类的继承层次结构：通过mro()或者类属性__mro__

class A
class B(A)
class C(B)
print(C.mro())

object根类
它是所有类的父类，因此所有的类都有object类的属性和方法
通过dir()查看对象属性

class Person:
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def say_age(self):
		print(...)
obj = object()
print(dir(obj))
p = Person('xx',18)
print(dir(p))

从上面我们可以发现这样几个要点：

1. Person 对象增加了六个属性：
   __dict__ __module__ __weakref__ age name say_age
2. object 的所有属性，Person 类作为 object 的子类，显然包含了所有的属性。
3. 我们打印 age、name、say_age，发现 say_age 虽然是方法，实际上也是属性。只不过，这个属性的类型是“method”而已。
   age <class ‘int’>
   name <class ‘str’>
   say_age <class ‘method’>

3 重写__str__方法

用于返回一个对于“对象的描述”，对应于内置函数 str()
经常用于 print()方法，帮助我们查看对象的信息。__str__()可以重写

class Person:
	def __init__(self,name,age):
		self.name = name
		self.__age = age
	def __str__(self): 
	'''将对象转化成一个字符串，一般用于 print 方法''' 
		return "名字是：{0},年龄是{1}".format(self.name,self.__age)

4 多重继承

一个类可以同时有多个直接父类，由于这样会让类的整体结构搞的异常复杂，尽量避免使用多重继承

class A:
	def aa(self):
		print("aa")
	def say(self):
		print('aa')
class B:
	def bb(self):
		print("bb")
	def say(self):
		print('bb')
class C(B,A):
	def cc(self):
		print("cc")
c = C()
c.cc() # 对象c同时有aa、bb和cc方法
c.bb()
c.aa()
c.say() 因为是C(B,A),所所以执行B类中的say()

如果继承的多个父类中有相同的名字，在子类没有指定父类名时，解释器会从左到右按顺序搜索

5 super()获得父类定义

在子类中，如果想用父类方法，可通过super()，super()代表父类的定义(可以理解为用父类的代码)，不是父类对象

class A:
	def say(self):
		print("A: ",self)
		print("say AAA")
class B(A):
	def say(self):
		#A.say(self) 调用父类的 say 方法
		super().say() #通过 super()调用父类的方法
		print("say BBB")
b = B()
b.say()

运行结果：
A: <main.B object at 0x007A5690>
say AAA
say BB

6 特殊属性和特殊方法

特殊方法：

特殊属性：

2.2 多态

多态指同一个方法由于调用对象不同可能会产生不同的行为。
多态的要点;
1、只有方法有多态，属性没有多态
2、多态存在的2个必要条件：继承、方法重写

class Animal:
	def shout(self):
		print("动物叫了一声")
class Dog(Animal):
	def shout(self):
		print("小狗，汪汪汪")
class Cat(Animal):
	def shout(self):
		print("小猫，喵喵喵")
def animalShout(a):
	if isinstance(a,Animal):
		a.shout() #传入的对象不同，shout 方法对应的实际行为也不同。
animalShout(Dog())
animalShout(Cat())

2.3 对象的浅拷贝和深拷贝

• 变量的赋值操作
  只是形成两个变量，实际还是指向同一个对象。
• 浅拷贝
  Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
• 深拷贝
  使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同

import copy
class MobilePhone:
	def __init__(self,cpu,screen):
		self.cpu = cpu
		self.screen = screen
class CPU:
	def calculate(self):
		print("计算，算个 12345")
		print("CPU 对象:",self)
class Screen:
	def show(self):
		print("显示一个好看的画面，亮瞎你的钛合金大眼")
		print("屏幕对象：",self)
		
c = CPU()
s = Screen()
m = MobilePhone(c,s)
n = m #两个变量，但是指向了同一个对象

m2 = copy.copy(m) #m2是新拷贝的另一个手机对象
m.cpu.calculate()
m2.cpu.calculate() #m2 和 m 拥有了一样的 cpu 对象和 screen 对象

m3 = copy.deepcopy(m)
m3.cpu.calculate() #m3 和 m 拥有不一样的 cpu 对象和 screen
对象

2.4 组合

组合也是为了代码的复用

• “is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
• “has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

上面mobilephone的代码就是组合关系

m = MobilePhone（CPU(),Screen())
m.CPU.calculate() #通过组合，我们也能调用 cpu 对象的方法。相当于手机对象间接拥有了“cpu 的方法

2 设计模式

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。当然，我们没有必要全部学习，学习几个常用的即可。

2.1 工程模式

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进
行统一的管理和控制

class CarFactory:
	def createCar(self,brand):
	if brand == "奔驰":
		return Benz()
	elif brand == "宝马":
		return BMW()
	elif brand == '比亚迪':
		return BYD()
	else:
		return "未知品牌，无法创建"

class Benz:
	pass
class BMW:
	pass
class BYD:
	pass
factory = CarFactory()
c1 = factory.createCar("奔驰")
c2 = factory.createCar("宝马")
print(c1) #<__main__.Benz object at 0x021C5770>
print(c2) #<__main__.BMW object at 0x021C5790>

2.2 单例模式

核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。

class CarFactory: 
	__obj = None #类属性
	__init_flag = True
def create_car(self,brand):
	if brand =="奔驰":
		return Benz()
	elif brand =="宝马":
		return BMW()
	elif brand == "比亚迪":
		return BYD()
	else:
		return "未知品牌，无法创建" 
	def __new__(cls, *args, **kwargs):
		if cls.__obj ==None:
			cls.__obj = object.__new__(cls)
			return cls.__obj
	def __init__(self):
			if CarFactory.__init_flag:
				print("init CarFactory....")
				CarFactory.__init_flag = False
class Benz:
	pass
class BMW:
	pass
class BYD:
	pass
factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)
factory2 = CarFactory()
print(factory)
print(factory2)