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

　　書寫時，讓 全局變量 都大寫，局部變量 都小寫