Python中的list,tuple,set,dict

Python中的序列

序列-功能总览

在这里插入图片描述

在这里插入图片描述

一. list

1. 列表的定义

列表序列名称 = [列表中的元素1, 列表中的元素2, 列表中的元素3, …]

list = ["apple", "banana", "pear"]
print(list)
print(type(list))
['apple', 'banana', 'pear']

<class ‘list’>

2. list的操作方法

①. 增

编号函数作用
1append()增加指定数据到列表中
2extend()列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表
3insert()指定位置新增数据
Ⅰ. append()

在列表的尾部追加元素

list1 = ['apple', 'banana', 'pineapple','banana']

list1.append("pear")
print(list1)
['apple', 'banana', 'pineapple', 'banana', 'pear']
Ⅱ. extend()
list1 = ['apple', 'banana']
list2 = ['pineapple', 'banana']

list1.extend(list2)
print(list1)

list1.extend("grape")
print(list1)
['apple', 'banana', 'pineapple', 'banana']
['apple', 'banana', 'pineapple', 'banana', 'g', 'r', 'a', 'p', 'e']

参数必须是个容器

list1 = ['apple', 'banana']

list1.extend(3)
print(list1)#报错
TypeError: 'int' object is not iterable
Ⅲ. insert()

insert参考

list1 = ['apple', 'banana']

list1.insert(1, "pear")
print(list1)
['apple', 'pear', 'banana']

②. 删

编号函数作用
1del list[i]删除列表中的某个元素
2pop()删除指定下标的数据(默认为最后一个),并返回该数据
3remove()移除列表中某个数据的第一个匹配项,没有则报错
4clear()清空列表,删除列表中的所有元素,返回空列表。
Ⅰ. del list[i]
list1 = ['apple', 'banana', "pear"]

del list1[0]
print(list1)
['banana', 'pear']
Ⅱ. pop()
list1 = ['apple', 'banana', "pear", "grape"]

p1 = list1.pop()
print(p1)
p2 = list1.pop(0)
print(p2)

print(list1)
grape
apple
['banana', 'pear']
Ⅲ. remove()
list1 = ['apple','apple', 'banana', "pear", "grape"]

list1.remove("apple")
print(list1)
['apple', 'banana', 'pear', 'grape']
Ⅳ. clear()
list1 = ['apple','apple', 'banana', "pear", "grape"]

list1.clear()
print(list1)
[]

③. 改

编号函数作用
1list[i] = val修改列表中的某个元素
2reverse()将数据序列进行倒叙排列
3sort()对列表序列进行排序
Ⅰ. list[i] = val
list1 = ['apple', 'apple', 'banana', "pear", "grape"]

list1[1] = "peach"
print(list1)
['apple', 'peach', 'banana', 'pear', 'grape']
Ⅱ. reverse()
list1 = ['apple', 'apple', 'banana', "pear", "grape"]

list1.reverse()
print(list1)
['grape', 'pear', 'banana', 'apple', 'apple']
Ⅲ. sort()
list1 = ['apple', 'apple', 'banana', "pear", "grape"]
list2 = [1, 5, 3, 9, 7]

list1.sort()
list2.sort()
print(list1)
print(list2)
['apple', 'apple', 'banana', 'grape', 'pear']
[1, 3, 5, 7, 9]

④. 查

编号函数作用
1val = list[i]获取列表中的某个元素
2index()指定数据所在位置的下标
3count()统计指定数据在当前列表中出现的次数
4in判断指定数据在某个列表序列,如果在返回True,否则返回False
5not in判断指定数据不在某个列表序列,如果不在返回True,否则返回False
6len()计算列表中元素个数
7max()返回列表中元素最大值
8min()返回列表中元素最小值
Ⅰ. val = list[i]
list1 = ['apple', 'banana', 'pineapple']
# 获取列表中的banana
print(list1[1])
banana
Ⅱ. index()
list1 = ['apple', 'banana', 'pineapple']
# 获取列表中的banana索引下标
print(list1.index("banana"))
1
Ⅲ. count()
#统计元素在列表中出现的次数
list1 = ['apple', 'banana', 'pineapple','banana']

print(list1.count("banana"))
print(list1.count("apple"))
2
1
Ⅳ. in
list1 = ['apple', 'banana', 'pineapple','banana']

