Aprendre A Programar2.0

Aprendre a Programar
Autors:
Roger Meix Mañá
Roser Agramunt Marquès
2
ÍNDEX
Mòdul 1:Python, Variables, i Funcions.................................................................................................. 7
1.1 Introducció: Instal·lant Python............................................................................................................................. 7
Llenguatges de programació............................................................................................................................. 7
Python........................................................................................................................................................................ 7
1.2 Python com una Calculadora................................................................................................................................. 8
Operadors Aritmètics........................................................................................................................................... 8
Types int i float....................................................................................................................................................... 8
Prioritat o preferència d’operadors aritmètics.......................................................................................... 8
Sintaxis i Semàntica.............................................................................................................................................. 8
Errors......................................................................................................................................................................... 9
1.3 Variables....................................................................................................................................................................... 10
Instrucció d’assignació...................................................................................................................................... 10
Nom de les variables.......................................................................................................................................... 10
1.4 Built-in Functions..................................................................................................................................................... 11
Crida d’una funció............................................................................................................................................... 11
Function dir........................................................................................................................................................... 11
Funció help............................................................................................................................................................ 12
Arguments opcionals......................................................................................................................................... 12
1.5 Definint les funcions................................................................................................................................................ 12
Definicions de funcions.................................................................................................................................... 12
Sentència return.................................................................................................................................................. 13
Crida a la funció................................................................................................................................................... 13
Desant els teus programes en fitxers ".py"............................................................................................... 14
Mòdul 2: Strings i Dissenyant Funcions............................................................................................. 16
2.1 Type str: Strings en Python.................................................................................................................................. 16
String Literal......................................................................................................................................................... 16
Seqüències d’escapament................................................................................................................................ 16
String Operators.................................................................................................................................................. 17
2.2 Input/Output and str Formatting..................................................................................................................... 17
Function print....................................................................................................................................................... 17
return vs. print..................................................................................................................................................... 18
Function input...................................................................................................................................................... 19
Operacions amb strings.................................................................................................................................... 19
Triple-cometes strings...................................................................................................................................... 19
Seqüències d’escapament................................................................................................................................ 20
2.3 Funció Design Recipe.............................................................................................................................................. 21
Els Sis Passos........................................................................................................................................................ 21
Aplicar el Design Recipe................................................................................................................................... 21
2.4 Funció Reutilitzable................................................................................................................................................. 23
Cridar funcions dins d’altres definicions de funció............................................................................... 23
Cridar funcions dins d’altres crides a funcions....................................................................................... 23
2.5 Funcions, Variables, i la Call Stack.................................................................................................................... 24
Explorant el codi.................................................................................................................................................. 24
Nota Important.................................................................................................................................................... 29
Mòdul 3: Booleans, Import, Namespaces, i Sentència if................................................................ 30
3.1 Tipus (Type) bool: Booleans amb Python...................................................................................................... 30
Valors Booleans................................................................................................................................................... 30
Operadors de comparació............................................................................................................................... 30
3
Operadors lògics.................................................................................................................................................. 30
and Taula lògica................................................................................................................................................... 31
or Taula lògica...................................................................................................................................................... 31
not Taula lògica.................................................................................................................................................... 31
Ordre de prioritat del operadors lògics..................................................................................................... 31
3.2 Convertint entre int, str, i float........................................................................................................................... 32
str.............................................................................................................................................................................. 32
int.............................................................................................................................................................................. 32
float........................................................................................................................................................................... 32
3.3 Import: Utilitzant Non-Builtin Functions...................................................................................................... 33
Modules................................................................................................................................................................... 33
import...................................................................................................................................................................... 33
3.4 La sentència if............................................................................................................................................................ 34
Una nota sobre None......................................................................................................................................... 34
3.5 Innecessari if............................................................................................................................................................... 35
3.6 Estructurant la sentència if.................................................................................................................................. 36
if-elif vs. if-if........................................................................................................................................................... 36
Anidats (Nested) ifs............................................................................................................................................ 37
Mòdul 4: For Loops i Manipulació String........................................................................................... 39
4.1 Més Operadors str.................................................................................................................................................... 39
Comparació d’strings......................................................................................................................................... 39
Provant Substrings............................................................................................................................................. 40
Longitud String: funció len.............................................................................................................................. 40
Resum...................................................................................................................................................................... 40
4.2 str: indexing i slicing............................................................................................................................................... 41
Indexing.................................................................................................................................................................. 41
Slicing....................................................................................................................................................................... 41
Modificant Strings............................................................................................................................................... 42
4.3 str Methods: Funcions pels Objectes................................................................................................................. 43
Mètodes................................................................................................................................................................... 43
String Methods..................................................................................................................................................... 43
4.4 Bucle for sobre str.................................................................................................................................................... 44
For Loops................................................................................................................................................................ 44
Patró d’acumulador: acumulador númeric............................................................................................... 44
Patró d’acumulador: acumulador de string.............................................................................................. 45
4.5 IDLE's Debugger....................................................................................................................................................... 46
Debug Control....................................................................................................................................................... 46
Debug Window..................................................................................................................................................... 46
Mòdul 5: While Loops, Lists, i Mutability........................................................................................... 48
5.1 Bucle while.................................................................................................................................................................. 48
Condició del bucle i Lazy Evaluation........................................................................................................... 48
5.2 Comentaris.................................................................................................................................................................. 49
El Perquè i el Com dels Comentaris............................................................................................................. 49
5.3 Type list......................................................................................................................................................................... 50
Introducció............................................................................................................................................................ 50
Operacions List.................................................................................................................................................... 50
Tipus d’elements d’una llista.......................................................................................................................... 51
for bucle sobre list.............................................................................................................................................. 51
5.4 list Methods................................................................................................................................................................. 52
Mètodes................................................................................................................................................................... 52
Modificant lists..................................................................................................................................................... 52
Obtenint informació sobre “lists”................................................................................................................. 52
5.5 Mutabilitat i Aliasing.............................................................................................................................................. 54
4
Mutabilitat............................................................................................................................................................. 54
Aliasing.................................................................................................................................................................... 54
5.6 Function range.......................................................................................................................................................... 55
Introducció............................................................................................................................................................ 55
Mòdul 6: For Loops Sobre Indexos, Parallel i Nested Lists and Strings, i File.........................59
6.1 for loops sobre índexos........................................................................................................................................... 59
range........................................................................................................................................................................ 59
Iterant sobre els index d’una llista............................................................................................................... 59
No és "Què" sinó "On"........................................................................................................................................ 61
Exemple 1............................................................................................................................................................... 61
Exemple 2............................................................................................................................................................... 61
6.2 Parallel Lists and Strings...................................................................................................................................... 62
Elements corresponents.................................................................................................................................. 62
Exemple de Elements corresponents.......................................................................................................... 63
6.3 Nested Lists................................................................................................................................................................. 63
6.4 Nested Loops............................................................................................................................................................... 64
Cossos dels bucles............................................................................................................................................... 64
Exemple de Nested Loops................................................................................................................................ 65
6.5 Reading Files.............................................................................................................................................................. 65
Obrir i Tancar un arxiu...................................................................................................................................... 65
Exemples................................................................................................................................................................ 67
L’enfocament readline....................................................................................................................................... 67
L’enfocament for line in file......................................................................................................................................... 67
L’enfocament read........................................................................................................................................................... 67
L’enfocament readlines................................................................................................................................................. 67
6.6 Write Files.................................................................................................................................................................... 68
Escriure en un arxiu dins d’un programa en Python............................................................................ 68
File dialogs............................................................................................................................................................. 68
Exemple.................................................................................................................................................................. 68
Mòdul 7: Tuples i Dictionaries.............................................................................................................. 70
7.1 Tuples............................................................................................................................................................................. 70
Seqüències Immutables.................................................................................................................................... 70
7.2 Type dict....................................................................................................................................................................... 71
Diccionari............................................................................................................................................................... 71
Com modificar diccionaris............................................................................................................................... 72
Accés a la informació dels diccionaris........................................................................................................ 72
Diccionaris buits.................................................................................................................................................. 73
Diccionaris heterogenis.................................................................................................................................... 73
Claus Immutables................................................................................................................................................ 73
7.3 Inversió d’un diccionari......................................................................................................................................... 73
Canviar Claus i Valors........................................................................................................................................ 73
Mapejar una Clau a una Llista........................................................................................................................ 74
5
6
Mòdul 1: Python,
Variables, i Funcions
1.1 Introducció: Instal·lant Python

Llenguatges de programació
Els programes es poden trobar en un munt de llocs, per exemple en teu ordinador,
mòbil, o a Internet. Un programa és un conjunt d’instruccions que s’executen. Hi ha
molts llenguatges de programació, per aquest curs utilitzarem el llenguatge Python.
Python
Per executar programes amb Python, descarregueu Python 3. Aquesta descarrega

també inclou un programa anomenat IDLE:
1. Visita http://python.org/download/releases/3.2.3/ per descarregar Python

3.2.3
2. Depenen del teu sistema operatiu, segueix els següents passos:
o Linux: utilitza el teu paquet instal·ladorper descarregar Python 3
o Windows: descarrega Windows x86 Installer (3.2.3) (sig)
o Mac OS X 10.6 and 10.7: descarrega Mac OS X 64-bit/32-bit Installer
(3.2.3)
o Mac OS X 10.3 through 10.6: descarrega Mac OS X 32-bit i386/PPC
Installer (3.2.3)
Nota: si utilitzeu un Mac, també necessitareu descarregar Tcl/Tk. Clica aquí per
descarregar ActiveTcl.
Una vegada hagueu descarregat Python, podeu buscar IDLE en la carpeta de
Python.
7
1.2 Python com una Calculadora
Operadors Aritmètics
Operador Operació Expressió Descripció Resultat

