Python基础知识点
Python是一种面向对象的解释型计算机程序设计语言。
Python是强类型的动态脚本语言。
编译型和解释型语言各有优缺点：
解释型：
缺点：执行慢
优点：可以跨平台（操作系统）
编译型：
缺点：不能跨平台
优点：执行快
1 注释
1.1 单行注释
1.2 多行注释
使用方式
三组英文双引号（"""）或三组英文单引号（'''）
1.3 批量注释/取消注释
选中后按 (Ctrl+/)
2 输入输出
1.1输出：print()
sep=' '设置多语句输出的分隔符，默认为空格
print("哈哈哈","嘿嘿嘿","嘻嘻嘻") # 输出：哈哈哈 嘿嘿嘿 嘻嘻嘻 print("哈哈哈","嘿嘿嘿","嘻嘻嘻"，sep=',') # 输出：哈哈哈，嘿嘿嘿，嘻嘻嘻end=' '设定以...结尾，默认值是'\n'。也可用于字符串拼接
print("字符串1",end="字符串2") # 输出：字符串1+字符串2+第二个print里的值字符串输入输出必须加上引号，单引号双引号均可
1.2输入：input()
name = input("请输入姓名：") print(name)3 变量
标识符的命名规范
3.1 合法的标识符:
字母，数字(不能开头),下划线，py3可以用中文（不建议），py2不可以。
3.2 注意大小
3.3 不能使用关键字和保留字
关键字： if,while,for,as,import
保留字：input，print，range
3.4没有长度限制
3.5望文生义，看到名字就知道要表达的意思。
4 数据类型
4.1 数值类型
整数
int浮点型
float布尔型
bool复数
complex固定写法：
z = a + bja是实部，b是虚部，j是虚数单位
4.2核心数据类型：
数据类型查询：print(type(数据名))
字符串（str）：
"Hello"或'Python'。数字（int/float）：
42或3.14。布尔值（bool）：
True或False。列表（list）：
[1, 2, 3]（可修改）。元组（tuple）：
(1, "a")（不可修改）。字典（dict）：
{"name": "Alice"}（键值对）。
5 表达式
数字、算符、数字分组符号（括号）、变量等对象的组合叫做表达式，表达式均有固定字面值
6 运算符
6.1 算术运算符
基本运算：
+（加）、-（减）、*（乘）、/（除，返回浮点数）。特殊运算：
//（整除）：结果向下取整%（取模）：余数符号与除数一致**（幂运算）：右结合性，如2**3**2 = 2^(3^2) = 512。
6.2 位运算符
操作二进制位：仅支持整数类型，需掌握二进制转换（如
5→101）。关键运算符：
~（按位取反）：结果为-(x+1)，如~5 = -6。>>（右移）：正数补0，负数补1，如-5 >> 2 = -2。
6.3 比较运算符
结果类型：返回布尔值（
True/False），支持数值、字符串、列表等。易错点：
==（值相等） vsis（内存地址相同），如1 == 1.0为True，但1 is 1.0为False。链式比较：如
1 < 2 < 3等价于1 < 2 and 2 < 3。字符串比较：按ASCII码顺序，如
'A' < 'a'，'abc' < 'abd'。
6.4 逻辑运算符
组合布尔值：
not>and>or（优先级），支持短路求值。
6.5 赋值运算符
基础形式：
=（赋值），复合形式如+=、-=、*=等。注意：Python无
++或--自增运算符，需用x += 1替代。
6.6 运算符优先级
从高到低：
幂运算
**。按位取反
~、正负号+x/-x。算术运算（乘
*、除/、整除//、取模%> 加+、减-）。位运算（左移
<<、右移>>> 按位与&> 按位异或^> 按位或|）。比较运算（
<、>、==等）和身份运算（is、is not）。逻辑运算（
not>and>or）。赋值运算（
=及其复合形式，优先级最低）。
强制优先级：使用括号
()明确运算顺序。
6.7 特殊规则
结合性：同优先级运算符按“左结合”（从左到右）或“右结合”（如幂运算
**从右到左）。类型限制：位运算仅支持整数，算术运算支持数值类型。
7 字符串
7.1 字符串基础特性
不可变性
定义后无法直接修改单个字符（如
s[0] = 'A'会报错），需通过切片或拼接生成新字符串。
可迭代性
支持遍历每个字符：
三种表示形式
引号类型 语法示例 适用场景 单引号 'Hello'短文本，内部可嵌套双引号（如 'He said "Hi"'）双引号 "Python"功能同单引号，内部可嵌套单引号（如 "It's a cat"）三引号 '''多行\n文本'''或"""多行\n文本"""多行文本或保留换行/空格，也可作多行注释
7.2 字符串访问与操作
1. 索引（获取单个字符）
规则：正向从
0开始，反向从-1开始。s = "Python" print(s[0]) # 输出: P（正向索引0） print(s[-1]) # 输出: n（反向索引-1）
2. 切片（截取子串）
语法：
[start:end:step]，左闭右开（包含start，不包含end），step默认为1。s = "Python" print(s[1:4]) # 输出: yth（索引1到3） print(s[::2]) # 输出: Pto（全串，步长2） print(s[::-1]) # 输出: nohtyp（步长-1，反转字符串）
3. 常用操作
拼接：用
+连接字符串（仅支持字符串间拼接）。print("Hello" + " " + "World") # 输出: Hello World重复：用
*重复字符串n次。print("-" * 10) # 输出: ----------成员判断：用
in/not in判断字符/子串是否存在。print("ll" in "hello") # 输出: True
7.3 字符串内置方法
1. 大小写转换
s.upper()：全部转为大写。s.lower()：全部转为小写。s.title()：每个单词首字母大写。print("hello".upper()) # 输出: HELLO print("HELLO".lower()) # 输出: hello print("hello world".title()) # 输出: Hello World
2. 去除空白字符
s.strip()：去除首尾空白（含空格、换行符\n、制表符\t）。s.lstrip()/s.rstrip()：仅去除左/右空白。s = " \n Python \t " print(s.strip()) # 输出: Python
3. 查找与替换
s.find(sub)：返回子串sub第一次出现的下标，不存在返回-1。s.replace(old, new, count)：替换old为new，count可选（指定替换次数，默认全部）。s = "hello world" print(s.find("l")) # 输出: 2 print(s.replace("l", "x", 2)) # 输出: hexxo world
4. 分割与连接
s.split(sep)：按sep分割字符串，返回列表（sep默认为空白）。sep.join(list)：用sep连接列表元素为字符串。s = "a,b,c" print(s.split(",")) # 输出: ['a', 'b', 'c'] print("-".join(["a", "b"])) # 输出: a-b
5. 类型判断
s.isdigit()：判断是否全为数字。s.isalpha()：判断是否全为字母。print("123".isdigit()) # 输出: True print("abc".isalpha()) # 输出: True
7.4 字符串格式化
1. f-string
name = "Elysia" age = 18 print(f"Hello, {name}!") # 输出: Hello, Elysia!2.format()方法
print("Hello, {}!".format(name)) # 输出: Hello, Elysia!3.%格式化（最常用）
print("Hello, %s!" % name) # 输出: Hello, Elysia! print("姓名: %s,年龄: %d" % (name,age)) # 输出: 姓名: Elysia,年龄: 18%6d：输出整数位数为6，不足的话用空格补全
%06d：输出整数位数为6，不足的话用0补全
7.5 转义字符
Python用反斜杠
\转义特殊字符：print("\n") # 换行符 print("\t") # 制表符 print("\\") # 输出\ print("%%") # 输出%使用原始字符串（
r'\n'）可忽略转义：print(r'\n') # 输出: \n
7.6 注意事项
引号必须成对使用，且开始与结束的引号类型需一致。
字符串拼接时，非字符串类型需用
str()转换（如"Num:" + str(123)）。字符串方法均返回新字符串，不修改原字符串（不可变性）。
8 判断语句
8.1 if判断
例：
age = input("请输入你的年龄：") if age < '18': '''input内部默认字符串类型，而字符串与整形不能进行大小比较，故将整形变为字符串类型''' print("未成年人不能上网") if age >= '18': print("年龄通过，祝您愉快！")8.2 if-else判断
8.3 if嵌套
9 循环
9.1 循环类型
while循环（条件循环）
条件循环：通过判断条件决定是否执行循环体，分为当型循环和直到型循环。
语法：
初始化计数器 while 条件: 循环体 更新计数器
特点：
需手动初始化计数器并更新条件，否则可能形成死循环。
适用于循环次数未知的场景 。
for循环（迭代循环）
遍历循环：用于迭代序列（如
str、list、tuple、dict）或可迭代对象。语法：
for 元素 in 可迭代对象: 循环体
for i in range(1,6): print(i) # 输出1,2,3,4,5特点：
循环次数由序列长度决定，无需手动更新计数器。
遍历顺序为元素在序列中的原始顺序。
9.2 循环控制语句
break
作用：立即终止整个循环（无论条件是否满足）。
场景：搜索算法中提前退出、用户输入满足条件时停止。
示例：
for i in range(10): if i == 5: break print(i) # 输出0-4
continue
作用：跳过当前迭代，直接进入下一次循环。
场景：过滤数据时跳过不符合条件的元素。
示例：
for i in range(5): if i == 2: continue print(i) # 输出0,1,3,4
9.3 循环选择建议
for循环：优先用于已知迭代次数或需遍历序列的场景
while循环：适用于循环次数未知或需动态判断条件的场景
10 列表(list)
10.1 列表的创建与特性
创建方式
直接定义：
list1 = [1, "hello", True, [2, 3]]（支持嵌套和混合类型）空列表：
list2 = []或list2 = list()转换其他对象：
list3 = list("abc") # 输出: ['a', 'b', 'c'] list4 = list((1, 2, 3)) # 输出: [1, 2, 3]
核心特性
可变：可直接修改元素（增、删、改），内存地址不变。
有序：元素按插入顺序排列，支持索引访问（从0开始）。
可重复：允许存储相同值的元素（如
[1, 1, 2]）。类型无限制：可存储整数、字符串、列表、字典等任意类型。
10.2 索引与切片（访问元素）
索引
正向索引：从左到右，第一个元素为0（如
lst[0]）。反向索引：从右到左，最后一个元素为-1（如
lst[-1]）。示例：
lst = [10, 20, 30, 40] print(lst[0]) # 输出: 10 print(lst[-1]) # 输出: 40
切片
语法：
lst[start:end:step]，返回新列表（不修改原列表）。规则：
start：起始位置（默认0）。end：结束位置（不包含，默认列表长度）。step：步长（默认1，负数表示反向切片）。
示例：
lst = [10, 20, 30, 40, 50] print(lst[1:3]) # 输出: [20, 30] print(lst[::2]) # 输出: [10, 30, 50] print(lst[::-1]) # 输出: [50, 40, 30, 20, 10]
10.3 列表的相关操作
增加元素
lst = [10, 20, 30, 40, 50]| 方法 | 功能 | 示例 |
|---|---|---|
append(x) | 在末尾添加一个元素 | lst.append(60)→[10,20,30,40,50,60] |
extend(iterable) | 在末尾添加可迭代对象的所有元素(对于字符串分散添加) | lst.extend([60,70])→[10,20,30,40,50,60,70] |
insert(index, x) | 在指定索引处插入元素（指定位置如果有元素，原有元素会后移） | lst.insert(2, 25)→[10,20,25,30,40,50] |
删除元素
| 方法 | 功能 | 示例 |
|---|---|---|
remove(x) | 根据元素的值进行删除（默认删除最先出现的元素） | lst.remove(1)→ 删除第一个1 |
pop([i]) | 删除指定位置元素 (若无索引，则默认删除最后一个元素) | popped = lst.pop(2)→ 删除索引2的元素 |
clear() | 清空列表 | lst.clear()→[] |
del | 删除列表或删除指定位置元素 | del lst→ 删除列表lstdel lst[2]→ 删除索引2的元素 |
修改元素
通过索引直接修改：
lst = [1, 2, 3] lst[0] = 10 # 修改第一个元素 → [10, 2, 3]
查询与统计
name_list = ['bingbing','susu','zizi']| 方法 | 功能 | 示例 |
|---|---|---|
index(x) | 返回元素第一次出现的索引 | lst.index(3)→ 返回3的索引 |
count(x) | 统计元素出现的次数 | lst.count(1)→ 统计1的个数 |
排序与反转
lst = [2,3,5,1,4]
| 方法 | 功能 | 示例 |
|---|---|---|
sort() | 排序列表（默认升序排列，即从小到大） | lst.sort()→print 输出[1, 2, 3, 4, 5] |
reverse() | 反转列表顺序 | lst.reverse()→ print输出[4, 1, 5, 3, 2] |
#降序排列 ls = [2,3,5,1,4] ls.sort() #升序排列（从小到大） ls.reverse() #倒叙排列 print(ls) #输出列表 #输出结果为降序[5, 4, 3, 2, 1]复制与浅拷贝
copy()：返回列表的浅拷贝（相当于a[:]）。
lst_copy = lst.copy() # 浅拷贝，修改不影响原列表10.4 高级操作
列表推导式
简洁创建列表的方式，可结合条件语句：
squares = [x**2 for x in range(10) if x % 2 == 0] # 输出: [0, 4, 16, 36, 64]
嵌套列表
列表中可包含其他列表，形成多维结构：
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
11 元组(tuple)
11.1 元组基本格式
tua = (1,2,3,'a','b','c') #定义元组（不同元素可以是不同数据类型 tua = () #定义空元组 tua = (1,) #只有一个元素时，末尾必须加上','，否则返回唯一的值的数据类型11.2 元组与列表的区别
元组只有一个元素末尾必须加逗号，列表不用
元组只支持查询操作，不支持增删改（元组只读）
11.3 应用场景
12 字典(dict)
12.1 基本格式
字典名 = {键1 ：值1 ，键2 ，值2}
字典中键具有唯一性，但值可以重复
如果键发生重复，不会报错，但相同键名前面的值会被后面的值所覆盖
12.2 字典常见操作一
查看元素
变量名[键名] 键名不存在会报错 变量名.get(键名) 键名不存在默认返回None 变量名[键名]
不可以根据下标查询，字典里没有下标，查找元素需要根据键名，键名相当于下标
dic = {'name':'bingbing','age':18} #创建字典 print(dic['age']) #查找元素需要根据键名 print(dic['sex']) #键名不存在会报错变量名.get(键名)
键名不存在会返回None
dic = {'name':'bingbing','age':18} #创建字典 print(dic.get('sex')) #键名不存在，默认返回None print(dic.get('sex','不存在')) #可自行设置返回值，目前返回‘不存在’
修改元素
添加元素
删除元素
方法 功能 示例 del 字典名删除整个字典 del dicdel 字典名[键名]删除指定键值对（键值对不存在会报错） del dic['age'].pop()删除指定键值对（键值对不存在会报错） dic.pop('age').clear()清空字典内容，保留字典本身 dic.clear()→print(dic)输出结果为{}
12.3 字典常见操作二
len()求长度求字典中键值对个数
求列表中元素个数
求字符串中字符个数（不包括'\0'）
.keys()返回字典里包含的所有键名dic = {'name':'bingbing','age':18} print(dic.keys()) #输出 dict_keys(['name','age']) # for循环取出键名 for i in dic.keys(): #只取出键名 print(i) #输出 name \n age.values()返回字典里包含的所有值dic = {'name':'bingbing','age':18} print(dic.values()) #输出 dict_values(['bingbing',18]) # for循环取出值 for i in dic.keys(): #只取出值 print(i) #输出 bingbing \n 18.item()返回字典里包含的所有键值对键值对以元组形式输出
12.4 字典的应用场景
使用键值对，存储描述一个物体的相关信息
13 集合(set)
13.1 集合的基本格式
集合中的元素可以是不同的数据类型
13.2 集合的特性
无序性：同一个集合，每次打印输出时，输出的字符元素顺序都各不相同（但数字集合运行结果一致）
且不能修改集合中的值，不能通过下标去查询
唯一性：可以自动去重
13.3 集合的常见操作
集合具有无序性，所以不能通过下标去查询或修改
添加元素
集合的唯一性决定了如果需要添加的元素在原集合中已经存在，就不进行任何操作
方法 功能 示例 .add()整体添加（一次只能添加一个元素，但可用元组类型整体添加） s2.add(5)→ 向原有集合s2中增添一个元素5s2.add(5,6)→报错，一次只能添加一个元素s2.add((5,6))→ 向原有集合s2中添加一个元组（5，6）.update()拆分元素，逐个放入集合（括号里需要放可迭代对象，如字符串、列表、元组） s2.update('567')删除元素
方法 功能 示例 .remove()指定元素删除（若指定元素集合中没有则报错） s2.remove(3)→ 删除原集合s2中的元素3.pop()括号中无参，默认删除根据hash表无序排列后的第一个元素 s2.pop().discard()指定元素删除（若指定元素集合中没有则不会进行任何操作） s2.discard()
13.4 交集和并集
14 类型转换
15 深浅拷贝
浅拷贝只拷贝数据，深拷贝拷贝内存地址
| 方法 | 功能 | 示例 |
|---|---|---|
| 赋值 | 数据完全共享，变化一致 | li = [1,2,3]li2 = li |
| 浅拷贝 | 数据半共享 | li2 = copy.copy(li) |
| 深拷贝 | 数据完全不共享 | li2 = copy.deepcopy(li) |
15.1 赋值
15.2 浅拷贝(数据半共享，藕断丝连)
会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
import copy #导入copy模块 li = [1,2,3,[4,5,6]] #定义一个嵌套列表 #浅拷贝 第一个copy是调用库copy,第二个是库copy中的copy函数 li2 = copy.copy(li) print("li",li) print("li2",li2) #查看内存地址 id() print("li内存地址：",id(li)) print("li2内存地址：",id(li2)) #内存地址不一样，说明不是同一个对象 li.append(8) print("li",li) #打印输出包含新增元素8 print("li2",li2) #打印输出不包含新增元素8 #往嵌套列表添加元素 li[3].append(7) print("li",li) #打印输出嵌套列表中包含新增元素7 print("li2",li2) #打印输出嵌套列表中包含新增元素7 #查看嵌套列表内存地址 print("li[3]内存地址：",id(li)) print("li2[3]内存地址：",id(li2)) #内存地址相同，说明是同一个对象，即嵌套层会指向原来的内存地址 #总结：外层的内存地址不同，但内层的内存地址相同优点：拷贝速度快，占用空间少，拷贝效率高
15.3 深拷贝（数据完全不共享，完全无关）
外部的对象和内部的元素全部拷贝了一遍
import copy #导入copy模块 li = [1,2,3,[4,5,6]] #定义一个嵌套列表 #深拷贝 第一个copy是调用库copy,第二个是库copy中的deepcopy函数 li2 = copy.deepcopy(li) print("li",li) print("li2",li2) #查看内存地址 id() print("li内存地址：",id(li)) print("li2内存地址：",id(li2)) #内存地址不一样，说明不是同一个对象 li.append(8) print("li",li) #打印输出包含新增元素8 print("li2",li2) #打印输出不包含新增元素8 #往嵌套列表添加元素 li[3].append(7) print("li",li) #打印输出嵌套列表中包含新增元素7 print("li2",li2) #打印输出嵌套列表中不包含新增元素7 #查看嵌套列表内存地址 print("li[3]内存地址：",id(li)) print("li2[3]内存地址：",id(li2)) #嵌套列表内存地址不一样，说明也不是同一个对象 #总结：内外层的内存地址均不同，即深拷贝数据变化只影响自己本身，跟原来对象没有联系16 可变与不可变对象
16.1 可变对象
含义：变量对应的值可以修改，但内存地址不会发生改变
16.2 不可变对象
含义：变量对应的值不能被修改，如果修改就会生成一个新的之从而分配新的内存空间
17 函数
17.1 函数基础
函数定义
用
def 函数名(参数列表):定义，函数体缩进。def login(name): print("这是登录函数")函数调用
函数名加括号传参调用。
login()
17.2 参数类型
位置参数
按定义顺序传参。
def add(a, b): return a + b result = add(3, 5)关键字参数
指定参数名传参，可打乱顺序。
result = add(b = 5, a = 3)默认参数
定义时为参数设默认值，调用可省略。
def power(x, n = 2): return x ** n result = power(4)可变参数
*args
接收任意数量位置参数，打包成元组。
def sum_numbers(*args): return sum(args) result = sum_numbers(1, 2, 3, 4)**kwargs
接收任意数量关键字参数，打包成字典。
def print_info(**kwargs): for k, v in kwargs.items(): print(f"{k}: {v}") print_info(name = "Bob", age = 25)
17.3 返回值
无返回值
返回None
单返回值
用 return 返回一个值。
def square(x): return x * x result = square(6) print(result)多返回值
以元组形式返回多个值。
def get_name_and_age(): return "bingbing", 18 print(get_name_and_age())
return与print的区别
1.return表示函数结束，print会一直执行
2.return是返回计算值，print是打印结果
17.4 作用域
局部作用域
函数内变量，只能内部访问。
def test_local(): local_var = 10 print(local_var) test_local()全局作用域
函数外变量，程序全局可访问。用 global 在函数内修改。
global_var = 20 def modify_global(): global global_var global_var = 30 modify_global() print(global_var)嵌套作用域
内层函数可访问外层变量，用 nonlocal 修改。
def outer(): outer_var = 40 def inner(): nonlocal outer_var outer_var = 50 inner() print(outer_var) outer()
17.5 匿名函数（lambda 函数）
定义简单一次性函数，lambda 参数: 表达式。
add = lambda a, b: a + b result = add(7, 8)17.6 装饰器
增强函数功能，本质高阶函数。
def my_decorator(func): def wrapper(): print("Before") func() print("After") return wrapper @my_decorator def say_hello(): print("Hello!") say_hello()17.7 递归函数
函数调用自身，需有终止条件。
def factorial(n): return 1 if n in [0, 1] else n * factorial(n - 1) result = factorial(5)17.8 生成器函数
用 yield 关键字，返回生成器对象。
def count_up_to(n): num = 1 while num <= n: yield num num += 1 counter = count_up_to(3) for num in counter: print(num)