函数

最新推荐文章于 2021-12-18 15:23:22 发布

沟通障碍的游戏废人

最新推荐文章于 2021-12-18 15:23:22 发布

阅读量175

点赞数

本文链接：https://blog.csdn.net/riku22/article/details/97289464

版权

函数

引子：

求1-16的和：

求24-54的和：

求36-100的和：

程序而言：函数就是对程序逻辑进行结构化或者过程化的一种编程方法。

built-in function 内置函数 —>BIF

函数的定义

声明函数的一般形式：

def function_name(arg1,arg2,...,argn):
    ```statements````
    func_statements
    return Value

说明:

1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。
2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

函数的调用

格式：

函数名（参数）

函数的文档说明

格式：

help(函数名)
函数名._doc_

函数的参数

不传参函数
传参函数
顺序
- 必选参数、默认参数、可变参数、命名关键字参数和关键字参数**。

函数返回值

return 返回值

函数的参数种类

形参和实参

形参
- 只有在调用时才分配内存单元。调用结束后，立即释放所分配的内存单元。因此，形参只在函数内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量。
实参
- 实参是一个确定的值，能够传递

位置参数

只传递实参，位置一一对应----->位置参数

使用位置参数时和函数头定义的形参在顺序，个数，以及类型上匹配。

def user_manage(name,age,job):
    print('Name:',name)
    print('Age:',age)
    print('job:',job)

user_manage('Tom',18,'IT') 
#输出
Name: Tom
Age: 18
job: IT

默认值参数

Python函数支持默认参数，即可以给函数的参数指定默认值。当该参数没有传入相应的值时，该参数就使用默认值。

def user_manage(name,age,job,hobby='Trip'):
    print('Name:',name)
    print('Age:',age)
    print('Job:',job)
    print('Hobby:', hobby)

user_manage('Tom',18,'IT')
#输出
Name: Tom
Age: 18
Job: IT
Hobby: Trip

关键字参数

默认值参数，关键字参数，必须放置于位置参数之后

def user_manage(name,age,job='IT',hobby='Trip'):
    print('Name:',name)
    print('Age:',age)
    print('Job:',job)
    print('Hobby:', hobby)

user_manage('Tom',18,'IT','Coding')
user_manage('Jam',19,'Student','Studying')
#输出
Name: Tom
Age: 18
Job: IT
Hobby: Coding
Name: Jam
Age: 19
Job: Student
Hobby: Studying

不定参数

在Python中不定参数主要是指*args和**kwargs两个变量

他们两个主要是用于函数定义，我们可以将不定数量的参数传递给一个函数

函数内部args收到的参数类型为元组，kwargs收到的参数类型为字典

def x(*args):
    s = 0
    for i in args[0]:
        s += i
    return s / len(args[0])

li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x(li))
#输出
5.0

def y(**kwargs):
    print(kwargs)
    print(type(kwargs))
y(a=1,b=2,c=3)
#输出
{'a': 1, 'b': 2, 'c': 3}
<class 'dict'>

递归函数

函数不断调用自身

def fib(n):
    if n == 1 or n ==2:
        return 1
    else:
        return fib(n-2) + fib(n-1)
print(fib(10))
#55

匿名函数（lambda）

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

格式：

lambda para1, para2, para3, ..., paraN : expression using paras

def add(x, y, z):
    return x + y + z
f = lambda x, y, z: x + y + z
print(add(1, 2, 3))
print(f(1, 2, 3))
#6
#6

高阶函数

高阶函数：把一个函数名，以实参的形式，传递给这个函数的形参，这个函数就成为高阶函数。

def pow_2(x):
    return x**2
def add(a, b, c):
    return c(a) + c(b)
a_value = add(-9, 1, pow_2)
print(a_value)
#82

filter函数

通过函数实现过滤：

li = ['Zhejiang', 'University', 'City', 'College']
s = lambda sr:sr.startswith('C')
e = lambda sr:sr.endswith('ty')
def filter_test_2(para, n):
    ret = []
    for i in para:
        if not n(i):
            ret.append(i)
    return ret
print(filter_test_2(li, s))
print(filter_test_2(li, e))
#['Zhejiang', 'University']
#['Zhejiang', 'College']

filter：

功能：

过滤掉序列中不符合函数条件的元素。当序列中需要保留的元素可以用某些函数描述时，就应该想到filter函数。

调用格式：

filter(function, sequence)
- function —> 可以是自定义的函数，也可以是匿名函数
- sequence —> 列表、元组、字符串

li = ['Zhejiang', 'University', 'City', 'College']
fl = filter(lambda sr: sr.endswith('ty'), li)
print(list(fl))
#['University', 'City']

map 映射

功能

求一个序列或者多个序列进行函数映射后的值。（用list()强转）

格式

map(function, iterable1, iterable2)
- function的参数可以不止一个
- iterable1，iterable2就是传入的参数

li = [1, 2, 3, 4, 5]
li2 = [3, 4, 5, 6, 7, 8]
res = map(lambda x, y: x*y+2, li, li2)
print(list(res))
#[5, 10, 17, 26, 37]

使用其他方法实现类似功能：

def func_test(oj):
    return oj+1
def func_test2(oj):
    return oj-1
def add_1(a, b):
    for i in range(0, len(b)):
        b[i] = a(b[i])
    return b
print(add_1(func_test, [1, 2, 3, 4]))
print(add_1(func_test2, [1, 2, 3, 4]))

reduce函数

功能
- 对一个序列进行压缩运算，得到一个value。
- python2中，reduce()是内置函数。py3中，已移植到functools模块中。
- from functools import reduce
格式
```
reduce(function,sequence[,initial])
```
- functione必须要传入两个参数
- sequence为可迭代序列
- initial为起始值，从第一次开始参与运算

from functools import reduce

y = [1, 2, 3, 4, 5, 6]
z = reduce(lambda x, y: x + y, y, 100)
print(z)
#输出
121    #100+1+2+3+4+5+6=121

from functools import reduce

y = [1, 2, 3, 4, 5, 6]
z = reduce(lambda x, y: 10 * x + y, y, 99)
print(z)
#输出
99123456

apply函数

功能

pandas 中，应用对象是pandas中的DataFrame或者Series
直接对DataFrame或者Series应用函数
对pandas中groupby之后的聚合对象应用apply

import numpy as np
import pandas as pd

a = np.random.randint(low=0, high=4, size=(4, 4))
print(a)
data = pd.DataFrame(a)
print(data)
data = data.apply(lambda x: x * 10)
print(data)
#输出
[[2 2 3 1]
 [2 0 1 0]
 [3 0 3 0]
 [3 3 3 0]]
   0  1  2  3
0  2  2  3  1
1  2  0  1  0
2  3  0  3  0
3  3  3  3  0
    0   1   2   3
0  20  20  30  10
1  20   0  10   0
2  30   0  30   0
3  30  30  30   0

zip函数

功能：

将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由这些元组构成的对象
长度不一样的时候，以长度短的为标准

注意：

利用*号操作符，与zip相反，进行解压。

格式：

zip(iterable1,iterable2,...)

iterable -->两个或者多个可迭代序列(字符串，列表，元组，字典)

#压缩
a = [1, 2, 3]
b = [4, 5, 6]
zip1 = zip(a, b)
print(list(zip1))
#输出
[(1, 4), (2, 5), (3, 6)]

#解压
a = [1, 2, 3]
b = [4, 5, 6]
zip1 = zip(a, b)

star_zip = zip(*zip1)
print(list(star_zip))
#输出
[(1, 2, 3), (4, 5, 6)]

沟通障碍的游戏废人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
函数

文章目录函数引子：函数的定义函数的调用函数的文档说明函数的参数函数返回值函数的参数种类位置参数默认值参数关键字参数不定参数递归函数匿名函数（lambda）高阶函数filter函数map 映射reduce函数apply函数zip函数函数引子：求1-16的和：求24-54的和：求36-100的和：程序而言：函数就是对程序逻辑进行结构化或者过程化的一种编程方法。built-in funct...
复制链接

扫一扫