Python/Numeri
Wikibooks, manuali e libri di testo liberi.
Python, mette a disposizione 4 tipi di numeri: interi, interi lunghi, in virgola mobile, complessi.
Indice |
[modifica] Numeri interi
I numeri inter int, vanno da -2147483648 a 2147483647 cioè da -2^31 a 2^31-1. Quando il risultato di un calcolo tra interi esce da questo intervallo, il numero viene automaticamente convertito in intero lungo.
>>> 2**30 1073741824 >>> 2**100 1267650600228229401496703205376L
È stato modificato il comportamento di Python nel passaggio dalla versione 2.x alla versione 3.x. Nella versione 2.x il quoziente di due numeri interi è un numero intero:
>>> 7/2 3
Nella versione 3.x il quoziente di due numeri interi è un numero in virgola mobile:
>>> 7/2 3.5 >>> 6/2 3.0
Per fare in modo che anche Python 2.x si comporti come Python 3.x basta dare il comando:
from __future__ import division
Per ottenere la divisione intera in Python 3.x si usa l'operatore //:
>>> 7//2 3
[modifica] Numeri interi lunghi
I numeri interi lunghi, long, non hanno limiti inferiori o superiori, o meglio i loro limiti derivano dalla quantità di memoria presente nella macchina.
[modifica] Numeri in virgola mobile
I numeri in virgola mobile float vanno da -1.797693134862316e308 a 1.797693134862316e308.
Nell'usare i numeri in virgola mobile dobbiamo tenere presente che, per questioni di efficienza, sono memorizzati in base 2. Nel cambiare la base di un numero, si possono introdurre delle approssimazioni, infatti un numero tranquillo in base 10 ad esempio: 0.3 (tre decimi) diventa un numero periodico se rappresentato in base 2. Possiamo vedere come è rappresentato 0.3 internamente con il comando:
>>> 0.3 0.29999999999999999
Mentre l'istruzione print ci nasconde i dettagli interni e ci dà un risultato più famigliare.
>>> print 0.3 0.3
Si deve tener conto di queste osservazioni se vogliamo usare un ciclo comandato da una variabile folat:
>>> f=0 >>> while f!=1.0: print f f+=0.1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 ...
Questo ciclo non termina! L'istruzione "corretta" è:
>>> f=0 >>> while f<=1.0: print f f+=0.1
Ma non è una buona idea comandare un ciclo con una variabile float (provate a sostituire "<=" con "<"...). Bisogna sempre considerare i numeri in virgola mobile come numeri approssimati. La funzione repr ci mostra la rappresentazione interna del numero e ci dà l'idea di cosa succede dentron alla macchina:
>>> f=0 >>> while f<=1.0: print repr(f) f+=0.1 0 0.10000000000000001 0.20000000000000001 0.30000000000000004 0.40000000000000002 0.5 0.59999999999999998 0.69999999999999996 0.79999999999999993 0.89999999999999991 0.99999999999999989
[modifica] Numeri complessi
I numeri complessi complex sono numeri nella forma a+bj dove a e b sono numeri in virgola mobile.
I numeri complessi hanno due attributi: imag e real che sono i riferimenti alla parte reale e al coefficiente immaginario del numero e un metodo che restituisce il coniugato del numero: conjugate :
>>> c0=(5+6j) >>> c0 (5+6j) >>> c0.imag 6.0 >>> c0.real 5.0 >>> c0.conjugate() (5-6j)
[modifica] Operazioni
Si possono scrivere espressioni utilizzando diversi operatori, la seguente tabella li riassume:
| Operazione | Operatore | Interi | Float | Complex |
|---|---|---|---|---|
| addizione | x+y | 3+8 --> 11 | 3.+8. --> 11. | (3+5j)+(8-7j) --> (11-2j) |
| sottrazione | x-y | 3-8 --> -5 | 3.-8. --> -5. | (3+5j)-(8-7j) --> (-5+12j) |
| moltiplicazione | x*y | 3*8 --> -5 | 3.*8. --> -5. | (3+5j)*(8-7j) --> (59+19j) |
| divisione | x/y | 3/8 --> 0 | 3./8. --> 0.375 | (3+5j)/(8-7j) --> (-0.097345+0.5398230j) |
| potenza | x**y | 3**8 --> 6561 | 3.**8. --> 6561. | (3+5j)**8 --> (-506864+1236480j) |
| opposto | -x | -3 --> -3 | -3. --> -3. | -(3+5j) --> (-3-5j) |
| divisione intera | x//y | 8//3 --> 2 | 8.**3. --> 2. | (3+5j)//(8-7j) --> (-1+0j) |
| modulo | x%y | 8%3 --> 2 | 8.%3. --> 2. | (3+5j)%(8-7j) --> (11-2j) |
| uguale | x==y | 3==5 --> False | 3.==5. --> False | (3+5j)==(8-7j) --> False |
| diverso | x!=y | 3!=5 --> True | 3.!=5. --> True | (3+5j)!=(8-7j) --> True |
| minore | x<y | 3<5 --> True | 3.<5. --> True | |
| maggiore | x>y | 3>5 --> False | 3.>5. --> False | |
| minore o uguale | x<=y | 3<=5 --> True | 3.<=5. --> True | |
| maggiore o uguale | x>=y | 3>=5 --> False | 3.>=5. --> False | |
| bit and | x&y | 12&5 --> 4 | ||
| bit or | y | 5 --> 13 | ||
| bit xor | x^y | 12^5 --> 9 | ||
| scorrimento a sinistra | x<<y | 19<<2 --> 76 | ||
| scorrimento a destra | x>>y | 19>>2 --> 4 |
Ci sono anche alcune funzioni applicate ai numeri:
| Operazione | Funzione | Interi | Float | Complex |
|---|---|---|---|---|
| valore assoluto | abs(x) | abs(-7) --> 7 | abs(-7.) --> 7. | abs(3+5j) --> 5.8309518948453007 |
| quoziente, modulo | divmod(x) | divmod(32, 5) --> (6, 2) | divmod(32., 5.) --> (6.0, 2.0) | divmod((3+5j),(8-7j)) --> ((-1+0j), (11-2j)) |
| conversione in stringa | str(x) | str(32) --> '32' | str(3.2) --> '3.2' | str(3+5j) --> '(3+5j)' |
| rappresentazione interna | repr(x) | repr(32) --> '32' | repr(3.2) --> '3.2000000000000002' | repr(3+5j) --> '(3+5j)') |
| conv. in intero | int(x) | int(37) --> 37 | int(3.7) --> 3 | |
| conv. in lungo | long(x) | repr(37) --> 37L | long(3.7) --> 3L | |
| conv. in virgola mobile | float(x) | float(32) --> 32.0 | float(3.2) --> 3.2000000000000002 | |
| conv. in ottale | oct(x) | oct(4354) --> '010402' | ||
| conv. in esadecimale | hex(x) | hex(543543) --> '0x84b37' |
La funzione int accetta un secondo argomento che permette di interpretare la stringa passata come primo argomento come numero scritto in una determinata base:
>>> int('213', 4) 39 >>> int('213', 10) 213 >>> int('213', 12) 303 >>> int('213', 16) 531
[modifica] La libreria math
La libreria 'math mette a disposizioni molte funzioni matematiche che non sono interne al linguaggio Python:
| Funzione | Significato |
|---|---|
| acos(x) | restituisce l'arco coseno (misurato in radianti) di x |
| asin(x) | restituisce l'arco seno (misurato in radianti) di x |
| atan(x) | restituisce l'arco tangente (misurato in radianti) di x |
| atan2(y, x) | restituisce l'arco tangente (misurato in radianti) di y/x. tiene conto dei segni di x e di y |
| ceil(x) | restituisce l'approssimazione per eccesso di x come float |
| cos(x) | restituisce il coseno di x (misurato in radianti) |
| cosh(x) | restituisce il coseno iperbolico di x |
| degree(x) | converte l'angolo x da radianti in gradi |
| exp(x) | restituisce e elevato alla x |
| fabs(x) | restituisce il valore assoluto di x |
| floor(x) | restituisce l'approssimazione per difetto di x come float |
| fmod(x, y) | restituisce il resto della divisione tra x e y |
| frexp(x) | restituisce la mantissa e l'esponente di x |
| hypot(x, y) | restituisce la distanza euclidea sqrt(x*x+y*y) |
| ldexp(x, i) | restituisce x*(2**i) |
| log(x[, base]) | restituisce il logaritmo di x nella base base |
| log10(x) | restituisce il logaritmo di x nella base 10 |
| modf(x) | restituisce la parte frazionaria e la parte intera di x |
| pow(x, y) | restituisce la potenza x**y |
| radians(x) | converte l'angolo x da gradi in radianti |
| sin(x) | restituisce il seno di x (misurato in radianti) |
| sinh(x) | restituisce il seno iperbolico di x |
| sqrt(x) | restituisce la radice quadrata di x |
| tan(x) | restituisce la tangente di x (misurato in radianti) |
| tanh(x) | restituisce la tangente iperbolica di x |
Oltre a queste funzioni, math fornisce due costanti:
| Funzione | Significato |
|---|---|
| e | 2.7182818284590451 |
| pi | 3.1415926535897931 |