面向对象编程（2）self的含义，类和方法应用及析构函数，继承。

1.类的联系使用

class Baby():

    country = 'China' #类变量，公共的变量,每个实例都可以用 对于公共的东西可以定义节省内存  

    def my(self):

        self.name = '牛寒阳'    #name 是属性 是本类对象。

    def cry(self):  #  实例方法

        print('哇哇哇')

 ##########

属性方法
    看起来像属性的一个方法。
###########

    @property  #这是一个装饰器，hhh不能入参  结果就是函数的返回值。不能按照原来的调用。

    def hhh(self):

        return 198

    @classmethod  #类方法

    def xm(cls):#cls代表的就是baby

        print(cls.country)

        print('我是类方法')

#1、不实例化，直接用类名调用这个xm的方法

#2、实例化之后，在通过实例化之后的对象调用xm方法，看看可以不   实例化会传递内存地址给类，所以通过不同的内存地址取得不同实例的值（self就是指内存地址本身）

#你不想实例化的时候，就可以定义成类方法

 ######

1、不用实例化就可以直接调用。
2、它可以通过cls使用类变量
3、它不能调用这个类里面的其他实例方法和实例变量

#######

    @staticmethod  #静态方法

    def xh():

        print('这个是静态方法，它和一个没写在类里面的函数一样')

#静态方法就是一个普通函数，只不过是写在类里面而已，它用不了类变量、类方法、实例变量、实例方法

****

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

# Baby.xh()

# Baby.country='USA'  #类变量是可以直接通过类名.xxx来进行修改的。

#  

# dcg = Baby()

# # dcg.country = 'Japan'   #只会该自己的属性 不会影响类变量  self。country也可以调用

# print(dcg.country)

# yjt = Baby()

# print(yjt.country)

# b = Baby()

# print(b.hhh)

# dcg = Baby('春光')

# print('董春光的内存的',id(dcg))  **self的内存地址和改内存地址一样。

# zll = Baby('张流量')

# print('董春光的内存的',id(zll))  **self的内存地址和改内存地址一样

2.利用类来改写数据库连接

import pymysql

class MyDb(object):

    def __del__(self):

        #析构函数   结束时执行

        self.cur.close()

        self.coon.close()

        print('over...')

    def __init__(self,

                 host,user,passwd,db,

                 port=3306,charset='utf8'):

        try:

            self.coon = pymysql.connect(

                host=host,user=user,passwd=passwd,port=port,charset=charset,db=db,

                autocommit=True,#自动提交

            )

        except Exception as e:

            print('数据库连接失败！%s'%e)

        else:

            self.cur = self.coon.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()      #返回slect的结果，其他没返回会报错。

            return self.res

###

析构函数
    def __del__():
        pass
  实例被销毁的时候执行的。
######

my = MyDb('118.24.3.40','jxz','123456','jxz')

my.ex_sql('select * from stu;')

print(my.res)

print('我是最后一行代码了。。。')  #这里才会执行析构函数。  析构函数实在实例被销毁的时候执行。

3.连接redis雏形（包含私有）    #封装就是把零零散散的功能整合到一起

###私有方法
##私有变量
    ###出了类之后，就不能用了。

import redis

class My(object):

    def __init__(self):

        self.__host = 'xx.xx.xxx.xx'   #前面加__符号，就是私有，变量加入成为私有方法

        self.__port = 6379

        self.__password = 'HK139bc&*'

        self.r = redis.Redis(host=self.__host,port=self.__port,password=self.__password)

    def get(self,k):

        res = self.r.get(k)

        if res:

            return res.decode()

        return None

    def __close(self):         #私有方法

        print('close')

    def str_set(self,k,v):

        pass

    def str_delete(self):

        #stt类型的删除key

        pass

    def hash_get(self):

        #hash类型获取单个key

        pass

    def hash_set(self):

        #hash类型set

        pass

    def hash_getall(self):

        #hash类型获取key里面的所有数据

        pass

    def hash_del(self):

        #删除某个hash里面小key

        pass

    def clean_redis(self):

        #清理redis

        pass

my = My()

4.继承

class Zll(object):
    def __init__(self):
        self.money = 1000000000
        self.house = '3环里20套'
    def sing(self):
        print('唱歌')
    def dance(self):
        print('跳广场舞')
    def lm(self):
        print('找朋友')

class Zxl(Zll):    #zxl继承zll，zxl实例化后可以使用父类的属性方法
    def dance(self):   #  可以重写父类的方法，作为自己的方法
        print('跳霹雳舞')

class Base(object):
    def __init__(self,host,port,password):   #将一些公共属性定义为父类
        self.host = host,
        self.port = port
        self.password = password

class Mysql(Base):  #继承Base的属性
    pass
class Redis(Base):
    pass