1 import time
 2 print("返回标准时间（含年月日等信息）：",time.asctime())
 3 print("返回本地时间的struct time时间格式：",time.localtime())
 4 print("返回utc的struct时间对象格式：",time.gmtime(time.time()-800000))
 5 print("返回标准时间格式：",time.asctime(time.localtime()))
 6 print("返回标准时间格式：",time.ctime())
 7 # #
 8 # # #将日期字符串转换成时间戳
 9 string2_struct=time.strptime("2016/10/22","%Y/%m/%d")
10 print("将日期字符串转换成struct格式：",string2_struct)
11 # #
12 struct_2_stamp=time.mktime(string2_struct)
13 print("将struct转换成时间戳：",struct_2_stamp)
14 # #
15 # # #将时间戳转换为字符串
16 print(time.gmtime(time.time()-86640))  #将utc时间戳转换成structtime格式
17 print(time.altzone)
18 # #
19 # # #将utc struct_time 格式转成指定的字符串格式  格式化时间格式
20 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))
21 # #
22 # #
23 # # #datetime
24 import datetime
25 print("返回系统当前时间：",datetime.datetime.now())
26 print("标准格式;",datetime.datetime.fromtimestamp(time.time()))
27 # # #时间加减
28 print("当前时间加三天：",datetime.datetime.now()+datetime.timedelta(3))
29 print("当前时间减三天：",datetime.datetime.now()+datetime.timedelta(-3))
30 print("当前时间加三小时：",datetime.datetime.now()+datetime.timedelta(hours=3))
31 print("当前时间加30分钟：",datetime.datetime.now()+datetime.timedelta(minutes=30))
32 # #
33 # # #时间替换,即对现有时间的修改
34 c_time=datetime.datetime.now()
35 print(c_time.replace(minute=3,hour=2))

 1 import random
 2 print(random.randint(1,2))
 3 print(random.randrange(1,3))
 4 # #
 5 # # #生成随机验证码
 6 checkcode=""
 7 for i in range(4):
 8     current=random.randrange(0,4)
 9     if current!=i:
10         temp=chr(random.randint(65,90))
11     else:
12         temp=random.randint(0,9)
13     checkcode+=str(temp)
14 print("验证码为：",checkcode)
15 # #
16 # # # print("生成65-90之间的随机数：",random.randint(65,90))
17 # # # print("根据ASCII码转换：",chr(random.randint(65,90)))

 1 import random
 2 print(random.randint(1,2))
 3 print(random.randrange(1,3))
 4 # #
 5 # # #生成随机验证码
 6 checkcode=""
 7 for i in range(4):
 8     current=random.randrange(0,4)
 9     if current!=i:
10         temp=chr(random.randint(65,90))
11     else:
12         temp=random.randint(0,9)
13     checkcode+=str(temp)
14 print("验证码为：",checkcode)
15 # #
16 # # # print("生成65-90之间的随机数：",random.randint(65,90))
17 # # # print("根据ASCII码转换：",chr(random.randint(65,90)))

1 import sys   #用来提供对解释器的相关操作
2 print("返回模块的搜索路径，初始化时使用环境变量的值：",sys.path)
3 print(sys.argv)  #命令行参数list,第一个元素是程序本身路径

 1 import hashlib
 2 m=hashlib.md5()
 3 m.update(b"Hello")
 4 print("二进制格式加密：",m.digest())
 5 print("十六进制加密：",m.hexdigest(),len(m.hexdigest()))
 6 
 7 #sha1
 8 s1=hashlib.sha1()
 9 s1.update(b"Hello world")
