全志H616开发学习笔记（八）：Python3快速入门

Python快速入门

由于项目（基于Linux的智能垃圾桶）需要涉及到一些图像处理和语音识别的算法，用Python处理起来比较方便，因此从这小节开始，简单学习一下Python的基础知识

一、Python3.9安装

orangepizero2提供的的Ubuntu镜像默认已经安装了python2.7版本，为了更优的性能，以3.9.10为例介绍安装过程

• 源码下载，wget https://www.python.org/ftp/python/3.9.10/Python-3.9.10.tgz （网络不好的情况下可以使用--no-check-certificate跳过SSL证书校验）

• 源码解压，配置编译选项./configure --enable-optimization

• make -j4命令编译，make install安装（此过程实质上是把编译好的文件拷贝到特定目录下，需要root权限）

• 默认使用python --version还是显示2.7.x，是因为/usr/bin/python目录下还是原来默认创建的指向老版本的软连接。如果我们要使用3.9版本的，就要指定使用python3（嫌麻烦可将此链接删除，替换为指向3.9版本python的链接）

• 安装一下pip，package installer for python：apt install python-pip python3-pip

• 最后设置一下pip依赖下载源地址：~/.pip/pip.conf

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

二、Python初识

Python是一种动态解释型的编程语言。Python可以在Windows、UNIX、MAC等多种操作系统上使用，也可以在]ava、.NET开发平台上使用

Python特性：

• 使用C语言开发，但不再有C语言中的指针等复杂的数据类型。
  具有很强的面向对象特性，而且简化了面向对象的实现。消除了保护类型、抽象类、接口等面向对象的元素。
• Python代码块使用空格或制表符缩进的方式分隔代码，缩进不匹配会导致语法错误或错误的执行逻辑默认缩进是4个字符但不强制要求，前后一致即可。
• Python仅有31个保留字，而且没有分号、begin、end等标记。
• Python是强类型语言，变量创建后会对应一种数据类型，出现在统一表达式中的不同类型的变量需要做类型转换。
• Python语句不需以;结尾

总而言之，课程不会太深入，像学shell脚本一样去学习就行了。学习资料方面，可以参考Python十分钟入门和Python基础教程。另外，Python内置的控制台help手册也可用于速查。

运行Python命令或文件执行的几种方式

1. 直接在Python控制台执行单条命令，适合对陌生命令的验证，或不涉及到文件等复杂操作等场景

2. 写好python文件，用python解释器运行，如：python hello.py（冷知识：python文件后缀名不重要）

3. 在python文件中手动指定解释器，编写好后授权，直接当成可执行文件运行：

   #!/usr/bin/python
   print('Hello, world! --from-python')

   chmod +x hello.py
   ./hello.py

4. 若想要在python控制台运行编写好的python文件，可使用exec(open(r"<path to script here>").read())命令。详见如何在Python控制台中运行带有选项的.py文件？

基本输入输出

• Python3输出：print(content)，注意如果是非Linux环境且设计中文输出，需加入# -*- coding: UTF-8 -*-指定编码，输出是自带换行的

• Python2输出：print content，若要在2.x版本中使用3.x版本的输出语法，则先from __future__ import print_function，输出默认换行，可使用print x,y同行输出，不同内容间可逗号连接同行输出print "dasds",xyz

• Python3.2：input(tip)，tip为提示信息可为空。不同内容间可逗号连接同行输出print ("dasds",xyz)

  Python3.2以上版本，input的返回值一律为字符串类型，如果想使用数字需使用int()或float()转换

• Python2输入：raw_input(content)，若要在2.x版本中使用3.x版本的输出语法，则先from __future__ import print_function

三、变量基础

Python中的变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。**元组和列表中的每个元素可以是不同类型**

变量赋值

• 直接使用等号，无需提前声明变量
• 使用=变量赋值，背后的机制是右边的变量值拷贝到一个临时内存空间，替换掉左边的变量值。两个变量交换值可使用(a,b)=(b,a)
• 可使用连等赋值a=b=c，也可多变量同时赋值a,b,c=1,2,3

标准变量类型

• Numbers（数字），分为int、float、long（3.x版本废除）、complex（复数，比如1+2j或complex(1,2)）

• String（字符串），由字母、数字和下划线组成

• List（列表），使用[]标识，通过下标读取

• Tuple（元组），使用()标识，与列表的区别在于内部一级元素不可重新赋值（若为嵌套的列表则不受此限，另外可以直接修改元组指向重新赋值），列表不受此限

• Dictionary（字典），除列表外python中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。两者的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

  字典用{}标识。字典由索引(key)和它对应的值value组成。key必须为字符串

