Bases Llenguatge Python 18oct

Departament dInformticaGeneralitat de Catalunya Departament dEducaci

Crdit EDD Estructures dinmiques de dades

UD 1 Bases del llenguatge Pythonndex de continguts UD 1 Bases del llenguatge Python...........................................................................1NA1: Entorn de desenvolupament....................................................................................2 NA2: Sintaxi bsica de Python.........................................................................................3Variables....................................................................................................................................3 Referncies.............................................................................................................................4 Entrada i sortida.......................................................................................................................4 Sortida per pantalla.................................................................................................................4 Entrada des de teclat...............................................................................................................5 Arguments de la lnia de comandes........................................................................................6 Operadors..................................................................................................................................6 Control del flux d'execuci.......................................................................................................6 La sangria...............................................................................................................................6 Sentncies condicionals..........................................................................................................7 Sentncies iteratives...............................................................................................................7 Comentaris.................................................................................................................................8 Exercicis.....................................................................................................................................8 Errors i excepcions....................................................................................................................9 Errors......................................................................................................................................9 Excepcions I...........................................................................................................................9 Tractament de cadenes...........................................................................................................12 Les cadenes com a llistes......................................................................................................12 Les cadenes com a objectes de la classe str..........................................................................13 Exercicis...................................................................................................................................14 Funcions...................................................................................................................................15 Totes les variables sn locals a la funci.............................................................................15 El valor de retorn..................................................................................................................16 Valors per defecte.................................................................................................................16 Pas per referncia i pas per valor..........................................................................................17 Passar nombres i cadenes per referncia..............................................................................17 Arguments de paraula clau...................................................................................................17 Excepcions II...........................................................................................................................18 Excepcions en cadena...........................................................................................................18 Llanament d'excepcions......................................................................................................19 Exercicis...................................................................................................................................20

NA3: Recursivitat............................................................................................................20Concepte de recursivitat.........................................................................................................20 Exemples de funcions recursives...........................................................................................21 Clcul del factorial ..............................................................................................................21 Clcul del nombre de Fibonacci ..........................................................................................21 Clcul de l'inters compost ..................................................................................................22 Exercicis...................................................................................................................................22

Curs 2010-2011

1

Versi: 18oct



NA1: Entorn de desenvolupamentEl Python s un llenguatge interpretat multipropsit que t diversos avantatges: s, juntament amb el Perl, un dels llenguatges preferits per als administradors de sistemes. Gran part de GNU/Linux est escrit en Python. T una sintaxi molt clara i fcil d'aprendre. Ens podem aprofitar de l'existncia de gran quantitat de biblioteques (funcions ja fetes). Per exemple, baixar i analitzar una pgina web s una tasca bastant senzilla.

Hi ha dues formes de treballar amb el Python, de la mateixa manera que passa amb els scripts de Bash. El Python t el seu propi interpret de comandes. Per invocar-lo noms hem d'escriure en un intrpret (bash, cmd) la paraula python.$ python Python 2.6.6 (r266:84292, Aug 29 2010, 12:36:23) [GCC 4.4.5 20100824 (prerelease)] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>>

A l'intrpret s'hi poden escriure diverses comandes. Aqu, per exemple, s'ha escrit la comanda print Aix s l'intrpret de Python. L'intrpret ha interpretar l'ordre print i en conseqncia ha imprs per pantalla el que li hem dit. Les fletxes >>> ens indiquen el STDIN s a dir, l'entrada de carcters per pantalla. L'absncia de fletxes ens indica el STDOUT, s a dir, la sortida estndard. El STDERR, que s la sortida per als errors apareix tamb sense fletxes:>>> comanda_no_existeix Traceback (most recent call last): File "", line 1, in NameError: name 'comanda_no_existeix' is not defined >>>

Aquesta forma de treballar s til per a provar coses rpides, per generalment el que voldrem s fer un programa que contindr diverses lnies. Podem fer-ho utilitzant qualsevol editor de text. Normalment guardarem el programa amb l'extensi .py i desprs executar-lo amb:python el_nostre_programa.py

