Python知识点整理（3） —— 编程范式

编程范式

面向对象

OOP

• 对象抽象成类
• 数据封装、继承、多态

组合与继承

• 组合（使用其他类的实例当作自己的属性 has-a）
• 继承（子类继承父类的属性和方法 is-a）
• 优先使用组合

类变量&实例变量
classmethod & staticmethod

class Person:
	country = "China" # 类变量
	def __init__(self, name):
		self.name = name # 实例变量/属性
	@classmethod # classmethod
	def print_country(cls):
		print (cls.country)
	@staticmethod # staticmethod：其实可以放在外面（处于组织的需要）
	def join_name(first_name, last_name):
		return last_name + first_name

元类（meta class）

• 元类允许我们控制类的生成，比如修改类的属性
• 使用type来定义元类
• 元类最常见的使用场景：ORM框架

# 这两种定义是完全相同的
class x:
	a = 1
xx = type('x', (object,), dict(a = 1)) # 参数分别表示：类名，基类，字典 

装饰器

decorator

• python中一切皆对象
• 接受一个函数作为参数，在不修改原来的函数的情况下，增添功能，返回一个新的函数
• 通过@来使用装饰器
• 使用场景：打印日志
• 使用函数编写装饰器

import time
def log_time(func): # 接受一个函数作为参数
	def _log(*args, **kwargs): # 可以接受所有参数
		beg = time.time()
		res = func(*args, **kwargs)
		print ('use time:{}'.format(time.time()-beg))
		return res
	return _log
	
@log_time # @是装饰器语法糖
def mysleep():
	time.sleep(1)
mysleep()		
# 和上面等价的调用方式
newsleep = log_time(mysleep)
newsleep()

• 使用类编写装饰器

import time
class LogTime:
	def __call__(self, func):
		def _log(*args, **kwargs):
			beg = time.time()
			res = func(*args, **kwargs)
			print ('use time:{}'.format(time.time()-beg))
			return res
		return _log
		
@LogTime() # 注意：加括号是为了初始化类的实例
def mysleep():
	time.sleep(1)
mysleep()

• 给装饰器增加参数

import time
class LogTime:
	def __init__(self, use_int = False):
		self.use_int = use_int
	def __call__(self, func):
		def _log(*args, **kwargs):
			beg = time.time()
			res = func(*args, **kwargs)
			if self.use_int:
				print ('use time:{}'.format(
					int(time.time()-beg))
				)
			else:
				print ('use time:{}'.format(
					time.time()-beg)
				)
			return res
		return _log
		
@LogTime(True) # 注意：加括号是为了初始化类的实例
def mysleep():
	time.sleep(1)
mysleep()

设计模式：创建型

工厂模式

• 解决对象创建问题
• 解耦对象
• 工厂方法 & 抽象工厂

构造模式

• 创建表示分离：买电脑，工厂模式直接给你需要的电脑；构造模式允许diy电脑的配置

原型模式

• 使用相同的原型，通过修改部分属性来创建新的事例

单例模式

• 一个类创建出来的对象都是同一个
• python的模块是单例的，只会导入一次
• 使用共享同一个实例的方式来创建单例模式
• 通过单例模式可以保证系统中，应用该模式的一个类只有一个实例

class Singleton:
	"""
	基于__new__的方法实现单例模式：每次创建一个新的实例的时候，都会使用_instance来作为共享的实例
	这种方法的好处：不需要为了保证线程安全在内部加入锁
	原理：当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式
	
	详见：https://www.cnblogs.com/huchong/p/8244279.html#_lab2_1_0 
	"""
	def __new__(cls, *args, **kwargs): # __new__() 创建实例
		if not hasattr(clas, '_instance'): # _instance表示所有的共享实例，如果当前的类没有_instance这个实例，则创建
			_instance = super().__new__(cls, *args, **kwargs)
			cls._instance = _instance
		return cls._instance
class MyClass(Singleton):
	pass

c1 = MyClass()
c2 = MyClass()
assert c1 is c2 # c1、c2的id是相同的，验证了c1和c2是同一个实例

设计模式：结构型

设计模式：行为型

相关文章

• Python知识点整理（1）语言基础
• Python知识点整理（2） 数据结构与内置算法