首页 > 其他分享 >第六章-类与对象

第六章-类与对象

时间：2024-09-09 12:52:37浏览次数：10  
标签：__ 对象 self print 第六章 5g id def

class 类名称:

        类的属性（定义在类中的成员变量）

        类的行为（定义在类中的函数，也就是成员方法）

举例：

class Student:
    name = None
    place = None
    age = None
    def say_hi(self):
        print(f"你好，我是{self.name}")

stu1 = Student()
stu1.name = "方靓仔"
stu1.place = "山东省"
stu1.age = 23

print(stu1.age)
stu1.say_hi()

其中，self关键字是成员方法定义的时候必须填写的，用来表示类对象自身。

上面这个代码中的say_hi方法又称为成员方法

类和对象

例子：

假如闹钟有两个属性，id和price和一个行为：响铃ring

import winsound
# 设计一个闹钟类
class clock:
    id = None
    price = None
    def ring(self):
        winsound.Beep(500,500)

# 构造两个闹钟，并让他们工作
clock1 = clock()
clock1.id = "6501"
clock1.price = 20
print(f"闹钟ID:{clock1.id}")
clock1.ring()

clock2 = clock()
clock2.id = "6502"
clock2.price = 22
print(f"闹钟ID:{clock2.id}")
clock2.ring()

魔术方法

Python类内置方法被称为魔术方法

__init__构造方法
__str__字符串方法（类对象转换为字符串）
__lt__小于、大于符号比较

__le__

小于等于、大于等于符号比较
__eq__等于==符号比较

__init__方法

__init__方法是构造方法，创建类对象或构造类时自动执行，同时传入参数自动传递给__init__方法。需要注意的是包括__init__方法在内的几个魔术方法前面和后面都有两条下划线。

class Student:
    def __init__(self, name, id):
        self.name = name
        self.id = id
        print("Student类创建了一个对象")
stu = Student("睿智阿杰", 356)
print(stu.name, stu.id)
# python类内置的方法称为魔术方法
# init构造方法 str字符串方法(类对象转字符串) lt小于、大于符号比较 le小于等于、大于等于符号比较 eq等于符号比较
class student:
    def __init__(self,name,id):
        self.name=name
        self.id=id
    def __str__(self):
        return f'student类对象，name={self.name}，id={self.id}'
    def __lt__(self,other):
        return self.id < other.id
    def __le__(self,other):
        return self.id <= other.id
    def __eq__(self,other):
        return self.id == other.id
stu1 = student("睿智杰",356)
stu2 = student("帅哥方",360)
stu3 = student("陈小明",360)
print(stu1)
print(str(stu2))
print('stu1 > stu2',stu1 > stu2)
print('stu1 < stu2',stu1 < stu2)
print('stu3 > stu2',stu3 > stu2)
print('stu3 >= stu2',stu3 >= stu2)
print('stu1 <= stu2',stu1 <= stu2)
print('stu3 == stu2',stu3 == stu2)
print('stu1 == stu2',stu1 == stu2)

☆封装

在实际开发中，不是每一个属性和行为都是公开的，所以使用私有成员来隐藏他们。

私有成员变量的变量名，私有成员方法的方法名都以__开头（两条下划线）。

私有成员无法被类对象使用，但是可以被其他的成员使用。

class Phone:
    __current_voltage = 0.6 # 手机运行电压
    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通话，已设置为单核模式省电")
"""
test_phone = Phone()
print(test_phone.__keep_single_core())
# 无法运行
"""

# 私有成员无法被类对象使用，但是可以被其他的成员使用
phone = Phone()
phone.call_by_5g()

例题

设计带有私有成员的手机
设计一个手机类，内部包含:
私有成员变量: __is_5g_enable，类型bool，True表示开启5g，False表示关闭5g

私有成员方法:__check 5g()，会判断私有成员__is_5g_enable的值

        若为True，打印输出:5g开启
        若为False，打印输出:5g关闭，使用4g网络
公开成员方法:call_by_5g()，调用它会执行
        调用私有成员方法:__check_5g()，判断5g网络状态
        打印输出:正在通话中
运行结果:

                5g关闭，使用4g

                网络正在通话中
通过完成这个类的设计和使用，体会封装中私有成员的作用
对用户公开的，call_by_5g()方法
对用户隐藏的，__is_5g_enable私有变量和__check_5g私有成员

我的作答

class phone:
    __is_5g_enable = False
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")
mobile = phone()
mobile.call_by_5g()

☆继承

继承可以理解为每次设计新手机都可以基于老设计图修改，而非从0开始

单继承

单继承只继承一个父类，直接将父类写在括号里

