澳门新浦京娱乐场网站-www.146.net-新浦京娱乐场官网
做最好的网站

澳门新浦京娱乐场网站Python中的模块介绍和行使

 

1.1Python中的模块介绍和使用

1.1Python中的模块介绍和使用

在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。

代码裤子:

模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块

有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数,必须用语句#include 引入math.h这个头文件,否则是无法正常进行调用的。

说的通俗点:模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块

在线编程:

1.1.1import

那么在Python中,如果要引用一些其他的函数,该怎么处理呢?

1.import

在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。

形如:

importmodule1,mudule2...

当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。

在调用math模块中的函数时,必须这样引用:

模块名.函数名

这种方式必须加上模块名调用,因为可能存在这样一种情况:在多个模块中含有相同名称的函数,此时如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候,调用函数必须加上模块名。

澳门新浦京娱乐场网站 1

有时候我们只需要用到模块中的某个函数,只需要引入该函数即可,此时可以用下面方法实现:

from模块名import函数名1,函数名2....

不仅可以引入函数,还可以引入一些全局变量、类等

注意:

通过这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( ),在模块B中也有函数function( ),如果引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去执行模块B中的function函数。

如果想一次性引入math中所有的东西,还可以通过from math import *来实现

在线预览:http://github.lesschina.com/python/base/module/模块专题.html

在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。

在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。

2.from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

语法如下:

from modname import name1[, name2[, ... nameN]]

例如,要导入模块fib的fibonacci函数,使用如下语句:

from fib import fibonacci

注意

·不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入

老师休假度蜜月去了,这学期也到了尾声,小明同学觉得自己学的挺好的,在四处逛游的过程中看见了小潘的电脑,然后惊到了!

形如:

说的通俗点:模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块

3.from … import *

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

from modname import *

注意

·这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

In [1]:

importmodule1,mudule2...

1.1.1import

4.as

澳门新浦京娱乐场网站 2

澳门新浦京娱乐场网站 3

澳门新浦京娱乐场网站 4

# 导入matplotlib的pyplot模块
import matplotlib.pyplot as plt

x_list=list(range(1,11))
y_list=[y*2 1 for y in x_list]

print(x_list)
print(y_list)

当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。

在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。

5.定位模块

当你导入一个模块,Python解析器对模块位置的搜索顺序是:

1.当前目录

2.如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。

3.如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/

4.模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

 

在调用math模块中的函数时,必须这样引用:

形如:

6.模块制作

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

模块名.函数名

importmodule1,mudule2...

1.定义自己的模块

在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。

比如有这样一个文件test.py,在test.py中定义了函数add

澳门新浦京娱乐场网站 5

In [2]:

只需要用到模块中某个函数的时候,可以用下面方法实现:

当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。

2.调用自己定义的模块

那么在其他文件中就可以先import test,然后通过test.add(a,b)来调用了,当然也可以通过from test import add来引入

main.py

澳门新浦京娱乐场网站 6

# 画图
plt.plot(x_list,y_list)
# 设置X,Y的坐标区间(可以不设置,用默认显示方式)
plt.axis([0,10,0,25])
# 显示图片
plt.show()

from模块名import函数名1,函数名2....

在调用math模块中的函数时,必须这样引用:

3.测试模块

在实际开中,当一个开发人员编写完一个模块后,为了让模块能够在项目中达到想要的效果,这个开发人员会自行在py文件中添加一些测试信息,例如:

澳门新浦京娱乐场网站 7

如果此时,在其他py文件中引入了此文件的话,想想看,测试的那段代码是否也会执行呢!

澳门新浦京娱乐场网站 8

至此,可发现test.py中的测试代码,应该是单独执行test.py文件时才应该执行的,不应该是其他的文件中引用而执行

为了解决这个问题,python在执行一个文件时有个变量__name__

澳门新浦京娱乐场网站 9

总结:

·可以根据__name__变量的结果能够判断出,是直接执行的python脚本还是被引入执行的,从而能够有选择性的执行测试代码

 

不仅可以引入函数,还可以引入一些全局变量、类等

模块名.函数名

7.模块中的__all__

澳门新浦京娱乐场网站 10

注意:

·想一想:

1.没有__all__

澳门新浦京娱乐场网站 11

澳门新浦京娱乐场网站 12

澳门新浦京娱乐场网站 13

 

o通过这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( ),在模块B中也有函数function(

为什么必须加上模块名调用呢?

2.模块中有__all__

澳门新浦京娱乐场网站 14

澳门新浦京娱乐场网站 15

小潘昨晚螃蟹吃多了,今天拉肚子拉的不要不要的,现在去药店买紫苏和干姜来解蟹毒呢

),如果引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去执行模块B中的function函数。

·答:

8.python中的包

怎么办呢,感觉自己不再萌萌哒了,好心情瞬间被比下去了,小明内心不断思索中....

o如果想一次性引入math中所有的东西,还可以通过from math import *来实现

因为可能存在这样一种情况:在多个模块中含有相同名称的函数,此时如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候,调用函数必须加上模块名

1.引入包

有2个模块功能有些联系

澳门新浦京娱乐场网站 16

所以将其放到同一个文件夹下

澳门新浦京娱乐场网站 17

使用import文件.模块 的方式导入

澳门新浦京娱乐场网站 18

使用from文件夹import模块 的方式导入

澳门新浦京娱乐场网站 19

在msg文件夹下创建__init__.py文件

澳门新浦京娱乐场网站 20

在__init__.py文件中写入

澳门新浦京娱乐场网站 21

重新使用from文件夹import模块 的方式导入

澳门新浦京娱乐场网站 22

总结:

包将有联系的模块组织在一起,即放到同一个文件夹下,并且在这个文件夹创建一个名字为__init__.py文件,那么这个文件夹就称之为包

有效避免模块名称冲突问题,让应用组织结构更加清晰

作为一个吃胖了的小明,过了一分钟就调节好了,然后好好看小潘的Code