print("banana" in list1)
print("pear" in list1)
True
False
Ⅴ. not in
list1 = ['apple', 'banana', 'pineapple','banana']

print("banana" not in list1)
print("pear" not in list1)
False
True
Ⅵ. len()
list1 = [1, 2, 3, 4]

print(len(list1))
4
Ⅶ. max()
list1 = [1, 2, 3, 4]

print(max(list1))
4
Ⅷ. min()
list1 = [1, 2, 3, 4]

print(min(list1))
1

3. 列表的切片

list1 = ['apple', 'apple', 'banana', "pear", "grape"]

print(list1[1:3])
['apple', 'banana']

4. 列表的循环遍历

list1 = ['apple', 'apple', 'banana', "pear", "grape"]

for i in list1:
    print(i)
apple
apple
banana
pear
grape

5. 列表拆包

list1 = [1, 2, 3, 4]

a,b,c,d = list1
print(a)
print(b)
print(c)
print(d)
1
2
3
4

6. 列表合并与复制

list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]

print(list1 + list2)
print(list1 * 2)
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 1, 2, 3, 4]

7. 列表的嵌套

"""
classes = ['第一个班级','第二个班级','第三个班级']

一班:['张三', '李四']
二班:['王五', '赵六']
三班:['田七', '孙八']
"""
#把班级和学员信息合并在一起,组成一个嵌套列表
students = [['张三', '李四'],['王五', '赵六'],['田七', '孙八']]

print(students[0])
print(students[0][1])
['张三', '李四']
李四

8. enumerate()

list1 = [1, 2, 3, 4]

for key, value in enumerate(list1):
    print(key, ":", value)

0 : 1
1 : 2
2 : 3
3 : 4

二. tuple

1. 元组的定义

定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型
元组可以存储多个数据且元组内的数据是不能修改的

① 多个数据元组

tuple1 = (1, 2, 3)

② 单个数据元组

tuple1 = (1, )#如果定义的元组只有一个数据,那么这个数据后面也要添加逗号

2. tuple的操作方法

①. 增

②. 删

③. 改

④. 查

编号函数作用
1val = tuple[i]根据索引下标查找元素
2index()查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index方法相同
3count()统计某个数据在当前元组出现的次数
4in元素是否存在
5not in元素是否不存在
6len()计算元组中元素个数
7max()返回元组中元素最大值
8min()返回元组中元素最小值
Ⅰ. val = tuple[i]
nums = (10, 20, 30)
print(nums[2])
30
Ⅱ. index()
nums = (10, 20, 30)
print(nums.index(10))
0
Ⅲ. count()
nums = (10, 20, 30, 20, 30)
print(nums.count(10))
print(nums.count(20))
1
2
Ⅳ. in
t1 = (1, 2, 3, 4)

print(1 in t1)
print(5 in t1)
True
False
Ⅴ. not in
t1 = (1, 2, 3, 4)

print(1 not in t1)
print(5 not in t1)

False
True
Ⅵ. len()
t1 = (1, 2, 3, 4)

print(len(t1))
4
Ⅶ. max()
t1 = (1, 2, 3, 4)

print(max(t1))
4
Ⅷ. min()
t1 = (1, 2, 3, 4)

print(min(t1))
1

3. 元组的切片

nums = (10, 20, 30, 20, 30)
print(nums[0:3])
(10, 20, 30)

4. 元组的循环遍历

nums = (10, 20, 30, 20, 30)

for i in nums:
    print(i)
10
20
30
20
30

5. 元组拆包

t1 = (1, 2, 3, 4)

a, b, c, d = t1
print(a)
print(b)
print(c)
print(d)
1
2
3
4

6.元组的合并与复制

t1 = (1, 2, 3, 4)
t2 = (5, 6, 7, 8)

print(t1 + t2)
print(t1 * 2)
(1, 2, 3, 4, 5, 6, 7, 8)
(1, 2, 3, 4, 1, 2, 3, 4)

7. enumerate()

t1 = (1, 2, 3, 4)

for key, value in enumerate(t1):
    print(key, ":", value)
0 : 1
1 : 2
2 : 3
3 : 4

三. set

1. 集合的定义

天生去重
无序

① 定义一个集合

