Python List、tuple和字典（3.9）

大地之灯

已于 2022-02-20 19:20:01 修改

阅读量535

点赞数 1

分类专栏： python知识点总结文章标签： python 数据结构

于 2021-03-10 08:59:52 首次发布

本文链接：https://blog.csdn.net/qq_33489955/article/details/114592067

版权

python知识点总结专栏收录该内容

27 篇文章 1 订阅

订阅专栏

常用的列表方法及推导式

1.列表.clear() 清空列表（删除列表中的所有元素）

比直接赋空值效率高,

nums=[1,3,4,5,5]
nums.clear()
print(nums)

2.列表.copy() - 复制原列表产生一个一模一样的新列表，将新列表返回

变量保存数据其实是保存的数据在内存空间中的地址

将nums中的地址赋给nums1

nums1=[23,4,4,56,6]
nums2=nums1.copy()
# 对nums2进行改变，nums1不会改变
del nums2[-1]
print(nums1,nums2)
print('nums1({}):,nums2({})'.format(id(nums1),id(nums2)))
# 如果是赋值操作，原列表的值也会随之改变
nums3=[1,2,3,4]
nums4=nums3
print('nums3({}):,nums4({})'.format(id(nums3),id(nums4)))

其他类似的操作

列表[:],列表+[],列表*1的功能和列表.copy()的功能一模一样

3 .列表.count(元素 - )统计列表中指定元素的个数

nums5=[23,456,67,76,34,231,67,67]
print(nums5.count(67))  #3
print(nums5.count(888)) #没有就返回0

4.列表.extend(序列)- 将指定序列中的所有的元素全部添加到列表的后面

l1=[1,2]
l2=l1.copy()
l1.append('abc') #[1, 2, 'abc']
l2.extend('abc') #[1, 2, 'a', 'b', 'c']
print(l1,l2)
# print(l1.extend(3)) #不是序列会报错，'int' object is not iterable

5.列表.index - 获取指定元素在列表中的下标（下标是0开始增加的下标值）

同一元素有多个时,只返回第一个的下标值

元素不存在时，会报错

movies=['怦然心动','阿甘正传','绿皮书','肖生克的救赎','触不可及','阿甘正传','当幸福来敲门']
print(movies.index('触不可及')) #4
print(movies.index('阿甘正传')) #1
# print(movies.index('沉默的羔羊')) #ValueError: '沉默的羔羊' is not in list

6.列表.reverse() - 将原列表倒序

movies.reverse()
print(movies) #['当幸福来敲门', '阿甘正传', '触不可及', '肖生克的救赎', '绿皮书', '阿甘正传', '怦然心动']

7.列表.sort() - 直接修改原列表中元素的顺序，从小到大排序，不会产生新的列表

sorted.（列表），是返回一个新建立的有序列表，从小到大

nums6=[23,45,675,1,656,24,645]
print(sorted(nums6)) #[1, 23, 24, 45, 645, 656, 675]
nums6.sort()
print(nums6) #[1, 23, 24, 45, 645, 656, 675]
nums6.sort(reverse=True)
print(nums6) #[675, 656, 645, 45, 24, 23, 1]

元组

元组是容器型数据类型（序列），将（）作为容器的标志，里面多个元素用逗号隔开：（元素### 1，元素2，…）

特点：元组是不可变的（不支持增删改）

元组是有序的（支持下标操作）

元素：任何类型的数据都可以作为元组的元素

2.元组就是不可变的列表 - 列表中除了增删改以外的操作都适用

2.1获取元素

t3=('绿色','黄色','粉色','红色','白色')
print(t3[1],t3[-4]) #黄色 黄色
print(t3[1:3]) #('黄色', '粉色')
print(t3[::-2]) #('白色', '粉色', '绿色')

for x in t3:
    print(x)
for index in range(len(t3)):
    print(index,t3[index])

2.2相关操作，相关函数

t3=('绿色','黄色','粉色','红色','白色')
print('黑色'in t3) #False
print('白色'in t3) #True

