目录
1.模块的导入
import module1,module2
from module1 import * # 导入所有，易冲突
from module1 import m1,m2,m3
from module1 import logger as logger_long # 重命名
2.import模块的本质就是把模块.py解释一遍
import包的本质是运行其下的__init__.py文件
不能直接调用包下的模块,需要在init中from . import module1（相对导入）
例：
import package1
package1.module1 # 无法调用
importlib模块
import importlib
aa = importlib.import_module("lib.aa")
print(aa.name)
3.time，datetime模块，random模块
time模块-时间的表示
import time
print(time.time()) # 获得当前时间戳*********s，以1974年开始计算
# 不加参数默认当前时间
print(time.localtime()) # 时间tuple，年，月，日...
# time.struct_time(tm_year=2018, tm_mon=9, tm_mday=23, tm_hour=16, tm_min=34, tm_sec=57,
# tm_wday=6, tm_yday=266, tm_isdst=0) 一周中的第几天，一年中的第几天，是否夏令时DST（0否）
# 24个时区，UTC+8
print(time.timezone) # 时区，以s为单位
t = time.localtime()
# time.sleep(5)
print(time.gmtime()) # 时间戳转换成时间tuple(UTC0)，默认当前时间
print(time.localtime()) # 时间戳转换成时间tuple(本地)，默认本地当前时间
print(time.mktime(t)) # 时间tuple(本地)转换成时间戳，必须填入tuple
print(time.strftime("%Y-%m-%d %H:%M:%S", t)) # 将时间tuple转化成格式化字符串 2018-09-23 17:05:32
print(time.strptime("2018-09-23 17:05:32", "%Y-%m-%d %H:%M:%S")) # 将格式化字符串转换成时间tuple
print(time.asctime()) # 时间tuple(本地)转换成格式化字符串，默认当前时间
print(time.ctime()) # 时间戳(本地)转换成格式化字符串，默认当前时间
# print(help(time.strftime))
'''
%Y Year with century as a decimal number.
%m Month as a decimal number [01,12].
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%M Minute as a decimal number [00,59].
%S Second as a decimal number [00,61].
%z Time zone offset from UTC.
%a Locale's abbreviated weekday name.
%A Locale's full weekday name.
%b Locale's abbreviated month name.
%B Locale's full month name.
%c Locale's appropriate date and time representation.
%I Hour (12-hour clock) as a decimal number [01,12].
%p Locale's equivalent of either AM or PM.
'''
datatime时间加减
import datetime
print(datetime.datetime.now()) # 当前时间 2018-09-23 17:43:05.334686
print(datetime.datetime.now() + datetime.timedelta(3)) # 3天后的时间
print(datetime.datetime.now() + datetime.timedelta(hours=3)) # 3h后的时间
c_time = datetime.datetime.now()
print(c_time.replace(minute=3, hour=2)) # 时间替换
# 1.把datetime转成字符串
def datetime_toString(dt):
print("1.把datetime转成字符串: ", dt.strftime(dt,"%Y-%m-%d %H:%M:%S"))
# 2.把字符串转成datetime
def string_toDatetime():
print("2.把字符串转成datetime: ", datetime.datetime.strptime("2018-09-23 17:43:05", "%Y-%m-%d %H:%M:%S"))
random模块
import random
print(random.random()) # 0.6445010863311293 # 生成一个0到1的随机符点数: 0 <= n < 1.0
print(random.uniform(1, 10)) # 9.887001463194844
print(random.randint(1, 7)) # 生成随机整数n: a <= n <= b
print(random.randrange(1, 100, 2)) # 从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，
print(random.choice('liukuni')) # random.choice从序列中获取一个随机元素。
# 下面是使用choice的一些例子：
print(random.choice("学习Python")) # 学
print(random.choice(["JGood", "is", "a", "handsome", "boy"])) # List
print(random.sample([1, 2, 3, 4, 5], 3)) # [1, 2, 5] # 从指定序列中随机获取指定长度的片断。
print(random.sample('abcdefghij', 3)) # ['f', 'h', 'd']
items = [1, 2, 3, 4, 5, 6, 7]
random.shuffle(items) # 打乱
print(items)
# 生成随机验证码
import random
checkcode = ''
for i in range(4): # 四位验证码
current = random.randrange(0, 4)
if current != i: # 随机字母
temp = chr(random.randint(65, 90)) # 字母65~69，chr将整数转换成对应的ASCII字符
else: # 随机数字
temp = random.randint(0, 9)
checkcode += str(temp)
print(checkcode)
4. os模块,shutil模块 文件处理模块
os模块
import os
print(os.getcwd())
# os.chdir(r"C:DATACode")
print(os.getcwd())
# os.curdir
print(os.getcwd())
path = os.curdir
print(path + 'day5')
# 操作
# os.chdir(r"C:DATACode") #切换目录
# print(os.getcwd()) #获取当前目录
# print(os.curdir) #返回当前目录
# print(os.pardir) #返回父目录
# # os.makedirs(r'C:DATACodestudyday5 est') #生成多级递归目录,上级目录不存在则创建
# # os.removedirs(r'C:DATACodestudyday5 est') #逐层清理空文件夹
# os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname，上级目录不存在报错
# os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
# 获取信息
# os.listdir('dirname') 列出所有文件和子目录，包括隐藏文件，并以列表方式打印
# os.stat('path/filename') 获取文件/目录信息
# os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
# os.linesep 输出当前平台使用的行终止符，win下为"
",Linux下为"
"
# os.pathsep 输出用于分割文件路径的字符串
# os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
# os.system("bash command") 运行shell命令，直接显示
# os.environ 获取系统环境变量
# os.remove() 删除一个文件
# os.rename("oldname","newname") 重命名文件/目录
# os.system('ipconfig /all') #系统命令符
# os.path.basename(__file__) #文件名
# os.path.dirname(__file__) #目录名
# os.path.abspath(path) 返回path规范化的绝对路径
# os.path.split(path) 将path分割成目录和文件名二元组返回
# os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
# os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
# os.path.exists(r'C:DATACodestudyday5 est') #是否存在 isfile isdir
# os.path.isabs(r'C:DATACodestudyday5 est') #是否绝对路径
# os.path.join(r'C:',r'DATACodestudyday5 est') #连接 第一个绝对路径前的值将被忽略
# os.path.getatime(r'C:DATACodestudyday5 est.txt') #最后存储时间
# os.path.getmtime(r'C:DATACodestudyday5 est.txt') #最后修改时间
shutil模块 文件处理模块，比os好
# 内置模块shutil
# http://www.cnblogs.com/wupeiqi/articles/4963027.html
import shutil
# f1 = open('test', 'r')
# f2 = open('test2.txt', 'a')
# shutil.copyfileobj(f1, f2)
shutil.copyfile('test2.txt', 'test3.txt') # 与上述代码作用一样
shutil.make_archive('C:DATACodestudyday5', 'zip')
# shutil.copystat("本节笔记","笔记3") #拷贝状态的信息，包括：mode bits, atime, mtime, flags
# shutil.copytree("test4","new_test4") # 递归的去拷贝文件，拷贝子目录及文件
# shutil.rmtree("new_test4") # 递归的去删除文件，删除子目录及文件
# shutil.move(src, dst) #递归的去移动文件
# shutil.make_archive("shutil_archive_test", "zip","E:PyProjectsday1") #创建压缩包并返回文件路径
import zipfile
z = zipfile.ZipFile("day5.zip", "w") # 打开
z.write("p_test.py") # 将文件压缩近z
print("-----") # 干点别的事
z.write("笔记2") # 继续压缩
z.close()
5.shelve 数据序列化/持久化，类似pickle
# 序列化
# shelve模块是一个简单的key，value将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式
import shelve
import datetime
d = shelve.open('shelve_test') # 打开一个文件
# 数据存储，将产生三个文件dat，bak，dir
# class Test(object):
# def __init__(self,n):
# self.n = n
# t = Test(1213)
# info = {'age':22,"job":'it'}
# name = ["alex", "rain", "test"]
#
# d["name"] = name # 持久化列表
# d["info"] = info # 持久dict
# d['t1'] = t # 持久化类的实例
# d['date'] = datetime.datetime.now()
# 数据读取
print(d.get("name"))
print(d.get("info"))
print(d.get("date"))
# print(d.get('t1'))
d.close()
6.xml, json数据序列化传输
xml模块
xml是实现不同语言或程序之间进行数据交换的协议，
跟json差不多，但json使用起来更简单，
不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，
至今很多传统公司如金融行业的很多系统的接口还主要是xml。
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
# 遍历xml文档
# for child in root:
# print(child.tag, child.attrib)
# for i in child:
# print(i.tag, i.text,i.attrib)
# 只遍历year 节点
for node in root.iter('year'):
print(node.tag, node.text)
#xml文件创建
new_xml = ET.Element("personinfolist")
personinfo = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "yes"})
name = ET.SubElement(personinfo, "name")
name.text = "Alex Li"
age = ET.SubElement(personinfo, "age", attrib={"checked": "no"})
sex = ET.SubElement(personinfo, "sex")
age.text = '56'
personinfo2 = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "no"})
name = ET.SubElement(personinfo2, "name")
name.text = "Oldboy Ran"
age = ET.SubElement(personinfo2, "age")
age.text = '19'
et = ET.ElementTree(new_xml) # 生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True)
ET.dump(new_xml) # 打印生成的格式
# 修改xml数据
tree = ET.parse("xmltest.xml")
root = tree.getroot()
# 修改
# for node in root.iter('year'):
# new_year = int(node.text) + 1
# node.text = str(new_year)
# node.set("updated_by", "Alex")
#
# tree.write("xmltest.xml")
# 删除node
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('output.xml')
json模块 - 数据序列化
import json
# 只能处理简单的数据
ret = 'sdas'
json.dumps() # 存
json.dumps(ret, ensure_ascii=False, indent=4) # 为方便查看，不转换成ascii码，且使用4空格缩进
json.loads() # 取
json.dump() # 能直接处理类文件对象(具有read()或者write()方法的对象)，
# 比如with open(...) as f的f，不需要将f.read()，就能dump
json.load()
import pickle
# 处理复杂数据
pickle.dumps() # 保存的是二进制
7.configparser模块 - 配置文件处理
# 用于生成和修改常见配置文档
import configparser
# 创建配置文件
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
config['topsecret.server.com']['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)
# 读
conf = configparser.ConfigParser()
conf.read("example.ini")
print(conf.defaults())
print(conf['bitbucket.org']['user'])
#print(conf.sections())
sec = conf.remove_section('bitbucket.org')
conf.write(open('example.ini', "w"))
8.正则表达式 Re
import re
s = '1-2*(-1388337.0476190478-'
a = re.search(r"-[^+-]*$", s) # 匹配
if not a:
print('a', a)
re.match('', s) # （从头找一个）re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search('', s) # （找一个）re.search 扫描整个字符串并返回第一个成功的匹配。
re.findall('', s) # ***（找所有，返回列表）
re.sub('', '', s) # （替换,前者替换后者）
pattern = re.compile('') # （编译正则字符串，提高效率）
pattern.search(s) # 此处pattern具有与re一致的函数，但参数需要放进compile内
r"a/nb" # 原始字符串r，=="a//nb", 加r表示自动转义，不需加\,
# 但用在re中可以匹配"a/nb"，不能匹配"a//nb"，建议使用，能忽略目标对象转义的影响
# ‘
’长度为1，r’
’长度为2
re.findall(r"a.*bc", "a
bc", re.DOTALL) # -> a
bc
re.findall(r"a(.*)bc", "a
bc", re.DOTALL) # ->
# 不分组时匹配的是全部，分组后匹配的是组内的内容
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式：
line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（
、
）之外的任何单个或多个字符
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print ("matchObj.group() : ", matchObj.group()) # Cats are smarter than dogs
print ("matchObj.group(1) : ", matchObj.group(1)) # Cats
print ("matchObj.group(2) : ", matchObj.group(2)) # smarter
else:
print ("No match!!")
匹配规则：
'''
^ 匹配字符串的开头
$ 匹配字符串的末尾。
. 匹配任意字符，除了/n换行符，(贪婪),加re.DOTALL或re.S参数则可以匹配包括换行符的任意字符。
re.sub的第4个参数不是flags ，而是counts。re.DOTALL的值是16 因此re.sub(.., re.DOTALL)将只替换16次。
将flags指定为关键字参数将解决您的问题：
re.sub(r'<fig(.*?)</fig>', ' ', xml, flags=re.DOTALL)
* 匹配0个或多个表达式。(贪婪)
+ 匹配1个或多个表达式。(贪婪)
? 匹配0个或1个表达式。加在其他限定符后面表示非贪婪方式
*?, +?, ?? *+?的非贪婪模式，匹配尽可能少的字符
对任一特定字符进行转义
w 匹配字母数字及下划线
W 匹配非字母数字及下划线
s 匹配任意空白字符，等价于 [
f].
S 匹配任意非空字符
d 匹配任意数字，等价于 [0-9].
D 匹配任意非数字
A 匹配字符串开始处
匹配字符串结束处，如果是存在换行，只匹配到换行前的结束字符串。
z 匹配字符串结束处
G 匹配最后匹配完成的位置。
匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
B 匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
, , 等. 匹配一个换行符。匹配一个制表符。等
1...9 匹配第n个分组的内容。
10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
[...] 表示或 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
a|b 匹配a或b
{n} 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
{n,} 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
{n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
(...) 匹配括号内的表达式，也表示一个组,分组的内容在完成匹配后可以提取出来，而且可以在后面1引用，称为回溯引用
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。re.I（忽略大小写），re.L（依赖区域设置），re.M（多行），re.S（点号匹配所有字符），re.U（依赖Unicode），re.X（详细模式）
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: ...) 类似 (...), 但是不表示一个组
(?imx: ...) 在括号中使用i, m, 或 x 可选标志
(?-imx: ...) 在括号中不使用i, m, 或 x 可选标志
(?#...) 注释.
(?=...) 前向肯定界定符（lookahead assertion）。
当前面的匹配条件后跟 ... 时才匹配，但不引用 ... 的内容。
(?!...) 前向否定界定符（negative lookahead assertion）。
当前面的匹配条件后不跟 ... 时才匹配，但不引用 ... 的内容。
(?<=...) 后向肯定界定符（positive lookbehind assertion）。
当后面的匹配条件前面有...时才匹配，但不引用...的内容。...只能匹配固定长度的字符串，不定长度的不能使用.
(?<!...) 后向否定界定符（negative lookbehind assertion）。
当后面的匹配条件前面没有...时才匹配，但不引用...的内容。
(?(id/name)yes-pattern|no-pattern) ，
当组id或name对应的组()匹配成功后，匹配yes-pattern的内容，否则匹配no-pattern的内容
'''
9.map模块
http://blog.51cto.com/egon09/1840425
10.hashlib模块 - 数据加密
import hashlib
# m = hashlib.md5()
# m.update(b"Hello")
# print(m.hexdigest()) #16进制md5值
# m.update(b"It's been a long time since we spoken...")
m2 = hashlib.md5()
m2.update("HelloIt's me天王盖地虎".encode(encoding="utf-8"))
print(m2.hexdigest())
#
# s2 = hashlib.sha1()
# s2.update(b"HelloIt's me")
# print(s2.hexdigest())
#hmac，它内部对我们创建 key和内容 再进行处理然后再加密
# 散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。
# 使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；
# 一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，
# 然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，
# 拿加密后的值 跟 发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。
import hmac
h = hmac.new(b"12345","you are 250你是".encode(encoding="utf-8"))
print(h.digest())
print(h.hexdigest())
11. 异常处理try,except
class My_exception(Exception):
def __init__(self,msg):
self.messge = msg
def __str__(self):
return self.messge
try:
ll = [1,2,3,4]
# a =ll[4]
# raise Exception('主动触发异常')
# raise My_exception('自定义异常')
except (IndexError,KeyError) as e: # 抓特定异常
print(e)
except My_exception as e: # 抓自定义异常
print(e)
except Exception as e: # 抓住所有异常，建议用在最后
print(e)
else: # 没出异常
print('一切正常')
finally: # 不管是否异常都会执行
print('一定会走')
12.assert
a = 0
assert a == 1 # 断言，简化if判断，不正确则抛异常
print('重要代码')