Aprenda Operações Eficientes com Strings | Aperfeiçoando o Desempenho com Ferramentas Integradas

Concatenação Eficiente de Strings

Ao trabalhar com muitas strings, é fundamental utilizar o método mais eficiente para concatenação. Utilizar o operador + (+=) repetidamente é ineficiente para grandes volumes de dados, pois cria uma nova string a cada operação. Em vez disso, utilizar str.join() é muito mais rápido e consome menos memória.

A seguir, uma comparação de desempenho entre duas abordagens para concatenar strings com caracteres de nova linha em uma única string. A primeira utiliza um laço for com o operador +=, enquanto a segunda utiliza o método mais eficiente str.join().


              1234567891011121314151617181920212223
            
import os
decorators = os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated lines of a report
lines = [f"Line {i}" for i in range(1, 1000001)]

# Inefficient concatenation
@timeit_decorator(number=50)
def concat_with_plus():
    result = ""
    for line in lines:
        result += line + "\n"
    return result

# Efficient concatenation
@timeit_decorator(number=50)
def concat_with_join():
    return "\n".join(lines) + "\n"  # Add final newline for consistency

result_plus = concat_with_plus()
result_join = concat_with_join()
print(result_plus == result_join)

Pré-compilação de Expressões Regulares

Ao trabalhar com expressões regulares, o desempenho pode se tornar um fator crítico, especialmente ao lidar com grandes volumes de dados ou correspondências de padrões repetitivas. Nesses casos, pré-compilar o padrão é uma técnica útil de otimização.

Pré-compilar garante que o mecanismo de regex não recompile o padrão toda vez que for utilizado, o que pode melhorar significativamente o desempenho quando o mesmo padrão é aplicado várias vezes em um conjunto de dados. Essa abordagem é especialmente benéfica em cenários como filtragem, validação ou busca em arquivos de texto grandes.

Vamos comparar o desempenho de duas abordagens para validar nomes de usuário usando expressões regulares. A primeira abordagem utiliza a função re.match com o padrão definido inline toda vez que é chamada. A segunda, mais eficiente, pré-compila o padrão regex usando re.compile e o reutiliza para todas as validações.


              1234567891011121314151617181920212223
            
import os
import re
decorators = os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated usernames
usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000

# Naive approach
@timeit_decorator(number=10)
def validate_with_re():
    pattern = r"^\w+$"
    return [bool(re.match(pattern, username)) for username in usernames]

# Optimized approach
@timeit_decorator(number=10)
def validate_with_compiled_re():
    compiled_pattern = re.compile(r"^\w+$")
    return [bool(compiled_pattern.match(username)) for username in usernames]

result_without_precompiling = validate_with_re()
result_with_precompiling = validate_with_compiled_re()
print(result_without_precompiling == result_with_precompiling)

1. Você está gerando um relatório com `10000` linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com `;` entre elas?

2. Por que pré-compilar uma expressão regular usando `re.compile()` geralmente é mais rápido do que usar `re.match()` com um padrão inline?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 4

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Deslize para mostrar o menu

Concatenação Eficiente de Strings


              1234567891011121314151617181920212223
            
import os
decorators = os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated lines of a report
lines = [f"Line {i}" for i in range(1, 1000001)]

# Inefficient concatenation
@timeit_decorator(number=50)
def concat_with_plus():
    result = ""
    for line in lines:
        result += line + "\n"
    return result

# Efficient concatenation
@timeit_decorator(number=50)
def concat_with_join():
    return "\n".join(lines) + "\n"  # Add final newline for consistency

result_plus = concat_with_plus()
result_join = concat_with_join()
print(result_plus == result_join)

Pré-compilação de Expressões Regulares


              1234567891011121314151617181920212223
            
import os
import re
decorators = os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Simulated usernames
usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000

# Naive approach
@timeit_decorator(number=10)
def validate_with_re():
    pattern = r"^\w+$"
    return [bool(re.match(pattern, username)) for username in usernames]

# Optimized approach
@timeit_decorator(number=10)
def validate_with_compiled_re():
    compiled_pattern = re.compile(r"^\w+$")
    return [bool(compiled_pattern.match(username)) for username in usernames]

result_without_precompiling = validate_with_re()
result_with_precompiling = validate_with_compiled_re()
print(result_without_precompiling == result_with_precompiling)

1. Você está gerando um relatório com `10000` linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com `;` entre elas?

2. Por que pré-compilar uma expressão regular usando `re.compile()` geralmente é mais rápido do que usar `re.match()` com um padrão inline?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 4

Operações Eficientes com Strings

Concatenação Eficiente de Strings

Pré-compilação de Expressões Regulares

1. Você está gerando um relatório com 10000 linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com ; entre elas?

2. Por que pré-compilar uma expressão regular usando re.compile() geralmente é mais rápido do que usar re.match() com um padrão inline?

Operações Eficientes com Strings

Concatenação Eficiente de Strings

Pré-compilação de Expressões Regulares

1. Você está gerando um relatório com 10000 linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com ; entre elas?

2. Por que pré-compilar uma expressão regular usando re.compile() geralmente é mais rápido do que usar re.match() com um padrão inline?

1. Você está gerando um relatório com `10000` linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com `;` entre elas?

2. Por que pré-compilar uma expressão regular usando `re.compile()` geralmente é mais rápido do que usar `re.match()` com um padrão inline?

1. Você está gerando um relatório com `10000` linhas, onde cada linha representa um resumo de transação. Qual método é mais eficiente para combinar essas linhas em uma única string com `;` entre elas?

2. Por que pré-compilar uma expressão regular usando `re.compile()` geralmente é mais rápido do que usar `re.match()` com um padrão inline?