您的位置:68399皇家赌场 > 集群主机 > 【皇家赌场】陆、python全栈之路-常用模块

【皇家赌场】陆、python全栈之路-常用模块

发布时间:2019-05-09 05:52编辑:集群主机浏览(176)

    2.原来是因为自身的台本命名字为json.py, python误以为是json模块的源代码。

     

    json模块提供了八个艺术

    肆.三 随机选取一个回来

    >>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]

    【总结】

    pickle

     

    ***shelve 只提供1个 open 方法,操作有一些像字典.***

    三.2.二 格式化的时日字符串(Format String)

    #光阴字符串

    >>>time.strftime("%Y-%m-%d %X")

    '2017-07-24 13:54:37'

    >>>time.strftime("%Y-%m-%d %H-%M-%S")

    '2017-07-24 13-55-04'

     

    python中时间日期格式化符号:

    %y 两位数的年份表示(00-99)

    %Y 四个人数的年份表示(000-999玖)

    %m 月份(01-12)

    %d 月内中的一天(0-3一)

    %H 二肆小时制时辰数(0-2三)

    %I 12时辰制小时数(0一-1二)

    %M 分钟数(00=59)

    %S 秒(00-59)

    %a 本地简化星期名称

    %A 本地完整星期名称

    %b 本地简化的月份名称

    %B 本地完整的月份名称

    %c 本地相应的日期表示和时间代表

    %j 年内的一天(00一-36陆)

    %p 本地A.M.或P.M.的等价符

    %U 一年中的星期数(00-五三)礼拜日为星期的起首

    %w 星期(0-陆),礼拜贰为星期的伊始

    %W 一年中的星期数(00-伍三)星期1为星期的上马

    %x 本地相应的日期表示

    %X 本地相应的日子代表

    %Z 当前时区的名目

    %% %号本身

    一.进来python解释器,查看是或不是留存json模块。json模块存在且可用。

    怎么着叫体系化——将原来的字典、列表等剧情调换到二个字符串的进度就叫做序列化

    dumps 和 loads 实例

    陆.壹 常用用法

    sys.argv           命令行参数List,第二个要素是先后自身路线

    sys.exit(n)        退出程序,平常退出时exit(0)

    sys.version        获取Python解释程序的版本音信

    sys.path           重返模块的寻找路线,初叶化时选拔PYTHONPATH景况变量的值

    sys.platform       再次来到操作系统平台名称

    自然笔者要去 json.py找dumps方法,不过未来温馨成为了json.py,并且自身也绝非定义dumps方法,自然就不大概找到了

    贰、将对象从2个地点传递到另多少个地点。

    **而是pickle仅仅只可以对python中的数据开始展览体系化 , 反系列化时别的语言就不可能读懂了那是什么样了** , 所以大家一般用引入应用json

    叁、时间模块

    和岁月有关系的大家将在用到时间模块。在行使模块在此以前,应该率先河入这么些模块。

    1. import json
    2. dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
    3. str_dic = json.dumps(dic)
    4. print(type(str_dic), str_dic)

    壹、以某种存储方式使自定义对象持久化;

    loads的特别情状

    3.1.1 time.sleep(secs)

    (线程)推迟钦命的年华运作。单位为秒。

     

    皇家赌场 1

    ` writeback `参数 , 能够减弱大家失误的概率 , 并且让对象的长久化对用户更加的晶莹了 ; 但这种措施并不是具有的情景下都供给 , 首先 , 使用writeback以往 , shelf在open()的时候会追加额外的内部存款和储蓄器消耗 , 并且当数据库在close()的时候会将缓存中的每1个对象都写入到多少库 , 这也会推动卓越的等候时间 , 因为shelve未有艺术知道缓存中怎么样对象修改了 , 哪些对象未有改动 , 由此具备的对象都会被写入

    7.1 序列化

    要多精晓底层脚本的命名,以防再出新此处的误会

    shelve

    shelve也是python提供给我们的系列化学工业具,比pickle用起来更轻便一些。
    shelve只提需要大家贰个open方法,是用key来访问的,使用起来和字典类似。

    import shelve
    f = shelve.open('shelve_file')
    f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'} #直接对文本句柄操作,就足以存入数据
    f.close()

    import shelve
    f1 = shelve.open('shelve_file')
    existing = f1['key'] #抽出数据的时候也只供给直接用key获取就能够,不过要是key不存在会报错
    f1.close()
    print(existing)

    shelve

     

    这几个模块有个限制,它不支持多少个应用同一时间往同八个DB进行写操作。所以当大家知晓我们的选用倘诺只进行读操作,大家能够让shelve通过只读情势展开DB

    import shelve
    f = shelve.open('shelve_file', flag='r')
    existing = f['key']
    f.close()
    print(existing)
    

     

    由于shelve在私下认可情况下是不会记录待悠久化对象的别的修改的,所以大家在shelve.open()时候需求修改默许参数,不然对象的修改不会保留。

    import shelve
    f1 = shelve.open('shelve_file')
    print(f1['key'])
    f1['key']['new_value'] = 'this was not here before'
    f1.close()

    f2 = shelve.open('shelve_file', writeback=True)
    print(f2['key'])
    f2['key']['new_value'] = 'this was not here before'
    f2.close()

    设置writeback

    writeback格局有可取也反常。优点是减掉了我们失误的可能率,并且让对象的长久化对用户更加的的晶莹了;但这种办法并不是具有的状态下都急需,首先,使用writeback将来,shelf在open()的时候会大增额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每一个目的都写入到DB,那也会推动万分的等候时间。因为shelve未有艺术知道缓存中什么对象修改了,哪些对象未有退换,由此具备的指标都会被写入。

    PS : json可用以不一样语言之间的数据交流

    伍.一 常用用法

    os.getcwd() 获取当前专门的职业目录,即近些日子python脚本职业的目录路线

    os.chdir("dirname")  更动近来剧本职业目录;约等于shell下cd

    os.curdir  重临当前目录: ('.')

    os.pardir  获取当前目录的父目录字符串名:('..')

    os.makedirs('dirname1/dirname二')    可生成多层递归目录

    os.removedirs('dirname一')    若目录为空,则删除,并递归到上一级目录,若是也为空,则删除,以此类推

    os.mkdir('dirname')    生成单级目录;也就是shell中mkdir dirname

    os.rmdir('dirname')    删除单级空目录,若目录不为空则异常的小概删除,报错;相当于shell中rmdir dirname

    os.listdir('dirname')    列出钦命目录下的保有文件和子目录,包蕴隐形文件,并以列表情势打字与印刷

    os.remove()  删除贰个文书

    os.rename("oldname","newname")  重命名文件/目录

    os.stat('path/filename')  获取文件/目录音信

    os.sep    输出操作系统特定的门道分隔符,win下为"\",Linux下为"/"

    os.linesep    输出当前平台运用的行终止符,win下为"tn",Linux下为"n"

    os.pathsep    输出用于私分文件路线的字符串 win下为;,Linux下为:

    os.name    输出字符串提醒当前使用平台。win->'nt'; Linux->'posix'

    os.system("bash command")  运营shell命令,直接体现

    os.popen("bash command)  运维shell命令,获取推行结果

    os.environ  获取系统境遇变量

     

    os.path

    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是3个设有的文本,重返True。不然再次来到False

    os.path.isdir(path)  假设path是多个存在的目录,则赶回True。不然重回False

    os.path.join(path1[, path2[, ...]])  将多个门路组合后赶回,第四个相对路径以前的参数将被忽略

    os.path.getatime(path)  重回path所指向的文本恐怕目录的终极访问时间

    os.path.getmtime(path)  再次回到path所指向的文书或许目录的结尾修改时间

    os.path.getsize(path) 返回path的大小

    代码如下:

    三、使程序更具维护性。

     

    2、collections模块

    在松手数据类型(dict、list、set、tuple)的功底上,collections模块还提供了多少个附加的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。

    分析json数据时,不要将脚本命名称叫json.py 或是 simplejson.py

    种类化的目标

     ## pickle :four_leaf_clover:

    八、正则表明式

    在线测试工具

            比如,大家在python代码中总括的2个数额供给给别的壹段程序使用,那我们怎么给?
    现行反革命我们能体会了然的诀要正是存在文件里,然后另二个python程序再从文件里读出来。
    但是我们都通晓,对于文本来讲是未有字典那个概念的,所以大家只可以将数据转变来字典放到文件中。
    您料定会问,将字典转变来3个字符串很轻松,正是str(dic)就足以办到了,为啥大家还要学习连串化模块呢?
    没有错系列化的经过正是从dic 产生str(dic)的经过。未来您能够经过str(dic),将贰个名字为dic的字典调换来一个字符串,
    而是你要怎么把3个字符串转变到字典呢?
    聪明的你势必想到了eval(),若是大家将三个字符串类型的字典str_dic传给eval,就能够猎取三个回到的字典类型了。
    eval()函数十分无敌,不过eval是做怎么样的?e官方demo解释为:将字符串str当成有效的表达式来求值并回到总结结果。
    BUT!庞大的函数有代价。安全性是其最大的缺点。
    想象一下,假使大家从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。
    而利用eval将在担这一个风险。
    就此,大家并不引入用eval方法来举办反连串化操作(将str调换来python中的数据结构)

    shelve不扶助四个利用还要往叁个数据库实行操作 , 所以当大家精通大家的选择假若只实行操作 , 咱们能够安装shelve.open() 方法的参数来打开

    5、os模块

    os模块是与操作系统交互的一个接口

    json

    Json模块提供了三个效益:dumps、dump、loads、load

    loads和dumps

    import json
    dic = {'k1':'v1','k2':'v2','k3':'v3'}
    str_dic = json.dumps(dic) #类别化:将八个字典转变到三个字符串
    print(type(str_dic),str_dic) #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
    #注意,json转变完的字符串类型的字典中的字符串是由""表示的

    dic2 = json.loads(str_dic) #反种类化:将二个字符串格式的字典调换到三个字典
    #专注,要用json的loads效率管理的字符串类型的字典中的字符串必须由""表示
    print(type(dic2),dic2) #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

    list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
    str_dic = json.dumps(list_dic) #也得以拍卖嵌套的数据类型
    print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
    list_dic2 = json.loads(str_dic)
    print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

    load和dump

    import json
    f = open('json_file','w')
    dic = {'k1':'v1','k2':'v2','k3':'v3'}
    json.dump(dic,f) #dump方法接收3个文书句柄,直接将字典调换来json字符串写入文件
    f.close()

    f = open('json_file')
    dic2 = json.load(f) #load方法接收三个文本句柄,直接将文件中的json字符串转变来数据结构重返
    f.close()
    print(type(dic2),dic2)

     

     

    ***pickle 在 python 里专项使用的,能够对别的数据类型做系列化,结果是 bytes 类型***

    7.4 shelve

    shelve也是python提须求我们的体系化学工业具,比pickle用起来更简便一些。

    shelve只提须求我们一个open方法,是用key来访问的,使用起来和字典类似。

    何以要有类别化模块

    用于python特有的体系和python的数据类型间开始展览转变

    1一.一 灵活布置日志等级,日志格式,输出地点

    import logging
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                        datefmt='%a, %d %b %Y %H:%M:%S',
                        filename='/tmp/test.log',
                        filemode='w')

    logging.debug('debug message')
    logging.info('info message')
    logging.warning('warning message')
    logging.error('error message')
    logging.critical('critical message')

    json & pickle 模块

     

    用以种类化的多个模块

     

    • json,用于字符串 和 python数据类型间展开转移
    • pickle,用于python特有的类型 和 python的数据类型间打开转移

     

    pickle模块提供了三个职能:dumps、dump(种类化,存)、loads(反类别化,读)、load  (不止能够类别化字典,列表...可以把python中率性的数据类型连串化

     

    import pickle
    dic = {'k1':'v1','k2':'v2','k3':'v3'}
    str_dic = pickle.dumps(dic)
    print(str_dic) #1串二进制内容

    dic2 = pickle.loads(str_dic)
    print(dic2) #字典

    import time
    struct_time = time.localtime(1000000000)
    print(struct_time)
    f = open('pickle_file','wb')
    pickle.dump(struct_time,f)
    f.close()

    f = open('pickle_file','rb')
    struct_time2 = pickle.load(f)
    print(struct_time.tm_year)

    pickle

     

    shelve只提需求大家一个open方法 , 是用key来访问的 , 使用起来和字典类似

    八.二.1 贪婪相称

     皇家赌场 2

    回首算法:贪婪相配的原形

    先匹配第一个,然后径直十二分到终极再往前相称直到非常到

     

    7.2.1 loads和dumps

    import json

    dic = {'k1':'v1','k2':'v2','k3':'v3'}

    str_dic = json.dumps(dic)  #种类化:将一个字典调换来贰个字符串

    print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}

    #留神,json转换完的字符串类型的字典中的字符串是由""表示的

     

    dic2 = json.loads(str_dic)  #反系列化:将3个字符串格式的字典转换到2个字典

    #小心,要用json的loads功用管理的字符串类型的字典中的字符串必须由""表示

    print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

     

    list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]

    str_dic = json.dumps(list_dic) #也得以拍卖嵌套的数据类型

    print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]

    list_dic2 = json.loads(str_dic)

    print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

    ```python
    # 导入json模块
    import json
    # 创制2个字符串,内部为二个字典
    dic_s = "{'k1':'v1','k2':'v2','k3':3}"
    # 将字符串调换来字典
    json.loads(dic_s)
    # 解释器出现报错
    # json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
    '''
    报错原因,用json的loads效率时,字符串类型的字典中的字符串必须由 "" 表示
    即上边包车型大巴dic_s应该改为 '{"k一":"v1","k二":"v二","k三":叁}'

    七.叁.1 json & pickle模块的区分

    用于类别化的七个模块

     

    •json,用于字符串 和 python数据类型间展开转移

    •pickle,用于python特有的类型 和 python的数据类型间展开转移

    ```python
    # 导入shelve模块
    import shelve
    # shelve提供open方法
    f = shelve.open('shelve_file')
    # 直接对文件句柄进行操作,就能够写入文件中
    f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}
    # 关闭文件
    f.close()
    # 张开文件
    f1 = shelve.open('shelve_file')
    # 直接用key取值,key不存在就报错
    existing = f1['key']
    # 关闭文件
    f1.close()
    # 打字与印刷结果
    print(existing)
    # {'float': 9.5, 'int': 10, 'string': 'Sample data'}
    ```

    10.1 md5()

    ***time 时间相关 二种格式:时间戳,格式化时间(字符串),时间元组(结构化时间).
    ***
    ```python
    #岁月戳: timestamp 从19陆8年七月二十一日00:00发轫按秒统计偏移量.
    time.time()

    2.5 Counter

    计数器,首要用来计数

    Counter类的目标是用来追踪值出现的次数。它是贰个无序的器皿类型,以字典的键值对情势积攒,其否月素作为key,其计数作为value。计数值能够是随便的Interger(包涵0和负数)。Counter类和别的语言的bags或multisets很相似。

     

    c = Counter('abcdeabcdabcaba')

    print c

    输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

    其余详细内容

    pickle模块也提供了多个方法 , 与json一样 dumps , dump , loads , load

    三.三.二 结构化时间-->时间戳 

    #time.mktime(结构化时间)

    >>>time_tuple = time.localtime(1500000000)

    >>>time.mktime(time_tuple)

    1500000000.0

     

    叁.4 实例:计算时间差

    import time

    true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))

    time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))

    dif_time=time_now-true_time

    struct_time=time.gmtime(dif_time)

    print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,

                                           struct_time.tm_mday-1,struct_time.tm_hour,

                                           struct_time.tm_min,struct_time.tm_sec))

     皇家赌场 3

    ```python
    # 导入json模块
    import json
    # 创设二个文本句柄
    f = open('json_file','w')
    # 成立3个字典
    dic = {'k1':'v1','k2':'v2'}
    # 将字典转变到字符串写入文件
    json.dump(dic,f)
    # 关闭文件
    f.close()
    # 创立三个文件句柄
    f = open('json_file')
    # 将文件中的字符串读出并转变到原数据类型
    dic2 = json.load(f)
    # 关闭文件句柄
    f.close()
    # 打字与印刷项目和结果
    print(type(dic2),dic2)
    # <class 'dict'> {'k1': 'v1', 'k2': 'v2'}
    ```

    玖.9 相称标签

    分组命名

    (?P<name>)  (?P=name)

    ret = re.search("<(?P<tag_name>w )>w </(?P=tag_name)>","<h1>hello</h1>")
    #还足以在分组中选取?<name>的花样给分组起名字
    #猎取的同盟结果能够一向用group('名字')获得相应的值
    print(ret.group('tag_name'))  #结果 :h1 print(ret.group())  *#结果 :<h1>hello</h1>

    ret = re.search(r"<(w )>w </1>","<h1>hello</h1>") #如若不给组起名字,也得以用序号来找到相应的组,表示要找的源委和日前的组内容一律
    #获取的万分结果能够一向用group(序号)得到相应的值
    print(ret.group(1))
    print(ret.group())  
    #结果 :<h1>hello</h1>*

    用以字符串和python数据类型之间实行改造 , 因为json表示出来正是二个字符串

    9.6 subn()

    轮换 并再次回到替换一次

    ret = re.subn('d', 'H', 'eva3egon4yuan4')#将数字替换到'H',再次来到元组(替换的结果,替换了多少次) print(ret)

    #时间元组: (结构化时间)Stack_Time 包涵7个因素:年 月 日 时 分 秒 二零一九年第几周 今年的第几天 夏令时
    ```
    ```
    #时间戳-->时间元组(结构化时间)
    time.gmtime(#填时间戳) #UTC时间
    time.localtime(#填时间戳) #本地时间

    7.4.2 shelve只读

    import shelve

    f = shelve.open('shelve_file', flag='r')

    existing = f['key']

    f.close()

    print(existing)

    鉴于shelve在暗许情形下是不会记录待漫长化对象的别的修改的,所以我们在shelve.open()时候须求修改默许参数,不然对象的修改不会保留。

    本文由68399皇家赌场发布于集群主机,转载请注明出处:【皇家赌场】陆、python全栈之路-常用模块

    关键词: 68399皇家赌场 pythonS7