元組

元組：用（）包含起來並用逗號分隔開的一系列資料的集合。

1. 能夠儲存多個值
2. 有序，可以用過元素位置進行索引
3. 不可變型別：即元組的值的改變，地址也會發生改變，可Hash（但是元組記憶體儲的可變型別中儲存的值發生改變，不會導致元組的地址發生改變。）
4. 可迭代型別：可以用For迴圈進行遍歷

1、常用操作（索引、切片、元組化、成員運算、遍歷、長度）

1. 索引與切片（等同於字串與列表）

number=(1,2,3,2,1)
#元組的索引
print(number[0]) #返回第一個值》1
print(number[-1]) #返回最後一個值》1
#元組切片
print(number[0:5:1]) #返回一個元組。元組包括：第一個到第（5-1）個值，步長為1》(1, 2, 3, 2, 1)
print(number[-1:-5:-1])#反向取值，組成一個新元組
 

2. 成員運算與遍歷（等同於字串與列表）

#元組的遍歷，同列表等，採用for
names=["alex","duke","fox","duke","fox","fox"]
name_count={}
for name in names:
    name_count.setdefault(name,names.count(name))
print(name_count)
#成員運算，（邏輯運算） in ,not in
number=("duke","ergou","erick","egon")
print("erick" in number)  #True
print("erick" not in number) #False
 

3. 長度len()>==retuen 元素個數
4. 元組化tuple()

#初始化元組
#tuple(可迭代型別)，返回一個元組，tuple()定義了一個空元組
tuple1=tuple("abcud as")
print(tuple1)
tuple1=tuple([1,22,3,4,5])
print(tuple1)
tuple1=tuple((1,2,3,4,5))
print(tuple1)
tuple1=tuple({1:1,2:2,3:3})
print(tuple1)
tuple1=tuple({1,2,3,4,5})
print(tuple1)
"""輸出結果：
('a', 'b', 'c', 'u', 'd', ' ', 'a', 's')
(1, 22, 3, 4, 5)
(1, 2, 3, 4, 5)
(1, 2, 3)
(1, 2, 3, 4, 5)
"""
#定義知有一個元素的元組
tuple1=tuple()
tuple2=()
print(type(tuple1),type(tuple2))
tuple1=(2,)
tuple2=(2)
print(type(tuple1),type(tuple2))
"""輸出結果：
<class 'tuple'> <class 'tuple'>
<class 'tuple'> <class 'int'>
"""
 

2、內建函式 index，count index（）：返回第一個索引值，若不存在就報錯 count（）：計算某一元素在元組中出現的次數

"""
index:查詢，並返回該值所在可迭代型別中的位置，若未找到值，則報錯
使用方法：T.index(value, [start, [stop]])
"""
print(number.index(2))
print(number.index(2,2))

number=("duke","ergou","erick","egon")
number.count("duke")

字典

字典：在{}中，用逗號隔開的“key:value”鍵值對的集合。

1. 能夠儲存多個值（鍵值對 ，鍵 與 值與一一對應，鍵必需為可hash型別（數字、字串、元組、集合），值可以為任何型別。）。字典的key值不能重複，若重複的話，後面值會覆蓋前面的值
2. 字典是無序的，但是可採用key去呼叫相對應的value值
3. 可變型別，內部儲存的id地址的改變，並不會引起該字典對應id地址的改變，不可hash

一、常用操作

1. 索引、新增、鍵、值、鍵值對、迴圈、長度、成員運算、初始化

• [ ]索引：按照key值返回value，若key值不存在，則會報錯

name_age={"alex":18,"liric":13,"duke":20,"alex":19}
name_age["alex"]   #>>>>= 18
name_age["duke"]   #>>>>= 20

• 新增：D[key]=value，若key存在，則覆蓋，否則新增

name_age={"alex":18,"liric":13,"duke":20,"alex":19}
name_age["alex"]=25 #>>>={'alex': 25, 'liric': 13, 'duke': 20}
print(name_age)
name_age["zhang dadan"]=21
print(name_age)     #>>>={'alex': 25, 'liric': 13, 'duke': 20, 'zhang dadan': 21}

• 鍵：D.keys() 提出裡面所有的key;值:D.values() 提出裡面所有的value;鍵值對:D.items() 提出裡面所有的key,value。

name_age={"alex":18,"liric":13,"duke":20,"alex":19}

print(name_age.keys())   #>===dict_keys(['alex', 'liric', 'duke']) 不會佔用記憶體
print(name_age.values()) #>===dict_values([19, 13, 20])
print(name_age.items())  #>===dict_items([('alex', 19), ('liric', 13), ('duke', 20)])

• 迴圈：for item in D[.keys()\values\items()]:

"""字典迴圈"""
name_age={"alex":18,"liric":13,"duke":20}
for k in name_age.keys():
    print(k)
for k in name_age:
    print((k))
for v in name_age.values():
    print(v)
for item in name_age.items():
    k,v=item
    print(k,v)
for k,v in name_age.items():
    print(k,v)

• 長度：len()，返回字典中鍵值對的個數
• 成員運算：not in \in : if item in D[.keys()\values\items()]: 返回False\True
• 初始化：dict(object):將object轉換為字典型別儲存

"""dict()初始化：
(1):dict():建立一個空字典
(2):dict(mapping):從具有對映關係（目前所學：字典）（key,value）初始化一個新字典
(3):dict(iterable):從一個可迭代型別初始化一個新字典，可迭代型別（key,value）
(4):dict(**args):從key=vlaue中初始化一個新字典"""
dict1=dict()
print(dict1)
dict1=dict({"able":2,"ergou":123})
print(dict1)
# 集合、列表、元組的隨意組合，內層每一個包含兩個值，第一個值不能為可變型別
dict1=dict((["able",16],["ergou",123]))
print(dict1)
#key值會自動轉為字串
dict1=dict(able=18,ergou=18)
print(dict1)
"""輸出結果：
{}
{'able': 2, 'ergou': 123}
{'able': 16, 'ergou': 123}
{'able': 18, 'ergou': 18}
"""

2. 內建函式：get ,setdefult,update,pop,popitem,fromkeys,del

• get(key)：item = D.get(key) if key in D: item=D(key) else: item = None
• setdefult(key,d) :f.setdefult(key,d) if key in f: D(key)=D(key) else: D(key)=d