python学习——类

"""
类定义：
关键字：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的顺序