零、文章目录

Python基础04-数据容器

1、了解字符串

（1）字符串的定义

• 字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。<class ‘str’>即为字符串类型。
• 一对引号字符串

str= 'Tom'
name2 = "Rose"

'''
在Python代码中，字符串是最常见的一种数据类型 => 数据容器的一种，一个变量中可以同时保存多个字符
基本语法：
变量名称 = '变量的值'
或
变量名称 = "变量的值"
另外注意：字符串在输出时，是没有引号的！
'''
name = '刘备'
address = "四川省成都市"

print(type(name))  #<class 'str'>
print(type(address))  #<class 'str'>

# 访问以及获取变量的信息
print(name)
print(address)

print(name, address)

• 三引号字符串：三引号形式的字符串支持换行。

name3 = ''' Tom '''
name4 = """ Rose """

a = '''I am Tom,
	nice to meet you! '''
b = """ I am Rose,
	nice to meet you! """

'''
在Python代码中，字符串除了使用引号进行定义以外，还可以使用三引号的定义方式！
三引号的定义方式与多行注释的语句非常类似，但是字符串定义以后要进行赋值！
三引号定义字符串的优势在于它支持换行操作.
'''
content = '''
    锄禾日当午,
    汗滴禾下土,
    谁知盘中餐,
    粒粒皆辛苦.
'''

print(content)
print(type(content))

• 特殊字符串：使用转义字符

'''
思考一个问题：定义一个字符串，值为I'm Tom!
答：如果在Python字符串中，其又包含了一个引号，要记住一个原则：
① 交叉定义，比如里面是单引号，外面就使用双引号
② 借助于\反斜杠，转义字符，对引号进行转义
'''
str1 = "I'm Tom"
str2 = 'I\'m Tom'

print(str1)
print(str2)

（2）字符串输入

• 在Python中，使用input()接收用户输入，input()方法返回的结果是一个字符串类型的数据。
• input()可以阻断当前正在执行的代码，让系统处于等待状态，直到用户输入完成。

name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')

print(name, age, address)

（3）字符串的输出

• 普通输出

print(变量名称)
print(变量名称1, 变量名称2, 变量名称3)

• 格式化输出–百分号（Python2和Python3）

name = input('请输入您的姓名：')
age = int(input('请输入您的年龄：'))
address = input('请输入您的住址：')

print('我的名字是%s，今年%d岁了，家里住在%s...' % (name, age, address))

• 格式化输出–format方法（Python3）

name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')

print('我的名字是{}，今年{}岁了，家里住在{}...'.format(name, age, address))

• 格式化输出–f形式（Python3）， 推荐使用

name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')

print(f'我的名字是{name}，今年{age}岁了，家里住在{address}...')

• 格式化输出–f简写形式（Python3）

name = input('请输入您购买商品的名称：')
price = float(input('请输入您购买商品的价格：'))  # 18.5

print(f'购买商品名称：{name}，商品价格：{price:.2f}')

（4）字符串的底层存储结构

• 在计算机底层，Python中的字符串是一段连续的内存地址。
• 底层存储结构：索引下标从0开始，索引的最大值 = len(字符串) - 1

（5）索引下标

• 索引下标，就是编号。下标的作用即是通过下标快速找到对应的数据。

'''
在Python中，字符串类型的数据每个字符都有一个编号，我们称之为索引下标，默认从0开始，到字符串最大长度-1结束。
str1 = 'myname'
str1[0] 对应 字符m
str1[1] 对应 字符y
还可以通过 字符名称[索引下标] 来访问字符串中的某个或某几个字符

len(字符串名称) ：代表获取字符串的长度
'''
str1 = 'abcdef'
# print(str1[0])  # a
# print(str1[1])  # b
# print(str1[2])  # c
# print(str1[3])  # d
# print(str1[4])  # e
# print(str1[5])  # f
#
# print(str1[6])  # 报错：out of range

# 使用while循环或for循环遍历
i = 0
while i < len(str1):  # abcdef一共6个字符，循环条件 0 < 6 取值0 1 2 3 4 5
    print(str1[i])
    i += 1

