匿名函数

顾名思义就是函数没有名字，使用lambda关键字定义的函数就是匿名函数,简化代码，增加运行效率。 特点： 匿名函数只适合做一下简单的操作，返回值不需要加上return。

#普通函数
def func(a,b,c):
    return a+b+c
print(func(1,3,4))

8

#匿名函数
result=(lambda a,b,c:a+b+c)(1,3,4)
# 匿名函数也是函数
print(result)

8

# 对字典列表排序的时候还可以使用匿名函数
my_list={'age':23,'name':'张三'}
def get_value(item):
    return item['age']

get_value(my_list)

# my_list.sort(key=get_value,reverse=True)print(my_list)

23

面向对象的编程

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

我们以一个例子来说明面向过程和面向对象在程序流程上的不同之处。

假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

std1 = { 'name': 'Curry', 'score': 98 }
std2 = { 'name': 'James', 'score': 81 }

而处理学生成绩可以通过函数实现，比如打印学生的成绩：

def print_score(std):
    print('%s: %s' % (std['name'], std['score']))

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这 个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

class Student(object):
    def init (self, name, score): 
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：

bart = Student('Bart Simpson', 59) 
lisa = Student('Lisa Simpson', 87) 
bart.print_score() 
lisa.print_score()

面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。

Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具 体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。

面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。

类和对象

面向对象编程的2个非常重要的概念：类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类

类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象。

补充：

• 需求：做一道西红柿炒鸡蛋

方法1：按步骤一步一步制作（面向过程）——[将每个过程打包成函数，需要时依次调用]

方法2：制作一台机器人，告诉机器人炒菜（面向对象）——[打包成类与对象]

类作为母版制作出很多对象

类

人以类聚物以群分。 具有相似内部状态和运动规律的实体的集合(或统称为抽象)。 具有相同属性和行为事物的统称类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

对象

某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。 可以是直接使用的

类和对象之间的关系

定义类和创建对象

定义一个类，格式如下：

class 类名:

方法列表

# class Hero: # 经典类（旧式类）定义形式
# class Hero():

class Hero(object): # 新式类定义形式
    def info(self): 
        print("hero")

说明：

• 定义类时有2种形式：新式类和经典类，上面代码中的Hero为新式类，前两行注释部分则为经典类；

• object 是Python 里所有类的最顶级父类； 类名 的命名规则按照"大驼峰命名法"；

• info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象.

• python中，可以根据已经定义的类去创建出一个或多个对象。

创建对象的格式为

对象名1 = 类名()

对象名2 = 类名()

对象名3 = 类名()

class Hero(object): # 新式类定义形式
    '''info 是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self'''
    def info(self):
        '''当对象调用实例方法时，Python会自动将对象本身的引用做为参数， 传递到实例方法的第一个参数self里'''
        print(self)
        print("self各不同，对象是出处。")

# Hero这个类 实例化了一个对象
hero = Hero()

# 对象调用实例方法info()，执行info()里的代码
# . 表示选择属性或者方法
hero.info()
print(hero) # 打印对象，则默认打印对象在内存的地址，结果等同于info里的print(self)

<__main__.Hero object at 0x0000000005413EF0>
self各不同，对象是出处。
<__main__.Hero object at 0x0000000005413EF0>

补充：类与对象

#类的使用
class 成绩单():
    @classmethod#类的方法（函数）同类的属性（变量）结合
    #类的属性作为类方法的参数
    def 录入成绩单(cls):
        cls.学生姓名=input('请输入学生姓名：')
        cls.语文_成绩=int(input('请输入语文成绩：'))
        cls.数学_成绩=int(input('请输入数学成绩：'))
    @classmethod
    def 打印成绩单(cls):
        print(cls.学生姓名+'的成绩如下：')
        print('语文成绩：'+str(cls.语文_成绩))
        print('语文成绩：'+str(cls.语文_成绩))
    
成绩单.录入成绩单()
成绩单.打印成绩单()

请输入学生姓名：Ryan
请输入语文成绩：100
请输入数学成绩：99
Ryan的成绩如下：
语文成绩：100
语文成绩：100

#实例化
class 成绩单():
    #①
    def 录入成绩单(self):#②
        self.学生姓名=input('请输入学生姓名：')
        self.语文_成绩=int(input('请输入语文成绩：'))
        self.数学_成绩=int(input('请输入数学成绩：'))