1.1.2from…import

importmath

2__init__.py文件有什么用

__init__.py控制着包的导入行为

可以在__init__内添加导入的功能 比如from ab import a

咦,第一句是啥?不管,继续看x_list=list(range(1,11)) y_list=[y*2 1 for y in x_list]

Python的from语句可以从模块中导入一个指定的部分到当前命名空间中

#这样会报错

3__init__.py为空

仅仅是把这个包导入,不会导入包中的模块

这不是之前老师讲的列表生成式吗?然后就是画图了,好像也不是很难,开头到底是个啥,有了这个就可以几句话实现牛逼哄哄的技能了,不行得买瓶饮料问问课代表伟哥~

语法如下:

printsqrt(2)

4__all__

在__init__.py文件中,定义一个__all__变量,它控制着from包名import *时导入的模块

一进伟哥宿舍就发现,伟哥在给舍友们补课?这是要讲课的节奏吗?赶紧凑过来学习~

frommodnameimportname1[, name2[, ... nameN]]

#这样才能正确输出结果

5.(了解)可以在__init__.py文件中编写内容

可以在这个文件中编写语句,当导入时,这些语句就会被执行

__init__.py文件

澳门新浦京娱乐场网站 23

澳门新浦京娱乐场网站 24

1.模块导入¶

模块就是一组功能的集合体,我们的程序可以导入模块来复用模块里的功能

在Python中,一个py文件就称之为一个 模块(Module)

我们先来讲讲 模块怎么导入,上学期我们学了点C,发现每个文件开头都有一个#include <stdio.h>

这个就类似我们说的模块导入了,咱们Python的模块导入和Java有点像用 import 来导入

先看个例子 ~ 我们定义了一个test.py文件,里面定义了这么一个函数:

# %load test.py
def show():
    print("---show---")

我们想在新的py文件中使用这个函数

例如,要导入模块fib的fibonacci函数,使用如下语句:

printmath.sqrt(2)

6.扩展:嵌套的包

假定我们的包的例子有如下的目录结构:

澳门新浦京娱乐场网站 25

Phone是最顶层的包,Voicedta等是它的子包。 我们可以这样导入子包:

澳门新浦京娱乐场网站 26

你也可使用from-import实现不同需求的导入

第一种方法是只导入顶层的子包,然后使用属性/点操作符向下引用子包树:

澳门新浦京娱乐场网站 27

此外,我们可以还引用更多的子包:

澳门新浦京娱乐场网站 28

事实上,你可以一直沿子包的树状结构导入:

澳门新浦京娱乐场网站 29

在我们上边的目录结构中,我们可以发现很多的__init__.py文件。这些是初始化模块,from-import语句导入子包时需要用到它。 如果没有用到,他们可以是空文件。

包同样支持from-import all语句:

澳门新浦京娱乐场网站 30

然而,这样的语句会导入哪些文件取决于操作系统的文件系统。所以我们在__init__.py中加入__all__变量。该变量包含执行这样的语句时应该导入的模块的名字。它由一个模块名字符串列表组成。

澳门新浦京娱乐场网站 31

澳门新浦京娱乐场网站 32

总结:

澳门新浦京娱乐场网站 33

澳门新浦京娱乐场网站 34

1.1.import导入方式1¶

import test 把这个文件直接导入进来了

import test

test.show()

执行结果:

---show---

fromfibimportfibonacci

有时候我们只需要用到模块中的某个函数,只需要引入该函数即可,此时可以用下面方法实现:

9.模块发布

1.2.from…import导入方式2¶

有时候我们只需要用到模块中的某个函数,只需要引入该函数即可

from test import show 把这个文件的show方法导入进来,调用的时候直接show()即可

from test import show

show()

执行结果:

---show---

使用模块有什么好处?

  1. 提高了代码的维护性,当一个模块编写完毕,就可以被其他地方引用。

  2. 使用模块还可以 避免函数名和变量名冲突澳门新浦京娱乐场网站Python中的模块介绍和行使,模块总计。。相同名字的函数和变量完全可以分别存在不同的模块中

我们自己在编写模块时,不必考虑名字会与其他模块冲突(不要和内置函数名字冲突)

澳门新浦京娱乐场网站 35

 

注意

from模块名import函数名1,函数名2....

1.mymodule目录结构体如下:

澳门新浦京娱乐场网站 36

1.3.导入多个模块¶

看着小明一愣一愣的,加上那瓶菊花茶的面子,课代表来了一个demo:

test1.py

test_str = "111"

def show():
    print(__name__, "show")

test2.py

test_str = "222"

def show():
    print(__name__, "show")

