python基础知识分享03-容器类型介绍

• 容器类型介绍
  • 字符串
  • 列表
  • 集合
  • 元组
  • 字典
• 字符串切片
• 字符串相关函数
  • len()
  • find()
  • rfind()
  • index()
  • rindex()
• 字符串案例
  • 统计大串中, 小串出现的次数
• 列表介绍
• 列表的CURD操作

---

1.容器类型入门

"""
容器类型介绍:
    概述:
        容器类型指的是用来 同时存储 多个元素 的一种类型, 即: 存储多个值的.
    常用的容器类型:
        字符串: str
        列表:  list
        元组:  tuple
        字典:  dict
        集合:  set
    回顾之前学习的 "单值"类型:
        整型: int
        浮点型: float
        布尔型: bool

字符串介绍:
    概述:
        它属于容器类型的一种, 可以同时存储多个字符. 例如: 'abc', 就是由字符'a', 'b', 'c'组成的.
    特点:
        1. 字符串值必须用引号包裹, 单双引号均可.
        2. 字符串中的每个字符都是有编号(脚标, 下标, 索引),
           正向索引: 是从左往右的顺序, 从0开始数.
           逆向索引: 是从右往左的顺序, 从-1开始数.
    格式:
        格式1: 单双引号包裹即可, 不能换行.
        格式2: 可以用三引号包裹, 支持换行.
"""
# 1. 字符串入门.
s1 = '张三'
s2 = "李四"
print(s1, s2)
print('-' * 31)

# 2. 用字符串存储 I'm Tom!
s3 = "I'm Tom!"
print(s3)

s4 = 'I\'m Tom!'        # \'类似于之前的\n, \t, 被称之为: 转义符.
print(s4)
print('-' * 31)

# 3. 格式化字符串, 三引号包裹, 单双引号均可.
sql1 = """
select
    *
from
    student;
"""
print(sql1)

sql2 = '''
select
    * 
from
    teacher
'''
print(sql2)

2.字符串-索引

"""
字符串的索引介绍:
    概述:
        索引也叫下标, 脚标, 编号, 目的是: 方便我们快速去字符串中查找对应字符的.
    格式:
        字符串[编号]     根据编号, 从字符串中获取对应的字符.
    解释:
        字符串中每个字符都是有编号的, 从左往右数, 叫: 正向索引, 从0开始.   从右往左数, 叫: 逆向索引, 从-1开始.
"""
# 1. 定义1个字符串.
s1 = 'abcdefg'

# 2. 根据索引, 获取字符串中的某个字符.
print(s1[3])     # d, 正向索引, 从0开始数, 即: 0 ->
print(s1[-4])    # d, 逆向索引, 从-1开始数, 即: <- -1


print(s1[5])   # f
print(s1[-2])  # f

3.字符串-切片

"""
字符串切片介绍:
    概述:
        所谓的切片, 就是去字符串中截取出指定的部分, 不仅字符串支持切片, 列表, 元组等也支持切片.
    格式:
        [起始索引:结束索引:步长]
    格式解释:
        1. 如果不写起始索引, 默认: 从索引0开始.
        2. 如果不写结束索引, 默认: 是字符串的长度, 即: 能取到字符串的最大索引
        3. 如果不写步长, 默认是: 1
        4. 上述的格式中, 是包左不包右的, 即: 包括起始索引, 不包括结束索引.
        5. 上述的格式中, 不仅支持正常索引(从左往右), 支持逆向索引(从右往左).
    例如:
        s1   =   'a     b   c   d   e   f   g'          # 假设没有空格, 即: 'abcdef', 加空格, 是为了更好的和下述索引对应.
        正向索引:  0     1   2   3   4   5   6
        逆向索引: -7    -6  -5  -4  -3  -2   -1
"""

# 1. 定义字符串.
s1 = 'abcdefg'

# 2. 演示切片.
print(s1[2:5])      # cde
print(s1[2:5:1])    # cde, 同上

print(s1[2:])       # cdefg, 不写结束索引, 默认到最后.
print(s1[:5])       # abcde, 不写起始索引, 默认: 从索引0开始.
print(s1[:5:2])     # ace, 不写起始索引, 默认: 从索引0开始.  步长为2

print(s1[-1:])      # g, 默认步长是1, 表示从左往右拿.
print(s1[-6:-1])    # bcdef
print('-' * 31)

