【python进阶学习笔记看这一篇就够啦！全网最全！！！】

努力学习的哇塞妹妹‍

已于 2023-06-26 20:24:36 修改

阅读量211

点赞数

分类专栏： python 文章标签： python 学习笔记

于 2023-06-25 23:52:49 首次发布

本文链接：https://blog.csdn.net/CrazyDog_JJ/article/details/131339264

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

焦焦的python学习笔记

python与其他语言的区别：
⚠️注意：
区别一下💁🏻：
python中的参数 🫥
python中的保留字😶‍🌫️
面向对象🐘
三器一闭
魔法方法🦄

python与其他语言的区别：

python每条语句不需要分号；
python通过缩紧来划分语句块；
不需要进行变量声明；不需要引用头文件；
整数只有int型一种（没有long int），没有char 和double型；
没有switch语句，没有do- while语句；
没有main函数，是从上到下执行的；
python中的注释：
单行注释：#
多行注释：“““ ”””或‘’‘ ’‘’
变量的类型随着指向的数据类型变化而变化，name创建时必须指向任意一个object（name=object）
python中对大小写很敏感哦
python中没有自增自减

⚠️注意：

多个可变类型通过赋值引用同一可变类型对象时，任何一个变量改变了可变类型的对象，其他变量也随之改变
实例展示：

a=[1,2,3,4];
a
//[1,2,3,4]
b=a
b
//[1,2,3,4]
a[0]='hello'
a
//['hello',2,3,4]
b
//['hello',2,3,4]

字符串要用单引号（‘ ’）或双引号（“ ”）引起来噢
for循环的格式：for … in …
input()返回值是字符串，如果想用整数要进行强制类型转换
range是左闭右开的
切片和索引：
使用[]来进行切片和索引
s.split(‘-’):用-作为切片标志

区别一下💁🏻：

1.reverse/sort和reversed/sorted的区别：
前者把原列表的数据元素反转重新排列/按大小顺序重排；后者会得到一个新的列表，而原来的列表不发生变化；

2.区别元组,列表,字典,集合
元组：用（）表示；一旦创建不可修改【不可变性】
列表：用[]表示；用逗号间隔各个元素，列表中数据可以是不同类型的；列表中数据可以是有序的，可通过下标进行索引和切片
字典：用{}表示，用key-:value形式；其中key可以是任意不可变类型（数值/字符串/元组），value可以是任意类型，甚至可以是字典
集合：用{}表示，无序不重复；

3.类属性和实例属性：
类属性：在类中定义，可以通过类名或者实例名进行访问
实例属性：在def函数中定义，只作用于当前实例，只能通过实例名进行访问
特殊的抽象属性：通过@property将一个方法转化为属性，且只有一个self参数，转化后的属性不能重新赋值，实现了只读（对于简单的方法，无需传参，且有返回值时使用）

4.实例方法、类方法和静态方法：
实例方法：第一个参数时实例self，要通过函数进行调用
类方法：@classmethod进行修饰，第一个参数为cls，通过类进行调用
静态方法：@staticmethod进行修饰，无第一个参数的限制，一般用类进行调用，也可以用实例进行调用（方法中不用对象中封装的值时用）

python中的参数 🫥

形参：定义中的形式参数
实参：实际使用时传入的值
默认值参数：在定义时进行了赋值，函数调用时，这份参数有传入使用传入值，没有时使用默认值（默认值参数只能出现在参数列表的最右侧）
位置参数：使用时注意实参要和形参位置一致，在没有默认值的情况下，参数的个数也要一致
关键字参数：实参传入时，通过赋值语句用形参名字进行赋值传入，使用参数名称就可以不管顺序啦～
位置参数和关键字参数可以混用，但位置参数在前，关键字参数在后
不定长位置参数：在参数名称前加*，可以接受多个不确定个数的位置参数
不定长关键字参数：在参数前面加**，可以接受多个不确定个数的关键字参数
混合参数：如果有很多个值都是不定长参数，可以将缺省参数放到*par后面，但是如果有**pars时，**pars要放在最后面；

python中的保留字😶‍🌫️

python中有33个保留字:and/as/assert/break/class/continue/def/elif/else/except/finally/for/from/if/import/in/is/lambda/not/or/pass/raise/return/try/while/with/yield/del/global/nonlocal/True/False/None

True/Flase/None 这三个保留字首字母要大写，没有大写时，它就只是个name不是关键字啦

面向对象🐘

tips

类和对象的关系：类是抽象的，对象时具体的
方法创建时用def，第一个参数必须时self，这个参数指向实例本身
特殊方法以__开头,__结束
访问权限：
__ foo__：特殊定义，通常时系统定义的名字，比如__init__
_foo:protected类型，只允许本身和子类访问
__foo：private类型，只允许定义该方法的类本身进行访问，却不能通过类的实例进行访问，当为私有属性或者方法时，外部无法进行调用，子类无法继承

