搜索

【初学不要怕】教你全方位理解python模块与包的安装与使用（万字总结详解系列，一文就够了）

做一个柔情的程序猿

共 16316字，需浏览 33分钟

 · 2022-04-23


🚩python模块导入安装教程

以xlrd-0.9.4.tar.gz模块的安装为例

⭐️3.0以下版本的安装使用easy_install

导入带有setup.py的模块，需要使用到setuptools 的 easy_install 命令，安装setuptools 需要使用ez_setup.py

ez_setup.py是python官方给出的一个安装setuptools的工具，利用它，我们可以很轻松用命令行就自动完成安装过程，而之后，setuptools就可以派上用场了，安装步骤如下：

🍊1、电脑在安装了python的环境，进入python的官网下载工具，网址如下：

下载 ez_setup.py

找到ez_setup.py，点击右键--目标另存为，放在电脑任意位置都可以，为方便起见，放在了python的安装目录下（D:\Python27）（该路径需要根据自己选择的路径进行修改）

🍊2、在cmd命令行下进入ez_setup.py存放的路径，比如我是D:\Python27

  1. cmd: d:
  2. cd Python27
  3. python ez_setup.py

即可以出现以下界面安装setuptools成功，可以下载其他模块包

 

🍊3、为了方便可以设置python和easy_install的环境变量path，方便在cmd中调用python命令：

python的path： D:\Python27；

easy_install的path： D:\Python27\Scripts

🍊4、下载模块包，比如xlrd；设置好环境变量后只要在cmd中输入：easy_install xlrd，下载xlrd模块包

 

可以看到xlrd 版本为0.9.4，没有报错，存在位置可以看到在D:\Python27\Lib\site-packages

🍊5、模块下载成功后，运行安装即可cmd中进入D:\Python27\Lib\site-packages\xlrd-0.9.4

中运行 python setup.py install 安装

 

安装成功后可以在模块路径下看到xlrd模块文件夹安装出现，表示安装成功。

⭐️3.0以上版本的安装使用pip

pip 是一个安装和管理 Python 包的工具 , 是 easy_install 的一个替换品。

distribute是setuptools的取代(Setuptools包后期不再维护了)，pip是easy_install的取代。

pip的安装需要setuptools 或者 distribute，如果使用的是Python3.x那么就只能使用distribute，因为Python3.x不支持setuptools。

distribute下载地址： http://python-distribute.org/distribute_setup.py

Pip下载地址：https://pypi.python.org/pypi/pip#downloads

1、解压pip安装包，在cmd中pip安装包路径下使用 python setup.py install

2、安装好后直接使用pip install xlrd 下载安装包即可

 pip安装与换源下载见博文：手把手教你进行pip换源

🚩模块

⭐️什么是模块

模块就是⼀系列功能的集合体（对函数集的封装）。模块的三种来源：

  • 1. 内置模块

  • 2. 第三方模块

  • 3. ⾃定义模块

⭐️为何要用模块

  • 1. 使⽤内置或者第三⽅的模块的好处是：拿来主义，极⼤提升开发效率

  • 2. 使⽤⾃定义的模块的好处是：将程序的各部分组件共⽤的功能提取出来放到⼀个模块中，其他的组件通过导入的方式使用该模块，该模块即⾃定义模块，好处是可以减少代码冗余。

⭐️导入模块

模块需要先导入，然后才能使用其中的变量、函数或者类等。

可使用import或from语句导入模块，导⼊模块的三种⽅式：

💗import + 模块

首次导入模块的会发生三件事：

  • 会产⽣⼀个模块名称空间

  • 会执行模块⽂件的内容，将产⽣的名字丢到模的名称空间⾥

  • 在当前执⾏的⽂件中拿到⼀个名字（模块名），该名字指向模块的名称空间

模块的内功能的调用

module.func()

缺点：当模块名复杂（stu_ifo_msg)时，会大大降低开发效率。

import语句用于导入整个模块。

  1. >>> import math	        #导入模块
  2. >>> math.fabs(-5)	    #调用模块中的函数
  3. 5.0
  4. >>> math.e		        #使用模块中的常量
  5. 2.718281828459045
  6. >>> fabs(-5)			#试图直接使用模块中的函数，出错
  7. Traceback (most recent call last):
  8. File "", line 1, in 
  9. NameError: name 'fabs' is not defined

