Python基础语法

1.基础语法-初识Python

众所周知，Python是一种相对其他语言来说，更容易简单易上手，下面将介绍Python语法的输入输出格式，以及各种变量定义方式等等。
下面示例：介绍了python使用示例：

上面的框框为我们日常编写代码的工作台，下面框框是Pycharm的控制台。

1.1 常量

顾名思义，不能改变的量。

示例：

其中 1,2,3都叫常量，1+2+3叫做表达式

python在进行整数除法不会进行截断，而是直接计算结果，符合正常思维

1.2 变量和类型

变量就是可以改变的量
有时为了节省代码量或者方便理解，我们需要一些变量来临时存储一些数据。

有如下问题：

给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的方差.
PS: 方差的计算过程: 取每一项, 减去平均值, 计算平方, 再求和, 最后除以 (项数 - 1)

在这个代码中，我们需要先计算平均值，然后用变量保存起来。

变量的使用能够大大减少我们的编写难度和逻辑

1.2.1 变量定义

a=10

• 其中a为变量名
• =作用就是把右面的值，赋给变量a。

定理变量名规则：
（必须遵守）

• 变量名由数字字母下划线构成.
• 数字不能开头.
• 变量名不能和 “关键字” 重复.
• 变量名大小写敏感. num 和 Num 是两个不同的变量名.

（建议遵守）

• 变量名使用有描述性的单词来表示, 尽量表达出变量的作用.长一点没事，但是一定要表达清晰变量的含义。
• 建议使用 “驼峰命名法”. 形如 totalCount , personInfo 这种, 除了首个单词外, 剩余单词首字母大写。或者蛇形命名方式：total_count,person_info。

变量名是为了帮助人们更加容易看懂代码的含义，取一个很好的名子，也是不容易的.

1.2.2 使用变量

我们可以用下面的方法修改变量的值，如下示例：

1.2.3 变量类型

对于不同的变量，我们不仅仅要用数字来区分，同时也需要“类型”来区分。

整型

数据的范围是无穷的，根据表示数据的大小自动扩容。
a=10，10就是一个整型数据，用int来表示。

浮点数（小数）

python小数是双精度小数，相当于double类型
a=10.1，10.1就是小数，用float表示。

字符串

由一个个数字或字符串起来的串（类似羊肉串），整个串被当作字符串数据。
a ="hello Python"或者’hello Python’ ，用单引号双引号都可以，用str来表示。

len()可以用来求字符串长度，a+b可以将两个字符串加起来

可以用单双引号，甚至是三引号结合的方式来输出特定的字符串

布尔

布尔类型是一种特殊的类型，数值只有True（真）和False（假）两种，用bool表示
用于判断表达式的真假

使用示例：

其他类型

除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型 等等. 后续会继续补充.

1. 类型决定了数据在内存中占据多大空间.
2. 类型其实约定了能对这个变量做什么样的操作.

例如：+对于整型数据来说，是算数相加，对于字符串来说，就是拼接数据。

动态类型

可以根据数据类型动态的改变自己的类型

如下示例：可以看到变量a的类型由int变为str。

1.3 注释

注释就像说明书一样，可以帮注人们理解代码的含义。
要想让自己的代码被人看懂，就要学会写注释。

显然，有了注释之后，人们一眼便能知道这段代码的功能。

Python提供了两种注释风格

注释行，以#开头
#这是一行注释.

使用"“” 或者‘’‘来进行文本注释。
该方法可以注释好几行

如下示例两种注释方法：

1.4 输入和输出

print()为输出语句

使用方式：

inpute()为输入语句

使用方式1：

使用方式2：因为input是以字符串的格式接受的，不能直接进行算术运算。

改正：

类似的, 使用 float( ), bool( ), str( ) 等可以完成对应的类型转换.

1.5 运算符

1.5.1 算数运算符

+ - * / % ** // 这种进行算术运算的运算符, 称为 算术运算符

其中：'+‘加法，’-‘减法，’*‘乘法，’%‘取余，’**'乘方、
//为整除，/为正常除法。
如下示例：

1.5.2 关系运算符

< ，<= ，>， >= ，==， !=。
用来比较两个操作数之间的关系

示例1：

示例2：

直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同).

示例3：

对于浮点数一般不能用==来判断是否相等，只需要在误差允许的范围内即可

print(-0.000001 < (a - b) < 0.000001)

1.5.3 逻辑运算符

与 and
或 or
非

a = 10
b = 20
c = 30
print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)

结果：

a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同.

短路求值：

1. 对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行.
2. 对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行.

print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

上述代码没有抛出异常, 说明右侧的除以 0 操作没有真正执行.