print(s1[-3:-5])    # 不报错, 没内容. 默认步长是1, 表示从左往右拿.
print(s1[-3:-5:-1]) # ed, 负数步长, 表示从右往左拿数据.
print(s1[-3::-2])         # eca

# 3. 特殊写法, 反转字符串内容.
print(s1[::-1])     # gfedcba

4.字符串-常用函数

"""
函数介绍:
    可以理解为就是Python已经定义好的规则, 我们直接拿过来用就可以了.
    简单理解: 函数 = 工具

字符串常用函数介绍:
    len()           # 获取字符串的长度.
    find()          # 查找子串在字符串中, 第一次出现的位置, 找不到就返回-1
        格式:
            字符串.find(字符串, 起始索引, 结束索引)  起始索引和结束索引是指定查找范围, 不写就是在整个字符串中查找.
    rfind()         # 查找子串在字符串中, 最后一次出现的位置, 找不到就返回-1, 格式同上.

    index()         # 作用和find()一样, 区别在于: 找不到就报错.
    rindex()        # 作用和rfind()一样, 区别在于: 找不到就报错.

    replace(旧字符串, 新字符串, 个数)   # 用新字符串替换旧字符串, 替换几个(不写就替换所有).
    split(切割字符, 个数)             # 按照指定字符切割字符串, 指定个数表示切几个, 不指定就切所有.
    count()                         # 统计次数.
"""

# 1. 定义字符串
#           6          17      25
s1 = "hello and python and sql and linux"

# 2. 打印字符串的长度, 即: 里边有多少个字符.
print(len(s1))      # 34
print('-' * 31)

# 3. 演示find()函数
print(s1.find('java'))                # -1
print(s1.find('and'))                 # 6
print(s1.find('and', 7)) # 17, 从索引7开始往后查找, 直至结束.
print(s1.find('and', 7, 19)) # -1, 从索引 7 ~ 19间开始找, 包左不包右.
print(s1.find('and', 7, 20)) # 17
print('-' * 31)

# 4. 演示rfind()函数
print(s1.rfind('java'))                     # -1
print(s1.rfind('and'))                      # 25
print(s1.rfind('and', 9))      # 25
print(s1.rfind('and', 2, 21))      # 17
print('-' * 31)

# 5. 演示index()函数.
# print(s1.index('java'))                # 报错, 因为找不到.
# print(s1.index('and', 7, 19)) # 报错, 因为找不到.
print(s1.index('and'))                 # 6
print(s1.index('and', 7)) # 17, 从索引7开始往后查找, 直至结束.
print(s1.index('and', 7, 20)) # 17
print('-' * 31)

# 6. 演示rindex()函数
# print(s1.rindex('java'))                     # 报错, 因为找不到.
print(s1.rindex('and'))                      # 25
print(s1.rindex('and', 9))      # 25
print(s1.rindex('and', 2, 21))      # 17
print('-' * 31)


# 7. 演示replace()函数, 替换.
s2 = s1.replace('and', 'or', 2) # 用or替换and, 替换2个.
print(s2)

s3 = s1.replace('and', 'or') # 用or替换and, 替换所有.
print(s3)
print('-' * 31)

# 8. split()
# 结果为: ["hello ", " python ", " sql ", " linux"]
list1 = s1.split('and') # 按照and切割, 因为有3个and, 切完后, 会获取1个长度为4的列表
print(list1)

# 结果为: [hello ", " python ", " sql and linux"]
list2 = s1.split('and', 2) # 按照and切割, 因为有3个and, 我们只按照前2个and切.
print(list2)
print('-' * 31)

# 9. 统计大串中小串出现的次数.
max_str = "hello and python and sql and linux"
min_str = 'and'

# 思路1: count()函数实现.
result1 = max_str.count(min_str)
print(result1)      # 3

# 思路2: 数学公式 (大串长度 - 新串长度) // 小串的长度
# 核心: 把大串中 所有的小串替换为空, 即为新串.
new_str = max_str.replace(min_str, '')  # "hello  python  sql  linux"

result2 = (len(max_str) - len(new_str)) // len(min_str)
print(result2)  # 3

5.案例-打印偶数位上的字符

# 练习题1：输入一个字符串，打印所有偶数位上的字符(下标是0，2，4，6…位上的字符)
# 1. 提示用户录入1个字符串, 并接收.
s = input('请录入1个字符串: ')

