一、列表 [list]

•  线性表与列表的关系
• 线性表：是一种抽象的数据结构，特点是除首尾元素外，每个元素都有唯一的前驱和后继，它在内存中占用一段连续的存储空间，因此可以通过下标快速查询元素。
• 列表：是线性表在 Python 中的具体实现，完全继承了线性表的特性，并在此基础上做了更灵活的封装。
• 列表的核心特性

1. 有序性：元素的存储顺序和插入顺序完全一致。
2. 可重复性：同一个值可以在列表中出现多次。
3. 任意类型存储：可以同时存放数字、字符串、布尔值等不同类型的数据

1.列表的定义方式

• 直接使用 [] 定义

1.1.列表定义的几种方式

第一种：直接使用 [] 定义

list1 = [40, 10, 10, 20, 30, 40, "zhangsan", True]
print(list1)
print(type(list1))

输出结果
[40, 10, 10, 20, 30, 40, 'zhangsan', True]
<class 'list'>

第二种：使用 list() 函数转化

list2 = list([10, 20, 30, 40, 50])
print(list2)
print(type(list2))

输出结果
[10, 20, 30, 40, 50]
<class 'list'>

第三种：字符串转列表

list3 = list("zhangsan")
print(list3)
print(type(list3))

输出结果
['z', 'h', 'a', 'n', 'g', 's', 'a', 'n']
<class 'list'>

⚠️ 注意：list() 只能接收可迭代对象，直接传入数字（如 list(10)）会报错。

2.列表的访问

因为列表是有序的线性结构，所以我们可以通过 索引（下标）来快速访问元素，索引从 0 开始。

list2 = list([10, 20, 30, 40, 50])
print(list2[1])  # 访问 list2 的第2个元素

输出：

20

3.列表的遍历

遍历就是循环获取列表中的每一个元素，Python 提供了两种常用的遍历方式：

方式 1：通过索引遍历

list2 = list([10, 20, 30, 40, 50])
for i in range(5):  # 遍历前5个元素（索引 0~4）
    print(list2[i])

输出结果
10
20
30
40
50

方式 2：直接遍历元素

list1 = [40, 10, 10, 20, 30, 40, "zhangsan", True]
for item in list1:
    print(item)

输出结果：
40
10
10
20
30
40
zhangsan
True

4.列表的常用内置函数

4.1 dir () 函数的使用

list = [1,2,3,4]
print (dir(list))
"""
输出

 ['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
"""

4.2 列表的常用内置函数

①  append() -末尾添加元素

list1 = [78, 98, 100, 67, 87, 24, 60, 78,]
res = list1.append("zhangsan")
print("append执行后返回值:",res)
print("append执行后的list:",list1)

输出 
append执行后返回值: None   这个方法直接修改原列表，不会创建新列表，
append执行后的list: [78, 98, 100, 67, 87, 24, 60, 78, 'zhangsan']

②  count()-统计元素出现次数

list1 = [78,98,100,67,87,24,60,78]
res = list1.count(78)
print("78在list1中出现的次数:",res) 

输出
78在list1中出现的次数: 2

③ index() -从列表中找出某个值第一个匹配项的索引位置

list1 = [78,98,100,67,87,24,60,78]
res = list1.index(78)
print("78在list1中的位置:",res)

输出
78在list1中的位置: 0

④ insert() - 插入元素

list1 = [10,20,30,80,40]
list2 = ["zhangsan","tom",88]
res = list1.insert(2,888)
print("insert执行后的返回值：",res)
print("执行后list1的值",list1)

输出
insert执行后的返回值： None
执行后list1的值 [10, 20, 888, 30, 80, 40]

⑤ pop()  -删除最后一个元素，并返回，原列表发生变化

list1 = [78,98,100,67,87,24,60,78]
res = list1.pop()
print("pop后的返回值:",res)
print("pop后的list1:",list1)

输出
pop后的返回值: 78
pop后的list1: [78, 98, 100, 67, 87, 24, 60]

⑥ remove()  -删除匹配元素

