day-8List/Dict/set/tuple

一.列表 recode

1.格式字符串

name = '喜爱'
age = 18
message = name  + '今年'+str(age)+'岁'
mssage = '%s今年%d %c % (name,age,800)'

常见的格式字符串:%s %d %N.f ,%c

2.列表(list)

• 可变(支持增删改)\有序(支持下标操作)

list1 = [1,2,3]
list1.remove(1)
print(list1)
print(list1.remove(1))   -- ######null不产生新的列表

• 列表中的增删改查
• 查:查单个元素:列表[下标],- 结果是元素.
• 切片:列表[开始下标:结束下标:步长]
• 切片后结果是小列表
• 遍历 --结果是元素

2) 增加:列表.append(元素)

• 列表.insert(下标,元素)

3)删除: del 列表[下标]/

列表.remove(元素) - 只删除第一个元素/
列表.pop()删除最后一个元素/
列表.pop(下标) 可以取到删除的元素

4) 修改 : 列表[下标] = 新值 不能直接修改元素.

---

---

二.列表相关运算

1).数学运算: + , *

list1= [1,2,3]
list2= ['name','age']
new_list = list1 + list2
print(new_list)

1.1加法: 列表一+列表二 -将两个列表中的元素合并产生一个新的列表,院原列表不会发生改变

1.2乘法: 列表*N -列表中的元素重复N次产生新的列表.

print(list1*3)

2)比较运算: == , !=

print([1,2] == [2,1]) #False 两个列表对应的元素,元素个数,和列表长度都要一样才相等

• 注意: > ,<,>=,<= 只支持相同位置上元素类型相同的两个列表.

print([1,2,3] > [1,2])    #True

2.内置函数

• len(列表长度) --结果是个整数

• sum(列表) --里面的列表必须是数字列表

• print(sum([1,2,3])) --输出 1+2+3=6

• max(列表)/min(列表) -- 找出列表里面最大或者最小的元素

• print(max([1,100])) --100

• list(数据) --将指定数据转化成列表,所有的序列都可以转化成列表,比如字符串,列表,字典,集合,元祖,range,迭代器,生成器,数字布尔不可以.

--转换的时候是将序列的元素作为列表元素

print(list('abcdef'))                   # --[a,b,c,d,e,f]
print(list(range(5)))                # --[0,1,2,3,4]

3.相关方法

1)列表.count(元素) -获取指定元素在列表中出现的次数,结果是整数

print([1,2,3,1,4].count(1))               # 2

2) 列表.extend(序列) - 将序列中的元素添加到列表中

list1 = []                       -- none
list1.extend('abc')
print(list1)                   ----['a','b','c']

3)列表.index(元素) --获取指定元素在列表中的下标,如果这个元素有多个只获取第一个.

4)列表.reverse( ) --将列表中的元素倒序,不会产生新列表

list2 = [1,2,2,34,44,55645,546,65]
list2.reverse( )
print(list2)

• 补充: 内置函数: reverse(序列) 像切片一样产生一个新的列表

• 将序列中的元素倒序产生一个新的迭代器,原序列不会修改.

5)列表.sort( ) -- 对列表的元素进行升序排序(从小到大),(列表中的元素类型一致并且支持比较运算).

• 列表.sort(reverse = True) --从大到小排序

scores = [10,100,89,20,67,34,9]
scores.sort()
print(scores)     ---[9,34,67,20,89,100,10]

6)列表.copy( ) - 产生一个新的列表,列表中的元素和原列表一样,相当于;列表[:]

