python函数

定义

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

t = input()
s = int(t)
print(my_abs(s))

异常错误处理

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

空函数–占位

def nop():
    pass

返回值 可以为多个值–实际为元祖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

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

小结

• 定义确定函数名和参数
• 必要时检查参数类型
• 返回值可以为空，多个时为tuple
• 引入import

函数参数

默认参数

# 递归求幂
def power(x,n):  # 参数有两个，且都要传入
    if n == 1:
        return x
    elif n == 0:
        return 1
    elif n % 2 == 0:
        t = power(x,n/2)
        return  t * t
    elif n % 2 == 1:
        t =power(x,(n-1)/2)
        return t * t * x

print(power(2,4))  # 必须传两个参数

# 设置一个n有默认值，则可以只传入一个参数

def power(x,n = 2):   # 常用的 2次方 设默认
    if n == 1:
        return x
    elif n == 0:
        return 1
    elif n % 2 == 0:
        t = power(x,n/2)
        return  t * t
    elif n % 2 == 1:
        t =power(x,(n-1)/2)
        return t * t * x

print(power(2))   # 可以只传一个参数等价于 power(2,2)
print(power(2,4))  # 也可以传两个参数

注意： 默认参数只能放在最后，可以为多个

注意： 默认参数必须为不可变对象

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

print(add_end([1,2,'aa']))  # [1, 2, 'aa', 'END']
print(add_end([1,2,'hh']))  # [1, 2, 'hh', 'END']
print(add_end())  # ['END']  默认参数L列表被记住为‘END’,下次默认参数就不是空了而是上一个列表
print(add_end())  # ['END', 'END']
print(add_end())  # ['END', 'END', 'END']

# 需要将L变为 不变对象 L = None(不变对象)
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

可变参数

nums = [1,2,3] 或 nums = (1,2,3)

*nums 把nums列表/元祖中可变参数传入

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum += n*n
    return sum
    
print(calc(1,2,3))
print(calc(1,3,4,5))

nums = [1,3,4]
print(calc(*nums))

test1 = (1,2,3)
print(calc(*test1))

关键字参数

根据传入的参数自动组装为字典dict

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

>>> person('a',10)
name: a age: 10 other: {}

>>> person('b',20,cith='BJ')
name: b age: 20 other: {'cith': 'BJ'}

>>> person('b',20,cith='BJ',job = 'Eng')
name: b age: 20 other: {'cith': 'BJ', 'job': 'Eng'}

>>> extra = {'city':'BJ','job':'Eng'}
>>> person('a',10,**extra)
name: a age: 10 other: {'city': 'BJ', 'job': 'Eng'}
>>>

命名关键字

限制关键字名字，使用命名关键字，通过 * 隔开

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

person('jack',19,city='BJ',job='eng')  # jack 19 BJ eng 后面的命名关键字必须相同

也可以设置默认的命名关键字

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

person('jack',19,job='eng')    # jack 19 BJ eng

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

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)

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}

>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}

>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}

>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

特殊情况 需要深入理解*num 和 **kw

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)    #  将args中可变参数依次传入
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)     #   将**kw中对于传入
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

小结

• 默认参数 一定为 不可变参数
• 可变参数 *args 为 tuple ，传入表示为 f(*args) == f(1,2,3)
• 关键字参数 **kw 为 dict , 传入表示为 f(**kw) == f(a=1,b=2)
• 命名关键字参数 为了 限制使用者传入的参数名，同时提供默认值，用*分隔表示