商业数据分析从入门到入职（6）Python程序结构和函数

痛定思痛。 2022-12-10 01:29 203阅读 0赞

### 文章目录 ###

*  一、Python程序结构
 *   *  1.if条件
     *  2.循环
     *   *  while循环
         *  for循环
     *  3.案例-王者荣耀纯文本分析
 *  二、函数的介绍和基本使用
 *  三、函数进阶
 *   *  1.可变位置参数
     *  2.可变关键字参数
     *  3.函数定义和查看文档字符串
     *  5.函数作为参数
     *  6.装饰器
     *  7.匿名函数-lambda表达式
     *  8.异常处理

# 一、Python程序结构 #

Python中，有3种常见的程序结构：

*  Sequence顺序  
    从上向下依次执行。
 *  Condition条件  
    满足某个条件则执行。
 *  Loop循环  
    重复执行某个动作。

## 1.if条件 ##

判断某个变量是否满足某个条件时如下：

possibility_to_rain = 0.7
    print(possibility_to_rain > 0.8)
    print(possibility_to_rain > 0.3)
    possibility_to_rain = 1
    print(possibility_to_rain > 0.8)
    print(possibility_to_rain > 0.3)

输出：

False
    True
    True
    True

> 如需本节同步`ipynb`文件，可以直接点击加QQ群 [![Python极客部落][Python]963624318][Python_Python_963624318] 在群文件夹**商业数据分析从入门到入职**中下载即可。

但是如果想在变量满足某个条件时需要执行某个动作，则需要if条件判断语句，如下：

possibility_to_rain = 0.7
    
    if possibility_to_rain > 0.8:
        print("Do take your umberalla with you.") ## 这个地方标准格式是四个空格的缩进
    elif possibility_to_rain > 0.3:
        print("Take your umberalla just in case. hahaha")    
    else:
        print("Enjoy the sunshine!")
    print('hello')

输出：

Take your umberalla just in case. hahaha

这段代码的意思是：  
如果`possibility_to_rain > 0.8`为True，则执行`print("Do take your umberalla with you.")`，如果不满足前述条件，但满足`possibility_to_rain > 0.3`，则执行`print("Take your umberalla just in case. hahaha")`，否则执行`print("Enjoy the sunshine!")`；  
if语句执行完后，再执行后面的语句，如`print('hello')`；  
需要注意**缩进**，if、elif、else语句后面的语句都应该缩进4格并保持对齐，即通过缩进控制代码块和代码结构，而不像其他语言使用`{}`来控制代码结构，如下：  
![python code blocks][]

前面也看到，出现了很多以`#`开头的代码和文字性说明，代码颜色也是和其他代码有所区别的，这就是Python中的单行注释，**注释后的代码不会被执行**，而只能起到说明作用，这段代码中`这个地方标准格式是四个空格的缩进`被`#`注释，这一行前面的代码能正常执行，`#`后的文字不会执行、也不会报错、作为解释性语句。

除了对数值进行判断，还能对字符串进行判断：

card_type = "debit"
    account_type = "checking"
    
    if card_type == "debit":
        if account_type == "checking":
            print("Checkings selectd.")
        else:
            print("Savings selected.")
    else:
        print("Credit card.")

输出：

Take your umberalla just in case. hahaha
    hello

可以看到，使用到了条件判断的**嵌套**。

## 2.循环 ##

### while循环 ###

之前要是需要执行重复操作，可能如下：

count =1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)
    count+=1
    print(count)

输出：

1
    2
    3
    4
    5
    6
    7
    8
    9
    10

显然，代码很冗长，此时就可以使用循环进行优化。

使用while循环如下：

count = 1
    while count <= 10:
        print(count)
        count += 1

执行效果与前面相同；  
需要注意，循环一般要有**停止的条件**，当满足`count <= 10`时循环会一直执行，直到`count = 11`时就会不符合、从而退出循环；  
如果没有停止条件，则可能陷入死循环、消耗内存。

再如：

cnt = 1
    while True:
        print("cnt = %d" % cnt)
        ch = input('Do you want to continue? [y:n]: ')
        if ch == 'y':
            cnt += 1
        else:
            break

输出如下：  
![python while loop break][]

