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)
