（萌新笔记）python的复习笔记（2）

简介：此文是接着（萌新笔记）python的复习笔记 续写的第二篇（我比较弱鸡，所以本文可能会有记录很多我初学时遇到的问题，还请大家斟酌观看

Start！─=≡Σ٩( ๑╹ ꇴ╹)۶

一、字典

字典不是序列类型，是映射类型
字典有 键、值、项（左边、右边、单个整体）
键 是独一无二的，键 和 值 都必须不可变

赋值和访问字典

>>>tep = dict((('I',1),('R',2),('O',3),('N',4))) #字典只能接受一个参数（此为元组内包含元组）
>>>tep
{'I':1,'R':2,'O':3,'N':4} #大括号

>>>tep = dict(I = 1,R = 2,O = 3,N = 4) #注意不能是'I' = 1 这个样子
>>>tep
{'I':1,'R':2,'O':3,'N':4} #结果与上面的一样

>>>tep = dict(zip(['I','R','O','N',],[1,2,3,4]))
>>>>tep
{'I':1,'R':2,'O':3,'N':4} #结果与上面的一样

>>>tep
{'I':1,'R':2,'O':3,'N':4} 

>>>tep['I']
1

>>>tep['I'] = 0
>>>tep['I']
1

>>>tep['X'] = 5
>>>tep
{'I':0,'R':2,'O':3,'N':4,'X':5} 

注意事项

>>>demo = {"蜘蛛侠":"death","蜘蛛侠":"live"}
>>>demo
"蜘蛛侠":"live" #同一个键出现被赋值两次，取后者

>>>demo = {(1,2,3):"a,b,c"}
>>>demo
{(1,2,3):"a,b,c"} #元组不可变，可行

>>>demo = {[1,2,3]:"a,b,c"}
error #报错，因为键不可变而列表可变

有别于序列，字典是不支持拼接和重复操作的

设 a,b 是字典

c = a + b
error #报错

d = a * 3
error #报错

各种内置方法

1、fromkeys()
作用是传入一个键值

>>>stuff = {}
>>>stuff
{}

>>>stuff.fromkeys(1,2,3)
>>>stuff
{1:"None",2:"None",3:"None"}

>>>stuff.fromkeys((1,2,3),"number")
>>>stuff
{1:"number",2:"number",3:"number"}

>>>stuff.fromkeys((1,2,3),"One,Two,Three")
>>>stuff
{1:"One,Two,Three",2:"One,Two,Three",3:"One,Two,Three"} #值只能接受一个参数

2、keys()、values()、iteams()
作用分别是返回字典中的键、值、项

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>tep.keys()
dict_keys(['I','R','O','N'])

>>>tep.values()
dict_values([1,2,3,4])

>>>tep.iteams()
dict_iteams([('I',1),('R',2),('O',3),('N',4)])

3、gets()
作用是查找字典中的键

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>tep.gets('I')
1
>>>tep.gets('X')
None

也可以自定义找不到的键的的返回值
>>>tep.gets('X','NoNoNo')
>>>tep.gets('X')
NoNoNo

4、clear() 和 copy()
作用分别是清除和复制
注意:若是直接用'='赋值则会使两个字典相关联

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>temp = tep.copy()
>>>temp1 = tep

>>>temp1.clear()

>>>tep #因为相关联
{}

>>>temp
{'I':1,'R':2,'O':3,'N':4} 

5、pop() 和 popitem
作用分别是访问键 和 随机访问项

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>tep.pop('I')
1

>>tep.popitem()
('I',1)

6、setdefault()
作用使访问键，若访问不到就自动添加

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>tep.setdefault('I')
1

>>>tep.setdefault('X')
>>>tep
{'I':1,'R':2,'O':3,'N':4,'X':None}

7、update()
作用是更新字典

>>>tep = {'I':1,'R':2,'O':3,'N':4} 

>>>tep.update(N = 5) #注意更新的键不是字符形式
>>>tep
{'I':1,'R':2,'O':3,'N':5} 

8、打包和解包
**在形参中是打包成字典，而**在实参中是解包

>>>def pack(**params):
	print(params)
	
>>>pack(a = 1,b = 2,c = 3)
{'a': 1, 'b': 2, 'c': 3}

>>>def unpack(a,b):
	print(a)
	print(b)

>>>c = {'a':1,'b':2} #注意必须要 'a' 与 a 一致（的确很麻烦
>>>unpack(**c)
1
2

二、集合

集合在python中的最大的特点就是：无序

区分集合 和 字典
>>>num = {}
>>>num2 = {0,1,2}

>>>type(num)
<class 'dict'> #字典类型

