Python学习笔记13_模块

1
2
3
4
import time		# 使用 	import 模块名 		直接导入
time.time()		# 模块名.函数名 	使用模块里的函数
time.sleep(3)	# 可以使用模块里所有的函数或变量

1
2
3
from random import randint		# 使用	 form 模块名 import 函数名/子包名 	导入模块里一个函数或变量
randint(0,2)	# 直接使用且只能使用这一个函数

1
2
3
4
5
6
7
from math import *		# 使用 	form 模块名 import * 		导入模块里所用函数和变量

# 可以直接使用模块里所有函数和变量
print(pi)	
abs(-4)		

1
2
3
import datetime as dt	# 导入一个模块,并起一个别名
dt.MAXYEAR		# 使用别名代替原模块名

1
2
3
from copy import deepcopy as dp		# 导入模块里一个函数或变量,并起一个别名
dp(['hello','good'[1,5,9],'yes'])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 也可以一次导入多个模块，多个模块之间用逗号隔开。
# 导入sys、os两个模块
import sys,os


# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
import sys as s,os as o


# 导入sys模块的argv,winver成员
from sys import argv, winver


# 导入sys模块的argv,winver成员，并为其指定别名v、wv
from sys import argv as v, winver as wv

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from modname1 import *
from modname2 import *
from modname3 import *

# 这样写代码的时候，代码中的变量会变得非常混乱。不仅仅是后面导入的同名函数会覆盖前面的问题，而且导致在写一个函数的时候不能确定它到底来自哪里，代码可读性会变得非常差。


# 建议尽量这样写
import modname1
import modname2
import modname3

modname1.def1()
modname2.def1()
modname3.def1()
# 这样不仅不会找不见同名函数，也可以非常确切的看到这个函数来自哪里


# 如果库一层套一层，是这样的结构：
import path1.path2.path3.modname1
# 可以用as关键字给它重命名，以便于缩短代码宽度，维持可读性
import path1.path2.path3.modname1 as pm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import os

# 返回正在使用的平台。如果是windows则用‘nt’表示，对于linux/unix用户则用'posix'表示。
os.name		

# 返回当前python脚本工作的目录路径。
os.getcwd()		
# 返回一个当前工作目录的Unicode对象
os.getcwdb()
# 获取当前目录的父目录，以字符串形式显示目录名。
os.pardir()

# 获取环境配置
os.environ	
# 获取指定环境配置
os.environ.get('PATH')	

# 返回指定目录下的所有文件和目录名，括号里如果调用函数则不用双引号或单引号，如果是传入一个路径，则必须要用双引号或单引号将变量标识为一个整体，否则报错。括号内可以：1）调用函数 2）传入参数（即路径）
os.listdir()	

# 重命名
os.rename(name,name1)	
# 删除一个文件，括号里必须是文件的指定路径
os.remove("文件路径")   
# 删除空文件夹
os.rmdir('文件夹路径')	
 # 删除空文件夹
os.removedirs('文件夹路径')	
# 创建一个文件夹
os.mkdir()		

# 运行shell命令
os.system("shell命令")	

# 改变当前脚本的工作目录,相当于shell下的cd命令
os.chdir(path)		
# 返回上级目录
os.chdir('../')	

# 取代操作系统特定的路径分隔符，python是跨平台的，在windows上，文件的路径分隔符是''。为了让代码在不同的平台上上都能运行，使用os.sep会根据你所处的平台，自动采用相应的分隔符号。
os.sep()		

# 返回当前平台使用的行终止符，Linux使用'n', windows使用'rn', mac使用'r'.
os.linesep()		

# 获取文件的属性信息。
os.path 模块
# 返回一个路径的目录名和文件名
os.path.split()		
# 检验给出的是否为文件
os.path.isfile()	
# 检验给出的是否为文件夹	
os.path.isdir() 		
# 检验给出的路径是否真实存在
os.path.exists()		
# 获得文件的绝对路径
os.path.abspath(name)	
# 规范path字符串形式
os.path.normpath(path)		
# 获取文件大小(字节); 在没写文件的路径的时候,默认的是当前的工作路径
os.path.getsize(name)	
# 分离文件名与扩展名
os.path.splitext()		
# 连接目录与文件名或目录
os.path.join(path,name)		
# 返回文件名，不包含拓展名
os.path.basename(path)		
# 返回文件路径
os.path.dirname(path)		

# 更改权限
os.chmod(path,flags)
# 更改文件所有者
os.chown(path,uid,gid)

# 改变当前进程的根目录
os.chroot(path)

# 关闭文件描述符 fd
os.close(fd)
# 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
os.closerange(fd_low,fd_high)
# 复制文件描述符 fd
os.dup(fd)
# 将一个文件描述符 fd 复制到另一个 fd2
os.dup2(fd,fd2)
# 通过文件描述符改变当前工作目录
os.fchdir(fd)
# 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
os.fchmod(fd,mod)
# 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
os.fchown(fd,uid,gid)
# 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
os.fdatafsync(fd)
# 强制将文件描述符为fd的文件写入硬盘。
os.fsync(fd)