t4=(10,20)
t5=(100,200,300)
print(t4+t5)#(10, 20, 100, 200, 300)
print(t4*3)#(10, 20, 100, 200, 300)

print(max(t5))
print(min(t5))
print(sum(t5))
#可以排序，但是输出值是列表，想要元组再进行类型转换
new_nums=sorted((1,45,3,65,4))
print(new_nums)
print(tuple(new_nums))

3.元组的常用操作

3.1 只有一个元素的元组

t6=(1)
#元组只有一个元素，必须在唯一元素后添加逗号
t7=(1,)
print(t6,type(t6))# 1 <class 'int'>
print(t7,type(t7))#(1,) <class 'tuple'>

3.2在没有歧义的情况下，元组的小括号可以省略

直接将多个数据用逗号隔开，也表示一个元组

t8=(2,3,4,5)
t9=2,3,4,5
print(t8,type(t8)) # (2, 3, 4, 5) <class 'tuple'>
print(t9,type(t9)) # (2, 3, 4, 5) <class 'tuple'>

3.3 直接使用多个变量获取元组中的元素

1）让变量的个数和元组中的元素个数保持一致

subjects=('Python','Java','H5','UI')
x1,x2,x3,x4=subjects
print(x1,x2,x3,x4) # Python Java H5 UI

p1=(100,200)
x,y=p1
print(x,y) # 100 200

2)让变量的个数小于元组中元素的个数，并且在其中的一个变量前加*

获取的时候先让不带的变量按位置获取对应元素，剩下的全部给有的

student=('小明',18,89,78,23,8,'男')
name,*others,sex=student
print(name,sex) #小明 男
print(others) #[18, 89, 78, 23, 8]

name,age,*s,sex=student
print(name,age,sex)
print(*s) #89 78 23 8
print(s) #[89, 78, 23, 8]

4.元组相关的方法

1）元组.count(元素) - 统计元组中指定元素的个数

2）元组.index(元素) - 获取指定元素对应的下标，有多个，只返回第一个

字典

1.什么是字典（dict）

字典是容器型数据类型（序列）;将{}作为容器的标志，里面多个元素用逗号隔开，

每个元素都是键值对:{键1：值1,键2:值2,…}

字典是可变的（支持增删改）;

字典是无序的（不支持下标操作）

字典真正想要保存的其实是值，键是用来对值进行区分和说明

元素：字典的一个元素是一个键值对

键 - 必须是不可变类型的数据（数字，字符串和元组），但一般使用字符串；

键是惟一的

值 - 可以是任何类型的数据

# 键是不可变的数据
d2={'a':10,10:20,(10,20):30}
# d2={'a':10,10:20,[10,20]:30} #列表不能作为键，TypeError: unhashable type: 'list'
print(d2)
# 键是唯一的
d4={'a':10,'b':20,'a':30}
print(d4) #{'a': 30, 'b': 20}
# 字典是无序的
print({'a': 30, 'b': 20}=={'b': 20, 'a': 10}) # False

2.增删改查

2.1 查 - 获取字典中某个元素的值

1）查单个（只能通过键找值）

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

字典.get(key) - 获取字典中指定key对应的值,key不存在返回None

字典.get(key,默认值) - 获取字典中指定key对应的值,key不存在返回默认值

student={'name':'小明','age':30,'gender':'男','height':175,'weight':73,'grade':65}
print(student['gender']) #男
print(student['weight']) #73
# 如果key不存在会报错
# print(student['score']) #KeyError: 'score'

print(student.get('height')) #173
print(student.get('score')) #None
print(student.get('score',0)) #0

2）遍历

for 变量 in 字典:

循环体

：注意，变量依次取到的值键

for x in student:
    print('x:',x,student[x])

作业

1.创建一个列表，列表中有10个舒宗, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

