丙午🐎年

class Dog:
    species = "Canis familiaris"    # 类属性（所有狗都是这个物种）
    
    def __init__(self, name, age):  # 初始化函数
        self.name = name            # 实例属性
        self.age = age              # 实例属性

# 使用
print(Dog.species)          # Canis familiaris（类访问类属性）
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)
print(dog1.name)            # Buddy（实例访问实例属性）
print(dog2.name)            # Max
print(dog1.species)         # Canis familiaris（实例可访问类属性）

# 修改类属性影响所有实例
Dog.species = "Canis lupus"
print(dog1.species)         # Canis lupus
print(dog2.species)         # Canis lupus

from datetime import date

class Dog:
    species = "Canis familiaris"
    count = 0                       # 统计实例个数
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Dog.count += 1              # 修改类属性
    
    # 实例方法
    def bark(self):
        return f"{self.name} says: 汪汪!"
    
    def get_info(self):
        return f"{self.name} is {self.age} years old"
    
    # 类方法
    @classmethod
    def get_species(cls):
        return cls.species
    
    @classmethod
    def from_birth_year(cls, name, birth_year):  # 替代构造器
        age = date.today().year - birth_year
        return cls(name, age)
    
    # 静态方法
    @staticmethod
    def is_dog_year(age):           # 狗龄转人类年龄
        return age * 7
    
    @staticmethod
    def check_adult(age):
        return age >= 3

# 使用
dog = Dog("Buddy", 3)
print(dog.bark())                   # Buddy says: 汪汪!
print(dog.get_info())               # Buddy is 3 years old

print(Dog.get_species())            # Canis familiaris（类方法）
print(dog.get_species())            # 也可实例调用

# 类方法创建对象
dog2 = Dog.from_birth_year("Max", 2020)  # 自动算年龄

# 静态方法（不需要实例）
print(Dog.is_dog_year(3))           # 21
print(Dog.check_adult(5))           # True
print(Dog.count)                    # 2（创建了两个实例）

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self._bank_code = "ICBC001"         # 单下划线：约定私有
        self.__balance = balance             # 双下划线：名称修饰保护
    
    # 私有方法（双下划线）
    def __validate(self, amount):
        return amount > 0
    
    # 对外接口：安全存取
    def deposit(self, amount):
        if self.__validate(amount):
            self.__balance += amount
            return True
        return False
    
    def withdraw(self, amount):
        if self.__validate(amount) and amount <= self.__balance:
            self.__balance -= amount
            return True
        return False
    
    # @property 让方法像属性一样访问
    @property
    def balance(self):                      # getter
        return self.__balance
    
    @balance.setter
    def balance(self, value):               # setter（控制写入）
        raise AttributeError("不能直接修改余额，请使用 deposit/withdraw")

# 使用
acc = BankAccount("Tom", 1000)

# 访问"属性"（实际调用方法）
print(acc.balance)          # 1000（看起来像属性，实则是 @property）

# 试图直接修改
# acc.balance = 2000        # AttributeError: 不能直接修改余额

# 必须通过接口操作
acc.deposit(500)
print(acc.balance)          # 1500

# 双下划线"伪私有"（实际可绕过，但不建议）
print(acc._BankAccount__balance)  # 1500（名称修饰后的真名）

# 单下划线只是约定
print(acc._bank_code)       # ICBC001（完全可访问，但别这么干）

class Animal:                           # 父类
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):                    # 父类方法（占位）
        raise NotImplementedError("子类必须实现")
    
    def info(self):
        return f"{self.name}, {self.age}岁"

class Dog(Animal):                      # 子类继承 Animal
    def __init__(self, name, age, breed):
        super().__init__(name, age)     # 调用父类构造
        self.breed = breed              # 新增属性
    
    def speak(self):                    # 重写父类方法
        return f"{self.name}: 汪汪!"
    
    def fetch(self):                    # 子类特有方法
        return f"{self.name} 去捡球了"

class Cat(Animal):                      # 另一个子类
    def speak(self):
        return f"{self.name}: 喵喵!"

# 使用
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Kitty", 2)