list2 = ["zhangsan","tom",88]
res = list2.remove(88)
print("remove返回值：",res)
print("list2的值",list2)


输出
remove返回值： None
list2的值 ['zhangsan', 'tom']

⑦ 反转reverse()和排序sort()

list1 = [78,98,100,67,87,24,60,78]
res = list1.reverse()
print("reverse后的返回值:",res)
print("reverse后的list1:",list1)

输出
reverse后的返回值: None
reverse后的list1: [78, 60, 24, 87, 67, 100, 98, 78]

list1 = [78,98,100,67,87,24,60,78]
res = list1.sort()
print("sort后的返回值:",res)
print("执行后的list1：",list1)

输出
sort后的返回值: None
执行后的list1： [24, 60, 67, 78, 78, 87, 98, 100]

⑧  clear()

list1 = [78,98,100,67,87,24,60,78]
res = list1.clear()
print("clear执行后的返回值:",res)
print("执行后clear的值",list1)
输出
clear执行后的返回值: None
执行后clear的值 []

⑨  extend() -合并列表

list1 = [78,98,100,67,87,24,60,78]
list2 = ["zhangsan","lisi","wangwu"]
res = list1.extend(list2)
print("extend执行后的返回值：",res)
print("执行后extend的值",list1)

输出
extend执行后的返回值： None
执行后extend的值 [78, 98, 100, 67, 87, 24, 60, 78, 'zhangsan', 'lisi', 'wangwu']

⑩  len() -判断容器的长度

list1 = [78,98,100,67,87,24,60,78]
res = len(list1)
print("列表的长度:",res)

输出
列表的长度: 8

5.列表的运算 + *

list3 = ["zhangsan","lisi","wangwu"]
list4 = [1,2,3]
print("加法输出结果",list3 + list4)
print("乘法输出结果",list4 * 3)

输出
加法输出结果 ['zhangsan', 'lisi', 'wangwu', 1, 2, 3]

乘法输出结果 [1, 2, 3, 1, 2, 3, 1, 2, 3]

6.二维列表：列表的嵌套

6.1.测试二维列表

list1 = [[10, 20, 30], [1, 2, 3], [100, 200, 300]]
print("定义的二维列表：", list1)

输出
定义的二维列表： [[10, 20, 30], [1, 2, 3], [100, 200, 300]]

6.2. 访问二维列表

访问二维列表需要两层索引：外层索引定位子列表，内层索引定位子列表中的元素

list1 = [[10,20,30],[1,2,3],[100,200,300]]
res = list1[0]
print("第一个子列表：", res)
print("子列表的第二个元素：", res[1])

输出
第一个子列表： [10, 20, 30]
直接访问第一个子列表的第二个元素： 20

# 合并写法：一步定位元素
print("直接访问第一个子列表的第二个元素：", list1[0][1])

输出
直接访问第一个子列表的第二个元素： 20

6.3 遍历二维列表

list1 = [[10, 20, 30], [1, 2, 3], [100, 200, 300]]
for items in list1:
    for item in items:
        print(f"{item}", end=" ")
    print()

输出
10 20 30 
1 2 3 
100 200 300 

7.列表推导式：一行生成新列表

列表推导式是 Python 中一种简洁的语法，用来快速生成新列表，同时支持对元素进行操作和筛选。

• 基本格式：

[元素操作 for 元素 in 原列表]
[元素操作 for 元素 in 原列表 if 条件]

•  基础用法：元素批量运算

list2 = [10, 20, 30, 40, 50]
# 传统方式：循环生成新列表
list3 = []
for item in list2:
    item *= 10
    list3.append(item)
print("传统方式生成的新列表：", list3)

输出
传统方式生成的新列表： [100, 200, 300, 400, 500]

• 列表推导式：一行搞定

list2 = [10, 20, 30, 40, 50]
list4 = [x * 100 for x in list2]
print("原列表 list2：", list2)
print("列表推导式生成的新列表：", list4)

输出
原列表 list2： [10, 20, 30, 40, 50]
列表推导式生成的新列表： [1000, 2000, 3000, 4000, 5000]

