zoukankan      html  css  js  c++  java
  • 假期(模块相关)

    # ----------------------------------------------------------------------------------------
    import time
    timestamp = time.time()    #时间戳
    struct_time = time.localtime()      #结构化时间
    format_time = time.strftime("%Y-%m-%d %X")   #格式化时间
    
    # print(time.localtime(timestamp))         #  时间戳   ====== >  结构化时间
    # print(time.mktime(struct_time))        #  结构化时间   ======>  时间戳
    
    # print(time.strftime("%Y-%m-%d %X"),struct_time)     #格式化时间 ===== > 结构化时间
    # print(time.strptime("2018-02-13 09:25:45","%Y-%m-%d %X"))   #结构化时间 === > 格式化时间
    
    # print(time.asctime())              #Tue Feb 13 09:28:49 2018
    # print(time.ctime(timestamp))         #Tue Feb 13 09:29:29 2018
    
    # time.sleep(10)     #睡多少秒
    
    # ----------------------------------------------------------------------------------------
    import random
    
    # print(random.random())     #0-1的随机小数
    # print(random.randint(1,4))   # 产生大于等于1,小于等于4的整数
    # print(random.randrange(1,4))    # 产生大于等于1,小于4的整数
    # print(random.choice([1,"23",[4,5]]))   #随机产生列表中的一项
    # print(random.sample([1,"23",[4,5],2],2))   #第一个参数是列表,第二个参数是随便产生的列表项
    # print(random.uniform(1,3))     #产生1-3之间的随机小数
    
    # item = [1,2,3,4,5,6]
    # random.shuffle(item)    #打乱原列表的顺序,没有返回值
    # print(item)
    # 生成随机验证码
    # def make_code(n):
    #     res = ""
    #     for i in range(n):
    #         s1 = chr(random.randint(65,90))
    #         s2 = str(random.randint(0,9))
    #         res+=random.choice([s1,s2])
    #     return res
    # print(make_code(9))
    
    # ----------------------------------------------------------------------------------------
    import os
    # print(os.getcwd())       #获取当前工作目录
    # print(os.chdir("dirname"))  #相当于cd切换命令
    # os.remove("dirname")     #删除dirname目录
    # os.rename("oldname","newname")   #重命名
    # print(os.environ)              #获取当前的环境变量
    # os.path.join("dirname")    #路径拼接
    
    # ----------------------------------------------------------------------------------------
    import sys
    # print(sys.argv)          #当前程序的路径
    # print(sys.exit(0))       #退出程序
    # print(sys.version)         #获取python的版、本信息
    # print(sys.maxsize)         #获取最大int值
    # print(sys.path)            #返回模块的搜索路径
    # print(sys.platform)         #返回操作系统的名称
    # 实现打印进度条
    # def progress(percent,width=50):
    #     if percent >= 1:
    #         percent = 1
    #     show_str = ('[%%-%ds]'%width)%(int(width*percent)*"#")
    #     print('
    %s %d%%'%(show_str,int(100*percent)),file=sys.stdout,flush=True,end="")
    # data_size = 1025
    # recv_size = 0
    # while recv_size < data_size:
    #     time.sleep(0.1)
    #     recv_size += 1024
    #     percent = recv_size/data_size
    #     progress(percent,width=70)
    
    # ----------------------------------------------------------------------------------------
    import shutil
    # shutil.copyfile("file1","file2")     #将文件内容拷贝到另一个文中
    # shutil.copymode("file1.log","file2.log")  #仅仅拷贝权限  file2.log 必须存在
    # shutil.copystat("file1","file2")    #拷贝状态信息,file2必须存在
    # shutil.copy("file1.log","file2.log")    #拷贝文件和权限
    # shutil.copy2("file1.log","file2.log")    #拷贝文件和状态信息
    # shutil.copytree()    #递归拷贝
    # shutil.rmtree("filepath")   #递归删除文件
    # shutil.move("file1","file2")  #递归的去移动文件
    
    # ----------------------------------------------------------------------------------------
    import json
    # x = "[1,2,3,4,5,6,7,8]"
    # print(x,type(x))    #[1,2,3,4,5,6,7,8] <class 'str'>
    # print(eval(x),type(eval(x)))       #[1, 2, 3, 4, 5, 6, 7, 8] <class 'list'>
    # print(json.loads(x),type(json.loads(x)))      #[1, 2, 3, 4, 5, 6, 7, 8] <class 'list'>
    # json数据主要用于跨平台数据交互
    # dic = {'name':'alvin','age':23,'sex':'male'}
    # print(type(dic))       #<class 'dict'>
    # j = json.dumps(dic)
    # print(type(j))      # <class 'str'>
    
    # f = open("序列化对象","w")
    # f.write(j)
    # f.close()
    # #反序列化操作
    # f = open("序列化对象","r")
    # data = json.loads(f.read())
    # json不认单引号,json可以跨平台交互,pickle只可以在python中数据交互
    # import pickle
    # dic = {'name':'alvin','age':23,'sex':'male'}
    # j = pickle.dumps(dic)
    # print(type(j))     #<class 'bytes'>
    
    # ----------------------------------------------------------------------------------------
    import shelve
    # shelve模块比pickle模块更加的简单,只有一个open函数,返回类字典对象,可读可写,key必须为字符串,值可以是python所支持的数据类型
    # f=shelve.open(r'sheve.txt')
    # # f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
    # # f['stu2_info']={'name':'gangdan','age':53}
    # # f['school_info']={'website':'http://www.pypy.org','city':'beijing'}
    #
    # print(f['stu1_info']['hobby'])
    # f.close()
    # ----------------------------------------------------------------------------------------
    import xml        #这个模块以及过时,已经被lxml取代
    # ----------------------------------------------------------------------------------------
    import configparser
    # ----------------------------------------------------------------------------------------
    import hashlib
    m = hashlib.md5()
    m.update("hello_zhang".encode("utf8"))
    print(m.hexdigest())     #ed5e024cfdceba3e24b4333709d2dc1a
    #模拟撞库破解密码
    passwds=[
        'alex3714',
        'alex1313',
        'alex94139413',
        'alex123456',
        '123456alex',
        'a123lex',
        ]
    def make_passwd_dic(passwds):
        dic={}
        for passwd in passwds:
            m=hashlib.md5()
            m.update(passwd.encode('utf-8'))
            dic[passwd]=m.hexdigest()
        return dic
    
    def break_code(cryptograph,passwd_dic):
        for k,v in passwd_dic.items():
            if v == cryptograph:
                print('密码是===>33[46m%s33[0m' %k)
    
    cryptograph='aee949757a2e698417463d47acac93df'
    break_code(cryptograph,make_passwd_dic(passwds))
    
    # ----------------------------------------------------------------------------------------
    import 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']
    
    #
     	都是空,都可以被s匹配
    print(re.findall('s','hello 
     egon 	 123')) #[' ', '
    ', ' ', ' ', '	', ' ']
    
    #
    print(re.findall(r'
    ','hello egon 
    123')) #['
    ']
    print(re.findall(r'	','hello egon	123')) #['
    ']
    
    #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与
    print(re.findall('Ahe','hello egon 123')) #['he'],A==>^
    print(re.findall('123','hello egon 123')) #['he'],==>$
    
    #^与$
    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
    b')) #[]
    print(re.findall('a.b','a
    b',re.S)) #['a
    b']
    print(re.findall('a.b','a
    b',re.DOTALL)) #['a
    b']同上一条意思一样
    
    #*
    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','ac')) #对于正则来说a\c确实可以匹配到ac,但是在python解释器读取a\c时,会发生转义,然后交给re去执行,所以抛出异常
    print(re.findall(r'a\c','ac')) #r代表告诉解释器使用rawstring,即原生字符串,把我们正则内的所有符号都当普通字符处理,不要转义
    print(re.findall('a\\c','ac')) #同上面的意思一样,和上面的结果一样都是['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('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
    
    
    
    # ===========================re模块提供的方法介绍===========================
    import re
    #1
    print(re.findall('e','alex make love') )   #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里
    #2
    print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。
    
    #3
    print(re.match('e','alex make love'))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
    
    #4
    print(re.split('[ab]','abcd'))     #['', '', 'cd'],先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
    
    #5
    print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love,不指定n,默认替换所有
    print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love
    print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love
    print('===>',re.sub('^(w+)(.*?s)(w+)(.*?s)(w+)(.*?)$',r'52341','alex make love')) #===> love make alex
    
    print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),结果带有总共替换的个数
    
    
    #6
    obj=re.compile('d{2}')
    
    print(obj.search('abc123eeee').group()) #12
    print(obj.findall('abc123eeee')) #['12'],重用了obj
  • 相关阅读:
    Java实现 蓝桥杯VIP 算法训练 校门外的树
    Java实现 蓝桥杯VIP 算法训练 统计单词个数
    Java实现 蓝桥杯VIP 算法训练 统计单词个数
    Java实现 蓝桥杯VIP 算法训练 开心的金明
    Java实现 蓝桥杯VIP 算法训练 开心的金明
    Java实现 蓝桥杯 算法训练 纪念品分组
    Java实现 蓝桥杯 算法训练 纪念品分组
    Java实现 蓝桥杯VIP 算法训练 校门外的树
    Java实现 蓝桥杯VIP 算法训练 统计单词个数
    Java实现 蓝桥杯VIP 算法训练 开心的金明
  • 原文地址:https://www.cnblogs.com/52-qq/p/8446945.html
Copyright © 2011-2022 走看看