for i in str1:
    print(i)

2、字符串切片

（1）字符串切片是什么

• 切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

（2）基本语法

• 顾头不顾尾，不包含结束位置下标对应的数据， 正负整数均可。
• 步长是选取间隔，正负整数均可，正数从左向右，负数从右向左。默认步长为1。

序列名称[开始位置下标:结束位置下标:步长(步阶)]

numstr = '0123456789'
numstr[0:3:1]  # 012 => range方法非常类似，步长：每次前进1步
numstr[0:3:2]  # 02 => 每次前进2步

（3）切片使用

'''
什么是切片？所谓的切片就是对操作对象截取其中的一部分数据，这个过程就是切片。切片可以针对字符串、列表、元组
基本语法：
字符串名称[起始位置:结束位置:步长]，步长默认为1
备注：起始位置与结束位置都是索引下标，并不是具体的数据！！！

总结切片使用小技巧：
① 绘制图像
② 记住切片口诀（切片其实很简单，只顾头来尾不管，步长为正则正向移，步长为负则逆向移）
正向移动：就是从左向右移动
逆向移动：就是从右向左移动
注意：一定先看步长，确定移动方向，在切片

记住：如果没有开始或者没有结束解决方案
没有开始就代表从切片方向的开头开始算起（从第一个元素）
没有结束就代表截取到切片方向的结尾（到最后一个元素）

注意事项：如果切片方向与步长方向相反，则截取不到任何数据！！！
'''
numstr = '0123456789'

print(numstr[2:5])    # 234
print(numstr[2:5:1])  # 234

# 没有起始位置，只有结束位置，没有步长（默认为1）
print(numstr[:5])  # 01234

# 只有开头没有结尾，先看步长
print(numstr[1:])  # 123456789

# 特殊情况：大家容易犯错的
print(numstr[5::-1])  # 543210

# 没有开头，没有结束，只有一个冒号（相当于对整个字符串进行拷贝操作）
print(numstr[:])  # 0123456789

# 字符串翻转（原来123 => 321)
print(numstr[::-1])  # 9876543210

# 起始位置与结束位置都是负数
print(numstr[-4:-1])  # [-4:-1:1] 678

# 没有开始，只有结束，步长为1的情况（默认）
print(numstr[:-1])  # 012345678

print(numstr[2:5:-1])  # 步长为-1代表从右向左，起始位置与结束位置从左向右

# 步长为某一个数值
print(numstr[::2])  # 0 2 4 6 8（相当于获取所有索引为偶数对应的数据）

3、字符串常用操作方法

（1）字符串查找

• 所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
• find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
• 基本语法：字符串序列.find(子串, 开始位置下标, 结束位置下标)，开始和结束位置下标可以省略，表示在整个字符串序列中查找。

'''
find()方法：主要功能就是查找关键词在字符串中出现的位置，找到了就返回开始的索引下标，没有找到，返回-1
'''
str1 = 'hello python'
# 查找python关键字在字符串中出现的位置
print(str1.find('python'))  # 6（关键字所在位置）
print(str1.find('bigdata'))  # -1（未找到对应的内容）

'''
find()：查找关键词在字符串中出现的位置
上传文件：avatar.png
第一个部分：avatar => 文件名称
第二个部分：.png => 文件后缀名
'''
file = input("请上传您的文件：")
# 第一步：查找点号所在的位置
index = file.find('.')
# 第二步：通过点号的索引获取文件名称
filename = file[:index]  # file[0:6:1]
# 第三步：通过点号的索引获取文件的后缀名 => .png这部分
postfix = file[index:]   # file[6::1]

print(f'文件名称：{filename}')
print(f'文件后缀：{postfix}')

（2）字符串修改

• 所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。

• 数据按照是否能直接修改分为可变类型和不可变类型两种。由于字符串属于不可变类型，所以修改的时候不能改变原有字符串，只能返回新字符串。

• replace()：返回替换后的字符串

  • 基本语法：字符串序列.replace(旧子串, 新子串, 替换次数)
  • 注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

