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

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