一、元组及常用操作
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、字典总结
存一个值or存多个值
存多值
有序or无序
无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
可变
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
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、字典总结
存一个值or存多个值
存多值
有序or无序
无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
可变
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
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、字典总结
存一个值or存多个值
存多值
有序or无序
无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
可变
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集合是可变类型
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
