1. Classes, atributs i mètodes
1.1. Exercici 2.2
Únicament és necessari un atribut. En aquest cas la representació de l'atribut color tant pot ser un string com un enter que codifica el color ( la representació, es molt variable segons el problema a tractar)
1 class Semafor(object):
2 """
3 >>> s1 = Semafor('vermell')
4 >>> s2 = Semafor('verd')
5 >>> s1.estat()
6 vermell
7 >>> s2.estat()
8 verd
9 >>> s1.canvi('verd')
10 >>> s1.estat()
11 verd
12 """
13 def __init__(self, color):
14 self.color=color
15
16 # Ampliació.
17
18 def estat(self):
19 """
20 Consulta l'estat actual del semàfor
21 """
22 return self.color
23
24 def canvi(self, color):
25 """
26 Modifica l'estat actual del semàfor
27 """
28 self.color=color
1.2. Exercici 2.3
Com sabem les implementació d'un problema té moltíssimes solucions a l'hora de planteja l'implementació d'un problema hem de observar quina es la forma que creiem més còmode per treballar. Un exemple es aquest exercici on ens demana que creem una classe Vector2d que representa un vector en el pla, en aquest cas una de les maneres més habituals que utilitzem per representar vectors en el pla, és amb les seves coordenades cartesianes.Si seguim llegint l'enunciat ens adonem que ens demanen que creem un metòde que retorni el mòdul del vector, ara podem reconsiderar si la manera de representar que havíem plantejat és la que ens resulta més comode. Un altra forma totalment vàlida que podem utilitzar és la de representar el vector de forma polar, donant el mòdul i l'angle respecte l'eix X.A continuació podem observar l'implementació de l'exercici utilitzant les dues representacions esmentades.
1 from math import sqrt
2
3 class Vector2d_1(object):
4 """
5 Vecotr representat amb coordenades cartesianes
6 """
7 def __init__(self, x, y):
8 self.x=x
9 self.y=y
10
11 def modul(self):
12 return sqrt((self.x * self.x) + (self.y * self.y))
13
14
15 class Vector2d_2(object):
16 """
17 El vector es representa de forma polar
18 """
19 def __init__(self, mod, ang):
20 self._modul = mod
21 self._angle = ang
22
23 def modul(self):
24 return self._modul
25
26 class Vectorpolar(object):
27
28 def __init__(self,mod,ang):
29
30 self._mod=mod
31 self._ang= (ang * 2*math.pi)/360
32
33 def modul(self):
34 return self._mod
35
36 def cartesia(self):
37
38 x= math.cos(self._ang) * self._mod
39 y= math.sin(self._ang) * self._mod
40
41 return x,y
1.3. Exercici 2.4
1 class Fraccio(object):
2 """
3 >>> f1 = Fraccio(1, 2)
4 >>> f2 = Fraccio(2, 1)
5 >>> f1.suma(f2)
6 >>> f1.mostrar()
7 (1, 1)
8 >>> f2,mostrar()
9 (2, 1)
10 """
11 def __init__(self, num, denom):
12 self.num=num
13 self.denom=denom
14
15 def suma(self, frac):
16 """
17 Suma dues fraccions
18 """
19 self.num += frac.num
20 self.denom += frac.denom
21
22 def mostrar(self):
23 """
24 Mostra el numerador i el denominador de la fraccio
25 """
26 return (self.num, self.denom)
1.4. Exercici 2.5
1 class Byte(object):
2 """
3 >>> b1 = Byte((0,0,0,0,1,0,0,1))
4 >>> b1.value()
5 9
6 >>> b2 = Byte((0,0,0,0,0,0,0,1))
7 >>> b2.value()
8 1
9 """
10 def __init__(self, b):
11 self.byte=b
12
13 def value(self):
14 """
15 Retorna el valor enter del byte
16 """
17 e=0
18 for i,v in enumerate(self.byte):
19 e+=(v*(2**(7-i)))
20 return e
21
22 class Byte(object):
23 def __init__(self,t=(0,0,0,0,0,0,0,0)):
24 self.t=t[::-1]
25
26 def valor(self):
27
28 valor=0
29 for v,i in enumerate(self.t):
30 if i:
31 valor= valor+ 2**v
32
33 return valor
34
35 def __repr__(self):
36
37 return str(self.valor())
1.5. Exercici 2.6
Codificació
negre => 0
marró =>1
vermell => 2
taronja => 3
groc => 4
verd => 5
blau => 6
violeta => 7
gris => 8
blanc => 9
1 class Codif(object):
2 """
3 >>> r1 = Codif(1, 2, 5)
4 >>> r1.value()
5 1200000
6 >>> print(r1.colors())
7 Marro, Vermell, Verd
8 """
9 def __init__(self, lin1, lin2, mult):
10 self._l1 = lin1
11 self._l2 = lin2
12 self._m = mult
13
14 def value(self):
15 """
16 Retorna el valor de la resitència
17 """
18 c = self._l1 * 10
19 c += self._l2
20 c *= 10** self._m
21 return c
22
23 def colors(self):
24 """
25 Retorna el codi de colors de la resitència
26 """
27 dic = {0: 'Negre', 1: 'Marro', 2: 'Vermell', 3: 'Taronja', 4: 'Groc', 5: 'Verd', 6: 'Blau', 7: 'Violeta', 8: 'Gris', 9: 'Blanc'}
28 return dic[self._l1]+', '+ dic[self._l2]+', '+ dic[self._m]