>>>type(num2)
<class 'set'> #集合类型

创建集合

可以直接创建，也可以用set（）函数

>>>set1 = {1,2,3,4,5}
>>>set2 = {set[1,2,3,4,5]}

>>>set1 == set2
True

集合的唯一性

>>>list1 = [1,2,3,4,5,4,3,2,1,0]

>>>set1 = set(list1)
>>>set1
{0,1,2,3,4,5} #元素是唯一的

访问集合
其实集合具有无序性、只是每次都按顺序排好罢了，所以不能使用下标法进行索引

可以用for语句、成员操作符、add()函数

>>>set1 = {1,2,3,4,5}

>>>for each in set1:
	print(each,end = '')
12345

>>>2 in set1
True

>>>set1.add('6')
>>>set1
{1,2,3,4,5,'6'} #集合按照数字与浮点数（按数值）在前面，字符与字符串（按ASCII码）在后面的顺序自动排列

>>>set1.remove('6')
>>>set1
{1,2,3,4,5}

不可变集合

>>>set1 = frozenset({1,2,3,4,5})
>>>set1.add(6)
error #报错，因为集合属于frozen(冰冻的)，所以是不可变的

三、函数

1、基本知识

举例（1）

def a():
    ...
    return 123

a是函数的名称，其中也可以用 中文 作为函数的名称
. . . 里的内容称为函数体，函数体里面有函数的内容，也可以有函数文档（后面讲）
return 即代表函数的结束，后面可以接任何东西

举例（2）

def 多参数(x,y):
	return x[0]*x[1] - y[0]*y[1]

input:多参数((3,4)(1,2))

output:10

多参数(x,y)里的是形参，多参数((3,4)(1,2))里的是实参

举例（3）

def hello():
	"""打印你好
	就是楼下的hello！"""
	
	print("Hello!")

input: hello()

output: Hello!

input: print(hello())

output: Hello!
		None

用三个引号围起来的是函数文档
自定义函数时可以不加 return 值
用 print 打印此函数会返回函数内容和 None 是因为print有个特性：打印没有 return 值的函数时会多返回一个None

举例（4）

def a():
	'''我的梦想是
	世界和平'''
	return

input: print(a.__doc__)

output: a():
			我的梦想是
			世界和平

input: help(a)

output: 我的梦想是
				世界和平

return 值也可以什么都没有
这两种方式都是查看函数文档，区别在于第一种多打印了函数名称，第二种的下面多了一个缩进符号

2、关于参数

One、默认参数和关键字参数

def a(name, age = 18, tall = 175)：
	return (name, age, tall)

output:a('CourserLi') 

input: ('CourserLi', 18, 175)

output: a('CourserLi', 19) 

input: ('CourserLi', 19, 175)

output: a('CourserLi', tall = 185, age = 19) #可以不按照定义时的顺序

input: ('CourserLi', 19, 185)

此函数的 name 是位置参数，age 和 tall 是关键字参数（即默认参数）
定义参数时位置参数一定要在关键字参数前面
当只输入位置参数时，关键字参数会默认输出
当按顺序输入关键字参数时，关键字参数值会随之而变
当按关键字参数输入时，关键字参数值会随之而变（注意位置参数一定要在关键字参数前面）

Two、收集参数

之前讲过字典的打包与解包，这次讲讲元组的

def test(*params, extra):
	print("收集的参数是:", params)
	print("位置参数:", extra)

input: test(1,2,3,4,5)

output: error #报错

input: test(1,2,3,4, extra = 5)

output: 收集的参数是:(1,2,3,4)
		位置参数:5

要收集参数只需要在定义时为参数加个 * 号

在形参中 * 号是打包（pack）成元组，而在实参中是解包（unpack） 如：

tuple1 = (1,2,3,4,5)
str1 = "12345"
list1 = [1,2,3,4,5]

print(*tuple1);print(*str1);print(*list1)

output: 1 2 3 4 5
		1 2 3 4 5
		1 2 3 4 5

3、局部变量和作用域

在代码片中复习

b = 3 #全局变量
def a():
	b = 12 #局部变量
	return b #返回局部变量

input:print(b)

output:13 #打印全局变量

input:print(a())

output: 12 #打印局部变量
		None #print的特性

虽然全局变量和局部变量同名（python允许），但是它们的作用域不一样，全局变量位于全局作用域，而局部变量位于局部作用域，当程序进入局部作用域并遇到与全局变量同名的局部变量时，会自动屏蔽全局变量，称为 shadowing

若要在局部函数里修改全局变量的值，则用 global 关键字，用法如下：

b = 3 
def a():
	global b
	b = 12 
	return b 

