11.17 PYTHON 类

""""""
"""类：
万物皆对象：
类---（手机，人类，动物类---概括性很广）
对象---（对象是类的实例个体）
每一个物体都可以称为对象
当前我有一个手机类（包含有各式各样的手机），对象就是手机的实例，
苹果14，华为mate40，小米12，锤子手机，都是手机类的实例对象

共同的方法:打电话，拍照，发短信  手机共有的方法
     属性：硬件的配置cup，内存，摄像头，屏幕


python 用 class定义一个类（）：包含具有一些共有的属性和方法
        方法：函数
        属性：变量

用来组织函数和属性

"""
# class MyPhone():
#     def dadianhua(self):
#         print("这是一个打电话的方法")
#
#     def faduanxin(self):
#         print("这是一个发短信的方法")
#
#     def test(self):
#         print("这是一个卫星定位的功能")
#
#     def test01(self):
#         print("这是一个拍照的功能")
#
# MyPhone().test() # 当前手机类调用类当中的方法
# MyPhone().dadianhua()

# 通过对象具体实例调用类当中的方法


# 实例化对象就是，创建对象的过程叫做实例化
# iphone14 = MyPhone()  # 实例化一个对象
# mate30 = MyPhone()  # 实例化一个对象
#
# print(iphone14,mate30)
# # 对象也可以调用类当中的功能
# iphone14.dadianhua()
# mate30.faduanxin()


""" 类就是一个容器，可以组织一个共有的方法和属性进行管理
对象就是当前类单独的个体，也可以调用类当中的方法
实例化：实例化对象，创建对象的过程叫做实例化
对象：类的实例个体
方法：类当中的函数
属性：类当中的变量
    第一种类变量：类当中共享的值。
    第二种实例变量：只是当前的实例对象可以调用的变量
    第三种私有变量
"""

"""类当中的属性：
    类变量：
"""
# class MyPhone():
#     number = 1000
#     age = "18"
#     name = "张三"
#     """这些定义的变量称之为类变量"""
#
# print(MyPhone().number)
# iphone14 = MyPhone()
# print(iphone14.name)


# class MyPhone():   # 这里的括号不能定义形参

    # 通过init的函数方法帮他去完成形参的定义

    #也是一个初始化的功能，每次调用这个类的时候，都会先去初始化init的类型重新赋值
#     def __init__(self,name,age,number):
#
#         self.number = number
#         self.name = name
#         self.age = age
#
# iphone14 = MyPhone(name="苹果",age="20",number="10000")
# mate30 = MyPhone(name="华为",age="23",number="20000")
# # 在调用前的类的过程中   ,name,age,number
# print(iphone14.name)
# print(mate30.name)



""" 类 当中的self他就是类的对象，也就是实例对象本身。带self参数的
方法变量：说明当前的方法变量是属于实例对象的，所以这样的方法也称为
实例变量，实例方法"""
# class MyClass():
#
#     def __init__(self):
#         print(self)
#
#     def func(self):
#         print(self)
# a = MyClass()
# print(a)
# a.func()
"""
    <__main__.MyClass object at 0x00EBAEB0>
    <__main__.MyClass object at 0x00EBAEB0>
"""




# class MyClass():
#     __age = "武汉多测师"
#     number = "wuhanduoceshi"
#     def __init__(self,host,user,password,database,port=3306):
#         self.host=host
#         self.user=user
#         self.password=password
#         self.database=database
#         self.port=port
#
#     def func(self):
#         print(f"host 的参数{self.host}\n",
#               f"user 的参数{self.user}\n",
#               f"password 的参数{self.password}\n",
#               f"database的参数 {self.database}\n",
#               f"port的参数{self.port}\n",
#               f"类变量的属性{self.number}\n"
#               f"私有变量的属性{self.__age}\n")  # 引用私有变量
# a = MyClass("192.168.2.36","root","123456","dcs20")
# a.func()

# MyClass("192.168.2.36","root","123456","dcs20").func()
# print(MyClass("192.168.2.36","root","123456","dcs20").number)
# print(MyClass("192.168.2.36","root","123456","dcs20").__age)  # 报错，因为__age是私有变量

""" 类当中：方法函数分为多种：
实例方法：
    1.()当中第一个参数默认是self
    2.实例方法可以被类对象进行调用
    3.实例方法可以使用类变量，和实例变量
类方法:需要通过装饰器  @class method 装饰器进行定义
     装饰器@classmethod 就是进行功能拓展和属性赋予的
    1.类方法需要通过装饰器进行修饰
        （装饰器分为类装饰器，和函数器
            作用：1.可以给当前的函数和类拓展新的功能
                2.可以给档期啊你的函数和类进行属性的赋予）
    装饰器本身就是一个函数，或者是一个类
    2.可以被类或者对象直接进行引用
    3.函数当中的第一个参数默认是cls
    4.类方法可以引用类变量，但是不能使用实例变量


静态方法：
    1.需要通过装饰器进行修饰，staticmethod装饰修饰
    2.静态方法不能使用类变量
    3.静态方法不能使用实例变量
    4.静态方法中没有默认的形参，静态方法可以被类和对象
    直接进行调用
私有方法:
    定义规则使用双下划线开头

私有变量：当前的变量只能在类当中进行使用，不能在外部进行访问，只属于当前的
        类本身。__开头

"""
# class MyClass():
#     number = 100
#     def __init__(self):
#         self.name = "张三"
#         self.age= "18"
#
#     def test01(self):
#         print(f"这是一个实例方法：类变量：{self.number} 实例变量{self.name}")
#
#
#     @classmethod
#     def test02(cls):
#         print(f"这是一个类方法：引用类变量{cls.number} ")
#
#     @staticmethod
#     def test03():
#         # MyClass().__test04()  #在类的内部使用类直接调用
#         a = MyClass()  # 在类的内部当中使用，实例化对象进行调用
#         a.__test04()
#         print("这是一个静态方法,引用变量 ")
#
#     def __test04(self):
#         print(f"这是一个私有方法.引用类变量{self.number} 实例变量{self.name} ")