💗import + 模块 + as + 新名字

import语句用于导入整个模块，可用as为导入的模块指定一个新名称。导入模块后，使用“模块名称.对象名称”格式来引用模块中的对象。

  1. >>> import math as m	#导入模块并指定新名称
  2. >>> m.fabs(-5)		    #通过新名称调用模块函数
  3. 5.0
  4. >>> m.e			        #通过新名称使用模块常量
  5. 2.718281828459045

💗from + 模块 + import + 函数名，函数名，函数名……

首次导入模块会发生三件事：

  • 会产生⼀个模块名称空间

  • 会执行模块文件内容，见文件中产生的名字丢入到模块的名称空间中

  • 在当前执行文件中拿到的函数名，该名字指向模块的名称空间中的函数

功能函数的调用

func()

缺点：当执⾏函数中有相同函数名时，会造成名称空间混淆

from语句用于导入模块中的指定对象，导入的对象可直接使用，不需要使用模块名称作为限定符，示例代码如下：

  1. >>> from math import fabs		#从模块导入指定函数
  2. >>> fabs(-5)
  3. 5.0
  4. >>> from math import e		#从模块导入指定常量
  5. >>> e
  6. 2.718281828459045
  7. >>> from math import fabs as f1	#导入时指定新名称
  8. >>> f1(-10)
  9. 10.0

from … import *语句使用星号时，可导入模块顶层的所有全局变量和函数 示例代码如下：

  1. >>> from math import *	#导入模块顶层的全局变量和函数
  2. >>> fabs(-5)			#直接使用导入的函数
  3. 5.0
  4. >>> e			        #直接使用导入的常量
  5. 2.718281828459045

⭐️导入时执行模块

import和from语句在执行导入操作时，会执行导入模块中的全部语句。

只有执行了模块，模块中的变量和函数才会被创建，才能在当前模块中使用。

只有在第一次执行导入操作时，才会执行模块。再次导入模块时，并不会重新执行模块。

🍊import和from语句是隐性的赋值语句，两者的区别如下：

Python执行import语句时：

  • 会创建一个模块对象和一个与模块文件同名的变量，并建立变量和模块对象的引用。

  • 模块中的变量和函数等均作为模块对象的属性使用。

  • 再次导入时，不会改变模块对象属性的当前值。

 Python执行from语句时：

  • 会同时在当前模块和被导入模块中创建同名变量，这两个变量引用同一个对象。

  • 再次导入时，会将被导入模块的变量的初始值赋值给前模块的变量。

示例代码如下：

首先，创建模块文件test.py，其代码如下：

  1. x=100					            #赋值，创建变量x
  2. print('这是模块test.py中的输出！')	#输出字符串
  3. def show():		                    #定义函数，执行时创建函数对象
  4. print('这是模块test.py中的show()函数中的输出！')

可将test.py放在系统D盘根目录中，然后进入系统命令提示符窗口，在D盘根目录中执行python.exe进入Python交互环境：

  1. D:\>python
  2. ……
  3. >>> import test		        #导入模块，下面的输出说明模块在导入时被执行
  4. 这是模块test.py中的输出！
  5. >>> test.x		            #使用模块变量
  6. 100
  7. >>> test.x=200		        #为模块变量赋值
  8. >>> import test		        #重新导入模块
  9. >>> test.x		            #使用模块变量，输出结果显示重新导入未影响变量的值
  10. 200
  11. >>> test.show()		        #调用模块函数
  12. 这是模块test.py中的show()函数中的输出！
  13. >>> abc=test			    #将模块变量赋值给另一个变量
  14. >>> abc.x			        #使用模块变量
  15. 200
  16. >>> abc.show()		        #调用模块函数
  17. 这是模块test.py中的show()函数中的输出！

🍊执行import导入后模块与变量的关系

  