# 打开一个文件，并且设置需要的打开选项，mode参数是可选的
os.fopen(file,flags[,mode])
# 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
os.pipe()
# 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
os.read(fd,n)

# 删除文件路径
os.unlink(path)

# 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
os.write(fd,str)

1
2
3
4
5
6
7
8
9
10
import sys
print(sys.path)		# 返回一个列表,列出查找模块的所有路径
sys.argv		# 传递给Python脚本的命令行参数列表
sys.exit()		# 程序退出,和内置函数exit功能一样

sys.stdin		# 接收用户输入
sys.stdout		# 标准输出, 改变默认输出位置(如:输出到一个文件里)
sys.stderr		# 改变错误输出的默认位置

1
2
3
4
5
6
7
>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757

>>> math.log(1024, 2)
10.0

1
2
3
4
5
6
7
8
9
10
11
12
>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'

>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]

>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'


>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import time		# 导入时间模块
start = time.time()		# 获取当前时间戳
#时间戳就是格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起到现在的总秒数

time.sleep(3)	# 延时3秒
time.localtime(start)	# 格式化时间戳为本地时间, 返回一个时间元组

time.asctime(time.localtime(start))	#接受一个时间元组并返回一个可读的形式


time.ctime([secs])	# 需要一个时间戳,如果没有则返回计算机时间	
time.gmtime()	# 返回一个格林威治天文时间下的时间

end=time.time();

lenTime=end-start		# 单位为秒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41

>>> t = zlib.compress(s)
>>> len(t)
37

>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

1
2
3
4
>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

1
2
3
4
5
6
>>> import re
>>> re.findall(r'bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(b[a-z]+) 1', r'1', 'cat in the the hat')
'cat in the hat'

1
2
3
>>> 'tea for too'.replace('too', 'two')
'tea for two'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     line = line.decode('utf-8')  # Decoding the binary data to text.
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print(line)

<BR>Nov. 25, 09:43:32 PM EST

>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()

1
2
3
4
5
6
7
import hashlib

# 需要将加密的内容转化为二进制
x=hashlib.md5()		# 生成一个md5对象
x.update('123'.encode('utf8'))
print(x.hexdigest())

1
2
3
4
5
6
7
8
9
10
11
# hmac模块也是一种单向的加密算法,并且它是基于各种哈希算法/散列算法,
# 只是它可以在运算的过程中,使用一种密钥来增强安全性,hmac模块实现了HAMC算法,
# 提供了相应的函数和方法,且与hashlib提供的api基本一致.
import hmac

h = hmac.new(bytes('secret_key','utf8'),bytes('ssssddddddd','utf8'),hashlib.sha1)
#第一个参数是密钥key，第二个参数是待加密的字符串，第三个参数是hash函数
# Python3 key和带加密字符串需转换为bytes类型,且需要utf8编码
result = h.hexdigest()
print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 下载安装第三方库
pip install <库名>		

# 卸载第三方库
pip uninstall <库名>		

# 列出当前环境安装了哪些模块和版本号
pip list		

# 列出当前环境安装了哪些模块和版本号
pip freeze		

# 重定向,即将安装的库及对应的版本号放到 requirements.txt文件里
pip freeze > requirements.txt		

# 读取并安装文件里的库
pip -r install requirements.txt		

# 临时从指定网站下载
pip install <库名> -i <网址> 		

1
2
3
4
5
[global]
index-url=https://mirrors.aliyun.com/pypi/simple
[install]
trusted-host=mirrors.aliyun.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
__all__ = ['m', 'date']
'''from <模块名> import * 语法只能调用__all__列表包含的变量和函数,
如果没有__all__才会导入所有的变量和函数,但不能导入以一个下换线开始的变量和函数'''

m = 'hello'
a = 1000


def date():
    print('我是模块里的name')


# 约定俗成: 以一个下划线开始的变量和函数只在本模块内部使用,不建议外部调用,如果强行调用可能会崩
_x = 'world'  # 使用 from <> impport * 语法无法调用以一个下划线开始的变量和函数，通过不将 _x放入 __all__来保证使用 import * 不会导入 _x



def _qute():
    print('我是_qute函数')
    
def division(a,b):
    return a/b


# __name__当直接运行py文件时,值是__main__
# 如果这个py文件作为模块导入时,值是文件名
if __name__=='__main__':       # 使用次语句可以检测模块里的函数,而在调用时不执行以下内容
    print('模块里的name是:',__name__)    # 模块里的name是: __main__
    print('测试一下 division 函数,结果是:',division(4,2))


# 在最后使用del函数删除变量和函数,即使外部强行调用也会崩,没有删除的可以调用
# 约定俗成:只删除以一个下划线开始的变量和函数
del (_x)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...