import time# ---- 时间戳格式 ----print(time.time()) # 1590424571.3390846# ---- 结构化格式 ----print(time.localtime()) # 如果未指定参数seconds，则默认放入time.time()print(time.gmtime()) # 如果未指定参数seconds，则默认放入time.time()"""执行结果:time.struct_time(tm_year=2020, tm_mon=5, tm_mday=26, tm_hour=0, tm_min=36, tm_sec=11, tm_wday=1, tm_yday=147, tm_isdst=0)time.struct_time(tm_year=2020, tm_mon=5, tm_mday=25, tm_hour=16, tm_min=36, tm_sec=11, tm_wday=0, tm_yday=146, tm_isdst=0)"""# ---- 结构化时间其他玩法 ----print(time.localtime().tm_year)  # 只拿到年份 2020# ---- 字符串格式 ----print(time.asctime())print(time.ctime())print(time.strftime("%Y-%m-%d %H:%M:%S")) # 相当于 ： %Y-%m-%d %X"""执行结果:Tue May 26 00:36:11 2020Tue May 26 00:36:11 20202020-05-26 00:36:11"""# ==============转换相关=======================# --- 结构化时间转时间戳 ---print(time.mktime(time.localtime())) # 1590424571.0# --- 结构化时间转字符串 ---print(time.strftime("%Y-%m-%d %X",time.gmtime())) # 如不指定time.strftime（）的参数。默认为localtime() Tue May 26 00:36:11 2020# --- 字符串格式转结构化 ---print(time.strptime(time.ctime())) # 默认转换格式是%a %b %d %H:%M:%S %Y。刚好可以放ctime或者asctime，因为ctime和asctime支持该种格式。res = time.strftime("%Y-%m-%d %X")print(time.strptime(res,"%Y-%m-%d %X")) # 如果放入的是其他格式的字符串时间，则需要按原定格式转回，相当于strftime的逆操作。"""执行结果:time.struct_time(tm_year=2020, tm_mon=5, tm_mday=26, tm_hour=0, tm_min=36, tm_sec=11, tm_wday=1, tm_yday=147, tm_isdst=-1)time.struct_time(tm_year=2020, tm_mon=5, tm_mday=26, tm_hour=0, tm_min=36, tm_sec=11, tm_wday=1, tm_yday=147, tm_isdst=-1)"""# --- 时间戳转本地结构化 ---print(time.localtime(333333))# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=5, tm_hour=4, tm_min=35, tm_sec=33, tm_wday=0, tm_yday=5, tm_isdst=0)# --- 时间戳转UTC时间结构化 ---print(time.gmtime(333333))# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=4, tm_hour=20, tm_min=35, tm_sec=33, tm_wday=6, tm_yday=4, tm_isdst=0)# --- 时间戳转固定的UTC时间字符串格式 ---print(time.ctime(00))# print(time.asctime(1)) 注意。无法时间戳转本地字符串格式时间# Thu Jan  1 08:00:00 1970# --- 时间戳转本地时间字符串格式 --- 重点！t = time.time()struct_lo = time.localtime(t) # 先转为本地结构化时间res = time.strftime("%Y-%m-%d %X",struct_lo) # 将本地结构化时间转为字符串格式时间print(res) # 2020-05-26 00:36:11# --- 时间戳转UTC时间字符串格式 --- 重点！t = time.time()struct_gm = time.gmtime(t)res = time.strftime("%Y-%m-%d %X",struct_gm)print(res) # 2020-05-25 16:36:11# --- 字符串格式转时间戳 --- 重点！str_time = "1998-01-26 00:00:10"struct_lo = time.strptime(str_time,"%Y-%m-%d %X") # 先转为本地结构化时间res = time.mktime(struct_lo) # 将本地结构化时间转为时间戳格式print(res) # 885744010.0# 总结 #"""字符串与时间戳的转换字符串 ----> 结构化时间（指定是UTC时间还是本地时间） ---> 时间戳"""

import timeto_day_time = time.time()sum_7day_time = to_day_time+7*86400 #七天后的时间 = 天数 乘以 每天的秒数总和sub_3day_time = to_day_time-3*86400 #三天前的时间str_to_day_time = time.strftime("%Y-%m-%d %X",time.localtime(to_day_time))str_sum_7day_time = time.strftime("%Y-%m-%d %X",time.localtime(sum_7day_time))str_sub_3day_time = time.strftime("%Y-%m-%d %X",time.localtime(sub_3day_time))print(str_to_day_time) # 2020-05-26 00:57:33 当前时间print(str_sum_7day_time) # 2020-06-02 00:57:33 七天后的时间print(str_sub_3day_time) # 2020-05-23 00:57:33 三天前的时间

