**Python** é unha linguaxe de programación creada por Guido van Rossum no ano 1990.

É comparado habitualmente con TCL, Perl, Scheme, Java e Ruby. Na actualidade Python desenvólvese como un proxecto de código aberto, administrado pola Python Software Foundation. A última versión estable da linguaxe é a 3.6.5.

Historia e características
--------------------------

Python é considerado como "a oposición leal" a Perl, linguaxe co cal mantén unha rivalidade amigable. Os usuarios de Python consideran a este moito máis limpo e elegante para programar.

Python permite dividir o programa en módulos reutilizables desde outros programas Python. Vén cunha gran colección de módulos estándar que se poden utilizar como base dos programas (ou como exemplos para empezar a aprender Python). Tamén hai módulos incluídos que proporcionan E/S de ficheiros, chamadas ao sistema, sockets e ata interfaces a GUI (interface gráfica co usuario) como Tk, GTK, Qt entre outros...

Python é unha linguaxe interpretada, o que aforra un tempo considerable no desenvolvemento do programa, pois non é necesario compilar nin enlazar. O intérprete pódese utilizar de modo interactivo, o que facilita experimentar con características da linguaxe, escribir programas desechables ou probar funcións durante o desenvolvemento do programa. Tamén é unha calculadora moi útil.

O nome da linguaxe provén da afección do seu creador orixinal, Guido van Rossum, polos humoristas británicos Monty Python. O principal obxectivo que persegue esta linguaxe é a facilidade, tanto de lectura, como de deseño.

Un script en **Python**
**Python** é unha Linguaxe de programación orientada a obxectos e *interpretada*.

Paradigmas
----------

Python é unha linguaxe de programación multiparadigma. Isto significa que máis que forzar aos programadores a adoptar un estilo particular de programación, permite varios estilos:Programación orientada a obxectos, programación estruturada, programación funcional e programación orientada a aspectos. Outros moitos paradigmas máis están soportados mediante o uso de extensións. Python usa tipado dinámico de datos e reference counting para o manexo de memoria. Unha característica importante de Python é a resolución dinámica de nomes, o que enlaza un método e un nome de variable durante a execución do programa.

Outro obxectivo do deseño da linguaxe era a facilidade de extensión. Novos módulos pódense escribir facilmente en C ou C++. Python pode utilizarse como unha linguaxe de extensión para módulos e aplicacións que necesitan dunha interface programable.
Aínda que o deseño de Python é dalgún xeito hostil á programación funcional tradicional do Lisp, existen bastantes analoxías entre Python e as linguaxes minimalistas da familia do Lisp como pode ser Scheme.

Linguaxe interpretada
---------------------

Unha das súas características fundamentais é ser unha linguaxe interpretada (igual que TCL, perl etc), que pode ser executada en calquera sistema operativo, con tal de que este teña un intérprete desta linguaxe. Polo tanto, non se compila, senón un script interpretado pola máquina.

Filosofía da Linguaxe
---------------------

Os usuarios de Python refírense a miúdo á **Filosofía Python** que é bastante análoga á filosofía de Unix. O código que segue os principios de Python de lexibilidade e transparencia dise que é "pythonico". Contrariamente, o código opaco ou ofuscado é bautizado como "non pythonico" ("unpythonic" en inglés). Estes principios foron famosamente descritos polo desenvolvedor de Python Tim Peters en *O Zen de Python*:

Bonito é mellor que feo.  

Explícito é mellor que implícito.  

Simple é mellor que complexo.  

Complexo é mellor que complicado.  

Plano é mellor que aglomerado.  

Escaso é mellor que denso.  

A lexibilidade fai a diferenza.  

Os casos especiais non son tan especiais como para quebrar as regras.  

Aínda que a practicidade venza a pureza.  

Os erros nunca deben pasar silenciosamente.  

A menos que sexan explicitamente silenciados.  

Diante da ambigüidade, recuse a tentación de adiviñar.  

Debe haber un -- e preferencialmente só un -- xeito obvio de facer algo.  

Aínda que ese modo poida non ser obvio á primeira vista a menos que vostede sexa holandés.  

