python的函数最详解

目录
  • 一、函数入门
    • 1.概念
    • 2.定义函数的语法格式
      • 函数名
      • 形参列表
      • 返回值
    • 3.函数的文档(注释→help)
    • 4.举例
  • 二、函数的参数
    • 1.可变对象
    • 2.参数收集(不定个数的参数)
    • 3.解决一个实际问题
    • 4.参数收集(收集关键字参数)
    • 5.逆向参数收集(炸开参数)
    • 6.参数的内存管理
    • 7.函数中变量的作用域
    • 8.获取指定范围内的变量
  • 三、局部函数(函数的嵌套)
  • 四、函数的高级内容
    • 1.函数作为函数的形参
    • 2.使用函数作为返回值
    • 3.递归
  • 五、局部函数与lambda
    • 1.用lambda表达式代替局部函数
    • 2.常见数学方法的内部函数
  • 总结

一、函数入门

1.概念

  • 函数是可以重复执行一定任务的代码片段,具有独立的固定的输入输出接口。
  • 函数定义的本质,是给一段代码取个名字,方便以后重复使用
  • 为了方便以后调用这个函数,在定义它的时候,就需要明确它的输入(参数)与输出(返回值)

2.定义函数的语法格式

def 函数名(形参列表):
    #可执行语句
    return 返回值

函数名

  • 只要是合法的标识符即可(同变量命名)
  • 为了提高可读性,建议函数名由一个或多个有意义的单词组成,单词之间用下划线_分隔,字母全部小写

形参列表

  • 在函数名后面的括号内,多个形参用逗号分隔,可以没有参数
  • 参数可以有默认值,可以用等号=直接指定默认值,有默认值的参数必须排最后
  • 没有默认值的参数,在调用的时候必须指定
  • 形参也可以没有,但是括号不能省略
  • 调用有默认值的参数要指定名字

返回值

  • 返回值可以没有,直接省略return这句话
  • 返回值可以是一个或多个,用逗号分隔,组合成一个元组
  • 返回值还可以是表达式
  • 多个返回值,不需要的用下划线顶替!

3.函数的文档(注释→help)

  • 一段被注释的文字对函数进行解释。
  • 可以用help()查看函数的文档,只要把一段字符串紧接着放在函数的声明行的后面,它就可以被help识别了。

4.举例

# 函数定义
def myfunc(arg1, arg2, arg3=None):
    '''
    This is a example for python documentation.
    这是一个为python函数提供文档的例子。
    arg1: 第一个参数的说明
    arg2: 第二个参数的说明
    arg3: 第三个参数的说明(这个参数有默认值)
    v1, v2, v3: 返回值的说明
    '''
    v1 = arg1 + arg2
    v2 = arg1 * arg2
    if arg3 is None:
        v3 = arg1 + arg2
    else:
        v3 = arg1 + arg2 + arg3
    return v1, v2, v3
# 函数调用
v1, v2, v3 = myfunc(5, 3, arg3=4)
print(v1, v2, v3)    #8 15 12
# 使用arg3的默认值调用函数
v1, v2, v3 = myfunc(5, 3)
print(v1, v2, v3)    #8 15 8
# 忽略一个返回值
v1, v2, _ = myfunc(5, 3)
print(v1, v2, v3)    #8 15 8
# 看看返回值是元组tuple,在返回的过程中被自动解包
print(type(myfunc(5,3)))    #<class 'tuple'>

二、函数的参数

  • 函数的参数是参数与外部可变的输入之间交互的通道。
  • 函数的参数名称应该满足标识符命名规范,应该有明确的含义,可通过参数名称知道每个参数的含义。
  • 在函数定义下面的注释中逐个注明函数(和返回值)的含义,以便用户即使不甚了解函数中的具体内容也能正确无误的使用它。
  • 实参:实际参数,从外面传递来的实际的参数
  • 形参:形式参数,在函数内部它形式上的名字
  • 调用函数时,实参按照顺序位置与形参绑定,称为位置参数(Positional Argument)
  • 也可以在调用时,写明实参与形参的对应关系,称作传递关键字参数(Keyword Argument),这时候位置信息被忽略了
  • 同时传递位置参数与关键字参数,应该先传递位置参数,再传递关键字参数!
  • 函数定义的时候,可以指定默认值,但带默认值的参数必须列在参数列表的最后