下面的代码使用from语句导入test模块：

  1. >>> from test import x,show			#导入模块的变量x、show
  2. 这是模块test.py中的输出！
  3. >>> x						        #输出模块的变量的初始值
  4. 100    
  5. >>> show()					        #调用模块函数
  6. 这是模块test.py中的show()函数中的输出！
  7. >>> x=200					        #这里是为当前模块的变量赋值
  8. >>> from test import x,show			#重新导入
  9. >>> x						        #x的值为模块的变量的初始值
  10. 100

  • 在执行from语句时，test模块的所有语句均被执行。

  • from语句将test模块的变量x和show赋值给当前模块的变量x和show。

  • 语句“x=200”为当前模块的变量x赋值，不会影响test模块的变量x。

  • 在重新导入时，当前模块变量x被重新赋值为test模块的变量x的值。

🍊执行from导入后模块与变量的关系

  

⭐️用import还是from

使用import导入模块时，模块的变量使用“模块名.”作为限定词，所以不存在歧义，即使与其他模块的变量同名也没有关系。在使用from时，当前模块的同名变量引用了模块内部的对象，应注意引用模块变量与当前模块或其他模块的变量同名的情况。

💗使用模块内的可修改对象

使用from导入模块时，可以直接使用变量引用模块中的对象，从而避免输入“模块名.”作为限定词。这种便利有时也会遇到麻烦。

🍊在下面的模块test中，变量x引用了整数对象100（100是不可修改对象），y引用了一个可修改的列表对象。

  1. # test.py
  2. x=100	    #赋值，创建整数对象100和变量x，变量x引用整数对象100
  3. y=[10,20]	#赋值，创建列表对象[10,20]和变量y，变量y引用列表对象

🍊下面的代码使用from导入模块test：

  1. >>> x=10		        #创建当前模块的变量x
  2. >>> y=[1,2]		        #创建当前模块的变量y
  3. >>> from test import *	#引用模块中的x和y
  4. >>> x,y			        #输出结果显示确实引用了模块中的对象
  5. (100, [10, 20])
  6. >>> x=200		        #赋值，使当前模块的变量x引用整数对象200
  7. >>> y[0]=['abc']		#修改第一个列表元素，此时会修改模块中的列表对象
  8. >>> import test		    #再次导入模块
  9. >>> test3.x,test.y	    #输出结果显示模块中的列表对象已被修改
  10. (100, [['abc'], 20])

💗使用from导入两个模块中的同名变量

🍊在下面的两个模块test1.py和test2.py中包含了同名的变量。

  1. # test1.py
  2. def show():
  3. print('out in test1.py')
  4. # test2.py
  5. def show():
  6. print('out in test2.py')

🍊当两个模块存在同名变量时，使用from语句导入模块会导致变量名冲突，示例代码如下：

  1. >>> from test1 import show
  2. >>> from test2 import show
  3. >>> show()
  4. out in test2.py
  5. >>> from test2 import show
  6. >>> from test1 import show
  7. >>> show()
  8. out in test1.py

🍊当两个模块存在同名变量时，应使用import语句导入模块，示例代码如下。

  1. >>> import test1
  2. >>> import test2
  3. >>> test1.show()
  4. out in test1.py
  5. >>> test2.show()
  6. out in test2.py

⭐️重新载入模块

再次使用import或from导入模块时，不会重新执行模块，所以不能使模块的所有变量恢复为初始值。

imp模块的reload()函数可重新载入并执行模块代码，从而使模块中的变量全部恢复为初始值。

reload()函数用模块名称作为参数，所以只能重载使用import语句导入的模块。

如果模块还没有导入，执行reload()函数会出错

  1. >>> import test			#导入模块，模块代码被执行
  2. 这是模块test.py中的输出！
  3. >>> test.x
  4. 100
  5. >>> test.x=200
  6. >>> import test			#再次导入
  7. >>> test.x				#再次导入没有改变当前值
  8. 200
  9. >>> from imp import reload		#导入reload函数
  10. >>> reload(test)	            #重载模块，可以看到模块代码被再次执行
  11. 这是模块test.py中的输出！
  12. 'test' from 'D:\\Python35\\test.py'>
  13. >>> test.x		                #因为模块代码再次执行，x恢复为初始值
  14. 100

⭐️模块搜索路径

