简介：此文是接着（萌新笔记）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、递归相比迭代效率低下，因此不建议使用

结束语●﹏●

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