?本教程通过示例概述了 Python 中的面向对象编程 (OOP)。这是一个分步指南，专为没有编程经验的人设计。面向对象编程很流行，除了 P
ython 之外，还可以使用其他编程语言，如 Java、C++、PHP。目录什么是面向对象编程？数据科学家使用面向对象编程吗？基础
知识：Python 中的 OOP对象和类构造函数变量方法遗产多态性方法重写方法重载什么是__str__？数据封装Getter 和
Setter如何导入类什么是 __name__ == "__main__"？锻炼什么是面向对象编程？在面向对象编程 (OOP) 中
，您可以灵活地在代码中表示现实世界的对象，如汽车、动物、人、ATM 等。简单来说，物体就是具有一定特征、能够执行一定功能的东西。例
如，汽车是一个物体，可以执行启动、停止、驱动和制动等功能。这些都是汽车的功能。特征是汽车的颜色、里程、最高速度、车型年份等。 在上
面的例子中，car 是一个object.?在 OOP 世界中调用函数methods。特点是attributes (properti
es)。从技术上讲，属性是与对象状态相关的变量或值，而方法是影响对象属性的函数。在Python中，一切都是对象。字符串、整数、浮点
、列表、字典、函数、模块等都是对象。 数据科学家使用面向对象编程吗？这是数据科学家在学习 OOP 之前最常见的问题之一。当涉及到使
用 Python 进行数据操作和机器学习时，通常建议学习https://www.listendata.com/2017/12/py
thon-pandas-tutorial.htmlpandas、https://www.listendata.com/2017/1
2/numpy-tutorial.htmlnumpy、https://www.listendata.com/2019/06/mat
plotlib-tutorial-learn-plot-python.htmlmatplotlib、 scikit-learn 库
。这些库由经验丰富的 Python 开发人员编写，用于自动化或简化与数据科学相关的大多数任务。所有这些库都依赖于 OOP 及其概念
。例如，您正在使用 scikit-learn 库构建回归模型。您首先必须将模型声明为对象，然后使用 fit 方法。如果不了解 OO
P 的基础知识，您将无法理解为什么以这种方式编写代码。 在Python中，主要有3种编程风格，即面向对象编程、函数式编程和过程式编
程。简单来说，Python 中有 3 种不同的方法来解决这个问题。函数式编程因其性能优势而在数据科学家中最受欢迎。当您使用大型代码
库并且代码可维护性非常重要时，OOP 非常有用。结论：学习 OOP 基础知识很有好处，这样您就可以了解所使用的库背后的原理。如果你
的目标是成为一名优秀的 Python 开发人员并想要构建 Python 库，你需要学习 OOP（必须！）。与此同时，有许多数据科学
家不了解 OOP 概念，但仍然在工作中表现出色。基础知识：Python 中的 OOP在本节中，我们将详细了解 Python 中与
OOP 相关的概念。 对象和类类是对象的架构。它是对类的属性和方法的正确描述。例如，同一类型的汽车的设计是一个类。您可以从一个类创
建许多对象。就像您可以通过设计汽车来制造许多相同类型的汽车一样。 ?编辑?编辑有许多真实世界的类示例，如下所述 -煎蛋卷的食谱是一
类。煎蛋卷是一个对象。银行账户持有人是一个类。属性有名字、姓氏、出生日期、职业、地址等。方法可以是“更改地址”、“更改职业”、“更
改姓氏”等。“更改姓氏”一般适用于女性结婚后更改姓氏狗是一个类。属性包括品种、腿数、大小、年龄、颜色等。方法可以是吃、睡、坐、吠、
跑等。在Python中，我们可以使用关键字创建一个类class。类的方法可以通过关键字定义def。它与普通函数类似，但它是在类中定
义的，并且是类的函数。方法定义中的第一个参数始终为self，并且在没有该参数的情况下调用方法self。示例 1：创建汽车类clas
s： 车attributes：年份、英里数和速度methods：加速和制动object: 汽车1class?: carattrib
utes?: year, mpg and speedmethods?: accelerate and brakeobject?:
car1车类： ＃ 属性 Year = 2016 # 车型年份 mpg = 20 # 里程 speed = 100 # 当前速度
＃ 方法 def 加速（自身）： 回程车速度+20 默认制动（自制动）： 返回车速 - 50class car: # att
ributes year = 2016 # car model''s year mpg = 20 # mileage sp
eed = 100 # current speed # methods def accelerate(self): re
turn car.speed + 20 def brake(self): return car.speed - 50汽车1=汽车(
)car1.accelerate()120car1.brake()50汽车1年2016年car1.mpg20汽车1.速度100ca
r1=car()car1.accelerate()120car1.brake()50car1.year2016car1.mpg20
car1.speed100要提交方法，我们需要使用圆括号。 示例 2：创建公司类别在下面的示例中，我们创建一个名为 company
的类。这里的属性是名称、营业额、收入和在公司工作的员工人数。方法是每个员工产生的收入（出于演示目的，我们将其称为生产力）。 #
创建公司类类公司： ＃ 属性 名称 =“XYZ 银行” 营业额 = 5000 收入 = 1000 员工人数 = 100 ＃ 方
法 定义生产力（自我）： 返回 Company.revenue/Company.no_of_employees# Creates
class Companyclass Company: # attributes name = "XYZ Bank" turno
ver = 5000 revenue = 1000 no_of_employees = 100 # method def pro
ductivity(self): return Company.revenue/Company.no_of_employees可以
提取在方法外部定义的属性，而无需创建对象。公司名称输出“XYZ 银行”公司营业额输出5000Company.no_of_emplo
yees输出100公司().生产力()输出10.0Company.nameOutput''XYZ Bank''Company.turn
overOutput5000Company.no_of_employeesOutput100Company().productiv
ity()Output10.0构造函数构造函数是一种特殊的方法。您可以将其视为初始化或激活对象的类的属性或属性的函数。使用关键字_
_init__为构造函数创建方法。在上一节中，我们讨论了汽车作为对象的示例。您可以将构造函数视为所需的整个操作序列，以便工厂根据类
设计模式构造汽车对象。self表示继承这些属性的对象。 对象是类的实例。“实例”和“对象”这两个词可以互换使用。创建类的对象的过程
称为instantiation。在下面的示例中，我们要求用户输入值。__init__当构造该类的对象时调用。班级人物： def _
_init__(自我,名字,姓氏): self.first = 名字 self.last = 姓氏myname = person(
"Deepanshu","Bhalla")print(我的名字.姓氏)class person: def __init__(sel
f,firstname,lastname): self.first = firstname self.last = lastnam
emyname = person("Deepanshu","Bhalla")print(myname.last)我们已经创建了my
nameperson 类的对象。 当您创建一个新对象时 >>> __init__ 方法被调用 >>> __init__ 方法内的行
为执行我们再举一个例子。这里，下面的程序根据类中定义的方法返回输出我的公司类： ＃ 方法 def __init__(self,
公司名称, 收入, 员工人数): self.name = 公司名称 自营收入 = 收入 self.no_of_employees
= 员工人数 定义生产力（自我）： 返回 self.revenue/self.no_of_employeesMyCompany(''
XYZ 银行'', 1000,100).productivity()输出10.0MyCompany(''ABC 银行'', 5000,2
00).productivity()输出25.0class MyCompany: # methods def __init__(
self, compname, revenue, employeesize): self.name = compname self
.revenue = revenue self.no_of_employees = employeesize def produc
tivity(self): return self.revenue/self.no_of_employeesMyCompany(''
XYZ Bank'', 1000,100).productivity()Output10.0MyCompany(''ABC Bank''
, 5000,200).productivity()Output25.0调用类方法的替代方法银行 = MyCompany(''ABC
银行'', 5000,200)MyCompany.生产力（银行）Bank = MyCompany(''ABC Bank'', 5000
,200)MyCompany.productivity(Bank)rateperkm返回每公里出租车费的价格，其计算方法是用总账单
除以车次。出租车行驶公里数。noofcabs返回正在运行的出租车数量。考虑一下拥有许多出租车的出租车代理公司，并且想知道有多少辆出
租车在忙碌avgnoofpassengers返回乘坐汽车出行的平均乘客人数。为了计算平均值，它考虑了所有正在运行的出租车以及每个出
租车中的乘客数量。驾驶室类别： #初始化第一次迭代的变量 出租车数量 = 0 乘客数量 = 0 def __init__(自身、
司机、公里数、地点、工资、乘客): self.driver = 驱动程序 自运行=公里 self.places = 地点 自助账单
= 付款 出租车数 = 出租车数 + 1 Cab.numpassengers = Cab.numpassengers + 乘客
#返回每公里出租车费价格 def 每公里率（自身）： 返回 self.bill/self.running #返回正在运行的出租车
数量 @类方法 def noofcabs(cls): 返回 cls.numberofcabs #返回乘坐出租车的平均乘客人数 @类
方法 def avgnoofpassengers(cls): return int(cls.numpassengers/cls.n
umberofcabs)Firstcab = Cab("拉梅什", 80, [''德里'', ''诺伊达''], 2200, 3)Seco
ndcab = Cab("苏雷什", 60, [''古尔冈'', ''诺伊达''], 1500, 1)Thirdcab = Cab("戴夫
", 20, [''古尔冈'', ''诺伊达''], 680, 2)第一出租??车司机“拉梅什”第二个出租车司机''苏雷什''第三出租车司机“
戴夫”Firstcab.rateperkm() 27.5Secondcab.rateperkm()25.0Thirdcab.rat
eperkm()34.0Cab.noofcabs() 3Cab.avgnoofpassengers()2class Cab: #
Initialise variables for first iteration numberofcabs = 0 numpas
sengers = 0 def __init__(self,driver,kms,places,pay,passengers):
self.driver = driver self.running = kms self.places = places self
.bill = pay Cab.numberofcabs = Cab.numberofcabs + 1 Cab.numpasse
ngers = Cab.numpassengers + passengers #Returns price of cab far
e per km def rateperkm(self): return self.bill/self.running #Ret
urns number of cabs running @classmethod def noofcabs(cls): retur
n cls.numberofcabs #Returns average number of passengers travelli
ng in a cab @classmethod def avgnoofpassengers(cls): return int(c
ls.numpassengers/cls.numberofcabs)firstcab = Cab("Ramesh", 80, [
''Delhi'', ''Noida''], 2200, 3)secondcab = Cab("Suresh", 60, [''Gurgao
n'', ''Noida''], 1500, 1)thirdcab = Cab("Dave", 20, [''Gurgaon'', ''No
ida''], 680, 2)firstcab.driver''Ramesh''secondcab.driver''Suresh''thir
dcab.driver''Dave''firstcab.rateperkm()27.5secondcab.rateperkm()25.
0thirdcab.rateperkm()34.0Cab.noofcabs()3Cab.avgnoofpassengers()2C
ab.avgnoofpassengers() 返回 2，计算公式为 (3 + 1 + 2) / 3静态方法静态方法是这三种方法中最
不流行的方法。与实例和类方法不同，静态方法不采用特殊关键字（self、cls）作为第一个参数。它的用途有限，因为您既不能访问类的实
例（对象）的属性，也不能访问该类的属性。唯一的用法是可以在没有对象的情况下调用它。它主要用于创建帮助程序或实用程序函数，例如验证驱
动程序名称（驱动程序名称必须小于 32 个字符）或账单金额必须大于零（不能为负数或零）。请参阅下面的程序来完成相同的任务。 驾驶室
类别： @静态方法 def billvalidation（支付）： 返回整数（支付）> 0出租车账单验证(0.2)输出错误的cl
ass Cab: @staticmethod def billvalidation(pay): return int(pay)
> 0Cab.billvalidation(0.2)OutputFalse遗产继承利用了已经为父类编写的子类代码。例如，车辆类别的
某些属性与汽车、公共汽车和卡车类别相同。所有级别的驾驶员姓名、车轮数量等属性均相同。车辆是 a?，汽车、公共汽车和卡车是。在OOO
中，这意味着类从其父类继承属性和行为方法。?parent classchildren classes 车辆类别： def __in
it__(自身、驾驶员、车轮、座椅): self.driver = 驱动程序 self.noofwheels = 轮子 self.
noofseats = 座位驾驶室类别（车辆）： 经过cab_1 = Cab(''桑迪'',4, 2)cab_1.driver输出''桑
迪''class Vehicle: def __init__(self,driver,wheels,seats): self.dri
ver = driver self.noofwheels = wheels self.noofseats = seatsclass
Cab(Vehicle): passcab_1 = Cab(''Sandy'',4, 2)cab_1.driverOutput''Sa
ndy''车辆类别： 最低利率 = 50 def __init__(自身、驾驶员、车轮、座椅): self.driver = 驱动程
序 self.noofwheels = 轮子 self.noofseats = 座位驾驶室类别（车辆）： 最低利率 = 75车辆最
低费率50出租车最低费率75class Vehicle: minimumrate = 50 def __init__(self,d
river,wheels,seats): self.driver = driver self.noofwheels = wheel
s self.noofseats = seatsclass Cab(Vehicle): minimumrate = 75Vehic
le.minimumrate50Cab.minimumrate75创建一个父类Vehicle并将其属性用于子类Vehicle。在下
面的程序中，我们不需要指定 cab 类的属性。它继承自车辆。如何更改子类的类变量Vehicle如何让子类的参数比父类多在这个例子中
，我们有两个类Cab，Bus它们有许多相似的属性，但也有一些是类所独有的。为了解决这个问题，我们创建了一个名为的父类Vehicle
，其中包含公共属性和方法。 ?编辑车辆类别： 最低利率 = 50 def __init__(自身、驾驶员、车轮、座位、公里数、账单
): self.driver = 驱动程序 self.noofwheels = 轮子 self.noofseats = 座位 自运
行=公里 self.bill = 帐单 def 每公里率（自身）： 返回 self.bill/self.running驾驶室类别
（车辆）： 最低利率 = 75 def __init__(自身、驾驶员、车轮、座椅、公里数、账单、出租车类型): 车辆.__ini
t__(自身、驾驶员、车轮、座位、公里数、账单) self.category = 出租车类型巴士类（车辆）： 最低利率 = 25
def __init__(自身、驾驶员、车轮、座椅、公里数、账单、颜色): 车辆.__init__(自身、驾驶员、车轮、座位、公里
数、账单) self.color = 颜色cab_1 = 出租车(''Prateek'', 4, 3, 50, 700, ''SUV'')
cab_1.类别cab_1.rateperkm()Bus_1 = 巴士(''戴夫'', 4, 10, 50, 400, ''绿色'')总线
_1.颜色Bus_1.rateperkm()class Vehicle: minimumrate = 50 def __init_
_(self,driver,wheels,seats,kms,bill): self.driver = driver self.n
oofwheels = wheels self.noofseats = seats self.running = kms self
.bill = bill def rateperkm(self): return self.bill/self.runningc
lass Cab(Vehicle): minimumrate = 75 def __init__(self,driver,whee
ls,seats,kms,bill,cabtype): Vehicle.__init__(self,driver,wheels,s
eats,kms,bill) self.category = cabtypeclass Bus(Vehicle): minimum
rate = 25 def __init__(self,driver,wheels,seats,kms,bill,color):
Vehicle.__init__(self,driver,wheels,seats,kms,bill) self.color =
colorcab_1 = Cab(''Prateek'', 4, 3, 50, 700, ''SUV'')cab_1.categoryc
ab_1.rateperkm()bus_1 = Bus(''Dave'', 4, 10, 50, 400, ''green'')bus_1
.colorbus_1.rateperkm()我们可以将此命令替换Vehicle.__init__(self,driver,whe
els,seats,kms,bill)为super().__init__(driver,wheels,seats,kms,bill
).super()用于引用父属性和方法。多态性多态性意味着具有多种形式的能力。当您处理子类和父类时，这是一个重要的概念。pytho
n 中的多态性是通过方法重写和方法重载来应用的。 方法重写方法重写允许我们在子类中拥有与父类同名的方法，但子类方法的定义与父类方法
不同。 车辆类别： def 消息（自身）： print("父类方法")驾驶室类别（车辆）： def 消息（自身）： print("
子 Cab 类方法")巴士类（车辆）： def 消息（自身）： print("子总线类方法")x = 车辆()x.message(
)父类方法y= 驾驶室()y.message()子驾驶室类方法z = 总线()z.message()子总线类方法class Veh
icle: def message(self): print("Parent class method")class Cab(Ve
hicle): def message(self): print("Child Cab class method")class B
us(Vehicle): def message(self): print("Child Bus class method")x
= Vehicle()x.message()Parent class methody= Cab()y.message()Child
Cab class methodz = Bus()z.message()Child Bus class method正如您可以看
到上面显示的输出，子类重写了父类方法。 方法重载它允许您灵活地定义函数或方法，以便您可以仅使用某些参数来调用它，而无需指定其他参数
。您还可以使用所有参数来调用它。你可以按照你想要的方式去做。 在下面的脚本中，可以不带参数调用方法（忽略短语参数）。或者可以使用参
数来调用phrase。班级留言： def 详细信息（自我，短语=无）： 如果短语不是 None： print(''我的消息 - ''
+ 短语) 别的： print(''欢迎来到Python世界'') ＃ 目的x = 消息() # 调用不带参数的方法x.detail
s() # 调用带有参数的方法x.details(''生活是美丽的'')class Message: def details(self
, phrase=None): if phrase is not None: print(''My message - '' + p
hrase) else: print(''Welcome to Python World'') # Objectx = Message
() # Call the method with no parameterx.details() # Call the meth
od with a parameterx.details(''Life is beautiful'')什么是__str__？它用于生成
对象的可读表示。 车辆类别： def __init__(自身、驾驶员、车轮、座椅): self.driver = 驱动程序 sel
f.noofwheels = 轮子 self.noofseats = 座位veh_1 = 车辆("桑迪", 4, 2)打印（veh
_1）输出__main__.Vehicle 对象位于 0x0000019ECCCA05F8class Vehicle: def _
_init__(self,driver,wheels,seats): self.driver = driver self.noof
wheels = wheels self.noofseats = seatsveh_1 = Vehicle("Sandy", 4,
2)print(veh_1)Output __main__.Vehicle object at 0x0000019ECCCA05
F8车辆类别： def __init__(自身、驾驶员、车轮、座椅): self.driver = 驱动程序 self.noofw
heels = 轮子 self.noofseats = 座位 def __str__(自身): return "司机姓名：" +
self.driver + " ; " + "驾驶室座位数：" + str(self.noofseats)veh_1 = 车辆("
桑迪", 4, 2)打印（veh_1）输出驱动器名称：Sandy；驾驶室座位数：2class Vehicle: def __ini
t__(self,driver,wheels,seats): self.driver = driver self.noofwhee
ls = wheels self.noofseats = seats def __str__(self): return "Dri
ver Name : " + self.driver + " ; " + "Number of seats in cab : "
+ str(self.noofseats)veh_1 = Vehicle("Sandy", 4, 2)print(veh_1)Ou
tputDriver Name : Sandy ; Number of seats in cab : 2数据封装数据封装意味着限制
对方法和变量的访问。这可以防止数据被意外（错误）修改。 当我们在属性名称之前使用两个下划线“__”时，它会使属性在类外部不可访问。
它成为私有属性，这意味着除了类内部之外，您无法读取和写入这些属性。它通常由模块的开发人员使用。当属性前不使用下划线时，它是一个公共
属性，可以在类内部或外部访问。公寓类： def __init__(自身): self.type = "高级" self.__bhk
= "3 BHK"flat_1 = 平坦()flat_1.类型优质的flat_1.__bhkAttributeError：“Fl
at”对象没有属性“__bhk”class Flat: def __init__(self): self.type = "prem
ium" self.__bhk = "3 BHK"flat_1 = Flat()flat_1.typepremiumflat_1.
__bhkAttributeError: ''Flat'' object has no attribute ''__bhk''在上面的程序
中，type是公共属性，bhk是私有属性，不能在类外部访问。 Getter 和 Setter它们用于检索和更新变量的值。Sette
r 是一种更新变量值的方法。Getter 是一种读取变量值的方法。让我们通过例子来学习一下。 车辆类别： def __init__
(self,driver_firstname,driver_lastname): self.fdriver = 驱动程序名字 se
lf.ldriver = 驱动程序姓氏 self.email = self.fdriver + ''.'' + self.ldrive
r + ''@uber.com''veh_1 = 车辆(“桑迪”,“斯图尔特”)veh_1.fdriver沙veh_1.电子邮件“桑迪
.斯图尔特@uber.com”class Vehicle: def __init__(self,driver_firstname,
driver_lastname): self.fdriver = driver_firstname self.ldriver =
driver_lastname self.email = self.fdriver + ''.'' + self.ldriver +
''@uber.com''veh_1 = Vehicle("Sandy", "Stewart")veh_1.fdriverSandyv
eh_1.email''Sandy.Stewart@uber.com''在这里，我们正在更新驾驶员的名字，但它不会影响由名字和姓氏组合
而成的电子邮件地址。 veh_1.fdriver = ''汤姆''veh_1.fdriver''汤姆''veh_1.电子邮件“桑迪.斯图尔
特@uber.com”veh_1.fdriver = ''Tom''veh_1.fdriver''Tom''veh_1.email''San
dy.Stewart@uber.com''名字已从桑迪更改为汤姆，但电子邮件地址保持不变。好吧，明显的问题出现了“如何更新电子邮件地
址？”。通过使用@property装饰器，我们可以改变电子邮件的行为。email(self)是一种方法，但它的运行方式与普通属性类
似。这种特殊的方法称为Getters and Setters 车辆类别： def __init__(self,driver_fir
stname,driver_lastname): self.fdriver = 驱动程序名字 self.ldriver = 驱动程
序姓氏 @财产 def电子邮件（自己）： 返回 self.fdriver + ''.'' + self.ldriver + ''@
uber.com''veh_1 = 车辆(“桑迪”,“斯图尔特”)veh_1.fdriver = ''汤姆''veh_1.电子邮件“汤姆
.斯图尔特@uber.com”class Vehicle: def __init__(self,driver_firstname,
driver_lastname): self.fdriver = driver_firstname self.ldriver =
driver_lastname @property def email(self): return self.fdriver
+ ''.'' + self.ldriver + ''@uber.com''veh_1 = Vehicle("Sandy", "Stew
art")veh_1.fdriver = ''Tom''veh_1.email''Tom.Stewart@uber.com''如何通过更改
电子邮件地址自动更新名字和姓氏车辆类别： def __init__(self,driver_firstname,driver_la
stname): self.fdriver = 驱动程序名字 self.ldriver = 驱动程序姓氏 @财产 def电子邮件
（自己）： 返回 self.fdriver + ''.'' + self.ldriver + ''@uber.com'' @email.s
etter def电子邮件（自己，地址）： 首先 = 地址[:地址.find(''.'')] 最后 = 地址[地址.find(''.'')
+1:地址.find(''@'')] self.fdriver = 第一个 self.ldriver = 最后一个veh_1 = 车辆
(“桑迪”,“斯图尔特”)veh_1.email = ''deep.bhalla@uber.com''veh_1.fdriver''深的
''veh_1.ldriver''巴拉''class Vehicle: def __init__(self,driver_firstna
me,driver_lastname): self.fdriver = driver_firstname self.ldriver
= driver_lastname @property def email(self): return self.fdrive
r + ''.'' + self.ldriver + ''@uber.com'' @email.setter def email(self
, address): first = address[:address.find(''.'')] last = address[a
ddress.find(''.'')+1:address.find(''@'')] self.fdriver = first self.l
driver = lastveh_1 = Vehicle("Sandy", "Stewart")veh_1.email = ''de
ep.bhalla@uber.com''veh_1.fdriver''deep''veh_1.ldriver''bhalla''验证在现实世
界中，getter 和 setter 主要用于包含验证逻辑。在下面的示例中，我们将创建具有 amount 属性的捐赠类。金额必须介
于 10 到 1,000,000 之间。如果用户输入的值小于 10，则应设置为 10。同样，如果用户尝试输入大于 100 万的值，
则应将其限制为仅 100 万。 班级捐赠： def __init__(自我,金额): self.金额 = 金额 @财产 默认金额
（自己）： 返回 self.__ 金额 @amount.setter def 金额（自身，金额）： 如果金额 < 10： 自我._
_金额 = 10 elif 金额 > 1000000: self.__金额 = 1000000 别的： self.__金额 = 金
额慈善=捐赠(5)慈善金额10class donation: def __init__(self,amount): self.am
ount = amount @property def amount(self): return self.__amount @
amount.setter def amount(self, amount): if amount < 10: self.__am
ount = 10 elif amount > 1000000: self.__amount = 1000000 else: se
lf.__amount = amountcharity = donation(5)charity.amount10如何导入类1、在
本节中，我们将介绍如何从不同的文件或目录加载类。 ”“”汽车类”“”驾驶室类别： #第一次迭代初始化 出租车数量 = 0 def
__init__(自我、司机、公里数、工资): self.driver = 驱动程序 自运行=公里 自助账单 = 付款 出租车数
= 出租车数 + 1 #返回每公里平均价格 def 每公里率（自身）： 返回 self.bill/self.running #
返回正在运行的出租车数量 @类方法 def noofcabs(cls): 返回 cls.numberofcabs如果 __name
__ == "__main__": #出租车班 第一出租??车 = Cab("拉梅什", 80, 1200) Cab 类中的 #
driver 属性 打印（firstcab.driver） #类方法 打印(Cab.noofcabs())导入操作系统os.ch
dir("C:/Users/DELL/Desktop/")导入我的模块Mymodule.py 中的 #Cab 类Firstcab
= Mymodule.Cab("拉梅什", 80, 1200)cab 类中的 #driver 属性第一出租??车司机Mymodul
e2.py 中的#rateperkm 实例方法Firstcab.rateperkm()Mymodule2.py 中的 #noofc
abs 类方法Mymodule.Cab.noofcabs()"""Car Class"""class Cab: #Initial
ise for first iteration numberofcabs = 0 def __init__(self,drive
r,kms,pay): self.driver = driver self.running = kms self.bill = p
ay Cab.numberofcabs = Cab.numberofcabs + 1 #Returns average pric
e per km def rateperkm(self): return self.bill/self.running #Ret
urns number of cabs running @classmethod def noofcabs(cls): retur
n cls.numberofcabsif __name__ == "__main__": #Cab class firstcab
= Cab("Ramesh", 80, 1200) #driver attribute in Cab class print(
firstcab.driver) #class method print(Cab.noofcabs())2、在下面的代码中，指定
Mymodule.py存储文件的目录导入操作系统os.chdir("C:/Users/DELL/Desktop/")导入我的模块i
mport osos.chdir("C:/Users/DELL/Desktop/")import Mymodule3、像平常一样创
建对象或运行方法。在使用类和类方法之前确保添加模块名称作为前缀Mymodule.py 中的 #Cab 类Firstcab = My
module.Cab("拉梅什", 80, 1200)cab 类中的 #driver 属性第一出租??车司机Mymodule2.py 中的#rateperkm 实例方法Firstcab.rateperkm()Mymodule2.py 中的 #noofcabs 类方法Mymodule.Cab.noofcabs()#Cab class in Mymodule.pyfirstcab = Mymodule.Cab("Ramesh", 80, 1200)#driver attribute in cab classfirstcab.driver#rateperkm instance method in Mymodule2.pyfirstcab.rateperkm()#noofcabs classmethod in Mymodule2.pyMymodule.Cab.noofcabs()在下面的代码中，指定Mymodule.py存储文件的目录像平常一样创建对象或运行方法。在使用类和类方法之前确保添加模块名称作为前缀为了避免编写模块名称来访问类，您可以使用“from”将模块加载到当前命名空间中。 从我的模块导入Firstcab = Cab("桑迪", 80, [''德里'', ''诺伊达''], 1200, 3)from Mymodule import firstcab = Cab("Sandy", 80, [''Delhi'', ''Noida''], 1200, 3)什么是 __name__ == "__main__"？if __name__ == ''__main__'':当您直接（从终端）运行 .py 文件时，将执行其中的任何代码。如果导入 module?import Mymodule，里面的代码if __name__ == ''__main__'':将不会运行。要测试这一点，请从终端保存并运行以下脚本，并使用 import 命令访问它。 如果 __name__ == ''__main__'': print(''第一个结果'')别的： print(''第二个结果'')if __name__ == ''__main__'': print(''First Result'')else: print(''Second Result'')如何在命令提示符中更改目录键入cd，后跟空格，然后键入文件夹名称。设置正确的目录后，您可以输入 python 脚本文件的名称。请参阅下面的快照。 ?编辑锻炼创建Rectangle具有长度和宽度属性的类。创建 2 种计算矩形面积和矩形周长的方法。面积通过长度乘以宽度来计算。周长是（长+宽）的2倍。解决并将您的解决方案发布在评论框中。结论完成本教程后，您一定对 Python 中使用的面向对象编程的重要主题有了很好的了解。您的下一步应该是练习您所学的概念。尝试在您的实际项目中使用它。? |
|