Per aconseguir la consola del python: En sistemes debian (ubuntu) ja ve installada. En sistemes windows: http://www.python.org/ftp/python/2.6.2/python-2.6.2.msi

Encara que la versi actual del Python s la 3 (Feb2009), treballarem amb l'ltima versi disponibles de la branca 2. Al nivell que ens movem no hi ha masses diferncies, per la versi 3 no s compatible (encara) amb algunes llibreries d'administraci de sistemes. Hem dit que podem utilitzar qualsevol editor de text, per existeixen editors que faciliten la feina perqu ens ressalten la sintaxi i inclouen funcions d'autocompleci. El primer editor que veure, l'IDLE, t com a avantatge principal la senzillesa. Per aconseguir la consola IDLE: En sistemes debian (ubuntu): installarem el paquet idle (apt-get install idle). En sistemes windows: s'installa juntament amb el Python amb l'msi anterior.

Un bon entorn de programaci s el PyDev, una extensi de l'Eclipse per a Python que t tots els avantatges de l'IDLE i tots els avantatges de l'entorn professional Eclipse, entre elles, magnfiques funcions de depuraci.Curs 2010-2011 2 Versi: 18oct



Un cop dins del Python podem obtenir ajuda amb la funci help:help(range)

NA2: Sintaxi bsica de Python

VariablesEls tipus de variables ms utilitzats sn: Els nombres enters (tipus integer) o amb decimals (tipus float). Les cadenes (tipus string). Els booleans (tipus boolean): True o False.

El Python s un llenguatge no tipat, cosa que significa que no fa falta definir el tipus de la variable quan la declarem. El Python ja ho interpreta depenent de la dada que se li assigni. L'assignaci es fa amb el smbol =.X=5 X=5.3 X=Python #X s un nombre enter, val 5 #X s un nombre decimal, val 5.3 #X s un string, val Python

Per tant, per a definir strings posarem entre cometes la cadenes de carcters. s igual si utilitzem cometes simples o dobles. Ms coses sobre variables: Podem definit diverses variables a la vegada:X,Y,Z=1,2,3 (X valdr 1, Y valdr 2, Z valdr 3) X=Y=Z=10

El Python diferencia entre MAJSCULES i minscules. La variable Nom s diferent de la variable nom. Per saber de quin tipus s una variable, utilitzarem la funci type(variable) s possible redefinir el varor d'una variable, cosa que redifineix automticament el seu tipus:>>>X=10 >>>type(X) >>>X=Python >>>type(X)

# Ens diu que s de tipus int (enter)

# Ens diu que s de tipus str (string)

L'operaci suma (+) significa dues coses diferents depenent de com siguin els operands. Si els operands sn nombres, equival a l'operaci de suma, si els operands sn cadenes, consisteix en una concatenaci: Amb nombres:>>>X=10 >>>Y=50 >>>print X+Y 60

Amb cadenes:>>>X=10 >>>Y=50 >>>print X+Y 1050

Per, qu passa si barregem nombres i cadenes?>>>X=10 >>>Y=50Curs 2010-2011 3 Versi: 18oct



>>>print X+Y Traceback (most recent call last): File "", line 1, in X+Y TypeError: unsupported operand type(s) for +: 'int' and 'str'

Traducci: la suma (+) s una operaci no suportada si barreges operands enters i cadenes. s possible convertir un tipus a un altre. No s'ha de confondre aix amb redefinir (donar-li un nou valor). Aqu convertim una cadena (imaginem que l'hem obtinguda d'un fitxer de text) a un enter, perqu ens interessa per poder calcular un valor:>>>X=10 >>>Y=50 >>>Y=int(Y) >>>X+Y 60

Hem convertit una cadena (50) en un nombre (50), i aix ja s possible sumar-los. Per a convertir un nombre en cadena utilitzarem la funci str(nombre a convertir)

RefernciesRealment, quan definim que una variable t un determinat valor, aquest valor s'emmagatzema a memria i la variable s una referncia a aquest valor. Dit d'una altra manera, totes les variables sn implcitament punters, encara que habitualment podem treballar amb elles ignorant aquest fet. Per exemple:x = blau y = verd z = x

