Python - ferPiece/docs GitHub Wiki
- Introducción
- Modo interactivo
- Sintaxis Basica
- Control de flujo
- Estructuras de Datos
- La instrucción del
- Tuplas
Python es un lenguaje de programación fácil de aprender, muy poderoso, es un lenguaje orientado a objetos, multiparadigma, dinámico, con una sintaxis elegante y tipado dinámico ademas de ser interpretado, lo cual te ahorra tiempo de compilar.
Python permite escribir programas compactos y legibles. Los programas en Python son típicamente más cortos que sus programas equivalentes en C, C++ o Java por varios motivos:
los tipos de datos de alto nivel permiten expresar operaciones complejas en una sola instrucción la agrupación de instrucciones se hace por sangría en vez de llaves de apertura y cierre no es necesario declarar variables ni argumentos.
Python es extensible: si ya sabes programar en C es fácil agregar una nueva función o módulo al intérprete, ya sea para realizar operaciones críticas a velocidad máxima, o para enlazar programas Python con bibliotecas que tal vez sólo estén disponibles en forma binaria (por ejemplo bibliotecas gráficas específicas de un fabricante). Una vez que estés realmente entusiasmado, podés enlazar el intérprete Python en una aplicación hecha en C y usarlo como lenguaje de extensión o de comando para esa aplicación.
Por cierto, el lenguaje recibe su nombre del programa de televisión de la BBC “Monty Python’s Flying Circus” y no tiene nada que ver con reptiles. Hacer referencias a sketches de Monty Python en la documentación no sólo esta permitido, ¡sino que también está bien visto!
El intérprete de Python se instala normalmente en /usr/local/bin/python3.6 en las máquinas dónde está disponible; poner /usr/local/bin en el camino de búsqueda de tu intérprete de comandos Unix hace posible iniciarlo ingresando la orden:
$ python3.6
Python 3.6.0 (default, Dec 23 2016, 08:06:12)
[GCC 4.8.2] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>
Para usar el windows, recomiendo instalar Cmder
On Windows:
Python 3.6.0 (v3.6.0:41df79263a11, Dec 23 2016, 08:06:12) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
Probar python de modo interactivo:
>>> print ("Hello, Python!")
Hola, Python!
>>>
Por defecto, los archivos fuente son codificados en UTF-8 codificación estándar, a pesar de que la biblioteca estándar utiliza solamente ASCII para los identificadores. Para indicar convenciones de que el código fuente soporta UTF-8 o algún otro tipo de codificación usar el comando especial #! Ejemplo:
# -*- coding: encoding -*-
En Python no es necesario definir el tipo de dato de la variable, solo basta con asignarle el valor que deseemos.
>>> n = 1
1
Los números enteros como: 4, 20, 51, etc son del tipo int. Aquellos fraccionales por ejemplo 5.0, 5.16 son del tipo float
Python puede manipular cadenas de texto, las cuales pueden ser expresadas de distintas formas. Pueden estar encerradas en comillas simples ('...') o dobles ("...") con el mismo resultado
>>> 'pan solo' # comillas simples
'pan solo'
La función print() produce una salida más legible, omitiendo las comillas que la encierran e imprimiendo caracteres especiales y escapados:
>>> print('pan solo') # comillas simples
pan solo
Las cadenas de texto pueden ser concatenadas (pegadas juntas) con el operador + y repetidas con *:Las cadenas de texto pueden ser concatenadas (pegadas juntas) con el operador + y repetidas con *:
>>> n = 'hola'
>>> m = 'mundo'
>>> print(3 * n + ' ' + m)
holaholahola mundo
Dos o más cadenas literales (aquellas encerradas entre comillas) una al lado de la otra son automáticamente concatenadas:
>>> 'Ho' 'La'
'HoLa'
Esto solo funciona con dos literales, no con variables ni expresiones.
>>> prefijo = 'Ho'
prefijo 'La'
...
SintaxError: invalid sintax
>>> ('Hola' * 3) 'Mundo'
...
SintaxError: invalid sintax
Los caracteres antepuestos por \ sean interpretados como caracteres especiales, es posible usar cadenas crudas agregando una r antes de la primera comilla:
>>> print('C:\algun\nombre')
C:\algun
ombre
>>> print(r'C:\algun\nombre')
C:\algun\nombre
Las cadenas de texto literales pueden contener múltiples líneas. Una forma es usar triple comillas: """...""" o '''...'''. Los fin de línea son incluídos automáticamente, pero es posible prevenir esto agregando una \ al final de la línea. Por ejemplo:
print("""\
Uso: algo [OPTIONS]
-h Muestra el mensaje de uso
-H nombrehost Nombre del host al cual conectarse
""")
produce la siguiente salida: (nota que la línea inicial no está incluída)
Uso: algo [OPTIONS]
-h Muestra el mensaje de uso
-H nombrehost Nombre del host al cual conectarse
>>> x = True
>>> if x:
... print(x)
...
True
>>> x = [1,2,3,4,5]
>>> for i in x:
... print(x)
...
1
2
3
4
5
>>> x = ['hola', 'mundo']
>>> for i in x:
... print(i)
...
hola
mundo
>>> x = [1,2,3,4,5]
>>> i = 0
>>> while i < len(x):
... print(x[i])
... x+=1
...
1
2
3
4
5
>>> x = ['hola', 'mundo']
>>> while i < len(x):
... print(x[i])
... i+=1
...
hola
mundo
>>>
Si es necesario iterar una secuencia de números, es apropiado utilizar la funcion range(), la cual genera progresiones aritméticas:
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
>>>
El valor final nunca forma parte de la secuencia, range(10) genera 10 valores, los indices correspondientes para los items de una secuencia de longitud 10. Es posible hacer que el rango empiece con otro número, o especificar un incremento diferente (incluso negativo; algunas veces se lo llama ‘paso’):
>>> for i in range(5, 10):
... print(i)
...
5
6
7
8
9
>>>
>>> for i in range(0, 10, 3):
... print(i)
...
0
3
6
9
>>>
Para iterar sobre los índices de una secuencia, podés combinar range() y len() así:
>>> names = ['Cynthia', 'Adrian', 'Karina', 'Marcelo', 'Doris', 'Davis']
>>> for i in range(len(names)):
... print(i, names[i])
...
0 Cynthia
1 Adrian
2 Karina
3 Marcelo
4 Doris
5 David
La sentencia break, como en C, termina el bucle for o while más anidado.
Las sentencias del bucle pueden tener una cláusula else que es ejecutada cuando el bucle termina, luego de agotar la lista (con for) o cuando la condición se hace falsa (con while), pero no cuando el bucle es terminado con la sentencia break. Se ejemplifica en el siguiente bucle, que busca números primos:
>>> for n in range(2,10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'es igual a ', x, '*', n/x)
... break
... else:
... # sigue el bucle sin encontrar un factor
... print(n, ' es un numero primo.')
...
Cuando se usa con un ciclo, el else tiene más en común con el else de una declaración try que con el de un if: el else de un try se ejecuta cuando no se genera ninguna excepción, y el else de un ciclo se ejecuta cuando no hay ningún break
La sentencia pass no hace nada. Se puede usar para cuando una sentencia es requerida por la sintaxis pero el programa no requiere ninguna acción. Ejemplo
>>> while True:
... pass #Espera ocupado hasta la interrupción del teclado (Ctrl + C)
...
Se usa normalmente para crear clases en un mínima expresión
>>> class MyClase:
... pass
...
También puede usar para definir la cabecera de una función
>>> def mi_funcion(*args):
... pass
...
Definir una función pro medio de la palabra reservada def seguido del nombre de la función y la lista de parámetros formales entre paréntesis. Las sentencias que forman parte del cuerpo de la función empiezan en la linea siguiente y deben estar con sangría.
La primer sentencia de una función puede ser opcionalmente un docstrings.
>>> def nombre_funcion(*args):
... """Docstrings para documentar la función"""
... pass
...
Estilo de codificación PEP8
-
Usar sangrías de 4 espacios, no tabs.
-
4 espacios son un buen compromiso entre una sangría pequeña (permite mayor nivel de sangrado)y una sangría grande (más fácil de leer). Los tabs introducen confusión y es mejor dejarlos de lado.
-
Recortar las líneas para que no superen los 79 caracteres.
-
Esto ayuda a los usuarios con pantallas pequeñas y hace posible tener varios archivos de código abiertos, uno al lado del otro, en pantallas grandes.
-
Usar líneas en blanco para separar funciones y clases, y bloques grandes de código dentro de funciones.
-
Cuando sea posible, poner comentarios en una sola línea.
-
Usar docstrings.
-
Usar espacios alrededor de operadores y luego de las comas, pero no directamente dentro de paréntesis: a = f(1, 2) + g(3, 4).
-
Nombrar las clases y funciones consistentemente; la convención es usar NotacionCamello para clases y minusculas_con_guiones_bajos para funciones y métodos. Siempre usá self como el nombre para el primer argumento en los métodos.
-
No usar codificaciones estrafalarias si esperás usar el código en entornos internacionales. El default de Python, UTF-8, o incluso ASCII plano funcionan bien en la mayoría de los casos.
-
De la misma manera, no usar caracteres no-ASCII en los identificadores si hay incluso una pequeñísima chance de que gente que hable otro idioma tenga que leer o mantener el código.
Principales métodos de los objetos de una lista:
- list.apend(x) : Agregar un ítem al final de la lista.
- list.extend(L) : Extiende la lista agregándole todos los ítems de la lista dada.
- list.insert(i, x) : Inserta un ítem en una posición dada. El primer argumento es la posición seguido del valor.
- list.remove(x) : Quita el primer ítem de la lista cuyo valor sea x. Da error si no existe el ítem.
- list.pop([i]) : Quita el ítem de la lista en la posición dada y lo devuelve.
- list.pop() : Si no especifica el indice, quita y devuelve el ultimo elemento de la lista.
- list.clear() : Quita todos los elementos de la lista.
- list.index(x[, start[, end]]) : Devuelve un indice de la lista cuyo primer valor sea igual a x, los parámetros opcionales star y end se utilizan para limitar la búsqueda.
- list.count(x) : Devuelve el número de veces que aparece x en la lista.
- list.sort(key=None, reverse=False) :
- list.reverse(x) : Invierte los elementos de la lista in situ.
- list.copy(x) : Devuelve un copia de la lista.
Ejemplos.
>>> lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4', 'elemento1', 'elemento2']
>>> lista.count('elemento1')
2
>>> lista.index('elemento2')
1
>>> lista.index('elemento2', 4)
5
>>> lista.reverse()
>>> lista
['elemento2', 'elemento1', 'elemento4', 'elemento3', 'elemento2', 'elemento1']
>>> lista.append('elemento5')
>>> lista
['elemento2', 'elemento1', 'elemento4', 'elemento3', 'elemento2', 'elemento1', 'elemento5']
>>> lista.sort()
['elemento1', 'elemento1', 'elemento2', 'elemento2', 'elemento3', 'elemento4', 'elemento5']
>>> lista.pop()
'elemento5'
>>> lista
['elemento1', 'elemento1', 'elemento2', 'elemento2', 'elemento3', 'elemento4']
Los métodos de lista hacen que resulte muy fácil usar una lista como una pila, donde el último elemento añadido es el primer elemento retirado (“último en entrar, primero en salir”).
- Para agregar un ítem a la cima de la pila, se usa append().
- Para retirar un ítem de la cima de la pila, se usa pop() sin un índice explícito.
Por ejemplo:
>>> pila = [5,4,7,8,9,4,2]
>>> pila.append(3)
>>> pila.append(6)
>>> pila
[5,4,7,8,9,4,2,3,6]
>>> pila.pop()
7
>>> pila
[5,4,7,8,9,4,2,3]
Es posible usar una lista como una cola, donde el primer elemento añadido es el primer elemento retirado (“primero en entrar, primero en salir”); sin embargo, las listas no son eficientes para este propósito. Agregar y sacar del final de la lista es rápido, pero insertar o sacar del comienzo de una lista es lento (porque todos los otros elementos tienen que ser desplazados por uno).
Para implementar una cola, usá collections.deque el cual fue diseñado para agregar y sacar de ambas puntas de forma rápida. Por ejemplo:
>>> from collections import deque
>>> queue = deque(["Fer", "Cyn", "Rodrigo"])
>>> queue.append("Nico") # llega Nico
>>> queue.append("Lili") # llega Lili
>>> queue.popleft() # el primero en llegar ahora se va
'Fer'
>>> queue.popleft() # el segundo en llegar ahora se va
'Cyn'
>>> queue # el resto de la cola en órden de llegada
['Rodrigo', 'Nico', 'Lili']
Las listas aveces no me comprenden 😢😢😢
Las comprensiones de listas ofrecen una manera concisa de crear listas. Sus usos comunes son para hacer nuevas listas donde cada elemento es el resultado de algunas operaciones aplicadas a cada miembro de otra secuencia o iterable, o para crear una subsecuencia de esos elementos para satisfacer una condición determinada.
Por ejemplo 🤔
Asumir que queremos crear una lista de cuadrados, como:
>>> cuadrados = []
>>> for x in range(10):
... cuadrados.append(x**2)
...
>>> cuadrados
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Podemos calcularlo de la siguiente manera:
>>> cuadrados = [x ** 2 for x in range(10)]
que según leo por todos lados es más conciso y legible. 😅
Una lista de comprensión consiste de corchetes rodeando una expresión seguida de la declaración for y luego cero o más declaraciones for o if. El resultado será una nueva lista que sale de evaluar la expresión en el contexto de los for o if que le siguen. Por ejemplo, esta lista de comprensión combina los elementos de dos listas si no son iguales:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
lo cual es equivalente en forma tradicional a:
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Instrucción del
Hay una manera de quitar un ítem de una lista dado su índice en lugar de su valor: la instrucción del. Esta es diferente del método pop(), el cual devuelve un valor.
La instrucción del también puede usarse para quitar secciones de una lista o vaciar la lista completa.
Por ejemplo:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del puede usarse también para eliminar variables:
>>> del a
Una tupla consiste de un número de valores separados por comas, por ejemplo:
>>> t = 12345, 54321, 'hola!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hola!')
>>> # Las tuplas pueden anidarse:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hola!'), (1, 2, 3, 4, 5))
>>> # Las tuplas son inmutables:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # pero pueden contener objetos mutables:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
En la salida las tuplas siempre se encierran entre paréntesis, para que las tuplas anidadas puedan interpretarse correctamente; pueden ingresarse con o sin paréntesis, aunque a menudo los paréntesis son necesarios de todas formas (si la tupla es parte de una expresión más grande).
No es posible asignar a los ítems individuales de una tupla, pero sin embargo sí se puede crear tuplas que contengan objetos mutables, como las listas. A pesar de que las tuplas puedan parecerse a las listas, frecuentemente se utilizan en distintas situaciones y para distintos propósitos.
Las tuplas son inmutables y normalmente contienen una secuencia heterogénea de elementos que son accedidos al desempaquetar o indizar (o incluso acceder por atributo en el caso de las namedtuples). Las listas son mutables, y sus elementos son normalmente homogéneos y se acceden iterando a la lista.
Un problema particular es la construcción de tuplas que contengan 0 o 1 ítem: la sintaxis presenta algunas peculiaridades para estos casos. Las tuplas vacías se construyen mediante un par de paréntesis vacío; una tupla con un ítem se construye poniendo una coma a continuación del valor (no alcanza con encerrar un único valor entre paréntesis). Feo, pero efectivo.
Por ejemplo:
>>> vacia = ()
>>> singleton = 'hola', # <-- notar la coma al final
>>> len(vacia)
0
>>> len(singleton)
1
>>> singleton
('hola',)