python对象

python对象

一、基础

1、成员方法

1、使用class关键字定义对象，相当于java中的定义pojo类

class Student:
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None


stu_1 = Student()

stu_1.name = "张三"
stu_1.age = 23
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "浙江"

print(f"{stu_1.name}")
# -----输出结果------------
张三

2、类中的方法

与模块中的函数不同的是，方法的形参必须要写上self关键字，这个关键字代替的是这个类本身，调用时传参可忽略。但是在这个方法中要调用类属性时，需要使用self去调用

class Student:
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None

    def say_hi(self):
        print(f"my name is {self.name}")

    def say_hi2(self, msg):
        # 想要访问类中定义的属性，必须使用self关键字，外部传参可直接调用
        print(f"my name is {self.name},{msg}")

stu = Student()
stu.name = "jj周"
stu.say_hi()

stu2 = Student()
stu2.name = "杰杰"
stu2.say_hi2("哦有")

# -----输出结果------------
my name is jj周
my name is 杰杰,哦有

对象的应用（会发出蜂鸣器的声音）

class Clock:
    id = None
    price = None

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

clock1 = Clock()
clock1.id = "003"
clock1.price = 19
print(f"clock Id={clock1.id}，价格 = {clock1.price}")
clock1.ring()

2、构造方法

2.1 基础

1、构造方法可以使用：__init()__方法

• 在创建类的对象时，会自动执行
• 在创建类的对象时，将传入的参数自动传递给__init()__方法使用

class Student:
    name = None
    age = None
    gender = None

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"构造方法执行，接受的结果：{self.name}，{self.age},{self.gender}")

stu = Student("jj", "23", "man")
#-----输出结果------------
构造方法执行，接受的结果：jj，23,man

2、代码简化：

有了__init()__方法，且形参中定义了属性，那么在类的里面可以不再定义：

class Student:

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"构造方法执行，接受的结果：{self.name}，{self.age},{self.gender}")

stu = Student("jj", "23", "man")

2.2、魔术方法

2.2.1 __str__字符串方法

在print对象时，如果没有字符串方法，那么输出的是内存地址。所以，这个相当于java中的toString方法

class Student:

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"构造方法执行，接受的结果：{self.name}，{self.age},{self.gender}")

    def __str__(self):
        return f"Student类对象，name：{self.name}，age = {self.age}, gender = {self.gender}"

stu = Student("jj", "23", "man")
print(stu)
#-----输出结果------------
构造方法执行，接受的结果：jj，23,man
Student类对象，name：jj，age = 23, gender = man

2.2.2 __lt__小于号方法

在比较两个对象中指定的属性时，可以直接使用符号连接两个对象，这时就默认走__init__方法

至于比较哪个属性，可以自己在__init__方法中写

class Student:

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"构造方法执行，接受的结果：{self.name}，{self.age},{self.gender}")

    def __str__(self):
        return f"Student类对象，name：{self.name}，age = {self.age}, gender = {self.gender}"

    def __lt__(self, other):
        return self.age < other.age

stu1 = Student("小米", "23", "man")
stu2 = Student("大红", "56", "girl")
print(stu1 < stu2)
#-----输出结果------------
构造方法执行，接受的结果：小米，23,man
构造方法执行，接受的结果：大红，56,girl
True

2.2.3 __le__小于等于方法

同__lt__的作用，只是比较方式多了个等于

2.2.4 __eq__等于方法

同__lt__的作用，只是比较方式固定为等于

3、封装

3.1 定义私有成员

私有成员只能被本类使用，在本类之外调用会报错

定义方式：在属性或者方法名前面加双下划线

class Phone:
    __voltage = None

    def __core(self):
        print("单核运行")

phone = Phone()
print(phone.__core)
#-----输出结果------------
AttributeError: 'Phone' object has no attribute '__core'

二、继承

1、单继承

与Java相同，继承了父类，则子类可以使用父类的属性与方法

定义格式：

class 类名(父类名)

使用：

class Iphone12:
    IMEI = None
    producer = "ZJ"

    def call4G(self):
        print(self.producer)
        print("4G通话")

class Iphone13(Iphone12):
    face = "10010"

    def call5G(self):
        print("5G通话")

phone = Iphone13()
phone.call4G()
phone.call5G()
#-----输出结果------------
ZJ
4G通话
5G通话

2、多继承

与java不同，python可以多继承

2.1 pass关键字

pass关键字弥补了语法的不足，例如在定义一个空方法时，语法会报错，这时可以协商pass关键字，即可弥补语法的不足

class MyPhone(Iphone12,NFCReader,RemoteControl):
    pass

2.2 多继承

class Iphone12:
    IMEI = None
    producer = "ZJ"

    def call4G(self):
        print(self.producer)
        print("4G通话")

class NFCReader:
    nfc = "NFC5.0"
    producer = "SH"

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

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

class RemoteControl:
    re_type = "红外遥控"

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

class MyPhone(Iphone12, NFCReader, RemoteControl):
    pass

phone = MyPhone()
phone.read_card()
phone.write_card()
phone.control()
print(phone.producer)
#-----输出结果------------
NFC读卡
NFC写卡
红外遥控开启
ZJ

