python知识点总结(六)：类

最新推荐文章于 2024-04-17 22:04:05 发布
最新推荐文章于 2024-04-17 22:04:05 发布
阅读量350 收藏 1
点赞数
分类专栏： python 文章标签： python 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44607113/article/details/126059005
版权

目录

类

  面向对象编程是最有效的软件编写方法之一。根据类来创建对象被称为实例化，这让你能够使用类的实例。

1. 创建和使用类

  使用类几乎可以模拟任何东西。

（1）创建类

  方法    init    ()：类中的函数称为方法。与前面学到的有关函数的一切都适用于方法，目前唯一重要的差别是调用方法的方式。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免 Python 默认方法与普通方法发生名称冲突。
编写一个表示小狗的简单类 Dog ——它表示的不是特定的小狗，而是任何小狗。

class Dog(): 
    def __init__(self, name, age):  #包含三个形参：self 、name 和age      
        self.name = name   #两个变量都有前缀self        
        self.age = age      
    def sit(self):  #由于该方法不需要额外的信息，只有一个形参self                
        print(self.name.title() + " is now sitting.")      
    def roll_over(self):                  
        print(self.name.title() + " rolled over!")

  形参 self 必不可少，还必须位于其他形参的前面。 Python 调用这个     init    () 方法来创建 Dog 实例时，将自动传入实参 self 。每个与类相关联的方法调用都自动传递实参 self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
  以 self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。self.name = name 获取存储在形参 name 中的值，并将其存储到变量 name 中，然后该变量被关联到当前创建的实例。像这样可通过实例访问的变量称为属性。

（2）根据类创建实例
class Dog(): 
    def __init__(self, name, age):  #属性name、age      
        self.name = name          
        self.age = age      
    def sit(self):                 
        print(self.name.title() + " is now sitting.")      
    def roll_over(self):                  
        print(self.name.title() + " rolled over!")
my_dog = Dog('willie', 6)  #实例my_dog 
#使用句点表示法访问实例的属性my_dog.name
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
my_dog.sit()  #使用句点表示法来调用Dog类中定义的任何方法
my_dog.roll_over()

2. 使用类和实例

（1）给属性指定默认值

  类中的每个属性都必须有初始值，哪怕这个值是 0 或空字符串。在方法     init    () 内指定这种初始值是可行的；如果你对某个属性设置默认值时，就无需包含为它提供初始值的形参。

class Car(): 
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
my_car = Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_car.read_record()
（2）修改属性的值

  修改属性的值有三种不同的方式：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）。
直接通过实例修改属性的值

class Car(): 
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
my_car = Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_car.record = 100  #直接将里程数设置为100
my_car.read_record()

通过方法修改属性的值

class Car(): 
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
    def update_mile(self, mile):  #更新里程数
        if mile >= self.record:  #检查数值是否合理
            self.record = mile
        else:
            print("Wrong, the mileage has to be bigger!")
my_car = Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_car.update_mile(100)
my_car.read_record()

通过方法对属性的值进行递增

class Car(): 
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
    def update_mile(self, mile):  #更新里程数
        if mile >= self.record:  #检查数值是否合理
            self.record = mile
        else:
            print("Wrong, the mileage has to be bigger!")
    def increase_mile(self, mile):  #增加里程数
        self.record += mile
my_car = Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_car.update_mile(100)
my_car.read_record()
my_car.increase_mile(10)  #增加10公里
my_car.read_record()

3. 继承

  编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

（1）子类的方法    init    ()

  子类的方法     init    () 需要父类施以援手。

class Car():   #父类
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
    def update_mile(self, mile):  #更新里程数
        if mile >= self.record:  #检查数值是否合理
            self.record = mile
        else:
            print("Wrong, the mileage has to be bigger!")
    def increase_mile(self, mile):  #增加里程数
        self.record += mile

class ElectricCar(Car):  #子类：定义子类时，必须在括号内指定父类的名称
    def __init__(self, make, model, year):
        super().__init__(make, model, year) #函数super()让子类实例包含父类的所有属性

my_electric_car = ElectricCar('yadi','d5','2020')
print("My electric car: " + my_electric_car.describe())
（2）给子类定义属性和方法
class Car():   #父类
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
    def update_mile(self, mile):  #更新里程数
        if mile >= self.record:  #检查数值是否合理
            self.record = mile
        else:
            print("Wrong, the mileage has to be bigger!")
    def increase_mile(self, mile):  #增加里程数
        self.record += mile

class ElectricCar(Car):  #子类：定义子类时，必须在括号内指定父类的名称
    def __init__(self, make, model, year):
        super().__init__(make, model, year) #函数super()让子类实例包含父类的所有属性
        self.battery_size = 50  #设置默认值：电瓶容量=50 
    def describe_battery(self):   #电动车容量
        print("This electric car has a " + str(self.battery_size) + " KWh battery!")

my_electric_car = ElectricCar('yadi','d5','2020')
print("My electric car: " + my_electric_car.describe())
my_electric_car.describe_battery()
（3）重写父类的方法

  对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。