Quantes cadenes hem creat? A la primera i segona sentncies, com que la cadena no existia, la creava i assignava a la variable x i y una referncia a aquesta cadena:

x y

blau verd

En canvi, a la tercera sentncia, com que x ja s una referncia a un objecte existent, no es crea una cadena nova, sin que z apuntar, o far referncia, a la mateixa cadena que x:

x z y blau verd

Entrada i sortidaSortida per pantallaUtilitzarem la funci:print argument1, argument2, ... , argument n

on els arguments poden ser nombres, cadenes, etc.

Curs 2010-2011

4

Versi: 18oct



Nota: En Python 3 la funci print es crida com qualsevol altra funci: print(arg1, arg2, ..., argn) Per imprimir cadenes:>>> print La meva edat s: La meva edat s:

Per imprimir nombres:>>> print 25 25

Per imprimir nombres combinats amb cadenes:>>> print La meva edat s:, 25 La meva edat s:25

Fixeu-vos que el print posa un espai automticament. Com podem fer-ho per tal que ho imprimeixi tot junt?>>> print La meva edat s: + str(25) La meva edat s:25

Ha estat necessari convertir el nombre 25 a cadena, concatenar-lo i desprs imprimir-lo. A diferncia del primer cas, aqu noms hi ha un argument. Podem imprimir una lnia en blanc simplement posant: print ATENCI: Per a poder escriure accents, , o , cal escriure al principi del vostre fitxer:# -*- coding: utf-8 -*-

Entrada des de teclat Per capturar nombres, s tan fcil com:>>> input ("Diga'm la teva edat:") Diga'm la teva edat:

Es queda esperant fins que l'usuari introdueix un valor. Normalment voldrem guardar-nos aquest valor en una variable:>>> edat=input ("Diga'm la teva edat:") Diga'm la teva edat: [l'usuari contesta i posa un 25]

Ara podem imprimir la variable sense problemes:>>> print edad 25

Per a capturar cadenes, hem d'utilitzar la funci raw_input():>>> nom=raw_input ("Com et dius?")

Un error com s intentar capturar una cadena amb input:>>> nom=input ("Com et dius?")