'''
list[1,2,3]

7) 获取变量

id(变量) --查看变量中实质储存的地址,Python中所有的变量实质都是保存的数据在内存中的地址.

---

---

三.列表中删除数据

问题1:通过元素删除的时候可能出现删不干净的问题.

scores = [10,50,90,89,45,70] 删除列表中所有小于六十分的数字

scores = [10,50,90,89,45,70]
for score in scores:
    if score < 60:
        scores.remove(score)
print(scores)
"""
scores = [10,50,90,89,45,70]
scores = 10, if 10 < 60 ,scores.remove(10)  ,scores=[50,90,89,45,70]
scores = 90
...###默认原来列表的123...顺序取

解决问题1:

scores = [10,50,90,89,45,70]
scores2 = scores[:]
for score in scores:                #######写法二 for score in scores[:]
                                                                       scores[:]自动释放
    if score < 60:
        scores.remove(score)
del scores2  #####score2只是提供遍历用的,用完之后没有其他用处,可以直接删除.
print(scores)
一个列表取值,一个列表删除元素,相互不干扰

print('=======================问题2========================')

问题2:通过下标,删除满足要求的元素的时候,出现下标越界的错误.

scores = [10,50,90,89,45,70]
for index in range(len(scores)):
    if scores[index] < 60:
        del scores[index]
print(scores)

scores = [10,50,90,89,45,70]
for index in range(6)
index = (0,1,2,3,4,5)
index = 0  if scores[0]<60   del scores[0]  scores=[50,90,89,45,70]
index = 1   if 90< 60
index = 2    if 89< 60

scores = [10,50,90,89,45,70]
index = 0
while index 

---

---

四. 元祖(tuple)

1.元祖就是不可变的列表,作为序列不可变(不支持增删改),支持下标操作.

- (元素1,元素2,元素3,...),元素的要求和列表一样

2.操作,查 -获取元素(和列表一样)

tuple1 = (1,2,3,4)
print(tuple1[0],tuple1[-1])    --    1, 4 #获取元祖里面的元素

print(tuple1[0:5:2])     #切片后元祖还是元祖
for item in tuple1:    # 遍历元祖
    print(item) 

for index in range(len(tuple1)):
    print(index,tuple1[index])    # 遍历下标和元祖元素

3.数学运算,比较运算,in和not in ,len(),max(),min(),sum(),tuple()和对应的列表操作是一样的.

print(1,2,3)+('a','b','c')    --(1,2,3,'a','b','c')
print((1,2,3)*2)             --(1,2,3,1,2,3)
print(tuple('abcd'),tuple(range(4)),tuple(['abc',100]))  
   # ('a', 'b', 'c', 'd') (0, 1, 2, 3) ('abc', 100)

4.元祖专有的特点

1).只有一个元素的元祖,需要在这个元素的后面加一个逗号,

empty = (10,)
print(type(empty))     --tuple

2).元祖的值可以去掉小括号,直接将多个元素用逗号隔开,也表示一个元祖

看成一个整体的时候要加().

tu2 = 10,20,'abc'
print(tu2,type(tu2))    -- # (10, 20, 'abc') 

3).让变量的个数和元祖中元素的个数保持一致,可以让变量一次取出元祖中的元素.

point = (100,200)
x,y = point
print(x,y)

3.2),通过多个变量去获取元祖元素的时候,可以在某个变量的前面加*,将这个变量变成列表获取不带星号的变量的数据.

• 注意:带星号的变量只能有一个.

student = ('小明',30,60,50,100,175,70)
name,age,*scores,height = student
print(name,scores)                  #小明 [60, 50, 100, 175]

---

---

五.字典(dict)

1.什么是字典(dict)

• 字典是Python内置的一个容器型数据,可变(支持增删改)/无序(不支持下标操作)

• {键值对1,键值对2,...} = {键1:值1,键2:值2}

• 键(key):a.不可变 b.唯一 (实际情开发用字符串)

• 值(value):和列表元素的要求一样.

• 注意:键值对是成对出现,字典存数据实质要存的是值,键是索引.

dict1 = {'a': 123,'b': 'adf','c':[1,3]}
print(dict1)            --'a': 123,'b': 'adf','c': [1,3]

2.什么时候用字典

如果保存了多个数据是具有相同意义的数据,用列表

如果同时保存的多个数据的意义不同就用字典.

3.查 - 获取字典的值.

a.获取key对应的值: 字典[key] --获取字典中指定key对应的值

dog1 = {'name':'大黄','type':'中华田园犬','color':'3岁'}
print(dog1['type'])   #中华田园犬
print(dog1['gender'])    ***如果key不存在,报错 keyError:'gender'***

b.获取key对应的值 : 字典.get(key) -- 获取字典中指定key对应的值

字典.get(key,默认值) --如果key不存在,返回指定默认值

dog1 = {'name':'大黄','type':'中华田园犬','color':'3岁'}
print(dog1.get('type'))    #中华田园犬
print(dog1.get('gender'))   #如果key不存在,返回None

• 注意:None是python中的关键字,表示数据没有或者空的意思

dog1 = {'name':'大黄','type':'中华田园犬','color':'3岁'}
for x in dog1:
    print(x)

4.遍历

• 遍历:直接遍历字典,取出来的是key

dog1 = {'name':'大黄','type':'中华田园犬','color':'yellow'}
for x in dog1:
    print(x,dog1[x])

方法二: 不建议使用

for value in dog1.values():
    print(x)

方法三: 不建议使用

for key in dog1.keys():
    print(key)    #键

方法四: 不建议使用

for key,value in dog1.items():
    print(key,value)

5.增 / 改 - 添加键值对

• 字典[key] = 值 当key不存在的时候,就是添加键值对,当key存在的时候,就是修改key对应的值.

film = {'name':'流浪地球','主演':'吴京','time':'2019-2-5'}
film['票房'] = '40亿'
print(film)          #不存在就加进去
film['time'] = '2019-2-6'           #'time' 这个key存在,修改time值为最新的值

字典.setdefault(key,value) - 只能添加不能修改.

6.字典的删除

a.del 字典[key] - 删除字典中key对应的键值对

film = {'name':'流浪地球','主演':'吴京','time':'2019-2-5'}
del film['time']
print(film)           
#输出:film = {'name':'流浪地球','主演':'吴京','2019-2-5'}
#不会产生新的字典

b.字典.pop(key) - 从字典中取出key对应的值,结果是key对应的值

film = {'name':'流浪地球','主演':'吴京','time':'2019-02-05'}
name =film.pop('name')
print(name)    #流浪地球
print(film)    #{'主演': '吴京', 'time': '2019-02-05'}

6.相关运算

6.1只支持比较运算符

print({'a':10,'b':20} == {'b':20,'a':10})

6.2 in 和 not in

key in 字典 -- 判断字典中存在某个key对应的键值对(判断key)

film = {'name':'流浪地球','主演':'吴京','time':'2019-02-05'}
print('name' in film)  #True
print('流浪地球' in film)   #False

• len() 求有多少个键值对

• max() 求key最大的值

• min() 求key自小的值

• dict() 类型转化为字典

print(dict([[1,2],['a',100],[1000,[1]]]))
#输出:{1: 2, 'a': 100, 1000: [1]}

转换为字典的要求:

本身是一个序列,序列中元素是小序列,小序列必须有且只有2个元素,而且这两个元素中的第一个元素是不可变的.

print(list(字典)) - 字典转列表或者元祖的时候是将key取出来作为列表 / 元祖的元素:

film = {'name':'流浪地球','主演':'吴京','time':'2019-02-05'}
print(list(film))    # ['name', '主演', 'time']  将key取出来作为列表 / 元祖的元素

7.相关方法

7.1 字典.clear() -清空字典

7.2 字典.copy() -复制字典的内容,产生一个新的字典

7.3 dict.fromkeys(序列,值) - 创建一个新的字典,将序列中的元素作为新字典的key,指定的值作为每个key对应的值.

• 字典.copy() -- 复制字典的内容,产生一个新的字典

film = {'name':'流浪地球','主演':'吴京','time':'2019-02-05'}
film1 = film.copy()
film1['name'] = '死神'
print(film)  #{'name': '流浪地球', '主演': '吴京', 'time': '2019-02-05'}
print(film1) #{'name': '死神', '主演': '吴京', 'time': '2019-02-05'}

• dict.fromkeys(序列,值) -- 创建一个新的字典,将序列中的元素作为新字典的key,值都是一样的(指定的值)

new_dict = dict.fromkeys('abc','a')
print(new_dict)   #{'a': 'a', 'b': 'a', 'c': 'a'}

7.4 字典1.update(字典2)

• 说明:将字典2中的键值对添加到字典1中,如果字典1中存在键值对,则不管,如果不存在就用字典2中的value更新值.