• split()：按照指定字符分割字符串

  • 基本语法：字符串序列.split(分割字符, num)
  • 注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个

• join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串

'''
replace(old, new) ： 把字符串中的关键词进行替换
split(分隔符号) ：使用分割符号对字符串进行切割，返回一个列表，列表中的每一个元素就是分隔符两边的数据
join(列表容器) ：把一个列表在拼接为字符串
'''
str1 = 'hello python'
print(str1.replace('python', 'bigdata'))  # hello bigdata

str2 = 'apple-banana-orange'
list2 = str2.split('-')
print(list2)  # ['apple', 'banana', 'orange']

list3 = ['apple', 'banana', 'orange']
print('-'.join(list3)) #apple-banana-orange

（3）字符串判断

• 所谓判断即是判断真假，返回的结果是布尔型数据：True 或 False。
• isdigit() ：如果 mystr 所有字符都是数字则返回 True，否则返回 False

'''
isdigit() ：判断一个字符串是否全部由纯数字组成，全部为纯数字True，反之就返回为False
'''
password = input('请输入您的6位银行卡密码：')

# 输入的密码是否合理
if password.isdigit():
    print(f'您的银行卡密码为{password}')
else:
    print('您输入的银行卡有误，请重新输入！')

4、列表及其应用

（1）为什么需要列表

• 思考：有一个人的姓名(TOM)怎么书写存储程序？
  • 答：变量。
• 思考：如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？
  • 答：No，我们使用列表就可以了， 列表一次可以存储多个数据。

（2）列表的定义

• 基本语法：列表名称 = [数据1, 数据2, 数据3, 数据4, …]
• 注意：列表可以一次存储多个数据且可以为不同的数据类型

'''
为什么需要列表？
答：列表是容器的一种，允许我们在一个列表容器中同时保存多个数据信息

列表的定义
列表名称 = [元素1, 元素2, 元素3]

在Python中，列表中的每一个元素也有一个对应的索引下标，默认从0开始，所以我们也可以通过：
列表名称[索引下标]
实现对列表中某个元素的访问！
'''
names = ['张三', '李四', '王五', '赵六']
print(names)
print(type(names))  # list => 列表类型

# 访问李四
print(names[1])
print(names[2])

# 对列表进行遍历操作
i = 0
while i < len(names):
    print(names[i])
    i += 1

for i in names:
    print(i)

（3）列表的常用操作

• 列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
• 查询
  • 索引下标：通过索引下标获取列表数据
  • len()方法：获取列表的长度（列表中元素的个数）
  • in：判断指定数据在某个列表序列，如果在返回True，否则返回False

'''
列表名称[索引下标] ：访问列表中的元素
len(列表名称) ：求列表的长度（列表中元素的个数），配合while循环实现遍历操作
if 元素 in 数据容器：判断元素是否出现在容器中，如果出现，则返回True，没有出现，则返回False
in方法 => 既可以在字符串中使用，也可以在列表中使用，甚至还可以在元组中使用！
'''
black_ip = ['192.168.89.77', '222.246.129.81', '172.16.54.33']
if '192.168.89.77' in black_ip:
    print('您的IP已被锁定，禁止访问！')
else:
    print('您的IP正常，可以正常访问此服务器！')
    
# 注意：in方法还可以用于字符串
str1 = 'hello python'
if 'py' in str1:
    print('py关键词出现在str1字符串中')
else:
    print('py关键词没有出现在str1字符串中')

• 增加
  • append()方法：增加指定数据到列表中

'''
append() : 在列表的尾部追加元素，append()方法本身不返回任何内容，所以我们追加完毕后，要打印原列表
+ 加号 : 可以把两个列表进行合并操作
'''
list1 = ['刘备', '曹操']
# 希望向列表中追加一个元素
list1.append('孙权')
# 打印list1
print(list1) #['刘备', '曹操', '孙权']

list2 = ['贾宝玉', '薛宝钗']
list3 = ['林黛玉', '刘姥姥']
print(list2 + list3)#['贾宝玉', '薛宝钗', '林黛玉', '刘姥姥']

