函数

#函数
#调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，
#并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个

#如果传入的参数数量是对的，但参数类型不能被函数所接受，
#也会报TypeError的错误，并且给出错误信息：str是错误的参数类型
print(abs(-100))

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

#数据类型转换
int('123') #123
int(12.23) #12
float('12.34') #12.34
str(1.23) #'1.23'
str(100) #'100'
bool(1) #True
bool('') #False

#定义函数
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

print(my_abs(2))

#test.py
#test2.py from test import my_abs
#不能数字开头

#空函数
def nop():
    pass

age = 0
#pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，
#比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
#缺少了pass，代码运行就会有语法错误
if age >= 18:
    pass


#当传入了不恰当的参数时，内置函数abs会检查出参数错误，而我们定义的my_abs没有参数检查，
#会导致if语句出错，出错信息和abs不一样。所以，这个函数定义不够完善。

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

x, y = move(100, 100, 60, math.pi / 6)
print(x, y)

r = move(100, 100, 60, math.pi / 6)
print(r)

#返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，
#按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便

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

#必选参数在前，默认参数在后

print(power(2))
print(power(2, 3))

def enroll(name, gender, age=6, city='Beijing'):
    print(name, gender, age, city)

enroll('Adam', 'M', city='Tianjin')

# 默认参数必须指向不变对象

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

def add_end2(L2=None):
    if L2 is None:
        L2 = []
    L2.append('END')
    return L2

print(add_end2())
print(add_end2())
print(add_end2())

#可变参数
def calc(*numbers):
    sum = 0
    for n in  numbers:
        sum = sum + n * n
    return sum

print(calc(1, 2))
print(calc(*[1,2,3]))

#关键字参数
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])
person('Jack', 24, **extra)

#命名关键字参数

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

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


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

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

#def fact(n):
#    if n==1:
#        return 1
#    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)

print(fact(100))

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

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