day21 os random 序列json

一、random模块    

import random
# print(random.random())    #0到1之间数
# print(random.uniform(10,20)) #范围内小数
# print(random.randint(1,12))  # 指定范围内的数字包含右半部分
# print(random.randrange(1,12)) #指定范围 不包含右半部分.可以加步长
# ret = random.sample('abcs',2)   #一个可迭代对象，返回多个值
# print(ret)        #打乱顺序可以加选择的参数
# print(random.choices([1,2,3]))   #参数是可迭代对象返回一个列表
# print(random.choice({'a':1,'b':1,'d':1})) #参数是一个可迭代对象，返回一个值
#验证码程序
# code = ""
# for i in range(4):
#     char_upper = chr(random.randint(65,90))
#     char_lower = chr(random.randint(97,122))
#     num = str(random.randrange(10))
#     ret = random.choice([char_upper,char_lower,num])
#     code += ret
# #code = ''.join[code,ret]
# print(code)
#shuffle  打乱顺序
# a = [2,3,5,6,7]
# print(random.shuffle(a))
# print(a)

二 os模块

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

'''
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
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下为"	
",Linux下为"
"
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是一个存在的文件，返回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的大小
'''

#创建序列化的文件夹
# with open('nameinfo',encoding='utf-8') as f:
#     for i in f:
#         i = i.strip()
#         print(os.path.exists(r'D:abc\%s'%i))
#         if  not os.path.exists(r'D:abc\%s'%i):
#             os.mkdir(r'D:abc\%s'%i)
# #
# abcdir_list = os.listdir(r'D:abc')
# print(abcdir_list)
# for name in abcdir_list:
#     if not os.listdir(r'D:abc\%s'%name):
#     #     os.rmdir(r'D:abc\%s'%name)
#     # else:
#         os.remove(r'D:abc\%s'%name)
# # os.rmdir(r'D:abc')
#查看获取当前脚本的绝对路径
import os
import sys
import shutil
if __name__ == "__main__":
    print(os.path.abspath(sys.argv[0]))
    print(os.path.split(os.path.realpath(sys.argv[0])))
    print (os.path.split(os.path.realpath(sys.argv[0]))
           
# 
# os.remove(path)   #删除文件
# os.removedirs(path)   #删除空文件夹
# shutil.rmtree(path)    #递归删除文件夹

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。

1、以某种存储形式使自定义对象持久化；

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

1）json

import json  #json中和文件操作的dump用的较少，可以用dumps 和write
dic = {'str':'张','k2':'v2','k3':'v3'}
l = (1,2,3)
str_dic = json.dumps(dic)
print(repr(str_dic),type(str_dic))
# dic1 = json.loads(str_dic)
# print(dic1)
# str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
# print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
# #注意，json转换完的字符串类型的字典中的字符串是由""表示的
# with open('nameinfo','a') as f:
#     str_dic1 = json.dumps(dic)
#     f.write(str_dic)
# dic1 = json.loads(str_dic)
# print(dic1)
with open('nameinfo','r') as f:  #R+和r模式都不影响解码   不过对于多行用for循环解码
    for line in f:
        # line = line.strip()
        str_dic2 = json.loads(line)
        print(str_dic2)

json & pickle   shelve模块

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换
• shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
  shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

• import json  #json中和文件操作的dump用的较少，可以用dumps 和write
  dic = {'str':'张','k2':'v2','k3':'v3'}
  l = (1,2,3)
  str_dic = json.dumps(dic)
  # print(repr(str_dic),type(str_dic))
  # dic1 = json.loads(str_dic)
  # print(dic1)
  # str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
  # print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
  # #注意，json转换完的字符串类型的字典中的字符串是由""表示的
  # with open('nameinfo','a') as f:  # 写的时候可以写ab模式 也可以a
      # str_dic1 = json.dump(dic,f)
      # f.write(str_dic)
  # dic1 = json.loads(str_dic)
  # print(dic1)
  # with open('nameinfo','rb') as f:  #Rb和r模式都不影响解码   不过对于多行用for循环解码
  #     # t = f.read()
  #     # print(t)
  #     for line in f:
  #         # line = line.strip()
  #         print(line)
  #         str_dic2 = json.loads(line)
  #         print(str_dic2)

• # import pickle   #写文件和读文件只能用rb模式
  # dic = {'k1':'v1','k2':'v2','k3':'v3'}
  # l = {1,2,3}
  # # str_dic = pickle.dumps(l)
  # # print(str_dic)
  # # dic2 = pickle.loads(str_dic)
  # # print(dic2)
  # with open('nameinfo','ab') as f:
  #     pickle.dump(dic,f)
  # with open('nameinfo','rb') as f:
  #     ret = pickle.load(f)
  #     print(ret)

  import shelve          #
  with shelve.open('ff') as f:
      f['k1'] = dic
      f['k2'] = l
      f['k1'] = 'this was not here before'
  with shelve.open('ff') as f:
      print(f,type(f['k1']))
      for i in f :
          print(i,f[i])
  
  s = shelve.open('test.dat')
  s['x'] = ['a', 'b', 'c']
  s['x'].append('d')
  s['x']
  #['a', 'b', 'c']
  # 存储的d到哪里去了呢？其实很简单，d没有写回，你把['a', 'b', 'c']
  # 存到了x，当你再次读取s['x']
  # 的时候，s['x']
  # 只是一个拷贝，而你没有将拷贝写回，所以当你再次读取s['x']
  # 的时候，它又从源中读取了一个拷贝，所以，你新修改的内容并不会出现在拷贝中，解决的办法就是，第一个是利用一个缓存的变量，如下所示
  # 在python2.4中有了另外的方法，就是把open方法的writeback参数的值赋为True，这样的话，你open后所有的内容都将在cache中，当你close的时候，
  # 将全部一次性写到硬盘里面。如果数据量不是很大的时候，建议这么做。
  # writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；
  # 但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，
  # 并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。
  # 因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。
  temp = s['x']
  temp.append('d')
  s['x'] = temp
  s['x']
  ['a', 'b', 'c', 'd']

   异常处理

• 程序中难免出现错误

• 1.语法错误（这种错误，根本过不了python解释器的语法检测，必须在程序执行前就改正）
• 2.逻辑错误（逻辑错误）
• 在python中不同的异常可以用不同的类型（python中统一了类与类型，类型即类）去标识，不同的类对象标识不同的异常，一个异常标识一种错误

  AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
  IOError 输入/输出异常；基本上是无法打开文件
  ImportError 无法引入模块或包；基本上是路径问题或名称错误
  IndentationError 语法错误（的子类） ；代码没有正确对齐
  IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
  KeyError 试图访问字典里不存在的键
  KeyboardInterrupt Ctrl+C被按下
  NameError 使用一个还未被赋予对象的变量
  SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
  TypeError 传入对象类型与要求的不符合
  UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
  导致你以为正在访问它
  ValueError 传入一个调用者不期望的值，即使值的类型是正确的
  
  常用异常

  ArithmeticError
  AssertionError
  AttributeError
  BaseException
  BufferError
  BytesWarning
  DeprecationWarning
  EnvironmentError
  EOFError
  Exception
  FloatingPointError
  FutureWarning
  GeneratorExit
  ImportError
  ImportWarning
  IndentationError
  IndexError
  IOError
  KeyboardInterrupt
  KeyError
  LookupError
  MemoryError
  NameError
  NotImplementedError
  OSError
  OverflowError
  PendingDeprecationWarning
  ReferenceError
  RuntimeError
  RuntimeWarning
  StandardError
  StopIteration
  SyntaxError
  SyntaxWarning
  SystemError
  SystemExit
  TabError
  TypeError
  UnboundLocalError
  UnicodeDecodeError
  UnicodeEncodeError
  UnicodeError
  UnicodeTranslateError
  UnicodeWarning
  UserWarning
  ValueError
  Warning
  ZeroDivisionError
  
  更多异常

  python解释器检测到错误，触发异常（也允许程序员自己触发异常）

  程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）

  如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理

  为什么要进行异常处理？

  python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。

  所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性 

 

1.if判断式的异常处理只能针对某一段代码，对于不同的代码段的相同类型的错误你需要写重复的if来进行处理。

2.在你的程序中频繁的写与程序本身无关，与异常处理有关的if，会使得你的代码可读性极其的差

3.if是可以解决异常的，只是存在1,2的问题，所以，千万不要妄下定论if不能用来异常处理。

python为每一种异常定制了一个类型，然后提供了一种特定的语法结构用来进行异常处理

基本语法

try:
     被检测的代码块
except 异常类型：
     try中一旦检测到异常，就执行这个位置的逻辑

其他语法

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
else:
    代码正常时候走这个

万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：

s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print(e)

异常的finally  #try 也可以和finally 一起使用

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
#except Exception as e:
#    print(e)
else:
    print('try内代码块没有异常则执行我')
finally
    print('无论异常与否,都会执行该模块,通常是进行清理工作')

主动触发异常

try:
    raise TypeError('类型错误')
except Exception as e:
    print(e)

自定义异常

class EvaException(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

try:
    raise EvaException('类型错误')
except EvaException as e:
    print(e)

断言

# assert 条件
 
assert 1 == 1
 
assert 1 == 2

try except 和if 的比较

try..except这种异常处理机制就是取代if那种方式，让你的程序在不牺牲可读性的前提下增强健壮性和容错性

异常处理中为每一个异常定制了异常类型（python中统一了类与类型，类型即类），对于同一种异常，一个except就可以捕捉到，可以同时处理多段代码的异常（无需‘写多个if判断式’）减少了代码，增强了可读性 

使用try..except的方式

1：把错误处理和真正的工作分开来
2：代码更易组织，更清晰，复杂的工作任务更容易实现；
3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；