python之列表、字典、集合、元组操作

前言

在前面讲了字符串的一些操作，仅仅字符串还是远远不够的，在这里介绍几种常用的数据储存方式

列表

在python中，列表的作用是一次性存储多个数据，而且属于可变序列，我们可以对这些数据进行的操作有：增、删、改、查。

列表的创建

# 创建列表
# listname = []
# listname = list()
# 列表里储存着值
listdata = [1,2,3,4,5]

# 在python中可以用list()将range()转为列表
print(list(range(1,10)))

# 这样也可以
list_data = [i*10 for i in range(10)]
print(list_data)

列表的索引与切片

列表的索引和切片和字符串是一样的。

								正向索引

值	值1	值2	值3	…	值n
索引	0	1	2	…	n-1

								反向索引

值	值1	值2	值3	…	值n
索引	-n	-(n-1)	-(n-2)	…	-1

切片

# [start,end,step]
# start:起始值
# end:结束值
# step:步长 步长为正从右往左取值 步长为负冲左往右取值

list_data = list(range(1,10))


# 指定区间
print(list_data[2: 4]) # [3, 4]

# 指定步长
print(list_data[1: 4: 2]) # [2, 4]

# 取全部
print(list_data[:]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 步长为负
print(list_data[:2:-1]) # [9, 8, 7, 6, 5, 4]

列表的增删改查

• 往列表里添加元素值

有三种方法往列表里添加元素值
第一种是往列表末尾一个元素值
第二种是将整个列表添加另外一个列表的末尾
第三种是往指定位置插入元素值

# 往列表末尾添加元素值
# listname.appen(obj) 会添加在列表的末尾
data = list(range(3)) # [0, 1, 2]
print(data.append(5)) # [0, 1, 2, 5]


# 将整个列表添加到另一个列表末尾
# listname.exten(seq)
data1 = list(range(3))  # [0, 1, 2]
data2 = list(range(4))  # [0, 1, 2, 3]
data1.extend(data2)
# 也可以将两个列表相加

# 往列表中插入元素值
# listname.insert(位置下标, 元素值)
data3 = list(range(4))  # [0, 1, 2, 3]
data3.insert(1, 10)  # [0, 10, 1, 2, 3]

• 删除列表中的值
  删除列表中的值有两种
  第一种是根据索引删除
  第二种是根据元素值删除

# 第一种 根据索引删除
# listname.pop(下标) 默认为最后一个 并返回删除的值
data1 = list(range(4))  # [0, 1, 2, 3]

# 默认为最后一个
data = data1.pop()  # 3
print(data1)  # [0, 1, 2]
data2 = data1.pop(1)  # 1
print(data1)  # [0, 2]


# 第二种 根据元素值删除 删除第一个匹配的数据
# 
data3 = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
data3.remove(2) # 返回值为None
print(data3)  # [0, 1, 3, 4, 5, 6, 7, 8, 9]

• 修改列表中的元素值
  可以根据索引值修改

data = list(range(10))  # 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
data[1] = 100
print(data)  # [0, 100, 200, 300, 4, 5, 6, 7, 8, 9]

# 切片也可以
data[2:4] = [200, 300]
print(data)  # [0, 100, 200, 300, 4, 5, 6, 7, 8, 9]

• 查找列表中的元素值
  查找列表中的元素值可以用index()和count()

listname.index(obj)
获取指定元素值首次出现的位置，会返回元素值的索引。

# index()
data = list(range(1, 8)) # [1, 2, 3, 4, 5, 6, 7]
print(data.index(3))  # 3

# 指定的元素值如果不存在会报错

• listname.count(obj)
  统计指定元素出现的次数

# count() 
data = [1,2,4,5,2,1]
# 指定元素 1 出现的次数
print(data.count(1)) # 2

列表的排序

sort() 将列表进行排序 原列表一起改变
reverse() 将整个列表颠倒过来，如[1,2,3]，颠倒过来为[3,2,1]
sorted() 将列表进行排序 生成一个新的列表 原列表不改变

data = [1, 3, 4, 5, 2, 6]

# sort(key=None,reverse=False)
# key 指定排列规则
# reverse的值如果True则是降序排列 为False是升序排列 默认为False
data.sort(key=None, reverse=False)
print(data)

# 将列表颠倒过来
data.reverse()
print(data)



# 内置函数sorted()
data1 = [2, 4, 1, 3, 2, 5]
# 降序排列
new_list = sorted(data1, reverse=True)
print('原列表:', data1)
print('新列表:', new_list)

while for 循环遍历列表

# while 
data = [2,4,51,2]
num = 0
# len()计算列表的长度
while num < len(data):
    print(data[num])
    num += 1

# for
for i in data:
    print(i)

列表推导式

什么是列表推导式？就是在列表里用for循环快速生成一个满足需求的列表。

# 生成10的倍数 从0到100
data1 = [i*10 for i in range(11)]
print(data1)
# [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 现在有一个列表 我们需要剔除我们不需要的值，那怎们实现？
# 也可以用列表推导式
price = [1234,4555,2345,3445,9000,7565,7454,8656]
new = [i for i in price if i > 4000 ]
print(new) # [4555, 9000, 7565, 7454, 8656]

# 如果看起来有点懵 可以看下面这个 效果是一样的
price = [1234, 4555, 2345, 3445, 9000, 7565, 7454, 8656]
new = []
for i in price:
    if i > 4000:
        new.append(i)
print(new)        

列表嵌套

列表嵌套指的就是一个列表里面包含了其他的数据类型。

data = [[1,2],[2,5,6],[2,3,45]]
# 同样是通过索引取值
print(data[0])
print(data[0][1])

# 还可以嵌套别的数据类型
data1 = [1,{'s':1},3,[4,5]]

在列表中是允许其他数据类型共存的，如

listname = [1, 'str', 1.2, False]
print(type(listname[0])) # <class 'int'>
print(type(listname[1])) # <class 'str'>
print(type(listname[2])) # <class 'float'>
print(type(listname[3])) # <class 'bool'>

在列表中常用append()、index()、remove()、len()，其他方法要用的时候查一下就好了。

元组

我们可以用列表来储存多个数据，并且可以对这些数据进行增删改查，但是如果不想让这些数据被修改，那怎么办？我们可以用元组，元组用于保存不可修改的内柔。元组跟列表区别不大，都是通过索引查找值，很多方法都能g共用。

元组的创建与删除

# 创建元组
data1 = ('1','a','s')
# 用英文括号创建跟列表相似
# 注意如果元组中只有一个元素值，后面要加一个英文逗号
data2 = (1,)

# 我们可以用tuple()将range()转化为元组
data3 = tuple(range(3))
print(data3)


# 创建空元组
d = ()
d = tuple()

元组的常用操作

因为元组不支持修改，所以我们只能查找

• 索引找值

data = (1,2,5,5)
print(data[1]) # 2

• len()

# 计算元组中的数据个数
data = (1,2,5,5)
print(len(data)) # 4

• index()

# 跟列表一样 查找某个数据 并返回索引
data = (1,2,5,5)

re = data.index(2)
print(re) # 1

• count()

# count()统计元素出现的次数
data = (1,2,5,5)
print(data.count(5)) # 2

字典

字典与列表相似，属于可变序列，但是字典是无序的，字典是中的数据是以“ 键:值 ”的形式存放数据。下面就来详细的介绍一下。

创建字典

# 创建控字典
data = {}
data1 = dict()
# 字典是以“ 键:值 ”形式存放值的
# 我们可以通过键来找到值，而且更好理解这值所代表的意义
# 在一个字典中键必须唯一，键可以是字符串/数值/元组/布尔类型, 不能是列表
# 字典取值
data2 = {'name':'天天','age':18,'weight':50}
# 这取值跟列表完成不同 字典是通过键来取值 而不是索引
print(data2['name'])}

