python函数

于 2024-07-03 21:04:05 发布
阅读量866 收藏 20
点赞数 25
分类专栏： python 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52606060/article/details/140108358
版权

概述

定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：

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

在这里插入图片描述

def 函数名（参数列表）:
    函数体

定义一个简单函数

def fn() :
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')

调用函数

fn()

在这里插入图片描述

函数传参

# 求任意三个数的乘积
def mul(a,b,c):
    print(a*b*c)
# 调用
mul(1,2,3)

在这里插入图片描述

# 根据不同的用户名显示不同的欢迎信息   
def welcome(username):
    print('欢迎',username,'光临')
# 调用
welcome('孙悟空')

在这里插入图片描述

为函数参数设置默认值

# 定义一个函数
# 定义形参时，可以为形参指定默认值
# 指定了默认值以后，如果用户传递了参数则默认值没有任何作用
#   如果用户没有传递，则默认值就会生效
def fn(a = 5 , b = 10 , c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)
# 调用
fn(1 , 2 , 3)
fn(1 , 2)
fn()

在这里插入图片描述

实参的传递方式

# 位置参数
# 位置参数就是将对应位置的实参复制给对应位置的形参
# 第一个实参赋值给第一个形参，第二个实参赋值给第二个形参 。。。
fn(1 , 2 , 3)

在这里插入图片描述

关键字参数

# 关键字参数，可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
fn(b=1 , c=2 , a=3)

在这里插入图片描述

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    # a = 20
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时
    #   会影响到所有指向该对象的变量
    a[0] = 30
    print('a =',a,id(a))

c = 10
c = [1,2,3] 
fn4(c)
fn4(c.copy())
fn4(c[:])

在这里插入图片描述

不定长的参数

# 定义一个函数，可以求任意个数字的和
def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    print(result)
# 调用函数
sum(123,456,789,10,20,30,40)
sum(123,456)

在这里插入图片描述

# 在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参
# 它将会将所有的实参保存到一个元组中
# a,b,*c = (1,2,3,4,5,6)
# *a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
def fn(*a):
    print("a =",a,type(a))
# 调用
fn(1,2,3,4,5)

在这里插入图片描述

带星号的形参只能有一个
带星号的参数，可以和其他参数配合使用

# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
def fn2(a, b, *c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


# 调用函数
fn2(2, 3, 4, 5, 6)

在这里插入图片描述

可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递

# 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数
def fn2(a, *b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


fn2(1, 2, 3, 4, c=2)


# 所有的位置参数都给a，b和c必须使用关键字参数
print("第一个参数有*")
def fn2(*a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)

fn2(1, 2, 3, b=2, c=1)


# 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递
print("形参的开头直接写一个*")
def fn2(*, a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


fn2(a=3,b=4,c=5)

print("**形参")
# **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
#   字典的key就是参数的名字，字典的value就是参数的值
# **形参只能有一个，并且必须写在所有参数的最后
def fn3(b, c, **a):
    print('a =', a, type(a))
    print('b =', b)
    print('c =', c)


fn3(b=1,d=2,c=3,e=10,f=20)

在这里插入图片描述

参数的解包（拆包）

def fn4(a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


# 创建一个元组
t = (10, 20, 30)

# 传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
# 这里要求序列中元素的个数必须和形参的个数的一致
fn4(*t)

# 创建一个字典
d = {'a': 100, 'b': 200, 'c': 300}
# 通过 **来对一个字典进行解包操作
fn4(**d)

在这里插入图片描述

返回值

返回值就是函数执行以后返回的结果
可以通过 return 来指定函数的返回值
可以之间使用函数的返回值，也可以通过一个变量来接收函数的返回值

def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums:
        result += n
    return result


print(sum(123, 456, 789))

在这里插入图片描述

return 后边跟什么值，函数就会返回什么值，return 后边可以跟任意的对象，返回值甚至可以是一个函数

def fn():
    # return 'Hello'
    # return [1,2,3]
    # return {'k':'v'}
    def fn2():
        print('hello')

    return fn2  # 返回值也可以是一个函数


r = fn()  # 这个函数的执行结果就是它的返回值


# r()
print(fn())
print(r)

在这里插入图片描述

如果仅仅写一个return 或者 不写return，则相当于return None

def fn2():
    a = 10
    return

print(fn2())

在这里插入图片描述

在函数中，return后的代码都不会执行，return 一旦执行函数自动结束

def fn3():
    print('hello')
    return
    print('abc')


r = fn3()
print(r)

在这里插入图片描述

def fn4():
    for i in range(5):
        if i == 3:
            # break 用来退出当前循环
            # continue 用来跳过当次循环
            return  # return 用来结束函数
        print(i)
    print('循环执行完毕！')


fn4()

在这里插入图片描述

fn5 和 fn5()的区别

def fn5():
    return 10

print(fn5)  # fn5是函数对象，打印fn5实际是在打印函数对象 <function fn5 at 0x05771BB8>
print(fn5())  # fn5()是在调用函数，打印fn5()实际上是在打印fn5()函数的返回值 10

在这里插入图片描述

文档字符串

# help()是Python中的内置函数
# 通过help()函数可以查询python中的函数的用法
# 语法：help(函数对象)
# help(print) # 获取print()函数的使用说明

# 文档字符串（doc str）


# 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
#   当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
#   文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
def fn(a: int, b: bool, c: str = 'hello') -> int:
    '''
    这是一个文档字符串的示例

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。
        b，作用，类型，默认值。。。。
        c，作用，类型，默认值。。。。
    '''
    return 10


help(fn)

在这里插入图片描述

作用域

作用域指的是变量生效的区域

def fn():
    a = 10 # a定义在了函数内部，所以他的作用域就是函数内部，函数外部无法访问
    print('函数内部：','a =',a)
    print('函数内部：','b =',b)

fn()

在这里插入图片描述

高阶函数

只要满足下面的任意一个条件就是高阶函数

1、一个函数的函数名作为参数传给另外一个函数
2、一个函数返回值（return）为另外一个函数（返回为自己，则为递归）

高阶函数：一个函数的函数名作为参数传给另外一个函数

def func():
    print("定义一个普通函数")


def high_level(func):
    print("定义一个高阶函数")
    # 在函数内部，通过传入的函数参数调用
    func()


high_level(func)

在这里插入图片描述

高阶函数：一个函数返回值（return）为另外一个函数

def func():
    print("定义一个普通函数")


def high_level(func):
    print("定义一个高阶函数")
    return func
    #  return func() 这个是直接返回函数调用，递归函数就是如此


res = high_level(func)
# 高阶函数返回函数之后在调用func函数
res()
# 结果

在这里插入图片描述

闭包

将函数作为返回值返回，也是一种高阶函数
这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
可以将一些私有的数据藏到的闭包中

def fn():

    a = 10

    # 函数内部再定义一个函数
    def inner():
        print('我是fn2' , a)

    # 将内部函数 inner作为返回值返回   
    return inner

# r是一个函数，是调用fn()后返回的函数
# 这个函数实在fn()内部定义，并不是全局函数
# 所以这个函数总是能访问到fn()函数内的变量
a=100
r = fn()    

r()

形成闭包的要件

① 函数嵌套
② 将内部函数作为返回值返回
③ 内部函数必须要使用到外部函数的变量

def make_averager():
    # 创建一个列表，用来保存数值
    nums = []

    # 创建一个函数，用来计算平均值
    def averager(n) :
        # 将n添加到列表中
        nums.append(n)
        # 求平均值
        return sum(nums)/len(nums)

    return averager

averager = make_averager()

print(averager(10))
print(averager(20))
print(averager(30))
print(averager(40))

在这里插入图片描述

装饰器

相当于高阶函数，根据现有的函数，来创建一个新的函数

希望函数可以在计算前，打印开始计算，计算结束后打印计算完毕
我们可以直接通过修改函数中的代码来完成这个需求，但是会产生以下一些问题
① 如果要修改的函数过多，修改起来会比较麻烦
② 并且不方便后期的维护
③ 并且这样做会违反开闭原则（OCP）
程序的设计，要求开发对程序的扩展，要关闭对程序的修改

def add(a , b):
    '''
        求任意两个数的和
    '''
    r = a + b
    return r

# 只需要根据现有的函数，来创建一个新的函数
def fn2(a, b):
    print('函数开始执行~~~')
    print(add(a, b))
    print('函数执行结束~~~')

在这里插入图片描述

def new_add(a, b):
    print('计算开始~~~')
    r = add(a, b)
    print('计算结束~~~')
    return r


r = new_add(111,222)
print(r)

在这里插入图片描述
上边的方式，已经可以在不修改源代码的情况下对函数进行扩展了
但是，这种方式要求我们每扩展一个函数就要手动创建一个新的函数，实在是太麻烦了
为了解决这个问题，我们创建一个函数，让这个函数可以自动的帮助我们生产函数

def add(a, b):
    '''
        求任意两个数的和
    '''
    r = a + b
    return r


def mul(a, b):
    '''
        求任意两个数的积
    '''
    r = a * b
    return r

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数,直接把要扩展的函数当参数传进来就行了
        result = old(*args, **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function


f2 = begin_end(add)
f3 = begin_end(mul)



s = f2(123,456)
r = f3(123,456)
print(r)
print(s)

在这里插入图片描述

装饰器的语法糖@

装饰器的语法使用 @decorator_name 来应用在函数或方法上来装饰当前的函数
可以同时为一个函数指定多个装饰器，这样函数将会安装从内向外的顺序被装饰

相当于把新函数作为参数传入@的函数里面。

def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function


# 相当于把 say_hello()函数作为参数传入fn3()函数

def say_hello():
    print('大家好~~~')


cms = fn3(say_hello)
cms()

在这里插入图片描述

def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function


# 相当于把 say_hello()函数作为参数传入fn3()函数
@fn3
def say_hello():
    print('大家好~~~')


say_hello()

在这里插入图片描述

语法糖是支持多层装饰的，写法上从下到上，函数嵌套从内到外对应

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数,直接把要扩展的函数当参数传进来就行了
        result = old(*args, **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function


def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function


# 相当于把 say_hello()函数作为参数传入fn3()函数
@fn3
@begin_end
def say_hello():
    print('大家好~~~')


say_hello()

在这里插入图片描述

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数,直接把要扩展的函数当参数传进来就行了
        result = old(*args, **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function


def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function


# 相当于把 say_hello()函数作为参数传入fn3()函数

@begin_end
@fn3
def say_hello():
    print('大家好~~~')


say_hello()

在这里插入图片描述

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数,直接把要扩展的函数当参数传进来就行了
        result = old(*args, **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function


def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''

    # 创建一个新函数
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function


# 相当于把 say_hello()函数作为参数传入fn3()函数

@begin_end
@fn3
@begin_end
def say_hello():
    print('大家好~~~')


say_hello()

在这里插入图片描述

python基础语法 - 函数
Cherish1ove的博客
07-20 1618
python函数相关笔记
Python_5_函数:函数简介（function）,函数的参数,函数式编程
qq_43265673的博客
09-08 488
第五章 函数 函数简介（function） - 函数也是一个对象 - 对象是内存中专门用来存储数据的一块区域 - 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用 - 创建函数： def 函数名([形参1,形参2,...形参n]) : 代码块 - 函数名必须要符号标识符的规范 （可以包含字母、数字、下划线、但是不能以数字开...
python 函数语法_python函数的基本语法
weixin_42486913的博客
12-29 148
函数：一次定义，多次调用，函数可以变相看成变量函数的阶段：1.定义阶段2调用阶段形参和实参:定义阶段的参数叫形参，调用阶段的参数叫实参函数的几种基本用法：#多变量def test(name,age):print("在下%s，今年%s，请问有何贵干！"%(name,age))a = test(‘赵日天‘,‘18‘)>>> 在下赵日天，今年18，请问有何贵干！def test(nam...
python函数基础语法
h2828的博客
04-19 719
函数声明：理解为将一段可以重复使用的代码通过关键字def 包裹起来 格式： def 函数名（参数列表）： """ # 函数说明文档, params：参数 return：结果 """ #实现特定功能的多行代码 return （返回值） 函数名（） 定义完函数后，函数是不会自动执行的，需要调用才可以。每次调用函数，函数都会从头开始执行，当这个函数中的代码执行到最后或遇到关键字return时，意味着调用结束。 def foo(): pr...
Python语法之函数
CMtotoe的博客
01-19 633
Python语法中函数语法的详细讲解
第六章Python函数习题及答案--中文
12-26
本章节主要讲解了 Python 函数的基本概念和应用，包括函数的定义、函数的调用、函数的参数、函数的返回值等。通过实践习题和答案，读者可以更好地理解 Python 函数的使用和应用。 6.1 节定义函数：默认返回值 在 ...
systemverilog-python:Systemverilog DPI-C调用Python函数
03-06
Systemverilog DPI-C调用Python函数 0.systemverilog_only python3 -m pip install scapy cd 0.systemverilog_only export PYTHONPATH=. make 日志 \rm -rf simv* csrc* *.log __pycache__ ucli.key vc_hdrs.h ...
python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数.txt
最新发布
05-08
python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数python 函数的动态参数
04-Python函数
02-19
Python函数思维导图，便捷整理思路，函数介绍、函数的定义与调用、函数参数、函数返回值、、局部变量和全局变量、递归函数、匿名函数
Python 函数.html
02-09
什么是函数？函数的定义和调用，函数的参数，默认参数、不定长参数、函数的返回值，函数的四种类型，包括，有参数，无返回值，有参数，有返回值
Web安全和渗透测试有什么关系？
Python_0011的博客
03-31 1723
做渗透测试的一个环节就是测试web安全，需要明白漏洞产生原理，通过信息收集互联网暴露面，进行漏洞扫描，漏洞利用，必要时进行脚本自编写和手工测试，力求挖出目标存在的漏洞并提出整改建议，当然如果技术再精一些，还要学习内网渗透（工作组和域环境），白盒审计，app，小程序渗透那些了......可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。当然除了有配套的视频，同时也为大家整理了各种文档和书籍资料&工具，并且已经帮大家分好类了。总之，web安全包含于渗透测试，但不是渗透测试的全部。
Python基础语法 - 函数
weixin_42194865的博客
09-28 392
Python基础语法 - 函数 函数就是对实现某一特定功能的代码的封装。 目的： 将多段代码分块； 实现一次编写代码，功能多次使用。 1. 函数的分类 函数就是实现某一特定功能的代码的封装。根据创造者对函数进行分类，分为两种：系统函数、自定义函数 系统函数：由Python创建好的函数。例如：print、input、type、max、min、id等 自定义函数：由程序员自己创建的函数 2. 定义函数 语法： def 函数名(形参列表): 函数说明文档 函数体 return 返回值
python
once924的博客
03-21 197
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括： 1. 有序集合：list，tuple，str和unicode； 2. 无序集合：set 3. 无序集合并且具有 key-value 对：dict请用for循环迭代数列 1-100 并打印出7的倍数。 用range(1, 101)可以创建数组。 参考代码: for i in range(1, 101):     if i % 7 == 0...
python之基本逻辑(函数)语句
Once_day的回忆
02-18 653
python基本逻辑(函数)语句 author：Once Day date:2022年2月18日 本文档在于总结相关内容，零散的知识难以记忆学习。 本文档基于windows平台。 全系列文档查看：python基础_CSDN博客。 文章目录python基本逻辑(函数)语句1.基本规则2. if `__name__ == '__main__'`3.条件判断3.1 if /elif/else3.2 match-case(python3.10)4.循环while、for5.中断操作break，continue
python之基本内置函数
Once_day的回忆
02-21 475
Python基础内置函数(builtins)详解 author：Once Day date:2022年2月19日 本文档在于总结相关内容，零散的知识难以记忆学习。 本文档基于windows平台。 全系列文档查看：python基础_CSDN博客。 文章目录Python基础内置函数(builtins)详解1.序言2.数学类函数2.1 abs() 绝对值2.2 bin() / oct() /hex() 十进制转换2/8/16进制2.3 bool() 类函数，判断bool值2.4.1 ord() 返回单字符字
python语法基础汇总
雷爷的博客
11-05 7686
python语法基础 文章目录python语法基础一、简介及运算符什么是计算机语言编译型语言和解释型语言Python的介绍Python开发环境搭建Python的交互界面Python和Sublime的整合几个概念基本语法字面量和变量变量和标识符数据类型类型检查对象（object）对象的结构变量和对象类型转换运算符(操作符)算术运算符赋值运算符关系运算符逻辑运算符条件运算符运算符的优先级二、条件判断及...
python基础梳理（十一）函数function②函数变量\函数名做实参\函数做返回值\函数嵌套\作用域\globals和locals
KingOfMyHeart的博客
03-29 1070
一、函数变量 函数名是变量，它在创建的时候绑定一个函数 python中的变量不分类型，每个变量记录对象的内存地址或id xxxx（）：函数调用 xxxx ：函数变量，绑定在函数对象，保存函数的入口地址 示例一： def fun(L = []): print("函数fun被调用") print(fun) fun([1,2,3]) fun = None 执行结果： <fu...
python 输出 ＜function z at 0x000002CDB971F1C0＞
weixin_44070217的博客
08-04 1182
python 输出
python中函数（function）总结一
weixin_44615267的博客
11-26 984
定义：函数是可以重复执行的语句块，可以重复的调用。 作用：用于封装语句块，提高代码的重用性，定义用户级别的函数。 一.定义函数语法 def 函数名（形参列表）：     语句块（代码块) 作用:用语句块创建一个函数，并用函数名变量绑定这个函数。 语法说明: 1)函数名是变量，它用于绑定语句块。 2)函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在...
python 函数
05-31
Python 函数是一段可重复使用的代码块，用于完成特定任务。函数可以接受输入参数并返回输出结果。 函数定义的一般形式如下： ```python def function_name(parameters): """函数文档字符串""" function_body ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值