第8课：异常处理、面向对象编程、发送邮件、url编码

1.　异常处理

import traceback

import pymysql

import requests

def calc(a, b):

    res = a / b

    return res

def main():

    money = input("输入多少钱：")

    month = input("还几个月：")

    try:

        res = calc(int(money), int(month))

    except ZeroDivisionError as e:  # try里面的代码如果出错了，走except里面带的代码

        traceback.print_exc()  # 只是输出错误信息，不影响代码继续执行

        print("月份必须是大于1的整数， %s" % e)

    except ValueError as e:

        print("输入必须是整数，%s" % e)

    except Exception as e:  # 捕获所有的异常

        print("未知错误,%s" % e)

    else:  # 没有出错的情况下走else中的代码

        print('每个月应还多少钱', res)

    finally:  # 不管有没有捕捉到异常，都要执行的代码

        pass

    print("hahahha")

def req():

    url = 'http://api.nnzhp.cn/api/user/all_stu'

    mpp = {'Referer': 'http://api.nnzhp.cn/'}

    res = requests.get(url, headers=mpp)

    print(res.json().get('stu_info'))

    if len(res.json().get('stu_info')) > 0:

        pass

    else:

        raise Exception('接口未返回数据')  # raise主动抛出异常,程序中断

        # raise ValueError

    print("hahha")

req()

2.  面向对象编程

1）类

'''

定义类名时，最好大写

用类的话，得先实例化

self代表的是实例化好的对象，即本类对象

私有函数,私有变量:出了类就不能使用的了。

'''

class Car():  # 类是一个模型，模板

    # 构造函数，类初始化时执行

    # 如果类实例化时需传入一组参数，需在__init__函数中写参数

    def __init__(self, color, window):

        self.color = color

        self.window = window

        self.price = 1000

        print("init...")

    def run(self):

        print("汽车在跑。。。")

    def my_self(self):

        print("我是一个汽车，我的颜色是：%s，我有%s个窗户" % (self.color, self.window))

bus = Car("黄色", "3")  # 实例化, 把模型做成实际的汽车，这个过程叫实例化

# 实例就是具体造出来的东西，通过类实例化造出的东西，就是实例。

# 对象，即实例

bus.my_self()

　self小结

class My(object):

    country = "China"  # 类变量

    def __init__(self, name):

        self.name = name  # 实例变量，必须实例化后才能用的变量，也称为成员变量

        self.cry()

    def cry(self):

        print("%s is crying..." %self.name)

    def learn(self):

        self.skill = ["开车"]

    def my_self(self):

        print("我的名字是【%s】 我会【%s】" %(self.name, self.skill))

print(My.country)

qxy = My('qxy')

qxy.skill = "写代码"

qxy.learn()

qxy.my_self()  # 我的名字是【qxy】 我会【写代码】

print(qxy.name)

2）继承

# 继承

#     父类有的变量 函数，子类全部能继承到

#     如果定义的类，有很多重复功能，那么可以将它定义为父类

#

class Father(object):
    # 属性方法：看上去好像是一个属性，实际是一个方法，也得实例化后才能使用

    @property

    def money(self):

        return 100000

    def smoke(self):

        print("抽烟")

    def drink(self):

        print("喝碱水")

    def run(self):

        print("每天喝水")

class Yjz(Father):

    def drive(self):

        print("我会开车")

yjz = Yjz()

print(yjz.money)

class Animal(object):

    def eat(self):

        print("i am eating")

3） 私有函数、私有变量

import redis

class MyRedis(object):

    xiaohei = "小黑"

    def __init__(self, host, password='', port=6379):

        self.__host = host  # 私有变量，只能在类里面使用，在类外面使用提示不存在这个变量

        self.password = password

        self.port = port

        # self.__conn_redis()

    def __conn_redis(self):  # 私有方法，只能在类里面使用

        print(self.__host)

        self.conn = redis.Redis(host=self.__host,password=self.password, port=self.port)

    def get(self, k):

        return self.conn.get(k).decode()

    # 静态方法：只是写在了类里面的方法，用不了self的属性或方法，调用不了类中的其它函数

    @staticmethod

    def other():

        print("我是other方法")

    # 类方法：不需要实例化就可以直接使用，可以使用类的变量和方法

    @classmethod

    def class_function(cls):

        print(cls.xiaohei)

        cls.class_function1()

        # print(cls.get(cls,'session:qxy'))

    @classmethod

    def class_function1(cls):

        print("类方法2")

