Cadenes

L’objectiu de la secció serà la creació d’un programa que compta les xifres d’un nombre enter. Tot i que ja heu resolt aquest problema amb un bucle while i operacions matemàtiques, aquesta vegada us centrareu en la manipulació de cadenes per apropar-vos més a l’algorisme natural que utilitzeu.

L’algorisme que aplicareu consisteix a tractar el nombre com si fos una cadena de caràcters. Només caldrà treure el signe si en té i comptar els caràcters restants.

L’entrada per a aquest programa serà un nombre enter qualsevol. Heu de tenir present que nombre 021 no existeix, i la funció int() no és capaç de convertir-lo en enter.

A la taula hi ha el joc de proves del programa:

A continuació teniu el refinament i codi del programa:

::copytoclipboard:

#llegir el nombre com a enter
n = int(input())

#convertir a cadena
nombre = str(n)

# Saber si hi ha signe o no
te_signe = False
if nombre[0] in '+-':
    te_signe = True
    
xifres = len(nombre)

if te_signe:
    xifres -= 1
print(xifres)
:::

En la figura es mostra programa amb els números de línia.

Explicació dels nous conceptes:

• Línia 18: lectura del nombre com a enter. Tot i que immediatament es faci la conversió a cadena, l’entrada del programa ha de ser compatible amb la funció int().
• Línia 21: la funció str() converteix l’argument (un enter en aquesta ocasió) a cadena. Això permetrà treballar amb una dada de tipus str i aplicar propietats que els nombres no tenen.
• Línia 24: es crea una variable booleana per comptabilitzar si el primer caràcter del nombre és o no un signe.
• Línia 25: s’utilitza la indexació de cadenes. Es pot accedir al caràcter que ocupa la posició i d’una cadena, si posem després del nom de la cadena els símbols [ ], i a dins la posició i . Per exemple nombre[0] accedeix al caràcter que es troba a la primera posició de la cadena (la posició 0). També es fa servir l’operador in per comprovar si un caràcter està o no en una cadena. En aquest cas, si el caràcter consultat és un dels que hi ha a la cadena '+-'
• Línia 28: la funció len retorna la longitud, o quantitat de caràcters de la cadena.

Els tipus de dades són elements fonamentals en la programació que defineixen la naturalesa de la informació amb la qual es treballa. Fins ara, heu explorat els enters (int), els nombres de punt flotant (float) i els booleans (bool). Aquests tres són exemples de tipus de dades escalars, ja que consisteixen en un únic element o àtom. Les cadenes, en canvi, es poden trossejar en elements diferents (els caràcters).

Una llista també és una seqüència d’elements. Que una cadena sigui immutable significa que no es pot modificar. No es pot canviar un caràcter d’una cadena sense crear una cadena nova.

Per assignar una cadena a una variable, heu de seguir el mateix procediment que amb els nombres enters o float. Recordeu que Python és un llenguatge no tipat, així que no és necessari declarar el tipus de la variable. Els literals de cadena es defineixen entre cometes simples o dobles, i és important ser coherent en la seva utilització.

Podeu comprovar les següents instruccions amb l’intèrpret interactiu:

>>> a = 'hola'
>>> a
'hola'
>>> b = "adeu"
>>> b
'adeu'
>>> c = ''
>>> c
''
>>> print(c)

Els caràcters que es necessiten escapar en una cadena de Python són aquells que tenen significats especials i podrien ser interpretats de manera diferent si no es manegen correctament. Alguns dels caràcters que sovint es necessita escapar són:

• Cometes simples ( ' ) i dobles ( “). S’utilitzen per delimitar les cadenes. Si voleu incloure la mateixa cometa dins d’una cadena, heu de fer servir l’escapament.

  >>> cadena1 = 'Això és una cadena amb una cometa simple (\')'
  >>> print(cadena1)
  Això és una cadena amb una cometa simple (')
  >>> cadena2 = "Això és una altra cadena amb una cometa doble (\")"
  >>> print(cadena2)
  Això és una altra cadena amb una cometa doble (")

• Barra invertida (\). Es fa servir com a caràcter d’escapament. Si voleu incloure una barra invertida en una cadena, cal escapar-la amb una altra barra invertida.

  >>> cadena_amb_barra = "Això inclou una barra invertida (\)"
  >>> print(cadena_amb_barra)
  Això inclou una barra invertida (\)

• Caràcters de control: \n, \t, etc. Alguns caràcters de control com el salt de línia (‘\n’) o el tabulador ( \t) s’utilitzen per a formatar el text. Cal escapar-los si voleu incloure aquests caràcters directament a la cadena.

  >>> cadena_amb_salt_linea = "Aquesta és una línia\ni aquesta és una altra línia">>> print(cadena_amb_salt_linea)
  Aquesta és una línia
  i aquesta és una altra línia
  >>> cadena_amb_tabulador = "Columna1\tColumna2"
  >>> print(cadena_amb_tabulador)
  Columna1	Columna2

• Barra invertida doble ( \). Si voleu incloure una barra invertida doble en una cadena, cal escapar-la amb una altra barra invertida doble.

  >>> cadena_amb_doble_barra = "Això conté una barra invertida doble (\\)"
  >>> print(cadena_amb_doble_barra)
  Això conté una barra invertida doble (\)

Aquesta pràctica és essencial per garantir que les cadenes es defineixin i interpretin correctament a Python. Escapant aquests caràcters, el programari entendrà les vostres intencions i no interpretarà erròniament la sintaxi de la cadena.

A Python, les cadenes suporten diferents operadors que permeten realitzar diverses operacions. Aquests són uns dels més comuns:

Operador binari que s’utilitza per concatenar dues cadenes, creant una nova cadena que conté tots els caràcters de les cadenes originals.

Comproveu amb l’intèrpret interactiu:

>>> hora = '10'
>>> separador = ':'
>>> minut = '02'
>>> hora = hora + separador + minut
>>> print(hora)
10:02

Cal remarcar que es crea una cadena nova anomenada hora, que tot i que tingui el mateix nom que la primera és un objecte diferent.

Aquest operador permet repetir una cadena múltiples vegades, creant-ne una de nova, que conté la repetició de la cadena original. És un operador binari en què un element ha de ser de tipus enter i l’altre de tipus cadena.

>>> 3 * 'hola'
'holaholahola'
>>> '*' * 5
'*****'
>>> -2 * 'hola'
''

Tots són operadors binaris que treballen entre cadenes i proporciones dades booleanes. En aquesta lliçó explorareu els operadors d’igualtat (== ) i desigualtat (!= ). Tots dos poden relacionar una cadena amb qualsevol tipus de dada, i un és l’invers de l’altre (en el sentit que la dada booleana resultant sempre serà la contrària si operen sobre les mateixes dades).

L’operador d’igualtat només dona True si les dues dades són exactament la mateixa cadena.

>>> cadena1 = "gat"
>>> cadena2 = "gos"
>>> cadena1 == cadena2
False
>>> cadena1 != cadena2
True
>>> 'gat' == cadena1
True

En Python, l’operador in és una eina que serveix per verificar la presència d’un subconjunt d’elements dins d’una seqüència. Pot ser utilitzat tant per examinar si un caràcter pertany a una cadena com per comprovar si una cadena concreta pot formar part d’una altra, més extensa.

A més de la seva aplicació per validar la inclusió d’un enter en una llista d’enters, com heu observat fins ara, aquest operador té una utilitat més àmplia. Vegeu els exemples següents:

>>> cadena1 = 'Python'
>>> cadena2 = 'm\'agrada programar en Python'
>>> '\'' in cadena2
True
>>> cadena1 in cadena2
True
>>> 'programa' not in cadena2
False

El sistema ofereix diverses funcions que treballen amb cadenes. Aquí es mencionen algunes d’elles:

Les funcions int() i float() serveixen per a efectuar conversions entre diferents tipus de dades. Si els arguments de qualsevol d’aquestes funcions és una cadena, s’intentarà fer la conversió al tipus indicats. De la mateixa manera, la funció str() convertirà la dada que rebi com a argument a un objecte de tipus str. Fixeu-vos en els exemples següents:

>>> str(3 + 4)
'7'
>>> str(3) + str(4)
'34'
>>> float('3') + 3
6.0
>>> str(float(3)) + '2'
'3.02'
>>> str(3 == 5)
'False'
>>> float('2.2.3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: '2.2.3'

Són funcions que relacionen un caràcter i la posició que aquest ocupa dins de la Taula ASCII.

Aquesta taula inclou caràcters com lletres majúscules i minúscules, dígits, símbols de puntuació, caràcters de control (per exemple, retorn de carro, tabulador), i altres caràcters especials. No és necessari (ni molt menys), saber el codi ASCII dels caràcters, però sí que és cal saber que en la taula, les xifres del 0 al 9 ocupen posicions consecutives, igual com les lletres minúscules de la “a” a la “z” i les majúscules de la “A” a la “Z”.

La taula ASCII s’utilitza en programació, processament de text i comunicació de dades per assegurar la compatibilitat en el tractament de caràcters. Els valors ASCII permeten als ordinadors representar text de manera universal, independentment de la plataforma o del sistema operatiu.

La funció ord() en Python retorna el valor ASCII d’un caràcter donat. L’argument és un caràcter (una cadena amb un únic caràcter), i retorna un enter.

La funció chr() és la funció inversa, permet convertir un valor ASCII en el caràcter associat. L’argument ha de ser un nombre enter i retornarà el caràcter corresponent.

Exemples:

>>> ord('a')
97
>>> ord('b')
98
>>> chr(97)
'a'
>>> chr(98)
'b'
>>> ord('1')
49
>>> ord('2')
50
>>> ord('7') - ord('3')
4

La funció len() retorna la longitud d’una cadena (o una seqüència). És a dir, el nombre de caràcters (o elements) que conté. L’argument ha de ser la cadena i el resultat serà sempre un nombre enter major o igual a zero.

Exemples:

>>> len('hola')
4
>>> len('hola' * 5)
20
>>> len('hola') + len('adeu')
8
>>> len('hola' + 'adeu')
8
>>> len('')
0
>>> len(' ')
1

Fixeu-vos en el penúltim exemple: la longitud de la cadena buida és zero (no conté cap caràcter). En canvi, en l’últim exemple es mostra la longitud d’una cadena que conté un espai en blanc.

Una cadena és una seqüència ordenada de caràcters, cadascun dels quals ocupa una posició única. La indexació permet relacionar l’element (el caràcter en aquest cas) amb la posició que ocupa dins d’una cadena.

En Python, com en molts altres llenguatges de programació, la indexació comença amb el zero.

La taula taula mostra la relació entre la posició que ocupa cada caràcter de la cadena ‘Python’ amb el seu índex.

Utilitzeu l’intèrpret interactiu per a comprovar els exemples següents:

>>> cadena = 'Python'
>>> len(cadena)
6
>>> cadena[0]
'P'
>>> cadena[4]
'o'
>>> cadena[5]
'n'
>>> cadena[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Fixeu-vos en l’últim cas: la cadena té longitud 5, però com que la posició comença per 0, l’últim índex al qual es pot accedir és el 4. Si s’intenta accedir a una posició major que 4 es produeix un error de tipus string index out of range.

A diferència d’altres llenguatges, Python permet l’ús d’índexs negatius, que es comencen a comptar des de la darrera posició. Això significa que l’índex -1 apunta a l’últim caràcter, el -2 al penúltim, i així successivament.

>>> cadena[-1]
'n'
>>> cadena[-2]
'o'

Les dades seqüencials tenen la propietat iterativa i es poden recórrer de manera natural utilitzant el bucle for-in, tal com sabeu fer amb les llistes d’enters. Hi ha dues maneres de recórrer una cadena: caràcter a caràcter o per posició.

for c in cadena:
	#instruccions

Amb els coneixements que teniu del bucle for-in, segur que podeu anticipar el resultat del programa de la figura.

Fer el seguiment de la taula us resultarà senzill:

Hi haurà programes en els quals necessitareu accedir a la posició (o índex) que ocupa un caràcter de la cadena. Si recorreu la cadena caràcter a caràcter, no tindreu accés a la posició (tret que definiu una variable comptador).

Però es pot utilitzar el for per iterar les posicions una a una (que són enters consecutius), i tenir accés al valor del caràcter mitjançant la indexació de cadenes.

for i in range(0, len(cadena):
	#instruccions

Fixeu-vos en el programa següent:

cadena = 'hola'
for i in range (0,len(cadena)):
    print(i,cadena[i])
print('fi')

Ho teniu amb línies de codi a la figura.

Vegeu el seguiment recollit en la taula.

Amb aquests exemples heu après l’ús bàsic de cadenes per a manipular-les en els primers programes.

Una cadena és una dada estructurada de tipus seqüència i immutable. Està formada per una successió de caràcters. El caràcter és l’element atòmic de les cadenes, en el sentit que no es pot dividir. Un caràcter és una dada de tipus str que té longitud 1.

Hi ha diversos operadors que actuen sobre les dades de tipus str:

• Operador de concatenació (+). Operador binari que actua sobre dues cadenes i en crea una de nova, amb tots els caràcters de la primera, seguits dels caràcters de la segona.
• Operador de repetició (*). Operador binari que actua sobre un nombre enter i una cadena. La dada resultant és una altra cadena, que conté la repetició de la cadena inicial tantes vegades com el nombre enter indica.
• Operadors d’igualtat i desigualtat (== i !=). Aquests operadors binaris poden actuar sobre dues dades de qualsevol tipus, inclús entre dos tipus diferents. L’operador == només dona True en el cas que les dues cadenes comparades siguin la mateixa.
• Operador de pertinença (in). Opera sobre dues cadenes i indica si la primera és una subcadena de la segona o no.

Existeixen diverses funcions del sistema que ajuden a treballar amb cadenes. Aquestes són algunes de les més útils:

• Funcions de conversió (int(), float() i str(). Permeten convertir qualsevol mena de dada al tipus de la funció int() i float, si reben una cadena que pot ser convertida als respectius tipus, la transformen en els seus valors numèrics i str() fa el camí invers. Tots els objectes de Python poden ser convertits a cadena.
• Funció len(). Permet calcular la longitud d’una cadena, o el que és el mateix, la quantitat de caràcters que la componen.

Es pot accedir a un caràcter d’una cadena mitjançant la seva posició. Això s’aconsegueix escrivint el nombre enter posició entre els caràcters [ i ]. cadena[pos] retornarà el caràcter que ocupa la posició pos del str cadena.

Les cadenes es poden recórrer amb el bucle for, iterant sobre tots els seus caràcters. Hi ha dues maneres de fer-ho:

• Caràcter a caràcter. Permet accedir directament a cada caràcter de la cadena. L’estructura és:

  for c in cadena:
  	#instruccions

En la variable c es van carregant els valors dels diferents caràcters de la cadena. En aquesta variable sempre hi haurà una dada de tipus str.

• Per posició. El foranterior no permet accedir a la posició de la cadena. Si en necessita controlar-la, s’ha d’utilitzar la següent estructura:

for i in range(0, len(cadena)):
	#instruccions

En la variable i es recorren tots els enters entre el 0 i len(cadena) - 1. És a dir, totes les possibles posicions que ocupen els caràcters de la cadena. En aquest cas, s’ha de recórrer a la indexació per a obtenir el valor del caràcter corresponent: el caràcter cadena[i] serà el que ocupa la posició i de la cadena.