1. Teoria 1 (17/02/2011) - Classes, atributs i mètodes

1.1. Temari

Programació orientada a objectes.
Tipus (classes) definits per l'usuari.Concepte de representació. Instància i instanciació.
Atributs. Expressions d'accés als atributs. Creació i destrucció dinàmica d'atributs. Diagrama d'un objecte.
Inicialització (construcció) i self. Mètodes. Diferència entre mètodes i funcions.
Instàncies com a paràmetres de funcions.

1.2. Xuletari

Per definir una nova classe, amb atributs i operacions (exemple):
```
   1  class Point(object):
   2     def __init__(self,x,y)   # Definim uns atributs x,y
   3        self.x=x; self.y=y
   4     def distance_to_origin(self):  # Definim una operació
   5        return math.sqrt(self.x*self.x + self.y*self.y)
```
La instrucció INIT (SELF, …): fa posible inicialitzar una instància d'aquesta manera:
```
   1  >>> x=point(20.0, 4.0)
```
Self: paràmetre genèric que representa la instància a la qual s'aplicarà la funció.
Per cridar o utilitzar propietats(atributs i funcions) cal ferho amb el "."
Instanciació: mètodes constructors o inicialitzadors

1.3. Exercicis Resolts

Exercici 1.1 Cerqueu a la wikipedia el terme anglès programming paradigm. Estudieu-ne el contingut i resumiu en dos o tres paràgrafs que significa aquest concepte.

Paradigma de programació

Un paradigma és una forma de representar i manipular el coneixement.

Representa un enfocament particular o filosofia per a la construcció del programari. No és millor un que un altre, sinó que cada un té avantatges i desavantatges. També hi ha situacions on un paradigma resulta més apropiat que un altre.

Alguns exemples de paradigmes de programació:

El paradigma imperatiu és considerat el més comú i està representat, per exemple, pel C o per BASIC..
El paradigma funcional està representat per llenguatges com LISP, Scheme, Haskell..
El paradigma lògic, un exemple és Prolog.
El paradigma orientat a objectes. Un llenguatge completament orientat a objectes és Smalltalk.

Nota: La representació orientada a objectes millora l'estructura de les dades i per això s'ha aplicat a diferents paradigmes.

Si bé es pot seleccionar la forma pura d'aquests paradigmes al moment de programar, en la pràctica és habitual que es barregin. Així, llenguatges com C++, Delphi ó Visual Basic combinen el paradigma imperatiu amb l'orientat a objectes.

Un altre exemple: Llenguatges com Scheme o Prolog, paradigma funcional i lògic respectivament, compten amb estructures repetitives. Aquestes són més pròpies del paradigma imperatiu que a la forma pura d'aquells.

Exercici 1.2 Definiu la classe Semaf que representa un semàfor de carrer, amb els tres colors habituals. Quants atributs hauria de tenir? Definiu un mètode per inicialitzar instàncies d'aquesta classe que permeti definir el color en que es troba el semàfor just després de crear-lo.

>>> class semaf(object):
            def __init__(self, Verd, Taronja, Vermell):
                    self.verd=Verd
                    self.taronja=Taronja
                    self.vermell=Vermell

semaf1.semaf(1,0,0)
semaf1.verd
1
semaf1.taronja
0

SOLUCIÓ SEBAS:

>>> def __init__(self,c):
           d={"vermell":0, "verd":1,"groc":2}
           self.c=d[c]

Exercici 1.3 Definiu la classe Vector2d que representa un vector en el pla. Doteu la classe d'uun constructor i també d'un mètode que retorni el mòdul del vector en qüestió.

>>> class vector2d(object):
        def __init__(self,x,y):
                self.x=x; self.y=y
        def mod(self):
                return math.sqrt(self.x*self.x+self.y*self.y)
                # prèviament, cal importar la llibreria math.
    
>>> v1=vector2d(3.0,4.0)
>>> v1.x; v1.y; v1.mod()
    3.0
    4.0 
    5.0

SOLUCIÓ SEBAS:

>>> def vector2d(object):
        def __init__(self, m , a):
                self.m=m
                self.a=a
        def modul(self):
                return self.m

Exercici 1.4 Definiu la classe Fracció. Creeu un constructor o inicialitzador que instancii un objecte d'aquesta classe donant el numerador i el denominador. Afegiu-hi un mètode que permeti sumar una fracció amb una altra.

>>> class Fracc(object):
        def __init__(self,num,den):
            self.n=num; self.d=den

        def suma(self,f):
            s_num=self.n*f.d+f.n*self.d
            s_den=self.d*f.d
            resultat=fracc(s_num,s_den)
            return resultat.n,resultat.d

Alternativa:

>>> class fraccio(object):
    def __init__(self,n,d):
        self.d= d ; self.n= n  
        
    def sum(self,f2):

        return fraccio(self.n* f2.d + f2.n *self.d , self.d * f2.d) 

    def tostring(self):
        return '%s / %s' %(self.n,self.d)

#Perqué quedés la cosa una mica més decent, potser caldria implementar un petit mètode que simplifiqués la fracció.

Exercici 1.5 Dissenyeu la classe Byte. Un byte és una paraula de 8 bits. Representeu un byte com una tupla de 8 enters, que prendran sempre valor 0 o 1. Definiu un mètode constructor i també un altre mètode que retorna el valor enter corresponent al byte. Aquesta classe hauria de superar el següent doctest:

>>> x = Byte((0,0,0,0,1,0,0,1)) >>> print x.value() 9

SOLUCIÓ SEBAS:

>>> class Byte(object):
        def __init__(self, b):   # b es una tupla
                self.b=b
        def valor(self):   # prover de fer-ho amb una línia
                v=0; p=1
                for d in self.b[::-1]:
                        v+=d*p
                        p*=2
                return v

_Exercici 1.6

class Codif(object):
    def __init__(self,c1,c2,c3):
     
        self.c1=c1 ; self.c2=c2 ; self.c3=c3 

    def value(self):
        
        return str(self.c1)+str(self.c2)+str(10**self.c3)[1:]
        
    def colors(self):
        d={0:"negre",1:"marro",2:"vermell",3:"troja",4:"groc",5:"verd",6:"blau",7:"lila",8:"gris",9:"blanc"}

        return d[self.c1],d[self.c2],d[self.c3]

CategoryApunts