Python教程

注意

本教程仅供具有一定代码基础的爱好者学习借鉴
对于执行任何操作所造成的后果, 作者不予负责

相关信息

本文随作者学习而更新

提示

Contribution Welcome! 欢迎贡献！
本教程急需重新排版

---变量---

输出变量类型 type(变量名)
判断变量是否为某类型 isinstance(变量, 类型) 返回布尔值

该判断语句包含了子类，适用性比type()更强

整数

浮点数

保留n位小数 format(浮点数, '.nf')

进制

进制类型	前缀标识	区分大小写	示例（对应十进制数值 10）
二进制	0b 或 0B	不区分	0b1010, 0B1010
八进制	0o 或 0O	不区分	0o12, 0O12
十六进制	0x 或 0X	不区分	0xA, 0XA
十进制	无前缀且不应有前导0	/	10

注意

Python中不支持使用后缀表示进制数

存储

整数型变量只能存储十进制数
无前缀非十进制数须以字符串存储
有前缀非十进制数(非字符串)会被自动转换为整数型存储(输出)

print(0b1001) 将输出 9

转换

整数转二进制 bin(整数) 返回字符串
整数转八进制 oct(整数) 返回字符串
整数转十六进制 hex(整数) 返回字符串
非十进制数(字符串)转十进制

字符串

转义

换行 \n
制表符 \t
输出单引号 \'
输出双引号 \"
输出反斜杠 \\

常用语法

切片
切割(split方法)
全小写 字符串.lower()
全大写 字符串.upper()
检测是否全是大写 字符串.isupper() 返回布尔值
检测是否全是小写 字符串.islower() 返回布尔值
判定结尾字符串 字符串.endswith(结尾判定) 返回布尔值
查看某字符串的数量 字符串.count(字符串)
替换字符串中的字符串 字符串.replace(old, new, count) 返回字符串
返回Unicode编码 ord(单个字符) 返回整数
返回Unicode字符 chr(Unicode编码) 返回字符
转整数型
转列表(list函数)

元组

定义空元组 变量 = tuple() 或 变量 = ()
特性：有序、不可变

集合

定义空集合 变量 = set()
定义有元素集合 变量 = {元素0, 元素1, ...}
特性：无序、可变、元素在集合内唯一(不可重复)

注意

注意区分空集合与空字典的定义方法
{}为空字典

取交集 集合1 & 集合2 返回集合
取并集 集合1 | 集合2 返回集合
取补集 属集 - 种集 返回集合

列表

在结尾添加元素 列表名.append(元素)
删除指定元素 列表.remove(元素)
复制列表 新列表 = 旧列表[:]
取最值
遍历序列(元素) for value in 列表名
遍历序列 enumerate(列表名/字符串/元组, start = n) 返回可迭代对象index, value

start = n 指定索引起始值(可实现由1开始的序列索引)
注意: 本项效果并非从第 n-1 个元素遍历, 而是将原本的 0 元素的索引改为 n , 依旧是从第一个元素开始遍历

转列表并使字符串整体作为一个元素传入 [字符串] 返回新列表 实际上是列表推导式
以指定函数遍历执行序列元素 map(函数,序列) 返回迭代器
查看列表中某元素的数量 列表.count(元素)
查找指定元素的索引 列表.index(元素)
反转列表 reversed(列表) 返回反转的迭代器
排序列表 sorted(列表, reverse = False, key = 排序依据的值) 返回排序后的新列表
原地排序 列表.sort(reverse = False) 返回None

reverse = False为升序(默认)
key参数用法

去除重复项 列表名 = list(set(原列表/字符串...))

原理：集合是一种不可重复的序列，先set()转为集合自动去重，再转列表

元素拼接为字符串 ''.join(列表/元组/可迭代对象) 返回字符串

元素必须为字符串; 若包含非字符串元素, 建议使用生成器表达式转换

列表推导式

字典

唯一的内置映射类型
键视图 字典.keys() 返回视图对象
值视图 字典.values() 返回视图对象
键值对视图 字典.items() 返回视图对象
删除指定键的键值对(pop方法)
删除最后插入的键值对(popitem方法)
获取指定键对应的值

常用语法
存在则取当前值, 不存在则取0 字典[key] = 字典.get(key, 0) + value

---执行---

