A secuencia ten unha serie de características como por exemplo:

• Ó dividir un termo entre o anterior a partir do cuarto valor, por exemplo 3/2, 5/3, 8/5… o resultado aproximarase ó numero 1,6 tamén chamado a proporción áurea de Fibonacci.
• A suma de dez números Fibonacci consecutivos é sempre 11 veces superior ó séptimo número da serie.
• A suma dos n primeiros números é igual ó número que ocupa a posición n+2 menos un.

Ademais esta sucesión relaciónase con moitos elementos da natureza, dende a reprodución animal, anatomía vexetal e animal ou relacións entre sexos nas especies.

Código

#! /usr/bin/env python
# -*- coding: utf-8 -*-

n = int(raw_input("¿Valor tope da serie? "))
print " Serie de Fibonacci "

a, b = 0, 1

while b <= n:
    print b
    a, b = b, a + b

chuzame

O código desta anotación é un módulo chamado rot13 que implementa unha función chamada encrypt que codifica/decodifica unha cadea de caracteres. Internamente encrypt chama a un módulo privado chamado _rot13 que é o que fai a codificación dun caracterer. O código tamén se pode executar coma un script por si mesmo e neste caso codificará/decodificará o que se lle pase ó script coma parámetros.

Para aplicar este algoritmo hai que ter claro que non se pode codificar tódolos caracteres posibles con rot-13, só 26 (ou 52 se diferenciamos entre maiúsculas e minúsculas). Así, o primeiro que se fai na función _rot13 é verificar se o caracter se pode codificar/decodificar e devolve-lo intacto se non se pode.

Código

#! /usr/bin/env python
# -*- coding: iso-8859-15 -*-
"""Módulo que codifica e decodifica un texto co algoritmo rot13.
Este algoritmo non é seguro e só se debe empregar coma exemplo."""

__all__ = ["encrypt"]

__ord_A = ord("A")
__num_chars = ord("Z") - ord("A") + 1

def _rot13(character):
    """Devolve un caracter codificado co algoriitmo rot-13."""
    index = ord(character.upper()) - __ord_A
    if not character.isalpha() or index > 127:
        return character

    new_character = chr((index + 13) % __num_chars + __ord_A)
    if character.islower():
        new_character = new_character.lower()

    return new_character

def encrypt(text):
    """Devolve un texto codificado co algoritmo rot-13."""
    encrypted_text = []
    for character in text:
        encrypted_text.append(_rot13(character))
    return "".join(encrypted_text)

if __name__ == "__main__":
    # Execución do algoritmo ós parámetros do script
    import sys
    print encrypt(" ".join(sys.argv[1:]))

chuzame

A funcionalidade do Ola mundo! é moi sinxela, posto que tan só visualiza por pantalla un “Ola mundo!”.

Código

#! /usr/bin/env python
# -*- coding: utf-8 -*-

print "Ola mundo!"

chuzame

Exemplos de linguaxes funcionais son Lisp, Scheme e Haskell.

Composición de funcións

A composición de funcións é a operación fundamental na programación funcional. A composición de funcións consiste en empregar como parámetros dunha función outras funcións. Por exemplo, supoñendo as funcións f e g, a operación f(g()) executa a función g e pásalle o resultado á f como parámetro.

Recursividade

Unha función recursiva é aquela que se chama a si mesma para obte-lo resultado. Para os problemas de natureza recursiva o emprego de funcións recursivas é evidente.

Por exemplo, o factorial de n defínese coma a multiplicación de n polo factorial de n - 1, é dicir n! = n * (n - 1)!. O xeito de codificar o factorial sería:

FUNCIÓN factorial(n)
    SE n = 0
        ENTÓN resultado = 1
        SENÓN resultado = n * factorial(n - 1)
    FinSE
FinFUNCION

A maioría de problemas son iterativos, é dicir, un conxunto de instruccións atópanse nun bucle que se executa ata que se produce unha condición de saída. Aínda que a natureza dun problema non sexa recursiva, sempre se poderá codificar recursivamente, igual que os problemas recursivos se poden codificar iterativamente.

