Python基础（五）- 列表、元组、集合、字典_头歌python基础(5-1)列表、元组、字典、集合——列表

列表

什么是列表

列表是最基本的数据结构之一，最常用的Python数据类型之一，列表中的元素不需要具有相同的类型。列表中的每个元素都分配一个下标 - 它的位置，或着叫索引，第一个索引是0，第二个索引是1，依此类推。
列表是Python内置的6个序列类型之一，最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。而列表中的成员还可以进行修改和删除。

列表的常用方法

1. 创建列表

列表中的元素可以是多个类型，甚至是列表，用’[]’来表示列表，并往中括号中放入元素，每个元素之间用’,’隔开。
list()是创建列表的方法，可以把其他类型(如元组)转换成列表类型

# 创建空列表
list1 = []
list2 = list()
# 用列表的生成表达式方法创建列表容器
f = [x ** 2 for x in range(1, 10)]
# 因为列表中的元素不需要是同一种类型，所以可以放入多个类型的变量
list1 = [123, 123.45, 'abc', True, [1, 2], (1, 2)]
tuple1 = (1, 2, 3) #这是一个元组
list2 = list(tuple1) #[1, 2, 3]
1
2
3
4
5
6
7
8
9

想要获取哪个元素，直接使用列表加索引即可

# 用索引来获取相应的元素，索引从0开始，n个元素索引是0～(n-1)
list1 = [123, 123.45, 'abc', True, [1, 2], (1, 2)]
a = list1[0] #123
b = list1[1] #123.45

# 使用-1～-n可以从后往前获取列表中的元素
list1 = [123, 123.45, 'abc', True, [1, 2], (1, 2)]
a = list1[-1] #(1, 2)
b = list1[-3] #True
1
2
3
4
5
6
7
8
9

说明： 需要注意的是，在大多数变成语言中，通过下标来获取数据时，下标的数字通常是从0开始计数的，而不是从1开始，对于第一次学习变成语言的新手来说，总是会在类似于列表这样通过下标来获取元素的数据类型上犯错误，所以养成在通过下标获取数据时总是先从0开始实验数据的获取范围的习惯，是一件很好的事情。

2. 列表添加元素

列表添加元素的方法常用的有两种，一种是append()方法，一种是extend()方法

# append()方法
list1 = [1, 2, 3]
list1.append(4) #[1, 2, 3, 4]
# extend()方法
list2 = [1, 2, 3]
list2.extend([4]) # [1, 2, 3, 4]
1
2
3
4
5
6

append()方法和extend()方法的区别是，append方法会把括号中的对象当成一个元素直接添加在列表里，而extend方法只能将另一个列表的元素依次添加到当前列表里

# append与extend的区别
list1 = [1, 2, 3]
list1.append([4, 5]) # [1, 2, 3, [4, 5]] 有四个元素
list2 = [1, 2, 3]
list2.entend([4, 5]) # [1, 2, 3, 4, 5] 有五个元素
1
2
3
4
5

3. 列表删除元素

删除元素有del函数和remove()方法

# del函数
list1 = [1, 2, 3]
del list1[0] # [2, 3]
# remove()方法
list1 = [1, 1, 2, 3]
if 1 in list1:# 如果数组中有1这个元素
    list1.remove(1) #[1, 2, 3]
1
2
3
4
5
6
7

del函数的原理是删除当前列表对对应下标的元素的引用，效果就是删除指定位置的元素
remove()方法则是从列表中找到第一个与指定变量相应的元素并从列表中移除

4. 列表修改元素

直接使用索引找到想要替换的元素的位置，然后进行替换

# 替换元素
list1 = [1, 2, 3]
list1[0] = 4 # [4, 2, 3]
1
2
3

5. 列表查找元素

使用循环遍历找到自己想要的元素

list1 = [1, 2, 3]
for val in list1:
    if val == 1:
        print('找到了')
1
2
3
4

元组

元组的概念

元组与列表一样，是Python语言六大序列类型之一，与列表相比，元组是一个元素不可变的容器，在创建的时候元组中的元素就被确定，不可对单个元素再进行更改。

元组的优缺点

与其他可更改元素的序列类型相比：
元组的缺点就是它所含的元素是固定的，无法对某一个特定元素进行更改，使用起来相对不灵活；
元组的优点是，创建一个元组所花费的时间远小于一个包含同样元素的列表创建所需要的时间，当我们需要的是一个固定的不许更改的数据时，使用元组是更高效的一种做法

集合

集合的概念

