一 模块

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

导入方式 一般为 ： import 模块名

在python中， 模块一般分为四个通用类别

1使用python编写.py 文件

2、已被编译为共享库或DLL 的c 或c++扩展

3把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

4、使用c编写并链接到python解释器的内置模块

使用模块的优点：

1、从文件级别组织程序， 更方便管理

2、拿来主义， 提升开发效率

二 使用模块 import

导入模块 import

1：语法： import 模块名

2：在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果

1、为源文件穿件新的名称空间，
2、在新建的名称空间中执行模块中包含的代码。
3、创建名字（模块名）来引用该名称空间

3：被导入的模块 有独立的名称空间

每个模块都是一个独立的名称空间， 定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间， 这样我们在编写自己的模块时， 就不用担心我们定义在自己模块中全局变量会被导入时 ， 与使用者的全局变量冲突。

4 为模块名起别名

为依据导入的模块起别人的方式对编写可扩展的代码很有用

import span as sm

5 在一行中导入多个模块   模块名中间用 “，” 分隔

import sys,os,re

三 使用模块 form.....import

1、from...import 的使用

1 from 模块名 import  要读的read1，read2

2 、import  和from ....import   的对比

唯一区别就是：使用from。。import... 则是将spam 中的名字直接导入到当前的名称空间中， 所有在当前名称空间中， 直接使用名字就可以了， 无需加前缀 模块名

优点:使用起来方便了
缺点：容易与当前执行文件中的名字冲突

3、也支持重命名 as

 from spam import read1 as read

4、一行导入多个名字

from spam import read1,read2,money

5、 导入所有   from。。。。import *

#from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置

四：py 文件区分两种用途：模块与脚本

编写好的一个python文件 可以有两种途径：

一：脚本，一个文件就是整个程序，用来被执行
二 ：模块，文件中存放着一堆功能，用来呗导入使用

#python为我们内置了全局变量__name__，
    当文件被当做脚本执行时：__name__ 等于‘__main__‘
    当文件被当做模块导入时：__name__等于模块名

#作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
    if __name__ == ‘__main__‘:

五：模块的搜索路径

模块的查找顺序：内存中已经加载的模块-->内置模块---->sys.path路径中包含的模块

包

包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

需要强调的是：

1、在python3中，即使包下没有__init__.py 文件，import包仍然不会报错，而python2中若是没有的话， 就会报错

2、创建包的目的不是为了运行， 而是被导入使用， 记住，包只是模块的一种形式而已，包的本质就是一种模块

一、包的使用之import

1 import glance.db.models
2 glance.db.models.register_models(‘mysql‘) 

二：包的使用之 from。。。import。。。

1 from glance.db import models

强调：

1、在导入时带点，  点的左边必须是一个包， 这是导入包特有的语法
2、包内， 模块直接的导入应该使用from。。。import。。。
3、from。。。import。。。。 import后必须是一个明确的名字， 没有任何的前缀。

from a.b.c.f  import g.h.x    # 这是错误的

#f 的左边必须是包
import后的名字不能有任何的前缀， 不能有 .

常用模块

一、time和datetime 模块

在python中通常有这几种方式来表达时间：

1：时间戳（timestamp）:通常来说， 时间戳表示的是从1970年1月1日 00:00:00 开始按照秒计算的偏移量

2：格式化的时间字符串(Format String)

3：结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

二、random模块

 1 import random
 2
 3 print(random.random())#(0,1)----float    大于0且小于1之间的小数
 4
 5 print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
 6
 7 print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数
 8
 9 print(random.choice([1,‘23‘,[4,5]]))#1或者23或者[4,5]
10
11 print(random.sample([1,‘23‘,[4,5]],2))#列表元素任意2个组合
12
13 print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716
14
15
16 item=[1,3,5,7,9]
17 random.shuffle(item) #打乱item的顺序,相当于"洗牌"
18 print(item)

三： os 模块

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下为"\t\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路径处理：

推荐使用：

import  os

import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)

四: sys模块

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       返回操作系统平台名称

五  序列化：json&pickle

序列化：我们把对象（变量）从内存中编程可存储或传输的过程称之为序列化，在python中pickling.

序列化的优点：

1：持久保存状态

2：跨平台数据交互  （其中pickle只能读取python文件，不能跨平台）

import json
import pickle

注意：json 不认单引号，

序列化：

序列化：
json。dumps(dic)
pickle.dumps(s)

反序列化：
json.loads()
pickle.loads()

六 hashlib 模块

1：hash:一种算法， 该算法接受传入的内容，经过运算得到一串 hash值

hash 值得特点是：

#只要传入的内容是一样的 得到的hash值必然一样。

#不能由hash值返解成内容 ===》把密码做成hash值，不应该在网络传输明文密码

#只要使用的hash算法不变， 无论小燕的内容多大， 得到的hash值长度是固定的

# import hashlib
#
# m=hashlib.md5()
# m.update(‘hello‘.encode(‘utf-8‘))
# m.update(‘world‘.encode(‘utf-8‘))
# m.update(‘egon‘.encode(‘utf-8‘))
# print(m.hexdigest()) #3801fab9b8c8d9fcb481017969843ed5