import timeimport datetime # Ps:与time模块不同的是，datetime获取的是一个datetime对象，而并非Python基本数据类型# --- 字符串格式 ---print(datetime.datetime.now()) # 获取本地时间 2020-05-26 13:55:35.758277print(datetime.datetime.utcnow()) # 获取UTC时间（世界标准时间） 2020-05-26 05:55:35.758277# --- 时间转换:时间戳转字符串格式 ---print(datetime.date.fromtimestamp(1111)) # 1970-01-01# --- 时间加减 --- Ps: 时间加减中不支持年份加减。可用天数365代替# days: float  天# seconds: float  秒# microseconds: float  微秒# milliseconds: float  毫秒# minutes: float  分钟# hours: float    小时# weeks: float    周to_day_time = datetime.datetime.now() # 获取当前时间的字符串格式sum_3day_time = to_day_time + datetime.timedelta(+3) # 当前时间加三天sub_3day_time = to_day_time + datetime.timedelta(-3) # 当前时间减三天sum_7hours_time = to_day_time + datetime.timedelta(hours= +7) # 当前时间加7小时sub_3hours_time = to_day_time + datetime.timedelta(hours= -3) # 当前时间减7小时print(to_day_time)  # 2020-05-26 13:55:35.758277print(sum_3day_time) # 2020-05-29 13:55:35.758277print(sub_3day_time) # 2020-05-23 13:55:35.758277print(sum_7hours_time) # 2020-05-26 20:55:35.758277print(sub_3hours_time) # 2020-05-26 10:55:35.758277# --- 时间替换---str_lo_time = datetime.datetime.now()print("替换前 ---> ",str_lo_time) # 替换前 --->  2020-05-26 13:55:35.758277new_time = str_lo_time.replace(year=2012)print("替换后 ---> ",new_time) # 替换后 --->  2012-05-26 13:55:35.758277

import randomprint(random.random())  # (0,1)----float    大于0且小于1之间的小数 0.25697226355807967print(random.randint(1, 3))  # [1,3]    大于等于1且小于等于3之间的整数 3print(random.randrange(1, 3))  # [1,3)    大于等于1且小于3之间的整数 2print(random.choice([1, '23', [4, 5]]))  # 1或者23或者[4,5] 结果是：23print(random.sample([1, '23', [4, 5]], 2))  # 列表元素任意2个组合 [[4, 5], 1]print(random.uniform(1, 3))  # 大于1小于3的小数，如2.3551911687118054item = [1, 3, 5, 7, 9]random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"print(item)  # [1, 5, 3, 9, 7]

import os# === 工作目录相关 ===print(os.getcwd()) # C:\Users\Administrator\PycharmProjects\learnos.chdir("PerfectProject") # 相当于 cd 命令print(os.getcwd()) # C:\Users\Administrator\PycharmProjects\learn\PerfectProjectprint(os.curdir) # 就是 . ，它的作用是返回当前目录，可与os.chdir搭配使用print(os.pardir) # 就是 .. 它的作用是返回上级目录。可与os.chdir搭配使用# === 文件与目录相关 ===# -- 创建与删除 --"""os.makedirs(r'a/b/c') # 创建三个目录。当目录已存在时抛出异常。os.removedirs(r'a/b/c') # 递归删除刚刚创建好的三个目录，相当于rm -ros.mkdir("test") # 创建test目录os.rmdir("test") # 删除test目录os.remove('README.txt') # 删除单个文件"""# -- 浏览与修改 --print(os.listdir(".")) # 打印当前目录下的所有内容（包含隐藏文件，以list返回）['api', 'bin', 'conf', 'core', 'db', 'lib', 'log', 'README.txt', 'requirements.txt']# os.rename("requirements.txt","Req.txt") # 改名 第一个参数是旧名，第二个参数是新名print(os.stat("Req.txt")) # 获取文件或者目录的信息 os.stat_result(st_mode=33206, st_ino=844424930256166, st_dev=442394905, st_nlink=1, st_uid=0, st_gid=0, st_size=1209, st_atime=1590476737, st_mtime=1590162165, st_ctime=1590159649)# === 操作系统相关 ===print(os.sep) # \ 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"print(os.linesep) # 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"print(os.pathsep) # ; 输出用于分割文件路径的字符串 win下为;,Linux下为:print(os.name) # nt 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'os.system("bash command")  # 运行sell命令，在Windows平台上会产生乱码：'ll' �����ڲ����ⲿ���Ҳ���ǿ����еij������������ļ���print(os.environ)   # 全局环境变量字典（有用处）# === 路径相关 ===# -- 操作与获取路径 --print(os.path.abspath(".")) # 返回指定目录或文件的绝对路径 C:\Users\Administrator\PycharmProjects\learn\PerfectProjectprint(os.path.split(__file__)) # 返回二分元组形式。[0]是目录路径，[1]是文件名。 ('C:/Users/Administrator/PycharmProjects/learn', 'test.py')print(os.path.dirname(__file__)) # 二分元组的第一部分 C:/Users/Administrator/PycharmProjects/learnprint(os.path.basename(__file__)) # 二分元组的第二部分 test.pyprint(os.path.join(r"one","two","1.txt")) # 路径拼接。按平台的路径分隔符拼接  one\two\1.txt# -- 判断路径 --print(os.path.exists("bin")) # 一个路径是否存在，返回一个布尔值 Trueprint(os.path.isabs("a/b")) # 一个路径是否是绝对路径，返回一个布尔值 Falseprint(os.path.isfile("bin/run.py")) # 文件是否存在，返回一个布尔值 Trueprint(os.path.isdir("conf")) # 目录是否存在，返回一个布尔值 True# -- 获取权限信息 --print(os.path.getmtime(__file__)) # 返回path所指向的文件或者目录的最后修改时间 1590477809.9701936print(os.path.getsize(__file__)) # 返回path大小 3248

