编程语言
首页 > 编程语言> > Python基础知识(函数)

Python基础知识(函数)

作者:互联网

一、Python中函数的定义

  函数的定义:是指将一组可重复使用的、用来实现某一关联功能的语句(代码段)通过一个名字(函数名)封装起来,在想要执行这个函数时,只需要通过“函数名”直接调用即可。函数的特点:功能强大、调用方便及灵活高效。

二、Python中函数的语法

  1.关键字:“ def ” 是关键字。是用来识别是否为一个函数,不可缺少。

  2.函数名:“square” 是函数名。可自定义,不要使用“关键字”或“内建函数”同名。

  3.参数:“x,y” 是参数(形参),“12,20”是参数(实参)。形参不是必须的,可以不填,但是()不能省略。

  4.方法:“s = x*y” 是函数方法。组织好的函数语句,默认缩进1个tab键(等同4个空格)。

  5.返回值:“return” 是返回值。return后面可以没有返回值,甚至return语句也可省略,默认返回值为None。

# 1)函数的语法:
def square(x,y):      # 声明一个函数(方法)

    s = x * y         # 函数语句(方法)
    print(s)                                     # 注意:输出语句放在函数里面!
# 没有return square(12,20) # 调用函数(方法) >>240
# 2)函数的语法:
def square(x,y): # 声明一个函数(方法) s = x * y # 函数语句(方法) # 函数内部无输出语句。 return s # 返回变量 b = square(12,20) # 调用函数(方法),并通过变量 "b" 去接收返回值 "s" print(b) # 输出语句放在外面,打印的值是接收变量的值。 >>240 

三、参数类型解析

  Python函数中的参数:实参(1种)【关键字参数】+形参(4种)【必须参数;可变参数;默认值参数;可变关键字参数】。

  1.关键字参数:"param1" ,在实参中定义。将实参的赋值指定给予某形参,可以不用记住传参的顺序。

  2.必须参数:"param2" ,在形参中定义。对应于形参,有多少个形参就给出多少实参。在实参中传"param1",函数在调用时,可将它用于函数方法的运算。

  3.可变参数:"*args" ,在形参中定义。形参中直接传"*args",函数在调用时,实参可以传递任意个参数。

  4.默认值参数:"param3" , 在形参中定义。给函数的形参赋予默认值。

  5.可变关键字参数:"**kwargs" ,在形参中定义。形参中传"**kwargs",函数在调用时,实参可以传递任意个关键字参数。

# 示例语法展示:
def square(param2,*args,param3=0,**kwargs): pass return # square(param2,param1=8)
# 1)关键字函数(在实参中定义)
def fruit(apple,lemon):
    print("苹果的数量为:"+ str(apple))
    print("柠檬的数量为:" + str(lemon))
fruit(2,lemon=12)   #lemon=12“关键字参数”可以不用记住参数的顺序


>>苹果的数量为:2
>>柠檬的数量为:12
# 2)必须参数:
# 不建议定义过多必须函数;如需要,可将多个必须参数封装成一个对象,把对象传入到函数中。
# 需求:创建一个函数,录入苹果、柠檬两种水果数量,并打印详情

def detail(apple, lemon):
    print("苹果的数量为:" + str(apple))
    print("柠檬的数量为:" + str(lemon))

detail(4, 5)


# >>苹果的数量为:4
# >>柠檬的数量为:5
# 3)可变参数:
# 需求:创建一个函数,用户可传入任意值,并返回任意值相加后的值
def add_all(*args):
    summ = 0
    for i in args:
        summ = summ + i
        print(summ)
    return summ


# add_all(1, 2, 3, 4)        # 可传入任意个参数

a = (1, 2, 3, 4)             # 如果传入的是一个序列,可使用*将每个元素平埔出来,传递到可变参数的函数里面。
add_all(*a)


>>1
>>3
>>6
>>10
# 4)默认值参数:
def fruit(apple=1, lemon=2):  # 在形参中定义,设置默认值。
    print("苹果的数量为:" + str(apple))
    print("柠檬的数量为:" + str(lemon))

fruit()
# fruit(lemon=5)  # 可使用关键字参数对默认值参数赋值,改变默认值参数的定义


>>苹果的数量为:1
>>柠檬的数量为:2
# 5)可变关键字参数 :
def fruit(**kwargs):
    print("水果的数量为:" + str(kwargs))
    # print(type(kwargs))         # kwargs的类型为字典


# fruit(lemon=5, apple=10)         # 可传递任意个关键字参数,这些关键字参数在函数调用的时候会自动组装成一个dict。

fruits = {"lemon": 5, "apple": 10}
fruit(**fruits)                        # 如果传的是一个字典,用 "**" 将字典中的键值对平铺出来。


