复习
1.python：解释性语言、可移植性、floss（免费开源）、面向对象、丰富的库。
2.eval()与exec()
eval()计算指定表达式的值。也就是说它要执行的python代码只能是单个表达式（注意eval不支持任何形式的赋值操作），而不能是复杂的代码逻辑。
exec()动态执行python代码。也就是说exec可以执行复杂的python代码，而不像eval函数那样只能计算一个表达式的值。
eval()函数和exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
eval()如下：
x = 10
def func():
y = 20 #局部变量y
a = eval("x+y")
print("a:",a) #x没有就调用全局变量
b = eval("x+y",{"x":1,"y":2}) #定义局部变量，优先调用
print("b:",b)
d = eval("print(x,y)")
print("d:",d) #对于变量d，因为print()函数不是一个计算表达式，因此没有返回值
func()
输出结果：
a: 30 b: 3 10 20 d: None
exec() 1.借用如上函数:
x = 10
def func():
y = 20
a = exec("x+y")
print("a:",a)
b = exec("x+y",{"x":1,"y":2})
print("b:",b)
d = exec("print(x,y)")
print("d:",d)
func()
输出结果：
#exec不会有任何返回值 a: None b: None 10 20 d: None
例2：
x = 10
expr = """
z = 30
sum = x + y + z #一大包代码
print(sum)
"""
def func():
y = 20
exec(expr) 10+20+30
exec(expr,{'x':1,'y':2}) 30+1+2
exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是定义全局变量1，y是局部变量
func()
输出结果：
60 33 34
3.list set dictionary tuple
1).list 列表 []
切片 [a:b:c] a.起始位置 b.终止位置（不包括b） c.步长（可正可负）
列表使用下标来寻找，截取，修改列表值
替换一个集合片段如下：
mm=[1,2,3,4,5,6,7,8,9] mm[2:7]=[9,99,999] print(mm)
输出：
[1, 2, 9, 99, 999, 8, 9]
2).set 集合{}
具有无序，唯一性的特点。集合使用set()来创造一个集合
&交集 |并集 -差集 ^对称差集（即并集-差集）
3).dictionary 字典{key:value}
.keys 字典中的所有key .value 字典中所有value .items字典中所有key与value组成元组形式
del 删除字典中某个元素
clear() 清空字典
4).tuple 元组 (,)
当一个元组中只有一个值时，一定要在其后加逗号！
元组不可以被修改。
4.zip() map()
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a = [1,2,3] b = [4,5,6] c = [4,5,6,7,8] zipped = zip(a,b) # 打包为元组的列表 #输出[(1, 4), (2, 5), (3, 6)] zip(a,c) # 元素个数与最短的列表一致 #输出[(1, 4), (2, 5), (3, 6)] zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式 #输出[(1, 2, 3), (4, 5, 6)]map()
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
def square(x) : # 计算平方数
return x ** 2
map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
#输出 [1, 4, 9, 16, 25]
map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
#输出[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
#输出[3, 7, 11, 15, 19]
5)函数与方法
#函数:独立定义和调用 （例如一个def函数 或者map()）
#方法:依赖定义的和调用 （例如类方法 ）
class Tst:
name = 'tst'
data = 'this is data'
# 普通方法
def normalMethod(self, name):
print(self.data, name)
# 类方法,可以访问类属性
@classmethod
def classMethod(cls, name):
print (cls.data, name)
# 静态方法,不可以访问类属性
@staticmethod
def staticMethod(name):
print (name)
tst = Tst()
tst.data = 'this is new'
tst.normalMethod('name')
tst.staticMethod('name')
tst.classMethod('name')
输出结果如下：
this is new name name this is data name类方法可以访问类属性，所以classMethod 输出结果为类属性定义的结果‘this is data’
静态方法不访问类属性，所以没有访问类定义的（name=tst），直接输出了'name'。