字符串相关

• 字符串索引示意：默认从左0到右递增，或从右-1到左递减。

• 字符串截取：

  • 可直接使用索引获取对应下标字符
  • [a:b]表示截取下标a、b之间的内容
  • [:b]表示截取下标b（不包含）之前的内容，[a:]表示截取下标a（包含）之后的内容。[:]原样输出
  • [a:b:c]表示从a开始，以c为步长截取下标a、b之间的内容，取左不取右
  • a*n表示a重复输出n次，[a]*n返回n个重复a组成的数组，a+b表示两个字符串拼接
  • list和tuple同理

流程控制

if-else和while循环：

for循环：

for iterating_var in sequence:
   statements(s)
for iterating_var2 in range(start,end):
   statements(s2)

sequence指的是可遍历的序列，包括列表、元组、字符串、字典

上面这些语句都不用括号包围，True与False首字母大写！

如上所示，range函数取左不取右

pass语句：空语句，一般为了保持程序结构的完整性，充当占位的作用。

值得注意的是，在Python2.x版本中，空函数必须写pass语句，Python3.x中则可写可不写

四、Numbers

Python中的数字类型不允许重新赋值，也即如果改变Number类型的数值，将重新分配内存空间

前面提过，Number类型又分为四种

• Number对象直接通过=进行赋值

• 通过del语句进行删除：del var1[,var2[,var3[....,varN]]]];

• 类型转换：语法格式与C稍有不同，类型不用括号而原值用括号

  • int(x[,base])
  • long(x[,base])
  • float(x[,base])
  • complex(x[,base])，转复数
  • eval(str)，计算字符串形式的Python表达式的计算结果
  • repr(x)，x转化为表达式字符串或计算值的字符串形式
  • str(x)，x转化为str类型
  • tuple(x)，转化为元组类型

在Python中，与数学运算相关的函数都在math和cmath库中，比较常用的有这么一些：

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x[,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

除此之外还有如下函数可获取随机数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

另外，Python中有两个内置的数学常量pi和e，分别代表圆周率π（其他获取方式见Python获取pi值的五种方法）和自然常数e

五、Str

字符串的索引和截取前面提过，此处略去

1.转义字符\

转义字符	描述	实例
\(在行尾时)	续行符
\\	反斜杠符号	print("\\")
\'	单引号	print("\'")
\"	双引号	print("\"")
\a	响铃	print(“\a”) 执行后电脑有响声。
\b	退格(Backspace)	print("Hello \\b World!") : Hello World!
\000	空	print(“\000”)
\n	换行	print(“\n”)
\v	纵向制表符	print("Hello \\v World!")
\t	横向制表符	print("Hello \\t World!")
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
\f	换页	print("Hello \\f World!") 命令将在当前页面输出Hello，清屏并输出World
\yyy	输出八进制数ASCII码对应的字符，y 范围0~7 ，例如：\012 代表换行。	print("\\110\\145\\154\\154\\157\\40\\127\\157\\162\\154\\144\\41") Hello World!
\xyy	输出十六进制数ASCII码对应的字符，以 \x 开头，y 范围0-15，例如：\x0a 代表换行	print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other	其它的字符以普通格式输出

2.字符串运算

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符	描述	实例
+	字符串连接	a + b ： HelloPython
*	重复输出字符串	a*2 ： HelloHello
[]	通过索引获取字符串中字符	a[1]： e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4]： ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in a： True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )
%	格式化字符串