1.5.4 赋值运算符

链式赋值：
a = b = 10 ，10先赋给b，b再赋给a
多元赋值：
a, b = 10, 20，10赋给a，20赋给b

基于多元赋值的交换数字：
正常写法：

a = 10
b = 20
tmp = a
a = b
b = tmp

Python特有写法：

a = 10
b = 20
a, b = b, a

复合赋值运算符：

1. += ，-+，*=，/=，%=。
2. 但是没有a++，++a这样的运算！

2.控制语句

有些时候我们需要控制代码进行的顺序，或者重复多段代码，此时我们就需要控制语句。

2.1 条件语句（分支语句）

if else语句来表达：如果…否则…

语法格式：

#（1）
if expression:
 	do_something1
 	do_something2
next_something

#（2）
if expression:
 	do_something1
else:
 	do_something2

# (3)
if expression1:
 	do_something1
elif expression2:
 d	o_something2
else:
 	do_something3

注意：Python中的条件语句写法, 和很多编程语言不太一样.

• if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.
• if / else 命中条件后要执行的 “语句块”, 使用 缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }
• 对于多条件分支, 不是写作 else if, 而是 elif (合体了).

示例：不同的缩进有着不同的结果：

判断一个年是否是闰年：

#输入一个年份判断是闰年还是平年
#input是按字符串格式接受，要转化成整型
year = int(input('请输入一个年份：'))
if ((year%4==0) and (year%100 != 0)) or (year%400==0):
    print(f'{year}是闰年')
else:
    print(f'{year}不是闰年')

2.1.1 空语句

为了表达该语句什么也不做，Python引入了空语句
pass

使用示例：

a=1
if a==1:
#pass代表空语句什么也不做
    pass
print('haha')

2.2 循环语句

2.2.1 while

while 条件:
	循环体

满足条件执行循环体，否则跳出循环。

计算5的阶乘：

#计算5的阶乘
n=1
i=1
while i<=5:
    n*=i
    i+=1
print(n)

计算1！+2！+3！+4！+5！之和

#计算1！+2！+3！+4！+5！之和
sum = 0
#把各个阶乘加起来
i=1
while i<=5:
    #每次初始化n ,j
    n=1
    j=1
    #求每个阶乘
    while j<=i:
        n=n*j
        j+=1
    i+=1
    sum+=n
print(sum)

2.2.2 for循环

2.2.2.1 基本语法

基本语法格式：

for 循环变量 in 可迭代对象:
    循环体

• python 的 for 和其他语言不同, 没有 “初始化语句”, “循环条件判定语句”, “循环变量更新语句”, 而是更加简单
• 所谓的 “可迭代对象”, 指的是 “内部包含多个元素, 能一个一个把元素取出来的特殊变量”

打印1~10

for i in range(1,11):
    print(i)

使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]

打印2，4，6，8，10

for i in range(2,11,2):
    print(i)

通过 range 的第三个参数, 可以指定迭代时候的 “步长”. 也就是一次让循环变量加几.

打印10~1

for i in range(10,0,-1):
    print(i)

range 的 步长 也可以设定成负数.

2.2.2.2进阶语法

for循环语句的迭代用法链接
numpy遍历数组的操作

---

enumerate()用于将一个可遍历的数据对象（如列表、元组、字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中：

i, data = enumerate(sequence, [start=0])
参数：sequence可迭代的对象
start：下标从start开始
前一个数据i是索引值，后一个data是数据
示例：

>>> seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
...
0 one
1 two
2 three

2.2.3 contibue

continue 直接跳过本次循环，进行下一次循环

示例：

for i in range (1,4):
    if i==2:
        continue
    print(i)

该代码跳过i==2，打印1，3

2.2.4 break

break直接跳出本层循环，相当于中断循环的意思

示例：

for i in range(1, 4):
    if i == 2:
        break
    print(i)

该代码只打印了1，可知在i==2时，直接中断了循环

3. 函数

函数是一段可以被重复使用的代码片段 .
使用函数可以简化代码量，使文章逻辑更清晰。

代码示例: 求数列的和, 不使用函数

# 1. 求 1 - 100 的和
sum = 0
for i in range(1, 101):
    sum += i
print(sum)
# 2. 求 300 - 400 的和
sum = 0
for i in range(300, 401):
    sum += i
print(sum)
# 3. 求 1 - 1000 的和
sum = 0
for i in range(1, 1001):
    sum += i
print(sum)

这组代码有很多重复的语句，仅仅是变量不同，我们可以把重复的代码提取出来，构成函数。

代码示例: 求数列的和, 使用函数

