自动发邮件、面向对象

一、自动发邮件

1、使用模块 yagmail，安装模块，python install yagmail-0.10.212-py2.py3-none-any.whl

如果直接pip install yagmail，发中文附件，文件名显示为乱码

2、在邮箱设置开启smtp服务

3、开启邮箱授权码，授权码是用于登录第三方邮件客户端的专用密码。

适用于登录以下服务: POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服务

自动发邮件代码示例：

import yagmail

username = '[email protected]'
passwd = 'sdfsdfsd'#授权码,随便填的,请输入自己的
mail = yagmail.SMTP(user=username,
                    password=passwd,
                    host='smtp.163.com',
                    # smtp_ssl=True
                    ) #如果用的是qq邮箱或者你们公司的邮箱使用是安全协议的话，
                    # smtp_ssl=True
mail.send(
    to=['[email protected]','[email protected]'], #如果多个收件人的话，写成list就行了
    cc='[email protected]',#抄送
    subject='学习发送邮件',#邮件标题
    contents='你好，你今天开心吗？',#邮件正文
    attachments=[r'C:\\Users\\nhy\\Desktop\\修改pip源.py',
                 r'C:\\Users\\nhy\\PycharmProjects\\pp\\day9\\笔记.txt'])
print('发送成功')

二、面向对象编程

1、面向对象与面向过程的区别

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

举例:买车

面向过程编程执行者，完成买车整个过程，要在不同地点完成不同的事情，要进行以下步骤：

1、4S店掏钱买车

2、保险公司上保险

3、税务局交购置税

4、交管局验车、选号、交钱、取牌、上牌

面向对象指挥者，买车只需要在买车办事处完成，在办事处4S店、保险公司等这些角色（即对象）能完成相应的事情

买车办事处

1、4S店掏钱买车

2、保险公司上保险

3、税务局交购置税

4、交管局验车、选号、交钱、取牌、上牌

2、面向对象的一些概念

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。 python3中多继承都是广度优先，python2中经典类的多继承是深度优先，新式类的多继承是按照广度优先的。

继承是为了代码的重用

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

10.封装：把一些功能的实现细节不对外暴露，类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

比如说造的一个人，你把他身体内部的什么心肝脾肺肾都封装起来了，其他人都看不到，你直接找这个人。

11.多态：对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。

多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话

3、类的一些概念

属性：属性就是类里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。这个可以理解为，人是一个类，他的名字、年龄、性别就是它的属性。
方法：方法就是类的功能，也就是定义在类里面的函数，它实现了某个功能，比如说人有睡觉的功能。
构造函数：什么是构造函数，就是类在实例化的时候做的某些初始化操作，比如说人，你造一个汽车的时候，它得有颜色、型号等等。

def __init__():

pass

析构函数：析构函数就是这个实例在销毁的时候做的一些操作。

def __del__():

pass

定义类：定义类使用class关键字，类名一般我们开发的时候首字母要大写。python中有经典类和新式类，他俩在python3中没有区别，在python2中经典类在多继承的时候是深度优先，新式类是广度优先。python3中统一是广度优先，这个后面在说继承的时候会说。

属性方法

看起来像属性的一个方法。

7. 类变量

类变量，公共的变量,每个实例都可以用

8. 实例变量（成员变量）

9. 实例方法

实例化之后才可以用的。

10. 类方法

1、不用实例化就可以直接调用。

2、它可以通过cls使用类变量

3、它不能调用这个类里面的其他实例方法和实例变量

11.静态方法

#你不想实例化的时候，就可以定义成类方法

#静态方法就是一个普通函数，只不过是写在类里面而已，它用不了类变量、类方法、实例变量、实例方法

12.私有

私有方法

私有变量

出了类之后，就不能用了。

代码示例：

class Person:  #经典类
    def __init__(self,name):#构造函数
        self.name = name
        self.nose = 2 #鼻子  #属性
        self.face = 2 #脸
        self.head = 10 #脑子
        self.wing = 4#翅膀
        print('开始造人。。。')
    def driver(self):
        print('老司机，开车非常稳')
        self.eat() #调用类里面的函数
    def fly(self):
        print('%s 在飞。。'%self.name)
        #获取类里面的变量
    def eat(self):
        print('%s 吃火锅，吃小龙虾，喝啤酒'%self.name)

#类在用到时候，首先必须实例化,即模型要造出对象才能用
zll=Person('张流量')#传入参数
zll = Person('张流量')#传入参数
zll.driver()

# zlj = Person()  #实例化，类名加上括号就是实例化
# zlj.eat()
# zlj.fly()
# zlj.fly()
# zlj.eat()
# print(zlj.wing)
# print(zlj.nose)

class Person2(object):#新式类
    pass

#类名首字母都大写
#在python3里面经典类和新式类没有任何区别

4、“签名规则”功能分别使用面向对象和面向过程来实现

1）、签名规则的需求：

A、输入数据：

1、请求数据：

vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0

2：商家编码:

1697

B、计算规则：

1、将商家编码（vendorId）1697进行两次MD5加密得到一个字符串 Astr：09B764965CE4E92BED8BD3140E22D5CF

2、将请求数据

vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0

进行urlDecode处理（编码格式为utf-8）得到一个字符串urlDecodeStr：

vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0

3、urlDecodeStr + Astr 拼接得到一个待加密的字符串 beforeMD5

vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E009B764965CE4E92BED8BD3140E22D5CF

然后将 beforeMD5字符串进行加密得到最终的签名：

6F811B63B11D92BA4A359E6DC98EEE31

2）需求分析

python基础教程 %DFSDF url编码

%DFSDF 学习 url解码

1、请求数据获取到

2、提取到商家编码

3、将商家编码进程2次md5 得到astr

