Python学习（五）——数据类型之列表、元组、字典和集合_创建列表元组字典和集合

创建空集合时，必须使用set()，不能是{}；因为{}默认为空字典。

list1 = []  # 空列表
tuple1 = ()  # 空元祖
str1 = ""  # 空字符串
dict1 = {}  # 空字典
set1 = set()  # 空集合
1
2
3
4
5
'
运行
运行

序列类型

字符串 str

不可变：创建好后内部无法修改。
内置功能均为创建新字符。

a = 'abc'
b = a.upper()
print(a)
print(b)	# 新字符串
# 结果：abc
#		ABC
1
2
3
4
5
6
'
运行
运行

列表 list

有序且可变，可存放多个不同类型、同一类别的元素。
内置功能都是直接在列表内部操作，不会创建新列表。

创建列表：普通方式：列表名 = [ ]

list1 = ['笔', '本子']
list1.append('橡皮')
print(list1)
# 结果：['笔', '本子', '橡皮']
1
2
3
4
'
运行
运行

• 生成一到五的列表

# 普通方式
list1 = [1, 2, 3, 4, 5]
print(list1)
# 使用range()
print(list(range(1, 6)))
# for循环
list1 = []
for i in range(1, 6):
	list1.append(i)
print(list1)
# 列表生成式生成
print([i for i in range(1, 6)])
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

# 列表推导式创建列表[1,4,7,10,13]
print([i for i in range(1,14,3)])	# 1~13之间的数，步长为3
1
2
'
运行
运行

增

append()

将数据添加至列表末尾。

• 语法：列表名.append(“所需添加的内容”)

list1 = [1, 2, 3, 4, 5]
list1.append("小王")
print(list1)
# 结果：[1, 2, 3, 4, 5, '小王']
1
2
3
4
'
运行
运行

insert()

将数据添加至列表指定下标的位置。

• 语法：列表名.insert(下标, “所需添加的内容”)

list1 = [1, 2, 3, 4, 5]
list1.insert(1, "小王")
print(list1)
# 结果：[1, '小王', 2, 3, 4, 5]
1
2
3
4
'
运行
运行

extend()

将数据添加至列表末尾，并把序列类型拆分。

• 语法：列表名.extend(“序列类型”)

list1 = [1, 2, 3, 4, 5]
list1.extend("小王")
print(list1)
# 结果：[1, 2, 3, 4, 5, '小', '王']
1
2
3
4
'
运行
运行

将数据添加至列表末尾。

• 语法：列表名.extend([“序列类型”])

list1 = [1, 2, 3, 4, 5]
list1.extend(["小王"])
print(list1)
# 结果：[1, 2, 3, 4, 5, '小王']
1
2
3
4
'
运行
运行

删

pop()

从列表指定下标的位置，删除一个值，默认从最后一个开始删除。

• 语法：列表名.pop(下标)

list1 = [1, 2, 3, 4, 5]
list1.pop(1)
print(list1)
list1.pop()
print(list1)
# 结果：[1, 3, 4, 5]
#		[1, 3, 4]
1
2
3
4
5
6
7
'
运行
运行

remove()

从列表中删除一个指定的值，若有多个，则从第一个开始删除。

• 语法：列表名.remove(“删除对象的值”)

list1 = [1, 2, 3, 4, 5, 3]
list1.remove(3)
print(list1)
# 结果：[1, 2, 4, 5, 3]
1
2
3
4
'
运行
运行

clear()

将列表中所有内容全部删除。

