Python/Numeri

Python, mette a disposizione 4 tipi di numeri: interi, interi lunghi, in virgola mobile, complessi.

Numeri interi

In Python 2, i numeri interi possono essere

• int: compresi nel range da - sys.maxint - 1 a sys.maxint (il valore effettivo dipende dal sistema)
• long: dimensione arbitraria

Quando il risultato di un calcolo tra int esce dall'intervallo, il numero viene automaticamente convertito in intero lungo. Per esempio, sys.maxint+1 restituisce un long.

In Python 3, esiste un solo tipo intero a precisione arbitraria, int.

>>> 2**30
1073741824
>>> 2**100
1267650600228229401496703205376L

Divisione

È 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

A questo punto anche Python 2.x si comporta come Python 3.x:

>>> 7/2
3.5
>>> 6/2
3.0

Per ottenere la divisione intera in Python 3.x si usa l'operatore //:

>>> 7//2
3

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.

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ù familiare.

>>> print 0.3
0.3

Si deve tener conto di queste osservazioni se vogliamo usare un ciclo comandato da una variabile float:

>>> 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 dentro la 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

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)

Operazioni

Si possono scrivere espressioni utilizzando diversi operatori, la seguente tabella li riassume:

Operazione	Operatore	Int	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	$x|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	Int	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

La libreria math

La libreria 'math mette a disposizione 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