#③
    def 打印成绩单(self):
        print(self.学生姓名+'的成绩如下：')
        print('语文成绩：'+str(self.语文_成绩))
        print('语文成绩：'+str(self.语文_成绩))

#④
成绩单1=成绩单()#实例化得到成绩单1
#调用实例化变量
成绩单1.录入成绩单()
成绩单1.打印成绩单()

请输入学生姓名：Ryan
请输入语文成绩：34
请输入数学成绩：53
Ryan的成绩如下：
语文成绩：34
语文成绩：34

对比分析：

• ①是空着的，意思是这里不再需要@classmethod的声明

• 第②处，把cls替换成了 self.

• 实例化后再使用的格式，需要先赋值然后再调用(第③处)在第④步骤， 我们需要用实例名=类(的方式(实例名其实就是任取一个变量名)，为类创建一个实例， 然后再使用实例名函数0的方式调用对应的方法。

对象的属性和方法

添加和获取对象的属性

class Hero(object):
    """定义了一个英雄类，可以移动和攻击""" 
    def move(self):
        """实例方法"""
        print("正在前往事发地点...")
# 实例化了一个英雄对象

hero = Hero()
# 给对象添加属性，以及对应的属性值
hero.name = "德玛西亚" # 姓名
hero.hp = 2600 # 生 命 值
# 通过.成员选择运算符，获取对象的属性值
print("英雄 %s 的生命值 :%d" % (hero.name, hero.hp))

# 通过.成员选择运算符，获取对象的实例方法
hero.move()

英雄 德玛西亚 的生命值 :2600
正在前往事发地点...

通过self获取对象属性

 class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
    def move(self):
        """实例方法"""
        print("正在前往事发地点...")

    def info(self):
        """在类的实例方法中，通过self获取该对象的属性"""
        print("英雄 %s 的生命值 :%d" % (self.name, self.hp))

# 实例化了一个英雄对象
 hero = Hero()

# 给对象添加属性，以及对应的属性值
hero.name = "德玛西亚" # 姓名
hero.hp = 2600 # 生 命 值

# 通过.成员选择运算符，获取对象的实例方法

hero.info() # 只需要调用实例方法info()，即可获取英雄的属性
hero.move()

英雄 德玛西亚 的生命值 :2600
正在前往事发地点...

init魔法方法

init方法

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
#Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法， init ()就是一个魔法方法， 通常用来做属性初始化 或 赋值 操作。

# 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，

# 如果为了能够在完成自己想要的功能，可以自己定义__init__方法，

# 所以一个类里无论自己是否编写 __init__方法 一定有__init__方法。

    def __init__(self):
        """ 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用""" 
        self.name = "hero" # 姓 名
        self.hp = 2600 # 生命值
    def move(self):
        """实例方法"""
        print("正在前往事发地点...")


# 实例化了一个英雄对象，并自动调用 init ()方法
hero = Hero()

# 通过.成员选择运算符，获取对象的实例方法
hero.info() # 只需要调用实例方法info()，即可获取英雄的属性
hero.move()

总结

• __init__()方法，在创建一个对象时默认被调用，不需要手动调用
• __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

有参数的init（）方法

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
    def __init__(self, name, hp):
        """ init () 方法，用来做变量初始化 或 赋值操作"""
# 英雄名
        self.name = name
# 生命值：
        self.hp = hp

    def move(self):
        """实例方法"""
        print("%s 正在前往事发地点..." % self.name)
    def info(self):
        print("英雄 %s 的生命值 :%d" % (self.name, self.hp))



#实例化英雄对象时，参数会传递到对象的 init()方法里
blind = Hero('瞎哥',2600) 
gailun = Hero("盖伦",4200)

#print(gailun)

#print(blind)

  

# 不同对象的属性值的单独保存
print(id(blind.name)) 
print(id(gailun.name))

# 同一个类的不同对象，实例方法共享
print(id(blind.move())) 
print(id(gailun.move()))

87554072
87555744
瞎哥 正在前往事发地点...
2004853904
盖伦 正在前往事发地点...
2004853904

注意：

• 通过一个类，可以创建多个对象，就好比 通过一个模具创建多个实体一样
• __init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么init (self)中出了self作为第一个形参外还需要2个形参，例如 init (self,x,y)
• 在类内部获取 属性 和 实例方法，通过self获取；
• 在类外部获取 属性 和 实例方法，通过对象名获取。
• 如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；
• 但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。

继承

• 在程序中，继承描述的是多个类之间的所属关系。
• 如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。
• 那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

# 父 类
class A(object):
    def __init__(self):
        self.num = 10
        
    def print_num(self):
        print(self.num + 10)

# 子 类
class B(A): 
    pass

b = B()
print(b.num) 
b.print_num()

10
20

单继承

子类只能继承一个父类

#定义一个Person类
class Person(object): 
    def __init__(self):
# 属 性
        self.name = "女娲"

    # 实例方法
    def make_person(self):
        print(" <%s> 造了一个人..." % self.name)

# 定义Teacher类，继承了 Person，则Teacher是子类，Person是父类。
class Teacher(Person):
# 子类可以继承父类所有的属性和方法，哪怕子类没有自己的属性和方法，也可以使用父类的属性和方法。
    pass

panda = Teacher() 
    # 创建子类实例对象
print(panda.name) 
    # 子类对象可以直接使用父类的属性
panda.make_person() 
    # 子类对象可以直接使用父类的方法
    

女娲
 <女娲> 造了一个人...

总结

• 虽然子类没有定义 init 方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的 init 方法
• 子类在继承的时候，在定义类时，小括号()中为父类的名字
• 父类的属性、方法，会被继承给子类

多继承

子类继承多个父类

class Women(object): 
    def __init__(self):
        self.name = "女娲" # 实例变量，属性

    def make_person(self):          # 实例方法，方法
        print(" <%s> 造了一个人..." % self.name)
    
    def move(self):
        print("移动..")

class Man(object):
    def __init__(self):
        self.name = "亚当"

    def make_person(self):
        print("<%s> 造了一个人..." % self.name)

    def run(self):
        print("跑..")

class Person(Women, Man): # 多继承，继承了多个父类
    pass

ls = Person() 
print(ls.name) 
ls.make_person()

# 子类的魔法属性 mro 决定了属性和方法的查找顺序
print(Person. mro)

女娲
 <女娲> 造了一个人...
<built-in method mro of type object at 0x0000000004376698>

结论：

• 多继承可以继承多个父类，也继承了所有父类的属性和方法

• 注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro 的顺序来查找）

• 多个父类中，不重名的属性和方法，不会有任何影响。

重写父类方法

子类继承父类，父类的方法满足不了子类的需要可以对父类的方法进行重写

**重写的特点: **

1. 继承关系，
2. 方法名相同

class Person(object): 
    def run(self):
        print("跑起来了")

class Student(Person):
    def __init__(self, name, age): 
        self.name = name
        self.age = age

# 因为父类的方法满足不了子类的需要，对其进行重写
    def run(self):
        print("%s跑起来了" % self.name)

stu = Student("王五", 10)

# 调用方法的时候先从本类去找，如果本来没有再去父类去找，会遵循mro的特点

stu.run()

王五跑起来了

属性方法

类属性和实例属性

类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问

class People(object):
    name = 'Tom'# 公有的类属性
    __age = 12# 私有的类属性

p = People() 
print(p.name)   # 正 确
print(People.name)  # 正 确
# print(p.__age)    # 错误，不能在类外通过实例对象访问私有的类属性
# print(People.__age) # 错误，不能在类外通过类对象访问私有的类属性实例属性(对象属性)

class People(object):
    address = '山东'  # 类属性
    def __init__(self):
        self.name = 'xiaowang'  # 实例属性
        self.age = 20   # 实例属性

p = People()
p.age = 12  # 实例属性
print(p.address)    # 正 确
print(p.name)       # 正 确
print(p.age)    # 正 确
print(People.address)   # 正 确
#print(People.name)     # 错 误
#print(People.age)  # 错 误

#通过实例(对象)去修改类属性
class People(object):
    country = 'china' #类属性

    
print(People.country) 
p = People() 
print(p.country) 

p.country = 'japan'
print(p.country)    # 实例属性会屏蔽掉同名的类属性
print(People.country)

del p.country # 删除实例属性
print(p.country)

Tom
Tom
山东
xiaowang
12
山东
china
china
japan
china
china

总结
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

静态方法和类方法

1.类方法

是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象， 一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

class People(object): 
    country = 'china'
#类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls): 
        return cls.country

p = People()
print(p.get_country())  #可以用过实例对象引用print(People.get_country())  #可以通过类对象引用类方法还有一个用途就是可以对类属性进行修改：

class People(object): 
    country = 'china'
#类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls): 
        return cls.country

    @classmethod
    def set_country(cls,country): 
        cls.country = country

p = People()
print(p.get_country())  #可以用过实例对象访问print(People.get_country())  #可以通过类访问

p.set_country('japan')

print(p.get_country()) 
print(People.get_country())
#结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变

china
china
japan
japan

2. 静态方法

需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数，可以通过对象和类来访问。

class People(object): 
    country = 'china'
    @staticmethod #静态方法
    def get_country():
        return People.country

p = People()
# 通过对象访问静态方法
p.get_country()
# 通过类访问静态方法
print(People.get_country())

china

总结
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的 必定是类对象的属性和方法； 实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。 静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类实例对象来引用

多态

• 多态, 不同的子类对象调用相同的父类方法，产生不同的执行结果，可以增加代码的外部调用灵活度
• 多态以继承和重写父类方法为前提
• 多态是调用方法的技巧，不会影响到类的内部设计

class Animal(object): 
    def run(self):
        print('Animal is running...') 

        
class Dog(object):
    def run(self):
        print('Dog is running...') 
    
    
class Cat(object):
    def run(self):
        print('Cat is running...')

# 定义一个方法
def run_twice(animal): 
    animal.run() 
    animal.run()

dog = Dog() 
cat = Cat()

run_twice(dog) 
run_twice(cat)

Dog is running...
Dog is running...
Cat is running...
Cat is running...

函数的简介

如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

例如：我们知道圆的面积计算公式为：\(S = πr^2\)

当我们知道半径r的值时，就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积：

r1 = 12.34
r2 = 9.08
r3 = 73.1
s1 = 3.14 * r1 * r1 s2 = 3.14 * r2 * r2 s3 = 3.14 * r3 * r3

当代码出现有规律的重复的时候，你就需要当心了，每次写3.14 * x * x不仅很麻烦，而且，如果要把3.14改成3.14159265359的时候，得全部替换。

有了函数，我们就不再每次写s = 3.14 * x * x，而是写成更有意义的函数调用s = area_of_circle(x)， 而函数area_of_circle本身只需要写一次，就可以多次调用。

基本上所有的高级语言都支持函数，Python也不例外。Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

函数定义和调用

定义函数

def 函数名(): 代码
# 定义一个函数，能够完成打印信息的功能
def printInfo():
print(' ')
print(' 人生苦短，我用Python')
print(' ')

调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它调用函数很简单的，通过 函数名() 即可完成调用

# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()

注意:

• 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
  
• 当然了如果函数中执行到了return也会结束函数

函数的文档说明

def test(a,b):
    '''用来完成对2个数求和'''
    print("%d"%(a+b))

test(11,22) 

help(test)

33
Help on function test in module __main__:

test(a, b)
    用来完成对2个数求和

还可以用test. doc 直接查看文档说明

def test(a,b):
    "用来完成对2个数求和"
    print("%d"%(a+b))

    print(test. doc )

来完成对两个数的求和

函数的参数

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关 键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

位置参数

我们先写一个计算x² 的函数：

def power(x):
    return x * x

对于power(x)函数，参数x就是一个位置参数。
当我们调用power函数时，必须传入有且仅有的一个参数x：

power(5)

25

现在，如果我们要计算\(x^3\)怎么办？可以再定义一个power3函数，但是如果要计算 \(x^4\) 、 \(x^5\) ……怎么办？我们不可能定义无限多个函数。
你也许想到了，可以把power(x)修改为power(x, n)，用来计\(x^n\) ，说干就干：

def power(x, n): 
    s = 1
    while n > 0:
        n = n - 1 
        s = s * x
    return s

对于这个修改后的power(x, n)函数，可以计算任意n次方：

power(5,2)

25

修改后的power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

默认参数

新的power(x, n)函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用：

power(5)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-89-4cd340f296c6> in <module>()
----> 1 power(5)


TypeError: power() missing 1 required positional argument: 'n'

Python的错误信息很明确：调用函数power()缺少了一个位置参数n。
这个时候，默认参数就排上用场了。由于我们经常计算 x² ，所以，完全可以把第二个参数n的默认值设定为2：

def power(x, n=2): 
    s = 1
    while n > 0:
        n = n - 1 
        s = s * x
    return s

这样，当我们调用power(5)时，相当于调用power(5, 2)：

power(5)

25

而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)。

