Python 列表元组和字典

最新推荐文章于 2022-06-06 15:44:43 发布

头发莫的了呀

最新推荐文章于 2022-06-06 15:44:43 发布

阅读量209

点赞数

分类专栏： python 文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/m0_56444183/article/details/122550414

版权

python 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、列表
二、元组
三、字典

一、列表

1. 什么是列表

序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推；
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现；
列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2. 访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推；
通过索引列表可以进行截取、组合等操作。

mark

示例

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

#输出结果
red
green
blue

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

mark

示例

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

#输出结果
black
white
yellow

使用下标索引来访问列表中的值，同样你也可以使用方括号[]的形式截取字符，如下所示：

mark

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

#输出结果
[10, 20, 30, 40]

使用负数索引值截取，如下

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
 
print ("list[1]: ", list[1])				# 读取第二位
print ("list[1:-2]: ", list[1:-2])			# 从第二位开始（包含）截取到倒数第二位（不包含）

#输出结果
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

3. 列表的赋值

#示例
lst=[1,2,3,4,5,6]

lst.append(10)								#列表末尾追加10
lst.append(8)								#列表末尾追加8
lst[0:2]=7,9								#把下标0和2的值1，2替换成7，9
print(lst)

#输出结果
[7, 9, 3, 4, 5, 6, 10, 8]
------------------------------------------------------------------------------------------------
list.append(元素)  							#在列表尾部追加元素
list[index]=元素  							#把对应下标的值改为元素
list[index]=元素1,元素2 						#默认变为元组插入该位置
list[index1,index2]=元素1,元素2 				#会按位插入
list[index1,index2]=元素1,元素2,元素3... 		#会替换插入
list[index1,index2]=元素1					#值比位置少的情况下不能插入，会报错

3.1 在列表中增加元素

在列表中增加元素的方式有多种，具体如下:
① 通过append可以向列表添加元素。
② 通过extend可以将另一个列表的元素添加到列表中
③ 通过insert可以在指定位置前插入元素。

PS： insert 消耗资源多，尽量避免使用

示例

lst=[1,2,3,4,5]
lst2=[50,90,80]
lst.extend(lst2)			   #在lst后面追加lst2的值
print(lst)

#输出结果
[1, 2, 3, 4, 5, 50, 90, 80]

#add和extend的区别在于，extend是直接将值加入到lst当中了，而add会返回追加后的结果，并且原本的值是不变的
lst=[1,2,3,4,5]
lst2=[50,90,80]
a=lst.__add__(lst2)				#用a来接收它返回的值
print(lst.__add__(lst2))	
print(a)

#输出结果
[1, 2, 3, 4, 5, 50, 90, 80]
[1, 2, 3, 4, 5, 50, 90, 80]

lst=[1,2,3,4,5]
lst.append(10)
lst.append(8)
print(lst)
lst.insert(0,66)        #在下标为0的位置插入66
print(lst)

#输出结果
[1, 2, 3, 4, 5, 10, 8]
[66, 1, 2, 3, 4, 5, 10, 8]

3.2 在列表中查找元素

在列表中查找元素的运算符包括：

in 如果存在那么结果为True，否则为False
not in 如果不存在那么结果为True，否则为False

lst=[1,2,3,4,5]
print(5 in lst)
print(6 in lst)
print(5 not in lst)
print(6 not in lst)
print(lst.index(4))			#index也可以查找元素，并且可以查到在哪个位置

#输出结果
True
False
False
True
3

3.3 在列表中修改元素

列表元素的修改也是通过下标来实现的

示例

lst=[1,2,3,4,5]
lst[1],lst[3]=22,66
lst[0:5]=55,66				#多个元素替换多个位置的值

print(lst)

#输出结果
[1, 22, 3, 66, 5]
[55, 66]

3.4 在列表中删除元素

删除列表元素的常用方法有三种，具体如下：

del ：根据下标进行删除

lst=[1,2,3,4,5]

del lst[0]
print(lst)
del lst[0:3]		#批量删除
print(lst)

#输出结果
[2, 3, 4, 5]
[5]

pop ：删除最后一个元素

lst=[1,2,3,4,5]

lst.pop()				#也可以指定下标删除
print(lst)