可以看到，虽然循环条件为`True`，是恒成立的，但是循环内部进行了条件判断，输入的是`y`就会一直循环，输入其他则执行`break`退出循环；  
但是需要注意，这里只有严格地输入`y`才能继续循环，但是输入`yes`都会退出循环，所以要想进一步控制运行逻辑、还需要对代码进行完善。

在Python中，else也可以与while循环结合使用，如果循环不是因调用`break`而结束的，将执行else中的语句，这可以用于判断循环是不是完全执行，例如前面第1个循环的例子是不是运行了10次。

如下：

count = 1
    while count < 11:
        print(count)
        count = count + 1
    else:
        print('Counting complete.')
    
        print()
    count = 1
    while count < 11:
        print(count)
        count = count + 1
        if count == 8:
            break
    else:
        print('Counting complete.')

输出：

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Counting complete.
    
    1
    2
    3
    4
    5
    6
    7

可以看到：  
第一个循环并没有因为break而停止循环，因此在执行完循环语句后执行了else语句；  
第二个循环因为count为8时满足if条件而退出循环、并未将循环执行完毕，因此未执行else语句。

再如：

count=0
    while count < 11:
        print("while count:",count)
        count = count + 1
        if count == 11:
            break
    else:
        print("else:",count)

输出：

while count: 0
    while count: 1
    while count: 2
    while count: 3
    while count: 4
    while count: 5
    while count: 6
    while count: 7
    while count: 8
    while count: 9
    while count: 10

显然，此时因为执行最后一次循环时满足if条件而执行了break语句，因此并未执行else语句块。

### for循环 ###

经常与for循环同时出现的还有`range`，`range(self, /, *args, **kwargs)`函数有以下两种常见的用法：

range(stop) -> range object
    range(start, stop[, step]) -> range object

该函数返回一个对象，该对象以step为步长生成从start（包含）到stop（排除）的**整数序列**。例如`range(i, j)`产生i，i+1，i+2，…，j-1的序列。

输入：

for i in range(10):
        print(i)

输出：

0
    1
    2
    3
    4
    5
    6
    7
    8
    9

再如：

for i in range(4,10):
        print(i)
        
    print()
    for i in range(4,10,2):
        print(i)
        
    print()
    for i in range(5):
        print('Corley')
        
    print()
    for i in range(5):
        print('Corley'[i])

输出：

4
    5
    6
    7
    8
    9
    
    4
    6
    8
    
    Corley
    Corley
    Corley
    Corley
    Corley
    
    C
    o
    r
    l
    e

可以看到，for循环内也可以执行与i无关的操作；  
还可以用来遍历字符串。

for循环中也可以使用break语句来终止循环，如下：

for i in range(10):
        print(i) 
        if i == 5:
            break

输出：

0
    1
    2
    3
    4
    5

再如：

result = 0
    
    for num in range(1,100):
        if num % 2 == 0:
            result = result + num
            
    print(result)

输出：

2450

上面的例子实现了计算从1到100（不包括）的所有偶数的和。

## 3.案例-王者荣耀纯文本分析 ##

目标是从以下文本提取出所有的英雄信息链接、头像图片链接、英雄名称，如herodetail/194.shtml、http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg和苏烈：

我们可以先找出一个英雄的信息，即使用下标进行字符串切分，找下标时使用`find()`方法。  
例如，对于链接`http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg`，如果找到第一个h字母和最后一个g字母的下标，就可以通过切分将该链接提取出来。

先读入字符串，如下：

page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="苏烈">苏烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守约">百里守约</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="铠">铠</a></li></ul> '''

此时再通过一步步地获取与目标相关字符的下标和根据下标切片来获取目标字符串，如获取图片链接如下：

start_link = page_hero.find('<img src="')
    print(start_link)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link = page_hero[start_quote+1:end_quote]
    print(hero_link)

输出：

81
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg

此时再依次获取英雄名和信息链接如下：

# 第1个英雄
    start_link = page_hero.find('<a href="')
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_info1 = page_hero[start_quote+1:end_quote]
    print(hero_info1)
    start_link = page_hero.find('<img src="', end_quote+1)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link1 = page_hero[start_quote+1:end_quote]
    print(hero_link1)
    end_bracket = page_hero.find('>', end_quote+1)
    start_bracket = page_hero.find('<', end_bracket+1)
    hero_name1 = page_hero[end_bracket+1:start_bracket]
    print(hero_name1)

