Python学习笔记06-类与文件和异常

面向对象编程

创建和使用类,dog.py

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!")

在Python 2.7中创建类

在Python 2.7中创建类时，需要做细微的修改——在括号内包含单词 object ：

class  ClassName (object):


class Dog(object):
-- 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.name

调用方法
my_dog.sit()
my_dog.roll_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()

给属性指定默认值

里面是用构造函数给赋值的

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):
        -- snip --

   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()

修改属性的值

class Car():
-- snip --


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()

通过方法修改属性的值
 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

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()

继承

子类的方法 init()

父类
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):

子类
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
    """初始化父类的属性"""
        super().__init__(make, model, year)



my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

2016 Tesla Model S

Python 2.7 中的继承

class Car(object):
    def __init__(self, make, model, year):
    -- snip --


class ElectricCar(Car):
    def __init__(self, make, model, year):
        super(ElectricCar, self).__init__(make, model, year)

给子类定义属性和方法

class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""
    def __init__(self, make, model, year):
        """
        电动汽车的独特之处
        初始化父类的属性，再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery_size = 70

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")


my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

重写父类的方法

可在子类中定义一个这样的方法，
即它与要重写的父类方法同名。
这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。
calss ElectricCar(Car):
    -- snip --
    def fill_gas_tank():
    """电动汽车没有油箱"""
        print("This car doesn't need a gas tank!")

将实例用作属性

class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    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.")

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
    """
    初始化父类的属性，再初始化电动汽车特有的属性
    """
        super().__init__(make, model, year)
        self.battery = Battery()


my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

导入类

导入单个类-my_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_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

另一个类

from car import Car


my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23

在一个模块中存储多个类

class Car():
-- snip --
class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=60):
        """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
    def get_range(self):
        """打印一条描述电瓶续航里程的消息"""
        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().__init__(make, model, year)
        self.battery = Battery()

导入的类的中my_electric_car.py

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()
输出与我们前面看到的相同，但大部分逻辑都隐藏在一个模块中：
2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full charge.

从一个模块中导入多个类

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())

导入整个模块

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 * 不推荐使用这种导入方式

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

electric_car.py
from car import Car
class Battery():
-- snip --
class ElectricCar(Car):
-- snip --


car.py
class Car():
-- snip --


my_cars.py
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 都包含它

from collections import OrderedDict

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() + ".")


Jen's favorite language is Python.
Sarah's favorite language is C.
Edward's favorite language is Ruby.
Phil's favorite language is Python.

从文件中读取数据

读取整个文件

file_reader.py

with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents)

关键字 with 在不再需要访问文件后将其关闭无需调用close()

文件路径

在Linux和OS X中，你可以这样编写代码：
with open('text_files/ filename .txt') as file_object:
Windows系统中，在文件路径中使用反斜杠（ \ ）而不是斜杠（ / ）：
with open('text_files\ filename .txt') as file_object:

逐行读取

filename = 'pi_digits.txt'

with open(filename) as file_object:
    for line in file_object:
        print(line.rstrip())

创建一个包含文件各行内容的列表

filename = 'pi_digits.txt'

with open(filename) as file_object:
    lines = file_object.readlines()

for line in lines:
    print(line.rstrip())

写入文件

write_message.py

filename = 'programming.txt'

with open(filename, 'w') as file_object:
 file_object.write("I love programming.")

添加到文件上

filename = 'programming.txt'

with open(filename, 'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")
    file_object.write("I love creating apps that can run in a browser.\n")

异常

使用 try-except 代码块

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

使用异常避免崩溃

else 代码块等于其它语言的final

try:
    answer = int(first_number) / int(second_number)
except ZeroDivisionError:
    print("You can't divide by 0!")
    有异常不会到else里面
else:
    print(answer)

处理 FileNotFoundError 异常

filename = 'alice.txt'
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError:
    msg = "Sorry, the file " + filename + " does not exist."
    print(msg)

失败时一声不吭

Python有一个 pass 语句，可在代码块中使用它来让Python什么都不要做

except FileNotFoundError:
    pass

将数字列表存贮到json文件里面

import json
numarr = [2,3,4,5,6,7]

filename = 'numbers.json'

with open(filename,'w') as f_obj:
    json.dump(numbers, f_obj)

读取

import json
filename = 'numbers.json'

with open(filename) as f_obj:
    numbers = json.load(f_obj)

print(numbers)