python学习笔记（十九）面向对象编程，类

一、面向对象编程

面向对象，是一种程序设计思想。

编程范式：编程范式就是你按照什么方式去编程，去实现一个功能。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，两种最重要的编程范式分别是面向过程编程和面向对象编程。

面向过程：什么是面向过程，面向过程的思想就是把一个项目，一件事情按照一定的顺序，从头到尾一步一步的做下去，先做什么，后做什么，一直到结束。这种编程思想，只要前面一个步骤变了，那么后面的就也要变，后面维护一起比较麻烦，这样的编程思想，我们在写一些简单的小程序，只执行一次的脚本时可以使用。

面向对象：面向对象的思想就是把一个项目，一件事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。这种思想比较适合多人的分工合作，就像一个大的机关，分各个部门，每个部门分别负责某样职能，各个部门可以充分发挥自己的特色，只有符合一个前提就行。

二，面向对象的特性：

类：class

类，对比现实世界来说就是一个种类，一个模型

一个类即是对一类拥有相同属性的对象的抽象，蓝图，原型

在类中定义了这些对象的都具备的属性，共同的方法。

对象：object

对象，也就是指模型造出来的具体的东西

一个对象既是一个类的实例化后实例，一个类必须经过实例化方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之间有性，亦有不同

实例化：

初始化一个类，造了一个对象。把一个类变成一个具体的对象的过程，叫做实例化

封装：

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

继承：

一个类可以派生出子类，在这个父类里定义的属性，方法自动被子类继承。

继承是为了代码的重用

多态：

对不同类的对象发出相同的消息将会有不同的行为。

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

一种接口，多种实现

三，面向对象的好处

对于编程语言的初学者来讲，OOP不是一个很容易理解的编程方式，大家虽然都按老师讲的都知道OOP的三大特性是继承、封装、多态，并且大家也都知道了如何定义类、方法等面向对象的常用语法，但是一到真正写程序的时候，还是很多人喜欢用函数式编程来写代码，特别是初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发现在使用了面向对象后，对我们的程序开发效率或其它方面带来什么好处，因为我使用函数编程就可以减少重复代码并做到程序可扩展了，为啥子还用面向对象？”对于此，我个人觉得原因应该还是因为你没有充分了解到面向对象能带来的好处。

无论用什么形式来编程，我们都要明确记住以下原则：

写重复代码是非常不好的低级行为

你写的代码需要经常变更

开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

如果你把一段同样的代码复制、粘贴到了程序的多个地方以实现在程序的各个地方调用，这个功能，那日后你再对这个功能进行修改时，就需要把程序里多个地方都改一遍，这种写程序的方式是有问题的，因为如果你不小心漏掉了一个地方没改，那可能会导致整个程序的运行都 出问题。 因此我们知道 在开发中一定要努力避免写重复的代码，否则就相当于给自己再挖坑。

还好，函数的出现就能帮我们轻松的解决重复代码的问题，对于需要重复调用的功能，只需要把它写成一个函数，然后在程序的各个地方直接调用这个函数名就好了，并且当需要修改这个功能时，只需改函数代码，然后整个程序就都更新了。

其实OOP编程的主要作用也是使你的代码修改和扩展变的更容易，那么小白要问了，既然函数都能实现这个需求了，还要OOP干毛线用呢？ 呵呵，说这话就像，古时候，人们打仗杀人都用刀，后来出来了枪，它的主要功能跟刀一样，也是杀人，然后小白就问，既然刀能杀人了，那还要枪干毛线，哈哈，显而易见，因为枪能更好更快更容易的杀人。函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改。

四、类
属性：属性就是里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。这个可以理解为，人是一个类，他的名字，年龄，性别就是它的属性

方法：方法就是类的功能，也就是定义在类里面的函数，它实现了某个功能，比如说人有睡觉的功能。

构造函数：就是类在实例化的时候做的某些初始化操作

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

定义类：

定义类使用class关键字，类名一般首字母大写。

 class Car():#模型，模板
     def __del__(self):
         #析构函数，这个实例被销毁的执行的。
         print('over..')

     def my_self(self):
         print(
             '我是一个汽车 我的颜色是【%s】,我有【%s】个窗户'%(self.color,self.window)
         )
         self.price = 10002
     def run(self):
         print(self.color)
         print(self.window)
         print(self.price)
         print('汽车在跑。。。')

     def __init__(self,color,window):
         #
         #构造函数，是类在初始化的时候会执行它
         #如果你的类在实例化的时候要传入一些参数，那么你就要在__init__这个函数里写参数了
         self.color = color  #绑定属性
         self.window = window
         print('执行我了。。')

 #把模型做成实际的一个汽车，这个过程叫做实例化。
 bus = Car('黄色','3开门') #实例化
 bus2 = Car('黑色','4开门') #实例化
 bus3 = Car('粉色','2开门') #实例化
 bus.my_self()   #
 bus2.my_self()
 bus3.my_self()

 #实例就是指具体造出来的东西，通过类实例化处理的东西，就是实例
 #对象，就是实例
 #

