python笔记--列表、字典、元组和集合

编程语言 2022-08-14 07:12:37 阅读次数: 0

1. 列表

1.1 简介

  • 变量可以存储一个元素，而列表是一个“大容器”，可以存储N多个元素，程序可以方便地对这些数据进行整体操作
  • Python中的列表相当于Java语言中的数组
  • 与Java不同的是，它的列表更具”包容性“，Python中的列表中可以加入不同的数据类型
# 列表中可以加入不同的数据类型
list = [1, 3.14, 'hello', [1,2,3], None]
print(list)
print('id: ', id(list))
print('类型：', type(list))

在这里插入图片描述
列表特点

  • 列表元素按顺序有序排序
  • 索引映射唯一一个数据
  • 列表可以存储重复数据（集合不可以）
  • 任意数据类型混存，如 [1, 3.14, ‘hello’]
  • 根据需要动态分配和回收内存，

1.2 列表创建方式

  1. 使用 []
  2. 使用内置函数list()
# 方式1，使用[]
list1 = [1, 3.14, 'hello']
# 方式2，使用内置函数list()
list2 = list(['hello', '13', 56])

1.3 操作列表

1.3.1 查询

1. 查询单个元素

list1 = [1, 3.14, 'hello', 6, 89]
# 获取索引值为1的元素
print(list1[1])
# 获取列表中最后一个元素
print(list1[-1])
# 获取列表中倒数第2个元素
print(list1[-2])
# 索引值超出列表长度，报IndexError
print(list1[5])

在这里插入图片描述
2. 查询多个元素

切片操作

  • 语法格式：列表名[start:stop:step]
  • 遵循左闭右开规则，[start, stop)，step默认为1
  • 切片结果是原列表片段的拷贝，id值不同
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
# start=1 stop=6 左闭右开， step=1
a = lst[1:6:1]
# 输出切片结果
print(a)
# id值不同
print(id(a) == id(lst))
# 默认步长为1
print('[1, 6)，默认步长为1：', lst[1:6])
print('[1, 6)，默认步长为1：', lst[1:6:])
# 步长为2
print('[1, 6)，step=2：', lst[1:6:2])
# start=0 stop=6 左闭右开， step=2
print('[0, 6)，step=2：', lst[:6:2])
# start=1 左闭右开， step=2
print('start=1 step=2：', lst[1::2])
print('\n')
# 逆序输出
print('逆序输出：', lst[::-1])
# 逆序输出，step=2
print('逆序输出，step=2：', lst[::-2])
# [7, 1)，步长为1，逆序
print('[7, 1)，步长为1，逆序：', lst[7:1:-1])

在这里插入图片描述

3. index()函数

  • 根据元素查找并返回元素索引
  • 索引值从0开始
  • 若列表中没有该元素，则抛出ValueError
  • 若列表中有多个相同元素，只返回第一个元素的索引值
  • 可以在指定区间查找
list3 = [1, 3.14, 'hello', 6, 89]
print(list3.index(6))   # 返回3
print(list3.index(0))  # 报异常

在这里插入图片描述

list3 = [1, 3.14, 'hello', 6, 89]
# 在索引值1~3之间查找元素值为'value'的索引值，区间为[1, 3)
print(list3.index('hello', 1, 3))

在这里插入图片描述
4. 元素判断、列表遍历操作

# 元素判断
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(3 in lst)
print(9 in lst)
print(4 not in lst)

在这里插入图片描述

# 列表遍历
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
for i in lst:
    print(i)

在这里插入图片描述

1.3.2 增、删、改操作

1. 添加操作

方式 说明
append() 【常用】 末尾添加一个元素
extend() 末尾添加元素，可以多个
insert() 任意位置添加元素
切片 
lst = [1,3,7]
print('添加元素前标识值：', id(lst))
print('列表值：', lst)
lst.append(10)
print('添加元素后标识值：', id(lst))
print('append 10 后列表值：', lst)
lst.extend(['hello', 'world'])
print('extend [\'hello\', \'world\'] 后列表值：', lst)
lst.insert(1, 'swy')
print('在索引值1处insert \'swy\' 后列表值：', lst)

在这里插入图片描述
切片操作：

# 切片
lst = [0, 1, 2, 3, 4, 5, 6]
lst2 = [11, 22, 33]
# 在索引值1处切片，后面添加lst2的元素
lst[1:] = lst2
print(lst)

在这里插入图片描述

2. 删除操作