>>水果的数量为:{'lemon': 5, 'apple': 10}
# 补充内容:函数中形参的传参顺序【1.必须参数-2.可变参数-3.默认值参数-4.可变关键字参数】
def fruit(apple_num,*args,banana_num=5,lemon_num=4,**kwargs):
    print("苹果的数量为:"+ str(apple_num))
    print("柠檬的数量为:" + str(lemon_num))
    print("香蕉的数量为:" + str(banana_num))
    print("数量为:" + str(args))
    print("水果的数量为:" + str(kwargs))
numm=(3,5,4)
fruits={"苹果":3,"柠檬":4,"香蕉":5}      
fruit(10,*numm,**fruits)


>>苹果的数量为:10
>>柠檬的数量为:4
>>香蕉的数量为:5
>>数量为:(3, 5, 4)
>>水果的数量为:{'苹果': 3, '柠檬': 4, '香蕉': 5}

四、内建函数

  Python自带的函数【print()、len()、help()等】,也就是说这是python的类库帮我们已经写好的函数,只需要我们直接使用就可以了。

# 内建函数-del 的用法:
a = [1, 2, 3]    # 对象[1, 2, 3]被 a 引用
b = a            # 对象 a 被 b 引用
c = b            # 对象 b 被 c 引用

print(a)

del a  # 删除变量a,解除a对[1, 2, 3]的引用
del b  # 删除变量b,解除b对[1, 2, 3]的引用

# print(a)
# print(b)         # 会报错,NameError: name 'b' is not defined
print(c)          # 最终变量c仍然引用1


>>[1, 2, 3]
>>[1, 2, 3]
# 内建函数-3个常见输出函数【print()、eval()、input()】

print("你是谁!")

a = eval("20+20")   # eval()函数去掉字符串最外侧的引号,并按照python语句方式执行去掉引号后的字符串内容。
print(a)

input("我在哪?")  # 阻塞式输出。


>>你是谁!
>>40
>>我在哪?_

五、匿名函数

  匿名函数:就是没有名字的函数。Python中使用 lambda 来创建匿名函数。lambda 函数的语法只包含一个语句【 lambda [arg1 [,arg2,...argn]] : expression 】。

sum = lambda arg1, arg2: arg1 + arg2

demo = sum(20, 40)

# print("相加后的值是:", sum(10, 20))
print("相加后的值是:", demo)


>>相加后的值是: 30
>>相加后的值是: 60

六、自定义函数

  用户自己创建的函数被叫做自定义函数。

def summ(x, y, z):
    s = x + y + z
    print(s)
    return s

summ(3, 4, 5)


>>12

七、递归函数

# 定义:在函数内部可以调用其他函数,如果调用的是本身,这个函数就是递归函数
# 特性:
# 1、必须要有明确的结束条件
# 2、每次更深一层递归时,问题模块相比上一次递归减少
# 3、递归效率不高,递归层次过多会导致栈溢出

def calc(n):
    print(n)
    if int(n/2) >0:
        return calc(int(n/2))
    print('...',n)
calc(10)


>>10
>>5
>>2
>>1
>>... 1

 八、函数的过滤、映射与聚合

#函数的数据处理:过滤、映射与聚合
#三个基础函数:filter()、map()和reduce()
# 语法:filter(function,iterable) function是一个函数,参数iterable是可迭代对象;
#filter()函数调用时iterable会被遍历,它的元素被逐一传入function函数,function函数返回布尔值。
#在function函数中编写过滤条件,如果为True的元素被保留,如果为False的元素被过滤掉。
# 示例1:
# users=["Tony","Tom","Ben","Alex"]
# users_filter=filter(lambda u:u.startswith("T"),users)   #如果字符串以指定的值开头,则 startswith() 方法返回 True,否则返回 False。
# print(users_filter)
# print(list(users_filter))

# 语法:map(function,iterable) function是一个函数,参数iterable是可迭代对象;
#示例2:
# users=["Tony","Tom","Ben","Alex"]
# users_map=map(lambda u:u.lower(),users)
# print(list(users_map))

#聚合操作会将多个数据聚合起来输出单个数据,聚合操作中最基础的是归纳函数reduce(),
#reduce()函数会将多个数据按照指定的算法积累叠加起来,最后输出一个数据。
# 语法:reduce(function,iterable[,initializer]) function是一个函数,参数iterable是可迭代对象,参数initializer是初始值;
#示例2:(实现对一个数列的求和运算)
from functools import reduce
a=(1,2,3,4)
a_reduce=reduce(lambda  acc,i:acc+i,a)
print(a_reduce)

标签:lemon,函数,Python,基础知识,关键字,参数,str,print
来源: https://www.cnblogs.com/lovezhuzhu1314/p/15044907.html