input:print(b)

output: 3

input:a()

output:12 

input:print(b)

output:12 #全局变量发生改变

global 关键字的作用：使局部函数具有改变全局变量的权限。一旦使用，全局变量的值就会随之发生改变

类似的，还可以建立内联函数，即函数里有函数

def fun(): #外部函数
	temp = 2 #外部变量
	def a(): #内部函数
		temp = 13 #内部变量
		print(temp)
		return "Hello!"
	print(temp)
	return a() #返回内部函数

input:fun()

output: 2 #打印外部函数
		13 #打印内部变量
		Hello! #返回内部函数 return 值

同理，内部变量位于内部作用域（即内部函数里），外部变量位于外部作用域（即外部函数里），但都属于局部变量

小总结：

一、外部变量可访问全局变量，但全局变量不可访问外部变量
二、内部变量和全局变量互相都不可访问
三、内部函数可访问外部函数，但外部函数不可访问内部函数

既然可以用 global 关键字在局部函数里修改全局变量的值，那么是否有关键字能在内部函数改变外部函数的变量的值（注意不是修改全局变量的值）呢？当然有，就是 nonlocal 关键字，且用法和 global 关键字是一样的，所以我就不详细说明了

补充：如果在一个内部函数里对在外部作用域的变量(外部变量)进行引用，则这个内部函数就是一个闭包，故a（）函数就是一个闭包

那么除了 nonlocal 关键字还有说明办法能实现闭包呢？也有，利用的是堆栈的原理（了解就行

def fun():
	x = [5] #将数字 5 放入X列表中
	def a():
		x[0] = x[0] + 1 #X列表中的第一个元素的值（就是 5）加一
		return x[0] #返回X列表中的第一个元素的值
	return a()
	
input:fun()

output:6

这是因为容器类型（列表）不是属于栈里的，而在栈里的变量才会被屏蔽，所以 x 不会被屏蔽

那么如何调用含参数的内联函数呢？如下：

def fun(x):
	def a(y):
		return (x * y)
	return a #记住要返回内部函数名

input:fun(2)(3)

output:6


input:temp = fun(3)
	  temp(2)
	  
output:6

这两种写法都可以（其实性质都一样

4、装饰器：@语法糖

5、函数式编程

lambda

这是函数
def g(x):
	return 2 * x + 1
	
这是lambda #两种效果是一样的
g = lambda x : 2 * x + 1

>>>g(5) #调用 lambda
11

多参数
g = lambda x, y : x + y

>>>g(3, 4)
7

闭包
def g(x):
	return lambda : x * y

>>>g(2)(3)
6

filter（）
相当于一个过滤器，将 True 的筛选出来

函数原型
class filter(object)
filter(function or None,iterable) --> filter object

iterable就是可迭代的，可以是函数，也可以是 lambda 和其他

>>>temp = filter(None, [1, 0, False, True])
>>>list(temp)
[1, True]

>>>def odd(x):
	return x % 2
	
>>temp = filter(odd, range(10))
>>>list(temp)
[1, 3, 5, 7, 9]

>>>list(filter(lambda x : x % 2, range(10)))
[1, 3, 5, 7, 9]

map（）
在编程中，map被称为映射

函数原型
class map(object)
map(func,*iterable) --> map object

func 即 function（函数），就是将可迭代的参数作为函数的参数进行加工

>>>list(map(lambda x : x * 2, range(10)))
[0, 2, 4, 6, 8, 10]

多参数(迭代到较短的停止)
>>>list(map(lambda x, y : x + y, [1, 3, 5],[2, 4, 6, 8]))
[3, 9, 11]

6、递归

因为我在C语言有关函数的概念（2）已经写过递归了，因此我就不重复写进来了，我就写一些python专有的知识点

1、python3.8默认最大递归深度

def a():
	return a()

>>> a()

output

Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    a()
  File "<pyshell#2>", line 2, in a
    return a()
  File "<pyshell#2>", line 2, in a
    return a()
  File "<pyshell#2>", line 2, in a
    return a()
  [Previous line repeated 1022 more times]
RecursionError: maximum recursion depth exceeded

倒数第二句话意思是上一行重复1022次，因此最大递归深度为1026层

2、设置递归深度

>>> import sys
>>> sys.setrecursionlimit(10000)

意为设置最大递归深度为10000层

3、递归相比迭代效率低下，因此不建议使用

结束语●﹏●

我是（新手 + 弱鸡），因此在写的过程中可能也有些疏忽，若你们在阅读的过程中发现了什么问题，或者想补充些知识点，也请大家在评论区里面留言斧正,互相交流学习，我不胜感激~