相关疑难解决方法(0)

我正在写一小段python作为家庭作业,我不会让它运行!我没有那么多的Python经验,但我知道很多Java.我正在尝试实现粒子群优化算法,这就是我所拥有的:

class Particle:    

    def __init__(self,domain,ID):
        self.ID = ID
        self.gbest = None
        self.velocity = []
        self.current = []
        self.pbest = []
        for x in range(len(domain)):
            self.current.append(random.randint(domain[x][0],domain[x][1])) 
            self.velocity.append(random.randint(domain[x][0],domain[x][1])) 
            self.pbestx = self.current          

    def updateVelocity():
    for x in range(0,len(self.velocity)):
        self.velocity[x] = 2*random.random()*(self.pbestx[x]-self.current[x]) + 2 * random.random()*(self.gbest[x]-self.current[x]) 


    def updatePosition():    
        for x in range(0,len(self.current)):
            self.current[x] = self.current[x] + self.velocity[x]    

    def updatePbest():
        if costf(self.current) < costf(self.best):
            self.best = self.current        

    def psoOptimize(domain,costf,noOfParticles=20, noOfRuns=30):
        particles = []
        for i in range(noOfParticles):    
            particle = Particle(domain,i)    
            particles.append(particle)    

        for i in range(noOfRuns): …

Python是否在运行时严格解释,还是可以用于开发作为后台应用程序运行的程序(如Java应用程序或C程序)？

def do_something():
    print 'doing something...'

def maybe_do_it(hesitant=False):
    if hesitant:
        do_something = lambda: 'did nothing'
    result = do_something()
    print result

maybe_do_it()

这段代码的结果是:

  File "scope_test.py", line 10, in <module>
    maybe_do_it()
  File "scope_test.py", line 7, in maybe_do_it
    result = do_something()
UnboundLocalError: local variable 'do_something' referenced before assignment

但是这段代码按照预期印刷了"做了些什么......":

def do_something():
    print 'doing something...'

def maybe_do_it(hesitant=False):
    result = do_something()
    print result

maybe_do_it()

即使if语句中的条件从未执行过,该函数是如何被覆盖的？这种情况发生在Python 2.7中 - 在Python 3中是否相同？

我刚刚在macintosh上注意到这一点.运行$ python使用以下行触发解释器会话:

$ python2.7
Python 2.7.10 (default, Feb  6 2017, 23:53:20) 
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 

启动文本的第二行提到了GCC和clang版本.

这两个如何与python解释器相关？鉴于python是一种解释型语言,根本不应该有编译器的低语,所以我很好奇为什么会显示它.

现在这与python3.6是一样的:

$ python3.6
Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 

这次没有提到铿锵声.为什么？

作为一个非常简单的基准测试,我在同一个Raspberry Pi 3模型B上执行了PHP 7.0.19-1和Python 3.5.3(命令行)上面的简单代码.

与PHP相比,Python的执行时间非常糟糕(74秒对1.4秒).任何人都可以帮助我理解为什么执行在Python上需要这么长时间？有什么我做错了,或者一些优化/设置可以提高其性能以达到或超过PHP的性能？或者Python的速度要慢得多(当然不是!)？

是的,我看到了这个基准测试,它报告了PHP 7超越其他语言,但你认为在进行这样一个简单的操作时两者都会得到相当优化.

如果用字符串赋值代替添加,Python执行循环的速度大约快两倍.但这仍然是34秒vs 1.1秒.

PHP7代码:

<?php

function test($x)
{
    $t1 = microtime(true);
    $a = 0;
    for($i = 0; $i < $x; $i++)
    {
        $a++;
    }
    $t2 = microtime(true);

    echo "Time for $x was " . ($t2 - $t1) . "\n";

    return $a;
}


echo test(100000);
echo test(1000000);
echo test(10000000);

结果:100000的时间为0.036377191543579 100000时间1000000为0.18501400947571 1000000时间为10000000为1.3939099311829

Python3代码:

import time
def test(x):
    t1 = time.clock()
    a = 0
    for i in range(x):
        a += 1 …

我知道这可能是一个非常明显的答案,而且我将自己暴露给不那么有用的讽刺评论,但我不知道答案所以这里就是这样.

如果Python在运行时编译为字节码,那么只需要花费更长时间的初始编译步骤吗？如果是这样的话,那么代码中的前期成本就不会那么小(即如果代码运行的时间很长,那么C和python之间的差异是否会减少？)

Python源代码最终转化为机器码最终被CPU运行的过程是，

1. 使用Python解释器将其转换为ByteCode
2. 使用 Python 虚拟机运行字节码

当涉及到 Java 时，会发生相同的事件序列。Java源代码转换为字节码，然后由Java虚拟机运行。所以我想知道，为什么 Python 被称为解释语言，而 Java 通常被称为编译语言，但是两种语言获取机器代码的相同事件序列是相同的。

我的理解

C++被编译成机器代码并执行.

Python被编译成字节码

然后执行该字节码

这个执行步骤需要什么？Cpython和PyPy有什么不同？

性能差异在哪里发挥作用？Python的动态类型在性能方面取得了哪些进展？

谢谢!

我是python的新手,我做了以下程序:

class AddressBook:
    def __init__(self):
        self.b = {}

    def insert(self,name, phone):
        self.b[name]=phone
        print "I am confused"

    def get(self,name):
        return self.b[name]

    def has_name(self,name):
        return self.b.has_key(name)

    def list(self):
        for n,p in self.b.iteritems():
            print n,p

    def delete(self, name):
        del self.b[name]

    def orderedList(self):
        orderedkeys = self.b.keys()
        orderedkeys.sort()
        for n in orderedkeys:
            print n, self.b[n]

我现在想编译它在终端测试它,看看它是否全部有效.我去了目录并用它编译

python address.py

现在我想要添加到列表中的内容,打印列表的内容,删除它们(几乎玩我的程序)但我不知道如何...

编译后,如何使用我的python程序手动测试(玩转)？

提前致谢.

来自Google样式指南的词法范围:

嵌套的Python函数可以引用封闭函数中定义的变量,但不能赋值给它们.

这两个似乎最初都要检查:

# Reference
def toplevel():
    a = 5
    def nested():
        print(a + 2)
    nested()
    return a
toplevel()
7
Out[]: 5

# Assignment
def toplevel():
    a = 5
    def nested():
        a = 7 # a is still 5, can't modify enclosing scope variable
    nested()
    return a
toplevel()
Out[]: 5

那么,为什么嵌套函数中的引用和赋值的组合会导致异常呢？

# Reference and assignment
def toplevel():
    a = 5
    def nested():
        print(a + 2)
        a = 7
    nested()
    return a
toplevel()
# UnboundLocalError: local variable 'a' referenced …