# 基于sys.stdout的原生版。可用try与except使程序更加健硕import sysimport timeif sys.argv[1] == "get":    print("正在下载{0}的资源".format(sys.argv[2]))    print("程序正在下载..\n")    for i in range(20):        sys.stdout.write("#") # 写入#好        time.sleep(0.1) # 模拟数据传输的延迟        sys.stdout.flush() # 不断刷新    print("程序下载完成")elif sys.argv[1] == "put":    print("正在上传资源至:",sys.argv[2])    for i in range(20):        sys.stdout.write("#") # 写入#好        time.sleep(0.1) # 模拟数据传输的延迟        sys.stdout.flush() # 不断刷新    print("程序上传完成")else:    print("请指定正确的参数:\n1.put or get\n2.url")

# print与\r的应用（优化版） Ps：print是基于sys.stdout来做的，可用try与except使程序更加健硕import sysimport timeimport randomdef progress(percent,width=50):    if percent >= 1: # 代表已经全部接收完成了        percent=1    show_str=("[%%-%ds]" %width) %(int(width*percent)*"#")    print("\r%s %d%%" %(show_str,int(100*percent)),file=sys.stdout,flush=True,end="")if sys.argv[1] == "get":    print("正在下载{0}的资源".format(sys.argv[2]))    print("程序正在下载..\n")    data_size = random.randint(1024,102400)    recv_size = 0    while recv_size < data_size:        time.sleep(0.1) # 模拟数据的传输延迟        recv_size += 1024 # 每次收1024的数据        percent = recv_size / data_size # 接收的比例，不能用 // 因为会得出 0        progress(percent,width=100) # 宽度控制为 100，传入当前的接收比例elif sys.argv[1] == "put":    print("正在上传资源至:",sys.argv[2])    data_size = random.randint(1024,102400)    send_size = 0    while send_size < data_size:        time.sleep(0.1)  # 模拟数据传输的延迟        send_size += 1024 # 每次发送1024的数据        percent = send_size / data_size  # 接收的比例，不能用 // 因为会得出 0        progress(percent, width=100)  # 宽度控制为 100，传入当前的接收比例else:    print("请指定正确的参数:\n1.put or get\n2.url")

import shutilshutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))'''通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件'''拷贝软连接

import json#dct="{'1':111}"#json 不认单引号#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}dct='{"1":"111"}'print(json.loads(dct))#conclusion:#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

""" If ``ensure_ascii`` is false, then the return value can contain non-ASCII    characters if they appear in strings contained in ``obj``. Otherwise, all    such characters are escaped in JSON strings.ensure_ascii如果为false，则返回值可以包含非ASCII字符（如果它们出现在obj中的字符串中）。否则，所有此类字符都将以JSON字符串转义。注意：该参数默认为True"""import jsondic = {'name':'云崖先生'}res1 = json.dumps(dic)print(res1) #{"name": "\u4e91\u5d16\u5148\u751f"}res2 = json.dumps(dic,ensure_ascii=False) # 改为Falseprint(res2) #{"name": "云崖先生"}

# 在python解释器2.7与3.6之后都可以json.loads(bytes类型)，但唯独3.5不可以>>> import json>>> json.loads(b'{"a":111}')Traceback (most recent call last):  File "<stdin>", line 1, in <module>  File "/Users/linhaifeng/anaconda3/lib/python3.5/json/__init__.py", line 312, in loads    s.__class__.__name__))TypeError: the JSON object must be str, not 'bytes'

# 一.什么是猴子补丁?      猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下　　1，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。　　2，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。# 二. 猴子补丁的功能(一切皆对象)　　1.拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)class Monkey:    def hello(self):        print('hello')    def world(self):        print('world')def other_func():    print("from other_func")monkey = Monkey()monkey.hello = monkey.worldmonkey.hello()monkey.world = other_funcmonkey.world()# 三.monkey patch的应用场景如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高，但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能会想到这么做import ujson as json，但是这么做的需要每个文件都重新导入一下，维护成本依然很高此时我们就可以用到猴子补丁了只需要在入口处加上, 只需要在入口加上:import jsonimport ujsondef monkey_patch_json():    json.__name__ = 'ujson'    json.dumps = ujson.dumps    json.loads = ujson.loadsmonkey_patch_json() # 之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果#其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用MonkeyPatch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉MonkeyPatch带了便利的同时也有搞乱源代码的风险!

