当前位置 : 主页 > 编程语言 > python >

Python ❀ 类

来源:互联网 收集:自由互联 发布时间:2022-06-27
文章目录 ​​1、创建与使用​​ ​​1.1 创建一个简单的类​​ ​​1.2 根据类创建实例​​ ​​1.2.1 访问属性​​ ​​1.2.2 调用方法​​ ​​1.2.3 创建多个实例​​ ​​2、类和实


文章目录

  • ​​1、创建与使用​​
  • ​​1.1 创建一个简单的类​​
  • ​​1.2 根据类创建实例​​
  • ​​1.2.1 访问属性​​
  • ​​1.2.2 调用方法​​
  • ​​1.2.3 创建多个实例​​

  • ​​2、类和实例​​
  • ​​2.1 创建一个类​​
  • ​​2.2 给属性指定默认值​​
  • ​​2.3 修改属性的值​​
  • ​​2.3.1 直接修改属性的值​​
  • ​​2.3.2 通过方法修改属性的值​​
  • ​​2.3.3 通过方法对属性的值进行递增​​

  • ​​3、继承​​
  • ​​3.1 子类的方法__init__( )​​
  • ​​3.2 Python 2.7版本中的继承​​
  • ​​3.3 给子类定义属性和方法​​
  • ​​3.4 重写父类的方法​​
  • ​​3.5 将实例用作属性​​
  • ​​4、导入类​​
  • ​​4.1 导入单个类​​
  • ​​4.2 单个模块存储多个类​​
  • ​​4.3 从一个模块中导入多个类​​
  • ​​4.4 导入整个模块​​
  • ​​4.5 导入模块中所有的类​​
  • ​​4.6 在一个模块内导入另一个模块​​
  • ​​5、标准库​​

1、创建与使用


使用类可以模拟任何对象,根据类创建对象被称为实例化;

1.1 创建一个简单的类

根据Dog类创建的每一个实例都将存储名字与年龄,并赋予其sit( )与roll( )能力;

class Dog():
# 上面类Dog的一个详细描述,以展示其功能0

def __init__(self,name,age):
# 解释第一个方法
self.name = name
self.age = age

def sit(self):
# 解释第二个方法
print(self.name.title() + "is now sitting")

def roll(self):
# 解释第三个方法
print(self.name.title() + "is now roll")

在Python中,首字母大写的名称指的是类,上述类的定义括号内容为空,需要从空白创建这个类;
类中的函数称之为方法,所有对于函数的限制都适用于方法,方法与函数的唯一区别就是调用方式不同; 代码中__init__()是一个比较特殊的方法,当你根据Dog类创建新实例时,Python会自动运行它,在这个方法的名称中,前后均有两个下划线,这是一种Python规范,意在避免Python默认方法与普通方法发生名称冲突而导致其失效;
方法__init__()中定义了包含三个形参:self、name、age;形参self必须存在且在其他参数前面,Python调用方法__init__()来创建Dog实例时,自动传入实参self,每个与类相关联的方法调用都自动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性与方法;当创建Dog实例时,Python将调用Dog类的方法__init__(),通过实参向Dog()传递名字与年龄,self会自动传递,因此不需要传递它,每当根据Dog类创建实例时,都只需要给最后两个形参提供具体的值即可;
self.name = name定义两个变量都有前缀self,以self为前缀的变量都可供类中的所有方法使用,还可以通过类的任何实例来访问这些变量,self.name = name获取存储在形参name中,然后变量被关联到当前创建的实例中;像这样可以通过实例访问的变量被称之为属性;
Dog类还定义了两个方法sit()与roll(),由于这些方法不需要额外的信息,因此它们只有一个形参self,后面将创建的实例能够访问这些方法;

1.2 根据类创建实例

可将类视为有关如何创建实例的说明;

class Dog():

def __init__(self,name,age):
self.name = name
self.age = age

def sit(self):
print(self.name.title() + "is now sitting")

def roll(self):
print(self.name.title() + "is now roll")

my_dog = Dog("a",10)
print("My dog name is " + my_dog.name)
print("my dog age is " + str(my_dog.age))

输出结果:

My dog name is a
my dog age is 10

这里使用的是前面示例中的Dog类,首先创建了一条名字为a,年龄为10的小狗对象,遇到这行代码时,Python使用实参a与6调用Dog类中的方法__init__(),方法__init__()创建一个表示特定小狗的示例,并使用提供的值来设置属性name与age;方法__init__()并未显示的包含return语句,但是Python自动返回一个表示这条小狗的实例,将这个实例存储在my_dog变量中(通常情况下,以大写字母开头的名称代表类,全小写名称指类创建的实例);

