python 出去set空字符串元素

思考：列表是可以修改的。 如果想要传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于： 元组一旦定义完成，就不可修改 所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

元组和字符串

1元组

1.1 元组的定义

定义空元组:  元组名 = ()   或者  元组名 = tuple()

定义非空元组:  元组名 = (元素1,元素2,元素3,...)   注意: 如果只有一个元素需要加逗号

①.示例:

"""
替换: ctrl+R
查找: ctrl+F
"""
# 定义空元组
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))

1.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

1.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))

②.元组嵌套列表示例:

# 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]))

1.4 元组的遍历

1.for循环遍历
    for 元素名 in 元组:
        操作元素
        
2.while循环遍历
    核心思想: 利用while变量作为元组的索引使用
    index = 0
    while index < len(元组):
        元素名 = 元组[index]
        操作元素
        index+=13.对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
    while循环可以自定循环条件，并自行控制
    for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
    while循环可以通过条件控制做到无限循环
    for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
    while循环适用于任何想要循环的场景
    for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

①.示例:

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


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

1.5 元组的特点

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

2. 字符串[重点]

尽管字符串看起来并不像列表、元组那样，一看就是存放了许多数据的容器。 但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

2.1 字符串的定义

空字符串:
字符串名=str()
字符串名=''
字符串名=""
字符串名=''''''
字符串名=""""""

非空字符串:
字符串名='内容'
字符串名="内容"
字符串名='''内容'''
字符串名="""内容"""

①.示例:

# 定义空字符串
s = str()
s1 = ''
s2 = ""
s3 = ''''''
s4 = """"""

# 定义非空字符串
s5 = '中秋节'
s6 = "国庆节"
s7 = '''农历8.15
中秋节
'''
s8 = """10.1
国庆节
"""
print(s)
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
print(s7)
print(s8)

2.2 字符串的下标索引

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号 正索引: 从0开始,从左到右,依次递增 负索引: 从-1开始,从右到左,依次递减 根据下标索引查找对应元素格式: 字符串[索引]

①.示例:

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

2.3 字符串的常用操作

字符串是不可变类型

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

类似列表和元组的查询操作:
    字符串[索引]: 查找指定索引位置上的元素
    字符串名.count(元素): 查找指定元素在字符串中出现的次数    
    字符串名.index(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
    len(字符串名): 查询当前元组中所有元素的总个数
    
特有查询操作:
   字符串名.rindex(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
   字符串名.find(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1
   字符串名.rfind(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1
    
其他特有操作:
    replace:替换
    split: 切割
    join: 连接
    strip: 去除
    startswitch: 以...开头
    endswitch: 以...结尾
    upper: 大写
    lower: 小写

①.查询操作:

# 需求: 定义非空字符串
s1 = '农历8.15中秋节是传统节日'
# 需求: 查找第二个位置上的字符
print(s1[1])
# 需求: 查询该字符串中有多少个字符
print(len(s1))
# 需求: 查询'节'出现的次数
print(s1.count('节'))
# 需求: 查询'节'出现的索引位置
print(s1.index('节'))  # 从左往右找,返回第一个正索引  9
# 注意: 如果访问了不存在就会报错
# print(s1.index('你')) # 报错 ValueError: substring not found

# 拓展
# 和列表元组查询操作不同的查询操作
print(s1.rindex('节'))  # 从右往左找,返回第一个正索引  13
# print(s1.rindex('你')) # 报错 ValueError: substring not found

# 因为index和rindex如果找不到就报错,会影响程序继续执行,字符串中提供了find和rfind解决了此问题
print(s1.find('节')) # 9
print(s1.find('你'))  # 不报错,如果找不到直接返回-1,不影响后续代码执行
print(s1.rfind('节')) # 13
print(s1.rfind('你'))  # 不报错,如果找不到直接返回-1,不影响后续代码执行

②.其他特有操作:

"""
大字符串.replace(旧子串,新子串): 把大字符串中所有的旧子串替换为新子串
"""
# 需求: 聊天关键词语替换,举例: '你蠢得像pig哦'变成'你***哦'
s1 = '你蠢得像pig哦'
s2 = s1.replace('蠢得像pig', '****')
print(s2)

# 思考:如果多个关键词语怎么替换? 使用链式编程
# 举例: '你T萌D的哦,真傻呀' 变成 你***的哦,真**呀
s3 = '你T萌D的哦,真傻呀'
s4 = s3.replace('T萌D', '***').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())

2.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 = '农历8.15中秋节'
# for循环遍历
for n in name:
    print(n)


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

2.5 字符串的特点

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