Python Part2

1265-张同学

发表文章数:58

热门标签

首页 » 算法 » 正文

知识点

  1. 嵌套函数:函数内定义的函数。
    • 封装,隐藏。
    • 贯彻DRY(Don’t Repeat Yourself)原则,在函数内部避免重复代码。
    • 闭包?
  2. 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
  1. LEGB规则:Python在查找“名称”时遵循的准则。Local -> Enclosed -> Global -> Built in
    • Local 函数或者类的内部方法
    • Enclosed 嵌套函数(闭包)
    • Global 全局变量
    • Built in Python自带
  2. Python中一切都是对象,支持面向过程,面向对象,函数式编程多种范式。
  3. 面向过程和面向对象
    • 面向过程(Procedure Oriented),执行者思维,适合编写小程序。
    • 面向对象(Object Oriented),设计者思维,适合编写大规模程序。
      两者都是解决问题的思维方式,都是代码组织的方法。
      解决简单问题可以使用面向过程。
      解决复杂问题:宏观上使用面向对象把握,微观处理上仍然是面向过程。
  4. 对象的进化,数据变多进化数组,数组类型复杂进化除了“结构体”(C语言中的数据结构),处理数据 的方式和逻辑复杂化,进化出了“对象”。
  5. 类产生对象。类的结构包含方法和属性。
  6. 初始化类有两步,先是__new__()创建对象,然后__init__()初始化该对象。
  7. obj = 类名()
    obj.实例属性 = value
    obj.方法 = func
    dir(obj)查看所有属性,方法
    obj.__dict__对象的属性词典
    pass空语句
    isinstance(对象,类型)
  8. 类内存分析(important)
    Python Part2
  9. 类方法是从属于类属性的方法。类方法通过装饰器@classmethod来定义。
class Student:
	company = 'SXT'
	@classmethod
	def printCompany(cls):
		print(cls.company)

Student.printCompany()
  1. 静态方法,定义与类对象无关的方法。
  2. 类方法和静态方法中不能调用实例属性和方法。
  3. del:析构函数,删除对象,释放空间。
  4. __call__方法,调用对象本质上就是调用call方法。
  5. 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()  -> 好好工作

一切皆是对象。

  1. 私有属性和私有方法实现封装。
    python对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。
    • __开头为私有,其他公有
    • 类内部可以访问私有属性(方法)
    • 类外部不能直接访问私有属性(方法)
    • 类外部可以通过"__类名__私有属性"来访问。
  2. @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
  1. 面向对象的三大特征。
    • 封装 隐藏细节,对外提供最简单方法。
    • 继承 让子类具有父类特征。
    • 多态 同一个方法调用由于对象不同会产生不同的行为。比如:正常人休息是打游戏,程序猿休息是写几行代码。
  2. 继承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	
  1. Python支持多重继承,一个子类可以有多个父亲,一般情况下避免使用。
  2. super()获得父类定义。
  3. 多态
    • 多态是方法的多态,不是属性的多态
    • 多态存在两个必要条件:继承,方法重写
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()) -> 英国人用刀叉吃饭
  1. 特殊方法
    方法 | 说明 | 例子
    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 | 指数
  2. 特殊属性
    • obj.dict 对象的属性字典
    • obj.class 对象的类
    • class.bases 类的基类元组
    • class.base 类的基类
    • class.mro 类的层次结构
    • class.subclasses() 类的子类
  3. 组合也能实现一个类拥有另一个类的方法和属性。
Class A2:
	def say_a2():
		print('a2a2')
Class B2:
	def __init__(self,A):
		self.a = A		
b2 = B2(A2())
b2.a.say_a2() -> a2a2
  1. 设计模式是面向对象语言特有的内容,有很多种,比较流行的是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')
  1. 单例模式。核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。
    Python Part2
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共享一个单例对象。
  1. 异常机制本质,指程序运行过程中出现的非正常现象。
    Python Part2
  2. python中一切都是对象,异常也使用对象的方法处理,处理过程:
    • 抛出异常
    • 捕获异常
  3. try:
    被监控的可能引发异常的语句块
    except BaseException as e:
    异常处理语句块
    如果try模块没有问题,跳过except。若发生异常,则跳过try模块执行except。try可以跟多个except模块。
  4. try…except…else 有异常执行except,无异常则执行完try再执行else。
  5. finally模块无论过程,最终都要执行,通常释放资源。
  6. 常见异常
    Python Part2
    Python Part2
    Python Part2
  7. with上下文管理可以自动管理资源,在with代码块执行完毕后,自动还原进入该代码之前的现场或上下文,不论何种原因跳出with,不论是否异常,总能保证资源正常释放。
  8. trackback
    输出异常。
import traceback
try:
	print('step1')
	num = 1/0
except:
	with open('./dd.txt','a') as f:
		trackback.print_exec(file = f)
  1. 自定义异常:
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('正常')
  1. pycharm调试。
    Python Part2
    Python Part2
标签:

未经允许不得转载:作者:1265-张同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Python Part2》 发布于2020-12-05

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录