输出：

herodetail/194.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg
    苏烈

显然，已经获取到第1个英雄的完整信息。

此时再获取第2个英雄的信息，如下：

# 第2个英雄
    page_hero = page_hero[start_bracket:]
    start_link = page_hero.find('<a href="')
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_info2 = page_hero[start_quote+1:end_quote]
    print(hero_info2)
    start_link = page_hero.find('<img src="', end_quote+1)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link2 = page_hero[start_quote+1:end_quote]
    print(hero_link2)
    end_bracket = page_hero.find('>', end_quote+1)
    start_bracket = page_hero.find('<', end_bracket+1)
    hero_name2 = page_hero[end_bracket+1:start_bracket]
    print(hero_name2)

输出：

herodetail/195.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg
    百里玄策

需要注意：  
第二次切分不需要再在原字符串上进行切分、而只要从上次切分的位置开始查找和切分即可，所以`page_hero = page_hero[end_quote:]`即是将上次切分之后的子字符串重新赋值给page\_hero作为新字符串；  
因为各个英雄信息的字符串形式是一样的，所以可以直接利用查找第一个英雄的方式即可。

查找第3个和第4个英雄也类似如下：

# 第3个英雄
    page_hero = page_hero[start_bracket:]
    start_link = page_hero.find('<a href="')
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_info3 = page_hero[start_quote+1:end_quote]
    print(hero_info3)
    start_link = page_hero.find('<img src="', end_quote+1)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link3 = page_hero[start_quote+1:end_quote]
    print(hero_link3)
    end_bracket = page_hero.find('>', end_quote+1)
    start_bracket = page_hero.find('<', end_bracket+1)
    hero_name3 = page_hero[end_bracket+1:start_bracket]
    print(hero_name3)
    
    # 第4个英雄
    page_hero = page_hero[start_bracket:]
    start_link = page_hero.find('<a href="')
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_info4 = page_hero[start_quote+1:end_quote]
    print(hero_info4)
    start_link = page_hero.find('<img src="', end_quote+1)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link4 = page_hero[start_quote+1:end_quote]
    print(hero_link4)
    end_bracket = page_hero.find('>', end_quote+1)
    start_bracket = page_hero.find('<', end_bracket+1)
    hero_name4 = page_hero[end_bracket+1:start_bracket]
    print(hero_name4)

输出：

herodetail/196.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
    百里守约
    herodetail/193.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg
    铠

可以看到，找4个英雄的思路都大致如下：  
（1）找到第一个出现的<img src= >=>start\_link；  
（2）找到第一个出现的"=>start\_quote；  
（3）找到start\_quote+1之后那个引号 end\_quote；  
（4）end\_quote+1找到后面的>记作 end\_bracket；  
（5）end\_bracket+1 找到 start\_bracket；  
（6）抛弃start\_bracket之前的所有内容，再根据上面的方法找。

可以看到，3部分代码也有很大部分相似，因此可以使用循环来简化代码：

# 使用循环简化代码
    page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="苏烈">苏烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守约">百里守约</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="铠">铠</a></li></ul> '''
    for i in range(4):
        print('第%d个英雄：' % (i+1))
        start_link = page_hero.find('<a href="')
        start_quote = page_hero.find('"', start_link)
        end_quote = page_hero.find('"', start_quote+1)
        hero_info = page_hero[start_quote+1:end_quote]
        print(hero_info)
        start_link = page_hero.find('<img src="', end_quote+1)
        start_quote = page_hero.find('"', start_link)
        end_quote = page_hero.find('"', start_quote+1)
        hero_link = page_hero[start_quote+1:end_quote]
        print(hero_link)
        end_bracket = page_hero.find('>', end_quote+1)
        start_bracket = page_hero.find('<', end_bracket+1)
        hero_name = page_hero[end_bracket+1:start_bracket]
        print(hero_name)
        page_hero = page_hero[start_bracket:]

输出：

