Python学习（四）列表、元组、字典、集合

最新推荐文章于 2024-06-08 17:48:40 发布
最新推荐文章于 2024-06-08 17:48:40 发布
阅读量1k 收藏 4
点赞数 1
文章标签： 学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57085534/article/details/124835817
版权

1.列表的应用场景

        一个变量一次性可以存储一个数据，多个数据要一次性存储则使用列表。

列表可以一次性存储多个数据，且可以为不同的数据类型。但一般存储相同类型（为了后期好控制）

2.列表的格式

        [数据1，数据2，数据3....]

3.列表的常用操作

        3.1查找

                3.1.1下标

a=['tom','cat','pig','dog']
print(a[2])
#结果
pig

                3.1.2函数

        语法：列表序列.index(数据，开始位置下标，结束位置下标）

                index()：返回指定数据所在位置的下标

                count()：统计指定数据在当前列表中出现的次数

                len()：访问列表长度，即列表中数据的个数

a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print(a.index('ox'))
print(a.count('ox'))
print(len(a))
#结果
6#ox的下标位置时6
1#ox出现的次数是1次
8#列表中总共有8个数据

                3.1.3判断是否存在

        in/not in 返回都是bool型，True或False

a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print('tom'in a)
print('a'in a)
print('a'not in a)
#结果
True
False
True

 案例：查找用户输入的名字是否存在

a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的名字')
if name in a:
    print(f'您输入的名字是{name},名字已存在')
else:
    print(f'您输入的名字是{name},请继续下一步')

        3.2增加

作用：增加指定数据到列表中

语法：列表序列.append(数据) ，列表序列.extend(数据)，列表序列.insert(位置下标，数据)

append()： 如果追加的是一个序列，则将整个序列增加在序列中

a=['lily','rose','Julia','jack','kangkang','Maria']
a.append('jesse')
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']
#追加一个序列[1,2]
a=['lily','rose','Julia','jack','kangkang','Maria']
name=[1,2]
a.append(name)
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', [1, 2]]
a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的账号名')
if name not in a:
    a.append(name)
    print(f'您输入的账号{name}不存在，已将您账号进行保存如下：',a)
else:
    print(f'您输入的账号已存在，具体情况如下：',a)
#结果
请输入您的账号名jesse
您输入的账号jesse不存在，已将您账号进行保存如下： ['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']

 extend()：如果追加的数据是一个序列，则会将这个序列的数据拆开，逐一添加到列表。

a=['lily','rose','Julia','jack','kangkang','Maria']
a.extend('name')
a.extend(['name','haha'])
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'n', 'a', 'm', 'e', 'name', 'haha']
#['name','haha']被拆开,name被拆开

insert(位置下标，数据) 

a=['lily','rose','Julia','jack','kangkang','Maria']
a.insert(1,'jesse')
print(a)
#结果
['lily', 'jesse', 'rose', 'Julia', 'jack', 'kangkang', 'Maria']

        3.3删除

         del():        del目标，可以直接删除列表（del 列表；或者del (列表)），也可以删除指定下标的数据：del[下标位置]

a=['lily','rose','Julia','jack','kangkang','Maria']
del a[1]#删除指定位置的数据，用下标来实现
print(a)
#结果
['lily', 'Julia', 'jack', 'kangkang', 'Maria']

        pop()        删除指定下标的数据，如果不加下标，则是删除最后一个

a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop()
print(a1)
#结果a.pop()没有指定位置，则删除的是最后一个数据；会返回这个被删除的数据
Maria
#指定下标删
a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop(1)
print(a1)
print(a)
#结果
rose
['lily', 'Julia', 'jack', 'kangkang', 'Maria']

        remove()        移除列表中某个数据的第一个匹配项

a=['lily','rose','lily','jack','kangkang','Maria']
a.remove('lily')
print(a)
#结果
['rose', 'lily', 'jack', 'kangkang', 'Maria']

        clear()        清空列表

a=['lily','rose','lily','jack','kangkang','Maria']
a.clear(a)
print(a)

        3.4修改

                （1）逆置：reverse()

a=['lily','rose','lily','jack','kangkang','Maria']
a.reverse()
print(a)
#结果：
['Maria', 'kangkang', 'jack', 'lily', 'rose', 'lily']

                （2）排序：sort(key=None，reverse=False)；False表示非逆序，即升序排序；True表示逆序，即降序排序