封装

将相关功能封装到一个类中，将数据封装到一个对象中

继承

在继承时，self是哪个类的对象，先从自己开始找，再找父类，多继承时，先找第一个父亲，采用广度优先遍历方法进行继承

class Base1:
	def f1(self): 
		print('base1.f1')
	def f2(self): 
		print('base1.f2')
class Base2:
	def f1(self): 
		print('base2.f1')
	def f2(self): 
		print('base2.f2')
	def f3(self):
		print('base2.f3')
   		self.f1()
   		
class Foo(Base1, Base2):
	def f0(self):
		print('foo. f0')
		self.f3()
obj=Foo()
obj.f0()
# foo.f0
# base2.f3
# base1.f1

在类的继承中，调用需要super()函数，不会自动调用父类的方法；如果子类同名方法会覆盖父类方法

多态

多个对象共用一个接口，又表现出不同的形态

三器一闭

闭包

一个函数中嵌套另一个函数，里面的函数用了外面函数，外面的函数return里面的函数；则将外部函数变量和内部函数这个整体叫做闭包
闭包与普通函数区别：在外部函数执行完后，外部函数的所有局部变量+形参都不会释放，在调用内部函数时还可以使用

闭包的内部函数中，如果没有用特殊的关键字来声明外部函数中的变量，则不能对其修改
增加nonlocal可以对闭包的内部函数进行修改
多个闭包间是没有关系的，可以创建多个闭包

装饰器

装饰器的作用：增加功能
装饰器：将基本函数作为参数作为参数传入别的函数中；装饰器的语法糖@，@decor相当于 j=decor(jiao);
装饰器的总结：
outer：可以区分或者使用参数arg
decor：具有接收基本函数传入的参数func
inner：定义未来扩充好的参数

基础的装饰器

def decor(func):#装饰器
	def inner():
		print("study") #增加功能
		func()#调用基本函数jiao（）
	return inner; #返回扩充了新功能的函数
	
@decor
def jiao():
	print("sleep")

jiao()
#sleep
#study

装饰器返回值应该是一个函数，且为装饰后的新函数

装饰有返回值的函数

def decor(func):#定义增加功能的函数
	def inner():
		print("study") #增加函数
		func()#调用基本函数jiao（）
		return 123
	return inner; #返回未来的inner函数
@decor
def jiao():
	print("sleep")
	return 123

jiao()
#study
#sleep
#123

装饰后的函数也有返回值

装饰有参数的函数

def decor(func):#定义增加功能的函数
	def inner(w1,w2):
		print("study") #增加函数
		func(w1,w2)#调用基本函数jiao（）
		return 123
	return inner; #返回未来的inner函数
@decor
def friends(x,y):
	print('{}和{}是好朋友'.format(x,y))
	return 123

friends('a','b')
#study
#a和b是好朋友

一个装饰器同时装饰不同的函数

定义一个outer要返回decor，outer用于接收参数，decor要返回新的功能函数inner，在innner函数中进行判断参数具体增加哪种功能

def outer(arg):#定义outer返回decor
	def decor(func):#装饰器要返回新的功能函数inner
		def inner():
			if arg=='smile':
				print('hahaha......')
				func()
			elif arg == 'cry':
				print('wuwuwu...')
				func()
		return inner
	return decor
@outer('smile')
def s():
	print('哈哈哈')	
@outer('cry')
def c():
	print('呜呜呜')

s()
#hahaha......
#哈哈哈
c()
#wuwuwu...
#呜呜呜

为类加装饰器

在outer中传入类，在inner中可以调用类

class People():
	def sleep():
		print('zzz...')
	def eat():
		print('awu...awu...')
		
def outer(cls):#将参数类传入
	def decor(func):#将参数传入
		def inner():
			cls.sleep()
			func()
			cls.eat()
		return inner
	return decor
@outer(People)
def jiao():
	print('study!')
jiao()
#zzz...
#study!
#awu...awu...

用类作为装饰器

outer中要有__ call __方法使得对象可以当函数使用（相当于decor函数）；outer中要有__init __方法使得参数可以传入（相当于outer函数）；其中inner在__call __中传入即可

class Outer:
	def __init__(self,arg):
		self.arg=arg
	def __call__(self,func):
		self.func=func
		return self.inner
	def inner(self):
		if self.arg == 'a':
			print('aaaa')
			self.func()
		else:
			print('no')
			self.func()
@Outer('a')
def jiao():
	print('bbb')
