python基础：面向对象

一、定义

面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用

类：一个种类，一个模型。
对象：指具体的东西，模型造出来的东西叫做对象。
实例：实例和对象是一样的。
实例化：实例化就是造东西的这个过程。
属性：就是变量
方法：就是类里面的函数

类的定义：

class Person:  #类
    def __init__(self):#构造函数
        self.name = 'zhang'
        self.nose = 2 #  #公有属性

    def driver(self):#方法
        print('老司机，开车非常稳')

p=Person()#实例化，p就是实例即对象
print(p.name)#实例化对象可调用类的公共属性
p.driver()#实例化对象可调用类的公共方法

二、构造函数：

__init__(self)  这个是构造函数。可写可不写。当类实例化的时候，最先执行构造函数。构造函数也可带参数。如果构造函数带参数，则在实例化的时候，就要带参数

class Person:  #类
    def __init__(self，age):#带参数的构造函数
        self.name = 'zhang'
        self.nose = 2 #  #公有属性
        self.age=age
p=person(18)#实例化，必须将age的值带过去
print(p.age)#打印18

三、self

self代表的是本类对象。因为函数里面的变量都是局部变量，出了函数就不能用了。
用self给对象绑定了之后，就可以self.xx随便用了

class Person:  #类
    def __init__(self，age):#带参数的构造函数
        self.name = 'zhang'
        self.nose = 2 #  #公有属性
        self.age=age
    def haha(self):
        print(self.nose)#可直接用self.nose使用构造函数中的变量，会打印出2

p=Person(18)

四、私有属性和方法

私有属性和方法的定义，在前面加上两个横。私有属性和方法只能在类内部调用。出了类体就不能再调用

class Person:  #类
    def __init__(self):#构造函数
        self.name = 'zhang'
        self.nose = 2 #  #公有属性
        self.__ear=2#私有属性，变量前加__  

    def driver(self):#方法
        print('老司机，开车非常稳')
    def __eat(self):#私有方法
        print('吃。。。。。。。。。')

p=Person()#实例化，p就是实例即对象
print(p.__ear)#报错
p.__ear()#报错，私有方法只在类内有效，出了类就无法调用

五、属性方法

看起来像属性的方法。跟普通方法的区别：在方法前加上@property。调用的时候像调用属性一样，不用加括号

class Baby():
    #没有构造函数
    def my(self):
        self.name = 'aaa'
    def cry(self):#实例方法
        print('哇哇哇')

    @property#属性方法
    def hhh(self):
        return 198
b=Baby()
b.cry()
print(b.hhh)#属性方法的调用跟调用属性一样，方法名后不加括号

六、类变量

可以直接通过类名来引用并操作的变量。实例也可引用操作，但是实例并不是实际改变类变量的值

类变量直接在类内部定义（不要定义到函数体中）

class Baby():
    country = 'China' #类变量，公共的变量,每个实例都可以用
    def my(self):
        self.name = 'aaa'
    def cry(self):#实例方法
        print('哇哇哇')
        print(self.country)#函数调用类变量时，要用self.xxx
b=Baby()
b.country='zhongguo'#实例对象修改类变量的值
print(b.coutry)#打印出zhongguo
print(Baby.country)#类直接调用类标量，仍旧是原值china,并没有改变
Baby.country='japan'#类变量可通过 类.xxx=xx修改
print(Baby.country)#打印出japan

七、类方法

类方法不仅可以直接用实例调用，也可以直接用类名调用。类方法的定义需要在普通方法前加上@classmethod

class Baby():
    country='china'#类变量，公共变量，所有实例化对象都可用
    # def __init__(self):#构造函数不是必须写的
    #     print(id(self))
    #     self.name=name
    def cry(self):#带self的方法，叫实例方法.必须先实例化后才能调用
        print('哇哇啊啊')
        print(self.xiaoming())#调用类方法时，必须用self.xxx

    @property#加上这句，将函数定义为属性方法，当做变量用。不能加入参
    def hhh(self):
        return 198

    @classmethod
    def xiaoming(cls):#cls代表本类,这个是类方法
        print(cls.country)
        print('我是类方法')

b=Baby()
b.xiaoming()#实例对象调用类方法
Baby.xiaoming()#类名直接调用类方法

八、静态方法

#静态方法就是一个普通的函数，只不过就是写在类中，不能用类变量，类方法，也用不了实例方法，实例变量。。静态方法的定义在普通方法前加上@staticmethod

class Byby():
    @staticmethod
    def xiaohei():
        print('这个是静态方法，它和一个没卸载类里面的函数一样')

九、析构函数

析构函数在实例销毁时执行，一般用作最后的善尾工作。比如在数据库操作中，可以将关闭操作都放在析构函数中，当程序全部执行的时候，会自动地执行析构函数，将数据库连接关闭

析构函数也是非必写

import pymysql
class MyDb(object):
    def __del__(self):#析构函数不是必写的
        #析构函数
        self.cur.close()#将数据库关闭操作放在析构函数。在程序执行完毕后，会执行析构函数
        self.conn.close()#
        print('over....')

    def __init__(self,host,user,password,db,port=3306,charset='utf8'):
        try:
            self.conn=pymysql.connect(host=host,user=user,password=password,port=port,charset=charset,db=db,autocommit=True)
            #autocommit  在执行insert,update,delete语句时可以自动提交commit
        except Exception as e:
            print('数据库连接失败%s'%e)
        else:
            self.cur=self.conn.cursor(cursor=pymysql.cursors.DictCursor)

    def ex_sql(self,sql):
        try:
            self.cur.execute(sql)
        except Exception as e:
            print('sql语句有问题%s'%sql)
        else:
            self.res=self.cur.fetchall()
            return self.res

my=MyDb('127.0.0.1','root','','db')
my.ex_sql('select * from stu;')
print('最后一行......')#程序自上向下执行，这一行代码执行完毕后，程序结束，此时就会执行析构函数

#所以最终会看到打印结果中显示：
最后一行......
over......

十、if  __name__ == '__main__':

作用：

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

2、这句话一般是做测试的时候用的，直接执行该句话所在的文件，加与不加没有任何区别

3、但是如果在别的文件import该文件，则main下的所有代码不会被执行

假设文件aa.py中代码如下：

print(__name__)#直接执行该文件，会打印出__main__。但是如果在别的文件import该文件，这句话回打印出当前文件的文件名
if __name__ == '__main__':#  直接运行当前python文件，main 写这里并没有什么用。写与不写一样#但是如果在别的python中导入当前python文件，那么main下的代码不会被执行
    print('测试。。。。。。。。'）

以上代码，如果直接运行所在py文件，则会打印出：

__main__

测试。。。。。。

如果在文件b.py中import aa.py,执行结果：

aa    #直接打印出aa.py的文件名。同时不会执行if__name__=='__main__' 下的代码

十一、经典类和新式类区别

#经典类和新式类在python2中有区别，在python3中没有任何区别

#python2中，在多继承时，一个是深度优先，一个是广度优先