python基础4——类、异常处理、常用模块

一、类

面向对象编程&面向过程编程概念：

1. 面向过程编程：是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程。比如前面的定义函数就是面向过程编程，代码是从上往下一行行执行，可以看到整个过程。
2. 面向对象编程：是一种计算机编程架构，以对象为中心的编程思想，对现实世界理解和抽象的方法。比如把作用相似的函数规划到一起创建一个类，是从对象来考虑代码结构的。

类&对象之间的关系：

1. 类：类是对现实生活中一类具有共同特征的事物的抽象描述。例如电脑类、空调类、人类。
2. 对象：类的实体，实际存在的事物，例如电脑类的“主机”、“显示器”。
3. 类是由对象来定，这个过程叫做抽象化。用类创建对象，这个过程称为实例化

类的特点：

1. 封装：把相同对象的功能（函数）、属性（变量）组合在一起。
2. 方法：对象的功能（例如电脑能上网、看片），实际在类里面就是函数，称为成员函数，也可以称为方法。
3. 属性：对象的特征（例如电脑都有主机、显示器）。
4. 实例化：用类创建对象，这个对象具体是什么东西，例如你用的电脑、我这个人。

定义方法：

• 使用class关键字定义类。

类的书写规范：

• 类一般采用大驼峰命名，例如MyClass。
• 类注释，用于说明该类的用途，提高可阅读性。
• 类中只存在两种数据：属性和方法。
• 声明属性必须赋值。
• 声明方法的第一个参数必须是self，其他与普通函数一样。
• 一般会使用__init__方法给类指定的初始状态属性。

1.类的定义和使用。

#######################################################
##定义类。
class Computer():    ##类的名称为Computer
    '''
    电脑类
    '''
    #定义属性，相当于变量。
    def __init__(self):
        self.host = "4C8G"
        self.displayer = "27寸"
        self.keyboard = "机械键盘"
        self.mouse = "无线鼠标"
    #定义方法，相当于函数。后续通过引用函数名称调用类的哪个函数功能。
    def office(self):
        return "办公"
    def internet(self):
        return "上网"
    def movies(self):
        return "看片"
#######################################################
##类的实例化。
##实例化：用类创建对象的过程。
##类实例：用类创建对象。
##实例属性：对象的属性。
##实例方法：对象调用的方法。

pc = Computer()      #类实例化，pc是类实例。
print(pc.host)       #访问类属性，查看电脑配置。
print(pc.movies())   #访问类方法，让电脑做事。        

2.例一，让某个人使用电脑做事。

class Computer():
    '''
    电脑类
    '''
    # 属性。
    def __init__(self, name):   ##传入一个参数name。
        self.host = "4C8G"
        self.displayer = "27寸"
        self.keyboard = "机械键盘"
        self.mouse = "无线鼠标"
        self.name = name
    # 方法。
    def office(self):
        return "%s在办公" %self.name
    def internet(self):
        return "%s在上网" %self.name
    def movies(self):
        return "%s在看片" %self.name

zhangsan = Computer("张三")
print(zhangsan.office())

lisi = Computer("李四")
print(lisi.movies())

3.例二，初始化函数。

class Calc():
    '''计算器类'''
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
    def jia(self):
        return self.num1 + self.num2
    def jian(self):
        return self.num1 - self.num2
    def cheng(self):
        return self.num1 * self.num2
    def chu(self):
        return self.num1 / self.num2

calc = Calc(6, 6)
print(calc.jia())

二、python异常处理

捕获异常的原因：

1. 异常是指程序因为某种原因无法正常工作了，比如代码缩进错误、缺少软件包、环境错误、连接超时等都会引发异常。
2. 一个健壮的程序应该把所能预知的异常都应做相应的处理，保障程序长期运行。

捕获异常方法：

• 如果在执行 try 块里的业务逻辑代码时出现异常，系统会自动生成一个异常对象，该异常对象被提交给 Python 解释器，这个过程被称为引发异常。
• 当 Python 解释器收到异常对象时，会寻找能处理该异常对象的 except 块，如果找到合适的 except 块，则把该异常对象交给该 except 块处理，这个过程被称为捕获异常。如果 Python 解释器找不到捕获异常的except 块，则运行时环境终止，Python 解释器也将退出。