10 print("SHA1:",s1.hexdigest(),len(s1.hexdigest()))
11 
12 s2=hashlib.sha224()
13 s2.update(b"Hello world")
14 print("SHA224:",s2.hexdigest(),len(s2.hexdigest()))
15 
16 s3=hashlib.sha256()
17 s3.update(b"Hello world")
18 print("SHA256:",s3.hexdigest(),len(s3.hexdigest()))
19 
20 s4=hashlib.sha384()
21 s4.update(b"Hello world")
22 print("SHA384:",s4.hexdigest(),len(s4.hexdigest()))
23 
24 s5=hashlib.sha512()
25 s5.update(b"Hello world")
26 print("SHA512:",s5.hexdigest(),len(s5.hexdigest()))
27 # # #由上述例子可以看出，不同的加密算法位数是不一样的，随着指数的增大，加密位数越来越多
28 # # #但是上述方法的加密可以通过撞库来反解,可以通过对加密算法添加自定义key来加密
29 m2=hashlib.md5(b"8jindeod098")
30 m2.update(b"Hello")
31 print("自定义参数加密：",m2.hexdigest())
32 # #
33 # # #更加牛逼的加密方式  内部对我们创建key和内容再进行处理后然后再加密
34 import hmac
35 h=hmac.new(b"Eric")
36 h.update(b"Hello world")
37 print("HMac:",h.hexdigest())

 1 #生成随机验证码的函数
 2 def code():
 3     _code = list()
 4     for i in range(4):
 5         ra = random.randrange(4)
 6         if i == ra:
 7             _code.append(chr(random.randrange(97, 122)))
 8         else:
 9             _code.append(str(i))
10     result = ‘‘.join(_code)
11     return result
12 print("123:",code())

 1 import pickle,json
 2 data=http://www.mamicode.com/{"k1":123,"k2":"Hello"}
 3 # # #pickle.dumps将数据通过特殊的形式转换为只有python语言认识的字符串
 4 p_str=pickle.dumps(data)
 5 print(p_str)
 6 ss=pickle.loads(p_str)
 7 print("111",ss)
 8 # #
 9 # # #pickle.dump将数据通过特殊形式转换为只有python认识的字符串，并写入文件
10 with open("result.pk","w") as f:
11     pickle.dump(data,f)
12 # #
13 import json
14 # # #json.dumps 将数据通过特殊的形式转换为所有程序语言都认识的字符串
15 j_str=json.dumps(data)
16 print(j_str)
17 # #
18 # # #json.dump将数据通过特殊形式转换为只有python认识的字符串，并写入文件
19 with open("result.json","w") as fp:
20     json.dump(data,fp)

 1 import re
 2 # # #正则表达式相关操作
 3 print()
 4 print("--------------------分隔符----------------------")
 5 origin = "hel1lo al2ex b1cd ab3cd lge acd 19"
 6 r=re.match("\w+",origin)   #从头开始匹配，匹配成功返回一个对象，不成功返回NONE
 7 print("获取匹配的所有结果：",r.group())
 8 #分组：提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
 9 print("获取匹配的分组结果：",r.groups())
10 
11 #浏览整个字符串去匹配第一个，未匹配成功返回None
12 r=re.search("\d+",origin)
13 print("浏览整个字符串，匹配第一个：",r.group())
14 #获取非重复的匹配列表，如果有一组则用列表形式返回
15 r=re.findall("\d+",origin)
16 print(r)
17 #替换匹配成功指定位置的字符串
18 r=re.sub("\d+","8888",origin,1)
19 print("替换匹配成功指定位置的字符串:",r)
20 
21 #split  根据正则匹配分割字符串
22 r=re.split("\d+",origin)
23 print("split:",r)
24 
25 origin1 = "hello alex bcd alex lge alex acd 19"
26 r1 = re.split("(alex)", origin1, 1)
27 print("用alex来拆分，但是保留Alex：",r1)
28 r2 = re.split("(al(ex))", origin1, 1)
29 print("用alex或ex来拆分，但是均保留：",r2)
30 
31 #匹配IP地址
32 str_ip="Hello,222.168.16.60,Welcome,13783417293,172560199@sina.com"
33 m=re.search("((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)",str_ip)
34 print("匹配到的IP是：",m.group())
35 m1=re.search("(1)([358]\d{9})",str_ip)
36 print("匹配到的电话为：",m1.group())
37 m2=re.search("[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+",str_ip)
38 print("匹配到的邮箱是：",m2.group())

 1 import configparser
 2 config=configparser.ConfigParser()
 3 config.read("Hello world",encoding="utf-8")
 4 ret=config.sections()
 5 print("获取所有的节点：",ret)
 6 
 7 #获取指定节点下的键值对
 8 ret1=config.items("sections1")
 9 print("获取sections1下的键值对：",ret1)