jiao()
#aaaa
#bbb

以类作为装饰器

此时inner要返回的一个对象

def decor(cls):
	def inner():
		obj=cls()
		obj.age=18
		obj.name='jiaojiao'
		return obj
	return inner
@decor
class Human():
	pass
ren=Human()
print(ren.__dict__)

多层装饰器嵌套

层层嵌套，基本函数由里到外的装饰

def decor1(func):
	def inner():
		print('aaa')
		func()
		print('bbb')
	return inner
def decor2(func):
	def inner():
		print('ccc')
		func()
		print('ddd')
	return inner
	
@decor2
@decor1
def f():
	print('3.1415926')
f()
'''
ccc
aaa
3.1415926
bbb
ddd
'''

迭代器

可迭代对象：实现了__iter__方法的
迭代器：用过iter()实现，不断使用next()获取下一条数据，若迭代长度超过可迭代对象长度，抛出StopIteration异常
自定义迭代器：通过创建__iter__和__next__可以自定义迭代器

def __iter__(self):
	return self
def __next__(self):
	if self.current_num<len(self.stus):
		ret=self.a[self.current_num]#取出当前列表中的元素
		self.current_num+=1
		return ret
	else:	
		self.current_num=0
		raise StopIteration

是否可迭代：
（1）用collection中的iterable判断，返回True
（2）可以作用于for循环的
（3）集合数据类型list/dict/str等都是iterable

生成器

生成器使用了yield，返回的是迭代器函数，满足迭代器的特征

yield关键字：下次从本次后面开始运行

def __iter__(self):
	return self
def __next__(self):
	if self.current_num<len(self.stus):
		ret=self.a[self.current_num]#取出当前列表中的元素
		self.current_num+=1
		return ret
	else:	
		self.current_num=0
		raise StopIteration

魔法方法🦄

不需要人工调用，在特定时刻自动执行

函数	触发时机	参数	返回值	注意事项
__init __	实例化对象后触发	self+自定义参数	无	可以为对象增加所属成员
__new __	实例化对象时触发	cls+自定义参数	可有可无，无时实例化结果为None	无
__del __	对象被系统回收时触发	self	无	无
__call __	将对象当作函数调用时触发	self+自定义参数	可有可无	无
__len __	使用len()函数时	self	必须有，且为整数	len检测什么由程序员自己决定
__str __	（1）print函数输出时（2）调用str（）进行字符串转化时	self	必须有，且为字符串	str方法可以继承object的，自己定义就是重载了；该方法用于定义打印对象的显示内容
__repr __	调用__repr __	self	必须有，且为字符串	一般情况str和repr方法结果一样，字符串除外，重载repr，str也会变（系统默认__str__=__repr __）但是重载str，repr不会变
__bool __	使用bool()函数	self	True/False	无
__format __	使用format()函数	self+参数(必须有)	字符串	无
__getattribute __	访问对象成员即可触发，不管对象是否存在	self+item(用于接收访问成员名称的字符串)	有，不设定返回None	不能使用当前对象成员访问，否则会再次出发递归循环，要用object.getattribute访问成员
__getattr __	访问不存在的对象成员	self+item	可有可无	防止访问不存在成员报错为不存在成员定义值
__setattr __	增加或修改对象成员	self+进行设置的成员名称字符串+要设置的值	无	不能使用当前对象成员访问，否则会再次出发递归循环，要用object.setattr访问成员

属性访问顺序：
1.__getattribute __
2.调用数据描述符
3.调用当前对象的所属成员
4.调用类的所属成员
5.调用非数据描述符
6.调用父类的所属成员
7.调用__getattr __

#__format__魔法方法
class Gril():
	name='jiaojiao'
	def __format__(self,arg):
		flag = arg#接收限定符号
		#拆分限定符号
		fillchar=flag[0]#拆分填充字符
		align=flag[1]#拆分对其方式
		length=int(flag[2:])#拆分字符长度
		#进行填充操作
		if align=='>':#右对齐
			newname=self.name.rjust(length,fillchar)
			return newname
		elif align=='-':#居中
			newname=self.name.center(length,fillchar)
			return newname
		elif align=='<':#左对齐
			newname=self.name.ljust(length,fillchar)
			return newname
		else :
				return ''
g=Gril()	
#使用format来操作对象
action = '我❤️{:*-15}'
result = action.format(g)
print(result)
#我❤️****jiaojiao***

class Gril:
	def __init__(self):
		self.name = 'jiao'
	def __getattribute__(self,item):
		result = object.__getattribute__(self,item)
		#隐匿用户名
		newname=result[0]+'*'+result[-1]
		return newname#返回数据
j=Gril()
print(j.name)
#j*o