• 删除
• remove()方法：移除列表中某个数据的第一个匹配项。

'''
remove() : 根据元素值删除元素，remove()本身也不返回任何内容，打印时要打印原列表
'''
list1 = [10, 20, 30, 40]
# 删除元素值为30的这个元素
list1.remove(30)
print(list1)#[10, 20, 40]

• 修改
  • 列表[索引] = 修改后的值

'''
列表名称[索引] = 修改后的值，代表把列表中指定索引的这个元素进行修改操作
'''
list1 = ['刘备', '曹操', '孙权']
# 替换列表中的刘备 => 刘禅
list1[0] = '刘禅'
print(list1)#['刘禅', '曹操', '孙权']

• 排序
  • reverse()：将数据序列进行倒叙排列，列表序列.reverse()
  • sort()方法：对列表序列进行排序，列表序列.sort( key=None, reverse=False)，reverse表示排序规则，reverse = True降序， reverse = False升序（默认）

'''
reverse() ：字符串的翻转操作，相当于切片中的[::-1]
sort(reverse=False) ：把列表中的元素从小到大排序，也可以通过更改参数让其从大到小排序
'''
list1 = [5, 3, 2, 7, 1, 9]
list2 = ['刘备', '关羽', '张飞']

# 列表翻转
list2.reverse()
print(list2)#['张飞', '关羽', '刘备']

# 列表翻转
print(list2[::-1])#['刘备', '关羽', '张飞']

# 列表排序
list1.sort(reverse=True)
print(list1)#[9, 7, 5, 3, 2, 1]

（4）while循环遍历列表

name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

（5）for循环遍历列表

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
    print(i)

5、列表嵌套

（1）列表嵌套是什么

• 所谓列表嵌套指的就是一个列表里面包含了其他的子列表

（2）应用场景

• 要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。
• name_list = [[‘小明’, ‘小红’, ‘小绿’], [‘Tom’, ‘Lily’, ‘Rose’], [‘张三’, ‘李四’, ‘王五’]]

（3）嵌套列表操作

'''
什么是列表的嵌套？答：所谓的嵌套就是在列表中又出现了列表结构！
基本语法：
列表名称 = [[], [], []]

举个栗子：假设我们有三个班级，分别为一班、二班、三班
1班：Tom, Jack, Harry
2班：小明，小红，小绿
3班：刘备，关羽，张飞
如何实现保存以上信息
'''
# students = [1班, 2班, 3班]
students = [['Tom', 'Jack', 'Harry'], ['小明', '小红', '小绿'], ['刘备', '关羽', '张飞']]
# 需求：访问小红的信息 => 原则，先访问外层，在访问内层
print(students[1][1])

6、元组及其应用

（1）为什么需要元组

• 思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
  • 答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。
• 那这种情况下，我们想要存储多个数据且数据不允许更改，应该怎么办呢？
  • 答：使用元组，元组可以存储多个数据且元组内的数据是不能修改的。

（2）定义元组

• 元组特点：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
• 基本语法：

# 多个数据元组
tuple1 = (10, 20, 30)

# 单个数据元组
tuple2 = (10,)

• 注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型。

t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str

• 定义与访问

'''
在Python数据容器中，有一种特殊的数据类型 => 元组tuple
元组类型和列表一样，都可以在一个变量中同时保存多个数据。但是两者又有所不同：
元组中的数据一旦定义成功以后，就不能进行修改和删除了！

基本语法：
元组名称 = (元素1, 元素2, 元素3)
注意：如果定义的元组是一个单元素元组，则最后必须保留一个逗号，否则定义的就不是元组类型了！
'''
# 1、定义一个单元素的元组（特殊）
tuple1 = (10,)
print(type(tuple1))

# 2、定义一个多元素的元组（常用）
tuple2 = (10, 20, 30, 40)
print(type(tuple2))

# 3、元组的访问
print(tuple1)
print(tuple2)

# 4、对元组进行遍历while循环 也可以通过 for循环
for i in tuple2:
    print(i)

