Python ❀ 类（python下载安装教程）

Python ❀ 类（python下载安装教程）

文章目录

​​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 amy 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 sittingA 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 sittingA is now rollyou 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_nameif __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 A4None!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 A4None!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 A4None!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 outbackNone!200None!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 sthis 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-kWhthis 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 Carmy_car = Car("Audi","A4",2022)print(my_car.get_name())my_car.odometer_reading = 23my_car.read_odometer()

输出结果：

2022 Audi Audithis 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 += milesclass 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 ElectricCarmy_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,ElectricCarmy_car = Car("Audi","A4",2022)print(my_car.get_name())my_tesla = ElectricCar('tesla','s',2020)print(my_tesla.get_name())

输出结果：

2022 Audi Audi2020 tesla tesla

4.4 导入整个模块

支持导入整个模块内容；

import carmy_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 Audi2020 tesla tesla

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

4.5 导入模块中所有的类

不推荐使用此方式导入；

import [module_name] import *

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

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

class Car():~将Battery类与ElectricCar类存放于第二个文件，此文件需要导入Car类；from car import Carclass Battery():~class ElectricCar(Car):~

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

from car import Carfrom electriccar import ElectricCarmy_car = Car("Audi","A4",2022)print(my_car.get_name())my_tesla = ElectricCar('tesla','s',2020)print(my_tesla.get_name())

输出结果：

2022 Audi Audi2020 tesla tesla

5、标准库

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

from random import randintprint(randint(0,1))print(randint(0,1))print(randint(0,1))

输出结果：

010

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。