import jsonimport datetimeres = datetime.datetime.now()  # 得到的是datetime对象print(type(res))  # <class 'datetime.datetime'># json无法对其进行序列化,此时我们需要对json功能做出一些改进。# json.loads(res)# ========== 扩展json方法开始 =========== 思路：将非基本数据类型转换为基本数据类型再做序列化import json as default_jsonfrom json.encoder import JSONEncoderclass JsonEncoder(JSONEncoder):    """该类是逻辑处理类"""    def default(self, o): # 此时的o就是Json中穿过来的serialize_obj        if isinstance(o, datetime.datetime):  # 判断对象o是否是否属于datetime类型            return str(o)  # 转换为str类型，str类型可以被序列化。        return JSONEncoder.default(self, o)  # 将对象o转换为json对象后返回。class Json(object):    """该类是自定义的接口，用来给用户提供非基本数据类型序列化的操作"""    @staticmethod    def dumps(serialize_obj, ensure_ascii=True):  # 接收一个序列化对象        return default_json.dumps(serialize_obj, ensure_ascii=ensure_ascii,                                  cls=JsonEncoder)  # 去 JsonEncoder中执行default方法str_datatime = Json.dumps(res)  # 注意，我们用的是自己写的Json来序列化。print(str_datatime)  # "2020-05-27 15:22:00.099375"，此时的str_datatime已经被序列化了print(json.loads(str_datatime))  # 2020-05-27 15:22:00.099375

# coding:utf-8import picklewith open('a.pkl',mode='wb') as f:    # 一：在python3中执行的序列化操作如何兼容python2    # python2不支持protocol>2，默认python3中protocol=4    # 所以在python3中dump操作应该指定protocol=2    pickle.dump('你好啊',f,protocol=2)with open('a.pkl', mode='rb') as f:    # 二：python2中反序列化才能正常使用    res=pickle.load(f)    print(res)

import shelvewith shelve.open(r"test.txt") as f: # 将文件句柄看做一个大字典    f["Yunya"] = {"age":18,"sex":"male"}    f["Xiaohua"] = {"age":19,"sex":"Fmale"}with shelve.open(r"test.txt") as f:    yunyamsg = f.get("Yunya") # 通过键值对的方式取出就好。f本身就是个字典print(yunyamsg) #{'age': 18, 'sex': 'male'}"""Ps:生成了三个文件test.txt.bak'Yunya', (0, 41)'Xiaohua', (512, 42)test.txt.bat乱码。估计是用二进制存储的test.txt.dir'Yunya', (0, 41)'Xiaohua', (512, 42)"""

<?xml version="1.0"?><data>    <country name="Liechtenstein">        <rank updated="yes">2</rank>        <year>2008</year>        <gdppc>141100</gdppc>        <neighbor name="Austria" direction="E"/>        <neighbor name="Switzerland" direction="W"/>    </country>    <country name="Singapore">        <rank updated="yes">5</rank>        <year>2011</year>        <gdppc>59900</gdppc>        <neighbor name="Malaysia" direction="N"/>    </country>    <country name="Panama">        <rank updated="yes">69</rank>        <year>2011</year>        <gdppc>13600</gdppc>        <neighbor name="Costa Rica" direction="W"/>        <neighbor name="Colombia" direction="E"/>    </country></data>

try:    import xml.etree.cElementTree as ET # 速度快except ImportError:    import xml.etree.ElementTree as ET

# === 1.导入ET ===try:    import xml.etree.cElementTree as ET # 速度快except ImportError:    import xml.etree.ElementTree as ET# === 2.创建文档树对象与获取根节点 ===tree = ET.ElementTree(file='test.xml') # 导入文件,拿到文档树对象（文档树对象可用write方法）root = tree.getroot() # 获取根节点# === 3.1 获取国家标签 ===for child in root:    print(child.tag) # 打印国家标签的名字    print(child.attrib) # 打印国家标签的属性    # print(child.text) # 打印国家标签的文本内容""" Ps: 文本内容为空country{'name': 'Liechtenstein'}country{'name': 'Singapore'}country{'name': 'Panama'}"""# === 3.2 我们也可以使用iter方法来查看特定的节点 ===for node in root.iter("country"): # 循环所有的国家标签。注意，iter方法是查找所有的子孙代标签，并非只针对子代    print("="*20)    print(node.tag)    print("="*20)    for child in node: # 循环当前拿到国家级标签下的所有标签，并打印其标签名与文本内容        print(child.tag,child.text)"""====================country====================rank 2year 2008gdppc 141100neighbor Noneneighbor None====================country====================rank 5year 2011gdppc 59900neighbor None====================country====================rank 69year 2011gdppc 13600neighbor Noneneighbor None"""

