Python基础知识（类）

# 面向过程
def demo(x, y):
    if x > y:
        print(x)
        return x
    elif x < y:
        print(y)
        return y
    else:
        print(x + y)
        return x + y

demo(12, 12)


>>24

# 面向对象
class Cat(object):  # 定义一个猫类
    print(‘喵喵！‘)

    def hobby(self):  # 实例方法，第1技能
        print("我喜欢吃鱼！")

    def color(self):  # 实例方法，第2技能
        print("我是灰色的！")


jiafei = Cat()  # 实例化对象，实例化后才能调用方法。注意：给这个类取名叫加菲，这一类猫叫加菲猫，不是指具体某一只。
jiafei.hobby()  # 让豆豆类使用猫的1技能


>>喵喵！
>>我喜欢吃鱼！

# 示例语法：
class Name():      # ”类名“通常首字母大写，为了区分”函数名“
    name = "变量"  # 刻画类的通用特征

    def ff_name(self,):      # 描述类的行为
        pass

class Men(object):  # object是最大的类
    gender = "male"  # 刻画类的通用特征

    def strong(self,name):  # self名称是约定成俗的，指向类的实例化的对象本身
        print(name,"可以干重活！")  # 功能1（描述类的行为）

    def job(self,name):            # 设置name参数，可用于区分多个对象的识别
        print(name,"工作很努力！")


zg_man = Men()  # 实例化对象，实例化后可调用类的方法。zg_man定义为中国男人这一类。
zg_man.strong("Ttan")  # 实例方法，给这个人取名叫“泰坦”，让他调用1技能
zg_man.job("猪八戒")   # “猪八戒”，让他调用2技能


>>Ttan 可以干重活！
>>猪八戒 工作很努力！　

# 面向对象中的属性与方法：
# 【魔术方法（初始化方法）、类方法（@classmethod）、静态方法（@staticmethod）、实例方法（普通方法）】
#  1）魔术方法：以“__”双下划线包起来的方法，都统称为“Magic Method”（魔术方法）,例如类的初始化方法 __init__。无需调用，自动触发。
#  2）类方法：用@classmethod装饰，默认参数【cls】。作为类的补充附加内容,可以使用实例对象/类名调用。类方法中只能使用类属性。
#  3）静态方法：用@staticmethod装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以使用实例对象/类名调用。
#  4）实例方法：即普通方法。第一个参数必须是实例本身，一般使用【self】表示，实例方法只能通过实例对象去调用。
class Men(object):
    gender = "男"                # 类属性，公共属性该类中的所有对象均可共享
    height = 170

    # 1）魔术方法（初始化方法）---相当于设置默认值，程序启动即执行的方法
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("1）魔术方法 -----大家好！------")

    # 2）类方法，用装饰器 @classmethod---通过cls增加类变量的值，修改类变量属性
    @classmethod
    def modify_height(cls, height_add):
        cls.height += height_add
        print("2)类方法 你已经成功增加了平均高度" + str(height_add))

    # 3）静态方法，用装饰器@staticmethod
    @staticmethod
    def character():
        print("3)静态方法 他喜欢做一些对国家有意义的事情！")

    # 4）实例方法（普通方法）
    def talk(self):
        self.name = "爆炸头"        # 实例属性

        print(f"4)实例方法 {self.name}说话像个孩子！身高为{self.height}")

    def sleep(self, style_sl):
        print("4)实例方法 {}中午在{}睡觉！".format(self.name, style_sl))


gd_man = Men("大头", 18)          # 类的实例化,实参要传递初始化方法所有参数

print(gd_man.__dict__)           # 显示对象的属性值

# Men.modify_height(0.05)         # 实例对象和类均可调用类方法
gd_man.modify_height(0.5)         # 实例对象，调用 2)类方法
gd_man.character()                # 实例对象，调用 3)静态方法

gd_man.talk()                     # 实例对象，调用 4)实例方法中的talk方法
gd_man.sleep("趴在桌子上")        # 实例对象，调用 4)实例方法中的sleep方法