#求和函数
def add(beg,end):
    sum = 0
    for i in range(beg,end + 1):
        sum += i
    print(sum)

add(1,100)
add(300,400)
add(1,1000)

可以看到代码量减少许多，重复的代码已经消除

3.1 语法格式

创建函数：

def 函数名(形参列表):
    函数体
    return 返回值

调用函数/使用函数：

#函数名(实参列表)           // 不考虑返回值
#返回值 = 函数名(实参列表)   // 考虑返回值

key：函数必须先定义再使用，否则会报错

test3()         
 # 还没有执行到定义, 就先执行调用了, 此时就会报错. 
def test3():
    print('hello')

报错内容如下：

3.2 函数参数

在函数定义的时候, 可以在 ( ) 中指定 “形式参数” (简称 形参), 然后在调用的时候, 由调用者把 “实际参数” (简称 实参) 传递进去

代码示例：

#求和函数
def add(beg,end):
    sum = 0
    for i in range(beg,end + 1):
        sum += i
    print(sum)

add(1,100)
add(300,400)
add(1,1000)

上面的代码中, beg, end 就是函数的形参. 1, 100 / 300, 400 就是函数的实参.

注意：

• 和 C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型. 换句话说, 一个函数可以支持多种不同类型的参数

例如下面代码：

#一个函数参数可以接受多种类型的实参
def test(a):
    print(a)
test(10)
test('hello')
test(True)

3.3 函数返回值

函数的参数可以视为是函数的 “输入”, 则函数的返回值, 就可以视为是函数的 “输出”

如下代码：

# 定义求和函数
def add(a, b):
    return a + b


ret = add(5, 6)
print(ret)

上述代码就使用了函数的返回值

支持一次返回多个值，这是Python所特有的！！！

# 定义求和函数
def add_sub(a, b):
    return a + b, a - b


sum, sub = add_sub(5, 6)
print(sum,sub)

运行结果：

使用 _ 来忽略不想要的返回值.

# 定义求和函数
def add_sub(a, b):
    return a + b, a - b

#使用_来进行占位，表示不接收第一个返回值
_, sub = add_sub(5, 6)
print(sub)

使用_来占位，只接受一个返回值

3.4 变量作用域

在Python中：
在函数内部的变量, 也称为 “局部变量”
不在任何函数内部的变量, 也称为 “全局变量”
变量只能在所在的函数内部中生效，出了函数变量就销毁了！

如下示例：

def getPoint():
    x = 10
    y = 20
    return x, y
getPoint()
print(x, y)

这段代码，编译器提醒我们x,y未定义

在不同的作用域中，允许存在同名变量

x = 20
def test():
    x = 10
    print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}')

只要在不同的作用域中，变量可以同名

如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明：

x=10
def fun():
    #告诉函数，这个x是全局变量
    global x
    x = 20


fun()
print(x)

通过global声明，函数也能修改全局变量的值啦

注意：

if ,for ,while 语句的语句块不会影响到变量的作用域
换言之，for语句定义的变量i,在for语句外，也能使用。

示例：

for i in range(1,4):
    print(f'函数内部 i = {i}')
print(f'函数外部 i = {i}')

3.5 函数递归

递归是嵌套调用中的一种特殊情况, 即一个函数嵌套调用自己.

递归示例：

def factor(n):
    if n == 1:
        return 1
    return n * factor(n - 1)
result = factor(5)
print(result)

注意：

• 存在递归结束条件. 比如 if n == 1 就是结束条件. 当 n 为 1 的时候, 递归就结束了.
• 每次递归的时候,要保证函数的实参是逐渐逼近结束条件的

上述代码是经典的递归函数

3.6 参数默认值

Python 中的函数, 可以给形参指定默认值.
带有默认值的参数, 可以在调用的时候不传参.

代码示例：

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y
print(add(10, 20))
print(add(10, 20, True))

此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.

带有默认值的参数需要放到没有默认值的参数的后面：

def add(x, debug=False, y):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y
print(add(10, 20))

多个带有默认参数的形参，都得放在后面

3.7 关键字参数

在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的.
但是我们也可以通过关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参。

代码示例：

def fun(x, y):
    print(f'x={x}')
    print(f'y={y}')


fun(10,20)
fun(y=10,x=20)

关键字参数也是Python特有的功能，这样可以方便的告诉程序员，这个函数要赋给谁。位置参数和关键字参数还能混着用，只不过混着用的时候，要求位置参数在前，关键字参数在后。

4 列表和元组

列表可以认为是Python里的数组，并且功能更丰富简便！

4.1 列表

4.1.1 创建列表

创建列表主要有两种方式. [ ] 表示一个空的列表。类型为：list