10 #获取制定节点下的所有键
11 ret2=config.options("sections1")
12 print(ret2)
13 #获取指定节点下指定key值
14 v=config.get("section1","k1")
15 print(v)
16 
17 # 检查、删除、添加节点
18 has_sec=config.has_section("section1")
19 print("是否存在节点：",has_sec)
20 
21 #添加节点
22 config.add_section("sect1")
23 config.write(open("Hello","w"))
24 ret=config.sections()
25 print("查看节点是否添加成功:",ret)
26 
27 #删除节点
28 config.remove_section("sect1")
29 config.write(open("Hello","w"))
30 ret=config.sections()
31 print("查看节点是否删除成功:",ret)
32 
33 #检查、删除、设置指定组内的键值对
34 #检查是否存在键：k1
35 has_opt=config.has_option("sect1","k1")
36 print(has_opt)
37 
38 #删除指定节点下的指定键
39 config.remove_option("sect1","k1")
40 config.write(open("Hello","w"))
41 
42 #设置指定节点下的键值对
43 config.set("sect1","k10","123")
44 config.write(open("Hello","w"))

  1 # #XML是实现不同语言或程序之间进行数据交换的协议
  2 #1、解析XML
  3 from xml.etree import ElementTree as ET
  4 #打开文件，读取XML内容,xo为xml文件
  5 str_xml=open("xo","r").read()
  6 # #将字符串解析成xml特殊对象，root代指xml文件的根节点
  7 root=ET.XML(str_xml)
  8 print(root)
  9 #
 10 # #直接解析xml文件
 11 tree=ET.parse("xo")
 12 # #获取xml文件的根节点
 13 root1=tree.getroot()
 14 print(root1)
 15 #
 16 # #遍历xml文档的所有内容
 17 # #顶层标签
 18 print("获取顶层节点：",root1.tag)
 19 #遍历xml文档的第二层
 20 for child in root1:
 21     #第二层节点的标签名和标签属性
 22     print(child.tag,child.attrib)
 23     #遍历xml 文档的第三层
 24     for i in child:
 25         print(i.tag,i.text)
 26 
 27 
 28 #遍历xml中指定的节点year
 29 for node in root1.iter("year"):
 30     print(node.tag,node.text)
 31 
 32 #修改节点的内容，由于修改节点时，均是在内存中进行，其不会影响文件中的内容
 33 #因此如果需要修改，则需要将重新将内存中的文件写入到文件
 34 
 35 for node in root1.iter("year"):
 36     #将year节点中的内容自增1
 37     new_year=int(node.text)+1
 38     node.text=str(new_year)
 39     #设置属性
 40     node.set("name","eric")
 41     node.set("age","99")
 42     #删除属性
 43     del node.attrib["name"]
 44 #
 45 #     #保存文件
 46 tree=ET.ElementTree(root1)
 47 tree.write("newnew.xml",encoding="utf-8")
 48 #
 49 for country in root1.findall("country"):
 50     #获取每一个country节点下rank节点的内容
 51     rank=int(country.find("rank").text)
 52     print(rank)
 53 
 54     if rank>50:
 55         root1.remove(country)
 56 #
 57 # #保存文件
 58 tree=ET.ElementTree(root1)
 59 tree.write("new1.xml",encoding="utf-8")
 60 
 61 #创建XML文档
 62 #创建根节点
 63 root2=ET.Element("family")
 64 #创建节点子节点
 65 son1=ET.Element("son",{"name":"son1"})
 66 son2=ET.Element("son",{"name":"son2"})
 67 #在第一个子节点中创建两个孙节点
 68 grandson1=ET.Element("grandson",{"name":"111"})
 69 grandson2=ET.Element("grandson",{"name":"222"})
 70 son1.append(grandson1)
 71 son1.append(grandson2)
 72 
 73 #将子节点添加到根节点中
 74 root2.append(son1)
 75 root2.append(son2)
 76 
 77 tree=ET.ElementTree(root2)
 78 tree.write("create1.xml",encoding="utf-8",short_empty_elements=False)
 79 
 80 #创建xml文档方法二
 81 root=ET.Element("family")
 82 #创建子节点，调用根节点的makeelementff
 83 son1=root.makeelement("son1",{"name":"son1"})
 84 son2=root.makeelement("son2",{"name":"son2"})
 85 
 86 #在son1中创建两个孙子节点
 87 grandson11=son1.makeelement("grandson11",{"name":"555"})
 88 grandson12=son1.makeelement("grandson12",{"name":"666"})
 89 
 90 son1.append(grandson11)
 91 son1.append(grandson12)
 92 
 93 root.append(son1)
 94 root.append(son2)
 95 
 96 tree1=ET.ElementTree(root)  #生成文档对象
 97 tree1.write("create2.xml",encoding="utf-8",short_empty_elements=False)  #将文档对象写入文件
 98 
 99 #创建xml文档方法三
