自动发邮件、面向对象

            import
             yagmail

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

            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里面经典类和新式类没有任何区别

            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)

            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...)

            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)

            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.sexprint(‘哇哇哇‘)
    @property#装饰器def hhh(self):
        return 198
    def xm(self):
        print(‘我是类方法‘)
  #  @classmethoddef xm1(cls):#cls代表的就是Babyprint(cls.country)
        print(‘我是类方法‘)
        # print(cls.name)# cls.cry
    @staticmethod
    def xh():
        print(‘这是个静态方法,他和一个没写在类里面的函数是一样的‘)

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