方式 说明
remove() 删除一个元素，重复元素只删除第一个，元素不存在抛出ValueError
pop() 删除指定索引位置上的元素，若不存在抛出IndexError，若不指定索引，则删除列表中最后一个元素
切片 一次至少删除一个元素
clear() 清空列表
del() 删除列表 
print('-------remove-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
# 删除值为1的元素
lst.remove(1)
print(lst)

print('\n-------pop-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
# 删除索引为7的元素
lst.pop(7)
print(lst)
# 删除最后一个元素
lst.pop()
print(lst)

print('\n-------clear-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
lst.clear()
print(lst)

print('\n-------del-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
del(lst)
print(lst)

在这里插入图片描述
3. 修改操作

lst = [1, 2, 3, 4]
lst[0] = 111
print(lst)
# lst列表中[1, 3)区间的元素替换成后面的列表元素
lst[1:3] = [11, 22, 33]
print(lst)

在这里插入图片描述

1.3.3 排序

  • sort() 在原列表上排序，不会生成新列表
  • 内置函数sorted() 会生成新列表
print('---------sort---------')
# sort默认升序，在原列表上排序，没有生成新列表
lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
lst.sort()
print(lst)

lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
# 降序排序，在原列表上排序，没有生成新列表
lst.sort(reverse = True)
print(lst)

print('\n---------内置函数sorted---------')
# sorted默认升序，会生成新列表
lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
new_lst = sorted(lst)
print(new_lst)

new_lst = sorted(lst, reverse = True)
print(new_lst)

在这里插入图片描述

2. 字典

2.1 概念

  • 字典是Python内置的数据结构之一，与列表一样是一个可变序列
  • 以键值对的方式存储数据，字典是一个无序的序列
  • 使用 ‘{}’ 定义，类似于json
  • 类似于Java中的map
  • 键不允许重复，若重复会被后面覆盖
  • 字典会浪费较大的内存，以空间换时间

字典格式如下：

d = {key1 : value1, key2 : value2 }

2.2 字典创建方式

  • 使用花括号
  • 使用内置函数dict()
print('---------使用{}创建---------')
s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print(s)
print(type(s))

print('---------使用dict()创建---------')
s1 = dict(name = 'jack', age = 20)
print(s1)
print(type(s1))

在这里插入图片描述

2.3 字典操作

2.3.1 元素获取

方法 例子 说明
[…] s[‘id’] 如果字典中不存在指定key，则抛出keyError异常
get(…) s.get(‘id’) 如果字典中不存在指定key，返回None，也可以设置并返回默认value 
s1 = dict(name = 'jack', age = 20)
print('-----------使用get()方式-----------')
print(s1.get('name'))
# 使用默认值-1，当字典中没有'id'时，返回默认值，若不设默认值，则返回None
print(s1.get('id', -1))

print('-----------使用[]方式-----------')
print(s1['name'])
print(s1['id'])

在这里插入图片描述

2.3.2 字典元素增、删、改

s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print('------------key的判断------------')
# key的判断
print('name' in s)

s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print('------------删除key------------')
# 删除key
del s['id']
print(s)

s = {
    
    'name': 'swy', 'age': 23}
print('------------清空字典------------')
s.clear()
print(s)

print('------------新增元素------------')
s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
s['sex'] = '男'
print(s)

{
    
    'id': 10, 'name': 'swy', 'age': 23, 'sex': '男'}
print('------------修改元素------------')
s['sex'] = '女'
print(s)

在这里插入图片描述

2.3.3 获取字典视图

方法 说明
keys() 获取所有key
values() 获取所有value
items() 获取所有key,value对 
s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print('------------获取所有键------------')
keys = s.keys()
print(keys)
print(type(keys))
# 视图转换成列表
print(list(keys))

s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print('\n------------获取所有值------------')
values = s.values()
print(values)
print(type(values))
# 视图转换成列表
print(list(values))

s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
print('\n------------获取所有键值对------------')
items = s.items()
print(items)
print(type(items))
# 视图转换成包含元组的列表
print(list(items))

在这里插入图片描述

2.3.4 字典常用操作

遍历

s = {
    
    'id': 10, 'name': 'swy', 'age': 23}
for key in s:
    print(key, s.get(key))

在这里插入图片描述

2.4 字典生成式

内置函数zip()：将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，返回由这些元组组成的列表

items = ['name', 'id', 'age']
data = ['swy', '26', '23']

d = {
    
     item:data for item,data in zip(items, data)}
print(d)

在这里插入图片描述

3. 元组

3.1 概念

元组是Python的内置的数据结构之一，是一个不可变序列

t=( ‘java’, ‘C++’, ‘Python’ )

3.2 元组的创建方式

元组的创建方式

方式 说明
小括号 t = ( ‘java’, ‘C++’, ‘Python’ )
内置函数tuple() t = tuple(( ‘java’, ‘C++’, ‘Python’ ))
逗号和小括号 t = ( 10, )【只包含一个元素时使用】 
print('------------使用()------------')
t = ('C++', 'Python', 'Java')
print(t)
print(type(t))

print('\n------------使用tuple()------------')
t = tuple(('C++', 'Python', 'Java'))
print(t)
print(type(t))

print('\n------------只包含一个元素时，使用, 和 ()------------')
t = (1, )
print(t)
print(type(t))

print('\n------------空元组------------')
t = ()
t = tuple()
print(t)

在这里插入图片描述

3.3 元组的遍历

元组是可迭代对象，可以使用for…in进行遍历

t = tuple(('C++', 'Python', 'Java'))

for i in t:
    print(i)

在这里插入图片描述

4. 集合

4.1 概念

  • Python的内置数据结构
  • 属于可变类型的序列
  • 集合是没有value的字典

4.2 集合的创建方式

  • {}
  • 内置函数set()
print('------------通过{}创建------------')
s = {
    
    2, 3, 4, 5, 6, 7}
print(s)

print('\n------------内置函数set()------------')
print(set([2, 3, 4, 5, 6, 7]))
print(set((1, 2, 3, 4, 5)))
print(set({
    
    2, 3, 4, 5}))
print(set(range(10)))
print(set())

在这里插入图片描述

4.3 集合操作

集合元素判断操作

元素判断操作 说明
in 或 not in

添加操作

添加操作 说明
add() 一次添加一个元素
update() 一次添加多个元素，可以是集合、列表、元组

删除操作

删除操作 说明
remove() 删除一个指定元素，元素不存在抛出KeyError
discard() 删除一个指定元素,元素不存在不抛异常
pop() 一次只删除一个任意元素
clear() 清空集合 
print('------------判断是否存在集合中------------')
s = {
    
    2, 3, 4, 5, 6, 7}
print(10 in s)
print(2 in s)

print('\n------------集合中新增元素------------')
s = {
    
    1 ,2}
s.add(100)
print(s)
s.update({
    
    200, 300})
print(s)
s.update([11, 22, 33])
print(s)

print('\n------------集合中删除元素------------')
s = {
    
    2, 3, 4, 5, 6, 7}
s.remove(6)
print(s)
s.discard(3)
print(s)
s.pop()
print(s)
s.clear()
print(s)

在这里插入图片描述

4.4 集合间关系

关系 说明
是否相等 == 或 != 判断
a是否是b的子集 调用issubset判断
a是否是b的超集 调用issuperset判断
a、b是否没有交集 调用isdisjoint判断 
s1 = {
    
    1, 2, 3, 4, 5, 6}
s2 = {
    
    2, 4, 6}
s3 = {
    
    1, 8, 9}
print('s2是s1的子集吗？', s2.issubset(s1))
print('s1是s2的超集吗？', s1.issuperset(s2))
print('s1与s2是否不相交？', s1.isdisjoint(s3))

在这里插入图片描述

集合间的数学关系如下：

在这里插入图片描述具体用法如下表所示：

数学操作 说明
交集 a.intersection(b) 或者 a & b
并集 a.union(b) 或者 a | b
差集 a.difference(b) 或者 a - b
对称差集 a.symmetric_difference(b) 或者 a ^ b 
s1 = {
    
    1, 2, 3, 4, 5, 6}
s3 = {
    
    1, 8, 9}

print('交集：', s1.intersection(s3))
print('交集：', s1 & s3)
print('并集：', s1.union(s3))
print('并集：', s1 | s3)
print('差集：', s1.difference(s3))
print('差集：', s1 - s3)
print('对称差集：', s1.symmetric_difference(s3))
print('对称差集：', s1 ^ s3)

在这里插入图片描述

4.5 集合生成式

s = {
    
     i*i for i in range(10) }
print(s)

在这里插入图片描述

5. 总结

数据结构 是否可变 是否重复 是否有序 定义符号
列表 list 可变 可重复 有序 []
元组 tuple 不可变 可重复 有序 ()
字典 dict 可变 key不可重复 无序 {key : value}
集合 set 可变 不可重复 无序 {}

猜你喜欢

转载自blog.csdn.net/swy66/article/details/126323624
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022