Python常⽤库与IO操作及异常管理

菜鸟学识

已于 2023-03-08 16:28:04 修改

阅读量162

点赞数

分类专栏： python编程基础文章标签： python json os

于 2021-07-01 22:55:25 首次发布

本文链接：https://blog.csdn.net/suruoxun/article/details/118399914

版权

python编程基础专栏收录该内容

16 篇文章 1 订阅

订阅专栏

包&模块

标准库

os库：

json模块：主要用法是序列化dumps（列表，元组，字典转成str）和反序列化loads（str转成python对象的过程）

time和Datetime:

sys实战：实际应用一般是寻找被调用的模块，使用sys把它添加到搜索的路径中

hashlib模块：主要涉及到md5的加密算法

包&模块

在Python⾥⾯，每⼀个Python⽂件都是都可以成为⼀个模块，在⼀个包中可以包含多个Python⽂件，也就是多个Python的⽂件。包与模块的关系具体如下:

如果是同包之间的模块调⽤，也就是说模块是在同⼀个包⾥⾯，不同的Python⽂件模块之间互相调⽤，它的⽅式为:

from 包.被调⽤的模块 import 被调⽤的模块

如果是不同包之间的模块调⽤，那么它的规则就需要到包的级别，规则和上⾯的⼀样

标准库

在Python中，库可以分为两类，⼀类是标准库，也就是说安装完Python的解释器后，这些库就已经存在，不需要单独的再次安装，如unittest,os,sys,hashlib,time等，另外⼀类是第三⽅的库，需要单独的进⾏安装，如selenium,flask,django,requests。关于第三⽅的库，安装⽅式主要分为两类，⼀类是在线安装，另外⼀类是离线安装，⼀般性的建议是在线安装的⽅式。⽐如安装很多第三⽅的库，在线安装的⽅式具体如下:

pip3 install selenium
pip3 install requests
pip3 install django
pip3 install flask
pip3 install xlrd
pip3 install aiohttp

os库：

import os

# 获取当前路径
a_path = os.path.dirname(__file__)
print(a_path)
# 路径拼接
b_path = os.path.join(a_path, 'b.py')
print(b_path)
# 获取上一层的目录
next_path = os.path.dirname(os.path.dirname(__file__))
print("输出next_path:", next_path)
#  获取当前路径的绝对路径
ab_path = os.path.abspath(os.path.dirname(__file__))
print(ab_path)

json模块：主要用法是序列化dumps（列表，元组，字典转成str）和反序列化loads（str转成python对象的过程）

import json

list1 = ['name', 'age', 'sex']
tuple1 = ('java', 'python', 'go')
dict1 = {'name': 'xia', 'age': '18', 'sex': '女'}

print(type(json.dumps(list1)))
print(type(json.dumps(tuple1)))
print(type(json.dumps(dict1)))
print(type(json.loads(json.dumps(list1))))

输出结果：
<class 'str'>
<class 'str'>
<class 'str'>
<class 'list'>

对文件的序列化（往文件里写）和反序列化（从文件里读）操作

import json


def fileDump():
    temp = {'username': 'xia', 'password': '123'}
    json.dump(temp, open('jsonfile.json', 'w'))


def fileLoad():
    print(type(json.load(open('jsonfile.json', 'r'))))


fileDump()
fileLoad()

输出结果：<class 'dict'>

time和Datetime:

import time
import datetime

print(time.strftime('%y-%m-%d %H:%M:%S', time.localtime()))
print(datetime.datetime.now())

输出结果：
21-06-23 15:25:14
2021-06-23 15:25:14.089259

sys实战：实际应用一般是寻找被调用的模块，使用sys把它添加到搜索的路径中

import sys
import os

basePath = os.path.dirname(os.path.dirname(__file__))
aPath = os.path.join(basePath, 'untitled2', 'a.py')
# 将a.py添加搭配路径搜索中
sys.path.append(aPath)
for item in sys.path:
    print(item)

hashlib模块：主要涉及到md5的加密算法

import hashlib
from urllib import parse


def sign():
    dict1 = {'name': 'xia', 'age': '18', 'sex': '女'}
    # 对dict1 进行ascii码的排序
    data = sorted(dict1.items(), key=lambda item: item[0])
    # urlencode将数据处理成key=value的形式
    datas = parse.urlencode(data)
    # 进行md5加密
    m = hashlib.md5()  # md5对象
    m.update(datas.encode('utf-8'))  # 对datas加密
    return m.hexdigest()  # 拿到加密后的字符串


print(sign())

输出结果：21066b3e7b17dfc5b00a64538d3b6c36

IO操作

⽂本模式

