连接字符串与加入列表的性能？ [复制]

Question

为了好玩，我正在做一个小的 Python 练习。

我需要根据一些输入和一些逻辑打印一些看起来像这样的东西：

.P....
.I....
.D....
.Z....
BANANA
.M....
.A....

现在我在构建带有点的字符串时有些吃力。 所以我需要一个函数，它接受一个数字 n 一个数字 i 和一个字符，就像这样；

def buildstring(n,i, char):

然后返回一个长度为 n 的字符串，仅由点组成，其中第 i 个字符是给定的字符。

我目前有这个尝试：

def buildprint(n,i,char):

    start = "".join(['.']*(i))
    mid = char 
    end = "".join(['.']*(n - i-1))
    print(start+mid+end)


buildprint(10,3,"j")

产生：

...j......

这是我想要的。但是我的解决方案将按时进行评分，但我不确定这是否是连接字符串的最有效方式，因为我记得连接字符串通常是程序的缓慢部分，或者这是否会更有性能：

def buildprint(n,i,char):

    start = ['.']*(i)
    mid = [char] 
    end = ['.']*(n - i-1)
    print("".join(start+mid+end))

所以问题实际上是关于字符串连接的工作方式，而不是加入列表

Answer 1

我会使用完全不同的方法，使用字符串插值和 f-string

def buildprint(n,i,char):
    start = "".join(['.']*(i))
    mid = char
    end = "".join(['.']*(n - i-1))
    print(start+mid+end)


def build_f_string(total_char, dots, char):
    total_char -= dots + 1
    print(f'{"." * dots}{char}{"." * total_char}')

test_1 = (10, 3, "j")
buildprint(*test_1)
build_f_string(*test_1)

一个班轮

build_f_string = lambda total_char, dots, char : print(f'{"." * dots}{char}{"." * (total_char - (dots + 1 ))}')
build_f_string(*test_1)

性能

1. 做一个定时器函数

    from time import perf_counter
    from functools import wraps
   
   
    def timer(runs):
        def _timer(f,):
            @wraps(f)
            def wrapper(*args, **kwargs):
                start = perf_counter()
                for test in range(runs):
                    res = f(*args, **kwargs)
                end = perf_counter()
                print(f'{f.__name__}: Total Time: {end - start}')
                return res
   
            return wrapper
        return _timer
   

2. 装饰我们的功能

        TEST_RUNS = 100_000
   
   
        @timer(runs=TEST_RUNS)
        def buildprint(n, i, char):
            start = "".join(['.'] * (i))
            mid = char
            end = "".join(['.'] * (n - i - 1))
            return start + mid + end
   
   
        @timer(runs=TEST_RUNS)
        def build_f_string(total_char, dots, char):
           return f'{"." * dots}{char}{"." * (total_char - dots + 1)}'
   

3. 运行测试

    test_1 = (10, 3, "j")
    buildprint(*test_1)
    build_f_string(*test_1)
   
    # Output
   
    # buildprint: Total Time: 0.06150109999999999
    # build_f_string: Total Time: 0.027191400000000004
   

进入下一个阶段

我们可以使用 Python Deque

双端队列是堆栈和队列的概括（名称发音为“deck”，是“双端队列”的缩写）。双端队列支持线程安全、内存高效的从双端队列的任一侧追加和弹出，在任一方向上的 O(1) 性能大致相同。

def build_withdeque(n, i, char):
    hyper_list = deque([char]) # initialize the deque with the char, is in the middle already
    hyper_list.extendleft(["." for _ in range(i)]) # Add left side
    hyper_list.extend(["." for _ in range(n - i - 1)])
    return "".join(hyper_list)

运行测试

    from collections import deque
    TEST_RUNS = 10_00_000
    
    @timer(runs=TEST_RUNS)
    def build_withdeque(n, i, char):
        hyper_list = deque([char]) # initialize the deque with the char, is in the middle already
        hyper_list.extendleft(["." for _ in range(i)]) # Add left side
        hyper_list.extend(["." for _ in range(n - i - 1)])
        return "".join(hyper_list)
    
    test_1 = (10, 3, "j")
    buildprint(*test_1)
    build_f_string(*test_1)
    build_withdeque(*test_1)
    
    # buildprint: Total Time: 0.546178
    # build_f_string: Total Time: 0.29445559999999993
    # build_withdeque: Total Time: 1.4074019

还是不太好..

预建列表

@timer(runs=TEST_RUNS)
def build_list_complete(n, i, char):
    return ''.join(["." * i, char, "." * (n - i - 1)])



test_1 = (10, 3, "j")
buildprint(*test_1)
build_f_string(*test_1)
build_withdeque(*test_1)
build_list_complete(*test_1)

# buildprint: Total Time: 0.5440142
# build_f_string: Total Time: 0.3002815999999999
# build_withdeque: Total Time: 1.4215970999999998
# build_list_complete: Total Time: 0.30323829999999985

最终结果

# TEST_RUNS = 10_00_000

test_1 = (10, 3, "j")
buildprint(*test_1)
build_f_string(*test_1)
build_withdeque(*test_1)
build_list_complete(*test_1)

# buildprint: Total Time: 0.6512364
# build_f_string: Total Time: 0.2695955000000001
# build_withdeque: Total Time: 14.0086889
# build_list_complete: Total Time: 3.049139399999998

别等这么快

正如@MisterMiyagi 指出的那样，使用return "." * i + char + ("." * (n - i + 1)) 可能等同于使用return f'{"." * dots}{char}{"." * (total_char - dots + 1)}'。

但实际上它更快。

看看这个：

def SuperHyperMegaUltraFastButBasicallyLikeFStringThatMisterMiyagiSayd(n, i, char):
    return "." * i + char + ("." * (n - i + 1))

运行一些重复 100_00_000 次的测试。

@timer(runs=TEST_RUNS)
def SuperHyperMegaUltraFastButBasicallyLikeFStringThatMisterMiyagiSaid(n, i, char):
    return "." * i + char + ("." * (n - i + 1))


test_1 = (10, 3, "j")
buildprint(*test_1)
build_f_string(*test_1)
build_withdeque(*test_1)
build_list_complete(*test_1)

    
    buildprint: Total Time: 5.3067210000000005
    build_f_string: Total Time: 2.721678
    build_withdeque: Total Time: 14.302031600000001
    build_list_complete: Total Time: 3.0364287999999995        SuperHyperMegaUltraFastButBasicallyLikeFStringThatMisterMiyagiSayd: Total Time: 2.440598699999999


    buildprint: Total Time: 5.3067210000000005
    build_f_string: Total Time: 2.721678
    build_withdeque: Total Time: 14.302031600000001
    build_list_complete: Total Time: 3.0364287999999995
    SuperHyperMegaUltraFastButBasicallyLikeFStringThatMisterMiyagiSayd 

Total Time: 2.440598699999999

f-string 字符串连接显然是赢家，除非另有证明