python笔记：类

一、创建和使用类

注：在Python中，类的名称首字母需要大写。

（1）以创建Dog类为例

设定Dog类具有名字和年龄两个信息，以及打滚和蹲下两种行为。

>>> class Dog:
...     """一次模仿小狗的简单尝试"""
...     def __init__(self,name,age):
...             self.name=name
...             self.age=age
...     def sit(self):
...             """模仿小狗收到命令后坐下"""
...             print(f"{self.name} is now sitting")
...     def roll_over(self):
...             """模仿小狗打滚"""
...             print(f"{self.name} rolled over")
...

• 类中的函数称为方法,上一节我们学到的有关函数的一切都适用于方法，就目前而言，唯一重要的区别在于调用方法的方式。
• init是个特殊的方法，每当你根据Dog类 创建新实例的时候，Python都会自动运行它
• 开头和末尾各有两个下划线,旨在避免Python的默认方法和普通方法名称发生冲突（如果你没有注意，只各输入了一个下划线会发生takes no arguments错误）
• init方法的定义包含三个形参：init、name、age。这里形参self的意义在于：每个与实例相关联的方法调用都自动传入实参self，他是一个指向实例本身的引用，让实例访问类中的属性和方法。
• 当我们通过实参向Dog()传递名字的时，将自动传入
• 以self为前缀的变量可供类中的所有方法使用
• self.name=name获取与形参name相关联的值并赋给变量name，然后该变量被关联到当前所创建的实例。像这样可以通过实例访问的变量称为属性。

（2）根据类创建实例

根据类来创建对象称为类的实例化。
注：通常认为小写名称指的是类创建的实例

>>> class Dog:
...     """一次模仿小狗的简单尝试"""
...     def __init__(self,name,age):
...             self.name=name
...             self.age=age
...     def sit(self):
...             """模仿小狗收到命令后坐下"""
...             print(f"{self.name} is now sitting")
...     def roll_over(self):
...             """模仿小狗打滚"""
...             print(f"{self.name} rolled over")
...
>>> my_dog=Dog("Blake",2)

• 访问属性

>>> print(f"My dog's name is {my_dog.name}")
My dog's name is Blake
>>> print(f"it is {my_dog.age} years old")
it is 2 years old

访问实例的属性可以使用句点表示法

• 调用方法
  根据类创建实例过后，就可以通过句点表示法来调用类中定义的方法了，要调用方法，可指定实例的名称和要调用的方法

>>> my_dog.sit()
Blake is now sitting
>>> my_dog.roll_over()
Blake rolled over

• 创建多个实例
  你可以按需求根据一个类创建任意数量的实例，条件时将每个实例都存储在不同的变量中，或者占用列表或字典的不同位置。

二、使用类和实例

（1）以Car类为例

设定汽车含有制造商、型号、年份三个信息

>>> class Car:
...     """一次模拟汽车的简单尝试"""
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...     def get_descriptive_name(self):
...             long_name=f"{self.make} {self.model} {self.year}"
...             return long_name
...
>>> my_new_car=Car("Ford","Escape",2017)
>>> print(my_new_car.get_descriptive_name())
Ford Escape 2017

为了让这个类更有趣，下面为它增添一个随时间变化的属性，用来存储汽车的总里程。

（2）给属性指定默认值

创建实例的时候，有些属性无需通过形参来定义。可以直接在init()方法中指定默认值
下面来添加一个odometer_reading的属性，其初始值总是为0.并添加一个名为read_odometer()的方法，用于读取汽车的里程表

>>> class Car:
...     """一次模仿汽车的简单尝试"""
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer_reading=0
...     def read_odometer(self):
...             print(f"The car has ran {self.odometer_reading} miles")
...
>>> my_new_car=Car("Ford","Escape",2017)
>>> my_new_car.read_odometer()
The car has ran 0 miles

（3）修改属性的值

而汽车的历程随着汽车的使用会发生改变，这就需要我们修改属性的值。而我们可以用三种方法修改属性的值。下面我们依次介绍这些方法。

• 直接修改属性的值