继承：

 class WssFather(object):
     @property
     def money(self):
         return 10000000
     def smoke(self):
         self.yan = '玉溪'
         print('抽烟')
     def drink(self):
         print('喝酒')
     def tangtou(self):
         print('烫头')

 class Wss(WssFather):
     def driver(self):
         print('开车')

 class Animal(object):
     def eat(self,name):
         print('吃')

 class Brid(Animal):
     pass

实例变量：

 class Person(object):
     country = 'China' #类变量
     def __init__(self,name,age,sex):
         self.name=name #实例变量，必须实例化之后才能用,成员变量
         self.age=age
         self.sex=sex

     def say_my_country(self):
         print(self.country)

 print(Person.country)
 # dsx = Person(小师妹,23,'男')
 # print(dsx.name)
 # print(dsx.age)
 # print(dsx.sex)
 # print(dsx.country)
 # ybq = Person('绿萝',28,'男')

静态方法，类方法：

私有方法、私有属性：

什么是私有，私有就是只有在类里面可以访问，实例化之后不可以访问和调用，有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线，其实就是通过私有来实现封装的

　　import redis
 class MyRedis():
     xiaohei = '哈哈哈'
     def __init__(self,host,password='',port=6379):
         self.__host = host #私有属性
         self.passwd = password
         self.port = port
         self.__coon_redis()
     def __coon_redis(self): #私有方法
         self.coon = redis.Redis(host=self.__host,password=self.passwd,port=self.port)
     def get(self,k):
         print('__host...',self.__host)
         return self.coon.get(k).decode()

     @staticmethod #静态方法
     def other():
         print('我是other')
     @classmethod#类方法，也不需要实例化，直接就能用。它静态方法高级一点
     #它可以使用类变量和类方法。
     def class_fun(cls):
         print(cls.xiaohei)
         cls.class_fun2()
     @classmethod
     def class_fun2(cls):
         print('我是类方法2')
 # r = MyRedis('211.149.218.16','123456')
 MyRedis.class_fun()

小练习：
#签名，作用为了作弊

#sign ：82B20DE4-40C2-4859-9DBC-C93B0FBFD09C

#1.先取用户的设备号码，md5 加密一次

#2.再取加密之后前10位

#3.再加盐，再给md5一次

#4.最后生成一个字符串

 from hashlib import md5
 class GetSign(object):
     slat='SDF234_&#$_12'
     def __init__(self,device_id):
         self.device_id=device_id
     def md5(self,str):
         #md5加密的
         s=str.encode()
         m=md5(s)
         return m.hexdigest()
     @property #把这个函数变成一个属性方法 ,如果这个方法没有入参，那就可以给变成一个属性方法
     def get_res(self):
         first_md5 = self.md5(self.device_id)
     tmp = first_md5[:10] #取前10位
     after_salt = tmp+self.slat
     self.sign = self.md5(after_salt)
     return self.sign
 res = GetSign('82B20DE4-40C2-4859-9DBC-C93B0FBFD09C')
 print(res.device_id)
 print(res.get_res)

写日志：

 import logging
 from logging import handlers

 class Logger(object):
     level_relations = {
         'debug': logging.DEBUG,
         'info': logging.INFO,
         'warning': logging.WARN,
         'error': logging.ERROR,
         'crit': logging.CRITICAL
     }  # 日志级别关系映射

     def __init__(self, fp, level='debug', when='midnight', interval=1, backCount=5, encoding='utf-8'):
         '''

         :param fp:日志文件路径
         :param level: 日志级别 默认是debug
         :param when: 分割日志的单位 S 秒、M 分、 H 小时、 D 天、 W 每星期（interval==0时代表星期一）、midnight 每天凌晨
         :param interval: 时间间隔 默认每天凌晨
         :param backCount: 备份文件个数 默认5个
         :param encoding: 日志文件编码
         '''
         self.level = self.level_relations.get(level)
         self.logger = logging.getLogger(fp)
         self.logger.setLevel(self.level)
         fmt = logging.Formatter('%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s')
         sh = logging.StreamHandler()
         sh.setFormatter(fmt)
         sh.setLevel(self.level)
         th = handlers.TimedRotatingFileHandler(fp, when=when, interval=interval, backupCount=backCount,
                                                encoding=encoding)
         th.setFormatter(fmt)
         th.setLevel(self.level)
         self.logger.addHandler(th)
         self.logger.addHandler(sh)

     def debug(self, msg):
         self.logger.debug(msg)

     def info(self, msg):
         self.logger.info(msg)

     def warning(self, msg):
         self.logger.warning(msg)

     def error(self, msg):
         self.logger.error(msg)

     def crit(self, msg):
         self.logger.critical(msg)

 if __name__ == '__main__':
     l = Logger('a.log')  # 实例化
     l.info('hehehe')  # 调用
     l.debug('哈哈哈')
     l.error('xxx')

 class My():
     def __init__(self,name):
         self.name = name
         self.cry()
     def cry(self): #实例方法，必须得实例化后才可以调用
         print('%s在哭。。。'%self.name)
     def learn(self):
         self.skill = ['开车']
     def my_self(self):
         print('我的名字【%s】 我会%s'%(self.name,self.skill))

 wsl = My('小黑黑') #    self = wsl
 wsl.skill = '黑'
 wsl.learn()
 wsl.skill.append('花')
 wsl.skill.append('话')
 wsl.skill.append('滑')
 wsl.my_self()
 wsl.learn()
 wsl.my_self()

 td = My('蘑菇')

