Python从入门到实践，总结笔记3：函数+类

1，函数：

函数定义，与调用（位置实参+关键字实参）：

def describe_pet(animal_type, pet_name):
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
    return animal_type + ' ' + pet_name


describe_pet('hamster', 'harry')  # 位置实参
describe_pet(pet_name='harry', animal_type='hamster')  # 关键字实参
print(describe_pet(pet_name='harry', animal_type='hamster'))

返回字典：

def build_person(first_name, last_name, age=''):  # 返回字典
    person = {'first': first_name, 'last': last_name}
    if age:
        person['age'] = age
    return person


musician = build_person('jimi', 'hendrix', age=27)
print(musician)

传入列表：

def greet_users(names):  # 传递列表
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)


usersnames = ['hannah', 'ty', 'margot']
greet_users(usersnames)

创建两个函数：

def print_models(unprinted_designs, completed_models):  # 定义两个函数
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: " + current_design)
        completed_models.append(current_design)


def show_completed_models(completed_models):
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)


unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)

禁止函数修改列表：使用切片表示法，创建列表的副本

print_models(unprinted_designs[:], completed_models)  # 禁止修改列表
show_completed_models(completed_models)
print(unprinted_designs)

传递任意数量的实参：

def make_pizza(size, *toppings):  # 传入任意个数的实参
    print("\nMaking " + str(size) + "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)


make_pizza(16, 'pepperoni')
make_pizza(32, 'mushrooms', 'green peppers', 'extra cheese')

接受任意数量的关键字实参：

def build_profile(first, last, **user_info):  # 使用任意数量的关键字实参
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile


user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')

print(user_profile)

将函数存储在类里面：

myLib.py

def make_pizza(size, *toppings):
    print("\nMaking a " + str(size) + "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

导入与调用：

import myLib  # 导入整个模块
import myLib as mL  # 使用as 给模块指定别名
from myLib import make_pizza  # 导入特定函数
from myLib import make_pizza as mp  # 使用as 给函数指定别名
from myLib import *  # 导入所有函数

myLib.make_pizza(16, 'pepperoni')
myLib.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
mL.make_pizza(16, 'pepperoni')
mL.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

2，类：函数为方法，数据为属性

创建一个类：dog.py。

1，Python调用__init__() 方法来创建Dog 实例时，将自动传入实参self。

2，可通过实例访问的变量称为属性。

class Dog():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.odometer_reading = 0

    def sit(self):
        print(self.name.title() + " is now sitting")

    def roll_over(self):
        print(self.name.title() + " rolled over!")

    def get_descriptive_name(self):
        long_name = str(self.age) + ' ' + self.name
        return long_name.title()

    def read_odometer(self):
        print("This dog 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

类的实例化和调用：

import dog  # 导入整个模块

my_dog = dog.Dog('willie', 6)  # 实例化
young_dog = 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()
my_dog.roll_over()
young_dog.sit()
print("My dog'long_name is " + my_dog.get_descriptive_name())
my_dog.read_odometer()

my_dog.odometer_reading = 30  # 直接修改属性的值
my_dog.read_odometer()

my_dog.update_odometer(50)  # 用方法修改属性的值
my_dog.read_odometer()

my_dog.increment_odometer(10)  # 通过方法对属性的值进行递增
my_dog.read_odometer()

创建继承的类：

super() 是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所有属性。父类也称为超类（superclass），名称super因此而得名。

from dog import Dog # 从一个模块导入到另一个模块


class Battery():
    def __init__(self):
        self.battery_size = 70

    def describe_battery(self):
        print("This elecdog 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 ElecDog can go approximately " + str(range)
        message += " miles on a full charge"
        print(message)


class ElectricDog(Dog):  # 子类从父类（超类）继承
    def __init__(self, name, age):
        super().__init__(name, age)
        self.odometer_reading = 0
        self.battery = Battery()  # 实例化一个Battery作为ElectricDog的属性

    def describe_odometer(self):  # 给子类定义属性和方法
        print("This elecdog has " + str(self.odometer_reading) + "-km odometer")

    def sit(self):  # 子类重写父类方法
        print("ElecDog " + self.name.title() + " is now sitting")

继承的类的调用：

from dog import Dog, ElectricDog    # 从一个文件里面导入多个类
import elecdog
import dog  # 导入整个模块

elec_dog = elecdog.ElectricDog('harry', 8)  # 实例化这个子类
print(elec_dog.get_descriptive_name())

elec_dog.describe_odometer()
elec_dog.sit()
elec_dog.battery.describe_battery()  # 使用子类中的属性—battery类的方法describe_battery()
elec_dog.battery.get_range()

代码风格：

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。

对于每个类，都应紧跟在类定义后面包含一个文档字符串。

这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。

每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。

可使用空行来组织代码，但不要滥用。

在类中，可使用一个空行来分隔方法；

而在模块中，可使用两个空行来分隔