power(5,3)

125

从上面的例子可以看出，默认参数可以简化函数的调用。设置默认参数时，有几点要注意：

• 一是必选参数在前，默认参数在后，否则Python的解释器会报错；
• 二是当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

使用默认参数有什么好处？

举个例子，我们写个一年级小学生注册的函数，需要传入name和gender两个参数：

def enroll(name, gender): 
    print('name:', name) 
    print('gender:', gender)

# 调用
enroll('张三','M')

name: 张三
gender: M

如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。 我们可以把年龄和城市设为默认参数：

def enroll(name, gender,city='amoy'): 
    print('name:', name) 
    print('gender:', gender)
    print('city:', city)
    
enroll('李四','F')

name: 李四
gender: F
city: amoy

这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数,只有与默认参数不符的学生才需要提供额外的信息.

enroll('李四','F','chengdu')

name: 李四
gender: F
city: chengdu

可见，默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个。

有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。

也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

注意：默认参数有个最大的坑，演示如下：

先定义一个函数，传入一个list，添加一个END再返回：

def add_end(L=[]): 
    L.append('END')
    return L

#调用
add_end([1,24,4])

[1, 24, 4, 'END']

#默认参数调用的时候
add_end()
add_end()
add_end()

['END', 'END', 'END', 'END']