#举一个小栗子,计算纸箱子的体积
def cube_volume(length, width, height = 0.25):
    '''
    计算纸箱子的体积(单位:m)
    length: 长;    width: 宽
    height: 高(默认参数0.25)
    v: 返回值,纸箱的体积,单位m**3
    '''
    if length <= 0:
        print('length must larger than 0!')
        return 0
    if width <= 0:
        print('width must larger than 0!')
        return 0
    if height <= 0:
        print('height must larger than 0!')
        return 0
    v = length*width*height
    print('length = %.2f; width = %.2f; height = %.2f; cube volume = %.2f' % \
          (length, width, height, v))
    return v
# 使用位置参数调用
v = cube_volume(1, 2, 3)
# 使用关键字参数调用
v = cube_volume(width = 1, height = 2, length = 3)
# 位置参数和关键字参数混用
v = cube_volume(1, height = 2, width = 3)
# 关键字参数在位置参数之前会报错
# v = cube_volume(width = 1, 2, 3)

1.可变对象

  • 如果参数是可变对象(如列表),函数内部对此对象的修改会在函数执行后仍然有效
  • 如果默认参数是可变对象,函数内部修改了此对象后,函数默认值也发生了改变!
  • 实际函数传递进去的是地址,函数体不会将地址传递出来,但地址对应的值发生了变化。
# 对列表的乘方运算
def pow_list(x, p):
    '''
    power of a list
    x: list
    p: power
    not return value
    '''
    for i in range(len(x)):
        x[i] **= p
    #这样会输出乘方后的值,但不会改变x列表里的值
    #因为在计算时将x中的值传入了新的参数进行计算
    #for i in x:
    #    i **= p
    #    print(i)
    #print(x)
x = [1,2,3,5,7,9,10,12]
pow_list(x,2)
print(x)
# 可见函数内部对列表x中元素的更改,当函数退出之后依然有效

利用可变对象的特点,可以制作一种隐藏的参数记录器

# 隐藏的参数记录器
def growing_list(x, y=[]):
    y.append(x)
    print(y)
# 重复执行growing_list(‘a')会发生什么结果?
growing_list(2)         #[2]
growing_list('张三')    #[2, '张三']
growing_list(22333)     #[2, '张三', 22333]

2.参数收集(不定个数的参数)

  • 参数收集,指定是可以往函数内传递不定个数的参数,例如有时候传递3个,有时候传递5个,有时候传递10个,等等。
  • 传递不定个数的参数,要在定义参数时,加上一个星号“*”(形参为空的tuple)。
  • 带星号的参数可以位于参数列表的任意位置(不一定是开头也不一定是结尾),python要求一个函数只能有一个带星参数。
# 不定个数的数字求和
def my_sum(*t):
    # 带星号的输入参数被当作元组处理
    print(t, type(t))
    sum = 0
    for s in t:
        sum += s
    return sum
# 事实上该函数接受了不定个数的输入参数
my_sum(1,2,3,4,2233)

如果带星参数后面还有别的参数,则它们必须要用关键字参数的方式传递,否则python不知道它们到底是啥,都会给收集到带星参数里。

# 不定个数的数字乘方后求和
def pow_sum(*t, p):
    # 带星号的输入参数被当作元组处理
    print(t, type(t))
    sum = 0
    for s in t:
        sum += s**p
    return sum
# 最后一个参数p,需要指定关键字传递
pow_sum(1,2,3,4,2233,p=2)
# 如果不指定关键字传递呢?会报错
# pow_sum(1,2,3,4,2233,2)

3.解决一个实际问题

