元组（tuple）

==元组(tuple)是不可变类型==

元组的定义

定义空元组:

方式1(常用): 元组名 = ()  
方式2: 元组名 = tuple()

定义非空元组:

方式1(常用): 元组名 = (元素1 , 元素2 , 元素3 , ...)
方式2: 元组名 = ( (元素1,元素2) , (元素1,元素2) , ...)

注意:如果元组中只有一个元素需要加逗号 定义1个元素的元组: 元组名 = (元素 ,)

# 1.定义空元组
tuple1 = ()
# 可以使用类型()方式定义空元组
tuple2 = tuple()

# 2.定义非空元组
tuple3 = ('张三', '李四', '王五', '赵六')

# 注意: 元组可以存储不同类型数据,但是不建议
tuple4 = ('张三', 10, 3.14, True, None)

# 3.定义嵌套元组
big_tuple = (tuple1, tuple2, tuple3, tuple4)
print(big_tuple)

# 注意:如果元组中只有一个元素需要加逗号
tuple5 = ('张三',)

元组的下标索引

下标索引: 本质就是每个元素对应的编号,但是需要注意的是有两套索引

正索引: 从前到后,从0开始,依次递增

负索引: 从后到前,从-1开始,依次递减

根据索引找元素: 元组名[索引]

元组中最大索引: len(元组)-1

注意: 如果访问了不存在的索引就会报: 索引越界异常(IndexError: tuple index out of range)

#元组嵌套元组
# 定义两个元组,分别存储姓名和年龄
name_tuple = ('张三', '李四', '王五')
age_tuple = (18, 28, 38)
# info嵌套两个小元组
stu_info = (name_tuple, age_tuple)
# 先根据索引获取元素,然后字符串格式化
print(f"{stu_info[0][0]}的年龄是:{stu_info[1][0]}")

最后从info元组中查找元素打印效果如下
张三的年龄18

元组的查询操作

根据索引查询指定位置上的元素: 元组名[索引]

查询元组中元素的总个数: length = len(元组名)

查询指定元素出现的次数: count = 元组名.count(元素) 注意: 查找的元素如果不存在就返回0

查询指定元素的索引位置: index = 元组名.index(元素) 注意: 如果查找的元素不存在就报错: ValueError: tuple.index(x): x not in tuple

#  定义元组存储10,20,30,40,50,10, 10, 30, 10
num_tuple = (10, 20, 30, 40, 50, 10, 10, 30, 10)

#  查询元组中元素的个数
size = len(num_tuple)

#  查询10这个元素出现了几次，查找的元素如果不存在就返回0
count = num_tuple.count(10)

#查询30这个元素的索引位置，如果查找的元素不存在就报错:ValueError: tuple.index(x): x not in tuple
index = num_tuple.index(30)

元组的遍历

# 定义一个元组存储'张三','李四','王五'
name_tuple = ('张三', '李四', '王五')
print(name_tuple)
# for循环遍历:一个个取出赋值给临时变量
for name in name_tuple:
    # 直接输出每个元素
    print(name)

元组的特点

容器特点: 可以容纳多个元素

是否可以混装: 可以容纳不同类型的元素（混装）

是否有下标索引: 数据是有序存储的（有下标序号）

是否支持for循环: 支持(因为for循环又叫遍历循环)

是否支持while循环: 支持(因为有下标序号)

是否允许重复数据: 允许重复数据存在

是否支持元素修改操作: 不支持修改!!!

字符串_str

==字符串(str)是不可变类型==

字符串的定义

定义空字符串:  字符串名 = ''    
字符串名 = ""