• 语法：列表名.clear(")

list1 = [1, 2, 3, 4, 5]
list1.clear()
print(list1)
# 结果：[]
1
2
3
4
'
运行
运行

del

从列表指定下标的位置，删除一个值，也可以全部删除。

• 语法：del 列表名[下标]

list1 = [1, 2, 3, 4, 5]
del list1[2]
print(list1)
# 结果：[1, 2, 4, 5]
1
2
3
4
'
运行
运行

全局删除。

• 语法：del 列表名

list1 = [1, 2, 3, 4, 5]
del list1
print(list1)
# 结果：报错
1
2
3
4

改

单个修改

直接通过下标进行修改。

• 语法：列表名[下标] = 内容

list1 = [1, 2, 3, 4, 5]
list1[1] = "张三"
print(list1)
# 结果：[1, '张三', 3, 4, 5]
1
2
3
4
'
运行
运行

多个修改

通过切片方式，由下标对其进行修改。

• 语法：列表名[起点:终点] = 数据1,数据2… 左闭右开

list1 = [1, 2, 3, 4, 5]
list1[2:4] = 9, 8
print(list1)
# 结果：[1, 2, 9, 8, 5]
1
2
3
4
'
运行
运行

查

index()

根据内容获取指定数据的下标。

• 语法：
  1.列表名.index(“所需查找的内容”)
  2.列表名.index(“所需查找的内容”,起点值)

list1 = [1, 3, 2, 3, 4, 5]
print(list1.index(3))
print(list1.index(3,2))
# 结果：1
#		3
1
2
3
4
5
'
运行
运行

count()

统计数据出现的次数。

• 语法：列表名.count(“所需查找的内容”)

list1 = [1, 3, 2, 3, 4, 5]
print(list1.count(3))
# 结果：2
1
2
3
'
运行
运行

排序 sort()和sorted()

全int类型的列表才可以排序

• sort：在原列表上修改
  • 升序：列表名.sort()
  • 降序：列表名.sort(reverse=True)

list1 = [4, 2, 7, 5, 9, 3]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)
# 结果：[2, 3, 4, 5, 7, 9]
#		[9, 7, 5, 4, 3, 2]
1
2
3
4
5
6
7
'
运行
运行

• sorted：返回一个新的列表

list1 = [4, 2, 7, 5, 9, 3]
list2 = sorted(list1)	# 生成一个新列表
print(list2)
# 结果：[4, 2, 7, 5, 9, 3]
#		[2, 3, 4, 5, 7, 9]
1
2
3
4
5
'
运行
运行

元组 tuple

不可变，只有查询方法，和列表的用法一样。
若元素数量是固定的，建议使用元组，因为占用空间更小。

创建元组：普通方式：列表名 = ( ) # 小括号可省略

# 或 tuple1 = ("Python","Java")
tuple1 = "Python", "Java"
print(tuple1)
1
2
3
'
运行
运行

功能

1.相加。两个元组相加获取生成一个新元组

tuple1 = ('Python', 'Java')+('hi', '你好')
print(tuple1) 
# 结果：('Python','Java', 'hi', '你好')
1
2
3
'
运行
运行

2.相乘，元组*整型。将元组中的元素创建n份并生成一个新的元组

tuple1 = ('hi', '你好')*2
print(tuple1)
# 结果：('hi', '你好', 'hi', '你好')
1
2
3
'
运行
运行

3.获取长度

tuple1 = ('123', 'Python', '你好')
print(len(tuple1))  
# 结果：3
1
2
3
'
运行
运行

4.索引

tuple1 = ('Python', 'Java', 'hi', '你好')
print(tuple1[0])
# 结果：Python
1
2
3
'
运行
运行

5.切片

tuple1 = ('Python', 'Java', 'hi', '你好')
print(tuple1[0:2])	# 左闭右开
print(tuple1[2:])
# 结果：('Python', 'Java')
#		('hi', '你好')
1
2
3
4
5
'
运行
运行

6.步长，隔多少取值

tuple1 = ('Python', 'Java', 'hi', '你好', 'import')
print(tuple1[1:4:2])
print(tuple1[0::2]) 
# 结果：('Java', '你好')
#		('Python', 'hi', 'import')
1
2
3
4
5
'
运行
运行

7.for循环

tuple1 = ('Python', 'Java', 'hi', '你好')
for i in tuple1:
    print(i)
# 结果：Python
#		Java
#		hi
#		你好    
tuple1 = ('Python', 'Java', 'hi', '你好')
for i in tuple1:
    if i == 'hi':
        continue
    print(i)
# 结果：Python
#		Java
#		你好
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

散列类型

散列类型的特征：无序、内部元素不重复。

字典 dict

用键值对的方式来存储一些典型的对应关系的数据类型。查询速度快。
键值：类似于我们生活中的字典，根据拼音找某个字。拼音就是key(键)，字就是value(值)。

字典语法：字典名 = {键:值}
键值对的语法：key:value ——> (键:值)
输出语法：字典名[键]
键重新赋值语法：字典名[键] = 值

• 特点

1. 字典是无序的，即没有下标。直接通过键值对的方式进行数据的存储，通过键来取值。

num = {'Jim':'1101','Amiy':'1102','Bob':'1103'}
user = {'姓名':'Jim','年龄':18,'工作':'python工程师'}
print(num['Jim'])
print(user['工作'])
# 结果：1101
#       python工程师
1
2
3
4
5
6
'
运行
运行

