相关疑难解决方法(0)

我想要一种有效的方法在Python中将一个字符串附加到另一个字符串.

var1 = "foo"
var2 = "bar"
var3 = var1 + var2

有没有什么好的内置方法可供使用？

我是使用字典格式化字符串的忠实粉丝.它帮助我阅读我正在使用的字符串格式,以及让我利用现有的字典.例如:

class MyClass:
    def __init__(self):
        self.title = 'Title'

a = MyClass()
print 'The title is %(title)s' % a.__dict__

path = '/path/to/a/file'
print 'You put your file here: %(path)s' % locals()

但是,我无法弄清楚python 3.x语法做同样的事情(或者如果可能的话).我想做以下几点

# Fails, KeyError 'latitude'
geopoint = {'latitude':41.123,'longitude':71.091}
print '{latitude} {longitude}'.format(geopoint)

# Succeeds
print '{latitude} {longitude}'.format(latitude=41.123,longitude=71.091)

Python中常见的反模式是+在循环中连接一系列字符串.这很糟糕,因为Python解释器必须为每次迭代创建一个新的字符串对象,并最终获得二次时间.(在某些情况下,CPython的最新版本显然可以优化它,但是其他实现不能,因此不鼓励程序员依赖它.)''.join是正确的方法.

不过,我听人说(这里包括对堆栈溢出),你应该永远不会使用+字符串连接,而是始终使用''.join或格式字符串.我不明白为什么如果你只是连接两个字符串就是这种情况.如果我的理解是正确的,它不应该花费二次时间,我认为a + b比任何一个''.join((a, b))或更清晰,更可读'%s%s' % (a, b).

+用于连接两个字符串是一种好习惯吗？还是有一个我不知道的问题？

我想从字符串中读取一些字符并将其放入其他字符串中(就像我们在C中所做的那样).

所以我的代码如下所示

import string
import re
str = "Hello World"
j = 0
srr = ""
for i in str:
    srr[j] = i #'str' object does not support item assignment 
    j = j + 1
print (srr)

在C中代码可能是

i = j = 0; 
while(str[i] != '\0')
{
srr[j++] = str [i++];
}

我怎样才能在Python中实现相同的功能？

我在早期的帖子中询问了最有效的大规模动态字符串连接方法,我建议使用join方法,这是最好,最简单,最快速的方法(就像大家所说的那样).但是当我玩字符串连接时,我发现了一些奇怪的(？)结果.我确信事情正在发生,但我不能完全理解.这是我做的:

我定义了这些功能:

import timeit
def x():
    s=[]
    for i in range(100):
        # Other codes here...
        s.append("abcdefg"[i%7])
    return ''.join(s)

def y():
    s=''
    for i in range(100):
        # Other codes here...
        s+="abcdefg"[i%7]
    return s

def z():
    s=''
    for i in range(100):
        # Other codes here...
        s=s+"abcdefg"[i%7]
    return s

def p():
    s=[]
    for i in range(100):
        # Other codes here...
        s+="abcdefg"[i%7]
    return ''.join(s)

def q():
    s=[]
    for i in range(100):
        # Other codes here...
        s = s + ["abcdefg"[i%7]]
    return ''.join(s) …

我想比较不同以在Python中用不同的变量构建一个字符串:

• 使用+来连接(被称为"加号")
• 运用 %
• 运用 "".join(list)
• 使用format功能
• 运用 "{0.<attribute>}".format(object)

我比较了3种类型的情景

• 带2个变量的字符串
• 4个变量的字符串
• 带有4个变量的字符串,每个变量两次使

我每次测量100万次操作并且平均执行超过6次测量.我想出了以下时间:

在每个场景中,我得出以下结论

• 连接似乎是最快的方法之一
• 使用格式化%比使用format函数格式化要快得多

我相信format比%(例如在这个问题中)要好得多,并且%几乎被弃用了.

因此,我有几个问题:

1. 是%真的比快format？
2. 如果是这样,为什么呢？
3. 为什么"{} {}".format(var1, var2)效率更高"{0.attribute1} {0.attribute2}".format(object)？

作为参考,我使用以下代码来测量不同的时序.