例如：随机生成了[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
		--- 去重之后 [70, 88, 91, 107, 234, 177, 282, 197]
  	---- 降序排序 [282, 234, 197, 177, 107, 91, 88, 70]

from random import randint
def alone_sort():
    #随机生成列表并打印
    num=int(input('您想生成几个数的随机列表（请输入）：'))
    new_list=[]
    for _ in range(num):
        new_list.append(randint(0,200))
    print('随机生成的列表为：{}'.format(new_list))
    #去重和降序
    for _ in range(num):
        item=new_list.pop()
        if item not in new_list:
            new_list.insert(0,item)
    print('去重后的列表为：{}'.format(new_list))
    print('进行降序后的列表为：{}'.format(sorted(new_list,reverse=True)))

alone_sort()

方法二：

def alone_sort2():
    #随机生成列表并打印
    n = int(input('您想生成几个数的随机列表（请输入）：'))
    nums=[randint(0,200) for x in range(n)]
    print('随机生成的列表为：{}'.format(nums))
    #去重和降序
    new_list=[]
    for x in nums:
        if x not in new_list:
            new_list.append(x)
    print('去重后的列表为：{}'.format(new_list))
    print('进行降序后的列表为：{}'.format(sorted(new_list,reverse=True)))

alone_sort2()

结果：
在这里插入图片描述

2.利用列表推导式, 完成以下需求

a. 生成一个存放1-100中个位数为3的数据列表

结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]

list1=[x+10 for x in range(-7,84,10)]
list2=[x for x in range(3,94,10)]
print(list1)
print(list2)

结果：
在这里插入图片描述

b. 利用列表推到是将列表中的整数提取出来

例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]

list3=[True, 17, "hello", "bye", 98, 34, 21]
new_list=[x for x in list3 if type(x)==int]
#str.isdigit() 
#new_list2=[x for x in list3 if x.isdigit()]
print(new_list)

结果：
在这里插入图片描述

c.利用列表推导式存放指定列表中字符串的长度

例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]

list4=["good", "nice", "see you", "bye"]
new_list=[len(x) for x in list4]
print(new_list)

结果：
在这里插入图片描述

3.已知代码如下，请回答出各个print的结果并说明原因


nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums)) # 这个结果是什么   请描述原因

结果：3  
原因：直接赋值nums2的地址空间和nums一样，执行nums2.pop()时，nums也会进行同样的变化

numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3) # 结果  原因是什么
numlist[-1][0] = 99
print(nums3) # num3会不会发生变化

结果：False
	 [17, 22, 39, 58, [99, 43]]
     
原因：->nums3是通过copy（）方法建立的新列表，序列地址空间与原序列不相同，所以输出结果为False;
	  ->会发生变化，因为是浅拷贝(列表中的列表地址和原来的一样)，想要不变化，用deepcopy（）方法

补充：

is - 判断两个数据的地址是否相等

4.定义一个列表，在列表中保存6个学生的信息(学生信息中包括: 姓名、年龄、成绩(单科)、电话、性别(男、女、不明) )
a.统计不及格学生的个数
b.打印不及格学生的名字和对应的成绩
c.统计未成年学生的个数
d.打印手机尾号是8的学生的名字
e.打印最高分和对应的学生的名字

f.删除性别不明的所有学生

g.将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)

student=[
    {'姓名':'二狗子','年龄':28,'成绩':99,'电话':'12377770008','性别':'不明'},
    {'姓名':'三娃子','年龄':8,'成绩':3,'电话':'12377770009','性别':'女'},
    {'姓名':'水娃','年龄':5,'成绩':4,'电话':'12377771008','性别':'男'},
    {'姓名':'火娃','年龄':6,'成绩':13,'电话':'12377772008','性别':'男'},
    {'姓名':'皮卡丘','年龄':10,'成绩':999,'电话':'12377770007','性别':'不明'},
    {'姓名':'神童','年龄':2,'成绩':999,'电话':'12377770000','性别':'女'}
]
count_grade=0
count_yong=0
max1=0
for x in student:
    #先把需要用到的取出来，后面再用到就不用取了
    name=x['姓名']
    score=x['成绩']
    age=x['年龄']
    tel=x['电话']
    if score<60:
        count_grade+=1
        print(name,':',score,'(不及格)')
        # print('{}:{}(不及格)'.format(x['姓名']),x['成绩'])
    if age<18:
        count_yong+=1
    # if int(tel[-1])%10==8: #转换成整型取余判断也可以
    if list(tel)[-1]=='8':
        print(name,'的手机尾号是8')
        # print('{}的手机尾号是8'.format(x['姓名']))
    if score>max1:
        max1=score
