"""
类定义：
关键字：class
语法：
class 类名：
# 类里面的代码
类名的命名规范：遵循标识符的命名规范，风格采用大驼峰命名法（每个单词的第一个字母大写）
通过类创建对象：
对象 = 类名()
"""
class Cat:
pass
class MyTestClass:
pass
# 关于对象：有人叫对象，也有人叫实例
# 通过类创建对象(实例化对象)
kitty = Cat()
print(kitty, id(kitty))
coffee = Cat()
print(coffee, id(coffee))
类属性和实例属性
"""
这一类事物拥有的共同特征，我们通常会定义为类属性
类属性：在类里面直接定义的变量，叫做类属性
# 通过对象访问类属性：对象名.属性名
# 通过类访问类属性：类名.属性名
实例属性：每个对象的属性值都有可能不一样，就应该定义为实例属性（对象属性）
实例属性的定义：对象.属性名 = 属性值
"""
print("------------------类属性--------------------")
class Cat:
leg = "四条腿"
tail = "长尾巴"
kitty = Cat()
coffee = Cat()
# 通过对象访问类属性：对象名.属性名
print(kitty.leg)
print(coffee.leg)
# 通过类访问类属性：类名.属性名
print(Cat.leg)
print("------------------实例属性--------------------")
class Cat:
leg = "四条腿"
tail = "长尾巴"
kitty = Cat()
coffee = Cat()
# 给对象添加属性
kitty.name = "凯蒂猫"
kitty.age = 2
kitty.gender = "母"
coffee.name = "加菲猫"
coffee.age = 1
coffee.gender = "公"
# 通过对象访问对象属性：对象名.属性名
print(kitty.name)
print(coffee.name)
# 通过类访问类属性：类名.属性名
print(Cat.leg)
在类里面定义对象属性
"""
定义在类里面的函数叫做方法：
__init__方法：初始化方法，在创建对象的时候，会自动调用执行里面的代码
关于方法中的第一个参数self:self代表的时对象，不用手动传，调用用改方法的时候会自动传
"""
# init方法的作用
class Cat:
leg = "四条腿"
tail = "长尾巴"
def __init__(self, name1, age1, gender1):
"""初始化对象属性"""
self.name = name1
self.age = age1
self.gender = gender1
kitty = Cat("凯蒂猫", 2, "母猫")
print(kitty.name) #这里self就等于kitty
coffee = Cat("加菲猫", 1, "公猫")
print(coffee.name)
# 定义一个学生类
class Students:
attr1 = "学生"
def __init__(self, name, age, class_):
self.name = name
self.age = age
self.class_ = class_
类里面的方法
"""
特征 + 行为
特性:属性(类属性，和实例属性)
行为:方法(类方法，实例方法)，方法的本质就是类里面的函数
实例方法：第一个参数是self，self代表的是对象本身，那个对象调用该方法，self就代表那个对象
实例方法：只能通过对象去调用
类方法：@classmethod进行装饰（标识）
第一个参数是cls,cls代表的是类本身
静态方法：@statictmethod进行装饰（标识）
"""
class Cat:
leg = "四条腿"
tail = "长尾巴"
def __init__(self, name, age, gender):
"""初始化对象属性"""
self.name = name
self.age = age
self.gender = gender
def skill1(self, skill_name):
print("{}施展了抓老鼠的技能：{}".format(self.name, skill_name))
def skill2(self):
print("施展了爬树的技能")
@classmethod
def func(cls):
print(cls)
print("这个是类方法")
@staticmethod
def func2():
print("这个是静态方法")
kitty = Cat("凯蒂猫", 2, "母猫")
coffee = Cat("加菲猫", 1, "公猫")
print(kitty.name)
print(coffee.name)
kitty.skill1("往前扑")
coffee.skill1("从天而降")
关于方法的调用：
实例方法：只能通过对象去调用
Cat.skill2()
类方法：可以通过类和对象去调用
Cat.func()
kitty.func()
静态方法：可以通过类和对象去调用
Cat.func2()
kitty.func2()
属性的访问：
类属性：可以通过类和对象去访问
对象（实例）属性：只有对象自己能用
class Cat:
leg = "四条腿"
tail = "长尾巴"
def __init__(self, name, age, gender):
"""初始化对象属性"""
self.name = name
self.age = age
self.gender = gender
def move(self):
print("快速移动")
def skill2(self):
"""在方法内部，会使用到对象相关的属性，或方法，那么适合定义为对象方法"""
print("{}施展了抓老鼠的技能".format(self.name))
self.move()
@classmethod
def func(cls):
"""在方法内部只会使用到类属性"""
print("这个是猫类共同特征:", cls.leg, cls.tail)
@staticmethod
def func2():
"""方法内部，既不会使用类相关的属性和方法，也不会使用对象相关的属性和方法"""
print("这个是静态方法")
@staticmethod
def func11():
print("这是一个普通的函数")
kitty = Cat("凯蒂猫", 2, "母猫")
----------------------------------------------------------------------------------
01类属性之私有属性
类属性：
公有属性：既可以在类的内部使用，又可以在类外部使用。
私有属性：私有属性，使用双下划线开头。私有属性，只能在类的内部使用，在类外面无法使用。
class MyClass:
# 公有属性
attr = 100
# 私有属性
__attr = 999
02类定义的两种形式
# python3中下面两种类定义没有区别。
# 方式一：不写继承的父类，默认继承object
class MyTest:
pass
# 方式二：在类名的括号后面指定继承object这个类。
class MyClass(object):
pass
# python2中，方式一：的定义形式叫经典类，方式二：的定义形式叫新式类。
03类的继承
object:python中所有类的基类(祖宗类)
关于继承：
子类通过继承父类，能够获取父类中定义的所有属性和方法（私有属性除外）
注意：父类不能使用子类的属性和方法。
# 需求一：V1：大哥大
class PhoneV1(object):
def phone(self):
print("打电话的功能")
# 需求二：V2:功能机
class PhoneV2(PhoneV1):
def music(self):
print("听音乐的功能")
def send_msg(self):
print("发送信息的功能")
class PhoneV3(PhoneV2):
def pay(self):
print("支付功能")
def game(self):
print("玩游戏的功能")
v1 = PhoneV1()
v2 = PhoneV2()
v3 = PhoneV3()
# v1对应的类，
v1.phone()
# v2对应的类
v2.phone()
v2.music()
v2.send_msg()
# v3对应的类
v3.phone()
# v3.music()
# v3.send_msg()
# v3.pay()
# v3.game()
04重写父类方法
调用的时候一级一级往上，同名方法先调用最下面子类中的
# 在子类中定义和父类同名的方法（重写父类方法）
class PhoneV1(object):
def phone(self):
print("打电话的功能")
class PhoneV2(PhoneV1):
def phone(self):
print("功能机打电话的功能")
class PhoneV3(PhoneV2):
def phone(self):
print("智能机打视频电话的功能")
v3 = PhoneV3()
v3.phone()
结果：智能机打视频电话的功能
05调用被重写的父类方法
方式一：父类名.方法名（self）方式二：super().方法名（）
也是根据继承的循序调用父类
class PhoneV1(object):
def phone(self):
print("打语音电话的功能")
class PhoneV3(PhoneV1):
def phone(self):
print("智能机打视频电话的功能")
print("。。。。五分钟过去，，，接下来想打语音电话")
# 如何在这里调用父类里面的phone
# 方式一：父类名.方法名（self）
PhoneV1.phone(self)
# 方式二：super().方法名（）
super().phone()
v3 = PhoneV3()
v3.phone()
06动态设置和获取属性
getattr:获取类属性
参数1：类
参数2：属性名
参数3: 如果属性不存在，则返回该值(默认值)
class TestData:
url = "http://www.baidu.com"
method = "get"
# 在类外面获取类属性
print(TestData.url)
res = getattr(TestData, "url1", "None")
print(res)
# 动态获取属性的含义：
name = input("请输入要获取的属性名:")
res = getattr(TestData, name, "None")
print(res)
类外面定义类属性
方式一：类.属性名= 属性值
方式二：使用setattr
class TestData:
url = "http://www.baidu.com"
method = "get"
# 类外面定义类属性
# 方式一：类.属性名= 属性值
TestData.attr = 100
print(TestData.attr)
# 方式二：使用setattr
# 动态设置属性：setattr
# 参数一：类
# 参数二：属性名
# 参数三：属性值
setattr(TestData,"attr2",999)
print(TestData.attr2)
# 需求：把下面两个列表中的数据设为属性和对应的属性值
title = ["name", "age", "gender"]
data = ["木森", 18, "男"]
for i in range(len(title)):
setattr(TestData, title[i], data[i])
print(TestData.name)
print(TestData.age)
print(TestData.gender)
动态删除属性 delattr
参数一：类
参数二 ：属性名
# 方式一：关键字：del
del TestData.url
print(TestData.url)
#方式二：delattr
name = input("请输入你要删除的属性:")
delattr(TestData,name)
print(TestData.url)
# 扩展：使用del删除变量 a = 100 del a print(a)
结果：NameError: name 'a' is not defined
判断属性是否存在
# 判断属性是否存在：存在返回Ture,不存在返回False
res = hasattr(TestData, "url1")
print(res)
07super的应用场景
class MyCalss:
def __init__(self, a, b):
self.a = a
self.b = b
def number(self):
print("a+b的结果：", self.a + self.b)
class MyClassV2(MyCalss):
def number(self):
super().number()
# 在原方法的基础上扩展的新功能
print("a-b的结果：", self.a - self.b)
print("a/b的结果：", self.a / self.b)
m = MyClassV2(11,22)
m.number()
08多继承
class BaseA(object):
attr_a = 100
def func(self):
print("func---------aaa")
class BaseB(object):
attr_b = 999
def func(self):
print("func---------bbb")
class MyTest(BaseA, BaseB):
def func(self):
print("func---------mytest")
#遇到同名方法，先找自己的，自己没有再BaseA，BaseB的顺序