1.2.1 访问属性

若要访问实例的属性,需要使用句号表示法;如前面的my_dog.name与my_dog.age,这种语法演示了Python如何获悉属性的值,Python首先找到实例my_dog,再查找与这个实例相关联的属性name,在Dog类中引用这个属性时,使用的是self.name;

1.2.2 调用方法

根据Dog类创建实例后,就可以使用句号表示法来调用Dog类中定义的任何方法;

class Dog():

def __init__(self,name,age):
self.name = name
self.age = age

def sit(self):
print(self.name.title() + " is now sitting")

def roll(self):
print(self.name.title() + " is now roll")

my_dog = Dog("a",10)
my_dog.sit()
my_dog.roll()

输出结果:

A is now sitting
A is now roll

要调用方法,可以指定实例的名称和要调用的方法,并用句号分隔它们;遇到代码my_dog.sit()时,Python在Dog类中查找方法sit()并运行其代码返回结果;

1.2.3 创建多个实例

可以安装需求根据类创建人员数量的实例;

class Dog():

def __init__(self,name,age):
self.name = name
self.age = age

def sit(self):
print(self.name.title() + " is now sitting")

def roll(self):
print(self.name.title() + " is now roll")

my_dog = Dog("a",10)
you_dog = Dog("b",12)

my_dog.sit()
my_dog.roll()

print("you dog name is " + you_dog.name)

输出结果:

A is now sitting
A is now roll
you dog name is b

2、类和实例


当类编写完成后,大部分时间都将花费在使用根据类创建实例上,需要执行一个重要任务是修改实例的属性;

2.1 创建一个类

下面编写一个类,用于后面的实验;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year

def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

if __name__ == '__main__':
my_car = Car("BMW","A4",2016)
print(my_car.get_name())

输出结果:

2016 BMW A4

首先定义了方法__init__(),第一个形参为self,另外三个形参:make、model、year;方法__init__()接受这些形参的值,并将它们存储在根据这个类创建的实例的属性中,创建新的Car实例时,需要指定这三个形参的值;接下来定义了一个名称为get_name()的方法,它使用属性year、make、model创建一个对汽车进行描述的字符串;

2.2 给属性指定默认值

类中的每个属性都必须有初始值,哪怕这个值是0或者为空,某些情况下,如果设置默认值,方法__init__()内指定这种初始默认值是可行的;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odo = 0

def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

def read_odo(self):
print("None!" + str(self.odo))

if __name__ == '__main__':
my_car = Car("BMW","A4",2016)
print(my_car.get_name())
my_car.read_odo()

输出结果:

2016 BMW A4
None!0

2.3 修改属性的值

在Python中可以使用三种方式修改属性的值,下面将依次介绍这三种方法;

2.3.1 直接修改属性的值

可以使用句号表示法直接访问并设置汽车的属性;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odo = 0

def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

def read_odo(self):
print("None!" + str(self.odo))

if __name__ == '__main__':
my_car = Car("BMW","A4",2016)
print(my_car.get_name())
# 直接修改属性的值
my_car.odo = 23
my_car.read_odo()

输出结果:

2016 BMW A4
None!23

2.3.2 通过方法修改属性的值

添加一个方法updata_odo(),定了一个形参,关联到我们需要修改的属性,并最终调用此函数并赋予其一个实参即可;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odo = 0

# 添加新方法,修改属性的值
def update_odo(self,new_odo):
self.odo = new_odo

def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

def read_odo(self):
print("None!" + str(self.odo))

if __name__ == '__main__':
my_car = Car("BMW","A4",2016)
print(my_car.get_name())
# 以函数的方法进行修改属性的值
my_car.update_odo(23)
my_car.read_odo()

输出结果:

2016 BMW A4
None!23

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

特殊情况下需要将属性值递增特定的量,而不是将其设置为全新的某个值;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odo = 0

def update_odo(self,new_odo):
self.odo = new_odo

#添加一个新方法,以递增的方法修改属性的值
def incr_odo(self,miles):
self.odo += miles
# self.odo += miles 等同于 self.odo = self.odo + miles

def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

def read_odo(self):
print("None!" + str(self.odo))

if __name__ == '__main__':
my_car = Car('BMW','outback',2020)
print(my_car.get_name())

my_car.update_odo(200)
my_car.read_odo()

my_car.incr_odo(300)
my_car.read_odo()

输出结果:

2020 BMW outback
None!200
None!500