r = MyRedis('127.0.0.1')

MyRedis.other()

# print(r.get('session:qxy'))

# print(r.__host)

# print(r.__conn_redis)

MyRedis.class_function()

4） 析构函数

import pymysql

class OpMySql1:  # 经典类

    pass

class OpMySql(object):  # 新式类

    # 析构函数，实例被销毁时执行此函数

    def __del__(self):

        print("over")

        self.cur.close()

        self.conn.close()

bus = OpMySql('***', '**', '***', '***')

print(bus.db_execute("select * from user;"))

# del bus  # 这也是实例被销毁的一种写法,销毁时会调用__del__方法

# bus.close()

3. 发送邮件　

import smtplib  # 发邮件的模块

from email.mime.text import MIMEText  # 构造邮件内容的对象

from email.mime.multipart import MIMEMultipart  # 发附件要导入的模块

email_host = 'smtp.126.com'  # 邮箱地址

email_sender = '**@126.com'  # 发送者账号

email_pwd = '***'  # 发送者密码

email_receiver_list = "**@qq.com, **@qq.com"  # 收件人邮箱，多个账号的话

me = email_sender

# msg = MIMEText('邮件发送测试内容')  # 邮件内容

# msg['Subject'] = '邮件测试主题'  # 邮件主题

# msg['From'] = me  # 发送者账号

# # msg['To'] = maillist  # 接收者账号列表

# attachment 附件

attach_obj = MIMEMultipart()  # 创建带附件邮件的对象

file = 'a.txt'

content = "邮件正文"

att = MIMEText(open(file, encoding='utf-8').read())  # 邮件内容对象

att["Content-Type"] = 'application/octet-stream'

att["Content-Disposition"] = 'attachment; filename="%s"' % file

attach_obj.attach(att)

# msg.attach(MIMEText(content))  # 邮件正文的内容

attach_obj['Subject'] = '邮件测试主题'  # 邮件主题

attach_obj['From'] = me  # 发送者账号

attach_obj['To'] = email_receiver_list  # 接收者账号

# smtp = smtplib.SMTP_SSL(email_host,port=465)#qq邮箱

# smtp = smtplib.SMTP(email_host,port=25)#其他邮箱

# smtp.login(email_user,email_pwd)

# smtp.sendmail(email_user,maillist,msg.as_string())

# smtp.quit()

smtp = smtplib.SMTP('smtp.126.com', port=25)  # 和邮箱服务器建立连接

smtp.login(me, email_pwd)

# attach_obj['To']是str类型，sendemail()中接收邮件人是list类型

smtp.sendmail(me, email_receiver_list.split(','), attach_obj.as_string())  # 将邮件对象转换为string

# smtp = smtplib.SMTP(email_host, port=25)  # 连接邮箱，传入邮箱地址，和端口号，smtp的端口号是25

# smtp.login(email_user, email_pwd)  # 发送者的邮箱账号，密码

# smtp.sendmail(me, maillist, msg.as_string())

# # 参数分别是发送者，接收者，第三个是把上面的发送邮件的内容变成字符串

smtp.quit()  # 发送完毕后退出smtp

print('email send success.')

4. URL编码

import urllib.parse

s = "besttest 自动化测试"

print(urllib.parse.quote(s))  # url编码

# 打印结果：besttest%20%E8%87%AA%E5%8A%A8%E5%8C%96%E6%B5%8B%E8%AF%95

src = "https://www.baidu.com/s?ie=UTF-8&wd=%E8%87%AA%E5%8A%A8%E5%8C%96%E6%B5%8B%E8%AF%95"

# src

print(urllib.parse.unquote(src))  # url解码

# 打印结果： https://www.baidu.com/s?ie=UTF-8&wd=自动化测试

print(urllib.parse.unquote_plus(src))  # 加强版url解码

# 打印结果： https://www.baidu.com/s?ie=UTF-8&wd=自动化测试