# === 1.导入ET ===try:    import xml.etree.cElementTree as ET # 速度快except ImportError:    import xml.etree.ElementTree as ET# === 2.创建文档树对象与获取根节点 ===tree = ET.ElementTree(file='test.xml') # 导入文件,拿到文档树对象（文档树对象可用write方法）root = tree.getroot() # 获取根节点# === 3 获取与修改国家标签名字 ===for node in root.findall("country"): # 拿到所有的root子级标签中名为country的标签，对其循环。（不包含孙级）    node.tag = "nation" # 将国家标签的标签名改为 nationprint(root.findall("country"))  # [] 可以看到，已经查找不到country标签，代表修改标签名成功了print(root.findall("nation")) # [<Element 'nation' at 0x000001E5D08EDC70>, <Element 'nation' at 0x000001E5D0B4A130>, <Element 'nation' at 0x000001E5D0B4A2C0>]# === 4 获取所有year标签的文本内容并对其进行修改 ===res = list(map(lambda x:x.text,root.iter("year")))print(res) #  查看未修改前的year文本内容列表 ['2008', '2011', '2011']for node in root.iter("year"): # 拿到所有root子孙级标签中名为year的标签，对其循环。    node.text = "2020"res = list(map(lambda x:x.text,root.iter("year")))print(res) #  查看修改后的year文本内容列表 ['2020', '2020', '2020']# === 5 为每个国家增添新的标签，并且删除其下的year标签 ===for node in root.findall("nation"):    new_ele = ET.SubElement(node,"test",attrib={"test":"True"}).text="新添加的标签" # 创建新标签,parent代表父亲。tag代表标签名，attrib代表属性. 注意：parent和tag必须是使用位置传参    # node.append(new_ele) 由于SubElement中已经设置了parent，故不用append添加。    for ele in node.findall("year"):        node.remove(ele)        # === 6 打印根节点，写入修改后的文档树对象 ===ET.dump(root) # 打印root节点。tree.write(file_or_filename="test2.xml",encoding='utf-8',xml_declaration=True) # 将文档树对象写入新文件。"""<data>    <nation name="Liechtenstein">        <rank updated="yes">2</rank>        <gdppc>141100</gdppc>        <neighbor name="Austria" direction="E" />        <neighbor name="Switzerland" direction="W" />    <test test="True">新添加的标签</test></nation>    <nation name="Singapore">        <rank updated="yes">5</rank>        <gdppc>59900</gdppc>        <neighbor name="Malaysia" direction="N" />    <test test="True">新添加的标签</test></nation>    <nation name="Panama">        <rank updated="yes">69</rank>        <gdppc>13600</gdppc>        <neighbor name="Costa Rica" direction="W" />        <neighbor name="Colombia" direction="E" />    <test test="True">新添加的标签</test></nation></data>Process finished with exit code 0"""

# === 1.导入ET ===from xml.dom import minidomtry:    import xml.etree.cElementTree as ET  # 速度快except ImportError:    import xml.etree.ElementTree as ET# === 2.添加缩进 === Ps:由于原生保存的XML时默认无缩进，如果想要设置缩进的话， 需要修改保存方式def prettify(elem):    """将节点转换成字符串，并添加缩进。    """    rough_string = ET.tostring(elem, 'utf-8')    reparsed = minidom.parseString(rough_string)    return reparsed.toprettyxml(indent="\t")# === 3.创建主标签 ===root = ET.Element("data")# === 4.创建子标签 ===one = ET.SubElement(root, "son", attrib={"name": "son_1"})two = ET.SubElement(root, "son", attrib={"name": "son_2"})three = ET.SubElement(root, "son", attrib={"name": "son_3"})# === 5.创建孙级标签 ===g_one = ET.SubElement(one, "grandson", attrib={"name": "grandson_1"})g_one.text = "one的儿子，data的孙子" # 设置文本属性g_two = ET.SubElement(two, "grandson", attrib={"name": "grandson_2"})g_two.text = "two的儿子，data的孙子"g_three = ET.SubElement(three, "grandson", attrib={"name": "grandson_3"})g_three.text = "three的儿子，data的孙子"# === 6.生成文档树 ===# ==== 如果直接进行写入，那么是没有缩进的。 ====# ET.dump(root) # 打印根节点,此时是未有缩进的# et = ET.ElementTree(element=root)# et.write("new_xml.xml",encoding="utf-8",xml_declaration=True)# ==== 先将根节点做格式化，再写入文件 ====raw_str = prettify(root)  # 将根节点进行格式化print(raw_str)  # 打印根节点,with open(file="new_xml.xml", mode="wt", encoding='utf-8') as f:    f.write(raw_str)

from xml.etree import ElementTree as ETET.register_namespace('com',"http://www.company.com") #some name# build a tree structureroot = ET.Element("{http://www.company.com}STUFF")body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})body.text = "STUFF EVERYWHERE!"# wrap it in an ElementTree instance, and save as XMLtree = ET.ElementTree(root)tree.write("page.xml",           xml_declaration=True,           encoding='utf-8',           method="xml")

import hashlib# === 使用md5得出的hash值 ===m = hashlib.md5()  # <--- 此处可填写 m = hashlib.md5("helloYunya")m.update("hello".encode("utf-8"))  # 注意：必须是二进制类型m.update("Yunya".encode("utf-8"))res = m.hexdigest()print(res)  # 7a8c8e846b9cdb345bf7005c335c7389# === 使用SHA256得出的hash值 ===m = hashlib.sha256()  # <--- 此处可填写 m = hashlib.sha256("helloYunya")m.update("hello".encode("utf-8"))m.update("Yunya".encode("utf-8"))res = m.hexdigest()print(res)  # 69bd8de772d4f50882288eaac0a3a22230b3adf8e14c88ff40cfe84af805a59e# Ps: 可以看出，可以不断的对一个hash对象进行填值。它的加密结果也会不断的发生变化。

import timeimport hashlib# === 模拟网络传输密码 ===send_res = hashlib.sha256("YY123456".encode("UTF-8")).hexdigest() # 假设用户输入的是 YY123456# == 模拟网络传输延迟 ===time.sleep(0.5) # 注意，在网络传输的过程中该密码很可能被黑客截取。使用sha256加密后传输让黑客不知道真实的密码。（不可反解）# === 服务端存储的密码 ===password = "YY123456" # 服务端数据库中存储了用户密码，由于sha256得到的hash值不可反解，所以只能通过加密后比对的方式server_res = hashlib.sha256(password.encode("UTF-8")).hexdigest()if server_res == send_res:    print("密码正确..")else:    print("密码错误..")

