一、元組及常用操作
1、用途：元組就是一個不可變的清單
2、定義方式: 在小括号()内用逗号分隔開多個任意類型的值
l=[111,222,333]
t=(111,222,333) # t=tupe((111,222,333))
print(type(t))
類型轉換
tuple(任意能夠被for循環周遊的類型) # ===> 元組
list(任意能夠被for循環周遊的類型) # ===> 清單
3、常用操作+内置的方法 優先掌握的操作：
1、按索引取值(正向取+反向取)：隻能取
2、切片(顧頭不顧尾，步長)
t=(111,222,333)
print(t[0:2])#(111, 222)
print(t)#(111, 222, 333)
3、長度
t = (111, 222, 333)
print(len(t))#3
4、成員運算in和not in
t = (111, 222, 333)
print(111 in t)#True
5、循環
for i in t:
print(i)#111 222 333 需要掌握的内置方法
t = (4444, 5555,111,222, 111,111,333)
print(t.index(111))#2
# print(t.index(111123123123123123)) # 找不到則報錯
print(t.count(111))#3 4、元組總結：
存一個值or存多個值
存多值
有序or無序
有序
可變or不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）
不可變
t = (111, 222, 333,[444,555])
# t[0]=123123123123123
print(t)#(111, 222, 333, [444, 555])
# t[3] = 6666666666
print(t)#(111, 222, 333, [444, 555])
print(id(t[3]))#5892160
t[3][0]=44444444444444444444444444
print(t)#(111, 222, 333, [44444444444444444444444444, 555])
print(id(t[3]))#5892160 二、字典類及常用操作
1、用途：存多個不同屬性的值，用key對應value，key必須是不可變類型，key通常應該是
# 字元串類型，因為字元串類型對值value會有解釋說明的效果
2、定義方式：在{}内用逗号分隔開多個key:value元素，其中key必須是不可變類型，并且key不可重複
# 而value可以是任意類型
d={"k1":1111,"k2":222} # d=dict({"k1":1111,"k2":222})
print(type(d))
d={'k':111,'k':222,'k':333,'k':444}
print(d)#要注意結果是{'k': 444}
# 類型轉換
d=dict([("name","egon"),["age",18],("gender",18)])
print(d)#{'name': 'egon', 'age': 18, 'gender': 18} 把清單轉換為字典
res=dict(x=111,y=222,z=333)
print(res)#{'x': 111, 'y': 222, 'z': 333}
# 定義空
# d={} # 定義空字典
print(type(d))#<class 'dict'>
s=''
print(type(s))#<class 'str'>
l=[]
print(type(l))#<class 'list'>
t=()
print(type(t))#<class 'tuple'>
t=("abc",) # 當元組内隻有一個元素時，必須加逗号
print(t)#('abc',)
print(type(t))#<class 'tuple'>
s=set() # 定義空集合 3、常用操作+内置的方法
#優先掌握的操作：
#1、按key存取值：可存可取
d={'name':'egon','age':18}
l=[111,222,333]
print(d['name'])#egon
print(l[0])#111
d['gender']='male' # 可以通過不存在的key完成指派操作來達到為字典添加值的效果
print(d)#{'name': 'egon', 'age': 18, 'gender': 'male'}
# l[3]=444 # 清單不行,會報錯
# 2、長度len
d={'name':'egon','age':18}
print(len(d))#2
# 3、成員運算in和not in:判斷的是字典的key
d={'name':'egon','age':18}
print("name" in d) # 判斷的字典的key，結果為True
print("egon" in d) # 判斷的不是value，結果為False
#4、删除
#a：萬能删除法
d={'name':'egon','age':18}
# del d['name']
# print(d)#{'age': 18}
#b:删除-》取走
# res=d.popitem() # 随機删除，傳回一個删除元素的小元組
# print(res) # ('age', 18)
res=d.pop('name')# 傳回key對應的那一個值
# print(res)#egon 要把上面那些代碼注釋掉，不然會有影響
print(d)# {'age': 18} 要把上面那些代碼注釋掉，不然會有影響
#5、鍵keys()，值values()，鍵值對items()
'''
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> d={'name':'egon','age':18}
>>>
>>> d.keys()
['age', 'name']
>>> d.values()
[18, 'egon']
>>> d.items()
[('age', 18), ('name', 'egon')]
'''
#6、循環
d={'name':'egon','age':18}
for k in d.keys():
print(k)# name age
for k in d:
print(k)# name age
for v in d.values():
print(v)# egon 18
for k,v in d.items(): # k,v=('age', 18)
print(k,v) #name egon age 18 # 需要掌握的内置方法
d={'name':'egon','age':18}
d.clear()
print(d)#{}
d.update(age=19,gender='male')
# d.update({'age':19,"gender":"male"})這行等同于上面一行
print(d) #{'age': 19, 'gender': 'male'}
print(d.get('name111')) # key不存在不會報錯，會傳回None
# print(d["name111"]) # key不存在則報錯 # 了解**
# 快速初始化好一個字典
d={}.fromkeys(["name","age","gender"],None)
print(d)#{'name': None, 'age': None, 'gender': None}
# 保證字典中肯定有一個key是"name"
if "name" not in d:
d["name"]="egon"
print(d["name"])#None
print(d)#{'name': None, 'age': None, 'gender': None}
val=d.setdefault("name","egon")
print(d)#{'name': None, 'age': None, 'gender': None}
print(val)#None 4、字典總結 無序
可變
d={'k1':111,'k2':2222}
print(id(d))#34685888
d['k1']=333333333333333
print(id(d))#34685888
print(d)#{'k1': 333333333333333, 'k2': 2222} 三、集合及其常用操作
1、用途：
去重
關系運算
2、定義方式:在{}内用逗号分隔開多個元素，元素的特點如下： I：無序 s1={'aaa',111,'ddd'}
print(s1)
II：元素必須是不可變類型
s1={1,2.2,"abc",(1,2),[]} #報錯
III: 集合内元素不能重複
s1={1,1,1,1,1,1,1,1,1,1,1,} # s1=set(...)
print(s1) #{1}
print(type(s1))#<class 'set'>
s2=set()
print(type(s2))#<class 'set'> # 類型轉換
# set(任意能被for循環周遊的類型)
res=set("hello")
print(res)#{'o', 'h', 'l', 'e'}
print("".join(res))#ohle
res=set([111,222,333,444,111,111])
print(res)#{444, 333, 222, 111}
print(list(res))#[444, 333, 222, 111] src_l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in src_l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
#列印出[{'name': 'lili', 'age': 18, 'sex': 'male'}, {'name': 'jack', 'age': 73, 'sex': 'male'}, {'name': 'tom', 'age': 20, 'sex': 'female'}] 3、常用操作+内置的方法 friends1={"zero","kevin","jason","egon"}
friends2={"jy","ricky",'jason',"egon"}
print(friends1 & friends2)#{'jason', 'egon'}
friends1=["zero","kevin","jason","egon"]
friends2=["jy","ricky",'jason',"egon"]
l=[]
for name in friends1:
if name not in friends2:
l.append(name)
print(l) #['zero', 'kevin'] 4、集合總結
存一個值or存多個值
存多值
有序or無序
無序
可變or不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）
不可變
set集合是可變類型
1、用途：元組就是一個不可變的清單
2、定義方式: 在小括号()内用逗号分隔開多個任意類型的值
l=[111,222,333]
t=(111,222,333) # t=tupe((111,222,333))
print(type(t))
類型轉換
tuple(任意能夠被for循環周遊的類型) # ===> 元組
list(任意能夠被for循環周遊的類型) # ===> 清單
3、常用操作+内置的方法 優先掌握的操作：
1、按索引取值(正向取+反向取)：隻能取
2、切片(顧頭不顧尾，步長)
t=(111,222,333)
print(t[0:2])#(111, 222)
print(t)#(111, 222, 333)
3、長度
t = (111, 222, 333)
print(len(t))#3
4、成員運算in和not in
t = (111, 222, 333)
print(111 in t)#True
5、循環
for i in t:
print(i)#111 222 333 需要掌握的内置方法
t = (4444, 5555,111,222, 111,111,333)
print(t.index(111))#2
# print(t.index(111123123123123123)) # 找不到則報錯
print(t.count(111))#3 t = (111, 222, 333,[444,555])
# t[0]=123123123123123
print(t)#(111, 222, 333, [444, 555])
# t[3] = 6666666666
print(t)#(111, 222, 333, [444, 555])
print(id(t[3]))#5892160
t[3][0]=44444444444444444444444444
print(t)#(111, 222, 333, [44444444444444444444444444, 555])
print(id(t[3]))#5892160 1、用途：存多個不同屬性的值，用key對應value，key必須是不可變類型，key通常應該是
# 字元串類型，因為字元串類型對值value會有解釋說明的效果
2、定義方式：在{}内用逗号分隔開多個key:value元素，其中key必須是不可變類型，并且key不可重複
# 而value可以是任意類型
d={"k1":1111,"k2":222} # d=dict({"k1":1111,"k2":222})
print(type(d))
d={'k':111,'k':222,'k':333,'k':444}
print(d)#要注意結果是{'k': 444}
# 類型轉換
d=dict([("name","egon"),["age",18],("gender",18)])
print(d)#{'name': 'egon', 'age': 18, 'gender': 18} 把清單轉換為字典
res=dict(x=111,y=222,z=333)
print(res)#{'x': 111, 'y': 222, 'z': 333}
# 定義空
# d={} # 定義空字典
print(type(d))#<class 'dict'>
s=''
print(type(s))#<class 'str'>
l=[]
print(type(l))#<class 'list'>
t=()
print(type(t))#<class 'tuple'>
t=("abc",) # 當元組内隻有一個元素時，必須加逗号
print(t)#('abc',)
print(type(t))#<class 'tuple'>
s=set() # 定義空集合 3、常用操作+内置的方法
#優先掌握的操作：
#1、按key存取值：可存可取
d={'name':'egon','age':18}
l=[111,222,333]
print(d['name'])#egon
print(l[0])#111
d['gender']='male' # 可以通過不存在的key完成指派操作來達到為字典添加值的效果
print(d)#{'name': 'egon', 'age': 18, 'gender': 'male'}
# l[3]=444 # 清單不行,會報錯
# 2、長度len
d={'name':'egon','age':18}
print(len(d))#2
# 3、成員運算in和not in:判斷的是字典的key
d={'name':'egon','age':18}
print("name" in d) # 判斷的字典的key，結果為True
print("egon" in d) # 判斷的不是value，結果為False
#4、删除
#a：萬能删除法
d={'name':'egon','age':18}
# del d['name']
# print(d)#{'age': 18}
#b:删除-》取走
# res=d.popitem() # 随機删除，傳回一個删除元素的小元組
# print(res) # ('age', 18)
res=d.pop('name')# 傳回key對應的那一個值
# print(res)#egon 要把上面那些代碼注釋掉，不然會有影響
print(d)# {'age': 18} 要把上面那些代碼注釋掉，不然會有影響
#5、鍵keys()，值values()，鍵值對items()
'''
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> d={'name':'egon','age':18}
>>>
>>> d.keys()
['age', 'name']
>>> d.values()
[18, 'egon']
>>> d.items()
[('age', 18), ('name', 'egon')]
'''
#6、循環
d={'name':'egon','age':18}
for k in d.keys():
print(k)# name age
for k in d:
print(k)# name age
for v in d.values():
print(v)# egon 18
for k,v in d.items(): # k,v=('age', 18)
print(k,v) #name egon age 18 # 需要掌握的内置方法
d={'name':'egon','age':18}
d.clear()
print(d)#{}
d.update(age=19,gender='male')
# d.update({'age':19,"gender":"male"})這行等同于上面一行
print(d) #{'age': 19, 'gender': 'male'}
print(d.get('name111')) # key不存在不會報錯，會傳回None
# print(d["name111"]) # key不存在則報錯 # 了解**
# 快速初始化好一個字典
d={}.fromkeys(["name","age","gender"],None)
print(d)#{'name': None, 'age': None, 'gender': None}
# 保證字典中肯定有一個key是"name"
if "name" not in d:
d["name"]="egon"
print(d["name"])#None
print(d)#{'name': None, 'age': None, 'gender': None}
val=d.setdefault("name","egon")
print(d)#{'name': None, 'age': None, 'gender': None}
print(val)#None 4、字典總結 d={'k1':111,'k2':2222}
print(id(d))#34685888
d['k1']=333333333333333
print(id(d))#34685888
print(d)#{'k1': 333333333333333, 'k2': 2222} 1、用途：
去重
關系運算
2、定義方式:在{}内用逗号分隔開多個元素，元素的特點如下： I：無序 s1={'aaa',111,'ddd'}
print(s1)
II：元素必須是不可變類型
s1={1,2.2,"abc",(1,2),[]} #報錯
III: 集合内元素不能重複
s1={1,1,1,1,1,1,1,1,1,1,1,} # s1=set(...)
print(s1) #{1}
print(type(s1))#<class 'set'>
s2=set()
print(type(s2))#<class 'set'> # 類型轉換
# set(任意能被for循環周遊的類型)
res=set("hello")
print(res)#{'o', 'h', 'l', 'e'}
print("".join(res))#ohle
res=set([111,222,333,444,111,111])
print(res)#{444, 333, 222, 111}
print(list(res))#[444, 333, 222, 111] src_l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in src_l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
#列印出[{'name': 'lili', 'age': 18, 'sex': 'male'}, {'name': 'jack', 'age': 73, 'sex': 'male'}, {'name': 'tom', 'age': 20, 'sex': 'female'}] 3、常用操作+内置的方法 friends1={"zero","kevin","jason","egon"}
friends2={"jy","ricky",'jason',"egon"}
print(friends1 & friends2)#{'jason', 'egon'}
friends1=["zero","kevin","jason","egon"]
friends2=["jy","ricky",'jason',"egon"]
l=[]
for name in friends1:
if name not in friends2:
l.append(name)
print(l) #['zero', 'kevin'] 1、用途：元組就是一個不可變的清單
2、定義方式: 在小括号()内用逗号分隔開多個任意類型的值
l=[111,222,333]
t=(111,222,333) # t=tupe((111,222,333))
print(type(t))
類型轉換
tuple(任意能夠被for循環周遊的類型) # ===> 元組
list(任意能夠被for循環周遊的類型) # ===> 清單
3、常用操作+内置的方法 優先掌握的操作：
1、按索引取值(正向取+反向取)：隻能取
2、切片(顧頭不顧尾，步長)
t=(111,222,333)
print(t[0:2])#(111, 222)
print(t)#(111, 222, 333)
3、長度
t = (111, 222, 333)
print(len(t))#3
4、成員運算in和not in
t = (111, 222, 333)
print(111 in t)#True
5、循環
for i in t:
print(i)#111 222 333 需要掌握的内置方法
t = (4444, 5555,111,222, 111,111,333)
print(t.index(111))#2
# print(t.index(111123123123123123)) # 找不到則報錯
print(t.count(111))#3 t = (111, 222, 333,[444,555])
# t[0]=123123123123123
print(t)#(111, 222, 333, [444, 555])
# t[3] = 6666666666
print(t)#(111, 222, 333, [444, 555])
print(id(t[3]))#5892160
t[3][0]=44444444444444444444444444
print(t)#(111, 222, 333, [44444444444444444444444444, 555])
print(id(t[3]))#5892160 1、用途：存多個不同屬性的值，用key對應value，key必須是不可變類型，key通常應該是
# 字元串類型，因為字元串類型對值value會有解釋說明的效果
2、定義方式：在{}内用逗号分隔開多個key:value元素，其中key必須是不可變類型，并且key不可重複
# 而value可以是任意類型
d={"k1":1111,"k2":222} # d=dict({"k1":1111,"k2":222})
print(type(d))
d={'k':111,'k':222,'k':333,'k':444}
print(d)#要注意結果是{'k': 444}
# 類型轉換
d=dict([("name","egon"),["age",18],("gender",18)])
print(d)#{'name': 'egon', 'age': 18, 'gender': 18} 把清單轉換為字典
res=dict(x=111,y=222,z=333)
print(res)#{'x': 111, 'y': 222, 'z': 333}
# 定義空
# d={} # 定義空字典
print(type(d))#<class 'dict'>
s=''
print(type(s))#<class 'str'>
l=[]
print(type(l))#<class 'list'>
t=()
print(type(t))#<class 'tuple'>
t=("abc",) # 當元組内隻有一個元素時，必須加逗号
print(t)#('abc',)
print(type(t))#<class 'tuple'>
s=set() # 定義空集合 3、常用操作+内置的方法
#優先掌握的操作：
#1、按key存取值：可存可取
d={'name':'egon','age':18}
l=[111,222,333]
print(d['name'])#egon
print(l[0])#111
d['gender']='male' # 可以通過不存在的key完成指派操作來達到為字典添加值的效果
print(d)#{'name': 'egon', 'age': 18, 'gender': 'male'}
# l[3]=444 # 清單不行,會報錯
# 2、長度len
d={'name':'egon','age':18}
print(len(d))#2
# 3、成員運算in和not in:判斷的是字典的key
d={'name':'egon','age':18}
print("name" in d) # 判斷的字典的key，結果為True
print("egon" in d) # 判斷的不是value，結果為False
#4、删除
#a：萬能删除法
d={'name':'egon','age':18}
# del d['name']
# print(d)#{'age': 18}
#b:删除-》取走
# res=d.popitem() # 随機删除，傳回一個删除元素的小元組
# print(res) # ('age', 18)
res=d.pop('name')# 傳回key對應的那一個值
# print(res)#egon 要把上面那些代碼注釋掉，不然會有影響
print(d)# {'age': 18} 要把上面那些代碼注釋掉，不然會有影響
#5、鍵keys()，值values()，鍵值對items()
'''
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> d={'name':'egon','age':18}
>>>
>>> d.keys()
['age', 'name']
>>> d.values()
[18, 'egon']
>>> d.items()
[('age', 18), ('name', 'egon')]
'''
#6、循環
d={'name':'egon','age':18}
for k in d.keys():
print(k)# name age
for k in d:
print(k)# name age
for v in d.values():
print(v)# egon 18
for k,v in d.items(): # k,v=('age', 18)
print(k,v) #name egon age 18 # 需要掌握的内置方法
d={'name':'egon','age':18}
d.clear()
print(d)#{}
d.update(age=19,gender='male')
# d.update({'age':19,"gender":"male"})這行等同于上面一行
print(d) #{'age': 19, 'gender': 'male'}
print(d.get('name111')) # key不存在不會報錯，會傳回None
# print(d["name111"]) # key不存在則報錯 # 了解**
# 快速初始化好一個字典
d={}.fromkeys(["name","age","gender"],None)
print(d)#{'name': None, 'age': None, 'gender': None}
# 保證字典中肯定有一個key是"name"
if "name" not in d:
d["name"]="egon"
print(d["name"])#None
print(d)#{'name': None, 'age': None, 'gender': None}
val=d.setdefault("name","egon")
print(d)#{'name': None, 'age': None, 'gender': None}
print(val)#None 4、字典總結 d={'k1':111,'k2':2222}
print(id(d))#34685888
d['k1']=333333333333333
print(id(d))#34685888
print(d)#{'k1': 333333333333333, 'k2': 2222} 1、用途：
去重
關系運算
2、定義方式:在{}内用逗号分隔開多個元素，元素的特點如下： I：無序 s1={'aaa',111,'ddd'}
print(s1)
II：元素必須是不可變類型
s1={1,2.2,"abc",(1,2),[]} #報錯
III: 集合内元素不能重複
s1={1,1,1,1,1,1,1,1,1,1,1,} # s1=set(...)
print(s1) #{1}
print(type(s1))#<class 'set'>
s2=set()
print(type(s2))#<class 'set'> # 類型轉換
# set(任意能被for循環周遊的類型)
res=set("hello")
print(res)#{'o', 'h', 'l', 'e'}
print("".join(res))#ohle
res=set([111,222,333,444,111,111])
print(res)#{444, 333, 222, 111}
print(list(res))#[444, 333, 222, 111] src_l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in src_l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
#列印出[{'name': 'lili', 'age': 18, 'sex': 'male'}, {'name': 'jack', 'age': 73, 'sex': 'male'}, {'name': 'tom', 'age': 20, 'sex': 'female'}] 3、常用操作+内置的方法 friends1={"zero","kevin","jason","egon"}
friends2={"jy","ricky",'jason',"egon"}
print(friends1 & friends2)#{'jason', 'egon'}
friends1=["zero","kevin","jason","egon"]
friends2=["jy","ricky",'jason',"egon"]
l=[]
for name in friends1:
if name not in friends2:
l.append(name)
print(l) #['zero', 'kevin'] ![圖像去噪的原理及實作[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)