Python学习笔记（27）面向对象-类

一、类

　　类的概念：类是指面向对象的编程，面向对象包含面对过程，类的思想就是化零为整的操作，把某些操作封装在一个类中后，可以通过类名.属性，类名.方法来调用

　　举例：买车　　

买车：
1、4s看车，买车 a
2、上保险，保险公司 b
3、交税 地税局 c
4、交管所 上牌 d

面向过程：以前买车需要到 a,b,c,d四个地方操作完后才能完成买车所有的东西 

卖车处：
1、4s
2、保险
3、交税
4、上牌

面向对象：现在将所有的买车操作手续封装到卖车处，只需要在4S店就可以完成所有的操作即可

类：类是一个模型，包含了属性和方法，如下以Person类为例

　　

import time
class Person(object): #新式类
# class Person:#经典类
    country = 'China' #类变量，通过实例或者类名都可以调用
    def __init__(self,name,sex,color):#构造方法，也就是初始化方法，在创建时调用
        self.name = name #实例变量，在类中和实例中都可以调用
        self.sex = sex
        self.color = color
        '''__开头变量就是私有变量，只有在类中才能使用，出类的范围后失效，且私有变量无法被继承'''
        self.__money = 10000
        print('self的内存地址',id(self))

    '''__开头方法名就是私有方法，只能在类中使用，出了类后失效，且私有方法无法被继承'''
    def __secret(self):
        print('每个人都有自己的秘密')

    @classmethod
    def xuexi(cls):
        '''类方法，可通过类名和实例来调用，类方法中不能调用实例变量或者实例方法,但是可调用其他类方法'''
        print("爱学习")
        return True

    @classmethod
    def makemoney(cls):
        print('要挣钱要爱学习',cls.xuexi())

    def __del__(self):
        '''析构函数，在实例销毁时自动执行'''
        print('这是析构函数，实例销毁时自动执行')

    @staticmethod
    def help():
        '''静态方法一般只用来介绍类的说明，与类和方法没有多大关联性，可通过实例.方法名，类名.方法名调用'''
        print('这是人类的使用说明')

    def cry(self):#带self的都是实例方法
        print('%s cry....'%self.name)

    def fly(self):
        print('%s fly....'%self.name)
        '''调用私有变量__money'''
        print('需要%s元才能飞'%self.__money)
        '''调用私有方法__secret'''
        self.__secret()
    def eat(self):
        print('color',self.color)
        print('eat..')

    '''属性方法：使用装饰器property的方法，一般用来计算或处理数据，可当做变量来调用,通过实例.方法名调用即可'''
    @property
    def work_age(self):
        self.help()
        create_time = 1528860238
        result = (time.time()  - create_time) / (365*24*60*60)
        return round(result,1)

ccx = Person('Tang','女','黑色')#实例化后调用init初始化方法
print('实例的内存地址',id(ccx))
ccx.eat()  #eat(ccx)
print(ccx.work_age)#调用属性方法
#类变量
print(ccx.country)
print(Person.country)
#类方法
ccx.xuexi()
Person.xuexi()
Person.makemoney()
#静态方法
ccx.help()
Person.help()

ccx.fly()

　

类
        一个模型、一个例子
    实例/对象
        实例，通过模型造出来具体东西
    实例化
        把模型变成实例的过程
    继承
　　　　
    封装
    构造函数
        类在实例化的时候，自动执行的函数
        __init__
    self
        本类对象
        self就是你实例化的那个变量
        self.xxx = xxx
        在别的函数里面就直接可以用了

    析构函数
      实例被销毁的时候自动执行的函数
       __del__
    类方法
　　　　可通过实例或者类名来调用，使用@classmethod修饰，不能调用实例变量，不能调用实例方法，但是能调用类方法
    类变量
　　　　可通过实例或者类名来调用
    属性方法
　　　　使用@property修饰，如def price(self),不可再传参数，可使用实例.函数名来调用 如 xh.price
   
　　　　当某个功能有N个函数来实现，函数名比较多，使用if...else比较繁琐，可使用hasattr(类名，方法名)判断该类中是否含有这种方法名，getattr(类名，方法名)来获取对应的方法名，如，getattr(MyRequests,method)()来执行如get() post()等方法
    私有 -》不是公共的,只能在类里面的函数调用，在类外面不可以调用
        函数/变量以__开头，就是私有的，私有变量和私有方法不能被继承，只能在类中调用，出类后失效
    实例方法
　　　　方法中带有self入参的方法，就是实例方法，需要实例化后才能使用
    实例变量
　　　　通过self.xxx调用    一般在init构造函数中定义实例变量

　　关于数据库操作的一个例子：

class MysqlDB:
    def __init__(self,mysql_info):
        self.mysql_info = mysql_info
        self.__connect()

    def __del__(self):
        self.__close()

    def __connect(self):
        self.conn = pymysql.connect(**self.mysql_info)
        self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)

    def execute(self,sql):
        self.cursor.execute(sql)

    def fetchone(self): #select * from user where username = 'xx';
        return self.cursor.fetchone()

    def fetchall(self):#select * from user;
        return self.cursor.fetchall()

    def fetchmany(self,limit):
        return self.cursor.fetchmany(limit)

    def __close(self):
        self.cursor.close()
        self.conn.close()

mysql_info = {'host':'127.0.0.1','user':'jxz','password':'123456',
              'port':3306,'autocommit':True,'charset':'utf8','db':'jxz'}
m = MysqlDB(mysql_info)

m.execute('select * from app_myuser where username = "liangcailian";')

result = m.fetchone()