异常类型	释义
SyntaxError	语法错误
IndentationError	缩进错误
TypeError	对象类型与要求不符合
ImportError	模块或包导入错误；一般路径或名称错误
KeyError	字典里面不存在的键
NameError	变量不存在
IndexError	下标超出序列范围
IOError	输入/输出异常；一般是无法打开文件
AttributeError	对象里没有属性
KeyboardInterrupt	键盘接受到Ctrl+C
Exception	通用的异常类型；一般会捕捉所有异常
UnicodeEncodeError	编码错误

1.语法。

try:
    <代码块>
except [异常类型]:
    <发生异常时执行的代码块>

2.例一，打印一个没有定义的变量。

try:
    print(name)
except NameError:
    print("发生名称错误时，执行的代码")

3.例二，当不确定异常类型时，可以使用通用异常类型。

try:
    print(name)
except Exception:   ##Exception指通用类型。
    print("发生名称错误时，执行的代码")

4.例三，保存异常信息。

try:
    print(name)
except Exception as e:
    print("错误：%s" %e)
    print("发生名称错误时，执行的代码")

三、自定义模块

模块是什么？

1. 一个较大的程序一般应分为若干个程序块，这些程序块称为模块，每个模块用来实现一部分特定的功能。这样可以方便管理和重复使用。
2. python中有很多别人已经定义好的模块，我们可以直接拿来使用。我们也可以根据项目情况去自定义模块使用。
3. python中的模块定义就是写一个py文件，然后导入这个py文件就代表引用该模块了。

使用模块的方法：

import <模块名称>
from <模块名称> import <方法名>
import <模块名称> as <别名>

1.定义模块，写一个py文件，我这里就命名为qingjun.py，qingjun为模块名。

##定义函数1。
def count1(a,b):
    return a+b

##定义函数2.
name = "mm"
def count2(a, b):
    result = a * b
    return f"{a}与{b}的乘积是: {result}"

##定义类。
class jia():
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def baimu(self):
        return self.a + self.b

2.导入模块，方式一。

import qingjun

##调用qingjun模块中的一个名为jia的类。
c = qingjun.jia(10, 5)
print(c.baimu())

##调用qingjun模块中的一个名称conut1的函数。
print(qingjun.count1(1,6))

3.导入模块并重命名，方式二。

import qingjun as a

##调用qingjun模块中的一个名为jia的类。
c = a.jia(10, 5)
print(c.baimu())

##调用qingjun模块中的一个名称conut1的函数。
print(a.count1(1,6))

4.导入模块某个功能，方式三。

from qingjun import jia

##调用qingjun模块中的一个名为jia的类。
c = jia(10, 5)    ##这种方法可以不跟模块名称。
print(c.baimu())

3.1 保留模块测试代码

• 保留模块py文件中的测试代码，可以方便他人查阅使用模块。我们自定义好一个模块时，常常在后面写一小段代码进行测试，但又不想让他人使用该模块时导入我这段测试代码，这时可以用Python文件的内置属性__name__实现。
• 若直接运行Python文件，__name__的值是"main"；若import一个模块，那么模块的__name__的值是"文件名"。

1.在模块py文件中添加“__name__”，执行模块文件返回的是“__main__”。

2.在模块py文件中添加“__name__”，引用模块时执行返回的是模块名称。

3.所以常常在模块的测试代码中添加if判断，这样可以防止别人引用模块时也把测试代码执行了。

##测试代码。
if __name__ == "__main__":
    print(count1(1,1))    ##打印函数count1的值。
    c = jia(10, 5)
    print(c.baimu())      ##打印类jia的值。

3.2 添加模块使用说明

• 自定义模块也可以添加说明文档，方便他人使用。与函数或类的添加方法相同，即只需在模块开头的位置定义一个字符串即可。

1.定义模块说明文档。

2.引用模块后，可以打印模块说明文档。

##导入模块。
import qingjun

##打印模块的说明文档,方式一。
print("说明文档: %s" %qingjun.__doc__)
##打印模块的说明文档,方式二。
help(qingjun)

3.查看效果。

四、内置模块

• 官方文档。

常用内置模块	作用
os	操作系统管理
sys	解释器交互
platform	操作系统信息
glob	查找文件
shutil	文件管理
random	随机数
subprocess	执行Shell命令
pickle	对象数据持久化
json	JSON编码和解码
time	时间访问和转换
datetime	日期和时间
urllib	HTTP访问

4.1 os标准库