100 #利用ET的SubElement方法进行创建
101 root=ET.Element("family")   #创建根节点
102 #创建第一个子节点
103 son1=ET.SubElement(root,"son1",attrib={"name":"son111"})
104 son2=ET.SubElement(root,"son2",attrib={"name":"son222"})
105 
106 #在第一个子节点中创建孙节点
107 grandson1=ET.SubElement(son1,"grandson11",attrib={"name":"grandson666"})
108 grandson1.text="孙子"
109 et=ET.ElementTree(root)
110 et.write("test.xml",encoding="utf-8",xml_declaration=True,short_empty_elements=False)
111 
112 #由上述例子的执行结果来看，均无法实现xml的缩进，若想要缩进的话，需要修改保存格式
113 from xml.dom import minidom
114 def prettify(elem):
115     """
116     将节点转换成字符串，并添加缩进
117     :param elem:要转换的对象
118     :return:
119     """
120     rough_string=ET.tostring(elem,"utf-8")
121     reparsed=minidom.parseString(rough_string)
122     return reparsed.toprettyxml(indent="\t")
123 #利用ET的SubElement方法进行创建
124 root=ET.Element("family")   #创建根节点
125 #创建第一个子节点
126 son1=ET.SubElement(root,"son1",attrib={"name":"son111"})
127 son2=ET.SubElement(root,"son2",attrib={"name":"son222"})
128 
129 #在第一个子节点中创建孙节点
130 grandson1=ET.SubElement(son1,"grandson11",attrib={"name":"grandson666"})
131 grandson1.text="孙子"
132 
133 raw_str=prettify(root)
134 with open("test2.xml","w",encoding="utf-8") as f:
135     f.write(raw_str)

 1 import urllib.request
 2 #python标准库中提供了：urllib等模块以供http请求，但是，他的API太渣，他是为另一个时代、另一个互联网
 3 #创建的，他需要巨量的工作，甚至包括各种方法覆盖，来完成最简单的任务
 4 #发送get请求
 5 f=urllib.request.urlopen("http://www.qq.com")
 6 result=f.read()
 7 print(result)
 8 
 9 #发送携带请求头的GET请求
