Python: Numeri (Soluzioni)¶

Soluzioni:

a = 12
b = 23
print a, b
print type(a), type(b)          # int, int

c = 34L
d = 45L
print c, d
print type(c), type(d)          # long, long

x = 21.0
y = 14.f
print x, y
print type(x), type(y)          # float, float

Soluzioni:

print a, b, c, d, x, y

print a, ";", b, ";", c, ";", ...

Soluzioni:

# casi semplici:

prodotto = a * b                # int * int
print prodotto
print type(prodotto)            # int

differenza = c - d              # long - log
print differenza
print type(differenza)          # long

# divisione e divisione intera tra vari
# tipi di numeri:

quoziente = x / y               # float / float
print quoziente
print type(quoziente)           # float

risultato = a // b              # int // int
print risultato
print type(risultato)           # int

risultato = c // d              # long // long
print risultato
print type(risultato)           # long

risultato = x // y              # float // float
print risultato
print type(risultato)           # float

# casi piu' complicati, in cui il tipo del
# risultato e' il tipo piu' complesso tra
# quelli degli operandi:

risultato = a * c               # int * long
print risultato
print type(risultato)           # long

risultato = b * y               # int * float
print risultato
print type(risultato)           # float

risultato = x * d               # float * long
print risultato
print type(risultato)           # float

# qui il tipo e' determinato automaticamente
# in base alla magnitudine del risultato:

risultato = 2**0                # int**int
print risultato
print type(risultato)           # int

risultato = 2**0                # int*int
print risultato
print type(risultato)           # *** long!!! ***

risultato = 2**1.2              # int*float
print risultato
print type(risultato0           # float

risultato = 2**-2               # int*int
print risultato
print type(risultato)           # *** float!!! ***

risultato = 4**0.5              # int*float
print risultato
print type(risultato)           # float

risultato = 2**0.5              # int*float
print risultato
print type(risultato)           # float

Soluzioni:
```
>>> print 10 / 12
0
>>> print 10 / 12.0
0.833333333333
>>> print 10 // 12
0
>>> print 10 // 12.0
0.0
```
Come si vede la divisione intera si comporta normalmente rispetto ai tipi: quando la applico ai due float il risultato e’ quello della divisione normale, ma troncato all’intero 0.
Soluzioni:
```
>>> 10 % 3
1
>>> 10 % 3.0
1.0
```
Come si puo’ vedere, % ritorna il resto di 10 / 3:
```
10 = 3*3 + 1
#          ^
#       il resto
```
Il tipo degli operandi non influenza il valore del risultato, solo il suo tipo.

Soluzione:

pi = 3.141592
r = 2.5

circonferenza = 2 * pi * r
print circonferenza

area = 2 * pi * r**2
print area

area = 2 * pi * r * r
print area

volume = (4.0 / 3.0) * pi * r**3
print volume

Occhio che 4 / 3 != 4.0 / 3.0.

Soluzione:

a, b = 100, True

a2 = a
b2 = b
b = a2
a = b2

print a, b

oppure:

a, b = 100, True

x = a
a = b
b = x

print a, b

Soluzione:

gene1_inizio, gene1_fine = 10, 20
gene2_inizio, gene2_fine = 30, 40

# disegnino:
#
# 5'                            3'
# ~~~~~xxxxxxxx~~~~~xxxxxxx~~~~~>
#     10      20   30     40
#      \______/     \_____/
#       gene_1       gene_2


# due alternative
condizione_1 = (10 <= pos <= 20)
condizione_1 = (pos >= 10 and pos <= 20)


condizione_2 = (30 <= pos <= 40)


condizione_3 = (10 <= pos <= 40)


# due alternative
condizione_4 = condizione_3 and not (condizione_1 or condizione_2)
condizione_4 = (20 <= pos <= 40)


condizione_5 = pos < 10 or pos > 40
# occhio che:
#
#   pos < 10 and pos > 40
#
# non ha senso: e' sempre False!


condizione_6 = condizione_1 or condizione_2


condizione_7 = (0 <= pos <= 20)

Il codice va testato con diversi valori di posizione, in modo da controllare che le condizioni si comportino come vogliamo: che siano True quando la posizione soddisfa i requisiti della domanda, e False altrimenti.

Soluzione:

tutte_e_tre = t and u and v

t_oppure_u_ma_non_tutte_e_due = (t or u) and not (t and u)

# NOTA: qui i backslash alla fine delle righe servono
# per andare "a capo", potete ignorarli.
una_delle_tre_falsa = \
    (t and u and not v) or \
    (t and not u and v) or \
    (not t and u and v)

una_delle_tre_vera = \
    (t and not u and not v) or \
    (not t and u and not v) or \
    (not t and not u and v)

Di nuovo, il codice va testato usando diversi valori per t, u e v. Ci sono 8 combinazioni in tutto:

t, u, v = False, False, False
t, u, v = False, False, True
t, u, v = False, True, False
t, u, v = False, True, True
# ...