连接数据库：

 import pymysql
 class OpMySql1:  #经典类
     pass

 class OpMySql(object):#新式类
     def __init__(self,host,user,password,db,port=3306,charset='utf8'):
         schema = {
             'user':user,
             'host':host,
             'password':password,
             'db':db,
             'port':port,
             'charset':charset
         }
         try:
             self.coon = pymysql.connect(**schema)
         except Exception as e:
             print('数据库连接异常！%s'%e)
             quit('数据库连接异常！%s'%e)
         else:#没有出异常的情况下，建立游标
             self.cur = self.coon.cursor(cursor=pymysql.cursors.DictCursor)

     def execute(self,sql):
         try:
             self.cur.execute(sql)
         except Exception as e:
             print('sql有错误%s'%e)
             return e
         if sql[:6].upper()=='SELECT':
             return self.cur.fetchall()
         else:#其他sql语句的话
             self.coon.commit()
             return 'ok'

     def __del__(self):
         self.cur.close()
         self.coon.close()

 ybq = OpMySql('211.149.218.16','jxz','',db='jxz')  #实例化

 print(ybq.execute('select * from stu;'))
 print(ybq.execute('select * from stu;'))
 print(ybq.execute('select * from stu;'))

url编码：

 import urllib.parse
 s='besttest 自动化测试'
 print(urllib.parse.quote(s)) #url编码
 print(urllib.parse.quote_plus(s)) #url编码,
 src='https://www.baidu.com/s?wd=besttest%20%E8%87%AA%E5%8A%A8%E5%8C%96%E6%B5%8B%E8%AF%95&rsv_spt=1&rsv_iqid=0x90f615640005e9b2&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&rqlang=cn&tn=baiduhome_pg&rsv_enter=1&inputT=8129&rsv_t=0d22VbBsLUg6wkL0kNn1rPhfwhU%2F5UCRNiEBd5oqMzEh6ImgExR7fH65dNLwCf0ilzUT&rsv_sug3=36&rsv_sug1=9&rsv_sug7=100&oq=besttest&rsv_pq=f857c55a00063cfd&rsv_sug2=0&rsv_sug4=8623'

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

self代表本类对象

修改父类的方法：

重写父类的方法的目的是为了给他扩展一些功能

核心思想就一句话，先调用一下你要重写的父类方法，然后再加新的代码就好了。

 class Coon(object):
     def conn(self,host,passwd):
         print(host,passwd)
 class Coon2(Coon):
     def conn(self):
         #重写父类的方法
         print('hahahha')
 c=Coon2()
 c.conn() #hahahha

 class Coon(object):
     #基类
     def __init__(self,host,passwd,port):
         self.host=host
         self.passwd=passwd
         self.port=port
 class CoonMySql(Coon):
     def __init__(self,host,passwd,port,username,db,charset='utf8'):
         Coon.__init__(self,host,passwd,port)#在调用父类的构造方法，咱们自己手动调用父类的方法
         self.username=username
         self.db=db
         self.charset=charset
     def coon_mysql(self):
         print(self.host)

 class Coon(object):
     #基类
     def __init__(self,host,passwd,port):
         self.host=host
         self.passwd=passwd
         self.port=port
 class CoonMySql(Coon):
     def __init__(self,host,passwd,port,username,db,charset='utf8'):
        super(CoonMySql,self).__init__(host,passwd,port)#super自动帮忙找到父类，然后调用
         self.username=username
         self.db=db
         self.charset=charset
     def coon_mysql(self):
         print(self.host)