函数&参数

#函数
#抽象
#调用内置函数

abs(-100)
max(1,2,3,4,0)

#数据类型转换

a = int('123')
print("int('123') : ",a) #123
a = int(12.34)
print("int(12.34) : ",a) #12
a = float('12.34')
print("float('12.34') : ", a) #12.34
print("str(1.23) : ",str(1.23)) #1.23
print("bool(1) : ",bool(1)) #True
print("bool('') : ",bool('')) #False
print("bool(0) : ",bool(0))#False

#函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”

a = abs
print("a(-1) : ",a(-1))#1

#定义函数

def my_abs(x):
    if x > 0:
        return x
    else:
        return -x

print('自定义函数 my_abs(-99) : ',my_abs(-99)) #99
#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return
#用from abstest import my_abs 来导入my_abs()函数，注意abstest是文件名

#空函数 如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

#pass还可以用在其他语句里，缺少了pass，代码运行就会有语法错误
#if age >= 18:
#pass
#数据类型检查可以用内置函数isinstance()实现，如果传入错误的参数类型，函数就可以抛出一个错误：

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

函数可以同时返回多个值，但其实就是一个tuple。

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)#151.96152422706632 70.0

#但其实这只是一种假象，Python函数返回的仍然是单一值tuple，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值

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

默认参数

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
power(5,2) #25

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

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

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

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

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

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

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

可变参数

#以下为list或tuple的方式，调用的时候有点麻烦

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

#调用的时候，需要先组装出一个list或tuple

calc([1, 2, 3])
calc((1, 3, 5, 7))

#如果利用可变参数

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

#调用函数的方式可以简化成这样

calc(1, 2, 3)
calc(1, 3, 5, 7)

#定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple
#如果已经有一个list或者tuple

nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2])#这种调用方式太繁琐
#可以在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去
calc(*nums)

关键字参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

#函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数，也可以传入任意个数的关键字参数：

person('Michael', 30) #name: Michael age: 30 other: {}
person('Adam', 45, gender='M', job='Engineer')#name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

#场景 正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
#和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去

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

#上面复杂的调用可以用简化的写法：

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) #name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}，传入的是拷贝

命名关键字参数

#限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数

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

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

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

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

#person('Jack', 24, 'Beijing', 'Engineer') #报错
#命名关键字参数可以有缺省值，从而简化调用，调用的时候就可以不写
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
person('Jack', 24, job='Engineer') #Jack 24 Beijing Engineer

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

参数组合

#顺序： 必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

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)

#通过一个tuple和dict，你也可以调用上述函数