# 5、还可以通过元组名称[索引下标]访问元素
print(tuple2[2])

（3）元组的应用场景

• 函数的参数和返回值，一个函数可以接受任意多个参数，或者依次返回多个数据(了解)

def func(参数1, 参数2, 参数3):
    return 返回值1, 返回值2, 返回3

• 格式化字符串，百分号和format，格式化字符串后面的（）本质上就是一个元组

print('姓名：%s，年龄：%d，家庭住址：%s'  %  (name, age, address))

• 让列表不可以修改，以保护数据安全

• python操作mysql数据库，返回结果，默认也是元组类型

（4）元组的相关操作

• 查询
  • 元组[索引] ：根据索引下标查找元素
  • len()：统计元组中数据的个数
  • in：判断元素是否出现在元组中

'''
由于元组特性：一旦定义成功以后，就不能进行修改和删除了。所以其方法主要都是查询方法
① 元组名称[索引编号] : 访问元组中的某个元素
② len(元组名称) : 求元组中元素的个数（总长度）
③ if 元素 in 元组 : 判断元素是否出现在元组中，出现返回True，没有出现，则返回False
'''
tuple1 = ('刘备', '关羽', '张飞')
print(tuple1[0])
print(tuple1[1])
print(tuple1[2])

tuple2 = (10, 20, 30, 40, 10)
print(len(tuple2))

if '关羽' in tuple1:
    print('关羽这个元素出现在tuple1元组中')
else:
    print('关羽这个元素没有出现在tuple1元组中')

• 修改：元组内的数据如果直接修改则立即报错，但是如果元组里面有列表，修改列表里面的数据则是支持的，故这个特点非常重要。

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2) # (10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)

7、字典及其应用

（1）为什么需要字典

• 思考1： 如果有多个数据，例如：‘Tom’, ‘男’, 20，如何快速存储？
  • 答：列表，list1 = [‘Tom’, ‘男’, 20]
• 思考2：如何查找到数据’Tom’？
  • 答：查找到下标为0的数据即可，list1[0]
• 思考3：如果将来数据顺序发生变化，如下所示，还能用list1[0]访问到数据’Tom’吗？list1 = [‘男’, 20, ‘Tom’]
  • 答：不能，数据’Tom’此时下标为2。
• 思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一的标准查找数据呢？
  • 答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

（2）字典的定义

• 字典特点：
  • 符号为大括号（花括号）
  • 数据为键值对形式出现
  • 各个键值对之间用逗号隔开
  • 一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v；key:value就是我们通常说的键值对了。
• 基本语法：

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': 'male'}
# 空字典
dict2 = {}
dict3 = dict()

• 定义与访问

'''
在Python中，有一种比较特殊的数据类型叫做字典类型，其特别适合保存一个事物的信息。如一个人的信息、一本书的信息、一个商品的信息等等。
一个人：姓名、性别、年龄
一本书：标题、价格、出版社
一个商品：标题、描述、价格、库存...
字典是如何定义的？基本语法：
字典名称 = {key1:value1, key2:value2, key3:value3}
注意事项：字典中是没有索引下标的，其是通过key:value键值对来体现键（等价于索引下标）与值的关系
key：键名，必须是唯一的且没有顺序要求，其可以是（字符串类型、数字化类型）或者元组类型
value：代表的字典中具体的元素值

常见问题答疑：
① 字典是没有切片的，不被允许的，因为字典没有索引下标
② 创建有数据的字典，只能通过{}大括号，不能通过dict()方法
③ 无论key还是value，遵循一个原则：如果是字符串类型，则添加引号。如果是数值类型，则不需要添加引号
'''
# 1、定义一个空字典
dict1 = {}
dict2 = dict()

print(type(dict1))
print(type(dict2))

# 2、定义一个有数据的字典
dict3 = {'name':'Tom', 'gender':'male', 'age':20}

# 3、输出字典
print(dict3)

# 4、访问字典中具体某个value值 => 字典名称[key]
print(dict3['name'])
print(dict3['gender'])
print(dict3['age'])