• os库主要对目标和文件操作。

方法	作用
os.name	返回操作系统类型
os.environ	以字典形式返回系统变量
os.putenv(key, value)	改变或添加环境变量
os.listdir(path=’.’)	列表形式列出目录下所有目录和文件名
os.getcwd()	获取当前路径
os.chdir(path)	改变当前工作目录到指定目录
os.mkdir(path [, mode=0777])	创建目录
os.makedirs(path [, mode=0777])	递归创建目录
os.rmdir(path)	移除空目录，不能删除有文件的目录
os.remove(path)	移除文件
os.rename(old, new)	重命名文件或目录
os.stat(path)	获取文件或目录属性
os.chown(path, uid, gid)	改变文件或目录所有者
os.chmod(path, mode)	改变文件访问权限
os.symlink(src, dst)	创建软链接
os.unlink(path)	移除软链接
os.getuid()	返回当前进程UID
os.getlogin()	返回登录用户名
os.getpid()	返回当前进程ID
os.kill(pid, sig)	发送一个信号给进程
os.walk(path)	目录树生成器，生成一个三组 (dirpath, dirnames, filenames)
os.system(command)	执行shell命令，不能存储结果
os.popen(command [, mode=‘r’ [, bufsize]])	打开管道来自shell命令，并返回一个文件对象

1.可以使用ipython进入，获取当前操作系统类型。

2.列出当前目录下的文件和目录。

3.获取目录树生成树。

4.2 os.path类

• 用于获取文件属性。

方法	作用
os.path.basename(path)	返回最后一个文件或目录名
os.path.dirname(path)	返回最后一个文件所属目录
os.path.abspath(path)	返回一个绝对路径
os.path.exists(path)	判断路径是否存在，返回布尔值
os.path.isdir(path)	判断是否是目录
os.path.isfile(path)	判断是否是文件
os.path.islink(path)	判断是否是链接
os.path.ismount(path)	判断是否挂载
os.path.getatime(filename)	返回文件访问时间戳
os.path.getctime(filename)	返回文件变化时间戳
os.path.getmtime(filename)	返回文件修改时间戳
os.path.getsize(filename)	返回文件大小，单位字节
os.path.join(a, *p)	加入两个或两个以上路径，以正斜杠"/"分隔。常用于拼接路径
os.path.split(path）	分隔路径名
os.path.splitext(path）	分隔扩展名

1.分隔路径名。

2.分隔扩展名。

4.3 sys库

• 用于与Python解释器交互。

方法	作用
sys.argv	从程序外部传递参数 argv[0] #代表本身名字 argv[1] #第一个参数 argv[2] #第二个参数 argv[3] #第三个参数 argv[N] #第N个参数 argv #参数以空格分隔存储到列表
sys.exit([status])	退出Python解释器
sys.path	当前Python解释器查找模块搜索的路径，列表返回。
sys.getdefaultencoding()	获取系统当前编码
sys.platform	返回操作系统类型
sys.version	获取Python版本

1.写一个python脚本，执行并传入参数。

[root@qingjun opt]# cat qingjun.py 
import sys
print(sys.argv)
print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])
print(sys.argv[3])

2.退出python解释器，可以添加退出状态码。

[root@qingjun opt]# cat qingjun.py 
import sys
print(sys.argv)
print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])
sys.exit([443])
print(sys.argv[3])

3.添加自定义模块路径。

##追加自定义模块路径。
sys.path.append("/opt/qingjun.py")

4.查看操作系统类型，与os.name作用相似。

4.4 platform库

• 用于获取操作系统详细信息。

方法	作用
platform.platform()	返回操作系统平台
platform.uname()	返回操作系统信息
platform.system()	返回操作系统平台
platform.version()	返回操作系统版本
platform.machine()	返回计算机类型
platform.processor()	返回计算机处理器类型
platform.node()	返回计算机网络名
platform.python_version()	返回Python版本号

4.5 glob库

• 用于文件查找，支持通配符（*、？、[]）

1.查找/opt/目录中所有以.py为后缀的文件。

glob.glob('/opt/*.py')   ##查找以py结尾的文件。
glob.glob('/opt/*')      ##查找所有文件。

##对返回的元组进行取值。
glob.glob('/opt/*')[0]   
glob.glob('/opt/*')[1]
glob.glob('/opt/*')[2]

