（四）Python 函数

func.py
abstest.py
# 1.内置函数 Built-in Function

# Python内置了很多有用的函数，我们可以直接调用。

# 要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。可以直接从Python的官方网站查看文档：

# http://docs.python.org/3/library/functions.html#abs

# 也可以在交互式命令行通过help(abs)查看abs函数的帮助信息。

print(abs(100)) # 100
print(abs(-20)) # 20
print(abs(12.34)) # 12.34

print(max(2, 3, 1, -5)) # 3

print(int('123')) # 123
print(int(12.34)) # 12
print(float('12.34')) # 12.34
print(str(1.23)) # '1.23'
print(str(100)) # '100'
print(bool(1)) # True
print(bool('')) # False



# 2. 定义函数
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

# 如果你已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，
# 用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）
from abstest import my_abs
print(my_abs(-9))



# 3. 空函数
def nop():
    pass

# pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，
# 就可以先放一个pass，让代码能运行起来。

# pass还可以用在其他语句里，比如：
num = 20
if num > 18:
	pass
else:
	print('num <= 18')



# 4. 返回多个值
import math
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

print(move(1, 2, 1, 60)) # (0.04758701958484368, 2.3048106211022166) 返回多值其实就是返回一个tuple
x, y = move(1, 2, 1, 60)
print(x, y) # 0.04758701958484368, 2.3048106211022166, tuple赋值给变量时会自动展开



# 5. 默认参数
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(3)) # 9


def func(x, a=2, b=3, c=4):
    print(x, a, b, c)

# 指定默认参数
func(1, b=1) # 1 2 1 4



# 6. 可变参数, 变长参数, 打印可以看到参数列表也是一个tuple
def func(*params):
    print(len(params)) # 4
    print(params) # (1, 2, 3, '4')

func(1, 2, 3, '4')


# 7. 关键字参数
def func(a, b, c, **params):
    print(params)

func(1, 2, 3, i='a', j=10)  # {'i': 'a', 'j': 10}, 传入自定义参数时自动组装成dict

d={'n':'a', 'm':11}
func(1, 2, 3, **d) # {'n': 'a', 'm': 11}, 也可以传入定义好的dict，记住前面加**




# 练习，组合各种类型参数
def func(a, b, c=10, *args, **kw):
    print(a, b, c, args, kw)

func(1, 2, 3, 4, 5, 6, aa=7, bb=8) # 1 2 3 (4, 5, 6) {'aa': 7, 'bb': 8}



# 8. 递归函数
# 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
# 求和[1-5]
# a. 循环写法
def func():
    sum = 0
    for num in range(1,6):
        sum = sum + num
    return sum

print(func()) #15

# b. 递归写法
def func(num):
    if num==0:
        return num
    return num + func(num-1)

print(func(1000)) # 15

# func(5)
# 5 + func(4)
# 5 + (4 + func(3))
# 5 + (4 + (3 + func(2)))
# 5 + (4 + (3 + (2 + func(1))))
# 5 + (4 + (3 + (2 + 1)))


# 注意：func(1000) 会有报错 RuntimeError: maximum recursion depth exceeded in comparison
# 使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
# 每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，
# 所以，递归调用的次数过多，会导致栈溢出。

# 能用循环的尽量用循环，递归深度不大的可以用递归
猜你喜欢
