基于Orangepi全志H616学习Python3

环境搭建：（备注：在香橙派 3.0.6版本的镜像里已经默认自带了python3.10的版本，不需要安装，只需要后续安装下python3 dev即可，后续统一采用Orangepizero2_3.0.6_ubuntu_jammy_desktop_xfce_linux5.16.17的系统镜像）

1、查看当前Linux下自带的Python版本
python --version
    
2、更新Linux源
sudo apt update
    
3、安装Python所需要的环境-代码如下（通用代码：树莓派、全志、Linux均适用）
sudo apt install -y build-essential zlib1g-dev \
libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev \
libreadline-dev libffi-dev curl libbz2-dev
    
4、载python3.9源码压缩包
wget \
https://www.python.org/ftp/python/3.9.10/Python-3.9.10.tgz

5、解压包
tar xvf Python-3.9.10.tgz
    
6、进入python文件操作-配置
./configure --enable-optimizations
    
7、查看创建好的Makefile文件
vi Makefile
    
8、编译(大概35分钟)
make -j4
    
9、安装
sudo make install
    
10、查看python安装路径
/usr/local/bin

11、可以查看到其他路径下的python版本
which python

12、可以将python2.7版本删除
sudo rm -f /usr/bin/python

13.建立一个软链接专门指向python3.9
sudo ln -s /usr/local/bin/python3.9 /usr/bin/python

14.更新源
sudo apt install -y python-pip python3-pip

15.更新源(返回主目录下再操作)
mkdir .pip 建立pip工作文件夹

cd .pip

vi pip.conf 添加 pip 服务器配置文件

内容如下：
[global]
timeout = 6000
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn

到这里pytnon就安装完成了，安装好之后输入python指令进入python的命令行模式

三、Python的基础学习

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

系统学习Python3Python 基础教程 | 菜鸟教程 (runoob.com)]()Python3课程内容地址如下：

https://www.runoob.com/python/python-tutorial.html

3.1 Python的特点：

Python 是一种广泛使用的高级编程语言，以其简洁、易读和强大的功能而著称。以下是 Python 的一些主要特点：

易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
易于阅读：Python代码定义的更清晰。
易于维护：Python的成功在于它的源代码是相当容易维护的。
一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
数据库：Python提供所有主要的商业数据库的接口。
GUI编程：Python支持GUI可以创建和移植到许多系统调用。
可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

综上所述，Python 是一种功能强大、易于学习且应用广泛的编程语言，它的这些特点使得它成为许多程序员的首选语言。

3.2 编写并运行第一个Python程序：

首先我们创建一个Python的文件夹，我们在这个文件夹下创建第一个python代码文件：hello.py，其实linux系统不是很关心文件的后缀名，py也行，其他也行，但是为了格式还是写成py最好

## hello.py

print("linux C python")

我们写完代码保存退出后，输入：python hello.py运行程序，我们可以看到打印了一句linux C python

#! /usr/bin/python

print("linux C python")

如果我们在hello.py程序开头就指定了解释器，并赋予这个程序一个运行权限，那么就可以直接使用：./hello.py来运行程序

#! /usr/bin/python
# -* - coding: UTF-8 -* -

print("linux C python")
print("石亚豪很帅！")

如果我们在hello.py程序开头加上了：# -* - coding: UTF-8 -* -，则可以支持中文显示，所以py程序的开头就默认这两句话

3.3 标识符：

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

3.4 关键字：

Python关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

import keyword
keyword.kwlist
    
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

3.5 注释：

3.6 行与缩进：

3.7 多行语句：

3.8 数字类型：

python中数字有四种类型：整数、布尔型、浮点数和复数。

int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j

3.9 字符串（String）:

3.9.1 Python访问字符串中的值：

#!/usr/bin/python3
 
str='123456789'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第六个的字符（不包含）
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

3.9.2 字符串拼接：

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

str = "Hello World!"
print("原先的字符串是：",str)

print("更新字符串后：",str[:6] + 'Python')

3.10 空行：

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。

3.11 获取用户输入：

#! /usr/bin/python
# -* - coding: UTF-8 -* -

str = input("请输入任何字符：")         # 输入字符串
print("您输入的字符是：",str)           # 输出字符串

3.12 print输出和input输入：

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

print("欢迎来到我的Python世界！")            # 输出欢迎语

# 输入一个整数  
num = input("请输入一个整数：")              # 输入整数时，不要加引号
print("你输入的整数是：", num)  

# 输入一个浮点数                    
float_num = input("请输入一个浮点数：")      # 输入浮点数时，不要加引号
print("你输入的浮点数是：", float_num)  