#假设父类有一个fill_gas_tank()的方法
class ElectricCar(Car):  
    def __init__(self, make, model, year):
        super().__init__(make, model, year) 
    def fill_gas_tank():  #重写
        print("The electric car doesn't need a gas tank!")  #电动汽车没有油箱
（4）将实例用作属性

  使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。

class Car():   #父类
    def __init__(self, make, model, year):        
        self.make = make          
        self.model = model
        self.year = year    
        self.record = 0   #设置默认值：里程数=0   
    def describe(self):   #汽车的特征
        name = str(self.year) + ' ' + self.make + ' ' + self.model
        return name.title()      
    def read_record(self):   #读取汽车的里程表               
        print("This car has " + str(self.record) + " miles on it!")
    def update_mile(self, mile):  #更新里程数
        if mile >= self.record:  #检查数值是否合理
            self.record = mile
        else:
            print("Wrong, the mileage has to be bigger!")
    def increase_mile(self, mile):  #增加里程数
        self.record += mile

class ElectricCar(Car):  #子类：定义子类时，必须在括号内指定父类的名称
    def __init__(self, make, model, year):
        super().__init__(make, model, year) #函数super()让子类实例包含父类的所有属性 
        self.battery = Battery()  #添加属性
    def fill_gas_tank():
        print("The electric car doesn't need a gas tank!") #电动汽车没有油箱

#将属性和方法提取出来放到Battery类中，并将Battery实例用作ElectricCar类的一个属性
class Battery():  
    def __init__(self, battery_size=70):
        self.battery_size = battery_size
    def describe_battery(self):   #电动车容量
        print("This electric car has a " + str(self.battery_size) + " KWh battery!")
        
my_electric_car = ElectricCar('yadi','d5','2020')
print("My electric car: " + my_electric_car.describe())
my_electric_car.battery.describe_battery()

4. 导入类

  随着你不断地给类添加功能，文件可能变得很长，即便你妥善地使用了继承亦如此。为让文件尽可能整洁可将类存储在模块中，然后在主程序中导入所需的模块。

（1）导入单个类

  将 Car 类存储在一个名为 car.py 的模块中，然后在 my_car.py 文件中导入 Car 类：

from car import Car
my_car = Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_car.update_mile(100)
my_car.read_record()
（2）在一个模块中存储多个类

  虽然同一个模块中的类之间应存在某种相关性，但可根据需要在一个模块中存储任意数量的类。可将 Car 类、Battery 类、ElectricCar 类等存储在 car.py 的模块中。

（3）从一个模块中导入多个类

  可根据需要在程序文件中导入任意数量的类。

from car import Car, ElectricCar
（4）导入整个模块

  你还可以导入整个模块，再使用句点表示法访问需要的类。

import car
my_car = car.Car('audi','a4','2020')
print("My car: " + my_car.describe())
my_electric_car = car.ElectricCar('yadi','d5','2020')
print("My electric car: " + my_electric_car.describe())
（5）导入模块中的所有类

  from 模块名 import *
  不推荐使用这种导入方式，其原因有二：
  一、这种导入方式没有明确地指出你使用了模块中的哪些类。
  二、这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。

（6）在一个模块中导入另一个模块

  将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
  例如：将 Car 类存储在一个模块中 car.py，并将 ElectricCar 和 Battery 类存储在另一个模块中 electric_car.py。ElectricCar 类需要访问其父类 Car，因此直接将 Car 类导入 electric_car.py 中。

5. Python标准库

  Python 标准库是一组模块，安装的 Python 都包含它，可使用标准库中的任何函数和类。如，模块 collections 中的一个类 OrderedDict，OrderedDict 实例记录了字典中键值对的添加顺序。
在这里插入图片描述