10 req=urllib.request.Request("http://www.qq.com")
11 req.add_header("QQ","http://www.baidu.com")
12 r=urllib.request.urlopen(req)
13 result=r.read()
14 print(result)
15 
16 #Requests 是使用 Apache2 Licensed 许可证的 基于Python开发的HTTP 库，其在Python内置模块的基础上进行了高度的封装，从
17 # 而使得Pythoner进行网络请求时，变得美好了许多，使用Requests可以轻而易举的完成浏览器可有的任何操作。
18 #get和post的区别
19 #get:获取服务器的信息，而不进行修改;是安全的和幂等的，例如新闻的读取
20 #post:可能改变服务器上的资源；例如对新闻的评论就是用post
21 import requests
22 ret=requests.get("http://www.qq.com")
23 print(ret.url)
24 print(ret.text)
25 
26 payload={"key1":"value1","key2":"value2"}
27 ret=requests.get("http://sports.qq.com/nba/",params=payload)
28 print(ret.url)
29 print(ret.text)
30 
31 #基本post实例
32 payload={"key1":"value1","key2":"value2"}
33 ret=requests.post("http://sports.qq.com/a/20161027/023124.htm",data=http://www.mamicode.com/payload)
34 print(ret.text)
35 
36 import json
37 url="http://sports.qq.com/a/20161027/023124.htm"
38 payload={"some":"data"}
39 headers={‘content-type‘: ‘application/json‘}
40 ret=requests.post(url,data=http://www.mamicode.com/json.dumps(payload),headers=headers)
41 print(ret.text)
42 print(ret.cookies)
43 
44 #检测QQ是否在线
45 import urllib
46 import requests
47 from xml.etree import ElementTree as ET
48 r=requests.get("http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=172560199")
49 result=r.text
50 print(result)
51 # #解析xml格式的内容
52 node=ET.XML(result)
53 print(node.text)
54 # #获取内容
55 if node.text=="Y":
56     print("在线")
57 else:
58     print("离线")
59 
60 #查看火车停靠信息
61 r=requests.get("http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G651&UserID=")
62 result=r.text
63 print(r.text)
64 # #解析xml格式内容
65 root=ET.XML(result)
66 print(root.text)
67 for node in root.iter("TrainDetailInfo"):
68     print(node.find("TrainStation").text)
69     print("到达时间：",node.find("ArriveTime").text,"发车时间：",node.find("StartTime").text)
70 
71 #查询手机号归属地
72 r=requests.get("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo?mobileCode=13783417293&UserID=")
73 result=r.text
74 print(result)
75 node=ET.XML(result)
76 print(node.text)

 1 import logging
 2 logging.basicConfig(filename="log.log",
 3                     format="%(asctime)s-%(name)s-%(levelname)s-%(module)s:%(message)s",
 4                     datefmt="%Y-%m-%d %H:%M:%S %p",
 5                     level=10)
 6 logging.debug("debug")
 7 logging.info("info")
 8 logging.warning("warning")
 9 logging.error("error")
10 logging.critical("critical")
11 logging.log(10,"log")
12 #上述记录日志的功能，只能讲日志记录在单文件中，如果想要设置多个日志文件，上述方法无法完成，需要自定义文件和日志操作对象
13 #定义文件
14 file_1=logging.FileHandler("l1.log","a",encoding="utf-8")
15 fmt=logging.Formatter(fmt="%(asctime)s-%(name)s-%(levelname)s-%(module)s:%(message)s")
16 file_1.setFormatter(fmt)
17 
18 file_2=logging.FileHandler("l2.log","a",encoding="utf-8")
19 fmt=logging.Formatter()
20 file_2.setFormatter(fmt)
21 #
22 # #定义日志
23 logger1=logging.Logger("s1",level=logging.ERROR)
24 logger1.addHandler(file_1)
25 logger1.addHandler(file_2)
26 #
27 # #写日志
28 logger1.critical("2222")
29 
30 file_21=logging.FileHandler("l3.log","a",encoding="utf-8")
31 fmt=logging.Formatter()
32 file_21.setFormatter(fmt)
33 
34 logger2=logging.Logger("s2",level=logging.INFO)
35 logger2.addHandler(file_21)
36 logger2.critical("6666")

 1 import shutil
 2 #将一个文件的内容拷贝到另一个文件中
 3 shutil.copyfileobj(open("new1.xml","r"),open("new3.xml","w"))
 4 #拷贝文件
 5 shutil.copyfile("new1.xml","new6.xml")
 6 
 7 #压缩
 8 # shutil.make_archive("压缩包的文件名或路径","format 保存的格式，zip,gtar等","root_dir：要压缩的文件夹路径",
 9 #                     "owner:用户","group:组","logger:用于记录日志，通常是logging.Logger对象 ")
10 
11 #解压缩  shutil对压缩包的处理是调用ZipFile和TarFile两个模块
12 import zipfile
13 #压缩
14 z=zipfile.ZipFile("aa.zip","w")
15 z.write("aa.log")
16 z.write("data.data")
17 z.close()
18 #解压
19 z=zipfile.ZipFile("aa.zip","r")
20 z.extractall()
21 z.close()
22 
23 import tarfile
24 
25 # 压缩
26 tar = tarfile.open(‘your.tar‘,‘w‘)
27 tar.add(‘/Users/wupeiqi/PycharmProjects/bbs2.log‘, arcname=‘bbs2.log‘)
28 tar.add(‘/Users/wupeiqi/PycharmProjects/cmdb.log‘, arcname=‘cmdb.log‘)
29 tar.close()
30 
31 # 解压
32 tar = tarfile.open(‘your.tar‘,‘r‘)
33 tar.extractall()  # 可设置解压地址
34 tar.close()