Por exemplo, a solución á suma dos primeiros n números enteiros é en principio iterativa. A solución iterativa sería ir sumando tódolos números dende o 1 ata n e a condición de saída sería que alcanzásemos o número dado.

FUNCIÓN suma_ata(n)
    resultado = 0
    MENTRES n > 0
        resultado = resultado + n
        n = n - 1
    FinMENTRES
FinFUNCIÓN

Esta función iterativa pódese convertir en recursiva do seguinte xeito:

FUNCIÓN suma_ata(n)
    SE n <= 0
        ENTÓN suma_ata = 0
        SENÓN suma_ata = n + suma_ata(n - 1)
    FinSE
FinFUNCIÓN

chuzame

Exemplos de linguaxes orientadas a obxectos son Smalltalk, C++ ou Ada.

Obxecto

A estructura dun obxecto ven definida pola clase á que pertence. Un obxecto está composto por atributos e métodos. Os atributos son os datos que o definen e os métodos son as accións que pode realizar. De tal xeito que poden haber varios obxectos da mesma clase pero distintos entre si.

O paso de mensaxes da programación orientada a obxectos é equivalente á chamada de funcións na programación imperativa. Unha forma extricta de orientación a obxectos esixiría que a única forma de comunicación co obxecto fose o paso de mensaxes, impidindo o acceso directo ós atributos.

Características

A programación orientada a obxectos caracterízase por ter unha serie de propiedades como son:

1. Abstracción: É a captación das características esenciais dun obxecto, así como o seu comportamiento.
2. Encapsulamiento: É a ocultación da implementación concreta do obxecto, deixando visible só o xeito de tratar co obxecto.
3. Polimorfismo: É a capacidade de que métodos que se comportan de forma distinta compartan o mesmo nome.
4. Herencia: Propiedade pola cal as subclases dunha clase adquiren as propiedades e métodos desta. Na herencia fálase de clases bases e derivadas ou clases nais e fillas.

Avantaxes

A programación orientada a obxetos ten unha serie de avantaxes que a fan idónea para o desenvolvemento de programas.

1. Comprensión: Tanto os datos que compoñen os obxectos, coma os procedementos que os manipulan, están agrupados en clases, que se corresponden cas estructuras de información cas que traballa o programa.
2. Flexibilidade: Ó ter relacionados os procedementos que manipulan os datos cos datos a tratar, cualquera cambio que se realice sobre eles quedará reflexado automáticamente en calquera lugar onde aparezan estes datos.
3. Estabilidade: Xa que permite o tratamiento diferenciado de aqueles obxectos que permanecen constantes no tempo sobre aqueles que cambian con frecuencia, deste xeito permite aislar as partes do programa que permanecen inalterables no tempo.
4. Reutilización: Os programas que traten as mesmas estructuras de información poden reutilizar tanto as definicions de obxectos empregadas noutros programas e incluso os procedementos que os manipulan. Deste xeito, o desenvolvemento dun programa pode chegar a ser unha simple combinación de obxectos xa definidos.

chuzame

Os tipos de datos sinxelos predefinidos en python son: booleanos, números enteiros e números reais. Os tipos de datos compostos predefinidos en python son: cadenas de caracteres, tuplas, listas, dicionarios e clases.

Para comproba-lo tipo dun dato emprégase a función type() que toma como parámetro o dato do que queremos sabe-lo seu tipo.

chuzame

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'>

chuzame

Exemplos de linguaxes estructuradas son: C, Modula 3 ou Java.

Secuencia

A secuencia é a estructura máis básica da programación estructurada. Unha secuencia consiste na execución de varias instrucións seguidas, unha detrás da outra. Estas instrucións poden ser simples ou estar compostas por estructuras máis elaboradas (concatenación de selecións, repeticións ou unha mistura).

Un exemplo de secuencia é o intercambio entre os valores de dúas variables (a e b no exemplo).

tmp = a
a = b
b = tmp

Seleción

