python中的序列、列表、元组、字典

最新推荐文章于 2024-08-05 17:04:33 发布

冰鑫999

最新推荐文章于 2024-08-05 17:04:33 发布

阅读量292

点赞数 5

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/imouse728/article/details/140845125

版权

python 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

1 序列
- 切片
2 列表
3 元组
字典

1 序列

序列是用于存储多个值的连续空间，每个值都对应一个整数的编号称为索引
索引分为正向递增索引、反向递减索引。
在这里插入图片描述

s='helloworld'

# 正向索引
for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
print('\n')

# 反向索引
for i in range(-10,0):
    print(i,s[i],end='\t\t')

输出
在这里插入图片描述

切片

语法：

序列[start:end:step]

start：切片开始索引
end：切片结束索引
step：步长

s='HELLOWORLD'
print(s[0],s[-10]) # 序号0与-10表示的是同一个字符
print('北京欢迎您'[4])  # 您
print('北京欢迎您'[-1])  # 您
print(s[2:7]) # 从2开始7结束，但不包含7
print(s[-8:-3]) # 反向 从-8到-3，但不包含-3
print(s[:5]) # 从0开始到5结束，但是不包含5
print(s[5:]) # 从5开始到结尾

输出
H H
您
您
LLOWO
LLOWO
HELLO
WORLD

2 列表

指一系列的按特定顺序排列的元素组成
在python中内置的可变序列
在python中使用[]定义列表，元素与元素之间使用英文的逗号隔开
列表中的元素可以是任意的数据类型

创建

使用[ ]创建列表

列表名=[element1,element2,...... elementN]

使用内置函数list()创建列表

列表名=list(序列）

demo

lst=['e1','e2','e3','e4',1,2,3,4]
print(lst)

lst2=list('hello')
print(lst2)

lst3=list(['h','e','l'])
print(lst3)

lst4=list(range(1,10,2))
print(lst4)

输出
在这里插入图片描述

列表生成式的创建

lst=[expression for item in range]
lst=[expression for item in range if condition]

import random
lst=[item for item in range(1,11)]
print(lst)

lst1=[item*item for item in range(1,11)]
print(lst1)

lst2=[random.randint(1,100) for _ in range(10)]
print(lst2)

# 从列表中选择符合条件的元素组成新的列表
lst3=[i for i in range(10) if i%2==0]
print(lst3)

输出
在这里插入图片描述

删除

del 列表名

列表的操作方法

列表数据类型支持很多方法，列表对象的所有方法所示如下：

list.append(x)
在列表末尾添加一个元素，相当于 a[len(a):] = [x] 。

list.extend(iterable)
用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable 。

list.insert(i, x)
在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0, x) 在列表开头插入元素， a.insert(len(a), x) 等同于 a.append(x) 。

list.remove(x)
从列表中删除第一个值为 x 的元素。未找到指定元素时，触发 ValueError 异常。

list.pop([i])
移除列表中给定位置上的条目，并返回该条目。如果未指定索引号，则 a.pop() 将移除并返回列表中的最后一个条目。如果列表为空或索引号在列表索引范围之外则会引发 IndexError。

list.clear()
删除列表里的所有元素，相当于 del a[:] 。

list.index(x[, start[, end]])
返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时，触发 ValueError 异常。

可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。

list.count(x)
返回列表中元素 x 出现的次数。

list.sort(*, key=None, reverse=False)
就地排序列表中的元素（要了解自定义排序参数，详见 sorted()）。

list.reverse()
翻转列表中的元素。

list.copy()
返回列表的浅拷贝。相当于 a[:] 。

demo


fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print('fruits.count(\'apple\')===',fruits.count('apple'))
print("fruits.count('tangerine')===",fruits.count('tangerine'))
print("fruits.index('banana')===",fruits.index('banana'))

# Find next banana starting at position 4
print("fruits.index('banana', 4)===",fruits.index('banana', 4))

fruits.reverse()
print(fruits)

fruits.append('grape')
print(fruits)

fruits.sort()
print(fruits)

fruits.pop()
print(fruits)

输出
在这里插入图片描述

列表的遍历


lst6=['hello','python','how','are','you']
for item in lst6:
    print(item)

print('-'*40)

for i in range(0,len(lst6)):
    print(i,'=',lst6[i])

print('-'*40)

for index,item in enumerate(lst6):
    print(index,'=',item)
print('-'*40)
# 手动修改序号的起始值
for index,item in enumerate(lst6,start=2):
    print(index,'=',item)

输出
在这里插入图片描述

二维列表

lst=[
    ['00','01','02','03'],
    ['10','11','12','13'],
    ['20','21','22','23'],
    ['30','31','32','33']
]
print(lst)

# 遍历
for row in lst:
    for i in row:
        print(i,end='\t')
    print()

输出
在这里插入图片描述

3 元组

是python中内置的不可变序列
在python中使用()定义元组，元素与元素之间使用英文逗号分隔
元组中只有一个元素的时候，逗号也不能省略

