Python-Day8
set 集合
list ---> 允许重复的集合，可以修改，有序
tuple ---> 允许重复的集合，不可修改，有序
dic ---> 允许重复的集合，可以修改，无序
set ---> 不允许重复， 无序
1. 创建
1. s = set() #创建空集合时使用这种方式
>>> l = [11,22,33,44,33,22,11,]
>>> s = set(l)
>>> s
{33, 11, 44, 22}
>>>
2. s = {11,22,33,44} #直接创建，若s={} 会被当作字典类型
2. 常用方法
s.add(33) ---> 添加元素
s.clear() ---> 清空集合
ret = a.difference(b) ---> 返回 a 存在 b 不存在的元素组成的集合赋给 ret
a.difference(b) ---> 返回 a 存在 b 不存在的元素组成的集合赋给 a , 即更新自己
s.discard(33) ---> 移除指定元素，若该元素不存在，不报错
s.remove(33) ---> 移除指定元素，若该元素不存在，报错
ret = a.intersection(b) ---> 取交集，赋给 ret
a.intersection_update(b) ---> 取交集，赋给 a, 即更新 a
ret = a.isdisjoint(b) ---> 没有交集返回True
ret = a.issubset(b) ---> a是b的子序列返回True
ret = a.issuperset(b) ---> a是b的父序列返回True
ret = a.pop() ---> 随机移除元素到ret中
ret = a.symmetric_difference(b) ---> 取对称差集到ret中（即a中有的且b中没有的 + b中有的a中没有的）
a.symmetric_difference_update(b) ---> 取对称差集更新到a中（即a中有的且b中没有的 + b中有的a中没有的）
ret = a.union(b) ---> 返回 a b 的并集到ret中
a.update(b) ---> 将b合并到a中
三元运算符
ret = value1 if condition else value2 -----> 如果condition为真，ret = value1, 否则=value2
内存中的表示
str ---> 一次性创建，不可被修改，若要修改只会产生一个新的
list ---> 类似 C语言 中的链表结构
深浅拷贝
******对 int str 来说，无论深拷贝 浅拷贝 赋值， 地址都是一样的******
赋值：
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1
浅拷贝：只拷贝最外面一层
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
深拷贝：除 int str 外都拷贝
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = copy.deepcopy(n1)
函数
定义函数，解释器会将函数放在内存中并不执行，之后调用函数的时候才执行该函数。
def function_name(form_parameters1, f_p2, ...):
function_body...
................
return anything
调用的时候可以按默认形参顺序赋以实参，也可以注明 函数名（形参2 = 实参2，形参1 = 实参1）不按顺序来 指定参数
默认参数 放在形参列表的后面
动态参数
*args 默认元组类型
def fff(*a):
print(a, type(a))
fff(111,222,333,444,555,[111,222],'huad')
#>>>>>>>>>>>>>>>按顺序
(111, 222, 333, 444, 555, [111, 222], 'huad') <class 'tuple'>
**kwargs 默认字典类型
def fff(**a):
print(a, type(a))
fff(k1 = 'v1', k2 = 'v2', k3 = 222, k4 = [11,22,33])
#>>>>>>>>>>>>无序
{'k3': 222, 'k4': [11, 22, 33], 'k1': 'v1', 'k2': 'v2'} <class 'dict'>
都包含时 *args 一定在 **kwargs 前面，最前面可以有其他形参
def fff(c, *a, **b):
print(c, type(c))
print(a, type(a))
print(b, type(b))
fff(11,22,33, k1=11,k2=22)
#>>>>>>>>>>>
11 <class 'int'>
(22, 33) <class 'tuple'>
{'k1': 11, 'k2': 22} <class 'dict'>
为动态参数传入 列表 元组 字典
实参前面 带有* 不带* 的区别
def fff(*args):
print(args, type(args))
li = [11, 22, 33, 44]
fff(li)
fff(*li)
#>>>>>>>>
([11, 22, 33, 44],) <class 'tuple'>
(11, 22, 33, 44) <class 'tuple'>
def fff(**kwargs):
print(kwargs, type(kwargs))
dic = {'k1': 'v1'}
# fff(dic) #报错
# fff(*dic) #报错
fff(**dic)
#>>>>>>>>>>>>
{'k1': 'v1'} <class 'dict'>
全局变量 局部变量
全局变量可以被局部读取，但不能修改，若要修改前面加 globle XXX
PPP = 'hello' #全局变量
def fun1():
a = 123 #局部变量
global PPP #若没有这句，表示新建了一个局部变量,输出为hello
PPP = 'world'
print(a)
def fun2():
b = 456
print(PPP)
print(b)
fun1()
fun2()
#>>>>>>>>>>>>>>
123
world
456
书写时，让 全局变量 都大写，局部变量 都小写