# 不定个数的数字加权求和
# 权重随着数字的个数而发生变化
def weighted_sum(x1,x2,*y):
    sum = 0
    n = len(y)
    weight = 1/3/n
    for i in y:
        sum += weight*i
    return sum+1/3*x1+1/3*x2
weighted_sum(1,2,3)
weighted_sum(1,2,3,22,44,55)
weighted_sum(1,2,3,4,5,6)

4.参数收集(收集关键字参数)

  • python除了带一个型号的参数,还支持带两个星号的参数。它的功能是收集关键字参数。
  • 一个函数,至多可以带一个一星参数(收集位置参数),加上一个二星参数(收集关键字参数)。
  • 二星参数在函数内部以字典的形式存在。
  • 二星参数必须在参数列表的末尾,它后面不能再有别的关键字参数和位置参数了。
# 测试一星参数和两星参数
def test_star(a, b, c, *onestar, **twostar):
    print('a = %d; b = %d; c = %d' % (a, b, c))
    print(onestar, type(onestar))
    print(twostar, type(twostar))
test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9)
# 换个顺序呢?
# test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9, a = 10, b = 11, c = 12)
# 报错了,二星参数后面不能再传递关键字参数了(当然位置参数也不行)

“参数收集”功能,会让带星参数尽量少的收集,把更多参数留给正常的位置参数和关键字参数

# 如果有默认参数,要注意可能引起的bug
def test_star(a, b, c, p = 5, *onestar, **twostar):
    print('a = %d; b = %d; c = %d; p = %d' % (a, b, c, p))    #a = 1; b = 2; c = 3; p = 4
    print(onestar, type(onestar))            #(5, 6) <class 'tuple'>
    print(twostar, type(twostar))            #{'s1': 7, 's2': 8, 's3': 9} <class 'dict'>
# 会传递一个p=4进去,而不是设想的,onestar=(4,5,6)
test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9)

5.逆向参数收集(炸开参数)

  • 在参数外部定义好了的列表、元组、字典等,可以在传参的时候被“炸开”,其中的内容被自动分配到参数列表中
  • “炸”列表或者元组,需要在前面添加一个星号。
  • “炸”字典,需要在前面添加两个星号。
# 炸参数例子
def zha(a,b,c):
    print(a,b,c)
# 炸元组
z = (1,2,3)            #1 2 3
zha(*z)
# 炸列表
z = [4,5,6]            #4 5 6
zha(*z)
# 炸字典
z = {'a':7,'b':8,'c':9}    #7 8 9
zha(**z)
# 炸字典
z = {'c':7,'a':8,'b':9}    #8 9 7
zha(**z)
# 如果炸开后参数个数或Key不匹配,会报错
# z = {'c':7,'a':8}
# zha(**z)

6.参数的内存管理

  • python的参数传递,传递的是参数值而非参数地址。参数值被复制后传递进函数。
  • 对于数值类型的参数(整型、浮点、复数等),在函数内改变参数值,函数外面不受影响。
  • 对于容器类型的参数(列表、字典、字符串等),在函数内改变了容器里的内容,在函数的外面也可以体现出来。
# 传递数值类型参数
# 在函数内修改,在函数外面不受影响
def mod_para1(a,b):
    print('In mod_para1, before modification: a = %d; b = %d' % (a,b))    #a = 2; b = 8
    a *= 2
    b += 4
    print('In mod_para1, after modification: a = %d; b = %d' % (a,b))    #a = 4; b = 12
a = 2
b = 8
print('Out of mod_para1, before modification: a = %d; b = %d' % (a,b))    #a = 2; b = 8
mod_para1(a,b)
print('Out of mod_para1, after modification: a = %d; b = %d' % (a,b))    #a = 2; b = 8
  • 传递容器类型参数
  • 在函数内修改,在函数外面也能体现,也可以用这种方法向外界传递信息
  • 如果不希望容器类型中的内容被修改,请手动使用copy.copy() copy.deepcopy()方法
