day9-面向对象和面向过程(代码片段)

class Baby:#经典类
    nationnality = ‘China‘#类属性
    def __init__(self,name):#构造函数，非必须
        self.name = name,#实例属性
        self.face = 1,
        print(‘实例创建时执行‘)
    def __del__(self):#析构函数，非必须
        print(‘实例销毁前执行‘)
    def eat(self):#方法
        print(‘want milk‘)
class car(object):#新式类
    def drive(self):
        pass
#在python3里经典类和新式类没有任何区别，均是广度优先
#python2中经典类在多继承的时候是深度优先，新式类是广度优先

Amy = Baby(‘A‘) #实例化，Amy就是Baby这个类的实例
#构造函数里面制定了必须传name，在实例化的时候就要把name传进去
#实例化需要变量接收，不然实例化结束,实例销毁
print(Amy.face)#调用实例属性
Amy.eat()#调用实例方法

class Baby:
    nationnality = ‘China‘#类属性，公共的变量，在外面都可以用
    def __init__(self,name):
        self.name = name,#实例属性，每个实例name不一样
        # self.country = ‘China‘#若每个对象都会存一个一样country，比较浪费内存，变为类变量
Amy = Baby(‘小A‘)
print(Amy.name)
Amy.sex = ‘famale‘#为实例新增实例属性
print(Amy.sex)
Amy.nationnality = ‘USA‘#不会改变类变量，只影响实例里的变量
print(Amy.nationnality)#USA
Ben =Baby(‘小B‘)
print(Ben.nationnality)#China
Baby.nationnality = ‘UK‘#类变量直接通过类名.xxx来进行修改，不需要实例化
print(Amy.nationnality)#USA,Amy的实例化发生在修改类变量之前，所以不再改变
print(Ben.nationnality)#UK
Cindy = Baby(‘小C‘)
print(Cindy.nationnality)#UK

class Baby:
    nationnality = ‘China‘#类变量
    def __init__(self,name):
        self.name = name,#实例变量

    def cry(self):#实例方法
        print(‘555...‘)

    @classmethod #类方法
    def lei(cls):#cls代表的就是Baby
        print(cls.nationnality)
        # print(cls.name)#报错，不能调用类中其他实例变量
        # cls.cry()#报错，不能调用类中其他实例方法

Amy = Baby(‘小A‘)
# Baby.cry()#报错，带self的方法均是实例方法，需要实例化后才能调用
Baby.lei()#不实例化，直接用类名调用这个lei的方法
Amy.lei()#实例化后，再通过对象调用类方法

class Baby:

    @property #属性方法
    def smile(self):
        return ‘haha‘

Amy = Baby(‘小A‘)
print(Amy.smile)#属性方法像属性一样调用
# print(Amy.smile())#报错,调用属性方法不用加括号

class Baby:

    @staticmethod
    def jing():#括号中未自动填充cls、self
        print(‘这是静态方法，它和一个没写在类里面的函数一样‘)

Amy = Baby(‘小A‘)
Amy.jing()#调用静态方法

class Daddy(object):
    def __init__(self):
        self.house = 1
    def drive(self):
        print(‘会开车‘)
    def dance(self):
        print(‘跳广场舞‘)

class Son(Daddy):#继承
    def dance(self):#重写父类方法
        print(‘跳鬼步舞‘)

s = Son()
print(s.house)#1
s.drive()#会开车
s.dance()#跳鬼步舞

class Base(object):
    def __init__(self,host,port,password):
        self.host = host,
        self.port = port,
        self.password =password
class Mysql(Base):
    pass
class Redis(Base):
    pass

class Baby:
    def __init__(self,name):
        #name = name#局部变量，出了函数就失效
        self.name = name#在类中self.name可以随便用了
        print(‘self的内存地址‘, id(self))
    def cry(self):
        print(‘%s在哭‘%self.name)#self.name在类中其他方法可以使用
Amy = Baby(‘小A‘)#实例化时将Amy的地址给self
print(‘实例的内存地址‘,id(Amy))#与实例化时self的内存地址一致
Amy.cry()

class Baby:
    def __init__(self,name):#构造函数
        self.name = name
    def cry(self):
        self.action = ‘哭了‘
        print(self.action)
Amy = Baby(‘小A‘)
print(Amy.name)#实例化时构造函数自动执行，
print(Amy.action)#cry方法未被执行，直接调用Amy.action会报错，object has no attribute对象没有该属性

class Baby:
    def __init__(self,name):#构造函数
        self.name = name
        self.cry()#将cry这个方法放在构造函数里
    def cry(self):
        self.action = ‘哭了‘
        print(self.action)