3.三引号"""

允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

三引号的出现极大地帮助了程序员，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐：

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

4.字符串内建函数

Python中的字符串内建函数约有四十多种，下面列举几个最常用的：

函数	描述
capitalize()	将字符串的第一个字符转换为大写
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数， 如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 suffix 结束， 如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束， 如果是，返回 True,否则返回 False。类似的有startwith
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中， 如果指定范围 beg 和 end ，则检查是否包含在指定范围内， 如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字 则返回 True，否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字 则返回 True, 否则返回 False。 类似的方法还有isdigit() islower() isnumeric() isspace() istitle()
join(seq)	以指定字符串作为分隔符， 将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
ljust(width[, fillchar])	返回一个原字符串左对齐, 并使用 fillchar 填充至长度 width 的新字符串， fillchar 默认为空格。rjust同理
lower()	转换字符串中所有大写字符为小写.
lstrip()	截掉字符串左边的空格或指定字符。rstipt()和strip()同理
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
replace(old, new [, max])	把 将字符串中的 old 替换成 new, 如果 max 指定，则替换不超过 max 次。
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始.
split(str=””, num=string.count(str))	以 str 为分隔符截取字符串， 如果 num 有指定值，则仅截取 num+1 个子字符串
swapcase()	将字符串中大写转换为小写，小写转换为大写
translate(table, deletechars=””)	根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()	转换字符串中的小写字母为大写
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

六、List

列表是Python中最基本的数据结构之一，常用的操作包括：

• 索引（正负下标访问）
• 切片（[:]取元素）
• 加（list.append(item)方法，在末尾追加元素）与删（del list[index]方法，删掉指定位置元素，后面的元素顺移）
• 乘（*n重复n次）
• 检查成员，包括对列表本身操作的函数和列表对象自身对成员使用的方法

除此之外，列表还支持嵌套、切片（索引方式与字符串一致）、拼接、列表间比较（operator模块的eq方法）

Python中常用的函数和方法一览表：

函数/方法	说明
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

七、Tuple

元组和列表类似，与列表的不同之处主要有两点：

1. 列表的元素可以修改，元组的子级元素不能修改（指向地址的内容不变）
2. 列表通过[]标识，元组通过()标识，在创建时只需要用逗号分隔开即可。

需要注意的是，当元组中只有一个元素时，需要在元素后面添加一个逗号，否则元组的类型将被识别为元素的类型

元组的访问、修改与删除

• 元组可通过下标索引访问，支持切片
• 元组内子级元素不允许修改（和删除），但支持连接组合、扩充
• 元组本身可通过del语句删除

元组内置函数

方法	描述	实例
len(tuple)	计算元组元素个数。	>>> tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’) >>> len(tuple1) 3 >>>
max(tuple)	返回元组中元素最大值。	>>> tuple2 = (‘5’, ‘4’, ‘8’) >>> max(tuple2) ‘8’ >>>
min(tuple)	返回元组中元素最小值。	>>> tuple2 = (‘5’, ‘4’, ‘8’) >>> min(tuple2) ‘4’ >>>
tuple(iterable)	将可迭代系列转换为元组。	>>> list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’] >>> tuple1=tuple(list1) >>> tuple1 (‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’)

八、Dict

Python中，字典是一种可变容器模型，可存储任意数据类型

赋值

整个字典以用括号{}包围，元素用key:value的形式表达，元素间用逗号隔开，通过key值作为索引访问，通过del语句删除元素，但字典之间不可扩充、拼接组合

关于字典的键

1. 字典中键必定是唯一的，但可以重复赋值，最终值的内容以最后一次赋值为准
2. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典相关函数与方法

Python字典包含了以下内置函数与方法：

函数/方法	描述/实例
len(dict)	计算字典元素个数，即键的总数。 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> len(tinydict) 3
str(dict)	输出字典，可以打印的字符串表示。 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> str(tinydict) “{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}”`
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> type(tinydict) <class ‘dict’>
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict	如果键在字典dict里返回true，否则返回false
dict.items()	以列表返回一个视图对象
dict.keys()	返回一个视图对象
dict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.values()	返回一个视图对象
pop(key[,default])	删除字典 key（键）所对应的值，返回被删除的值。
popitem()	返回并删除字典中的最后一对键和值。

九、函数

Python中函数整体还是和C语言一致的模块化编程思想，主要有

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

Python提供了许多内建函数，比如print()。但我们也可以自己创建函数，这叫做用户自定义函数。

函数定义

函数定义的基本语法格式：

def function(params):
    #todo1
    #todo2
    #……
    return xxx

函数调用

函数代码块结构定义好后直接通过函数名和参数调用，示例略

参数传递

在 python 中，类型属于对象，对象有不同类型的区分，而变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，**[1,2,3]** 是 List 类型，**”Runoob”** 是 String 类型。

变量 a 没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

  类似 C++ 的值传递，如整数、字符串、元组等，要么无法修改元素，要么修改代表重新生成

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

  类似 C++ 的引用传递，如列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

传递不可变对象实例：

可以看到，传入参数后虽然对形参进行了重新赋值，但是主函数里变量a并未发生变化

传递可变对象实例：

可以看到，在调用函数内外，参数内容是一致的，id也未发生变化。

几种正式参数类型

除了上面说的两种对象类型，在Python中一般将调用的参数叫做正式参数，共有以下几种正式参数类型：

• 必需参数，须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

• 关键字参数，和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

  #!/usr/bin/python3
   
  #可写函数说明
  def printinfo( name, age ):
     "打印任何传入的字符串"
     print ("名字: ", name)
     print ("年龄: ", age)
     return
   
  #调用printinfo函数
  printinfo( age=50, name="runoob" )

• 默认参数，指如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

  #!/usr/bin/python3
   
  #可写函数说明
  def printinfo( name, age = 35 ):
     "打印任何传入的字符串"
     print ("名字: ", name)
     print ("年龄: ", age)
     return
   
  #调用printinfo函数
  printinfo( age=50, name="runoob" )
  print ("------------------------")
  printinfo( name="runoob" )

• 不定长参数，指的是不向函数传递未命名的变量。下面的实例中，arg1是必需参数，vartuple为不定长参数，长度不定，在调用函数中以元组的形式处理

  #!/usr/bin/python3
   
  # 可写函数说明
  def printinfo( arg1, *vartuple ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     for var in vartuple:
        print (var)
     return
   
  # 调用printinfo 函数
  printinfo( 10 )
  printinfo( 70, 60, 50 )

  如果不定长参数使用两个*，则当作字典处理

• 不定长参数中的*如果单独出现，则后面的参数必须使用形式参数指定：

  #!/usr/bin/python
  def f(a,b,*,c):
       return a+b+c
  
  print(f(1,2,c=3))#正常输出
  print(f(1,2,3))#TypeError: f() takes 2 positional arguments but 3 were given

匿名函数

所谓匿名函数，指的是不使用 def 语句这样常规的形式定义一个函数，在Python中通常通过lambda来实现匿名函数

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• lambda 不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda函数的基本语法格式：

lambda [arg1 [,arg2,.....argn]]:expression

lambda函数可以直接赋值给一个变量，也可封装到函数体中，作为return值返回给调用函数（好处是可以通过相同的代码，传入不同的参数来创建不同的匿名函数：）：

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

十、模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

简单来说，就是把一些常用、通用的函数和变量，依据具体的使用用途、场景，集中放在独立的Python文件中，在具体使用时用import语句引入即可调用相应函数

如上图所示，using_sys.py文件中引入了sys模块并使用了sys.argv、sys.path两个变量。通过执行结果，我们得知Python解释器寻找模块的路径主要是当前目录、Python主目录（/usr/local/lib/python3.9）和shell变量PYTHONPATH中的目录。该实例中的sys模块即是该标准库提供的模块

如果是我们自己编写的模块要想import，则要么将其放到上面所述的标准库路径，要么与调用模块的Python文件置于同级目录

#fibo.py，用于斐波那契数列计算
def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()
 
def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

用下面的实例测试fibo模块的两个函数：

#!/usr/bin/python
import fibo
print(fibo.__name__)
fibo.fib(1000)
print(fibo.fib2(100))

fibo
1 1 23 5 8 13 21 34 55 89 144 233 377 610 987
[1,1,2,3,5,8,13,21,34,55,89]

按需引入

一般来说一个模块中包含的函数和变量是比较多的，我们并不一定都需要用到。在这个时候我们可以通过from ... import语句来具体指定要引入模块的哪些函数

这样做还有另一个好处：不需要像上面一样，使用外部方法时指定模块名，而是直接用引入时指定的名字即可：

from fibo import fib, fib2

print(fib2(100))

from ... import *与import ...的区别

*是常用的通配符，放在import语句中时将能够引入模块所有内容。那么，这两者之间有什么区别呢？

简单来说，from ... import引入的是绝对路径下的具体方法，后文中可直接使用方法名；而import ...则是引入某个模块（文件），使用的是“相对路径”，因此使用时还需要指定模块名，具体可参见菜鸟教程解析

十一、文件与File方法

Python中的文件处理相关操作与C语言类似（可参见Linux系统编程—文件篇），主要有以下几个要点：

1. open方法，在对文件进行处理的所有过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError

   使用open方法打开的文件对象，一定要使用close方法关闭

2. open方法有两个基本参数：文件名filename和打开模式mode，完整的语法格式为：

   open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   关于mode参数，主要有这些作用：指定文件操作的权限（如可读可写），指定打开文件的格式（如普通文本模式、二进制格式）、文件读写模式（追加、覆盖）

3. file对象，前面提到通过open方法创建。对象创建后，主要有如下常用的标准函数：

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

方法	描述
file.close()	关闭文件。关闭后文件不能再进行读写操作。
file.flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()	返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()	如果文件连接到一个终端设备返回 True，否则返回 False。
file.next()	Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])	读取整行，包括 “\n” 字符。
file.readlines([sizeint])	读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.seek(offset[, whence])	移动文件读取指针到指定位置
file.tell()	返回文件当前位置。
file.truncate([size])	从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
file.write(str)	将字符串写入文件，返回的是写入的字符长度。
file.writelines(sequence)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。