import time
def timing(f, n, show, *args):
    if show: print f.__name__ + ":\t",
    r = range(n/10)
    t1 = time.clock()
    for i in r:
        f(*args); f(*args); f(*args); f(*args); f(*args); f(*args); f(*args); …

网上有很多关于python性能的文章,你读的第一件事:不应该使用'+'连接字符串:避免使用s1 + s2 + s3,而是使用str.join

我尝试了以下内容:将两个字符串连接为目录路径的一部分:三种方法:

1. 我不应该做的'+'
2. str.join
3. os.path.join

这是我的代码:

import os,time

s1='/part/one/of/dir'
s2='part/two/of/dir'
N=10000

t=time.clock()
for i in xrange(N):
    s=s1+os.sep+s2
print time.clock()-t

t=time.clock()
for i in xrange(N):
    s=os.sep.join((s1,s2))
print time.clock()-t

t=time.clock()
for i in xrange(N):
    s=os.path.join(s1,s2)
print time.clock()-t

这里的结果(python 2.5 WinXP)

0.0182201927899
0.0262544541275
0.120238186697

不应该完全相反吗？

在Python中,我有一个字符串,它是逗号分隔的值列表.例如'5,2,7,8,3,4'

我需要在末尾添加一个新值并删除第一个值,

例如'5,22,7,814,3,4' - > '22,7,814,3,4,1'

目前,我这样做如下:

mystr = '5,22,7,814,3,4'
latestValue='1'
mylist = mystr.split(',')
mystr = ''
for i in range(len(mylist)-1):
   if i==0:
      mystr += mylist[i+1]
   if i>0:
      mystr += ','+mylist[i+1]

mystr += ','+latestValue

这在我的代码中运行了数百万次,并且我已将其识别为瓶颈,因此我热衷于优化它以使其运行更快.

这样做最有效(在运行时方面)？

我有一个简单的问题.我有一些文本文件,其中的单词已在行尾分割(连字符号).像这样的东西:

toward an emotionless evalu-
ation of objectively gained

我想摆脱连字并再次加入这些词.这可以使用该replace()功能简单快速地完成.但是在某些情况下,连字符后面会有一些额外的换行符.像这样:

end up as a first rate con-


tribution, but that was not

replace()我只是切换到正则表达式而不是堆积几次调用,而是使用re.sub('\-\n+', '', text):

def replace_hyphens(text):
    return re.sub('\-\n+', '', text)

这很有效,但我想知道如何用直接在Python中编码的函数实现相同的结果.这就是我想出的:

def join_hyphens(text):
    processed = ''
    i = 0
    while i < len(text):
        if text[i] == '-':
            while text[i+1] == '\n':
                i += 1
            i += 1
        processed += text[i]
        i += 1
    return processed

但是,与正则表达式相比,当然表现糟糕.如果我在相当长的字符串上超过100次迭代计时,结果就是这里.

join_hyphens done in 2.398ms
replace_hyphens done in 0.021ms …

在下面的代码中,连接是瓶颈.正如你所看到的,我已经尝试了一些复杂的方法来加快速度,但无论如何它的血腥都很慢.我想知道我能做些什么来使它紧固.

简单和秘密BTW是从二进制文件读取的数据,它们相当大(约1mb)

x = b''
if len(plain) < len(secret*8):
    return False
i = 0

for secByte in secret:
    for j in range(8):
        z = setBit(plain[i],0,getBit(secByte,j))
        #x += bytes([z])
        x = x.join([b"", bytes([z])])
        #x = array.array("B",(int(z) for z in x.join([b"", bytes([z])]))).tostring()
        i = i+1

我在 python3 中有一个字节字符串数组（它是一个音频块）。我想从中生成一个大字节串。简单的实现有点慢。怎样才能做得更好呢？

chunks = []
while not audio.ends():
  chunks.append( bytes(audio.next_buffer()) )
  do_some_chunk_processing()

all_audio=b''
for ch in chunks:
  all_audio += ch

怎样才能做得更快呢？

目前我正在这样做，但问题是我正在遍历数千个这样的字符串（它们都比下面给出的示例字符串长得多）并且当前方法需要很长时间才能完成：

    example_string = '1001011101010010101010100100000001111011010101'
    reversed = ''
    for c in example_string:
        if c == '1':
            reversed += '0'
        elif c == '0':
            reversed += '1'
    print(reversed)