第1个英雄：
    herodetail/194.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg
    苏烈
    第2个英雄：
    herodetail/195.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg
    百里玄策
    第3个英雄：
    herodetail/196.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
    百里守约
    第4个英雄：
    herodetail/193.shtml
    http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg
    铠

显然，代码精简很多。

# 二、函数的介绍和基本使用 #

函数是一段命名的代码，并且独立于所有其他代码。  
函数可以接受任何类型的输入参数，并返回任意数量和类型的输出结果。  
简而言之，函数可以**代替大段代码**，在需要使用这些代码的时候、直接调用函数即可，而不再需要重复大段代码，很大程度上优化了代码的结构、提高了代码的**可读性**。

定义一个不做任何事的函数如下：

# An empty function that does nothing
    def do_nothing():
        pass
    
    do_nothing()
    type(do_nothing)

输出：

function

其中，`do_nothing()`是调用函数，即`函数名()`。

定义一个不带参数和返回值的函数如下：

# A function without parameters and returns values
    def greeting():
        print("Hello Python")
    
    # Call the function
    a = greeting()

输出：

Hello Python

以后需要打印`Hello Python`的地方，就不用再使用`print("Hello Python")`语句，直接调用`greeting()`即可。

还可以定义带参数、但是不带返回值的函数：

# A function with a parameter that returns nothing
    def greeting(name):
        print("Hello %s" % name)
    
    # Call the function
    greeting('Corley')

输出：

Hello Corley

此时在调用函数时，传入了参数`'Corley'`，会在函数内部使用，如果参数值变化，在函数内部被使用的变量也会同步变化，导致结果也可能变化。

但是此时：

print(a)

输出：

None

即返回为空，这是因为在函数内部并未定义返回值。  
在需要时可以在函数内部定义返回值，以便用于下一步的运算。

如下：

# A function with a parameter and return a string
    def greeting_str(name):
        return "Hello again " + name
    
    # Use the function
    s = greeting_str("Corley")
    print(s)

输出：

Hello again Corley

像许多编程语言一样，Python支持位置参数，其值按顺序复制到相应的参数中。即可以给函数传递多个参数，如下：

# A function with 3 parameters
    def menu(wine, entree, dessert):
        return "wine:{},entree:{},dessert:{}".format(wine,entree,dessert)
    
    # Get a menu
    menu('chardonnay', 'chicken', 'cake')

输出：

'wine:chardonnay,entree:chicken,dessert:cake'

为了避免位置参数混淆，可以通过参数对应的名称来指定参数，甚至可以使用与函数中定义不同的顺序来指定参数，即关键字参数。  
如下：

menu(entree='beef', dessert='cake', wine='bordeaux')

输出：

'wine:bordeaux,entree:beef,dessert:cake'

显然，此时不按照顺序也可以实现传参。

甚至可以混合使用位置参数和关键字参数；  
但是需要注意，在输入任何关键字参数之前，必须提供所有位置参数。

如果函数调用者未提供任何参数的默认值，则可以为参数设置默认值。  
如下：

# default dessert is pudding
    def menu(wine, entree, dessert='pudding'):
        return "wine:{},entree:{},dessert:{}".format(wine,entree,dessert)
    
    
    # Call menu without providing dessert
    menu('chardonnay', 'chicken')

输出：

'wine:chardonnay,entree:chicken,dessert:pudding'

可以看到，此时也可以不给dessert参数传值也能正常运行，因为在定义函数时已经提供了默认值。

当然，也可以给dessert参数传值，此时就会使用传递的值代替默认值，如下：

# Default value will be overwritten if caller provide a value
    menu('chardonnay', 'chicken', 'doughnut')

输出：

'wine:chardonnay,entree:chicken,dessert:doughnut'

在函数中，存在作用域，即变量在函数内外是否有效。  
如下：

x = 1
    def new_x():
        x = 5
        print(x)
        
        
    def old_x():
        print(x)
        
    new_x()
    old_x()

输出：

5
    1

显然，第一个函数中的x在函数内部，属于局部变量，局部变量只能在当前函数内部使用；  
第二个函数使用的x函数内部并未定义，因此使用函数外部的x，即全局变量，全局变量可以在函数内部使用，也可以在函数外部使用；  
函数内部定义了与全局变量同名的局部变量后，不会改变全局变量的值。