Python 代码（整体）
├── 执行属性上，分为两大基本执行单元
│ ├── 表达式（求“值”：是什么，能算出结果）
│ │ ├── 基础表达式（1+2、"abc"、x）
│ │ ├── 函数调用表达式（len([])、sorted([1,2])）
│ │ └── 方法调用表达式（list1.extend(list2)、"a".upper()）
│ └── 语句（做“动作”：做什么，执行操作，无返回值/返回None）
│ ├── 赋值语句（x = 1+2）
│ ├── 打印语句（print(x)）
│ ├── 条件语句（if/else）
│ ├── 循环语句（for/while）
│ └── 函数定义语句（def 函数名()）
└── 功能属性上，可以将一些语句和表达式打包，定义为函数，目的是方便重复调用实现功能
├── 函数（通用功能，可独立调用）
│ ├── 内置全局函数（Python自带：len()、sorted()、print()）
│ └── 自定义函数（自己用def定义：def add(a,b): ...）
└── 方法（依附于对象的特殊函数：对象专属，必须“对象.方法()”调用）
├── 列表专属方法（list方法：extend()、append()、sort()）
├── 字符串专属方法（str方法：upper()、expandtabs()、split()）
├── 元组专属方法（tuple方法：count()、index()）
└── 其他对象方法（dict、set等）

快速判断一行代码的性质的方法
有返回值的是表达式 如: 1 + 1 'happy'.upper() #返回字符串'HAPPY'
无括号、返回值为None的是语句 如: a = 10 if True for i in (1,2) import math

带括号、无前缀的是内置函数 如: print() input()
带括号、有库/模块前缀的是模块函数 如: math.sqrt() turtle.Screen()
带括号、有对象前缀的是方法 如: ''.join() ['1','5','2'].sort()

表达式

算术

加减乘除 +-*/
幂运算 底数 ** 指数
整除 被除数 // 除数
求余数(求模) 被除数 % 除数

比较

大小 > < >= <=
相等 如: a == b
不等 如: a != b
容器类型值相等 如: ['1','2'] == ['1','2']

逻辑

与 如: True and True
或 如: True or True
非 如: not True
三元表达式

字符串

拼接 如: "hello" + " world"
重复 如: "python" * 3
切片
调用函数 如: len("hello")
调用字符串方法(有返回值) 如: "hello".upper(), "a,b,c".split(",")

运算符%格式化

元组表达 print(' %d %s ' %(整数变量0, 字符串变量1) ) 按顺序对应
字典表达 print(' %(name)d %(age)s' %{'name':整数变量0, 'age':字符串变量1} ) 按键值对应
数据类型代号：

• %d 整数
• %s 字符串
• %.nf 保留n位小数的浮点数
• ...

辅助符号：

• % 用于转义 % (%% 将被打印为符号 %)
• ...

f-string 格式化 (Python 3.6+)