# 2. 通过for遍历字符串.
# for i in s:     # 这种方式直接遍历字符串, 无法实现需求.
#     print(i)

# 方式1: for + if判断.
for i in range(len(s)): # 如果不写起始索引, 默认从0开始, 这里等价于: 0 ~ len(s) 包左不包右.
    # 判断是否是偶数索引, 如果是就打印其对应的字符.
    if i % 2 == 0:
        # print(i)    # i是索引
        print(s[i])

print('-' * 31)

# 方式2: 加入步长即可.
for i in range(0, len(s), 2):   # 范围 0 ~ len(s), 包左不包右, 步长为: 2
    print(s[i])
print('-' * 31)

6.案例-判断文件名

# 练习题2：给定一个文件名，判断其尾部是否以".png"结尾

# 1.定义变量, 记录文件名.
file_name = "abc.xyz.txt.png"

# 2. 思路1: 逆向索引, 获取最后4个字符, 然后判断是否是: .png即可.
if file_name[-4:] == '.png':
    print(f'{file_name}文件的后缀名 是 以.png结尾的')
else:
    print(f'{file_name}文件的后缀名 不是 以.png结尾的')

# 3. 思路2: 正向索引, 即: 找最后1个.的索引, 然后往后截完, 看是否是.png
if file_name[file_name.rfind('.'):] == '.png':
    print(f'{file_name}文件的后缀名 是 以.png结尾的')
else:
    print(f'{file_name}文件的后缀名 不是 以.png结尾的')

# 4. 上述格式可以改成 三元表达式.
print(f'{file_name}文件的后缀名 {"是" if file_name[-4:] == ".png" else "不是"} 以.png结尾的')
print(f'{file_name}文件的后缀名 {"是" if  file_name[file_name.rfind("."):] == ".png" else "不是"} 以.png结尾的')

7.案例-模拟登陆

"""
需求:
    模拟登陆, 只给3次机会, 并进行相应的提示, 登陆成功, 或者 登陆失败, 您还有 * 次机会.
    假设:
        初始账号: chuanzhi
        初始密码: heima
    请用所学, 模拟该知识点.
"""

# 1. 定义两个变量, 分别记录初始账号和密码.
username, password = 'chuanzhi', 'heima'

# 2. 因为只给3次机会, 循环次数固定, 建议使用 for循环.
for i in range(0, 3):   # 第0次, 第1次, 第2次 = 共计3次
    # 3. 提示用户录入他/她的账号或者密码.
    uname = input('请录入您的账号: ')
    pwd = input('请录入您的密码: ')

    # 4. 判断是否登录成功.
    if uname == username and pwd == password:
        # 登陆成功
        print(f'欢迎您, {uname}, 登陆成功!')
        break       # 记得跳出循环.
    else:
        # 走这里, 说明登陆失败, 判断是否还有登陆机会, 提示即可.
        # if i == 2:
        #     # 没有机会了, 3次已用尽.
        #     print('录入错误达上限, 账号被锁定, 请于管理员联系!')
        # else:
        #     # 还有试错机会, 提示即可.
        #     print(f'账号或者密码错误, 您还有 {2 - i} 次机会')

        # 三元表达式优化.
        print('录入错误达上限, 账号被锁定, 请于管理员联系!' if i == 2 else f'账号或者密码错误, 您还有 {2 - i} 次机会')

8.列表-入门

"""
列表介绍:
    概述:
        它属于容器类型的一种, 可以用来同时存储多个元素值.
    格式:
        1. 变量名 = [值1, 值2, 值3...]
        2. list()       # 创建1个空列表.
    细节:
        1. 列表也是容器类型的一种, 列表中的元素也是有正向索引 和 逆向索引.
        2. 列表可以同时存储多个不同类型的元素, 也可以同时存储多个同类型的元素,
           实际开发中, 建议列表存储多个 同类型的 元素.
"""
# 1. 定义列表.
list1 = [10, 20, 30, 'abc', True, 10.3]
list2 = list()      # 创建1个空列表
list3 = []

# 2. 打印列表
print(f'list1: {list1}')
print(f'list2: {list2}')
print(f'list3: {list3}')
print('-' * 31)

# 3. 打印变量类型.
print(type(list1))  # <class 'list'>
print(type(list2))  # <class 'list'>
print(type(list3))  # <class 'list'>
print('-' * 31)