A seleción permite executar código de forma condicional. No mundo real, nunca se atopa un programa onde tódalas súas instruccións se executen, senón que dependendo da entrada do programa se tomarán certos camiños dentro do código. A seleción está formada por tres partes: a primeira é a condición, a segunda son as instrucións que se executarán en caso de que se cumpla a condición e a terceira as instrucións que se executarán en caso de que non se cumpla.

Un exemplo de seleción é o cálculo do valor absoluto dun número. Neste exemplo compróbase se o número é maior ou igual que cero, se o é, non hai que modificar este valor, se é menor que cero (se non é maior ou igual que cero) hai que cambiarlle o signo.

SE n >= 0
    ENTÓN valor_absoluto = n
    SENÖN valor_absoluto = -n
FinSE

Repetición

A repetición permite executar un bloque de instrucións un número variable, e a miúdo descoñecido, de veces. A repetición está formada por dúas partes: a primeira é a condición de repetición do bucle e a segunda é o bloque de instrucións a executar. O bloque de instrucións estarase a executar mentres que se cumpla a condición de repetición. Un erro frecuente é esquecerse de modificar dalgún xeito os operadores que interveñen na condición de repetición facendo que o programa entre nun bucle infinito.

Un exemplo de repetición é o calculo do primeiros n números enteiros. Neste exemplo, i vai tomando tódolos valores dende 1 ata n (1 <= i < n).

total = 0
i = 1
MENTRES i <= n
    total = total + i
    i = i + 1
FinMENTRES

chuzame

Á hora de desenvolver unha aplicación empréganse varios paradigmas ó mesmo tempo. É por iso que agás raras excepcións, as linguaxes de programación facilitan o emprego dos paradigmas máis difundidos.

Neste titorial explicaranse os tres paradigmas máis difundidos: a programación estructurada, a programación funcional e a programación orientada a obxetos. Outros paradigmas dignos de mención son: a programación imperativa, a programación orientada a aspectos ou a programación xenérica.

chuzame

Segundo o nivel de abstración, temos tres tipos de linguaxes de programación: linguaxe máquina, linguaxes compiladas, linguaxes interpretadas e linguaxes virtualizadas.

Linguaxe máquina

A linguaxe máquina ou código obxeto, é código entendible directamente pola CPU. Esta linguaxe é de moi baixo nivel e non é entendible directamente por un programador.

Linguaxes compiladas

As linguaxes compiladas precisan dun compilador que converte o código fonte en código obxeto que xa é directamente executable pola máquina. Estas linguaxes permiten un código fácil de escribir, ler e manter.

Exemplos deste tipo de linguaxes son C, Eiffel ou Ada.

Linguaxes interpretadas

As linguaxe interpretadas precisan dun intérprete que irá executando o código fonte liña a liña. A existenza do intérprete ten a avantaxe de que acurta o ciclo de codificación-proba e posibilita a realización de código moito máis portable entre distintos tipos de máquinas. A desventaxe é que a execución é máis lenta que no caso de executar código obxeto.

Exemplos deste tipo de linguaxes son Python, Perl ou Ruby.

Linguaxes virtualizadas

As linguaxes virtualizadas son unha mistura das dúas anteriores. Nun primeiro paso, precisan ser compiladas a bytecode, un código obxeto para unha máquina virtual, posteriormente, a máquina virtual executa este bytecode. É un refinamento sobre as linguaxes interpretadas co que se consegue un aumento da velocidade de execución.

Exemplos deste tipo de linguaxes son Java ou C#.

Algunhas linguaxes interpretadas tamén fan unha compilación previa á execución, polo que non é sinxelo diferenciar estas linguaxes interpretadas das virtualizadas. A diferenza reside en que nas linguaxes virtualizadas, o bytecode está pensado para poder ser distribuído coma o executable das linguaxes compiladas, mentres que no caso das linguaxes interpretadas este código intermedio é só unha forma de axiliza-lo proceso de verificación e execución do código fonte. Un exemplo de linguaxe interpretada que ten unha máquina virtual é python.

chuzame