很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list。 原因解释如下：

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]， 每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

定义默认参数要牢记一点：默认参数必须指向不变对象！

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None): 
    if L is None:
        L = []
    L.append('END') 
    return L
#调用
add_end()
add_end()
add_end()

['END']

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
我们以数学题为例子，给定一组数字a，b，c……，请计算\(a^2 + b^2 + c^2 +....\)。

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

def calc(numbers): 
    sum = 0
    for n in numbers:
        sum = sum + n * n 
    return sum

#调用
calc([1,3,5])

35

所以，我们把函数的参数改为可变参数：

def calc(*numbers): 
    sum = 0
    for n in numbers:
        sum = sum + n * n 
    return sum

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

calc(1,2)

5

calc()

0

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2])

14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

nums=[1,2,3]
calc(*nums)

14

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

仍以person()函数为例，我们希望检查是否有city和job参数：

def person(name, age, **kw): 
    if 'city' in kw:# 有city参数
        pass
    if 'job' in kw:# 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

但是调用者仍可以传入不受限制的关键字参数：

person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

name: Jack age: 24 other: {'city': 'Beijing', 'addr': 'Chaoyang', 'zipcode': 123456}

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job): 
    print(name, age, city, job)

和关键字参数kw不同，命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数。调用方式如下：

 person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

 person('Jack', 24, 'Beijing','Engineer')

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-17-7465e072842a> in <module>()
----> 1 person('Jack', 24, 'Beijing','Engineer')



TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。

命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job): 
    print(name, age, city, job)
   

# 利用默认值，调用时可以不用传入
person('Jack', 24, job='Engineer')

Jack 24 Beijing Engineer

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数：

def person(name, age, city, job):

# 缺少 *，city和job被视为位置参数 pass

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

比如定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

#调用
f1(1,2)

a = 1 b = 2 c = 0 args = () kw = {}

f1(1,2,c=3)

a = 1 b = 2 c = 3 args = () kw = {}

f1(1,2,3,'a','b')

a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}

f1(1,2,3,'a','b',x=99)

a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

f2(1, 2, d=99, ext=None)

a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

最神奇的是通过一个tuple和dict，你也可以调用上述函数：

args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)

a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}
f2(*args, **kw)

a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，对于任意函数，都可以通过类似func(args, *kw)的形式调用它，无论它的参数是如何定义的。虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

函数返回值

“返回值”介绍

• 现实生活中的场景:

我给儿子10块钱，让他给我买包烟。这个例子中，10块钱是我给儿子的，就相当于调用函数时传递到参数，让儿子买烟这个事情最终的目标是，让他把烟给你带回来然后给你对么，此时烟就是返回值

• 开发中的场景：

定义了一个函数，完成了获取室内温度，想一想是不是应该把这个结果给调用者，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return如下示例:

   def add2num(a, b): 
   c = a+b
   return c

