python面向对象--类

1、类的概念：简单来说就是一组符合逻辑的参数或者是函数，一个种类、一个模型。

一个类中可以包含任意参数，并且可以定义任意个方法，但类并不是随意的将多个参数或者方法包含在class下，而是创建一个在事物之间具有逻辑链接的对象。

在python中class关键字定义一个类，在class中有def定义的函数，也就是类的方法。

2. 实例、实例化、对象

    实例或叫对象：
        根据模型制作出来的东西。
          写法： 对象名/实例名 = 类名(参数-如果有)
    实例化：
        就是做东西的这个过程。

3.方法：类里面的函数
   写法： 
        def 方法名（self,参数-如果有）：
　　　　　　　　pass

4. 属性：类里面的变量
5. 构造函数：类在实例化的时候会自动执行的一个函数
   写法： 
　　    def __init__(self,参数-如果有):
　　　　　　　　pass

6. 析构函数：实例在销毁的时候自动执行的函数
　 写法：
　　　　def __del__(self,参数-如果有):
　　　　　　　　pass

7. self：代表的本类对象。

例1：

#以下3种定义类的方式在python3中没有区别，可任意使用

class My:  #经典类
    pass

class My2(object):  #新式类
    pass

class My3(): #新式类
    pass

country = 'China' #全局变量

class Person:
    def __init__(self,name): #构造函数 __init__
        print('开始了',name)
        self.name = name  # 实例变量
        self.age = 18
        # 人的名字是 xxx
        self.data = '哈哈哈'
        self.addr = '北京'

    def cry(self,size): #cry是方法，size是属性
        print('%s在%s哭。年龄是%s'%(self.name,size,self.age))
        self.size = '大哭'
        self.date = ''

    def say(self):
        print('我叫%s，我住在%s.'%(self.name,self.addr))
        print(self.size)
        print('今天的日期',self.date)
        self.help()

    def help(self):
        print(self.date)

mcb = Person('Jack') #这里的“赋值”就是在实例化
cq = Person('Alice') #mcb和cq就是实例或者称作对象

mcb.grilfriend = cq 

print('Jack的女朋友',mcb.grilfriend.name)
mcb.grilfriend.cry('大')

#以上输出结果如下：

开始了 Jack
开始了 Alice
Jack的女朋友 Alice
Alice在大哭。年龄是18

例2：

import pymysql
class MyDb:
    def __init__(self,host,user,password,db,port=3306,charset='utf8'):#构造函数，
        print('连接数据库')
        self.conn = pymysql.connect(host=host,user=user,password=password,
                        db=db,port=port,charset=charset)
        self.cur = self.conn.cursor()

    def execute_one(self,sql):
        print('返回单条数据')
        self.cur.execute(sql)
        res = self.cur.fetchone()
        return res

    def execute_many(self,sql):
        print('返回多条数据的')
        self.cur.execute(sql)
        res = self.cur.fetchall()
        return res

    def __del__(self):#析构函数
        print('关闭数据库连接')
        self.cur.close()
        self.conn.close()

my = MyDb('100.10.1.10','name','pwd','dbname') #实例化

#一个变量前面加了self之后，那么在这个类里面的其他的函数都可以用了。

res = my.execute_one('select * from app_myuser where username="testuser1";')
print(res)

res2 = my.execute_many('select * from app_myuser limit 10;')
print(res2)

#以上输出结果如下
连接数据库
返回单条数据
(34847, 'TESTUSER1', '96e79218965eb72c92a549dd5a330112', 1)
返回多条数据的
((1122, 'liuyana03', '', 1), (1123, 'wpp', '', 1), (1128, 'wangcan', 'hhhh', 1), (1129, 'wangcan1', 'hhhh', 1), (1185, 'wangliwen', '', 1), (1186, 'wangzhihua', '', 1), (1187, 'zyb123', '', 1), (1188, 'nhy1233', '', 1), (1190, 'aaaa', '', 1), (1191, 'zzf', '', 1))
关闭数据库连接

8. 类变量：就在直接在类下面定义的变量，没有加self的，每个实例都可以用

　 写法：