在导入模块时，Python会执行下列3个步骤。

 🍊（1）搜索模块文件：在导入模块时， Python按特定的路径搜索模块文件。

 🍊（2）必要时编译模块：

  • 找到模块文件后，Python会检查文件的时间戳。

  • 如果字节码文件比源代码文件旧（即源代码文件作了修改），Python就会执行编译操作，生成最新的字节码文件。

  • 如果字节码文件是最新的，则跳过编译环节。如果在搜索路径中只发现了字节码，而没有发现源代码文件，则直接加载字节码文件。

  • 如果只有源代码文件，Python会执行编译操作，生成字节码文件。

 🍊（3）执行模块：执行模块的字节码文件。嵌套导入模块查看模块对象属性__name__属性和命令行参数

在导入模块时，不能在import或from语句中指定模块文件的路径，只能依赖于Python搜索路径。

可使用标准模块sys的path属性来查看当前搜索路径设置，示例代码如下：

  1. >>> import sys
  2. >>> sys.path
  3. ['', 'D:\\Python35\\python35.zip', 'D:\\Python35\\DLLs', 'D:\\Python35\\lib ', 'D:\\Python35', 'D:\\Python35\\lib\\site-packages']

 第一个空字符串表示Python当前工作目录。Python按照先后顺序依次搜索path列表中的路径。如果在path列表的所有路径中均未找到模块，则导入操作失败。

通常，sys.path由4部分设置组成：

🍊（1）Python的当前工作目录（可用os模块中的getcwd()函数查看当前目录名称）。

🍊（2）操作系统的环境变量PYTHONPATH中包含的目录（如果存在）。

🍊（3）Python标准库目录。

🍊（4）任何pth文件包含的目录（如果有存在）。

Python按照上面的顺序搜索各个目录。

pth文件通常放在Python安装目录中，文件名可以任意，例如searchpath.pth。

在pth文件中，每个目录占一行，可包含多个目录，示例代码如下：

  1. C:\myapp\hello
  2. D:\pytemp\src

sys.path列表在程序启动时，自动进行初始化。可在代码中对sys.path列表执行添加或删除操作

  1. >>> from sys import path		#导入path变量
  2. >>> path					    #显示当前搜索路径列表
  3. ……
  4. >>> del path[1]					#删除第二个搜索路径
  5. >>> path
  6. ……
  7. >>> path.append(r'D:\temp')		#添加一条搜索路径
  8. >>> path
  9. ……

⭐️PYTHONPATH 变量

作为环境变量，PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。

在 Windows 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=c:\python27\lib;

在 UNIX 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=/usr/local/lib/python

⭐️嵌套导入模块

Python允许任意层次的嵌套导入。

每个模块都有一个名字空间，嵌套导入意味着名字空间的嵌套。

在使用模块的变量名时，应依次使用模块名称作为限定符。

例如，有两个模块文件test1.py和test2.py，下面的代码说明了嵌套导入时应如何使用模块中的变量：

  1. #test1.py
  2. x=100
  3. def show():
  4. print('这是模块test.py中的show()函数中的输出！')
  5. print('载入模块test.py！')
  6. import test2
  7. #test2.py
  8. x2=200
  9. print('载入模块test2.py！')

在交互模式下导入test1.py的示例如下：

  1. >>> import test1				#导入模块test
  2. 载入模块test1.py！
  3. 载入模块test2.py！
  4. >>> test1.x				        #使用test模块的变量
  5. 100
  6. >>> test1.show()				#调用test模块的函数
  7. 这是模块test1.py中的show()函数中的输出！
  8. >>> test1.test2.x2				#使用嵌套导入的test2模块中的变量
  9. 200

⭐️查看模块对象属性

在导入模块时，Python为模块文件创建一个模块对象。模块中的各种对象是模块对象的属性。

Python会为模块对象添加一些内置属性。

可使用dir()函数查看对象属性。

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

  1. # 导入内置math模块
  2. import math
  3. content = dir(math)
  4. print content;

以上实例输出结果：

  1. ['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
  2. 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
  3. 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
  4. 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
  5. 'sqrt', 'tan', 'tanh']

在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

⭐️__name__属性和命令行参数

当作为导入模块使用时，模块的__name__属性值为模块文件的主名。

当作为顶层模块直接执行时，__name__属性值为“__main__”。

在下面的代码中，检查__name__属性值是否为“__main__”。如果为“__main__”，则将命令行参数输出：

  1. #test.py
  2. if __name__=='__main__':
  3. #模块独立运行时，执行下面的代码
  4. def show():
  5. print('test.py独立运行')
  6. show()
  7. import sys
  8. print(sys.argv)				        #输出命令行参数
  9. else:
  10. #作为导入模块时，执行下面的代码
  11. def show():
  12. print('test.py作为导入模块使用')
  13. print('test.py执行完毕！')              	#该语句总会执行

