“类”的各项相关知识

# 设计一个类
class Student():
    name=None
    gender=None
    nationality=None
    native_country=None
    age=None

# 创建一个对象
stu_1 = Student()

# 对象属性进行赋值
stu_1.name="zhangsan"
stu_1.gender="male"
stu_1.nationality="china"
stu_1.native_country="beijing"
stu_1.age=18

# 获取对象中记录的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_country)
print(stu_1.age)

"""
演示面向对象类中的成员方法定义和使用
"""

# 定义一个带有成员方法的类
class Student():
    name=None

    def say_hi(self):
        print(f"大家好啊，我是{self.name},欢迎大家多多关照")


    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")


stu=Student()
stu.name="zhangsan"
stu.say_hi2("啊对对对")

stu2=Student()
stu2.name="wanger"
stu2.say_hi2("好好好")


"""
演示类和对象的关系，即面向对象的编程套路（思想）
"""

# 设计一个闹钟类
class Clock:
    id=None
    price=None


    def ring(self):
        import winsound
        winsound.Beep(2000,3000)

# 构建2个闹钟对象并让其工作
clock1=Clock()
clock1.id="003032"
clock1.price=19.99
print(f"闹钟ID={clock1.id}，价格price={clock1}")
clock1.ring()

clock2=Clock()
clock2.id="003033"
clock2.price=29.99
print(f"闹钟ID={clock2.id}，价格price={clock2}")
clock2.ring()

"""
演示类的构造方法
"""

# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称： __init__

class Student():
    name=None    # 可以省略
    age=None     # 可以省略
    tel=None     # 可以省略


    def __init__(self,name,age,tel):
        self.name=name
        self.age=age
        self.tel=tel
        print("Student类创建了一个类对象")


stu=Student("周杰伦",31,"18500006666")
print(stu.name)
print(stu.age)
print(stu.tel)


"""
演示python内置的各类魔术方法
"""

class Student:
    def __init__(self, name, age):
        self.name = name  # 学生姓名
        self.age = age    # 学生年龄


    # __str__魔术方法
    def __str__(self):
        return f'{self.name} is {self.age} years'

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age

    # __eq__魔术方法
    def __eq__(self, other):
        return self.age == other.age


stu1=Student("张三",36)
stu2=Student("王二",36)
print(stu1==stu2)
print(stu1==stu2)


"""
演示面向对象封装思想中私有成员的使用
"""

# 定义一个类，内含私有成员变量和私有成员方法
class Phone:

    __current_voltage=0.5   # 当前手机运行电压

    def __keep_single_core(self):
        print("让CPU以单核模式运行")


    def call_by_5G(self):
        if self.__current_voltage  >=1:
            print("5g通话已经开启")

        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核省电状态")


phone=Phone()
phone.call_by_5G()


"""
封装特性课后练习题
设计带有私有成员的手机
"""

# 设计一个类，用来描述手机
class Phone:
    # 提供私有成员变量：__is_5g_enable
    __is_5g_enable = True   # 5g状态


    # 提供私有成员方法：__check_5g()
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")

    # 提供公开成员方法： call_by_5g()
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")


phone = Phone()
phone.call_by_5g()


"""
演示面向对象：继承的基础语法
"""

# 演示单继承
class Phone:
    IMEI=True       # 序列号
    producer="ITCAST"   # 厂商


    def call_by_4g(self):
        print("4g通话")


class Phone2022(Phone):
    face_id="10001"


    def call_by_5g(self):
        print("2022年新功能，5g通话")

phone=Phone2022()
phone.call_by_4g()
print(phone.producer)


# 演示多继承
# 演示多继承下，父类成员名一致的场景
class NFCReader:
    nfc_type="第五代"
    producer = "HM"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")


class RemoteControl:
    rc_type="红外遥控"

    def control(self):
        print("红外遥控开启了")

class MyPhone(Phone,NFCReader,RemoteControl):
    pass


phone=MyPhone()
phone.call_by_4g()
phone.control()
phone.write_card()
phone.read_card()

print(phone.producer)


"""
演示变量的类型注解
"""
import random

# 基础数据类型注解
var_1:int=10
var_2:str="itheima"
var_3:bool=False

# 类对象类型注解
class Student:
    pass
stu:Student=Student()

# 基础容器类型注解
my_list:list=[1,2,3,4,5]
my_tuple:tuple=(1,2,3,4,5)
my_dict:dict={"itheima":666}

# 容器类型详细注解
my_list:list[int]=[1,2,3,4,5]
my_tuple:tuple[int,str,bool]=(1,"itheima",True)
my_dict:dict[str,int]={"itheima":666}

# 在注释中进行类型注解
var_1=random.randint(1,10)     # type:int
var_2=json.loads('{"name":"zhangsan"}')   # type:dict[str,str]
def func():
    return 10
var_3=func()   #type:int

# 类型注解的限制
var_4:int="itheima"    # 注释只是注释，就算是写错了也不会影响程序运行
var_5:str=123


"""
演示对函数（方法）进行类型注解
"""

# 对形参进行类型注解
def add(x:int,y:int):
    return x+y

# 对返回值进行类型注解
def func(data:list)->list:
    return data

print(func(1))   # 注解只是注解，只是提示性而非决定性，就算是写错了也不会影响程序运行

"""
演示Union联合类型注解
"""
# 使用Union类型必须先导包
from typing import Union

my_list:list[Union[int,str]] = [1,2,"itheima","itcast"]

def func(data:Union[int,str])->Union[int,str]:
    pass

func()

"""
演示抽象类

"""
class AC:
    def cool_wind(self):
        """制冷"""
        pass

    def hot_wind(self):
        """制热"""
        pass

    def swing_l_r(self):
        """左右摆风"""
        pass


class MEIDI_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")



class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")


def make_cool(ac:AC):
    ac.cool_wind()


meidi_ac=MEIDI_AC()
gree_ac=GREE_AC()

make_cool(meidi_ac)
make_cool(gree_ac)