将list2中元素大于20的筛选并*100,且产生一个新列表
list5 = [i * 100 for i in list2 if i > 20]
print(list5)

输出
[3000, 4000, 5000, 6000]

8.列表负索引

列表支持正索引（从左往右，从 0 开始）和负索引（从右往左，从 -1 开始）。负索引让你可以直接从列表末尾开始定位元素，非常方便。

list1 = [10, 20, 30, 40, 50]
# 正索引访问第一个元素
print(list1[0]) #输出10

# 负索引访问第一个元素
print(list1[-len(list1)]) #输出10
# 等价于 list1[-5]，因为 len(list1) = 5

# 正索引访问最后一个元素
print(list1[4])  #输出50
print(list1[len(list1)-1]) #输出50


# 负索引访问最后一个元素
print(list1[-1]) #输出50

9.列表的切片

切片的格式是 list[start:end:step]，其中：

• start：切片起始位置（包含）
• end：切片结束位置（不包含）
• step：步长（可选，默认为 1）

list1 = [10, 20, 30, 40, 50]

# 截取整个列表
print(list[:])  # 输出：[10, 20, 30, 40, 50]

#从索引1到索引3
print(list1[1:3]) # 输出：[20, 30]

#步长为 2
print(list1[::2])  #输出[10, 30, 50]

#步长为-1
print(list2[::-1]) #输出[50, 40, 30, 20, 10]

# 从倒数第 5 个到倒数第 2 个
print(list1[-5:-2:]) #输出[10,20,30]

# 从开头到倒数第 2 个
print(list1[:-2]) # 输出：[10, 20, 30]

二、元组（tuple）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

1.元组的概念

• 有序：元素的存储顺序和插入顺序一致，可以通过索引访问。
• 可重复：允许包含重复的元素。
• 任意类型：可以同时存储数字、字符串、列表等不同类型的数据。
• 不可修改：一旦创建，就不能添加、删除或修改其中的元素，这是它和列表最核心的区别。

2.元组的定义

元组使用 () 来定义，也可以通过 tuple() 函数转换其他可迭代对象生成。

• 通过() 来定义

# 定义包含多种类型元素的元组
tuple1 = ("zhangsan", 10, 1, 2, 3, 4, 5, 5)
print("定义的元组：", tuple1)
print("元组的类型：", type(tuple1))

输出
定义的元组： ('zhangsan', 10, 1, 2, 3, 4, 5, 5)
元组的类型： <class 'tuple'>

• 通过 tuple() 函数转换来定义

#定义一个列表
list = [10,20,30,40,50]
src = tuple(list)
print("原列表：",list)
print("转换后的：",src,type(src))

输出

原列表： [10, 20, 30, 40, 50]
转换后的： (10, 20, 30, 40, 50) <class 'tuple'>

• 单元素元组

tuple1 = （2）
print("不加逗号的类型：", type(tuple1))

tuple2 = (2,)
print("加逗号的类型：", type(tuple2))


输出
不加逗号的类型： <class 'int'>
加逗号的类型： <class 'tuple'>

3.元组的访问

元组是有序的，所以可以通过索引（下标）来访问元素，索引从 0 开始。

tuple1 = ("zhangsan", 10, 1, 2, 3, 4, 5, 5)
print("元组的第一个元素：",tuple1[0])

输出
元组的第一个元素： zhangsan

⚠️ 注意：元组不可修改，如果尝试修改元素会报错：

# tuple1[0] = "lisi"
# 报错信息：TypeError: 'tuple' object does not support item assignment

4. 元组的遍历

• 直接遍历元素

tuple1 = ("zhangsan", 10, 1, 2, 3, 4, 5, 5)
print("直接遍历元素：")
for item in tuple1:
    print(item, end=" ")
print()  # 换行

输出：
直接遍历元素：
zhangsan 10 1 2 3 4 5 5 

• 通过索引遍历

tuple1 = ("zhangsan", 10, 1, 2, 3, 4, 5, 5)
for i in range(len(tuple))  或者也可以这么写 for i in range(8)) 
    print(f"{tuple[i]}")