定义非空字符串: 字符串名 = '多个字符' 
字符串名 = "多个字符"  
字符串名 = """多个字符_支持换行操作""

字符串的下标索引

标索引: 本质就是每个元素对应的编号,但是需要注意的是有两套索引

正索引: 从前到后,从0开始,依次递增

负索引: 从后到前,从-1开始,依次递减

根据索引找元素: 字符串名[索引]

列表中最大索引: len(字符串名)-1

注意: 如果访问了不存在的索引就会报: 索引越界异常(IndexError: string index out of range)

字符串的查询操作

字符串中的每个元素都单独小字符串，根据索引查询指定位置上的元素: 字符串名[索引]。

查询列表中元素的总个数: length = len(字符串名)

查询指定元素出现的次数: count = 字符串名.count(元素) 注意: 查找的元素如果不存在就返回0

查询指定元素的索引位置: index = 字符串名.index(元素) 注意: 如果查找的元素不存在就报错: ValueError: substring not found

字符串的特有操作

==本质: 不是修改了原有字符串,而是重新生成了一个新字符串或者其他类型内容==

基本方法

把原有字符串中指定内容替换成新内容: 新的字符串 = 原有字符串.replace()

把原有字符串中两端空白或指定内容去除: 新的字符串 = 原有字符串.strip()

根据指定分隔符,把原有字符串切割成多个子串放到列表中: 列表存储切割的小字符 = 原有字符串.split(分隔符)

字符串拓展常用方法

判断是否以某子串开头: 布尔结果 = 字符串名.startswith(子串)

判断是否以某子串结尾: 布尔结果 = 字符串名.endswith(子串)

注意: 以后在字符串中查找索引建议用find,不用index,因为find找不到返回-1,index报错

从左往右找,返回第一个正索引: 索引 = 字符串名.find(子串)， 注意:如果不存在就返回-1。从右往左找,返回第一个正索引: 索引 = 字符串名.rfind(子串)

把字符串中所有字母变成大写: 新字符串 = 字符串名.upper()

把字符串中所有字母变成小写: 新字符串 = 字符串名.lower()

# 定义字符串存储姓名
name = '欧阳AbcD娜娜'
# 判断是否以某子串开头: 字符串名.startswith(子串)
print(name.startswith('欧'))  # True
# 判断是否以某子串结尾:字符串名.endswith(子串)
print(name.endswith('娜'))  # True

# 查找指定元素的索引,如果不存在就返回-1
# 字符串名.find(子串): 从左往右找,返回正索引
print(name.find('娜'))  # 6
print(name.index('娜'))  # 6
# find和index的功能几乎一样,只是如果访问内容不存在,不会报错,返回-1
print(name.find('国'))  # -1
# 字符串名.rfind(子串): 从右往左找,返回正索引
print(name.rfind('娜'))  # 7

# 把字符串中所有字母变成大写:字符串名.upper()
print(name.upper())  # 欧阳ABCD娜娜
# 把字符串中所有字母变成小写:字符串名.lower()
print(name.lower())  # 欧阳abcd娜娜

字符串的特点

容器特点: 可以容纳多个元素

是否可以混装: 只能存储字符串

是否有下标索引: 数据是有序存储的（有下标序号）

是否支持for循环: 支持(因为for循环又叫遍历循环)

是否支持while循环: 支持(因为有下标序号)

是否允许重复数据: 允许重复数据存在

是否支持元素修改操作: 不支持修改!!!

序列(列表/元组/字符串)

==序列: 内容连续、有序，支持下标索引的一类数据容器==

切片

常见的序列: 列表、元组、字符串

序列切片格式: 序列[起始索引:结束索引:步长]

        起始索引: 可以省略，省略就代表从头开始
        结束索引: 可以省略，省略就代表一直到末尾结束
        步长: 可以省略，省略就代表步长为1（可以为负数，表示倒序执行）

# 定义列表
list1 = ['a', 'b', 'c', 'd', 'e']
# 需求1: 多种方式打印整个列表
print(list1[::])
print(list1[:])
print(list1)
# 需求2: 获取['a', 'b', 'c']
print(list1[:3])
# 需求3: 获取['b', 'c', 'd']
print(list1[1:4])
# 需求4: 获取['c', 'd', 'e']
print(list1[2:])
# 需求5: 获取['d', 'c', 'b']
print(list1[3:0:-1])
print(list1[-2:-5:-1])

运算符

序列1 + 序列2: 就是把两个序列中的数据取出拼接到一起产生一个新的序列

序列 * n : 就是把序列数据取出重复拼接n次,产生一个新的序列

# 序列:  列表 元组 字符串
# + 和 *: 运算符操作序列的时候,本质是产生了一个新的序列
# 演示列表
list1 = [1, 2, 3]
list2 = [4]
print(list1 + list2)  # [1, 2, 3, 4]
print(list1 * 2)  # [1, 2, 3, 1, 2, 3]

# 演示元组
tuple1 = (1, 2, 3)
tuple2 = (4,)
print(tuple1 + tuple2)  # (1, 2, 3, 4)
print(tuple1 * 2)  # (1, 2, 3, 1, 2, 3)

# 演示字符串
str1 = '123'
str2 = '4'
print(str1 + str2)  # "1234"
print(str1 * 2)  # "123123"