def get_fullname(first_name,last_name='杜'):
    '''
    求全名
    :param last_name:姓
    :param first_name: 名
    :return: 全名
    '''
    full_name=last_name+first_name
    return full_name

full_name=get_fullname(first_name='亚宁')
print(full_name)

变长参数

一个星号*将参数都放置到一个元组中

def self_print(name,*a):
    print(a)
    print(type(a))
    print(name)
self_print(1,2,3,4,5,6)

两个星号 ** 将参数都放到字

def d_self_print(**kwargs):
    print(kwargs)

d_self_print(last_name='张',first_name='三')

形参顺序：位置参数->元组->字典

def mix(name,*t,**kw):
    print(name)
    print(t)
    print(kw)

mix('王五',20,'李四')
mix('wangwu',20,'lisi',sex='nv')

t=(1,2,3,4,5)
print(*t)

*有拆开元组列表的作用

def f(*tt):
    print(tt)

f(*(1,2,3,4,5))

**有拆字典的作用

def ff(**kwargs):
    print(kwargs)
ff(**{'name':'zhangsan','age':20})

return 返回值可以用，分割，代表一个元组

def sum_and_avg(*numbers):
    total=sum(numbers)
    avg_numbers=total/len(numbers)
    return  total,avg_numbers

sum,avg=sum_and_avg(1,2,3,4,5,6,7,8,9,10)
print('总和是:',sum)
print('平均值是:',avg)

函数的传参问题

数据分为引用类型，普通类型
python中基本数据类型都是普通类型，例如数，布尔，字符串，
除了这些之外都是引用类型
普通类型赋值时传的是值本身
引用类型赋值时传的是地址

l1=[1,2,3,4,5]
l2=l1
l2[0]=5
print(l1)
print(l2)

a=5
b=a
b=10
print(a)

def power(numbers):
    #numbers=[x**2 for x in numbers]
    numbers=numbers[:]
    numbers[3]=10
    return numbers
nums=[1,2,3,4]
print(power(nums))
print(nums)

内层函数可以访问外层函数的变量，但不能修改

内层函数访问变量时，先从自己内部查找，如果找不到，就会层层向上查找
python中，变量的作用域是以函数为单位的
global修饰变量时，说明使用的是最外层的全局变量
nonlocal修饰变量时，说明使用的是嵌套函数的变量
闭包闭包的本质是函数嵌套函数，外层函数返回内层函数的地址

aa=10
def outter():
    aa=10
    def inner():
        nonlocal aa
        aa-=1
        print(aa)
    return  inner

fo=outter()
fo()
print(aa)

递归：函数自己调自己，编写递归或循环一般先考虑出口（结束的条件）问题

阶乘
5！=54321

    mm=1
    for num in range(1,n+1):
        mm*=num
    return mm
print(factorial(5))
#使用递归
def factorial1(n):
    if n==1:
        return 1
    return n*factorial1(n-1)
print(factorial1(5))

斐波那契数列：1 1 2 3 5 8 13

#用循环实现
def fbnq(n):
    list=[1,1]
    for i in range(2,n):
        sum=list[i-1]+list[i-2]
        list.append(sum)
    return list
print(fbnq(8))

#用递归实现
def fibonacci(n):
    if n==1 or n==2:
        return 1
    return fibonacci(n-1)+fibonacci(n-2)
print(fibonacci(5))

高阶函数：函数的参数或函数的返回值是函数的函数

def handle(func,*param):
    return func(*param)

def my_sum(*param):
    sum=0
    for j in range(len(param)):
        sum+=param[j]
    return  sum
print(my_sum(1,2,3,4,5))
#函数的参数还是一个参数
print(handle(my_sum,1,2,3,4,5))

map(func,interable) 该函数会把inteable中的数据一次传递给fun函数处理，最后把处理结果返回

[1,2,3,4,5]-->[1,4,9,16,25]
def power(x):
    return x*x

res=map(power,[1,2,3,4,5,6])
# for i in res:
#     print(i)
res=map(lambda x:x*x,[1,2,3,4,5,6])
print(list(res))

reduce 函数累积操作
func函数必须接受两个参数，reduce会把func的运行结果当作一个参数，然后从inteable中再取一个数据当作另一个参数

from functools import reduce
li=[1,2,3,4,5]
result=reduce(lambda x,y:x*y,li)
print(result)

filter(func, interable) 根据函数func来过滤interbale
如果函数返回True，就保留该数据，否则删除该数据

li=[1,2,4,5,6,9,10,15]
res=list(filter(lambda x:x%2==1,li))
print(res)

sort(interable,key=none,reverse=False)对数据进行排序，key可以用来指定排序的规则，值是一个函数，reverse是用来指定排序的顺序：升序或降序

li=[1,4,5,-2,-9]
li.sort()#就地排序
print(li)

#list自带的sort方法会形象原始数据，系统的sorted不会影响原始数据

res=sorted(li,key=abs)
print(res)
print(li)

函数