函数

函数就像程序内的小程序

1.定义函数：

def关键字 缩进控制函数代码块 其中代码块也称为函数体，函数在调用时执行而不是定义时

def hello():
    print('world')
hello()
hello()
hello()

def hello(ni):
    print('world'+ni)
hello('Bob')
hello('Alice')
hello('mary')

ni 为参数 即一个名为ni的变元 是一个变量 当函数被调用时 参数就存放在其中：在函数返回时就丢失了

2.返回值和return语句

import random
def getAnswer(answerNumber):
    if answerNumber == 1:
        return 'It is certain'
    elif answerNumber == 2:
        return 'It is decidedly so'
    elif answerNumber == 3:
        return 'Yes'
    elif answerNumber == 4:
        return 'Reply hazy try again'
    elif answerNumber == 5:
        return 'Ask again later'
    elif answerNumber == 6:
        return 'Concentrate and ask again'
    elif answerNumber == 7:
        return 'My reply is no'
    elif answerNumber == 8:
        return 'Outlook not so good'
    elif answerNumber == 9:
        return 'Very doubtful'
r = random.randint(1, 9)
fortune = getAnswer(r)
print(fortune)

3.None值

在后台：对于所有没有 return 语句的函数定义，Python 都会在末尾加上 return None。这类似于 while 或 for 循环隐式地以 continue 语句结尾。而且，如果使用不带值的 return 语句（也就是只有 return 关键字本身），那么就返回 None。

spam = print('Hello')
None == spam

1. Hello
2. True

4.关键字参数和print函数

大多数函数的参数是由他们在函数中调用的位置来确定的，但是关键字参数是由在调用函数时所加的关键字来识别的，关键字参数通常用于可选变元
例如 print()函数有可选变元end和sep 分别指定在参数末尾打印什么以及用什么分割参数

print('Hello', end = ' ')
print('World')
print('qqq','www','eee', sep = ',')

5.局部和全局作用域

在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”。在所有函数之外赋值的变量，属于“全局作用域”。处于局部作用域的变量，被称为“局部变量”。处于全局作用域的变量，被称为“全局变量”。一个变量必是其中一种，不
能既是局部的又是全局的。可以将“作用域”看成是变量的容器。当作用域被销毁时，所有保存在该作用域内的变量的值就被丢弃了。

1. 全局作用域中的代码不能使用任何局部变量；
2. 但是，局部作用域可以访问全局变量；
3. 一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。
4. 如果在不同的作用域中，你可以用相同的名字命名不同的变量。也就是说，可以有一个名为 spam 的局部变量，和一个名为 spam 的全局变量。

6.global语句

如果在一个函数内修改全局变量就用 global语句

def spam():
    global eggs
    eggs = 'spam'
eggs = 'glabol'
spam()
print(eggs)

有 4 条法则，来区分一个变量是处于局部作用域还是全局作用域：

1. 如果变量在全局作用域中使用（即在所有函数之外），它就总是全局变量。
2. 如果在一个函数中，有针对该变量的 global 语句，它就是全局变量。
3. 否则，如果该变量用于函数中的赋值语句，它就是局部变量。
4. 但是，如果该变量没有用在赋值语句中，它就是全局变量。

def spam():
    global eggs
    eggs = 'spam' # this is the global
def bacon():
    eggs = 'bacon' # this is a local
def ham():
    print(eggs) # this is the global
eggs = 42 # this is the global
spam()
print(eggs)

• spam

7.异常处理

希望程序在遇到错误时，处理异常并且继续运行，就得处理异常
异常可以由try和except语句来处理 把可能会出错的代码块放在try子句中，如果发生错误就直接跳转到except子句开始处

def  math(num):
    return  30/num
try:
    math(10)
    math(2)
    math(0)
except ZeroDivisionError: # 这里不能乱写 必须要写正常的报错类型
    print('division by zero')

一个猜数字游戏

import random
num1 = random.randint(1,20)
for i in range(1,7):
    num2 = int(input())
    if num1 < num2:
        print('你猜的数据大了')
    elif num1 > num2:
        print("你猜的数据小了")
    else:
       break
if num1 ==num2:
    print('你猜对了,神秘数字是：' + str(num1))   
else:
    print('你猜的是 '+ str(num2) + '神秘数字是 ' + str(num1))

8.总结

函数时将代码逻辑分组的主要方式，因为函数中的变量作用于他们局部作用域中，所以一个函数中的代码不能直接影响其他函数中变量的值。这限制了哪些代码才能改变变量的值 对于调试很有帮助。函数是个很好的工具，可以把他当做一个黑盒，他们以参数的形式接受输入，以返回值的形式产生输出，他们内部的代码不会影响其他函数的变量。

