精华内容
下载资源
问答
  • 具体到阶乘计算,无非就是某个数字 n 阶乘,变成这个数乘以 n-1 阶乘。因此,递归法则就两条:一是自顶而下(从目标直接出发),二是不断重复。递归另一个特点在于,它只关心自己下一层细节,而并不关心...

    对于求 n!,你可能会问,为何要用递归?有何优势?答案并不复杂,利用递归可以使算法的逻辑变得非常简单。因为递归过程的每一步用的都是同一个算法,计算机只需要自顶向下不断重复即可。

    具体到阶乘的计算,无非就是某个数字 n 的阶乘,变成这个数乘以 n-1 的阶乘。因此,递归的法则就两条:一是自顶而下(从目标直接出发),二是不断重复。

    递归的另一个特点在于,它只关心自己下一层的细节,而并不关心更下层的细节。你可以理解为,递归的简单源自它只关注“当下”,把握“小趋势”,虽然每一步都简单,但一直追寻下去,也能获得自己独特的精彩。

    下面我们就以计算阶乘为例,分别使用递推和递归方式实现,见例 1,读者可体会二者的区别。

    【例 1 】利用递推和递归方式分别计算 n!(iterative-recursive.py)。

    #用正向递推的方式计算阶乘

    def iterative_fact(n):

    fact = 1

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

    fact *= i

    return fact

    #用逆向递归的方式计算阶乘

    def recursive_fact(n):

    if n <= 1 :

    return n

    return n * recursive_fact(n - 1)

    #调用递推方法计算

    num = 5

    result = iterative_fact(num)

    print("递推方法:{} != {}".format(num, result))

    #调用递归方法计算

    result = recursive_fact(num)

    print ("递归方法:{} != {}".format(num,result))

    程序执行结果为:

    递推方法:5 != 120

    递归方法:5 != 120

    第 02~06 行定义了一个递推计算阶乘的函数 iterative_fact( ),函数内部采用 for 循环的方式来计算结果。在 for 循环控制过程中使用了 range( ) 函数,由于 range( ) 的取值区间是左闭右开的,最后一个值取不到,所以在第 04 行执行了 n+1 操作。

    第 09~12 行定义一个递归函数 recursive_fact( ),采用递归的方式计算结果。

    第 17 行和第 20 行用到了 Python 的格式化输出。在 Python 中,一切皆对象。用双引号引起来的字符串“递归方法:{}!= {}”,实际上是一个 str 对象。既然是对象,它就会有相应的方法成员,format( ) 就是用于格式化输出的方法,因此可以通过“对象.方法名”的格式来调用合适的方法。

    字符串中的花括号{ }表示输出占位符,第 1 个占位符{ }用于输出 format( ) 函数中第 1 个变量,第 2 个占位符{ }用于输出 format( ) 函数中第 2 个变量,以此类推。

    递归函数的优点在于,定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但正向递推(即循环)的逻辑不如逆向递归的逻辑清晰。

    对于递推的实现,这里用到了前面章节中讲到的 for 循环语句,以 1 为基数不断循环相乘,最终得出阶乘的结果。而在递归实现的操作中,这里通过对方法本身压栈和弹栈的方式,将每一层的结果逐级返回,通过逐步累加求得结果。

    recursive_fact(5)的计算过程如下。

    ===> recursive_fact(5)

    ===> 5 * recursive_fact(4)

    ===> 5 * (4 * recursive_fact(3))

    ===> 5 * (4 * (3 * recursive_fact(2))

    ===> 5 * (4 * (3 * (2 * recursive_fact(1))))

    ===> 5 * (4 * (3 * (2 * 1)))

    ===> 5 * (4 * (3*2))

    ===> 5 *(4*6)

    ===> 5 * 24

    ===> 120

    需要注意的是,虽然递归有许多的优点,但缺点也很明显。那就是,使用递归方式需要函数做大量的压栈和弹栈操作,由于压栈和弹栈涉及函数执行上下文(context)的现场保存和现场恢复,所以程序的运行速度比不用递归实现要慢。

    此外,大量的堆栈操作消耗的内存资源要比非递归调用多。而且,过深的递归调用还可能会导致堆栈溢出。如果操作不慎,还容易出现死循环。因此读者编写代码时需要多加注意,一定要设置递归操作的终止条件。

    展开全文
  • Python中的pass是什么?Pass是一个在Python中不会被执行语句。在复杂语句中,如果一个地方需要暂时被留白,它常常被用于占位符。数组和元组之间区别是什么?数组内容是可以被修改。元组内容是只读。元组可以...

    Python都有哪些自带的数据结构?

    Python自带的数据结构分为可变的和不可变的。

    可变的有: 数组、集合、字典。

    不可变的有: 字符串、元组、数。

    Python中的pass是什么?

    Pass是一个在Python中不会被执行的语句。在复杂语句中,如果一个地方需要暂时被留白,它常常被用于占位符。

    数组和元组之间的区别是什么?

    数组内容是可以被修改的。

    元组内容是只读的。元组可以被哈希,比如作为字典的关键字。

    Python是如何进行类型转换的?

    int( x [,base ] ):将x转换为一个整数

    long( x [,base ] ):将x转换为一个长整数

    float( x ):将x转换到一个浮点数

    complex( real [,imag ] ):创建一个复数

    str( x ):将对象 x 转换为字符串

    repr( x ):将对象 x 转换为表达式字符串

    eval( str ):用来计算在字符串中的有效Python表达式,并返回一个对象

    tuple( s ):将序列 s 转换为一个元组

    list( s ) :将序列 s 转换为一个列表

    chr( x ):将一个整数转换为一个字符

    unichr( x ):将一个整数转换为Unicode字符

    ord( x ):将一个字符转换为它的整数值

    hex( x ):将一个整数转换为一个十六进制字符串

    oct( x ):将一个整数转换为一个八进制字符串

    解释参数 *args,**kwargs

    在不确定要往函数中传入多少个参数或我们想往函数中以列表和元组的形式传参数时,那就使用*args;

    如果不知道要往函数中传入多少个关键词参数或想传入字典的值作为关键词参数时,那就使用**kwargs。

    args和kwargs这两个标识符是约定俗成的用法,你当然还可以用*bob和**billy,但是这样不太妥。

    match()和search()函数有什么区别

    match()函数只检测字符串开头位置是否匹配,匹配成功才会返回结果,否则返回None。

    import re

    print(re.match("func", "function"))

    # 打印结果 <_sre.SRE_Match object; span=(0, 4), match="func">

    print(re.match("func", "function").span())

    # 打印结果  (0, 4)

    print(re.match("func1", "function"))

    # 打印结果 None

    # print(re.match("func1", "function").span())会报错,因为取不到span

    search()函数会在整个字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

    import re

    print(re.search("tion", "function"))# 打印结果 <_sre.SRE_Match object; span=(4, 8), match="tion">

    print(re.search("tion", "function").span())# 打印结果  (4, 8)

    print(re.search("tion1", "function"))# 打印结果 None

    # print(re.search("tion1", "function").span())会报错,因为取不到tion1

    什么是lambda函数?它有什么好处?

    lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数。

    lambda 函数不能包含命令,它们所包含的表达式不能超过一个。不要试图向lambda 函数中塞入太多的东西,如果你需要更复杂的东西,应该定义一个普通函数,然后让它多长就多长。

    简述一下read、readline、readlines

    read:读取整个文件

    readline:读取下一行数据

    readlines:读取整个文件到一个迭代器以供我们遍历(读取 到一个list中,以供使用,比较方便)

    time,datetime,calender模块的区别

    time: 提供了更底层的时间相关的功能,大部分函数调用了C语言的同名函数,但在不同的操作系统上表现的行为可能不一致,如:time.clock()。

    datetime: 是python处理日期和时间的标准库,提供了更多实用功能,如:时间加减。

    calender: 提供了日历相关的功能,如:判断是否闰年。

    Python里面如何实现tuple和list的转换?

    >>> l = tuple(iplist)

    >>> print l

    ("217.169.209.2:6666", "192.227.139.106:7808", "110.4.12.170:83", "69.197.132.80:7808", "205.164.41.101:3128", "63.141.249.37:8089", "27.34.142.47:9090")

    >>> t = list(l)

    >>> print t

    ["217.169.209.2:6666", "192.227.139.106:7808", "110.4.12.170:83", "69.197.132.80:7808", "205.164.41.101:3128", "63.141.249.37:8089", "27.34.142.47:9090"]

    Python代码实现删除一个list里面的重复元素

    >>> l = [1,1,2,3,4,5,4]

    >>> list(set(l))

    [1, 2, 3, 4, 5]

    或者

    d = {}

    for x in mylist:

    d[x] = 1

    mylist = list(d.keys())

    最后

    如果对软件测试、接口测试、自动化测试、软件测试零基础入门、性能测试、LR脚本开发、python自动化全栈、面试经验感兴趣可以175317069,群内会有不定期的发放免费的资料链接。如果你有好的学习也资料可以私聊发我,我会注明出处之后分享给大家。

    好看的小哥哥小姐姐们点个【赞同】、【关注】吧  罒ω罒

    展开全文
  • 首先我是辣鸡,然后这个问题的确有点意思首先,类是一个集合,包含了数据,操作描述一个抽象集合你可以首先只把类当做一个容器来使用class Cycle:def __init__(self,r):self.pi=3.14self.r=ra=Cycle(4)b=Cycle(7)...

    首先我是辣鸡,然后这个问题的确有点意思

    首先,类是一个集合,包含了数据,操作描述的一个抽象集合

    你可以首先只把类当做一个容器来使用

    class Cycle:

    def __init__(self,r):

    self.pi=3.14

    self.r=r

    a=Cycle(4)

    b=Cycle(7)

    你看,我们定义了一个 Cycle 类,我们现在只是将它当做一个数据集合来用,我们利用其实例之间彼此数据隔离的特性来保证具体的实例数据彼此不污染。好了你现在想问,为什么我们要用数据集合来放数据

    好了,我们来看看没有类之前我们会怎么样,假设我们现在要计算圆的面积

    def square(r,pi):

    return pi * (r**2)

    PI=3.14

    a_r=4

    a_square=square(a_r,PI)

    b_r=7

    b_square=square(b_r,PI)

    看起来没有问题,好了,现在问题来了,假如,你现在要计算很多圆的面积,那么你是不是发现,不断的用变量命来隔离数据方式变得越来越脏了。而且你发现是不是有很多冗余的代码

    好了我们这么改一改

    class Cycle:

    def __init__(self,r):

    self.pi=3.14

    self.r=r

    def square(value):

    if not isinstance(value,Cycle):

    raise ValueError("value muse be Cycle instace")

    value.square=value.pi * (value.r**2)

    a=Cycle(4)

    b=Cycle(7)

    square(a)

    square(b)

    好了,你有没有觉得现在清晰了一点。

    好了,现在我们现在还可以改一下

    class Cycle:

    def __init__(self,r):

    self.pi=3.14

    self.r=r

    def square(self,value):

    return self.pi * (self.r**2)

    好了,现在你可能迷惑了,我们为啥要把 square 函数放在类中?

    好了,我现在要计算长方形,原型,梯形各种各样二维几何图形的面积,这样该怎么写???

    你想了想我们之前说的将类作为数据容器,你想了想写了如下的代码

    class Rectangle:

    def __init__(self,length,height):

    self.length=length

    self.height=height

    class Cycle:

    def __init__(self,r):

    self.pi=3.14

    self.r=r

    def rec_square(value):

    if not isinstance(value,Rectangle):

    raise ValueError("value muse be Rectangle instace")

    value.square=value.length * value.height

    def cycle_square(value):

    if not isinstance(value,Cycle):

    raise ValueError("value muse be Cycle instace")

    value.square=value.pi * (value.r**2)

    你想一想,这样是不是感觉如果计算需求越来越多,代码是不是还是会越来越脏?

    如果我们将函数放在类里,并且用继承的特性,我们可以写出这样的代码

    class Geometry:

    def get_square(self):

    raise NotImplementedError

    class Rectangle(Geometry):

    def __init__(self,length,height):

    self.length=length

    self.height=height

    def get_square(self):

    return self.length*self.height

    class Cycle(Geometry):

    def __init__(self,r):

    self.pi=3.14

    self.r=r

    def get_square(self,value):

    return self.pi * (self.r**2)

    def square(value):

    if not isinstance(value,Geometry):

    raise ValueError("value muse be Geometry instace")

    value.square=value.get_square()

    你看,我们现在只需要给用户暴露一个统一的接口,用户(用户也以是我们自己)不需要关心怎么样选择正确的函数,他只需要调用统一的 square 函数,就可以获取到具体的面积,是不是轻松很多了??

    所以,类,它是对数据,操作的一种封装,这个封装的意义在于我们可以去更好的优化代码结构。

    好了再举一个例子,我们可以用类来控制访问权限

    class People:

    def __init__(self,website):

    self.__favorite_website="1024.com"

    def bad_or_not(self):

    return self.__favorite_website=="1024.com"

    你看,我们用 private 变量,来确保外部没法直接访问一些敏感数据(实际上 Python 里 private 并不严格,hook 一下还是可以访问的)

    好,在举一个例子

    class People:

    def __init__(self,website):

    self.__favorite_website="1024.com"

    def bad_or_not(self):

    return self.__favorite_website=="1024.com"

    @property

    def favorite_website(self):

    return self.__favorite_website

    @favorite_website.setter

    def favorite_website(self,value):

    if value=="1024.com":

    raise ValueError("你不能去草榴,兄弟,你营养不足")

    self.__favorite_website=value

    你看,我们现在很方便的实现在设置数据值的时候,对其过滤。

    撤了这么多,回到你的问题首先A君说的没毛病,但我想知道仅仅使用函数锤子,螺丝刀来完成一个项目比使用Class工厂+函数锤子来完成一个项目的效率会更低么?理由是什么?大神在什么时候会考虑使用Class来提高代码的“执行效率”和代码的“可读性”。回归实际情况,我很多时候都是调用同一个函数/方法去输出某个结果。至今还想不出为什么调用Class会更方便?(PS:本人大菜鸟,写了上千行代码了,但仍然搞不懂什么情况下需要用到Class类。也曾尝试在自己的代码中强行加入Class输出结果,但感觉不灵活,而且要写的代码明显多了也不便于理解。求大神举例,碾压我的无知!)。C君说大型项目不使用Class调用对象会累死,到底这个“累死”体现在哪里?

    首先一个问题,我整个答案里所写的这些代码,不用面向对象这一套能不能实现?

    很明显,能。

    但是实现的干净么?个人觉得不干净。

    项目规格上去后,我们如果按照传统的方式进行开发,务必要多重检查,确保自己不会手抖调用了错误的东西。而 OOP 这一套思想,其实就是通过利用合适的代码结构和封装,某种程度上来讲是减少我们犯错的可能。

    同时,现在开发基本都不是一个人的单打独斗,你写的代码可能会被其余人使用与维护。我们有个前提,要假设使用维护你代码的人都是傻逼。我们要适当的封装代码,优化结构,让使用者尽可能的少犯错、

    所以最后,无论是各个语言的变量命名规则也好,还是 OOP 这一套范式也好。其本质是在自由度与可读性可维护性之间的一种相对较优的妥协,这种妥协根本的目的就在于通过规范化的操作与封装,减少团队开发维护的成本,优化开发体验。

    另外,关于开发这一套还有个老生常谈的问题过度封装。我个人的观点是在你知道什么是 过度封装 之前,你没必要考虑这个问题,按照教科书和开源代码里的结构,去不断封装优化你的代码。

    展开全文
  • 本文就来谈谈Lambda表达式在Python中的优点和缺点。一方面,Lambda函数的减少了代码的行数,方便又简洁。另一方面,Lambda表达式有诸多限制,不能使用复杂逻辑。一、Lambda表达式的概念。Lambda表达式也叫匿名函数,...

    学过python的人,相信都接触过Lambda表达式。本文就来谈谈Lambda表达式在Python中的优点和缺点。一方面,Lambda函数的减少了代码的行数,方便又简洁。另一方面,Lambda表达式有诸多限制,不能使用复杂逻辑。

    4c2d89e5305840f18ad63bcd2b17a441.jpg

    一、Lambda表达式的概念。

    Lambda表达式也叫匿名函数,即函数没有具体的名称。Lambda表达式是Python中一类特殊的定义函数的形式,使用它可以定义一个匿名函数。与其它语言不同,Python的Lambda表达式的函数体只能有单独的一条语句,也就是返回值表达式语句。Lambda语句构建的其实是一个函数对象。匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果。

    二、Lambda表达式的优点:

    1、使用Python写一些执行脚本时,使用Lambda可以省去定义函数的过程,让代码更加精简。

    2、对于一些抽象的,不会别的地方再复用的函数,有时候给函数起个名字也是个难题,使用Lambda不需要考虑命名的问题。

    3、使用Lambda在某些时候让代码更容易理解。

    4、举例:

    def f(x):

    return x**2

    print f(4)

    Python中使用lambda的话,写成这样

    g = lambda x : x**2

    print g(4)

    三、Lambda表达式的缺点:

    1. 若不用并行计算,很多时候计算速度没有比传统的 for 循环快(并行计算有时需要预热才显示出效率优势,并行计算目前对 Collection 类型支持的好,对其他类型支持的一般)。

    2. 不容易调试。

    3. 若其他程序员没有学过Lambda表达式,代码不容易让其他语言的程序员看懂。

    4. 在Lambda语句中强制类型转换貌似不方便,一定要搞清楚到底是 map 还是 mapToDouble 还是 mapToInt。

    总之,Lambda表达式在Python中的也会有争议的声音,它既有其优点又存在缺点。大家又是怎么认为的呢?

    展开全文
  • 本篇文章总结出你应该了解的Python功能特色,希望大家在学习过程,少走弯路,善用技巧!带任意数量参数的函数你可能已经知道了Python允许你定义可选参数。但还有一个方法,可以定义函数任意数量参数。首先,看...
  • Python中函数的使用

    2020-04-26 23:04:16
    文章目录函数的基本使用方法函数的定义函数的调用函数单的嵌套函数变量的使用函数的参数位置参数默认参数可变参数关键字参数返回值变量作用域 函数就是通过关键字,将某些代码实现的功能进行封装。 在使用到该...
  • 那么会将功能封装成函数,当我们在使用功能时候直接调用函数即可本质:函数就是对功能封装优点1 简化代码结构,增加了代码重复使用程度2 如果想修改某些功能或者修改某个BUG,修改对应的函数''''''定义函数:...
  • 函数简介 定义:具有特殊功能的一段代码 ...函数的定义格式: def 函数体[参数列表]: 函数体 []表示参数可选的,参数可以有,也可以没有,有也可以是一个或多个 函数名:像变量名一样,只要符合标识符命...
  • python中的函数

    2020-09-26 16:33:54
    函数函数的作用函数的结构函数执行空间,取值空间局部作用域全局作用域取值函数的返回值函数的参数形参实参函数的应用函数的三大器生成器生成器的三种产生方式装饰器迭代迭代器优点缺点可迭代对象优点缺点闭包什么是...
  • Python中的函数

    2018-08-19 23:09:28
    函数的定义 在一个完整的项目,某些功能会被反复的进行使用,我们须将这些功能封装成函数,当我们要使用这些功能的时候直接调用函数即可。函数的本质:对功能的封装。 优点:1.简化代码结构,增加了代码的重复...
  • python的函数

    2019-07-14 00:49:34
    认识函数 :在一个完整的项目,某些代码会被反复使用。那么将某段代码封装成函数,当我们要使用功能的时候直接调用函数即可 本质:函数是对功能的封装 ...参数列表:是函数的调用者给函数的的...
  • 先记住: 可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。 而关键字参数允许你传入0个或任意个含参数...归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循...
  • python中函数参数

    2015-11-23 19:42:00
    优点:灵活,当没有指定与形参对应实参时就会使用默认参数 缺陷: 例子: >>> def h(m, l=[]):#默认参数时列表,可变对象 ... l.append(m) ... print id(l) ... return l ... >>> h(1) ...
  • python中函数定义和使用

    千次阅读 2018-12-25 18:08:21
    1-函数的概念:  1-就是一段代码  2-一段操作流程  优点:  1- 代码量少-简洁  2- 维护起来方便---在函数的定义进行修改 2-函数的定义:  1-def 函数名():  函数内容  2- 函数的定义是不会执行函数内容的...
  • python中的函数简介

    2018-09-22 09:21:45
    自定义:用户自己封装的函数 函数使用 定义函数格式 def 函数名([参数列表]): 函数体 []表示可选,参数可以有,也可以没有,也可以是多个。 函数名: 与变量一样,只要遵循标识符命名规范即可。 函数调...
  • Python的函数介绍

    2020-04-16 17:02:51
    在一个完整项目,某些功能可能会反复地使用,这时我们会将这些功能封装为函数,然后当我们使用时候直接调用函数就行。 本质: 对功能封装就是函数优点: 1.简化代码结构,增加了代码重复使用程度 2....
  • python函数

    2018-04-26 19:14:00
    1.函数: 定义:函数是指将一组可执行的程序语句通过一个函数名封装起来,要想执行或者...3.python中函数的定义: 定义函数使用关键字def,后面跟函数名,函数名不能重复 1 def say(): 2 num1 = 1 3 num2...
  • python中的递归函数

    2021-04-13 22:52:24
    定义:如果在一个函数的函数体内调用了该函数本身,这个函数就称为递归函数。 组成部分:递归调用与递归终止条件 递归的调用过程:每递归调用一次函数,都会在栈内存分配一个栈帧,每执行完一次函数,都会释放相应的...
  • Python_函数

    2020-02-26 22:57:29
    文章目录Python1 认识函数2 函数的定义与调用2.1 定义2.2 调用3 函数的返回值4 函数的参数4.1 实参和形参4.2 传递多个参数 1 认识函数 为什么要使用函数? 1.避免代码重用,在一个完整的项目,某些功能会反复使用...
  • python递归函数的尾递归优化 参考:廖雪峰python教程 递归函数:函数内部调用自身来完成计算。 比如我们要计算阶乘n! = 1 x 2 x 3 x ... x n,用函数function1来表示,可采用如下写法。 def function1(n): if n==1: ...
  • Python函数

    2018-10-29 09:22:15
    函数的优点就是简化编程,我们将公共的代码逻辑声明在函数,例:要求用户从Cosole台输入用户信息的时候 input() 函数的特征:能完成某种操作 要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数ads(),...
  • Python匿名函数

    2018-10-16 20:18:19
    匿名函数的优点: 一些情况下,使用lambda可以省去定义函数的过程,使代码简洁易读。 使用lambda不需要考虑函数重名的问题。 语法 lambda [arg1 [,arg2,.....argn]]:expression lambda函数的语法只包含了一条...
  • Python中format函数用法

    千次阅读 2020-08-17 16:42:21
    Python中format函数用法 format优点 format是python2.6新增格式化字符串方法,相对于老版%格式方法,它有很多优点。 1.不需要理会数据类型问题,在%方法中%s只能替代字符串类型 2.单个参数可以多次输出...
  • python中的format函数

    2019-06-17 11:01:47
    format()是python2.6新增的一个格式化字符串的方法,功能非常强大,有可能在未来完全替代%格式化方法,相比 % ,format()的优点有: 1 .格式化时不用关心数据类型的问题,format()会自动转换,而在%方法,%s用来...
  • Python中的format函数

    2018-02-26 16:21:00
    format是python2.6新增一个格式化字符串方法,相对于老版%格式方法,它有很多优点。 1.不需要理会数据类型问题,在%方法%s只能替代字符串类型 2.单个参数可以多次输出,参数顺序可以不相同 3.填充方式...
  • Python中的高阶函数

    2020-07-10 17:11:41
    高阶函数map()函数reduce()函数filter()函数sorted() 函数zip()函数 Map、Reduce主要应用于分布式。 分布式思想:将一个连续的字符串转为列表,...python的优点:内置了map()和reduce()函数,可以直接使用。 # pyt
  • 匿名函数lambda语法:示例1(普通用法)示例2(高级用法)匿名函数的优点:参考链接: lambda 函数是一种小的匿名函数,可接受任意数量的参数,但只能有一个表达式。 语法: lambda arguments : expression 示例1(普通...
  • python函数

    2019-05-05 08:34:00
    函数的优点 使代码模块化 代码复用,减少冗余 保证了代码的一致性 python中的函数分为内置函数和自定义函数 内置函数: 如int(), str(), len(), range(), id(), max(), print()等,所有的内置函数参考 本章节来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 796
精华内容 318
关键字:

python中函数的优点

python 订阅