python3学习笔记---类

基于类创建对象时，每个对象都自动具备这种通用行为，然后根据需要赋予每个对象独特的个性。

根据类来创建对象被称为实例化，这让你能够使用类的实例。

1、方法__init__()

类中的函数称为方法，函数的一切都适用于方法。

访问属性：要访问实例的属性，可使用句点法：my_dog.name

调用方法: 实例 = class_name(实参）--->实例.function_name()

class Dog():
    '''一次模拟小狗的简单尝试'''
    def __init__(self, name, age):  #类似于构造函数
        self.name = name
        self.age = age


    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + "is sitting  now")


    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + "rolled over !")

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

>>>My dog's name is Willie.
My dog is 6 years old.
Willie is sitting  now
Willie rolled over !

使用类和实例：

给属性指定默认值：类中的每个属性都必须有初始值，哪怕是0或者空字符串。设置默认值时，在方法__init__()内指定这种初始值是可行的，且无需包含为它提供初始值的形参。

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, maker, model, year ):
        """初始化描述汽车的属性"""
        self.maker = maker
        self.model = model
        self.year = year
        self.odometer_reading = 160

    def get_descriptive_name(self):
        """返回的整洁性的描述信息"""
        long_time = str(self.year) + " " + self.maker + " " + self.model
        return long_time.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()

>>>2016 Audi A4
      This car has 160 miles on it.

修改属性的值：

直接通过实例进行修改：

my_new_car.odometer_reading = 23

通过方法进行设置：

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, maker, model, year, mileage):
        """初始化描述汽车的属性"""
        self.maker = maker
        self.model = model
        self.year = year
        self.mileage = mileage

    def get_descriptive_name(self):
        """返回的整洁性的描述信息"""
        long_time = str(self.year) + " " + self.maker + " " + self.model
        return long_time.title()

    def update_odometer(self):

        print("This car has " + str(self.mileage) + " miles on it.")


my_new_car = Car('audi', 'a4', 2016, 1222)
print(my_new_car.get_descriptive_name())

通过方法进行递增（增加特定的值）：

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, maker, model, year, mileage):
        """初始化描述汽车的属性"""
        self.maker = maker
        self.model = model
        self.year = year
        self.mileage = mileage
        self.odometer_reading = 0

    def get_descriptive_name(self):
        """返回的整洁性的描述信息"""
        long_time = str(self.year) + " " + self.maker + " " + self.model
        return long_time.title()

    def read_odometer(self):
        """打印一条指出汽车里程的信息"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mileage):
        print("This car has " + str(self.mileage) + " miles on it.")

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


my_used_car = Car('subaru', 'outback', 2013, 1010)
my_used_car.update_odometer(1010)
my_used_car.increment(100)
my_used_car.read_odometer()
print(my_used_car.get_descriptive_name())

>>>  This car has 1010 miles on it.
        This car has 100 miles on it.
        2013 Subaru Outback

2、继承

编写类时，并非总是要从空白开始。让一个你要编写的类是另一个现成类的特殊版本，可使用继承。

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，新类为子类。

子类继承了父类所有属性和方法，同时还可定义自己的属性和方法。

子类的方法__init__():

创建子类的实例时，python首先需要完成的认为是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。

super是一个特殊函数，帮助python将父类和子类联系起来。父类也称为超类（superclass）

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, maker, model, year):
        """初始化描述汽车的属性"""
        self.maker = maker
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        """返回的整洁性的描述信息"""
        long_time = str(self.year) + " " + self.maker + " " + self.model
        return long_time.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(self, miles):
        self.odometer_reading += miles
        
        
class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类"""
        super(ElectricCar, self).__init__(make, model, year )  #super是一个特殊函数，将父类和子类联系起来
        
        
my_tesla = ElectricCar('tesla', 'model s', 2018)
print(my_tesla.get_descriptive_name())

>>>

2018 Tesla Model S

给子类定义属性和方法：可区分父类和子类

class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类"""
        super(ElectricCar, self).__init__(make, model, year )  #super是一个特殊函数，将父类和子类联系起来
        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', 2018)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

>>>

2018 Tesla Model S
This car has a 70-KWh battery

重写父类方法：

对于父类的方法，只要它不符合子类模拟的实物的行为，都可以对其进行重写。

在子类中定义这样一个方法，即它与要写的父类方法同名。

class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类"""
        super(ElectricCar, self).__init__(make, model, year )  #super是一个特殊函数，将父类和子类联系起来
        self.battery_size = 70

    def describe_battery(self):
        print("This car has a " + str(self.battery_size) + "-KWh battery")
######方法重写#########
    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print("This car doesn't have a gas tank!")

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

>>>

2018 Tesla Model S
This car has a 70-KWh battery
This car doesn't have a gas tank!

将实例用作属性：

class Car():
 --snip--

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,maker, model, year):
        """
        初始化父类的属性，再初始化电动车特有的属性
        """
        super().__init__(maker, model, year)
        self.battery = Battery()

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

>>>

2016 Teslamiles On It.
This car has a  70 -KWh battery.

3、导入类

我们新建一个文件如：car.py。其中包含了Car类、Battery类、ElectricCar类等若干类。称car.py为一个模块。

导入一个类：from car import ElecticCar

导入多个类：from car import Car ,  ElectricCar

导入整个模块：import car

导入模块中的而所有类：from module_name import *

在一个模块中导入另一个模块：from module_name import class_name

4、Python 标准库

字典能够将信息关联起来，但是并不记录你添加键-值对的顺序。要创建字典并记录其中的键值对的添加顺序，可使用模块collection中的OrderedDict类。OrderedDict实例的行为几乎与字典相同，区别只在于记录了键值对的添加顺序。

from collections import OrderedDict

favorite_languages = OrderedDict()### 记录了键值对的添加顺序
#favorite_languages = {}         ###普通情况下。字典时无序的
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 languages is " + language.title() + ".")

>>>

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

5、类编码风格：

类名：驼峰法命名法，即将类名中每个单词的首字母全都大写，而不使用下划线。

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

对于每个类，都应紧跟在类定义后面包含一个文档字符串。简单描述类的功能。

在类中，可使用一个空行来分隔方法；而在模块中可使用两个空行来分隔类。

需要同时导入标准库中的函数和你自己写的函数时，先导入标准库模块的import语句，再添加一个空行，然后编写导入你自己编写的模块的import语句。（可让别人更容易明白程序的哥哥模块来自何方）