# 列表通过函数传参时,被改动了数据
def mod_para2(x):
    print('In mod_para2, before modification: x = ' + str(x))
    for i in range(len(x)):
        x[i] *= 2
    print('In mod_para2, after modification: x = ' + str(x))
x = [i for i in range(10)]
print('Out of mod_para2, before modification: x = ' + str(x))
mod_para2(x)
print('Out of mod_para2, after modification: x = ' + str(x))
import copy
A = [1,2,3]; B = copy.copy(A)
mod_para2(B); print(A,B)

7.函数中变量的作用域

  • 创建于函数外部,它是全局(Global)的,它在这个py文件内部的任何地方可见。
  • 创建于函数内部,它是局部(Local)的,它只能在函数内部才能访问,在函数外部不可见。
  • 全局变量和局部变量重名,函数内会访问到局部变量,函数外访问到全局变量。
  • 函数内部能访问全局变量,但不能修改!
  • 如果非要在函数内部修改全局变量,需要声明(不推荐这么干!)
gv1 = 1
def test():
    # gv1=2
    print('在函数内部访问全局变量:gv1 = %d' % gv1)    #1
    # gv1=2
test()
print('在函数外部访问全局变量:gv1 = %d' % gv1)    #1
  • ​​​​​​上面的例子,会在gv1 = 2的前一行,报错,看起来匪夷所思。
  • 事实上,这属于python对全局变量的“遮蔽”(hide)操作。在python的函数内部对不存在的变量赋值时,默认会重新定义局部变量。也就是说,在整个函数的内部,gv1都被重新定义了,这一操作会影响整个函数,因此会在它的上一行报错。
  • 为了访问被遮蔽的全局变量,需要使用globals()函数,将全局变量以字典的形式输出。(globals()['全局变量名'])——或者可以简单认为出全局变量通过globals()中的字典存储
  • 目前得知python3.10以后是不会报错了,但这种操作方法我们一般是不推荐的!
# 访问被遮蔽的全局变量
gv1 = 1
def test():
    # 用globals函数访问被遮蔽的全局变量
    print('在函数内部访问全局变量:gv1 = %d' % globals()['gv1'])
    gv1 = 2
    print('在函数内部访问修改后的全局变量:gv1 = %d' % gv1)
test()
print('在函数外部访问全局变量:gv1 = %d' % gv1) # 函数内部修改的其实是同名局部变量,全局变量没有被修改。
  • 正常的做法是,只要有定义全局变量,函数内部的局部变量就不应该和它重名!
  • 可以用global语句,在函数内部声明全局变量,经过声明的全局变量在函数内部可以访问和修改。
# 测试全局变量
gv1 = 1
def test():
    global gv1 #全局变量我来撑控
    print('在函数内部访问全局变量:gv1 = %d' % gv1)    #1
    gv1+=1
test()
print('在函数外部访问全局变量:gv1 = %d' % gv1)    #2

8.获取指定范围内的变量

  • python提供了多个方法可以让我们访问到每个变量的“名字”和他们持有的“值”
  • 变量在内存的某处保存着“名字”-“值”对儿
  • globals(): 返回全局范围内所有变量组成的字典, globals()[“名字”]
  • locals(): 返回当前函数范围内的所有变量组成的字典
  • vars(object): 获取指定对象范围内的所有变量组成的字典(如果不传入object参数,vars和locals的作用完全相同)
  • 如果在全局范围内(在函数外部)调用locals(),则它的行为和globals()一样,也会列出全局范围内所有变量
  • 一般来说,上述函数所列出的变量字典,都不应该被修改!但事实上它们可以被修改!!不推荐使用这种方式修改变量。

三、局部函数(函数的嵌套)

  • python可以在函数的内部定义函数,多个函数相互嵌套。在其它函数内部的函数称为“局部函数”。
  • 局部函数是对外隐藏的,只能封闭在定义它的那一个函数的内部使用。
  • python的函数也可以作为返回值,如果把局部函数作为返回值,就可以在其它函数中使用了。