import timeimport hashlib# ==== 为何要有文件校验 ===="""server端    --------->     client端                |                |        可能被黑客窃取，修改下载文件解决方案：    在发送文件的时候要让用户知道我们文件本身的hash校验值    用户下载完成后将得出的结果与我们的hash校验值做对比    如果一致则文件没有被篡改过    如果不一致则文件已被篡改过"""# ======= 模拟sever端生成文件hash校验值的两种方式  =======# 方式1：文件所有内容hash校验一遍。安全系数最高，速度最慢。res = ""m =  hashlib.sha256()f = open(file="1.txt",mode="rb")while 1:    temp = f.read(1024)    # === 更新hash值 ===    m.update(temp) # 由于temp本身就是字节类型。故不用encode    if not len(temp):        f.close()        hash_res = m.hexdigest() # 读取完毕后生成hash字符串        breakprint(hash_res) # 48dd13d8629b4a15f791dec773cab271895187a11683a3d19d4877a8c256cb70# 方式2：文件指定指针点来更新hash值，安全系数小幅度降低，但速度大幅度提升。（迅雷等下载软件均采用此种方式），前提是要让用户知道我们seek()的文件指针点在哪里.m =  hashlib.sha256()f = open(file="1.txt",mode="rb")# === 获取最开始的点 ===f.seek(20,0)temp = f.read(10)m.update(temp)# === 获取中间部位的点 ===f.seek(20,1)temp = f.read(10)m.update(temp)# === 获取尾部的点 ===f.seek(-20,2)temp = f.read(10)m.update(temp)# 最后得到的结果是每个点后面十个字节所组成的hash字符串，Ps：指针点越多安全系数越高hash_res = m.hexdigest()print(hash_res) # daffa21b2be95802d2beeb1f66ce5feb61195e31074120a605421563f775e360

import hashlibsalt = "salt" # <-- 盐m = hashlib.md5()m.update("hello,world".encode("utf-8"))m.update(salt.encode("utf-8")) # <-- 加盐 Ps:盐可以掺在任何地方hash_res = m.hexdigest() # <-- 拿到掺了盐的结果# === 服务端必须也有有盐，在收到带盐的hash值后跟数据库中存储的数据做对比 ===# 取出数据# hash加密# 掺盐# 对比结果

"""hmac模块的使用与hashlib大同小异。但是在某些方面会比hashlib更优秀。"""import hmach1 = hmac.new("hello".encode("utf-8"), digestmod='md5')  # 最后面指定加密方式h1.update("world".encode("utf-8"))print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b

# 配置文件除开.ini后缀，还经常以cfg作为后缀; 该种文件的注释方式有两种。分别是 # 与 ;[regulator]user_name : Yunyaage = 21sex = maleis_admin = truesalary = 20[path]# 后面加上 $true 是自己定制的一个规则。如果为 $true 则与 BASE_DIR 做拼接。得到完整的路径RUN_LOG_FILE = log/run.log $trueERROR_LOG_FILE = log/error.log $true

import subprocessmsg ="""#coding:utf-8print "Hello,Python2.x"print u"我是云崖"    """# 1.首先进入了Python2.x的解释器，然后开始写入msg的内容，被管道拿到执行结果。res = subprocess.Popen("python2",shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)res.stdin.write(msg.encode("utf-8"))res.stdin.close()print(res.stdout.read().decode("utf-8"))print(res.stderr.read().decode("utf-8"))res.stdout.close()res.stderr.close()"""Hello,Python2.x我是云崖"""

============ basicConfig函数参数大全 ============filename    --->    用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。filemode    --->    文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。format      --->    指定handler使用的日志显示格式。datefmt     --->    指定日期时间格式。level       --->    设置rootlogger的日志级别(注意，默认的用户是root)stream      --->    用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。============ format参数可选格式大全 ============%(name)s        --->    Logger的名字，并非用户名，详细查看%(levelno)s     --->    数字形式的日志级别%(levelname)s   --->    文本形式的日志级别%(pathname)s    --->    调用日志输出函数的模块的完整路径名，可能没有%(filename)s    --->    调用日志输出函数的模块的文件名%(module)s      --->    调用日志输出函数的模块名%(funcName)s    --->    调用日志输出函数的函数名%(lineno)d      --->    调用日志输出函数的语句所在的代码行%(created)f     --->    当前时间，用UNIX标准的表示时间的浮 点数表示%(relativeCreated)d     输出日志信息时的，自Logger创建以 来的毫秒数%(asctime)s     --->    字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒%(thread)d      --->    线程ID。可能没有%(threadName)s  --->    线程名。可能没有%(process)d     --->    进程ID。可能没有%(message)s     --->    用户输出的消息

