python模块
1.概念
在python中一个.py文件就称为一个模块（Module），包带有__init__.py文件的，包用来组织模块.
import 模块：
1).执行对应文件（所以from cal import add也会执行文件），但是导入包，是执行__init__.py模块
2).引入变量名
3).sys.path就是import加载的目录，也就是执行文件的目录是import搜索的路径
from xxx import aa from就是帮你加了一个xxx\aa.py
imprt导入的是模块，也就是一个.py文件，from就是帮你加上一个路径，import中前面的相对论路径都是针对你运行的文件的相对路径来说的，理解这一点很重要
2.timem模块
时间戳 time.time() 从1976年到调用的秒数
结构化时间 time.localtime(seconds=None)：返回time.struct_time(tm_year=2018, tm_mon=3, tm_mday=20, tm_hour=20, tm_min=17, tm_sec=27, tm_wday=1, tm_yday=79, tm_isdst=0)
time.strftime('%Y-%m-%d %X',time.localtime())
time.strptime('2018-02-20','%Y-%m-%d')
print(time.time()) #1535445272.0377316
print(time.localtime())#time.struct_time(tm_year=2018, tm_mon=8, tm_mday=28, tm_hour=1, tm_min=34, tm_sec=32, tm_wday=1, tm_yday=240, tm_isdst=1)
print(time.strftime("%Y-%m-%d %X",time.localtime())) #2018-08-28 01:34:32
print(time.strptime('2018-02-20','%Y-%m-%d')) #time.struct_time(tm_year=2018, tm_mon=2, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=51, tm_isdst=-1)
3.os模块
BASE_DIR = os.path.dirname(os.path.abspath(__file__))，这样的话可以根据不同的运行环境都能找到绝对路径啦
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","new") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 用于分割文件路径的字符串
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所指向的文件或者目录的最后修改时间
4.sys模块
sys.argv 命令行参数List，第一个元素是程序本身路径 如你运行python a.py abc def 则sys.argv 会得到一个列表['a.py','abc','def']
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdin 输入相关
sys.stdout 输出相关 sys.stdout.write('#')会放在缓存中，sys.stdout.flush()刷新缓存，与终端交互
sys.stderror 错误相关
5.json模块
json的字符串必须双引号,因为json是一种通用的字符串,单引号只是针对python而言是通用的.
json.dumps(obj):将obj转换成一个json字符串
如果是类对象,是不是可以直接用json.dumps(obj)来处理呢?
class Man(object):
def __init__(self,name,age):
self.name = name
self.age = age
m = Man("chen",22)
print(json.dumps(m))#TypeError: <__main__.Man object at 0x7f12c30b5320> is not JSON serializable
会报错,错误的原因就是Man对象不是一个可序列化为JSON的对象.如果连class的实例对象都无法序列化为JSON,这肯定是不合理的.我们仔细看看dumps()方法的参数列表，可以发现，除了第一个必须的obj参数外，dumps()方法还提供了一大堆的可选参数：
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
# skipkeys: 如果为True的话，则只能是字典对象，否则会TypeError错误, 默认False
# ensure_ascii: 确定是否为ASCII编码
# check_circular: 循环类型检查，如果为True的话
# allow_nan: 确定是否为允许的值
# indent: 会以美观的方式来打印，呈现
# separators: 对象分隔符，默认为,
# encoding: 编码方式,默认为utf-8
# sort_keys: 如果是字典对象，选择True的话，会按照键的ASCII码来排序
这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把Man类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Man实例变为一个JSON的{}对象。
可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Man专门写一个转换函数，再把函数传进去即可：
class Man(object):
def __init__(self,name,age):
self.name = name
self.age = age
def obj_json(obj):
return {
"name":obj.name,
"age":obj.age
}
m = Man("chen",22)
data = json.dumps(m,default=obj_json)
print(type(data)) #<class 'str'>
print(data)
data = json.loads(data)
print(type(data)) #<class 'dict'>
print(data)
json.loads(obj):将一个json字符串转换为原来对应的数据类型
class Man(object):
def __init__(self,name,age):
self.name = name
self.age = age
def obj_json(obj):
return {
"name":obj.name,
"age":obj.age
}
m = Man("chen",22)
data = json.dumps(m,default=obj_json)
print(type(data)) #<class 'str'>
print(data)
data_dic = json.loads(data)
print(type(data_dic)) #<class 'dict'>
print(data_dic)
def handle(d):
return Man(d['name'],d['age'])
m = json.loads(data,object_hook=handle)
print(type(m)) #<class '__main__.Man'>
6.logging模块
a.logging.basicConfig方式
import logging
logging.basicConfig(
level=logging.DEBUG,
filename='log.log',
filemode='a',
format='%(asctime)s %(filename)s [%(lineno)d] %(message)s'
)
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.critical('critical message')
b.logger对象(类似于吸星大法)
import logging
logger = logging.getLogger() #创建一个根用户
fh = logging.FileHandler('test.log') #具有处理文件的能力
ch = logging.StreamHandler() #具有处理输出至屏幕的能力
#定义日志处理的格式
fm = logging.Formatter('%(asctime)s %(filename)s [%(lineno)d] %(message)s')
fh.setFormatter(fm)
ch.setFormatter(fm)
logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel(logging.DEBUG)
logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')
7.re模块
正则表达式是一种小型的、高度专业化的编程语言，它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节
元字符：.^$*+?{}[]|()\
.通配符，除了\n不能匹配，其它都能匹配
^以什么开头（必须在字符串的开头匹配），$在字符串的结尾匹配
重复符号*+?{}
*重复紧挨着的字符0-无穷次，+表示1-无穷次，？表示0-1，{0,n}表示0-n次{6}表示重复6次
前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加？号使其变成惰性匹配
av[abv]:[]表示是或的意思，匹配ava,avb,avv都行，如[a-z],[A-Z],[1-9],[^A-Z]^表示非的意思，在[]中只有这三个特殊字符有用-，^,$,其他的都是匹配字
符
转义字符\，能让普通字符变成有意义的，能让特殊字符变成普通字符
\d 匹配任何十进制数
\D 匹配任何非数字字符
\s 匹配任何空白字符
\S 匹配任何非空白字符
\w 匹配任何字符数字字符[a-zA-Z0-9_]
\W 匹配任何非字母数字字符[^a-zA-Z0-9_]
\b 匹配一个特殊字符边界，比如空格,&,#等
data1 = re.findall(r'c\\s','c\ssssc\s')
data2 = re.findall('c\\\\s','c\ssssc\s')
这两种情况是一样的，因为python解释器会做一步转义，而python解释器到re模块又需要做一步转义，所以需要四个\表示到re里两个了\\，r则表示直接通过re模块
分组：也就是指定的名字来获取自己只想要的某一部分数据，命名分组
# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
# 空的匹配也会包含在结果中
#findall(pattern, string, flags=0)
# search,浏览整个字符串去匹配第一个，未匹配成功返回None
# search(pattern, string, flags=0)，完全可以替代match啦，match紧在字符串开始处进行匹配
origin = "hello alex bcd abcd lge acd 19"
r = re.search("a(\w+).*(?P<name>\d)$", origin) 这里的分组可以通过r.group(name)获得第二个组里匹配的东西
print(r.group()) # 获取匹配到的所有结果 alex bcd abcd lge acd 19
print(r.groups()) # 获取模型中匹配到的分组结果 ('lex', '9')
print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组 {'name': '9'}
# sub，替换匹配成功的指定位置字符串
sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl ： 要替换的字符串或可执行对象
# string ： 要匹配的字符串
# count ： 指定匹配个数
# flags ： 匹配模式
re.findall('（abc)+','abcabcabc')显示输出的是['abc']
但是re.findall('（?:abc)+','abcabcabc')显示输出的是['abcabcabc'] ?:取消显示的优先级
浙公网安备 33010602011771号