如果多继承中，父类的属性或者方法名相同，那么按继承的优先级来调用，即调用最左边的父类

上面的例子即调用Iphone12中的属性

3、复写父类成员与调用父类成员

3.1 重写

与java的重写相同

class Iphone12:
    IMEI = None
    producer = "ZJ"

    def call4G(self):
        print("4G通话")

class MyPhone(Iphone12):
    producer = "SH"

    def call4G(self):
        print("复写父类的通话模式")
        
phone = MyPhone()
phone.call4G()
print(phone.producer)
#-----输出结果------------
复写父类的通话模式
SH

3.2 调用父类成员

1、方式一

• 父类名.成员变量
• 父类名.成员方法(self)

2、方式二

• supper().成员变量
• supper().成员方法()

class Iphone12:
    IMEI = None
    producer = "ZJ"

    def call4G(self):
        print("4G通话")

class MyPhone(Iphone12):
    producer = "SH"

    def call4G(self):
        print("复写父类的通话模式")
        # 方式一
        print(f"父类的producer = {Iphone12.producer}")
        Iphone12.call4G(self)
        # 方式二
        print(f"父类的producer = {super().producer}")
        super().call4G()

# 调用父类成员
phone = MyPhone()
phone.call4G()

三、类型注解

在代码中涉及数据交互的地方，提供数据类型的注解（显示的说明），一般在无法直接看出变量类型时会添加类型注解

仅作提示用，仅作为备注。不会影响改变程序的运行

支持：

• 变量类型的注解
• 函数（方法）形参列表和返回值的类型注解

3.1 变量的类型注解

3.1.1 代码中注解

1、基础数据类型注解

var_1: int = 10
var_2: str = "cx"
var_3: bool = True

2、类对象注解

class Student:
    pass

stu: Student = Student()

3、基础容器类型注解

my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"zj": 666}

4、容器类型详细注解

my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, "SH", True)
my_dict: dict[str, int] = {"zj": 666}

3.1.2 注释中注解

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

3.2 函数和方法类型注解

1、对形参注解

def add(x: int, y: int):
    return x + y

2、对返回值注解

def func(data:list) -> list:
    return data

3.3 Union类型注解

当一个变量可以传多个类型时，可以使用Union[类型1,类型2,…]来表示

from typing import Union

my_dict: dict[str, int] = {"age": 11, "num": 3}

my_list: list[Union[int, str]] = [1, 2, "ZJ", "SH"]

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

可以看到在调用时，括号中给出了提示

四、多态

4.1 定义

多态指的时多种状态，即完成某个行为时，使用不同的队形会得到不同的形态

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")


class Cat(Animal):
    def speak(self):
        print("喵喵喵")

def make_noise(animal: Animal):
    animal.speak()

dog = Dog()
cat = Cat()

make_noise(dog)
#-----输出结果------------
汪汪汪

4.2 抽象类（接口）

类中的方法全都为空，子类需要去重写方法，和java中不同的是，python中不需要重写所有的抽象方法

class AC:
    def cool_wind(self):
        pass

    def hot_wind(self):
        pass

    def swing(self):
        pass

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

    def hot_wind(self):
        print("美的炙热")

    def swing(self):
        print("美的摇摆")


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

media = Media_AC()

make_cool(media)
#-----输出结果------------
美的制冷空调

五、案例

原始数据文件

data.txt

2023-06-04,d4s564ds-dsa54d4-da4d5a6-da456,1689,湖南省
2023-06-24,fds424-d57fhd4-dadsa4a6-dsacas6,2356,河北省
2023-02-04,d4s564ds-dsa54d4-da4d5a6-da456,1689,浙江省
2023-03-24,fds424-d57fhd4-dadsa4a6-dsacas6,2357,湖南省

data_define.py

class Record:
    def __init__(self, date, order_id, money, province):
        self.date = date
        self.order_id = order_id
        self.money = money
        self.province = province

file_read.py

from data_define import Record

class FileReader:

    def read_data(self) -> list[Record]:
        pass

class TextFileReader(FileReader):

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

    def read_data(self) -> list[Record]:
        f = open(self.path, "r", encoding="UTF-8")
        record_list = []
        for line in f.readlines():
            line = line.strip()
            data_list = line.split(",")
            record = Record(data_list[0], data_list[1], data_list[2], data_list[3])
            record_list.append(record)
        f.close()
        return record_list

if __name__ == '__main__':
    text_file_read = TextFileReader("F:/study/code/data.txt")

main.py

from file_read import *
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import *

text_file_read = TextFileReader("F:/study/code/data.txt")

jan_data: list[Record] = text_file_read.read_data()

data_dict = {}
for record in jan_data:
    if record.date in data_dict.keys():
        data_dict[record.date] += record.money
    else:
        data_dict[record.date] = record.money

# 可视化图表
bar = Bar()
bar.add_xaxis(list(data_dict.keys()))
bar.add_yaxis("销售额", list(data_dict.values()))
bar.set_global_opts(
    title_opts=TitleOpts(title="每日销售额")
)

bar.render("每日销售额柱状图.html")

输出结果