输出结果
zhangsan
10
1
2
3
4
5
5

5.元组的常用内置函数

# 查看元组所有内置方法
print("元组的内置方法：", dir(tuple))


#'count', 'index'

①  count() -统计元素出现次数

tuple1 = (1,1,2,2,2,4)
print("2出现的次数为：",tuple1.count(2))

输出结果
2出现的次数为：3

② index() -查找元素首次出现的索引

tuple1 = ("zhangsan", 10, 1, 2, 3, 4, 5, 5)
print("元素3首次在tuple1中出现的位置：", tuple1.index(3))

输出结果：
元素3首次在tuple1中出现的位置： 4

6.元组的运算

6.1. 加法运算

+ 运算符可将两个元组拼接为新元组，原元组保持不变：

tuple1 = (1,2,3,4)
tuple2 = (5,6,7,8,)
print("加法运算：",tuple1+tuple2)

输出结果：
加法运算： (1, 2, 3, 4, 5, 6, 7, 8)

6.2 乘法运算

* 运算符可将元组元素重复指定次数，生成新元组:

tuple3 = (1, 2, 3)
tuple4= tuple3 * 3
print("重复3次的新元组：", tuple4)

三、字典 {dict}

字典是 Python 中最核心的映射型数据结构，它通过 键值对（key-value） 存储数据，是处理关联数据的首选工具

1.字典的核心概念

• ✅ 键值对存储：每个元素由 key: value 组成，通过键快速查找值（时间复杂度 O (1)）。
• ✅ 键唯一性：同一个字典中，键不能重复，重复的键会被最后一次赋值覆盖。
• ✅ 值可变性：值可以是任意类型（数字、字符串、列表、字典等），且支持修改。
• ✅ 无序性：Python 3.7+ 中字典会保留插入顺序，但逻辑上仍为无序结构。

2. 定义字典

使用 {} 直接定义，或通过 dict() 函数生成。

# 直接定义字典（重复的 key 会被最后一个覆盖）
dict1 = {"score": "113", "score": "111", "username": "lijian", "password": "753951", "address": "陕西省西安市"}
print("定义的字典：", dict1)
print("字典的类型：", type(dict1))
print("字典的长度（键值对数量）：", len(dict1))

输出结果
定义的字典： {'score': '111', 'username': 'lijian', 'password': '753951', 'address': '陕西省西安市'}
字典的类型： <class 'dict'>
字典的长度（键值对数量）： 4

3.字典的访问

有两种常用方式：直接通过键访问，或使用 get() 方法。

dict1 = {"score": "113", "score": "111", "username": "xiaoming", "password": "753951", "address": "陕西省西安市"}
print("通过键访问：",dict1[score])

print("通过get访问:",dict1.get("username"))

输出结果
通过键访问：111
通过get访问: xiaoming

4. 修改字典的值

直接通过键赋值即可修改，get() 方法仅用于查询，无法修改值。

dict1 = {"score": "113", "score": "111", "username": "lijian", "password": "753951", "address": "陕西省西安市"}
# 修改已有键的值
dict1["username"] = "zhangsan"
print("修改后的字典：", dict1)

输出结果
修改后的字典： {'score': '111', 'username': 'zhangsan', 'password': '753951', 'address': '陕西省西安市'}

5.字典的遍历方式

字典支持多种遍历方式，可单独遍历键、值，或同时遍历键值对。

• 直接遍历

dict1 = {"score": "113", "score": "111", "username": "zhangsan", "password": "753951", "address": "陕西省西安市"}
for key in dict1:
    print(dict1[key])

输出结果
111
zhangsan
753951
陕西省西安市

• 遍历键值对

遍历字典的键值对
for item in dict1:
    print(item,":",dict1[item])

输出结果
score : 111
username : zhangsan
passwd : 951753
------------------------------
遍历字典的键
for item in dict1:
    print(item)

输出结果
score
username
passwd

6.字典的内置函数

① copy()：复制字典

dict1 = {"语文"：90，"数学":97,"英语":98}
print(dict1.copy())