要想在函数内部使用全局变量并进行修改，需要使用`global`关键字进行声明。  
如下：

x = 1
    
    def change_x():
        global x
        print('before changing inside,', x)
        x = 3
        print('after changing inside,', x)
        
    print('before changing outside,', x)
    change_x()
    print('after changing outside,', x)

输出：

before changing outside, 1
    before changing inside, 1
    after changing inside, 3
    after changing outside, 3

可以看到，此时在函数内部对变量进行修改后，函数外部也发生改变。

此时可以对之前王者荣耀纯文本分析案例进一步优化：

# 使用函数实现
    def extract_info(current_page):
        start_link = current_page.find('<a href="')
        start_quote = current_page.find('"', start_link)
        end_quote = current_page.find('"', start_quote+1)
        hero_info = current_page[start_quote+1:end_quote]
        print(hero_info)
        start_link = current_page.find('<img src="', end_quote+1)
        start_quote = current_page.find('"', start_link)
        end_quote = current_page.find('"', start_quote+1)
        hero_link = current_page[start_quote+1:end_quote]
        print(hero_link)
        end_bracket = current_page.find('>', end_quote+1)
        start_bracket = current_page.find('<', end_bracket+1)
        hero_name = current_page[end_bracket+1:start_bracket]
        print(hero_name)
        return start_bracket
    
    
    start_bracket = 0
    page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="苏烈">苏烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守约">百里守约</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="铠">铠</a></li></ul> '''
    for i in range(4):
        print('第%d个英雄：' % (i+1))
        page_hero = page_hero[start_bracket:]
        start_bracket = extract_info(page_hero)

输出：

显然，循环和函数结合使用，实现了功能，并且进一步简化代码。

除了使用for循环，还可以使用while循环，如下：

# 使用函数实现
    def extract_info(i, current_page):
        start_link = current_page.find('<a href="')
        start_quote = current_page.find('"', start_link)
        end_quote = current_page.find('"', start_quote+1)
        hero_info = current_page[start_quote+1:end_quote]    
        start_link = current_page.find('<img src="', end_quote+1)
        start_quote = current_page.find('"', start_link)
        end_quote = current_page.find('"', start_quote+1)
        hero_link = current_page[start_quote+1:end_quote]    
        end_bracket = current_page.find('>', end_quote+1)
        start_bracket = current_page.find('<', end_bracket+1)
        hero_name = current_page[end_bracket+1:start_bracket]    
        if hero_info.startswith('hero'):
            print('第%d个英雄：' % i)
            print(hero_info)
            print(hero_link)
            print(hero_name)
            return start_bracket
        else:
            return -1
    
    
    start_bracket = 0
    i = 1
    page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="苏烈">苏烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守约">百里守约</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="铠">铠</a></li></ul> '''
    while True:    
        page_hero = page_hero[start_bracket:]
        start_bracket = extract_info(i, page_hero)
        i += 1
        if start_bracket == -1:
            break

效果与前面一样。

# 三、函数进阶 #

## 1.可变位置参数 ##

一般情况下，在定义了一个包含若干个参数的函数后，在调用时，也需要传递相同数量的参数值才能正常调用函数，否则会报错。  
但是也可以看到，之前在调用`print()`函数时，每次要打印的变量数可能都不一样，即参数的数量可能是多变的，如果需要定义不变数量的参数，就需要使用参数`*args`，也称为**可变位置参数**。

如下：

def print_args(*args):
        print('Positonal args:', args)
        
    print('hello', 'Corley')
    print('hello', 'Corley','again')
    print('what', 'are','you','doing')

输出：

hello Corley
    hello Corley again
    what are you doing

显然，此时传入不同个数的参数，均可以正常调用函数。

查看`args`类型，如下：

def print_args(*args):
        print(type(args))
        print('Positonal args:', args)
        
    print_args('hello')

输出：

<class 'tuple'>
    Positonal args: ('hello',)

可以看到，传入的`args`类型被解析为元组，包含了传递的所有参数；  
`print()`函数也是用类似的方式定义的。

此时定义函数时，传递参数可以更加灵活。  
如下：