import logging# === 第一步：创建logger对象 ===root = logging.getLogger() # 创建looger对象/如不指定用户默认使用root用户Yunya = logging.getLogger("Yunya") # 相当于创建了一个root的子用户 root_Yunya# === 第二步：设置logger实例对象的默认级别，如不设置默认为warning级别。30root.setLevel(30) # 注意！root应该打印3条信息Yunya.setLevel(10) # 注意！Yunya应该打印5条信息# === 第三步：创建用于写入文件的对象（可指定文件名）以及创建用于向屏幕打印日志的对象 ===fh = logging.FileHandler(filename="access.log",encoding="utf-8") # 如不指定字符编码，按照平台指定。Windows -> GBK , Linux,MacOS -> UTF-8ch = logging.StreamHandler()# === 第四步：设置日志打印格式 === Ps:可以看到我为文件和屏幕设置了不同的两种格式fh_formatter = logging.Formatter("[%(asctime)s]-[%(threadName)s-%(thread)d]-[task_id-%(name)s][%(filename)s-%(lineno)d]" \                  "[%(levelname)s]-[%(message)s]")ch_formatter = logging.Formatter("[%(levelname)s]-[%(asctime)s]-[%(filename)s-%(lineno)d]-%(message)s")fh.setFormatter(fh_formatter)ch.setFormatter(ch_formatter)# === 第五步：为logger实例对象添加接口 ===root.addHandler(fh)root.addHandler(ch)Yunya.addHandler(fh)Yunya.addHandler(ch)# === 第六步：测试，logger实例对象日志记录信息 ===root.debug("debug ... 调试的信息")root.info("info ... 普通的信息")root.warning("warning ... 警告的信息")root.error("error ... 错误的信息")root.critical("critical ... 危机/致命/严重的错误信息")Yunya.debug("debug ... 调试的信息")Yunya.info("info ... 普通的信息")Yunya.warning("warning ... 警告的信息")Yunya.error("error ... 错误的信息")Yunya.critical("critical ... 危机/致命/严重的错误信息")# ==== 执行结果 ==== Ps：root显示正常，Yunya却打印了10条信息。这是为何？？？"""文件中：[2020-05-31 23:41:06,431]-[MainThread-12952]-[task_id-root][logging模块学习.py-40][WARNING]-[warning ... 警告的信息][2020-05-31 23:41:06,432]-[MainThread-12952]-[task_id-root][logging模块学习.py-41][ERROR]-[error ... 错误的信息][2020-05-31 23:41:06,432]-[MainThread-12952]-[task_id-root][logging模块学习.py-42][CRITICAL]-[critical ... 危机/致命/严重的错误信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-44][DEBUG]-[debug ... 调试的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-44][DEBUG]-[debug ... 调试的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-45][INFO]-[info ... 普通的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-45][INFO]-[info ... 普通的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-46][WARNING]-[warning ... 警告的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-46][WARNING]-[warning ... 警告的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-47][ERROR]-[error ... 错误的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-47][ERROR]-[error ... 错误的信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-48][CRITICAL]-[critical ... 危机/致命/严重的错误信息][2020-05-31 23:41:06,433]-[MainThread-12952]-[task_id-Yunya][logging模块学习.py-48][CRITICAL]-[critical ... 危机/致命/严重的错误信息]""""""屏幕终端：[WARNING]-[2020-05-31 23:41:06,431]-[logging模块学习.py-40]-warning ... 警告的信息[ERROR]-[2020-05-31 23:41:06,432]-[logging模块学习.py-41]-error ... 错误的信息[CRITICAL]-[2020-05-31 23:41:06,432]-[logging模块学习.py-42]-critical ... 危机/致命/严重的错误信息[DEBUG]-[2020-05-31 23:41:06,433]-[logging模块学习.py-44]-debug ... 调试的信息[DEBUG]-[2020-05-31 23:41:06,433]-[logging模块学习.py-44]-debug ... 调试的信息[INFO]-[2020-05-31 23:41:06,433]-[logging模块学习.py-45]-info ... 普通的信息[INFO]-[2020-05-31 23:41:06,433]-[logging模块学习.py-45]-info ... 普通的信息[WARNING]-[2020-05-31 23:41:06,433]-[logging模块学习.py-46]-warning ... 警告的信息[WARNING]-[2020-05-31 23:41:06,433]-[logging模块学习.py-46]-warning ... 警告的信息[ERROR]-[2020-05-31 23:41:06,433]-[logging模块学习.py-47]-error ... 错误的信息[ERROR]-[2020-05-31 23:41:06,433]-[logging模块学习.py-47]-error ... 错误的信息[CRITICAL]-[2020-05-31 23:41:06,433]-[logging模块学习.py-48]-critical ... 危机/致命/严重的错误信息[CRITICAL]-[2020-05-31 23:41:06,433]-[logging模块学习.py-48]-critical ... 危机/致命/严重的错误信息"""