Aiolei
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何通过类来创建一个对象
qq_36148879的博客
03-11 988
如何通过类创建一个对象
python中如何创建类的对象_Python如何创建对象，有哪些方法
weixin_39609573的博客
12-10 1572
Python如何创建对象，有哪些方法以下介绍Python创建对象的9种方法。class Point:def __init__(self,x,y):self.x = xself.y = yimport sysimport copyimport typespoint1 = Point(1,2)point2 = eval("{}({},{})".format("Point",1,2))point3 = ...
Python面向对象
最新发布
m0_75011423的博客
04-17 144
类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作 这种套路，称之为：面向对象编程。
Python的类总结
夏虫语冰的博客
01-28 873
该示例中，我们定义了一个名为Dog的类，其中包含了三个方法：bark，do_trick和birthday。类和对象是面向对象编程的基础，通过使用类和对象可以将复杂的程序组织得更好，并使代码更易于维护和扩展。在do_trick方法中，我们使用了方法的参数来打印do_trick方法中的信息。在birthday方法中，我们通过将self.age属性加1来模拟狗的生日。类是面向对象编程的重要概念，使用类可以更好的组织代码，提高代码的重用性。在程序的最后，我们实例化了一个Dog类的对象，将其赋值给dog1变量。
关于Python类的总结
长期更新Java自学笔记
09-11 356
一、类对象及类属性 类对象： 类的定义执行后会生成一个类对象 类的属性： 类定义中的变量和类中定义的方法都是类的属性 类变量： 例如下面的namenamename就是类的变量 类命名： 大驼峰方式，大写字母开头 class Person: name = "leo" def say(self): print(self.name + ' say hello') 二、实例化 每次实例化后得到的实例，是完全不同的实例。Python类实例化后，会自动调用__init__ 方法进
python面向对象 —— 类和对象（一）
haoweixl的博客
03-23 370
一、类属性与类方法 二、类属性的私有化 三、类方法，静态方法，实例方法
总结python知识点大全.zip
08-25
这个名为“总结python知识点大全.zip”的压缩包文件包含了对Python编程语言关键知识点的详细概述。通过解压并查阅“python总结知识点大全.pdf”，我们可以深入学习Python的基础和高级特性。 1. **基础语法** ...
关于Python解包知识点总结
12-20
Python 中的解包是自动完成的，例如： student = ['xiaoqiang','man','22'] name,sex,age = student print(name,sex,age) 结果：xiaoqiang man 22 如果列表中有3个元素，那么刚好可以分配给3个变量。除了列表对象...
python知识点总结.pdf
12-10
Python 知识点总结 Python 语言概述 * Python 是一种面向对象的语言，具有面向对象、面向过程的特点。 * ASCII 码是一种字符编码标准，使用一个字节表示一个字符，而 Unicode 编码通常用两个字节表示一个字符。 ...
python知识点总结
03-04
1. 语法基础：Python 的基本语法、变量、数据类型、运算符和控制流等基础知识。 2. 数据结构：Python 中的列表、元组、字典、集合等数据结构的使用和操作。 3. 函数和模块：定义和调用函数，创建和使用模块，以及...
python中类的总结一
weixin_44615267的博客
12-03 182
面向对象的基本特征：继承，封装，多态 类的定义和使用 类的创建语句 class 语句 语法： class 类名（继承列表）: '''类的文档字符串''' 实例方法 类变量 类方法 静态方法 示例代码： #创建类 class Dog: '''此语句用来定义一个类型''' pass print(Dog) <class '__main__....
通过类创建对象
zhangpeng888888的博客
04-12 1931
通过类创建对象 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1、创建类2、创建对象3.不在一个包内创建对象时 1、创建类 此处使用了private，因此需要通过右键–generate–set/set操作 public class Student { //成员变量 private String name; private int age; public String getName() { return name;
如何根据类名和参数创建对象
Dojo中文博客
08-18 5741
<br />开发时遇到这样的需求，希望通过一个类似factory的机制来创建对象，这个机制接收两个参数，一个是对象所属的类，另一个是参数数组，例如：<br />function getObject(cls, args){ //.... }<br /> <br />这里cls是一个类（即javascript函数），args是一个参数数组，例如[arg1, arg2, ....]，希望这个函数返回的对象等同于下面代码的效果：<br />new cls(arg1, arg2...);<br /> <b
根据类创建对象
girls的博客
02-06 679
python中的 “类” 知识点详解
qq_48456652的博客
04-02 615
目录类的基本定义类的初始化1. 对类本身初始化2. 输出个体所定义的数据3. 返回所定义的属性4.修改类以及个体的数据多态 类的基本定义 先创建一个类： class Person: name = None age = None gender = None #定义类的基本信息 def print_obj(self): print("Person") #用函数输出定义的类 print("zhangsan---------------------------
python 类的总结
baidu_36831253的博客
09-06 210
题外话：为了自己方便，所以做个总结。全无技术含量。1）关于多继承的。 继承中：现在自身中找寻相关方法，如果没有的话，就是用父类。 如果父类有多个的话 ，按照一定规则继承。可以查看继承顺序。class Test(object): def __init__(self,person): self.person = personclass St(Test): def __
Python 6种数据类型总结
热门推荐
Jzkuan的博客
04-21 1万+
数据类型 **不可变数据：**Number（数字）、String（字符串）、Tuple（元组） **可变数据：**List（列表）、Dictionary（字典）、Set（集合） Number（数字） 常用的数学函数 abs(x) #返回数字的绝对值，如abs(-10) 返回 10 math.fabs(x) #返回数字的绝对值，如math.fabs(-10) 返回10.0 e...
python学习总结9 - 类
因热爱而坚持，因坚持而愈发热爱。
04-01 1003
基础
python类的继承、属性总结和方法总结
andyfeng088的博客
01-15 3614
1、类的继承 继承是面向对象的重要特性之一： 继承关系：继承是相对两个类而言的父子关系，子类继承了父类的所有 公有属性和方法 继承实现了代码重用。 1.1、使用继承 继承可以重用已经存在的数据和行为，减少代码的重复编写。Python在类名后使用一对括号来表示继承关系，括号中的类即为父类。 class Myclass(ParentClass) 如果父类定义了init方法，子类必须显
Python核心知识点总结.doc
05-08
《Python核心知识点总结.doc》介绍了Python的对象类型，包括Python内置对象类型（如数字、字符串、列表、元组、字典、集合、文件、其他类型）以及编程单元类型（函数、模块、类）等。此外，该文档还涉及了与实现相关...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值