#输出结果
[1, 2, 3, 4]

remove ：根据元素的值删除

lst=[1,2,3,4,5]

lst.remove(3)			#根据指定的值来删除
print(lst)

#输出结果
[1, 2, 4, 5]

4. 列表的循环遍历

4.1 random 随机数

random() 方法返回随机生成的一个实数，它在[0,1)范围内。

random() 的语法:

import random
random.random()

示例

import random
lst=[]
for i in range(5):
    lst.append(random.randint(0,100))
print(lst)

#输出结果
[0, 39, 99, 70, 30]

4.2 列表的循环遍历

当随机数的范围过大的时候，不太便于查找使用，这时候就需要使用到遍历

使用 for 循环遍历列表

#生成随机列表
lst=[]
for i in range(5):
    lst.append(random.randint(0,100))
print(lst)

#列表的遍历
 for x in lst:
     print(x)

#输出结果
[50, 54, 36, 23, 87]
50
54
36
23
87
---------------------------------------------------------------------------------------------
#使用长度遍历
for x in range(lst.__len__()):    #lst.__len__()代表lst的长度，为5，也就是下标0到4的值
    print(lst[x])

#输出结果
[50, 54, 36, 23, 87]
50
54
36
23
87

使用 while 循环遍历列表

names_list=['xiaowang','xiaozhang','xiaohua']
length=len(names_list)
i=0
while i < length:
    print(names_list)
    i+=1
#输出结果
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang', 'xiaohua']

除了遍历我们还可以用来批量更改列表中的值

for x in range(lst.__len__()):
   lst[x]+=1

for x in lst:
    print(x)

#输出结果
[26, 81, 54, 22, 2]
27
82
55
23
3

两种方式的区别

lst=[]
for i in range(5):
    lst.append(random.randint(0,100))
print(lst)
------------------------------------------------------------------------------------------------
#type1:
for x in lst:					#x是个临时变量，只是lst中每个元素的复制
print(x)						#对复制的操作不能影响到元素本身
    							#但是如果传入的是地址，对其内容的改变是会传递到外部的
 
#type2:
for x in range(lst.__len__()):
    print(lst[x])				#lst[x]操作的是lst元素本身

#输出结果						#可以看到返回的结果，值并没有发生变化
[17, 77, 67, 85, 40]
17
77
67
85
40

5. 列表的排序操作

5.1 升序和降序排序

列表的排序可以通过以下两个方式来实现：
① sort 方法：列表的元素按照特定的顺序排列
② reverse 方法：将列表逆置

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法

list.sort(cmp=None, key=None, reverse=False)

#参数
cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

示例

#方法一：
lst=[24, 37, 91, 95, 71]

lst.sort(reverse=True)				#降序排序
print(lst)

#输出结果
[95, 91, 71, 37, 24]
-------------------------------------------------------------------------------------------------
#方法二：
lst=[24, 37, 91, 95, 71]
lst.sort()
lst.reverse()
print(lst)

#输出结果
[95, 91, 71, 37, 24]

5.2 冒泡排序

双重循环
外循环控制比较轮数
内层循环控制每轮比较次数

lst= [15, 24, 6, 52, 88]

for x in range(len(lst)-1):					#最后一轮只剩一个元素，不需要比较，因此-1
    for y in range(len(lst)-x-1):
#每轮都能确定一个最大值，所以每轮减少一次比较   
        if lst[y]>lst[y+1]:
            tmp=lst[y]
            lst[y]=lst[y+1]
            lst[y+1]=tmp
print(lst)

#输出结果
[6, 15, 24, 52, 88]

5.3 选择排序

选择排序：每次从前向后遍历，找到一个最小值，与该位置交换

import random

lst=[]
for x in range(10):
    lst.append(random.randint(0,100))
print(lst)

for x in range(len(lst)-1):                 #最后一个位置不需要比较
    tmp=lst[x]                              #每一轮定一个初始值，目的是为了和后面的值进行比较
    idx=x
    for y in range(x+1,len(lst)):           #从初始值处向后遍历
        if(tmp>lst[y]):                     #为了在一轮中找出最小值
            tmp=lst[y]                      #最小值保存在tmp中
            idx=y                           #下标保存在idx中
    else:
        lst[idx]=lst[x]                     #根据最小值下标，把初始值放进去
        lst[x]=tmp                          #把最小值放入初始位置中