我们对⽂件的操作，⼀般情况下，分为三种情况，分别是:打开⽂件，操作⽂件(读写等)，关闭⽂件。在Python 的语⾔里，提供了对⽂件的操作⽅法，默认open()是打开⽂件并且是只读模式，事实上打开和关闭⽂件⽐较很好的理解，操作⽂件，那么操作⽂件的前提打开⽂件，打开⽂件就涉及到以什么样的模式来打开⽂件，⽐如读，写，只读，只写，⼆进制等等模式，具体总结的⻅如下:

r:只读模式 w:只写模式【不可读，不存在就创建，存在就清空内容】
x:只写模式【不可读，不存在就创建，存在就报错】
a:增加模式【可读，不存在就创建，存在只增加内容】

"+"表示可以同时读写某个⽂件，具体为:
r+:读写
w+:写读
x+:写读
a+:写读

open函数

w模式

def write():
   f=open('log.md','w')
   f.write('hello world')
   f.close()
   
if __name__ == '__main__':
   write()

备注:w的模式是每次操作前，会清空⽂件⾥⾯的内容，然后把新的内容写进去。

r模式

def read():
   '''只读模式来获取⽂件的内容''' 
   f=open('log.md','r') 
   print('读取⽂件内容:\n',f.read()) 
   print('只读取⽂件的第⼀⾏:\n',f.readline())
   print('按⾏读取所有的⽂件内容:\n')
   
for item in f.readlines():
   print(item)
   
if __name__ == '__main__':
   read()

备注:r是只读模式，来读取⽂件⾥⾯的内容。

a模式

def addWrite(): 
   '''追加的模式来读取⽂件⾥⾯的内容信息''' 
   f=open('info.md','a') 
   f.write('Hello')
   f.close()
   
if __name__ == '__main__':
   addWrite()

备注:a的模式是追加的模式，就是在之前⽂件内容的基础上增加新的⽂件内容。

⽂件指针

读取⼀个⽂件⾥⾯的内容，并不⼀定读取它⾥⾯所有的⽂件内容，⽐如⽂件内容是:Hello Go，我们只是想读取Go的内容，就涉及到⽂件的指针，具体如下:

def readPoint():
   '''⽂件指针的应⽤'''
   f=open('info.md','r')
   print('当前⽂件的指针为:{0}'.format(f.tell()))
   print('读取⽂件的所有内容:',f.read()) 
   #指针指向6的位置，然后读取⾥⾯的内容信息
   f.seek(6)
   print(f.read())
   
if __name__ == '__main__':
   readPoint()

with上下⽂

针对⽂件的操作，我们特别需要注意我们open⽂件后，⼀定要进⾏close的操作，但是很多的时候⼜会忘记close,这个时候我们可以使⽤with上下⽂来解决这个问题，它内部会对⽂件进⾏close的操作，我们只需要更多的关注⽂件本身IO的操作。具体写和读的内容如下:

def withWrite():
   with open('info.md','w') as f:
      f.write('This Is A Test Data')
      
def withRead():
   with open('info.md','r') as f:
      print('获取到的⽂件内容为:\n',f.read())
      
if __name__ == '__main__':
   withWrite()
   withRead()

异常管理

认识异常

在编写程序的时候，某些时候需要处理异常，⽐如写⼀个除法的函数或者⽅法，分⺟是0，那么这样的程序肯定是要处理异常的，我们来看看如果不异常处理，代码如下:

def func():
   print(10/0)
   
if __name__ == '__main__':
   func()


输出：
print(10/0)
ZeroDivisionError: division by zero

因此，为了程序的健壮性，我们需要针对这种异常的情况进⾏处理和优化。在Python⾥⾯，异常的⽗类是BaseException类，源码如下:

class Exception(BaseException):
    """ Common base class for all non-exit exceptions. """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

异常顺序

在Python中，针对异常的处理我们可以使⽤的关键字是try expect else finally，它的流程具体如下:

如：

def func():
   try:
      print(10/0)
   except Exception as e:
      print(e.args[0])
   else:
      print('try执⾏完就到我') 
   finally:
      print('我都是被执⾏的')
      
if __name__ == '__main__':
   func()

异常案例实战

import sys
import json


def out():
    username = input('请输⼊登录⽤户名:\n')
    password = input('请输⼊登录密码:\n')
    return username, password


def login():
    username, password = out()
    userInfo = json.load(open('user.txt'))
    lists = userInfo.split('|')
    if lists[0] == username and lists[1] == password:
        print('登录后台系统成功!')
    else:
        print('您的⽤户名或者是错误')


def register():
    username, password = out()
    temp = username + '|' + password
    json.dump(temp, open('user.txt', 'w'))


def func():
    while True:
        try:
            f = int(input('1、登录 2、注册 3、退出\n'))
            if f == 1:
                login()
            elif f == 2:
                register()
            elif f == 3:
                sys.exit(0)
            else:
                continue
        except Exception as e:
            continue


if __name__ == '__main__':
    func()