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")
输出结果