函数 function
def 函数名():
# 函数实现
pass # pass空语句
# 函数执行的顺序，调用的时候才会被执行
num = 100
print(num)
# 100
def say_hello():
print('hello1')
print('hello2')
print('hello3')
print('haha')
# # 调用函数
say_hello()
'''
haha
hello1
hello2
hello3
'''
1 代码重用 2 便与修改，易扩展
# 7个长度的字符串，替换第三个字符
str1 = 'abcdefg'
str1 = str1[:2] + 'z' + str1[3:]
print(str1)
#abzdefg
str1 = '1234567'
str1 = str1[:2] + '8' + str1[3:]
print(str1)
#1284567
改进封装成函数
def set_str(msg,index,char):
"""
将目标字符串的指定位置进行替换
:param msg: 目标字符串
:param index: 替换字符串的索引位置
:param char: 要替换的字符
:return: 返回替换完成的字符串
"""
res = msg[:index] + char + msg[index+1:]
return res
# 对给定的char进行判断 isinstance(char, type) 判断两个变量是否属于某种类型
if isinstance(char, int):
char = str(char)
return msg[:index] + char + msg[index + 1:]
res = set_str('1234567',2, '9')
set_str('abcdefddd',1, 9)
res = set_str('abcdefddd',1, 9)
print(res)
- 函数的形参和实参
形式参数、实际调动的参数
区别： 形参式虚拟的，不占内存空间，形参变量只有在被调用的时候才分配内存空间; 实参是一个变量，占用内存空间，数据是单向传送的 实参传给形参，
# 求矩形面积
def area(width, length):
return width*length
w = 4
l = 6
print(area(width=4,length=6))
print(area(4,6))
#24
- 函数参数
1、必须参数：以正确的顺序传入函数，调用的时候必须和声明的时候保持一致
def f(name, age):
print('我叫%s,我今年%d岁'%(name, age))
f('张三',18)
#我叫张三,我今年18岁
f(18, '李四') #错误的
#%d format: a number is required, not str
2、关键字参数， 关键字参数允许函数调用时参数的顺序与声明不一致，因为Python解释器能够用参数名匹配参数值
f(age=19, name='李四')
3、默认参数（缺省参数）
在调用函数时，缺省的参数如果没有被传入，则会使用默认值
def f(name, age, sex = 'male'):
print('我叫%s,我今年%d岁'%(name, age))
print('性别%s'%(sex))
# f(age=19, name='李四')
f(age=19, name='李四',sex='female')
# 我叫李四,我今年19岁
# 性别female
4、不定长参数
有时候可能需要一个函数能处理比当初声明时更多的参数，这些参数叫不定长参数
def funcname([formal_args,]*args,**kwargs):
"""文档字符串"""
pass
加了星号的变量args会存放所有未命名的变量参数，args为元组
加了星星号的变量kwargs会存放命名参数,即形如 ket=value形式的参数, kwargs为字典
例1func(1, 2, c, d) 注意不加星号的传入方式
def func(a, b, *args, **kwargs):
"""
可变参数演示示例
:param a: formal_args
:param b: formal_args
:param args: 未命名的变量参数 args为元组
:param kwargs: 命名参数 kwargs为字典
:return: 无
"""
print('a = ', a)
print('b = ', b)
print('args=', args)
print('kwargs = ')
for k, v in kwargs.items():
print(k, '----->',v)
c = (3, 4, 5)
d = {"m":6,"n":7,"p":8}
func(1, 2, c, d) # 注意不加星号的传入方式
# a = 1
# b = 2
# args= ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
# kwargs =
例1func(1, 2, *c, **d) 加星号的传入方式
def func(a, b, *args, **kwargs):
"""
可变参数演示示例
:param a: formal_args
:param b: formal_args
:param args: 未命名的变量参数 args为元组
:param kwargs: 命名参数 kwargs为字典
:return: 无
"""
print('a = ', a)
print('b = ', b)
print('args=', args)
print('kwargs = ')
for k, v in kwargs.items():
print(k, '----->',v)
c = (3, 4, 5)
d = {"m":6,"n":7,"p":8}
func(1, 2, *c,**d)
func(1, 2, 3, 4, 5, m=6, n=7, p=8)#结果相同
# a = 1
# b = 2
# args= (3, 4, 5)
# kwargs =
# m -----> 6
# n -----> 7
# p -----> 8
def f(*args):
print(args)
f(*[1,2,5])
#(1, 2, 5)
def f1(**kargs):
print(kargs)
f1(**{'name':'alex'})
# {'name': 'alex'}
- 函数的返回值
如果想要获取函数的执行结果，我们一般要编写函数的返回值，使用return可以把结果返回
return 作用： return停止这个函数的执行，返回指定的结果
Python中的return可以返回多个对象， 解释器会将其组装成一个元组作为一个整体结果输出
如果未指定return，那么这个函数的返回值是 None
例：
给定一个list 将列表中所有数字进行累加，并且返回他们的累加和以及平均数
def sum_and_ave(list):
"""
:param list: 给定一个列表
:return: 返回他们的累加和以及平均数
"""
count = 0
sum = 0
for x in list:
if isinstance(x, int) or isinstance(x, float):
# 进行累加
sum += x
# 计数
count +=1
ave = sum/count
return sum, ave
li = [20, 15, 2.8, 'a', 35, 5.9, -1.8]
print(sum_and_ave(li))
print('累加和',sum_and_ave(li)[0])
print('平均数',sum_and_ave(li)[1])
# (76.9, 12.816666666666668)
# 累加和 76.9
# 平均数 12.816666666666668
- 高阶函数
满足，输入：接受一个或多个函数， 输出：一个函数
def add(x, y, f):
return f(x) + f(y)
# 传入的是函数名
res = add(3, -6, abs)#abs绝对值
#9
def method():
x = 2
def double(n):
return n*x
return double
d = method()
res2 = d(40)
print(res2)
#80
- Python系统高阶函数
1.map()
map(func, iterable)
函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，最后把处理的结果作为新的可迭代对象返回
# 举例： [1, 2, 3, 4, 5] -> [1, 4, 9, 16, 25]
def power(x):
return x*x
result = map(power, [1, 2, 3, 4, 5])
print(list(result))
# [1, 4, 9, 16, 25]
# 使用map函数: [1, 2, 3, 4, 5, 6, 7, 8, 9] -> ['1', '2', '3', '4', '5', '6', '7', '8', '9']
res2 = map(str,[1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(res2))
# ['1', '2', '3', '4', '5', '6', '7', '8', '9']
2.reduce()
reduce(func, sequence) 函数，累积操作。
func函数必须接受两个参数， reduce会把func的运行结果继续和序列的下一个元素做累积计算，reduce(func, [1,2,3]) 等同于 func(func(1,2), 3)
引入
from functools import reduce
def mul(x, y):
return x*y
li = [1, 2, 3, 4, 5]
res = reduce(mul, li)
print(res)
#120
#理解为mul(mul(mul(mul(1*2)*3)*4)*5)
3.lambda匿名函数
表达式： 不需要显示指定名字的函数
格式
函数名 = lambda 参数1，参数2，。。。n ：返回表达式
lambda 的参数可以是无限个，但是返回表达式只能有一个
优点: 1、用担心函数名冲突 2、减少代码量 3、优雅
lambda主要目的是联合其他函数使用
print(reduce(lambda x, y: x * y, li))
#120
4.filter()
filter(func,iterable) 和map相似接收一个函数和一个序列
与map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
# 如果函数返回True，则保留该数据，否则就不保留
li = [i for i in range(1, 15)]
# 将li 中所有的奇数筛选出来
print(list(filter(lambda x: x % 2 == 1, li)))
# [1, 3, 5, 7, 9, 11, 13]
5.sorted()
对数据进行排序，并且返回一个新的对象，原对象不变
from random import randint
li2 = [randint(-10,10) for _ in range(5)]
#li2 = [10, 2, 7, -5, 3]
print('排序前',li2)
res = li2.sort() # None
res = sorted(li2)
print('排序后',li2)
print('返回值',res)
# 排序前 [-4, -10, 10, 3, 7]
# 排序后 [-10, -4, 3, 7, 10]
# 返回值 [-10, -4, 3, 7, 10]
key参数可以用来指定排序的规则，key接受的值是一个函数
li2 = [-4, -10, 10, 3, 7]
res = sorted(li2, key=abs)
print(res)
#[3, -4, 7, -10, 10]
#按照绝对值排序
reverse参数是指定排序的顺序（升序还是降序），默认是升序
chars = ['lee', 'james', 'kobe', 'Antetokounmpo', 'jordan', ]
# 对chars进行排序 按照字母的长度 降序
chars = sorted(chars, key=len, reverse=True)
print(chars)
# ['Antetokounmpo', 'jordan', 'james', 'kobe', 'lee']
chars = sorted(chars, key=lambda x:len(x), reverse=True)
print(chars)
# ['Antetokounmpo', 'jordan', 'james', 'kobe', 'lee']
复合列表结构的列表排序
grade_list = [
{'name':'张三', 'grade':90},
{'name':'李四', 'grade':30},
{'name':'王五', 'grade':70},
{'name':'赵六', 'grade':52},
]
print(grade_list)
# 按照成绩进行排序
grade_list = sorted(grade_list, key=lambda d:d['grade'])
print(grade_list)
stu_info = [
('wunan',22),('yangjiulin',39),('hanlei',17),('chenzhenqi', 90)
]
# 按照年龄降序排序
stu_info = sorted(stu_info, key=lambda x:x[1], reverse=True)
print(stu_info)
回顾三目运算符
store = ['']
print(len(store))
if len(store) == 0:
store = '当当自营'
else:
store = store[0]
print(store)
# 改成三目运算符
print('当当自营' if len(store) == 0 else store[0])
# 满足条件时返回的值 if 满足的条件 else 不满足条件时返回的值
# 将 x, y 如果 x>y 返回 x*y else x <= y x /y需求使用lambda表达式进行编写
res = lambda x, y:x*y if x > y else x/y
print(res(2, 5))
print(res(5, 2))
网友评论