标签：lemon 函数 Python 基础知识 关键字 参数 str print

一、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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。