（3）字典的"增"和“改”操作

• 基本语法：字典序列[key] = value
• 注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

'''
在Python中，字典的新增与修改使用的是相同的语法：
字典名称[key] = value值

① 如果字典中没有这个key，以上就是一个新增操作
② 如果字典中有这个key，以上就是修改操作
'''
# 1、定义一个空字典
person = {}

# 2、添加数据 => key:value键值对
person['name'] = 'Tom'
person['age'] = 20
person['gender'] = 'male'
print(person) # {'name': 'Tom', 'age': 20, 'gender': 'male'}

# 3、修改数据 => 字典名称[已存在的key] = value值
person['age'] = 21
print(person) # {'name': 'Tom', 'age': 21, 'gender': 'male'}

（4）字典的"删"操作

• del：删除字典或删除字典中指定键值对

'''
字典的删除操作主要删除字典中满足条件的key:value键值对！
基本语法：
del 字典名称[key]
解析：根据字典中的key，删除满足条件的key:value键值对
'''
# 1、定义一个有数据的字典
student = {'name':'陈城', 'age':23, 'gender':'male'}

# 2、删除字典中的age:23
del student['age']
print(student) # {'name': '陈城', 'gender': 'male'}

（5）字典的“查”操作（重点）

• 字典名称[key]：代表访问指定的元素，如果当前查找的key存在，则返回对应的值；否则则报错。
• keys() ：以列表返回一个字典所有的键
• values() ：以列表返回字典中的所有值
• items() ：以列表返回可遍历的(键, 值) 元组数组

'''
① 获取字典中的某个元素，字典名称[key]，代表访问指定的元素
② 字典也支持直接打印输出
③ 字典也可以配合for循环进行遍历，但是要特别注意：只有字典中的key可以遍历出来（默认）

其他方法：
keys() ：以列表方式返回字典中所有的key键
values() ：以列表方式返回字典中所有的value值
items() ：以外面是列表，里面每一个元素都是元组的方式获取字典中的key,value键值对 => [(key1, value1), (key2, value2)]
注意：以上三个方法很少单独使用，都要配合for循环进行遍历操作
'''
student = {'name':'Jack', 'age':20, 'address':'广州市天河区'}
# ① 直接获取字典中的某个元素
print(student['name'])
print(student['age'])
print(student['address'])

# ② 直接打印字典
print(student)

# ③ 使用for循环直接对字典进行遍历
for key in student:
    print(key)

# ④ 使用keys方法获取字典中所有的key键与上面的代码等价
for key in student.keys():
    print(key)

# ⑤ 使用values()方法获取字典中所有的value值
for value in student.values():
    print(value)

# ⑥ 使用items()方法获取字典中的key, value键值对
for key, value in student.items():
    print(f'{key}：{value}')

（6）列表和字典结合

• 把列表 + 字典结合起来就可以同时保存多个事物的信息

'''
列表：特别适合保存多个数据
字典：特别适合保存一个事物的信息，如一个人、一本书、一个商品等等
把列表 + 字典结合起来就可以同时保存多个事物的信息，比如多个人、多本书、多个商品
比如开发一个学生管理系统
'''
# 1、定义一个大列表，里面用于保存多个同学的信息
students = []

# 2、定义一个字典，把字典追加到列表中，形成以下结构 => [{}, {}, {}]
student = {'name':'岁鹏', 'age':23, 'mobile': '10086'}
students.append(student)
print(students) # [{'name': '岁鹏', 'age': 23, 'mobile': '10086'}]

# 3、把字典追加到列表中
student = {'name':'小美', 'age':19, 'mobile': '10010'}
students.append(student)
print(students) # [{'name': '岁鹏', 'age': 23, 'mobile': '10086'}, {'name': '小美', 'age': 19, 'mobile': '10010'}]

• 学生管理系统删除功能实现

# 1、定义一个大列表，里面保存了所有同学的信息
students = [{'name': '岁鹏', 'age': 23, 'mobile': '10086'}, {'name': '小美', 'age': 19, 'mobile': '10010'}]