密码加盐

import  hashlib
pwd="alex12345"

m=hashlib.me5()
m.update("一行白鹭上青天")
m.update(pwd.encode("utf-8"))
print(m.hexdigest())

七 re模块（正则）

正则就是用一些具有特殊含义的符号组合到一起（正则表达式）来描述字符或者字符串的方法。或者说正则就是 用来描述一列事物的规则。

在（python 它内嵌在python中， 并通过re模块来实现。

二 常用匹配模式（元字符）

 =================================匹配模式=================================
#一对一的匹配
# ‘hello‘.replace(old,new)
# ‘hello‘.find(‘pattern‘)

#正则匹配
import re
#\w与\W
print(re.findall(‘\w‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\W‘,‘hello egon 123‘)) #[‘ ‘, ‘ ‘]

#\s与\S
print(re.findall(‘\s‘,‘hello  egon  123‘)) #[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘]
print(re.findall(‘\S‘,‘hello  egon  123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]

#\n \t都是空,都可以被\s匹配
print(re.findall(‘\s‘,‘hello \n egon \t 123‘)) #[‘ ‘, ‘\n‘, ‘ ‘, ‘ ‘, ‘\t‘, ‘ ‘]

#\n与\t
print(re.findall(r‘\n‘,‘hello egon \n123‘)) #[‘\n‘]
print(re.findall(r‘\t‘,‘hello egon\t123‘)) #[‘\n‘]

#\d与\D
print(re.findall(‘\d‘,‘hello egon 123‘)) #[‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\D‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘]

#\A与\Z
print(re.findall(‘\Ahe‘,‘hello egon 123‘)) #[‘he‘],\A==>^
print(re.findall(‘123\Z‘,‘hello egon 123‘)) #[‘he‘],\Z==>$

#^与$
print(re.findall(‘^h‘,‘hello egon 123‘)) #[‘h‘]
print(re.findall(‘3$‘,‘hello egon 123‘)) #[‘3‘]

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall(‘a.b‘,‘a1b‘)) #[‘a1b‘]
print(re.findall(‘a.b‘,‘a1b a*b a b aaab‘)) #[‘a1b‘, ‘a*b‘, ‘a b‘, ‘aab‘]
print(re.findall(‘a.b‘,‘a\nb‘)) #[]
print(re.findall(‘a.b‘,‘a\nb‘,re.S)) #[‘a\nb‘]
print(re.findall(‘a.b‘,‘a\nb‘,re.DOTALL)) #[‘a\nb‘]同上一条意思一样

#*
print(re.findall(‘ab*‘,‘bbbbbbb‘)) #[]
print(re.findall(‘ab*‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab*‘,‘abbbb‘)) #[‘abbbb‘]

#?
print(re.findall(‘ab?‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab?‘,‘abbb‘)) #[‘ab‘]
#匹配所有包含小数在内的数字
print(re.findall(‘\d+\.?\d*‘,"asdfasdf123as1.13dfa12adsf1asdf3")) #[‘123‘, ‘1.13‘, ‘12‘, ‘1‘, ‘3‘]

#.*默认为贪婪匹配
print(re.findall(‘a.*b‘,‘a1b22222222b‘)) #[‘a1b22222222b‘]

#.*?为非贪婪匹配：推荐使用
print(re.findall(‘a.*?b‘,‘a1b22222222b‘)) #[‘a1b‘]

#+
print(re.findall(‘ab+‘,‘a‘)) #[]
print(re.findall(‘ab+‘,‘abbb‘)) #[‘abbb‘]

#{n,m}
print(re.findall(‘ab{2}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{2,4}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{1,}‘,‘abbb‘)) #‘ab{1,}‘ ===> ‘ab+‘
print(re.findall(‘ab{0,}‘,‘abbb‘)) #‘ab{0,}‘ ===> ‘ab*‘

#[]
print(re.findall(‘a[1*-]b‘,‘a1b a*b a-b‘)) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall(‘a[^1*-]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[0-9]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[a-z]b‘,‘a1b a*b a-b a=b aeb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[a-zA-Z]b‘,‘a1b a*b a-b a=b aeb aEb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]

#\# print(re.findall(‘a\\c‘,‘a\c‘)) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
print(re.findall(r‘a\\c‘,‘a\c‘)) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall(‘a\\\\c‘,‘a\c‘)) #同上面的意思一样，和上面的结果一样都是[‘a\\c‘]

#():分组
print(re.findall(‘ab+‘,‘ababab123‘)) #[‘ab‘, ‘ab‘, ‘ab‘]
print(re.findall(‘(ab)+123‘,‘ababab123‘)) #[‘ab‘]，匹配到末尾的ab123中的ab
print(re.findall(‘(?:ab)+123‘,‘ababab123‘)) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall(‘href="(.*?)"‘,‘<a href="http://www.baidu.com">点击</a>‘))#[‘http://www.baidu.com‘]
print(re.findall(‘href="(?:.*?)"‘,‘<a href="http://www.baidu.com">点击</a>‘))#[‘href="http://www.baidu.com"‘]

#|
print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘))

原文地址：https://www.cnblogs.com/lx3822/p/9141512.html