>>1）魔术方法 -----大家好！------
>>{‘name‘: ‘大头‘, ‘age‘: 18}
>>2)类方法 你已经成功增加了平均高度0.5
>>3)静态方法 他喜欢做一些对国家有意义的事情！
>>4)实例方法 爆炸头说话像个孩子！身高为170.5
>>4)实例方法 爆炸头中午在趴在桌子上睡觉！

# 1）类的封装
class Card(object):

    def __init__(self, num, pwd, ban):

        self.num = num
        self.pwd = pwd
        self.__ban = ban  # 余额，在属性前加两个下划线"__"，变成私有属性（只能在类的内部被访问）

    def __cun(self):  # 私有方法，加两个下划线"__"

        print("存款")

    # 设置拿到余额的条件
    def getBan(self, numm, pwdd):
        if numm == self.num and pwdd == self.pwd:
            return self.__ban
        else:
            return "输入错误"

card = Card("1001", "123456", 1000)  # 开卡

# print(card.getBan("1001","123456"))  #通过验证,拿到属性，只有防止出错
print(card._Card__ban)  # 也可以通过这种方法，直接拿到私有属性
# 一个下划线拿到Card，两个下划线拿到ban


>>1000

# 2-1）类的继承（单继承）---1个子类继承1个父类
class Animal(object):
    def __init__(self,name):
        self.name=name
    def eat(self):
        print("吃东西")

class People(Animal):     # Animal继承object,People继承Animal
    def talk(self):
        print(‘say hello‘)

xiaoming=People("小明")
xiaoming.eat()


>>吃东西

# 2-2）类的继承（多继承）---1个子类继承多个父类
# A,B继承object；C分别继承A,B（新式类继承，广度优先）
class A(object):
    def text(self):
        print("AAA")

class B(object):
    def text(self):
        print("BBB")

class C(A,B):
        print("打印试试！")

eee=C()
eee.text()
print(C.__bases__)
# 内置的__bases__属性,通过该属性可以查看该类的所有“直接父类”，该属性返回所有直接父类组成的元组。


>>打印试试！
>>AAA
>>(<class ‘__main__.A‘>, <class ‘__main__.B‘>)

# 2-3）类的继承（多继承）---多个子类继承1个父类
class Animal(object):        # Animal继承object类

    def __init__(self, color):
        self.color = color

    def eat(self):
        print("动物在吃")

    def run(self):
        print("动物在跑")

class Cat(Animal):          # Cat类继承Animal类  
    pass

class Dog(Animal):          # Dog类继承Animal类  

    def __init__(self, name, age, color):
        self.name = name
        self.age = age
        super(Dog, self).__init__(color)  # 调用父类的初始化方法

    def eat(self):
        print("狗在啃骨头")

dog = Dog("小黑", 10, "红色")  # 实例化的时候，优先调用子类的方法。
dog.eat()
print(dog.color)

# print(cat.color)
# cat.eat()


>>狗在啃骨头
>>红色

# 3）类的多态
class Animal(object): #同一类事物:动物
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人,继承Animal的talk方法
    def talk(self):
        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗，继承Animal的talk方法
    def talk(self):
        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猪，继承Animal的talk方法
    def talk(self):
        print(‘say aoao‘)

xiaomin=People()
xiaomin.talk()
xiaohuang=Dog()
xiaohuang.talk()
xiaobai=Pig()
xiaobai.talk()


>>say hello
>>say wangwang
>>say aoao

# 补充内容：类的继承（super关键字调用父类的方法）
# super 不仅可以调用父类构造函数，也可调用父类实例方法；
# super 可以解决父类名称频繁变化的问题
class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(‘我要睡觉了！‘)

class People(Animal):  # 修改继承父类名称
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # Animal.__init__(self,name,age)
        super(People, self).__init__(name, age)
        # 该行代码并没有出现任何“父类”的名称，如果父类名称频繁变化，只需修改继承的父类名称即可

    def talk(self):
        print(‘say hello‘)
        super(People, self).sleep()  # 调用父类的方法

xiaoming = People("小明", 20)
xiaoming.sleep()


>>我要睡觉了！