一个栗子(利用局部函数实现多种平均值的切换)

# 利用局部函数实现多种平均值的切换
def mymean(x, mtype = 'arithmetic'):
    '''计算列表x的平均值,用mtype定义计算哪种平均值,默认为算术平均值(arithmetic mean)    '''
    def arithmetic(x):
        ''' 算术平均值(arithmetic mean)  '''
        m = sum(x)/len(x);    return m
    def geometric(x):
        '''几何平均值(geometric mean) '''
        p = 1.;  n = len(x)
        for i in range(n):      p *= x[i]
        m = p ** (1/n);       return m
    def harmonic(x):
        ''' 调和平均值(harmonic mean) '''
        s = 0.;      n = len(x)
        for i in range(n):        s += 1/x[i]
        m = 1/(s/n);        return m
    if mtype == 'arithmetic':    return arithmetic
    elif mtype == 'geometric':    return geometric
    elif mtype == 'harmonic':     return harmonic
    else:        return arithmetic
  • 类似于函数内局部变量遮蔽全局变量,局部函数内的变量也会遮蔽它所在函数的局部变量。
  • 因此使用局部函数时,同样要注意变量名的问题,不同层次的函数变量名应该不同。
  • 如果要访问上一层函数的局部变量,在局部函数中应该用nonlocal声明(类比于用global声明全局变量)。
# 局部函数内的变量与函数内的局部变量相冲突,这个程序会报错
def test1():
    fv = 1
    def test2():
        # print('局部函数内打印上层函数中的局部变量:%d' % fv) # 会在这里报错
        fv = 2
        print('局部函数内打印上层函数中的局部变量(更改后):%d' % fv)    #2
    test2()
    print('上层函数内打印局部变量(更改后):%d' % fv)    #1
    return fv
print('上层函数外打印局部变量(更改后):%d' % test1())    #1

用nolocal声明的方式可以使用/更改全局变量

# 局部函数内的变量与函数内的局部变量相冲突,应该改成这样就不报错了
def test1():
    fv = 1
    def test2():
        nonlocal fv # 用nonlocal声明,把fv声明为上一层函数的变量
        print('局部函数内打印上层函数中的局部变量:%d' % fv)    #1
        fv = 2
        print('局部函数内打印上层函数中的局部变量(更改后):%d' % fv)    #2
    test2()
    print('上层函数内打印局部变量(更改后):%d' % fv)    #2
    return fv
print('上层函数外打印局部变量(更改后):%d' % test1())    #2

四、函数的高级内容

  • python中万物皆对象,函数也是对象。函数可以赋值给变量,可以作为函数的参数,也可以作为函数的返回值。
  • python中以函数作为对象的用法,可以类比于c语言中的函数指针,但比函数指针灵活的多,也更不容易出错。
# 以第三章栗子中mymean函数为例
# 将函数赋值给变量f
f = mymean2('arithmetic')
# 打印出来看看
print(f)
# 测试一下
x = list(range(1,10))
m = f(x)
print(m)
# 也可以像上面的例子一样,连起来写
print(mymean2('geometric')(x))

1.函数作为函数的形参

  • 有时候需要定义一个函数,让它内部的大致流程都固定下来,但其中某些部件可以替换:类似于汽车换发动机,电脑换显卡。
  • 这种“可替换式”的程序设计方式,在python中可以方便的通过将函数作为形参的方式来实现。

2.使用函数作为返回值

  • 将一个函数对象(可以是局部函数,也可以是别的地方定义的函数)作为返回值,适合“部件替换式”程序设计中,判断使用哪个部件。
  • 具体实现方式参见第三章局部变量栗子中的代码
# 以第三章栗子中mymean函数为例
# 编写另一个程序,对列表中的数字进行变换,变成均值为1的另一个列表
# 均值,可以是算术平均值、几何平均值、调和平均值
def mynormalize(x, mtype):
    f = mymean(mtype)
    m = f(x)
    return [i/m for i in x]