创建

（1）使用()直接创建元组

元组名=(element1,element2,... elementN)

（2）使用内置函数 tuple()创建

元组名=tuple(序列）

demo

t=('e1','e2',[1,3,4],'e4','e5','e6')
print(t)

t1=tuple('hello')
print(t1)

t2=tuple([1,2,3,4,5])
print(t2)

t=tuple([10,20,30,40,50])

print('10在元组中是否存在:',(10 in t))
print('10在元组是不存在:',(10 not in t))
print('最大值:',max(t))
print('最小值:',min(t))
print('len:',len(t))
print('t.index:',t.index(10))
print('t.count',t.count(10))

输出
在这里插入图片描述

如果元组中仅有一个元素

逗号不能少

t=(10)
print(t,type(t))

t=(10,)
print(t,type(t))

输出
在这里插入图片描述

遍历

与列表的遍历完全相同

元组与列表的区别

元组	列表
不可变序列	可变序列
无法实现添加、删除和修改元素等操作	append() 、 insert()、remove()、pop()等方法实现添加和删除列表元素
支持切片访问元素，不支持修改操作	支持切片访问和修改列表中元素
访问和处理速度快	访问和处理速度慢
可以作为字典的键	不能做为字典的键

字典

字典是以键进行索引的，键可以是任何不可变类型；字符串和数字总是可以作为键。如果一个元组只包含字符串、数字或元组则也可以作为键；如果一个元组直接或间接地包含了任何可变对象，则不能作为键。列表不能作为键，因为列表可以使用索引赋值、切片赋值或者 append() 和 extend() 等方法进行原地修改列表。

可以把字典理解为键值对的集合，但字典的键必须是唯一的。花括号 {} 用于创建空字典。另一种初始化字典的方式是，在花括号里输入逗号分隔的键值对，这也是字典的输出方式。

字典的主要用途是通过关键字存储、提取值。用 del 可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。

对字典执行 list(d) 操作，返回该字典中所有键的列表，按插入次序排列（如需排序，请使用 sorted(d)）。检查字典里是否存在某个键，使用关键字 in。

创建方式

（1）使用{}创建字典

d={key1:value1,key2:value2.....}

（2）使用内置函数dict()创建字典

# 通过映射函数创建字典
zip(lst1,lst2)
# 使用dict()创建字典
dict(key1=value1,key2=value2......)

demo

tel = {'jack': 4098, 'sape': 4139,'sape':9527}  # key相同时，value值进行了覆盖
tel['guido'] = 4127
print(tel)

lst1=[10,20,30,40]
lst2=['cat','dog','zoo','orange']
zipobj=zip(lst1,lst2)
print(zipobj)
#print(list(zipobj))

d=dict(zipobj)
print(d)

d1=dict(cat=10,dog=20)
print(d1)

# dict() 构造函数可以直接用键值对序列创建字典：
d2=dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
print(d2)

# 字典推导式可以用任意键值表达式创建字典：
d={x: x**2 for x in (2, 4, 6)}
print(d)

# 关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷：
d=dict(sape=4139, guido=4127, jack=4098)
print(d)

在这里插入图片描述

d = {'jack': 4098, 'sape': 4139,'sape':9527}
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))

在这里插入图片描述

遍历

当对字典执行循环时，可以使用 items() 方法同时提取键及其对应的值。

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k,'--->', v)
for item in knights.items():
    print(item)

在这里插入图片描述

在序列中循环时，用 enumerate() 函数可以同时取出位置索引和对应的值：

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i,'--->', v)

在这里插入图片描述

字典常的操作方法

方法	描述说明
d.keys()	获取所有的key数据
d.values()	获取所有的value数据
d.pop(key,default)	key存在获取相应的value，同时删除key-value对，否则获取默认值
d.popitem()	随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除
d.clear()	清空字典中所有的key-value对

d = {'jack': 4098, 'sape': 4139,'li':9527}
print(d)

# 向字典中添加元素
d['tong']=1001
print(d)

# 获取所有的键
keys=d.keys()
print(keys)
print(list(keys))
print(tuple(keys))

# 获取字典中所有的value
values=d.values()
print(values)
print(list(values))
print(tuple(values))

# 如何将字典中的数据转成key-value对的形式，以元组的方式进行展示
lst=list(d.items())
print(lst)

# 再转回去
d=dict(lst)
print(d)

print(d.pop('tong'))
print(d)
print(d.pop('tong','不存在'))

# 随机删除
print(d.popitem())
print(d)

# 全部删除
d.clear()
print(d)

在这里插入图片描述

生成式创建字典

d={key:value for item in range}
d={key:value for key,value in zip(lst1,lst2)}

import random
d={item:random.randint(1,100) for item in range(4)}
print(d)

lst=[1,2,3]
lst2=['e1','e2','e3']
d={key:value for key,value in zip(lst,lst2)}
print(d)