Concatenación e unión de cadeas en Python: operadores +, funcións de unión, etc.

Negocios

A seguinte é unha descrición de como concatenar e unir cadeas de cadea en Python.

  • Concatenación e fusión de varias cadeas:+,+=operador
  • Concatenar e combinar números e cadeas:+,+=operador,str(),format(),corda f
  • Concatena e combina listas (matrices) de cadeas nunha única cadea:join()
  • Concatena e combina listas (matrices) de números nunha única cadea:join(),str()

Concatenación e fusión de varias cadeas:+,+=operador

conexión:+operador

O operador ++ pódese usar para concatenar os seguintes literales de cadea e variables de cadea

  • …’
  • “…”
s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

conexión:+=operador

Tamén se pode usar o operador +=, un operador de asignación acumulativa. A variable de cadea do lado esquerdo concatenase coa cadea do lado dereito e asígnase e actualízase.

s1 += s2
print(s1)
# aaabbb

Se queres engadir unha cadea ao final dunha variable de cadea, simplemente procesa a variable de cadea e calquera literal de cadea (ou outra variable de cadea) co operador +=.

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

Concatenación consecutiva de literais de cadea

Se simplemente escribe literais de cadea un lado a outro, os literais de cadea concatenaranse.

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

É aceptable ter un espazo entre dúas liñas ou un salto de liña invertido (considerado unha continuación).

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

Hai unha técnica para usar isto para escribir cadeas longas en varias liñas do código.

Este método de escritura non é posible para variables de cadea.

# s = s1 s2 s3
# SyntaxError: invalid syntax

Concatenación/concatenación numérica e de cadeas:+,+=operador,str(),format(),corda f

Unha operación + dun tipo diferente produce un erro.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

Se quere concatenar un valor numérico (por exemplo, tipo enteiro int ou tipo flotante de coma flotante) cunha cadea, converte o valor numérico nun tipo de cadea con str() e despois concatenaos co operador + (ou operador +=). ).

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

Se queres converter o formato dun número, como o recheo de cero ou os decimais, utiliza a función format() ou o método de cadea format().

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

Por suposto, tamén é posible inserir o valor dunha variable directamente nunha cadea sen formato. Isto é máis sinxelo de escribir que usar o operador +.

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

Consulte o seguinte artigo para obter máis información sobre como especificar o formato.

Desde Python 3.6, tamén se introduciu un mecanismo chamado f-strings (f-string), que é aínda máis sinxelo de escribir que format().

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

Concatenar e unir listas (matrices) de cadeas:join()

O método de cadea join() pódese usar para concatenar unha lista de cadeas nunha única cadea.

O seguinte é como escribilo.

'String to be inserted between'.join([List of strings to be concatenated])

Chame ao método join() con ‘cadea para inserir entre’ e pase [lista de cadeas para concatenar] como argumento.

Se se usa unha cadea baleira, [lista de cadeas que se deben concatenar] simplemente concatenarase, se se usa unha coma, as cadeas estarán separadas por comas, e se se usa un carácter de nova liña, cada elemento da cadea será nova.

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

Aínda que aquí só se dá un exemplo dunha lista, tamén se poden especificar outros obxectos iterables como as tuplas como argumentos para join().

En contraste con join(), split() úsase para dividir unha cadea delimitada por un delimitador específico e obtelo como unha lista.

Concatena e combina listas (matrices) de números como cadeas:join(),str()

Prodúcese un erro se o argumento para join() é unha lista cuxos elementos non son cadeas.

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

Para concatenar unha lista de números nunha única cadea, aplique a función str() a cada elemento da notación de comprensión da lista para converter os números nunha cadea e, a continuación, únaos con join().

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

Tamén se pode escribir como unha expresión xeradora, que é unha versión xeradora de listas de comprensións. As expresións xeradoras encóntranse entre parénteses, pero as parénteses pódense omitir se a expresión xeradora é o único argumento dunha función ou método.

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

As expresións xeradoras xeralmente teñen a vantaxe de usar menos memoria que as comprensións de listas, pero non hai ningunha vantaxe particular en usar expresións xeradoras xa que join() converte os xeradores en listas no seu procesamento interno. De feito, é un pouco máis rápido usar as listas de comprensión desde o principio.

Para obter máis información sobre as listas de comprensión e as expresións xeradoras, consulte o seguinte artigo.