精华内容
下载资源
问答
  • 实现跨文件函数调用,效果 at say:SB hello world 1617517009.549776(时间戳) 执行方法 执行name
  • 主要介绍了python 动态调用函数实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python调用C函数实例

    2018-03-08 17:52:10
    Python C/C++混编 Python 调用C函数 传递参数为:值传递,指针传递,数组
  • 主要介绍了python调用函数、类和文件操作,结合简单实例形式总结分析了Python调用函数、类和文件操作的各种常见操作技巧,需要的朋友可以参考下
  • 递归,就是在函数运行中自己调用自己代码示例:def recursion(n): # 定义递归函数print(n) # 打印nrecursion(n+1) # 在函数的运行种调用递归recursion(1) # 调用函数这个函数在不断的自己调用自己,每次调用n+1,看下...

    python递归函数

    什么是递归?

    递归,就是在函数运行中自己调用自己

    代码示例:

    def recursion(n): # 定义递归函数

    print(n) # 打印n

    recursion(n+1) # 在函数的运行种调用递归

    recursion(1) # 调用函数

    这个函数在不断的自己调用自己,每次调用n+1,看下运行结果:

    1

    2

    .....

    998Traceback (most recent call last):

    File "D:/py_study/day08-函数/python递归函数md/01-什么是递归.py", line 11, in

    recursion(1)

    File "D:/py_study/day08-函数/python递归函数md/01-什么是递归.py", line 9, in recursion

    recursion(n+1)

    File "D:/py_study/day08-函数/python递归函数md/01-什么是递归.py", line 9, in recursion

    recursion(n+1)

    File "D:/py_study/day08-函数/python递归函数md/01-什么是递归.py", line 9, in recursion

    recursion(n+1)

    [Previous line repeated 993 more times]

    File "D:/py_study/day08-函数/python递归函数md/01-什么是递归.py", line 8, in recursion

    print(n)

    RecursionError: maximum recursion depth exceeded while calling a Python object

    Process finished with exit code 1

    可为什么执行了900多次就报错了呢?还说超过了最大递归深度限制,为什么要限制呢?

    通俗来讲,是因为每个函数在调用自己的时候,还没有退出,占内存,多了肯定会导致内存崩溃.

    本质上来将,在计算机中,函数调用是通过栈(stack)这样数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会少一层栈帧.由于栈的大小不是无限的,所以,递归调用次数多了,会导致栈溢出.

    我们还可以修改递归深度,代码如下:

    import sys

    sys.setrecursionlimit(1500) # 修改递归调用深度

    def cacl(n):

    print(n)

    cacl(n+1)

    cacl(1)

    运行结果如下:

    1

    2

    ......

    1498Traceback (most recent call last):

    File "D:/py_study/day08-函数/python递归函数md/02-修改递归深度.py", line 11, in cacl

    cacl(n+1)

    File "D:/py_study/day08-函数/python递归函数md/02-修改递归深度.py", line 11, in cacl

    cacl(n+1)

    File "D:/py_study/day08-函数/python递归函数md/02-修改递归深度.py", line 11, in cacl

    cacl(n+1)

    [Previous line repeated 995 more times]

    File "D:/py_study/day08-函数/python递归函数md/02-修改递归深度.py", line 10, in cacl

    print(n)

    RecursionError: maximum recursion depth exceeded while calling a Python object

    让我们以最经典的例子说明递归

    # 计算n! # 相信很多人都学过阶乘,比如5! = 5*4*3*2*1 n! = n*(n-1)*(n-2)*...*1,那么在递归中该如何实现呢?

    # 1.打好函数的框架

    def factorial(n): # 定义一个计算阶乘的函数

    pass # 不做任何操作

    factorial(3) # 调用

    # 2.考虑两种情况,如果n=1,那么1的阶乘就是1了,如果这个传递的参数大于1,那么就需要计算继承了.

    def factorial(n):

    if n == 1: # 判断如果传递的参数是1的情况

    return 1 # 返回1,return代表程序的终止

    res = factorial(1) # res变量来接受函数的返回值

    print(res) # 打印

    2.1如果传递的参数不是1,怎么做?

    def factorial(n):

    if n == 1:

    return 1

    else:

    # 5*4! = 5*4*3! = 5*4*3*2!

    return n * factorial(n-1) # 传递的参数是n,那么再次调用factorial(n-1)

    res = factorial(1)

    print(res)

    举例2:

    # 让10不断除以2,直到0为止。

    int(10/2) = 5

    int(5/2) = 2

    int(2/2) = 1

    int(1/2) = 0

    # 1.同样第一步先打框架

    def cacl(n): # 定义函数

    pass

    cacl(10)

    # 2.那么我们想从10开始打印然后一直到0,怎么做?

    def cacl(n): # 定义函数

    print(n)

    cacl(10)

    # 3.已经把打印的值传递进去了,那么就是在里面操作了

    def cacl(n): # 定义函数

    print(n) # 打印传递进去的值

    v = int(n /2) # n/2

    if v>0: # 如果v还大于0

    cacl(v) # 递归,把v传递进去

    print(n) # 打印v,因为已经调用递归了,所以此时的n是v

    cacl(10)

    运行结果如下:

    10

    5

    2

    1

    1

    2

    5

    10

    怎么输出会是这样呢?我刚刚说过,什么是递归?递归就是在一个函数的内部调用函数本身,我们打个比方,递归一共有3层,那么第二层就是调用第一层的结果,第三层又去调用第二层的结果,所以!当上面这个程序运行时,第一次打印的是10,然后除上2,等于是5,再继续除,一直到了1,然后1/2是等于0的,此时就没有调用了递归,但是我还在调用上一层函数,就需要把这个数给返回出来,所以就变成后来的1,2,5,10了。

    递归特性

    1.必须要有一个明确的结束条件, 否则就变成死循环导致栈溢出

    2.每次进入更深一层递归时,问题规模相比上次递归都应有所减少,这句话的以上就是说,每进入一次递归,就会解决一些东西,数据量就会越来越小,最终解决了所有的问题,如果进入一次递归没有解决问题,那么不管递归多少层都没有意义,直到导致栈溢出。

    3.递归效率比较低,递归层次过多会导致栈溢出,意思是:每当进入一次函数调用,栈就会加一层栈帧,每当函数返回,就减少一层栈帧,由于栈不是无限大小的,所以,递归调用的次数过多,会导致栈溢出。

    那么有没有优化方式呢?肯定是有的

    尾递归

    我在知乎上找了一个特别有意思的例子来说明下什么是尾递归:

    def story() {

    从前有座山,

    山上有座庙,

    庙里有个老和尚,

    一天老和尚对小和尚讲故事:story() // 尾递归,进入下一个函数不再需要上一个函数的环境了,得出结果以后直接返回。

    }

    def story() {

    从前有座山,

    山上有座庙,

    庙里有个老和尚,

    一天老和尚对小和尚讲故事:story(),小和尚听了,找了块豆腐撞死了 // 非尾递归,下一个函数结束以后此函数还有后续,所以必须保存本身的环境以供处理返回值。

    }

    尾递归,进入下一个函数不再需要上一个函数的环境了,得出结果以后直接返回。

    def cal(n):

    print(n)

    return cal(n+1) # return代表函数的结束

    cal(1) # 这个会一直打印,直到导致栈溢出

    # 调用下一层的同时,自己就退出了

    展开全文
  • 在本文里我们给大家整理了关于python调用自定义函数实例操作相关内容,有此需要的朋友们可以学习参考下。
  • 下面小编就为大家带来一篇python 调用c语言函数实例讲解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1.在一个函数体内调用它自身,被称为函数递归。函数递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。例1.己知有一个数列:f(0) = 1,f(1) = 4,f(n + 2) = 2*f(n+ 1) +f(n),其中 n ...

    1.在一个函数体内调用它自身,被称为函数递归。函数递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。

    例1.己知有一个数列:f(0) = 1,f(1) = 4,f(n + 2) = 2*f(n+ 1) +f(n),其中 n 是大于 0 的整数,求 f(10) 的值?

    分析:

    f(10)=2*f(9)+f(8);f(9)=2*f(8)+f(7);f(8)=2*f(7)+f(6);f(7)=2*f(6)+f(5);f(6)=2*f(5)+f(4);f(5)=2*f(4)+f(3);f(4)=2*f(3)+f(2);f(3)=2*f(2)+f(1)==>f(1),f(2)已知,所以可以推出f(9),f(8)的值。所以我们的目的就是通过递归函数反复调用自身,直到将欲求函数的表达式用已知变量f(1),f(2)代替。

    deffun(n):if n==0:return 1

    elif n==1:return 4

    else:return 2*fun(n-1)+fun(n-2)print(fun(10))

    例2.如果把上面数学题改为如此。己知有一个数列:f(20)=1,f(21)=4,f(n + 2)=2*f(n+1)+f(n),其中 n 是大于 0 的整数,求 f(10) 的值?

    分析:

    fn(10) = fn(12)-2*fn(11),而 fn(11) =fn(13)-2*fn(12)……依此类推通过函数递归,直到 fn(19) 等于 fn(21)-2*fn(20),此时就可以得到 fn(19) 的值,然后依次反算到 fn(10) 的值

    deffn(n) :if n == 20:return 1

    elif n == 21:return 4

    else:return fn(n + 2) - 2*fn(n + 1)print(fn(10))

    运行结果:

    10497

    -3771

    tips:仔细看上面递归的过程,当一个函数不断地调用它自身时,必须在某个时刻函数的返回值是确定的,即不再调用它自身:否则,这种递归就变成了无穷递归,类似于死循环。

    因此,在定义递归函数时有一条最重要的规定: 递归一定要向已知方向进行。(对于求 fn(10) 而言,如果 fn(0) 和 fn(1) 是已知的,则应该采用 fn(n)=2*fn(n-1)+fn(n-2) 的形式递归,因为小的一端已知;如果 fn(20) 和 fn(21) 是已知的,则应该采用 fn(n)=fn(n+2)-2*fn(n+1) 的形式递归,因为大的一端已知。)

    例3.用循环和递归分别求 ∑100 (求1到100的和)

    #循环

    defsum1(n):

    sum=0for i in range(1,n+1):

    sum+=ireturnsumprint("循环累加:",sum1(100))#递归

    defsum2(n):while n==0:return0while n!=0:return n+sum2(n-1)print("递归累加1:",sum2(100))defsum3(n):if n==1:return 1

    else:return n+sum3(n-1)print("循环累加2:",sum3(100))

    运行结果:

    循环累加: 5050递归累加1:5050循环累加2:5050

    例4.用循环和递归分别求 10!(阶乘)

    #循环

    defjiecheng1(n):

    res= 1

    for i in range(1,n+1):

    res*=ireturnresprint("循环阶乘:",jiecheng1(10))#递归

    defjiecheng2(n):while n==1:return 1

    while n!=1:return n*jiecheng2(n-1)print("递归阶乘1:",jiecheng2(10))defjiecheng3(n):if n==1:return 1

    else:return n*jiecheng3(n-1)print("递归阶乘2:",jiecheng3(10))

    运行结果:

    循环阶乘: 3628800递归阶乘1:3628800递归阶乘2:3628800

    展开全文
  • 主要介绍了python通过apply使用元祖和列表调用函数,实例分析了python中apply方法的使用技巧,需要的朋友可以参考下
  • 今天和大家分享一下Python限制函数调用次数的实例,对Python感兴趣的小伙伴就随着小编一起来了解一下吧。 Python限制函数调用次数的实例 #newtest.py #!/usr/bin/env python #-*- coding:utf-8 -*- import ...

    今天和大家分享一下Python限制函数调用次数的实例,对Python感兴趣的小伙伴就随着小编一起来了解一下吧。

    Python限制函数调用次数实例,赶紧收藏吧

    Python限制函数调用次数的实例

    #newtest.py

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    import time

    def stat_called_time(func):

    cache={}

    limit_times=[10]

    Python限制函数调用次数实例,赶紧收藏吧

    def _called_time(*args,**kwargs):

    key=func.__name__

    if key in cache.keys():

    [call_times,updatetime]=cache[key]

    if time.time()-updatetime <60:

    cache[key][0]+=1

    else:

    print("超过调用次数了")

    return None

    return _called_time

    @stat_called_tim

    else:

    cache[key]=[1,time.time()]

    else:

    call_times=1

    cache[key]=[call_times,time.time()]

    print('调用次数: %s' % cache[key][0])

    print('限制次数: %s' % limit_times[0])

    if cache[key][0] <= limit_times[0]:

    res=func(*args,**kwargs)

    cache[key][1] = time.time()

    return res

    def foo():

    print("I'm foo")

    if __name__=='__main__':

    for i in range(10):

    foo()

    #test.py

    Python限制函数调用次数实例,赶紧收藏吧

    from newtest import foo

    import time

    for i in range(30):

    foo()

    print('*'*20)

    foo()

    foo()

    print('*'*20)

    for i in range(60):

    print(i)

    time.sleep(1)

    for i in range(11):

    foo()

    好了,以上就是小编给大家带来的全部内容,转发此文+关注 并私信小编“资料”即可免费领取2019最新python资料和零基础入门教程,不定期分享干货,欢迎初学和进阶中的小伙伴!

    Python限制函数调用次数实例,赶紧收藏吧

    展开全文
  • python函数实例

    2018-08-29 12:58:00
    使用偏函数,可以通过有效地“冻结”那些预先确定的参数来缓存函数参数,然后在运行时,当获得需要的剩余参数后,可以将它们解冻,传递到最终的参数中,从而使用最终确定的所有参数去调用函数。 偏函数最好的一点是...

    偏函数在Python 2.5 版本中添加进来,是函数式编程一系列重要改进中的一部分。使用偏函数,可以通过有效地“冻结”那些预先确定的参数来缓存函数参数,然后在运行时,当获得需要的剩余参数后,可以将它们解冻,传递到最终的参数中,从而使用最终确定的所有参数去调用函数。

    偏函数最好的一点是它不只局限于函数。偏函数可以用于可调用对象(任何包括函数接口的对象),只需要通过使用圆括号即可,包括类、方法或可调用实例。对于有很多可调用对象,并且许多调用都反复使用相同参数的情况,使用偏函数会非常合适。


    GUI編程是一个很好的偏函数用例,因为你很可能需要GUI控件在外观上具有一致性,而这种一致性来自于使用相同参数创建相似的对象。我们现在要实现一个应用,这个应用中有很多按钮有相同的前景色和背景色,对于这种只有细微差别的按钮,使用相同的参数创建相同的实例简直是一种浪费:前景色和背景色都是相同的,只有文本有点不同。

    交通路标示例:

    # encode utf-8
    from functools import partial as pto
    import tkinter as tk
    from tkinter.messagebox import showinfo, showwarning, showerror
    
    WARN = 'warn'
    CRIT = 'crit'
    REGU = 'regu'
    
    SIGNS = {
        'do not enter': CRIT,
        'railroad crossing': WARN,
        'SS\nspeed limit': REGU,
        'wrong way': CRIT,
        'merging traffic': WARN,
        'one way': REGU
    }
     
    critCB = lambda: showerror('Error', 'Error Button Pressed')           #showerror, showwarnning showinfo 是tkinter自带的函数  ,我们用lambda 把函数赋值   
    warnCB = lambda: showwarning('Warnning', 'Warnning Button Pressed')
    infoCB = lambda: showinfo('info', 'Info Button Pressed')
    
    top = tk.Tk()
    top.title('Road Signs')
    MyButton = pto(tk.Button, top)
    CritButton = pto(MyButton, command=critCB, bg='white', fg='red')     #偏函数式編程
    WarnButton = pto(MyButton, command=warnCB, bg='goldenrod1')
    ReguButton = pto(MyButton, command=infoCB, bg='white')
    quit = tk.Button(top, command=top.quit, text='QUIT').pack(fill=tk.X, expand=True)
    for eachSign in SIGNS:
        signType = SIGNS[eachSign]
        cmd = '%sButton(text=%r%s).pack(fill=tk.X, expand=True)' % (   #把命令变成字符串,对于不同的按钮进行modification
            signType.title(), eachSign,
            '.upper()' if signType == CRIT else '.title()')
        eval(cmd)                                                #利用eval ,运行字符串
    
    tk.mainloop()

    当我们运行这个程序时,会出现如下画面:

    点击WRONG WAY按钮:

     

    转载于:https://www.cnblogs.com/francischeng/p/9553646.html

    展开全文
  • 下面小编就为大家分享一篇python 限制函数调用次数的实例讲解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇python关于调用函数外的变量实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了Python函数及默认参数的定义与调用操作,结合实例形式分析了Python函数的定义及参数的使用技巧,需要的朋友可以参考下
  • 主要介绍了python 子类调用父类的构造函数实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 本文实例讲述了Python基类函数的重载与调用方法。分享给大家供大家参考。具体分析如下: 刚接触Python语言的时间不长,对于这个语言的很多特性并不是很了解,有很多用法都是还不知道。今天想着写一个Python面向对象...
  • Vs2015 - C++调用Python3函数与类的实例代码,具体可查看https://blog.csdn.net/automoblie0/article/details/102461477
  • 本文实例讲述了Python的函数返回值用法。分享给大家供大家参考。具体分析如下: ...再看看返回多个值的: 那怎么可以返回多个值呢,其他的语言一般调用函数的话,只能返回一个值,可能我不太熟悉所有的语
  • 主要介绍了Python函数调用与定义,是Python入门学习中的基础知识,需要的朋友可以参考下
  • python 子子类类调调用用父父类类的的构构造造函函数数实实例例 这篇文章主要介绍了python 子类调用父类的构造函数实例具有很好的参考价值希望对大家有所帮助 一起跟 随小编过来看看吧 当子类继承父类后需要调用父类...
  • Python 私有函数实例详解 与大多数语言一样,Python 也有私有的概念: • 私有函数不可以从它们的模块外面被调用 • 私有类方法不能够从它们的类外面被调用 • 私有属性不能够从它们的类外面被访问 与大多数的...
  • 对于第一次接触到python这门编程语言的朋友来说,刚刚开始学习python编程的时候对于python函数调用这一方面的了解比较少,在这篇文章之中我们就来了解一下python怎么调用函数Python内置了很多有用的函数,我们可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,937
精华内容 1,574
关键字:

python调用函数实例

python 订阅