一、定义
1、语法 def 函数名( ): 函数体
二、属性
1、函数在内存中准备好的代码,不会自动执行,只有手动调用时才执行,调用方式:函数名+括号; 2、函数是语句的封装; 3、函数声明时,在括号内传递参数,我们称之为形式参数(形参),只起到占位的作用; 4、函数调用时,传入的参数,我们称之为实际参数(实参)
三、操作
1、函数的参数
def pr_max(a, b):
x = a if a > b else b
print(x)
pr_max(34, 2)
def pr_sum(a, b):
print(a + b)
pr_sum(2, 3)
def sort_list(L):
L.sort()
nums = [8, 0, 1, 2, 9, 5, 4]
sort_list(nums)
print(nums)
- 2)可变参数
参数的个数不固定,就可以称为可变参数; 在python里有两种可变参数,*args、**kwargs; *args:可变参数,它是把参数以元组的形式保存; **kwargs:可变参数,它是把参数以字典的形式保存;
def demo(a, b, *args):
result = a + b
for arg in args:
result += arg
return result
print(demo(1, 2))
print((demo(1, 2, 3)))
- 3)缺省参数
在函数声明时,定义形参并给形参设置一个默认值,这种参数可以称之为缺省参数; 如果有缺省参数,缺省参数要放在非缺省参数的后面;
def demo(a, b, x='hello'):
print('a========>{}'.format(a))
print('b========>{}'.format(b))
print('x========>{}'.format(x))
demo('good', 12)
demo(100, 'yes', 'xxx')
demo(x='mmm', a=100, b='ssss')
- 4)可变参数和缺省参数同时出现
位置参数必须要放在关键字参数的前面
def demo(a, b, *args, x='hello', y='nice',**kwargs):
print('a========>{}'.format(a))
print('b========>{}'.format(b))
print('args========>{}'.format(args))
print('x========>{}'.format(x))
print('y========>{}'.format(y))
print('kwargs========>{}'.format(kwargs))
demo(12, 23, 100, 50, 'yes', 'no', x='qqqq', y='wwww')
names = ('zhangsan', 'lisi', 'wangwu')
person = {'name': 'zhangsna', 'age': 18}
demo(12, 34, names, x='qqqq', y='wwww')
demo(12, 34, *names, x='qqqq', y='wwww', **person)
2、函数返回值
- 如果一个函数没有return语句,那么这个函数的返回值的None;
- return语句后面不能再有任何的语句,因为执行不到,return表示函数的结束
def get_max(a, b):
x = a if a > b else b
return x
result = get_max(12, 3)
print(result * 2)
3、函数多个返回值
- 可以使用列表、元组、set设置字典等让一个函数有多个返回值结果
- 推荐使用元组(元组不可变)
def get_max_and_index(nums):
x = max(nums)
x_index = nums.index(x)
print(x, x_index)
get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
def get_max_and_index(nums):
x = nums[0]
x_index = 0
for i, num in enumerate(nums):
if num > x:
x = num
x_index = i
return x, x_index
result = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
print('列表里的最大数是{},它的下标是{}'.format(result[0], result[1]))
my_max, max_index = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
print('列表里的最大数是{},它的下标是{}'.format(my_max, max_index))
4、多个return语句
- 一般情况下,一个函数只会执行一个return语句;
- 在某种特殊情况(finally语句)下,有可能执行多个return语句
def get_max(a, b):
if a > b:
return a
else:
return b
result = get_max(23, 5)
print(result)
5、函数调用函数
def test1():
print('test1开始了')
print('test1结束了')
def test2():
print('test2开始了')
test1()
print('test2结束了')
test2()
6、函数的联系及注释
注释有两种格式:单行注释:#;多行注释:’’’ 注释 ‘’’ “”“注释 “””
def get_sum(n):
x = 0;
for i in range(1, n + 1):
x += i
return x
print(get_sum(100))
def get_total(n):
x = 0
for i in range(1, n + 1):
x += get_sum(i)
return x
print(get_total(5))
7、局部变量和全局变量
a = 100
def test():
b = 45
print('a的结果是====>{}'.format(a))
print('b的结果是====>{}'.format(b))
test()
print('函数外a是===>{}'.format(a))
8、数据的传递
- 在python里,任何的值传递都是内存地址的传递
- 如果修改了数据,内存地址没有发生变化,认为它是可变类型
- 如果修改了数据,内存地址发生了变化,认为它是不可变类型
def test(x):
x = 10
a = 20
test(a)
print(a)
def demo(x):
x[0] = 100
nums = [1, 2, 3]
demo(nums)
print(nums)
9、lambda表达式
- 匿名函数:用lambda关键词能创建小型匿名函数,这种函数得名于省略了用def声明函数的标准步骤;
- lambda函数的语法只包含一个语句: lambda 参数列表:运算表达式;
- 用处:lambda表达式,即匿名函数,一般用于把一个函数当做参数使用
- 1、栗子
def add(a, b):
return a + b
a = 12
b = 'hello'
x = add
add(1, 2)
print(x(1, 2))
fn = lambda a, b: a + b
print(fn(2, 3))
def test(a, x, y):
result = a(x, y)
print(result)
test(lambda m, n: m if m > n else n, 4, 30)
- 3、栗子,匿名函数的使用——sort、sorted
persons = [
{'name': 'zhangsan', 'age': 19},
{'name': 'lisi', 'age': 20},
{'name': 'jerry', 'age': 17},
{'name': 'herry', 'age': 22},
{'name': 'merry', 'age': 14},
{'name': 'tony', 'age': 23},
]
def demo(element):
return element['age']
persons.sort(key=demo)
persons.sort(key=demo, reverse=True)
persons.sort(key=lambda element: element['age'])
print(sorted(persons, key=lambda element: element['age']))
print(persons)
- 4、栗子,匿名函数的使用——filter
filter(function or None, iterable) --> filter object
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
x = []
for num in nums:
if not num % 2:
x.append(num)
print(x)
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
def test(element):
return element % 2 == 0
result = list(filter(test, nums))
print(result)
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
result = list(filter(lambda element: not element % 2, nums))
print(result)
- 5、map
可迭代对象操作函数的区别: 1)map和filter在python2里是内置函数,返回值结果就是一个列表;在python3里,map和filter变成了内置类,结果时map和filter对象,而不再是list列表;
nums = [1, 2, 3, 4, 5, 6]
def fn(element):
return element ** 2
result = list(map(fn, nums))
print(result)
result = list(map(lambda element: element ** 2, nums))
print(result)
- 6、reduce
1)reduce在python2里是内置函数,不需要额外的导入模块;在python3 里需要额外导入functiontools模块 For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5)
from functools import reduce
def foo(a, b):
print('a===={},b===={}'.format(a, b))
return a + b
print(reduce(foo, nums))
print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5, 6]))
from functools import reduce
persons = [
{'name': 'zhangsan', 'age': 19},
{'name': 'lisi', 'age': 20},
{'name': 'jerry', 'age': 17},
{'name': 'herry', 'age': 22},
{'name': 'merry', 'age': 14},
{'name': 'tony', 'age': 23},
]
def bar(x, y):
if isinstance(x, dict):
return x['age'] + y['age']
return x + y['age']
print(reduce(bar, persons))
|