print(lst)

#输出结果
[60, 34, 83, 72, 96, 66, 3, 25, 57, 13]
[3, 13, 25, 34, 57, 60, 66, 72, 83, 96]

5.4 插入排序

插入排序逻辑示例

#在一个有序数组中插入值并保持顺序
arr=[10,20,30,50,80]
a=int(input("请输入一个整数"))
arr.append(a)
idx=len(arr)-1
while idx>0:
    #从后向前遍历
    idx-=1
    #遇到比自己小的，则在后方插入
    if a>arr[idx]:
        arr[idx+1]=a
        break
    #遇到比自己大的，大的值向后移动
    else:
        arr[idx+1]=arr[idx]
    #如果到最后都没有插入，则插入在首位
    if idx==0:
        arr[0]=a
print(arr)

#输出结果
请输入一个整数5
[5, 10, 20, 30, 50, 80]

请输入一个整数888
[10, 20, 30, 50, 80, 888]

插入排序示例

刚开始一个元素，即为有序，每次加入一个元素，形成新的序列，应用插入元素的逻辑，使其继续有序

import random

lst=[]
for x in range(10):
    lst.append(random.randint(0,100))
print(lst)
for x in range(1,len(lst)):
    idx=x
    tmp=lst[x]
    while x>0:
        x-=1
        if tmp>=lst[x]:
            lst[x+1]=tmp
            break
        else:
            lst[x+1]=lst[x]
        if x==0:
            lst[0]=tmp
print(lst)

#输出结果
[46, 38, 42, 57, 40, 37, 59, 57, 75, 35]
[35, 37, 38, 40, 42, 46, 57, 57, 59, 75]

6. 列表的嵌套

列表的嵌套指的是一个列表的元素又是一个列表

示例

school_names = [['北京大学','清华大学'],['南开大学','天津大学','天津师范大学'],['山东大学','中国海洋大学']]
#嵌套列表的遍历
for x in school_names:
    for y in range(len(x)):
        print(x[y])

或

for x in range(len(school_names)):
    for y in range(len(school_names[x])):
        print(school_names[x][y])

或

for x in school_names:
    for y in x:
        print(y)

#输出结果
北京大学
清华大学
南开大学
天津大学
天津师范大学
山东大学
中国海洋大学

二、元组

1. 什么是元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号包裹元素，列表使用方括号包裹元素。

2. 元组的基本操作

示例

tpl=(1,2,3,4,5,6)
print(tpl[0])
print(tpl[0:3])
print(tpl[0:5:2])

#输出结果
1
(1, 2, 3)
(1, 3, 5)

tpl=(1,2,3,4,5,6)
tpl[0]=5
print(tpl)

#输出结果我们发现报错，因为元组中的元素不能被修改

在这里插入图片描述

把元组改为列表

tpl=(1,2,3,4,5)
print(list(tpl))

#输出结果
[1, 2, 3, 4, 5]

3. 元组的内置函数

方法	描述
len(tuple)	计算元组元素个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(seq)	将列表转为元组

示例

tpl=(1,2,3,4,5)

print(len(tpl))
print(max(tpl))
print(min(tpl))

#输出结果
5
5
1

4. 元组的循环遍历

tpl=(1,2,3,4,5)

for x in tpl:
    print(x)

#输出结果
1
2
3
4
5

三、字典

1. 什么是字典

字典是一种存储数据的容器，它和列表类似，都可以存储多个数据。

示例
info = {'name':'班长','sex':'f','address':'北京'}

字典的每个元素是由键和值组成的，例如，上面的’name’为键，‘班长为值’

注意：
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict；
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

2. 字典的基本操作

2.1 根据键访问值

示例

info={'name':'班长','sex':'f','address':'北京'}

print(info['sex'])
print(info['address'])

#输出结果
f
北京

当我们想获取某个键对应的值但又不确定该键是否存在时，可以使用get方法获取

d={"name":"大黄","age":5,"strain":"拉布拉多"}         			#json字符串
print(d.get("birthday"))
print(d.get("name"))
#输出结果
None
大黄

