422主要学习面向对象

'''
对象 objec
类class


class 类名：     类名首字母一定要大写 大驼峰方法！
    代码

'''


# 定义一个人的类
class People(object):
    # 类的内部 包括：属性，方法
    def eat(self):
        print(self)
        print('人吃东西')

    def drink(self):
        print('喝可乐')


# 实例化Perple类，生成实例化对象
# 对象名 = 类名()
P1 = People()

print(P1)
P1.eat()
P1.drink()

# 一个类可以创建不同的对象，但是地址不同 存储内容不同
P2 = People()
print(P2)

'''
self 打印self看一下,返回了内存地址，和对象P1的内存地址一样 

'''
# 类的外部调用属性  定义访问
P1.name = '露娜'
P1.age = '19'
P1.id = '刺客'

print(P1.name)
print(P1.age)
print(P1.id)


# 在类的内部调用对象的属性
class Monkey(object):
    # 定义一个方法 show_info打印对象自身属性
    def __init__(self):
        self.name = None
        self.skill = None

    def show_info(self):
        print(f'我的名字{self.name}、技能{self.skill}')


swk = Monkey()
swk.name = '孙悟空'
swk.skill = '筋斗云'
swk.show_info()

print('-' * 40)

'''
魔术方法
__init__() :初始化方法或构造方法

'''


class Person(object):

    def __init__(self, name, age):
        # self代表实例化对象，self.name 代表为对象添加一个name属性
        self.name = name
        self.age = age

    # 定义一个 __del__()魔术方法，当对象被删除或者销毁时，__def__方法会被自动调用
    def __del__(self):
        print('当对象被删除自动调用')


P3 = Person('露娜', 19)
print(P3.age)
print(P3.name)

del P3  # 自动调用，不需要再操作

'''
__str__()当print对象时，__str__()魔术方法会自动触发

'''
class Person(object):

    def __init__(self, name, age):
        # self代表实例化对象，self.name 代表为对象添加一个name属性
        self.name = name
        self.age = age

    # 定义一个 __del__()魔术方法，当对象被删除或者销毁时，__def__方法会被自动调用
    def __del__(self):
        print('当对象被删除自动调用')

    def __str__(self):

        # 要求，必须有return返回值，返回一个字符串
        # 应用场景：用于输出对象信息
        return f'姓名{self.name},年龄{self.age}'

P4 = Person('艾琳',"17")
print(P4)
del P4

'''
面向对象综合案例
'''
class Student(object):

    def __init__(self,name,score):
        self.name = name
        self.score = score

    def print_grade(self):
        if self.score >= 90:
            print(f'{self.name}成绩：{self.score}等级为优秀')
        elif self.score >=80:
            print(f'{self.name}成绩：{self.score}等级为良好')

        elif self.score >=70:
            print(f'{self.name}成绩：{self.score}等级为中等')
        elif self.score >=60:
            print(f'{self.name}成绩：{self.score}等级为及格')
        else:
            print(f'{self.name}成绩：{self.score}等级为不及格')

S1 = Student('张三',47)
# S1.print_grade()

class Person2(object):
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -=0.5

    def eat(self):
        self.weight +=1

    def __str__(self):
        return f'{self.name}当前体重{self.weight}'

P6 =Person2('小明',70.0)
P6.run()  #调用run
# print(P6)

'''
面向对象的三大基本特性：封装性，继承性，多态性


'''
# 私有属性
# class Girl(object):
#     # __age私有属性 name公有属性
#     def __init__(self,name):
#         self.name = name
#         self.__age = 18

# xm=Girl('小咩')
# print(xm.name)


# 私有属性 角色验证只针对特定用户
'''
管理员：root
普通用户：itheima
def get_salary(self):
    私有属性 
'''

print('-' * 40)

class Girl(object):
    # __age私有属性 name公有属性
    def __init__(self,name):
        self.name = name
        self.__age = 18

    #
    def set_age(self):
        # 使用函数前必须进行验证
        self.__age +=1

    # 对私有属性进行获取
    def get_age(self):
        # 使用函数前必须进行验证
        print(self.__age)

xm =Girl('小咩')
xm.set_age()
xm.get_age()

'''
银行取钱 ATM操作
1.插卡
2.用户验证
3.输入取款金额
4.取款
5.打印输出账号

'''
class ATM(object):

    def __init__(self):
        pass

    def __func1(self):
        print('插卡')

    def __func2(self):
        print('用户验证')

    def __func3(self):
        print('输入取款金额')

    def __func4(self):
        print('取款')

    def __func5(self):
        print('输出账单')

    # 定义一个公共方法，专门用于实现整个操作
    def withdrow(self):

        self.__func1()
        self.__func2()
        self.__func3()
        self.__func4()
        self.__func5()