集合与元组、列表一样，是Python语言六大序列类型之一，集合里存在的元素都是唯一的，不会有重复元素，并且与数学上的集合概念类似，可以进行交集、并集、差集等运算。

集合的使用

1. 集合的创建

# 创建集合可以使用大括号加元素
# 可以添加重复的元素，但是集合创建后会将重复元素变为一个元素
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # {1, 2, 3}
print('Length =', len(set1)) # Length = 3
set2 = set(range(1, 10))
print(set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
1
2
3
4
5
6
7

2. 集合的增删操作

set1 = {1, 2, 3, 3, 3, 2}
set2 = set(range(1, 10))
set1.add(4)
set1.add(5)
set2.update([11, 12])
print(set1) # {1, 2, 3, 4, 5}
print(set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
set2.discard(5)
# remove的元素如果不存在会引发KeyError
if 4 in set2:
    set2.remove(4)
print(set2) # {1, 2, 3, 6, 7, 8, 9, 11, 12}
# 遍历集合容器
for elem in set2:
    print(elem ** 2, end=' ') # 1 4 9 36 49 64 81 121 144
print()
# 将元组转换成集合
set3 = set((1, 2, 3, 3, 2, 1))
print(set3.pop()) # 3
print(set3) # {1, 2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 元素的交集、并集、差集等操作

# 集合的交集、并集、差集、对称差运算
set1 = {1, 2, 3, 10, 11}
set2 = set(range(1, 10))
print(set1 & set2) # {1, 2, 3}
# print(set1.intersection(set2)) # 交集
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
# print(set1.union(set2)) # 并集
print(set1 - set2) # {10, 11}
# print(set1.difference(set2)) # 差集
print(set1 ^ set2) # {4, 5, 6, 7, 8, 9, 10, 11}
# print(set1.symmetric_difference(set2)) # 对称差集
1
2
3
4
5
6
7
8
9
10
11

4. 集合判断子集和超集

# 判断子集和超集
set1 = {1, 2, 3, 10, 11}
set2 = set(range(1, 10))
set3 = set((1, 2, 3))
print(set2 <= set1) # False
# print(set2.issubset(set1))
print(set3 <= set1) # True
# print(set3.issubset(set1))
print(set1 >= set2) # False
# print(set1.issuperset(set2))
print(set1 >= set3) # True
# print(set1.issuperset(set3))
1
2
3
4
5
6
7
8
9
10
11
12

字典

字典的概念

字典是一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，并能够对存储的对象进行修改。与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

字典的使用

1. 创建字典

# 字典创建也使用大括号，一个元素由作为key的字符串和:后的一个对象组成的
person = {'name': 'L.C.Y', 'age': 18, 'grade': 82}
1
2

2. 字典获取元素

person = {'name': 'L.C.Y', 'age': 18, 'grade': 82}
# 通过键可以获取字典中对应的值
print(person['name'])
print(person['age'])
# 对字典进行遍历(遍历的其实是键再通过键取对应的值)
for elem in person:
    print('%s\t--->\t%d' % (elem, person[elem]))
if 'name' in person:
    print(person['name'])
print(person.get('name'))
# get方法也是通过键获取对应的值但是可以设置默认值
print(person.get('age', 60))
1
2
3
4
5
6
7
8
9
10
11
12

3. 字典添加和删除元素

person = {'name': 'L.C.Y', 'age': 18, 'grade': 82}
# 更新字典中的元素
person['age'] = 65
person['name'] = 'lcy'
person.update(like1='python', like2='game')
print(person)
# 删除字典中的元素
print(person.popitem())
print(person.popitem())
print(person.pop('age', 100))
# 清空字典
person.clear()
print(person)
1
2
3
4
5
6
7
8
9
10
11
12
13

练习

列表的实际应用

1. 输出斐波拉切数列

# 1，1,2,3,5,8,13,21

n = 20
my_list = [1, 1]
for i in range(2, n-1):
    num1 = my_list[i - 1] + my_list[i - 2]
    my_list.append(num1)
print(my_list)
print(my_list[6:])
print(my_list[::-1])
1
2
3
4
5
6
7
8
9
10
11

2. 计算平均值，找出最大最小值

# 输入一组数字，找出最大值最小值，计算平均值

my_list = [45, 34, 67, 89, 100, 76, 36, 99]
    # max_num = max(my_list)
    # min_num = min(my_list)
    max_num = my_list[0]
    min_num = my_list[0]
    total = 0
    for current in my_list:
        total += current
        max_num = max_num if max_num >= current else current
        min_num = min_num if min_num <= current else current
    print(max_num)
    print(min_num)
    print(total / len(my_list))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 双色球选号

# 双色球选号，红球6个（1-33），1个蓝球（1-16），机选n注，红色球不可重复，顺序排列
import random

n = int(input('要几注：'))
ball_list_list = []
for _ in range(n):
    ball_list = []
    num_list = [x for x in range(1, 34)]
    for _ in range(6):
        list_len = len(num_list)
        get_num = random.randint(0, list_len - 1)
        ball_list.append(num_list[get_num])
        del num_list[get_num]
    ball_list.sort()
    ball_list.append(random.randint(1, 16))
    ball_list_list.append(ball_list)
for my_list in ball_list_list:
    for ball in my_list:
        print('%02d' % ball, end = ' ')
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.找出第二大数字

# 设计传入一组列表找出第二大的元素   只能使用一次循环

my_list = [7, 2, 2, 4, 3, 1, 5, 3, 2, 3, 2, 1, 6, 6]
max_num = my_list[0]
second_num = 0
for num in my_list:
    if max_num > num:
        second_num = second_num if second_num >= num else num
    elif max_num < num:
        second_num = max_num
        max_num = num
print(second_num)
1
2
3
4
5
6
7
8
9
10
11
12

元组的使用

1. 元组的创建

元组的创建类似于列表，可以包含不同类型的多个元素，创建时使用的是()，而不是元组的[]

# 一般的创建方法
tuple1 = (1, 2, [3, 4], (1, 2), 'abc', True)
1
2

需要注意的是，元组如果只想要包含一个元素，那么创建的时候需要小心

# 单元素元组创建方法
tuple1 = (1,)
tuple2 = ('abc',)
print(type(tuple1)) # <type 'tuple'>
print(type(tuple2)) # <type 'tuple'>
tuple3 = (1)
tuple4 = ('abc')
print(type(tuple3)) # <type 'int'>
print(type(tuple4)) # <type 'str'>
1
2
3
4
5
6
7
8
9

说明 在创建单元素元组时，必须在元素后加’,’，否则()将不被判断为元组的符号，创建的变量的类型将变为元素本身的类型

2. 元组增加元素

元组增加元素的方法是通过与另一个元组的合并来实现，并不能随意插入元素到某个位置

# 元组的合并
tuple1 = (1, 2, (3, 4), [5, 6], 'abc123', True)
tuple2 = (1, 2)
tuple1 = tuple1 + tuple2
print(tuple1) # (1, 2, (3, 4), [5, 6], 'abc123', True, 1, 2)
1
2
3
4
5

2. 元组查找元素

# 查找一个变量在元组中的个数
tuple1 = (1, 2, [3, 4], 'abc', 'abc', 1, 2)
tuple1.count(1) # 2
tuple1.count(3) # 0
tuple1.count('abc') # 2

# 查找某个元素在元组中第一次出现的位置
tuple1 = (1, 2, [3, 4], 'abc', 'abc', 1, 2)
tuple1.index(1) # 0
tuple1.index('abc') # 3
1
2
3
4
5
6
7
8
9
10

3. 元组删除元素

元组中的元素无法随意更改，当然也包括了删除元素，而我们的解决办法就是对元组进行切片和重组

元组的切片：切片方法类似于对字符串的切片与对列表的切片

# 元组的切片
tuple1 = (1, 2, [3, 4], 'abc', 'abc', 1, 2)
tuple1[:3] # (1, 2, [3, 4])
tuple1[3:] # ('abc', 'abc', 1, 2)
tuple1[:] # (1, 2, [3, 4], 'abc', 'abc', 1, 2)

tuple2 = tuple1[:3] + tuple1[4:] # (1, 2, [3, 4], 'abc', 1, 2)
1
2
3
4
5
6
7

4. 元组更改元素

元素更改某元素时，需要找到这个元素所在的位置，并用切片与合并对次元素进行替换

# 更改某元素
tuple1 = (1, 2, [3, 4], 'abc', 'abc', 1, 2)
index = tuple1.index('abc') # 3
tuple2 = tuple1[:index] # (1, 2, [3, 4])
tuple3 = tuple1[index+1:] # ('abc', 1, 2)
tuple4 = ('abc123',)
tuple1 = tuple2 + tuple4 + tuple3 # (1, 2, [3, 4], 'abc123', 'abc', 1, 2)
1
2
3
4
5
6
7