# 4. 根据索引值, 获取列表中的指定元素.
print(list1[2])  # 30, 正向索引
print(list1[-4])  # 30, 逆向索引

9.列表-遍历

"""
遍历解释:
    概述:
        遍历也叫迭代(Iterator), 即: 获取容器类中的每一个元素的过程, 就称之为: 遍历.

列表的遍历:
    方式1: 直接获取每个元素.
    方式2: 根据索引获取每个元素.
"""

# 1. 定义列表, 记录要迭代的元素.
list1 = [1, 2, 3, 'aa', True]

# 2. 遍历列表.
# 方式1: 直接获取每个元素. for循环独有.
for value in list1:     # 这个value就是变量名, 你随便名, 符合格式就行.
    print(value)
print('-' * 31)

# 方式2: 根据索引获取每个元素.
# 思路1: while循环.
i = 0
while i < len(list1):   # i就表示列表中, 每个元素的索引.
    print(list1[i])     # 根据索引获取元素, 并打印.
    i += 1              # 记得写控制条件, 否则是: 死循环.
print('-' * 31)

# 思路2: for循环.
for i in range(0, len(list1)):
    print(list1[i])  # 根据索引获取元素, 并打印.

10.列表常见操作-增

"""
列表常见操作:
    概述:
        列表的元素是可以进行修改的, 所以列表属于: 可变类型.   之前学习的字符串属于不可变类型.
    常见操作:
        增: 就是往列表中添加元素.
        删:
        改:
        查:

    列表 增 相关的函数:
        列表.append(要添加的单个元素)        在列表的末尾追加1个元素.
        列表.extend(容器类型)               把容器类型的每个值(即: 多个值)添加到列表的末尾.
        列表.insert(索引, 要插入的单个元素)   在指定索引处, 插入指定的元素, 可以写 正向索引, 也可以写逆向索引
"""

# 1. 定义列表.
list1 = [10, 20, 30]

# 2. 演示 列表 增 相关函数.
# 演示: 列表.append(要添加的单个元素)        在列表的末尾追加1个元素.
# list1.append('hello')
# list1.append(True)

# 演示: 列表.extend(容器类型)               把容器类型的每个值(即: 多个值)添加到列表的末尾.
name_list = ['乔峰', '虚竹', '段誉']
# list1.extend(name_list)         # 把 name_list列表的每个元素添加到 list1列表中.
# list1.append(name_list)           # 把 name_list整体当做1个元素, 添加到list1列表中.

# 演示: 列表.insert(索引, 要插入的单个元素)   在指定索引处, 插入指定的元素, 可以写 正向索引, 也可以写逆向索引
# list1.insert(2, True)   # [10, 20, True, 30], 在索引2位置插入元素.
# list1.insert(10, False) # 找不到索引, 就在末尾追加.

# list1.insert(-2, 10.3)  # [10, 10.3, 20, 30], 逆向索引是在指定位置后插入的.
list1.insert(-20, 10.3)  # [10.3, 10, 20, 30], 索引不存在, 就在末尾追加元素, 因为是逆向索引, 索引末尾是最前.

# 3.打印列表内容.
print(list1)

11.列表常见操作-查

"""
列表 查 相关的函数:
    index(元素, 起始索引, 结束索引)       查找元素在列表中第一次出现的位置, 找不到就 报错.
    count()                            统计元素出现的次数
    in                                 是否在, 即: 是否包含
    not in                            是否不在, 即: 是否不包含.
"""

# 1. 定义列表.
list1 = [10, 20, 30, 'aa', 30, 'bb']

# 2. 演示列表的 查 相关函数.
# 演示 index(元素, 起始索引, 结束索引)       查找元素在列表中第一次出现的位置, 找不到就 报错.
print(list1.index(30))      # 2
print(list1.index(30, 3))   # 4, 从索引3开始往后找, 30在列表中第一次出现的位置.
# print(list1.index('cc'))    # 报错
print("-" * 31)

# 演示 count()                            统计元素出现的次数
print(list1.count(30))      # 2
print(list1.count(300))     # 0, 表示不存在.
print("-" * 31)

# 演示 in                                 是否在, 即: 是否包含
print(30 in list1)      # True

# 演示 not in                            是否不在, 即: 是否不包含.
print(30 not in list1)  # False

12.列表常见操作-删

