python 中 模块，包， 与常用模块

Posted 2020-11-11 C3的脚印

一 模块

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

导入方式 一般为 ： 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的大小

View Code

 

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\'))

View Code