day9 类
笔记：
面向对象
1.类
2.怎么发邮件
编码规范：
命名规范
strToDict 如果有多个单词，每个单词首字母大写
如果是类命令的话，首字母要大写
str_to_dict 多个单词用下划线也行
面向对象
面向过程
面向对象是包含面向过程
1.类 一个模型
2.实例 通过这个模型造出来的东西
3.对象 实例
4.实例化 就是造实例的过程
类
封装，继承，多态 称为面向对象的特性
封装 就是把零散的代码封装成一个类
继承 就是父类有的东西你也有
多态 一种方法多种实现
属性：就是类里面的变量
方法：就是类里面有什么功能，其实就是类里面的属性或者成为函数
构造函数
初始化这个对象
他会在这个类实例化的时候自动执行
析构函数
他是在这个实例被销毁的时候执行的
类里面函数有多次调用，而且还要获取到他的返回值，那就用return
如果这个变量就用一次，那么就用self。多次就用return
类变量
存在类里面的，一般用一些公共的东西，不会变的是类变量
实例变量
实例化的时候才创建的变量
实例方法
必须实例化之后才能调用的方法
类里面的的函数，如果有一个self，那么就是实例方法
属性方法，把实例化方法变成一个变量
@property#相当于直接调用，把方法当成变量
def myfunc(self):
return '现在是17：30'
属性方法也是实例方法，需要实例化才能实现
属性方法同样可以通过实例化实现
如果你使用属性方法必须有返回值，而且不能入参
私有
私有属性，变量
私有方法，函数
只要方法或者变量，在前面加上__，（两个下划线），他就是一个私有方法/私有变量
私有方法或者变量在类里随便使用，出了就不好使
类方法
可以通过类名进行调用
静态方法
就是写在类里面的普通函数而已
面向对象
class Student:#经典类
pass
class BuyCar(object):#新式类
addr = '昌平区xxx'#类变量
def fourS(self):
print('这里是4s店，要买车')
def dsj(self):
print('这里交购置税')
def cgs(self):
print('车管所')
def jgj(self):
print('交管局')
jxmc = BuyCar()#类名加括号就是实例化。
# jxmc就是一个实例，对象
class Person(object):
def __init__(self,name,sex):
print('名字是%s'%name)
print('性别是%s'%sex)
def cry(self):
print('哭')
# xiaohei = Person('小黑','男')
# xiaohei.cry()
class YueBing(object):
def __del__(self):#析构函数
print('月饼被吃了')
def wuren(self):
print('五仁月饼')
def __init__(self):
print('造好月饼了')
# gxyb = YueBing()#造月饼
# gxyb.wuren()
# del gxyb
# print('这里才是最后一行')
class Car(object):
def __init__(self,color,pl):
self.color = color
self.pl = pl
self.run()
def run(self):
print('汽车的颜色是%s:排量是%s'%(self.color,self.pl))
print('汽车跑了')
self.jiayou()
def jiayou(self):
print('加油')
my_car = Car('read','3.5T')
#self代表的就是本类对象
#self代表的是实例化之后的对象，通过self可以随便调用下面的类和函数，self只能在类里面调用
class Cat(object):
def __init__(self,name):
self.name = name
def cry(self):
print(''%self.name)
xiaohei = Cat('jarry')
编码规则
def md5_passwd(str):
import hashlib
md = hashlib.md5()#构造一个MD5
md.update(str.encode())
res = md.hexdigest()
return res
vedin='1709'
from urllib import parse
def sign(data,vendorld):
first_md5 = md5_passwd(vendorld)
second_md5 = md5_passwd(data)
urlDecodeStr = parse.unquote(data)
beforeMD5 = urlDecodeStr+second_md5
res = md5_passwd(beforeMD5)
print('加密完',res)
return res
sign = 'vendorId=1697&posCode=pos006&ip=127.0.0.1&posVersion=2.1.1.1.1&mac=;D4-81-D7-CA-20'
继承
class JxFather(object):
addr = '密云'
def __init__(self,num):
self.hose_num = num
def makeMoney(self):
print('jfksdljfklsdjgfdjflgjdflg,秘密')
class jx(JxFather):
def __init__(self):
self.name = 'wjx'
def dabaojian(self):
print('拔出大保健')
class JxSon(jx,JxFather):#多继承
pass
wds = JxSon('80')
print(wds.makeMoney())
print(wds.dabaojian())
类改写签名规则
from hashlib import md5
from urllib.parse import unquote
class DglSign(object):
def __init__(self,venderId,data):
self.dgl = venderId
self.wyf = data
self.get_vendorId()
self.data_encode()
def my_md5(self,str):
md = md5()
md.update(str.encode())
return md.hexdigest()
def get_vendorId(self):
first = self.my_md5(self.dgl)
self.Astr = self.my_md5(first)
def data_encode(self):
self.urlDecodeStr = unquote(self.wyf)
def get_sign(self):
src = self.Astr+self.urlDecodeStr
sign = self.my_md5(src)
return sign
mysign = DglSign('1697',"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")
res = mysign.get_sign()
print(res)
类变量和实例变量
class Student(object):
country = 'china'#叫类变量，也是公共的
def __init__(self):
self.name = 'xx'
self.addr = '望京'
self.sex = '男'
print('%s的国籍是%s'%(self.name,self.country))
# lanxia = Student('jmy')
# print(lanxia.sex)
# lanxia.sex = '未知'
# print(lanxia.sex)
sur = Student()
print(sur.name())
私有变量
class My(object):
def __init__(self):
self.__cup = '乐知'#变量里面加上两个下划线就是私有变量
print('cup is %s'%self.__cup)
def bad(self):
print('[%s]坏掉了'%self.__cup)
self.__cup = '矿泉水瓶'
print('[%s]坏掉了'% self.__cup)
def get_salt(self):
self.__my_money()
# print(self._salt)
def __my_money(self):
print('我今天带了80块钱')
my = My()
my.__cup = 'hahaha'
print(my.__cup)
print(my.bad())
属性方法
class Cale(object):
def __init__(self,a,b):
self.a = a
self.b = b
def add(self):
return self.a + self.b
@property#必须有return值
def add2(self):
return self.a + self.b
c = Cale(1,2)
r = c.add()
print(r)
print(c.add2)
各种方法
class My(object):
country = 'china' # 叫类变量，也是公共的
def __init__(self):
self.__cup = '乐知'#变量里面加上两个下划线就是私有变量
print('cup is %s'%self.__cup)
def bad(self):
print('[%s]坏掉了'%self.__cup)
self.__cup = '矿泉水瓶'
print('[%s]坏掉了'% self.__cup)
def get_salt(self):
self.__my_money()
print(self.__salt)
def __my_money(self):
print('我今天带了80块钱')
@classmethod
def ddl(cls):#类方法，通过类名可以调用
print(cls.country)
@staticmethod#静态方法
def myFunc():
return '现在是17：30'
@property#相当于直接调用，把方法当成变量
def myfunc(self):
return '现在是17：30'
ax = My()
print(ax.myfunc)
练习
import pymysql
class MyConnect:
def __init__(self,host,port,user,passwd,db,charset='utf8'):
self.__host = host
self.port = port
self.user = user
self.passwd = passwd
self.db = db
self.charset = charset
self.get_cur()#在类初始化的时候去调用创建游标的函数
def get_cur(self):
try:
self.coon = pymysql.connect(host=self.__host, port=self.port, user=self.user, passwd=self.passwd,
charset=self.charset, db=self.db)
except Exception as e:
print(e)
return '数据库连接失败'%e
else:
self.cur = self.coon.cursor()#建立由表
def select_sql(self,sql):#select语句不需要commit
self.cur.execute(sql)
return self.cur.fetchall()
def other_sql(self,sql):
try:
self.cur.execute(sql)
except Exception as e:
print('sql执行失败%s'%e)
return e
else:
self.coon.commit()
def __del__(self):
self.cur.close()
self.coon.close()
my = MyConnect(host='211.149.218.16',port=3306,user='jxz',passwd='123456',db='jxz')
res = my.select_sql('select * from jxz_stu limit10;')
my.other_sql("insert into jxz_stu values ('wjx','123交','223交','223交');")
res2 = my.select_sql('select * from jxz_stu where name="高光远"')
print(res)
print(res2)
