Python-2
元组 tuple
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一但元组生成， 则它不可以改变
元组的表示方式
用小括号()括起来，单个元素括起来用逗号(,)区分是单个对象还是元组
创建空元组的字符值
t = ()
创建非空元组的字面值
t = 200,
t = (20,)
t = (1,2,3)
t = 100, 200, 300
元组的构造函数 tuple
tuple() 生成一个空的元组，等同于()
tuple(iterable) 用可迭代对象生成一个元组
示例:
t = tuple()
t = tuple(range(10))
t = tuple('hello')
t = tuple([1,2,3,4])
元组的算术运算:
- += * *=
用法与列表的用法完全相同
元组的比较运算:
< <= > >= == !=
规则与列表完全相同
三个构造函数:
str(obj)
list(iterable)
tuple(iterable)
用于创建相应的对象
其它函数:
reversed(seq) 返回反向顺序的可迭代对象
sorted(iterable, reversed=False) 返回已排序的列表
示例:
for x in reversed("ABCD"):
print(x) # D C B A
L = [8, 6, 3, 5, 7]
L2 = sorted(L)
print(L2) # [3, 5, 6, 7, 8]
L3 = sorted(L, reversed=True)
print(L3) # [8, 7, 6, 5, 3]
print(L) # 保持不变
字典 dict
1. 字典是一种可变的容器，可以存储任意类型的数据
2. 字典中的每个数据都是用'键'(key) 进行索引，而不像序列可以用下标来进行索引
3. 字典的数据没有先后顺序关系，字典的存储是无序的
4. 字典中的数据以键(key)-值(value)对进行映射存储
5. 字典的键不能重复，且只能用不可变类型作为字典的键。
字典的字面值表示方式:
用 {} 括起来，以冒号(😃 分隔键-值对, 各键值对用分号分隔开
创建空字典
d = {}
创建非空的字典:
d = {'name': 'tarena', 'age': 15}
d = {'姓名': '小张'}
d = {1:'壹', 2:'贰'}
字典的构造函数 dict
dict() 创建一个空字典,等同于 {}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 关键字传参形式生成一个字典
示例:
d = dict()
d = dict([('name', 'tarena'), ('age',15)])
d = dict(name='tarena', age=15)
不可变类型
int,float,complex,bool,str,tuple,frozenset(固定集合), bytes(字节串)(后面会讲)
可变类型:
list, dict, set(集合), bytearray(字节数组)
字典的键索引
用[] 运算符可以获取字典内'键'所对应的'值'
语法:
字典[键]
获取数据元素
d = dict(name='tarena', age=15)
print(d['age']) # 15
添加/修改字典元素
字典[键] = 表达式
示例:
d = {}
d['name'] = 'tarena' # 创建一个新的键值对
d['age'] = 15 # 创建键值对
d['age'] = 16 # 修改键值对
del 语句删除字典的元素
语法:
del 字典[键]
示例:
d = {'name': 'china', 'pos': 'asia'}
del d['pos']
print(d)
del d['name']
print(d) # {}
字典推导式
字典推导式是用可迭代对象依次生成字典内元素的表达式
语法：
{键表达式 : 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注: []的内容代表可省略
示例:
d = {x : x**2 for x in range(10)}
集合 set
集合是可变的容器
集合内的数据对象是唯一的（不能重复多次的)
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代的
集合是相当于只有键没有值的字典(键则是集合的数据)
创建空的集合
s = set() # set() 创建一个空的集合
创建非空集合
s = {1, 2, 3} # 集合中的三个整数1,2,3
集合的构造函数 set
set() 创建空集合
set(iterable) 用可迭代对象创建一个新的集合对象
示例:
s = set("ABC")
s = set('ABCCBA')
s = set({1:"一", 2:'二', 5:'五'})
s = set([1, 3.14, False])
s = set((2,3,5,7))
# s = set([1, 2, [3.1, 3.2], 4]) # 错的[3.1, 3.2]是可变对象
集合的运算:
交集，并集，补集，子集，超集
& 生成两个集合的交集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2 # s3 = {2, 3}
| 生成两个集合的并集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2 # s3 = {1,2,3,4}
- 生成两个集合的补集
s1 = {1,2,3}
s2 = {2,3,4}
# 生成属于s1,但不属于s2的所有元素的集合
s3 = s1 - s2
^ 生成两个集合的对称补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 # s3 = {1, 4}
等同于 s3 = (s1 - s2) | (s2 -s1)
< 判断一个集合是另一个集合的子集
> 判断一个集合是另一个集合的超集
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True 判断子集
s1 > s2 # True 判断超集
== != 集合相同/不同
s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True
s1 != s2 # False # 集合的数据没有先后关系
固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用：
固定集合可以作为字典的键，也可以作为集合的值（元素)
创建空的固定集合
fs = frozenset()
创建非空的固定集合
fs = frozenset([2,3,5,7])
构造函数:
frozenset()
frozenset(可迭代对象) # 同set函数一致,返回固定集合
return 语句
语法:
return [表达式]
[] 代表可以省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个对象的 引用关系
python 函数的参数传递
传递方式
位置传递
序列传参
关键字传参
字典关键字传参
位置传参:
实际参数(实参)的对应关系与形式参数(形参)的对应关系是按位置来依次对应的
示意
def myfun(a, b, c):
pass
myfun(1, 2, 3)
说明:
实际参数和形式参数通过位置进行传递的匹配
实参个数必须与形参个数相同
序列传参:
序列传参是指在函数调用过程中，用 * 将序列拆解后按位置传参的方式进行参数传递
示例:
def myfun(a, b, c):
pass
s = [1, 2, 3]
myfun(s) # * 表示把s拆开
s2 = "ABC"
myfun(s2)
关键字传参:
关键字传参是指传参时，按着形参的名称给形参赋值
实参和形参按名称进行匹配
示例:
def myfun(a, b, c):
pass
myfun(b=22, c=33, a=11) # 等同于myfun(11,22,33)
myfun(c=3, b=2, a=1)
说明:
实参和形参可以不按位置匹配
字典关键字传参：
是指实参为字典，将字典用 ** 拆解后进行关键字传参
示例:
def myfun(a, b, c):
pass
d = {'c': 33, 'b': 22, 'a': 11}
myfun(**d) # 拆解字典后再传参
说明:
字典的键名和形参名必须一致
字典键名必须为字符串
字典的键名要在形参中存在
函数的综合传参
函数传参方式，在能确定形参能唯一匹配到相应实参的情况下可以任意组合
示例:
def myfun(a, b, c):
pass
myfun(100, [200, 300]) # 正确
myfun('AB', 300) # 正确
myfun(100, c=300, b=200) # 正确
myfun(1, {'c': 3, 'b': 2}) # 正确
myfun(, a=1) # 正确
myfun(b=2, c=3, 1) # 错误,不能确定1给谁?
说明:
传参时先位置传参，后关键字传参
函数的形参定义方式:
位置形参
星号元组形参
命名关键字形参
双星号字典形参
位置形参:
语法:
def 函数名(形参名1, 形参名2, ...):
语句块
星号元组形参:
语法
def 函数名(*元组形参名):
语句
作用：
收集多合的位置传参
说明:
元组形参名通常用: 'args'
命名关键字形参
语法:
def 函数名(*, 命名关键字形参):
语句
或
def 函数名(*args, 命名关键字形参):
语句
作用：
所有的参数都必须用关键字传参或字典关键字传参传递
双星号字典形参:
语法:
def 函数名(**字典形参名):
语句
作用：
收集多合的关键字传参
说明:
通常字典形参名定为: "kwargs"
函数的参数说明:
缺省参数，位置形参，星号元组形参，命名关键字形参和双号星字典形参可以混合使 用
函数参数自左至右的顺序为:
位置形参
星号元组形参
命名关键字形参
双星号字典形参
综合示例:
def f1(a, b, *args, c, **kwargs):
pass
f1(1, 2, 3, 4, d=6, c=5, e=7)
函数的不定长参数:
def fn(*args, **kwargs):
pass
# 可以接收任意的位置传参和关键字传参
全局变量和局部变量
局部变量:
定义在函数内部的变量称为局部变量(函数的形参也是局部变量)
局部变量只能在函数内部使用
局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁
全局变量
定义在函数外部，模块内部的变量称为全局变量
全局变量，所有的函数都可以直接访问（但函数内部不能将其直接赋值)
局部变量说明:
1. 在函数内首次对变量赋值是创建局部变量,再次为变量赋值是修改局部变量的绑定 关系
2. 在函数内部的赋值语句不会对全局变量造成影响
3. 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个模块范围内访问
globals 和 locals 函数
globals() 返回当前全局作用域内变量的字典
locals() 返回当前局部作用域内为量的字典
示例:
a = 1
b = 2
c = 3
def f1(c, d):
e = 300
print("locals()返回: ", locals())
print('globals()返回', globals())
f1(100, 200)
函数变量
函数名是变量，它在创建函数时绑定一个函数
示例:
def f1():
print("f1被调用")
fx = f1
fx() # 等同于 f1()
示例2:
def f1():
print("hello")
def f2():
print("world")
f1, f2 = f2, f1 # 交换两个变量的绑定关系
f1() # 请问打印结果是什么？ world?
一个函数可以作为另一个函数的参数传递
示例:
def f1():
print("hello")
def f2():
print('world')
def fx(fn):
print(fn)
fn() # 调用谁?
fx(f1) # 此语句在做什么？
fx(f2)
函数可以返回另一个函数(即:另一个函数可以返回一个函数)
函数嵌套定义
函数的嵌套定义是指一个函数里用def语句来创建其它的函数
示例:
def fn_outer():
print("fn_outer被调用!")
def fn_inner():
print("fn_inner被调用")
fn_inner()
fn_inner()
print('fn_outter调用结束')
fn_outer()
python的四个作用域 LEGB
局部作用域 Local function L
外部嵌套函数作用域 Enclosing Function Locals E
函数定义所在模块(文件)的作用域 Global(Mudule) G
python 内置模块的作用域 Builtin(python) B
变量名的查找规则
L --> E --> G --> B
在默认情况下，对变量名赋值会创建或改变本作用域内的变量
global语句
作用:
1.告诉解释器, global语句声明的一个或多个变量，这些变量的作用域为模块级的作用 域，也称作全局变量
2.全局声明(global)将赋值变量映身到模块文内部的作用域
语法
global 变量1, 变量2, ...
示例:
v = 100
def fn():
global v
v = 200
fn()
print(v) # 200
global说明
1. 全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是局部 变量)
2. 全局变量在函数内部不经过声明就可以直接访问
3. 不能先声明局部的变量，再用global声明为全局变量，此做法不附合规则
4. global 变量列表里的变量不能出现在此作用域内的形参列表里
nonlocal 语句
作用:
告诉解释器, nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函 数内的变量
语法:
nonlocal 变量名1, 变量名2, ...
nonlocal 说明
1. nonlocal语句只能在被嵌套函数内部进行使用
2. 访问nonlocal变量将对外部嵌套函数的作用域的变量进行操作
- 当有两层或两层以上的函数嵌套时，访问nonlocal变量只对最近一层的变量进行 操作
- nonlocal语句的变量列表里的变量名，不能出现在此函数的参数列表中
lambda 表达式(又称匿名函数)
作用:
创建一个匿名函数对象
同 def 类似，但不提供函数名
语法:
lambda [参数1, 参数2, ...]: 表达式
[] 里的内容可以省略
示例:
def myadd(x, y):
return x + y
# 以上函数可以改写为:
myadd = lambda x, y: x + y
print('2 + 3 =', myadd(2, 3))
语法说明:
1. lambda 只是一个表达式，它用来创建一个函数对象
2. 当lambda表达式调用时，先执行冒号后(:)的表达式，并返回表达式的结果的引用
3. lambda 表达式创建的函数只能包含一条"表达式"
4. lambda 比函数简单，且可以随时创建和销毁，有利于减少程序的偶合度
eval() 和 exec()函数
eval() 函数
格式:
eval(source, global=None, locals=None)
作用:
把一个字符串当成一个表达式来执行，返回表达式执行后的结果
示例:
x = 100
y = 200
a = eval('x+y')
print(a)
exec() 函数
作用:
把一个字符串当成程序来执行
格式:
exec(source, globals=None, locals=None)
示例:
x = 100
y = 200
s = 'z = x+y; print(z); del z; print("删除成功"'
exec(s) # 执行s绑定的语句
eval 和 exec的两个参数globals 和 locals
此两个参数是用来设置'表达式'或'程序'运行的全局变量和局部变量
示例:
x = 100
y = 200
s = 'print(x, y, x + y)'
exec(s) # 100 200, 300
exec(s, {'x': 10, 'y': 20}) # 10, 20, 30
exec(s, {'x': 10}, {'x': 1, 'y': 2}) # 1 2 3
exec(s, {'x': 10}, {'y': 2}) # 10 2 12
函数的可重入性:
可重入是指一个函数传的参数一定，则结果必须一定
要求:
def定义的函数不要访问除局部变量以外的变量
示例:
# 以下是不可重入的函数myadd
y = 200
def myadd(x):
return x + y
print(myadd(10)) # 210
y = 300
print(myadd(10)) # 310
# 以下是可重入的函数 myadd
def myadd(x, y):
return x + y
print(myadd(10, 20))
高阶函数 High Order Function
什么是高阶函数:
满足下列一个条件的函数即为高阶函数:
1. 函数接受一个或多个函数作为参数传入
2. 函数返回一个函数
python中内建（builtins)的高阶函数
map, filter, sorted
map函数:
map(func, *iterables) 用函数和对可迭代对象中的每一个元素作为参数计算出新的可迭 代对象，当最短的一个可迭代对象不再提供数据时，此可迭代对象生成结束
示例:
def pow2(x):
return x**2
for x in map(pow2, range(1, 10)):
print(x)
内建的pow(x, y, z=None)
# 生成 1 ** 4 , 2**3 , 3 ** 2, 4 ** 1
for x in map(pow, range(1, 10), range(4,0,-1)):
print(x)
for x in map(pow, [2,3,5,7],
[4,3,2,1], range(5, 10)):
print(x)
filter 函数
格式:
filter(func, iterable)
作用:
筛选可迭代对象iterable中的数据，返回一个可迭代对象，此可迭代对象将对iterable 进行筛选
说明:
函数func将对每个元素进行求值，返回False则将此数据丢弃，返回True则保留此数 据
示例:
def isodd(x): # 此函数判断x是否为奇数
return x % 2 == 1
for x in filter(isodd, range(10)):
print(x)
even = [x for x in
filter(lambda x: x%2==0, range(10))]
sorted 函数:
作用:
将原可迭代对象的数据进行排序，生成排序后的列表
格式:
sorted(iterable, key=None, reverse=False)
说明:
iterable 可迭代对象
key 函数是用来提供一个参考值，这个值将作为排序的依据
reverse 标志用来设置是否降序排序
示例:
L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L) # L2 = [-4, -2, 0, 1, 3, 5]
L2 = sorted(L, reverse=True)
L3 = sorted(L, key=abs) # L3 = [0, 1, -2, 3, -4, 5]
递归函数 recursion
函数直接或间接的调用自身
示例:
import time
def story():
# time.sleep(1)
print("从前有座山")
print("山上有座庙")
print('庙里有人老和尚讲故事:')
story() # 直接调用自身
stroy()
# 函数间接调用自身的递归
def fa():
fb()
def fb():
fa()
fa()
print("递归结束")
递归说明:
- 递归一定要控制递归的层数,当符合某一条件时要终止递归
- 几乎所有的递归都能用while循环来代替
控制递归层数的示例 ：
def fx(n):
print("递归进入第", n, "层")
if n == 3:
return
fx(n + 1)
print("递归退出第", n, '层')
fx(1)
print("程序结束")
递归的优缺点:
优点：
递归可以把问题简单化，让思路更为清晰，代码更简洁
缺点:
递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
递归函数的实现方法:
先假设函数已经实现
闭包 closure
将内嵌函数的语句和这些语句的执行环境打包在一起时，得到的对象称为闭包(closure)
闭包必须满足三个条件:
1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数返回值必须是内嵌函数
def make_power(y):
def fx(arg):
return arg ** y
return fx
pow2 = make_power(2)
print('3的平方是: ', pow2(3))
示例:
# 用 参数返回相应的数学函数的示例
# y = ax**2 + bx + c
def make_function(a, b, c):
def fx(x):
return ax**2 + bx + c
return fx
# 创建一个 y = 4x2 + 5x + 6 的函数用fx1绑定
fx1 = make_function(4, 5, 6)
print(fx1(2)) # 求在x等2时y的值