a=['12','7','3','23','77','33']
a.sort(reverse=True)
print(a)
#结果
['77', '7', '33', '3', '23', '12']

        3.5复制

                函数：copy() 

a=['12','7','3','23','77','33']
b=a.copy()
print(b)
#结果
['12', '7', '3', '23', '77', '33']

4.列表的循环遍历

需求：依次打印列表中的各个数据

        4.1while

a=['tom','maria','rose','jack']
i=0
while i<len(a):
    print(a[i])
    i+=1
#结果
tom
maria
rose
jack

        4.2 for

a=['tom','maria','rose','jack']
for i in a:
    print(i)
#结果
tom
maria
rose
jack

5.列表的嵌套使用

        就是一个列表里面包含了其他的子列表

应用场景：要存储一、二、三，三个班级学生姓名，且每个班级的学生姓名在一个列表，查找某一个学生姓名

a=[['tom','maria'],['yes','no'],['jack','rose']]
print(a[1][0])
#结果
yes

案例：随机分配办公室——有三个办公室，将8位老师随机分配到这个三个办公室 

#有三个办公室，有8位老师，将这8位老师随机分配到办公室里去
import random  
teachers=['a','b','c','d','e','f','g','h']
offices=[[],[],[]]
for name in teachers:
    num=random.randint(0,2)   #三个列表，所以0-2
    offices[num].append(name)  #将随机在0，1，2的列表中添加name
#办公室i的人数
i=1
for office in offices:   #如果子列表office在offices中，进入循环
    print(f'办公室{i}的老师是：')  #输出办公室的编号i
    for name in office:      #如果人在子列表office中
        print(name)          #输出具体的人名
    i += 1                   #办公室编号加1，继续输出人名
#结果
办公室1的老师是：
d
办公室2的老师是：
c
e
f
g
办公室3的老师是：
a
b
h

6.元组

        元组的应用场景：存储多个数据，但是这些数据是不能修改的数据

a=('a','c','b')    #多个数据的元组
b=('a')
c=('a',)            #单个数据的元组
print(a,type(a))
print((b,type(b)))
print(c,type(c))
#结果
('a', 'c', 'b') <class 'tuple'>
('a', <class 'str'>)             #说明单个数据的元组也要加“，”，不然会变成是这个数据的类型str
('a',) <class 'tuple'>

7.元组的常见操作

        元组只支持查找操作，统计操作（统计出现次数，统计长度）

a=('a','c','b')
print(a.index('c'))
print(len(a))
print(a.count('b'))
#结果
1        #c在下标为1的位置
3        #a元组总共3个
1        #b出现的次数是1

        元组的数据直接修改是会报错的；但是可以修改元组内列表的数据，但尽量避免修改

a=('a','c','b',['d','e'])
a[3][1]='f'  #修改元组里面列表的数据，将e改为f
print(a)
#结果
('a', 'c', 'b', ['d', 'f'])

8.字典

        8.1.字典的应用场景：有多个数据，存储的位置变换了，不改查找代码也能查到这个数据

字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

        8.2.创建字段的语法

        符号为大括号{}，数据为键值对形式出现，各个键值对之间用逗号隔开

        有数据字典：a={'a','b','c'}；空字典：a={}

i={'a':'tom','b':'jack','c':'rose'}
w={}
q=dict()
print(i,type(i))
print(w,type(w))
print(q,type(q))
#结果：
{'a': 'tom', 'b': 'jack', 'c': 'rose'} <class 'dict'>
{} <class 'dict'>
{} <class 'dict'>

        8.3.字典的常见操作

                8.3.1增加

        字典序列[key]=值；如果key存在则修改这个key对应的值，如果key不存在则新增此键值对