新增一个方法incr_odo(),用来以递增的方式修改属性self.odo的值,当self.odo为0时,首先修改为200,其次在200的基础上增加300,即返回500;

3、继承


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

3.1 子类的方法__init__( )

创建子类的实例时,Python首先需要完成的任务是给父类的所有属性赋值,为此,子类的方法__init__()需要父类进行限制;下面用一个案例进行说明:

class Car():
~

class ElectricCar(Car):

def __init__(self,make,model,year):
# 初始化父类的属性
super().__init__(make,model,year)
#子类调用父类Car的__init__方法

if __name__ == '__main__':
my_elcar = ElectricCar('tesla','s','2020')
print(my_elcar.get_name())

输出结果:

2020 tesla s

首先Car类的代码创建子类时,父类必须包含在当前文件中,且位于子类前面;当定义了子类ElectricCar时,必须在括号内指定父类的名称,方法__init__()接受创建Car实例所需的信息;
super()为一个特殊函数,帮助Python将父类和子类关联起来,让Python调用ElectricCar父类的方法__init__(),让ElectricCar实例包含父类的所有属性,父类也称之为超类,super函数因此而来;
为了测试这一结果,将创建一个ElectricCar的实例,并将其存储在变量my_elcar中;当这行代码调用ElectricCar类中的__init__()方法时,后者调用父类Car中定义的方法__init__(),从而提供了实参的值;

3.2 Python 2.7版本中的继承

函数super()需要两个参数:子类名称与对象self;在Python 2.7中必须在定义父类时在括号内指定object;

class Car(object):
#指定object
~
class ElectricCar(Car):

def __init__(self,make,model,year):
super(ElectricCar,self).__init__(make,model,year)
# super函数指定子类名称与对象self

3.3 给子类定义属性和方法

让一个类继承另一个类后,可以添加区分子类和父类所需的新属性和方法;
下面以添加子类特有的属性,以及一个描述该属性的方法进行说明:

class Car():
~

class ElectricCar(Car):

def __init__(self,make,model,year):
# 初始化父类的属性
super().__init__(make,model,year)
# 子类添加一个新属性
self.size = 70

# 子类添加一个新方法用来描述新创建的属性
def battery(self):
print("this car has a " + str(self.size) + "-kWh battery")

if __name__ == '__main__':
my_elcar = ElectricCar('tesla','s','2020')
print(my_elcar.get_name())
# 调用子类创建的新方法
my_elcar.battery()

输出结果:

2020 tesla s
this car has a 70-kWh battery

3.4 重写父类的方法

对于父类的方法,只要不满足子类的要求就可以对其进行重写;因此可以在子类中定义一个同名的方法,以此来替换掉父类的方法;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odo = 0

def update_odo(self,new_odo):
self.odo = new_odo

def incr_odo(self,miles):
self.odo += miles

#父类的方法
def get_name(self):
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name

def read_odo(self):
print("None!" + str(self.odo))

class ElectricCar(Car):

def __init__(self,make,model,year):
# 初始化父类的属性
super().__init__(make,model,year)
self.size = 70

# 子类创建一个与父类同名的方法,并修改其执行结果
def get_name(self):
print("this is change")

def battery(self):
print("this car has a " + str(self.size) + "-kWh battery")

if __name__ == '__main__':
my_elcar = ElectricCar('tesla','s','2020')
my_elcar.get_name()

输出结果:

this is change

当子类与父类拥有同名的方法时,调用结果为子类的代码,可以使用此方法修改所有子类无法契合的所有父类方法;

3.5 将实例用作属性

使用代码模拟实物时,就会发现给类添加的属性与方法会越来越多,在这种情况下就可以将部分属性作为一个单独的类提取出来(将一个大类拆分成多个小类);

class Car():
~

# 创建一个新类,没有继承父类
class Battery():

def __init__(self,battery_size=70):
# 属性初始化,定义默认实参
self.battery_size = battery_size

def desc_battery(self):
print("this is " + str(self.battery_size) + "-kWh")

class ElectricCar(Car):

def __init__(self,make,model,year):
super().__init__(make,model,year)
# 创建一个新的实例,将实例内容存储在属性self.battery中
self.battery = Battery()

def get_name(self):
print("this is change")

def battery(self):
print("this car has a " + str(self.size) + "-kWh battery")

if __name__ == '__main__':
my_elcar = ElectricCar('tesla','s','2020')
my_elcar.battery.desc_battery()

输出结果:

this is 70-kWh

下面再给Battery类添加一个方法,详细描述续航能力;

