Python数据容器-元组和字符串

一、数据容器-元组

1.元组的定义

（1）空元组：

        元组名 = （） 或    元组名 = tuple（）

（2）非空元组：

        元组名 = （元素1，元素2，元素3，...）

        只有一个元素时，需要加逗号： 元组名 = （元素1，）

# 定义空元组
tuple1 = ()
print(tuple1, type(tuple1))
tuple2 = tuple()
print(tuple2, type(tuple2))

# 定义非空元组
tuple3 = ('a', 'b', 'c')
print(tuple3, type(tuple3))

# 注意: 如果元组中是一个元素,必须加逗号,
tuple4 = ("张三",)
print(tuple4, type(tuple4))

# 元组的嵌套
class1_tuple = ('张三', '李四', '王五')
print(class1_tuple)
class2_tuple = ('赵六', '田七', '周八')
print(class2_tuple)
school_tuple = (class1_tuple, class2_tuple)
print(school_tuple, type(school_tuple))

2.元组的下标索引

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号

正索引: 从0开始,从左到右,依次递增

负索引: 从-1开始,从右到左,依次递减

根据下标索引查找对应元素格式:  元组名[索引]

# 需求:定义非空元组,存储4个姓名
name_tuple = ('张三', '李四', '王五', '赵六')
# 需求:打印第一个位置的姓名
print(name_tuple[0])  # 正索引
print(name_tuple[-4])  # 负索引
# 需求: 打印最后一个位置的姓名
print(name_tuple[-1])  # 负索引
print(name_tuple[3])  # 正索引
# 注意: 如果访问了不存在的索引就会报错
# print(name_tuple[4])  # IndexError: tuple index out of range

3.元组的常用操作

元组是不支持修改的(元素的增删改操作不支持的)，所以常用操作只有查询

查：查找元素

        元组名[索引]：查找指定索引位置上的元素

        元组名.count（元素）：查找指定元素在元组中出现的次数

        元组名.index（元素）：查找指定元素在元组中的索引位置     注意：元素不存在就报错

        len（元组名）：查询当前元组中所有元素的总个数

# 因为元组是不支持修改的,所以只有查询操作
# 需求: 定义非空元组
t1 = ('张三', '李四', '王五', '赵六', '李四')
# 注意: 元组不支持修改
# t1[0] = '田七' # 报错
print(t1[0])
# index(): 查询指定元素在元组中的索引,不存在就报错
# 需求: 查询'李四'的索引
index = t1.index('李四')
print(index)
# count(): 查询指定元素在元组中的个数,不存在就返回0
count = t1.count('李四')
print(count)
# len(): 查询元组中元素的总个数
print(len(t1))

4.元组嵌套列表

# id(数据): 查看数据的内存地址

# 定义元组嵌套列表
t1 = (10, 20, ['张三', '李四'])
# 需求: 获取元组中的每个元素
print(t1[0], id(t1[0]))  # 10
print(t1[1], id(t1[1]))  # 20
print(t1[2], id(t1[2]))  # ['张三', '李四']
# 测试元组中每个元素本身是否可以修改? 结论:元素整体不能修改
# t1[0] = 11 # 报错
# t1[1] = 22 # 报错
new_list = [33, 44]
print(new_list, id(new_list))
# t1[2] = new_list # 报错


# 注意: 列表本身是支持修改的
t1[2][0] = '王五'
t1[2][1] = '赵六'
print(t1[2], id(t1[2]))

5.元组的遍历

（1）for循环遍历

        for 元素名 in 元组：

                操作元素

（2）while循环遍历

        核心思想：利用while变量作为元组索引

        index=0

        while index < len（元组）：

                元素名 = 元组[index]

                操作元素

                index += 1

（3）对比

while循环和for循环，都是循环语句，但细节不同:

在循环控制上：

        while循环可以自定循环条件，并自行控制

        for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

        while循环可以通过条件控制坐到无限循环

        for循环理论上不能无限循环，因为被遍历的容器容量不是无限的