import logging# === 第一步：创建logger对象 ===root = logging.getLogger("") # 创建looger对象/如不指定用户默认使用root用户Yunya = logging.getLogger("Yunya") # 相当于创建了一个root的子用户 root_Yunya# === 第二步：设置logger实例对象的默认级别，如不设置默认为warning级别。30root.setLevel(30) # 注意！root应该打印3条信息Yunya.setLevel(10) # 注意！Yunya应该打印5条信息# === 第三步：创建用于写入文件的对象（可指定文件名）以及创建用于向屏幕打印日志的对象 ===fh = logging.FileHandler(filename="access.log",encoding="utf-8") # 如不指定字符编码，按照平台指定。Windows -> GBK , Linux,MacOS -> UTF-8ch = logging.StreamHandler()# === 第四步：设置日志打印格式 === Ps:可以看到我为文件和屏幕设置了不同的两种格式fh_formatter = logging.Formatter("[%(asctime)s]-[%(threadName)s-%(thread)d]-[task_id-%(name)s][%(filename)s-%(lineno)d]" \                  "[%(levelname)s]-[%(message)s]")ch_formatter = logging.Formatter("[%(levelname)s]-[%(asctime)s]-[%(filename)s-%(lineno)d]-%(message)s")fh.setFormatter(fh_formatter)ch.setFormatter(ch_formatter)# === 第五步：为logger实例对象添加接口 ===# root.addHandler(fh) # 关闭接口# root.addHandler(ch)Yunya.addHandler(fh)Yunya.addHandler(ch)# === 第六步：测试，logger实例对象日志记录信息 ===root.debug("debug ... 调试的信息")root.info("info ... 普通的信息")root.warning("warning ... 警告的信息")root.error("error ... 错误的信息")root.critical("critical ... 危机/致命/严重的错误信息")Yunya.debug("debug ... 调试的信息")Yunya.info("info ... 普通的信息")Yunya.warning("warning ... 警告的信息")Yunya.error("error ... 错误的信息")Yunya.critical("critical ... 危机/致命/严重的错误信息")# ==== 执行结果 ==== """文件中：Ps:文件不会再存有root用户的日志信息[2020-06-01 00:47:16,128]-[MainThread-480]-[task_id-Yunya][logging模块学习.py-44][DEBUG]-[debug ... 调试的信息][2020-06-01 00:47:16,128]-[MainThread-480]-[task_id-Yunya][logging模块学习.py-45][INFO]-[info ... 普通的信息][2020-06-01 00:47:16,128]-[MainThread-480]-[task_id-Yunya][logging模块学习.py-46][WARNING]-[warning ... 警告的信息][2020-06-01 00:47:16,128]-[MainThread-480]-[task_id-Yunya][logging模块学习.py-47][ERROR]-[error ... 错误的信息][2020-06-01 00:47:16,128]-[MainThread-480]-[task_id-Yunya][logging模块学习.py-48][CRITICAL]-[critical ... 危机/致命/严重的错误信息]""""""屏幕终端：warning ... 警告的信息error ... 错误的信息critical ... 危机/致命/严重的错误信息[DEBUG]-[2020-06-01 00:47:16,128]-[logging模块学习.py-44]-debug ... 调试的信息[INFO]-[2020-06-01 00:47:16,128]-[logging模块学习.py-45]-info ... 普通的信息[WARNING]-[2020-06-01 00:47:16,128]-[logging模块学习.py-46]-warning ... 警告的信息[ERROR]-[2020-06-01 00:47:16,128]-[logging模块学习.py-47]-error ... 错误的信息[CRITICAL]-[2020-06-01 00:47:16,128]-[logging模块学习.py-48]-critical ... 危机/致命/严重的错误信息"""

import loggingYunya1 =logging.getLogger("Yunya") # 注意他们的名字都是一样的Yunya2 =logging.getLogger("Yunya")Yunya1.setLevel(10)Yunya1.setLevel(30) # 后者设置覆盖前者ch = logging.StreamHandler()Yunya1.addHandler(ch)Yunya2.addHandler(ch)Yunya1.debug("debug ... 调试的信息 Yunya1")Yunya1.info("info ... 普通的信息 Yunya1")Yunya1.warning("warning ... 警告的信息 Yunya1")Yunya1.error("error ... 错误的信息 Yunya1")Yunya1.critical("critical ... 危机/致命/严重的错误信息 Yunya1")Yunya2.debug("debug ... 调试的信息 Yunya2")Yunya2.info("info ... 普通的信息 Yunya2")Yunya2.warning("warning ... 警告的信息 Yunya2")Yunya2.error("error ... 错误的信息 Yunya2")Yunya2.critical("critical ... 危机/致命/严重的错误信息 Yunya2")# ==== 执行结果 ==== Ps:Yunya1应该是打印五条信息的为何只打印3条？"""warning ... 警告的信息 Yunya1error ... 错误的信息 Yunya1critical ... 危机/致命/严重的错误信息 Yunya1warning ... 警告的信息 Yunya2error ... 错误的信息 Yunya2critical ... 危机/致命/严重的错误信息 Yunya2"""

import re#为何同样的表达式search与findall却有不同结果:print(re.search('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))").group()) #(-40.35/5)print(re.findall('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))")) #['/5', '*3']#看这个例子:(\d)+相当于(\d)(\d)(\d)(\d)...,是一系列分组print(re.search('(\d)+','123').group()) #group的作用是将所有组拼接到一起显示出来 123print(re.findall('(\d)+','123')) #findall结果是组内的结果,且是最后一个组的结果 ['3']

IP：^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$手机号：^1[3|4|5|8][0-9]\d{8}$邮箱：[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

import reret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')print(ret)#['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可 ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')print(ret)#['www.oldboy.com']