一、定义
面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
类：一个种类，一个模型。
对象：指具体的东西，模型造出来的东西叫做对象。 实例：实例和对象是一样的。 实例化：实例化就是造东西的这个过程。 属性：就是变量 方法：就是类里面的函数类的定义：
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=agep=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 198b=Baby()b.cry()print(b.hhh)#属性方法的调用跟调用属性一样，方法名后不加括号
六、类变量
可以直接通过类名来引用并操作的变量。实例也可引用操作，但是实例并不是实际改变类变量的值
类变量直接在类内部定义（不要定义到函数体中）
class Baby(): country = 'China' #类变量，公共的变量,每个实例都可以用 def my(self): self.name = 'aaa' def cry(self):#实例方法 print('哇哇哇') print(self.country)#函数调用类变量时，要用self.xxxb=Baby()b.country='zhongguo'#实例对象修改类变量的值print(b.coutry)#打印出zhongguoprint(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 pymysqlclass 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.resmy=MyDb('127.0.0.1','root','123456','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中，在多继承时，一个是深度优先，一个是广度优先