x = list(range(1,10))
mtype = 'geometric'
print(mymean(mtype)(x))
print(mynormalize(x, mtype))

3.递归

  • 在一个函数里面调用它自己,称为递归。
  • 递归可以视作一种隐式的循环,不需要循环语句控制也可实现重复执行某段代码。
  • 递归在大型复杂程序中非常有用,在数值和非数值算法中都能大显身手!
  • 使用递归的时候要注意,当一个函数不断调用自己的时候,必须保证在某个时刻函数的返回值是确定的,即不再调用自己。
# 斐波那契数列(Fibonacci sequence)
# 在现代物理、准晶体结构、化学等领域,斐波纳契数列都有直接的应用
def Fibonacci(n):
    '''    Fibonacci sequence
    f(0)=1, f(1) = 1, f(n) = f(n-1)+f(n-2)    '''
    if n == 0 or n == 1:        return 1
    else:      return Fibonacci(n-1) + Fibonacci(n-2)
# 测试一下,注意n不要设的太大,python的递归效率是比较低的,太大会死机
print(Fibonacci(5))
# 斐波那契数列,前20位
print('Fibonacci sequence:')
for i in range(20):
    print('%d: %d' % (i,Fibonacci(i)))

五、局部函数与lambda

  • lambda表达式是现代编程语言引入的一种函数实现方式,它可以在一定程度上代替局部函数。
  • 对于局部函数,它的名字只在函数内部有意义,在函数外部看不到它的名字。即便使用返回值的形式传出来了,它的名字并没有被同时传出来。
  • 从命名的意义上讲,局部函数都是“隐姓埋名”的,出了这个函数就没人知道它的名字。
  • lambda表达式就相当于匿名函数。
# 一行中的hello world
greeting = lambda: print('Hello lambda!')
greeting()
# lambda表达式可以放在数组里面,批量运行
L = [lambda x: x**2, lambda x: x**3, lambda x: x**4]
for p in L:
    print(p(3))

1.用lambda表达式代替局部函数

# 用lambda表达式代替局部函数
def mymean2(mtype = 'arithmetic'):
    '''    返回计算平均值所用的函数,用mtype定义计算哪种平均值,默认为算术平均值(arithmetic mean)    '''
    # 由于lambda表达式只能写一行,这里用numpy和scipy的现成的函数来实现
    import numpy as np
    import scipy.stats as st
    a = np.array(x)
    if mtype == 'arithmetic': # 算术平均值(arithmetic mean)
        return lambda a: np.mean(a)
    elif mtype == 'geometric':# 几何平均值(geometric mean)
        return lambda a: st.gmean(a)
    elif mtype == 'harmonic': # 调和平均值(harmonic mean)
        return lambda a: st.hmean(a)
    else:        # 默认:算术平均值(arithmetic mean)
        return lambda a: np.mean(a)
x = list(range(1,10))
print(x)
print(mymean2('arithmetic')(x))
print(mymean2('geometric')(x))
print(mymean2('harmonic')(x))

2.常见数学方法的内部函数