# 2、提示用户输入要删除的同学名称
name = input('请输入您要删除同学的名称：')  # 小明

# 3、对列表进行遍历
for i in students:
    if i['name'] == name:
        # 删除整个字典
        students.remove(i)
        # 弹出提示
        print('删除成功')
        print(students)
        break
else:
    print('很抱歉，您要删除的同学未找到！')

8、集合及其应用

（1）集合是什么

• 集合（set）是一个无序的不重复元素序列（数据容器）。

（2）集合的定义

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

'''
Python中，集合具备一个特点：天生去重，官方定义：集合是一个无序且不重复的数据集合。
① 集合里面的数据没有顺序
② 集合中的数据是不重复的
在Python中，我们可以通过{}或者set()方法来实现集合的定义。
问题：字典也是通过{}大括号，集合也是通过{}大括号，如何区分我们的定义的是一个字典还是一个集合呢？
答：主要看里面的数据结构，如果{}中存放的是键值对，则代表是一个字典类型的数据；如果大括号中是具体的值，则代表其是一个集合类型的数据。
注：空集合只能通过set()方法来进行实现，{}定义的默认是空字典。
'''
# 1、空集合的定义
set1 = set()
print(type(set1)) # <class 'set'>

# 2、定义一个有数据的集合
set2 = {10, 20, 30, 40, 20, 50}
print(type(set2)) # <class 'set'>

# 3、set()方法也可以把其他类型的数据转换为集合，如字符串
set3 = set('abcdefg')
print(set3) # {'b', 'f', 'e', 'g', 'c', 'a', 'd'}
print(type(set3)) # <class 'set'>

# 4、集合中元素的访问：由于集合中的数据没有顺序，所以其没有索引下标，数据的访问有两种方案
# ① 直接打印
print(set2) # {50, 20, 40, 10, 30}
# ② 使用for循环对其进行遍历操作(只能使用for循环)
for i in set2:
    print(i)

（3）集合的基本操作

• 增加：add()方法 ：增加单一元素，因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。
• 删除
  • remove()方法：删除集合中的指定数据，如果数据不存在则报错。
  • pop()：删除第一个元素，删除后，pop()方法返回被删除的那个元素
• 查询：in：判断元素是否出现在集合中，出现True，反之，则返回False

'''
增加方法：add()，主要用于向集合中添加数据
删除方法：remove()，根据值删除指定的元素
        pop()，删除第一个元素，删除后，pop()方法返回被删除的那个元素
查询方法：if 元素 in 集合，判断元素是否出现在集合中，出现True，反之，则返回False
'''
# 1、定义一个空集合
set1 = set()

# 2、想其追加数据
set1.add(10)
set1.add(20)
set1.add(30)
set1.add(20)
set1.add(40)
print(set1) # {40, 10, 20, 30}

# 3、在2的基础上，删除20这个元素
set1.remove(20)
print(set1) # {40, 10, 30}

# 4、删除第一个元素
set1.pop()
print(set1) # {10, 30}

# 5、判断元素是否出现在集合中
if 10 in set1:
    print('10 exist in the set1')
else:
    print('10 not exist in the set1')

9、数据容器的公共方法

（1）方法介绍

（2）+ 合并操作

# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)

（3）* 复制操作

# 1. 字符串
print('-' * 10)
# 2. 列表
list1 = ['hello']
print(list1 * 4)
# 3. 元组
t1 = ('world',)
print(t1 * 4)

（4）in

# 1. 字符串
print('a' in 'abcd') # True
print('-' * 10)
# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('-' * 10)
# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('-' * 10)
# 4. 字典
dict1 = {'name': 'heima', 'age':18}
print('name' in dict1) # True

（5）max()与min()

• max() ：返回容器的最大值
• min() ：返回容器的最小值