定义示例：

#定义一个列表a和一个列表b
a = []
b = list()
print(type(a))
print(type(b))

定义示例：可以直接用print打印列表

a = [1, 2, 3, 4]
print(a)

列表可以存放不同类型的元素，如下代码：

a = ['a', 1, "hello"]
print(a)

4.1.2 访问下标

可以通过下标访问操作符 [ ] 来读取或修改列表中的任意元素.

演示示例：

#定义列表a
a = [1, 2, 3, 4]
#取下标为1的元素
print(a[1])
#将下标为1的元素修改为0
a[1] = 0
print(a)

上述代码使用[]，访问了下标为1的元素，并将其修改为0。

访问下标超出列表的范围会抛异常：

a = [1, 2, 3, 4]
print(a[100])

访问下标支持负数访问：

a = [1, 2, 3, 4]
#访问倒数第一个元素
print(a[-1])

4.1.3 切片操作

通过切片，一次取出一组连续的元素，相当于得到一个子列表。
使用 [ : ]的方式进行切片。
例如a[1:3]表示的是[1，3）的左闭右开区间的元素。并且支持省略前后边界。

代码演示：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#对部分元素切片
print(a[5:7])
#省略前半部分
print(a[:3])
#省略后半部分
print(a[6:])
#省略所有
print(a[:])

还可以指定第三个参数，‘步长’，并且‘步长可以为负数’：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#步长为2
print(a[0:5:2])
#步长为3
print(a[::3])
#步长为4
print(a[::4])

#步长为负数
print(a[::-2])
print(a[::-3])

切片越界也不会有负面效果，会输出可能包括的所有元素：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(a[5:100])
print(a[200:300])

切片是个很高效的操作，进行切片的时候，只是取出了原有列表的一个部分，并不涉及到数据的‘拷贝’

4.1.4 遍历列表

使用for或while遍历列表

#最简便的遍历，依次取出各个元素的值，并打印
a = [1, 2, 3, 4]
for elem in a:
    print(elem)

#生成下标再访问
for i in range(0,len(a)) :
    print(a[i])


#按下标范围遍历，手动控制下标变化
i=0
while i<len(a):
    print(a[i])
    i+=1

---

列表遍历进阶

链接: list遍历进阶，转载地址

4.1.5 列表元素操作

append:向链表末尾插入一个元素（尾插）
insert:向任意位置插入一个元素。
in :查找元素是否在列表里，返回值是布尔类型。
not in :元素是否不在列表里面。
index():查找元素在列表中的下标。
pop :直接删除末尾元素(尾删)或者按下标来删除元素。
remove：按照值来删除元素。

操作演示：

a = ['zhangsan', 'lisi', 'wangwu']
print(f'原列表a={a}')

#向链表末尾插入一个元素
a.append('zhaoliu')
print(f'尾插后a={a}')

#向第一个位置插入一个元素
a.insert(1,'heihei')
print(f'第一个位置插入后a={a}')

#查找元素是否在列表里
print('zhangsan' in a)
print('zhangsan' not in a)
#查找元素，如果在列表里返回下标，不在抛异常
print(f'查找下标为：{a.index("zhangsan")}')

#尾删
a.pop()
print(f'尾删后a={a}')

#指定下标删除
a.pop(1)
print(f'删除第一个位置后a={a}')

#按照值来删除元素
a.remove('lisi')
print(f'删除"lisi"后a={a}')

4.1.6 列表拼接操作

+ :把两个列表拼接起来，生成一个新列表（不改变原来的列表）。
extend ：相当于把列表拼接到另一个列表的后面（直接在原来的列表上拼接）

# +不改变原来的列表，会生成新的列表
a =[1, 2, 3, 4]
b= [5, 6]
print(a+b)
print(a)
print(b)


#extend会在原来的基础上扩大列表
a = [1, 2, 3, 4]
b = [5, 6]
a.extend(b)
print(a)

4.2 元组

元组的功能和列表相比，基本一致（用[]来进行访问）。只不过元组不能修改里面的元素, 列表则可以修改里面的元素

元组定义：

atuple = ( )
atuple = tuple()

像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的.
但是, 像写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持.

4.3 字典

字典是一种存储键值对的结构。
把键(key)和值(value)进行一个一对一的映射, 然后就可以根据键, 快速找到值。

4.3.1 创建字典

创建一个空字典，使用{key:value}表示字典（dict）。

创建一个空字典：

a = {}
b = dict()
print(a)
print(b)

创建的时候为元组指定初始值：

a = {'id': 12345, 'score': 100, 'name': 'xiaoming'}
print(a)


# 为了代码更美观，可以这样写
a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

键值对之间使用逗号分割, 键和值之间使用冒号（:）分割. (冒号后面推荐加一个空格).

4.3.2 查找key

使用 in 可以判定 key 是否在字 中存在。返回布尔值

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

print('id' in a)
print('id' not in a)

使用方括号[]，来访问元组的元素：

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }
#用键访问字典中的值
print(a['id'])
print('name')