Amy = Baby(‘小A‘)
print(Amy.action)#不再报错

class Baby:
    def __init__(self,name):#构造函数
        self.name = name
    def cry(self):
        self.action = ‘哭了‘
        print(self.action)
Amy = Baby(‘小A‘)
Amy.cry()#先调用cry这个方法
print(Amy.action)

import pymysql
class MySQL(object):
    def __init__(self,host,user,passwd,db,port=3306,charset=‘utf8‘):#构造函数,类实例化的时候执行
        try:
            self.conn = pymysql.connect(
                host = host,user=user,passwd=passwd,db=db,port=port,charset=charset,
                autocommit=True  # 自动提交，执行insert，update语句时，可以自动提交
            )
        except Exception as e:
            print(‘数据库连接失败，%s‘%e)
        else:
            self.cur = self.conn.cursor(cursor=pymysql.cursors.DictCursor)
    def __del__(self):#析构函数,实例被销毁的时候执行
        self.cur.close()
        self.conn.close()
        print(‘数据库连接关闭‘)
    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 = MySQL(‘127.0.0.1‘, ‘root‘, ‘123456‘, ‘data‘)
my.ex_sql(‘select * from stu‘)
print(my.res)#可以用实例属性取值
# print(my.ex_sql(‘select * from stu‘))#也可以用实例方法的返回值
print(‘我是最后一行代码‘)#执行完最后一行代码，数据库连接关闭

import redis
class Si(object):
    def __init__(self):
        self.__host = ‘127.0.0.1‘#私有变量
        self.port = 6379
    def open(self):
        print(‘实例方法‘)
        self.__close()#类内部可以调用私有方法
    def __close(self):#私有方法
        print(‘私有方法‘)
m = Si()
# print(m.__host)#报错，没有__host这个属性,私有变量出类后不能再使用
print(m.port)
m.open()#打印出:实例方法，私有方法
# m.__close()#报错，没有这个方法，,私有方法出类后不能再使用

import redis
class MyRedis(object):
    def __init__(self):
        self.__host = ‘127.0.0.1‘
        self.__passwd =‘‘
        self.__db = 1
        self.__port = 6379
        try:
            self.r = redis.Redis(host=self.__host,password=self.__passwd,db=self.__db,port=self.__port)
        except Exception as e:
            print(‘数据库连接失败，%s‘%e)
    def str_get(self,k):#string类型获取value
        try:
            res = self.r.get(k)
        except Exception as e:
            print(‘获取数据错误，%s‘%e)
        else:
            if res:
                return res.decode()
        return None
    def str_set(self,k,v,time=None):#string类型添加修改key
        try:
            self.r.set(k,v)
        except Exception as e:
            print(‘插入数据错误，%s‘%e)
    def str_del(self,k):#string类型删除key
        try:
            self.r.delete(k)
        except Exception as e:
            print(‘删除数据错误，%s‘%e)
    def hash_get(self,bk,sk=None):#hash类型获取value
        if sk:
            try:
                res = self.r.hget(bk,sk)#指定大key和小key获取对应的数据
            except Exception as e:
                print(‘获取数据错误，%s‘ % e)
            else:
                if res:
                    return res.decode()
        else:
            try:
                res = self.r.hgetall(bk)#获取里面所有的key和value,获取结果是字典
            except Exception as e:
                print(‘获取数据错误，%s‘ % e)
            else:
                if res:
                    res_d = 
                    for k, v in res.items():
                        res_d[k.decode()]=v.decode()
                    return res_d
    def hash_set(self,bk,sk,v):#hash类型set
        try:
            self.r.hset(bk,sk,v)
        except Exception as e:
            print(‘插入数据错误，%s‘ % e)
    def hash_del(self,bk,sk=None):#hash类型del
        if sk:
            try:
                self.r.hdel(bk,sk)#删除指定的key
            except Exception as e:
                print(‘删除数据错误，%s‘ % e)
        else:
            try:
                self.r.delete(bk)#删除整个key
            except Exception as e:
                print(‘删除数据错误，%s‘ % e)
m = MyRedis()
m.str_set(‘Kity‘,‘famale‘)
print(m.str_get(‘Kity‘))
m.str_del(‘Kity‘)
m.hash_set(‘toy‘,‘car‘,‘red‘)
m.hash_set(‘toy‘,‘ball‘,‘blue‘)
print(m.hash_get(‘toy‘,‘car‘))
print(m.hash_get(‘toy‘))
m.hash_del(‘toy‘,‘car‘)
m.hash_del(‘toy‘)