Agora é mellor que nunca.  

Aínda que nunca frecuentemente sexa mellor que \*exactamente\* agora.  

Se a implementación é difícil de explicar, é unha má idea.  

Se a implementación é fácil de explicar, pode ser unha boa idea.  

Os "espazos de nomes" son unha grande idea -- faremos máis desas!

Elementos da linguaxe
---------------------

Python foi deseñado para ser lido con facilidade. Entre outras cousas utilízanse palabras en inglés onde outras linguaxes utilizarían símbolos (por exemplo, os operadores lóxicos `||` e `&&` en Python escríbense `or` e `and`, respectivamente).

No canto de delimitar os bloques de código mediante o uso de chaves (`{}`), Python utiliza a indentación. Isto fai que a mesma sexa obrigatoria, axudando á claridade e consistencia do código escrito (ata entre varios desenvolvedores):

| Función factorial en C | Función factorial en Python |
| --- | --- |
| 
```
int factorial(int x)
{
 if (x == 0)
 return 1;
 else
 return x\*factorial(x - 1);
}

```
 | 
```
def factorial(x):
    if x == 0:
        return 1
    else:
        return x \* factorial(x-1)

```
 |

### Comentarios

Os comentarios inícianse co símbolo `#`, e esténdense ata o final da liña.

### Variables

As variables escríbense de forma dinámica. O signo igual (`=`) úsase para asignar valores ás variables:

```
x = 1
x = 'texto' # isto é posible porque as variables son dinámicamente tipadas

```

### Tipos de datos

Os tipos de datos pódense resumir nesta táboa:

| Tipo | Clase | Notas | Exemplo |
| --- | --- | --- | --- |
| `str` | String | Inmutable | `'Wikipedia'` |
| `unicode` | String | Versión Unicode de code <>str | `ou'Wikipedia'` |
| `list` | Secuencia | Mutable, pode conter diversos tipos | `[4.0, 'string', True]` |
| `tuple` | Secuencia | Immutable | `(4.0, 'string', True)` |
| `set` | Conxunto | Mutable, sen orde, non contén duplicados | `set([4.0, 'string', True])` |
| `frozenset` | Conxunto | Inmutable, sen orde, non contén duplicados | `frozenset([4.0, 'string', True])` |
| `dict` | Mapping | Grupo de pares claves, valor | `{'key1': 1.0, 'key2': False}` |
| `int` | Número enteiro | Precisión fixa | `42` |
| `long` | Número enteiro | Precisión arbitraria | `42L` ou `456966786151987643L` |
| `float` | Número | Coma flotante | `3.1415927` |
|

#### Tuplas e Listas

* Para declarar unha *lista*, basta empregar os corchetes(`[ ]`), mentres que para declarar unha *tupla* débense usar a paréntese `()`.
* Tanto as *listas* como as *tuplas* poden conter elementos de diferentes tipos.
* Para acceder aos elementos dunha *lista* ou *tupla*, utilízase un índice enteiro. Pódense utilizar índices negativos para acceder elementos a partir do final do array.
* As *listas* caracterízanse por ser mutables, é dicir, pódese cambiar o seu contido, mentres que non é posible modificar o contido dunha *tupla* xa creada, posto que é inmutable.

```
>>> lista = ['aaa', 1, 90]
>>> lista[-1]
90
>>> lista[0] = 'aaa'
>>> lista[0:2]
['aaa', 1]
 
>>> tupla = (1, 2, 3)
>>> tupla[0] = 2
 ( xera un erro )
>>> tupla[0]
1
>>> otratupla = (tupla, ('a', 'b')) # é posible aniñar tuplas

```

#### Dicionarios

Os dicionarios decláranse entre chaves (`{}`), a que pode conter pares de valores separados por dous puntos (:).

Neste exemplo, percórrese a estrutura de dicionario, e imprímese o seu contido da forma *clave*=*valor*

```
>>> dict = {"dia": 24, "mes": "agosto"}
>>> for k in dict:
... print("%s=%s" % (k, dict[k]))
 
dia=24
mes=agosto

```

#### Conxuntos