字典的增删改查

• 增
  语法
  字典序列[key] = 值

data = {}
data['name'] = '天天'
print(data) # {'name': '天天'}
	
# 如果值早已存在 会被覆盖掉
data = {'name':2}
data['name'] = '天天'
print(data) # {'name': '天天'}


# update()
data1 = {'name': '天天'}
data2 = {'age': 18}
# 合并字典 update()
data1.update(data2)
print(data1)

	

• 删

data1 = {'name': '天天', 'age': 18}

# del 指定键 删除字典中元素
del data1['name']
print(data1)
# pop 指定键 删除字典中元素
# pop del 是一样的 但是pop有返回值
data1.pop('age')
print(data1)

data = {'name': '天天', 'age': 18}
# clear() 删除字典中所有键值对
data.clear()
print(data)

• 改
  语法
  字典[key] = value
• 查

get()

# get(key,默认值)
# get() 通过键查找相应的值 如果没有就返回默认值None 默认值可以修改
data = {'name':'天天','age':18,'school':'ti'}
print(data.get('name'))
print(data.get('s','没有'))

keys()

data = {'name':'天天','age':18,'school':'ti'}
# 获取所有键
print(data.keys()) # dict_keys(['name', 'age', 'school'])
# 可以用list()转化为列表
print(list(data.keys()))

