python基础：面向对象

            class Person:  #类def__init__(self):#构造函数
        self.name = ‘zhang‘
        self.nose = 2 #  #公有属性def driver(self):#方法print(‘老司机，开车非常稳‘)

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

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

            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()#报错，私有方法只在类内有效，出了类就无法调用

            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)#打印出zhongguoprint(Baby.country)#类直接调用类标量，仍旧是原值china,并没有改变
Baby.country=‘japan‘#类变量可通过 类.xxx=xx修改
print(Baby.country)#打印出japan

            class
             Baby():
    country=‘china‘#类变量，公共变量，所有实例化对象都可用# def __init__(self):#构造函数不是必须写的#     print(id(self))#     self.name=namedef 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()#类名直接调用类方法

            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语句时可以自动提交commitexcept 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‘,‘123456‘,‘db‘)
my.ex_sql(‘select * from stu;‘)
print(‘最后一行......‘)#程序自上向下执行，这一行代码执行完毕后，程序结束，此时就会执行析构函数
#所以最终会看到打印结果中显示：
最后一行......
over......

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