在使用场景上：

        while循环适用于任何想要循环的场景

        for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

# 定义非空元组
name_tuple = ('张三', '李四', '王五', '赵六')
# for循环遍历元组
for name in name_tuple:
    print(name)

print('--------------------------')
# while循环遍历元组
# 利用元组的索引找每个元素
index = 0
while index < len(name_tuple):
    name = name_tuple[index]
    print(name)
    index += 1

6.元组的特点

        可以存储多个元素
        可以存储不同类型数据
        支持下标索引
        不支持修改
        支持重复
        支持for循环
        支持while循环

二、字符串

1.字符串的定义

（1）空字符串：

字符串名=str()

字符串名=''

字符串名=""

字符串名=''''''

字符串名=""""""

（2）非空字符串：

字符串名='内容'  

字符串名="内容"  

字符串名='''内容'''

字符串名="""内容"""

# 定义空字符串
s = str()
s1 = ''
s2 = ""
s3 = ''''''
s4 = """"""
# 定义非空字符串
s5 = '你好'
s6 = "你好"
s7 = '''你
好
'''
s8 = """你
好
"""
print(s)
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
print(s7)
print(s8)

2.字符串的下标索引

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号

正索引: 从0开始,从左到右,依次递增

负索引: 从-1开始,从右到左,依次递减

根据下标索引查找对应元素格式:  字符串[索引]

# 需求: 定义非空字符串
name = '黑马程序员'
# 需求: 查询第一个位置的元素/字符
print(name[0])
print(name[-5])
# 需求: 查询最后一个位置的元素/字符
print(name[-1])
print(name[4])
# 注意: 如果访问了不存在的索引就会报错: 索引越界异常
print(name[5])  # IndexError: string index out of range

3.字符串的常用操作

字符串是不支持修改的(元素的增删改操作不支持的)

（1）类似列表和元组的查询操作：

        字符串[索引]：查找指定索引位置上的元素

        字符串名.count（元素）：查找指定元素在字符串中出现的次数

        字符串名.index（元素）：从左往右查找指定元素在字符串中的索引位置，返回第一个正索引，如果不存在则报错

        len（字符串名）：查询当前元组中所有元素的总个数

（2）特有查询操作：

        字符串名.rindex（元素）：从右往左查找指定元素在字符串中的索引位置，返回第一个正索引，如果不存在则报错

        字符串名.find（元素）：从左往右查找指定元素在字符串中的索引位置，返回第一个正索引，如果不存在则返回-1

        字符串名.rfind（元素）：从右往左查找指定元素在字符串中的索引位置，返回第一个正索引，如果不存在则返回-1

# 需求: 定义非空字符串
s1 = '随便写个字符串看看'
# 查找第二个位置上的字符
print(s1[1])
# 查询字符串总字符数量
print(len(s1))
# 查询 看 的出现次数
print(s1.count('看'))  # 2
# 查询看的索引位置，从左往右
print(s1.index('看'))  # 7
# print(s1.index('没'))#index查不存在的报错 ValueError: substring not found
print(s1.find('看'))  # 7
print(s1.find('没'))  # find查不存在的返回-1
# 从右往左
print(s1.rindex('看'))  # 8
# print(s1.rindex('没'))#rindex查不存在的报错 ValueError: substring not found
print(s1.rfind('看'))  # 8
print(s1.rfind('没'))  # rfind查不存在的返回-1

（3）其他特有操作：

        replace：替换

        split：切割

        join：连接

        strip：去除

        startswitch：以...开头

        endswitch：以...结尾

        upper：大写

        lower：小写