+ suma 11 + 56 11 més 56 67
- resta 23 - 52 23 menys 52 -29
* multiplicació 4 * 5 4 multiplicat per 5 20
** exponenciació 2 ** 5 2 a la potència de 32
5
/ divisió 9 / 2 9 dividit per 2 4.5
// divisió entera 9 // 2 9 dividit per 2 4
% mòdul (residu) 9 % 2 9 mòdul 2 1
Types int i float
Un tipus (type) és un conjunt de valors i operacions que es poden realitzar amb

aquells valors.
Tipus numèrics de Python (types):
 int: integer
Per exemple: 3, 4, 894, 0, -3, -18
 float: floating point number (una aproximació a un número real)
Per exemple: 5.6, 7.342, 53452.0, 0.0, -89.34, -9.5
Prioritat o preferència d’operadors aritmètics

Quan múltiples operadors són combinats en una sola expressió, les operacions són avaluades en ordre de
prioritat o preferència.
Operador Prioritat
** La més alta
- (negació)
*, /, //, %
+ (suma), - (resta) La més baixa
Sintaxis i Semàntica
Sintaxi: les regles que descriuen combinacions vàlides dels símbols de Python.
Semàntica: el significat de les combinacions dels símbols de Python, és el significat

d’una instrucció- que és una combinació particular que fa que s’executi la
instrucció.
8
Errors
Un “SyntaxError” ocorre quan executem una instrucció amb una sintaxi invàlida.
Per exemple:
>>> 3) + 2 * 4
SyntaxError: invalid syntax
Un error semàntic ocorre quan una instrucció amb semàntica invàlida és executada.
Per exemple:
>>> 89.4 / 0
Traceback (most recent call last):
File "", line 1, in
89.4 / 0
ZeroDivisionError: float division by zero
9
1.3 Variables
Instrucció d’assignació
La forma general d’una sentencia d’assignació és:
variable = expressió
Exemple d’instruccions d’assignació:
>>> base = 20
>>> height = 12
>>> area = base * height / 2
>>> area
120.0
Les regles per executar una instrucció d’assignació són:
1. Avalua l’expressió. Això produeix una adreça de memòria.

2. Guarda l’adreça de memòria dins la variable.
Nom de les variables
Les regles per a noms legals amb Python són:
1. Els noms han de començarà amb una lletra o _.

2. Els noms han de contenir sols lletres, dígits, i _.
Amb Python, en la majoria de situacions, la convenció és usar guió baix

pothole_case.
10
1.4 Built-in Functions
Crida d’una funció
La forma general d’una crida a una funció és:
function_name(arguments)
Les regles per executar una crida a una funció:
1. Avalua els arguments.

2. Crida a la funció, passant als arguments els valors.
Terminologia:
 Argument: un valor donat a una funció

 Paràmetre: per proveir una funció
 Crida (Call): pregunta a Python per avaluar una funció
 Return: valor retornat
Exemple de crida una funció:
>>> abs(-23)
23
>>> abs(56.24)
56.24
Function dir
Python té un conjunt de built-in functions (funcions predeterminades). Per veure la

llista de funcions (built-in functions), executa dir(__builtins__):
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError',
'BaseException', 'BufferError', 'BytesWarning',
'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError',
'Exception', 'False', 'FloatingPointError', 'FutureWarning',
'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'ReferenceError', 'ResourceWarning',
'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError',
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning',
'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__',
'__import__', '__name__', '__package__', 'abs', 'all', 'any',
'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr',
11
'classmethod', 'compile', 'complex', 'copyright', 'credits',
'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec',
'exit', 'filter', 'float', 'format', 'frozenset', 'getattr',
'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int',
'isinstance', 'issubclass', 'iter', 'len', 'license', 'list',
'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object',
'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range',
'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
'zip']
Funció help
Per obtenir informació sobre una funció en particular, tenim la comanda help i el
paràmetre de la funció com argument. Per exemple:
>>> help(abs)
Help on built-in function abs in module builtins:
abs(...)
abs(number) -> number
Return the absolute value of the argument.
Arguments opcionals
En la descripció de la funció pow, el claudàtor [, z] indica que hi ha un tercer

argument i és opcional:
>>> help(pow)
Help on built-in function pow in module builtins:
pow(...)
pow(x, y[, z]) -> number
With two arguments, equivalent to x**y. With three arguments,

equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
La funció pow pot ser cridada amb dos o tres arguments:
>>> pow(2, 5)
32
>>> pow(2, 5, 3)
2
1.5 Definint les funcions

Definicions de funcions
La forma general de definir una funció és :
def function_name(parameters):
body
12
 def: una paraula clau que indica que la definició d’una funció
 function_name: el nom de la funció
 paràmetres:
o els paràmetre(s) de la funció, poden ser 0 o més i estan separats per
una coma
o un paràmetre és una variable que el seu valor serà utilitzat quan la
funció es crida
 body:
o 1 o més instruccions, solen acabar amb la instrucció return
Exemple de la definició d’una funció:
def f(x):
return x ** 2
Sentència return
La forma general de la instrucció return:
return expressió
Les regles per executar una instrucció o sentència return:
1. Avalua l’expressió. Això produeix una adreça de memòria.

2. Torna enrere al lloc on ha estat cridada i surt del funció.
Crida a la funció
Les crides a una funció solen ser expressions i el seu resultat sol guardar-se a una
variable.
La forma general d’una crida a una funció:
function_name(arguments)
Les regles per executar una crida a una funció:
1. Avalua els arguments de les adreces de memòria.

2. Guarda les adreces memòria dels corresponents paràmetres.
3. Executa el cos de la funció (body).
Exemple d’una definició de funció i crides a l’esmentada funció:
>>> def area(base, height):
13
return base * height / 2
>>> area(3, 4)
6.0
>>> result = area(10, 7.45)
>>> result
37.25
Desant els teus programes en fitxers ".py"
Guardarem els nostres programes amb fitxers ".py". un fitxer pot tenir múltiples
definicions de funcions i altres sentències o instruccions. Abans de realitzar una
crida a una funció des d’un fitxer ".py" a la shell del IDLE, necessiteu primer
executar Run -> Run Module, o sinó la Shell no reconeixerà la crida a la funció.
14
15
Mòdul 2: Strings i
Dissenyant Funcions
2.1 Type str: Strings en Python

String Literal
U n string literal (cadena literal) és una seqüència de caràcters. En Python, aquest

tipus s’anomena str. Les cadenes en Python – comencen i acaben amb cometa
simple (') o doble cometes ("). Un string pot estar format per lletres, nombres i
caràcters especials. Per exemple:
>>> 'hello'
'hello'
>>> 'how are you?'
'how are you?'
>>> 'short- and long-term'
short- and long-term
Si una cadena comença amb una cometa simple, s’ha d’acabar amb una cometa
simple. El mateix s’aplica a cadenes amb cometes dobles. No es poden barrejar el
tipus de cometes.
Seqüències d’escapament
Per incloure cometes dins d’una cadena, utilitzeu un escape character (\) abans de
les cometes. En cas contrari, Python interpreta aquestes cometes com el final d’una
cadena i es produeix un error. Per exemple, el codi següent produeix un error
perquè Python no espera res després de la segona cometa:
>>> storm_greeting = 'wow, you're dripping wet.'

SyntaxError: invalid syntax
L a seqüència d’escapament \' indica que la segona cometa és simplement una

cometa, no el final de la cadena:
>>> storm_greeting = 'Wow, you\'re dripping wet.'

"Wow, you're dripping wet."
Un enfocament alternatiu és ficar una cadena entre cometes dobles quan la cadena
16
conté una cometa simple. Per exemple, quan fem servir cometes dobles per indicar
el principi i el final de la cadena, la cometa simple en you're no provoca un error:
>>> storm_greeting = "Wow, you're dripping wet."

"Wow, you're dripping wet."
String Operators
Expressió Descripció Exemple Sortida

str1 + str2 concatena str1 i print('ab' + 'c') abc
str2
str1 * int1 concatena int1 print('a' * 5) aaaaa
còpies de str1
int1 * str1 concatena int1 print(4 * 'bc') bcbcbcbc
còpies de str1
Nota: concatena significa que s’uneixen.
Els operands * i + quan s’utilitzen en cadenes compleixen les regles de

precedència estàndard.
Tots els altres operadors matemàtics donen un TypeError.
2.2 Input/Output and str Formatting

Function print
Python té una built-in function (funció integrada) anomenada print que mostra
missatges a l’usuari. Per exemple, la següent crida de funció mostra la cadena
"hello":
>>> print("hello")
hello
A la sortida anterior, es pot observar que hello es mostra sense les cometes. Les
cometes són només per al format de cadena intern de Python i no són vistes per
l’usuari.
La funció print també es pot cridar amb una expressió matemàtica com argument.
Python avalua l’expressió matemàtica primer i tot seguit, mostra el valor resultant a
l’usuari. Per exemple:
>>> print(3 + 7 - 3)
7
Finalment, print pot tenir més d’un argument. Cada parell d’arguments es separa
17
per una coma. Quan es mostren, s’insereix un espai entre ells. Per exemple:
>>> print("hello", "there")

hello there
return vs. print
Recorda: La forma general de la instrucció return :
return expressió
Quan s’executa una instrucció return, s’avalua l’expressió i produeix una adreça
de memòria.
 Què retorna la crida?

Retorna l’adreça de memòria.
 Què es mostra?
Res!
Un exemple de return:
>>> def square_return(num):

return num ** 2
>>> answer_return = square_return(4)
>>> answer_return
16
La forma general de crida a la funció print:
print(arguments)
Quan s’executa la crida a la funció print, s’avaluen els arguments i es produeixen

les adreces de memòria.
 Què retorna la crida?

Res!
 Què es mostra?
El valor(s) de les adreces de memòria es mostren per pantalla.
Un exemple de print:
>>> def square_print(num):

print("The square of num is", num ** 2)
>>> answer_print = square_print(4)
18
The square num is 16
>>> answer_print
>>>
Function input
La funció input és una built-in function que demana a l’usuari que introdueixi
alguna dada. El programa espera que l’usuari introdueixi l’entrada, abans
d’executar les instruccions següents. El valor retornat per aquesta funció és sempre
un string. Per exemple:
>>> input("What is your name? ")

What is your name? Jen
'Jen'
>>> name = input("What is your name? ")
What is your name? Jen
>>> name
'Jen'
>>> location = input("What is your location? ")
What is your location? Toronto
>>> location
'Toronto'
>>> print(name, "lives in", location)
Jen lives in Toronto
>>> num_coffee = input("How many cups of coffee? ")
How many cups of coffee? 2
'2'
Operacions amb strings
Operació Descripció Exemple Sortida

str1 + str2 concatena str1 i print('ab' + 'c') abc
str2
str1 * int1 concatena int1 print('a' * 5) aaaaa
còpies de str1
int1 * str1 concatena int1 print(4 * 'bc') bcbcbcbc
còpies de str1
Triple-cometes strings
Hem utilitzat cometes simples o cometes dobles per representar cadenes. El tercer
format de cadena, utilitza triple cometes. Un string amb triple cometes abasta
múltiples línies. Per exemple:
>>> print(''' How

are
you?''')
How
19
are
you?
Seqüències d’escapament
Python té un caràcter especial escape character: \. Quan el caràcter d’escapament

s’utilitza en una cadena, el caràcter que segueix al caràcter d’escapament és tractat
de manera diferent de la normal. El caràcter d’escapament juntament amb el
caràcter que el segueix a continuació és una seqüència d’escapament . La taula que es
mostra a continuació, conté algunes de les seqüències d’escapament de Python més comuns.
Seqüència Nom Exemple Sortida

d’escapament
\n newline (ASCII print('''How How
linefeed - LF) are are
you?''') you?
\t tab (ASCII print('3\t4\t5') 3 4 5
horizontal tab -
TAB)
\\ backslash (\) print('\\') \
\' single quote (') print('don\'t') don't
\" double quote (") print("He He says, "hi".
says, \"hi\".")
20
2.3 Funció Design Recipe
Els Sis Passos
1. Exemples
o Què ha de fer la funció?
o Escriure un parell de crides d’exemple.
o Triar un nom (normalment un verb o frase verbal): Que sigui una
resposta breu de "Què fa la funció"?
2. Type Contract
o Quins són els tipus dels paràmetres?
o Quin és el tipus del valor retornat?
3. Header
o Triar noms de paràmetre significatius
4. Descripció
o Menció de cada paràmetre en la descripció.
o Descriure el valor de retorn.
5. Body
o Escriure el cos de la funció.
6. Test
o Provar els exemples.
Aplicar el Design Recipe
El problema:
Als Estats Units mesuren la temperatura en graus Fahrenheit i a Catalunya es