s1 = {10, "aplle", 30, "pear", 30}

② 定义一个空集合

s1 = set()

2. set的操作方法

①. 增

编号函数作用
1add()向集合中增加一个元素(单一)
2update()向集合中增加序列类型的数据(字符串、列表、元组、字典)
Ⅰ. add()
s1 = {10, 20, 30, 40, 50}
s1.add(60)
s1.add(70)
print(s1)
{70, 40, 10, 50, 20, 60, 30}
Ⅱ. update()
s1 = {10, 20, 30, 40, 50}
list1 = [60, 70]
s2 = (80, 70)
str1 = "hello"

s1.update(list1)
s1.update(s2)
s1.update(str1)

print(s1)
{'o', 70, 40, 10, 'h', 80, 50, 'e', 20, 'l', 60, 30}

②. 删

编号函数作用
1remove()删除集合中的指定数据,如果数据不存在则报错。
2discard()删除集合中的指定数据,如果数据不存在也不会报错。
3pop()随机删除集合中的某个数据,并返回这个数据。
4clear()清空集合,删除集合中的所有元素,返回空集合
Ⅰ. remove()
s1 = {10, 20, 30, 40, 50}
s1.remove(10)
print(s1)
{40, 50, 20, 30}
Ⅱ. discard()
s1 = {10, 20, 30, 40, 50}
s1.discard(10)
print(s1)
{40, 50, 20, 30}
Ⅲ. pop()
s1 = {10, 20, 30, 40, 50}
s1.pop()
print(s1)

{10, 50, 20, 30}
Ⅳ. clear()
s1 = {10, 20, 30, 40, 50}
s1.clear()
print(s1)
set()

③. 改

④. 查

编号函数作用
1in判断某个元素是否在集合中,如果在,则返回True,否则返回False
2not in判断某个元素不在集合中,如果不在,则返回True,否则返回False
3len()计算集合中元素个数
4max()返回集合中元素最大值
5min()返回集合中元素最小值
Ⅰ. in
s1 = {10, 20, 30, 40, 50}

print(10 in s1)
print(70 in s1)
True
False
Ⅱ. not in
s1 = {10, 20, 30, 40, 50}

print(10 not in s1)
print(70 not in s1)
False
True
Ⅲ. len()
s1 = {10, 20, 30, 40, 50}

print(len(s1))
5
Ⅳ. max()
s1 = {10, 20, 30, 40, 50}

print(max(s1))
50
Ⅴ. min()
s1 = {10, 20, 30, 40, 50}

print(max(s1))
10

3. 集合的循环遍历

s1 = {1,2,3}
for i in s1:
    print(i)
1
2
3

4. 集合的拆包

s1 = {10, 20, 30, 40, 50}

a,b,c,d,e = s1
print(a)
print(b)
print(c)
print(d)
print(e)
40
10
50
20
30

4. 集合中的交集,并集与差集特性

s1 = {10, 20, 30, 40, 50}
s2 = {40, 50, 60, 70, 80}

print(s1 & s2)
print(s1 | s2)
print(s1 - s2)
{40, 50}
{70, 40, 10, 80, 50, 20, 60, 30}
{10, 20, 30}

5. enumerate()

s1 = {10, 20, 30, 40}

for key, value in enumerate(s1):
    print(key, ":", value)
0 : 40
1 : 10
2 : 20
3 : 30

四. dict

1. 字典的定义

① 定义一个字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

② 定义一个空字典

dict1 = {}
dict2 = dict()

2. dict的操作方法

①. 增

编号函数作用
1dict[key] = val如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
Ⅰ. dict[key] = val
dict1 = {}
dict1['name'] = 'Tom'
dict1['age'] = 20
dict1['gender'] = '男'
print(dict1)
{'name': 'Tom', 'age': 20, 'gender': '男'}

②. 删

编号函数作用
1del dict[key]删除指定元素
2pop(key)删除指定key下的数据,并返回该数据 ,key错则报错
2clear()清空字典中的所有key
Ⅰ. del dict[key]
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

del dict1["name"]
print(dict1)
{'age': 20, 'gender': '男'}
Ⅱ. pop()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.pop("name"))
# print(dict1.pop()) #错
#print(dict1.pop("11")) #错
Tom
Ⅲ.clear()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1.clear()
print(dict1)
{}

