Python Part2

最新推荐文章于 2022-08-29 23:11:08 发布

YoutiaoNo2

最新推荐文章于 2022-08-29 23:11:08 发布

阅读量133

点赞数

文章标签： python

本文链接：https://blog.csdn.net/YoutiaoNo2/article/details/110676537

版权

Python Part2

- 知识点

知识点

嵌套函数：函数内定义的函数。
- 封装，隐藏。
- 贯彻DRY(Don’t Repeat Yourself)原则，在函数内部避免重复代码。
- 闭包?
nonlocal声明外层局部变量，global声明全局变量。

def outer()：
	b = 10
	def inner():
		nonlocal b
		print('inner b:',b)
		b = 20
	inner()
	print('outer b:',b)
outer()
#output
'inner b:' 10 
'outer b:' 20

LEGB规则：Python在查找“名称”时遵循的准则。Local -> Enclosed -> Global -> Built in
- Local 函数或者类的内部方法
- Enclosed 嵌套函数（闭包）
- Global 全局变量
- Built in Python自带
Python中一切都是对象，支持面向过程，面向对象，函数式编程多种范式。
面向过程和面向对象
- 面向过程(Procedure Oriented)，执行者思维，适合编写小程序。
- 面向对象(Object Oriented)，设计者思维，适合编写大规模程序。
  两者都是解决问题的思维方式，都是代码组织的方法。
  解决简单问题可以使用面向过程。
  解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。
对象的进化，数据变多进化数组，数组类型复杂进化除了“结构体”（C语言中的数据结构），处理数据的方式和逻辑复杂化，进化出了“对象”。
类产生对象。类的结构包含方法和属性。
初始化类有两步，先是__new__()创建对象，然后__init__()初始化该对象。
obj = 类名()
obj.实例属性 = value
obj.方法 = func
dir(obj)查看所有属性，方法
obj.__dict__对象的属性词典
pass空语句
isinstance（对象，类型）
类内存分析(important)
类方法是从属于类属性的方法。类方法通过装饰器@classmethod来定义。

class Student:
	company = 'SXT'
	@classmethod
	def printCompany(cls):
		print(cls.company)

Student.printCompany()

静态方法，定义与类对象无关的方法。
类方法和静态方法中不能调用实例属性和方法。
del：析构函数，删除对象，释放空间。
__call__方法，调用对象本质上就是调用call方法。
Python是一种动态语言，可以在外部修改类内方法。

class Person:
	def work(self):
		print('努力上班')
def play_game(s):
	print('{0}在玩游戏'.format(s))
def work2(s):
	print('好好工作')
Person.play =play_game;
p = Person()
p.work()  -> 努力上班
p.play('luis')  -> luis在玩游戏 
Person.work = work2
p.work()  -> 好好工作

一切皆是对象。

私有属性和私有方法实现封装。
python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。
- __开头为私有，其他公有
- 类内部可以访问私有属性（方法）
- 类外部不能直接访问私有属性（方法）
- 类外部可以通过"__类名__私有属性"来访问。
@property可以将方法的调用转换为属性调用。内部属性方法的获取和修改：

class Employee:
	def __init__(self,name,salary):
		self.__name= name
		self.__salary = salary
	@property
	def salary(self):
		return self.__salary
	@salary.setter
	def salary(self,salary):
		self.__salary = salary