⭐️隐藏模块变量

在使用“from…import *”导入模块变量时，默认会将模块顶层的所有变量导入，但模块中以单个下划线开头的变量（如_abc）不会被导入 。

可以在模块文件开头使用__all__变量设置使用“from…import *”语句时导入的变量名。

“from…import *”语句根据__all__列表导入变量名。只要是__all__列表中的变量，不管是否以下划线开头，均会被导入。

  1. #test.py
  2. x=100
  3. _y=[1,2]
  4. def _add(a,b):
  5. return a+b
  6. def show():
  7. print('out from test.py')

🚩模块包

⭐️包的基本结构

当文件夹中存在__init__.py文件时，表示该目录是一个Python包。

__init__.py文件可以是一个空文件，或者在其中定义__all__列表、其他变量或类等。

按照下面的步骤创建包pytemp及其子目录和文件：

🍊（1）打开Windows的资源管理器，在D盘根目录中新建文件夹pytemp。

🍊（2）在D:\pytemp中新建文件夹mypysrc。

🍊（3）在D:\pytemp\mypysrc中新建文件夹db。

🍊（4）在IDLE中创建一个空的Python程序，将其分别保存到D:\pytemp、D:\pytemp\mypysrc和D:\pytemp\mypysrc\db文件夹，命名为__init__.py。

🍊（5）在IDLE中创建一个Python程序，将其保存D:\pytemp\mypysrc\db文件夹，命名为test.py程序代码如下：

  1. #D:\pytemp\mypysrc\db\test.py
  2. def show():
  3. print(r'这是模块D:\pytemp\mypysrc\db\test.py中的show()函数中的输出！')
  4. print(r'模块D:\pytemp\mypysrc\db\test.py执行完毕！')

  

⭐️导入包

导入包中的模块时，应指明包的路径，在路径中使用点号分隔目录，示例代码如下：

  1. D:\>cd pytemp		                        #进入包的根目录pytemp
  2. D:\pytemp>python		                    #进入Python交互环境
  3. ……
  4. >>>
  5. >>> import mypysrc.db.test		            #导入包中的模块
  6. 模块D:\pytemp\mypysrc\db\test.py执行完毕！
  7. >>> mypysrc.db.test.show()
  8. 这是模块D:\pytemp\mypysrc\db\test.py中的show()函数中的输出！
  9. >>> from mypysrc.db.test import show		#从包中的模块导入变量名
  10. >>> show()
  11. 这是模块D:\pytemp\mypysrc\db\test.py中的show()函数中的输出！

⭐️相对导入

Python总是在搜索路径中查找包。

  • “.”表示当前模块文件所在的目录——可称为当前路径，

  • “..”表示当前模块文件所在路径的上一级目录。

💗使用当前路径导入

🍊在IDLE中创建一个Python程序，将其保存D:\pytem\mypysrc文件夹，命名为reltest.py。程序代码如下：

  1. #D:\pytemp\mypysrc\reltest.py
  2. import os
  3. print('当前工作目录为：',os.getcwd())
  4. from .db.test import show	  #导入当前目录下的db.test模块中的函数
  5. show()
  6. print('相对导入测试完毕')

🍊在交互模式下导入reltest.py，示例代码如下：

  1. >>> import mypysrc.reltest   #导入模块
  2. 当前工作目录为：D:\pytemp
  3. 模块E:\Pytemp\mypysrc\db\test.py执行完毕！
  4. 这是模块D:\pytemp\mypysrc\db\test.py中的show()函数中的输出！
  5. 相对导入测试完毕

💗使用上一级目录路径

🍊在IDLE中创建一个Python程序，将其保存D:\pytem\mypysrc文件夹，命名为test.py。程序代码如下：

  1. #D:\pytemp\mypysrc\test.py
  2. def show():
  3. print(r'这是模块D:\pytemp\mypysrc\test.py中的show()函数中的输出！')
  4. print(r'模块D:\pytemp\mypysrc\test.py执行完毕！')