def print_args_with_required(req1, req2, *args):
        print('req1:', req1)
        print('req2:', req2)
        print('all other args:', args)
        
    print_args_with_required()

此时会报错：

---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-79-0f8d1d1519ce> in <module>
          4     print('all other args:', args)
          5 
    ----> 6 print_args_with_required()
    
    TypeError: print_args_with_required() missing 2 required positional arguments: 'req1' and 'req2'

因为这样定义函数，是表示req1和req2都是必须要传的参数，还可以根据需要决定是否需要传递其他参数，如果有则包含进`args中`，此时调用并没有传递前两个参数，因此会报错。

测试：

def print_args_with_required(req1, req2, *args):
        print('req1:', req1)
        print('req2:', req2)
        print('all other args:', args)
        
    print_args_with_required(1,2)
    print_args_with_required(1,2, 3, 'hello')

输出：

req1: 1
    req2: 2
    all other  args: ()
    req1: 1
    req2: 2
    all other  args: (3, 'hello')

此时，如果有多余的参数，则会放入元组。

## 2.可变关键字参数 ##

前面在传入额外的参数时没有指明参数名，直接传入参数值即可，但是还可以指定参数名，此时称为**可变关键字参数**，形式为`**kwargs`。

如下：

def print_kwargs(**kwargs):
        print('Keyword args:', kwargs)
        
    print_kwargs(1,2)

此时会报错：

---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-81-fbc2fa215023> in <module>
          2     print('Keyword args:', kwargs)
          3 
    ----> 4 print_kwargs(1,2)
    
    TypeError: print_kwargs() takes 0 positional arguments but 2 were given

此时需要指定参数名，如下：

def print_kwargs(**kwargs):
        print('Keyword args:', kwargs)
        
    print_kwargs(fst=1,scd=2)

输出：

Keyword args: { 'fst': 1, 'scd': 2}

可以看到，可变关键字参数被解析为字典。

可变位置参数和可变关键字参数可以结合使用。  
如下：

def print_all_args(req1, req2, *args, **kwargs):
        print('required args:', req1, req2)
        print('Positonal args:', args)
        print('Keyword args:', kwargs)
        
    print_all_args(1,2,3,4,s='hello')

输出：

required args: 1 2
    Positonal args: (3, 4)
    Keyword args: { 's': 'hello'}

在定义和调用函数时，需要注意3种参数的位置顺序：  
必填参数位于最前，可变位置参数次之，可变关键字参数位于最后。

## 3.函数定义和查看文档字符串 ##

在系统自定义的函数一般都有**文档字符串**，用来描述该函数的参数、用法注意事项等。

例如：

?print

运行后，会在页面下方弹出框，内容为：

Docstring:
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    Type:      builtin_function_or_method

其中，第一部分就是内部定义的文档字符串。

自定义的函数也可以实现该功能，如下：

def odd_or_even(num):
        ''' Return True id num is even, or return False if num is odd '''
        return num % 2 == 0
    
    ?odd_or_even

此时弹框中内容为：

Signature: odd_or_even(num)
    Docstring:
    Return True id num is even,
    or return False if num is odd
    File:      XXX\<ipython-input-85-b86074aa0e21>
    Type:      function

可以看到，是通过三对引号将文档字符串包裹起来的形式定义的，相当于注释作用，但是也是文档字符串。

还可以通过`help()`函数实现查看函数文档：

help(odd_or_even)

输出：

Help on function odd_or_even in module __main__:
    
    odd_or_even(num)
        Return True id num is even,
        or return False if num is odd

或者使用函数对象的`__doc__`属性，如下：

print(odd_or_even.__doc__)

输出：

Return True id num is even,
    or return False if num is odd

## 5.函数作为参数 ##

函数本身也可以作为参数传递到另一个函数中，进行调用。

如下：

def ask():
        print('Do you love Python?')
        
    def answer():
        print('Yes, I do')
        
    def run_sth(func):
        func()
        
    run_sth(ask)
    run_sth(answer)

输出：

Do you love Python?
    Yes, I do

可以看到，也能正常执行。

还可以传递参数：