继承将会从父类那里复制粘贴来成员变量和成员方法，但是不含私有成员变量和私有成员方法。

class phone2022:
    id = 369
    producer = '啊哈'
    def call_by_4g(self):
        print("可以4G通话")
class phone2023(phone2022):
    face_id = 567
    def call_by_5g(self):
        print("可以5g通话")
phone = phone2023()
print(phone.id, phone.face_id)
phone.call_by_4g()
phone.call_by_5g()

多继承

多继承可以继承多个父类，将父类与父类在括号中用逗号隔开。

当然，成员方法如果重名，按照继承的顺序，越往左优先级越高。

（代码接上条）

class RemoteControl:
    id = 503
    def control(self):
        print("红外遥控开启了")
# pass用于补充语法
class MyPhone(RemoteControl,phone2023):
    pass
# pass表示无内容，空的意思
phone = MyPhone()
phone.control()
print(phone.id)

复写

子类中重新定义同名的属性或方法

class Phone:
    id = 2
    def call(self):
        print("父类的通话")
class MyPhone(Phone):
    id = 16
    def call(self):
        print("子类的通话")
mobile = MyPhone()
mobile.call()

调用

调用父类成员变量super().成员变量父类名.成员变量
调用父类成员方法super.成员方法()父类名.成员方法(self)
class MyNewPhone(Phone):
    id = 17
    def call(self):
        print(f"父类的编号{Phone.id}")
        Phone.call(self)
    def call2(self):
        print(f"父类编号{super().id}")
        super().call()
newphone = MyNewPhone()
newphone.call()
newphone.call2()

类型注解

传参时快捷键ctrl+p可以弹出提示

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

显示的变量定义一般无需注解，即能一眼看出来就不用类型注解了

基础语法

变量：类型

import json
import random
# 基础数据类型注解
var1: int = 35
var2: str = 'fang'
var3: bool = True
# 类对象类型注解
class Student:
    pass
stu: Student = Student()
# 基础容器类型注解
mylist1: list = [1, 2, 3]
mytuple1: tuple = (1, 2, 3)
mydict1: dict = {'a': 1, 'b': 2, 'c': 3}
# 容器类型详细注解
mylist2: list[int] = [1, 2, 3]
mytuple2: tuple[int, str, bool] = (1, 'f', True)
mydict2: dict[str, int] = {'a': 1, 'b': 2, 'c': 3}
# 在注释中进行类型注解
var4 = random.randint(1, 10)    # type: int
var5 = json.loads('{"name":"zhangsan"}') # type: dict[str,str]
def func():
    return 10
var6 = func() # type: int

类型注解的限制

类型注解仅仅是提示性的，不是决定性的，比如下面这行不合理的代码仅仅是警告而非报错

var7: int = 'fang'

函数的类型注解

# 对形参进行类型注解
def add(x: int, y: int):
    return x + y
# 对返回值进行类型注解
def func(data: list) -> list:
    return data

Union类型的类型注解

使用Union类型，必须先导包

from typing import Union

Union[类型1,类型2,...]

from typing import Union
mylist: list[int] = [1, 2, 3]
# Union类型
mylist2: list[Union[int, str]] = [1, 2, 'fang', 'interesting']
mydict: dict[str, Union[int, str]] = {'name': 'fang','age':24}
print(mydict)
# 使用Union类型，必须先导包
# from typing import Union
def func(data: Union[int, str]) -> Union[int, str]:
    pass
func()

☆多态

多肽是多个氨基酸通过肽键连接形成的化合物

多态是父类中的方法可以被不同子类用不同方式实现。

class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪汪")
class Cat(Animal):
    def speak(self):
        print("喵")
Dog().speak()
Cat().speak()

比如这段代码中同样是speak方法，Dog类调用speak方法和Cat类调用speak方法输出不同，有不同的表现。

这种写法也就是抽象类了。

说白了就是子承父业，父亲指明方向，告诉孩子有这个东西，孩子努力实现。

抽象类：含有抽象方法的类

抽象方法：方法体是空实现的pass，有两个专门做空调的厂商方集团和李集团

注意：子类需要父类中的每一个抽象类，一个都不能漏

举个例子：

比如制定空调的标准是会制冷和制热和摆风

class standard:
    def cool_wind(self):
        pass
    def hot_wind(self):
        pass
    def swing(self):
        pass
class fang(standard):
    def cool_wind(self):
        print("方集团研究的制冷")
    def hot_wind(self):
        print("方集团研究的制热")
    def swing(self):
        print("方集团研究的摆风")
class li(standard):
    def cool_wind(self):
        print("李集团研究的制冷")
    def hot_wind(self):
        print("李集团研究的制热")
    def swing(self):
        print("李集团研究的摆风")