Os conxuntos decláranse mediante a instrución `set`. Os `set`s non permiten ter elementos repetidos.

```
>>> conj = set(['a','b','a'])
>>> print(conj)
set('a','b')

```

### Funcións

As funcións defínense coa palabra chave `def`, seguida do nome da función e os seus parámetros. Outra forma de crear funcións, aínda que máis limitada, é coa palabra chave `lambda` (que aparece en linguaxes funcionais como Lisp).

```
>>> f = lambda x: x+2
>>> f(4)
6

```

### Sistema de obxectos

En Python, todo é un obxecto (ata as clases). As clases, ao ser obxectos, son instancias dunha metaclase. Python ademais soporta herdanza múltiple e polimorfismo.

Biblioteca estándar
-------------------

Python vén con baterías "incluídas"
Python ten unha gran librería estándar, usada para unha diversidade de tarefas. Isto vén da filosofía "baterías incluídas" (*"batteries included"*) para módulos de Python. Os módulos da biblioteca estándar poden ser mellorados por módulos personalizados escritos tanto en C ou en Python. Debido á gran variedade de ferramentas incluídas na biblioteca estándar combinada coa habilidade de usar linguaxes de baixo nivel como C e C++, os cales son capaces de interactuar con outras bibliotecas, Python é unha linguaxe que combina a súa clara sintaxe co inmenso poder de linguaxes menos elegantes.

### Manexo de excepcións

Python soporta e usa intensamente o manexo de excepcións en execución (incluso é posible tratar a excepción de "erro sintáctico").

Postas en funcionamento
-----------------------

Python posúe diversas postas en funcionamento:

* CPython é a posta en funcionamento orixinal, dispoñible para varias plataformas no sitio oficial de Python.
* IronPython é a posta en funcionamento para .NET
* Stackless Python é a variante de CPython que trata de non usar o *stack* de C
* Jython é a posta en funcionamento feita en Java
* Pippy é a posta en funcionamento realizada para Palm
* PyPy é Python totalmente escrito en Python

Licenzas
--------

Python posúe unha licenza de código aberto, denominada *Python Software Foundation License*, que é compatible coa licenza GPL. Esta licenza non obriga a liberar o código fonte ao distribuír os arquivos binarios.

Utilización
-----------

Debido á súa potencia, a ser orientado a obxectos, así como á gran cantidade de librarías que trae incluídas (como por exemplo librarías gráficas), é unha linguaxe multi-propósito, tanto para *scripting* como para aplicacións máis serias.
A modo de exemplo, Google usa Python para multitude de tarefas, incluíndo os *backends* de aplicacions web tales como *Gmail*.

Fundamentalmente, debido á capacidade de orientación a obxectos, ten unha vantaxe considerable fronte a linguaxes de propósito similar, tal como TCL.

Notas
-----

1. ↑  Python Documentation: History and License
2. ↑  "Why was Python created in the first place?" (en inglés). Consultado o 10 de setembro de 2018.
3. ↑  "Python Tutorial". Arquivado dende o orixinal o 27 de agosto de 2006. Consultado o 19 de xaneiro de 2008.
4. ↑  www.stackless.com
5. ↑  pippy.sourceforge.net
6. ↑  "codespeak.net/pypy". Arquivado dende o orixinal o 05 de xaneiro de 2008. Consultado o 19 de xaneiro de 2008.
7. ↑  Python Software Foundation License, accesada o 1-03-2007

Véxase tamén
------------

|  |  |
| --- | --- |
|  | Wikimedia Commons ten máis contidos multimedia na categoría:  ***Python Modificar a ligazón no Wikidata*** |

### Outros artigos

* Perl
* TCL
* Java
* Ruby

### Ligazóns externas

* Páxina oficial de python *(en inglés)*
* Documentación sobre python *(en castelán)*
* Videoxogos con python *(en inglés)*

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q28865
* BNF: 13560465c
* FAST: 1084736
* GND: 4434275-5
* LCCN: sh96008834
* MAG: 519991488
* NKC: ph170668
* PSH: 13861
* SUDOC: 051626225

 |