面向对象编程（1） 概念及面向对象及面向过程的区别实例

1.面向过程和面向对象的区别

例子：

 面向对象编程  class

    面向过程编程      执行者

        1、4S店 掏钱买车

        2、保险公司 上保险

        3、税务局 交购置税

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

    面向对象       指挥者

        买车办事处   #直接合为一个整体

            1、4S店 掏钱买车

            2、保险公司 上保险

            3、税务局 交购置税

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

2.面向对象的一些相关概念

类

        一个种类，一个模型。比如汽车模型

对象

        指具体的东西，模型造出来的东西叫做对象。

实例

        实例和对象是一样的。

实例化

        实例化就是造东西的这个过程。

属性

        就是类里面变量

方法

        就是类里面的函数

    继承

    封装

    多态

    。。。。。

self代表的是本类对象。

    因为函数里面的变量都是局部变量，出了函数就不能用了。

    用self给对象绑定了之后，就可以self.xx随便用了

    构造函数

        def __init__():

            pass

     构造函数就是类在实例化的时候执行的函数。

     类在实例化的时候，会自动执行它

    析构函数

        def __del__():

            pass

      实例被销毁的时候执行的。

    属性方法

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

    类变量

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

    实例变量（成员变量）

    实例方法

        实例化之后才可以用的。

    类方法

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

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

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

    静态方法

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

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

    私有

        私有方法

        私有变量

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

    if  __name__ == '__main__':

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

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

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

        2、

3.类

例子

class Person:  #经典类，类名首字母都大写

#class Person2(object):#新式类  在python3里面经典类和新式类没有任何区别

    def __init__(self,name):#构造函数（不是必须的）  构造函数就是类在实例化的时候执行的函数 类在实例化的时候，会自动执行它（比如连接mysql就可以使用，不必多次连接）
        self.name = name   #self后就可以在类中直接用  就可以调用属性或方法
        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(name='张流量')#造人并赋予名字
zll.driver()  #
zlj = Person()  #实例化，类名加上括号就是实例化，实例化后保存到zlj
# zlj.eat()
# zlj.fly()
# zlj.fly()
# zlj.eat()
# print(zlj.wing)
# print(zlj.nose)


类的使用练习（签名规则）
前提

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


python基础教程 %DFSDF  url编码
%DFSDF   学习  url解码
需求分析：
1、请求数据获取到
2、提取到商家编码
3、将商家编码进程2次md5 得到astr
4、再将请求数据进行一次urldecode，urlstr  #urldecode 在访问页面会把汉字及特殊字符会变为url编码发送请求  所以需要url编码和解码  
如python基础教程 %DFSDF  url编码    %DFSDF   学习  url解码

5、astr+url_str  MD5

加密规则

from urllib import parse    #用到的模块

url='http://www.baidu.com?query=python基础教程 sdfsdf &^ '

url_str = parse.quote_plus(url)  #url编码（quote和quote_plus  一样但后者更好） parse.quote_plus

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解码

面向过程方式

from urllib import parse 

import hashlib

def get_vendorid(req_data):

    data_dict = {}

    sub_list = req_data.split('&')  #对于获取的信息先通过&进行分割成list

    #【vendorId=1697，poscode=xxx】

    for i in sub_list:     #  将list转化为kv的字典

        # verid=1697

        k,v = i.split('=')    #直接将k，v这两值存放。

        #[verid,1697]

        # data_dict.setdefault(k,v)

        data_dict[k]=v  #字典存值得两种方式

    return data_dict.get('vendorId')

def sign(req_data):

    verid = get_vendorid(req_data) #调用获取veriodid函数

    first = my_md5(verid)

    astr = my_md5(first)#两次md5

    url_str = parse.quote_plus(req_data)#url编码

    res = my_md5(astr+url_str)

    return res

def my_md5(s):   ####  该函数应该放到前面  否则sign调用事出错，有顺序先后的问题，面向对象则没有先后的限制

    md = hashlib.md5()  #实例化

    md.update(s.encode())#  加密时必须转为bytes类型

    return md.hexdigest()  #返回加密后结果

# print(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):

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