或者

   def add2num(a, b): 
   return a+b

保存函数的返回值

在“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存.

保存函数的返回值示例如下:

#定义函数

def add2num(a, b):
    return a+b
#调用函数，顺便保存函数的返回值 

result = add2num(100,98)
print(result)

198

如何返回多个值

多个ruturn？

def create_nums(): 
    print("---1---")
    return 1 # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    print("---2---") 
    return 2
    print("---3---")

总结1一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处 如果程序设计为如下，是可以的因为不同的场景下执行不同的return

def create_nums(num): 
    print("---1---") 
    if num == 100:
        print("---2---")
        return num+1 # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    else:
        print("---3---") 
        return num+2
    print("---4---")



result1 = create_nums(100)
print(result1) # 打印101 
result2 = create_nums(200) 
print(result2) # 打印202

---1---
---2---
101
---1---
---3---
202

一个函数返回多个数据的方式

def divid(a, b):
    shang = a//b 
    yushu = a%b
    return shang, yushu #默认是元组


result = divid(5, 2) 
print(result) # 输 出 (2, 1)

(2, 1)

总结2： return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据

def function():
# return [1, 2, 3]
# return (1, 2, 3)
    return {"num1": 1, "num2": 2, "num3": 3}

如果return后面有多个数据，那么默认是元组

In [1]: a = 1, 2

In [2]: a

Out[2]: (1, 2)



In [3]:

In [3]: b = (1, 2)

In [4]: b

Out[4]: (1, 2)

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

\(fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n\)

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。于是，fact(n)用递归的方式写出来就是：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

fact(2)

2

fact(4)

24

fact(1)

1

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试

fact(10000)

---------------------------------------------------------------------------

RecursionError                            Traceback (most recent call last)

<ipython-input-37-0b1842e84853> in <module>()
----> 1 fact(10000)



<ipython-input-32-6cee500c0290> in fact(n)
      2     if n==1:
      3         return 1
----> 4     return n * fact(n - 1)



... last 1 frames repeated, from the frame below ...



<ipython-input-32-6cee500c0290> in fact(n)
      2     if n==1:
      3         return 1
----> 4     return n * fact(n - 1)



RecursionError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product): 
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num*product在函数调用前就会被计算，不影响函数调用。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出
小结

• 使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

• 针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

• Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

局部变量

• 局部变量，就是在函数内部定义的变量。
• 作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的。因为其作用范围只是在自己的函数内部，所以不同的函数可以定义相同名字的局部变量（打个比方，把你、我是当做成函数，把局部变量理解为每个人手里的手机，你可有个iPhone8，我当然也可以有个iPhone8了， 互不相关）
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储。
• 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了。函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了。

def show():
# 局部变量
    score = 100
    print("分数:", score) 
show()

分数: 100

print(score)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-41-4405d376f933> in <module>()
----> 1 print(score)



NameError: name 'score' is not defined

全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量。

例如：有2个兄弟 各自都有手机，各自有自己的小秘密在手机里，不让另外一方使用（可以理解为局部变量）；但是家里的电话是2个兄弟都可以随便使用的（可以理解为全局变量）

# 定义全局变量

a = 100

def test1():

    print(a) # 虽然没有定义变量a但是依然可以获取其数据



def test2():

    print(a) # 虽然没有定义变量a但是依然可以获取其数据

# 调用函数

test1()
test2()

100
100

总结:

• 在函数外边定义的变量叫做全局变量
• 全局变量能够在所有的函数中进行访问

全局变量和局部变量名字相同问题

# 定义全局变量
a = 100
def test1():
# 定义局部变量
    a = 300
    print('---test1---%d'%a)
test1()
#修改
a = 200
print('修改后的%d'%a)

def test2():
    print('a = %d'%a)

test2()

---test1---300
修改后的200
a = 200

总结:

• 当函数内出现局部变量和全局变量相同名字时，函数内部中的 变量名 = 数据 此时理解为定义了一个局部变量，而不是修改全局变量的值

修改全局变量

函数中进行使用全局变量时可否进行修改呢？

# 定义全局变量
a = 100
def test1():
# 定义局部变量
    global a
    print('修改之前：%d'%a)

#修改
a = 200
print('修改后的%d'%a)


def test2():
    print('a = %d'%a)

test1() 
test2()

修改后的200
修改之前：200
a = 200