def make_cool(a: standard):
    a.cool_wind()
producer1 = fang()
producer2 = li()
make_cool(producer1)
make_cool(producer2)

课堂案例——猫狗大战

class Cat:
    role = 'cat'
    def __init__(self, name, breed, bite, value):
        self.name = name
        self.breed = breed
        self.value = value
        self.bite = bite
    def attack(self,dog):
        dog.value -= self.bite
    def eat(self):
        self.value += 50
    def die(self):
        if self.value <= 0:
            print("cat die")
        else:
            print(self.name,"生命值还有",self.value)
class Dog:
    role = 'dog'
    def __init__(self, name, breed, bite, value):
        self.name = name
        self.breed = breed
        self.value = value
        self.bite = bite
    def attack(self,cat):
        cat.value -= self.bite
    def eat(self):
        self.value += 50
    def die(self):
        if self.value <= 0:
            print("dog die")
        else:
            print(self.name,"生命值还有",self.value)
a = Cat('1','jumao',30,500)
b = Dog('2','jinmao', 50, 300)
a.die()
b.die()
a.attack(b)
b.die()

基础部分到此完毕，后面Python程序设计基础部分会更新一些例题和修改一些存在问题的表述。加油！

标签：__,对象,self,print,第六章,5g,id,def
From： https://blog.csdn.net/weixin_63461613/article/details/141966440

相关文章

  • 使用multipartFile对象解析Execl
    1.需要使用multipartFile包packageorg.springframework.web.multipart;2.数据校验publicStringexportVehicleViol(MultipartFilemultipartFile){    try{      //对前端传递的文件进行校验      if(multipartFile==null&&multipartF......
  • C++：类与对象
    一、面向对象编程(一)面向过程vs面向对象   面向过程（Procedural-Oriented-Programming， POP）和面向对象（Object-Oriented-Programming，OOP），是两种典型的编程范式，通常是作为划分编程语言的一大依据，在许多现代编程语言中都会有面向对象的编程范式，这是因为其与现实世界的良好......
  • 【Python】对象（包括类、函数）取名方法
    先上干货，通用的：字母：A-Za-z下划线：_数字：0-9（注意：数字不能在开头）理论上可以使用中文变量名，但强烈不建议使用。合法名字举例abcdef GoodCoder AD_fhrygfuigfrA_a_007 __NAME123 _P_T__123456 Cc_Dd _不合法名字举例666Code C++ 1+1=2 (5)4654ty54F 0.123 [email protected]......
  • C++万字解析类和对象
     1.类的定义class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。为了区分成员变量，一般习惯上成员变量会加一个特殊标识，如成员变量前面......
  • Java基础第六天-面向对象编程
    类与对象类就是数据类型，对象就是一个具体的实例。类拥有属性和行为。类是抽象的，概念的，代表一类事物，比如人类，猫类等它是数据类型。对象是具体的，实际的，代表一个具体事物，即是实例。类是对象的模板，对象是类得一个个体，对应一个实例。对象在内存中的存在形式：字符串是指向地址保......
  • 7.跟着狂神学JAVA（面向对象）
    什么是面向对象面向过程步骤清晰简单适合处理一些较为简单的问题线性思维面向对象先分类、然后对分类后的细节进行面向过程的思考适合处理复杂、多人协作的问题分类思维面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据抽象从认识论的角度考......
  • 31：Python面向对象的程序设计
    一、面向对象的程序设计什么是面向对象的程序设计及为什么要有它面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一......
  • 2024/9/8第六次记录：第六章数组
    第六章数组要存储大量的数据，就必须定义存储空间很大的变量，可以用数组和结构体。这里我们将数组。6.1数组与存储分配6.1.1定义数组数组是用来存放各个数据元素的一组相互间有关联的变量，这一组变量有共同的名称，用名称及在数组内的序号标识各个变量。定义数组的基本格......
  • python之对象通过直接引用协作
    对象通过直接引用协作是面向对象设计中的一个概念，它指的是在一个对象内部直接持有另一个对象的引用，以便可以调用后者的方法或访问其属性。这种方式可以使得对象之间的通信和数据共享变得直接和简单。以下是对象通过直接引用协作的一些关键点：封装：每个对象都封装了自己的数据......
  • JAVA(十五)类和对象
    面相对象编程为什么会设计类这个东西程序中要表示一个人的特征如何表示，它具有不同的类型，第一个name姓名age年龄 19intsex性别男String第二个name1姓名age1年龄 19intsex1性别男String第n个。调用第几个怎么调用，我们知道数组放的是数据相同的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99