Programar en Python

Números enteiros (int ou long)

Hai dúas clases de enteiros: normais e longos. Os enteiros normais son os que pode gardar a CPU na que se execute a máquina (en máquinas de 32 bits van dende -2.147.483.648 ata 2.147.483.647, en máquinas de 64 bits van dende -9.223.372.036.854.775.808 ata 9.223.372.036.854.775.807). Os enteiros longos non teñen un límite fixado, a única limitación é a cantidade de memoria do sistema para almacenalo. Os enteiros normais son máis eficientes por estar soportados directamente pola CPU do sistema. Pódese forzar que un número sexa considerado coma enteiro longo engadindo un L ó final. Así, 100L será un enteiro longo ainda que se poida gardar coma enteiro normal.

As dúas clases de enteiros pódense mistura-las dúas nunha operación. Neste caso, o resultado será un enteiro longo.

Booleanos (bool)

Os booleanos só poden tomar dous valores: False (falso) ou True (verdadeiro). Os booleanos son un subtipo dos números enteiros, polo que se poden empregar coma se fosen enteiros, False valendo 0 e True valendo 1; así, pódense empregar con eles as mesmas operacións que cos enteiros ou mistura-los cos enteiros nas mesmas operacións.

Os booleanos son o resultado das operacións de comparación.

Como exemplo pensemos nunha función que verifique se un número é par ou impar:

def e_par(numero):
    """Comproba se numero e enteiro"""
    return (numero % 2) == 0

Empregando esta función: e_par(1) devolve False, e_par(2) devolve True.

Bases dos números enteiros

Os números enteiros pódense escribir en tres bases distintas: decimal, octal ou hexadecimal. Para escribir un número en decimal só hai que escribi-lo número. Para escribir un número en octal escríbese un 0 diante do número. Para escribir un número en hexadecimal escríbese 0x diante do número.

Exemplos:

123         # 123 en decimal
0123        # 83 en decimal
0x123       # 291 en decimal

Números reais (float)

Os números reais almacénanse internamente coma flutuante. Este formato ten un tamaño establecido (64 bits), polo que a na maioría dos casos só se poderá almacenar unha aproximación ó número. Así, o valor 0.1 almacénase coma 0.10000000000000001. Os valores que se poden representar van dende o ±2.2250738585072020×10⁻³⁰⁸ ata o ±1.7976931348623157×10³⁰⁸.

Os números reais represéntase cun punto separando a parte enteira da parte fracionaria e opcionalmente un e e o exponente (x10) ó que está elevado. Por exemplo: -1.1, 1.2e23 ou 0.1e-2. Esta representación é a empregada polos angloxasóns.

Operacións matemáticas

Sobre os números pódense realizar tódalas operacións básicas: - (negación), + (suma), - (resta), * (multiplicación), / (división), % (módulo) e ** (exponenciación). Para realizar operacións máis complexas tense que emprega-lo módulo math. Hai que ter coidado coa división entre enteiros, posto que devolve só a parte enteira do resultado. Para obte-lo resultado real hai que convertir algún dos operadores a real.

Exemplos:

-1          # -1
1 + 2       # 3
1 - 2       # -1
2.5 * 2     # 5
1 / 2       # 0
1.0 / 2     # 0.5
5 % 2       # 1
2 ** 3      # 8

Operacións lóxicas

As operacións lóxicas son: not (negación), and (conxunción) e or (ou). not devolve o valor boolean contrario do operando sobre o que opera. and devolverá True só se os dous operandos son True. or devolverá True cando algún dos operandos sexa True.
Exemplos:

not True       # False
True and False # False
True or False  # True

Operacións de comparación

As operacións de comparación son: == (igualdade), != (desigualdade), < (menor), > (maior), <= (menor ou igual) e >= (maior ou igual)

Exemplos:

1.0 == 1    # True
1.0 != 1    # False
1 < 2       # True
1 > 2       # False
1 <= 2      # True
1 >= 1      # True

Operacións sobre bits

Estas operacións traballan sobre tódolos os bits dos operandos. Estas operacións son: ~ (negación), & (and), | (or) e ^ (or exclusiva). ~ é un operador unario que cambia tódolos bits do operando. & devolve un número cos bits a 1 cando os dous bits desa posición dos operandos son 1, 0 en caso contrario. | devolve un número cos bits a 1 cando algún bit desa operación dos operadores son 1, 0 en caso contrario. ^ devolve un número cos bits a 1 cando só un dos bits desa posición dos operandos está a 1, 0 en caso contrario.
Exemplos:

~0x00          # -1 (0xffffffff)
0x0f | 0xf0    # 0xff
0x0f % 0xf0    # 0x0f
0x0f & 0xf0    # 0x00
0xFF ^ 0xF0    # 0x0f

Conversión de tipos

Os tipos numéricos pódense converter dun tipo a outro empregando bool(), int(), long() e float(). bool() converte calquera valor distinto de 0 a True, False en caso contrario. int() e long() converten o valor a enteiro normal ou longo respectivamente. float() converten o valor a real.
Exemplos:

bool(23)     # True
bool(0.0)    # False
int(True)    # 1
long(2.5)    # 2
float(False) # 0.0
float(2)     # 2.0

Mistura de tipos

Nunha operación pódense misturar dous distintos tipos de datos numéricos. Ó realiza-la operación mírase cal dos datos é dun tipo máis xenérico e convértese (implicitamente) o outro a ese formato, dando como resultado un valor do deste mesmo tipo.

Debido a que hai tres tipos de datos numéricos, só haberá tres tipos de combinacións posibles. Se operamos un booleado cun enteiro, o booleano convertirase a enteiro e o resultado da operación será enteiro. Se operamos un enteiro cun real, o enteiro convertirase a real e o resultado da operación será real. Se operamos un booleano cun real, o booleano convertirase a real e o resultado da operación será real.

Exemplos:

type(True + 2) # <type 'int'>
type(2 + 2.0)  # <type 'float'>

chúzame -