"""
列表 删 相关的函数:
    列表.remove(元素)       根据元素内容进行删除.
    列表.pop(索引)          根据索引进行删除对应的元素.
    del 列表               把列表从内存中删除, 相当于注销, 也就是说, 没有创建该列表.
    列表.clear()           清空列表元素.
"""

# 1. 定义列表.
list1 = [10, 20, 30, 'aa', 30, 'bb']

# 2. 演示列表的 删 相关函数:
# 演示 列表.remove(元素)       根据元素内容进行删除.
# list1.remove(30)    # 删除元素值为30的 这个元素
# list1.remove(300)   # 要删除的元素不存在, 就报错.

# 演示 列表.pop(索引)          根据索引进行删除对应的元素.
# list1.pop(1)          # 删除索引为1的元素
# list1.pop(2)          # 删除索引为2的元素, 每次删除元素后, 其后边的元素值的索引都会发生改变.
# list1.pop(30)          # 索引不存在, 就报错.

# 演示 del 列表               把列表从内存中删除, 相当于注销, 也就是说, 没有创建该列表.
# del list1[0]        # 删除索引为0的元素
# del list1             # 从内存中移除list1, 相当于list1已经没有了.

# 演示 列表.clear()           清空列表元素.
list1.clear()

# 3. 打印列表.
print(list1)

13.列表常见操作-改

"""
列表 改 相关的函数:
    列表[索引] = 值          根据索引, 修改其对应的元素.
    sort(reverse=False)    排序, 默认是升序(reverse=False), 可以降序(reverse=True)
    reverse()              反转.
"""

# 1. 定义列表.
list1 = [11, 33, 55, 22, 66]

# 2. 测试列表 改 相关的函数.
# 演示 列表[索引] = 值          根据索引, 修改其对应的元素.
# list1[2] = 100

# 演示 sort(reverse=False)     排序, 默认是升序(reverse=False), 可以降序(reverse=True)
# list1.sort()                # 默认: 升序
# list1.sort(reverse=False)   # 升序的意思.  reverse=False, 说明不反转.
# list1.sort(reverse=True)    # 降序的意思, reverse=True, 表示反转

# 演示 reverse()              反转.
# list1.reverse()

# 自己写代码, 模拟: 降序, 即: 先升序, 后反转.
list1.sort()
list1.reverse()

# 3. 打印列表.
print(list1)

14.列表嵌套

"""
列表嵌套解释:
    概述:
        列表嵌套指的是: 列表的元素还是1个新的列表, 这种写法就叫列表嵌套.
    格式:
        变量名 = [[值1, 值2...], [值1, 值2...], [值1, 值2...]...]
"""

# 1. 定义嵌套列表.
list1 = [[10, 20, 30], ['aa', 'bb', 'cc', 'dd'], [True, False]]

# 2. 获取列表中的指定元素.
print(list1[1][1])     # 'bb'
print(list1[2][0])     # True
print(list1[0][2])     # 30
print('-' * 31)

# 3. 遍历(嵌套)列表.
for value in list1:     # value就是列表中的每个元素, 还是1个列表, 接着遍历. 例如: [10, 20, 30]
    for j in value:     # j就是 value列表中的每个元素, 例如: 10, 20, 30
        print(j, end='\t')
    # 走到这里, 说明一个列表打印完毕, 记得换行.
    print()

15.列表嵌套案例-随机分配办公室

"""
需求:
    已知有三个办公室, 即: [[], [], []], 列表嵌套的形式.
    已知有8名教师 name_list = [.....]
    请将上述的8名教师, 随机的分配到三个办公室中(注意: 因为是随机的, 所以可能出现某个办公室没有教师的情况)
"""
# 0. 导包.
import random

# 1. 定义办公室列表.
office_list = [[], [], []]  # 三个办公室分别是: office_list[0], office_list[1], office_list[2]

# 2. 定义教师列表.
name_list = ['乔峰A', '虚竹B', '段誉C', '阿朱D', '李清露E', '穆婉清F', '钟灵儿G', '王语嫣H']

# 3. for循环, 遍历教师列表, 获取到每个元素.
for name in name_list:
    # print(name) name就是每一名教师.
    # 4. 随机获取办公室, 表示把该教师, 添加到哪个办公室中.
    index = random.randint(0, 2)    # 包左包右, 获取随机的办公室编号.
    # 添加教师到具体的办公室中.
    office_list[index].append(name)

# 5. 至此, 分配完毕, 打印结果即可.
print(office_list)