如果要访问的key不在字典中，则会抛异常。

4.3.3 新增/修改元素

使用[ ] 可对字典中的数据修改，若字典中有该数据，则直接修改。若没有该数据，则在字典中新插入一个数据。

代码示例：

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

#元组中有该数据，直接修改
a['id'] =11111
print(a)
#元组中无该数据，直接添加键值对
a['tele'] = 88888888
print(a)

4.3.4 删除元素

使用pop根据key删除对应键值对

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

print(a)
#删除key ='id'的键值对
a.pop('id')
print(a)

4.3.5 遍历字典元素

直接使用 for 循环能够获取到字典中的所有的 key, 进一步的就可以取出每个值了.

代码示例：

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

for key in a:
    print(key,a[key])

字典特有操作：

• 使用 keys 方法可以获取到字典中的所有的 key
• 使用 values 方法可以获取到字典中的所有 value
• 使用 items 方法可以获取到字典中所有的键值对.
• 字典还可以当作函数的参数去传递，具体内容点链接查看

代码示例：

a = {'id': 12345,
     'score': 100,
     'name': 'xiaoming'
     }

print(a.keys())
print(a.values())
print(a.items())

4.3.6 合法的key(可哈希的key)

不是所有的类型都可以作为字典的 key.
字典本质上是一个哈希表, 哈希表的 key 要求是 “可哈希的”, 也就是可以计算出一个哈希值。

但凡能够计算出哈希的值的元素，都可以作为字典的key：

print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash(()))         # ( ) 是一个空的元组

列表和字典不可作为字典的key

5. 文件操作

5.1 打开文件

使用内建函数 open打开文件
f = open(‘d:/test.txt’, ‘r’)
1.第一个参数是一个字符串, 表示要打开的文件路径
2.第二个参数是一个字符串, 表示打开方式. 其中 r 表示按照读方式打开. w 表示按照写方式打开. a表示追加写方式打开.
如果打开文件成功, 返回一个文件对象f. 后续的读写文件操作都是围绕这个文件对象展开.
如果打开文件失败(比如路径指定的文件不存在), 就会抛出异常.

#打开文件
f = open('E:/text.txt', 'r')

f.close()

5.2 关闭文件

当我们不使用文件时，我们要讲文件关闭！
使用f.close关闭文件。

一个程序能打开文件的数量是有上限的：

flist = []
count = 0
while True:
    f = open('E:/text.txt', 'r')
    flist.append(f)
    count += 1
    print(f'count = {count}')

可以看出，当文件打开到一定数量的时候，就会抛异常

5.3 写文件

文件打开之后就可以写文件了
使用f.write的方法写文件

# 以写的方式打开文件    
f = open('E:/text.txt', 'w')
f.write('hello\n')
f.write('world !')
f.close()

换行也可以写进去

追加写：

由于每次使用 w 方式打开文件，每次都会清空文件，因此我们追加数据时用 a 来打开文件

# 以写的方式打开文件
f = open('E:/text.txt', 'w')
f.write('hello\n')
f.write('world !')
f.close()
#以追加的方式打开文件，不清空数据
f = open('E:/text.txt', 'a')
f.write('haha')
f.close()

5.4 读文件

读文件需要使用 r 的方式打开文件
使用f.read()方法完成读文件，参数表示读几个字符。

读字符文档：

# 以读的方式打开文件
f = open('E:/text.txt', 'r')
#读两个字符
a = f.read(2)
print(a)

读中文文档：

因为中文的编码有好几种，比较常见的就是GBK或者UTF-8，为了防止编码错误，我们需要对open函数输入第三个关键字参数，指定一下打开格式：

# 以读的方式打开文件
f = open('E:/text.txt', 'r',encoding='utf8')
#读十个字符
a = f.read(10)
print(a)
f.close

5.5 上下文管理器

防止我们忘记关闭文件，python提供了上下文管理器，来帮助我们自动关闭文件

• 使用 with 语句打开文件.
• 当 with 内部的代码块执行完毕后, 就会自动调用关闭方法

with open('d:/test.txt', 'r', encoding='utf8') as f:
    lines = f.readlines()
    print(lines)

以上是Python基础知识部分介绍，后续会继续补充，如有问题，恳请大佬指点💖