精华内容
下载资源
问答
  • Python 是一种解释型、交互式、面向对象的编程语言。 它包含了模块、异常、动态类型、高层级动态数据类型以及类等特性。 在面向对象编程以外它还支持多种编程范式,例如过程式和函数式编程等。 Python 结合了超强的...

    Python 是一种解释型、交互式、面向对象的编程语言。 它包含了模块、异常、动态类型、高层级动态数据类型以及类等特性。 在面向对象编程以外它还支持多种编程范式,例如过程式和函数式编程等。 Python 结合了超强的功能和极清晰的语法。 它带有许多系统调用和库以及多种窗口系统的接口,并且能用 C 或 C++ 来进行扩展。 它还可用作需要可编程接口的应用程序的扩展语言。 最后,Python 非常易于移植:它可以在包括 Linux 和 macOS 在内的许多 Unix 变种以及 Windows 上运行。

    要了解更多详情,请先查看 Python 教程。 Python 新手指南 提供了学习 Python 的其他入门教程及资源的链接。

    Python 软件基金会(Python Software Foundation,简称 PSF)是一个独立的非盈利组织,它拥有 Python 2.1 及以上各版本的版权。 PSF 的使命是推进与 Python 编程语言相关的开源技术,并推广 Python 的使用。 PSF 的主页是 https://www.python.org/psf/。

    向 PSF 提供捐助在美国是免税的。 如果你在使用 Python 并且感觉它对你很有帮助,可以通过 PSF 捐助页 进行捐助。

    你可以任意使用源码,只要你保留版权信息并在你基于 Python 的产品文档中显示该版权信息。 如果你遵守此版权规则,就可以将 Python 用于商业领域,以源码或二进制码的形式(不论是否经过修改)销售 Python 的副本,或是以某种形式包含了 Python 的产品。 当然,我们仍然希望获知所有对 Python 的商业使用。

    请参阅 PSF 许可页 以查看进一步的说明以及许可的完整文本内容的链接。

    Python 的徽标是注册商标,在某些情况下需要获得允许方可使用。 请参阅 商标使用政策 了解详情。

    以下是有关最初缘起的一份 非常 简短的摘要,由 Guido van Rossum 本人撰写:

    我在 CWI 的 ABC 部门时在实现解释型语言方面积累了丰富经验,通过与这个部门成员的协同工作,我学到了大量有关语言设计的知识。 这是许多 Python 特性的最初来源,包括使用缩进来组织语句以及包含非常高层级的数据结构(虽然在 Python 中具体的实现细节完全不同)。

    我对 ABC 语言有过许多抱怨,但同时也很喜欢它的许多特性。 没有可能通过扩展 ABC 语言(或它的实现)来弥补我的不满 —— 实际上缺乏可扩展性就是它最大的问题之一。 我也有一些使用 Modula-2+ 的经验,并曾与 Modula-3 的设计者进行交流,还阅读了 Modula-3 的报告。 Modula-3 是 Python 中异常机制所用语法和语义,以及其他一些语言特性的最初来源。

    我还曾在 CWI 的 Amoeba 分布式操作系统部门工作。 当时我们需要有一种比编写 C 程序或 Bash 脚本更好的方式来进行系统管理,因为 Amoeba 有它自己的系统调用接口,并且无法方便地通过 Bash 来访问。 我在 Amoeba 中处理错误的经验令我深刻地意识到异常处理在编程语言特性当中的重要地位。

    我发现,某种具有 ABC 式的语法而又能访问 Amoeba 系统调用的脚本语言将可满足需求。 我意识到编写一种 Amoeba 专属的语言是愚蠢的,所以我决定编写一种具有全面可扩展性的语言。

    在 1989 年的圣诞假期中,我手头的时间非常充裕,因此我决定开始尝试一下。 在接下来的一年里,虽然我仍然主要用我的业余时间来做这件事,但 Python 在 Amoeba 项目中的使用获得了很大的成功,来自同事的反馈让我得以增加了许多早期的改进。

    到 1991 年 2 月,经过一年多的开发,我决定将其发布到 USENET。 之后的事情就都可以在 Misc/HISTORY 文件里面看了。

    Python 是一种高层级的多用途编程语言,可用于解决许多不同门类的问题。

    该语言附带一个庞大的标准库,涵盖了字符串处理(正则表达式,Unicode,比较文件间的差异等),因特网协议(HTTP,FTP,SMTP,XML-RPC,POP,IMAP,CGI 编程等),软件工程(单元测试,日志记录,性能分析,Python 代码解析等),以及操作系统接口(系统调用,文件系统,TCP/IP 套接字等)。 请查看 Python 标准库 的目录以了解所有可用的内容。 此外还可以获取到各种各样的第三方扩展。 请访问 Python 包索引 来查找你感兴趣的软件包。

    Python 版本的编号形式是 A.B.C 或 A.B。 A 称为大版本号 —— 它仅在对语言特性进行非常重大改变时才会递增。 B 称为小版本号,它会在语言特性发生较小改变时递增。 C 称为微版本号 —— 它会在每次发布问题修正时递增。 请参阅 PEP 6 了解有关问题修正发布版的详情。

    发布版本并非都是问题修正版本。 在新的主要发布版本开发过程中,还会发布一系列的开发版,它们以 alpha (a), beta (b) 或 release candidate (rc) 来标示。 其中 alpha 版是早期发布的测试版,它的接口并未最终确定;在两个 alpha 发布版本间出现接口的改变并不意外。 而 beta 版更为稳定,它会保留现有的接口,但也可能增加新的模块,release candidate 版则会保持冻结状态不会再进行改变,除非有重大问题需要修正。

    以上 alpha, beta 和 release candidate 版本会附加一个后缀。 用于 alpha 版本的后缀是带有一个小数字 N 的 "aN”,beta 版本的后缀是带有一个小数字 N 的"bN”,release candidate 版本的后缀是带有一个小数字 N 的"cN”。 换句话说,所有标记为 2.0aN 的版本都早于标记为 2.0bN 的版本,后者又都早于标记为 2.0cN 的版本,而 这些版本 全都早于 2.0。

    你还可能看到带有"+”后缀的版本号,例如"2.2+”。 这表示未发布版本,直接基于 CPython 开发代码仓库构建。 在实际操作中,当一个小版本最终发布后,未发布版本号会递增到下一个小版本号,成为"a0”版本,例如"2.4a0”。

    发布版源代码是一个以 gzip 压缩的 tar 文件,其中包含完整的 C 源代码、Sphinx 格式的文档、Python 库模块、示例程序以及一些有用的自由分发软件。 该源代码将可在大多数 UNIX 类平台上直接编译并运行。

    请参阅 Python 开发者指南的初步上手部分 了解有关获取源代码并进行编译的更多信息。

    文档以 reStructuredText 格式撰写,并使用 Sphinx 文档工具 生成。 文档的 reStructuredText 源文件是 Python 源代码发布版的一部分。

    有许多可选择的教程和书籍。 标准文档中也包含有 Python 教程。

    请参阅 新手指南 以获取针对 Python 编程初学者的信息,包括教程的清单。

    有一个新闻组 comp.lang.python 和一个邮件列表 python-list。 新闻组和邮件列表是彼此互通的 —— 如果你可以阅读新闻就不必再订阅邮件列表。 comp.lang.python 的流量很大,每天会收到数以百计的发帖,Usenet 使用者通常更擅长处理这样大的流量。

    有关新软件发布和活动的公告可以在 comp.lang.python.announce 中找到,这是个严格管理的低流量列表,每天会收到五个左右的发帖。 可以在 Python 公告邮件列表 页面进行订阅。

    可以从 https://www.python.org/downloads/ 下载 alpha 和 beta 发布版。 所有发布版都会在 comp.lang.python 和 comp.lang.python.announce 新闻组以及 Python 主页 https://www.python.org/ 上进行公告;并会推送到 RSS 新闻源。

    你还可以通过 Git 访问 Python 的开发版。 请参阅 Python 开发者指南 了解详情。

    要报告错误或提交补丁,请使用安装于 https://bugs.python.org/ 上的 Roundup。

    你必须拥有一个 Roundup 账号才能报告错误;这样我们就可以在有后续问题时与你联系。 这也使得 Roundup 能在我们处理所报告的错误时向你发送更新消息。 如果你之前使用过 SourceForge 向 Python 报告错误,你可以通过 Roundup 的 密码重置操作 来获取你的 Roundup 密码。

    有关 Python 开发流程的更多信息,请参阅 Python 开发者指南。

    可能作为参考文献的最好方式还是引用你喜欢的 Python 相关书籍。

    第一篇有关 Python 的文章写于 1991 年,现在其内容已经相当过时了。

    Guido van Rossum 与 Jelke de Boer, "使用 Python 编程语言交互式地测试远程服务器", CWI 季刊, 第 4 卷, 第 4 期 (1991 年 12 月), 阿姆斯特丹, 第 283--303 页。

    是的,相关的书籍很多,还有更多即将发行。 请访问 python.org 的 wiki 页面 https://wiki.python.org/moin/PythonBooks 获取一份清单。

    你也可以到各大在线书店搜索 "Python" 并过滤掉对 Monty Python 的引用;或者也可以搜索 "Python" 加 "language"。

    Python 项目的基础架构分布于世界各地并由 Python 基础架构团队负责管理。 详情请访问 这里。

    在着手编写 Python 实现的时候,Guido van Rossum 同时还阅读了刚出版的 "Monty Python 的飞行马戏团" 剧本,这是一部自 1970 年代开始播出的 BBC 系列喜剧。 Van Rossum 觉得他需要选择一个简短、独特而又略显神秘的名字,于是他决定将这个新语言命名为 Python。

    展开全文
  • __foo表示私有属性、_foo表示受保护的属性、__foo__表示Python自带的属性2.请您简述Python编译的工作原理,PyCodeObject 和 PyFrameObject 对象的作用。Python编译的工作原理:Python语言写的程序不需要编译成二进制...

    1.__ foo 、foo_ 和 __foo__ 三者之间的区别是什么?

    __foo表示私有属性、_foo表示受保护的属性、__foo__表示Python自带的属性

    2.请您简述Python编译的工作原理,PyCodeObject 和 PyFrameObject 对象的作用。

    Python编译的工作原理:Python语言写的程序不需要编译成二进制代码,它可以直 接从源代码运行程序。当我们运行Python文件程序的时候,?Python解释器把源代码转换成中间形式:字节码,然后再由Python虚 拟机来执行这些字节码。

    PyCodeObject对象:pyc 字节码在Python虚拟机中对应的是PyCodeObject对象,虚拟机将字节封装成一个PyCodeObject对象再一条条执行字节码指令。

    PyFrameObject对象:当发生函数调用时,创建新的帧,对应Python的实现就是PyFrameObject对象。

    3.如何理解self、cls、和super?

    self是实例方法定义中的第一个参数,代表该方法的实例对象

    cls是类方法中的第一个参数,代表当前类

    super是指在Python面向对象的继承特征下中,若子类调用父类方法则需要super()实现。

    4.如何区分@classmethod和@staticmethod?

    @classmethod是类装饰器,使用装饰器方法定义类方法告知Python的解释器该方法为类方法,装饰器优化该方法的执行效率。

    @staticmethod是静态方法装饰器,使用装饰器方法定义静态方法告知Python的解释器该方法为静态方法,装饰器优化该方法的执行效率。

    5.如何理解闭包Closure(作用)?其语法规范要求?(可编写片段代码实现闭包规范)

    闭包:在一个外函数内定义了一个内函数 ,内函数运用了外函数的临时变量,并且外函数的返回值是内函数的引用,这样就形成了闭包

    闭包函数实例:

    outer为外函数、inner为内函数,a和b都是外函数的临时变量

    def outer(a):

    b=10

    def inner():

    print(a+b)

    return inner

    if __name__=="__main__":

    demo=outer(5)

    #在这里我们调用外函数传入参数5,此时外函数两个临时变量a=5,b=10并创建了内函数,然后把内函数的引用返回存给了demo,外函数结束时发现内函数将会用到自己的临时变量,这两个变量就不会释放,会绑定给内函数。

    demo()

    6.什么是迭代器Iterator ? 编写片段代码说明应用方式.

    迭代器就是用于迭代操作(for循环)的对象,它像列表一样,可以迭代获取其中的每一个元素,任何实现了next()方法的对象都可以被称为迭代器。

    对于可迭代对象(序列、range函数返回值、zip函数返回值、enumerate函数返回值等等)调用iter()函数就会返回一个迭代器,对于迭代器用iter方法就会返回迭代器自身。

    迭代器代码实例说明:

    it =iter([1,2,3,4,5])

    while True:

    try:

    x=next(it)

    except StopIteration:

    break

    #迭代器通过不断调用next方法会依次前进到序列中的下一个元素,并将其返回最后到达一系列结果的末尾时,会引发StopIteration异常

    7.说明list、tuple和dictionary之间的异同点。

    列表list支持的特性:索引、切片、连接、重复、成员操作符

    元组tuple支持的特性:索引、切片、连接、重复、成员操作符

    字典dictionary不支持这些特性

    列表list属于可变数据类型,是有序的、可迭代的(支持for循环遍历)

    元组tuple属于不可变数据类型,是有序的、可迭代的(支持for循环遍历)

    字典dictionary属于可变数据类型,是无序的、可迭代的(支持for循环遍历)

    8.如何理解生成器Generator? 在Python中有几种实现方式(可编写片段代码说明)?

    生成器本质上是一个高级迭代器,使得所需要返回的一系列元素所需的代码更加简单和高效。

    生成器有两种实现方式:

    (1).生成器函数

    生成器函数:常规函数定义中使用return返回结果,在生成器函数中使用yield关键字代替return,yield语句一次返回一个结果,在每个结果中间挂起函数的状态,以便下一次从它离开的地方执行。

    代码说明:

    def gensquares(Num):

    for i in range(Num):

    yield i**2

    for item in gensquares(5):

    print(item)

    (2).生成器表达式

    生成器表达式:和列表生成式相似,不过将"[]”改为"()”,但是生成器返回按需产生结果的一个对象,而不是一次构建一个结果列表。

    代码说明:

    squares=(i2 for i in range(2,5))

    print(type(squares))

    #使用next()方法每次返回一个结果

    next(squares)

    9.Python中的异常是什么?分为几种?多except捕获异常的规范要求都有哪些?

    异常是一个事件,该事件会在程序执行过程中发生,影响程序正常执行,在Python中程序无法正常处理时,就会抛出异常。在Python中常见的异常处理为单异常和多异常处理,在Python3中长使用try ... except ... finally处理,常见的有try ... except ...、try ... except ... except ... except ...(多except捕获)、try ... except ... else/finally.对于try ... except ... else/finally来说,else中的语句是当try语句块出现异常时不执行,当try语句块无异常时执行,如果替换为finally则是不论try语句块是否出现异常finally都会执行。

    多except捕获异常:一个try语句块可能包含多个except字句,分别用来处理不同的特定的异常,在多异常捕获时,我们常将小异常放在前面,大异常在后面,用于避免程序在处理时,异常不能分别处理,从而将所有异常归为一个异常进行处理。

    10.如何理解"鸭子模型”,其主要作用是什么?

    Python不支持多态,并且也用不到多态,多态是应用于Java和c#这一类强类型语言中,而Python推崇"鸭子类型”。

    "鸭子类型”是动态类型的一种风格,在这种风格中,一个对象有效的语义不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定。

    11.装饰器decorator的作用,编写片段代码说明。

    装饰器就是用来装饰函数的,想要增强原有函数的功能,但不希望改变现函数的定义,是一种在代码运行期间动态增加功能的方式。定义的装饰器实际上是返回函数的高阶函数。

    代码说明:

    #装饰器(无参数)

    import time

    def Timelt(ProMain):

    def program_times():

    startTime = time.time()

    ProMain()

    endTime = time.time()

    msecsTime = (endTime - startTime) * 1000

    print("程序%s运行时间:%s 毫秒" % (main.__name__,msecsTime))

    return program_times

    @Timelt #python提供的语法糖,@deco 和 main = deco(main) 是完全等价的,本质是一样的

    def main():

    print("程序运行开始...")

    time.sleep(0.5)

    print("程序运行结束...")

    if __name__=="__main__": #脚本程序入口

    main()

    补充:语法糖(Syntactic sugar),也译为糖衣语法,是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语,指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性,从而减少程序代码出错的机会。

    12.*args和**kwargs的异同点

    这两个参数为函数定义中参数列表中排名最后的参数

    *args代表该参数位置可以任意个参数,最后都会转为元组数据类型在函数体内处理

    **kwargs代表该参数位置可以放key-value格式的数据,最终都会转化为字段形式数据在函数体内处理。

    13.@property装饰器的作用,请举例说明。

    @property装饰器将方法定义为属性,后续可以使用对象.属性名的方式输出

    举例说明:

    class person():

    def __init__(self,name):

    self.__name=name

    pass

    @property #使用@property将私有实例变量变为一个属性,从而可以使用对象.属性的名称的方式进行输出。

    def name(self):

    return self.__name

    if __name__=="__main__":

    obj=person("Lee")

    print('name属性:{0}'.format(obj.name))

    14.请您简述Python如何理解对象序列化和反序列化操作?

    所谓序列化是将编程语言中的各种对象转化为字节流的过程,同时也可以逆向操作将字节流还原成一个对象,这个过程称为发序列化。

    15.Python连接数据库实现读写操作的标准流程描述。

    #导入模块

    import pymysql

    db=pymysql.connect("localhost","root","root","mysql")

    #创建游标对象

    cursor=db.cursor()

    #使用execute()方法执行SQL语句

    cursor.execute("select * from mysql")

    #使用fechone()方法获取单条数据

    data=cursor.fetchone()

    #关闭数据库

    db.close()

    16.python异常的关键字有哪些?每个代码块执行的规则是什么?

    python异常的关键字有:try,except,else,finally

    try语块执行方式:

    (1)首先执行try字句.

    (2)如果没有异常发生,忽略except子句,try子句执行后结束

    (3)如果执行try子句过程中发生异常,那么try子句余下的部分将被忽略,如果异常与except关键字后的名称相同,那么对应的except子句被执行,最后执行try语句之后的代码

    (4)如果一个异常没有与任何except匹配,那么这个异常会传递给上层的try中,对于可选子句else子句,如果使用这个子句,那么必须放在所有的except子句后,这个子句在try子句没有发生任何异常的时候执行,对于finally来说,不管前面子句是否执行,finally中的语句都会执行。

    17.pickle模块中的dumps()/loads()和dump()/load()的区别。

    pickle模块支持讲一个Python对象转化为字节流,同时还能对相应的字节流逆操作得到原来的对象

    pickle模块的常用函数:

    pickle.dump(obj.file [,protocol])对象序列化操作函数

    pickle.load(file)将file中的对象序列化读取

    pickle.dumps(obj,[,protocol]) 将对象转化为string字符串类型

    pickle.loads(string)从string中读取并反序列化还原之前的obj对象。

    展开全文
  • 4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用,而且保证每个父类函数只调用一次(如果每个类都使用super);5. 混用super类和非绑定的函数是一个危险行为,这可能导致应该调用的父类函数没有...

    1. 多Module的class继承,一定要指明父类(包.类名):

    A.py

    class A(object):

    错误的方式

    B1.py

    import A

    class B1(A):

    报错:

    AttributeError: 'module' object has no attribute 'A'

    正确的方式

    B1.py

    import A

    class B1(A.A):

    2. 两个Module的互相import尽量避免,改在需要的函数中import

    错误的方式

    A.py

    import B1

    class A(object):

    B1.py

    import A

    class B1(A):

    正确的方式

    A.py

    class A(object):

    '''

    classdocs

    '''

    data = 0

    def __init__(self, data):

    self.data = data

    '''

    Constructor

    '''

    def showA(self):

    import B1 tmp = B1.B1(3)

    print "A:" + str(self.data)

    B1.py

    import A

    class B1(A):

    3.super不是函数是类,多继承注意MRO现象。

    1. super并不是一个函数,是一个类名,形如super(B, self)事实上调用了super类的初始化函数,产生了一个super对象;2. super类的初始化函数并没有做什么特殊的操作,只是简单记录了类类型和具体实例;3. super(B, self).func的调用并不是用于调用当前类的父类的func函数;4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用,而且保证每个父类函数只调用一次(如果每个类都使用super);5. 混用super类和非绑定的函数是一个危险行为,这可能导致应该调用的父类函数没有调用或者一个父类函数被调用多次。

    4.Python中module,class,object,function都是对象。

    import A

    class B1(A):

    分享到:

    sina.jpg

    tec.jpg

    2012-05-22 13:01

    浏览 436

    评论

    展开全文
  • 简介在Python中也会有很多陷阱,在网上看到一篇文章,在此处记录以下,菜鸡翻译。问题集合类变量问题下面的代码将会输出什么? 并解释。def extend_list(value, my_list=[]):my_list.append(value)return my_list...

    简介

    在Python中也会有很多陷阱,在网上看到一篇文章,在此处记录以下,菜鸡翻译。

    问题集合

    类变量问题

    下面的代码将会输出什么? 并解释。

    def extend_list(value, my_list=[]):

    my_list.append(value)

    return my_list

    list1 = extend_list(10)

    list2 = extend_list(123, [])

    list3 = extend_list('a')

    print('list1 is: {}'.format(list1))

    print('list2 is: {}'.format(list2))

    print('list3 is: {}'.format(list3))

    答案揭晓:

    # output:

    list1 is: [10, 'a']

    list2 is: [123]

    list3 is: [10, 'a']

    许多人会误认为list1输出[10],list3将会输出['a'],以为参数my_list将会在调用extend_list函数的使用被设置为默认的值[].

    然而并非如此。在实际上发生的事情是,一个新的列表只会在函数被定义的时候创建一次。并且在extend_list函数被调用的时候,如果没有指定my_list的参数,那么它们将会使用同一个列表(也就是定义的时候初始化的那个)。

    所以上边的例子中,list1和list3操作的是同一个列表。而list2则是在它自己创建的空列表中进行操作(通过把自己的空列表作为函数的参数传递给了函数)。

    那么我们该如何修改上边的函数定义?来让它实现我们期望的功能呢?

    修改函数定义如下:

    def extend_list(value, my_list=None):

    if my_list is None:

    my_list = []

    my_list.append(value)

    return my_list

    就是说如果在没有指定my_list参数的值时,我们重新创建一个空列表。

    输出如下:

    list1 is: [10]

    list2 is: [123]

    list3 is: ['a']

    Tips:我在Pycharm中写这样的代码时, 还有一个警告信息,信息的内容大致就是上边我们所说的会出现的这种问题。神奇!!

    late binding(后期绑定)的问题

    下面的代码会输出什么? 请解释。

    def multipliers():

    return [lambda x: i * x for i in range(4)]

    print([m(2) for m in multipliers()])

    答案揭晓:

    # output:

    [6, 6, 6, 6]

    是不是有点慌?程序的输出不是我们期待的[0, 2, 4, 6]而是[6, 6, 6, 6]。

    这个原因主要是Python闭包的后期绑定late binding造成的。这就意味着在闭包中变量的值是在内部函数被调用的时候才去寻找的。

    所以造成的结果就是,在任何时候由multiplers()函数返回的函数集合被调用,变量i的值才会在那个时候去从它被调用时的作用域中查找。

    在那时,不管在被返回的函数集合中的哪个函数被调用,for循环是已经完成的,而变量i已经被指定为了最终的值3。因此,被返回的函数集合中的每个函数中的i都是3,

    所以在参数2被传递进入函数中,函数执行的操作其实是2*3,也就是6。

    顺便说一点,就像The Hitchhiker’s Guide to Python指出的那样,人们存在一个误解,以为这种问题是由lambda函数造成的,其实不然,由lambda关键字创建的函数和由def关键字创建的函数是没什么不一样的。

    下面我们给出一些解决这种问题的方法。

    1.使用Python的生成器

    def multipliers():

    for i in range(4):

    yield lambda x: i * x

    2.创建一个闭包,通过使用默认参数立即绑定到它的参数上。

    def multipliers():

    return [lambda x, i=i: i * x for i in range(4)]

    3.使用funtiontoos模块中的partial进行改写。

    from functools import partial

    from operator import mul

    def multipliers():

    return [partial(mul, i) for i in range(4)]

    4.在其他资料上我也发现了另外一种方法。

    def multipliers():

    return (lambda x: i * x for i in range(4))

    类变量的问题

    下面的代码会输出什么?请解释。

    class Parent(object):

    x = 1

    class ChildFirst(Parent):

    pass

    class ChildSecond(Parent):

    pass

    print(Parent.x, ChildFirst.x, ChildSecond.x)

    ChildFirst.x = 2

    print(Parent.x, ChildFirst.x, ChildSecond.x)

    Parent.x = 3

    print(Parent.x, ChildFirst.x, ChildSecond.x)

    答案揭晓:

    1 1 1

    1 2 1

    3 2 3

    WTF? 为什么最后一行输出不是3 2 1而是3 2 3? 为什么改变了Parent.x的值竟然也改变了ChildSecond.x的值。但是却没有改变ChildFirst.x的值?

    这个问题的答案的关键是: 在Python中,类变量在内部是作为字典来处理的。

    如果一个变量名没有在当前类的变量字典中找到,就会去搜索父类的变量字典,如果在一直延续到在顶层的祖先类的字典中也没有找到该变量。就会报出一个AttributeError的异常。

    因此,在Parent中设置了类变量x=1,在该类和其任何子类的的变量引用中生效x=1.这就是为什么第一行输出1 1 1。

    然后,如果某一个子类重写了这个变量,就像我们执行了ChildFirst.x=2,这个值会仅仅在这个子类中发生变化。这就是为什么第二行输出1 2 1。

    最后,如果在父类Parent中改变。就会使得所有没有重写这个变量的子类中的该变量的值发生变化。就是最后一行输出3 2 3的原因。

    除法操作的问题

    下面的代码在Python2环境下输出是什么? 请解释.

    def div1(x, y):

    print "{}/{}={}".format(x, y, x/y)

    def div2(x, y):

    print "{}/{}={}".format(x, y, x//y)

    div1(5,2)

    div1(5.,2)

    div2(5,2)

    div2(5.,2.)

    答案揭晓:

    5/2 = 2

    5.0/2 = 2.5

    5//2 = 2

    5.0//2.0 = 2.0

    默认情况下,如果两个操作数都是整数,Python2就会自动执行整型计算,

    所以结果是5/2=2, 然后5./2=2.5.

    注意,你可以在Python中重载这个方法达到在Python3中输出的结果,通过以下方式

    from __future__ import division

    此时输出:

    5/2 = 2.5

    5.0/2 = 2.5

    5//2 = 2

    5.0//2.0 = 2.0

    并且注意 双斜线//操作符一直执行整型运算,所以在Python2中输出5.0//2.0 = 2.0。

    在Python3中输出是和上边引入division的输出是一致的。

    注意,在Python3中/操作符是做浮点除法,而//是做整除(保留商,余数舍弃),有意思的是: Python3中(-7) // 3 = -3因为它的整型运算是向更小的数值取值(即向下取整)。例7 // 2 = 2。

    列表的问题1

    下面代码会输出什么?

    my_list = ["a", "b", "c", "d", "3"]

    print(my_list[10:])

    答案揭晓:

    # output:

    []

    上边的代码会输出[],而不是一个IndexError的异常。

    正如人们所预料的, 试图使用超过成员数量的索引访问列表的成员(eg..my_list[10])会报出IndexError异常。

    但是试图以一个超出列表成员数量的索引作为开始索引的切片操作不会导致下标异常,仅仅是返回一个空列表。

    一个特别严重的问题是,它可能导致的错误,但是很难追踪到,因为它并没有出现运行错误。

    列表的问题2

    思考下面的代码片段:

    1. list = [ [ ] ] * 5

    2. list # output?

    3. list[0].append(10)

    4. list # output?

    5. list[1].append(20)

    6. list # output?

    7. list.append(30)

    8. list # output?

    答案揭晓:

    [[], [], [], [], []]

    [[10], [10], [10], [10], [10]]

    [[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]]

    [[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30]

    第一行的输出是直观的,也很容易理解,仅仅是创建了5个列表的列表。

    但是,理解问题的关键是list = [ [ ] ] * 5并不是创建了5个不同的列表,而是对一个列表的5个引用,有了这层理解我们对下面的输出就好理解了。

    list[0].append(10)在第一个列表中添加了元素10, 其他列表都是对同一个列表的引用,所以输出如上。

    同样的道理,第二个列表添加了元素20,也是对同一个列表进行的操作。

    相反,list.append(30)则是添加了一个元素到外层列表中,也就是说, 30是和剩下的5个列表同一层级的(个人理解)。所以输出如上。

    列表的问题3

    给定n个数的列表,使用单列表理解来生成只包含如下这些值的新列表。

    偶数

    索引也是偶数

    我们可以采用如下代码完成这个工作:

    [x for x in my_list[::2] if x % 2 == 0]

    示例:

    my_list = [ 1 , 3 , 5 , 8 , 10 , 13 , 18 , 36 , 78 ]

    new_list = [x for x in my_list[::2] if x % 2 == 0]

    #output:

    [10, 18, 78]

    参考文章

    展开全文
  • 这篇文章收集了我在Python新手开发者写的代码中所见到的不规范但偶尔又很微妙的问题。本文的目的是为了帮助那些新手开发者渡过写出丑陋的Python代码的阶段。为了照顾目标读者,本文做了一些简化(例如:在讨论迭代器...
  • Python编程语言是一种广为应用的计算机语言,但是还是有很多人堆Python编程语言的相关知识不是很了解,以下的文章主要是介绍Python编程语言如何解决一些实际问题,下面是文章的主要描述。Python编程语言解决一些实际...
  • 汉诺塔(汉诺塔)用递归函数实现汉诺塔(A、B、C柱,要将圆盘从A柱移到C柱,且排列顺序不变)思想:不管A柱有多少个圆盘(假设n个),我们可以将看成将上面的(n-1)个圆盘看成一个整体,那么问题就变得非常简单:1)...
  • 这篇文章收集了我在Python新手开发者写的代码中所见到的不规范但偶尔又很微妙的问题。本文的目的是为了帮助那些新手开发者渡过写出丑陋的Python代码的阶段。为了照顾目标读者,本文做了一些简化(例如:在讨论迭代器...
  • 注意:很多人学Python过程中会遇到各种烦恼问题,没有人帮答疑。为此小编建了个Python全栈免费答疑交流.裙 :一久武其而而流一思(数字的谐音)转换下可以找到了,不懂的问题有老司机解决里面还有最新Python教程项目...
  • 当需要排序的时候,尽量设法使用内建 Python 列表的 sort 方法; 当需要搜索的时候,尽量设法使用内建的字典 ___________________________ 一直更新中..... 转载于:...
  • python语言常见问题

    2019-05-31 11:56:09
    最近整理了一些python语言常见一些问题,欢迎大家来补充!
  • Python环境常见问题解决方案

    千次阅读 2019-02-20 23:34:07
    如下列举了python使用过程中环境配置容易出现的一些问题,供小伙伴们参考: 1、pip版本升级 在安装一些依赖包时,会提示pip版本太低,需要升级 You are using pip version 19.0.3, however version 19.1 is ...
  • Python一些常见问题的解决

    千次阅读 2015-07-20 09:41:38
    Ubuntu下查看python版本号 /usr/bin/python Non-ASCII character ‘\xe6’ 源代码文件第一行添加:#coding:utf-8 name ‘urllib’ is not defined 在源码文件中添加:import urllib
  • python一些基本问题

    2019-11-16 19:49:00
    python 常见问题 1.用法查询 2. 常见类型报错 3.变量的数据类型 4.易错题
  • 安装python常见问题

    2020-03-26 10:50:42
    有时安装一些包时,会存在包太大,一时下载不下来,使用pip安装时会报错,网络超时,此处就以bayes-opt安装为例 bayes-opt 1、命令行安装 pip install bayesian-optimization 2、找到bayesian-optimization 0.6.0包...
  • Python编程常见问题与解答

    千次阅读 2019-02-18 16:43:09
    1.问:Python代码运行速度和C语言相比,哪个更快?...2.问:学习Python编程,用哪个开发环境更好一些呢? 答:目前来看,Anaconda3和PyCharm用的相对来说多一些。 3.问:在哪里执行pip命令安装Python扩展库?...
  • 1、python2中文的解决办法 #-*- coding:utf-8 -*- 2、python2与python3中的输入区别 python2中从键盘获取输入函数为raw_input() python3中从键盘获取输入函数为input() 获取数据当作字符串类型,根据特定需要...
  • 1.问:Python代码运行速度和C语言相比,哪个更...2.问:学习Python编程,用哪个开发环境更好一些呢?答:目前来看,Anaconda3和PyCharm用的相对来说多一些。3.问:在哪里执行pip命令安装Python扩展库?为什么在IDLE...
  • 好程序员Python教程分享Python常见面试问题,人工智能的火热进一步带动了求职...为此,好程序员整理了一些常见面试中涉及的Python编程语言的有关问题,希望对学员的面试有所帮助!  1.什么是Python?使用Python的...
  • Python 常见问题汇总

    多人点赞 2021-04-26 21:01:38
    在使用python过程中,遇到一些常见问题,整理汇总如下: 1、常见错误列表 异常 描述 NameError 尝试访问一个没有声明的变量 ZeroDivisionError 除数为0 SyntaxError 语法错误 IndexError 索引超出序列范围 Key...
  • 中作者对Python新手编程过程中如何规避一些常见问题给出了建议,主要着眼于初学者对于一些常用函数方法在平时的使用习惯中的问题给出建议,需要的朋友可以参考下
  • 在学习Python+Django的过程中,遇到的问题以及解决方法,会持续更新!
  • 初学Python,遇到很多问题:其中包括资料查找,软件的安装等等,以后会尽量坚持下来每天写一篇博客,因为我觉得有些东西你用一种形式记下来,是最好的,及时你当时认为很清楚,可是过了一段时间,你还是会忘,所以...
  • python 常见问题

    2014-02-25 15:54:35
    字典是python中很常见的一种类型。我们在很多地方都会用到。 在一些情况下,我们有时需要自己定义key的类型。这时为了满足需求,我们可能需要修改__hash__和(__eq__或__cmp__)函数。此时注意这两种函数在 字典的...
  • python queue常见问题(转)

    千次阅读 2019-03-05 11:40:25
    python 中,队列是线程间最常用的交换数据的形式。queue模块是提供队列操作的模块,虽然简单易用,但是不小心的话,还是会出现一些意外。 1. 阻塞模式 import queue q =queue.Queue(10) #创建一个队列 ...... ...
  • python3将raw_input和input进行了整合,只有input.所以您如果使用 这里的2.0文档在3.9版本上跑,请务必注意转化. 转化如下:用input替换 raw_input,并且把形如print "你输入的内容是: ", str 的加个 括号print( "你...
  • python常见问题

    2018-09-22 23:36:27
    问题1 到底什么是Python?你可以在回答中与其他技术进行对比。 答案 下面是一些关键点: Python是一种解释型语言。这就是说,与C语言和C的衍生语言不同,Python代码在运行之前不需要编译。其他解释型语言还...
  • 刷bugku的web时需要用python写脚本,web方面需要安装对应的模块,下面就分享一下我在安装模块时碰到的一些问题以及解决方法 首先找到pip文件所在的位置 打开cmd,cd文件位置,打开文件夹。 输入pip install ...
  • centos下 python3无法...ascii’ codec can’t encode characters in position 0-10: ordinal not in range(128这类问题多来源于python控制台的编码问题,进入python环境>>> import sys>>> sys.stdout.encoding'...

空空如也

空空如也

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

python一些常见问题

python 订阅