mesuren en graus Celsius. A un viatger que visita sovint els dos països li seria
d’ajuda tenir una funció de conversió. Escriu una funció que converteixi graus
Fahrenheit a Celsius.
1. Exemples
>>> convert_to_celsius(32)
0
100
2. Type Contract
21
(number) -> number
3. Header
def convert_to_celsius(fahrenheit):
4. Descripció
Return the number of Celsius degrees equivalent to fahrenheit

degrees.
5. Body
return (fahrenheit - 32) * 5 / 9
6. Test
Provar els exemples.
Solució:
def convert_to_celsius(fahrenheit):
''' (number) -> number
Return the number of Celsius degrees equivalent to Fahrenheit

degrees.
>>> convert_to_ccelsius(32)
0
100
'''
return (fahrenheit - 32) * 5 / 9
22
2.4 Funció Reutilitzable
Cridar funcions dins d’altres definicions de funció
El problema: Calcular el semi-perímetre d’un triangle.
L’enfocament: La funció semiperimeter crida a la funció perimeter.
def perimeter(side1, side2, side3):

'''(number, number, number) -> number
Return the perimeter of a triangle with sides of length

side1, side2 and side3.
>>> perimeter(3, 4, 5)
12
>>> perimeter(10.5, 6, 9.3)
25.8
'''
return side1 + side2 + side3
def semiperimeter(side1, side2, side3):

'''(number, number, number) -> float
Return the perimeter of a triangle with sides of

length side1, side2 and side3.
>>> semiperimeter(3, 4, 5)
6.0
>>> semiperimeter(10.5, 6, 9.3)
12.9
'''
return perimeter(side1, side2, side3) / 2
Cridar funcions dins d’altres crides a funcions
El problema: Un triangle té una base de 3.8 de longitud i una alçada de 7.0 de

longitud. Un segon triangle té una base de 3.5 de longitud i un alçada de 6.8 de
longitud. Calcula quin dels dos triangles té l’àrea més gran.
L’enfocament: Passar crides a la funció area com argument de la built-in function
23
max.
max(area(3.8, 7.0), area(3.5, 6.8))
2.5 Funcions, Variables, i la Call Stack

Explorant el codi
En aquest apartat anem a explorar quan es creen les variables, quant de temps
existeixen en la memòria del computador i que passa quan dues variables tenen el
mateix nom i dues funcions diferents.
A continuació, es mostra el codi de la funció convert_to_minutes i la funció

convert_to_seconds, que converteix un nombre d’hores a un nombre equivalent
d e s e g o n s . L a f u n c i ó convert_to_seconds c r i d a a l a f u n c i ó
convert_to_minutes i després multiplica el resultat per 60.
def convert_to_minutes(num_hours):
'''(int) -> int
Return the number of minutes there are in num_hours hours.
'''
minutes = num_hours * 60
return minutes
def convert_to_seconds(num_hours):
''' (int) -> int
Return the number of seconds there are in num_hours hours.
'''
minutes = convert_to_minutes(num_hours)
seconds = minutes * 60
return seconds
seconds = convert_to_seconds(2)
Python primer defineix les dues funcions, crea els objectes de funció en la
capçalera, i, a continuació observem que en el stack frame (marc de pila) de
__main__, crea les variables que fan referencia a les dues funcions objecte:
convert_to_minutes i convert_to_seconds.
24
En executar-se la instrucció d’assignació en la línia 20. Al costat dret de la
sentència d’assignació és crida a una funció, per tant, avaluarem el primer
argument. A continuació, obtindrem un marc per la funció convert_to_seconds
que apareixerà en la part superior de la pila. Aquest marc contindrà el paràmetre,
num_hours, que fa referència al valor 2.
La primera línia en el cos de funció convert_to_seconds és una sentencia

d’assignació. Seguim la mateixa regla de sempre, sempre avaluem el costat dret
primer. Aquesta és una crida a una funció i quan executem la crida de funció,
avaluem l’argument num_hours. Aquest produeix l’adreça de memòria x3, que té
el valor 2. S’afegeix stack frame per la funció convert_to_minutes a la part
superior de la call stack. Python passa la direcció de memòria x3 de parameter a
convert_to_minutes, que també passa a anomenar-se num_hours.
25
Podem veure que hi ha dues variables anomenades num_hours en la call stack;
una en la funció convert_to_minutes i l ’ a l t r e e n l a f u n c i ó
convert_to_seconds. Python manté aquestes dues funcions executant-se en
àrees separades de memòria, per a que no hi hagi confusió sobre quina variable
utilitzar.
La següent línia de codi que executa Python és minutes = num_hours * 60.

Però, quina instància de num_hours utilitzarem? Python sempre utilitza la variable
que està en el marc superior de la call stack. En la sentència d’assignació, si la
variable no existeix en el marc superior de la pila, Python la crea. Així un cop,
minutes és avaluada, la variable minutes es crea en el marc superior de la call
stack.
La última línea de la funció és return minutes. Un cop es completi aquesta

instrucció, Python retornarà just al marc de sota de la part superior de la call stack.
26
Python produeix l’adreça de memòria x4 (l’adreça de memòria conté el valor 120),
esborra el marc superior de la pila, crea una nova variable anomenada minutes en
el marc de pila convert_to_seconds, i emmagatzema x4 en aquesta variable.
Python llavors avalua seconds = minutes * 60. En aquesta instrucció

d’assignació, Python avalua el costat dret, obtenint el resultat 7200, i
emmagatzema l’adreça de memòria d’aquest resultat en la variable seconds. Com
aquesta variable encara no existeix, es crea en el marc superior de la call stack.
27
La següent instrucció return seconds és una instrucció de retorn. Com hem vist
anteriorment, aquesta retornarà el control al mòdul main.
Un cop el marc per convert_to_seconds s’elimini, la instrucció d’assignació a la

línia 20 (que ha estat esperant molt de temps!) es completa, i es crea una nova
variable seconds en el marc de pila del mòdul __main__ que conté l’adreça de
memòria x5.
28
Nota Important
Instrucció assignació i la memòria del computador
variable = expression
Si una variable no existeix en el marc de pila a la part superior de la call stack,

Python la crea.
Instrucció Return statement i la memòria del computador
return expression
A més d’avaluar l’expressió i d’obtenir el seu valor, return també esborra el marc de
pila a la part superior de la call stack.
29
Mòdul 3: Booleans,
Import, Namespaces, i
Sentència if
3.1 Tipus (Type) bool: Booleans amb
Python
Valors Booleans
El tipus (type) bool té dos valors: True i False.
Operadors de comparació
L’operador de comparació pot tenir dos valors i produeix un valor booleà (Boolean).
Descripció Operador Exemple Resultat de l’exemple