4、再将请求数据进行一次urldecode，urlstr

5、astr+url_str MD5

3）使用面向过程方式来实现编码规则的功能，代码示例：

from urllib import  parse
# url='http://www.baidu.com?query=python基础教程'
# url_str=parse.quote_plus(url)#URL解码
# #print(parse.quote_plus(url))
# baidu_url='https://www.baidu.com/s?ie=utf-8&f=3&rsv_bp=1&rsv_idx=1&tn=baidu&wd=python%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B&oq=python&rsv_pq=b6c92ffc00023232&rsv_t=be4d%2FdgIVLHbmdj5jU9bfpJTXGIAcO4y2u%2BfKsxWWJW2wIKbEuXL6tNXiug&rqlang=cn&rsv_enter=1&inputT=878&rsv_sug3=9&rsv_sug1=3&rsv_sug7=100&rsv_sug2=0&prefixsug=python&rsp=1&rsv_sug4=2134&rsv_sug=1'
#print(parse.unquote_plus(baidu_url))#url编码
s='vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0'
import  hashlib
def my_md5(s):
    md = hashlib.md5()
    md.update(s.encode())
    return md.hexdigest()
def get_vendorid(req_data):
    data_dict={}
    sub_list=req_data.split('&')
    for i in sub_list:
        k,v=i.split('=')
        data_dict[k]=v
    return data_dict.get('vendorId')
def sign(req_data):
     verid=get_vendorid(req_data)
     print(verid)
     first=my_md5(verid)
     astr=my_md5(first)
     url_srt=parse.unquote_plus(req_data)
     res=my_md5(astr+url_srt)
     return res
#s='vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0'
#print(sign(s))
#sign(s)

4）使用面向对象方式来实现编码规则的功能，代码示例：

class Sign(object):
    def __init__(self,req_data):
        self.req_data = req_data  #这写了self的话，在其他的函数里面也可以用self.xx
        self.get_verid()
        self.get_sign()
    def md5(self,s):#self叫做本类对象
        md = hashlib.md5()
        md.update(s.encode())
        return md.hexdigest()

    def get_verid(self):
        data_dict = {}
        sub_list = self.req_data.split('&')
        for i in sub_list:
            k, v = i.split('=')
            data_dict[k] = v
        self.verid = data_dict.get('vendorId')
    def get_sign(self):
        frist = self.md5(self.verid)
        astr = self.md5(frist)
        url_str = parse.quote_plus(self.req_data)
        self.sign = self.md5(astr+url_str)
        return self.sign
print('__nam__',__name__)

if __name__ == '__main__':    s='vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20-29;7C-67-A2-9A-06-05;7C-67-A2-9A-06-06;7C-67-A2-9A-06-09;00-00-00-00-00-0000E0'
    abc = Sign(s)
    print(abc.sign)
    print('我是sign...)

知识点:

if __name__ == '__main__':

判断这个python是在别的地方导入的，还是直接运行的这个python文件

这句话一般是做调试的时候用的。

1、如果是直接运行这个python文件的时候，这句话一点用都没有

2、如果是其他python文件中导入这个模块,则不会执行这个语句下面的内容

5、用面向对象方式来实现mysql数据库操作，代码示例：

import pymysql
class Mydb(object):
    def __del__(self):
        #析构函数，析构函数就是这个实例在销毁的时候做的一些操作，关闭游标，关闭数据库连接
       self.cur.close()
       self.coon.close()
       print('over....')

    def __init__(self,
                 host,user,passwd,db,port=3306,charset='utf8'):
        try:
            self.coon=pymysql.connect(
                host=host,user=user,passwd=passwd,port=port,charset=charset,db=db,
                autocommit=True,#自动提交
        )
        except Exception as e:
           print('数据库连接失败%s'%e)
        else:
            self.cur=self.coon.cursor(cursor=pymysql.cursors.DictCursor)
    def ex_sql(self,sql):
        try:
            self.cur.execute(sql)
        except Exception as e:
            print('sql语句有问题,%s'%sql)
        else:
            self.res=self.cur.fetchall()
            return self.res
my=Mydb('118.24.3.40','jxz','123456','jxz')
stu=my.ex_sql('select * from stu;')
print('我是最后一行代码了')
print(stu)

6、厘清面向对象的一些概念，代码示例

class Baby():
    country='China'#类变量,相当于公共的变量,不用实例化就可以用,可以节省内存
    # def __init__(self):
    #     self.country='China'
    # def __init__(self,name):
    #     print('self的内存地址',id(self))
    #     self.name=name
    #     #self代表的就是实例化之后的对象
    #     self.money=5000
    #     self.sex='女'
    def my(self):
        self.name='牛汉阳'

    def cry(self):#实例方法,都得实例化后才能调用
        #self.sex
        print('哇哇哇')
    @property#装饰器
    def hhh(self):
        return 198
    def xm(self):
        print('我是类方法')
  #  @classmethod
    def xm1(cls):#cls代表的就是Baby
        print(cls.country)
        print('我是类方法')
        # print(cls.name)
        # cls.cry

    @staticmethod
    def xh():
        print('这是个静态方法,他和一个没写在类里面的函数是一样的')

# Baby.country='USA' #类变量是可以直接通过类名.xxx来进行修改的。

# 类方法
# 1、不用实例化就可以直接调用。
# 2、它可以通过cls使用类变量
# 3、它不能调用这个类里面的其他实例方法和实例变量
#不想实例化的时候,就可以定义为类方法
#静态方法 @staticmethod
#你不想实例化的时候，就可以定义成类方法
#静态方法就是一个普通函数，只不过是写在类里面而已，它用不了类变量、类方法、实例变量、实例方法

自动发邮件、面向对象

猜你喜欢