python中day_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')

**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'}

都包含时 *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

(22, 33)

{'k1': 11, 'k2': 22}

为动态参数传入 列表 元组 字典

实参前面 带有* 不带* 的区别

def fff(*args):

print(args, type(args))

li = [11, 22, 33, 44]

fff(li)

fff(*li)

#>>>>>>>>

([11, 22, 33, 44],)

(11, 22, 33, 44)

def fff(**kwargs):

print(kwargs, type(kwargs))

dic = {'k1': 'v1'}

# fff(dic) #报错

# fff(*dic) #报错

fff(**dic)

#>>>>>>>>>>>>

{'k1': 'v1'}

全局变量 局部变量

全局变量可以被局部读取，但不能修改，若要修改前面加 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

书写时，让 全局变量 都大写，局部变量 都小写