③. 改

编号函数作用
1dict[key] = val如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
Ⅰ. dict[key] = val
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1["name"] = "Bob"
print(dict1)

{'name': 'Bob', 'age': 20, 'gender': '男'}

④. 查

编号函数作用
1val = dict[key]
2get(key, 默认值)根据字典的key获取对应的value值,如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数,则返回None
3keys()以列表返回一个字典所有的键
4values()以列表返回字典中的所有值
5items()以列表返回可遍历的(键, 值) 元组数组
6in元素是否存在
7not in元素是否不存在
8len()计算字典中元素个数
9max()返回字典中键值最大值
10min()返回字典中键值最小值
Ⅰ. val = dict[key]
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1["name"])
Tom
Ⅱ. get(key, 默认值)
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.get("name"))
print(dict1.get("name1","未找到"))
print(dict1.get("name1"))
Tom
未找到
None
Ⅲ. keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.keys())
dict_keys(['name', 'age', 'gender'])
Ⅳ. values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.values())
dict_values(['Tom', 20, '男'])
Ⅴ. items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.items())

dict_items([(‘name’, ‘Tom’), (‘age’, 20), (‘gender’, ‘男’)])

Ⅵ. in
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print("name" in dict1)
True
Ⅶ. not in
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print("name" not in dict1)
False
Ⅷ. len()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(len(dict1))
3
Ⅸ. max()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(max(dict1))
name
Ⅹ. min()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(min(dict1))
age

3.字典的循环查询

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key, val in dict1.items():
    print(key, ":", val)
name : Tom
age : 20
gender : 男

4. 字典的拆包

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

a,b,c = dict1
print(a)
print(b)
print(c)
name
age
gender

5. enumerate()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key, value in enumerate(dict1):
    print(key, ":", value)
0 : name
1 : age
2 : gender

五. 序列类型之间的相互转换

str1 = "hello"
list1 = ['a', 'b', 'c', 'd']
tuple1 = (10, 20, 30)
set1 = {10, 20, 30, 40}
dict1 = {'name': '白龙马', 'age': 23}

# list
print("list" + "*" * 20)
print(list(str1))
print(list(tuple1))
print(list(set1))
print(list(dict1))

# tuple
print("tuple" + "*" * 20)
print(tuple(str1))
print(tuple(list1))
print(tuple(set1))
print(tuple(dict1))

# set
print("set" + "*" * 20)
print(set(str1))
print(set(tuple1))
print(set(list1))
print(set(dict1))

# dict
print("dict" + "*" * 20)
# print(dict(str1))
# print(dict(tuple1))
# print(dict(set1))
# print(dict(list1))
list********************
['h', 'e', 'l', 'l', 'o']
[10, 20, 30]
[40, 10, 20, 30]
['name', 'age']
tuple********************
('h', 'e', 'l', 'l', 'o')
('a', 'b', 'c', 'd')
(40, 10, 20, 30)
('name', 'age')
set********************
{'o', 'e', 'h', 'l'}
{10, 20, 30}
{'c', 'b', 'd', 'a'}
{'name', 'age'}
dict********************

六. 列表集合字典推导式

推导式comprehensions(又称解析式),是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列(一个有规律的列表或控制一个有规律列表)的结构体。 共有三种推导:列表推导式集合推导式字典推导式

1. 列表推导式

变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]

#生成一个列表
list1 = [i * 2 for i in range(10)]
print(list1)

#生成0-9之间的偶数
list2 = [i for i in range(10) if i % 2 == 0]
print(list2)

#嵌套
list3 = [(i, j) for i in range(1, 3) for j in range(0, 3)]
print(list3)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[0, 2, 4, 6, 8]
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

2. 集合推导式

#生成一个集合
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1)

{1, 4}

3. 字典推导式

#创建一个字典
dict1 = {i: i ** 2 for i in range(1, 6)}
print(dict1)

#把两个列表合并为一个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'male']
dict2 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict2)

# 提取上述电脑数量大于等于200的字典数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'ACER': 99}
dict3 = {key: value for key, value in counts.items() if value >= 200}
print(dict3)
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'name': 'Tom', 'age': 20, 'gender': 'male'}
{'MBP': 268, 'DELL': 201}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值