i={'a':'tom','b':'jack','c':'rose'}
i['hah']='yes'    #不存在，则直接新增
print(i)
i['a']='cat'      #存在，则在之前的基础上修改
print(i)
#结果：
{'a': 'tom', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#没有hah，直接新增
{'a': 'cat', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#将a的值tom改为了cat

               8.3.2删除

        del/del()；clear()

i={'a':'tom','b':'jack','c':'rose'}
del i['b']# 或者del(i['a'])
print(i)
i.clear()
print(i)
#结果
{'a': 'tom', 'c': 'rose'}    #删除b的键值对
{}        #清空字典

                8.3.3修改

        字典序列[key]=值

        新增和修改的用法是一样的，存在则修改，不存在则新增

i={'a':'tom','b':'jack','c':'rose'}
i['a']='cat'
print(i)
#修改值结果
{'a': 'cat', 'b': 'jack', 'c': 'rose'}

              8.3.4查找

                        8.3.4.1 key值查找：当前查找的key存在，则返回对应的值，否则报错

i={'a':'tom','b':'jack','c':'rose'}
print(i['a'])
print(i['d'])
#结果
tom
Traceback (most recent call last):        #没有就直接报错
  File "D:\工作\python script\字典.py", line 3, in <module>
    print(i['d'])
KeyError: 'd'

                      8.3.4.2 get()函数查找：如果当前查找的key不存在，则返回第二个参数（默认值），如果省略第二个参数，则返回None

i={'a':'tom','b':'jack','c':'rose'}
print(i.get('a'))
print(i.get('jac'))
print(i.get('jac','找不到'))
#结果
tom
None    #找不到就返回None
找不到    #找不到就返回第二个参数（默认值）：找不到

                    8.3.4.3 keys() ：查找字典中所有的key，返回可迭代对象

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())        #查找字典中所有的key，返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])

                    8.3.4.4 values() :查找字典中所有的值，返回可迭代对象

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values())        #查找字典中所有的value，返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])

                    8.3.4.5items()：查找字典中所有的键值对，返回可迭代对象

        里面的数据是元组，元组数据1是字典的key，元组数据2是字典的value

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values())
print(i.items())    #查找字典中所有的键值对，返回可迭代对象，里面的数据是元组
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])
dict_items([('a', 'tom'), ('b', 'jack'), ('c', 'rose')])#元组数据1是字典的key，元组数据2是字典的value

        8.4.字典的循环遍历

                8.4.1遍历字典的key

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
for key in i.keys():
    print(key)
#结果
dict_keys(['a', 'b', 'c'])
a
b
c

                8.4.2遍历字典的value

i={'a':'tom','b':'jack','c':'rose'}
print(i.values())
for values in i.values():
    print(values)

#结果
dict_values(['tom', 'jack', 'rose'])
tom
jack
rose

                8.4.3遍历字典的键值对

i={'a':'tom','b':'jack','c':'rose'}
for a in i.items():
    print(a)
#结果
('a', 'tom')
('b', 'jack')
('c', 'rose')

                8.4.4遍历字典的键值对（拆包）

i={'a':'tom','b':'jack','c':'rose'}
for key,value in i.items():
    print(f'{key}={value}')
#结果
a=tom
b=jack
c=rose

9.集合

        创建集合使用{}或set()；但如果要创建空集合，只能用set()，因为{}是用来创建空字典的

集合里面有重复的会去重

i={1,2,3,4,1,2}    #集合里面有重复的数据
print(i,type(i))
#结果
{1, 2, 3, 4} <class 'set'>    #会去重

集合里面是没有顺序的

i={1,2,3,4,6,5}
q={10,34,20,45,50,43}
p={1,2,3,4,5}
w=set('abcdefg')
print(i,type(i))
print(q)
print(p)
print(w)
#结果
{1, 2, 3, 4, 5, 6} <class 'set'>
{34, 50, 20, 10, 43, 45}
{1, 2, 3, 4, 5}
{'d', 'g', 'f', 'c', 'e', 'a', 'b'}

10.集合的常见操作方法

        10.1增加

        1、add()，增加的只能是单一数据，不能是数组，会报错；且增加相同的数据，会去重。

        2、update()，增加的数据是序列，如果写单一数据的话，会报错

i={1,2,3,4,6,5}
q=i.add('hah')
w=i.update([100,'hahaha'])
print(i)
#结果
{1, 2, 3, 4, 5, 6, 'hahaha', 'hah', 100}

        10.2删除数据

        1、pop()，随机删除某个数，如果pop是删除不存在的数据，则会报错 

i={10,20,13,14,16,15}
q=i.pop()
print(i)
#结果
{20, 10, 13, 14, 15}

        2、remove()，指定数删除，如果remove是删除不存在的数据，则会报错 

i={1,2,3,4,6,5}
q=i.remove(2)
print(i)
#结果
{1, 3, 4, 5, 6}

        3、discard()，指定数删除，即是删除的数据不存在，也不会报错

