Iteració amb while

La sentència while (1)

• Iteració: execució repetida d’un bloc de sentències:

  def compte_enrere(n):
      while n > 0:
          print n
          n = n - 1
      print "Zero!!!"
  

• Sintaxi:

  while condició:    # capçalera
      sentències     # cos
  

La sentència while (2)

• Flux d’execució (bucle):

  1. S’avalua la condició obtenint cert o fals.

  2. Si la condició és certa s’executen les sentències del cos i es torna al punt 1.

  3. Si la condició és falsa l’execució continua per la següent sentència després del cos.

• Què succeeix si

  • la condició és falsa ja el primer cop?

  • no es modifica cap variable de la condició?

Acabarà la iteració?

• De vegades és senzill de veure: compte_enrere.

• De vegades és molt difícil de demostrar:

  def sequence(n):
      while n != 1:
          print n,
          if n % 2 == 0: # n és parell
               n=n/2
          else: # n és senar
               n=n*3+1
  

La traça d’un programa

• És el resultat de seguir el flux d’execució d’un programa prenent nota de l’estat després d’executar cada sentència.

• Estat:

  • Valors als que es refereixen les variables.

  • Sortida del programa.

Comptant dígits

• Patró comptador (comptador.py):

  def num_digits(n):
      compt = 0
      while n:
          compt = compt + 1
          n = n / 10
      return compt
  

Assignació abreviada

• Sintaxi:

  a += valor
  

  equivalent a

  a = a + valor
  

• Vàlid amb els altres operadors: -=, *=, /= i %=.

Taules

• Càlcul de resultats en forma de taules.

• Exemple: tabular les potències de 2 elevat de l’1 al 4.

  x=1
  while x < 5:
      print x, '\t', 2**x
      x += 1
  

Taules de dues dimensions

• Taula de multiplicar:

  i=1
  while i <= 6:
      print 2 * i, '   ',
      i += 1
  print
  

Encapsulació i generalització

• Encapsulació (multiples.py):

  def escriure_multiples_2_6():
      i=1
      while i <= 6:
          print 2 * i, '\t',
          i += 1
      print
  

• Generalització:

  def escriure_multiples_6(n):
      i=1
      while i <= 6:
          print n * i, '\t',
          i += 1
      print
  

Més encapsulació

• Escriure les taules de multiplicar fins la del 6:

  i=1
  while i <= 6:
      escriure_multiples_6(i)
      i += 1
  

• Encapsulació:

  def escriure_taula_multiplicar_6():
      i=1
      while i <= 6:
           escriure_multiples_6(i)
           i += 1
  

Variables locals

• Les variables i els paràmetres són locals a una funció.

• Pila d’execució.

• Online Python Tutor.

Més generalització

• Generalització:

  def escriure_taula_multiplicar(darrer):
      i=1
      while i <= darrer:
           escriure_multiples(i, darrer)
  
  def escriure_multiples(n, darrer):
      i=1
      while i <= darrer:
          print n * i, '\t',
          i += 1
      print
  

Exercicis

1. Com que les taules de multiplicar són simètriques, escriure’n només la meitat inferior (multiples_2.py).

2. En comptes dels múltiples d’un nombre, escriure les seves potències.

3. Encara més generalització: afegir un paràmetre de tipus funció que sigui l’operació sobre el nombre n i sobre i que s’ha de calcular (multiples_3.py).

Funcions

Per a què serveixen les funcions?

1. Donen nom a un bloc de sentències (encapsulació).

2. Divideix i venç (escriure multiples, escriure taula de multiplicar).

3. Reutilitzar (generalitzar).

El mètode de Newton

• Mètodes numèrics iteratius.

• Càlcul de l’arrel quadrada (arrel.py):

  def sqrt(n):
      approx = n/2.0
      better = (approx + n/approx)/2.0
      while better != approx:
           approx = better
           better = (approx + n/approx)/2.0
      return approx
  

Algorismes

• Procés mecànic que permet resoldre una classe de problemes.

• Exemples: mètode de Newton, suma, resta, multiplicació divisió, algorisme d’Euclides per calcular el mcd, …

• Algorisme: fàcil d’executar, difícil de dissenyar.