print(dog.info())           # Buddy, 3岁（继承父类方法）
print(dog.speak())          # Buddy: 汪汪!（重写）
print(dog.fetch())          # Buddy 去捡球了（子类特有）

print(cat.speak())          # Kitty: 喵喵!（各自重写）

# 多态：同一接口，不同表现
animals = [dog, cat]
for a in animals:
    print(a.speak())        # 自动调用各自版本

class Flyable:
    def fly(self):
        return "会飞"

class Swimmable:
    def swim(self):
        return "会游泳"

class Duck(Animal, Flyable, Swimmable):   # 继承多个类
    def speak(self):
        return "嘎嘎!"

donald = Duck("Donald", 5)
print(donald.fly())         # 会飞
print(donald.swim())        # 会游泳

class Dog:
    def speak(self):
        return "汪汪!"

class Cat:
    def speak(self):
        return "喵喵!"

class Duck:
    def speak(self):
        return "嘎嘎!"

# 多态函数：不判断类型，只调 speak()
def animal_concert(animals):
    for animal in animals:
        print(animal.speak())   # 各自发出不同声音

# 使用
zoo = [Dog(), Cat(), Duck()]
animal_concert(zoo)
# 汪汪!
# 喵喵!
# 嘎嘎!

from abc import ABC, abstractmethod

class Animal(ABC):              # 抽象基类
    @abstractmethod
    def speak(self):            # 子类必须实现
        pass
    
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def speak(self):            # 必须实现
        return "汪汪!"
    
    def move(self):             # 必须实现
        return "四条腿跑"

# animal = Animal()            # 报错：不能实例化抽象类
dog = Dog()                     # 必须实现所有抽象方法才能实例化

from datetime import date
from abc import ABC, abstractmethod

# 抽象基类
class Employee(ABC):
    __count = 0                 # 类属性：私有，统计员工数
    
    def __init__(self, name, hire_year):
        self.name = name
        self._hire_year = hire_year
        Employee.__count += 1
    
    @property
    def years_of_service(self):
        return date.today().year - self._hire_year
    
    @abstractmethod
    def calculate_salary(self): # 抽象方法：子类必须实现
        pass
    
    @classmethod
    def get_employee_count(cls):
        return cls.__count
    
    def __str__(self):          # 重写，友好打印
        return f"{self.name}（{self.years_of_service}年工龄）"

# 子类：正式员工
class FullTimeEmployee(Employee):
    def __init__(self, name, hire_year, base_salary, bonus_rate):
        super().__init__(name, hire_year)
        self.__base = base_salary           # 私有
        self.__bonus_rate = bonus_rate
    
    @property
    def base_salary(self):                  # 受控访问
        return self.__base
    
    @base_salary.setter
    def base_salary(self, value):
        if value > 0:
            self.__base = value
    
    def calculate_salary(self):             # 实现抽象方法
        return self.__base * (1 + self.__bonus_rate)

# 子类：合同工
class ContractEmployee(Employee):
    def __init__(self, name, hire_year, hourly_rate, hours):
        super().__init__(name, hire_year)
        self.hourly_rate = hourly_rate
        self.hours = hours
    
    def calculate_salary(self):
        return self.hourly_rate * self.hours

# 使用
emp1 = FullTimeEmployee("张三", 2018, 10000, 0.2)
emp2 = ContractEmployee("李四", 2020, 100, 160)

print(Employee.get_employee_count())    # 2

employees = [emp1, emp2]
for e in employees:
    print(f"{e}: {e.calculate_salary():.2f}元")
# 张三（7年工龄）: 12000.00元
# 李四（5年工龄）: 16000.00元

def func(a):
    s = 0
    while(a >0 ):
        rest = a % 10
        s = s + rest * rest
        a = a // 10
    return s

def main():
    inputStr = input()
    try:
        integer = eval(inputStr)
    except:
        print(False)
    else:
        i = 0
        while( i < 1000 and integer != 1):
            integer = func(integer)
            i += 1
        if i < 1000 and integer == 1:
            print(True)
        else:
            print(False)

main()