# 输入一个字符串  
string = input("请输入一个字符串：")         # 输入字符串时，不要加引号
print("你输入的字符串是：", string)

# 输入多个值  
a = input("请输入第一个数字：")
b = input("请输入第二个数字：")
c = input("请输入第三个数字：")

a = int(a)                                  # 将输入的字符转换为整数
b = int(b)                                  # 将输入的字符转换为整数
c = int(c)                                  # 将输入的字符转换为整数
ret = a + b + c                             # 计算三个数字的和

print("第一个数字是：", a)
print("第二个数字是：", b)
print("第三个数字是：", c)
print("三个数字的和是：",ret)

3.13 运算符：

3.14 流程控制：

if_else:

if (表达式) :
  语句1
else :
  语句2

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

data = True

if data == True:
    print("data is True")
else:
    print("data is False")

if_else嵌套:

if (表达式) :
  语句1
elif (表达式) :
  语句2
…
elif (表达式) :
  语句n
else :
  语句m

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

num = 10
if num > 0:
    print("num = 10")
elif num < 0:
    print("num < 0")
else:
    print("num = 0")

match_case：

在Python中，直到Python 3.10之前，并没有内置的match...case语法，这是在其他一些现代编程语言（如Rust、Scala、Swift等）中常见的模式匹配特性。不过，Python社区经常使用一系列的if-elif-else语句或者更高级的库（如dataclasses配合match库，虽然这不是Python标准库的一部分）来模拟模式匹配的行为。

但是，从Python 3.10开始，Python引入了结构化模式匹配（Structural Pattern Matching），这意味着Python现在有了自己的match...case语法。这个新特性允许根据值的结构来执行不同的代码块，与前面提到的其他语言中的模式匹配非常相似。

下面是Python 3.10及以上版本中match...case的一个基本示例：

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

num = int(input("请输入一个整数: 0-5"))

match num:
    case 0:
        print("你输入的数字是0")
    case 1:
        print("你输入的数字是1")
    case 2:
        print("你输入的数字是2")
    case 3:
        print("你输入的数字是3")
    case 4:
        print("你输入的数字是4")
    case 5:
        print("你输入的数字是5")
    case _:
        print("输入错误！请输入0-5之间的整数")

3.15 循环：

while循环：

while 判断条件(condition)：
    执行语句(statements)……

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

count = 0

while count < 9:
    print("The count is:", count)
    count = count + 1

print("Good bye!")

while循环使用else语句：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
    
expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

count = 0

while count < 5:
    print("count < 5")
    count = count + 1
else:
    print("count = 5 || count > 5")

无限循环：

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

num = 1

while num == 1:                             # 循环条件为num等于1
    data = int(input("请输入一个整数:"))     # 输入一个整数
    print("你输入的整数是:", data)           # 输出输入的整数
    if data == 0:                           # 如果输入的整数为0，则退出循环
       exit()                               # 退出循环

print("程序结束")

for循环:

for 变量 in 集合 :
   …
else : #一般不用
   …

#! /usr/bin/python                          # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                   # 定义文件编码为UTF-8

str = 'china'

for letter in str:                                                              # 遍历字符串中的每一个字母
    print(letter)                                                               # 输出字母

city = ['beijing', 'shanghai', 'guangzhou', 'shenzhen']                         # 定义列表

for place in city:                                                              # 遍历列表中的每一个元素
    print(place)                                                                # 输出元素

print('Done!')                                                                  # 输出Done!

3.16 列表：

3.16.1 访问列表中的值：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

arrey = ['red', 'green', 'blue', 'yellow', 'white', 'black']            # 创建数组

print(arrey)                                                            # 输出数组
print(arrey[0])                                                         # 输出数组第一个元素
print(arrey[1])                                                         # 输出数组第二个元素
print(arrey[2])                                                         # 输出数组第三个元素

3.16.2 从列表尾部访问列表的值：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

arrey = ['red', 'green', 'blue', 'yellow', 'white', 'black']            # 创建数组

print(arrey[-1])                                                        # 输出数组最后一个元素
print(arrey[-2])                                                        # 输出数组倒数第二个元素    
print(arrey[-3])                                                        # 输出数组倒数第三个元素

3.16.3 使用下标索引来访问列表的值：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

arrey = [10, 20, 30, 40, 50, 60, 70, 80, 90]                            # 定义一个数组

print("原始数组：", arrey)                                               # 输出原始数组
print(arrey[2:7])                                                       # 输出数组的第三个元素到第七个元素

3.16.4 更新列表：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

