精华内容
下载资源
问答
  • Python函数

    2019-04-18 11:03:47
    函数直接或者间接调用自身就是 递归 递归需要有边界条件、递归前进段、递归返回段 递归一定要有边界条件 当边界条件不满足的时候,递归前进 当边界条件满足的时候,递归返回 1.2 递归要求 递归一定要有退出条件,...

    1.递归函数

    1.1 递归Recursion

    函数直接或者间接调用自身就是 递归
    递归需要有边界条件、递归前进段、递归返回段
    递归一定要有边界条件
    当边界条件不满足的时候,递归前进
    当边界条件满足的时候,递归返回

    1.2 递归要求

    递归一定要有退出条件,递归调用一定要执行到这个退出条件。没有退出条件的递归调用,就是无限调用
    递归调用的深度不宜过深
    Python对递归调用的深度做了限制,以保护解释器
    超过递归深度限制,抛出RecursionError: maxinum recursion depth exceeded 超出最大深度
    sys.getrecursionlimit()

    1.3 递归的性能

    循环稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果
    深度越深,效率越低。
    递归还有深度限制,如果递归复杂,函数反复压栈,栈内存很快就溢出了

    1.4 递归总结

    递归是一种很自然的表达,符合逻辑思维
    递归相对运行效率低,每一次调用函数都要开辟栈帧
    递归有深度限制,如果递归层次太深,函数反复压栈,栈内存很快就溢出了
    如果是有限次数的递归,可以使用递归调用,或者使用循环代替,循环代码稍微复杂一些,但是只要不是
    死循环,可以多次迭代直至算出结果
    绝大多数递归,都可以使用循环实现
    即使递归代码很简洁,但是能不用则不用递归

    2. 匿名函数

    匿名:隐藏名字,即没有名称
    匿名函数:没有名字的函数。
    lambda x: x ** 2 # 定义
    (lambda x: x ** 2)(4) # 调用

    2.1 Lambda表达式

    Python中,使用Lambda表达式构建匿名函数。
    使用lambda关键字定义匿名函数,格式为 lambda [参数列表]: 表达式
    参数列表不需要小括号。无参就不写参数
    冒号用来分割参数列表和表达式部分
    不需要使用return。表达式的值,就是匿名函数的返回值。表达式中不能出现等号
    lambda表达式(匿名函数)只能写在一行上,也称为单行函数
    匿名函数往往用在为高阶函数传参时,使用lambda表达式,往往能简化代码
    #返回常量的函数
    print((lambda :0)())
    #加法匿名函数,带缺省值
    print((lambda x, y=3: x + y)(5))
    print((lambda x, y=3: x + y)(5, 6))
    #keyword-only参数
    print((lambda x, *, y=30: x + y)(5))
    print((lambda x, *, y=30: x + y)(5, y=10))
    #可变参数
    print((lambda *args: (x for x in args))(*range(5)))
    print((lambda *args: [x+1 for x in args])(*range(5)))
    print((lambda *args: {x%2 for x in args})(*range(5)))

    3. 生成器***

    生成器generator
    生成器指的是生成器对象,可以由生成器表达式得到,也可以使用yield关键字得到一个生成器函数,调用这
    个函数得到一个生成器对象
    生成器对象,是一个可迭代对象,是一个迭代器
    生成器对象,是延迟计算、惰性求值的

    3.1 生成器函数

    函数体中包含yield语句的函数,就是生成器函数,调用后返回生成器对象
    m = (i for i in range(5)) # 生成器表达式
    print(type(m))
    print(next(m))
    print(next(m))
    def inc(): # 生成器函数
    ----for i in range(5):
    --------yield i
    普通函数调用,函数会立即执行直到执行完毕。
    生成器函数调用,并不会立即执行函数体,而是需要使用next函数来驱动生成器函数执行后获得的生成器对象。
    生成器表达式和生成器函数都可以得到生成器对象,只不过生成器函数可以写的更加复杂的逻辑。
    包含yield语句的生成器函数调用后,生成生成器对象 的时候,生成器函数的函数体不会立即执行
    next(generator) 会从函数的当前位置向后执行到之后碰到的第一个yield语句,会弹出值,并暂停函数执行
    再次调用next函数,和上一条一样的处理过程
    继续调用next函数,生成器函数如果结束执行了(显式或隐式调用了return语句),会抛出StopIteration异

    3.2 生成器的执行

    在生成器函数中,可以多次yield,每执行一次yield后会暂停执行,把yield表达式的值返回
    再次执行会执行到下一个yield语句又会暂停执行
    return语句依然可以终止函数运行,但return语句的返回值不能被获取到
    return会导致当前函数返回,无法继续执行,也无法继续获取下一个值,抛出StopIteration异常
    如果函数没有显式的return语句,如果生成器函数执行到结尾(相当于执行了return None),一样会抛出
    StopIteration异常

    3.3 生成器的应用(交互)

    # 重置功能的计数器
    def inc():
        def counter():
            i = 0
            while True:
                i += 1
                response = yield i
                if response is not None:
                    i = response
        c = counter()
        return lambda x=False: next(c) if not x else c.send(0)
    foo = inc()
    print(foo())
    print(foo())
    print(foo())
    print(foo(True))
    print(foo())
    print(foo())
    print(foo())
    

    python提供了一个和生成器对象交互的方法send,该方法可以和生成器沟通。
    调用send方法,就可以把send的实参传给yield语句做结果,这个结果可以在等式右边被赋值给其它变量
    send和next一样可以推动生成器启动并执行。

    4.协程Coroutine

    生成器的高级用法
    它比进程、线程轻量级,是在用户空间调度函数的一种实现
    Python3 asyncio就是协程实现,已经加入到标准库
    Python3.5 使用async、await关键字直接原生支持协程
    协程调度器实现思路
    有2个生成器A、B
    next(A)后,A执行到了yield语句暂停,然后去执行next(B),B执行到yield语句也暂停,然后再次调用
    next(A),再调用next(B)在,周而复始,就实现了调度的效果
    可以引入调度的策略来实现切换的方式
    协程是一种非抢占式调度

    5. yield from语法

    从Python 3.3开始增加了yield from语法,使得yield from iterable 等价于 for item in iterable: yield item 。
    yield from就是一种简化语法的语法糖。
    本质上yield from的意思就是,从from后面的可迭代对象中拿元素一个个yield出去。

    6.树

    非线性结构
    树是n(n≥0)个元素的集合
    n = 0时,称为空树
    树只有一个特殊的没有前驱的元素,称为树的根Root
    树中除了根结点外,其余元素只能有一个前驱,可以有零个或多个后继

    6.1 递归定义

    树T是n(n≥0)个元素的集合。n=0时,称为空树
    有且只有一个特殊元素根,剩余元素都可以被划分为m个互不相交的集合T1、T2、T3、…、Tm,而每一个集合都是树,称为T的子树Subtree
    子树也有自己的根

    6.2 树的概念

    结点:树中的数据元素
    结点的度degree:结点拥有的子树的数目称为度,记作d(v)。
    叶子结点:结点的度为0,称为叶子结点leaf、终端结点、末
    端结点
    分支结点:结点的度不为0,称为非终端结点或分支结点
    分支:结点之间的关系
    内部结点:除根结点外的分支结点,当然也不包括叶子结点
    树的度是树内各结点的度的最大值。D结点度最大为3,树的
    度数就是3
    孩子(儿子Child)结点:结点的子树的根结点成为该结点的孩子
    双亲(父Parent)结点:一个结点是它各子树的根结点的双亲
    兄弟(Sibling)结点:具有相同双亲结点的结点
    祖先结点:从根结点到该结点所经分支上所有的结点。
    子孙结点:结点的所有子树上的结点都称为该结点的子孙。
    结点的层次(Level):根节点为第一层,根的孩子为第二层,以
    此类推,记作L(v)
    树的深度(高度Depth):树的层次的最大值。
    堂兄弟:双亲在同一层的结点
    有序树:结点的子树是有顺序的(兄弟有大小,有先后次序),
    不能交换。
    无序树:结点的子树是有无序的,可以交换。
    路径长度=路径上结点数-1,也是分支数

    6.3 树的特点

    唯一的根
    子树不相交
    除了根以外,每个元素只能有一个前驱,可以有零个或多个后继
    根结点没有双亲结点(前驱),叶子结点没有孩子结点(后继)
    vi是vj的双亲,则L(vi) = L(vj)-1,也就是说双亲比孩子结点的层次小1
    堂兄弟定义是,双亲结点是同一层的节点
    堂兄弟的双亲不一定是兄弟关系

    6.4 二叉树

    每个结点最多2棵子树
    二叉树不存在度数大于2的结点
    它是有序树,左子树、右子树是顺序的,不能交换次序
    即使某个结点只有一棵子树,也要确定它是左子树还是右子树
    二叉树的五种基本形态

    6.4.1 空二叉树

    只有一个根结点
    根结点只有左子树
    根结点只有右子树
    根结点有左子树和右子树

    6.4.2 斜树

    左斜树,所有结点都只有左子树
    右斜树,所有节点都只有右子树

    6.4.3 满二叉树

    一棵二叉树的所有分支结点都存在左子树和右子树,并且所有叶子结点只存在在最下面一层。
    同样深度二叉树中,满二叉树结点最多。
    k为深度(1≤k≤n),则结点总数为2^k-1

    6.4.4 完全二叉树Complete Binar y Tree

    若二叉树的深度为k,二叉树的层数从1到k-1层的结点数都达到了最大个数,在第k层的所有结点都集中在最左边,这就是完全二叉树
    完全二叉树由满二叉树引出
    满二叉树一定是完全二叉树,但完全二叉树不一定是满二叉树
    k为深度(1≤k≤n),则结点总数最大值为2^k-1,当达到最大值的时候就是满二叉树

    6.4.5 二叉树性质

    性质1
    在二叉树的第i层上至多有2^(i-1)个结点(i≥1)
    性质2
    深度为k的二叉树,至多有2^k-1个节点(k≥1)
    性质3
    对任何一棵二叉树T,如果其终端节点数为n0,度数为2的结点为
    n2,则有n0=n2+1
    换句话说,就是叶子结点数-1就等于度数为2的结点数。
    其他性质
    高度为k的二叉树,至少有k个结点。
    含有n(n≥1)的结点的二叉树高度至多为n。和上句一个意思
    含有n(n≥1)的结点的二叉树的高度至多为n,最小为
    math.ceil(log2 (n+1)),不小于对数值的最小整数,向上取整。

    假设高度为h,2^h-1=n => h = log (n+1),层次数是取整。
    如果是8个节点,3.1699就要向上取整为4,为4层
    性质4
    具有n个结点的完全二叉树的深度为int(log2 n)+1或者
    math.ceil(log2 (n+1))
    性质5
    如果有一棵n个结点的完全二叉树(深度为性质4),结点按照层
    序编号
    如果i=1,则结点i是二叉树的根,无双亲;如果i>1,则其双亲
    是int(i/2),向下取整。就是子节点的编号整除2得到的就是父结
    点的编号。父结点如果是i,那么左孩子结点就是2i,右孩子结点
    就是2i+1。
    如果2i>n,则结点i无左孩子,即结点i为叶子结点;否则其左孩
    子结点存在编号为2i。
    如果2i+1>n,则结点i无右孩子,注意这里并不能说明结点i没有
    左孩子;否则右孩子结点存在编号为2i+1。

    7. 插入排序

    直接插入排序
    直接插入排序原理
    在未排序序列中,构建一个子排序序列,直至全部数据排序完成
    将待排序的数,插入到已经排序的序列中合适的位置
    增加一个哨兵,放入待比较值,让它和后面已经排好序的序列比较,找到合适的插入点
    增加一个哨兵位,每趟将待比较数放入
    哨兵依次和待比较数的前一个数据比较,大数靠右移动,找到哨兵中值的插入位置
    每一轮结束后,得到一个从开始到待比较数位置的一个有序序列
    使用两层嵌套循环,时间复杂度O(n^2)
    使用在小规模数据比较
    用二分法进行优化(前提是有序)

    7.1 稳定排序算法

    如果待排序序列R中两元素相等,即Ri等于Rj,且i < j ,那么排序后这个先后顺序不变,这种排序算法就称为稳定排序
    冒泡排序和简单插入排序都属于稳定排序
    选择排序不是

    展开全文
  • Python函数:高阶函数

    千次阅读 2019-01-03 21:36:13
    返回函数   函数参数 将函数作为一个参数导入函数。例:用abs绝对值函数充当参数  def ad(x,y,f): return f(x)+f(y) print(ad(2,-5,abs))   递归 在函数内部调用自身,有两点要求 函数内部调用自身函数 ...

    目录

    函数参数

    递归

    map()

    reduce()

    filter()

    sorted()

    返回函数


     

    函数参数

    • 将函数作为一个参数导入函数。例:用abs绝对值函数充当参数 
    def ad(x,y,f):
        return f(x)+f(y)
    
    print(ad(2,-5,abs))

     

    递归

    • 在函数内部调用自身,有两点要求
    1. 函数内部调用自身函数
    2. 必须有个明确的结束条件,称为递归出口,一般使用return语句当做出口
    def f(a):
        print(a)
        if a==1:
            return   #出口
        a=a-1
        f(a)
        print('——')
    
    f(3)
    >>>3
    >>>2
    >>>1
    >>>——
    >>>——

     

    map()

    • map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。
    def oulaoula(a):
        return a*a
    
    print(list(map(oulaoula,[1,3,5,6,8])))

     注意:python2中可以直接打印print(map(oulaoula,[1,3,5,6,8])),但是在Python3中,map只会返回迭代器,因此在map外加上list()就可以返回列表了。

     

    reduce()

    • reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似,一个函数 f,一个list,但行为和 map()不同,reduce()传入的函数 f 必须接收两个参数,reduce()对list的每个元素反复调用函数f,并返回最终结果值。
    from functools import reduce
    def adaada(x,y):
        return x+y
    
    print(reduce(adaada,[1,2,3,4,5]))

     注意:python2中可以直接打印print(reduce(adaada,[1,2,3,4,5])),但是在Python3中,要先from functools import reduce导入reduce,然后再使用。

    reduce()还可以接收第3个可选参数,作为计算的初始值。

    reduce(f, [1, 3, 5, 7, 9], 100)
    #计算初始值和第一个元素:f(100, 1),结果为101。

     

    filter()

    • filter()函数是 Python 内置的另一个有用的高阶函数,filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。
    def mudamuda(x):
        return x%2==0
    
    print(list(filter(mudamuda,[1,2,3,4,5,6])))

     注意:Python3中返回迭代器的问题

    利用filter(),可以完成很多有用的功能,例如,删除 None 或者空字符串

     

    sorted()

    限于Python2

    • sorted()可以对字符串等进行排序,默认按照ASCII大小来比较。
    def hoooo(x,y):     #只能在Python2起作用
        if x.upper()>y.upper():
            return 1
        elif x.upper()<y.upper():
            return -1
    
    print(sorted(['abc','bcd','ACD','WDS'],key= lambda x: x.upper()))  #Python3中直接使用key函数

     Python3中取消了cmp参数,因此只能用key函数实现倒叙正序


    返回函数

    from functools import reduce
    def calc_prod(lst):
        def lazy():
            def f(x,y):
                return x*y
            return reduce(f,lst)
        return lazy
    g= calc_prod([1, 2, 3, 4])
    print(g())

     

    展开全文
  • 递归Recursion:函数直接或者间接调用自身就是递归,递归需要有边界条件,递归前进段,递归返回段,递归一定一定要有边界条件,不然很容易崩溃 #递归函数举例 计算斐波那契数列‘ def fib(n): if n &...

    函数执行流程:压栈 一层压一层

    函数执行流程
    函数流程2

    递归Recursion:函数直接或者间接调用自身就是递归,递归需要有边界条件,递归前进段,递归返回段,递归一定一定要有边界条件,不然很容易崩溃

    	#递归函数举例    计算斐波那契数列‘
    		def fib(n):
    			if n < 3:					#这里就是递归的边界  当n小于5就return退出
    				return 1
    			return fib(n-1) + fib(n-2)	#这里就是自己调用自己 一层层下去  到底然后一层层返回
    		print(fib(5))					# 打印  5			n传的数如果很大效率就很慢
    

    递归要求:递归一定要有退出条件,递归调用一定要执行到条件退出。如果没有退出条件的递归调用,就是无限调用,直到崩溃

    递归调用的深度不宜过深,python对递归调用的深度做了限制,用以保护解释器,当递归调用超过深度限制时,就会抛出RecursionError:maxinum recursion depth exceeded 超出最大深度的错误
    调用import sys 用sys.getrecursionlimit()可以查看解释器最大的调用深度

    递归的性能:循环稍微复杂一些,但是只要不是死循环,可以多次迭代直到算出结果,斐波那契函数的代码极简易懂,但是只能回去最外层的函数调用,而且给定一个n都要进行近2n次的递归,递归调用深度越深,效率越低,递归还有深度限制,如果递归复杂,函数反复压栈,栈内存很快就会溢出

    递归总结:

    总结

    递归的练习题:

    第一:用递归求n的阶乘

    def fn(n):
    	if n == 1:			#递归的边界条件
    		return 1
    	return n * fn(n - 1)		#递归进去计算  自己调用自己
    print(fn(5))
    

    第二:将一个数逆序打印

    def rev(x, tar = None):
    	if tar == None:			#判断tar是不是None 如果是 则追加一个空列表
    		tar = []
    	x, y = divmod(x, 10)		# 这里的divmod作用是 x / 10    然后x, y 解构 x拿到商(1234) y拿到余数(5)
    	tar.append(y)				#将5追加进列表
    	if x == 0:
    		return tar
    	return rev(x, tar)
    print(rev(12345))				#传入12345
    

    第三:解决猴子吃桃问题

    def fn(n):			
    	if n == 1:
    		return 1
    	return (fn(n-1)+1) * 2
    print(fn(10))
    
    展开全文
  • python内置函数

    2021-06-04 19:20:10
    函数返回数字的绝对值。 1 2 3 4Copy a = 5 b = -10 print(abs(a)) #输出3 print(abs(b)) #输出5 Copy 2、all() 此函数用于判断给定的可迭代参数iterable中的所有元素是否都不为0、都...

    python内置函数

    Python 内置函数就是 python 标准库里(语言自身携带的)函数(公共函数)。

    那么,接下来就来谈一谈 python 里的内置函数

    1、abs()

    此函数返回数字的绝对值。

    a = 5
    b = -10
    print(abs(a))  #输出3
    print(abs(b))  #输出5

    2、all()

    此函数用于判断给定的可迭代参数 iterable 中的所有元素是否都不为 0、都不为 False 或者 iterable 都 为空,如果是返回 True, 否则返回 False

    print(all(['a', 'b', 'c', 'd']))  # True
    print(all(['a', 'b', '', 'd']))   # False
    print(all([0, 1,2, 3]))          # False
    print(all(('a', 'b', '', 'd')))   # False
    print(all((0, 1,2, 3)))          # False
    print(all([]))  # True
    print(all(()))  # True

    3、any()

    函数用于判断给定的可迭代参数 iterable 是否全部为空对象,如果都为空、都为 0、或者都为 false,则返回 False,如果不都为空、不都为 0、不都为 false,则返回 True

    print(any(['a', 'b', 'c', 'd']))  # True
    print(any(['a', 'b', '', 'd']))   # True
    print(any([0, 1,2, 3]))          # True
    print(any(('a', 'b', '', 'd')))   # True
    print(any((0, 1,2, 3)))          # True
    print(any([]))  # False
    print(any(()))  # False

    4、bin()

    返回一个整数 int 或者长整数 long int 的二进制表示。

    print(bin(10))  #0b1010
    print(bin(20))  #0b10100

    5、bool()

    函数用于将给定参数转换为布尔类型,如果没有参数,返回 False

    • 传入布尔类型时,按原值返回

    • 参数如果缺省,则返回 False

    • 传入字符串时,空字符串返回 False,否则返回 True

    • 传入数值时,0 值返回 False,否则返回 True

    • 传入元组、列表、字典等对象时,元素个数为空返回 False,否则返回 True.

    print(bool())  #False
    print(bool(True))  #True
    print(bool(""))  #False
    print(bool("123"))  #True
    print(bool(0))  #False
    print(bool(1))  #True
    print(bool([])) #False  若元祖和字典为空时 也为False ,不为空 则为True

    6、chr()

    用一个范围在 range(256)内的(就是 0~255)整数作参数,返回一个对应的字符。(只能输入数字)

    print(chr(65))   #A
    print(chr(97))   #a
    print(chr(100))  #d

    7、cmp(x,y)

    函数用于比较 2 个对象,如果x <y返回-1, 如果 x == y 返回 0, 如果 x> y返回 1。(python3 已经删除了)

    8、compile()

    函数将一个字符串编译为字节代码。语法:compile(source, filename, mode[, flags[, dont_inherit]])

    import re
    pattern=re.compile('[a-zA-Z]')
    result=pattern.findall('as3SiOPdj#@23awe')
    print(result)

    9、complex(real,imag)

    函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。

    print(complex(1, 2))  #(1 + 2j)
    print(complex(1))  #(1 + 0j)
    print(complex("3")) #(3+0j)

    10、dict(**kwarg)

    返回一个字典

    >>>dict()                        # 创建空字典
    {}
    >>> dict(a='a', b='b', t='t')     # 传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
    >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    {'three': 3, 'two': 2, 'one': 1} 
    >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    {'three': 3, 'two': 2, 'one': 1}
    >>>

    11、dir([object])

    函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;

    带参数时,返回参数的属性、方法列表。

    如果参数包含方法__dir__(),该方法将被调用。

    如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

    >>>dir()   #  获得当前模块的属性列表
    ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
    >>> dir([ ])    # 查看列表的方法
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    >>>

    12、divmod(a, b)

    函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)

    >>>divmod(7, 2)
    (3, 1)
    >>> divmod(8, 2)
    (4, 0)
    >>> divmod(1+2j,1+0.5j)
    ((1+0j), 1.5j)

    13、enumerate(sequence, [start=0])

    函数用于将一个可遍历的数据对象 (如列表、元组或字符串) 组合为一个索引序列,同时列出数据和数据下标,一般用在for 循环当中。

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))       # 下标从 1 开始
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

    14、eval() 函数用来执行一个字符串表达式,并返回表达式的值。

    15、execfile() 函数可以用来执行一个文件。

    16、float() 函数用于将整数和字符串转换成浮点数。

    17、frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

    18、getattr() 函数用于返回一个对象属性值。

    19、hash() 用于获取取一个对象(字符串或者数值等)的哈希值。

    20、help() 函数用于查看函数或模块用途的详细说明。

    21、hex() 函数用于将 10 进制整数转换成 16 进制整数。

    22、id() 函数用于获取对象的内存地址。

    23、input() 输入函数

    24、int() 函数用于将一个字符串会数字转换为整型。

    25、isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。

       isinstance() 与 type() 区别:

    • type() 不会认为子类是一种父类类型,不考虑继承关系。

    • isinstance() 会认为子类是一种父类类型,考虑继承关系。

    • 如果要判断两个类型是否相同推荐使用 isinstance()。

    26、len() 方法返回对象(字符、列表、元组等)长度或项目个数。

    27、list() 方法用于将元组转换为列表。

    28、locals() 函数会以字典类型返回当前位置的全部局部变量。

    29、long() 函数将数字或字符串转换为一个长整型。

    30、max() 方法返回给定参数的最大值,参数可以为序列。

    31、memoryview() 函数返回给定参数的内存查看对象 (Momory view)。

    32、min() 方法返回给定参数的最小值,参数可以为序列。

    33、oct() 函数将一个整数转换成 8 进制字符串。

    34、open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。

    35、ord() 函数与 chr() 函数相反,输入字符返回数字

    36、pow() 方法返回 xy(x 的 y 次方) 的值。函数是计算 x 的 y 次方,如果 z 在存在,则再对结果进行取模,其结果等效于 pow(x,y) %z

    37、print() 输出函数

    38、range() 函数可创建一个整数列表,一般用在 for 循环中。

    39、reload() 用于重新载入之前载入的模块。

    40、everse() 函数用于反向列表中元素。

    41、round() 方法返回浮点数 x 的四舍五入值。

    42、set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

    43、str() 函数将对象转化字符串

    44、sum() 方法对系列进行求和计算。

    45、tuple() 元组 tuple() 函数将列表转换为元组。

    46、type() 返回对象类型。

    47、unichr() 该函数和 chr() 函数功能基本一样, 只不过是返回 unicode 的字符。

    48、vars() 函数返回对象 object 的属性和属性值的字典对象。

    49、xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。

    50、import() 函数用于动态加载类和函数 。如果一个模块经常变化就可以使用 import() 来动态载入。

    展开全文
  • python 内置函数

    2019-07-19 18:24:00
    官方链接:https://docs.python.org/3/library/functions.html?highlight=built#ascii Python内置函数就是python标准库里(语言自身携带的)函数(公共函数... abs() 函数返回数字的绝对值。 a = 3 b = -5 p...
  • 类型转换 int() str() float() type()获取对象类型 isinstance() 判断对象类型 >>>...len() 方法返回对象(字符、列表、元组等)长度或项目个数。 >>> b=[1,2,33] >&g
  • python递归函数

    2018-04-22 20:44:48
    python在函数内部,可以调用其他函数,如果...(func())使用递归函数需要注意防止栈溢出,在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当 进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会...
  • (15)python函数进阶

    2017-04-06 19:08:00
    如果一个函数在内部调用自身本身,这个函数就是递归函数。 例: def recursion(n): print(n) if int(n/2)>0: return recursion(int(n/2)) print('----->',n)recursion(10) 返回结果: 10 5 2...
  • Python异步爬虫进阶 爬虫是 IO 密集型任务,比如我们使用 requests 库来爬取某个站点的话,发出一个请求之后,程序必须要等待网站返回响应之后才能接着运行,而在等待响应的过程中,整个爬虫程序是一直在等待的,...
  • 函数调用函数自身,这种方式称为递归,这种函数称为递归函数 递归函数的优点是定义简单,逻辑清晰,缺点是过深的调用会导致栈溢出 递归函数使用过程中,需要找到不变的规律和停止递归的边界条件, 因为函数自身...
  • 可调用对象 ...可调用对象即将自身传入 callable 函数( callable(对象) )返回结果为 True 的对象 x = 1 print(callable(x)) # False # x() # 会报错,TypeError: 'int' object is not callable,...
  • python sorted函数

    2021-05-03 20:46:23
    sorted函数比sort函数要强大许多了,sort只能对列表进行排序,sorted可以对所有可迭代类型进行排序,并且返回新的已排序的列表。语法如下: sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted...
  • python 递归函数

    千次阅读 2016-10-24 19:42:56
    python里面也可以使用递归函数,所谓递归函数就是利用函数本身调用自身,然后一直不停地调用自身,达到合适的条件,然后返回计算后的值。 例如:#计算5的以内的加法  def add(j):  if j==0:  return 0  ...
  • Python 递归函数

    2018-04-08 11:47:00
    3.递归效率不高,可能会导致栈溢出(函数调用是通过栈这种数据结构实现的,每进入一个函数调用,栈就会增加一层栈帧,函数返回,栈就会减少一层栈帧,由于栈的大小不是无限的,递归调用过多,可能会导致栈溢出) ...
  • Python-函数进阶

    2021-03-15 20:04:07
    递归函数:在函数调用函数自身,我们把这样的函数叫做递归函数 递归边界:退出递归的终止条件 1 # 递归实现阶乘 2 def fun(num): 3 if num == 1 or num == 0: 4 return 1 5 else: 6 return num * fun(num - 1) 纯...
  • 调用自身函数,并且有正确的返回条件 递归求阶乘: def jie(n): if n==1: return 1 else: return n*jie(n-1)#自己调用自己 结果: jie(5) 120 习题及答案 0.递归在编程上的形式是如何表现的? 函数...
  • PYTHON-函数特性

    2015-04-13 17:27:15
    函数:在Python中,定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用 return 语句返回。 递归函数自身调用自身就是递归函数 定义默认参数 ...
  • python数学函数

    2019-08-09 09:11:04
    #取大于x的最小整数值,如果x是一个整数就返回自身 #取小于x的最大的整数值,如果x是一个整数,则返回自身 #求 弧度的余弦 #把弧度转成角度 #求绝对值 #求阶乘 #求指数 #对迭代器中的元素求和 #求余数, 得到浮点数...
  • 描述classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示...返回值返回函数的类方法。实例以下实例展示了 classmethod 的使用方法:#!/usr/bin/python# -*- coding: UTF-8 -*- c...
  • [转载] Python 递归函数

    2021-04-16 22:55:36
    递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的...
  • 递归就是函数调用自身的行为。 递归必须满足哪两个基本条件: 1,函数调用自身 2,设置了正确的返回条件 按照递归的特性,在编程里有没有必须要用到递归的情况? 例如汉诺塔,目录(你永远不知道目录里是否还有...
  • 1.列表相关的内置函数all(iterable):这个函数返回一个布尔值。如果iterable的所有元素都为真(或iterable自身为空)则返回True,否则返回False。例:all[2,3,0]将返回Falseany(iterable):这个函数返回一个布尔值。...
  • python递归函数的用法

    2020-11-04 02:59:34
    def fact(n): if n==1: return 1 ...尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。这样,编译器或者解释器就可以把尾递归做优化,使递归本身无论调用多少次,都只占..
  • 这里写自定义目录标题一、递归函数二、回调函数三、闭包函数四、匿名函数 lambda表达式 一、递归函数 ????递归是指函数/过程/子程序在运行...递归函数是一层一层的进入,再一层一层的返回。 举例 例①: # 初步认识
  • Python:递归函数

    2021-03-17 21:29:04
    函数直接或间接调用自身就是递归 递归函数需要有边界、递归前进段、递归返回段 递归一定要有边界条件 当边界不满足的时候,递归前进 当边界条件满足的时候,递归返回 斐波那契数列【用递归来实现】 用for循环...
  • python之递归函数

    2018-04-25 11:54:00
    一:递归函数:在函数内部,可以调用其他函数,如果一个函数在内部调用自身本身,这个函数就叫做递归函数 ...这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧...
  • 函数的返回值是函数自身 用于解决可以拆分的大问题 递归函数的条件 递归条件:问题可以被继续分解 基线条件:问题最小化时返回一个确切的值,并停止递归 例题1:判断回文字符串 def Palindrome(str1): if len...
  • 以下是写的两个函数1、‘自加函数’:接受一个对象、将她的值加到自身、然后返回和。几乎所有的标准数据类型都支持 + 运算符,不管是数值相加还是序列合并。2、默认函数函数的参数可以有一个默认值、如果提供有...
  • python3 递归函数

    2019-02-05 12:01:53
    函数中调用自身函数就是递归函数,递是一层层解决问题,归时一层层返回答案。 #简单递归 &gt;&gt;&gt; def story(): print('从前有座山') story() print('山上有座庙') &gt;&gt;&...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 289
精华内容 115
关键字:

python函数返回函数自身

python 订阅