駿馬金龍——python語法基礎

python基礎

變量與運算

符號	//	%	**
意義	整除	整除取余	冪次方

數據種類

0. 序列

參考：python序列操作

序列（str、list、tuple)可以進行的操作：
通過索引取元素、切片操作、找出第一個元素的位置index()

可變序列（list)可以進行的操作：
**1) 刪除相關操作有del、remove()、pop()、clear()。
2）添加相關操作有append()、extend()、insert()、s *= n
3）拷貝序列copy()、反轉序列reverse()。
4) 注意：列表復制有三種

l0 = [1, 2, 3]
print("l0_:",l0)
l1 = l0
l2 = l0[:]
l4 = l0*4
print("l4_:",l4)
l3 = l0.copy()
l0.append(1000)
l1.append(0)
print("l0:",l0)
print("l1:",l1)
print("l2:",l2)
print("l3:",l3)
print("l4:",l4)

l0_: [1, 2, 3]
l4_: [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]
l0: [1, 2, 3, 1000, 0]
l1: [1, 2, 3, 1000, 0]
l2: [1, 2, 3]
l3: [1, 2, 3]
l4: [[1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0]]
可見：因為可變序列引用的是地址，直接通過賦值的方式進行復制，只是將地址復制了，沒有真正地重新分配另一塊新的地址進行存放，所有當l0和l1任何一方進行改變的時候，都會導致地址的內容發生改變，因此l0和l1會發生改變，而l2,l3是通過copy等方式進行的深層復制，直接分配了一個新的地址進行存儲，因此不會隨l0改變而改變
l4是對列表進行復制，這樣引用的是地址嗎，導致后面也會出現隨動現象

不可變序列（tuple、str)可以進行的操作：
**hash(哈希映射操作)：就是根據一定的規則將不可變的序列映射成另一個形式，可以簡單地理解為y = f(x)的形式，最常見的是將不可變序列hash成十進制的數字，一般映射關系是一一對應的

>>> hash("asd")
-2014632507>>> hash((1,23))
1320437575>>> hash([1,23])
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

能夠hash的不可變序列，意味著能作為dict的key，能保存到set或frozenset中

1. 列表

# ----------------------列表的創建------------------
l1 = list()
l2 = []
print("l1:",l1)
print("l2:",l2)

1). 添加元素：append()、extend()、insert()

append()、extend()——前者是將整個添加的對象作為一個整體添加而后者則是將可迭代對象的內層每一個元素單個添加

# ----------------------列表元素的添加---------------------
## 直接在列表最后面進行元素的添加,append,extend
for i in range(10):l1.append(i)l2.append(i+2)
print("l1:",l1)
print("l2:",l2)
l1.extend(l2)
print(l1)## 根據索引將元素插入到指定的位置，列表自動延長，該位置及以后的原來元素向后挪位置
l1 = [1,2,3]
print("插入前：",l1)
l1.insert(1,["插入的元素"])
print("插入后：",l1)

2). 刪除元素：remove()、pop()、del

# -----------------刪除元素------------#
# 直接在列表末尾刪除元素,
popl1 = [1,2,3]
l1.pop()
print(l1)
## 直接移除指定的元素,remove,若要移除的元素不存在報錯
l1 = [1,2,3
l1.remove(2)
print(l1)
del l1[1]

3). 其他操作：reverse()、index()、count()等

# ----------------其他-----------------
## 合并
print(l1 + l2)
## 查找第一個元素的索引
print(l1.index(1))
## 反轉
print(l1.reverse())
## 計數
print(l1.count(1))

注意：

2、字典——{key:value}形式的非序列容器無序數據結構

字典是無序的，和集合一樣，根據索引得到的元素和添加元素的順序是沒有關系的
> 如上圖所示，字典是一個通過鍵值對進行元素的存放的一個數據結構，key代表元素的唯一標簽。對于字典的操作都是先對key進行hash,然后根據hash值（可以理解為地址）去得到key和value的指針，如：
1）存放字典元素：根據key得到hash值，若hash值對應的指向value的指針不存在，則新創建key-value鍵值對，若存在，則將value值覆蓋為最新的值

1)創建字典

dict1 = {"1":"1","2":2,"3":3}
dict2 = dict(one=1,two=2,three=3)
dict3 = dict([('one',1),("two",2)])
dict4 = dict(zip(("one","two","three"),(1,2,3)))

