Python编程：从入门到实践（读书笔记：第9章 类）

coding=gbk

coding:utf-8!

chapter 9 类

根据类来创建对象被称为实例化

创建和使用类

创建Dog类

class Dog(): #python中，首字母大写的名称指的是类
“”“一次模拟小狗的简单尝试”""
def init(self, name, age): #方法_ init _()是类中的函数
“”“初始化属性name和age”"" #self必不可少且须位于其他形参前
self.name = name #获取存储在形参name中的值并将其存储到name中
self.age = age #然后变量被关联到当前创建的实例 变量被称属性
def sit(self):
“”“模拟小狗被命令时蹲下”""
print(self.name.title() + " rolled over!")
def roll_over(self):
“”“模拟小狗被命令时打滚”""
print(self.name.title() + " rolled over!")

根据类创建实例

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

Dog类是一系列说明，让Python直到如何创建表示特定小狗的实例

print(“创建表示特定小狗的实例”)
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!")
# 书中的“–snip–”代表省略代码，需要将前面的代码贴过来
my_dog = Dog(‘willie’, 6)
print("My dog’s name is " + my_dog.name.title() + “.”)
print(“My dog is " + str(my_dog.age) + " years old.”)
my_dog.sit() # 注意这里实例与方法的位置：实例.方法
my_dog.roll_over()

创建多个实例