>>> class Car:
...     """一次模仿汽车的简单尝试"""
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer=0
...
>>> my_new_car=Car("Ford","Escape",2017)
>>> my_new_car.odometer=1000
>>> print(f"The car has {my_new_car.odometer} on it")
The car has 1000 on it

• 通过方法修改属性的值

>>> class Car:
...     """一次模仿汽车的简单尝试"""
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer=0
...     def update_odometer(self,mileage):
...             if(mileage>=self.odometer):
...                     self.odometer=mileage
...             else:
...                     print("You cant roll back an odometer")
...
>>> my_new_car=Car("Ford","Escape",2017)
>>> my_new_car.update_odometer(1000)
>>> print(my_new_car.odometer)
1000
>>> my_new_car.update_odometer(500)
You cant roll back an odometer

• 通过方法对属性的值进行递增
  有时候需要将属性值递增特定的量，而不是设置为全新的值.假设我们购买了一辆二手车，且从购买到登记期间增加了100英里的里程。下面的这个方法能够让我们传递这个增量，并相应的增大里程表的读数

>>> class Car:
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer=0
...     def read_odometer(self):
...             print(f"the car has ran {self.odometer} miles on it")
...     def update_odometer(self,mileage):
...             self.odometer=mileage
...     def increment_odometer(self,miles):
...             self.odometer+=miles
...
...
>>> my_new_car =Car("Ford","Escape",2017)
>>> my_new_car.increment_odometer(1000)
>>> my_new_car.read_odometer()
the car has ran 1000 miles on it
>>> my_new_car.increment_odometer(5000)
>>> my_new_car.read_odometer()
the car has ran 6000 miles on it

注：你可以使用类似于上面的方法来控制用户修改属性的值。但能够访问程序的人都可以通过直接访问属性来将里程表修改为任何值。因此要确保安全，除了进行类似于前面的基本检查外，还需注意特别的细节。

三、继承

编写类时，并不是都需要从空白开始。如果需要在一个类的基础上改变和扩展，可以使用继承。一个类继承另一个类，将自动获得这个类的所有属性和方法，并在此基础上定义自己的属性和方法，原有的类是父类，而新的类为子类。

（1）子类的方法init()

上面，我们创建了Car类，下面，我们模仿电动汽车来创建一个简单的子类ElectricCar,

>>> class Car:
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer_reading=0
...     def get_descriptive_name(self):
...             long_name=f"{self.year}{self.make}{self.model}"
...             return long_name.title()
...     def read_odometer(self):
...             print(f"This car has {self.odometer_reading} miles on it")
...     def update_odometer(self,mileage):
...             if mileage>=self.odometer_reading:
...                     self.odometer_reading=mileage
...             else:
...                     print("You cant roll back an odometer")
...     def increment_odometer(self,miles):
...             self.odometer_reading+=miles
...
>>> class ElectricCar(Car):
...     def __init__(self,make,model,year):
...             super().__init__(make,model,year)
...
>>> my_ford=ElectricCar("Ford","Escape",2017)
>>> print(my_ford.get_descriptive_name())
2017Fordescape

注： super()是一个特殊的函数，让你能够调用父类的方法

（2）给子类定义属性和方法

让一个类继承另一个类后，就可以定义新类自己的属性和方法了

>>> class Car:
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer_reading=0
...     def get_descriptive_name(self):
...             long_name=f"{self.year}{self.make}{self.model}"
...             return long_name.title()
...     def read_odometer(self):
...             print(f"This car has {self.odometer_reading} miles on it")
...     def update_odometer(self,mileage):
...             if mileage>=self.odometer_reading:
...                     self.odometer_reading=mileage
...             else:
...                     print("You cant roll back an odometer")
...     def increment_odometer(self,miles):
...             self.odometer_reading+=miles
...
>>> class ElectricCar(Car):
...     def __init__(self,make,model,year):
...             super().__init__(make,model,year)
...             self.battery_size=80
...     def describe_battery(self):
...             print(f"This car has a {self.battery_size}kwh battery")
...
>>> my_ford=ElectricCar("Ford","Escape",2017)
>>> my_ford.describe_battery()
This car has a 80kwh battery

