• 引子

• 資料型別的基本使用及內建方法

• 列表型別

• 元祖

• 字典型別

資料型別的基本使用及內建方法

• 列表list的基本使用

• 1、用途：按照位置存放多個任意型別的值

• 2、定義方式：在[ ]內用逗號分隔開多個任意型別的值

 l = [11,11.33,"xxx",[11,22,33]]  # l = list(...)

 print(type(l))

# list資料型別轉換：把可迭代的型別轉成列表

# 可以被for迴圈遍歷的型別都是可迭代的

 res = list("hello")

 res = list({"k1":111,'K2':2222})

 print(res)

 print(list(range(1000)))
 

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

=》=》=》優先掌握的操作:(*****)

1、按索引存取值(正向存取+反向存取)：即可存也可以取

 l=[111,222,333]

 print(id(l))

 l[0]=666

 print(l)

 print(id(l))

 l=[111,222,333]

 l[0]=666

 l[3]=777  # 列表索引不能超出範圍

 l[3]  # 列表索引不能超出範圍

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

 l=[11,22,33,44,55,66,77,88,99]

 res=l[1:7:2]

 res=l[:]

 res=l[::-1]

 print(res)
 

3、長度

 print(len(["aaa",111,2222]))

4、成員運算in和not in

 print(111 in ["aaa",111,2222])

5、追加

 l=[111,222,333]
 l.append(444)
 l.append(555)
  print(l)

## 插入

 l=[111,222,333]
 l.insert(1,6666)  # 索引，值
 print(l)

    
 l=[111,222,333]
 res = l.append(444)   # 值
 res = l.insert(1,444)
 print(res)

6、刪除

 l=[111,222,333]  
    
# 萬能刪除

 del l[0]

 print(l)

# l.remove(指定元素)

 res=l.remove(222)

 print(l)

 print(res)  #None

# l.pop(指定索引)

 res=l.pop(1)

 print(l)

 print(res)

7、迴圈

 l=[111,222,333]

 for x in l:

    print(x)
 for i,x in enumrate(l)
    print(i,x)

=》=》需要掌握的操作（****）

l = [11,22,33,44,33,55]
new_l = l.copy()   # new_l = l[:]  # 淺拷貝

print(len(l))  # l._len_() # 長度


# l.index()        # 檢視某一個元素出現的索引
print(l.index(33))   # 對應2號索引
print(l.index(777))  # 找不到就報錯

# l.count()        # 統計某一個元素出現的個數
print(l.count(33)) # 3  出現3次

# l.clear          # 清空列表，把列表裡面所有元素都刪掉
l.clear()
print(l)           # [] 剩下空列表

# l.extend         # 往列表裡面一次加多個值
l.extend('hello')  # 底層相當於調了一個for迴圈
l.extend([1,2,3])  
l.append([1,2,3])  # 往列表里加了一個子列表
print(l)

# l.reverse()      # 把列表裡面的元素倒過來
l.reverse()
print()

# l.sort()         # 排序
l=[11,-3,9,7,99,73]
l.sort()           # 預設從小到大的順序
l.sort(reverse=Ture) # 從大到小的順序
print(l)           

• 該型別總結

  ​ 存多個值

  ​ 有序

​ 可變

• 元組tuple的基本使用

• 1、用途：元組就相當於一種不可變的列表，所以說元組也是按照位置存放多個任意型別的元素

• 2、定義方式：在 () 內用逗號分隔開多個任意型別的元素

x = (11)
print(x,type(x))  # 11 <class 'int'>

#   整型  浮點型  字串    列表
t = (11, 11.33, "xxx", [44,55])
print(t[-1][0])   # 44
print(type(t))    # <class 'tuple'>

# tuple資料型別轉換:只要是可迭代的型別都可以轉換成元組tuple

# 注意：如果元組內只有一個元素，那麼必須用逗號分隔

t = (11,)
print(type(t))    # <class 'tuple'>

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

優先掌握操作：（****）

1、按索引取值（正向取+反向取）：只能取，不能改

t = (11, 22, 33)
t[0] = 7777   # 元組不支援賦值操作

2、切片（顧頭不顧尾，步長）

t = (11, 22, 33, 44, 55, 666)
print(t[0:4:2])  # (11, 33)

3、長度

t = (11, 22, 33, 44, 55, 666)
print(len(t))    #  6

4、成員運算in和not in

t = (11, 22, 33, [44, 55, 666])
print([44, 55, 666] in t)     # True

5、迴圈