核心语法 print(f'{变量0}')
函数表达 print(f'{变量0 + 变量1}') 函数或语句 变量0 + 变量1 将被执行并自动填入返回值
内引号不能与外引号(字符串定界符)冲突
如: 引用字典时, 键值的引号使用双引号, 避免与母字符串的单引号冲突 print(f'{字典["键值"]}')
转义: {{ 将被打印为符号 { (右花括号同理)
也可以使用数据类型代号和辅助符号 print(f'{变量0:.nf}') n代表保留几位小数

容器操作

取值 如: [1,2,3,4][0] {'name': '张三', 'age': 18}['name']
切片
拼接 如: [1,2] + [3,4]
调用函数 如: len([1,2,3,4])

调用函数/方法(有返回值的)

调用内置函数 如: int('3') float(1) list(range(0,10,2))
调用模块函数 如: math.sqrt(100)
调用方法 如: ls.append(10)

海象表达式 (Python 3.8+)

用:=实现同时赋取值
如: (n := 10) +5 返回15, 且为 n 赋值 10

切片表达式

核心语法 序列[start:stop:step]
切出单字符 序列[索引]
切片法反转字符串 序列[::-1]

start: 起始位置
stop: 停止位置
step: 步长, 默认为 1; 负数从后往前切(须 start > stop)

列表推导式

核心语法 [元素]
基础语法 [表达式 for 变量 in 可迭代对象]
带条件判断的语法 [表达式 for 变量 in 可迭代对象 if 条件]
三元表达式语法 [三元表达式 for 变量 in 可迭代对象]

先遍历再逐个执行三元表达式

针对嵌套对象的语法 [表达式 for 外层变量 in 嵌套可迭代对象 for 内层变量 in 外层变量]

从左到右执行 <=> 从外到内执行

语句

赋值

核心语法 变量名 = 值
增强赋值 变量名 += 值 在变量基础上进行操作

支持所有算术表达 += -= *= /= **= //= %=
支持序列的追加、拼接(+=)和重复(*=)

函数

自定义函数

格式

def 函数名(参量):
    ...
    return 返回值

调用时有两种传参方法

1. 位置传参 函数名(a, b)
2. 关键字传参 函数名(参量1 = a, 参量2 = b)

缺省参数

在参量传入区预设某参量的默认值，定义函数时初始化参量为默认值
示例 def run(key, value = 0)

默认值仅在定义函数时初始化一次，而非每次调用时都初始化
这代表当缺省参数是可变对象时，

算术型函数

取绝对值 abs(数值) 返回整数
取整除与模 divmod(x,y) 返回元组(整除数, 模)
幂运算(并取模) pow(底数, 指数[, 除数]) 返回数值(整数, 浮点数)
保留n位小数(四舍五入) round(x, n) 返回数值(整数, 浮点数)

n 默认为0: 保留到个位, 返回整数

取最值

匿名函数

用途: 执行简单操作并返回值
核心语法 lambda 变量: 函数 返回值为函数返回值
示例 lambda word: word[-1]

int函数

核心语法 int(字符串, 进制数)

进制数可为: 2, 8, 10, 16

list函数

核心语法 list(可迭代对象)
字符串将被按字符切片存入
字典(仅键, 值将被舍弃)将按键切片存入
其他可迭代对象将按元素切片存入

字典转列表实现

键 list(字典.keys())
值 list(字典.values())
键值对 list(字典.items())

print函数

核心语法 print(内容, end = '')

参数 end = '' 控制打印内容的结尾, 默认为'\n'

计算输出行数时，只计算有效输出行，不计算最后一个 '\n'

格式化方法(效果: 插入变量, 规定输出格式等)

1. %运算符格式化
2. 字符串.format()方法格式化 计算机二级要求掌握
3. f-string表达式格式化 最简便, 推荐

input函数

核心语法 input('提示') 返回字符串

eval函数

核心语法 eval(字符串) 返回字符串去除引号的运行结果
如: eval('1+2') 将返回 3

max函数(min函数)

核心语法 max(对象, key = 对比规则)
核心语法 min(对象, key = 对比规则)
要求: 若未定义转换规则, 待比较的对象类型须一致

key参数用法

取数值最大值 max(数值1, 数值2, 数值3, ..., 数值n) 返回数值(整数, 布尔值, 浮点数)
取纯数值序列最大值 max(序列1, 序列2, 序列3, ..., 序列n) 返回序列
取嵌套序列最大值 如: max(['a','b'],['b','c']) 返回外层序列['a','b']

对比依据: 按序列顺序依次对比每一个数，返回第一个出现最大数的序列

提示

布尔值为整数的子类
此处视为整数 True == 1 False == 0

方法

字符串方法

split方法

核心语法 字符串.split(str='分隔符',num=分割次数) 返回列表

默认以空字符(空格, \n, \t, 等)分割
分割次数默认为 -1，即全部分割

进阶用法: 变量1, 变量2, ..., 变量n = 字符串.split(,n) 变量类型为字符串

效果: 同时定义n个变量, 达到分割字符串的效果

format方法 (Python 3.0+)

核心语法 字符串.format()
顺序表达 print('{} {}'.format(变量0, 变量1) )

花括号中可标记变量在后缀元组中的索引
若未标记索引, 则按顺序一一对应

关键字表达 print('{age} {name}'.format(age = 变量0, name = 变量1) )

以上两种表达可以任意组合

字典索引表达 print('{0[name]} {0[age]} {0[hobby]}'.format(字典变量0)) 中括号内为键值
字典解包表达 print('{name} {age} {hobby}'.format(**字典变量0))
元组索引表达 print('{0[0]} and {0[1]}'.format(元组变量0)) 中括号内为索引
元组解包表达 print('{} and {}'.format(*元组)) 元组长度须与中括号个数相同

[!tips]
*代表解包元组, 元素按序填入

格式说明符

格式化语法 print('{:说明符}'.format(变量))
排版'{:[填充字符][对齐][宽度]...}'.format(变量)
整数'{:[排版][正负号][,(千位分隔符)][#(前缀)][进制]}'.format(变量)

进制：b二进制 d十进制 o八进制 x十六进制

浮点数'{:[排版][正负号][.n(精度)][显示类型]}'.format(变量)

类型：%百分比 e指数计数

更多格式说明符请自行学习(如日期、时间)

字典方法

pop方法

核心语法 字典.pop(指定键, 键不存在时返回的值) 返回删除的值或键不存在时的返回值
用途: 删除指定键对应的键值对

popitem方法

核心语法 字典.popitem() 返回删除的值
用途: 删除最后插入的键值对

get方法

核心语法 字典.get(key, default) 返回字典[key]或default
用途: 获取特定值, 键不存在时返回default

结构

循环结构

for循环语句

for i in range(开始,结束+1):
    ...

for遍历字符串

for 字符 in 字符串:
    ...

for遍历列表

for 元素 in 列表：
    ...

while循环语句

i = 0
while i <= n:
    ...
    i += 1

三元表达式

核心语法 值1 if 条件 else 值2
用途: 进行二分支条件判断并返回对应值

也支持更多分支的条件判断, 在值2处嵌套更多三元表达式即可
例: user_input = 'True' if yn == True else False if yn == False else '未知错误'
实现从左到右依次判断

条件结构

if条件结构

if 条件:
    ...
(可选) elif 条件2:
    ...
(可选) else:
    ...

if判断列表元素是否存在某项

for 元素 in 列表:
    if 元素 in ('a','e','i','o','u'):
        return True

判断身份 if 变量 is None/list/str/bool/...:
判断空列表 if not 列表名

该判断语句实质上是在判断列表本身的布尔值
若列表为空, 则列表为假; 若列表有元素, 则列表为真

异常处理结构

核心语法

try:
    '可能引发异常的语块'
except 异常1:
    '捕捉到异常1时执行的语块'
except 异常2:
    '...'
except:
    '捕捉到未指定的异常时执行的语块'
(可选)else:
    '无异常时执行的语块'
(可选)finally:
    '最后执行的语块'

特性：只会执行第一个匹配的except

库(模块)

Datetime 标准库

引入了 date() 对象
从 'yyyy-mm-dd' 格式的字符串解析date对象 datetime.date.fromisoformat(字符串)

string模块

常量(均为字符串)

常量名称	核心含义	具体值（字符串形式）	高频使用场景
string.ascii_lowercase	所有小写英文字母	'abcdefghijklmnopqrstuvwxyz'	生成小写字母验证码、匹配小写字母、字符分类
string.ascii_uppercase	所有大写英文字母	'ABCDEFGHIJKLMNOPQRSTUVWXYZ'	生成大写字母标识、匹配大写字母、格式规范化
string.ascii_letters	所有大小写英文字母（合集）	'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'	匹配所有英文字母、生成包含大小写的随机字符串
string.digits	所有阿拉伯数字字符	'0123456789'	生成数字验证码、提取字符串中的数字、匹配数字
string.punctuation	所有英文标点符号	'!"#$%&\'()*+,-./:;<=>?@[\\]^_{	}~'`
string.whitespace	所有空白字符	空格、制表符(\t)、换行(\n)、回车(\r)等	去除字符串首尾/中间的空白字符、匹配空白分隔符
string.hexdigits	所有十六进制字符	'0123456789abcdefABCDEF'	处理十六进制字符串、生成十六进制验证码
string.octdigits	所有八进制字符	'01234567'	处理八进制字符串、解析八进制数据

辅助函数

略

re模块

正则表达式语法

核心语法 [元字符][数量限定符][位置限定符]
该语块可穿插于字符串中任何一个位置作为正则匹配规则

1. 元字符: 用于限定匹配的字符
   |字符|含义|示例|
   |---|---|---|
   |.|匹配1个任意字符(除\n)|a.c|
   |[匹配字符]|匹配1个括号内字符|[0-9]将仅匹配数字|
   |[^非匹配字符]|匹配1个除括号内字符之外的字符|[0-9]将匹配除数字外的任何字符|
   | \d == [0-9] | 匹配任意1个数字 | \d |
   | \D == [^0-9] | 匹配任意1个非数字 | \D将匹配ab、_+ |
   | \w == [a-zA-Z0-9_] | 匹配任意1个字母/数字/下划线 | \w+将匹配a1_b、user123 |
   | \W == [^a-zA-Z0-9_] | 匹配任意1个非字母/数字/下划线 | \W将匹配@、+、（空格） |
   | \s == [ \t\n\r] | 匹配任意1个空白符（空格/制表符/换行） | a\sb将匹配a b、a\tb |
   | \S == [^ \t\n\r] | 匹配任意1个非空白符 | a\Sb将匹配a1b、a_b |
   |\|转义|将特殊字符转为字面量|

2. 数量限定符: 用于限定匹配次数
   |字符|含义|示例|
   |---|---|---|
   |*|匹配前一个字符任意次|a*b将匹配b ab ... aaaaaaaaaaaaaab|
   |+|匹配前一个字符至少1次|a+b将不匹配b|
   |?|匹配前一个字符0次或1次|a?b将仅匹配b或ab|
   |{n}|匹配前一个字符n次|a{n}将仅匹配'a'*n|
   |{n,}|匹配前一个字符至少n次|a{2,}将匹配aa, aaa ... aaaaaaa|
   |{n,m}|匹配前一个字符n到m次|a{2,4}将仅匹配aa, aaa和aaaa|

3. 位置限定符: 用于限定匹配位置
   |字符|含义|示例|
   |---|---|---|
   |^|匹配行首|^a将仅匹配在每行开头的'a'|
   |$|匹配行尾|\. $将仅匹配在每行结尾的'. '|
   |\A|匹配字符串开头|匹配字符串第一个^|
   |\Z|匹配字符串结尾|匹配字符串最后一个$|
   |\b|匹配单词边界(\w与\W间或^/$与\w间)||
   |\B|匹配非单词边界(两\w间或两\W间)||

4. 分组和选择
   分组语法: (匹配字符)[数量限定符]
   含义: 匹配括号内字符整体
   例: (ab)? 将仅匹配空字符串或ab

选择语法: 匹配字符1 | 匹配字符2
含义: 匹配 字符1或字符2
例: 1(2|3)将匹配'12'或'13'

模块语法

正则表达式规则的写法 r''
目的: 输入r标识传入原始字符串, 防止字符被python解释器转义

匹配字符串 match(r'', 字符串) 返回匹配对象或None

bool(match(...)) 返回布尔值

random库

生成[a,b]区间内的随机浮点数 uniform(a, b)
生成[a,b]区间内的随机整数 randint(a, b)
生成[a,b) 区间内符合步长的随机整数 randrange(a, b, step)
从非空序列中随机选择一个元素 choice(序列)
从非空序列中随机选择n个元素sample(序列, n) 返回列表
原地打乱序列 shuffle(序列) 返回None
设置种子随机 seed(种子)

turtle库

初始状态：海龟位于画布中心 (0,0)，朝向右侧，画笔为落笔状态，颜色为黑色
绘图完成后保持窗口打开 turtle.done()
提笔 penup() pu()
落笔 pendown() pd()

向前移动x个像素 forward(x) fd(x)
向后移动x个像素 backward(x) bk(x)
向左旋转α° left(α) lt(α)
向右旋转α° rignt(α) rt(α)
移动到指定坐标 goto(x,y)
绘制圆弧 circle(r, θ)

半径为r, r > 0时圆心在画笔左侧
圆心角为θ°

设置画笔粗细(像素) pensize(width) width(width)
设置画笔颜色(英文或十六进制) pencolor(color)
设置速度 speed(s)

1为最慢 10为最快 0为极速(瞬间)

隐藏海龟 hideturtle()

绘制闭合图形并填充颜色

turtle.begin_fill()
绘制闭合图形
turtle.end_fill()

collections模块

Counter类

核心语法 Counter(可迭代对象) 返回Counter对象(字典子类)

• most_common方法
  核心语法 Counter对象.most_common(n) 返回列表, 元素为元组('字符', '出现次数')
  用途: 返回出现频次最高的前n个元素
  n = None 返回所有(实现降序排序)
• update方法
  核心语法 Counter对象.update(可迭代对象)
  用于追加统计
• 获取指定键对应的值
• 其他字典方法

defaultdict类

核心语法 字典名 = defaultdict(默认工厂)
用途: 创建一个有默认值的字典, 当调用不存在的键时, 自动赋一个默认值(由指定的类型决定默认值)

默认工厂包括：数据类型、匿名函数和自定义无参函数
数据类型及其默认值包括但不限于int(0) list([]) str('') set(set())
匿名函数示例 dd = defaultdict(lambda: 100) 默认值为整数100
无参函数示例

def defaultfactory_time():
    import datetime
    now = datetime.datetime.now()
    return {"create_time": now, "value": 0}

time_dict = defaultdict(defaultfactory_time())

deque类

核心语法 变量名 = deque()
用途: 作为一种双端序列, 同时支持在首位添加/删除元素, 但不支持在中间添加或删除元素
方法
在首添加 变量名.appendleft()
在尾添加 变量名.append()
在首删除 变量名.popleft() 返回删除值
在尾删除 变量名.pop() 返回删除值
清空 变量名.clear()

nametuple类

命名元组: 可为元素指定属性名的元组. 作为元组占用资源少, 但相对于字典不可变, 适用于存储大量固定数据的场景.
不多介绍

jieba库

jieba模块

精确分词(无冗余) lcut(字符串) 返回列表
全分词(有冗余) lcut(字符串, cut_all = True) 返回列表
搜索引擎分词(有冗余) lcut_for_search(字符串) 返回列表

加载自定义词典 load_userdict(词典文件)

jieba.analyse模块

关键词提取

核心语法 extract_tags(字符串, topK, withWeight) 返回列表
topK: 个数, 默认为20
withWeight: 是否输出权重, 默认为False

os库

文件操作

提示

以下f均代表自定义别名

调用操作

打开文件 open(file, mode, encoding=None) as 自定义别名
关闭文件并释放资源 f.close()

file：文件路径 mode：打开模式 encoding：文件编码(中文须指定encoding='utf-8')
建议别名: f fp(file point) fo(file object)

模式	功能说明	是否创建新文件	是否覆盖原有内容	备注
'r'	只读模式（默认），仅能读取文件内容	否	-（不涉及写入）	文件不存在则报错，适合读取已存在的文件
'w'	只写模式，仅能写入文件内容	是	是（清空原有内容后写入）	文件存在则清空，不存在则创建，适合新建文件写入
'a'	追加模式，仅能在文件末尾写入内容	是	否（保留原有内容，末尾追加）	适合给已有文件补充内容，不破坏原有数据
'r+'	读写模式，既能读取又能写入文件内容	否	是（从文件开头开始覆盖写入）	文件不存在则报错，适合修改已有文件内容
'w+'	读写模式，既能读取又能写入文件内容	是	是（清空原有内容后写入）	先创建/清空文件，支持后续读取写入，适合新建并读写
'a+'	读写模式，既能读取又能写入文件内容	是	否（保留原有内容，末尾追加）	写入仅在末尾，读取需先移动文件指针，适合追加并读取
'rb'	二进制只读模式，用于读取非文本文件（图片、视频等）	否	-（不涉及写入）	无需指定encoding，返回二进制数据
'wb'	二进制只写模式，用于写入非文本文件（图片、视频等）	是	是（清空原有内容后写入）	无需指定encoding，写入二进制数据
'ab'	二进制追加模式，用于给非文本文件追加内容	是	否（保留原有内容，末尾追加）	无需指定encoding，追加二进制数据

with语法
优势: 执行完成后自动关闭, 无需手动调用close()

with open(...) as f:
    content = f.read()

方法

读取文件

核心语法 f.read(Byte) 返回字符串

Byte 为读取的字节数, 默认为-1(读取全部)
读取后，文件指针会移动到读取内容的末尾, 再次读取需要移动指针

提示

为节约内存资源, 大文件应优先选择逐行读取并调用列表

读取指针所在行

核心语法 f.readline(Byte) 返回字符串'行\n'

Byte 为读取的字节数, 默认为-1(读取整行)
读取行后指针移动到下一行首, 再次读取行即可实现逐行读取
由于返回的内容中包含换行符\n, 输出建议配合字符串.strip()方法去除

逐行读取语法

with open(...) as f:
    while True:
        line = f.readline()

        # 判断是否读完
        if not line:
            break
        
        print(line.strip())

读取全部行

核心语法 f.readlines(Byte) 返回列表, 元素为'行\n'

Byte 为读取的字节数, 默认为-1(全部读取)

提示

为节约内存资源, 大文件应优先选择逐行读取并调用列表

写入单个字符串

核心语法 f.write(字符串) 返回len(字符串)

需注意适当添加换行符
a模式下文件指针位于文件最后一行尾, 应在追加字符串前添加'\n'

写入多个字符串

核心语法 f.writelines(可迭代对象) 返回None

需在元素适当位置添加换行符
可搭配readlines()使用

移动指针

核心语法 f.seek(偏移量)

文本模式下, 仅支持从文件首位寻址, 使用偏移量(∈ N*)指定要向后移动的字节数
偏移量默认值为0, 将指针移动到文件首位

获取指针位置

核心语法 f.tell() 返回字节数(从文件首位到指针位置)

其他

key字段(排序依据)

排序依据值
使用 匿名函数 计算

常见自定义函数

1. 判断传入参数是否为质数, 返回布尔值

def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5)+1, 2):
        if n % i == 0:
            return False
    return True