2.2 添加和修改字典的元素

示例

d={"name":"大黄","age":5,"strain":"拉布拉多"}
d["name"]="川普"						#修改元素
d["birthday"]="2021-1-17"			#添加元素
print(d)

#输出结果
{'name': '川普', 'age': 5, 'strain': '拉布拉多', 'birthday': '2021-1-17'}

d={"name":"大黄","age":5,"strain":"拉布拉多"}
print(d)
d.setdefault("abc","sorry")					#如果key已经存在，则不做任何操作，如果key不存在，则以默认值插入
print(d)

#输出结果
{'name': '大黄', 'age': 5, 'strain': '拉布拉多'}
{'name': '大黄', 'age': 5, 'strain': '拉布拉多', 'abc': 'sorry'}

2.3 删除字典的元素

del:删除字典。字典直接从内存中删除，无法再根据键访问值。
clear:清空字典的元素。字典仍存在于内存中，但其中没有任何元素。

d={"name":"大黄","age":5,"strain":"拉布拉多"}
del d["strain"]				#删除"strain"键和值
print(d)
d.clear()					#清空字典的元素
print(d)

#输出结果
{'name': '大黄', 'age': 5, 'strain': '拉布拉多'}
{'name': '大黄', 'age': 5}
{}

2.4 获取字典的键视图

keys() 方法可以获取字典的键视图，以实时反映字典中键的变化

示例

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
print(keys)

dct.setdefault("birthday","2022-01")			#添加一个键值
print(keys)


#输出结果
dict_keys(['name', 'age', 'gender', 'id'])
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])

遍历字典的键

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
dct.setdefault("birthday","2022-01")
for k in keys:
    print(k+":",dct[k])

#输出结果
name: zhangsan
age: 18
gender: male
id: 10
birthday: 2022-01

2.5 获取字典的值视图

values() 方法可以获取字典的值视图，以实时反映字典中值的变化。

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
dct.setdefault("birthday","2022-01")
values=dct.values()
print(values)
#以列表的形式展现出来，只有值没有键
#输出结果
dict_values(['zhangsan', 18, 'male', 10, '2022-01'])

动态实时的显示更改的结果

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")
values=dct.values()
dct.setdefault("now","2022-01")
print(values)

#输出结果
dict_values(['zhangsan', 18, 'male', 10, '2022-01', '2022-01'])

2.6 获取字典的元素视图

items() 方法可以获取字典的元素视图，以实时地反映字典中键值对的变化。

示例

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")
itms=dct.items()
print(itms)

#输出结果
dict_items([('name', 'zhangsan'), ('age', 18), ('gender', 'male'), ('id', 10), ('birthday', '2022-01')])

遍历字典的键值对

dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")

itms=dct.items()
print(itms)

for x,y in itms:
    print(x+":",y)

#输出结果
dict_items([('name', 'zhangsan'), ('age', 18), ('gender', 'male'), ('id', 10), ('birthday', '2022-01')])
name: zhangsan
age: 18
gender: male
id: 10
birthday: 2022-01

3. 字典的遍历

3.1 遍历字典的键

dict_demo={'Name':'Lisi','Age':18}
for key in dict_demo.keys():
    print(keys)

#输出结果
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])

3.2 遍历字典的值

dict_demo={'Name':'Lisi','Age':18}
for value in dict_demo.values():
    print(value)

#输出结果
Lisi
18

3.3 遍历字典的元素

dict_demo={'Name':'Lisi','Age':18}
for item in dict_demo.items():
    print(item)

#输出结果
('Name', 'Lisi')
('Age', 18)

3.4 遍历字典的键值对

dict_demo={'Name':'Lisi','Age':18}
for key,value in dict_demo.items():
    print("key=%s,value=%s"%(key,value))

#输出结果
key=Name,value=Lisi
key=Age,value=18

头发莫的了呀

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python 列表元组和字典

文章目录一、列表概述1. 什么是列表2. 访问列表中的值3. 列表的赋值3.1 在列表中增加元素3.2 在列表中查找元素3.3 在列表中修改元素3.4 在列表中删除元素二、列表的循环遍历一、列表概述1. 什么是列表序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推；列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现；列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔
复制链接

扫一扫