提示：文章写完后
文章目录
前言
提示：以下是本篇文章正文内容
一、基础常识
1.注释
注释是代码中的辅助性文字，会被解释器过滤掉，不被 计算机执行。注释一般用于在代码中标明作者和作者的版权信息，或者解释代码原理及用途，或者通过注释单行代码辅助程序。
单行注释：以#开头，本行#之后的内容都为注释
多行注释：以一对三引号’’’ ‘’’ 或""" “”" 开头和结尾的内容
2.变量
变量是保存和表示数据值的占位符，采用标识符来表示，关联标识符的过程叫做命名；其值可以通过赋值符(=)向变量复制或者修改值
变量的命名规则：允许采用大小写，数字，下划线(_)和中文等字符及其组合给变量命名。
Python里面可以支持中文变量，不推荐使用
注：标识符对大小写敏感，首字母不能是数字，不能与保留字相同，中间不能出现空格
保留字：编程语言内部定义并保留使用的标识符
表达式：产生或计算新数据的代码片段称为表达式，一般由数据和操作数构成
变量的赋值：
< 变量> = < 表达式>
< 变量1> … < 变量N> = < 表达式1>…< 表达式2>
交换x,y的值
x, y = y ,x
在Python中可以连续赋值
x=y=z=1 / x = y = z+1 / x=5;y=5;z=5
但是, x = (y=z+1)是非法的，x被赋值 y = z + 1 ，它并不返回任何值，所以这是一个错误的赋值语句
Python中的变量并不直接存储值， 而是存储了值的内存地址或者引用， 这也是变量类型随时可以改变的原因
在Python中，允许多个变量指向同一个值
x = 3
id(x) # 1786684560
y = x
id(y) # 1786684560
x += 6
id(x) #1786684752
id(y) # 1786684560
采用的是基于值的内存管理方式, 也就是地址。x, y 相当于一个标签，指向地址的。id()函数用来查看对象的内存地址
注：不需要事先声明变量名及其类型，直接赋值即可创建各种类型的
3.缩进
Python语言采用严格的“缩进”来表明程序的格式框架。缩进指每一行代码开始前的空白区域，用来表示代码之间的包含和层次关系
1个缩进 = 4个空格 =1个TAB
缩进是Python语言中表明程序框架的唯一手段，当表达分支、循环、函数、类等程序含义时，在if、while、for、def、class等保留字所在完整语句后通过英文冒号(:)结尾并在之后进行缩进，表明后续代码与紧邻无缩进语句的所属关系
4.数字类型
(1)整型：1， 31
(2)布尔型：整型的子类， True和False对应整型的1和0
(3)浮点型： 1.23， 3.14e-10
(4)复数： 1 + 2j， 0.23-8.55j
real：复数的实部
imag：复数的虚部
conjugate()：返回该复数的共轭复数
注：复数不支持比较大小, python也不支持 ++ , –
相关函数 yu
在进行运算时，由于精度的问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据
0.3 + 0.2 # 0.5
0.4 - 0.1 # 0.30000000000000004
0.4 - 0.1 == 0.3 # False
abs(0.4-0.1 - 0.3) < 1e-6 # True
5.输入输出函数
input( )函数：从控制台获得用户输入的函数，可包含一些提示性文字，用户输入的信息以字符串类型保存在< 变量>中
< 变量> = input（< 提示信息字符串>）
eval( )函数：以Python表达式的方式解析并执行字符串，将返回结果输出，即去掉参数最外侧引号并执行余下语句的函数
eval（< 字符串或字符串变量>）
eval()函数经常和input()函数一起使用，用来获取用户 输入的数字：
<变量> = eval(input(<提示信息字符串>))
print( )函数：以字符形式向控制台输出结果的函数，字符串类型的一对引号仅在程序内部使用，输出无引号
print(value1, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
sep参数之前为需要输出的内容（可以有多个）；
sep参数用于指定数据之间的分隔符，默认为空格；
end参数用于指定输出完数据之后再输出什么字符；
file参数用于指定输出位置，默认为标准控制台，也可以重定向输出到文件
print(1, 3, 5, 7, sep='\t'，end='!')
1 3 5 7!
with open('test.txt', 'a+') as fp:
print('Hello world!', file=fp) #重定向，将内容输出到文件中
6.模块导入
1.使用import保留字完成
import <库名> [as 别名] #采用< a>.< b>( )编码风格
<库名>.<函数名>(<函数参数>)
2.使用from和import保留字共同完成
使用from和import保留字共同完成
from <库名> import <函数名> [as 别名]
from <库名> import *
<函数名>(<函数参数>)
7.del和垃圾回收
== del删除名称，而不是对象==，删除alist之后就不能未经初始化使用它，blist还有效， blist指向的对象还存在
Python的垃圾回收： Python 自动进行内存管理，主要算法为引用计数，当引用计数归零时，对象立即就被销毁，释放内存。当删除的变量保持的是对象最后一个引用的时候，会删除对象
8.条件组合
短路效应：当一个 or 表达式中所有值都为真， Python会选择第一个值；当一个 and 表达式 所有值都为真， Python 会选择最后一个值
(2 or 3) * (5 and 6 and 7)
14 # 2*7
二、组合数据类型
集合类型是一个元素集合， 元素之间无序， 相同元素在集合中唯一存在
序列类型是一个元素向量， 元素之间有序， 通过序号访问， 元素之间不排他
映射类型是“键-值” 数据项的组合， 每个元素是一个键值对， 表示为(key, value)
1.字符串
没有字符常量和变量的概念， 只有字符串类型的常量和变量，单个字符也是字符串
使用单引号、 双引号、 三单引号、 三双引号作为定界符（delimiter） 来表示字符串， 并且不同的定界符之间可以互相嵌套
与C/C++区别:
1.没有单独的char数据类型，一个字符就是长度为1的字符串
2.字符串是不可改变的
3.Python字符串后是没有’\0’ 结尾的
正向递增序号 和 反向递减序号
索引：返回字符串中单个字符 ，<字符串>[M]
切片：返回字符串中一段字符子串 ， <字符串>[M: N]
注：范围是左闭右开，M起点，N前一个字符为终点
使用[M: N: K]根据步长对字符串切片，M缺失表示至开头， N缺失表示至结尾，根据步长K对字符串切片
一些特殊的字符
续行符：“\”
转义符：" " , 转义符表达特定字符，一般用于输出单/双引号
"\b"回退
"\n"换行(光标移动到下行首)
“\r” 回车(光标移动到本行首)
r/R：原始字符串，所有的字符串都是直接按照字面的意思来使用， 没有转义特殊或不能打印的字符，用在字符串前面
[::-1] 将字符串进行逆序输出
[0:-1] 从开头到结尾除最后一个字符
[:] 全部字符串
[::2] 步长为2
字符串处理方法
| 方法 | 描述 |
|---|---|
| str.lower() 或 str.upper() | 返回字符串的副本，全部字符小/大写"AbCdEfGh".lower() 结果为 “abcdefgh” |
| str.split(sep=None) | 返回一个列表，由str根据sep被分隔的部分组成"A,B,C".split(",") 结果为 [‘A’,‘B’,‘C’] |
| str.count(sub) | 返回子串sub在str中出现的次数 “an apple a day”.count(“a”) 结果为 4 |
| str.replace(old, new) | 返回字符串str副本，所有old子串被替换为new"python".replace(“n”,“n123.io”) 结果为"python123.io" |
| str.center(width[,fillchar]) | 字符串str根据宽度width居中， fillchar可选"python".center(20,"=") 结果为’=python=’ |
| str.strip(chars) | 从str中去掉在其左侧和右侧chars中列出的字符"= python= “.strip(” =np") 结果为"ytho" |
| str.join(iter) | 在iter变量除最后元素外每个元素后增加一个str",".join(“12345”) 结果为"1,2,3,4,5" #主要用于字符串分隔等 |
字符串类型的格式化：格式化是对字符串进行格式表达的方式
1.format()方法
<模板字符串>.format(<逗号分隔的参数>)
如图：槽中的顺序可以默认，也可以自己设置
格式控制：
"{0:=^20}".format("PYTHON")
# '=======PYTHON======='
"{0:,.2f}".format(12345.6789)
# 12,345.68
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
# 110101001,Ʃ,425,651,1a9,1A9
"{0:e},{0:E},{0:f},{0:%}".format(3.14)
# 3.140000e+00,3.140000E+00,3.140000,314.000000%
2.格式化引导符
和C语言的一样使用%控制
print("%d"%(1+2)) # 表达式的输出项需要用括号括起来
print("%d+%d=%d"(1,2,1+2)) # 多个输出项也逗号隔开
print("%.2f"%3.1234) # 3.12
2.列表
列表是有序可变序列类型
特点：
创建后可以随意被修改
使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
列表中各元素类型可以不同，无长度限制
注：方括号 [] 真正创建一个列表，赋值仅传递引用
ls = [1,2,3]
lt =ls
ls[0] = 0
lt # [0,2,3]
ls由实际数据赋值产生，为列表对象，将ls赋值给lt仅能产生对列表对象ls的一个新引用，所以ls,lt共同指向了地址存储为[1,2,3]的空间，ls改变列表，lt也将改变
注意append() 与extend()
extend 接受一个参数, 这个参数总是一个 list, 并且添加这个 list 中的每个元素到原 list 中，将列表中的每一个添加到另一个列表里
append 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list的尾部
sort与sorted区别：
sort()会导致list内元素的顺序被改变；
sorted()函数是内置函数，返回排好序的新列表，同时保持原列表不变
列表的操作函数
3.集合
集合类型是一个元素集合， 元素之间无序， 相同元素在集合中唯一存在
特点
集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一， 不存在相同元素
集合元素不可更改，不能是可变数据类型
集合用大括号 {} 表示，元素间用逗号分隔
建立集合类型用 {} 或 set()
注：建立空集合类型，必须使用set()
B = set("pypy123") #使用set()建立集合
{
'1', 'p', '2', '3', 'y'}
C = {
"python", 123, "python",123} # {'python', 123}
集合操作符
A = {
"p", "y" , 123}
B = set("pypy123")
A-B # {123}
B-A # {'3', '1', '2'}
A&B # {'p', 'y'}
集合处理方法
集合作用：数据去重：集合类型所有元素无重复
ls = ["p", "p", "y", "y", 123]
s = set(ls) # 利用了集合无重复元素的特点
#{'p', 'y', 123}
lt = list(s) # 还可以将集合转换为列表
#['p', 'y', 123]
4.元组
元组是有序不可变序列类型
特点：
一旦创建就不能被修改
使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
可以使用或不使用小括号
creature = "cat", "dog", "tiger", "human"
# creature = "cat", "dog", "tiger", "human"
a, b = 'dog', 'tiger' #多变量同步赋值
a, b = (b, a) #多变量同步赋值， 括号可省略
5.字典
字典是无序可变映射类型
特点：
映射是一种键(索引)和值(数据)的对应
键值对之间无序，键值对用冒号: 表示
采用大括号{}和dict()创建
注意：键必须是不可变数据类型，比如说字符串，数字，元组，不可以是列表
d = {
[1,2]:1,[3,4]:3} #错误的
d = {
(1,2):1,(3,4):3} # 对的
通用操作函数
在字典变量中， 通过键获得：<值> = <字典变量>[<键>]
用来向字典变量中索引或增加元素：<字典变量>[<键>] = <值> [ ]
d[key]方式既可以索引， 也可以赋值
作用：表达键值对数据
例如：统计数据出现的次数，数据是键，次数是值
元组，字符串，列表这类格式，在进行两者之间的比较时，先从第一个元素开始比较ASCII码值的大小，如果相等，则依次往后比较，如果全部相等，则比较数量大小
6.列表推导式
列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性
语法格式
[expression for expr1 in sequence1 if condition1
for expr2 in sequence2 if condition2
for expr3 in sequence3 if condition3
...
for exprN in sequenceN if conditionN]
列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁
1到10的平方
aList = [x*x for x in range(10)]
等价于
aList = []
for x in range(10):
aList.append(x*x)
练习
# 使用列表推导式实现矩阵转置
matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
[[row[i] for row in matrix] for i in range(4)]
# 30以内所有能被3整除的数
multiples = [i for i in range(30) if i % 3 == 0]
print(multiples)
# 30以内所有能被3整除的数的平方
multiples2 = [ i*i for i in range(30) if i % 3 == 0]
print(multiples2)
7.集合与字典推导式
格式语法和列表的差不多
# 计算列表中每个值的平方，自带去重功能
squared = {
x**2 for x in [1, -1, 2]}
print(squared)
# 合并大小写对应的value值，将k统一成小写
mcase = {
'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {
k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
for k in mcase.keys()}
print(mcase_frequency)
三、控制结构
1.顺序结构
顺序结构就是平常一般的结构从上至下按照顺序执行，流程图如上
2.分支结构
一般单一分支流程图如下：
根据判断条件结果而选择不同向前路径的运行方式
格式：
if <条件> :
<语句块>
二分支结构
语法格式
if <条件> :
<语句块1>
else :
<语句块2>
紧凑形式：适用于简单表达式的二分支结构
<表达式1> if <条件> else <表达式2>
如果条件成立，则执行表达式1，反之表达式2
x = 5
y = 9
a = x+y if x > 0 else x-y
print(a) # 14
多分支结构
语法格式
if <条件1> :
<语句块1>
elif <条件2> :
<语句块2>
……
else :
<语句块N>
注：注意多条件之间的包含关系，变量取值范围的覆盖
3.循环结构
1.for循环
语法格式：
for <循环变量> in <遍历结构> :
<语句块>
主要用于
计数循环(N次): 遍历由range()函数产生的数字序列，产生循环
字符串遍历循环:s是字符串，遍历字符串每个字符，产生循环
列表遍历循环: ls是一个列表，遍历其每个元素，产生循环
文件遍历循环: fi是一个文件标识符，遍历其每行，产生循环
range()语法格式
range(stop)
range(start, stop)
range(start, stop, step)
该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,stop)内以step为步长的整数。参数start默认为0，step默认为1
循环的扩展：for与else
for c in "PYTHON" :
if c == "T" :
continue
print(c, end="")
else:
print("正常退出")
# PYHON正常退出
for c in "PYTHON" :
if c == "T" :
break
print(c, end="")
else:
print("正常退出")
# PY
else语句只在循环正常执行结束之后才执行，当循环没有被break语句退出时，执行else语句块，else语句块作为"正常"完成循环的奖励
2.while循环
由条件控制的循环运行方式，反复执行语句块，直到条件不满足时结束
语法格式：
while <条件> :
<语句块>
while 也可以和else搭配，也是一样的用法
break 和 continue
for c in "PYTHON" :
if c == "T" :
continue
print(c, end="")
# PYHON
s = "PYTHON"
while s != "" :
for c in s :
print(c, end="")
s = s[:-1] # 每次减最后一个字符
# PYTHONPYTHOPYTHPYTPYP
s = "PYTHON"
while s != "" :
for c in s :
if c == "T" :
break
print(c, end="")
s = s[:-1]
# PYPYPYPYPYP
continue跳出本次循环，继续下一次循环
break仅跳出当前最内层循环
四、异常处理
异常是指程序运行时引发的错误，引发错误的原因有很多，例如除零、 下标越界、 文件不存在、 网络异常、 类型错误、 名字错误、 字典键错误、 磁盘空间不足
常见的异常
捕获并处理异常，尝试将程序从异常中拯救出来，继续正常运行，至少做一些必要的紧急操作，避免严重后果的发生。将异常信息保存在错误日志中，以便程序员查找错误发生的原因。
(1)try…except…
try子句中的代码块包含可能会引发异常的语句，而except子句则用来捕捉相应的异常
如果try子句中的代码引发异常并被except子句捕捉，就执行except子
句的代码块
如果try中的代码块没有出现异常就继续往下执行异常处理结构后面的代码
如果出现异常但没有被except捕获，继续往外层抛出，如果所有层都没有捕获并处理该异常，程序崩溃并将该异常呈现给最终用户
语法格式：
try:
#可能会引发异常的代码，先执行一下试试
except Exception[ as reason]:
#如果try中的代码抛出异常并被except捕捉，就执行这里的代码
(2)try…except…else…
如果try中的代码抛出了异常并且被except语句捕捉则执行相应的异常处理代码，这种情况下就不会执行else中的代码，但是如果try中的代码没有引发异常，则执行else块的代码，这有点像for …else语句
语法格式
try:
#可能会引发异常的代码
except Exception [ as reason]:
#用来处理异常的代码
else:
#如果try子句中的代码没有引发异常，就继续执行这里的代码
(3)try…except…finally…
无论try中的代码是否发生异常，也不管抛出的异常有没有被except语句捕获， finally子句中的代码总是会得到执行
获取异常信息的描述：信息存储在result里面
# 一个异常信息
try:
print(a)
except NameError as result:
print(result)
# 捕获多个异常信息
try:
open("test.txt")
except (NameError,IOError) as result:
print("哈哈，捕获到异常")
print("异常的基本信息：%s" % result)
# 捕获所以的异常
try:
open("test.txt")
except Exception as result:
print("捕获到异常")
print(result)
五、函数
函数是一段代码的表示，函数是一段具有特定功能的、可重用的语句组
函数是一种功能的抽象，一般函数表达特定功能，两个作用：降低编程难度 和 代码复用
格式：
def <函数名>(<参数(0个或多个)>) :
<函数体>
return <返回值>
和C语言一样的这样写交换两个函数，不会交换a,b的值
def swap(x,y): #2
x,y=y,x #4
s=x+y #5
return s #
c = swap(a,b) #调用
1.函数传参
函数定义时可以为某些参数指定默认值，构成可选参数
格式：
def <函数名>(<非可选参数>, <可选参数>) :
<函数体>
return <返回值>
def fact(n, m=1) :
s = 1
for i in range(1, n+1):
s *= i
return s//m
# fact(10) 默认参数 3628800
# fact(10,5) 修改参数 725760
函数定义时可以设计可变数量参数，既不确定参数总数量
格式：
def <函数名>(<参数>, *b ) :
<函数体>
return <返回值>
def fact(n, *b) : # b为可以参数 ，本质是一个元组
s = 1
for i in range(1, n+1):
s *= i
for item in b:
s *= item
return s
# fact(10,3) 10886400
# fact(10,3,5,8) 435456000
def myprint(title, **contents):
print(title,":")
for k,v in contents.items():
print("\t", k+":\t", v)
print(type(contents))
myprint("Dora's Information", name="Dora Chen", age=26, salary=3200)
Dora's Information :
name: Dora Chen
age: 26
salary: 3200
<class 'dict'>
**跟随的形参只吸收关键字参数。contents在函数内表现为一个字典，其中，关键字为键，实参为值
函数调用时，参数可以按照位置或名称方式传递
def fact(n, m=1) :
s = 1
for i in range(1, n+1):
s *= i
return s//m
# fact( 10,5 ) 位置
# fact( m=5,n=10 ) 名称
函数可以返回0个或多个结果，return保留字用来传递返回值
注意，返回多个值是返回的元组类型
2.lambda函数
lambda函数是一种匿名函数，即没有名字的函数，使用lambda关键字，函数名是返回结果
<函数名> = lambda <参数>: <表达式>
f = lambda x, y : x + y
f(10, 15) # 25
f = lambda : "lambda函数"
print(f()) #lambda函数
使用lambda表达式将下边函数转变为匿名函数
def fun_A(x, y=3):
return x * y
f = lambda x, y=3 : x * y
f = lambda x : x if x % 2 else None
def is_odd(x):
if x % 2:
return x
else:
return None
3.全局变量与局部变量
4.递归函数
六、文件
1.文件的定义
文件是数据的抽象和集合，文件是存储在辅助存储器上的数据序列，是数据存储的一种形式，文件展现形态： 文本文件和二进制文件
注：所有文件都是二进制形式存储
文本文件:
由单一特定编码组成的文件，如UTF-8编码
由于存在编码，也可以被看作是存储在磁盘上的长字符串
比如：.txt文件、 .py文件
二进制文件
直接由比特0和1组成，没有统一字符编码
一般存在二进制0和1的组织结构，即文件格式
比如：.png文件、 .mp4文件
编码
(1)ascii码: 只有英文字母和特殊字符，一个字节是8位
(2)unicode码
一个字符是32位，一个字母4个字节
一个汉字是32位，一个汉字4个字节
(3)utf-8：
一个字母是8位，一个字母1个字节
一个汉字是24位，一个汉字3个字节
(4)Gbk
一个字母是8位，一个字母1个字节
一个汉字是16位，一个汉字2个字节
各个编码之间的二进制不能互相识别，会乱码。unicode占得内存太多，所以不能传输和储存。utf-8， gbk， utf-16， utf-32， gb2312， ascii等都可以储存和传输
python3在内存中是用unicode编码方式存储的，所以不能直接储存和传输，要转化为其他编码进行储存和传输
bytes类型
bytes类型也是一种数据类型。bytes不是用unicode方式编码的，所以可以储存和传输。bytes的编码方式是utf-8， gbk， ascii， gb2312等
英文：
在python3中： str表现形式； s = ‘‘xiaoming’’ str编码形式： unicode
在bytes中： str表现形式： s = b’‘xiaoming’’ str编码形式： utf-8， gbk， ascii， gb2312等
中文：
在python3中： str表现形式； s = ‘‘中国’’ str编码形式： unicode
在bytes中： str表现形式： s = b’'x\e91\e91e91\e91e91\e91 str编码形式： utf-8， gbkascii， gb2312等
字符串通过编码转换成字节码，字节码通过解码成为字符串
encode： str --> bytes 编码
decode： bytes --> str 解码
str = "我是Python3"
str_utf8 = str.encode('utf-8')
str_gbk = str.encode('GBK')
print(str)
print("UTF-8 编码： ", str_utf8)
print("GBK 编码： ",str_gbk)
print("UTF-8 解码： ", str_utf8.decode('utf-8'))
print("GBK解码： ",str_gbk.decode('GBK'))
我是Python3
UTF-8 编码：b'\xe6\x88\x91\xe6\x98\xafPython3'
GBK 编码： b'\xce\xd2\xca\xc7Python3'
UTF-8 解码： 我是Python3
GBK解码： 我是Python3
2.文件的处理
文件处理的步骤：打开-操作-关闭
文件的打开
格式：
<变量名> = open(<文件名>,<打开模式>)
文件句柄 文件路径和名称,源文件目录可省去路径 文本 or 二进制 读或写
文件的打开模式
f = open("f.txt") # 文本形式、只读模式、默认值
f = open("f.txt", "rt") # 文本形式、只读模式、同默认值
f = open("f.txt", "b") # 二进制形式、只读模式
f = open("f.txt", "wb") # 二进制形式、覆盖写模式
文件的关闭
<变量名>.close() # 文件句柄
文件使用
文件内容读取函数
遍历全文本
# 1.一次读入，统一处理
fname = input("请输入要打开的文件名称:")
fo = open(fname,"r")
txt = fo.read()
#对全文txt进行处理
fo.close()
# 2.按数量读入，逐步处理
fname = input("请输入要打开的文件名称:")
fo = open(fname,"r")
txt = fo.read(2)
while txt != " ":
#对txt进行处理
txt = fo.read(2)
fo.close()
文件的逐行操作
# 1.一次读入，分行处理
fname = input("请输入要打开的文件名称:")
fo = open(fname,"r")
for line in fo.readlines(): # readlines返回的是一个列表
print(line)
fo.close()
# 2.分行读入，逐行处理
fname = input("请输入要打开的文件名称:")
fo = open(fname,"r")
for line in fo: # 这里直接是文件句柄
print(line)
fo.close()
数据文件的写入
fo = open("output.txt","w+")
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
for line in fo:
print(line)
fo.close() # 写入字符串，但是这样没有输出，因为文件指针在文本末
修改：
fo = open("output.txt","w+")
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
fo.seek(0) # 写入数据后，文件指针指向开头，后面才会输出
for line in fo:
print(line)
fo.close()
总结
提示：这里对文章进行总结：