2.通配符？的用法，一个？代表一个字符。

glob.glob('/opt/???????.py')

3.查找目录中出现a.sh或b.sh的文件。

glob.glob("/opt/[a|b].py")

4.6 random库

• 用于生成随机数。

方法	作用
random.randint(a,b)	随机返回整数a和b范围内数字
random.random()	生成随机数，它在0和1范围内
random.randrange(start, stop[, step])	返回整数范围的随机数，并可以设置只返回跳数
random.sample(array, x)	从数组中返回随机x个元素
random.choice(seq)	从序列中返回一个元素

1.对生成的随机数进行切割，并取值。

##先转换数据类型为str，在进行切片取值。
str(random.random()).split('.')[1]
str(random.random()).split('.')[0]

4.7 subprocess库

作用：

• 用于执行Shell命令，工作时会fork一个子进程去执行任务，连接到子进程的标准输入、输出、错误，并获得它们的返回代码。
• 该模块将取代os.system、os.spawn*、os.popen*、popen2.* 和commands.*。

subprocess的主要方法：

• subprocess.run()，推荐使用。
• subprocess.Popen()，老版本使用。
• subprocess.call，偏底层。

语法：subprocess.run(args, *, stdin=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, check=False, encoding=None)

参数	说明
args	要执行的shell命令，默认是一个字符串序列，如[‘ls’, ‘-al’]或(‘ls’, ‘-al’)； 也可以是一个字符串，如’ls -al’，同时需要设置shell=True。
stdin stdout stderr	run()函数默认不会捕获命令运行结果的正常输出和错误输出， 可以设置stdout=PIPE, stderr=PIPE来从子进程中捕获相应的内容； 也可以设置stderr=STDOUT，使标准错误通过标准输出流输出。
shell	如果shell为True，那么指定的命令将通过shell执行。
cwd	改变当前工作目录
timeout	设置命令超时时间。如果命令执行时间超时，子进程将被杀死，并弹出TimeoutExpired 异常。
check	如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)。
encoding	如果指定了该参数，则 stdin、stdout 和 stderr 可以接收字符串数据，并以该编码方式编码。否则只接收 bytes 类型的数据。

1.在python脚本中导入subprocess模块，执行正确命令示范。

import subprocess    ##导入模块。
cmd = "pwd"   ##要执行的命令。
result = subprocess.run(cmd, shell=True, timeout=3, stderr=subprocess.PIPE，stdout=subprocess.PIPE)  ##run方法返回CompletedProcess实例，可以直接从这个实例中获取命令运行结果。
print(result)
print(result.returncode)     ##获取状态码。
print(result.stdout)         ##标准输出。
print(result.stderr)         ##错误输出。

2.在python脚本中导入subprocess模块，执行错误命令示范。

import subprocess    ##导入模块。
cmd = "pwdd"   ##错误命令。
result = subprocess.run(cmd, shell=True, timeout=3, stderr=subprocess.PIPE，stdout=subprocess.PIPE)   
print(result)
print(result.returncode)     ##获取状态码。
print(result.stdout)         ##标准输出。
print(result.stderr)         ##错误输出。

4.8 pickle库

• 可以实现对一个Python对象结构的二进制序列化和反序列化。
• 主要用于将对象持久化到文件存储，方便把数据文件给别人使用，适用于小型数据（几兆、几十兆）。

两个函数：

• dump() 把对象保存到文件中（序列化），使用load()函数从文件中读取（反序列化）。
• dumps() 把对象保存到内存中，使用loads()函数读取。

1.将数据对象保存到文件中，文件名自定义，一般使用pkl作为后缀名。

import pickle
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}

##导出数据到文件中。
with open("hehe.pkl", "wb") as f:
    pickle.dump(computer, f)

2.读取文件中的数据。

import pickle
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}

##读取文件中数据。
with open("hehe.pkl", "rb") as f:
    print(pickle.load(f))

4.9 JSON库

• 用于数据格式转换，一般API返回的数据大多是JSON、XML，如果返回JSON的话，需将获取的数据转换成字典，方便在python程序中处理。

两个函数：

• dumps() 对数据进行编码。
• loads() 对数据进行解码。

1.将字典类型转换为JSON对象，方便将我的python数据给其他人使用。

import json
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}
json_obj = json.dumps(computer)
print(type(computer))
print(type(json_obj))
print(json_obj)