# a = MyClass()
# a.test01()  # 实例方法可以引用类变量和实例变量
# a.test02()  # 类方法只能引用类变量，不能引用实例变量
# a.test03()
# a.__test04

"""类的封装  mysql"""
# import pymysql
#
# class MySqlDb():
#
#     """用来封装mysql数据的常用操作"""
#
#     def __init__(self, host, user, password, database, port=3306):
#         self.host=host
#         self.user=user
#         self.password=password
#         self.database=database
#         self.port=port
#
#     def connect_db(self):
#         """用来链接数据库的对象"""
#         db = pymysql.connect(host=self.host,user=self.user,
#                              password=self.password,
#                         database=self.database,port=self.port)
#         cursor = db.cursor()
#         return db
#
#     def select_sql(self,sql):
#         # 获取
#         cursor = self.connect_db().cursor()
#         cursor.execute(sql)
#         print(cursor.fetchall())
#
#     def update_sql(self,update_sql,select_sql):
#         cursor = self.connect_db().cursor()
#         cursor.execute(update_sql)
#         db = self.connect_db()
#         db.commit()
#         cursor.execute(select_sql)
#         print(cursor.fetchall())
#
#     def delete_sql(self,delete_sql,select_sql):
#         cursor = self.connect_db().cursor()
#         cursor.execute(delete_sql)
#         db =self.connect_db()
#         db.commit()
#         cursor.execute(select_sql)
#         print(cursor.fetchall())
#
#     def insert_sql(self,insert_sql,select_sql):
#         cursor = self.connect_db().cursor()
#         cursor.execute(insert_sql)
#         db=self.connect_db()
#         db.commit()
#         cursor.execute(select_sql)
#         print(cursor.fetchall())
#
# mysql = MySqlDb(host="192.168.33.36",user="root",password="123456"
#                 ,database="dcs20",port=3306)
# mysql.select_sql("select * from dept;")
# mysql.update_sql("update dept set dept_name = 'hasd' where dept1 = 105;"
#                  ,"select * from dept;")
# mysql.delete_sql("delete from dept where dept1=105","select * from dept")

# mysql.insert_sql("insert into dept values(100,'li')","select * from dept")


"""python :类的继承：
当前子类继承父类的方法和属性：、

注意：继承属性：如果当前的子类没有构造函数，会默认继承父类的构造函数方法
如果当前子类有构造函数方法，需要通过super类重写构造函数方法

__init__ :构造函数，__init__ 属于魔术方法的一种：。
注意点：如果当前的父类和子类都有相对的属性，那么字相当于重写了父类的方法


"""

# 父类                # 之前的版本默认需要填（object 也是一个类）
# class Myclass():      #括号当中填写继承的类
#     def __init__(self):
#         self.name = "张三"
#         self.age = 18
#
#     def youqian(self):
#         print("余额：10000000000.00")
#
#     def fangzi(self):
#         print("十来套房产")

# # 妈妈
# class MyClass1():
#     def a(self):
#         print("有别墅")
# # 爷爷
# class MyClass2():
#     def che(self):
#         print("法拉利")


# 儿子类
# class TestCase(Myclass,MyClass1,MyClass2):
#     def __init__(self):
#         super().__init__()  # super是个超类，通过super重写当前的构造函数
#         self.wuhan = "湖北"    # 重写构造函数，重新定义构造函数
#         self.name = "李四"
#     def yougongsi(self):
#         print("十几家上市公司")
#     def youchezi(self):
#         print("地库停满了")

# TestCase().fangzi()
# TestCase().yougongsi()

# 如果当中的子类没有构造函数的方法，默认继承父类的构造函数方法
# print(TestCase().name)
# print(TestCase().wuhan)
# TestCase().a()



class Test01():
    def boy(self,values):
        print("男一"+values)
class Test02(Test01):
    def boy(self,values):
        print("男二"+values)
class Test03():
    def boy(self, values):
        print("男三" + values)

a = Test01()
b = Test02()
c = Test03()
a.boy("女一")
b.boy("女二")



"""多态：相同名称的方法有多种形态
    1.有多个类，这些类当中都具有相同的方法，但是根据不同类执行不同的结果。
    2.基于继承关系，重写父类的方法，a 有boy，b也有boy，他不会继承a的方法
    而是重新定义boy这个方法


"""