　　class 类名:
    　 类变量名 = 值
　　　　def __init__(self,参数名-如果有):
　　　　　　　　pass

9. 类方法：

    1、不需要实例化就可以调用
    2、它可以使用类变量
    3、可调用其他的类方法。
    4、它不可以使用实例方法、实例变量
    如果类里面的这个方法，它并没有使用到其他的实例变量、或者其他实例方法，那么就给他定义成类方法
写法：

　　　@classmethod
　　  def 方法名(cls): #一般默认写cls,跟方法里的self意思差不多
　　　　　　pass

10. 静态方法：
    1、不需要实例化就可以调用的
    2、它就是一个定义在类里面的普通函数，不能使用实例变量、实例方法、不能使用类变量、类方法。
写法：

　　@staticmethod
　　def 方法名():
　　　　 pass

11. 属性方法：
    看起来像变量的一个方法。
写法：

　　@property
　　def 方法名(self):
　　　　  pass

12. 实例变量：
    写法： self.xxx = xxx
    加了self的变量才是实例变量，必须得实例化之后才可以使用

13. 实例方法：
    需要传self的方法，都是实例方法，必须得实例化之后才可以使用
    实例方法里面可以随便通过self来调用实例方法，类方法，静态方法，类变量。

class Car:
    wheel = 4 #类变量
    def __init__(self,color,p):
        self.color = color #实例变量
        self.p = p

    def help(self): #实例方法
        print('汽车有%s个轮子'%self.wheel)
        print('汽车的颜色是%s'%self.color)
        print('牌子%s'%self.p)
        print('='*10)
        self.haha() #调用其他方法
        self.check_wheel()

    @classmethod #类方法
    def check_wheel(cls):
        print('cls的内存地址',id(cls))
        print(cls.wheel) #类方法可以使用类变量
        cls.haha() #类方法可以调用其他方法

    @classmethod #类方法
    def haha(cls):
        print('哈哈哈')
        cls.help2() #类方法可调用其他的类方法

    @staticmethod #静态方法
    def help2():
        print('这个类的作用是造汽车，它里面有xxx方法')

    @property #属性方法
    def yesterday(self):
        import datetime
        res = datetime.date.today()  + datetime.timedelta(-1)
        return str(res)

    def tomorrow(self): #实例方法
        import datetime
        res = datetime.date.today()  + datetime.timedelta(1)
        return str(res)

Car.help2()  #静态方法的调用不需要实例化
#上一行代码输出：这个类的作用是造汽车，它里面有xxx方法

mcb = Car('赤橙黄绿青蓝紫','Jack')
print(mcb.yesterday) #属性方法的调用，对象名（yesterday）后不需要加括号
#上一行代码输出：2019-01-10

print(mcb.tomorrow()) # 输出：2019-01-12

mcb.wheel = 28
mcb.haha()
#上一行代码输出：
# 哈哈哈
# 这个类的作用是造汽车，它里面有xxx方法

mcb.help()
mcb.help2()

print('Car的内存地址',id(Car)) #输出：Car的内存地址 38354920

Car.check_wheel() #类方法不需要实例化就可以调用

Car.wheel= 19
print(Car.wheel) #输出：19

#以上代码输出：
这个类的作用是造汽车，它里面有xxx方法
2019-01-10
2019-01-12
哈哈哈
这个类的作用是造汽车，它里面有xxx方法
汽车有28个轮子
汽车的颜色是赤橙黄绿青蓝紫
牌子Jack
==========
哈哈哈
这个类的作用是造汽车，它里面有xxx方法
cls的内存地址 36782056
4
哈哈哈
这个类的作用是造汽车，它里面有xxx方法
这个类的作用是造汽车，它里面有xxx方法
Car的内存地址 36782056
cls的内存地址 36782056
4
哈哈哈
这个类的作用是造汽车，它里面有xxx方法
19
汽车有19个轮子
汽车的颜色是黑色
牌子奔驰
==========
哈哈哈
这个类的作用是造汽车，它里面有xxx方法
cls的内存地址 36782056
19
哈哈哈
这个类的作用是造汽车，它里面有xxx方法