2.将JSON对象转换为字典，方便将别人的数据拿到我的python中使用。

import json
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}

json_obj = json.dumps(computer)   ##比作获取的json数据。
data = json.loads(json_obj)     ##将json数据转换成字典型。
print(type(data))
print(data)

4.10 time库

• 用于满足简单的时间处理，例如获取当前时间戳、日期、时间、休眠。

方法	描述
time.ctime(seconds)	返回当前时间时间戳
time.localtime([seconds])	当前时间，以stuct_time时间类型返回
time.mktime(tuple)	将一个stuct_time时间类型转换成时间戳
time.strftime(format[, tuple])	将元组时间转换成指定格式。[tuple]不指定默认是当前时间
time.time()	返回当前时间时间戳
time.sleep(seconds)	延迟执行给定的秒数

1.获取当前时间。

import time
print(time.ctime())

##以stuct_time时间类型返回。
print(time.localtime())

2.获取时间戳。

import time

##以stuct_time时间类型返回时间戳。
print(time.localtime())

##将stuct_time时间类型转换成时间戳。
print(time.mktime(time.localtime()))

##获取时间戳，方式二。
print(time.time())

3.自定义时间格式。

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

##睡眠3秒。
time.sleep(3)

4.将时间戳转换指定格式。

now = time.time()
struct_time = time.localtime(now)
print(time.strftime('%Y-%m-%d %H:%M:%S',struct_time))

4.11 datetime库

• 用于处理更复杂的日期和时间。

类	作用
datetime.date	日期，年月日组成
datetime.datetime	包括日期和时间
datetime.time	时间，时分秒及微秒组成
datetime.timedelta	时间间隔
datetime.tzinfo	时区信息对象

1.获取系统时间。

from datetime import date, datetime
#获取当前系统时间。
print(datetime.now())

# 将当前系统时间转换指定格式。
print(date.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S'))

#获取当前系统时间(格式化，按天获取)。
print(date.isoformat(date.today()))

2.获取时间戳。

import time
from datetime import date, datetime

##获取时间戳。
date_array = datetime.fromtimestamp(time.time())
print(date_array)

#将时间戳转换指定格式。
print(date_array.strftime("%Y-%m-%d %H:%M:%S"))

3.获取昨天、明天的时间。

#获取昨天日期。
from datetime import date, timedelta
yesterday = date.today() - timedelta(days=1)
yesterday = date.isoformat(yesterday)
print(yesterday)

#获取明天日期。
tomorrow = date.today() + timedelta(days=1)
print(tomorrow)


#将时间对象格式化。
tomorrow = date.isoformat(tomorrow)
print(tomorrow)

4.12 urllib库

• 用于访问URL。
• 用的最多是urllib.request 类，它定义了适用于在各种复杂情况下打开 URL，例如基本认证、重定向、Cookie、代理等。

常用的类	作用
urllib.request	打开和读取 URL。
urllib.error	包含 urllib.request 抛出的异常。
urllib.parse	用于解析 URL。
urllib.robotparser	用于解析 robots.txt 文件。

4.12.1 request类

方法	描述
getcode()	获取响应的HTTP状态码。
geturl()	返回真实URL。有可能URL3xx跳转，那么这个将获得跳转后的URL。
headers	返回服务器header信息。
read(size=-1)	返回网页所有内容。size正整数指定读取多少字节。
readline(limit=-1)	读取下一行。size正整数指定读取多少字节。
readlines(hint=0, /)	列表形式返回网页所有内容，以列表形式返回。sizehint正整数指定读取多少字节。

1.自定义用户代理。

from urllib import request

##要请求的url。
url = "http://www.baidu.cn"

##浏览器信息。
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"
header = {"User-Agent": user_agent}
req = request.Request(url, headers=header)
res = request.urlopen(req)     ##打开url。
print(res.getcode())    ##获取访问url的状态码。

2.向接口提交用户数据。

from urllib import request, parse
url = "https://passport.jd.com/new/login.aspx?ReturnUrl=https%3A%2F%2Fwww.jd.com%2F"
post_data = {"username":"user1","password":"123456"}
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"
header = {"User-Agent": user_agent}
#将字典转为URL查询字符串格式，并转为bytes类型
post_data = parse.urlencode(post_data).encode("utf8")
req = request.Request(url, data=post_data, headers=header)
res = request.urlopen(req)
print(res.read())