python成长之路第二周day07

一、元组及其常用操作
二、字典及其常用操作
三、集合类型

PART ONE ：元组及其常用操作

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])
print(t)

3、长度
t = (111, 222, 333)
print(len(t))
4、成员运算in和not in
t = (111, 222, 333)
print(111 in t)
5、循环
for i in t:
print(i)

需要掌握的内置方法
t = (4444, 5555,111,222, 111,111,333)
print(t.index(111))
print(t.index(111123123123123123)) #找不到则报错

print(t.count(111))

类型总结：
存多个值

有序

不可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）
t = (111, 222, 333,[444,555])

t[0]=123123123123123
t[3] = 6666666666
print(id(t[3]))
t[3][0]=44444444444444444444444444
print(t)
print(id(t[3]))

PART TWO ：字典及其常用操作

1、用途：存多个不同属性的值，用key对应value,key必修是不可变类型，key通常
字符串类型，因为字符串类型对值value会有解释说明的效果

2、定义方式：在
而nalue是可以任意类型
d={“k1”:111,“k2”:222} #d=dict({“k1”:1111,“k2”:222)}
print(type(d))

类型转换
d=dict([“name”,“egon”,[“age”,18],(“gender”,18)])
print(d)

res=dict(x=111,y=222,z=333)
print(res)

定义空
d={}#定义空
print(d,type(d))

s=’’
print(type(s))

l=[]
print(type(l))

t=()
print(type(t))

s=set()#定义空集合

3、常用操作+内置方法
优先掌握的操作：
1、按key取值：可存可取
d={‘name’:‘egon’,‘age’:18}
l=[111,222,333]

print(d[‘name’])
print(l[0])

d[‘gender’]=‘male’#可以通过不存在的key完成赋值操作来达到为字典添加值得效果
print(d)
l[3]=444#列表不行

2、长度len
d={‘name’:‘egon’,‘age’:18}
print(len(d))
3、成员运算in和not in:判断的是字典的key
d={‘name’:‘egon’,‘age’:18}
print(“name” in d) # 判断的字典的key
print(“egon” in d) # 判断的不是value，结果为False

4、删除
a：万能删除法
d={‘name’:‘egon’,‘age’:18}
del d[‘name’]
print(d)

b:删除-》取走
res=d.popitem() # 随机删除，返回一个删除元素的小元组
print(res) # (‘age’, 18)

res=d.pop(‘name’) # 返回key对应的那一个值

print(res)

print(d)

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)

for k in d:
print(k)

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

for k,v in d.items(): #k,v=(‘age’, 18)
print(k,v)

字典需要掌握的内置方法
d={‘name’:‘egon’,‘age’:18}
d.clear()
print(d)

d.update(age=19,gender=‘male’)
d.update({‘age’:19,“gender”:“male”})
print(d)

print(d.get(‘name111’)) # key不存在不会报错，会返回None
print(d[“name111”]) # key不存在则报错

了解**
快速初始化好一个字典
d={}.fromkeys([“name”,“age”,“gender”],None)
print(d)

d={‘age’:18}

保证字典中肯定有一个key是"name"
if “name” not in d:
d[“name”]=“egon”
d[“name”]

val=d.setdefault(“name”,“egon”)
print(d)

print(val)

PART THREE : 集合类型

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)
print(type(s1))
s2=set()
print(type(s2))

类型转换
set(任意能被for循环遍历的类型)
res=set(“hello”)
print(res)
print("".join(res))

res=set([111,222,333,444,111,111])
print(res)
print(list(res))

res=set([111,[222],[222],333,444,111,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)

3、常用操作+内置的方法
friends1={“zero”,“kevin”,“jason”,“egon”}
friends2={“jy”,“ricky”,‘jason’,“egon”}

print(friends1 & friends2)

课后总结：
1，元组及其常用操作：
元组就是一个不可变的列表并且在小括号()内用逗号分隔开多个任意类型的值
，按索引取值(正向取+反向取)
2，字典及其常用操作：存多个不同属性的值，用key对应value,key必修是不可变类型，key通常字符串类型，因为字符串类型对值value会有解释说明的效果可以通过不存在的key完成赋值操作来达到为字典添加值得效果，item是取出字典中的集合

3，集合类型
去重
关系运算
在{}内用逗号分隔开多个元素，元素的特点如下：
无序
元素必须是不可变类型
集合内元素不能重复
set(任意能被for循环遍历的类型)