atm = ATM()
atm.withdrow()

print('-' * 40)
'''
python的继承特性与单继承
object --> class B(object) -->class A(B) 自动拥有B中所有的公共属性和方法，私有属性和方法不支持继承
'''
# 单继承
class Car():
    def run(self):
        print('i can run')


class TeslCar(Car):
    pass

tesla = TeslCar()
tesla.run()


# 继承传递性 和多层继承

'''
多继承
class B():
    pass
    
class C():
    pass
    
class A(B,C):
    pass   
'''
class GasolineCar(object):
    def run_with_gasoline(self):
        print('i can run with gasoline')

class EletricCar(object):
    def run_with_eletric(self):
        print('i can run with eletric')

class HybridCar(GasolineCar,EletricCar):
    pass

bmw = HybridCar()
bmw.run_with_eletric()
bmw.run_with_gasoline()

print('-------------------------------------------')
'''
子类继承
扩展特性：继承让子类继承父类的所有公共属性和方法，
但是如果仅仅是为了继承公共属性和方法，继承就没有实际的意义了，
应该是在继承以后，子类应该有一些自己的属性和方法。

'''

class Animal(object):
    def eat(self):
        print('i can eat')

    def call(self):
        print('i can call')

# 定义子类
class Cat(Animal):
    # 重写 父类中的call
    def call(self):
        print('i can miao miao')
class Dog(Animal):
    def call(self):    # 覆盖操作 子类重写
        print('i can wangwang')

cat = Cat()
cat.eat()
cat.call()
dog = Dog()
dog.call()

print('----------------------------------')

'''
强制继承父类中的同名属性及方法

'''

class Car2(object):

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

    def run(self):
        print('i can run')

class Gasolinecar(Car2):
    pass

class EletricCar(Car2):

    # 定义一个魔术方法
    def __init__(self, brand, color, model,battery):
        # 强制调用父类中的__init__反初始化方法，用于实现对brand, color, model)属性初始化
        super().__init__(brand, color, model)
        self.battery = battery

    def run(self):
        print('i can run with eletric')

teala = EletricCar('Tesla','red','Model S',70)
print(teala.color)
print(teala.model)

print('-------------------------------')

# 实例属性 （对象属性）
'''
class Person(object):
    # 定义类属性
    count = 0
    def __init__(self, name, age):
        self.name = name
        self.age = age

        
p1 = Person('Tom', 23)
p2 = Person('Harry', 26)
'''

# 类属性
'''
class Person(object):
    # 定义类属性count
    count = 0

    # 定义一个__init__魔术方法，用于进行初始化操作
    def __init__(self, name):
        self.name = name
        # 对count类属性进行+1操作，用于记录这个Person类一共生成了多少个对象
        Person.count += 1

# 1、实例化对象p1
p1 = Person('Tom')
p2 = Person('Harry')
p3 = Person('Jennifer')
# 2、在类外部输出类属性
print(f'我们共使用Person类生成了{Person.count}个实例对象')

'''


class Tool(object):
    # 定义一个类属性count
    count = 0

    # 定义一个__init__初始化方法
    def __init__(self, name):
        self.name = name
        Tool.count += 1

    # 封装一个类方法：专门实现对Tool.count类属性进行操作
    @classmethod
    def get_count(cls):
        print(f'我们使用Tool类共实例化了{cls.count}个工具')


t1 = Tool('斧头')
t2 = Tool('榔头')
t3 = Tool('铁锹')

Tool.get_count()

'''
静态方法

在开发时，如果需要在类中封装一个方法，这个方法：  

==① 既 不需要访问实例属性或者调用实例方法==

==② 也 不需要访问类属性或者调用类方法==

这个时候，可以把这个方法封装成一个静态方法
'''


class Game(object):
    # 开始游戏，打印游戏功能菜单
    @staticmethod
    def menu():
        print('1、开始游戏')
        print('2、游戏暂停')
        print('3、退出游戏')


# 开始游戏、打印菜单
Game.menu()

print('**************************************')

class Game(object):
    # 1、定义类属性top_score
    top_score = 0

    # 2、定义初始化方法__init__
    def __init__(self, player_name):
        self.player_name = player_name

    # 3、定义静态方法，用于输出帮助信息
    @staticmethod
    def show_help():
        print('游戏帮助信息')

    # 4、定义类方法
    @classmethod
    def show_top_score(cls):
        print(f'本游戏历史最高分：{cls.top_score}')

    # 5、定义实例方法，start_game()
    def start_game(self):
        print(f'{self.player_name}，游戏开始了，你准备好了么？')


# 实例化类生成实例对象
mario = Game('itheima')
mario.start_game()

# 显示历史最高分
Game.show_top_score()

# 弹出游戏帮助信息
Game.show_help()