一、列表的常用操作及內建方法

1、用途：按照索引存放多個任意型別的值，索引反映的是位置/順序

2、定義方式：在[]內用逗號分割開多個任意型別的元素
#資料型別轉換

res=list("hello")3['h', 'e', 'l', 'l', 'o']
# res=list({"k1":1,"k2":2,"k3":3})3['k1', 'k2', 'k3']
print(res)

3、常用操作+內建的方法

===============3.1 優先掌握的操作===============

1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值

2、切片(顧頭不顧尾，步長)

　　2.1 淺copy：
 
　　

l1 = [11,22,[66,77]]
l2=l1.copy()
print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l2[0]),id(l2[1]),id(l2[2]))#與上一橫id相同

　　2.2deepcopy:

l1 = [11,22,[66,77]]
from copy import deepcopy#深拷貝要引用的模組
l3=deepcopy(l1)
print(id(l3[0]),id(l3[1]),id(l3[2]))

l1[2][0]=6666
print(l1)
print(l3)

# 瞭解：

res=l1[-1:-4:-1]
res
 
=l1[::-1]
print(res)#步長與切片方向都要一致

3、長度

l1 = [11,22,[66,77]]
print(len(l1))

4、成員運算in和not in

l1 = [111,22,[66,77]]
print([66,77] in l1)#[66,77]是個整體
print(66 in l1)
print(66 not in l1)

5、追加append

l1=[11,222]
l1.append(33)
l1.append(44)
l1.append([55,66])
print(l1)

6、insert插入

l1 = [111,22,[66,77]]
l1.insert(
 
1,"aaa")#在索引1的前面插入'aaa'
print(l1)#[11, 'aaa', 22, [66, 77]]

7、刪除

l1=[11,222,[1,2]]
#6.1 萬能刪除，沒有返回值，代表的是單純的刪除
# del l1[0]
# print(l1)

#6.2 指定元素刪除,沒有返回值，代表的是單純的刪除
# res=l1.remove([1,2])
# print(l1)
# print(res)

#6.3 指定索引刪除，有返回值，代表的是取走操作
# res=l1.pop(1)
# print(l1)
# print(res)

8、迴圈

l1=[11,222,[1,2]]
for x in l1:
    print(x)

===============3.2 需要掌握的操作===============
1、clear

l1.clear()

2、append extend

extend內建for迴圈，而append沒有

l2=[444,555]
for item in l2:
    l1.append(item)
print(l1)#[11, 22, 333, 333, 333, 444, 555]
l1.extend(l2)
print(l1)#[11, 22, 333, 333, 333, 444, 555, 444, 555]
l1.extend("hello")#[11, 22, 333, 333, 333, 444, 555, 444, 555, 'h', 'e', 'l', 'l', 'o']
print(l1)

3、count

l1=[11,22,333,333,333,]
print(l1.count(333333333))#0計數為0
print(l1.count(22))  #1計數為1

4、index

l1=[11,22,333,333,333,]
# res=l1.index(333,0,2)#查詢不到報錯
# res=l1.index(444)#查詢不到報錯
print(res)

5、reverse

l1=[11,22,"aaa",'bbb']
l1.reverse()
# l1=l1[::-1]#也可以反轉
print(l1)#['bbb', 'aaa', 22, 11]

6、sort 排序，預設從小到大排，除非定義

l1 = [11, 22, "aaa", 'bbb']
l1 = [-3,99,12,-5,93]
l1.sort(reverse=True)
print(l1)

列表總結：

存多個值，有序，可變型別

二、元組的常用操作及內建方法

1、元組就是一個不可變的列表

2、用途: 按照索引存放多個任意型別的值，索引反應的是位置/順序
3、定義方式：在()內用逗號分隔開多個任意類下的值/元素

# 強調:當元組內只有一個元素時，必須加逗號

# 型別轉換

tuple(所有可以被for迴圈遍歷的型別)
#空元組  t=()
4、常用操作+內建的方法
=============優先掌握的操作=============

1、按索引取值(正向取+反向取)：只能取

2、切片(顧頭不顧尾，步長)

3、長度

4、成員運算in和not in

5、迴圈
============需要掌握的操作==============

元組總結：
存多個值，有序，不可變

三、字典的常用操作及內建方法

1、用途：按key:value的形式存放多個任意型別的value，key反映的是value的屬性

2、定義方式：在{}內用逗號分隔開多個key:value，其中value可以是任意型別，而key必須是不可變的型別，通常是字串型別

# 若 key重複，只保留一個

# 空字典 d={}

# 型別轉換

#列表轉換為字典
l=[("name","egon"),("age",18),["gender","male"]]
res=dict(l)
print(res)

d=dict(x=1,y=2,z=3)
print(d)

dic1={}.fromkeys(["name",'age',"gender"],None)

print(dic1)#{'name': None, 'age': None, 'gender': None}
dic2={}.fromkeys("hello",None)
print(dic2)#{'h': None, 'e': None, 'l': None, 'o': None}

 3、常用操作+內建的方法

============優先掌握的操作============

1、按key存取值：可存可取

d={'k1':111}#取
print(d['k1'])#111
d['k2']=222#存
print(d)#{'k1': 111, 'k2': 222}

2、長度len

d={'k1':111,'k2':222}
print(len(d))#2

3、成員運算in和not in  ====》說的是key

d={'k1':111,'k2':222}
print('k1' in d)#True
print(111 in d)#False

4、刪除

d={'k1':111,'k2':222}
#6.1 萬能刪除，沒有返回值，代表的是單純的刪除
# del d['k1']
# print(d)

#6.2 隨機刪,返回一個元組
# res=d.popitem()
# print(d)
# print(res)

#6.3 指定key刪除，有返回值，代表的是取走操作
# res=d.pop('k1')
# print(d)
# print(res)

5、鍵keys()，值values()，鍵值對items()

#python2中
"""
>>> d={'k1':111,'k2':222}
>>> d.keys()
['k2', 'k1']
>>> d.values()
[222, 111]
>>> d.items()
[('k2', 222), ('k1', 111)]
"""

6、迴圈

d={'k1':111,'k2':222}
for k in d:
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():
    print(k,v)

keys=[]
for k in d:
    keys.append(k)
print(keys)#['k1', 'k2']
print(d)#{'k1': 111, 'k2': 222}

7、

d={'k1':111,'k2':222}
keys=list(d.keys())
print(keys)#['k1', 'k2']

該型別總結：

存多個值，無序，可變型別