i={10,2,3,4,6,5}
q=i.discard(100)    #删除的数据不存在，也不会报错
print(i)
#结果
{2, 3, 4, 5, 6, 10}

        10.3查找

        in：在集合里；not in ：不在集合里；返回的是bool值

i={10,20,13,14,16,15}
print(1 in i)
print(10 in i)
print(10 not in i)
#结果
False
True
False

Tsai_1230
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python基本数据类型之列表、元组、字典、集合常见应用
qq_41845402的博客
09-04 794
Python基本数据类型之列表、元组、字典、集合常见应用
python中字符串、元组、列表、集合和字典区别和使用
Mr.熊熊
11-03 1500
字符串、元组、列表、集合和字典都可以通过索引访问其中的元素。可以使用切片操作来获取子序列。可以使用内置函数和方法对它们进行操作和处理。
Python 中的字符串、列表、元组和字典数据类型的特点和使用场景
最新发布
xy520521的博客
06-08 639
字典适用于存储多个相关的键值对，比如存储一个人的姓名、年龄、性别等信息。列表适用于存储多个相关或无关的元素，比如存储一个班级的学生姓名、一个购物车的商品等。元组适用于存储多个相关的元素，比如存储一个点的坐标、一本书的作者和出版日期等。元组（tuple）是一种不可变的序列类型，由多个元素组成。字典（dict）是一种可变的无序容器类型，由键值对组成。列表（list）是一种可变的序列类型，由多个元素组成。字符串（str）是一种不可变的序列类型，由字符组成。字符串适用于存储文本信息，比如存储名字、句子、网址等。
Python基础语法、内建数据结构列表、元组、字典、集合的讲解及应用（附源码 超详细必看）
showswoller的博客
01-05 484
Python基础语法、内建数据结构列表、元组、字典、集合的讲解及应用（附源码 超详细必看）
【从零学习python 】19. 循环遍历列表和列表嵌套的应用
全栈若城,专注知识分享
08-14 9204
本文介绍了使用循环遍历列表的两种方式，包括使用while循环和for循环。同时还讲解了交换两个变量的值的方法。此外，还介绍了列表的嵌套概念，并提供了一个示例代码演示如何操作被嵌套的列表。最后，通过一个随机分配办公室的案例展示了列表的实际应用场景。
字典如何取key和value,同时讲解for循环取值
qq_40024178的博客
07-28 6471
例题1： b = {"aa":11,"bb":22,"cc":33} #取aa的值value值 print(b["aa"]) 输入结果：11 #取字典b里面key值中的aa i = list(b.keys())[0]#list构建一个列表，里面包含字典，结果取列表第一个key值 print(i) 输入结果：aa #取全部key值 key = list(b.keys())[0:4] print(key) 输出结果：['aa', 'bb', 'cc'] 插入小知识for循环语法： for itera.
老男孩 Python 自动化开发 02 Python数据结构 列表 元组 字典 集合 共16页.pptx
09-12
列表、元组、字典的使用 集合的妙用 函数基础 作业 S.find(substring, [start [,end]]) #可指范围查找子串，返回索引值，否则返回-1  S.rfind(substring,[start [,end]]) #反向查找  S.index(substring,...
python容器:列表，元组，字典，集合的思维导图
02-27
python容器:列表，元组，字典，集合的思维导图
Python的学习心得和知识总结（三）|Python基础（列表、元组、字典和集合）
01-20
序列 什么是序列 列表（List）是什么 列表对象的常用方法列表对象的四种创建列表元素的增加删除列表元素的访问计数列表对象的切片操作列表元素的排序逆序列表相关的内置函数 多维列表(List的延伸) 二维列表 元组...
python 元组、集合与字典
12-22
列表、元组、字符串属于序列，字典属于映射，集合不属于2者其中之一。 在序列中，每个元素都有编号。 1、元组（tuple） 与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容...
python变量 数据类型 列表 元组 字典
12-22
python变量 数据类型 列表 元组 字典变量数据类型数据拼接列表添加列表元素修改元素删除列表元素组织列表确定列表长度创建数值列表操作列表元组元组拼接元组转列表字典创建字典列表取值字典删除增加修改 变量 变量...
列表（list）、元组（tuple）、字典（dict）、集合（set）的使用
agsgjsghusfg的博客
04-22 1586
列表（list） 列表就是由一系列特定顺序排序的元素组成。列表里面可以包含数字，字母等等，也可以将任何东西加入到列表中。元素之间可以没有任何关系。 创建第一个列表 在python中，用中括号“[]”来表示列表，并且里面的元素要用逗号隔开。来一个例子： ls = ['A','a',1,2,'蟒蛇'] print("数据类型:",type(ls)) print("返回结果:",ls) # 输出的结果为: ''' 数据类型: <class 'list'> 返回结果: ['A', 'a',
Python——列表，元组，字典，集合的相关操作总结
weixin_57238265的博客
04-06 2747
j最近看了python的相关理论，总觉得看一章写一页的手写笔记差点意思，今天刚好把该追的电视剧追完了，就来写个总结吧！作为我CSDN的开端~ 目录 1.简单介绍 1.1 列表（list）： 1.2 元组（tuple）： 1.3 字典（dict ）： 1.4 集合（set）： 2.创建 2.1 创建列表 2.2 创建元组 2.2 创建字典 2.4 创建集合 3.查找 3.1 查找列表元素 3.2 查找元组元素 3.3 查找字典元素 3.4查找集合元素 4.添加 ...
Python 列表，元组，字典，集合的特点及使用
So_that的博客
11-01 4704
一 列表 列表是一组任意类型的值，按照一定的顺序组合而成； 通过索引来标识元素，第一个索引为0；需要注意的是索引可以是负值； 列表中元素是任意类型的，包括列表类型； 可以进行合并，删除，索引，切片等操作； 定义列表使用中括号； 定义空列表 list=[] 增加元素 append（尾部增加） list.append(1) list.append(2) print(list) in...
Python基础入门——元组、列表、集合、字典的使用方法
dy_yx的博客
05-14 838
元组与列表 Python的序列类型包括字符、列表与元组等。 所有序列都支持迭代。 序列表示索引为非负整数的有序对象集合。 字符和元组属于不可变序列，列表可变。数据类型的可变与不可变将在下一篇博客中为大家介绍。 序列类型有12个通用的操作符和函数 操作符 描述 x in s 如果x是s的元素，返回True，否则返回False x not in s 如果x不是s的元素，返回Tr...
python中列表、元组、字典、集合的使用
ISmileLi的博客
01-05 3830
一、定义与特性 1、列表：列表是一组有序存储的数据，它的特性包括：(1、和一般的变量一样都有唯一的标识命名称；(2、列表中的元素都是相同类型的；(3、列表元素都有索引和值两个属性，索引从0开始，每个索引都对应一个值；(4、有中括号括起来元素，元素之间有逗号隔开。 2、元组：(1、一经定义内容无法改变；(2、元组元素可以是不同的类型；(3、元组使用圆括号括起来元素。 3、字典：(1、字典是在内存中保...
Python基础教程：keys()、values()和 items()方法
python学习者的博客
02-27 2611
有3个字典方法，它们将返回类似的列表值，分别对应于字典的键、值和键-值对：keys()、values()和 items()。 这些方法返回的值不是真正的列表，它们不能被修改，没有append()方法。但这些数据类型可以用于for循环。 1、values()方法，示例代码： spam = {'color': 'red', 'age': 42} for v in spam.values(): print(v) 运行结果： red 42 这里，for循环迭代了spam字典中的每个值。 2、keys()
python中用dict和dict.keys()查找目标值的不同
weixin_44849034的博客
09-17 2305
文章目录python中用dict和dict.keys()查找目标值 python中用dict和dict.keys()查找目标值 在python字典中进行查找操作时，通常用 xx in dict 或 xx in dict.keys() 方法，但这两种方法在内部实现与运行速度上存在不同。 下面是我在LeetCode题目49中遇到的情况： class Solution(object): def groupAnagrams(self, strs): """ :type strs:..
Python列表、元组、集合、字典的区别
做一个乐于分享的程序员
08-29 8425
Python列表、元组、集合、字典的区别和使用场景
python列表元组字典集合
09-06
在Python编程语言中，有四种常用的集合数据类型，它们分别是列表(List)、元组(Tuple)、字典(Dictionary)和集合(Set)。列表是一种有序和可更改的集合，允许重复的成员。元组是一种有序且不可更改的集合，也允许重复的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值