"""
大字符串.replace(旧子串,新子串): 把大字符串中所有的旧子串替换为新子串
"""
# 需求: 关键词替换,举例: ' 小华为了考试早上买了一杯小米粥喝，让黄飞鸿蒙题目中有几个苹果'中'华为'替换为'**'
s1 = ' 小华为了考试早上买了一杯小米粥喝，让黄飞鸿蒙题目中有几个苹果'
s2 = s1.replace('华为', '**')
print(s2)
# 思考:如果多个关键词怎么替换? 使用链式编程
# 举例: ' 小华为了考试早上买了一杯小米粥喝，让黄飞鸿蒙题目中有几个苹果' 中'华为','小米','鸿蒙','苹果'均替换为'**'
s3 = '小华为了考试早上买了一杯小米粥喝，让黄飞鸿蒙题目中有几个苹果'
s4 = s3.replace('华为', '**').replace('小米', '**').replace('鸿蒙', '**').replace('苹果', '**')
print(s4)

"""
大字符串.split(分隔符,切几次): 根据指定分隔符把一个大字符串切割成多个小字符串,放到列表中返回
                           注意: 默认切割所有
"""
# 需求: 切水果案例
# 举例: 已知大字符串'苹果-梨-橘子-香蕉',把每个水果单独切割出来房东容器中返回
s5 = '苹果,梨,橘子,香蕉'
fruit_list = s5.split(',')
print(fruit_list, type(fruit_list))

"""
'分隔符',join(可迭代对象): 使用指定分隔符把可迭代对象中每个元素连接到一起,生成字符串返回
"""
s6 = ','.join(['苹果', '梨', '橘子', '香蕉'])
print(s6, type(s6))


"""
大字符串.strip(): 默认去除大字符串两端的空白,当然也可以指定要去除两端的字符
大字符串.lstrip(): 默认去除大字符串左端的空白
大字符串.rstrip(): 默认去除大字符串右端的空白
"""
name = '张三'
user_name = ' 张三     '
print(name == user_name)  # False
print(name == user_name.strip())  # True
pwd = '123'
user_pwd = '%123%'
print(pwd == user_pwd)  # False
print(pwd == user_pwd.strip('%'))  # True

"""
大字符串.startswitch(子串): 判断大字符串是否以指定的子串开头
大字符串.endswitch(子串): 判断大字符串是否以指定的子串结尾
"""
# 定义姓名列表,存储多个姓名
name_list = ['张一山', '郭靖', '张无忌', '张翠山', '黄蓉']
# 遍历列表,判断如果以张开头并且以山结尾的打印出来
for name in name_list:
    if name.startswith('张') and name.endswith('山'):
        print(name)

"""
字符串.upper(): 把字符串中所有的字母都转换为大小大写字母
字符串.isupper() : 判断是否是大写
字符串.lower(): 把字符串中所有的字母都转换为大小小写字母
字符串.islower() : 判断是否是小写
"""
# 定义字符串
ss = 'abc123CDE中国'
# 把所有字母转为大写
print(ss.upper())
print('ABC'.isupper())
# 把所有字母转为小写
print(ss.lower())
print('abc'.islower())

4.字符串的遍历

（1）for循环遍历

        for 元素名 in 字符串：

                操作元素

（2）while循环遍历

        核心思想：利用while变量作为字符串的索引使用

        index = 0

        while index < len（字符串）

                元素名 = 字符串[index]

                操作元素

                index+=1

（3）对比

while循环和for循环，都是循环语句，但细节不同:

在循环控制上：

        while循环可以自定循环条件，并自行控制

        for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

        while循环可以通过条件控制坐到无限循环

        for循环理论上不能无限循环，因为被遍历的容器容量不是无限的

在使用场景上：

        while循环适用于任何想要循环的场景

        for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

# 定义字符串
name = '定义字符串'
# for循环遍历
for n in name:
    print(n)

print('-------------')
# while循环遍历
# 核心: 利用while循环变量作为字符串的下标索引
index = 0
while index < len(name):
    n = name[index]
    print(n)
    index += 1

5.字符串特点

        可以存储多个元素
        只能存储字符串类型
        支持下标索引
        不支持修改
        支持重复
        支持for循环
        支持while循环