print('有{}个同学不及格'.format(count_grade))
print('有{}个同学未成年'.format(count_yong))
#打印最高分的学生
#自己写逻辑判断
n=len(student)
for x in student:
    score=x['成绩']
    name = x['姓名']
    if score==max1:
        print(name,'获得了最高分')
        # print('{}获得了最高分'.format(i['姓名']))
new_list=[]
for i in range(n):
    #1.直接用del 或者remove() ,n也会相应减少，不好操作
    # if student[i]['性别']=='不明':
        # del student[i]
    #2.自己写逻辑
    if student[i]['性别']!='不明':
        new_list.append(student[i])
print('========================')
for x in new_list:
    print(x)
#从大到小排序(冒泡)
# 1，自己写排序
n=len(student)
for i in range(n):
    for j in range(n-i-1):
        if student[j]['成绩']<student[j+1]['成绩']:
            student[j],student[j+1]=student[j+1],student[j]
print('====================')
for x in student:
    print(x)

结果：

法二：（对法一的优化）

student=[
    {'姓名':'二狗子','年龄':28,'成绩':99,'电话':'12377770008','性别':'不明'},
    {'姓名':'三娃子','年龄':8,'成绩':3,'电话':'12377770009','性别':'女'},
    {'姓名':'水娃','年龄':5,'成绩':4,'电话':'12377771008','性别':'男'},
    {'姓名':'火娃','年龄':6,'成绩':13,'电话':'12377772008','性别':'男'},
    {'姓名':'皮卡丘','年龄':10,'成绩':999,'电话':'12377770007','性别':'不明'},
    {'姓名':'神童','年龄':2,'成绩':999,'电话':'12377770000','性别':'女'}
]
count_grade=0
count_yong=0
for x in student:
    #先把需要用到的取出来，后面再用到就不用取了
    name=x['姓名']
    score=x['成绩']
    age=x['年龄']
    tel=x['电话']
    if score<60:
        count_grade+=1
        print(name,':',score,'(不及格)')
        # print('{}:{}(不及格)'.format(x['姓名']),x['成绩'])
    if age<18:
        count_yong+=1
    # if int(tel[-1])%10==8: #转换成整型取余判断也可以
    if list(tel)[-1]=='8':
        print(name,'的手机尾号是8')
        # print('{}的手机尾号是8'.format(x['姓名']))
print('有{}个同学不及格'.format(count_grade))
print('有{}个同学未成年'.format(count_yong))
#打印最高分的学生
#用推导式做
max2=max([stu['成绩'] for stu in student])
names=[stu['姓名'] for stu in student if stu['成绩']==max2]
print('最高分的学生有：',names)
#筛选符合条件的列表元素（字典），组成新的列表并输出
new_list=[stu for stu in student if stu['性别']!='不明']
print('========================')
#一个一个输出方便控制台查看
for x in new_list:
    print(x)
#成绩从大到小排序
student.sort(key=lambda item:item['成绩'],reverse=True)
print('====================')
for x in student:
    print(x)

结果：
在这里插入图片描述

大地之灯

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python List、tuple和字典（3.9）

常用的列表方法及推导式1.列表.clear() 清空列表（删除列表中的所有元素）比直接赋空值效率高,nums=[1,3,4,5,5]nums.clear()print(nums)2.列表.copy() - 复制原列表产生一个一模一样的新列表，将新列表返回变量保存数据其实是保存的数据在内存空间中的地址将nums中的地址赋给nums1nums1=[23,4,4,56,6]nums2=nums1.copy()# 对nums2进行改变，nums1不会改变del nums2[-1]pr
复制链接

扫一扫

专栏目录