🍊在IDLE中创建一个Python程序，将其保存D:\pytem\mypysrc\db文件夹，命名为reltest_up.py。程序代码如下：

  1. #D:\pytemp\mypysrc\db\reltest_up.py
  2. from ..test import show	    #导入上一级目录下的test模块中的函数 show()
  3. print(r'模块D:\pytemp\mypysrc\db\reltest_up.py执行完毕！')
  4. print('相对导入测试完毕')

🍊在交互模式下导入reltest_up.py，示例代码如下：

  1. >>> import mypysrc.db.reltest_up
  2. 模块D:\pytemp\mypysrc\test.py执行完毕！
  3. 这是模块D:\pytemp\mypysrc\test.py中的show()函数中的输出！
  4. 模块D:\pytemp\mypysrc\db\reltest_up.py执行完毕！
  5. 相对导入测试完毕

⭐️在__init__.py中添加代码

在执行“from 包名 import *”导入包时，Python会执行包中的__init__.py文件，并根据__all__列表完成导入。

修改D:\pytemp\mypysrc文件夹中的__init__.py，代码如下：

  1. # __init__.py
  2. import mypysrc.db.test
  3. #__all__=['data1','showA']
  4. data1='包d:\pytem\mypysrc中的变量data1的值'
  5. data2='包d:\pytem\mypysrc中的变量data2的值'
  6. def showA():
  7. print('d:\pytem\mypysrc\__init__.py中的函数showA()的输出')
  8. def showB():
  9. print('d:\pytem\mypysrc\__init__.py中的函数showB()的输出')
  10. print('D:\pytem\mypysrc\__init__.py执行完毕’)

在交互模式下导入包mypysrc

🚩python常见模块与包

完整的模块与包资源可以自行下载：PYTHON常用模块.pdf

常用包：

  • 图片处理（PIL或Pillow）

  • 网页解析（goose）

  • 工具包下载安装（easy_install、pip）

  • 数据库（MySQLdb）

  • Web开发（Django）

  • 机器学习（numpy、pandas、scipy）

  • 游戏开发（PyGame）

  • 文件操作（os）

🚩综合实例

👍杨辉三角

在IDLE创建一个Python程序，在程序中定义一个函数输出杨辉三角。

程序独立运行时输出10阶杨辉三角，如图所示：

  

🍊杨辉三角实现分析：

将杨辉三角左对齐输出，如图所示。

  

可以看出，杨辉三角矩阵的规律为：

  • 第一列和主对角线上的数字都为1，

  • 其他位置的数字为“上一行前一列”和“上一行同一列”两个位置的数字之和。

  • 使用嵌套的列表表示杨辉三角，则非第一列和主对角线上元素的值可用下面的表达式表示。

  • x[i][j]=x[i-1][j-1]+x[i-1][j]

  1. 输出：
  2. 第一行：L = [1]
  3. len(L) = 1
  4. range(1,1) = []    #此时， L[n-1] for n in range(1,len(L))] 这个for in 不执行
  5. 第二行：L = [1] + [L[n] + L[n-1] for n in [] ] + [1]
  6. L = [1] + [1]
  7. L = [1, 1]
  8. len(L) = 2
  9. range(1,2) = [1]
  10. 第三行：L = [1] + [L[n] + L[n-1] for n in [1]] + [1]
  11. L = [1] + [ L[1] + L[1-1] ] + [1]
  12. L = [1] + [ L[1] + L[0] ] + [1]
  13. L = [1] + [ 1 + 1] + [1]
  14. L = [1, 2, 1]

实现代码：

  1. def transfor(fun):   #定义一个转换函数，
  2. def war(N):      #带参数的装饰器，把参数传闭包里
  3. L = N.copy()
  4. for j in range(len(L)):
  5. temp = str(L[j])
  6. L[j] = temp
  7. l = ' '.join(L).center(90)
  8. fun(l)
  9. return war
  10. @transfor
  11. def f1(N):        #把print定义成f1()函数
  12. print('模块独立运行，10阶杨辉三角如下：')
  13. print(N)
  14. N = [1]
  15. for i in range(10):
  16. f1(N)   #这里注意要用f()代替print()
  17. N.append(0)
  18. N = [N[k] + N[k-1] for k in range(i+2)]


🍊根据对称性打印（索引）：

  1. n = 6
  2. triangle = [[1],[1,1]]
  3. for i in range(2,n):
  4. row = [1] * (i+1)
  5. for j in range(i//2):    #有图知：大概的临界值为一半，再仔细推敲
  6. val = triangle[i-1][j] + triangle[i-1][j+1]
  7. row[j+1] = val
  8. row[i-j-1] =val      #此处规律：两个对称值的索引和等于 i
  9. triangle.append(row)
  10. print(triangle)
  11. 执行结果：
  12. [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]]

🍊单个列表覆盖、切片完成：

  1. n = 6
  2. row = [1] * n
  3. for i in range(n):                #n行n次
  4. old = 1                       #old刚开始为1
  5. for j in range(i//2):
  6. val = old + row[j+1]
  7. old = row[j+1]            #此处现将row[j+1]的值赋给old，以防止被覆盖
  8. row[j+1] = val
  9. if i != 2*j:
  10. row[i-j-1] = val
  11. 　　print(row[:i+1])
  12. 执行结果：
  13. [1]
  14. [1, 1]
  15. [1, 2, 1]
  16. [1, 3, 3, 1]
  17. [1, 4, 6, 4, 1]
  18. [1, 5, 10, 10, 5, 1]

👍包模块实例

实例的结构和具体的文件：

  1. PyPackage
  2. │  PyCommonM.py
  3. │  __init__.py
  4. │
  5. ├─p1Package
  6. │      P1M.py
  7. │      P1MC.py
  8. │      __init__.py
  9. │
  10. └─p2
  11. P2.py
  12. P2M.py

PyCommonM.py

  1. def PyCommonMF():
  2. print "PyCommonMF"

 P1M.py

  1. def P1MF():
  2. print 'P1MF'

P1MC.py

  1. class P1MC():
  2.     @staticmethod
  3. def P1MCF():
  4. print 'P1MCF'

P2M.py

  1. def P2MF():
  2. print 'P2MF'

P2.py

  1. import P2M
  2. from PyPackage import PyCommonM
  3. from PyPackage.p1Package import P1M
  4. from PyPackage.p1Package.P1MC import P1MC
  5. def P2F():
  6. print 'P2F'
  7. if __name__ == '__main__':
  8. P2F()
  9. P2M.P2MF()
  10. P1M.P1MF()
  11. P1MC.P1MCF()
  12. PyCommonM.PyCommonMF()

运行p2.py的结果：

  1. P2F
  2. P2MF
  3. P1MF
  4. P1MCF
  5. PyCommonMF

解析：

  • 一个py文件为一module，例如module：PyCommonM.py，P2M.py，P1MC.py， P1M.py 。

  • 包含__init__.py的文件夹为一个package,例如package：PyPackage，p1Package。

  • 可以直接使用import来引用相同目录下的其他的module， 例如p2.py中的import P2M。

  • 通过from import来引用其他的目录下且属于某个package的module，例如py.py中的from PyPackage import PyCommonM 和 from PyPackage.p1Package import P1M。

  • 通过from import来引用某个module中的类，例如from PyPackage.p1Package.P1MC import P1MC

👍批量处理图片   PIL(Image、ImageDraw、ImageFont)、os、time（时间戳）

  1. import os,time
  2. from PIL import Image,ImageDraw,ImageFont
  3. #源文件夹，目标文件夹，字体文件，屏幕分辨率（宽度，高度）
  4. srcpath, destpath, fontfile = r".\src", r"..\dest", r"..\font\301-CAI978.ttf"
  5. width, height = 640.0, 1136.0
  6. def zoomSize(filename,imgtype):
  7. imgtype = "jpeg" if imgtype=="jpg" else "png"
  8. #获取文件创建时间        例：1483882912.37   Sun Jan 08 21:41:52 2017
  9. t= time.ctime(os.path.getctime(filename))
  10. print filename +" 创建时间:"+ t
  11. im = Image.open(filename)   #默认mode="r"
  12. #在图片上添加创建时间
  13. draw = ImageDraw.Draw(im)
  14. fontsize = min(im.size)/30
  15. font = ImageFont.truetype(fontfile, fontsize)
  16. draw.text((0,im.height - fontsize),t,font=font,fill=(255,0,0))
  17. #按比例缩放，使之适应屏幕分辨率
  18. rate = max( im.width/width, im.height/height )
  19. if rate!=0:
  20. im.thumbnail((im.size[0]/rate , im.size[1]/rate))    #注：此处有两个括号,thumbnail的处理对象是元组
  21. return im
  22. def batchZoomSize():
  23. imgBatch = {}　　　　#字典  {文件名:对应的处理后Image对象}
  24. #切换至源文件目录，对每张图片进行处理
  25. os.chdir(srcpath)
  26. for filename in os.listdir(os.getcwdu()):    #列举当前目录下的所有文件
  27. postfix = os.path.splitext(filename)[1]  #获取元祖  (文件名,文件后缀)
  28. if postfix == ".jpg" or postfix == ".png":
  29. imgBatch[filename]=zoomSize(filename, postfix)
  30. #切换至目标文件目录，保存图片至目标文件夹,关闭图片文件
  31. os.chdir(destpath)
  32. for filename in imgBatch.keys():
  33. imgBatch[filename].save(filename)
  34. imgBatch[filename].close()

👍生成序列号　　random（随机数）、string（字符串）

  1. import string,random
  2. field = string.letters + string.digits    #'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
  3. def getRandom(size):
  4. return "".join(random.sample(field,size))
  5. def generate(n,group,size):
  6. for i in range(n):
  7. "-".join([getRandom(size) for i in range(group)])　　#注意：()里面还有[]，join的处理对象时列表
  8. if __name__=="__main__":
  9. print generate(2,4,4)            #['YcwC-fzE4-93pl-ROnY', '76AI-h1Aa-BNK4-PuFR']

👍统计单词词频　　os、re（正则表达式）、collections.Counter（统计计数）

  1. import os,re
  2. from collections import Counter'''
  3. 获取某一文件中的英文单词词频
  4.     例：Counter({word1:num1,word2:num2})
  5. '''
  6. def getCount(filename):
  7. pattern = r'''[A-Za-z]+|\$?\d+%?$'''
  8. with open(filename) as f:
  9. r = re.findall(pattern,f.read())
  10. return Counter(r)
  11. '''
  12. 将结果保存到文件中
  13. '''
  14. def saveFile(filename,counter):
  15. fp = open(filename,"w")for t in counter:
  16. fp.write(bytes(t[0]) + "," + bytes(t[1])+"\n")    # 单词,词频
  17. fp.close()
  18. count = getCount(r".\doc\1.txt")
  19. saveFile("count.csv",count.most_common())

🍊🍊🍊 

推荐阅读
（点击标题可跳转阅读）
简易的服务器接口开发入门教程
教你用Python制作实现自定义字符大小的简易小说阅读器
小程序云开发项目的创建与配置
汇总超全Matplotlib可视化最有价值的 50 个图表（附 Python 源代码）（一）
超详细讲解CTC理论和实战
ODBC连接主流数据库的配置方法
教你用python进行数字化妆，可爱至极
加速Python列表和字典，让你代码更加高效
老铁，三连支持一下，好吗？↓↓↓


点分享

点点赞

点在看

浏览 93
点赞
评论
收藏
分享

手机扫一扫分享

举报
评论
图片
表情
推荐
Python处理PDF——PyMuPDF的安装与使用！
恋习Python
0
Python处理PDF——PyMuPDF的安装与使用！
简说Python
0
Python处理PDF——PyMuPDF的安装与使用！
俊红的数据分析之路
0
Python处理PDF——PyMuPDF的安装与使用！
机器学习算法与Python实战
0
Python处理PDF神器：PyMuPDF的安装与使用
杰哥的IT之旅
0
Python处理PDF神器：PyMuPDF的安装与使用
Python绿色通道
0
Python处理PDF神器：PyMuPDF的安装与使用
数据分析1480
0
1万字详解 python logging日志模块
python之禅
0
一文详解Python Conda包管理工具
小詹学Python
0
详解Python中argpasrse模块的基本使用
点击蓝字关注我们argpasrse模块的使用import argparseparser = argparse.ArgumentParser( prog = 'ls', description='Process some int', add_help = True)parser.add_argument('path',nargs='?', default='.', help...
编程技术圈
0
点赞
评论
收藏
分享

手机扫一扫分享

举报