'''
类、构造函数、析构函数
面向对象
类
含义：一个种类，一个模型。类或模型不能直接使用，需要先实例化类或模型，就是根据模型制作出来的具体的东西
形式：
class 类名：
定义说明：一般类名首字符会大写
实例化：做模型的过程
实例：根据模型或类做出来的东西，这个东西就叫实例
方法：类里的函数
属性：类里面，定义的变量
self：代表类的对象，类的对象就是实例化后的对象
# 1、self在构造函数中定义。实例化的时候已经被自动执行了，所以当对象调用实例的时候，实例中的可以用构造函数中的变量
class A:
def __init__(self):
self.name='xiaozhang'
self.age=12
def b(self):
print('%s的年龄是%s'%(self.name,self.age))
a = A()
a.b()
# 2、self在方法中的定义。实例化后需要先执行当前方法，然后，后续的方法才能使用这个方法中的变量
class A:
def a(self,age):
self.name='oo'
self.age=age
def b(self):
print(self.name,self.age)
p = A()
p.a(12) #必须铣执行类方法a,下面使用到类方法a里的变量才能被继续使用，否则失败
p.b()
类变量：定义在类里，函数外的变量。每个函数都可以调用
class A:
aa =10
def a(self):
print(A.aa)
def b(self):
print(A.aa)
p = A()
p.a()
p.b()
析构函数：函数自上而下执行，执行到最后的时候，没有可执行代码了。内存中的实例在销毁的时候自动执行
class People:
def smile(self):
print('人会笑')
def run(self):
print('人会跑')
def __del__(self):
print('析构函数，实例在销毁的时候自动执行的一个函数')
p = People()
p.smile()
构造函数：类在实例化过程中自动执行的一个函数
class People:
def __init__(self): #构造函数
print('构造函数')
def smile(self):
pass
p = People() #构造函数在实例化的时候就【自动执行了】
#构造函数的使用，公共的使用数据库查询的情况下，把连接信息放在数构造函数里面
import pymysql
class People:
def __init__(self,host,port,username,password): #构造函数
self.conn = pymysql.connect(host=host,port=port,uername=username,
password=password,charset='utf8')
self.cur = self.conn.cursor()
print('构造函数')
def execute_one(self):
sql = 'select * from app_test where id=2'
a = self.cur.execute(sql)
p = People('118.3.0.225',3306,'root','111111') #构造函数在实例化的时候就【自动执行了】
self::
一个变量前加了self之后，那么这个类里面的其他函数都可以用了
'''
# 封装类。把多个函数封装到一个类下，后续执行程序内的方法或函数，仅针对这个类
import pymysql
class MyDb1:
name='mysql' #属性
def __init__(self): #构造函数，实例化的时候，会自动执行这个函数
print('99999')
def conn_mysql(self): #类下定义函数，会自动就一个self参数
print('连接MySQL')
def execute_one(self):
print('返回单条数据')
def execute_many(self):
print('多条')
def close(self):
print('关闭数据库')
# my = MyDb() #MyDb（）就是，实例化
#my就是实例
# my.conn_mysql()
'''
既然构造函数，实例化的时候，会自动执行这个函数。那么如果把数据库的连接信息放在这个函数下面，实例化的时候
my = MyDb()就会自动连接数据了。。。此时需要在实例化的时候，传参：数据库的连接信息
'''
class MyDb2:
name='mysql' #属性
def __init__(self,host,user,password,db,port=3306,charset='utf8'): #构造函数，实例化的时候，会自动执行这个函数。有入参
print('构造函数+连接数据库')
self.conn = pymysql.connect(host=host,user=user,password=password,
db=db,port=port,charset=charset)
self.cur = self.conn.cursor()
# 对比之前的数据方法，每次执行，都要连接一次数据库，现在的构造函数的方法，一次连接
def execute_one(self,sql):
self.cur.execute(sql)
res = self.cur.fetchone()
return res
print('返回单条数据')
def execute_many(self,sql):
self.cur.execute(sql)
res = self.cur.fetchall()
return res
print('多条')
def close(self):
self.cur.close()
self.conn.close()
print('关闭数据库')
# my = MyDb('118.24.3.40','jxz','123456','jxz') #实例化
# #my就是实例
# res = my.execute_one('select * from app_myuser where username = "testuser1"')
# print(res)
#
# print('*'*60)
#
# res2 = my.execute_many('select * from app_myuser limit 10')
# print(res2)
#
# my.close()
'''
不用数据库的时候，怎么让程序自动关系数据库
【析构函数】实例在销毁的时候，自动执行
'''
class MyDb:
name='mysql' #属性
def __init__(self,host,user,password,db,port=3306,charset='utf8'): #构造函数，实例化的时候，会自动执行这个函数。有入参
print('构造函数+连接数据库')
self.conn = pymysql.connect(host=host,user=user,password=password,
db=db,port=port,charset=charset)
self.cur = self.conn.cursor()
# 对比之前的数据方法，每次执行，都要连接一次数据库，现在的构造函数的方法，一次连接
def execute_one(self,sql):
self.cur.execute(sql)
res = self.cur.fetchone()
return res
print('返回单条数据')
def execute_many(self,sql):
self.cur.execute(sql)
res = self.cur.fetchall()
return res
print('多条')
def __del__(self):
self.cur.close()
self.conn.close()
print('关闭数据库')
my = MyDb('118.24.3.40','jxz','123456','jxz') #实例化
#my就是实例
res = my.execute_one('select * from app_myuser where username = "testuser1"')
print(res)
print('*'*60)
res2 = my.execute_many('select * from app_myuser limit 10')
print(res2)
#代码执行到这里，内存里的变量my，被销毁了，会自动执行析构函数__del__()