Python3-基础- 函数_py3 q函数-CSDN博客

本文链接：https://blog.csdn.net/weixin_54021642/article/details/126982184

函数 -- 独立的代码块、具有特定的功能

1 内置函数

# 查看所有的内置函数
import builtins
print(dir(builtins))

2 常用函数

# 1 input() 以str形式从键盘接收内容
a = input('请输入：')
print(type(a))
print(a)

# 2 abs()  返回绝对值
print(abs(17))
print(abs(-17))

# 3 sum() 求和
print(sum([1, 2, 3]))

# 4 min()最小值  max()最大值
print(min([3, 1, 7]))
print(max([3, 1, 7]))

# 5 zip()  拉链函数  函数将可迭代对象作为参数，将里面对应的元素打包成一个个元组
# 元素个数不一致，按照长度最短的返回
a = [1, 2, 3]
b = ['a', 'b', 'c']
print(zip(a, b))  # <zip object at 0x000001624C495788>
print(list(zip(a, b)))  # 转换成列表打印  # [(1, 'a'), (2, 'b'), (3, 'c')]

# 6 map(函数, 对象) 映射函数 将可迭代对象中每一个元素来进行映射，分别执行函数
li = [1, 2, 3]
def funa(x):
    return x * 3
mp = map(funa, li)   # 每个元素分别执行funa函数
print(mp)
print(list(mp))      # [3, 6, 9]    # 得到一个新的list

# 7 enumerate()函数  一般用于for循环中
li = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表
for i in li:
    print('列表中的值：', i)
for n, i in enumerate(li):     # n是下标   i是列表遍历出的值
    print(f'这是下标值n：{n},这是i值的第一个元素:{i[0]},这是i值的第二个元素:{i[1]} ')

# 8 reduce(函数, 对象): 先把对象中的前两个元素取出，计算出一个值然后保存着, 接下来把这个值跟第三个元素进行计算
# 函数： 必须接收两个参数
# 对象： 可迭代对象
li2 = range(101)
from functools import reduce
def add(x, y):
    return x + y
res = reduce(add, li2)
print(res)
print(reduce(lambda a, b: a * b, [3, 6, 4]))

# 9 递归函数       一个函数在内部不调用其他的函数，而是调用它本身
# 1.必须有一个明确的结束条件
# 2.每进行更深一层的递归时,问题规模相比上次递归都要有所减少
# 3 相邻两次重复之间有紧密的联系
# 递归函数
# python中的递归深度是有限制, 默认为1000
# break是在循环中使用

# 举例：
# 斐波那契数列 这个数列从第三项开始, 每一项都等于前两项之和
def fib(n):  # n代表第几个数
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)
print(fib(6))
for i in range(1, 11):
    print(fib(i))

3 自定义函数

# 语法
#   def 函数名():
#       函数体

# 调用函数： 函数名()

# return
# 1.遇到return，return下面的代码不会执行
# 2.return返回值：
#     1 如果return后面什么都不写，返回的结果是None
#     2 如果有一个值,把值返回给调用者
#     3 如果有多个值,返回一个元组


def test():
    n = 10
    return n, 'jiuge', '198'
print(test())   # (10, 'jiuge', '198')


def test2():
    return 123
    # print(456)
print(test2())  # 123

4 函数参数--形参和实参

函数传参：就是函数将实参交给形参的过程

形参：写在定义函数的位置,这个变量叫形参

实参：写在函数调用的位置,这个值叫实参
def add(a, b):  # a和b是形参
    return a+b    # a=5,  b=6

print(add(5, 6))  # 5和6是实参
默认参数：设置默认值，当没有传值会根据默认值执行代码; 传了值就根据传入的值来执行代码
def test2(a=10):
    print(a)
test2(200)
test2()
可变参数：传入的值的数量是可以改变, 可以传入多个，也可以不传

*args：前面的*是有特殊意义的; args是一个普通的形参, 规定使用args，约定俗成;以- 元组-的形式接收

**kwargs:前面的**是有特殊意义的; kwargs是一个普通的形参, 规定使用kwargs，以-字典-的形式接收
def test(*args):
    print(args)    #('pyy', '123', 'hello')
    print(type(args))  # <class 'tuple'>

test('pyy','123', 'hello')


def test(**kwargs):
    print(kwargs)     #{'name': 'pyy', 'age': '18'}
    print(type(kwargs)) # <class 'dict'>
test(name = 'pyy', age = '18')

5 函数嵌套

嵌套调用：在函数A里面调用函数B

嵌套定义：在一个函数中定义另外一个函数
def eat():
    print('吃饱了')
def sleep():
    eat()            # 函数里调用eat()
    print('睡觉')
sleep()
def play():
    print('玩完了')
    def Home():      # 函数里定义Home()
        print('回家')
    Home()
play()

6 匿名函数

# 语法：
#   函数名 = lambda 形参: 返回值（表达式）
res = lambda a, b: a * b  # a,b就是匿名函数的参数,   a+b是返回值的表达式
print(res(5, 6))
# lambda 不需要写return来返回值,表达式本身结果就是返回值


# 为真结果 if 条件 else 为假结果   # if else左真右假
n1 = 5
n2 = 8
print(n1) if n1 < n2 else print(n2)
we = lambda x, y: 'True' if x > y else 'False'
print(we(1, 2))

7 拆包

tu = (1, 2, 3, 4)
a, b, c, d = tu
print(a, b, c, d)  # 1 2 3 4

a, *b = tu
print(a)  # 1 取到开头的值
print(b)  # [2, 3, 4]

*c, d = tu
print(c)   # [1, 2, 3]
print(d)   # 4   取到结尾的值