# 判断所有元素是否为True,相当于多重的and
help(all)
print(all([3>2,6<9]))
# 任意一个元素是否为True,相当于多重的or
help(any)
print(any([3>2,6<9]))
# 最大值和最小值
help(max)
help(min)
print(max([1,2,5,3]))
print(min([1,2,5,3]))
# 四舍五入(到小数点后第n位)
help(round)
print(round(3.1415926,3))
# 所有元素相加
help(sum)
print(sum([1,2,3]))
print(sum([1,2,3],5))
# 乘幂
help(pow)
print(pow(6,2))
print(pow(6,2,5))
# 带余除法
help(divmod)
print(divmod(6,2))
# 绝对值
help(abs)
print(abs(-2.56))

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Python演化计算基准函数详解

    目录 基准函数定义 代码实现 调用方法 总结 基准函数是测试演化计算算法性能的函数集,由于大部分基准函数集都是C/C++编写,Python编写的基准函数比较少,因此本文实现了13个常用基准函数的Python版. 基准函数定义 代码实现 benchmark.py import numpy as np import copy """ Author : Robin_Hua update time : 2021.10.14 version : 1.0 ""&quo

  • python函数传参意义示例详解

    目录 C++这样的语言用多了之后,在Python函数传递参数的时候,经常会遇到一个问题,我要传递一个引用怎么办? 比如我们想要传一个x到函数中做个运算改变x的值: def change(y): y += 1 x = 1 print ("before change:", x) change(x) print ("after change: ", x) 得到的结果是 before change: 1 after change:  1 完全没用~~~这是怎么回事? 我来说

  • Python 类,对象,数据分类,函数参数传递详解

    目录 1.基本概念 1.1 类与对象的关系 1.3 对象的创建与引用 2.数据的分类 2.1 不可变类型 2.2 可变类型 3.函数传递参数的方式 3.1 值传递 3.2 引用传递 总结 最近在基于python写的接口自动化脚本,从Excel表中读取所有数据,每一行数据保存为字典,再将很多行的字典数据保存到一个列表里,运行时发现,列表中的字典均相同,且一直是excel最后一行的数据,情况类比如下: dd = {"a":1,"b":10} i = 2 list1 =

  • python中三种高阶函数(map,reduce,filter)详解

    map(function,seq[,seq2]) 接收至少两个参数,基本作用为将传入的函数依次作用到序列的每个元素,并且把结果作为新的序列 返回一个可迭代的map对象 function:函数对象 py2中可为None,作用等同于zip() 如: py3中不可为None,None是不可调用.不可迭代对象 seq:可迭代对象,可以传一个或多个 # 传一个: def func(i):return i*2 print([i for i in map(func,[1,'2'])]) # [2,'22']

  • Python 函数装饰器详解

    目录 使用场景 授权(Authorization) 日志(Logging) 带参数的装饰器 在函数中嵌入装饰器 装饰器类 总结 装饰器(Decorators)是 Python 的一个重要部分.简单地说:他们是修改其他函数的功能的函数.他们有助于让我们的代码更简短,也更Pythonic(Python范儿).大多数初学者不知道在哪儿使用它们,所以我将要分享下,哪些区域里装饰器可以让你的代码更简洁.首先,让我们讨论下如何写你自己的装饰器. 这可能是最难掌握的概念之一.我们会每次只讨论一个步骤,这样你能

  • Python常用正则函数使用方法详解

    今天给大家介绍一下Python中常用的正则表达式处理函数.Python的正则表达式主要有两种方法完成模式匹配:『搜索』和『匹配』   re.match re.match 尝试从字符串的开始全部或者部分匹配某个模式,如:下面的例子匹配第一个单词.  import re text = "PythonTab.com is a good Python website" m = re.match(r"(\w+)\s", text) if m: print m.group(0)

  • Python函数属性和PyC详解

    目录 函数属性 自定义属性 查看函数对象属性 属性和字节码对象PyCodeObject 总结 函数属性 python中的函数是一种对象,它有属于对象的属性.除此之外,函数还可以自定义自己的属性.注意,属性是和对象相关的,和作用域无关. 自定义属性 自定义函数自己的属性方式很简单.假设函数名称为myfunc,那么为这个函数添加一个属性var1: myfunc.var1="abc" 那么这个属性var1就像是全局变量一样被访问.修改.但它并不是全局变量. 可以跨模块自定义函数的属性.例如,

  • python groupby 函数 as_index详解

    在官方网站中对as_index有以下介绍: as_index : boolean, default True For aggregated output, return object with group labels as the index. Only relevant for DataFrame input. as_index=False is effectively "SQL-style" grouped output 翻译过来就是说as_index 的默认值为True, 对于

  • python isinstance函数用法详解

    这篇文章主要介绍了python isinstance函数用法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 isinstance() 函数来判断一个对象是否是一个已知的类型类似 type(). isinstance() 与 type() 区别: type() 不会认为子类是一种父类类型,不考虑继承关系. isinstance() 会认为子类是一种父类类型,考虑继承关系. 如果要判断两个类型是否相同推荐使用 isinstance(). 语法

  • Python ord函数()案例详解

    python中ord函数 Python ord()函数 (Python ord() function) ord() function is a library function in Python, it is used to get number value from given character value, it accepts a character and returns an integer i.e. it is used to convert a character to an

  • Python的函数使用详解

    目录 前言 1 跳出循环-break 2 python函数 2.1 内置函数 2.2 自定义函数 2.3 main函数 前言 在两种python循环语句的使用中,不仅仅是循环条件达到才能跳出循环体.所以,在对python函数进行阐述之前,先对跳出循环的简单语句块进行介绍. 1 跳出循环-break python提供了一种方便快捷的跳出循环的方法-break,示例如下,计算未知数字个数的总和: if __name__ == "__main__": sum = 0 while True:

  • Python groupby函数图文详解

    一.分组原理 核心: 1.不论分组键是数组.列表.字典.Series.函数,只要其与待分组变量的轴长度一致都可以传入groupby进行分组. 2.默认axis=0按行分组,可指定axis=1对列分组. groupby()语法格式 DataFrame.groupby(by=None, axis=0, level=None, as_index=True, group_keys=True, squeeze=False, observed=False, **kwargs) groupby原理 group

  • python的函数最详解

    目录 一.函数入门 1.概念 2.定义函数的语法格式 函数名 形参列表 返回值 3.函数的文档(注释→help) 4.举例 二.函数的参数 1.可变对象 2.参数收集(不定个数的参数) 3.解决一个实际问题 4.参数收集(收集关键字参数) 5.逆向参数收集(炸开参数) 6.参数的内存管理 7.函数中变量的作用域 8.获取指定范围内的变量 三.局部函数(函数的嵌套) 四.函数的高级内容 1.函数作为函数的形参 2.使用函数作为返回值 3.递归 五.局部函数与lambda 1.用lambda表达式代

  • 如何利用Python拟合函数曲线详解

    目录 拟合多项式 函数说明 拟合任意函数 函数说明 总结 使用Python拟合函数曲线需要用到一些第三方库: numpy:科学计算的基础库(例如:矩阵) matplotlib:绘图库 scipy:科学计算库 如果没有安装过这些库,需要在命令行中输入下列代码进行安装: pip install numpy matplotlib scipy 拟合多项式 ''' Author: CloudSir Date: 2021-08-01 13:40:50 LastEditTime: 2021-08-02 09:

  • Python help()函数用法详解

    help函数是python的一个内置函数(python的内置函数可以直接调用,无需import),它是python自带的函数,任何时候都可以被使用.help函数能作什么.怎么使用help函数查看python模块中函数的用法,和使用help函数时需要注意哪些问题,下面来简单的说一下. 一.help()函数的作用在使用python来编写代码时,会经常使用python自带函数或模块,一些不常用的函数或是模块的用途不是很清楚,这时候就需要用到help函数来查看帮助.这里要注意下,help()函数是查看函

  • python reduce 函数使用详解

    reduce() 函数在 python 2 是内置函数, 从python 3 开始移到了 functools 模块. 官方文档是这样介绍的 reduce(...) reduce(function, sequence[, initial]) -> value Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequen

  • python super()函数的详解

    目录 super的用法 super的原理 总结 Python是一门面向对象的语言,定义类时经常要用到继承,在类的继承中,子类继承父类中已经封装好的方法,不需要再次编写,如果子类如果重新定义了父类的某一方法,那么该方法就会覆盖父类的同名方法,但是有时我们希望子类保持父类方法的基础上进行扩展,而不是直接覆盖,就需要先调用父类的方法,然后再进行功能的扩展,这时就可以通过super来实现对父类方法的调用. super的用法 看下面一个例子: class A: def func(self): print(

随机推荐