2. 不重复，字典里的键(key)是不可以重复的，若重复则取最后一个

dict1 = {'a':1,'b':2,"b":3,"a":4,"a":5}
print(dict1)  # 默认取最后一个键
# 结果：{'a': 5, 'b': 3}
1
2
3
'
运行
运行

3. 可变性，字典里面的数据是可变的

dict1 = {'a':1,'b':2,"a":3,"a":4,"a":5}
dict1['b'] = 10
print(dict1)
# 结果：{'a': 5, 'b': 10}
1
2
3
4
'
运行
运行

# 通过key访问value
scores = {'语文':98}
print(scores['语文']) 
# 结果：98

# 通过key添加key-value对
scores = {'语文':98}
scores['数学'] = 96
scores[90] = 8.2
print(scores)  
# 结果：{'语文': 98, '数学': 96, 90: 8.2}
 
# 通过key删除key-value对，使用del语句
scores = {'语文':98}
scores['数学'] = 96
scores[90] = 8.2
del scores['语文']
del scores['数学']
print(scores) 
# 结果：{90: 8.2}
 
# 通过key修改key-value对，新赋的值就会覆盖原有的值
scores = {'语文': 98, '数学': 96, 90: 8.2}
scores['语文'] = 88
scores[90] = 7.8
print(scores)
# 结果：{'语文': 88, '数学': 96, 90: 7.8}
 
# 通过key判断指定key-value对是否存在，可以使用in或者not in，都是基于key来判断的
scores = {'语文': 98, '数学': 96, 90: 8.2}
scores['语文'] = 88
scores[90] = 7.8
print('语文' in scores) 
print('英语' in scores) 
print('体育' not in scores)
# 结果：True
#		False
#		True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
'
运行
运行

只能通过key访问value
key可以是任意不可变类型

字典可以对不存在的key赋值

字典的常用方法

clear()

清空字典中所有的键值对

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores)  
scores.clear()
print(scores)
# 结果：{'语文': 98, '数学': 96, 90: 8.2}
# 		{}
1
2
3
4
5
6
'
运行
运行

get()

根据key获取value，相当于是方括号语法的增强版。
如果使用方括号语法访问并不存在的key的时候，程序会报错；但是如果使用get()方法访问不存在的key的时候，这个方法会返回一个None，不会导致程序报错。

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.get('语文'))  #  98
print(scores.get('英语'))  #  None
print(scores['英语'])  # 会报错
1
2
3
4

len()

获取长度

scores = {'语文': 98, '数学': 96, 90: 8.2}
data = len(scores)
print(data)
# 结果：3
1
2
3
4
'
运行
运行

update()

可以使用一个字典所包含的键值对来更新已有的字典

scores = {'语文': 98, '数学': 96, 90: 8.2}
scores.update({'语文':91,'体育':84})
print(scores) 
# 结果：{'语文': 91, '数学': 96, 90: 8.2, '体育': 84}
1
2
3
4
'
运行
运行

items()、keys()、values()

分别获取字典中所有的键值对、key、value。

这三个方法依次会返回dict_items、dict_keys和dict_values的对象。
python不能直接操作这几个方法，应先通过list()函数把这三个方法的返回值转换成列表。

#获取字典所有的键值对
scores = {'语文': 98, '数学': 96, 90: 8.2}
items1 = scores.items()
print(type(items1))
print(list(items1)) 
print(list(items1)[0])
# 结果：<class 'dict_items'>
#		[('语文', 98), ('数学', 96), (90, 8.2)]
#		('语文': 98) 

# 获取字典中所有的key
scores = {'语文': 98, '数学': 96, 90: 8.2}
keys1 = scores.keys()
print(type(keys1)) 
print(list(keys1))
print(list(keys1)[1])
# 结果：<class 'dict_keys'>
#		['语文', '数学', 90]
#		数学

# 获取字典中所有的value
scores = {'语文': 98, '数学': 96, 90: 8.2}
values1 = scores.values()
print(type(values1))
print(list(values1))  
print(list(values1)[2]) 
# 结果：<class 'dict_values'>
#		[98, 96, 8.2]
#		8.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'
运行
运行

pop()

用于获取指定的key对应的value，并且删除这个键值对

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.pop('数学')) 
print(scores)
# 结果：96
#		{'语文': 98, 90: 8.2}
1
2
3
4
5
'
运行
运行

setdefault()