t = (11, 22, 33, [44, 55, 666])
for x in t:
print(x)

• 需要掌握的

t = (33, 22, 33, [44, 55, 666])
print(t.count(33))   # 2  統計某個元素出現的個數
print(t.index(33, 1, 4)) # 2 指定範圍從1開始找

• 該型別總結

​ 存多個數

​ 有序

​ 不可變：(元組指的不可變，是元組索引對應的記憶體地址不可變，

​ 如果元組內子元素是列表的話是可以改的)

• 字典dict的基本使用

• 1、用途：按照key:value的方式存放多個值，其中key對value應該有描述性的效果

• 2、定義方式：在{}內用逗號分隔開多個元素，每個元素都是key:value的組合，其中value可以是

  任意型別但是key必須是不可變型別，通常是字串型別,並且key不能重複

  d={1:111111,1.1:22222222222,"k1":333333,(1,2,3):44444444,[1,2,3]:5555}  # d=dict(...)
  print(d[1])
  print(d[1.1])
  print(d[(1,2,3)])
  # TypeError: unhashable type: 'list'
  # <class 'tuple'>
  
  # dict資料型別轉換 (資料型別的轉換比較狹窄)
  res = dict([("name","egon"),["age",18],["gender","male"]])
  print(res) # {'name':'egon', 'age': 18, 'gender':'male'}
  
  res = dict(a=1,b=2,c=3)  # 可以用這種方式造字典
  print(res)             # {'a':1, 'b':2, 'c':3}
  
  d={}                # 造空字典
  d=dict()
  print(type(d))
  
  # {} + fromkeys 可以快速初始化字典
  
  res = {}.fromkeys(['name',"age","gender"],None) # 前面每一個值都跟None配對
  res = {}.fromkeys(['name',"age","gender"],11)  #前面每一個值都跟11配對
  res["name"]=666       # 只有name值變了，其餘的都不變
  
  # key先準備好，value值先置空None，保證初始狀態之後再賦值給value
  # 通常都是None
  res = {}.fromkeys(['name',"age","gender"],[])
  res["name"]=666
  print(res)
  res["name"].append(1111111)
  print(res)
  

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

  =》=》=》優先掌握的操作：(*****)

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

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

d['k1']=6666
d['k3']=6666     # 字典是可以根據不存在的key往裡面加值的
print(d)

2、長度len

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

**3、成員運算in和not in: **判斷的是key

d={"name":"egon",'age':18}
print("egon" in d)    #   False
print("name" in d)    #   True

4、刪除

d={"name":"egon",'age':18}
print(d)
del d["name"]      # 萬能刪除法

v = d.pop("name")  # 指定key刪除
print(d)           # 顯示key已經刪除
print(v)           # pop刪除功能會把刪除key對應的value值返回 

item = d.popitem()
print(item)  # popitme刪除法會把刪除的key和value值存成元組返回
print(d)

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

d={"name":"egon",'age':18,"gender":"male"}
print(d.keys())
print(d.values())
print(d.items())

6、迴圈

d={"name":"egon",'age':18,"gender":"male"}
for k in d.keys():
    print(k)

for k in d:         # 不加.keys()預設就是
    print(k)    

for v in d.values(): # 只遍歷value
    print(v)

for k,v in d.items():  # k,v = ('gender', 'male'),
    print(k,v)

# 用list的方式還原成Python 2 的樣子
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

7、d.get()（取值方式）

d={"name":"egon",'age':18,"gender":"male"}
print(d["name"])      # 通常取值用這種方式
print(d.get("name"))


print(d["xxx"])      # key不存在 報錯
print(d.get("xxx"))  # 沒取到key返回None ，key值不存在的時候採用此種方式

=》=》需要掌握（****）

d={"name":"egon",'age':18,"gender":"male"}
d.clear()     # 清空字典裡面的key和value值
print(d)      # {}

d.copy()      # 淺copy

d={"name":"egon",'age':18,"gender":"xxx"}
if "gender" not in d:
    d['gender']="male" 
print(d)

d.setdefault()  # key不存在則新增key:value,key如果存在則什麼都不做
d.setdefault("gender","male")   # 與上面if 同種功能
print(d)


d.update()  # 更新字典，不相同的加入老字典，相同的新替舊
d={"name":"egon",'age':18,"gender":"male"}
d.update({"k1":111,"name":"xxx"})   #
print(d)

• 該型別總結

​ 存多個值

​ 無序

​ 可變

d={'k1':111}
print(id(d))
d['k1']=2222222
print(id(d))