print("\n创建多个实例")
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)
your_dog = Dog(‘lucy’, 3)
print(“My dog’s name is " + my_dog.name.title() + “.”)
print(“My dog is " + str(my_dog.age) + " years old.”)
my_dog.sit()
print(”\nYour dog’s name is " + your_dog.name.title() + “.”)
print(“Your dog is " + str(your_dog.age) + " years old.”)
your_dog.sit()

使用类和实例

Car类

print("\nCar类")
class Car():
“”“一次模拟汽车的简单尝试”""
def init(self, make, model, year):
“”“初始化描述汽车的属性”""
self.make = make
self.model = model
self.year = year
def get_discriptive_name(self):
“”“返回整洁的描述性信息”""
long_name = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_discriptive_name())

给属性指定默认值

print("\n添加odometer_reading的属性，且初始值总为0")
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 = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
“”“打印一条指出汽车里程的消息”""
print(“This car has " + str(self.odometer_reading) +
" miles on it.”)
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

修改属性的值（三种方法）

方法一：直接修改属性的值

print("\n直接修改属性的值:")
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 = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
“”“打印一条指出汽车里程的消息”""
print(“This car has " + str(self.odometer_reading) +
" miles on it.”)
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

方法二：通过方法修改属性的值

print("\n通过方法修改属性的值:")
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 = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
“”“打印一条指出汽车里程的消息”""
print(“This car has " + str(self.odometer_reading) +
" miles on it.”)
def update_odometer(self, mileage): # 添加方法update_odometer()
“”“将里程表读数设置为指定的值”""
self.odometer_reading = mileage
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()

对方法update_odometer()进行扩展，禁止将里程表回调

print("\n对方法update_odometer()进行扩展，禁止里程表回调：")
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 = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
“”“打印一条指出汽车里程的消息”""
print(“This car has " + str(self.odometer_reading) +
" miles on it.”)
def update_odometer(self, mileage):
“”"
将里程表读数设置为指定的值
禁止将里程表读数往回调
“”"
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print(“You can’t roll back an odometer!”)
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()

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

print("\n通过方法对属性的值进行递增:")
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 = str(self.year) + ’ ’ + self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
“”“打印一条指出汽车里程的消息”""
print(“This car has " + str(self.odometer_reading) +
" miles on it.”)
def update_odometer(self, mileage):
“”"
将里程表读数设置为指定的值
禁止将里程表读数往回调
“”"
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print(“You can’t roll back an odometer!”)
def increment_odometer(self, miles):
“”"
将里程表读数增加指定的量
禁止增量为负
“”"
if miles >= 0:
self.odometer_reading += miles
else:
print(“You can’t add a negtive miles!”)
my_used_car = Car(‘subaru’, ‘outback’, 2013)
print(my_used_car.get_descriptive_name())

my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()

继承

如果编写的类是另一个现成类的特殊版本，可使用继承

一个类继承另一个类时，会自动获得另一个类的属性和方法

原有的类称为父类，新类称为子类，子类还可定义自己的属性和方法

子类的方法__int__()

print("\n类的例子&给子类添加新属性和方法")
class Car():
“”“一次模拟汽车的简单尝试”""
def int(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = str(self.year) + ’ ’ +
self.make + ’ ’ + self.model
return long_name.title()
def read_odometer(self):
print(“This car has " + str(self.odometer_reading)
+ " miles on it.”)
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print(“You can’t roll back an odometer!”)
def increment_odometer(self, miles):
self.odometer_reading += miles
# 创建子类时，父类须在当前文件中且位于子类前面

class Battery(): # 将类的一部分提取出来，放到名为Battery的类中
# 将Battery实例用作ElectricCar类的一个属性
“”“一次模拟电动汽车电瓶的简单尝试”""
def init(self, battery_size=70):
“”“初始化电瓶的属性”""
self.battery_size = battery_size
def describe_battery(self):
“”“打印一条描述电瓶容量的消息”""
print(“This car has a " + str(self.battery_size)
+ “-kWh battery.”)
def get_range(self): # 新增方法get_range()
“”“打印一条消息，指出电瓶的续航里程””"
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = “This car can go approximately "
+ str(range)
message += " miles on a full charge.”
print(message)

class ElectricCar(Car): # 定义子类时，必须在括号内指定父类的名称
“”“电动汽车的独特之处”""
def init(self, make, model, year):
“”“初始化父类的属性”""
super().int(make, model, year)
# super()是特殊函数，帮助Python将父类和子类关联起来
# 让ElectricCar实例包含父类所有属性
# 父类也称为超类(superclass)
self.battery_size = 70
# 添加子类新属性
self.battery = Battery()
# 让python创建一个新的Battery实例，并将其存储在属性
# self.battery当中
def describe_battery(self): # 添加子类新方法
“”“打印一条描述电瓶容量的消息”""
print(“This car has a " +str(self.battery_size) +
“-kWh battery.”)
def fill_gas_tank(self): # 假设父类有一个fill_gas_tank()方法
#通过在子类中重写同名方法进行对父类该方法的重写
“”“电动汽车没有邮箱””"
print(“This car doesn’t need a gas tank!”)

my_tesla = ElectricCar(‘tesla’, ‘models’, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
my_tesla.fill_gas_tank()
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

导入类

将类存储在模块中，在主程序中导入所需模块

导入单个类

建立文件car.py模块，存储类Car

print(“导入单个类”)
from car import Car
my_new_car = Car(‘audi’, ‘a4’, 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

在一个模块中存储多个类

可在一个模块中存储任意数量的类

在文件car.py模块中，增加类Battery

print("\n同一个模块中增加类Battery后")
from car import ElectricCar
my_tesla = ElectricCar(‘tesla’, ‘model s’, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

从一个模块中导入多个类

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

print("\n导入任意数量的类")
from car import Car, ElectricCar
my_beetle = Car(‘volkswagen’, ‘beetle’, 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar(‘tesla’, ‘roadster’, 2016)
print(my_tesla.get_descriptive_name())

导入整个模块

导入整个模块后使用句点表示法访问需要的类

print("\n导入整个模块")
import car
my_beetle = car.Car(‘volkswagen’, ‘beetle’, 2016)
print(my_beetle.get_descriptive_name())
my_tesla = car.ElectricCar(‘tesla’, ‘roadster’, 2016)
print(my_tesla.get_descriptive_name())

导入模块中的所有类

用语法：from module_name import *

不推荐这种方式，可能引发名称方面的困惑

需要从模块中导入很多类的话，最好导入整个模块

并使用module_name.class_name语法来访问类

在一个模块中导入另一个模块

print("\n在一个模块中导入另一个模块")
from car import Car
from electric_car import ElectricCar
my_beetle = Car(‘volkswagen’, ‘beetle’, 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar(‘tesla’, ‘roadster’, 2016)
print(my_tesla.get_descriptive_name())

Python标准库

Python标准库是一组 模块， 安装的Python都包含它

OrderedDict类兼具列表和字典优点（将信息关联同时保留原来顺序）

print("\nPython标准库")
from collections import OrderedDict # 注意collections是小写
favorite_languages = OrderedDict() # 注意左边没有括号
favorite_languages[‘jen’] = ‘python’
favorite_languages[‘sarah’] = ‘c’
favorite_languages[‘edward’] = ‘ruby’
favorite_languages[‘phil’] = ‘python’
for name, language in favorite_languages.items():
print(name.title() + "'s favorite language is " +
language.title() + “.”)

类编码风格

类名采用驼峰命名法，类名中每个单词首字母大写，而不用下划线

实例名和模块名都采用小写格式，单词间加上下划线

空行不要滥用。类中，可用空行分隔方法；模块中，可用2个空行分隔类

若需同时导入标准库中的模块和自己编写的模块，

先编写导入标准库模块的import语句，

再添加一个空行，编写导入自己编写的模块的import语句