输出结果
 {'语文': 90, '数学': 97, '英语': 98}

② items 获取所有键值对（且每一个键值对都是一个元组）

for item in dict.item():
    print(item)

输出结果
 ('语文', 90),
('数学', 97)
 ('英语', 98)

③ pop() --删除键值对

dict1 = {"语文":90,"数学":97,"英语":98}
res = dict1.pop("英语")
print("pop后的dict:",res)
print("删除后的dict1:",dict1)

输出结果
pop后的dict: 98
删除后的dict1: {'语文': 90, '数学': 97}

④ keys 获取所有的key

dict1 = {"语文":90,"数学":97,"英语":98}
for key in dict1.keys()：
    print(key)

输出结果
语文
数学
英语

⑤ popitem()  删除字典最后一个kv对，并以元组的形式返回删除值，原字典发生改变

dict1 = {"语文":90,"数学":97,"英语":98}
res = dict1.popitem()
print("popitem后的返回值：",res)
print("pop后的字典：",dict1)

输出结果
popitem后的返回值： ('英语', 98)
pop后的字典： {'语文': 90, '数学': 97}

⑥ 设置默认值setdefault,设置一个新的key，值为默认值None

dict1 ={"语文":90,"数学":97,"英语":98}
dict1.setdefault("物理")  # 键不存在时添加，值默认 None
dict1.setdefault("物理",88)
print(dict1)

输出结果
{'语文': 90, '数学': 97, '英语': 98, '物理': None}
{'语文': 90, '数学': 97, '英语': 98, '物理': 88}

⑦ update() 合并

dict1 = {"语文":90,"数学":97,"英语":98}
print(dict1.update({"化学":"111"}))
print(dict1)

输出结果
{'语文': 90, '数学': 97, '英语': 98, '化学': '111'}

⑧ values() 返回字典中所有值（value）的可迭代对象。

dict1 = {"语文":90,"数学":97,"英语":98}
for value in dict1.values():
    print(value)
输出结果
90
97
98

7.字典的生成问题

除了直接定义，还可以通过 fromkeys() 和 zip() 快速生成字典。

1. fromkeys()：批量生成键，统一设置默认值

#1.fromkeys(列表，默认值) 将默认值和列表中的元素一一对应，并生成一个新的字典
dict_list=["语文","数学","英语","理综"]
res = dict.fromkeys(dict_list,90)
print(res)

输出结果
{'语文': 90, '数学': 90, '英语': 90, '理综': 90}

2. zip()：两个列表一一对应生成字典

#2.zip (list1,list2) list1和list2中的元素一一对应，并生成一个新列表
list1=["语文","数学","英语","理综"]
list2 = [98,50,60,80]
for item in zip(list1,list2):
    print(item)
print(dict(zip(list1,list2)))


输出结果
('语文', 98)
('数学', 50)
('英语', 60)
('理综', 80)

{'语文': 98, '数学': 50, '英语': 60, '理综': 80}

四、集合 {set}

1.集合的核心概念与特性

集合是一种无序、元素唯一、可存储任意不可变类型的数据容器，其核心特性如下：

• ✅ 无序性：元素没有固定顺序，不支持索引访问。
• ✅ 唯一性：自动去重，重复元素会被自动保留一个。
• ✅ 可变性：可以动态添加、删除元素（但集合中的元素必须是不可变类型，如数字、字符串、元组）。

2.集合的定义

set1 = {10, 20, "zhangsan", True, 10, 20, False, "lisi"}
print("定义的集合",set1)
print("集合的类型"type(set1))

输出结果
定义的集合： {False, True, 'lisi', 20, 10, 'zhangsan'}
集合的类型： <class 'set'>

• 空集合的定义

❌ 错误：{} 会创建空字典

set2 = {}
print("错误写法的类型：", type(set2))   

输出结果：
错误写法的类型： <class 'dict'>

✅ 正确：set() 创建空集合

set1 = set()
print("空集合",set1)
print("空集合的类型",type(set1))

输出结果
空集合： set()
空集合的类型： <class 'set'>

