【Python大数据学习笔记_day07】

LKL1026

已于 2023-10-06 21:16:57 修改

阅读量143

点赞数 3

分类专栏： Python大数据学习笔记文章标签： python 学习笔记

于 2023-10-05 21:16:11 首次发布

本文链接：https://blog.csdn.net/qq_52442855/article/details/133586577

版权

Python大数据学习笔记专栏收录该内容

31 篇文章 0 订阅

订阅专栏

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

2.元组的下标索引：

下标索引：就是我们说的编号，也就是容器中每个元素的编号

正索引：从0开始，从左到右，依次递增

负索引：从0开始，从右到左，依次递减

根据下标索引找到对应的元素格式：元组名[索引]

# 需求:定义非空元组,存储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循环

7.字符串的定义：

空字符串：字符串名=str() 字符串名='' 或者字符串名="" 或者字符串名='''''' 或者字符串名=""""""

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

# 定义空字符串
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)

8.字符串的下标索引：

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

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

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

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

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

9.字符串的常规操作：

字符串是不可变类型

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

        类似列表和元组的查询操作:
                字符串[索引]: 查找指定索引位置上的元素
                字符串名.count(元素): 查找指定元素在字符串中出现的次数
                字符串名.index(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
                len(字符串名): 查询当前字符串中所有元素的总个数

        特有查询操作:
                字符串名.rindex(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
                字符串名.find(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1
                字符串名.rfind(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1

        其他特有操作:
                replace:替换
                split: 切割
                join: 连接
                strip: 去除
                startswitch: 以...开头
                endswitch: 以...结尾
                upper: 大写
                lower: 小写

查询操作：

# 需求: 定义非空字符串
s1 = '黑马程序员是传智教育集团旗下的线下IT教育品牌'
# 需求: 查找第二个位置上的字符
print(s1[1])
# 需求: 查询该字符串中有多少个字符
print(len(s1))
# 需求: 查询'育'出现的次数
print(s1.count('育'))
# 需求: 查询'育'出现的索引位置
print(s1.index('育'))  # 从左往右找,返回第一个正索引  9
# 注意: 如果访问了不存在就会报错
# print(s1.index('你')) # 报错 ValueError: substring not found

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

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

其他特有操作：

"""
大字符串.replace(旧子串,新子串): 把大字符串中所有的旧子串替换为新子串
"""
# 需求: 聊天敏感词替换,举例: '你TMD的哦'变成'你***的哦'
s1 = '你TMD的哦'
s2 = s1.replace('TMD', '***')
print(s2)
# 思考:如果多个敏感词怎么替换? 使用链式编程
# 举例: '你TMD的哦,真sb呀' 变成 你***的哦,真**呀
s3 = '你TMD的哦,真sb呀'
s4 = s3.replace('TMD', '***').replace('sb', '**')
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())

10.字符串的遍历：

        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