9.练习

1. 为什么在程序中加入函数会有好处？
2. 函数中的代码何时执行：在函数被定义时，还是在函数被调用时？
3. 什么语句创建一个函数？
4. 一个函数和一次函数调用有什么区别？
5. Python 程序中有多少全局作用域？有多少局部作用域？
6. 当函数调用返回时，局部作用域中的变量发生了什么？
7. 什么是返回值？返回值可以作为表达式的一部分吗？
8. 如果函数没有返回语句，对它调用的返回值是什么？
9. 如何强制函数中的一个变量指的是全局变量？
10. None 的数据类型是什么？ # NoneType
11. import areallyourpetsnamederic 语句做了什么？
12. 如果在名为 spam 的模块中，有一个名为 bacon()的函数，在引入 spam 后，如何调用它？
13. 如何防止程序在遇到错误时崩溃？
14. try 子句中发生了什么？except 子句中发生了什么？
    这些简单问题先留个以后有个印象

9.Collatz 序列

编写一个名为 collatz()的函数，它有一个名为 number 的参数。如果参数是偶数，那么 collatz()就打印出 number // 2，并返回该值。如果number 是奇数，collatz()就打印并返回 3 * number + 1然后编写一个程序，让用户输入一个整数，并不断对这个数调用 collatz()，直到函数返回值１（令人惊奇的是，这个序列对于任何整数都有效，利用这个序列，你迟早会得到 1！既使数学家也不能确定为什么。你的程序在研究所谓的“Collatz序列”，它有时候被称为“最简单的、不可能的数学问题”）。

def collatz(number):
    if number % 2 == 0:
        print(number  // 2)
        return number // 2
    if number  % 2 == 1:
        print(3*number + 1)
        return 3*number + 1
print('Enter number: ')
try:
    input_number = int(input())
    while True:
        input_number = collatz(input_number) 
        if collatz(input_number) == 1:
            break  
except ValueError:
    print('请输入一个整数')

说明：
第一次在用户输入整数对函数不断调用这里出了问题，最后理解了一下 ：要不断迭代这个返回值再次调用：input_number = collatz(input_number)
即 把函数的返回值在赋给要传入的参数值 这一点很重要
也可以改写一下：

def collatz(number):
    if number % 2 == 0:
        print(number  // 2)
        return number // 2
    if number  % 2 == 1:
        print(3*number + 1)
        return 3*number + 1
print('Enter number: ')
try:
    input_number = int(input())
    while True:
        number_1 = collatz(input_number)
        input_number = number_1
        if collatz(input_number) == 1:
            break  
except ValueError:
    print('请输入一个整数')

输入333，输出结果：
Enter number:
1000
500
500
250
250
125
125
376
376
188
188
94
94
47
47
142
142
71
71
214
214
107
107
322
322
161
161
484
484
242
242
121
121
364
364
182
182
91
91
274
274
137
137
412
412
206
206
103
103
310
310
155
155
466
466
233
233
700
700
350
350
175
175
526
526
263
263
790
790
395
395
1186
1186
593
593
1780
1780
890
890
445
445
1336
1336
668
668
334
334
167
167
502
502
251
251
754
754
377
377
1132
1132
566
566
283
283
850
850
425
425
1276
1276
638
638
319
319
958
958
479
479
1438
1438
719
719
2158
2158
1079
1079
3238
3238
1619
1619
4858
4858
2429
2429
7288
7288
3644
3644
1822
1822
911
911
2734
2734
1367
1367
4102
4102
2051
2051
6154
6154
3077
3077
9232
9232
4616
4616
2308
2308
1154
1154
577
577
1732
1732
866
866
433
433
1300
1300
650
650
325
325
976
976
488
488
244
244
122
122
61
61
184
184
92
92
46
46
23
23
70
70
35
35
106
106
53
53
160
160
80
80
40
40
20
20
10
10
5
5
16
16
8
8
4
4
2
2
1

9.1collatz序列提示说明

1. str()与int()转换说明：
   input()的返回值为str字符串型，需要使用int()函数将其转成一个整数，否则程序在运行的时候会报错
2. 奇数和偶数如何判断说明：
   如果number % 2 == 0,则整数number就是偶数；如果number % 2 == 1,则整数number就是奇数

这个collatz序列还挺有意思的 任何一个数通过这个操作都会变成1
感觉像物理中的相互作用 不管一开始是奇数还是偶数，奇数就乘3加1 --增加能量 使他变成偶数 在除2取整 --减少能量 使得最终都会变成1