python-模块

pycharm中设置：file——setting——project：xxx——project structure——选中.py模块所在路径然后点击“source”——ok

模块化

• 将一个完整的程序分解为一个一个小的模块
• 通过将模块组合，来搭建出一个完整的程序
• 不采用模块化，统一将所有的代码编写到一个文件中
• 采用模块化，将程序分别编写到多个文件中
• 模块化优点
  • 方便开发
  • 方便维护
  • 模块可以复用

模块

• 在python中，一个py文件就是一个模块
• 模块名要符合标识符的规范

在一个模块中引入外部模块

import  模块名  #（模块名，就是python文件的名字，注意不要py）
import 模块名 as 模块别名

• import 可以在程序的任意位置调用，一般情况下，import语句都会统一写在程序的开头
• 在每一个模块内部都有一个 __name__属性,通过这个属性可以获取到模块的名字
• __name__ 属性值为 __main__ 的模块是主模块，一个程序中只会有一个主模块
• 主模块就是直接通过python执行的模块

示例：

test_module.py

# print('我是test_module')
print(__name__)

main.py

import test_module as test

# print(test.__name__)
print(__name__)  # __main__

访问模块中的变量

模块名.变量名

m.py

a = 10
b = 20

def test():
    print('test')

def test2():
    print('test2')

class Person:
    def __init__(self):
        self.name = '孙悟空'

main.py

import m

print(m.a, m.b)

m.test()
m.test2()

p = m.Person()
print(p.name)

引入模块中的部分内容

语法：

from 模块名 import 变量,变量,...

示例：
m.py

a = 10
b = 20

def test():
    print('test')

def test2():
    print('test2')

class Person:
    def __init__(self):
        self.name = '孙悟空'

main.py

from m import Person
# from m import test,Person
# from m import * #引入模块中所有内容，一般不会使用
p1 = Person()
print(p1)
#test()
#test2()

引入变量使用别名

语法：

from 模块名 import 变量 as 别名

模块私有

• 添加了 _ 的变量，只能在模块内部访问

模块标准编写方式

a = 10
b = 20
_c = 30

def test():
    print('test')

def test2():
    print('test2')

class Person:
    def __init__(self):
        self.name = '孙悟空'

if __name__ == '__main__':
    test()
    test2()
    p = Person()
    print(p.name)

包

• 包也是一个模块
• 当模块中代码过多时，或者一个模块需要被分解为多个模块时，就需要使用包
• 包是一个目录
• 包中必须要有一个 __init__.py 这个文件
• __pycache__ 是模块的缓存文件
• 为了提高程序运行的性能，python会在编译过一次以后，将代码保存到一个缓存文件中

hello/__init__.py

def test():
    print('test')

hello/a.py

c = 30

hello/b.py

d = 40

main.py

import hello
from hello import a, b

print(a.c)
print(b.d)
hello.test()

pycharm导入自己写的包

在python安装路径的site-packets目录下建立module_pwcong.pth , 然后将此文件的根目录（最接近的包目录）复制到此pth文件中即可

C:\Python36\Lib\site-packages\module_pwcong.pth 文件写入以下路径

D:\pyProject\myproject1\jenkins_ldap

python标准库

https://docs.python.org/zh-cn/3.6/py-modindex.html

时间模块

• 时间戳：从1970年到现在经过的秒数
• 格式化的字符串形式
• 结构化的时间

import time

# 时间戳
# 用于时间间隔的计算
print(time.time())

# 格式化的字符串形式
# 用于展示时间
print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
print(time.strftime('%Y-%m-%d %X'))

# 结构化的时间
# 用于单独获取时间的某一部分
res = time.localtime()
print(res)
print(res.tm_year)

import datetime
print(datetime.datetime.now())
print(datetime.datetime.now() + datetime.timedelta(days=3)) #三天后的时间
print(datetime.datetime.now() + datetime.timedelta(days=-3)) #三天前的时间
print(datetime.datetime.now() + datetime.timedelta(weeks=1)) #一周后的时间

时间格式转化

import time
# struct_time -> 时间戳
# s_time = time.localtime()
# print(time.mktime(s_time))

# 时间戳 -> struct_time
# tp_time = time.time()
# print(time.localtime(tp_time))

# 世界标准时间与本地时间
# print(time.localtime())
# print(time.gmtime()) # 世界标准时间
# print(time.localtime(333333333))
# print(time.gmtime(333333333))

# struct_time -> 格式化的字符串时间
s_time = time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S', s_time))

#  格式化的字符串时间 -> struct_time
print(time.strptime('1988-03-03 11:11:11', '%Y-%m-%d %H:%M:%S'))

