Python基础知识_0001

1.0 Python是一种怎样的语言

• Python是一门跨平台、开源、免费的解释型高级动态编程语言，支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，支持使用py2exe、pyinstaller或cx_Freeze工具将Python程序转换为二进制可执行文件。

• Python支持命令式编程（How to do）、函数式编程（What to do），完全支持面向对象程序设计，语法简洁清晰，拥有大量的几乎支持所有领域应用开发的成熟扩展库。

• 胶水语言：可以把多种不同语言编写的程序融合到一起实现无缝拼接，更好地发挥不同语言和工具的优势，满足不同应用领域的需求。

1.1 如何选择Python版本

• 3.x：必然的趋势，已经开始全面普及

• 启动“IDLE（Python GUI）”即可启动Python解释器并可以看到当前安装的Python版本号。

• 多版本共存与切换简便方法：修改系统环境变量path

  PIC_0001_Python3.5.2界面 PIC_0002_Python3.6.0界面 wChkJf.png

1.2 Python安装与简单使用

• 几个重要网址

  • Python官方主页--https://www.python.org/
    • Python帮助文档-https://www.python.org/doc/
      • Python3最新帮助文档中文版(3.8.5)-https://docs.python.org/zh-cn/3/
        • Python帮助文档历史版本列表-https://www.python.org/doc/versions/
    • Python追踪问题列表-http://bugs.python.org/
    • Python的安全漏洞披露政策-https://hackerone.com/python
    • 最新的python问题-http://stackoverflow.com/questions/tagged/python
    • 清华大学开源软件镜像站_主页 https://mirrors.tuna.tsinghua.edu.cn/
      • 清华大学开源软件镜像站_miniconda镜像下载地址

• 默认编程环境：IDLE

• 其他常用开发环境：

  • Eclipse+PyDev
    • pyCharm
    • wingIDE
    • Eric
    • PythonWin
    • Anaconda3：Jupyter Notebook、Spyder
    • zwPython
    • VS Code

• 在IDLE中，如果使用交互式编程模式，那么直接在提示符“>>>”后面输入相应的命令并回车执行即可，如果执行顺利的话，马上就可以看到执行结果，否则会抛出异常。交互模式下每次只能执行一条语句,直到再次出现提示符才能输入下一条语句

>>> 3+5     #交互模式下一次只能执行一条语句
8
>>> import math
>>> math.sqrt(9)      #直到再次出现提示符才能输入下一个语句
3.0
>>> 3*(2+6)
24
>>> 2/0   #代码出错会抛出异常
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    2/0
ZeroDivisionError: integer division or modulo by zero

>>> for i in range(5):
    print(i)              #交互模式下,复合语句需要按两次回车



0
1
2
3
4

• 在IDLE界面中使用菜单“File”==>“New File”创建一个程序文件，输入代码并保存为.py或.pyw文件。

  
  PIC_0003_IDE新建Py文件

• 使用菜单“Run”==>“Check Module”来检查程序中是否存在语法错误，或者使用菜单“Run”==>“Run Module”运行程序，程序运行结果将直接显示在IDLE交互界面上。

PIC_0004_检查Py文件

• 在有些情况下可能需要在命令提示符环境中运行Python程序文件。在“开始”菜单的“附件”中单击“命令提示符”，然后执行Python程序。假设有程序HelloWorld.py内容如下。

def main():
    print('Hello world')
                                    #说明：此处为空白行 建议保留 表示上面的函数已经编辑完毕
main()

PIC_0005_命令提示符环境

• 可以在资源管理器中切换至相应的文件夹并直接进入命令提示符环境。Shift+鼠标右键

  
  w9OHHO.png