menor que < 3 < 4 True
més gran que > 3 > 4 False
igual a == 3 == 4 False
més gran o igual que >= 3 >= 4 False
menor o igual que <= 3 <= 4 True
no igual a != 3 != 4 True
Operadors lògics
Hi ha també tres operadors lògics que produeixen un valor booleà (Boolean): and,
or, i not.
Descripció Operador Exemple Resultat de l’exemple

not not not (80 >= 50) False
and and (80 >= 50) and False
(70 <= 50)
or or (80 >= 50) or True
(70 <= 50)
30
and Taula lògica
L’operador and avalua com True si les dues expressions són True.
Tanmateix, si el primer operand és False, el segon operand de la condició no serà

comprovat, ja que el conjunt de l’expressió donarà i avaluarà com False.
expr1 expr2 expr1 and expr2

True True True
True False False
False True False
False False False
or Taula lògica
L’operador or avalua com True si almenys un operand és True.
Tanmateix, si el primer operand és True, el segon operand de la condició no será

comprovat, ja que l’expressió s’avaluarà o donarà True.
expr1 expr2 expr1 or expr2

True True True
True False True
False True True
False False False
not Taula lògica
L’operador not avalua True si i sols si l’operand és False.
expr1 not expr1

True False
False True
La doble negació es pot simplificar. Per exemple, l’expressió not not (4 == 5)

pot ser simplificada a 4 == 5.
Ordre de prioritat del operadors lògics
L’ordre de prioritat pels operadors lògics és: not, and, i llavors or. Podem
modificar la prioritat utilitzant parèntesis, que també es poden afegir per clarificar
les coses i fer-les quelcom més entenedores i fàcils de llegar i comprendre.
Per exemple, l’operador not s’aplica abans de l’operador or dins del següent
codi:
>>> grade = 80
>>> grade2 = 90
31
>>> not grade >= 50 or grade2 >= 50
True
Els parèntesis es poden afegir per fer-ho més clar i comprensible:
(not grade >= 50) or (grade2 >= 50)
Alternativament, els parèntesis es poden afegir per canviar l’ordre de les

operacions:
not ((grade >= 50) or (grade2 >= 50))
3.2 Convertint entre int, str, i float

str
Builtin function str : prèn com a paràmetre qualsevol valor i retorna un string de la
representació d’aquest valor.
>>> str(3)
'3'
>>> str(47.6)
'47.6'
int
Builtin function int : prèn un string que conté sols dígits (possibilitat del signe
negatiu -) i retorna el int que representa. La funció int també converteix valors
float (coma flotant) a enters (integers), deixant de banda la part fraccionaria.
>>> int('12345')
12345
>>> int('-998')
-998
>>> int(-99.9)
-99
Si la funció int es crida amb un string que conté qualsevol cosa excepte dígits
genera un ValueError.
>>> int('-99.9')
File "", line 1, in <module>
Int(‘-99.9’)
ValueError: invalid literal for int() with base 10: '-99.9'
float
Builtin function float : prèn un string que conté sols dígits i zero o més decimals
32
separats per punt (possibilitat del signe negatiu - ) i retorna el valor de float que
representa. La funció float també converteix els valors int a floats.
>>> float('-43.2')
-43.2
>>> float('432')
432.0
>>> float(4)
4.0
Si la funció float és cridada amb un string que no es pot convertir, generarà un

ValueError.
>>> float('-9.9.9')
float('-9.9.9')
ValueError: could not convert string to float: '-9.9.9'
3.3 Import: Utilitzant Non-Builtin

Functions
Modules
Python conté moltes funcions, però no totes estan disponibles immediatament com
builtin functions. Solsament estaran disponibles com builtins, algunes funcions
guardades en els diferents mòduls. Un mòdul (module) és un fitxer que conté
definicions de funcions i instruccions.
També podem definir els nostes propis mòduls amb les nostres funcions.
import
Per accedir a les funcions del mòdul, hem d’importar el primer el mòdul.
La forma general d’importar un mòdul és amb l’instrucció import:
import module_name
Per tal d’utilitzar una funció dins d’un mòdul, podem utilitzar:
module_name.function_name
Per exemple, podem importar el mòdul de Python math i cridar a la funció sqrt del
mòdul:
import math
def area2(side1, side2, side3):
semi = semiperimeter(side1, side2, side3)
33
area = math.sqrt(semi * (semi - side1) * (semi - side2) * (semi - side3))
return area
Addicionalment per importar mòduls amb Python, podem també importar els
mòduls que escrivim. Per exemple, si tinguéssim un fitxer triangle.py amb una sèrie
de funcions sobre l’àrea del triangle, podríem importar triangle: import triangle.
El mòdul haurà d’estar al mateix directori per a poder importar-lo.
3.4 La sentència if
La sentència IF es pot utilitzar per controlar quines instruciions s’executen. Sota
està la forma general:
if expression1:
body1
[elif expression2: 0 or more clauses
body2]
[else: 0 or 1 clause
bodyN]
elif supleix i és igual "else if", serà una altra condició.
Per executar una sentència if, s’avalua cada expressió en ordre des dalt fins a
baix. Si una expressió s’avalua com True, s’executa la part del cos (body) de la
següent clàusula i s’omet la resta de la sentència if .Si hi ha un else, i cap de les
expressions s’avalua True, llavors s’executa la part del cos (body) del else.
Per exemple, donada aquesta funció:
def report_status(scheduled_time, estimated_time):

''' (float, float) -> str '''
if scheduled_time == estimated_time:
return 'on time'
elif scheduled_time > estimated_time:
return 'early'
else:
return 'delayed'
Dins la shell:
>>> report_status(14.3, 14.3)

'on time'
'early'
'delayed'
Una nota sobre None
34
Quan una execució d’una funció acaba sense haver executat una sentència
return, la funció retorna el valor None. Aquest tipus (type) : None és NoneType
(Cap tipus).
Per exemple, analitza aquesta funció:
def report_status(scheduled_time, estimated_time):

''' (float, float) -> str
Return the flight status (on time, early, delayed) for a flight that was
scheduled to arrive at scheduled_timed, but is now estimated to arrive at
estimated_time.
Pre-condition: 0.0 <= scheduled_time < 24.0 and 0.0 <= estimated_time < 24.0

'on_time'
'early'
'delayed'
'''
if scheduled_time == estimated_time:
return 'on time'
Dins la shell:
>>> report_status(14,3, 14.3)

'on time'
>>> print(report_status(12.5, 11.5))
None
Perquè el tipus (type): None és NoneType, no str, aquest trenca Type Contract
( o sigui el tipus retornat). Per arreglar això caldria i necessitaríem completar la resta
de la funció.
3.5 Innecessari if
És molt comú pels nous programadors escriure un codi com el següent:
def is_even(num):
''' (int) -> bool
Return whether num is even.
'''
if num % 2 == 0:
return True
else:
return False
això funciona, però és d’estil qüestionable. És més llarg d’escriure i de llegir i és

innecessari!
35
num % 2 == 0 ja avalua com True o False, per tant l’expressió es podria
expressar amb una única sentència return:
def is_even(num):
''' (int) -> bool
Return whether num is even.
'''
return num % 2 == 0
3.6 Estructurant la sentència if

if-elif vs. if-if
Una sentència if amb una clàusula elif és simplement una sentència que té
més condicions. L’expressions són avaluades des dalt fins a baix i si una
d’aquestes sentències s’avalua com a True o no hi ha més sentències per avaluar
a l’esquerra acaba la sentència. Quan una expressió s’avalua com a True, el cos
(body) associat o bloc és executat i llavors té sentit la sentència if. Qualsevol
subseqüència serà ignorada. Per exemple:
grade1 = 70
grade2 = 80
if grade1 >= 50:

print('You passed a course with grade: ', grade1)
elif grade2 >= 50:
La sentència if amb la condició (grade1 >= 50) s’avalua com True, llavors el
cos (body) associat serà executat si existeix cos(body). La condició de elif no
serà avaluada en aquest cas.
És possible per les sentències if aparèixer una darrera l’altra dins d’un programa.
Si més no, poden no tenir res a veure i poden ser completament independents una
de l’altra, i es poden executar totes dues. Per exemple:
grade1 = 70
grade2 = 80
if grade1 >= 50:

if grade2 >= 50:
Al programa anterior, la condició associada amb la primera sentència if (grade1

>= 50) s’avalua com True, per tant el cos(body) serà executat. La segona
condició associada la segona sentència if (grade2 >= 50) també s’avalua com
True, així que també serà executat el cos(body) associat.
36
Anidats (Nested) ifs
És possible incloure una sentència if dins del cos(body) d’un alte if. Per exemple:
if precipitation:
if temperature > 0:
print('Bring your umbrella!')
else:
print('Wear your snow boots and winter coat!)
La sentència anterior podria ser simplificada esborrant anidament (nesting) . El

missatge 'Bring your umbrella!' serà imprimit per pantalla sols si les dues
condicions de les dues sentències if són True. El missatge 'Wear your snow
boots and winter coat!' serà imprimit sols quan la primera condició sigui
True, però la segona condició sigui False. El següent codi és equivalent a
l’anterior:
if precipitation and temperature > 0:

print('Bring your umbrella')
elif precipitation:
print('Wear your snow boots and winter coat!')
37
38
Mòdul 4: For Loops i
Manipulació String
4.1 Més Operadors str
Comparació d’strings
Els operadors d’igualtat i diferent es poden aplicar a Strings:
>>> 'a' == 'a'

True
>>> 'ant' == 'ace'
False
>>> 'a' == 'b'
False
>>> 'a' != 'b'
True
Nosaltres podem comparar dos Strings per ordre d’alfabètic lletra a lletra:
>>> 'abracadabra' < 'ace'

True
>>> 'abracadabra' > 'ace'
False
>>> 'a' <= 'a'
True
>>> 'A' < 'B'
True
Les majúscules són més petites que les:
>>> 'a' != 'A'

True
>>> 'a' < 'A'
False
Cada lletra pot ser comparada:
>>> ',' < '3'

True
Podem comparar un string i un integer amb igualtat:
39
>>> 's' == 3
False
No podem comparar valors de diferents tipus amb ordre (o sigui >,<):

>>> 's' <= 3
's' <= 3
TypeError: unorderable types: str() <= int()
Provant Substrings
L’operador in comprova que un string estigui dins de l’altre (és a dir si un substring
està dins del String principal).
>>> 'c' in 'aeiou'

False
>>> 'cad' in 'abracadabra'
True
>>> 'zoo' in 'ooze'
False
Longitud String: funció len
La builtin function len retorna el número de caràcters que hi ha dins String:
>>> len('')
0
>>> len('abracadabra')
11
>>> len('Bwa' + 'ha' * 10)
23
Resum
Descripció Operador Exemple Resultat de

l’exemple
igualtat == 'cat' == 'cat' True
desigualtat != 'cat' != 'Cat' True
menor que < 'A' < 'a' True
més gran que > 'a' > 'A' True
menor que o igual <= 'a' <= 'a' True
més gran o igual >= 'a' >= 'A' True
conté in 'cad' in 'abracadabra' True
longitud de str s len(s) len("abc") 3
40
4.2 str: indexing i slicing
Indexing
Un índex és una posició dins d’un string. Positiu indica que comença a l’esquerra i
ascendentment, sempre començant pel 0, el següent 1 , i així successivament. Si és
negatiu indica que comença a comptar per la dreta i l’últim caràcter és -1, el
penúltim -2 i així successivament. Per l’string "Learn to Program", seria així:
El primer caràcter de string està al índex 0 i accedim utilitzant brackets

(claudàtors) :
>>> s[0]
'L'
>>> s[1]
'e'
L’índex negatiu indica que comença a comptar pel final de String (o sigui a mà
dreta):
>>> s[-1]
'm'
>>> s[-2]
'a'
Slicing
Es pot extraure un o conjunts de caràcters utilitzant slicing. Un slice és un

substring que té uníndex d’inici i un de final, però del inici al final ja que sinó seria la
totalitat de String. Per exemple:
>>> s[0:5]
'Learn'
>>> s[6:8]
'to'
>>> s[9:16]
'Program'
Generalment, el final de string pot ser representat usant la longitud de string:
41
>>> s[9:len(s)]
'Program'
L’índex final pot ser omès i agafa per defecte len(s):
>>> s[9:]
'Program'
De manera similar, si l’índex de inici és omès, comença per l’índex 0:
>>> s[:]
'Learn to Program'
>>> s[:8]
'Learn to'
Els indexos negatius es poden usar també per realitzar slicing. Les següents 3
expressions són equivalents:
>>> s[1:8]
'earn to'
>>> s[1:-8]
'earn to'
>>> s[-15:-8]
'earn to'
Modificant Strings
Les operacions de slicing i indexing no modifiquen la cadena (string), per tant la

cadena s no canvia amb les operacions anteriors. De fet, una cadena no es pot
modificar. Operacions com aquesta donarien error:
>>> s[6] = 'd'

File <"pyshell#19", line 1, in <module>
s[6] = 'd'
TypeError: 'str' object does not support item assignment
Imagina que volem canviar aquest string s referit a 'Learned to Program'. La

següent expressió s’avalua com 'Learned to Program': s[:5] + 'ed' +
s[5:]
La variable s pren un nou string : s = s[:5] + 'ed' + s[5:]
Observa que la cadena s original no s’ha modificat: els strings no es poden

modificar. Com a conseqüència és crea un nou string i es canvia s per a que
apunti a aquest string.
42
4.3 str Methods: Funcions pels
Objectes
Mètodes
Un mètode és una funció dins d’un objecte.
La forma general de cridar és :
object.method(arguments)
String Methods
Considera el codi:
>>> white_rabbit = "I'm late! I'm late! For a very important date!"
Per conèixer els seus mètodes utilitzem dir:
>>> dir(white_rabbit)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__','__getitem__',
'__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__',
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__',
'__rmul__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', 'capitalize', 'center', 'count', 'encode',
'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index',
'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier',
'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',
'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
'swapcase', 'title', 'translate', 'upper', 'zfill']
Passant str com un argument dir dóna el mateix resultat:
>>> dir(str)
Molts dels mètodes de String, retornen un nou string. Això implica que els string
són immutables, l’string original no canviarà. Per exemple, un versió en lowercase
(minúscules) de str referit a white_rabbit:
>>> white_rabbit.lower()
>>> "i'm late! i'm late! for a very important date!"
>>> white_rabbit
>>> "I'm late! I'm late! For a very important date!"
43
Per obtenir informació sobre un mètode , per exemple lower method, fes el
següent:
>>> help(str.lower)
4.4 Bucle for sobre str

For Loops
La forma general d’un bucle for sobre un string és:
for variable in str:

body
La variable es refereix a cada caràcter de l’string i executa el body del bucle per a
cada caràcter. Per exemple:
>>> s = 'yesterday'
>>> for char in s:
... print(char)
...
y
e
s
t
e
r
d
a
y
Patró d’acumulador: acumulador númeric
Considera el codi següent, on la variable num_vowels és un acumulador:
def count_vowels(s):
''' (str) -> int
Return the number of vowels in s. Do not treat letter y as a vowel
>>> count_vowels('Happy Anniversary!')

5
>>> count_vowels('xyz')
0
'''
num_vowels = 0
for char in s:
if char in 'aeiouAEIOU':
num_vowels = num_vowels + 1
44
return num_vowels
El bucle (loop) de la funció de dalt farà tants bucles com caràcters hi hagi a s. O
sigui el cos (body) del bucle serà executat tantes vegades com caràcters hi hagi, i
quan el caràcter sigui una vocal, la condició i f s e r à True i el valor de
num_vowels serà incrementat en una unitat.
La variable num_vowels és una acumulador, perquè acumula informació. Aquesta

variable la inicialitzem al valor 0 i al final de la funció haurà comptat el número de
vocals que hi ha en s.
Patró d’acumulador: acumulador de string
En la següent funció, la variable vowels també és un acumulador:
def collect_vowels(s):
''' (str) -> str
Return the vowels from s. Do not treat the letter

y as a vowel.
>>> collect_vowels('Happy Anniversary!')

'aAiea'
>>> collect_vowels('xyz')
''
'''
vowels = ''
for char in s:
if char in 'aeiouAEIOU':
vowels = vowels + char
return vowels
La variable vowels inicialment és un String buit, però al llarg del bucle(loop)

acumula les vocals que hi ha en s.
45
4.5 IDLE's Debugger
Debug Control
IDLE ve a ser un debugger, aquesta eina s’ha d’utilitzar quan executem un

programa, els passos que hem de seguir són:
1. Tenir una Shell de Python oberta, Debug->Debugger. Això obre una finestra
anomenada "Debug Control".
2. Comprova el vostre codi font.
3. Obre un fitxer de Python (tenen la extensió .py) on l’hagis guardat.
4. Selecciona Run->Run Module. Ara apareixerà el contingut al Debug.
Debug Window
Step és un pas a pas, que executa instrucció a instrucció del teu programa. La
finestra de Debug Control marcarà la línia que s’està executant. També veurem les
“variables locals” en un panell del costat, el valor i la pila del programa.
46
47
Mòdul 5: While Loops,
Lists, i Mutability
5.1 Bucle while
La forma general d’un bucle while:
while expressió:
instruccions
S’avalua la condició del while, num < 100, i si aquesta és True s’executen les
instruccions del cos del bucle. Tornem a avaluar la condició del bucle i si és True,
s’executa de nou el cos del bucle. I així successivament fins que l’avaluació de la
condició del bucle sigui False. For example:
>>> num = 2
>>> while num < 100:
num = num * 2
print(num)
4
8
16
32
64
128
En l’exemple anterior, hi ha 6 iteracions: el cos del bucle s’executa 6 vegades.
Condició del bucle i Lazy Evaluation
El problema: imprimeix els caràcter de str s, fins que trobi la primera vocal en s.
El primer intent per resoldre el problema funciona bé quan s conté una o més
vocals, però obtenim un error si en la cadena s no hi ha vocals:
>>> i = 0
>>> s = 'xyz'
>>> while not (s[i] in 'aeiouAEIOU'):
print(s[i])
i = i + 1
48
y
z
while not (s[i] in 'aeiouAEIOU'):
IndexError: string index out of range
En el codi anterior, l’error es produeix quan s és indexat a i, i i es troba fora del