emp1 = Employee('luis',3000)
print(emp1.salary） -> 3000
emp1.salary = 20000
print(emp1.salary)  -> 20000

面向对象的三大特征。
- 封装隐藏细节，对外提供最简单方法。
- 继承让子类具有父类特征。
- 多态同一个方法调用由于对象不同会产生不同的行为。比如：正常人休息是打游戏，程序猿休息是写几行代码。
继承class son(father)，object为默认类，所有类的父类，含有__init__, new ,__call__等方法。

class Person:
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def say_age(self):
		print('IDK')

class Student(Person):
	def __init__(self,name,age,score):
		Person.__init__(self,name,age)
		self.score = score

Python支持多重继承，一个子类可以有多个父亲，一般情况下避免使用。
super()获得父类定义。
多态
- 多态是方法的多态，不是属性的多态
- 多态存在两个必要条件：继承，方法重写

Class Chinese(man):
	def eat(self):
		print('中国人用筷子吃饭')
Class English(man):
	def eat(self):
		print('英国人用刀叉吃饭')
def maneat(m):
	if isinstance(m,man):
		m.eat() #多态，一个方法调用，根据对象不同调用不同的方法。
	else:
		print('不能吃饭')
maneat(Chinese()) -> 中国人用筷子吃饭
maneat(English()) -> 英国人用刀叉吃饭

特殊方法
方法 | 说明 | 例子
init | 构造方法 | p = Person()
del | 析构方法 | 对象回收
repr, str | 打印，转换 | print(a)
call | 函数调用 | a()
getattr | 点号运算 | a.xxx
getitem | 索引运算 | a[key]
setitem | 索引赋值 | a[key]=value
len | 长度 | len(a)
add | 加法 | a.add(b)
sub | 减法 | a.sub(b)
<,<=,==,>,>=,!= | lt,le,eq,gt,ge,ne | 比较运算符
|,^,& | or,xor,and | 或，异或，与
<<,>> | lshift,rshift | 左移右移
*,/,%,// | mul,truediv,mod,floordiv | 乘，除，取余，整除
** | pow | 指数
特殊属性
- obj.dict 对象的属性字典
- obj.class 对象的类
- class.bases 类的基类元组
- class.base 类的基类
- class.mro 类的层次结构
- class.subclasses() 类的子类
组合也能实现一个类拥有另一个类的方法和属性。

Class A2:
	def say_a2():
		print('a2a2')
Class B2:
	def __init__(self,A):
		self.a = A		
b2 = B2(A2())
b2.a.say_a2() -> a2a2

设计模式是面向对象语言特有的内容，有很多种，比较流行的是GOF23，这种设计模式。
工厂模式实现了创建者和调用者的分离，使用专门的工厂类将实现类，创建对象的过程做统一的管理和空值。

Class Carfactory:
	def create_car(self,brand):
		if brand == 'Benz':
			return Benz()
		if brand == 'BMW':
			return BMW()
		if brand == 'BYD'：
			return BYD()
Class Benz:
	pass
Class BMW:
	pass
Class BYD:
	pass
f = Carfactory()
c1 = f.create_car('BMW')

单例模式。核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。

Class Mysingleton:
	__obj = None
	def __new__(cls,*args,**kwargs):
		if cls.__obj == None:
			cls.__obj  = object.__new__(cls)
		return cls.__obj
	
	def __init__(self,name):
		print('init.....')
		self.name = name
a = Mysingleton('aa')
b = Mysingleton('bb')	
#a,b共享一个单例对象。

异常机制本质，指程序运行过程中出现的非正常现象。
python中一切都是对象，异常也使用对象的方法处理，处理过程：
- 抛出异常
- 捕获异常
try:
被监控的可能引发异常的语句块
except BaseException as e:
异常处理语句块
如果try模块没有问题，跳过except。若发生异常，则跳过try模块执行except。try可以跟多个except模块。
try…except…else 有异常执行except，无异常则执行完try再执行else。
finally模块无论过程，最终都要执行，通常释放资源。
常见异常
with上下文管理可以自动管理资源，在with代码块执行完毕后，自动还原进入该代码之前的现场或上下文，不论何种原因跳出with，不论是否异常，总能保证资源正常释放。
trackback
输出异常。

import traceback
try:
	print('step1')
	num = 1/0
except:
	with open('./dd.txt','a') as f:
		trackback.print_exec(file = f)

自定义异常：

Class AgeError(Exception):
	def __init__(self,errorInfo):
		Exception.__init__(self)
		self.errorInfo = errorInfo
	def __str__(self):
		return '年龄错误'
if __name__ == '__main__':#如果是true,则模块作为独立文件运行。
	if age>100:
		raise AgeError()
	else:
		print('正常')