# format string <----> timestamp
struct_time = time.strptime('1988-03-03 11:11:11', '%Y-%m-%d %H:%M:%S')
timestamp = time.mktime(struct_time) + 7 * 86400
print(timestamp)

res = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))
print(res)

import time
print(time.asctime())

import datetime
print(datetime.datetime.now())
print(datetime.datetime.utcnow())
print(datetime.datetime.fromtimestamp(333333333)) # 1980-07-25 08:35:33

random模块

import random

print(random.random()) # (0,1)--float
print(random.randint(1, 3)) # [1,3]
print(random.randrange(1, 3)) # [1,3)
print(random.choice([1, 'aaa', [4, 5]])) # 1或者23或者[4,5]
print(random.sample([1, 'aaa', 'ccc', 'ddd'], 2)) # 列表元素任意2个组合
print(random.uniform(1, 3)) # 大于1小于3的小数
item = [1, 3, 5, 7, 9]
random.shuffle(item) # 打乱item的顺序，相当于'洗牌'
print(item)

# 随机验证码
import random

def make_code(size=4):
    res=''
    for i in range(size):
        s1 = chr(random.randint(65, 90))
        s2 = str(random.randint(0, 9))
        res += random.choice([s1, s2])
    return res

print(make_code(6))

sys模块

• 提供了一些变量和函数，可以获取到python解析器的信息或者通过函数操作python解析器

1 sys.argv           命令行参数List，第一个元素是程序本身路径
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称

sys.argv

• 获取执行代码时，命令行中的参数
• 该属性是一个列表，列表中保存了当前命令行的所有参数

import sys
print(sys.argv) # 获取解释器后的参数值

执行结果：

python python标准库.py aa bb cc
['python标准库.py', 'aa', 'bb', 'cc']

import sys

# print(sys.argv)

src_file = sys.argv[1]
dst_file = sys.argv[2]

with open(r'%s' %src_file, mode='rb') as read_f, \
    open(r'%s' %dst_file, mode='wb') as write_f:
    for line in read_f:
        write_f.write(line)

打印进度条

import time

def progress(percent):
    if percent > 1:
        percent = 1
    res = int(50 * percent) * '#'
    print('\r[%-50s] %d%%' % (res, int(percent * 100)), end='')


recv_size = 0
total_size = 333333

while recv_size < total_size:
    time.sleep(0.01)
    recv_size += 1024
    percent = recv_size / total_size
    progress(percent)

sys.modules

• 获取当前程序中引入的所有模块
• modules是一个字典，字典的key是模块的名字，字典的value是模块对象

sys.path

• 是一个列表，列表中保存的是模块的搜索路径

sys.platform

• 表示当前python运行的平台

sys.exit()

• 该函数用来退出程序

import sys
print(sys.argv)
# print(sys.modules)

import pprint
# pprint.pprint(sys.modules)

# pprint.pprint(sys.path)
print(sys.platform)

sys.exit('程序出现异常，结束')
print('hello')

os

• 可以对操作系统进行访问

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

os.environ

• 可以获取到系统的环境变量

os.system()

• 可以执行操作系统的命令

import os
print(os)
pprint.pprint(os.environ['path'])
os.system('notepad')

import os

# res = os.listdir(r'D:\工作')
# print(res)
#
# size = os.path.getsize(r'D:\supporting.txt')
# print(size)
#
# os.system("dir c:\\")
#
# print(os.environ) # key与value必须都为字符串
# os.environ['aaaaaaaaaa']='111'
# print(os.environ)

# print(os.path.abspath(__file__))
# print(__file__)

# res = os.path.split('C:\\a\\b\\c\\d.txt')
# print(res)

print(os.path.dirname(r'C:\\a\\b\\c\\d.txt'))
print(os.path.basename(r'C:\\a\\b\\c\\d.txt'))

print(os.path.isabs('C:\\a\\b\\c'))

print(os.path.isfile('2.random模块.py'))
print(os.path.isfile('aaa'))
print(os.path.isdir('aaa'))

print(os.path.join('a','b','c','d')) # a\b\c\d
print(os.path.join('a','C:','b','c','d')) # C:b\c\d


print(os.path.normpath('C:\\a\\b\\c\\d\\..\\..'))
# 推荐使用
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
print(BASE_DIR)


BASE_DIR = os.path.normpath(os.path.join(
    __file__,
    '..',
    '..'
))
print(BASE_DIR)

from pathlib import Path

root = Path(__file__)
res = root.parent.parent
print(res)

res = Path('/a/b/c') / 'd/e.txt'
print(res)
print(res.resolve())