{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘one’: 1, ‘two’: 2, ‘three’: 3}
{‘one’: 1, ‘two’: 2}
{‘one’: 1, ‘two’: 2, ‘three’: 3}

在python中，能hashable的數據類型都必須是不可變類型的，所以列表、集合、字典不能作為dict的key，字符串、數值、元組都可以作為dict的key(類的對象實例也可以，因為自定義類的對象默認是不可變的)。

2)初始化字典

dict.fromkeys（序列，默認的字典值）

dict5 = dict.fromkeys("abcd,",2)

3）字典的拷貝

# ------------字典的拷貝--------------------
dict6 = dict1.copy() # 淺拷貝，只是將每一個key的地址給到了新字典
print(dict1)
print(dict6)
print(id(dict1["1"]))
print(id(dict6["1"]))dict6["1"] = 4 # 但是在一個拷貝的字典中發生值的改變值，會為這個鍵新開辟一個地址用于存儲新的值
print(dict1)
print(dict6)
print(id(dict1["1"]))
print(id(dict6["1"]))
print(id(dict1["2"]))
print(id(dict6["2"]))

{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
1508279661712
1508279661712
{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘1’: 4, ‘2’: 2, ‘3’: 3}
1508279661712
140712196691072
140712196691008
140712196691008

4）增刪改查

# --------------------字典的增刪改查-------------------------
## 查詢,根據key查找，不存在時會報錯，可以通過重寫字典類的__missing__方法來實現返回None
dict7 = {"1":"1","2":2,"3":3}
value = dict7["1"]
## 更新
dict7.update({"1":2,"4":5})
dict7["5"] = 6
## pop類
print(dict7.pop("1"))
print(dict7.popitem()) #按照 LIFO（Last In First Out 后進先出法
## 刪除
dict7.update({"1":2,"4":5})
dict7["5"] = 6
del dict7["5"]
dict7.clear()

5）獲得key,value和鍵值對

#--------------------獲得字典key，value，鍵值對,若想對其進行迭代取值，需要利用list進行解析dict8 = {"1":"1","2":2,"3":3}
print(dict8.keys())
print(list(dict8.keys()))
print(dict8.values())
print(dict8.items())
print(iter(dict8))

dict_keys([‘1’, ‘2’, ‘3’])
[‘1’, ‘2’, ‘3’]
dict_values([‘1’, 2, 3])
dict_items([(‘1’, ‘1’), (‘2’, 2), (‘3’, 3)])
<dict_keyiterator object at 0x0000015F2C7BD908>

3、集合set——無value版本的字典

無序、元素不重復、元素可變

1）創建

#創建
set1 = set()
set2 = {1,2,3}

2）集合運算

# 集合運算
set3 = {1,2,3}
set4 = {3,4,5,6}
## 交集
interset = set3&set4
interset2 = set3.intersection(set4)
print(interset)
print(interset2)
## 并集
union1  =set3|set4
union2 = set3.union(set4)
print(union1)
print(union2)
## 差集
diff1 = set3-set4
diff2 = set3.difference(set4)
print(diff1)
print(diff2)
diff3 = set4-set3
diff4 = set4.difference(set3)
print(diff3)
print(diff4)
## XOR集合，非相交部分
xor1 = set3^set4
xor2 = set3.symmetric_difference(set4)
print(xor1)
print(xor2)

{3}
{3}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{1, 2}
{1, 2}
{4, 5, 6}
{4, 5, 6}
{1, 2, 4, 5, 6}
{1, 2, 4, 5, 6}

3）其他操作

set5 = {1,2,3,4,5}
print(set5)
set5.add(6)
print(set5)
set5.remove(6)
print(set5)
set5.pop()
print(set5)
set5.clear()
print(set5)

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5}
{2, 3, 4, 5}
set()

數據類型總結

數據類型	元素支持類型	元素可變性	元素有序性	查找元素的方法
字符串	字符	不可變	有序	根據下標索引
列表	所有數據類型	可變	有序	根據下標索引
字典	鍵(key)：不可變數據類型(tuple、str、字符、數值類型等)、可hash的數據類型；值(value):所有數據類型即可	可變	無序	根據鍵key查找
集合	所有數據類型（元素不重復）	可變	無序	/
元組	所有數據類型	不可變	有序	根據下標索引