values()

data = {'name':'天天','age':18,'school':'ti'}
# 获取所有值
print(data.values()) # dict_values(['天天', 18, 'ti'])
# 可以用list()转化为列表
print(list(data.values()))

items()

data = {'name': '天天', 'age': 18, 'school': 'ti'}
# 获取所有键值对
print(data.items())  # dict_items([('name', '天天'), ('age', 18), ('school', 'ti')])
# 可以用list()转化为列表
print(list(data.items()))
# [('name', '天天'), ('age', 18), ('school', 'ti')]

字典的循环遍历

data = {'name': '天天', 'age': 18, 'school': 'ti'}
# 遍历键
for i in data.keys():
    print(i)

# 遍历值
for k in data.values():
    print(k)

# 遍历键值对
# 返回的是一个元组(key,values) 可以用两个变量来接受
for key,values in data.items():
    print(key,values)

字典推导式

我们可以用字典推导式快速生成一个字典,如下

# i 表示键
# i * 2 表示值
data = {i: i * 2 for i in range(10)}
print(data)

# 将俩个列表合成为字典
data1 = ['name','age','fun']
data2 = ['天天501','18','game']
# 索引取值
data3 = {data1[i]:data2[i] for i in range(3)}
print(data3)

集合

集合的概念和数学中差不多，集合中的元素没有顺序，所有不支持索引，元素值是唯一的，所用集合常用来保存不重复的数据或者去除重复的数据。

集合的创建

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

# 创建集合
data = {'a','b'}

# 创建空集合
data1 = set()

集合的添加和删除

• 添加

data = {1,2,5}
# add() 添加数据
data.add(100)
print(data)


data1 = {1, 2, 5}
data2 = {1, 4, 5, 6}
# update() 合并集合 重复的数据会被去掉
data1.update(data2)
print(data1)

-删除

data = {1, 2, 5}
# remove()  删除指定的值 没有会报错
data.remove(5)
print(data)

# discard和remove() 差不多 没有值不会报错
data.discard(10)
print(data)
# 清空集合
data.clear()
print(data)

集合推导式

# i * 2 表示值
data = {i * 2 for i in range(10)}
print(data)
# {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

列表、元组、字典、集合之间的区别

在说他们的区别之前也先讲一下什么是可变序列与不可变序列。
我们知道，我们可以通过变量名来调用值，我们每创建一个变量，计算机就会分配一个内存地址，这个地址就代表值储存的位置。如下

data = 'a'
# id() 查询储存的地址
print(id(data))

可变序列与不可变序列

在python中有六个数据类型，列表、字典、字符串、集合、元组、数字。其中属于可变序列的是列表、字典、集合，不可变序列的是数字
、元组、字符串。

• 可变序列
  什么是可变序列？就是我们可以对它进行修改但是它原来的地址不会变。

data = [2, 3, 4]

print('原来:', id(data))

data[1] = 10

print('修改后:',id(data))

• 不可变序列
  不可变序列是指如果修改了值，那么它就会新建一个地址来储存修改的值。

data = 123

print('原来:', id(data))

data = 124

print('修改后:',id(data))

列表、元组、字典、集合之间的区别，集合和字典不支持索引、切片、相加、相乘的操作