num1 = int(input('请输入第一个数：'))
num2 = int(input('请输入第二个数：'))
num3 = int(input('请输入第三个数：’))
list1 = [num1, num2, num3]
max_num = max(list1)
min_num = min(list1)
print(f'最大值：{max_num}’)
print(f'最小值：{min_num}')

（6）容器类型转换

• tuple()方法：将某个序列转换成元组

• list()方法：将某个序列转换成列表

• set()方法：将某个序列转换成集合（但是要注意两件事 => ① 集合可以快速完成列表去重 ② 集合不支持下标）

'''
int() ：把其他数据类型转换为int整数类型
float() ：把其他数据类型转换为float浮点类型
str() ：把其他数据类型转换为str字符串类型
eval() ：只能转换字符串类型的数据，相当于把字符串类型的数据转换为原数据类型

list() ：把其他数据类型转换为list列表类型
tuple() ：把其他数据类型转换为tuple元组类型
set() ：把其他数据类型转换为set集合类型 => 去重
'''
# 1、定义一个元组类型的数据
tuple1 = (10, 20, 30) # 元组
list1 = list(tuple1) #转换列表
print(list1) # [10, 20, 30]

# 2、定义一个集合类型的数据
set2 = {'刘备', '关羽', '张飞'} # 集合
list2 = list(set2) # 转换列表
print(list2) # ['关羽', '刘备', '张飞']

# 3、定义一个列表类型的数据
list3 = [1, 3, 5, 7, 9] # 列表
tuple3 = tuple(list3) # 转换元组
print(tuple3) # (1, 3, 5, 7, 9)

# 4、定义一个集合类型的数据
set4 = {50, 30, 20, 10} # 集合
tuple4 = tuple(set4) # 转换元组
print(tuple4) # (50, 10, 20, 30)

# 5、定义一个列表或元组类型的数据
list5 = [10, 20, 30, 20, 40, 50] # 列表
# 需求：针对这个列表进行去重操作，要求返回结果还是一个列表
set5 = set(list5) # 转换集合 会去重
print(set5) # {40, 10, 50, 20, 30}
# 把集合类型在转换为列表类型
list5 = list(set5) # 转换列表
print(list5) # [40, 10, 50, 20, 30]

10、列表集合字典推导式

（1）推导式是什么

• 推导式comprehensions（又称解析式），是Python的一种独有特性。
• 推导式是可以从一个数据序列构建另一个新的数据序列（一个有规律的列表或控制一个有规律列表）的结构体。

（2）为什么需要列表推导式

'''
案例：生成一个0-9之间的列表，[0, 1, 2, 3, ..., 7, 8, 9]
'''
# 1、while循环
i = 0
list1 = []
while i < 10:
    list1.append(i)
    i += 1
print(list1)

# 2、for循环
list2 = []
for i in range(10):
    list2.append(i)
print(list2)

# 3、推导式的概念 => 用于推导生成一个有规律的列表
list3 = [i for i in range(10)]
print(list3)

（3）列表推导式

• 基本语法：

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

变量 = [表达式 for 临时变量 in 序列 if 条件判断]

等价于

for 临时变量 in 序列:
    if 条件判断

• 案例：创建一个0-9的列表

list1 = [i for i in range(10)]
print(list1)

• 案例：生成0-9之间的偶数

# 方法一：range()步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)

# 方法二：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

'''
列表推导式就是用于简化以下代码：
① for循环结构
list1 = []
for i in range(10):
    list1.append(i)
简化为推导式：
list2 = [i(列表中最终的元素) for i in range(10)]

② for循环 + if嵌套结构
# 案例1：生成一个列表，包含0-9之间所有的偶数 => [0, 2, 4, 6, 8]
'''
list1 = []
for i in range(10):
    if i % 2 == 0:
        list1.append(i)
print(list1)

# 简化为列表推导式
list2 = [i for i in range(10) if i % 2 == 0]
print(list2)

# 案例2：有一个列表，里面内容为[1, 2, 3, 4, 5]，通过Python代码将其转换为[1, 4, 9, 16, 25]
list3 = [1, 2, 3, 4, 5]
list4 = []
for i in list3:
    list4.append(i ** 2)
print(list4)

list5 = [i ** 2 for i in list3]
print(list5)  # 1, 4, 9, 16, 25