list = ['Google', 'Runoob', 1997, 2000]                                 # 创建列表

print ("第三个元素为 : ", list[2])                                       # 输出第三个元素
list[2] = 2001                                                          # 更新第三个元素
print ("更新后的第三个元素为 : ", list[2])                                # 输出更新后的第三个元素

list1 = ['Google', 'Runoob', 'Taobao']                                  # 创建列表  
list1.append('Baidu')                                                   # 在列表末尾添加元素 
print ("更新后的列表 : ", list1)                                         # 输出更新后的列表

3.16.5 删除列表元素：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
 
list = ['Google', 'Runoob', 1997, 2000]                                 # 定义列表
 
print ("原始列表 : ", list)                                              # 输出原始列表  
del list[2]                                                             # 删除第三个元素   
print ("删除第三个元素 : ", list)                                        # 输出删除第三个元素后的列表

3.17 元组：

3.17.1 访问元组：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
 
tup1 = ('Google', 'Runoob', 1997, 2000)                                 # 创建元组
tup2 = (1, 2, 3, 4, 5, 6, 7 )                                           # 创建元组
 
print ("tup1[0]: ", tup1[0])                                            # 输出元组的第一个元素
print ("tup2[1:5]: ", tup2[1:5])                                        # 输出元组的第二个至第五个元素

3.17.2 修改元组：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
 
tup1 = (12, 34.56)                                                      # 创建元组
tup2 = ('abc', 'xyz')                                                   # 创建元组
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2                                                     # 合并元组
print (tup3)                                                           # 输出元组

3.17.3 删除元组：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

str = ('Google', 'Runoob', 1997, 2000)                                  # 定义元组
 
print (str)                                                             # 输出元组 
del str                                                                 # 删除元组
print ("删除后的元组 str : ")                                             # 输出删除后的元组
print (str)                                                             # 输出删除后的元组

3.17.4 元组转换列表：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

str1 = ("one", "two", "three", "four", "five")                          # 定义元组str1
print("元组str1:",str1)                                                 # 输出元组str1

str2 = list(str1)                                                      # 将元组str1转换为列表str2
print("列表str2:",str2)                                                 # 输出列表str2

3.18 字典：

3.18.1 访问字典里的值：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

student = {'name': 'LiMing', 'age': 18, 'scoer': 98.5}                  # 创建字典

print("学生姓名：",student['name'])                                      # 输出字典中键为'name'的值
print("学生年龄：",student['age'])                                       # 输出字典中键为'age'的值
print("学生成绩：",student['scoer'])                                     # 输出字典中键为'scoer'的值

3.18.2 修改字典：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

student = {'name': 'LiMing', 'age': 18, 'scoer': 98.5}                  # 创建字典
print("修改前的字典：")                                                  # 输出提示信息
print(student)                                                          # 输出字典

student['name'] = 'ZhangSan'                                            # 修改字典元素
student['addr'] = '北京'                                                # 添加字典元素

print("修改后的字典：")                                                  # 输出提示信息
print(student)                                                          # 输出修改后的字典

print("学生姓名：",student['name'])                                      # 输出字典中键为'name'的值
print("学生年龄：",student['age'])                                       # 输出字典中键为'age'的值
print("学生成绩：",student['scoer'])                                     # 输出字典中键为'scoer'的值
print("学生地址：",student.get('addr','未知'))                           # 输出字典中键为'addr'的值，若不存在则返																			 回'未知'

3.18.3 删除字典：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

student = {'name': 'LiMing', 'age': 18, 'scoer': 98.5, 'addr': '北京'}  # 创建字典

print("删除前的字典：")                                                  # 输出删除前的字典
print("学生姓名：",student['name'])                                      # 输出字典中键为'name'的值
print("学生年龄：",student['age'])                                       # 输出字典中键为'age'的值
print("学生成绩：",student['scoer'])                                     # 输出字典中键为'scoer'的值
print("学生地址：",student.get('addr','未知'))                           # 输出字典中键为'addr'的值，若不存在则返回'未知'

del student['addr']                                                   # 删除字典中键为'addr'的值

print("删除后的字典：")                                                  # 输出删除后的字典
print("学生姓名：",student['name'])                                      # 输出字典中键为'name'的值
print("学生年龄：",student['age'])                                       # 输出字典中键为'age'的值
print("学生成绩：",student['scoer'])                                     # 输出字典中键为'scoer'的值
print("学生地址：",student.get('addr','未知'))                           # 输出字典中键为'addr'的值，若不存在则返回'未知'

3.19 函数：

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

