集合
集合：把不同的元素组成一起形成集合，是python基本的数据类型。
集合元素:组成集合的成员。
>>> x = [11,22,33,11]
>>> se = set(x)
>>> se
{33, 11, 22}
集合对象是一组无序排列的不重复的值。
创建集合
字符串，数字，列表和字典都可以作为集合中的元素，当用字典作为集合中的元素时，默认取字典中的Key作为集合中的元素。
1 >>> x = ()
2 >>> li = ['a','b','c']
3 >>> x = (li)
4 >>> x
5 ['a', 'b', 'c']
6 >>> x = set('abcdefg')
7 >>> x
8 {'a', 'g', 'c', 'f', 'b', 'd', 'e'}
9 >>> li = [11,22,33,44,55]
10 >>> y = set(li)
11 >>> y
12 {33, 11, 44, 22, 55}
13 >>> dict = {
14 ... 'cpu':12,
15 ... 'mem':16,
16 ... 'disk':'3.0T',
17 ... 'U位':'15'
18 ... }
19 >>> set(dict)
20 {'disk', 'cpu', 'mem', 'U位'}
集合本身是无序的，所以不能为集合创建索引或切片，只能循环遍历或使用in、not in来访问或判断集合元素
s.add()
s.update()
s.remove()
s.clear()
s1.intersection(s2) s1和s2的交集
>>> s1 = {11,22,33}
>>> s2 = {22,33,44}
>>> s1.intersection(s2)
{33, 22}
s1.difference(s2) s1中存在s2中不存在
>>> s1.difference(s2)
{11}
例：
现在字典1和字典2如下，要求用字典2去更新字典1，如果字典2中没有的key则在字典1中删除，字典2中有字典1中没有的key则在字典1中建立相应的key.
dict_1 = {
'cpu':16,
'mem':8,
'disk':'1.8T',
'U位':'25'
}
dict_2 = {
'cpu':12,
'mem':16,
'disk':'3.0T',
'U位':'15'
}
s1 = set(dict_1.keys())
s2 = set(dict_2.keys())
remove_key = s1.difference(s2)
add_key = s2.difference(s1)
update_key = s1.intersection(s2)
for i in remove_key:
del dict_1[i]
for i in add_key:
dict_1[i] = dict_2[i]
for i in update_key:
if dict_1[i] == dict_2[i]:
pass
else:
dict_1[i] = dict_2[i]
>>> dict_1 #字典更新完成
{'U位': '15', 'disk': '3.0T', 'cpu': 12, 'mem': 16}
函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
以下为一个最简单的函数，每次调用都会打印"this is a test"
def name ():
print('this is a test')
return
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
以下为一个函数最简单的调用方法：
def name ():
print('this is a test')
return
name()
this is a test
函数参数的传递：
1、普通参数（严格按照顺序，将实际参数赋值给形式参数）
2、默认参数（必须放置在参数列表的最后）
3、指定参数（将实际参数赋值给制定的形式参数）
4、动态参数：
* 默认将传入的参数，全部放置在元组中
** 默认将传入的参数，全部放置在字典中，以key,value的方式显示
5、万能参数, *args,**kwargs
以下为各种传入参数的具体方法：
def test1(x,y):
print(x,y)
test1(10,20)
10 20
def test2(*args):
print(args)
test2([1,2,3,4,5])
([1, 2, 3, 4, 5],) #默认会将传入的参数作为一个元组
def test2(**args):
print(args)
test2(name='yang',age=18)
{'name': 'yang', 'age': 18}
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
name = 'yang'
def test():
name = 'zheng'
age = 28
test()
print(name)
yang
def test2():
global name
name = 'zheng'
age = 28
test2()
print(name)
zheng
在上面的例子中，首先定义了name = 'yang',然后在函数内部重新定义了这个变量，可以看到在函数外部这个变量的值并未改变，而在下面的例子中，用了global声明，此时定义的变量可以在全局范围内使用。
lambda表达式和列表解析
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
def number (x): return x + 1 #普通方式定义函数 print(number(123)) 124 lambda_1 = lambda x: x+1 print(lambda_1(123)) #以lambda表达式方式定义函数 124
内置函数
map
遍历序列，对序列中每个元素进行操作，最终获得一个新的序列。
li = [11,22,33] lst = map(lambda x: x+1,li) print(list(lst)) >>>[12, 23, 34] #对列表中每个元素都加1
li_1 = [11,22,33] li_2 = [44,55,66] li_3 = map(lambda a,b: a+b,li_1,li_2) #用li_1中第一个元素加上li_2中第一个，第二个加第二个，依次相加 print(list(li_3)) >>>[55, 77, 99]
filter
对序列中的元素进行过滤，最终用符合要求的元素再组成一个新的序列。
li = [11, 22, 33] lst = filter(lambda x: x > 22, li) print(list(lst)) >>>[33]
当然，你也可以用列表解析的方法完成上述要求。
li = [11,22,33] lst = [x+1 for x in li] #加1 print(lst) >>>[12, 23, 34]
li_1 = [11,22,33] li_2 = [44,55,66] lst = [(a+b) for a in li_1 for b in li_2 if li_1.index(a) == li_2.index(b) ] #对应相加 print(lst) >>>[55, 77, 99]
li = [11,22,33] lst = [x for x in li if x > 22] #筛选出大于22的 print(lst) >>>[33]