一、注释
“#” (井号)为单行注释
“““xxx””” (三引号)为多行注释
二、字符串
字符串的定义
a='python'
b="python"
c="""python"""
以上三种方式都可以定义字符串
第三种定义方式如果没有变量接收那就是多行注释，并且和多行注释一样支持换行
如何在字符串中包含单双引号
在字符串内 包含双引号：
name = '"python"'
在字符串内 包含单引号:
name = "'python'"
使用转义字符 “" 解除引号的效用:
name = "\"python\""
name = '\'python\''
字符串的长度
len(str):返回字符串的长度
后面学容器依旧可以使用这个长度函数
字符串拼接
字符串的拼接和cpp相同，使用加号即可
字符串的格式化
方法一
name = "python"
message = "我要学%s" % name
print(message)
% 表示：我要占位
s 表示：将变量变成字符串放入占位的地方
需要加入非字符串的变量一样可以
python中，常见的数据类型占位有三种
| 符号 | 作用 |
|---|---|
| %s | 将内容转换成字符串，放入占位位置 |
| %d | 将内容转换成整数，放入占位位置 |
| %f | 将内容转换成浮点型，放入占位位置 |
例如:
name = "python"
day = 3
comp = 0.5
message = "学习%s%d天，已完成%f" % (name,day,comp)
方法二:
print(f"学习{name}{day}天,已完成{comp}")
但是这种格式化方式无法做精度控制
并且以上两种方式可以不用变量名，直接使用表达式也可以
如：message = “学习%s%d天，已完成%f” % (“python”,1+2,0.2+0.3)
三、分支语句
if-else:
if 条件表达式1:
语句块1
elif 条件表达式2:
语句块2
elif 条件表达式3:
语句块3
...
else:
语句块n
与c/c++类似，自行对比
match-case:
match 变量/表达式:
case 模式1:
语句块1
case 模式2:
语句块2
...
case _:
语句块n
与c/c++中的switch-case类似，自行对比
四、循环语句
while循环:
while 条件表达式:
循环体语句块
与c/c++的while用法相同
for循环:
此循环方式与c/c++略有不同，不宜跳过
for 变量 in 可迭代对象:
循环体语句块
可迭代对象包括：字符串、列表、元组、字典、集合、range()、文件等。
每次迭代将当前元素赋值给变量，自动遍历直到结束。
常用配合函数/方法
不宜跳过,too
range()函数 —— 生成数值序列
for i in range(5): # 0,1,2,3,4
for i in range(2, 8): # 2,3,4,5,6,7
for i in range(0, 10, 2): # 0,2,4,6,8
enumerate()函数 —— 同时获取索引和值
fruits = ['apple', 'banana', 'cherry']
for idx, fruit in enumerate(fruits):
print(idx, fruit)
该函数配合字典时使用较多
循环控制语句
| 语句 | 作用 |
|---|---|
| break | 立即终止整个循环，跳出循环体 |
| continue | 跳过本次循环剩余代码，进入下一次迭代 |
| pass | 空操作，占位符（语法上需要语句但什么都不做） |
五、函数
基本格式:
def 函数名(传入参数):
函数体
return 返回值
与c/c++的不同:
1.不需要写是否有返回值，更不需要写返回值的类型
2.传入参数只需要变量接收即可，不需要写参数的数据类型，其类型由调用函数时的实参决定
六、数据容器
本章共包含五个容器:列表(list) 元组(tuple) 字符串(str) 集合(set) 字典(dict)
列表(list)
特点:列表可以一次存储多个数据，并且可以为不同的数据类型，并支持嵌套
字面量
[a1, a2, ……]
定义变量
变量名称 = [a1, a2, ……]
定义空列表
变量名称 = []
变量名称 = list()
列表的索引
正向索引：与数组类似
反向索引：最后一个元素索引为-1，倒数第二个为-2，以此类推
嵌套列表的索引也和数组的索引类似
index()函数:
list.index(obj):在list列表中找到第一个值为obj的元素，并返回下标索引
修改元素：
list[pos] = obj:将下标为pos的元素更改为obj
插入元素：
list.insert(pos,obj):在list的下标为pos的位置插入元素obj
追加元素：
list.append(obj):在list列表的末尾加入元素obj
list.extend(container):在list列表的末尾加入容器container
删除元素：
del list[pos]:将list列表下标为pos的元素删掉
list.pop(pos):将list列表下标为pos的元素删掉，并返回别删除的元素
list.remove(obj):将list列表中第一个为obj的元素移出列表
清空列表：
list.clear():清空list列表
统计数量
list.count(obj):统计值为obj的元素数量，并返回数量的值
元组(tuple)
特点:元组一旦定义完成，就不可被修改
支持嵌套，可以嵌套其他数据容器
所以，当我们需要在程序中封装数据，又不希望数据别篡改，就适合使用元组
字面量
(a1, a2, ……)
定义变量
变量名称 = (a1, a2, ……)
注意：元组只有一个数据的情况下，这个数据的后面要添加逗号
eg:t = ("hello",)
如果我写t = ("hello")，则t的类型为str
定义空元组
变量名称 = ()
变量名称 = tuple()
元组的索引
元组的索引方式与列表完全一致
元组的基本操作
| 函数 | 作用 |
|---|---|
tuple.index(element) |
查找数据element，返回数据对应的下标 |
tuple.count(element) |
统计数据element在元组中出现的次数 |
len(tuple) |
统计元组tuple内的元素个数 |
元组的特殊情况
虽然元组不能被修改，但如果元组内嵌套了list，则可以修改该list里面的内容
eg:
t1 = (1, 2, ["songline", "nihao"])
t1[2][1] = "niubi"
print(t1) # 输出:(1, 2, ["songline", "niubi"])
字符串(str)
字符串是老朋友了，和c/c++类似的操作就不介绍了
但是注意:字符串也不支持修改内容，这是和c/c++不同的地方
字符串的替换
str.replace(str1,str2) :将字符串str里面的str1字符串替换为str2。
但是，这个函数不是修改字符串本身，而是得到一个新的字符串
字符串的分割
str.split(str1) :str1作为分割字符串，将字符串划分为多个字符串，存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
eg:
mystr = "hello songline nihao"
mystr_list = mystr.split(" ")
print(mystr_list,type(mystr_list)) #输出:['hello', 'songline', 'nihao'] <class 'list'>
字符串的规整操作
去前后空格
str.strip() :将str前后的空格去除，返回新的字符串
eg:
mystr = " hello songline nihao "
mystr = mystr.strip()
print(mystr) #输出:hello songline nihao
去前后字符串
str.strip(str1) :将str前后出现在str1中的字符去掉，返回新的字符串
eg:
mystr = "132hello songline nihao231"
mystr = mystr.strip("123")
print(mystr) #输出:hello songline nihao
字符串出现的次数
str.count(str1) :返回str1在str中出现的次数
eg:
mystr = "hello songline nihao"
a = mystr.count("i")
print(a) #输出:2
序列
序列是指：内容连续、有序，可使用下标索引的一类容器
因此，列表、元组、字符串均可视为序列
序列的切片操作
语法：序列[起始下标:结束下标:步长]
切片的内容为[起始下标，结束下标)
起始下标为空表示从头开始
结束下标为空表示截取到结尾
步长n表示每次跳过n-1个元素取
步长如果不写则默认是1
步长小于零表示反向取，这时起始下标和结束下标也要反向标
操作对原序列没有影响
集合(set)
集合与序列类的容器不同，它不允许元素重复
集合具有自动去重的功能
eg:
my_set = {"小红","小明","小白","小红","小明","小白","小红","小明","小白"}
print(f"my_set={my_set}") #输出结果:my_set={'小明', '小白', '小红'}
基本语法:
变量名称 = {元素,元素,......,元素}
定义空集合:
变量名称 = set()
修改操作：
集合是无序的，所以不支持下标索引访问
但是集合和列表一样，允许修改
添加新元素
语法: set.add(obj) ，表示在set集合中插入元素obj
移除元素
语法: set.remove(obj) ，表示移除set集合中的元素obj
随机取出元素
语法: set.pop() ，表示在set集合中随机取出一个元素，函数返回取出的元素，该元素在集合中消失
清空集合
语法: set.clear() ，表示清空set集合
取出两个集合的差集
语法: set3 = set1.difference(set2) ，set3表示set1集合有而set2集合没有的元素组成的集合
eg:
set1 = {1,2,3}
set2 = {1,4,5}
set3 = set1.difference(set2)
print(set3) #{2, 3}
print(set1) #{1, 2, 3}
print(set2) #{1, 4, 5}
消除两个集合的相同元素
语法: set1.difference_update(set2) ，在set1集合里面删除和set2集合相同的元素
eg:
set1 = {1,2,3}
set2 = {1,4,5}
set1.difference_update(set2)
print(set1) #{2, 3}
print(set2) #{1, 4, 5}
合并两个集合
语法: set3 = set1.union(set2) ，set3是set1和set2合并后的集合，原集合set1和set2不变
统计集合元素数量
语法: num = len(set) ，num是set集合去重之后的数量
集合的遍历(for循环)
eg:
set1 = {1,2,3,4,5}
for element in set1:
print(f"集合里面有:{element}")
"""输出:
集合里面有:1
集合里面有:2
集合里面有:3
集合里面有:4
集合里面有:5
"""
字典(dict)
和C++里面的map很类似，用于存放键值对key:value
定义字典变量
my_dict = {key:value,key:value,......,key:value}
定义空字典
my_dict = {} 或 my_dict = dict()
key重复的问题
key不能重复
如果字典中的key重复，后面的值会覆盖前面的值
字典数据的获取
字典和集合一样，不能使用下标索引
只允许通过key获取value，语法: my_dict[key]
字典的嵌套
字典的key和value可以是任何类型
但是，key不可为字典
eg:
my_dict = {
"小明":{
"语文":77,
"数学":66,
"英语":33
},
"小红":{
"语文":88,
"数学":86,
"英语":55
},
"小白":{
"语文":99,
"数学":96,
"英语":66}
}
a = input()
b = input()
print(f"{a}的{b}成绩是{my_dict[a][b]}")
my_dict[key] = value
如果key在字典中不存在，则添加key:value
如果存在，则是更新value的值
删除元素
value = my_dict.pop[key]
删除键为key的元素，同时返回其值value
清空元素
my_dict.clear()
获取全部的key
keys = my_dict.keys()
把my_dict里面所用的key返回
eg:
my_dict = {1:2,3:4,5:6}
keys = my_dict.keys()
print(f"keys={keys},type={type(keys)}")
# 输出:keys=dict_keys([1, 3, 5]),type=<class 'dict_keys'>
字典的遍历
- 法1：通过keys遍历 eg:
my_dict = {1:2,3:4,5:6}
keys = my_dict.keys()
for i in keys:
print(f"my_dict[{i}]={my_dict[i]}")
- 法2：直接for循环
eg:
my_dict = {1:2,3:4,5:6}
for key in my_dict:
print(f"my_dict[{key}]={my_dict[key]}")
统计字典的元素数量
num = len(my_dict)
数据容器总结
| 容器 | 增加（add） | 删除（delete） | 修改（update） | 查询（select） | 额外操作 |
|---|---|---|---|---|---|
| list | |||||
| 列表 | 1. append(obj)：末尾追加元素 |
||||
2. extend(container)：追加整个容器 |
|||||
3. insert(pos,obj)：指定下标插入元素 |
1. del list[pos]：按索引删除 |
||||
2. pop(pos)：删除并返回该元素 |
|||||
3. remove(obj)：删除第一个匹配元素 |
|||||
4. clear()：清空列表 |
list[pos] = obj：给指定下标赋值 |
1. index(obj)：获取第一个匹配元素下标 |
|||
2. count(obj)：统计元素个数 |
|||||
3. len(list)：统计总元素 |
切片[起始:结束:步长]、for遍历 |
||||
| tuple | |||||
| 元组 | 不能增加元素 | 不能删除元素 | 不能修改顶层元素，嵌套列表除外 | 1. index(element)：查找下标 |
|
2. count(element)：统计次数 |
|||||
3. len(tuple)：统计长度 |
切片、for循环遍历 | ||||
| str | |||||
| 字符串 | 不能原地增加字符，只能产生新字符串 | 不能原地删除字符，只能产生新字符串 | 不能原地修改内容，方法返回新字符串 | 1. count(str1)：统计子串出现次数 |
|
2. len(str)：获取字符串长度 |
1. replace(str1,str2)：替换生成新字符串 |
||||
2. split(str1)：分割成列表 |
|||||
3. strip() / strip(str1)：去除首尾字符 |
|||||
| 4. 切片、for遍历 | |||||
| set | |||||
| 集合 | add(obj)：添加单个元素 |
1. remove(obj)：移除指定元素 |
|||
2. pop()：随机取出一个元素 |
|||||
3. clear()：清空集合 |
集合里面单个元素无法修改；只能先删再加 | len(set)：统计去重后的元素数量 |
1. difference(set2)：获取set1独有的元素 |
||
2. difference_update(set2)：更新自身集合 |
|||||
3. union(set2)：合并集合 |
|||||
| 4. for遍历；无索引 | |||||
| dict | |||||
| 字典 | dict[key]=value：key不存在就是新增 |
1. pop(key)：删除键值对并返回value |
|||
2. clear()：清空字典 |
dict[key]=value：key存在则修改value |
1. dict[key]：通过key取值 |
|||
2. keys()：拿到全部key |
|||||
3. len(dict)：统计键‑值对总数 |
遍历： | ||||
①keys=dict.keys()再循环 |
|||||
②for key in dict；不支持下标索引 |
容器的通用操作
求长度
num = len(container)
求最值
求最大值：max(container)
求最小值：min(container)
字典中是按key比大小
类型转换
newContainer = 新容器类型(oldContainer)
注意:字典除转字符串外转其他类型只保留key。
其他类型不能转换成字典
容器通用排序
sorted(container,reverse=True)
reverse=True不写为从小到大，写了则是从大到小
返回的是序列，原容器不变
container.sort(reverse=True)
对原容器直接排序，reverse=True不写为从小到大，写了则是从大到小排序