class Car():
~

class Battery():

def __init__(self,battery_size=70):
self.battery_size = battery_size

def desc_battery(self):
print("this is " + str(self.battery_size) + "-kWh")

# 添加一个新方法
def get_range(self):
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270

print("this is car can go " + str(range) + "miles")

class ElectricCar(Car):

def __init__(self,make,model,year):
# 初始化父类的属性
super().__init__(make,model,year)
self.battery = Battery()

def get_name(self):
print("this is change")

def battery(self):
print("this car has a " + str(self.size) + "-kWh battery")

if __name__ == '__main__':
my_elcar = ElectricCar('tesla','s','2020')
my_elcar.battery.desc_battery()
# 调用新方法
my_elcar.battery.get_range()

输出结果:

this is 70-kWh
this is car can go 240miles

4、导入类


随着不断地进行类添加功能,文件长度会持续加长,因此可以将类存储在模块中,在主程序中导入所需的模块即可;

4.1 导入单个类

创建一个只包含Car类的摸快,将Car类的代码创建为一个名称为car.py的文件,下面将使用此文件作为模块进行导入操作;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.make
return long_name

def read_odometer(self):
print('this is car has ' + str(self.odometer_reading) + ' miles')

def update_odometer(self,mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("you can't roll back an odometer")

def incre_odometer(self,miles):
self.odometer_reading += miles

创建好模块后,打开一个新文件,导入该模块;

from car import Car

my_car = Car("Audi","A4",2022)
print(my_car.get_name())
my_car.odometer_reading = 23
my_car.read_odometer()

输出结果:

2022 Audi Audi
this is car has 23 miles

4.2 单个模块存储多个类

Python支持可以单个模块文件内包含多个类;

class Car():

def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0

def get_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.make
return long_name

def read_odometer(self):
print('this is car has ' + str(self.odometer_reading) + ' miles')

def update_odometer(self,mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("you can't roll back an odometer")

def incre_odometer(self,miles):
self.odometer_reading += miles

class Battery():

def __init__(self,battery_size=70):
self.battery_size = battery_size

def desc_battery(self):
print(" this is car has a " + str(self.battery_size) + " -kWh ")

def get_range(self):
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
print(" this car can go " + str(range) + " miles ")

class ElectricCar(Car):

def __init__(self,make,model,year):
super().__init__(make,model,year)
self.battery = Battery()

创建好模块后,打开一个新文件,导入该模块的某个类;

from car import ElectricCar

my_tesla = ElectricCar('tesla','s',2020)
print(my_tesla.get_name())
my_tesla.battery.desc_battery()
my_tesla.battery.get_range()

输出结果:

2020 tesla tesla
this is car has a 70 -kWh
this car can go 240 miles

4.3 从一个模块中导入多个类

支持从单个模块中导入多个类;

from car import Car,ElectricCar

my_car = Car("Audi","A4",2022)
print(my_car.get_name())

my_tesla = ElectricCar('tesla','s',2020)
print(my_tesla.get_name())

输出结果:

2022 Audi Audi
2020 tesla tesla

4.4 导入整个模块

支持导入整个模块内容;

import car

my_car = car.Car("Audi","A4",2022)
print(my_car.get_name())

my_tesla = car.ElectricCar('tesla','s',2020)
print(my_tesla.get_name())

输出结果:

2022 Audi Audi
2020 tesla tesla

需要注意的是,导入整个模块后,调用某个类要使用句号表示法引用;

4.5 导入模块中所有的类

不推荐使用此方式导入;

import [module_name] import *

4.6 在一个模块内导入另一个模块

如果模块代码较多时,需要将模块分开,因此就需要在一个模块内导入另一个模块;
将Car类单独存放于一个文件;

class Car():
~

将Battery类与ElectricCar类存放于第二个文件,此文件需要导入Car类;
from car import Car

class Battery():
~

class ElectricCar(Car):
~

打开新文件,分别导入Car类与ElectricCar类进行调用;

from car import Car
from electriccar import ElectricCar

my_car = Car("Audi","A4",2022)
print(my_car.get_name())

my_tesla = ElectricCar('tesla','s',2020)
print(my_tesla.get_name())

输出结果:

2022 Audi Audi
2020 tesla tesla

5、标准库


Python标准库是一组模块,安装的Python环境都会包含它,下面用一个例子以证明:random 随机模块;

from random import randint

print(randint(0,1))
print(randint(0,1))
print(randint(0,1))

输出结果:

0
1
0


上一篇:Python ❀ while循环
下一篇:没有了
网友评论