精华内容
下载资源
问答
  • 学习python最好的地方应该就是python官方提供的doc:https://docs.python.org,作为初学者就从Tutorial开始了,读了一会英文有些累,就找到了中文Python3的入门指导。 python解释器的使用: 在iTerm2窗口直接输入...

    学习python最好的地方应该就是python官方提供的doc: https://docs.python.org,作为初学者就从Tutorial开始了,读了一会英文有些累,就找到了中文Python3的入门指导。

    python解释器的使用:

    在iTerm2窗口直接输入python然后按tab键,就列出了本机python相关的命令

    $ python
    python             python2.7-config   python3.6-32       pythonw2.6
    python-config      python3            python3.6-config   pythonw2.7
    python2.6          python3-32         python3.6m
    python2.6-config   python3-config     python3.6m-config
    python2.7          python3.6          pythonw

    使用which + pythonXXX就显示出python的安装位置了

    $ which python2.7
    /usr/bin/python2.7
    which python3
    /Library/Frameworks/Python.framework/Versions/3.6/bin/python3

     

    直接输入pythonXXX就进入了对应版本的python解释器

    $ python3
    Python 3.6.4 (v3.6.4:d48ecebad5, Dec 18 2017, 21:07:28)
    [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>>

    退出python解释器的方法:quit() exit() 

    $ python2.6
    Python 2.6.9 (unknown, Oct 23 2015, 19:19:20)
    [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> exit
    Use exit() or Ctrl-D (i.e. EOF) to exit
    >>> exit()
    
    $ python2.7
    Python 2.7.10 (default, Oct 23 2015, 19:19:21)
    [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> quit
    Use quit() or Ctrl-D (i.e. EOF) to exit
    >>> ^D

    默认情况下,Python3 源文件是 UTF-8 编码。可以为源文件指定不同的字符编码:

    # -*- coding: encoding -*-

    例如:

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

    在 Unix 系统上,Python 3.X 解释器默认未被安装成名为 python 的命令,所以它不会与同时安装在系统中的 Python 2.x 命令冲突。在进入解释器的时候就可以指定使用的python版本:$python3   $python2.6

    对于多行命令,在编写完成后,多输入一个空行,解释器才知道是命令的结束,例如:

    >>> username="OldStone"
    >>> person = username
    >>> person1 = "GoldStone"
    >>> if person == person1:
    ...     print("Person is person1")
    ... elif person == username:
    ...     print("Hello OldStone")
    ...#这里输入空行后才知道上边片段结束
    Hello OldStone

     

    今天就到这里,明天学习python作为计算器。

     

     

     

     

    转载于:https://www.cnblogs.com/goldstone666/p/8620642.html

    展开全文
  • Python 3 解释器

    2021-03-26 10:05:25
    Linux/Unix 系统上,Python 解释器通常被安装在/usr/local/python3这样有效路径(目录)里。 我们可以将路径/usr/local/python3/bin添加到您 Linux/Unix 操作系统环境变量中(最好参照您 Python 安装路径...

    Linux/Unix 的系统上,Python 解释器通常被安装在 /usr/local/python3 这样的有效路径(目录)里。

    我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中(最好参照您 Python 的安装路径进行添加),这样您就可以通过 shell 终端输入下面的命令来启动 Python 。

    $ PATH=$PATH:/user/local/python3/bin/python #设置环境变量
    $ python3 --vesion
    Python 3.7.6

    在 Window 系统下你可以通过以下命令来设置 Python 的环境变量,假设你的 Python 安装在 C:\Python37 下:

    set path=%path%;C:\python37
    

    交互式编程

    打开 IDLE,默认的就是交互式编程,类似于一个 cmd 窗口。

    我们可以在命令提示符中输入 "Python" 命令来启动 Python 解释器:

    $ python3
    

    执行以上命令后,出现如下窗口信息:

    $ python3
    Python 3.4。0 (default, Mar 16 2014, 09:25:04)
    [GCC 4.8.2] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>>
    

    在 Python 提示符中输入以下语句,然后按回车键查看运行效果:

    print ("Welcome to W3Cschool!");
    

    以上命令执行结果如下:

     

    当键入一个多行结构时,续行是必须的。我们可以看下如下 if 语句:

    >>> the_world_is_flat = True
    >>> if the_world_is_flat:
    ...     print("Be careful not to fall off!")
    ...
    Be careful not to fall off!
    

    脚本式编程

    点击 File→New 后新建脚本文件,在此文件下进行的是脚本式编程。

    将如下代码拷贝至 W3C.py 文件中:

    print ("Welcome to W3Cschool!");
    

    通过以下命令执行该脚本:

    python W3C.py
    

    输出结果为:

    Welcome to W3Cschool!

    在 Linux/Unix 系统中,你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直接执行:

    #! /usr/bin/env python3.7
    

    然后修改脚本权限,使其有执行权限,命令如下:

    $ chmod +x W3C.py
    

    执行以下命令:

    ./hello.py
    

    输出结果为:

    Welcome to W3Cschool!
    展开全文
  • 这种用C语言实现的解释器成为Cpython,他是python领域性能最好,应用最广泛的一款解释器!!! # Jython:JPython解释器使用JAVA编写的python解释器 # IPython:IPython是基于CPython之上的一个交互式解释器 # PyPy...

    python解释器

    一、python解释器的种类

    官方的python解释器本质就是基于C语言开发的一个软件,该软件的功能就是读取以,py结尾的文件内容,然后按照Guido定义好的语法和规则去翻译并执行乡音的代码。这种用C语言实现的解释器成为Cpython,他是python领域性能最好,应用最广泛的一款解释器!!!
    # Jython:JPython解释器使用JAVA编写的python解释器
    # IPython:IPython是基于CPython之上的一个交互式解释器
    # PyPy:PyPy是Python开发者用Pyhton语言实现的Pyhton解释器
    # IronPython:和JPython类似,运行在微软.Net平台上的Python解释器
    

    二、安装python解释器

    2.1下载

    在Pyhton官网(https://www.python.org/)下载解释器:
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    2.2安装

    按照提示下一步~

    2.3测试

    windows键+R
    输入cmd,回车
    弹出cmd程序,输入python,进入交互式环境
    安装成功
    

    3、运行Python程序的两种方式

    3.1交互式

    3.2脚本的方式

    打开一个文本编辑工具,写下代码保存文件。
    # Python解释器执行程序是解释执行,解释的根本就是打开文件读内容,因此文件的后缀名没有硬性限制,但通常定义为,py结尾!!!
    打开cmd,运行命令
    

    4、注释

    4.1什么是注释?

    注释就是对代码的解释说明,注释的内容不会被当作代码运行
    

    4.2为什么要注释?

    增强代码的可读性!!
    

    4.3怎么用注释?

    # 代码注释分单行和多行注释
    1、单行注释用 ' # ' ,可以跟在代码的正上方或者正后方
    2、多行注释可以用三对双引号或者单引号
    
    展开全文
  • 作为一名教python的老师,我发现学生们基本上一开始很难搞定python的装饰,也许因为装饰确实很难懂。搞定装饰需要你了解一些函数式编程概念,当然还有理解在python中定义和调用函数相关语法一些特点。 我...

    转载:http://python.jobbole.com/81683/

    呵呵!作为一名教python的老师,我发现学生们基本上一开始很难搞定python的装饰器,也许因为装饰器确实很难懂。搞定装饰器需要你了解一些函数式编程的概念,当然还有理解在python中定义和调用函数相关语法的一些特点。

    我没法让装饰器变得简单,但是通过一步步的剖析,我也许能够让你在理解装饰器的时候更自信一点。因为装饰器很复杂,这篇文章将会很长(自己都说很长,还敢这么多废话blablabla前戏就不继续翻译直接省略了)

    1. 函数

    在python中,函数通过def关键字、函数名和可选的参数列表定义。通过return关键字返回值。我们举例来说明如何定义和调用一个简单的函数:

    def foo():
         return 1
    foo()
    1

    方法体(当然多行也是一样的)是必须的,通过缩进来表示,在方法名的后面加上双括号()就能够调用函数

    2. 作用域

    在python中,函数会创建一个新的作用域。python开发者可能会说函数有自己的命名空间,差不多一个意思。这意味着在函数内部碰到一个变量的时候函数会优先在自己的命名空间里面去寻找。让我们写一个简单的函数看一下 本地作用域 和 全局作用域有什么不同:

    1 a_string = "This is a global variable"
    2 def foo():
    3      print locals()
    4 print globals() # doctest: +ELLIPSIS
    5 {, 'a_string': 'This is a global variable'}
    6 foo() # 2
    7 {}

    内置的函数globals返回一个包含所有python解释器知道的变量名称的字典(为了干净和洗的白白的,我省略了python自行创建的一些变量)。在#2我调用了函数 foo 把函数内部本地作用域里面的内容打印出来。我们能够看到,函数foo有自己独立的命名空间,虽然暂时命名空间里面什么都还没有。

    3. 变量解析规则

    当然这并不是说我们在函数里面就不能访问外面的全局变量。在python的作用域规则里面,创建变量一定会一定会在当前作用域里创建一个变量,但是访问或者修改变量时会先在当前作用域查找变量,没有找到匹配变量的话会依次向上在闭合的作用域里面进行查看找。所以如果我们修改函数foo的实现让它打印全局的作用域里的变量也是可以的:

     
    1 a_string = "This is a global variable"
    2 def foo():
    3      print a_string # 1
    4 foo()
    5 This is a global variable

    在#1处,python解释器会尝试查找变量a_string,当然在函数的本地作用域里面是找不到的,所以接着会去上层的作用域里面去查找。
    但是另一方面,假如我们在函数内部给全局变量赋值,结果却和我们想的不一样:

    a_string = "This is a global variable"
    def foo():
    a_string = "test" # 1
    print locals()
    foo()
    {'a_string': 'test'}
    a_string # 2
    'This is a global variable'

    我们能够看到,全局变量能够被访问到(如果是可变数据类型(像list,dict这些)甚至能够被更改)但是赋值不行。在函数内部的#1处,我们实际上新创建了一个局部变量,隐藏全局作用域中的同名变量。我们可以通过打印出局部命名空间中的内容得出这个结论。我们也能看到在#2处打印出来的变量a_string的值并没有改变。

    4. 变量生存周期

    值得注意的一个点是,变量不仅是生存在一个个的命名空间内,他们都有自己的生存周期,请看下面这个例子:

    def foo():
    x = 1
    foo()
    print x # 1
    Traceback (most recent call last):

    NameError: name 'x' is not defined

    #1处发生的错误不仅仅是因为作用域规则导致的(尽管这是抛出了NameError的错误的原因)它还和python以及其它很多编程语言中函数调用实现的机制有关。在这个地方这个执行时间点并没有什么有效的语法让我们能够获取变量x的值,因为它这个时候压根不存在!函数foo的命名空间随着函数调用开始而开始,结束而销毁。

    5. 函数参数

    python允许我们向函数传递参数,参数会变成本地变量存在于函数内部

     
    1 def foo(x):
    2      print locals()
    3 foo(1)
    4 {'x': 1}

    在Python里有很多的方式来定义和传递参数,完整版可以查看 python官方文档。我们这里简略的说明一下:函数的参数可以是必须的位置参数或者是可选的命名,默认参数。

    def foo(x, y=0): # 1
    return x - y
    foo(3, 1) # 2
    2
    foo(3) # 3
    3
    foo() # 4
    Traceback (most recent call last):

    TypeError: foo() takes at least 1 argument (0 given)
    foo(y=1, x=3) # 5
    2

    在#1处我们定义了函数foo,它有一个位置参数x和一个命名参数y。在#2处我们能够通过常规的方式来调用函数,尽管有一个命名参数,但参数依然可以通过位置传递给函数。在调用函数的时候,对于命名参数y我们也可以完全不管就像#3处所示的一样。如果命名参数没有接收到任何值的话,python会自动使用声明的默认值也就是0。需要注意的是我们不能省略第一个位置参数x, 否则的话就会像#5处所示发生错误。

    目前还算简洁清晰吧, 但是接下来可能会有点令人困惑。python支持函数调用时的命名参数(个人觉得应该是命名实参)。看看#5处的函数调用,我们传递的是两个命名实参,这个时候因为有名称标识,参数传递的顺序也就不用在意了。

    当然相反的情况也是正确的:函数的第二个形参是y,但是我们通过位置的方式传递值给它。在#2处的函数调用foo(3,1),我们把3传递给了第一个参数,把1传递给了第二个参数,尽管第二个参数是一个命名参数。

    桑不起,感觉用了好大一段才说清楚这么一个简单的概念:函数的参数可以有名称和位置。这意味着在函数的定义和调用的时候会稍稍在理解上有点儿不同。我们可以给只定义了位置参数的函数传递命名参数(实参),反之亦然!如果觉得不够可以查看官方文档

    6. 嵌套函数

    Python允许创建嵌套函数。这意味着我们可以在函数里面定义函数而且现有的作用域和变量生存周期依旧适用。

    def outer():
    x = 1
    def inner():
    print x # 1
    inner() # 2

    outer()
    1

    这个例子有一点儿复杂,但是看起来也还行。想一想在#1发生了什么:python解释器需找一个叫x的本地变量,查找失败之后会继续在上层的作用域里面寻找,这个上层的作用域定义在另外一个函数里面。对函数outer来说,变量x是一个本地变量,但是如先前提到的一样,函数inner可以访问封闭的作用域(至少可以读和修改)。在#2处,我们调用函数inner,非常重要的一点是,inner也仅仅是一个遵循python变量解析规则的变量名,python解释器会优先在outer的作用域里面对变量名inner查找匹配的变量.

    7. 函数是python世界里的一级类对象

    显而易见,在python里函数和其他东西一样都是对象。(此处应该大声歌唱)啊!包含变量的函数,你也并不是那么特殊!

    issubclass(int, object) # all objects in Python inherit from a common baseclass
    True
    def foo():
    pass
    foo.__class__ # 1
    <type 'function'>
    issubclass(foo.__class__, object)
    True

    你也许从没有想过,你定义的函数居然会有属性。没办法,函数在python里面就是对象,和其他的东西一样,也许这样描述会太学院派太官方了点:在python里,函数只是一些普通的值而已和其他的值一毛一样。这就是说你尅一把函数想参数一样传递给其他的函数或者说从函数了里面返回函数!如果你从来没有这么想过,那看看下面这个例子:

    def add(x, y):
    return x + y
    def sub(x, y):
    return x - y
    def apply(func, x, y): # 1
    return func(x, y) # 2
    apply(add, 2, 1) # 3
    3
    apply(sub, 2, 1)
    1

    这个例子对你来说应该不会很奇怪。add和sub是非常普通的两个python函数,接受两个值,返回一个计算后的结果值。在#1处你们能看到准备接收一个函数的变量只是一个普通的变量而已,和其他变量一样。在#2处我们调用传进来的函数:“()代表着调用的操作并且调用变量包含的值。在#3处,你们也能看到传递函数并没有什么特殊的语法。” 函数的名称只是很其他变量一样的表标识符而已。

    你们也许看到过这样的行为:“python把频繁要用的操作变成函数作为参数进行使用,像通过传递一个函数给内置排序函数的key参数从而来自定义排序规则。那把函数当做返回值回事这样的情况呢:

    def outer():
    def inner():
    print "Inside inner"
    return inner # 1

    foo = outer() #2
    foo # doctest:+ELLIPSIS
    <function inner at 0x>
    foo()
    Inside inner

    这个例子看起来也许会更加的奇怪。在#1处我把恰好是函数标识符的变量inner作为返回值返回出来。这并没有什么特殊的语法:”把函数inner返回出来,否则它根本不可能会被调用到。“还记得变量的生存周期吗?每次函数outer被调用的时候,函数inner都会被重新定义,如果它不被当做变量返回的话,每次执行过后它将不复存在。

    在#2处我们捕获住返回值 – 函数inner,将它存在一个新的变量foo里。我们能够看到,当对变量foo进行求值,它确实包含函数inner,而且我们能够对他进行调用。初次看起来可能会觉得有点奇怪,但是理解起来并不困难是吧。坚持住,因为奇怪的转折马上就要来了(嘿嘿嘿嘿,我笑的并不猥琐!)

    8. 闭包

    我们先不急着定义什么是闭包,先来看看一段代码,仅仅是把上一个例子简单的调整了一下:

    def outer():
    x = 1
    def inner():
    print x # 1
    return inner
    foo = outer()
    foo.func_closure # doctest: +ELLIPSIS
    (<cell at 0x: int object at 0x>,)

    在上一个例子中我们了解到,inner作为一个函数被outer返回,保存在一个变量foo,并且我们能够对它进行调用foo()。不过它会正常的运行吗?我们先来看看作用域规则。

    所有的东西都在python的作用域规则下进行工作:“x是函数outer里的一个局部变量。当函数inner在#1处打印x的时候,python解释器会在inner内部查找相应的变量,当然会找不到,所以接着会到封闭作用域里面查找,并且会找到匹配。

    但是从变量的生存周期来看,该怎么理解呢?我们的变量x是函数outer的一个本地变量,这意味着只有当函数outer正在运行的时候才会存在。根据我们已知的python运行模式,我们没法在函数outer返回之后继续调用函数inner,在函数inner被调用的时候,变量x早已不复存在,可能会发生一个运行时错误。

    万万没想到,返回的函数inner居然能够正常工作。Python支持一个叫做函数闭包的特性,用人话来讲就是,嵌套定义在非全局作用域里面的函数能够记住它在被定义的时候它所处的封闭命名空间。这能够通过查看函数的func_closure属性得出结论,这个属性里面包含封闭作用域里面的值(只会包含被捕捉到的值,比如x,如果在outer里面还定义了其他的值,封闭作用域里面是不会有的)

    记住,每次函数outer被调用的时候,函数inner都会被重新定义。现在变量x的值不会变化,所以每次返回的函数inner会是同样的逻辑,假如我们稍微改动一下呢?

    def outer(x):
    def inner():
    print x # 1
    return inner
    print1 = outer(1)
    print2 = outer(2)
    print1()
    1
    print2()
    2

    从这个例子中你能够看到闭包 – 被函数记住的封闭作用域 – 能够被用来创建自定义的函数,本质上来说是一个硬编码的参数。事实上我们并不是传递参数1或者2给函数inner,我们实际上是创建了能够打印各种数字的各种自定义版本。

    闭包单独拿出来就是一个非常强大的功能, 在某些方面,你也许会把它当做一个类似于面向对象的技术:outer像是给inner服务的构造器,x像一个私有变量。使用闭包的方式也有很多:你如果熟悉python内置排序方法的参数key,你说不定已经写过一个lambda方法在排序一个列表的列表的时候基于第二个元素而不是第一个。现在你说不定也可以写一个itemgetter方法,接收一个索引值来返回一个完美的函数,传递给排序函数的参数key。

    不过,我们现在不会用闭包做这么low的事(⊙o⊙)…!相反,让我们再爽一次,写一个高大上的装饰器!

     

    9. 装饰器

    装饰器其实就是一个闭包,把一个函数当做参数然后返回一个替代版函数。我们一步步从简到繁来瞅瞅:

    def outer(some_func):
    def inner():
    print "before some_func"
    ret = some_func() # 1
    return ret + 1
    return inner
    def foo():
    return 1
    decorated = outer(foo) # 2
    decorated()
    before some_func
    2

    仔细看看上面这个装饰器的例子。们定义了一个函数outer,它只有一个some_func的参数,在他里面我们定义了一个嵌套的函数inner。inner会打印一串字符串,然后调用some_func,在#1处得到它的返回值。在outer每次调用的时候some_func的值可能会不一样,但是不管some_func的之如何,我们都会调用它。最后,inner返回some_func() + 1的值 – 我们通过调用在#2处存储在变量decorated里面的函数能够看到被打印出来的字符串以及返回值2,而不是期望中调用函数foo得到的返回值1。

    我们可以认为变量decorated是函数foo的一个装饰版本,一个加强版本。事实上如果打算写一个有用的装饰器的话,我们可能会想愿意用装饰版本完全取代原先的函数foo,这样我们总是会得到我们的”加强版“foo。想要达到这个效果,完全不需要学习新的语法,简单地赋值给变量foo就行了:

     
    1 foo = outer(foo)
    2 foo # doctest: +ELLIPSIS
    3 <function inner at 0x>

    现在,任何怎么调用都不会牵扯到原先的函数foo,都会得到新的装饰版本的foo,现在我们还是来写一个有用的装饰器。

    想象我们有一个库,这个库能够提供类似坐标的对象,也许它们仅仅是一些x和y的坐标对。不过可惜的是这些坐标对象不支持数学运算符,而且我们也不能对源代码进行修改,因此也就不能直接加入运算符的支持。我们将会做一系列的数学运算,所以我们想要能够对两个坐标对象进行合适加减运算的函数,这些方法很容易就能写出:

    class Coordinate(object):
    def __init__(self, x, y):
    self.x = x
    self.y = y
    def __repr__(self):
    return "Coord: " + str(self.__dict__)
    def add(a, b):
    return Coordinate(a.x + b.x, a.y + b.y)
    def sub(a, b):
    return Coordinate(a.x - b.x, a.y - b.y)
    one = Coordinate(100, 200)
    two = Coordinate(300, 200)
    add(one, two)
    Coord: {'y': 400, 'x': 400}

    如果不巧我们的加减函数同时也需要一些边界检查的行为那该怎么办呢?搞不好你只能够对正的坐标对象进行加减操作,任何返回的值也都应该是正的坐标。所以现在的期望是这样:

    one = Coordinate(100, 200)
    two = Coordinate(300, 200)
    three = Coordinate(-100, -100)
    sub(one, two)
    Coord: {'y': 0, 'x': -200}
    add(one, three)
    Coord: {'y': 100, 'x': 0}

    我们期望在不更改坐标对象one, two, three的前提下one减去two的值是{x: 0, y: 0},one加上three的值是{x: 100, y: 200}。与其给每个方法都加上参数和返回值边界检查的逻辑,我们来写一个边界检查的装饰器!

    def wrapper(func):
    def checker(a, b): # 1
    if a.x < 0 or a.y < 0:
    a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
    if b.x < 0 or b.y < 0:
    b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
    ret = func(a, b)
    if ret.x < 0 or ret.y < 0:
    ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
    return ret
    return checker
    add = wrapper(add)
    sub = wrapper(sub)
    sub(one, two)
    Coord: {'y': 0, 'x': 0}
    add(one, three)
    Coord: {'y': 200, 'x': 100}

    这个装饰器能想先前的装饰器例子一样进行工作,返回一个经过修改的函数,但是在这个例子中,它能够对函数的输入参数和返回值做一些非常有用的检查和格式化工作,将负值的x和 y替换成0。

    显而易见,通过这样的方式,我们的代码变得更加简洁:将边界检查的逻辑隔离到单独的方法中,然后通过装饰器包装的方式应用到我们需要进行检查的地方。另外一种方式通过在计算方法的开始处和返回值之前调用边界检查的方法也能够达到同样的目的。但是不可置否的是,使用装饰器能够让我们以最少的代码量达到坐标边界检查的目的。事实上,如果我们是在装饰自己定义的方法的话,我们能够让装饰器应用的更加有逼格。

    10. 使用 @ 标识符将装饰器应用到函数

    Python2.4支持使用标识符@将装饰器应用在函数上,只需要在函数的定义前加上@和装饰器的名称。在上一节的例子里我们是将原本的方法用装饰后的方法代替:

     
    add = wrapper(add)

    这种方式能够在任何时候对任意方法进行包装。但是如果我们自定义一个方法,我们可以使用@进行装饰:

     
    1 @wrapper
    2  def add(a, b):
    3      return Coordinate(a.x + b.x, a.y + b.y)

    需要明白的是,这样的做法和先前简单的用包装方法替代原有方法是一毛一样的, python只是加了一些语法糖让装饰的行为更加的直接明确和优雅一点。

    11. *args and **kwargs

    我们已经完成了一个有用的装饰器,但是由于硬编码的原因它只能应用在一类具体的方法上,这类方法接收两个参数,传递给闭包捕获的函数。如果我们想实现一个能够应用在任何方法上的装饰器要怎么做呢?再比如,如果我们要实现一个能应用在任何方法上的类似于计数器的装饰器,不需要改变原有方法的任何逻辑。这意味着装饰器能够接受拥有任何签名的函数作为自己的被装饰方法,同时能够用传递给它的参数对被装饰的方法进行调用。

    非常巧合的是Python正好有支持这个特性的语法。可以阅读 Python Tutorial 获取更多的细节。当定义函数的时候使用了*,意味着那些通过位置传递的参数将会被放在带有*前缀的变量中, 所以:

    def one(*args):
    print args # 1
    one()
    ()
    one(1, 2, 3)
    (1, 2, 3)
    def two(x, y, *args): # 2
    print x, y, args
    two('a', 'b', 'c')
    a b ('c',)

    第一个函数one只是简单地讲任何传递过来的位置参数全部打印出来而已,你们能够看到,在代码#1处我们只是引用了函数内的变量args, *args仅仅只是用在函数定义的时候用来表示位置参数应该存储在变量args里面。Python允许我们制定一些参数并且通过args捕获其他所有剩余的未被捕捉的位置参数,就像#2处所示的那样。
    *操作符在函数被调用的时候也能使用。意义基本是一样的。当调用一个函数的时候,一个用*标志的变量意思是变量里面的内容需要被提取出来然后当做位置参数被使用。同样的,来看个例子:

    def add(x, y):
    return x + y
    lst = [1,2]
    add(lst[0], lst[1]) # 1
    3
    add(*lst) # 2
    3

    #1处的代码和#2处的代码所做的事情其实是一样的,在#2处,python为我们所做的事其实也可以手动完成。这也不是什么坏事,*args要么是表示调用方法大的时候额外的参数可以从一个可迭代列表中取得,要么就是定义方法的时候标志这个方法能够接受任意的位置参数。
    接下来提到的**会稍多更复杂一点,**代表着键值对的餐宿字典,和*所代表的意义相差无几,也很简单对不对:

     
    1 def foo(**kwargs):
    2      print kwargs
    3 foo()
    4 {}
    5 foo(x=1, y=2)
    6 {'y': 2, 'x': 1}

    当我们定义一个函数的时候,我们能够用**kwargs来表明,所有未被捕获的关键字参数都应该存储在kwargs的字典中。如前所诉,argshe kwargs并不是python语法的一部分,但在定义函数的时候,使用这样的变量名算是一个不成文的约定。和*一样,我们同样可以在定义或者调用函数的时候使用**。

     
    1 dct = {'x': 1, 'y': 2}
    2 def bar(x, y):
    3      return x + y
    4 bar(**dct)
    5 3

    12. 更通用的装饰器

    有了这招新的技能,我们随随便便就可以写一个能够记录下传递给函数参数的装饰器了。先来个简单地把日志输出到界面的例子:

     
    1 def logger(func):
    2      def inner(*args, **kwargs): #1
    3          print "Arguments were: %s, %s" % (args, kwargs)
    4          return func(*args, **kwargs) #2
    5      return inner

    请注意我们的函数inner,它能够接受任意数量和类型的参数并把它们传递给被包装的方法,这让我们能够用这个装饰器来装饰任何方法。

    @logger
    def foo1(x, y=1):
    return x * y
    @logger
    def foo2():
    return 2
    foo1(5, 4)
    Arguments were: (5, 4), {}
    20
    foo1(1)
    Arguments were: (1,), {}
    1
    foo2()
    Arguments were: (), {}
    2

    随便调用我们定义的哪个方法,相应的日志也会打印到输出窗口,和我们预期的一样。

    转载于:https://www.cnblogs.com/niuli1987/p/9416078.html

    展开全文
  • 在该文中,Guido说他正在考虑使用PEG Parser代替现有类LL(1) Parser(名为pgen),来重构Python解释器。原因是现在 pgen 限制了Python语法自由度,使得一些语法难以实现,也让当前语法树不够整洁,一定程度...
  • 作为一名教python的老师,我发现学生们基本上一开始很难搞定python的装饰,也许因为装饰确实很难懂。搞定装饰需要你了解一些函数式编程概念,当然还有理解在python中定义和调用函数相关语法一些特点。 我...
  • 在安装软件后最好仔细浏览下软件目录结构,会发现很多有意思官方小工具。下面我们来看下python安装后那些小工具。 1. python软件4个小工具。 IDLE (Python 3.6 64-bit) python提供集成开发环境 Python ...
  • 安装Python解释器

    2020-06-01 15:20:37
    可以在Python官方网站下载到Python的Windows安装程序(exe文件),需要注意是如果在Windows 7环境下安装Python 3.x,需要先安装Service Pack 1补丁包(可以通过一些工具软件自动安装系统补丁功能来安装),安装...
  • 当我们想在命令行中运行pip命令或者python命令时,想在全局环境运行时不会有任何问题,但是当我们想在一个干净虚拟环境下开发自己项目时,这时就需要虚拟环境中的python解释器。往往在实践中可以发现,进入虚拟...
  • Python是一门强大语言,目前已支持所有主流操作系统,在Linux,Unix,Mac系统上自带Python环境,在Windows10系统上需要安装一下,超简单2. 下载完毕后打开进行安装,勾选(all users),然后点击(customize ...
  • 本文将介绍如何使用公司运行服务器进行开发调试,以及使用远程服务器python解释器,整理了对应配置流程。 进入配置页面 Pycharm菜单栏,如下图所示,依次点击 Tools -> Deployment -> Configration… 开始配置...
  • 世界上最好的Python编辑器是什么?我投PyCharm一票 选自 KDnuggets,作者:Saurabh Hooda,机器之心编译。...Linux、MacOS 和 Windows 等操作系统中都有 Python 解释器。 经过近 30 年的发展,Python 已成为编...
  • 定义语言文法 ,并且建立一个解释器来解释该语言中句子. 在GOF书中指出:如果一种特定类型问题发生频率足够高,那么可能就值得将该问题各个实例表述为一个简单语言中句子。这样就可以构建一个解释器...
  • IronPython:交互式解释器与常用函数 2010年06月04日  传闻中begtostudy希望您继续将他传闻下去!这里留下了begtostudy成长印记!如果是技术上问题,最好能够在这里评论或者留言,因为这样其他人也能看到和...
  • 这是我为Python找到的最好的探查。 它是跨平台的,不需要我更改正在分析的代码,并且其输出可以直接通过管道传递到flamegraph.pl 。 我只是用它来指出在每天结束时用某些代码运行的工作中严重滥用SQLAlchemy的...
  • python装饰器的理解

    千次阅读 2016-11-11 12:43:54
     关于装饰器解释:增加一个函数的的功能,但又不更改这个函数的内容的方式,称之为“装饰”(Decorator),初读非常拗口难懂,可是当你真正了解后,才发现他是最好的解读。然后我们需要知道的是在python中函数是...
  • Python代替VBA之说 ...VB解释器换成了Py解释器 常用数据分析类库一并加入Office中。数据分析类库是用Python开发Excel唯一优势,除了这一项Python没有哪里比VB好。但是添加了一些类库那么整个O
  • Python 代码最好的方式莫过于使用集成开发环境(IDE)了。它们不仅能使你的工作更加简单、更具逻辑性,还能够提升编程体验和效率。 IDE 是什么? IDE 是开发者创建程序时使用的软件包, 是一种改进代码创建、...
  • 问题描述:一开始打开之前建立的项目时并没有出现这个问题,但是当用之前在虚拟环境中建立的解释器再新建项目的时候,出现这个问题。 问题解决:点进去提示的detail,发现和在csdn中其他文章说的方法确实都是一样的...
  • 标准库会随每一版Python的发布而发布,其中包含数百个模块,为操作系统、解释器和互联网之间交互提供了丰富工具—所有这些模块都得到充分测试,可以用来作为应用开发起点。本书会提供一些精选例子,向你展示...
  • 在开始学习Python之前,你需要先选择最适合自己IDE(集成开发环境)。为了解决这一需求,本文调查了很多可用工具,并分析了它们优...Python解释器可以在多个操作系统上使用,包括Linux,MacOS和Windows。 有着...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 327
精华内容 130
关键字:

python最好的解释器

python 订阅