• 从可迭代对象生成集合

可以将列表、元组等可迭代对象转为集合，自动完成去重

list1 = [10, 20, 30, 30, 40, 10]
set1 = set(list1)
print(set1)

输出结果
{40, 10, 20, 30}

3.集合的访问与遍历

集合不支持索引访问，只能通过 for...in 遍历所有元素

set1 = {10, 10,20, "zhangsan", "zhangsan",True, False, "lisi"}
for i in set1:
    print(i)

输出结果
False True lisi 20 10 zhangsan

4.集合的常用内置函数

① add()：添加单个元素，元素已存在则无操作。

② update()：批量添加可迭代对象中的元素。

set_x = {1, 2, 3, 4, 5, 6}
res = set_x.add(7)
print("add返回值",res)
print("add后的集合",set_x)

输出结果
add返回值： None
add后的集合： {1, 2, 3, 4, 5, 6, 7}


print("upadte后的集合",set_x.update([8,9,10]))

输出
update() 后的集合： {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

③ discard()：删除指定元素，元素不存在则无操作。

④ remove()：删除指定元素，元素不存在则报错。

⑤ pop()：随机删除并返回一个元素（集合为空则报错）。

set_x = {1, 2, 3, 4, 5, 6, 7}

# discard() 删除元素
res = set_x.discard(7)
print("discard() 返回值：", res)
print("discard() 后的集合：", set_x)

输出
discard() 返回值:None
discard() 后的集合:{1, 2, 3, 4, 5, 6}


# remove() 删除元素
set_x.remove(6)
print("remove() 后的集合：", set_x)

输出
remove() 后的集合： {1, 2, 3, 4, 5}

# pop() 随机删除元素
res = set_x.pop()
print("pop() 删除的元素：", res)
print("pop() 后的集合：", set_x)

输出
pop() 删除的元素：1
pop() 后的集合: {2, 3, 4, 5}

⑥ 交集intersection()  两个集合共有的元素，并返回产生一个新的集合，原集合不会发生改变

⑦ .并集union

⑧ 差集difference A有B没有

set_x={1,2,3,4,5,6}
set_y={4,5,6,7,8,9}
set_z = {4,5,6,10,11,12}
# 交集
res = set_x.intersection(set_z,set_y)
print(res)
print(set_x)


#并集union
res = set_x.union(set_y)
print(res)
rint(set_x)

#差集difference

res = set_x.difference(set_y)
print(res)
print(set_x)

set集合的交并差符号运算

set_x = {1,2,3,4}
set_y = {3,4,5,6}

print("交集",set_x & set_y)
print("并集:",set_x | set_y)
print("差集:",set_x - set_y)

五、字符串

1.字符串的创建

Python 中字符串可以通过单引号、双引号、str() 函数等多种方式创建，并且支持将其他类型转为字符串。

# 1. 直接创建字符串
str1 = """Hello"""
print(str1)  # 输出: Hello

# 2. 使用 str() 函数创建
str2 = str("www.oracle.com")
print(str2)   # 输出: www.oracle.com

# 3. 类型转换
print(type(str(True)))  # 输出: <class 'str'>
print(type(str([10,"zhangsan",90])))  # 输出: <class 'str'>

2.字符串的访问

str1 = "www.oracle.com"
print(str1[0])  #输出w
print(str1[-1])  #输出m

3.字符串的遍历

str1 = "www.oracle.com"
#直接遍历
for item in str1:
    print(item)
#通过索引遍历
for i in range(len(str1)):
    print(str1[i],end=" ")

输出结果为
w w w . o r a c l e . c o m 
w w w . o r a c l e . c o m 

4.字符串的切片

通过 [start:end:step] 语法可以灵活截取子串，规则与列表切片完全一致。

str1 = "www.oracle.com"
print(str1[4:10])  #  截取索引4到9的字符 → oracle

5.字符串的格式化

格式化是字符串最常用的功能之一，Python 提供了多种格式化方式，其中 f-string 是最推荐的写法。

username = "zhangsan"
password = "111"

# 方式1：f-string（推荐）
print(f"姓名：{username},密码：{password}")

# 方式2：format() 方法
print("姓名:{},密码:{}".format(username,password))

# 方式3：% 格式化（旧版写法）
print("username:%s,password:%s" % (username, password))
print("username:%(u1)s,password:%(p1)s" % {"u1":username, "p1":password})

# 方式4：直接拼接
print("姓名:",username,"密码:",passwd)

输出：
姓名：zhangsan,密码：111
姓名:zhangsan,密码:111
姓名:zhangsan,密码:111
姓名:zhangsan,密码:111
姓名: zhangsan 密码:111

6.字符串的运算

str1 = "zhangsan"
str2 = "lisi"

print(str1 + str2)

#重复
print(str1 * 3)

#成员判断
print("z" in str1) #输出True
print("a" not in str1)  #输出False

7.字符转化

通过 ord() 和 chr() 可以实现字符与 ASCII 码的互转。

# ASCII 码转字符
print(chr(98)) #b
print(chr(66)) #B

# 字符转 ASCII 码
print(ord("a")) #97
print(ord("A")) #65

#将任意字符转换为字符串
print(repr("zhangsan")) #'zhangsan'
print(repr(100)) #'100'
print(type(repr(100)))  #<class 'str'>

案例：产生一个随机字符的列表

import random

list1 = []
for i in range(10):
    char = chr(random.randint(65,88))
    list1.append(char)
print("随机生成的字符",list1)


输出结果
随机生成的字符 ['C', 'P', 'K', 'M', 'K', 'O', 'S', 'Q', 'N', 'N']

8.字符串的常用函数

① 字符大小写转换

print("abc".upper()) #ABC
print("ABC".lower()) #abc
print("xYz".swapcase()) #XyZ

② 剔除空格的问题

• 剔除字符串两端空格

print("  username  ".strip())
print("  username".lstrip())
print("username  ".rstrip())

输出
username
username
username

③ center(生成字符串的总长度,居中后的两次填充物)   ---居中字符串

print("zhangsan".center(50,"-"))
#输出---------------------zhangsan---------------------

④ 根据字符找索引

str1 ="www.baidubaidu.com"
print(str1.find("baidu"))   #输出4

# index 返回字符串第一次出现的位置
print(str1.index("w"))  #0
print(str1.rindex("w"))  #2

⑤  replace字符串替换问题

str1 = "1999年5月4日出生"
print(str1.replace("出生"," "))

⑥ join链接问题

str1 = "zhangsan"
str2 = "-"
print(str2.join(str1))  #输出z-h-a-n-g-s-a-n

⑦ capitalize()首字符大写

print("zhangsan".capitalize()) #输出Zhangsan

⑧ casefold()返回全部的小写字符

print("ZhangSan".casefold()) #zhangsan

⑨ count()查询字符出现的个数

print("zhangsan".count("a"))  #2

⑩ encode()           GBK:支持中文    utf-8:世界通用字符集 ---乱码问题

print("zhang三".encode("utf-8"))
print("zhang三".encode("gbk"))

输出
b'zhang\xe4\xb8\x89'
b'zhang\xc8\xfd'

⑩① startswith()   endswith()         --字符串的判断问题

print("www.baidu.com".startswith("www"))
print("www.baidu.com".endswith("com"))

输出
True
True

⑩②  split(） 字符串分割问题 返回一个字符串列表 根据某字符分分割

print("www.baidu.com".split("."))  #输出#['www','baid','com']

⑩③   partition()   字符串拆分问题 返回字符元组， 根据目标字符，进行拆分三部分，且包含目标字符

print("www.baid.com".partition("."))#('www','.','baidu.com')

⑩④  maketrans()建立映射规则 translate()使用映射规则替换对应映射规则的字符

s1 = "aeiou"
s2 = "12345"

str1 = "i am a teacher woou"
my_maketrans = str.maketrans(s1,s2)

res = str1.translate(my_maketrans)
print(res)
print(str1)

输出
3 1m 1 t21ch2r w445
i am a teacher woou