rang d’índex vàlids. Per evitar aquest error, s’afegeix una condició addicional que
assegura que i està dins de l’interval d’índexs vàlids per s:
>>> i = 0
>>> s = 'xyz'
>>> while i < len(s) and not (s[i] in 'aeiouAEIOU'):
print(s[i])
i = i + 1
x
y
z
Com Python avalua la and usant lazy evaluation, si el primer operant és False,
llavors l’expressió s’avalua a False i el segon operant no s’avalua. Això impedeix
que es produexi IndexError.
5.2 Comentaris
El Perquè i el Com dels Comentaris
A mesura que els programes es fan més llargs, es recomana afegir alguna
explicació (en anglès) per ajudar als programadors a comprendre millor el codi.
Aquestes explicacions s’anomenen comentaris i documenten el nostre codi.
Els comentaris en Python comencen amb el caràcter (#) i acaben al final de línia.
Python ignora qualsevol línia que comenci per aquest caràcter.
Els comentaris fan els programes més llegibles, donen informació del propòsit de la
funció i de les relacions entre variables. Aquests ajuden a llegir/utilitzar el codi i a
recordar o comprendre el propòsit d’una determinada variable o funció en un
programa.
49
5.3 Type list
Introducció
Els programes acostumen a treballar amb col·leccions de dades. Una forma

d’emmagatzemar aquestes col·leccions de dades és usant el tipus list.
La forma general d’una llista:
[expr1, expr2, ..., exprN]
Per exemple, una llista amb tres graus:
grades = [80, 90, 70]
Operacions List
Igual que les cadenes (strings), les llistes es poden indexar:
>>> grades[0]
80
>>> grades[1]
90
>>> grades[2]
70
Les llistes també es poden tallar (sliced), utilitzant la mateixa notació que les
cadenes:
>>> grades[0:2]
[80, 90]
L’operador in pot aplicar-se per comprovar si un valor és un element de la llista.
>>> 90 in grades
True
>>> 60 in grades
False
Poden aplicar-se també, diverses built-in functions de Python, com:
 len(list): retorna la longitud de la llista list.

 min(list): retorna l’element més petit de la llista list.
 max(list): retorna l’element més gran de la llista list.
 sum(list): retorna la suma dels elements de la llista list (els elements de
la llista han de ser numèrics).
50
Per exemple, anem a veure algunes crides a built-in funcions:
>>> len(grades)
3
>>> min(grades)
70
>>> max(grades)
90
>>> sum(grades)
240
Tipus d’elements d’una llista
Els elements d’una llista poden ser de qualsevol tipus. Per exemple, una list de
str:
subjects = ['bio', 'cs', 'math', 'history']
Les llistes també poden contenir elements de més d’un tipus. Per exemple, una
adreça pot ser representada en una list de [int, str]:
street_address = [10, 'Main Street']
for bucle sobre list
Similar a recorre els caràcters d’una cadena, també es pot iterar sobre els elements
d’una llista. Per exemple:
>>> for grade in grades:

print(grade)
80
90
70
La forma general del bucle for sobre una list (llista):
for variable in list:

body
51
5.4 list Methods
Mètodes
Un mètode és una funció dins d’un objecte. Podem saber els mètodes del tipus
list escrivint dir(list).
Modificant lists
La taula següent mostra mètodes que modifiquen les llistes.
Mètode Descripció Exemple

list.append(object) Afegeix object al final >>> colours = ['yellow', 'blue']
de la llista >>> colours.append('red')
>>> print(colours)
['yellow', 'blue', 'red']
list.extend(list) Exten la llista afegint >>> colours.extend(['pink', 'green'])

tots els elements de la >>> print(colours)
['yellow', 'blue', 'red', 'pink',
llista passada per 'green']
paràmetre.
list.pop([index]) Esborra l’últim element >>> colours.pop()
de la llista; 'green'
>>> print(colours)
Si s’indica l’index, ['yellow', 'blue', 'red', 'pink']
elimina l’element >>> colours.pop(2)
corresponen a aquest 'red'
índex >>> print(colours)
['yellow', 'blue', 'pink']
list.remove(object) Esborra el primer >>> colours.remove('green')

element de la llista que Traceback (most recent call last):
File "", line 1, in
coincideixi amb el valor colours.remove('green')
de object; ValueError: list.remove(x): x not in
Error si no existeix. list
>>> colours.remove('pink')
>>> print(colours)
['yellow', 'blue']
list.reverse() Inverteix els elements >>> grades = [95, 65, 75, 85]
de la llista. >>> grades.reverse()
>>> print(grades)
[85, 75, 65, 95]
list.sort() Ordena la llista de >>> grades.sort()

menor a major. >>> print(grades)
[65, 75, 85, 95]
list.insert(int, Inserta object en >>> grades.insert(2, 80)

object) l’index int, movent els >>> print(grades)
[65, 75, 80, 85, 95]
elements de la llista.
Obtenint informació sobre “lists”

La taula següent mostra mètodes que retornen informació sobre les llistes.
52
Method Description Example
list.count(object) Retorna el nombre de >>> letters = ['a', 'a', 'b', 'c']
vegades que apareix >>> letters.count('a')
2
object en la llista.
list.index(object) Retorna l’índex de la >>> letters.index('a')
primera aparició de 0
>>> letters.index('d')
object en la llista; Traceback (most recent call last):
error si no troba File "", line 1, in
l’element object. letters.index('d')
ValueError: 'd' is not in list
53
5.5 Mutabilitat i Aliasing
Mutabilitat
Quan diem que les llistes són mutables: es poden modificar. La resta de tipus que
hem vist fins ara (str, int, float i bool) són immutables: no es poden modificar.
A continuació, es mostren varis exemples on es modifiquen les llistes:
>>> classes = ['chem', 'bio', 'cs', 'eng']

>>>
>>> # Podem afegir elements:
>>> classes.append('math')
>>> classes
['chem', 'bio', 'cs', 'eng', 'math']
>>>
>>> # Podem reemplaçar elements:
>>> classes[1] = 'soc'
>>> classes
['chem', 'soc', 'cs', 'eng', 'math']
>>>
>>> # Els elements es poden eliminar:
>>> classes.pop()
'math'
>>> classes
['chem', 'soc', 'cs', 'eng']
Aliasing
Observeu el següent codi:
>>> lst1 = [11, 12, 13, 14, 15, 16, 17]

>>> lst2 = lst1
>>> lst1[-1] = 18
>>> lst2
[11, 12, 13, 14, 15, 16, 18]
Després d’executar la segona instrucció, lst1 i lst2 fan referència a la mateixa

llista. Quan dues variables fan referència al mateix objecte, aquestes són aliases.
54
Si es modifica la llista, en l’exemple lst1, podem observar els canvis tant en lst1
com lst2.
5.6 Function range

Introducció
Python disposa de la builtin function range, que genera un rang de nombres. A

continuació es mostren les primeres línies de la consulta help(range):
class range(object)
55
| range([start,] stop[, step]) -> range object
|
| Returns a virtual sequence of numbers from start to stop by step.
Una crida a la funció range amb un argument int genera una llista de nombres
que va de 0 a int ( int no inclòs).
La funció range s’acostuma a utilitzar en un bucle for.
>>> for i in range(10):

print(i)
0
1
2
3
4
5
6
7
8
9
La funció len retorna la longitud d’una cadena, llavors range(len(s)) es pot

utilitzar per generar tots els índex dels caràcters en s:
>>> s = 'computer science'

>>> len(s)
16
>>> for i in range(len(s)):
print(i)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Una crida a la funció range amb 2 arguments, produeix una seqüència de nombres
que comença amb el primer argument i acaba amb el segon argument (no inclòs).
És a dir, range(1,20)genera la seqüència de nombres de 1 a 19.
56
>>> s = 'computer science'
>>> for i in range(1, len(s)):
print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Una crida a la funció range amb 3 arguments , produeix una seqüència de

nombres que comença amb el primer argument i acaba amb el segon argument (no
inclòs), el tercer argument indica l’increment en la seqüència de nombres.
>>> for i in range(1, len(s), 2):

print(i)
1
3
5
7
9
11
13
15
57
58
Mòdul 6: For Loops Sobre
Indexos, Parallel i
Nested Lists and
Strings, i File
6.1 for loops sobre índexos
range
A continuació, es mostra la part superior de l’ajuda per a range:
class range(object)
| range([start,] stop[, step]) -> range object
|
| Returns a virtual sequence of numbers from start to stop by step.
El valor stop no està inclòs.
range normalment s’utilitza en un bucle for loop per iterar una seqüència de
nombres. Per exemple:
# Iterar sobre els nombres 0, 1, 2, 3, i 4.

for i in range(5):
# Iterar sobre els nombres 2, 3, i 4.

for i in range(2, 5):
# Iterar sobre els nombres 3, 6, 9, 12, 15, i 18.

for i in range(3, 20, 3):
Iterant sobre els index d’una llista
La built-in function len retorna el nombre d’elements d’una llista, aquesta es pot
utilitzar amb range per iterar sobre tots els índex. Aquest bucle imprimeix tots els
valors en una llista:
for i in range(len(lst)):
print(lst[i])
59
Això, també ens dóna la flexibilitat de processar només part d’una llista. Per
exemple, podem imprimir només la primera meitat de la llista:
for i in range(len(lst) // 2):

print(lst[i])
O qualsevol altre element:
60
for i in range(0, len(lst), 2):
print(lst[i])
No és "Què" sinó "On"
Anteriorment, hem escrit bucles sobre els caràcters d’una cadena o elements d’una
llista. No obstant això, de vegades hi ha problemes on no n’hi ha prou en conèixer
el valor dels elements d’una llista o els caràcters en un string, sinó que necessitem
saber on es produeix (és a dir, el seu índex).
Exemple 1
El primer exemple es descriu a continuació:
def count_adjacent_repeats(s):
''' (str) -> int
Return the number of occurrences of a character and an adjacent

character being the same.
>>> count_adjacent_repeats('abccdeffggh')
3
'''
repeats = 0
for i in range(len(s) - 1):

if s[i] == s[i + 1]:
repeats = repeats + 1
return repeats
Volem comparar un caràcter de la cadena amb el caràcter del seu costat en la

cadena. Iterem sobre els índexs perquè la posició és important, i només coneixent
el valor del caràcter no tenim prou informació. Així aconseguim comptar caràcters
repetits en una cadena. No podem executar el cos del bucle si i és len(s) - 1
perquè comparem amb s[i + 1], i això produiria un IndexError.
Exemple 2
El segon exemple es descriu a continuació:
61
def shift_left(L):
''' (list) -> NoneType
Shift each item in L one position to the left and shift

the first item to the last position.
Precondition: len(L) >= 1
>>> shift_left(['a', 'b', 'c', 'd'])

'''
first_item = L[0]
for i in range(len(L) - 1):

L[i] = L[i + 1]
L[-1] = first_item
Pel mateix motiu que l’exemple anterior, només coneixent el valor dels elements de
la llista no és suficient, ja que necessitem saber on es troben els elements,
necessitem saber l’índex (posició) de l’element en la llista.
6.2 Parallel Lists and Strings

Elements corresponents
Dues llistes són paral·leles si tenen la mateixa longitud i els elements en tots els
índexs estan relacionats d’alguna manera. Els elements amb el mateix índex és diu
que estan en les posicions corresponents.
Considereu aquestes dues llistes:
list1 = [1, 2, 3]
list2 = [2, 4, 2]
En aquestes dues llistes, l’element corresponen de la list1[0] é s list2[0],

l’element corresponent de list2[1] is list1[1], i així successivament.
62
Exemple de Elements corresponents
def match_characters(s1, s2):
''' (str, str) -> int
Return the number of characters in s1 that are the same as the

character at the corresponding position of s2.
Precondition: len(s1) == len(s2)
>>> match_characters('ate', 'ape')

2
>>> match_characters('head', 'hard')
2
'''
num_matches = 0
for i in range(len(s1)):
if s1[i] == s2[i]:
num_matches = num_matches + 1
return num_matches
La funció anterior compta els elements corresponents de les dues cadenes que són
el mateix caràcter. Si un caràcter de s1 en l’índex i és el mateix que el caràcter de
s2 en el mateix índex, llavors incrementar num_matches per 1 (pel fet que
coincideixen). En cas contrari, continua amb el pròxim parell d’elements
corresponents i els compara.
6.3 Nested Lists

Les llistes poden contenir elements de qualsevol tipus, incloent altres llistes.
Aquestes es diuen nested lists (llistes aniuades).
Exemple:
>>> grades =[['Assignment 1',80],['Assignment 2',90], ['Assignment 3',70]]
>>> grades[0]
['Assignment 1', 80]
>>> grades[1]
>>> grades[2]
Per accedir a un nested item (element aniuat), primer selecciona la subllista, i

després tracta el resultat com una llista regular.
Per exemple, per accedir a 'Assignment 1', primer obtenim la subllista i després la
63
tractem com una llista regular:
>>> sublist = grades[0]

>>> sublist
>>> sublist[0]
'Assignment 1'
>>> sublist[1]
80
Ambdues sublist i grades[0] contenen l’adreça de memòria de la llista aniuada

Podem accedir als elements de les llistes aniuades de la següent manera:
>>> grades[0][0]
'Assignment 1'
>>> grades[0][1]
80
>>> grades[1][0]
'Assignment 2'
>>> grades[1][1]
90
>>> grades[2][0]
'Assignment 3'
>>> grades[2][1]
70
6.4 Nested Loops

Cossos dels bucles
Els cossos dels bucles poden contenir qualsevol declaració, incloent altres bucles.
Aquests es coneixen com a nested loop (bucles aniuats).
Un bucle aniuat implica 2 bucles for:
for i in range(10, 13):

for j in range(1, 5):
print(i, j)
El resultat:
10 1
10 2
10 3
10 4
11 1
11 2
11 3
11 4
12 1
64
12 2
12 3
12 4
Observa que quan i és 10, el bucle intern s’executa en la seva totalitat, i només
després de que j ha oscil·lat de 1 fins a 4, s’assigna a i el valor 11.
Exemple de Nested Loops

def calculate_averages(grades):
''' (list of list of number) -> list of float
Return a new list in which each item is the average of the

grades in the inner list at the corresponding position of
grades.
>>>calculate_averages([[70,75,80],[70,80,90,100],[80,100]])
[75.0, 85.0, 90.0]
'''
averages = []
# Calculate the average of each sublist and append it to

# averages.
for grades_list in grades:
# Calculate the average of grades_list.

total = 0
for mark in grades_list:
total = total + mark
averages.append(total / len(grades_list))
return averages
A la funció calculate_averages, el bucle for extern itera a través de cada subllista

en grades. A continuació es calcula la mitjana d’aquesta subllista utilitzant el bucle
aniuat o interior, i s’afegeix la mitjana a l’acumulador (la llista nova, averages).
6.5 Reading Files

Es pot accedir a la informació emmagatzemada en un fitxer amb un programa
Python. Per accedir al contingut d’un fitxer, es necessita obrir (open)l’arxiu en el
programa. Un cop s’han tractat les dades del fitxer, aquest s’ha de tancar (close).
Obrir i Tancar un arxiu
65
Python té una built-in function open que permet obrir un fitxer per a lectura.
La forma de open és open(filename, mode), on el mode 'r' (per obrir en mode

lectura), 'w' (per obrir en mode escriptura), or 'a' (per obrir per afegir en l’arxiu
existent).
Per obrir un arxiu anomenat In Flanders Fields.txt en mode lectura:
flanders_file = open('In Flanders Fields.txt', 'r')
Tingueu en compte, que si l’arxiu es guarda en el mateix directori que el programa,

simplement cal escriure el nom del fitxer, tal i com mostra l’exemple. No obstant
això, si el fitxer no es guarda en el mateix directori, s’ha de proporcionar la ruta
d’accés al fitxer.
Per tancar un arxiu, escriure flanders_file.close() .
Hi ha quatre formes estàndard per llegir d’un arxiu. Alguns usen aquests mètodes:
readline(): llegir i retornar la següent línia del fitxer, incloent el caràcter de nova
línia (si existeix). Retorna cadena buida si no hi ha més línies a l’arxiu.
readlines(): llegir i retornar totes les línies d’un fitxer en una llista. Les línies
inclouen el caràcter de nova línia (newline)
read(): llegeix l’arxiu sencer com una única cadena.
Enfocament Codi Quan s’ha

d’utilitzar
file = open(filename, 'r') Per processar
L’enfocament # Read lines until we reach the només part d’un
readline # place in the file that we want. l’arxiu.
line = file.readline()
while we are not at the place we want:
# Now we have reached the section

# of the file we want to process.
while we are not at the end of the section:
process the line
flanders_file.close()
L’enfocament file = open(filename, 'r') Per processar cada

for line in file for line in file: línia del fitxer d’una
process the line en una.
file.close()
L’enfocament file = open(filename, 'r') Per llegir tot l’arxiu

read contents = file.read() alhora i utilitzar-lo
com una única
now process contents
cadena.
66
file.close()
L’enfocament file = open(filename, 'r') Per examinar cada

readlines # Get the contents as a list of strings. línia d’un arxiu per
contents_list = file.readlines() índex
process contents_list using indexing to
access particular lines from the file
file.close()
Exemples
Els següents exemples, tots llegeixen l’arxiu sencer en una cadena i imprimeixen
aquesta cadena.
L’enfocament readline
flanders_file = open(flanders_filename, 'r')

flanders_poem = ''
line = flanders_file.readline()
while line != "":
flanders_poem = flanders_poem + line
line = flanders_file.readline()
print(flanders_poem)
L’enfocament for line in file

flanders_poem = ''
for line in flanders_file:

L’enfocament read

flanders_poem = flanders_file.read()
L’enfocament readlines
flanders_poem = ''
flanders_list = flanders_file.readlines()
67
for line in flanders_list:
6.6 Write Files

Escriure en un arxiu dins d’un programa en Python
Per escriure en un arxiu, fem servir file.write(str). Aquest mètode escriu una
cadena en un arxiu. El mètode write funciona com la funció print de Python,
excepte que no s’afegeix un caràcter de nova línia.
File dialogs
Mòdul tkinter té un submòdul anomenat filedialog. S’importa de la següent

forma:
import tkinter.filedialog
La funció askopenfilename demana a l’usuari que seleccioni un arxiu per obrir-lo:
tkinter.filedialog.askopenfilename()
Aquesta funció retorna la ruta completa de l’arxiu, per tant es pot utilitzar quan
cridem a la funció open per obrir el fitxer.
from_filename = tkinter.filedialog.askopenfilename()
La funció asksaveasfilename demana a l’usuari que seleccioni un fitxer per guardar,

i proporciona una advertència (warning) si el fitxer ja existeix.
to_filename = tkinter.filedialog.asksaveasfilename()
Exemple
A continuació, es mostra un programa que copia un fitxer, però posa "Copy" a la

primera línia de l’arxiu copiat.
Es sol·licita a l’usuari un arxiu.
A continuació, obrim l’arxiu que volem llegir i obtenim el seu contingut:
from_file = open(from_filename, 'r')

contents = from_file.read()
from_file.close()
Obrim el fitxer que volem escriure i escrivim el contingut:
68
to_file = open(to_filename, 'w')
to_file.write('Copy\n') # Afegim una nova línia pròpia.
to_file.write(contents) # Escrivim el contingut del fitxer.
to_file.close()
69
Mòdul 7: Tuples i
Dictionaries
7.1 Tuples
Seqüències Immutables
Les tuples són seqüències immutables: no es poden modificar. Les tuples i les
llistes tenen molt en comú, però les llistes són seqüències mutables: es poden
modificar.
Les tuples utilitzen parèntesis en lloc de claudàtors:

lst = ['a', 3, -0.2]
tup = ('a', 3, -0.2)
Un cop creats, els elements de les llistes i tuples s’accedeixen usant la mateixa
notació:
>>> lst[0]
'a'
>>> tup[0]
'a'
Slicing es pot utilitzar en ambdues:
>>> lst[:2]
['a', 3]
>>> tup[:2]
('a', 3)
Les tuples no es poden modificar:

>>> tup[0] = 'b'
TypeError: 'tuple' object does not support item assignment
Les tuples tenen menys mètodes que les llistes. De fet, els únics mètodes regulars
són count i index:
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__',
'__delitem__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
70
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__',
'append', 'count', extend', 'index', 'insert', 'pop', 'remove',
'reverse', sort'] >>> dir(tuple) ['__add__', '__class__',
'__contains__', '__delattr__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__',
'__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmul__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
La resta de mètodes de les llistes no estan disponibles per a les tuples, perquè
modifiquen l’objecte, i les tuples, són immutables, no es poden modificar.
Es pot utilitzar un for per iterar sobre els valors d’una tupla:
>>> tup = ('a', 3, -0.2)
>>> for item in tup:
print(item)
a
3
-0.2
Una tupla es pot passar com argument a la built-in function len:

>>> len(tup)
3
També és possible iterar sobre els índexs d’una tupla:

>>> for i in range(len(tup)):
print(tup[i])
a
3
-0.2
7.2 Type dict

Diccionari
Una altra forma d’emmagatzemar col·leccions de dades és utilitzant el tipus

diccionari de Python: dict.
La forma general d’un diccionari és:
{key1: value1, key2: value2, ..., keyN: valueN}
Les claus han de ser uniques. Els valors poden ser duplicats. Per exemple:
asn_to_grade = {'A1': 80, 'A2': 90, 'A3': 90}
71
En l’exemple anterior, les claus són úniques: 'A1', 'A2' i 'A3'. Els valors no són
únics: 80, 90 i 90.
Com modificar diccionaris
Els Diccionaris són mutables: es poden modificar. A continuació, es mostren les

operacions i mètodes que poden aplicar-se als diccionaris.
Operació Descripció Exemple

object in dict Comprova si un >>> asn_to_grade = {'A1': 80, 'A2': 90, 'A3': 90}
object és una >>> 'A1' in asn_to_grade
True
clau en dict. >>> 80 in asn_to_grade
False
len(dict) Retorna el >>> asn_to_grade = {'A1': 80, 'A2': 90, 'A3': 90}
nombre de >>> len(asn_to_grade)
3
claus en dict.
del dict[key] Esborra una >>> asn_to_grade = {'A1': 80, 'A2': 90, 'A3': 90}
clau i el seu >>> del asn_to_grade['A1']
>>> asn_to_grade
valor associat {'A3': 90, 'A2': 90}
del dict.
dict[key] = value Si key no >>> asn_to_grade = {'A1' : 80, 'A2': 90, 'A3':90}
existeix en dict, >>> asn_to_grade['A4'] = 70
>>> asn_to_grade
afegeix key i el {'A1': 80, 'A3': 90, 'A2': 90, 'A4': 70}
seu value
associat a
dict.
Si key existeix
en dict,
actualitza dict
per establir el
valor associat
amb la key per
value.
Accés a la informació dels diccionaris
Els diccionaris estan desordenats. És a dir, l’ordre en el que s’afegeix la parella

clau-valor al diccionari no afecta l’ordre en el que s’hi accedeix. Per exemple:
>>> asn_to_grade = {'A1': 80, 'A2': 70, 'A3': 90}
>>> for assignment in asn_to_grade:
print(assignment)
A1
A3
A2
El bucle-for anterior, imprimeix les claus del diccionari. També podem imprimir els
valors:
>>> asn_to_grade = {'A1': 80, 'A2': 70, 'A3': 90}
print(asn_to_grade[assignment])
80
90
70
Finalment, podem imprimir les claus i els valors:
72
>>> asn_to_grade = {'A1': 80, 'A2': 70, 'A3': 90}
print(assignment, asn_to_grade[assignment])
A1 80
A3 90
A2 70
Diccionaris buits
Un diccionari pot estar buit. Per exemple:

d = {}
Diccionaris heterogenis
Un diccionari pot tenir claus de diferents tipus. Per exemple, una clau pot ser de
tipus int i un altre de tipus str:
d = {'apple': 1, 3: 4}
Claus Immutables
Les claus d’un diccionari han de ser immutables. Per tant, les llistes, els diccionaris
i altres tipus mutables no poden utilitzar-se com a claus. El següent exemple, dóna
error:
d[[1, 2]] = 'banana'
Com les llistes són mutables, no poden ser claus. En el seu lloc, pots utilitzar un
tipus tuple, com a clau.
d[(1, 2)] = 'banana'
7.3 Inversió d’un diccionari

Canviar Claus i Valors
Els Diccionaris tenen claus que són úniques i cada clau té un valor associat a ella.
Per exemple, un diccionari que mapeja la fruita amb el seu color:
fruit_to_colour = {'watermelon': 'green', 'pomegranate': 'red', 'peach':

'orange', 'cherry': 'red', 'pear': 'green', 'banana': 'yellow', 'plum':
'purple', 'orange': 'orange'}
Per invertir el diccionari, és a dir, canviar el mapeig de colors a fruita. A continuació,

es mostra un enfoc:
73
>>> colour_to_fruit = {}
>>> for fruit in fruit_to_colour:
colour = fruit_to_colour[fruit]
colour_to_fruit[colour] = fruit
>>> colour_to_fruit
{'orange': 'orange', 'purple': 'plum', 'green': 'pear', 'yellow': 'banana',
'red': 'pomegranate'}
Al diccionari resultant hi falten varies fruites. Això succeeix perquè els colors, que
són claus, són únics. Com les darreres assignacions utilitzen el mateix color
reemplacen les entrades anteriors. Un manera de resoldre això, és mapejar colors a
una llista de fruites.
Mapejar una Clau a una Llista
En l’exemple anterior, hem de considerar dos casos, quan afegim un color i una
fruita al diccionari.
1. Si el color no és una clau en el diccionari, afegir-lo amb el seu valor que serà
un únic element de la llista de fruites.
2. Si el color ja és una clau, afegir la fruita a la llista de fruites associades amb
aquesta clau.
>>> colour_to_fruit = {}
>>> for fruit in fruit_to_colour:
# What colour is the fruit?
colour = fruit_to_colour[fruit]
if not (colour in colour_to_fruit):
colour_to_fruit[colour] = [fruit]
else:
colour_to_fruit[colour].append(fruit)
>>> colour_to_fruit
{'orange': ['peach', 'orange'], 'purple': ['plum'], 'green': ['watermelon',
'pear'], 'yellow': ['banana'], 'red': ['cherry', 'pomegranate']}
74

Aprendre A Programar2.0

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Aprendre A Programar2.0

Uploaded by

Copyright:

Available Formats

Aprendre a Programar

1.1 Introducció: Instal·lant Python

Per executar programes amb Python, descarregueu Python 3. Aquesta descarrega

1. Visita http://python.org/download/releases/3.2.3/ per descarregar Python

Operador Operació Expressió Descripció Resultat

Types int i float

Un tipus (type) és un conjunt de valors i operacions que es poden realitzar amb

Tipus numèrics de Python (types):

Prioritat o preferència d’operadors aritmètics

Semàntica: el significat de les combinacions dels símbols de Python, és el significat

La forma general d’una sentencia d’assignació és:

Exemple d’instruccions d’assignació:

Les regles per executar una instrucció d’assignació són:

1. Avalua l’expressió. Això produeix una adreça de memòria.

Nom de les variables

Les regles per a noms legals amb Python són:

1. Els noms han de començarà amb una lletra o _.

Amb Python, en la majoria de situacions, la convenció és usar guió baix

La forma general d’una crida a una funció és:

Les regles per executar una crida a una funció:

1. Avalua els arguments.

 Argument: un valor donat a una funció

Exemple de crida una funció:

Python té un conjunt de built-in functions (funcions predeterminades). Per veure la

Return the absolute value of the argument.

En la descripció de la funció pow, el claudàtor [, z] indica que hi ha un tercer

With two arguments, equivalent to x**y. With three arguments,

La funció pow pot ser cridada amb dos o tres arguments:

1.5 Definint les funcions

La forma general de definir una funció és :

Exemple de la definició d’una funció:

La forma general de la instrucció return:

Les regles per executar una instrucció o sentència return:

1. Avalua l’expressió. Això produeix una adreça de memòria.

La forma general d’una crida a una funció:

Les regles per executar una crida a una funció:

1. Avalua els arguments de les adreces de memòria.

Exemple d’una definició de funció i crides a l’esmentada funció:

>>> def area(base, height):

Desant els teus programes en fitxers ".py"

2.1 Type str: Strings en Python

U n string literal (cadena literal) és una seqüència de caràcters. En Python, aquest

>>> storm_greeting = 'wow, you're dripping wet.'

L a seqüència d’escapament \' indica que la segona cometa és simplement una

>>> storm_greeting = 'Wow, you\'re dripping wet.'

>>> storm_greeting = "Wow, you're dripping wet."

Expressió Descripció Exemple Sortida

Nota: concatena significa que s’uneixen.

Els operands * i + quan s’utilitzen en cadenes compleixen les regles de

Tots els altres operadors matemàtics donen un TypeError.

2.2 Input/Output and str Formatting

>>> print("hello", "there")

return vs. print

Recorda: La forma general de la instrucció return :

 Què retorna la crida?

>>> def square_return(num):

La forma general de crida a la funció print:

Quan s’executa la crida a la funció print, s’avaluen els arguments i es produeixen

 Què retorna la crida?

>>> def square_print(num):

>>> input("What is your name? ")

Operacions amb strings

Operació Descripció Exemple Sortida