3.19.1 定义一个函数：

/*函数定义语法*/

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

3.19.2 定义一个无参函数：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

def hello():                                                            # 定义hello()函数
    print("Hello, world!")                                              # 输出"Hello, world!"

hello()                                                                 # 调用hello()函数

3.19.3 定义一个有参函数：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

def max(a, b):
    if a > b:
        return a
    else:
        return b

a = 10
b = 20

print(max(a, b))

3.19.4 函数调用：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

def printStr(str):                                                      # 定义函数printStr
    print(str)                                                          # 打印传入的字符串
    return                                                              # 返回None

printStr("ShiYaHao handsome")                                           # 调用函数
printStr("没毛病666")                                                    #再次调用函数

3.19.5 python传入不可变参数：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

def func(a):                                                             # 定义函数func
    print("func函数内a = ", a)                                            # 输出参数a
    a = 100                                                              # 修改参数a
    print("func函数内修改后a = ", a)                                      # 输出修改后的参数a

a = 10                                                                  # 全局变量a
print("a = ", a)                                                        # 输出全局变量a
func(a)                                                                 # 调用函数func，传入参数a
print("a = ", a)                                                        # 输出全局变量a

3.19.6 python传入可变参数：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

def funcArrey(arrey):                                                   # 定义函数
    arrey[0] = 100                                                      # 修改数组元素
    print("修改后函数内取值：",arrey)                                    # 打印数组元素
    return 

arrey = [1, 2, 3, 4, 5]                                                 # 定义数组
print("修改前函数外取值：",arrey)                                         # 打印数组元素
funcArrey(arrey)                                                        # 调用函数
print("修改后函数外取值：",arrey)                                         # 打印数组

3.20 模块：

3.20.1 import语句：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
# Filename: support.py                                                  # 文件名

def print_func( par ):                                                  # 定义函数
    print ("Hello : ", par)                                             # 打印参数
    return                                                              # 返回None

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
# Filename: test.py                                                     # 文件名
 
# 导入模块
import support                                                          # 导入support模块
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")                                            # 调用support模块的print_func函数

3.20.2 from...import语句：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
# Filename: support.py                                                  # 文件名

def print_func( par ):                                                  # 定义函数
    print ("Hello : ", par)                                             # 打印参数
    return                                                              # 返回None

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8
# Filename: test2.py                                                    # 文件名

from support import print_func                                          # 导入support模块中的print_func函数

if __name__ == '__main__':                                              # 判断是否为主程序
    print_func("world!")                                                # 调用print_func函数输出字符串

3.21 文件：

3.21.1 打开和关闭文件：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

# 打开文件
fo = open("test.txt", "w")                                              # 打开文件test.txt，写入模式
print("文件名: ", fo.name)                                              # 打印文件名
print("是否已关闭: ", fo.closed)                                        # 打印文件是否已关闭
print("访问模式: ", fo.mode)                                            # 打印访问模式

# 关闭文件
fo.close()                                                             # 关闭文件
print("是否已关闭: ", fo.closed)                                        # 打印文件是否已关闭

open函数mode权限：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

3.21.2 文件写入：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

# 写入文件
fo = open("test.txt", "w")                                              # 打开文件test.txt，以写模式打开
fo.write("chenlichen handsome\n")                                       # 写入文件内容

# 关闭文件
fo.close()                                                             # 关闭文件

3.21.3 文件读取：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

#打开文件
fo = open("test.txt", "r")                                              # 以读方式打开文件

#读取文件内容
str = fo.read()                                                         # 读取文件内容
print("读取的文件内容为：", str)                                          # 打印文件内容

#关闭文件
fo.close()                                                              # 关闭文件

3.21.4 文件定位：

#! /usr/bin/python                                                      # 告诉系统使用Python解释器
# -* - coding: UTF-8 -* -                                               # 定义文件编码为UTF-8

#打开文件
fo = open("test.txt", "r+")                                              # 以读写方式打开文件
#读取文件内容  
str = fo.read(10)                                                        # 读取10个字符
print("读取的字符串为:", str)                                             # 输出读取的字符串

#查找当前位置
position = fo.tell()                                                     # 获取当前文件位置
print("当前文件位置为:", position)                                       # 输出当前文件位置

#把指针再次重新定位到文件开头
position = 0                                                            # 设置文件位置为0
fo.seek(position, 0)                                                    # 移动到文件开头

#读取文件内容
str = fo.read(10)                                                       # 读取10个字符
print("重新读取的字符串为:", str)                                         # 输出读取的字符串

#关闭文件
fo.close()                                                              # 关闭文件