• 添加了新属性self.battery_size,并设置初始值。
• 添加了名为descirbe_battery的方法，用来打印此车的电瓶信息。

（3）重写父类的方法

如果父类的方法不符合子类模拟实物的行为，就可以在子类中定义一个与父类方法同名的方法，从而实现对父类方法的重写。

（4）将实例用作属性

使用代码模拟实物，你可能发现自己给类添加的细节越来越多，属性、方法以及文件也随之变长。这种情况下，你可以将大类拆分成多个协同工作的小类。
例如：在不断给ElectricCar类添加细节的时候，我们可能发现其中有许多关于电瓶battery的属性和方法。在这种情况下，我们可以将这些属性和方法提取出来，放到Battery类中，并将Battery类作为ElectricCar类的属性

>>> class Car:
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             self.odometer_reading=0
...     def get_descriptive_name(self):
...             long_name=f"{self.year}{self.make}{self.model}"
...             return long_name.title()
...     def read_odometer(self):
...             print(f"This car has {self.odometer_reading} miles on it")
...     def update_odometer(self,mileage):
...             if mileage>=self.odometer_reading:
...                     self.odometer_reading=mileage
...             else:
...                     print("You cant roll back an odometer")
...     def increment_odometer(self,miles):
...             self.odometer_reading+=miles
...
>>> class Battery:
...     def __init__(self,battery_size=75):
...             self.battery_size=battery_size
...     def describe_battery(self):
...             print(f"The car has a {self.battery_size}kwh battery")
...
>>> class ElectricCar(Car):
...     def __init__(self,make,model,year):
...             super().__init__(make,model,year)
...             self.battery=Battery()
...
>>> my_ford=ElectricCar("Ford","Escape",2017)
>>> my_ford.battery.describe_battery()
The car has a 75kwh battery

• 在ElectricCar类中，添加了一个名为self.battery的属性，并创建一个新的Battery实例赋值给它。每当ElectricCar类的init方法被调用的时候都会进行这个操作，故而每个ElectricCar实例都包含了一个自动创建的 Battery实例。
  下面再给Battery类添加一个方法，它根据电瓶容量报告汽车的续航里程：

>>> class Car:
...     def __init__(self,make,model,year):
...             self.make=make
...             self.model=model
...             self.year=year
...             odometer_reading=0
...     def get_descriptive_name(self):
...             long_name=f"{self.year} {self.make} {self.model}"
...             return long_name.title()
...     def read_odometer(self):
...             print(f"This car has {self.odometer_reading} miles on it")
...     def update_odometer(self,mileage):
...             if mileage>=self.odometer_reading:
...                     self.odometer_reading=mileage
...             else:
...                     print("You cant roll back an odometer")
...     def increment_odometer(self,miles):
...             self.odometer+=miles
...
>>> class Battery:
...     def __init__(self,battery_size=75):
...             self.battery_size=battery_size
...     def describe_battery(self):
...             print(f"The car has a {self.battery_size}kwh battery")
...     def get_range(self):
...             if self.battery_size==75:
...                     range=300
...             elif self.battery_size==80:
...                     range=250
...             print(f"The car can go about {range} miles on a full charge")
...
>>> class ElectricCar(Car):
...     def __init__(self,make,model,year):
...             super().__init__(make,model,year)
...             self.battery = Battery(80)
...
>>> my_ford=ElectricCar("Ford","Escape",2017)
>>> my_ford.battery.get_range()
The car can go about 250 miles on a full charge

四、导入类

python允许将类存储在模块当中，然后在主程序中导入所需的模块

（1）导入单个类

（2）在一个模块中存储多个类

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

（4）导入整个模块

（5）导入模块中的所有类

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

五、Python标准库

标准库里的两个的函数

randint()

用于生成两个数之间的随机数

>>> from random import randint
>>> randint(1,6)
3

choice()

它将一个列表或元组作为参数，并随即返回其中的一个元素

>>> from random import choice
>>> players=["Blake","Jordan","Harden"]
>>> choosen_one=choice(players)
>>> choosen_one
'Jordan'