• 在IDLE环境下比较常用的快捷键如下表所示：

  快捷键	功能说明
  Ctrl+Z	撤销
  Ctrl+A	全选
  Ctrl+C	复制
  Ctrl+V	粘贴
  Ctrl+X	剪切
  Alt+p	浏览历史命令（上一条）
  Alt+n	浏览历史命令（下一条）
  Ctrl+F6	重启Shell，之前定义的对象和导入的模块全部失效
  F1	打开Python帮助文档
  Alt+/	自动补全前面曾经出现过的单词，如果之前有多个单词具有相同前缀，则在多个单词中循环选择
  Ctrl+]	缩进代码块
  Ctrl+[	取消代码块缩进
  Alt+3	注释代码块
  Alt+4	取消代码块注释。
  Tab	补全单词

1.3 使用pip管理第三方包

• pip工具常用命令

pip命令示例	说明
pip download SomePackage[==version]	下载扩展库的指定版本，不安装
pip freeze [> requirements.txt]	以requirements的格式列出已安装模块
pip list	列出当前已安装的所有模块
pip install SomePackage[==version]	在线安装SomePackage模块的指定版本
pip install SomePackage.whl	通过whl文件离线安装扩展库
pip install package1 package2 ...	依次（在线）安装package1、package2等扩展模块
pip install -r requirements.txt	安装requirements.txt文件中指定的扩展库
pip install --upgrade SomePackage	升级SomePackage模块
pip uninstall SomePackage[==version]	卸载SomePackage模块的指定版本

• 在Windows平台上，如果在线安装扩展库失败，可以从 http://www.lfd.uci.edu/~gohlke/pythonlibs/ 下载扩展库编译好的.whl文件（注意版本，并且一定不要修改下载的文件名），然后在命令提示符环境中使用pip命令进行离线安装。例如：pip install Django-2.1.3-py3-none-any.whl

• 如果由于网速问题导致在线安装速度过慢的话，pip命令还支持指定国内的站点来提高速度，下面的命令用来从阿里云下载安装扩展库jieba，其他服务器地址可以自行查阅。pip install jieba -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com

• 如果遇到类似于“拒绝访问”的出错信息，需要在执行pip命令时增加选项--user，例如pip install jieba --user

1.4.1 Python的对象模型

• 对象是python语言中最基本的概念，在python中处理的一切都是对象。python中有许多内置对象可供编程者使用，内置对象可直接使用，如数字、字符串、列表、del等；非内置对象需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等。
• 常用内置对象

对象类型	类型名称	示例	简要说明
数字	int,float,complex	1234,3.14,1.3e5,3+4j	数字大小没有限制，内置支持复数及其运算
字符串	str	'swfu',"I'm student",'''Python''',r'abc',R'bcd'	使用单引号、双引号、三引号作为定界符，以字母r或R引导的表示原始字符串
字节串	bytes	b’hello world’以字母b引导，可以使用单引号、双引号、三引号作为定界符
列表	list	[1, 2, 3]，['a', 'b', ['c', 2]]	所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是任意类型
字典	dict	{1:'food' ,2:'taste', 3:'import'}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为“键:值”
元组	tuple	(2, -5, 6), (3,)	不可变，所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素的话，后面的逗号不能省略
集合	set,frozenset	{'a', 'b', 'c'}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素不允许重复;另外，set是可变的，而frozenset是不可变的
布尔型	bool	True, False	逻辑值，关系运算符、成员测试运算符、同一性测试运算符组成的表达式的值一般为True或False
空类型	NoneType	None	空值
异常	Exception、ValueError、TypeError		Python内置大量异常类，分别对应不同类型的异常
文件		f = open('data.dat', 'rb')	open是Python内置函数，使用指定的模式打开文件，返回文件对象
其他可迭代对象		生成器对象、range对象、zip对象、enumerate对象、map对象、filter对象等等	具有惰性求值的特点，除range对象之外，其他对象中的元素只能看一次
编程单元		函数（使用def定义）；类（使用class定义）； 模块（类型为module）	类和函数都属于可调用对象，模块用来集中存放函数、类、常量或其他对象

1.4.2 Python变量

• 在Python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于Python任意类型的对象。

# 例如语句
>>> x = 3                   # 凭空出现一个整型变量x
# 创建了整型变量x，并赋值为3，再例如语句
>>> x = 'Hello world.'      # 新的字符串变量，再也不是原来的x了
# 创建了字符串变量x，并赋值为'Hello world.'。

• Python属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言，变量的类型也是可以随时变化的。

>>> x = 3
>>> print(type(x))
<class 'int'>
>>> x = 'Hello world.'
>>> print(type(x))                 #查看变量类型
<class 'str'>
>>> x = [1,2,3]
>>> print(type(x))
<class 'list'>
>>> isinstance(3, int)             #测试对象是否是某个类型的实例
True
>>> isinstance('Hello world', str)
True

• 如果变量出现在赋值运算符或复合赋值运算符（例如+=、=等等）的左边则表示创建变量或修改变量的值，否则表示引用*该变量的值，这一点同样适用于使用下标来访问列表、字典等可变序列以及其他自定义对象中元素的情况。

>>> x = 3       #创建整型变量
>>> print(x**2)
9
>>> x += 6      #修改变量值
>>> print(x)    #读取变量值并输出显示
9
>>> x = [1,2,3] #创建列表对象
>>> x[1] = 5    #修改列表元素值
>>> print(x)    #输出显示整个列表
[1, 5, 3]
>>> print(x[2]) #输出显示列表指定元素
3

• 字符串和元组属于不可变序列，不能通过下标的方式来修改其中的元素值，试图修改元组中元素的值时会抛出异常。

>>> x = (1,2,3)
>>> print(x)
(1, 2, 3)

>>> x[1] = 5
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    x[1] = 5
TypeError: 'tuple' object does not support item assignment

• 在Python中，允许多个变量指向同一个值，例如：

>>> x = 3
>>> id(x)
1786684560
>>> y = x
>>> id(y)
1786684560

Pic_0007_x=3

• 然而，当为其中一个变量修改值以后，其内存地址将会变化，但这并不影响另一个变量，例如接着上面的代码再继续执行下面的代码：

>>> x += 6
>>> id(x)
1786684752
>>> y
3
>>> id(y)
1786684560

Pic_0008_x=9

• Python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一块内存地址。

>>> x = 3
>>> id(x)
10417624
>>> y = 3
>>> id(y)
10417624
>>> x = [1, 1, 1, 1]
>>> id(x[0]) == id(x[1])
True

• 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。
• Python具有自动内存管理功能，对于没有任何变量指向的值，Python自动将其删除。Python会跟踪所有的值，并自动删除不再有变量指向的值。因此，Python程序员一般情况下不需要太多考虑内存管理的问题。
• 尽管如此，显式使用del命令删除不需要的值或显式关闭不再需要访问的资源，仍是一个好的习惯，同时也是一个优秀程序员的基本素养之一。
• 在定义变量名的时候，需要注意以下问题：
  • 变量名必须以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义；
    • 变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）；
    • 不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字；
    • 不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义，可以通过dir(__builtins__)查看所有内置模块、类型和函数；
    • 变量名对英文字母的大小写敏感，例如student和Student是不同的变量。

1.4.3 数字

• 数字是不可变对象，可以表示任意大小的数字。

>>> a=99999999999999999999999999999999
>>> a*a
9999999999999999999999999999999800000000000000000000000000000001
>>> a**3
999999999999999999999999999999970000000000000000000000000000000299999999999999999999999999999999

• Python的IDEL交互界面可以当做简便计算器来使用。

>>> ((3**2) + (4**2)) ** 0.5
5.0

• Python中的整数类型可以分为：
  • 十进制整数如，0、-1、9、123
    • 十六进制整数，需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef
    • 八进制整数，只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如0o35、0o11
    • 二进制整数，只需要2个数字0、1来表示整数，必须以0b开头如，0b101、0b100
• 浮点数又称小数，例如：15.0、0.37、-11.2、1.2e2、314.15e-2 都是浮点数
• Python内置支持复数类型。

>>> a = 3+4j
>>> b = 5+6j
>>> c = a+b
>>> c
(8+10j)
>>> c.real        #查看复数实部
8.0
>>> c.imag        #查看复数虚部
10.0
>>> a.conjugate() #返回共轭复数
(3-4j)
>>> a*b           #复数乘法
(-9+38j)
>>> a/b           #复数除法
(0.6393442622950819+0.03278688524590165j)

• Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。

>>> 1_000_000
1000000
>>> 1_2_3_4
1234
>>> 1_2 + 3_4j
(12+34j)
>>> 1_2.3_45
12.345

1.4.4 字符串

• 用单引号、双引号或三引号界定的符号系列称为字符串
• 单引号、双引号、三单引号、三双引号可以互相嵌套，用来表示复杂字符串
  'abc'、'123'、'中国'、"Python"、'''Tom said, "Let's go"'''
• 字符串属于不可变序列
• 空字符串表示为''或 ""
• 三引号'''或"""表示的字符串可以换行，支持排版较为复杂的字符串；三引号还可以在程序中表示较长的注释。
• 字符串合并

>>> a = 'abc' + '123'     #生成新字符串
>>> x = '1234''abcd'
>>> x
'1234abcd'
>>> x = x + ',.;'
>>> x
'1234abcd,.;'
>>> x = x'efg'            #不允许这样连接字符串
SyntaxError: invalid syntax

• 字符串格式化

>>> a = 3.6674
>>> '%7.3f' % a
'  3.667'
>>> "%d:%c"%(65,65)
'65:A'
>>> """My name is %s, and my age is %d""" % ('Dong Fuguo',39)
'My name is Dong Fuguo, and my age is 39'

• 常用转义字符

转义字符	含义	转义字符	含义
\b	退格，把光标移动到前一列位置	|一个斜线\
\f	换页符	\’	单引号’
\n	换行符	\”	双引号”
\r	回车	\ooo	3位八进制数对应的字符
\t	水平制表符	\xhh	2位十六进制数对应的字符
\v	垂直制表符	\uhhhh	4位十六进制数表示的Unicode字符

• 转义字符用法

>>> print('Hello\nWorld')          #包含转义字符的字符串
Hello
World
>>> print('\101')                  #三位八进制数对应的字符
A
>>> print('\x41')                  #两位十六进制数对应的字符
A
>>> print('变量x\u4e0d\u5b58\u5728')   #四位十六进制数表示Unicode字符
变量x不存在

• 字符串界定符前面加字母r或R表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\。原始字符串主要用于正则表达式、文件路径或者URL的场合。

>>> path = 'C:\Windows\notepad.exe'
>>> print(path)                      #字符\n被转义为换行符
C:\Windows
otepad.exe
>>> path = r'C:\Windows\notepad.exe' #原始字符串，任何字符都不转义
>>> print(path)
C:\Windows\notepad.exe

1.4.5 运算符和表达式

“|”运算符的用途是计算“位或”

运算符	功能说明
+	算术加法，列表、元组、字符串合并与连接，正号
-	算术减法，集合差集，相反数
*	算术乘法，序列重复
/	真除法
//	求整商，但如果操作数中有实数的话，结果为实数形式的整数
%	求余数，字符串格式化
**	幂运算
<、<=、>、>=、==、!=	（值）大小比较，集合的包含关系比较
or	逻辑或
and	逻辑与
not	逻辑非
in	成员测试
is	对象同一性测试，即测试是否为同一个对象或内存地址是否相同
^、&、<<、>>、~	位异或、位与、左移位、右移位、位求反
&、	、^	集合交集、并集、对称差集
@	矩阵相乘运算符

• +运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接。

>>> [1, 2, 3] + [4, 5, 6]          #连接两个列表
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4,)                #连接两个元组
(1, 2, 3, 4)
>>> 'abcd' + '1234'               #连接两个字符串
'abcd1234'
>>> 'A' + 1                            #不支持字符与数字相加，抛出异常
TypeError: Can't convert 'int' object to str implicitly
>>> True + 3                        #Python内部把True当作1处理
4
>>> False + 3                      #把False当作0处理

• 星号乘法 运算符不仅可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行“星号乘法”运算时，表示对内容进行重复并返回重复后的新对象。

>>> 2.0 * 3                     #浮点数与整数相乘
6.0
>>> (3+4j) * 2                  #复数与整数相乘
(6+8j)
>>> (3+4j) * (3-4j)             #复数与复数相乘
(25+0j)
>>> "a" * 10                    #字符串重复
'aaaaaaaaaa'
>>> [1,2,3] * 3                 #列表重复
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1,2,3) * 3                 #元组重复
(1, 2, 3, 1, 2, 3, 1, 2, 3)

• Python中的除法有两种，“/”和“//”分别表示除法和整除运算。

>>> 3 / 5                     #两个整数进行真除法得到精确结果0.6，如果能整除，则结果数据类型为int类型，不能整除则结果数据类型为class 'float'
0.6
>>> 3 // 5                    #两个整数进行整除运算得到不大于真除法结果0.6的最大整数0,结果数据类型恒定为class 'int'
0
>>> 3.0 / 5                   #一个浮点数与一个整数进行真除法得到精确结果0.6,有浮点数参与的真除法运算结果数据类型恒定为class 'float'，
0.6
>>> 3.0 // 5                  #一个浮点数与一个整数进行整除运算得到比0.6小的最大整数0的单精度浮点数结果0.0,有浮点数参与的整除法运算结果数据类型恒定为class 'float'
0.0
>>> 13 // 10                  #两个整数进行整除运算得到不大于真除法结果1.3的最大整数1,结果数据类型恒定为class 'int'
1
>>> 10 // 5                   #两个整数进行整除运算得到不大于真除法结果2的最大整数2,结果数据类型恒定为class 'int'
2
>>> -13 // 10                 #两个整数进行整除运算得到不大于真除法结果-1.3的最大整数-2,结果数据类型恒定为class 'int'
-2

• %运算符除去可以用于字符串格式化之外，还可以对整数和浮点数计算余数。但是由于浮点数的精确度影响，计算结果可能略有误差。

>>> 3.1 % 2                   #对整数和浮点数计算余数
1.1
>>> 6.3 % 2.1                 #对浮点数和浮点数计算余数,由于是浮点数 计算结果可能略有误差，此时有误差
2.0999999999999996
>>> 6 % 2                     #对整数和整数计算余数,无误差
0
>>> 6.0 % 2                   #对浮点数和整数计算余数,由于是浮点数 计算结果可能略有误差，此时无误差
0.0
>>> 6.0 % 2.0                 #对浮点数和浮点数计算余数,由于是浮点数 计算结果可能略有误差，此时无误差
0.0
>>> 5.7 % 4.8                 #对浮点数和浮点数计算余数,由于是浮点数 计算结果可能略有误差，此时有误差
0.9000000000000004

• 关系运算符可以连用，一般用于同类型对象之间值的大小比较，或者测试集合之间的包含关系

>>> 1 < 3 < 5                       #等价于1 < 3 and 3 < 5
True
>>> 'Hello' > 'world'               #比较字符串大小
False
>>> [1, 2, 3] < [1, 2, 4]           #比较列表大小
True
>>> 'Hello' > 3                     #字符串和数字不能比较
TypeError: unorderable types: str() > int()
>>> {1, 2, 3} < {1, 2, 3, 4}        #测试是否子集
True

• 成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。

>>> 3 in [1, 2, 3]       #测试3是否存在于列表[1, 2, 3]中
True
>>> 5 in range(1, 10, 1) #range()是用来生成指定范围数字的内置函数
True
>>> 'abc' in 'abcdefg'   #子字符串测试
True
>>> for i in (3, 5, 7):  #循环，成员遍历,采用水平制表符分离每个显示的成员
    print(i, end='\t')

3 5 7

• 同一性测试运算符（identity comparison）is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。

>>> 3 is 3
True
>>> x = [300, 300, 300]
>>> x[0] is x[1]        #基于值的内存管理，同一个值在内存中只有一份
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y              #上面形式创建的x和y不是同一个列表对象
False

• 位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。

>>> 3 << 2    #把3左移2位,每左移一位就是右侧补0，相当于把原来值乘以2，每右移一位左侧补0，相当于把原来数据整除2
12
>>> 3 & 7     #位与运算，0
3
>>> 3 | 8     #位或运算
11
>>> 3 ^ 5     #位异或运算
6

PIC_0009_位运算法则

• 集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）。

>>> {1, 2, 3} | {3, 4, 5}         #并集，自动去除重复元素
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5}         #交集
{3}
>>> {1, 2, 3} ^ {3, 4, 5}         #对称差集
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5}         #差集
{1, 2}

• and和or具有惰性求值特点，只计算必须计算的表达式。

>>> 3>5 and a>3     #注意，此时并没有定义变量a
False
>>> 3>5 or a>3      #3>5的值为False，所以需要计算后面表达式
NameError: name 'a' is not defined
>>> 3<5 or a>3      #3<5的值为True，不需要计算后面表达式
True
>>> 3 and 5         #最后一个计算的表达式的值作为整个表达式的值
5
>>> 3 and 5>2
True
>>> 3 not in [1, 2, 3]   #逻辑非运算not
False
>>> 3 is not 5           #not的计算结果只能是True或False之一
True

• Python 3.5之后增加了一个新的矩阵相乘运算符@

>>> import numpy             #numpy是用于科学计算的Python扩展库
>>> x = numpy.ones(3)        #ones()函数用于生成全1矩阵
>>> m = numpy.eye(3)*3       #eye()函数用于生成单位矩阵
>>> m[0,2] = 5               #设置矩阵指定位置上元素的值
>>> m[2, 0] =3
>>> x @ m                    #矩阵相乘
array([ 6.,  3.,  8.])

• 逗号并不是运算符，只是一个普通分隔符。

>>> 'a' in 'b', 'a'
(False, 'a')
>>> 'a' in ('b', 'a')
True
>>> x = 3, 5
>>> x
(3, 5)
>>> 3 == 3, 5
(True, 5)
>>> x = 3+5, 7
>>> x
(8, 7)

• Python不支持++和--运算符，虽然在形式上有时候似乎可以这样用，但实际上是另外的含义。

>>> i = 3
>>> ++i                       #正正得正
3
>>> +(+3)                     #与++i等价
3
>>> i++                       #Python不支持++运算符，语法错误
SyntaxError: invalid syntax
>>> --i                       #负负得正
3
>>> -(-i)                     #与--i等价
3

• 在Python中，单个任何类型的对象或常数属于合法表达式，使用运算符连接的变量和常量以及函数调用的任意组合也属于合法的表达式。

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = a + b
>>> c
[1, 2, 3, 4, 5, 6]
>>> d = list(map(str, c))
>>> d
['1', '2', '3', '4', '5', '6']
>>> import math
>>> list(map(math.sin, c))
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586]
>>> 'Hello' + ' ' + 'world'
'Hello world'
>>> 'welcome ' * 3
'welcome welcome welcome '
>>> ('welcome,'*3).rstrip(',')+'!'
'welcome,welcome,welcome!'

1.4.6 常用内置函数

• 内置函数不需要导入任何模块即可使用
• 执行下面的命令可以列出所有内置函数:

>>> dir(__builtins__)                 #注意 函数名称前后均为双下划线

函数	功能简要说明
abs(x)	返回数字x的绝对值或复数x的模
all(iterable)	如果对于可迭代对象中所有元素x都等价于True，也就是对于所有元素x都有bool(x)等于True，则返回True。对于空的可迭代对象也返回True
any(iterable)	只要可迭代对象iterable中存在元素x使得bool(x)为True，则返回True。对于空的可迭代对象，返回False
ascii(obj)	把对象转换为ASCII码表示形式，必要的时候使用转义字符来表示特定的字符
bin(x)	把整数x转换为二进制串表示形式
bool(x)	返回与x等价的布尔值True或False
bytes(x)	生成字节串，或把指定对象x转换为字节串表示形式
callable(obj)	测试对象obj是否可调用。类和函数是可调用的，包含__call__()方法的类的对象也是可调用的
compile()	用于把Python代码编译成可被exec()或eval()函数执行的代码对象
complex(real, [imag])	返回复数
chr(x)	返回Unicode编码为x的字符
delattr(obj, name)	删除属性，等价于del obj.name
dir(obj)	返回指定对象或模块obj的成员列表，如果不带参数则返回当前作用域内所有标识符
divmod(x, y)	返回包含整商和余数的元组((x-x%y)/y, x%y)
enumerate(iterable[, start])	返回包含元素形式为(0, iterable[0]), (1, iterable[1]), (2, iterable[2]), ...的迭代器对象
eval(s[, globals[, locals]])	计算并返回字符串s中表达式的值
exec(x)	执行代码或代码对象x
exit()	退出当前解释器环境
filter(func, seq)	返回filter对象，其中包含序列seq中使得单参数函数func返回值为True的那些元素，如果函数func为None则返回包含seq中等价于True的元素的filter对象
float(x)	把整数或字符串x转换为浮点数并返回
frozenset([x]))	创建不可变的集合对象
getattr(obj, name[, default])	获取对象中指定属性的值，等价于obj.name，如果不存在指定属性则返回default的值，如果要访问的属性不存在并且没有指定default则抛出异常
globals()	返回包含当前作用域内全局变量及其值的字典
hasattr(obj, name)	测试对象obj是否具有名为name的成员
hash(x)	返回对象x的哈希值，如果x不可哈希则抛出异常
help(obj)	返回对象obj的帮助信息
hex(x)	把整数x转换为十六进制串
id(obj)	返回对象obj的标识（内存地址）
input([提示])	显示提示，接收键盘输入的内容，返回字符串
int(x[, d])	返回实数（float）、分数（Fraction）或高精度实数（Decimal）x的整数部分，或把d进制的字符串x转换为十进制并返回，d默认为十进制
isinstance(obj, class-or-type-or-tuple)	测试对象obj是否属于指定类型（如果有多个类型的话需要放到元组中）的实例
iter(...)	返回指定对象的可迭代对象
len(obj)	返回对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象和其他可迭代对象
list([x])、set([x])、tuple([x])、dict([x])	把对象x转换为列表、集合、元组或字典并返回，或生成空列表、空集合、空元组、空字典
locals()	返回包含当前作用域内局部变量及其值的字典
map(func, *iterables)	返回包含若干函数值的map对象，函数func的参数分别来自于iterables指定的每个迭代对象，
max(x)、 min(x)	返回可迭代对象x中的最大值、最小值，要求x中的所有元素之间可比较大小，允许指定排序规则和x为空时返回的默认值
next(iterator[, default])	返回可迭代对象x中的下一个元素，允许指定迭代结束之后继续迭代时返回的默认值
oct(x)	把整数x转换为八进制串
open(name[, mode])	以指定模式mode打开文件name并返回文件对象
ord(x)	返回1个字符x的Unicode编码
pow(x, y, z=None)	返回x的y次方，等价于x y或(x y) % z
print(value, ..., sep=' ', end='\n', file = sys. stdout, flush=False)	基本输出函数
quit()	退出当前解释器环境
range([start,] end [, step] )	返回range对象，其中包含左闭右开区间[start,end)内以step为步长的整数
reduce(func, sequence[, initial])	将双参数的函数func以迭代的方式从左到右依次应用至序列seq中每个元素，最终返回单个值作为结果。在Python 2.x中该函数为内置函数，在Python 3.x中需要从functools中导入reduce函数再使用
repr(obj)	返回对象obj的规范化字符串表示形式，对于大多数对象有eval(repr(obj))==obj
reversed(seq)	返回seq（可以是列表、元组、字符串、range以及其他可迭代对象）中所有元素逆序后的迭代器对象
round(x [, 小数位数])	对x进行四舍五入，若不指定小数位数，则返回整数
sorted(iterable, key=None, reverse=False)	返回排序后的列表，其中iterable表示要排序的序列或迭代对象，key用来指定排序规则或依据，reverse用来指定升序或降序。该函数不改变iterable内任何元素的顺序
str(obj)	把对象obj直接转换为字符串
sum(x, start=0)	返回序列x中所有元素之和，返回start+sum(x)
type(obj)	返回对象obj的类型
zip(seq1 [, seq2 [...]])	返回zip对象，其中元素为(seq1[i], seq2[i], ...)形式的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个

• dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。
• help()函数则返回指定模块或函数的说明文档。
• 内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。

>>> bin(555)                      #把数字转换为二进制串
'0b1000101011'
>>> oct(555)                      #转换为八进制串
'0o1053'
>>> hex(555)                      #转换为十六进制串
'0x22b'

• ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

>>> ord('a')                    >>> chr(65)
97                              'A'
>>> chr(ord('A')+1)             >>> str(1)
'B'                             '1'
>>> str(1234)                   >>> str([1,2,3])
'1234'                          '[1, 2, 3]'
>>> str((1,2,3))                >>> str({1,2,3})
'(1, 2, 3)'                     '{1, 2, 3}'

• max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

>>> import random
>>> a = [random.randint(1,100) for i in range(10)]   #列表推导式
>>> a
[72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
>>> print(max(a), min(a), sum(a))
86 19 548

• 如果需要计算该列表中的所有元素的平均值，可以直接这样用：

>>> sum(a)/len(a)
54.8

• 内置函数max()和min()的key参数可以用来指定比较规则。

>>> x = ['21', '1234', '9']
>>> max(x)
'9'
>>> max(x, key=len)
'1234'
>>> max(x, key=int)
'1234'

内置函数示例1

>>> from random import randrange
>>> x = [[randrange(1,100) for i in range(10)] for j in range(5)]
>>> for item in x:
 print(item)       #此处2次回车执行代码

[90, 12, 82, 48, 22, 43, 7, 44, 65, 49]
[34, 28, 80, 33, 19, 61, 91, 91, 5, 78]
[48, 21, 49, 20, 21, 91, 99, 40, 7, 30]
[19, 7, 11, 53, 67, 83, 95, 89, 5, 96]
[19, 27, 92, 40, 85, 77, 39, 24, 56, 23]
>>> max(x, key=sum)       #求所有元素之和最大的子列表
[19, 7, 11, 53, 67, 83, 95, 89, 5, 96]

• 内置函数sum()的start参数可以实现非数值型列表元素的求和。

>>> sum([1,2,3,4])
10
>>> sum([[1], [2], [3], [4]], [])
[1, 2, 3, 4]

• 内置函数type()和isinstance()可以判断数据类型。

>>> type([3])                        #查看[3]的类型
<class 'list'>
>>> type({3}) in (list, tuple, dict) #判断{3}是否为list,tuple
                                     #或dict类型的实例
False
>>> isinstance(3, int)               #判断3是否为int类型的实例
True
>>> isinstance(3j, (int, float, complex)) #判断3j是否为int,float
                                          #或complex类型
True

• sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> sorted(x, key=lambda item: (len(item), item))
                                #先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']

• reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> reversed(x)                 #逆序，返回reversed对象
<list_reverseiterator object at 0x0000000002E6C3C8>
>>> list(reversed(x))           #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']

• range()语法格式为range([start,] end [, step] )，返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。

>>> range(5)                  #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2))     #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2))     #步长为负数时，start应比end大
[9, 7, 5, 3, 1]

• enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>> list(enumerate('abcd'))                #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Greate']))  #枚举列表中的元素
[(0, 'Python'), (1, 'Greate')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items()))
                                           #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
>>> for index, value in enumerate(range(10, 15)):
                                      #枚举range对象中的元素
 print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)

• 内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。

>>> list(map(str, range(5)))  #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v):              #单参数函数
 return v+5
>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y):            #可以接收2个参数的函数
 return x+y
>>> list(map(add, range(5), range(5,10)))
                              #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]

PIC_0010_mapy原理图

自定义函数

>>> def myMap(iterable, op, value):  #自定义函数
    if op not in '+-*/':             #实现序列与数字的四则运算
        return 'Error operator'
    func = lambda i:eval(repr(i)+op+repr(value))
    return map(func, iterable)

>>> list(myMap(range(5), '+', 5))
[5, 6, 7, 8, 9]
>>> list(myMap(range(5), '-', 5))
[-5, -4, -3, -2, -1]
>>> list(myMap(range(5), '*', 5))
[0, 5, 10, 15, 20]
>>> list(myMap(range(5), '/', 5))
[0.0, 0.2, 0.4, 0.6, 0.8]

>>> import random
>>> x = random.randint(1, 1e30)     #生成指定范围内的随机整数
>>> x
839746558215897242220046223150
>>> list(map(int, str(x)))          #提取大整数每位上的数字
[8, 3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2, 2, 3, 1, 5, 0]

• 标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45

PIC_011

>>> import operator                         #标准库operator提供了大量运算
>>> operator.add(3,5)                       #可以像普通函数一样直接调用
8
>>> reduce(operator.add, seq)               #使用add运算
45
>>> reduce(operator.mul, seq)               #乘法运算
362880
>>> reduce(operator.mul, range(1, 6))       #5的阶乘
120
>>> reduce(operator.add, map(str, seq))     #转换成字符串再累加
'123456789'
>>> reduce(operator.add, [[1, 2], [3]], []) #这个操作占用空间较大，慎用
[1, 2, 3]

• 内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
 return x.isalnum()                   #测试是否为字母或数字

>>> filter(func, seq)                   #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq))             #把filter对象转换为列表
['foo', 'x41']

• zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。

  
  PIC_0012_ZIP压缩

>>> list(zip('abcd', [1, 2, 3]))             #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!'))           #压缩3个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

• map、filter、enumerate、zip等对象不仅具有惰性求值的特点，还有另外一个特点：访问过的元素不可再次访问。

  
  PIC_0013_易失性对象

>>> x = map(str, range(10))
>>> list(x)
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> list(x)
[]
>>> x = map(str, range(10))
>>> '2' in x
True
>>> '2' in x
False
>>> '8' in x
False

1.4.7 对象的删除

• 在Python中具有自动内存管理功能，Python解释器会跟踪所有的值，一旦发现某个值不再有任何变量指向，将会自动删除该值。
• 显式释放自己申请的资源是程序员的好习惯之一，也是程序员素养的重要体现之一。
• 在Python中，可以使用del命令来显式删除对象并解除与值之间的指向关系。删除对象时，如果其指向的值还有别的变量指向则不删除该值，如果删除对象后该值不再有其他变量指向，则删除该值。

>>> x = [1,2,3,4,5,6]
>>> y = 3
>>> z = y
>>> print(y)
3
>>> del y             #删除对象
>>> print(y)
NameError: name 'y' is not defined
>>> print(z)
3
>>> del z
>>> print(z)
NameError: name 'z' is not defined
>>> del x[1]          #删除列表中指定元素
>>> print(x)
[1, 3, 4, 5, 6]
>>> del x             #删除整个列表
>>> print(x)
NameError: name 'x' is not defined

• del命令无法删除元组或字符串中的元素，只可以删除整个元组或字符串，因为这两者均属于不可变序列。

>>> x = (1,2,3)
>>> del x[1]
Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    del x[1]
TypeError: 'tuple' object doesn't support item deletion
>>> del x
>>> print(x)
Traceback (most recent call last):
  File "<pyshell#64>", line 1, in <module>
    print(x)
NameError: name 'x' is not defined

1.4.8 基本输入输出

• 用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为：

x = input('提示：')

该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。

• 在Python 3.x中，input()函数用来接收用户的键盘输入，不论用户输入数据时使用什么界定符，input()函数的返回结果都是字符串，需要将其转换为相应的类型再处理。

>>> x = input('Please input:')
Please input:3
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:'1'
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:[1,2,3]
>>> print(type(x))
<class 'str'>

• Python 3.x中使用print()函数进行输出。

>>> print(3, 5, 7)
3 5 7
>>> print(3, 5, 7, sep=',')    #指定分隔符
3,5,7
>>> print(3, 5, 7, sep=':')
3:5:7
>>> for i in range(10,20):
 print(i, end=' ')           #不换行

10 11 12 13 14 15 16 17 18 19

• 在Python 3.x中则需要使用下面的方法进行重定向：

>>> fp = open(r'D:\mytest.txt', 'a+')
>>> print('Hello,world!', file = fp)
>>> fp.close()

或

>>> with open(r'D:\mytest.txt', 'a+') as fp:
 print('Hello,world!', file=fp)

1.4.9 模块导入与使用

• Python默认安装仅包含部分基本或核心模块，但用户可以安装大量的扩展模块，pip是管理模块的重要工具。
• 在Python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。
• 减小运行的压力，仅加载真正需要的模块和功能，且具有很强的可扩展性。
• 可以使用sys.modules.items()显示所有预加载模块的相关信息。
• import 模块名

>>>import math
>>>math.sin(0.5)             #求0.5的正弦
>>>import random
>>>x=random.random( )        #获得[0,1) 内的随机小数
>>>y=random.random( )
>>>n=random.randint(1,100)   #获得[1,100]上的随机整数

• 可以使用dir()函数查看任意模块中所有的对象列表，如果调用不带参数的dir()函数，则返回当前所有名字列表。

  • 可以使用help()函数查看任意模块或函数的使用帮助。

• from 模块名 import 对象名[ as 别名] #可以减少查询次数，提高执行速度

• from math import * #谨慎使用

>>> from math import sin
>>> sin(3)
0.1411200080598672
>>> from math import sin as f #别名
>>> f(3)
0.141120008059867

• 在2.x中可以使用reload函数重新导入一个模块，在3.x中，需要使用imp模块的reload函数。
• Python首先在当前目录中查找需要导入的模块文件，如果没有找到则从sys模块的path变量所指定的目录中查找。可以使用sys模块的path变量查看python导入模块时搜索模块的路径，也可以向其中append自定义的目录以扩展搜索路径。
• 在导入模块时，会优先导入相应的pyc文件，如果相应的pyc文件与py文件时间不相符，则导入py文件并重新编译该模块。
• 导入模块时的文件搜索顺序
• 当前文件夹
  • sys.path变量指定的文件夹
    • 优先导入pyc文件
• 如果需要导入多个模块，一般建议按如下顺序进行导入：
  • 标准库
    • 成熟的第三方扩展库
    • 自己开发的库

1.5 Python代码编写规范

1.5.1 缩进

• 类定义、函数定义、选择结构、循环结构、with块，行尾的冒号表示缩进的开始。
• python程序是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。
• 同一个级别的代码块的缩进量必须相同。
• 一般而言，以4个空格为基本缩进单位。

1.5.2 注释

• 以#开始，表示本行#之后的内容为注释。
• 包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。

1.5.3 模块导入顺序

• 每个import语句只导入一个模块，最好按标准库、扩展库、自定义库的顺序依次导入。

1.5.4 长代码换行

• 如果一行语句太长，可以在行尾加上续行符\来换行分成多行，但是更建议使用括号来包含多行内容。

1.5.5 必要的空格与空行

• 运算符两侧、逗号后面建议增加一个空格。
• 不同功能的代码块之间、不同的函数定义之间建议增加一个空行以增加可读性。

1.5.6 其他

• 可以使用pip来安装pep8工具，然后使用命令pep8 test.py来检查test.py文件中Python代码的规范性。pep8常用的可选参数有--show-source、--first、--show-pep8等等。

• flake8结合了pyflakes和pep8的特点，可以检查更多的内容，优先推荐使用，使用pip install flake8可以直接安装，然后使用命令flake8 test.py检查test.py中代码的规范性。

• 也可以使用pip安装pylint，然后使用命令行工具pylint或者可视化工具pylint-gui来检查程序的规范性。

• 适当使用异常处理结构进行容错

• 软件应具有较强的可测试性，测试与开发齐头并进。

1.6 python文件名

• .py：Python源文件，由Python解释器负责解释执行。
• .pyw：Python源文件，常用于图形界面程序文件。
• .pyc：Python字节码文件，无法使用文本编辑器直接查看该类型文件内容，可用于隐藏Python源代码和提高运行速度。对于Python模块，第一次被导入时将被编译成字节码的形式，并在以后再次导入时优先使用“.pyc”文件，以提高模块的加载和运行速度。对于非模块文件，直接执行时并不生成“.pyc”文件，但可以使用py_compile模块的compile()函数进行编译以提高加载和运行速度。另外，Python还提供了compileall模块，其中包含compile_dir()、compile_file()和compile_path()等方法，用来支持批量Python源程序文件的编译。
• .pyo：优化的Python字节码文件，同样无法使用文本编辑器直接查看其内容。可以使用“python –O -m py_compile file.py”或“python –OO -m py_compile file.py”进行优化编译。Python 3.5不再支持.pyo文件。
• .pyd：一般是由其他语言编写并编译的二进制文件，常用于实现某些软件工具的Python编程接口插件或Python动态链接库。

1.7 基本输入输出、模块对象导入

1.7.1 基本输入

• 用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为：x = input('提示：'),该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。
• 在Python 3.x中，input()函数用来接收用户的键盘输入，不论用户输入数据时使用什么界定符，input()函数的返回结果都是字符串，需要将其转换为相应的类型再处理。

>>> x = input('Please input:')
Please input:3
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:'1'
>>> print(type(x))
<class 'str'>
>>> x = input('Please input:')
Please input:[1,2,3]
>>> print(type(x))
<class 'str'>

1.7.2 基本输出

-Python 3.x中使用print()函数进行输出。

>>> print(3, 5, 7)
3 5 7
>>> print(3, 5, 7, sep=',')    #指定分隔符
3,5,7
>>> print(3, 5, 7, sep=':')
3:5:7
>>> for i in range(10,20):
    print(i, end=' ')          #不换行

10 11 12 13 14 15 16 17 18 19

• 试试下面的代码在命令提示符环境会有什么样的运行效果：

from time import sleep

for i in range(101):
    print(i, '%', end='\r')
    sleep(0.05)

1.7.3 模块导入与使用

• 说明
  • Python默认安装仅包含部分基本或核心模块，但用户可以安装大量的扩展模块，pip是管理模块的重要工具。
  • 在Python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。
  • 减小运行的压力，仅加载真正需要的模块和功能，且具有很强的可扩展性。
  • 可以使用sys.modules.items()显示所有预加载模块的相关信息。
  • ========================================
  • 可以使用dir()函数查看任意模块中所有的对象列表，如果调用不带参数的dir()函数，则返回当前作用域所有名字列表。
  • 可以使用help()函数查看任意模块或函数的使用帮助。
• 导入模块的几种方式：

  • import 模块名

      >>> import math
      >>> math.sin(0.5)               #求0.5的正弦
      >>> import random
      >>> x = random.random( )        #获得[0,1) 内的随机小数
      >>> y = random.random( )
      >>> n = random.randint(1,100)   #获得[1,100]上的随机整数
    

  • from 模块名 import 对象名[ as 别名] #可以减少查询次数，提高执行速度

    >>> from math import sin
    >>> sin(3)
    0.1411200080598672
    >>> from math import sin as f #别名
    >>> f(3)
    0.141120008059867
    

  • from math import * #谨慎使用

• 在2.x中可以使用reload函数重新导入一个模块，在3.x中，需要使用imp模块的reload函数。
• Python首先在当前目录中查找需要导入的模块文件，如果没有找到则从sys模块的path变量所指定的目录中查找。可以使用sys模块的path变量查看python导入模块时搜索模块的路径，也可以向其中append自定义的目录以扩展搜索路径。
• 在导入模块时，会优先导入相应的pyc文件，如果相应的pyc文件与py文件时间不相符，则导入py文件并重新编译该模块。
  • 导入模块时的文件搜索顺序
    • 当前文件夹
    • sys.path变量指定的文件夹
    • 优先导入pyc文件
• 如果需要导入多个模块，一般建议按如下顺序进行导入：
  • 标准库
  • 成熟的第三方扩展库
  • 自己开发的库

1.8 Python脚本的“__name__”属性

• 每个Python脚本在运行时都有一个“__name__”属性。
  • 如果脚本作为模块被导入，则其“__name__”属性的值被自动设置为模块名；
  • 如果脚本独立运行，则其“__name__”属性值被自动设置为“__main__”。

例如，假设文件nametest.py中只包含下面一行代码：print(__name__)

• 在IDLE中直接运行该程序时，或者在命令行提示符环境中运行该程序文件时，运行结果如下：__main__

• 而将该文件作为模块导入时得到如下执行结果：

  >>> import nametest
  nametest
  

• 利用“__name__”属性即可控制Python程序的运行方式。例如，编写一个包含大量可被其他程序利用的函数的模块，而不希望该模块可以直接运行，则可以在程序文件中添加以下代码：

if __name__ == '__main__':
    print('Please use me as a module.')

• 这样一来，程序直接执行时将会得到提示“Please use me as a module.”，而使用import语句将其作为模块导入后可以使用其中的类、方法、常量或其他成员。

1.9 编写自己的包与模块

• 在包的每个目录中都必须包含一个__init__.py文件，该文件可以是一个空文件，仅用于表示该目录是一个包。
• __init__.py文件的主要用途是设置all变量以及所包含的包初始化所需的代码。其中all变量中定义的对象可以在使用from …import *时全部正确导入。

1.10 Python程序伪编译与打包

• Python程序伪编译

  • 可以使用py_compile模块的compile()函数或compileall模块的compile_file()函数对Python源程序文件进行伪编译得到扩展名为.pyc的字节码以提高加载和运行速度，同时还可以隐藏源代码。
  • 假设有Python程序Stack.py文件，并已导入py_compile，那么可以使用语句py_compile.compile('Stack.py')把Stack.py伪编译为字节码，如果需要优化编译可以使用py_compile.compile('Stack.py', optimize=1)或py_compile.compile('Stack.py', optimize=2)生成不同优化级别的字节码文件。
  • 生成的字节码文件都保存为__pycache__文件夹中。

• Python程序打包

  • 可以把Python程序打包为可执行程序的工具有py2exe（仅适用于Windows平台）、pyinstaller、cx_Freeze等等。
  • 以pyinstaller为例，使用pip工具安装该工具之后在命令提示符环境中使用命令“pyinstaller -F -w kousuan.pyw”或者“python pyinstaller-script.py -F -w kousuan.pyw”即可将Python程序kousuan.pyw及其所有依赖包打包成为当前所用平台上的可执行文件。