可以以,分隔(这种导入方式,官方推荐多行导入

import test1, test2

print(test1.test_str)

print(test2.test_str)

test1.show()

test2.show()

结果:

111
222
test1 show
test2 show

还可以用这种方式,该模块里面的函数名、变量名以逗号分隔(不用多行)

通过这种方式引入的时候,是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入,所以用as来避免一下

from test1 import show as show1, test_str as test_str1
from test2 import show as show2, test_str as test_str2

print(test_str1)
print(test_str2)

show1()
show2()

结果:

111
222
test1 show
test2 show

如果想引入模块中所有东西可以用 from 模块名 import *,这样所有被允许(过会讲)的变量和函数都被导入进来了(少用)

from 模块名 import 好处:使用起来方便了,坏处:容易与当前执行文件中的名字冲突

 

·不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入

不仅可以引入函数,还可以引入一些全局变量、类等

2.编辑setup.py文件��

py_modules需指明所需包含的py文件

澳门新浦京娱乐场网站 37

2.模块的简单自测试¶

小明恍然大悟,盯着__name__看了好久,然后结合前面的知识,乘着旁边位置电脑没人,写了一半的demo卡壳了:

get_infos.py

def get_infos():
    print("信息如下:xxxx")

def main():
    get_infos()

if __name__ == '__main__':
    main()

伟哥过来瞟了一眼继续讲到:

之前老师讲面向对象的时候有提到标准格式写法:

def main():
    get_infos()

if __name__ == '__main__':
    main()

python文件可以有两种用途:

  1. 当做 脚本来单独使用或者执行
  2. 当做 模块来给别人调用

那怎么区分呢?就要用到__name__

我们来看个案例就懂了:

get_user_infos.py

def get_infos():
    print(__name__)
    print("信息如下:xxxx")

def main():
    get_infos()

if __name__ == '__main__':
    main()

再定义一个函数来调用它

import get_user_infos as user_infos

user_infos.get_infos()

直接执行的时候__name__等于__main__,别人调用的时候显示该文件名 澳门新浦京娱乐场网站 38

这样的好处就是==> 避免被别人导入的时候执行某些Code

小明乐坏了,平时和小潘以前做项目老被吐槽,学了这个得好好嘲讽一下小潘了

以后再也不怕直接py文件各种问题了,咱们可以先简单自测一下O(∩_∩)O哈!

 

1.1.3from … import *

注意:

3.构建模块

python setup.py build

澳门新浦京娱乐场网站 39

3.控制可使用的函数、变量、类¶

把一个模块的所有内容全都导入到当前的命名空间:

o通过这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( ),在模块B中也有函数function( ),如果引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去执行模块B中的function函数。

4.生成发布压缩包

�python setup.py sdist

打包后,生成最终发布压缩包yongGe-1.0.tar.gz ,目录结构

澳门新浦京娱乐场网站 40

澳门新浦京娱乐场网站Python中的模块介绍和行使,模块总计。3.1.通过私有来控制¶

在一个模块中,我们可能会定义很多函数和变量,但有的函数和变量我们希望给别人使用,有的函数和变量我们希望仅仅在模块内部使用。在Python中,是通过_前缀来实现的

小明同学基础功底扎实,看见标题小明就乐了,前面看了这么多案例瞬间秒懂,大叫道~”等一下~~~我来写demo,要是不行请你们吃晚饭~“

写下了如下代码:

test3.py

def test1():
    print("test1")


def _test2():
    print("test2")


def __test3():
    print("test3")

调用代码:

import test3

test3.test1()
test3._test2()
test3.__test3()

结果:

test1
test2
test3

大家大眼瞪小眼的看着小明,嘴角边露出了阴谋的味道~

这下小明傻眼了,难道老师之前类的私有系列讲错了?

小平瞥了小明一眼说道,你自己的打开方式不对还怪老师咯?看我给你改改~

调用代码:

from test3 import *

test1()
_test2()
__test3()

小明运行后就傻眼了,心想到,课代表这个宿舍卧虎藏龙啊,下次少来点,不然这点老底就被他们吃空了

NameError: name '_test2' is not defined

注释掉_test2()运行结果: NameError: name '__test3' is not defined

小明有点尴尬,然后转了个话题,说道:”那import不是无敌了?我们的私有不给力啊?“

伟哥语重心长的说道:

类似_xxx__xxx这样的函数或变量就是非公开的(private),不应该被直接引用

之所以我们说,“不应该”被直接引用,而不是“不能”被直接引用,是因为Python并没有一种方法可以完全限制访问private函数或变量

比如小明的那种方式就可以直接使用了,但是从编程习惯上不应该引用private函数或变量。

我们平时使用的时候:

外部不需要引用的函数全部定义成private,只有外部需要引用的函数才定义为public,然后导入的时候尽量使用from ... import

frommodnameimport*

o如果想一次性引入math中所有的东西,还可以通过from math import *来实现

10.模块的安装使用

3.2.通过__all__来控制¶

来个案例即可:

test4.py

__all__ = ["Dog", "test1", "name"]

class Animal(object):
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

def test1():
    print("test1")

def test2():
    print("test2")

def test3():
    print("test3")

name = "小明"
age = "22"

效果:只有__all__列表里面的才能被访问 澳门新浦京娱乐场网站 41

 

注意

1.1.2from…import

1.安装的方式

1.找到模块的压缩包

2.解压

3.进入文件夹

4.执行命令python setup.py install

注意:

·如果在install的时候,执行目录安装,可以使用python setup.py install --prefix=安装路径

4.二进制文件pyc¶

小明,看到使用的电脑出现了这么多的pyc文件,以为中毒了,慌了慌了,连忙问道:"伟哥伟哥,这个pyc是啥啊?不会是病毒吧?"

├── 1.def_module.py
├── 2.use_module.py
├── 3.use_name.py
├── 4.use_module.py
├── 5.use_all_.py
├── get_user_infos.py
├── __pycache__
│   ├── get_user_infos.cpython-36.pyc
│   ├── test1.cpython-36.pyc
│   ├── test2.cpython-36.pyc
│   ├── test3.cpython-36.pyc
│   ├── test4.cpython-36.pyc
│   └── test.cpython-36.pyc
├── test1.py
├── test2.py
├── test3.py
├── test4.py
└── test.py

旁边小李嘲笑道~”这你都不知道“

为了 提高加载模块的速度,python解释器会在pycache目录中下缓存每个模块编译后的版本

格式为:模块名.Python版本号.pyc 这种命名规范保证了编译后的结果多版本共存

小明问道,那我更新文件它怎么办呢?

小李瞥了一眼说道:

Python检查源文件的修改时间与编译的版本进行对比,如果过期就自动重新编译

并且编译的模块是平台独立的,所以相同的库可以在不同的架构的系统之间共享

小明恍然大悟,说道:

这不类似于Java和Net嘛,将来咋们编写的东西都可以跨平台了啊,O(∩_∩)O~,反正是由python虚拟机来执行的,太方便了

PS:pyc文件是可以反编译的,因而它的出现仅仅是用来提升模块的加载速度的,不是用来加密的

 

·这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

2.模块的引入

在程序中,使用from import即可完成对安装的模块使用

from模块名import模块名或者*

5.自己添加模块路径¶

小明乘着大家休息的时候回宿舍拿了个笔记本,继续听道:

当你导入一个模块,Python解析器对模块位置的搜索顺序是:

  1. 当前目录
  2. 如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。
  3. 如果都找不到,Python会查看默认路径。xinux下,默认路径一般为/usr/local/lib/python/
  4. 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录

总之你看sys.path就对了

前几天时间发布了Python3.7,我们设置vscode的运行环境为Python3.7,然后看看: 澳门新浦京娱乐场网站 42

我用的是conda的一个路径,Python3.7相关的一下插件没那么完善,我用的是3.6系列,3.7你可以用来练习一下新语法糖 澳门新浦京娱乐场网站 43

['', # 当前目录
'/usr/lib/python37.zip', '/usr/lib/python3.7', 
'/usr/lib/python3.7/lib-dynload',
 '/usr/local/lib/python3.7/dist-packages', 
 '/usr/lib/python3/dist-packages']

小明心想,我是省事直接装了个conda路径是啥呢?于是自己测试了下:

In [3]:

# conda的默认搜索路径
import sys

print(sys.path)

 

['', '/home/dnt/anaconda3/lib/python36.zip', '/home/dnt/anaconda3/lib/python3.6', '/home/dnt/anaconda3/lib/python3.6/lib-dynload', '/home/dnt/.local/lib/python3.6/site-packages', '/home/dnt/anaconda3/lib/python3.6/site-packages', '/home/dnt/anaconda3/lib/python3.6/site-packages/IPython/extensions', '/home/dnt/.ipython']

 

运维方面用些许,平时用的不是很多,一带而过~

细心可以看到,sys.path是一个列表,那么你对其添加删除操作也是和list一样的

比如这个场景,服务器给不同的用户使用,又不想他们的程序访问到超过其文件夹外的文件(系统、其他用户)

那么可以弄一个公共的库文件夹(手段先不用管),用程序模拟一下 澳门新浦京娱乐场网站 44

这种方法是在运行时修改,运行结束后失效

其实还可以设置环境变量pythonpath,该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。

注意只需要添加你自己的搜索路径,Python自己本身的搜索路径不受影响。(列表第二个就是说的这个)

1.1.4as

语法如下:

6.模块重新导入¶

import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次

为了防止你重复导入,python的优化手段是:

第一次导入后就将模块名加载到内存了,后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用,不会重新执行模块内的语句

看个例子: 澳门新浦京娱乐场网站 45

想要重新导入修改的模块,可以使用官方推荐的方法:importlib下面的reload方法

from importlib import reload

reload(test)

当然了你也可以使用imp下面的reload方法(3.4往后,官方就不推荐使用 **imp** 了)

In [1]: import time as tt

frommodnameimportname1[, name2[, ... nameN]]

6.1.循环导入的问题¶

稍微提一下循环导入(类似于C#循环引用),能避免就避免。

子模块相对独立,尽量别相互导入,通过父模块来调用 (有点像微服务的感觉)

这样不会混乱也不会出现循环导入的问题了

如果项目里面真的出现了循环导入,那么可以这么解决(参考):

  1. 重新设计架构,解除相互引用的关系
  2. 把import语句放置在模块的最后
  3. 把import语句放置在函数中

 

In [2]: time.sleep(1)

例如,要导入模块fib的fibonacci函数,使用如下语句:

7.常用模块¶

看到标题小明就乐了,这不~终于可以说话了,不用被他们压抑的不敢出声了~

之前说了很多,比如time,random,sys等等,这次再扩充几个用的比较多的模块

后面demo里面还会再说,可以自己学习一下(官方文档)(源码文件)


fromfibimportfibonacci

7.1.time and datetime¶

在Python中,通常有这几种方式来表示时间:

由于Python的time模块实现主要调用C库,所以各个平台可能有所不同

  1. 时间戳(timestamp):从1970年1月1日00:00:00开始按秒计算的偏移量
    • type(time.time()) ==> float
    • 返回时间戳方式的函数主要有time()clock()(这个Win和Xinux系列有些区别)等
  2. 格式化的时间字符串
  3. UTC世界标准时间(在中国为UTC 8),DST(Daylight Saving Time)即夏令时。
    • 元组(struct_time)共有9个元素
    • 返回struct_time的函数主要有gmtime(),localtime(),strptime()

看到表格不用怀疑,没错,更详细可以看官方介绍

| 索引 | 属性                     | 值                        |
| ---- | -------------------------| ------------------------- |
| 0    | tm_year(年)             | eg:2018                   |
| 1    | tm_mon(月)              | range [1, 12]             |
| 2    | tm_mday(日)             | range [1, 31]             |
| 3    | tm_hour(时)             | range [0, 23]             |
| 4    | tm_min(分)              | range [0, 59]             |
| 5    | tm_sec(秒)              | range [0, 61]             |
| 6    | tm_wday(星期几)         | range [0, 6](0表示周日)   |
| 7    | tm_yday(一年中的第几天)   | range [1, 366]            |
| 8    | tm_isdst(是否是夏令时)   | 0, 1 or -1                |

datetime模块

datetime.datetime.now().strftime("%Y-%m-%d %X")

主要是时间相关的封装,案例在time模块的下面:

In [4]:

import time

# 时间戳,结果是float类型
print(time.time())

# 格式化的时间字符串:年-月-日 小时:分钟:秒
print(time.strftime("%Y-%m-%d%X"))


print(time.localtime())  # 本地时区的 struct_time
print(time.gmtime())  # UTC时区(世界标准时间)的struct_time

# time.mktime 将一个 struct_time 转化为时间戳
print(time.mktime(time.localtime()))

# t = time.localtime()
# print(time.asctime(t)) # 把一个表示时间的元组或者struct_time表示为这种形式:'Sun Jun 20 23:21:05 1993'
# print(time.asctime()) # 不写参数默认就是time.localtime()

 

1530595914.981183
2018-07-03 13:31:54
time.struct_time(tm_year=2018, tm_mon=7, tm_mday=3, tm_hour=13, tm_min=31, tm_sec=54, tm_wday=1, tm_yday=184, tm_isdst=0)
time.struct_time(tm_year=2018, tm_mon=7, tm_mday=3, tm_hour=5, tm_min=31, tm_sec=54, tm_wday=1, tm_yday=184, tm_isdst=0)
1530595914.0

In [5]:

import datetime

print(datetime.datetime.now())  # 当前时间 2018-07-03 13:02:20.824494
print(datetime.datetime.now().strftime("%Y-%m-%d%X"))  # 当前时间 2018-07-03 13:02:20

# 时间加减
print(datetime.datetime.now()   datetime.timedelta(3))  # 当前时间 3天
print(datetime.datetime.now()   datetime.timedelta(-3))  # 当前时间-3天
print(datetime.datetime.now()   datetime.timedelta(hours=3))  # 当前时间 3小时
print(datetime.datetime.now()   datetime.timedelta(minutes=30))  # 当前时间 30分

 

2018-07-03 13:31:55.147268
2018-07-03 13:31:55
2018-07-06 13:31:55.147883
2018-06-30 13:31:55.148109
2018-07-03 16:31:55.148315
2018-07-03 14:01:55.148532

 

NameErrorTraceback (most recent call last)

注意

7.2.random¶

random小明有好好研究,于是抢着讲解:

常用方法主要是这几个:

random.random():大于0且小于1之间的小数

random.randint(1, 3):[1,3] 大于等于1且小于等于3之间的整数

random.randrange(1, 3):[1,3) 大于等于1且小于3之间的整数

random.choice([4, 'a', [1, 2]]):随机返回三者之一

random.uniform(1, 3):大于1小于3的小数,如1.927109612082716

random.sample(old_list, 5):从list中随机获取5个元素,作为一个片断返回

random.shuffle(old_list):打乱list的顺序

下面来看看例子吧(最下面有个简单验证码的demo):

In [6]:

import random

In [7]:

print(random.random())  # 大于0且小于1之间的小数

print(random.randint(1, 3))  # [1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1, 3))  # [1,3)    大于等于1且小于3之间的整数

print(random.choice([4, 'a', [1, 2]]))  # 随机返回三者之一

print(random.uniform(1, 3))  # 大于1小于3的小数,如1.927109612082716

 

0.08269940155686328
3
2
[1, 2]
2.1607974783487136

In [8]:

# 从list中随机获取N个元素,作为一个片断返回
old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = random.sample(old_list, 5)  # 从list中随机获取5个元素,作为一个片断返回
print(old_list)
print(new_list)  # 原有序列并没有改变

 

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[7, 6, 9, 10, 3]

In [9]:

test_list = [1, 3, 5, 7, 9]
random.shuffle(test_list)  # 打乱test_list的顺序
print(test_list)

 

[1, 5, 7, 9, 3]

In [10]:

# 简单验证码的例子
import random


def get_code(n):
    """简单验证码"""
    code = ""
    for i in range(n):
        s1 = chr(random.randint(65, 90))  # 字母
        s2 = str(random.randint(0, 9))  # 数字
        code  = random.choice([s1, s2])  # 随机返回s1 or s2
    return code


def main():
    print(get_code(4))


if __name__ == '__main__':
    main()

 

KOOH

 

in ()

·不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入

7.3.hashlib¶

一看到hashlib,小明就退缩了,只能继续听伟哥讲解:

官方文档:

简单hash:hashlib.sha256(pass_str.encode("utf-8")).hexdigest()

和key一起加密:

import hashlib

pass_str = "123456"

m = hashlib.sha256()

m.update(pass_str.encode("utf-8"))

m.update("你设置的key".encode("utf-8"))

pass_str_new = m.hexdigest()

扩展:python 还有一个hmac模块,它内部对我们创建keypass进行处理后再加密:

In [11]:

import hashlib

pass_str = "123456"

In [12]:

# 简单hash一下
m = hashlib.sha256()

m.update(pass_str.encode("utf-8"))

pass_str_new = m.hexdigest()

print(pass_str_new)
print(len(pass_str_new))

 

8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
64

In [13]:

# 简写:
hashlib.sha256(pass_str.encode("utf-8")).hexdigest()

Out[13]:

'8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92'

In [14]:

# 简写这么方便为什么要像上面例子那么复杂呢?
# 直接加密的方式可以通过撞库破解,但你可以设置个key来加大难度
# 大部分网站都是用平台key   用户key(可以是用户创建时间或者id之类的不变信息)来加密的
m = hashlib.sha256()

m.update(pass_str.encode("utf-8"))

m.update("你设置的key".encode("utf-8"))

pass_str_new = m.hexdigest()

print(pass_str_new)
print(len(pass_str_new))

 

fadc86f44ab0f13346bf3293b5bc51112569a21e421809f93a096c917d7731ce
64

 

常用模块里面还有很多,就不一一介绍了,比如:functools里面的偏函数partial

这个我们下次讲闭包相关知识会说的functools.partial(函数名, 默认参数1,默认参数2...)

----> 1 time.sleep(1)

1.1.3from … import *

8.第三方模块安装¶

第三方模块安装之前有说过:

简单提一下:(pip官网)

pip install 模块名 # 正常

sudo pip install 模块名 # 没权限运行

pip install --user 模块名 # conda下的pip

貌似win下面有一个模块比较火virtualenv,作用好像可以使得pip安装的模块不会直接安装到系统中

因为逆天是Ubuntu的,所以具体的情况我不太清楚,你可以作为扩展了解下(参考)


NameError: name 'time' is not defined

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

9.包系列(导入、发布、安装)¶

如果不同的人编写的模块名相同怎么办?

小明抢答曰:”为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)“

小张斜了一眼小明补充道:”相互间有联系功能的模块可以放在一个包里,这个包就有点像C#的文件夹和类库的概念了“

小明不服气的把小潘那段代码的开头贴了出来:import matplotlib.pyplot as plt,然后叫嚣道:”怎么样,这个肯定用到了包“

In [3]:

frommodnameimport*

9.1.包的定义¶

课代表看着这两个活宝,然后继续讲解道:

模块是一组Python代码的集合,可以使用其他模块,也可以被其他模块使用

比如一个模块的名称是A.B, 那么他表示一个包A中的子模块B

刚说完,小明就得意的看着小张,然后继续听课:

创建自己的模块时,要注意:

  1. 模块名要遵循Python变量命名规范,不要使用中文、特殊字符
  2. 模块名不要和系统模块名冲突(标准库)

下面我们来一个简单的案例:

自己定义一个包,目录结构如下:(__init__.py是空文件)

web/
├── data.py
├── __init__.py
└── json.py

调用web包里面的get_json()方法:

from web.json import get_json

get_json()

或者:

import web.json as json

json.get_json()

每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则Python就把这个目录当成普通目录

__init__.py可以是空文件,编译器默认会把它认成名字是文件夹名的模块,eg:web

In [3]:

注意

9.2.包的制定化 ~ 控制可使用的模块¶

还记得之前讲得__all__吧,如果你想控制包里面的模块能否被访问使用,可以使用它

比如web包下的init文件中写下这一句:__all__ = ["json"]

神奇的事情发生了:

from web import *

json.get_json()

data.get_data()

在调用data.get_data()的时候出现了如下错误:

NameError: name 'data' is not defined

小明想到了自己当时的那顿饭,然后用当时的思路试了下:

# 你这样调就不行了
import web

web.data.get_data()

发现和上面一样的错误,然后夸张的说道~“哈哈哈,这种方式无敌了,里面有谁能调data模块下的get_data()方法我就请他喝饮料!”

话刚落完,发现大家刷刷的提交了相同的代码:

# 同样的,你硬是要调,python也拿你没办法
import web.data as data

data.get_data()

小明顿时崩溃了,自我安慰到:“反正都是要请你们吃晚饭的了,也不差这饮料了...”

 

In [3]: tt.sleep(1)

·这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

9.3.发布一个包¶

把我们之前的Code做一个包,目录结构如下:

├── datalib
│   ├── base
│   │   ├── get_user_infos.py
│   │   ├── __init__.py
│   │   ├── test1.py
│   │   ├── test2.py
│   │   ├── test3.py
│   │   ├── test4.py
│   │   └── test.py
│   ├── __init__.py
│   ├── main.py
│   └── web
│       ├── data.py
│       ├── __init__.py
│       └── json.py
└── setup.py

模块的目录结构中包含一个setup.py文件,用于定义模块名称、包含的模块等模块信息

固定格式如下:

setup(name="模块名称", version="版本", description="模块描述", author="模块作者", py_modules=[包含的模块内容])

以demo为例:

from distutils.core import setup

setup(
    name="datalib",
    version="1.0",
    description="数据相关的模块",
    author="小明",
    py_modules=[
        "datalib.base.get_user_infos", "datalib.base.test", "datalib.web.json"
    ])

build命令(构建模块):python setup.py sdist 来张图更形象:

澳门新浦京娱乐场网站 46

build文件夹:

dnt@MZY-PC:~/xiaoming/build$ tree
.
└── lib
    └── datalib
        ├── base
        │   ├── get_user_infos.py
        │   ├── __init__.py
        │   └── test.py
        └── web
            ├── __init__.py
            └── json.py

生成发布压缩包:python3 setup.py sdist 他会帮你打包成一个tar.gz的压缩包

其实你不构建,直接sdist也是可以的

dnt@MZY-PC:~/xiaoming$ tree
.
├── datalib
│   ├── base
│   │   ├── get_user_infos.py
│   │   ├── __init__.py
│   │   ├── test1.py
│   │   ├── test2.py
│   │   ├── test3.py
│   │   ├── test4.py
│   │   └── test.py
│   ├── __init__.py
│   ├── main.py
│   └── web
│       ├── data.py
│       ├── __init__.py
│       └── json.py
├── dist
│   └── datalib-1.0.tar.gz
├── MANIFEST
└── setup.py

In [4]:

1.1.4as

9.4.安装自己打包的模块¶

安装比较简单,如果是build文件夹,直接sudo python setup.py install

如果是tar.gz,那么解压后再执行sudo python setup.py install

当然了,也可以目录安装:python setup.py install --prefix=路径

查看包内容:tar -tvf datalib-1.0.tar.gz

解包:tar -zxvf datalib-1.0.tar.gz

这些基础命令如果还不是很熟悉的话,可以看看逆天2015年写的LinuxBase文档

其实说句心里话,2015开始摸索虚拟机中的Linux,几年提升肯定是有的,但是绝对没有这几个月的Linux真机开发来得快

逆天还是建议程序员尽快适应Linux环境开发,刚开始的确不方便,适应之后就感觉Win特别麻烦了...

很多东西一个指令就可以实现的,重复执行的东西写个脚本批量执行

当然了你Win下各种跑脚本也是一样的,但是别忘了~公司服务器基本上都是Linux的,该面对的总该来的,加油~

 

In [4]:

In [1]: import time as tt

CSharp包相关知识¶

Old C#相关的知识可以参考:如何在nuget上传自己的包

NetCore可以用打包命令:dotnet-pack来打包成Nuget包,官方文档说的很详细了,就不一一复述了

打包当前目录中的项目:dotnet pack

打包 app1 项目:dotnet pack ~/projects/app1/project.csproj

打包当前目录中的项目并将生成的包放置到 nupkgs 文件夹:

dotnet pack --output nupkgs

将当前目录中的项目打包到 nupkgs 文件夹并跳过生成步骤:

dotnet pack --no-build --output nupkgs

使用 PackageVersion MSBuild 属性将包版本设置为 2.1.0:

dotnet pack /p:PackageVersion=2.1.0

打包特定目标框架的项目:

dotnet pack /p:TargetFrameworks=net45

打包项目,并使用特定运行时 (Windows 10) 进行还原操作(.NET Core SDK 2.0 及更高版本):

dotnet pack --runtime win10-x64

 

小明听完了这节课,感叹道~ “模块用起来真是爽啊”

然后问道:“为什么老师没讲呢?”

其他人一起鄙视小明说道:“你自己睡大觉你自己心里没有点逼数吗?”

小明大囧,感觉饮料和饭钱真是白花了。。。(完)

In [4]: from time import sleep as sp

In [2]: time.sleep(1)

In [5]: sleep(1)



NameError                                 Traceback (most recent call last)

NameErrorTraceback (most recent call last)

in ()

in ()

----> 1 time.sleep(1)

----> 1 sleep(1)

NameError: name 'time' is not defined

NameError: name 'sleep' is not defined

In [3]:

In [6]:

In [3]:

In [6]:

In [3]: tt.sleep(1)

In [6]: sp(1)

In [4]:

In [7]:

In [4]:

1.1.5定位模块

In [4]: from time import sleep as sp

当导入一个模块时,Python解析器对模块位置的搜索顺序是:

In [5]: sleep(1)

1.当前目录


2.如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。

NameError                                 Traceback (most recent call last)

3.如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/

in ()

4.模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

----> 1 sleep(1)

1.2模块制作

NameError: name 'sleep' is not defined

1.2.1定义自己的模块

In [6]:

每个Python文件都可以作为一个模块,模块的名字就是文件的名字。

In [6]:

创建文件test.py,在test.py中定义函数add

In [6]: sp(1)

test.py

In [7]:

defadd(a,b):

1.1.5定位模块

returna b

当你导入一个模块,Python解析器对模块位置的搜索顺序是:

1.2.2调用自己定义的模块

1.当前目录

在其他文件中就可以先import test,然后通过test.add(a,b)来调用,当然也可以通过from test import add来引入

2.如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。

main.py

3.如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/

importtest

4.模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

result = test.add(11,22)

1.2模块制作

print(result)

1.2.1定义自己的模块

1.2.3测试模块

在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。

python在执行一个文件时有个变量__name__

比如有这样一个文件test.py,在test.py中定义了函数add

可以根据__name__变量的结果能够判断出,是直接执行的python脚本还是被引入执行的,从而能够有选择性的执行测试代码

test.py

__name__如果写在被直接运行的主文件中,是”__main__”

defadd(a,b):

如果写在被导入的文件中,运行主文件的时候,导入文件中的__name__是”模块的名字”

returna b

1.3模块中的__all__

1.2.2调用自己定义的模块

·如果一个文件中有__all__变量,那么也就意味着这个变量中的元素,不会被from xxx import *时导入

那么在其他文件中就可以先import test,然后通过test.add(a,b)来调用了,当然也可以通过from test import add来引入

1.4python中的包

main.py

importtest

·包将有联系的模块组织在一起,即放到同一个文件夹下,并且在这个文件夹创建一个名字为__init__.py文件,那么这个文件夹就称之为包

result = test.add(11,22)

·有效避免模块名称冲突问题,让应用组织结构更加清晰

print(result)

1.4.1__init__.py文件有什么用

1.2.3测试模块

__init__.py控制着包的导入行为

在实际开中,当一个开发人员编写完一个模块后,为了让模块能够在项目中达到想要的效果,这个开发人员会自行在py文件中添加一些测试信息,例如:

1.4.1.1__init__.py为空

test.py

仅仅是把这个包导入,不会导入包中的模块

defadd(a,b):

1.4.1.2__all__

returna b

在__init__.py文件中,定义一个__all__变量,它控制着from包名import *时导入的模块

#用来进行测试

1.4.1.3(了解)可以在__init__.py文件中编写内容

ret = add(12,22)

可以在__init__.py文件中编写语句,当导入时,这些语句就会被执行

print('int test.py file,,,,12 22=%d'%ret)

1.4.2扩展:嵌套的包

如果此时,在其他py文件中引入了此文件的话,想想看,测试的那段代码是否也会执行呢!

假定包的目录结构:

main.py

Phone/

importtest

__init__.py

result = test.add(11,22)

common_util.py

print(result)

Voicedta/

至此,可发现test.py中的测试代码,应该是单独执行test.py文件时才应该执行的,不应该是其他的文件中引用而执行

__init__.py

为了解决这个问题,python在执行一个文件时有个变量__name__

Pots.py

总结:

Isdn.py

·可以根据__name__变量的结果能够判断出,是直接执行的python脚本还是被引入执行的,从而能够有选择性的执行测试代码

Fax/

·__name__如果写在被直接运行的主文件中,是”__main__”

__init__.py

·如果写在被导入的文件中,运行主文件的时候,导入文件中的__name__是”模块的名字”

G3.py

1.4 python中的包

Mobile/

1.4.1 引入包

__init__.py

·包将有联系的模块组织在一起,即放到同一个文件夹下,并且在这个文件夹创建一个名字为__init__.py文件,那么这个文件夹就称之为包

Analog.py

·有效避免模块名称冲突问题,让应用组织结构更加清晰

igital.py

1.1.1扩展:嵌套的包

Pager/

假定我们的包的例子有如下的目录结构:

__init__.py

Phone/

Numeric.py

__init__.py

Phone是最顶层的包,Voicedta等是它的子包。可以这样导入子包:

common_util.py

import Phone.Mobile.Analog

Voicedta/

Phone.Mobile.Analog.dial()

__init__.py

也可使用from-import实现不同需求的导入

Pots.py

第一种方法是只导入顶层的子包,然后使用属性/点操作符向下引用子包树:

Isdn.py

from Phone import Mobile

Fax/

Mobile.Analog.dial('555-1212')

__init__.py

此外,还可以引用更多的子包:

G3.py

from Phone.Mobile import Analog

Mobile/

Analog.dial('555-1212')

__init__.py

事实上,可以一直沿子包的树状结构导入:

Analog.py

from Phone.Mobile.Analog import dial

igital.py

dial('555-1212')

Pager/

在上边的目录结构中,可以发现很多的__init__.py文件。这些是初始化模块,from-import语句导入子包时需要用到它。如果没有用到,他们可以是空文件。

__init__.py

包同样支持from-import all语句:

Numeric.py

from package.module import *

Phone是最顶层的包,Voicedta等是它的子包。 我们可以这样导入子包:

这样的语句会导入哪些文件取决于操作系统的文件系统。所以可以在__init__.py中加入__all__变量。该变量包含执行这样的语句时应该导入的模块的名字。它由一个模块名字符串列表组成.。

import Phone.Mobile.Analog

1.5模块发布

Phone.Mobile.Analog.dial()

1.mymodule目录结构体如下:

你也可使用from-import实现不同需求的导入

.

第一种方法是只导入顶层的子包,然后使用属性/点操作符向下引用子包树:

├── setup.py

from Phone import Mobile

├── suba

Mobile.Analog.dial('555-1212')

│├── aa.py

此外,我们可以还引用更多的子包:

│├── bb.py

from Phone.Mobile import Analog

│└── __init__.py

Analog.dial('555-1212')

└── subb

事实上,你可以一直沿子包的树状结构导入:

├── cc.py

from Phone.Mobile.Analog import dial

├── dd.py

dial('555-1212')

└── __init__.py

在我们上边的目录结构中,我们可以发现很多的__init__.py文件。这些是初始化模块,from-import语句导入子包时需要用到它。 如果没有用到,他们可以是空文件。

2.编辑setup.py文件

包同样支持from-import all语句:

py_modules需指明所需包含的py文件

from package.module import *

fromdistutils.coreimportsetup

然而,这样的语句会导入哪些文件取决于操作系统的文件系统。所以我们在__init__.py中加入__all__变量。该变量包含执行这样的语句时应该导入的模块的名字。它由一个模块名字符串列表组成.。

setup(name="yongGe", version="1.0", description="yongGe's module", author="yongGe", py_modules=['suba.aa','suba.bb','subb.cc','subb.dd'])

1.1模块发布

3.构建模块

1.mymodule目录结构体如下:

python setup.py build

.

构建后目录结构

├── setup.py

.

├── suba

├── build

│   ├── aa.py

│└── lib.linux-i686-2.7

│   ├── bb.py

│├── suba

│   └── __init__.py

││├── aa.py

└── subb

││├── bb.py

├── cc.py

││└── __init__.py

├── dd.py

│└── subb

└── __init__.py

│├── cc.py

2.编辑setup.py文件

│├── dd.py

py_modules需指明所需包含的py文件

│└── __init__.py

fromdistutils.coreimportsetup

├── setup.py

setup(name="yongGe", version="1.0", description="yongGe's module", author="yongGe", py_modules=['suba.aa','suba.bb','subb.cc','subb.dd'])

├── suba

3.构建模块

│├── aa.py

python setup.py build

│├── bb.py

构建后目录结构

│└── __init__.py

.

└── subb

├── build

├── cc.py

│   └── lib.linux-i686-2.7

├── dd.py

│       ├── suba

└── __init__.py

│       │   ├── aa.py

4.生成发布压缩包

│       │   ├── bb.py

python setup.py sdist

│       │   └── __init__.py

打包后,生成最终发布压缩包yongGe-1.0.tar.gz

│       └── subb

,目录结构

│           ├── cc.py

.

│           ├── dd.py

├── build

│           └── __init__.py

│└── lib.linux-i686-2.7

├── setup.py

│├── suba

├── suba

││├── aa.py

│   ├── aa.py

││├── bb.py

│   ├── bb.py

││└── __init__.py

│   └── __init__.py

│└── subb

└── subb

│├── cc.py

├── cc.py

│├── dd.py

├── dd.py

│└── __init__.py

└── __init__.py

├── dist

4.生成发布压缩包

│└── yongGe-1.0.tar.gz

python setup.py sdist

├── MANIFEST

打包后,生成最终发布压缩包yongGe-1.0.tar.gz ,目录结构

├── setup.py

.

├── suba

├── build

│├── aa.py

│   └── lib.linux-i686-2.7

│├── bb.py

│       ├── suba

│└── __init__.py

│       │   ├── aa.py

└── subb

│       │   ├── bb.py

├── cc.py

│       │   └── __init__.py

├── dd.py

│       └── subb

└── __init__.py

│           ├── cc.py

1.6模块安装、使用

│           ├── dd.py

1.6.1.1安装的方式

│           └── __init__.py

1.找到模块的压缩包

├── dist

2.解压

│   └── yongGe-1.0.tar.gz

3.进入文件夹

├── MANIFEST

4.执行命令python

├── setup.py

setup.py install

├── suba

注意:

│   ├── aa.py

·如果在install的时候,执行目录安装,可以使用python

│   ├── bb.py

setup.py install --prefix=安装路径

│   └── __init__.py

1.6.1.2模块的引入

└── subb

在程序中,使用from import即可完成对安装的模块使用

├── cc.py

from模块名import模块名或者*

├── dd.py

└── __init__.py

1.2模块安装、使用

1.2.0.1安装的方式

1.找到模块的压缩包

2.解压

3.进入文件夹

4.执行命令python setup.py install

注意:

·如果在install的时候,执行目录安装,可以使用python setup.py install --prefix=安装路径

1.2.0.2模块的引入

在程序中,使用from import即可完成对安装的模块使用

from模块名import模块名或者*

0.���'��

本文由澳门新浦京娱乐场网站发布于澳门新浦京娱乐场网站,转载请注明出处:澳门新浦京娱乐场网站Python中的模块介绍和行使