def bin_op(func, op1, op2):
        return func(op1, op2)
    
    def add(op1, op2):
        return op1 + op2
    
    def sub(op1, op2):
        return op1 - op2
    
    print('1 + 2 =', bin_op(add, 1,2))
    print('1 - 2 =', bin_op(sub, 1,2))

输出：

1 + 2 = 3
    1 - 2 = -1

还能定义嵌套函数。  
如下：

def exp_factory(n):
        def exp(a):
            return a ** n
        return exp
    
    sqr = exp_factory(2)
    print(type(sqr))
    print(sqr(3))

输出：

<class 'function'>
    9

可以看到，调用`exp_factory(2)`时返回的是`exp()`函数，其内部为`return a ** 2`，即求一个数的平方，所以再调用`sqr(3)`时，即是调用`exp(3)`，所以返回`3**2=9`.

此即**工厂函数**模式，可以生产出具有特定功能的函数。  
再如：

cube = exp_factory(3)
    cube(3)

输出：

## 6.装饰器 ##

函数可以使用**装饰器**，实现单独使用函数所不能实现的额外功能。  
简单地说：装饰器就是修改其他函数的功能的函数，其有助于让代码更简短，也更`Pythonic`。

例如：

def should_log(func):
        def func_with_log(*args, **kwargs):
            print('Calling:', func.__name__)
            return func(*args, **kwargs)
        return func_with_log
    
    add_with_log = should_log(add)
    add_with_log(2,3)

输出：

Calling: add
    
    5

可以看到，通过传递函数到`should_log()`函数中，使得函数具有了其他功能，例如打印日志；  
`__name__`属性用于获取函数的名字。

但是显得不太方便，此时可进一步简化如下：

@should_log
    def add(op1, op2):
        return op1 + op2
    
    @should_log
    def sub(op1, op2):
        return op1 * op2
    
    add(1, 2)
    sub(1, 2)

输出：

Calling: add
    Calling: sub
    
    2

此时用更简单的方式实现了需要的功能，这就是装饰器，经常适用于授权和日志等方面。

## 7.匿名函数-lambda表达式 ##

之前定义函数都是通过特定的形式定义出来的，如下：

def mul(op1, op2):
        return op1 * op2

可以看到，该函数通过`def`关键字定义，有函数名为`mul`，同时还有两个参数和返回值，但是实际上实现的功能很简单，就是求出两个数的乘积并返回，显然，如果用到该函数的地方较少或者与当前代码相隔较远就不太合适。  
此时就可以使用**匿名函数**，即没有函数名的函数，也叫**lambda表达式**，可以实现函数的功能。  
如下：

bin_op(lambda op1, op2:op1*op2, 2,4)

输出：

lambda表达式一般用于功能不复杂且使用不多的地方。

## 8.异常处理 ##

很多时候，因代码逻辑的不正确会报错，也就是抛出异常，可以进行**捕获和处理**，从而使程序继续运行。  
此时需要使用到`try...except...`语句。  
如下：

def div(op1, op2):
        try:
            return op1 / op2
        except ZeroDivisionError:
            print('Division by zero')
            
    div(5, 0)

输出:

Division by zero

可以看到，此时除数为0，但是并没有抛出异常，而是执行了`except`中的语句；  
如果`try`代码块中无异常，则正常执行该代码块，否则执行`except`块中的代码。

还可以结合`finally`使用。  
如下：

def div(op1, op2):
        try:
            return op1 / op2
        except:
            print('Division by zero')
        finally:
            print('finished')
            
    div(5, 0)

输出：

Division by zero
    finished

此时无论执行的是`try`还是`except`中的语句，最终都会执行`finally`中的语句。  
异常处理可以提高**程序的稳定性**，尽可能降低异常对程序的影响。

> 还有额外的代码结构的练习，如有需要，可以直接点击加QQ群 [![Python极客部落][Python]963624318][Python_Python_963624318] 在群文件夹**商业数据分析从入门到入职**中下载即可。

[Python]: https://pub.idqqimg.com/wpa/images/group.png
[Python_Python_963624318]: /images/20221123/b12359cc52614aa29277cb546a3f77f0.png
[python code blocks]: /images/20221123/c9f0b04d061045f397d2f25e5b87684f.png
[python while loop break]: /images/20221123/b9810eb01b5b4c90a8ec22413172fc8b.png