[l'usuari contesta pere]Traceback (most recent call last): File "", line 1, in nombre=input("Com et dius?") File "", line 1, in NameError: name 'pere' is not defined

Traducci: el Python veu que pere no s un nombre, i interpreta que s una variable que cont un nombre. Com que no existeix la variable pere, es queixa que no est definida.

Curs 2010-2011

5

Versi: 18oct



Arguments de la lnia de comandesPodem obtenir els arguments que s'han passat al nostre programa des de la lnia de comandes de la segent manera:#!/usr/bin/env python # -*- coding: utf-8 -*import sys print "Els arguments rebuts sn:", sys.argv print "El primer argument ("+sys.argv[0]+") es correspon amb el nom del programa." print "Hem rebut", len(sys.argv), "argument/s."

Fixa't en el resultat quan cridem el programa:$ ./prova_argv.py Els arguments rebuts sn: ['prova_argv.py'] El primer argument (prova_argv.py) es correspon amb el nom del programa. Hem rebut 1 argument/s. $ ./prova_argv.py a b c d Els arguments rebuts sn: ['prova_argv.py', 'a', 'b', 'c', 'd'] El primer argument (prova_argv.py) es correspon amb el nom del programa. Hem rebut 5 argument/s.

OperadorsEls operadors sn prcticament els mateixos que en C: Operadors aritmtics: sumar (+), restar (-), multiplicar (*), dividir (/), elevat a (**), etc. Operadors de comparaci: igual que (==), diferent de (!=), major que (>), menor que (>), major o igual (>=), menor o igual (>> 1> 1>> while True print 'Hola mn' File "", line 1, in ? while True print 'Hola mn' ^ SyntaxError: invalid syntax

Se'ns comunica la lnia on hi ha l'error i el punt on s'ha detectat que aquesta lnia no podia estar ben escrita.

Excepcions IAltres vegades, la sentncia est ben escrita, per en el moment d'executar-la es produeix una situaci anmala que fa que no sigui possible executar-la directament. En aquest cas, el que es produeix s una excepci, i l'intrpret ens n'informa de manera diferent:>>> 10 * (1/0) Traceback (most recent call last): File "", line 1, in ? ZeroDivisionError: integer division or modulo by zero >>> 4 + spam*3 Traceback (most recent call last): File "", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "", line 1, in ? TypeError: cannot concatenate 'str' and 'int' objects

En el primer exemple, no s possible realitzar una divisi per zero, en el segon estem utilitzant una variable que no hem definit abans, i en el tercer exemple estem intentant concatenar una cadena amb un nombre. El traceback s la pila de funcions que s'han cridat, i des de les quals encara no s'ha retornat, des del punt d'inici del programa fins al lloc on s'ha produt l'excepci. En parlarem ms endavant quan vegem les funcions. Desprs del traceback, ens informa del fitxer i lnia que ha causat el problema, i finalment ens informa del tipus d'error i ens dna una descripci del mateix. El tipus d'excepci del primer exemple s ZeroDivisionError, del segon NameError, i del tercer TypeError. Com hem vist, les excepcions sn situacions anmales que no podem preveure quan fem el programa, sin que hem de detectar en temps d'execuci, i preparar el nostre programa per tal que actu en conseqncia. Si una excepci es pot arreglar mentre fem el programa, l'hem de tractar com un error i arreglar-lo, i no gestionar-lo com farem a continuaci amb les excepcions. Exemple:#!/usr/bin/env python

Curs 2010-2011

9

Versi: 18oct



# -*- coding: utf-8 -*a=input("Introdueix el numerador: ") b=input("Introdueix el denominador: ") c=a/float(b) print "El resultat de la divisi s", c

Aquest programa, si l'usuari ens introdueix un 0 com a denominador, dna un error i acaba de forma incorrecta:Introdueix el numerador: 6 Introdueix el denominador: 0 Traceback (most recent call last): File "exemple_excepcio1.py", line 6, in c=a/float(b) ZeroDivisionError: float division

Aquest s el tractament per defecte quan el Python detecta una excepci. Naturalment, podrem evitar fcilment aquest problema, modificant el programa de la segent manera:#!/usr/bin/env python # -*- coding: utf-8 -*a=input("Introdueix el numerador: ") b=input("Introdueix el denominador: ") if b==0: print "No es pot dividir per 0" else: c=a/float(b) print "El resultat de la divisi s", c

El problema amb aquesta soluci s una qesti d'estil. Si en el nostre programa es poden donar diverses situacions excepcionals, ens hem de preocupar d'anar localitzant totes les possibilitats i de fer-ne el tractament oport. Aix fa que la resoluci de les situaci anmales es barregi amb el de la situaci habitual, cosa que dificulta la llegibilitat del codi. Per aix, les excepcions es poden tractar per separat del codi normal, com en l'exemple segent:#!/usr/bin/env python # -*- coding: utf-8 -*a=input("Introdueix el numerador: ") b=input("Introdueix el denominador: ") try: c=a/float(b) print "El resultat de la divisi s", c except ZeroDivisionError: print "No es pot dividir per 0"

En aquest cas, si es produeix una excepci de tipus ZeroDivisionError en el codi que hi ha dins del try, automticament es passa a executar la part de codi de l'except, ignorant les lnies que encara hi hagi en el try. Aix fa que puguem fer el tractament normal tot seguit en el try, i que puguem posar el tractament de cadascuna de les possibles excepcions en un bloc except, al final de tot. En el nostre exemple, encara podem tenir ms problemes: si l'usuari ens introdueix quelcom que sigui un nombre, es produeix una excepci:Introdueix el numerador: h Traceback (most recent call last): File "exemple_excepcio3.py", line 4, in a=input("Introdueix el numerador: ") File "", line 1, in NameError: name 'h' is not defined

Per tractar tamb aquesta situaci, podem fer el segent:

Curs 2010-2011

10

Versi: 18oct



#!/usr/bin/env python # -*- coding: utf-8 -*try: a=input("Introdueix el numerador: ") b=input("Introdueix el denominador: ") c=a/float(b) print "El resultat de la divisi s", c except NameError: print "Cal introduir un valor numric" except ZeroDivisionError: print "No es pot dividir per 0"

En aquest ltim cas, es gestiona b tan que l'usuari introdueixi lletres al numerador, com al denominador, i tamb la divisi per 0:$ python exemple_excepcio4.py Introdueix el numerador: f Cal introduir un valor numric $ python exemple_excepcio4.py Introdueix el numerador: 6 Introdueix el denominador: b Cal introduir un valor numric $ python exemple_excepcio4.py Introdueix el numerador: 3 Introdueix el denominador: 0 No es pot dividir per 0

Fixeu-vos com en cada cas, si es dna una excepci, ja no s'intenta seguir amb l'execuci normal del programa. Els blocs try es poden niar. El segent exemple s equivalent a l'anterior:#!/usr/bin/env python # -*- coding: utf-8 -*try: a=input("Introdueix el numerador: ") b=input("Introdueix el denominador: ") try: c=a/float(b) print "El resultat de la divisi s", c except ZeroDivisionError: print "No es pot dividir per 0" except NameError: print "Cal introduir un valor numric"

Noteu a ms que seria difcil gestionar les excepcions d'entrada de l'usuari noms amb if, perqu no podem saber que el valor introdut s incorrecte fins que ja ha saltat l'excepci. Per fer-ho, haurem d'agafar l'entrada amb raw_input, comprovar que efectivament ens han introdut un nombre, i desprs canviar-li el tipus de cadena a nombre. Exemple: El segent script escriu per pantalla les lnies que rep des de l'entrada estndard. Naturalment, aix noms t sentit quan l'entrada es redrea mitjanant el smbol ,email #imprimir: 11 --> [email protected]

Soluci2 (generalment no recomanable) : treballar amb variables globals.def funcio1(): global fnombre global fcadena fnombre=fnombre+1 [email protected] funcio1() print fnombre,-->,fcadena

Arguments de paraula clauHi ha dues maneres de passar els arguments a una funci. Una s per la posici dels arguments: el primer argument que passem es correspon al primer argument que espera la funci, el segon al segon, i aix successivament. Aquesta s la forma habitual, que hem utilitzat fins ara, i que s la mateixa que en C. A ms, per, es poden passar arguments de forma desordenada si indiquem explcitament el nom dels arguments:def funcio(a, b): print a+b

Es pot cridar com:funcio(4, 5) funcio(a=4, b=5) funcio(b=5, a=4)

En qualsevol d'aquests casos el resultat s el mateix. Fixeu-vos com passar els arguments per nom permet passar-los desordenats. Tamb la podem cridar com:

Curs 2010-2011

17

Versi: 18oct



funcio(4, b=5)

cosa que implica que el primer argument s per posici, i el segon per nom. Per no podem:funcio(b=5, 4)

perqu la posici del 4 s ambigua. Es veu la potncia d'aquesta forma de cridar les funcions si ho barregem amb els arguments opcionals. La segent funci ens retorna la cadena que rep a text, per la talla si la seva longitud s massa gran, cosa que indica posant un smbol concret al final de la cadena retornada:def shorten(text, longitud=25, indicador="..."): if len(text) > longitud: text = text[:longitud - len(indicador)] + indicador return text

Els parmetres per la longitud i per l'indicador ja tenen un valor per defecte, de manera que podem cridar la funci simplement com:shorten("M'agrada el Python")

cosa que retorna la cadena M'agrada el Python, perqu la longitud de la cadena no arriba a 25. Si volem especificar una altra longitud podem fer-ho de diverses maneres:shorten("M'agrada el Python", 12) shorten(longitud=12, text="M'agrada el Python") shorten("M'agrada el Python", longitud=12)

En qualsevol d'aquests casos es retorna la cadena M'agrada .... Si volem especificar tots els arguments:shorten("M'agrada el Python", indicador="&", longitud=12) shorten("M'agrada el Python", 12, "&")

I obtenim: M'agrada el&. La grcia d'aix s que podem especificar l'indicador sense especificar la longitud, cosa que no podem fer en el pas per posici:shorten("Aquesta s una cadena molt llarga que queda tallada", indicador="/")

retorna: Aquesta s una cadena m/ Aquesta forma de cridar les funcions ser especialment til per cridar funcions que poden rebre molts parmetres, la major part d'ells opcionals, si noms volem especificar el valor d'un o dos d'aquests arguments.

Excepcions IIExcepcions en cadenaAbans hem vist que es podia detectar i gestionar una excepci mitjanant les clusules try i except. Qu passa si es produeix una excepci en una funci i aquesta no es gestiona? Doncs l'excepci salta a la segent funci de la pila de crides, i aquesta altra funci t la seva oportunitat de gestionar-la. Mentre no es gestiona l'excepci, aquesta anir saltant de funci en funci, fins arribar al propi Pyhton. s aleshores quan el nostre programa acaba amb el missatge d'error que vam veure en tractar les excepcions. Exemple: Imaginem que tenim la segent funci:def divisio(a, b): return a/b

Curs 2010-2011

18

Versi: 18oct



Si quan la cridem, passem 0 com a denominador, el programa acabar mostrant l'error per pantalla. Per imaginem que tenim el segent codi on es crida a la funci de dividir:try: divisio(a, b) except ZeroDivisionError: print "Aqu podem capturar i tractar l'excepci!"

En aquest cas, el programa podria prosseguir a continuaci de la clusula except, i el fet que s'hagi produt l'excepci noms provocaria la impressi d'un missatge.

Llanament d'excepcionsFins ara hem tractat el cas en qu la crida a alguna funci de biblioteca ens retornava una excepci. Per tamb s possible que sigui a les nostres funcions on detectem una excepci, i decidim que en comptes de tractar-la al mateix codi, volem que sigui la funci o el programa que ha cridat a la nostra funci qui es faci crrec de gestionar-la. Per tal de provocar el llanament d'una excepci s'utilitza la sentncia raise. Exemple: Imaginem la segent funci que calcula el factorial d'un nombre. Noms t sentit que li passem per parmetre un nombre enter positiu.def factorial(n): if not isinstance(n, int) or n1: resultat *= n n -= 1 return resultat

Fixeu-vos com aqu som nosaltres qui detectem les situacions anmales, i ens encarreguem de llanar una excepci nova, de tipus ValueError. Com que en el nostre codi no hi ha cap try..except, ha de ser qui cridi a la funci factorial qui se'n faci crrec:s = raw_input("Introdueix el nombre del qual vols calcular-ne el factorial: ") try: n = int(s) fact = factorial(n) print "El factorial de",n,"s",fact except ValueError: print "No es pot calcular el factorial d'aquesta expressi."

Aqu, el try..except agafa tan la possible excepci al transformar la cadena a enter, a la sentncia n = int(s), com l'excepci que es produir dins de factorial si resulta que n s negatiu o zero. Qu ha passat amb el missatge personalitzat d'error que hem posat al crear l'excepci? El podem recuperar i utilitzar amb la segent sintaxi:s = raw_input("Introdueix el nombre del qual vols calcular-ne el factorial: ") try: n = int(s) fact = factorial(n) print "El factorial de",n,"s",fact except ValueError as e: print e.message

Curs 2010-2011

19

Versi: 18oct



Exercicis21. Fes una funci que donats dos nombres enters ens retorni el quocient i el residu de la seva divisi entera. Fes que si no es pot fer la divisi es retorni una excepci. 22. Utilitza la funci anterior per fer-ne una altra que calculi el mxim com divisor de dos nombres segons l'algorisme d'Euclides. Gestiona les excepcions que es puguin produir. 23. Fes una funci que donat un nombre enter ens retorni True si el nombre s primer, o False en cas contrari. 24. Utilitza la funci anterior per fer un programa que demani un nombre enter i ens mostri els nombres primers adjacents al nombre passat (s a dir, el primer ms petit que sigui superior, i el primer ms gran que sigui inferior). Gestiona el cas que no es passi un nombre, o aquest no sigui enter. 25. Fes una funci que donada una cadena i dos nombres positius, i i j, ens retorni la mateixa cadena amb les lletres que ocupen les posicions i i j intercanviades. Fes que es llenci una excepci si no existeixen les posicions i o j a la cadena. 26. Implementa la funci get_string amb les segents propietats: La funci mostrar un missatge a l'usuari. Aquest missatge s un dels parmetres de la funci. Desprs, esperar que aquest li introdueixi una cadena, que ser el valor de retorn de la funci. La funci podr rebre dos parmetres amb la mida mnima i mxima de la cadena que espera obtenir. Si aquests parmetres no es passen, la mida mnima ser de 0 i la mxima de 80. Si la cadena introduda no compleix aquestes mides, es mostrar un missatge a l'usuari informant de la mida mnima i mxima, i es retornar None. La funci podr rebre un parmetre amb el valor per defecte en cas que l'usuari no introdueixi cap cadena (premi enter). Quan es mostri el missatge demanant la cadena, s'afegir l'opci per defecte entre claudtors per informar-ne a l'usuari. Si no es passa a la funci, aquest valor per defecte ser None. Comprova l's de la funci get_string posant-ne diversos exemples d's en un programa.

27. Implementa la funci get_string2, idntica a l'anterior, per que ara llenar una excepci si la mida de la cadena introduda no s correcta, en comptes d'avisar a l'usuari i retornar None. 28. Fes una funci similar a l'anterior, get_integer, que demani un nombre enter a l'usuari. La funci tindr com a parmetre obligatori el missatge a mostrar, i com a parmetres opcionals, el nombre ms petit i ms gran que acceptarem, que per defecte seran 0 i 100 respectivament. Fes que llenci excepcions quan calgui, i assegura't de gestionar-les en els exemples de crida que facis.

NA3: Recursivitat

Concepte de recursivitatLa recursivitat s un concepte que permet definir un objecte (problema o estructura de dades) en termes d'ell mateix. Un subprograma (acci o funci) s recursiu quan al llarg de la seva execuci s'efectua alguna crida a ell mateix. La recursivitat en els programes es pot donar de dues formes diferents: Directa, quan el subprograma es crida directament a ell mateix. Indirecta, quan el subprograma crida un altre subprograma, i aquest o algun de ms intern crida el primer .

Si tenim una situaci recursiva, hem de garantir que tingui un final. El final d'un procs recursiu queda garantit per l'existncia d'un estat bsic (o soluci simple) que no fa una altra crida recursiva. Un estat bsic en un procs recursiu s una situaci en la qual ja no s'activa ms la recursivitat. A ms d'aquest estat, hem d'assegurar que la recursivitat va disminuint en algun grau el problema plantejat, s a dir, que les successives crides recursives tendeixen a l'estat bsic.

Curs 2010-2011

20

Versi: 18oct



Exemples de funcions recursivesClcul del factorialEl factorial d'un nombre n es defineix com:n ! =nn1n2 ...21

Fixeu-vos que tamb podem definir el factorial de n en funci del factorial d'un nmero ms petit:n ! =nn1!

Aix s cert per qualsevol n, excepte per n=1. El factorial de 1 s 1. Aquesta s la situaci habitual en les funcions recursives: cada element es defineix en termes de s mateix, per en cada pas l'element se simplifica, s a dir, tendeix a acostar-se a un cas trivial pel qual podem donar una resposta directa. En aquest cas l'element trivial s el factorial de 1, i el problema es simplifica en cada pas perqu el nombre es fa ms petit, acostant-se cada cop ms a 1. Si no tingussim un cas de sortida, o les diferents iteracions no tendissin a aquest final, obtindrem un procs infinit, cosa que en cap cas seria acceptable. Aix doncs, podem pensar en una funci del tipus:def factorial(n): if n

Bases Llenguatge Python 18oct

Documents

Transcript of Bases Llenguatge Python 18oct