用于根据key来获取对应的value
当所获取的key在字典中不存在时，会先为这个不存在的key设置一个默认的value，然后再返回这个key对应的value。

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.setdefault('体育',84))# 若不存在，直接添加
print(scores)
print(scores.setdefault('语文',34))  # 若存在，则不会改变
print(scores) 
# 结果：84
#		{'语文': 98, '数学': 96, 90: 8.2, '体育': 84}
#		98
#		{'语文': 98, '数学': 96, 90: 8.2, '体育': 84}
1
2
3
4
5
6
7
8
9
'
运行
运行

for循环

scores = {'语文': 98, '数学': 96, 90: 8.2}
# 遍历字典，获取所有的键
# Type1
for item in scores:
    print(item)  # 获取所有键
# Type2
for key in scores.keys():
    print(key)  # 获取所有键
# 结果：语文
#		数学
#		90
 
for value in scores.values():
    print(value)  # 获取所有的值
# 结果：98
#		96
#		8.2 

for k,v in scores.items():
    print(k,v)  # 获取所有的键值
# 结果：语文 98
#		数学 96
#		90 8.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'
运行
运行

集合 set

• 特点
  • 唯一性。保存不重复的元素，即集合中的元素都是唯一的，互不相同。
  • 无序性。每次输出时，元素的顺序可能都不同。

只能存储不可变的数据类型，无法存储列表，字典，集合。

语法： 集合名 = {数据1,数据2,数据3…}

因为集合中的元素具有唯一性，所以集合中每种数据元素只会保留一份。
若有重复数据，是不会被添加到内存空间里面的。

a = {1, 2, 1, (1,2), 'b', 'c', 'b'}
print(a)
# 结果：{1, 2, (1, 2), 'c', 'b'}
1
2
3
'
运行
运行

因为集合的无序性，所以集合不能通过下标提取元素，否则会报错。（无下标）

a = {1, 2, 1, (1,2), 'b', 'c', 'b'}
print(a[1])  
# 结果：报错
1
2
3

集合的作用：

1. 存储非重复数据
2. 用于将序列类型去重
3. 逻辑判断 交集，并集，差集

#   去重
a = [1,1,1,2,3,6,3,1]
print(list(set(a)))		# 将列表a用set()转换成集合，去重后，再转换成列表输出
# 结果：[1, 2, 3, 6]
1
2
3
4
'
运行
运行

集合数学运算

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1 & set2) 
print(set1 | set2)
print(set1 - set2)
print(set2 - set1)
print(3 in set2)
# 结果：{2, 3}
#		{1, 2, 3, 4}
#		{1}
#		{4}
#		True
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

增

add()

无序添加

• 语法：集合名.add(元素)

set1 = {'Python'}
set1.add("Java")
print(set1)
set1.add("MySQL")
print(set1)
set1.add("Linux")
print(set1)
# 结果：{'Python', 'Java'}
#		{'Python', 'MySQL', 'Java'}
#		{'Linux', 'Python', 'MySQL', 'Java'}
1
2
3
4
5
6
7
8
9
10
'
运行
运行

删

pop()

当集合元素是int类型时，默认删除第一个元素。
当集合元素是字符串时，随机删除一个元素。

set1 = {1, 5, 3, 7}
set1.pop()
print(set1)
set1.pop()
print(set1)
set1.pop()
print(set1)
# 结果：{3, 5, 7}
#		{5, 7}
#		{7}

set2 = {'Linux', 'Python', 'MySQL', 'Java'}
set2.pop()
print(set2)
set2.pop()
print(set2)
set2.pop()
print(set2)
# 结果：{'MySQL', 'Python', 'Java'}
# 		{'Python', 'Java'}
#		{'Java'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

remove()

必须有参数，参数为要删除的元素，若元素不存在则报错。

set1 = {'Linux', 'Python', 'MySQL', 'Java', 1}
set1.remove('MySQL')
print(set1)
# 结果：{1, 'Linux', 'Java', 'Python'}
set1.remove(2)
print(set1)  # 元素不存在会报错
1
2
3
4
5
6

discard()

和remove一样，但元素不存在不会报错。

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
set1.discard("aaa")
print(set1)  # 元素不存在不会报错
# 结果：{'Java', 'Linux', 'MySQL', 'Python'}
1
2
3
4
'
运行
运行

clear()

清空集合中所有元素

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
set1.clear()
print(set1)
# 结果：set()
1
2
3
4
'
运行
运行

del

删除集合

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
del set1  # 先删除了变量再去打印变量set1就会报错，显示变量set1不存在
print(set1)
# 结果：报错
1
2
3
4