Primeros pasos con el lenguaje Python

Empezando

Python es un lenguaje de programación de alto nivel ampliamente utilizado para la programación de propósito general, creado por Guido van Rossum y lanzado por primera vez en 1991. Python presenta un sistema de tipos dinámicos y administración automática de memoria y admite múltiples paradigmas de programación, incluidos los orientados a objetos, imperativo, programación funcional y estilos procedimentales. Tiene una biblioteca estándar grande y completa.

Dos versiones principales de Python están actualmente en uso activo:

  • Python 3.x es la versión actual y está en desarrollo activo.
  • Python 2.x es la versión heredada y solo recibirá actualizaciones de seguridad hasta 2020. No se implementarán nuevas funciones. Tenga en cuenta que muchos proyectos todavía usan Python 2, aunque la migración a Python 3 es cada vez más fácil.

Puede descargar e instalar cualquier versión de Python [aquí] descargas. Consulte [Python 3 vs. Python 2] comparación de Python para ver una comparación entre ellos. Además, algunos terceros ofrecen versiones reempaquetadas de Python que agregan bibliotecas de uso común y otras características para facilitar la configuración para casos de uso común, como matemáticas, análisis de datos o uso científico. Ver [la lista en el sitio oficial] reempaquetado.

Verificar si Python está instalado

Para confirmar que Python se instaló correctamente, puede verificarlo ejecutando el siguiente comando en su terminal favorito (si está utilizando el sistema operativo Windows, debe agregar la ruta de python a la variable de entorno antes de usarla en el símbolo del sistema):

$ python --version

Si tiene Python 3 instalado y es su versión predeterminada (consulte Solución de problemas para obtener más detalles), debería ver algo como esto:

$ python --version
Python 3.6.0

Si tiene Python 2 instalado y es su versión predeterminada (consulte Solución de problemas para obtener más detalles), debería ver algo como esto:

$ python --version
Python 2.7.13

Si ha instalado Python 3, pero $ python --version genera una versión de Python 2, también tiene instalado Python 2. Este suele ser el caso en MacOS y en muchas distribuciones de Linux. Use $ python3 en su lugar para usar explícitamente el intérprete de Python 3.

Hola, Mundo en Python usando IDLE


IDLE es un editor simple para Python, que viene incluido con Python.

Cómo crear el programa Hello, World en IDLE

  • Abra IDLE en su sistema de elección.
    • In older versions of Windows, it can be found at All Programs under the Windows menu.
    • In Windows 8+, search for IDLE or find it in the apps that are present in your system.
    • On Unix-based (including Mac) systems you can open it from the shell by typing $ idle python_file.py.
  • Se abrirá un caparazón con opciones en la parte superior.

En el caparazón, hay un indicador de tres corchetes de ángulo recto:

>>>

Ahora escribe el siguiente código en el indicador:

>>> print("Hello, World")

Pulse Intro.

>>> print("Hello, World")
Hello, World

Archivo Python Hola Mundo

Cree un nuevo archivo hello.py que contenga la siguiente línea:

print('Hello, World')

Puede usar la función “imprimir” de Python 3 en Python 2 con la siguiente instrucción “importar”:

from __future__ import print_function

Python 2 tiene una serie de funcionalidades que se pueden importar opcionalmente desde Python 3 usando el módulo __future__, como discutido aquí.

Si usa Python 2, también puede escribir la línea a continuación. Tenga en cuenta que esto no es válido en Python 3 y, por lo tanto, no se recomienda porque reduce la compatibilidad del código entre versiones.

print 'Hello, World'

En su terminal, navegue hasta el directorio que contiene el archivo hello.py.

Escriba python hello.py, luego presione la tecla Enter.

$ python hello.py
Hello, World

Debería ver Hello, World impreso en la consola.

También puede sustituir hello.py con la ruta a su archivo. Por ejemplo, si tiene el archivo en su directorio de inicio y su usuario es “usuario” en Linux, puede escribir python /home/user/hello.py.

Inicie un shell de Python interactivo

Al ejecutar (ejecutar) el comando python en su terminal, se le presenta un shell de Python interactivo. Esto también se conoce como Python Interpreter o REPL (para ‘Read Evaluate Print Loop’).

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

Si desea ejecutar Python 3 desde su terminal, ejecute el comando python3.

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

Alternativamente, inicie el indicador interactivo y cargue el archivo con python -i <file.py>.

En la línea de comando, ejecute:

$ python -i hello.py
"Hello World"
>>>

Hay varias formas de cerrar el shell de Python:

>>> exit()

o

>>> quit()

Alternativamente, CTRL + D cerrará el shell y lo regresará a la línea de comando de su terminal.

Si desea cancelar un comando que está escribiendo y volver a un símbolo del sistema limpio, mientras permanece dentro del intérprete de comandos, use CTRL + C.

Pruebe un shell de Python interactivo en línea.

Otras conchas en línea

Varios sitios web brindan acceso en línea a shells de Python.

Los proyectiles en línea pueden ser útiles para los siguientes propósitos:

  • Ejecute un pequeño fragmento de código desde una máquina que carece de python instalación (teléfonos inteligentes, tabletas, etc.).
  • Aprende o enseña Python básico.
  • Resolver problemas de juez en línea.

Ejemplos:

Descargo de responsabilidad: los autores de la documentación no están afiliados a ninguna recursos enumerados a continuación.

  • https://www.python.org/shell/ - El shell de Python en línea alojado en el sitio web oficial de Python.
  • https://ideone.com/ - Ampliamente utilizado en la Red para ilustrar código comportamiento del fragmento.
  • https://repl.it/languages/python3 - Potente y simple en línea compilador, IDE e intérprete. Codifique, compile y ejecute código en Python.
  • https://www.tutorialspoint.com/execute_python_online.php - Shell UNIX con todas las funciones y un explorador de proyectos fácil de usar.
  • http://rextester.com/l/python3_online_compiler - IDE simple y fácil de usar que muestra el tiempo de ejecución

Ejecutar comandos como una cadena

A Python se le puede pasar código arbitrario como una cadena en el shell:

$ python -c 'print("Hello, World")'
Hello, World

Esto puede ser útil al concatenar los resultados de los scripts en el shell.

Conchas y más allá

Administración de paquetes: la herramienta recomendada por PyPA para instalar paquetes de Python es PIP. Para instalar, en su línea de comando ejecute pip install <el nombre del paquete>. Por ejemplo, pip install numpy. (Nota: en Windows debe agregar pip a sus variables de entorno PATH. Para evitar esto, use python -m pip install <el nombre del paquete>)

Conchas: hasta ahora, hemos discutido diferentes formas de ejecutar código utilizando la shell interactiva nativa de Python. Los shells usan el poder interpretativo de Python para experimentar con código en tiempo real. Los shells alternativos incluyen [IDLE], una GUI preempaquetada, IPython, conocida por ampliar la experiencia interactiva, etc.

Programas: para el almacenamiento a largo plazo, puede guardar contenido en archivos .py y editarlos/ejecutarlos como scripts o programas con herramientas externas, p. shell, IDE (como PyCharm), cuadernos de Jupyter, etc. Los usuarios intermedios pueden usar estas herramientas; sin embargo, los métodos discutidos aquí son suficientes para comenzar.

[Tutor de Python][7] le permite recorrer paso a paso el código de Python para que pueda visualizar cómo fluirá el programa y le ayuda a comprender dónde salió mal su programa.

PEP8 define las pautas para formatear el código de Python. Formatear bien el código es importante para que pueda leer rápidamente lo que hace el código.

1: https://www.wikiod.com/es/python/primeros-pasos-con-el-lenguaje-python#IDLE - Interfaz gráfica de usuario de Python 2: https://docs.python.org/2/library/idle.html 3: https://www.wikiod.com/es/python/incompatibilidades-al-pasar-de-python-2-a-python-3 between-python-3-and-python-2/6894/use-future-imports#t=201612062212456247425 4: https://docs.python.org/3.6/tutorial/interpreter.html 5: https://www.python.org/shell/ 6: https://github.com/jupyter/notebook [7]: http://www.pythontutor.com/visualize.html#mode=editar

Creando variables y asignando valores

Para crear una variable en Python, todo lo que necesita hacer es especificar el nombre de la variable y luego asignarle un valor.

<variable name> = <value>

Python usa = para asignar valores a las variables. No es necesario declarar una variable por adelantado (o asignarle un tipo de datos), asignar un valor a una variable declara e inicializa la variable con ese valor. No hay forma de declarar una variable sin asignarle un valor inicial.

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

La asignación de variables funciona de izquierda a derecha. Entonces, lo siguiente le dará un error de sintaxis.

0 = x
=> Output: SyntaxError: can't assign to literal

No puede usar las palabras clave de python como un nombre de variable válido. Puede ver la lista de palabras clave por:

import keyword
print(keyword.kwlist)

Reglas para nombrar variables:

  1. Los nombres de las variables deben comenzar con una letra o un guión bajo.

    x = True # valid _y = True # valid

    9x = False # starts with numeral => SyntaxError: invalid syntax

    $y = False # starts with symbol => SyntaxError: invalid syntax

  2. El resto del nombre de su variable puede consistir en letras, números y guiones bajos.

    has_0_in_it = “Still Valid”

  3. Los nombres distinguen entre mayúsculas y minúsculas.

    x = 9
    y = X*5
    =>NameError: name ‘X’ is not defined


Aunque no es necesario especificar un tipo de datos al declarar una variable en Python, al asignar el área necesaria en la memoria para la variable, el intérprete de Python selecciona automáticamente el tipo integrado más adecuado para ella:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

Ahora que conoce los conceptos básicos de la asignación, eliminemos esta sutileza sobre la asignación en python.

Cuando usa = para hacer una operación de asignación, lo que está a la izquierda de = es un nombre para el objeto a la derecha. Finalmente, lo que hace = es asignar la referencia del objeto de la derecha al nombre de la izquierda.

Eso es:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

Entonces, de muchos ejemplos de asignaciones anteriores, si elegimos pi = 3.14, entonces pi es un nombre (no el nombre, ya que un objeto puede tener múltiples nombres) para el objeto 3.14 . Si no entiende algo a continuación, vuelva a este punto y lea esto de nuevo. Además, puede echar un vistazo a esto para una mejor comprensión.


Puede asignar múltiples valores a múltiples variables en una línea. Tenga en cuenta que debe haber el mismo número de argumentos en los lados derecho e izquierdo del operador =:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

El error del último ejemplo se puede obviar asignando los valores restantes a igual número de variables arbitrarias. Esta variable ficticia puede tener cualquier nombre, pero es convencional usar el guión bajo (_) para asignar valores no deseados:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

Tenga en cuenta que el número de _ y el número de valores restantes deben ser iguales. De lo contrario, se arroja ‘demasiados valores para desempaquetar el error’ como se indica arriba:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

También puede asignar un valor único a varias variables simultáneamente.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

Al usar tal asignación en cascada, es importante tener en cuenta que las tres variables a, b y c se refieren al mismo objeto en la memoria, un objeto int con el valor de 1. En otras palabras , a, b y c son tres nombres diferentes dados al mismo objeto int. Asignar un objeto diferente a uno de ellos después no cambia los demás, tal como se esperaba:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

Lo anterior también es cierto para tipos mutables (como list, dict, etc.) al igual que para tipos inmutables (como int, string, tuple, etc.):

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

Hasta aquí todo bien. Las cosas son un poco diferentes cuando se trata de modificar el objeto (en contraste con asignar el nombre a un objeto diferente, lo que hicimos anteriormente) cuando la asignación en cascada se usa para tipos mutables. Echa un vistazo a continuación y lo comprobarás de primera mano:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

Las listas anidadas también son válidas en python. Esto significa que una lista puede contener otra lista como elemento.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

Por último, las variables en Python no tienen que permanecer del mismo tipo que el que se definió por primera vez; simplemente puede usar = para asignar un nuevo valor a una variable, incluso si ese valor es de un tipo diferente.

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

Si esto te molesta, piensa en el hecho de que lo que está a la izquierda de = es solo el nombre de un objeto. Primero llamas al objeto int con el valor 2 a, luego cambias de opinión y decides dar el nombre a a un objeto string, que tiene el valor ‘Nuevo valor’. Sencillo, ¿verdad?

1: https://www.wikiod.com/es/python/primeros-pasos-con-el-lenguaje-python#Tipos de datos 2: http://effbot.org/zone/python-objects.htm

Sangría de bloque

Python usa sangría para definir construcciones de control y bucle. Esto contribuye a la legibilidad de Python, sin embargo, requiere que el programador preste mucha atención al uso de espacios en blanco. Por lo tanto, la mala calibración del editor podría dar como resultado un código que se comporta de manera inesperada.

Python usa el símbolo de dos puntos (:) y la sangría para mostrar dónde comienzan y terminan los bloques de código (si vienes de otro idioma, no confundas esto con estar relacionado de alguna manera con el operador ternario). Es decir, los bloques en Python, como funciones, bucles, cláusulas if y otras construcciones, no tienen identificadores finales. Todos los bloques comienzan con dos puntos y luego contienen las líneas sangradas debajo.

Por ejemplo:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

o

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

Los bloques que contienen exactamente una declaración de una sola línea pueden colocarse en la misma línea, aunque esta forma generalmente no se considera de buen estilo:

if a > b: print(a)
else: print(b)  

Intentar hacer esto con más de una declaración no funcionará:

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

Un bloque vacío provoca un IndentationError. Use pass (un comando que no hace nada) cuando tenga un bloque sin contenido:

def will_be_implemented_later():
    pass

Espacios vs. Pestañas

En resumen: siempre use 4 espacios para la sangría.

Es posible usar tabulaciones exclusivamente, pero PEP 8, la guía de estilo para el código de Python, establece que se prefieren los espacios.

Python 3 no permite mezclar el uso de tabulaciones y espacios para la sangría. En tal caso, se genera un error en tiempo de compilación: Uso inconsistente de tabulaciones y espacios en la sangría y el programa no se ejecutará.

Python 2 permite mezclar tabulaciones y espacios en sangría; esto está fuertemente desaconsejado. El carácter de tabulación completa la sangría anterior para ser un múltiplo de 8 espacios. Dado que es común que los editores estén configurados para mostrar pestañas como múltiplos de 4 espacios, esto puede causar errores sutiles.

Citando PEP 8:

Al invocar el intérprete de línea de comandos de Python 2 con la opción -t, emite advertencias sobre el código que mezcla ilegalmente tabulaciones y espacios. Cuando se usa -tt, estas advertencias se convierten en errores. ¡Estas opciones son muy recomendables!

Muchos editores tienen una configuración de “pestañas a espacios”. Al configurar el editor, se debe diferenciar entre el tabulador carácter (’\t’) y la tecla Tab.

  • La pestaña carácter debe configurarse para mostrar 8 espacios, para que coincida con la semántica del idioma, al menos en los casos en que sea posible una sangría mixta (accidental). Los editores también pueden convertir automáticamente el carácter de tabulación en espacios.
  • Sin embargo, podría ser útil configurar el editor para que al presionar la tecla Tab se inserten 4 espacios, en lugar de insertar un carácter de tabulación.

El código fuente de Python escrito con una combinación de tabulaciones y espacios, o con un número no estándar de espacios de sangría, se puede hacer compatible con pep8 usando autopep8. (Una alternativa menos poderosa viene con la mayoría de las instalaciones de Python: reindent.py)

Tipos de datos

Tipos incorporados

Booleanos

bool: Un valor booleano de Verdadero o Falso. Las operaciones lógicas como y, o, no se pueden realizar en booleanos.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

En Python 2.x y en Python 3.x, un booleano también es un int. El tipo bool es una subclase del tipo int y True y False son sus únicas instancias:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Si se utilizan valores booleanos en operaciones aritméticas, sus valores enteros (1 y 0 para Verdadero y Falso) se utilizarán para devolver un resultado entero:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Números

  • int: número entero

     a = 2
     b = 100
     c = 123456789
     d = 38563846326424324
    

    Integers in Python are of arbitrary sizes.

    Note: in older versions of Python, a long type was available and this was distinct from int. The two have been unified.

  • float: Número de punto flotante; la precisión depende de la implementación y la arquitectura del sistema, para CPython el tipo de datos flotante corresponde a un doble de C.

     a = 2.0
     b = 100.e0
     c = 123456789.e1
    
  • complejo: Números complejos

     a = 2 + 1j
     b = 100 + 10j
    

Los operadores <, <=, > y >= generarán una excepción TypeError cuando cualquier operando sea un número complejo.

Cuerdas

  • str: una cadena Unicode. El tipo de 'hola'
  • bytes: una cadena de bytes. El tipo de b'hola'
  • str: una cadena de bytes. El tipo de 'hola'
  • bytes: sinónimo de str
  • unicode: una cadena Unicode. El tipo de u'hola'

Secuencias y colecciones

Python diferencia entre secuencias ordenadas y colecciones desordenadas (como set y dict).

  • las cadenas (str, bytes, unicode) son secuencias

  • reversed: Un orden inverso de str con la función reversed

      a = reversed('hello')
    
  • tupla: Una colección ordenada de valores n de cualquier tipo (n >= 0).

      a = (1, 2, 3)
      b = ('a', 1, 'python', (1, 2))
      b[2] = 'something else' # returns a TypeError
    

    Supports indexing; immutable; hashable if all its members are hashable

  • lista: Una colección ordenada de valores n (n >= 0)

      a = [1, 2, 3]
      b = ['a', 1, 'python', (1, 2), [1, 2]]
      b[2] = 'something else' # allowed
    

    Not hashable; mutable.

  • set: Una colección desordenada de valores únicos. Los artículos deben ser hashable.

      a = {1, 2, 'a'}
    
  • dict: Una colección desordenada de pares clave-valor únicos; las claves deben ser hashable.

      a = {1: 'one',
           2: 'two'}
    
      b = {'a': [1, 2, 3],
           'b': 'a string'}
    

Un objeto es hashable si tiene un valor hash que nunca cambia durante su vida útil (necesita un método __hash__()), y puede compararse con otros objetos (necesita un método __eq__()). Los objetos hash que comparan la igualdad deben tener el mismo valor hash.

Constantes incorporadas

Junto con los tipos de datos integrados, hay una pequeña cantidad de constantes integradas en el espacio de nombres integrado:

  • True: El valor verdadero del tipo integrado bool

  • False: El valor falso del tipo incorporado bool

  • Ninguno: Un objeto singleton usado para señalar que un valor está ausente.

  • Ellipsis o ...: usado en el núcleo de Python3+ en cualquier lugar y uso limitado en Python2.7+ como parte de la notación de matriz. numpy y los paquetes relacionados usan esto como una referencia de ‘incluir todo’ en las matrices.

  • NotImplemented: un singleton utilizado para indicar a Python que un método especial no admite los argumentos específicos, y Python probará alternativas si están disponibles.

    a = None # No value will be assigned. Any valid datatype can be assigned later

Ninguno no tiene ningún orden natural. El uso de operadores de comparación de pedidos (<, <=, >=, >) ya no se admite y generará un TypeError.

Ninguno siempre es menor que cualquier número (Ninguno < -32 se evalúa como Verdadero).

Probando el tipo de variables

En python, podemos verificar el tipo de datos de un objeto usando la función incorporada type.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

En sentencias condicionales es posible probar el tipo de datos con isinstance. Sin embargo, por lo general no se recomienda confiar en el tipo de variable.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Para obtener información sobre las diferencias entre type() y isinstance(), lea: Diferencias entre isinstance y type en Python

Para probar si algo es de NoneType:

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Convertir entre tipos de datos

Puede realizar una conversión de tipo de datos explícita.

Por ejemplo, ‘123’ es del tipo ‘str’ y se puede convertir a entero usando la función ‘int’.

a = '123'
b = int(a)

La conversión de una cadena flotante como ‘123.456’ se puede hacer usando la función ‘flotante’.

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

También puede convertir tipos de secuencias o colecciones.

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Tipo de cadena explícito en la definición de literales

Con etiquetas de una letra justo delante de las comillas, puede saber qué tipo de cadena desea definir.

  • b'foo bar': da como resultado bytes en Python 3, str en Python 2

  • u'foo bar': resultados str en Python 3, unicode en Python 2

  • 'foo bar': resultados str

  • r'foo bar': da como resultado la llamada cadena sin procesar, donde no es necesario escapar de los caracteres especiales, todo se toma literalmente a medida que escribe

    normal = ‘foo\nbar’ # foo # bar escaped = ‘foo\nbar’ # foo\nbar
    raw = r’foo\nbar’ # foo\nbar

Tipos de datos mutables e inmutables

Un objeto se llama mutable si se puede cambiar. Por ejemplo, cuando pasa una lista a alguna función, la lista se puede cambiar:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Un objeto se llama inmutable si no se puede cambiar de ninguna manera. Por ejemplo, los números enteros son inmutables, ya que no hay forma de cambiarlos:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Tenga en cuenta que las variables en sí mismas son mutables, por lo que podemos reasignar la variable x, pero esto no cambia el objeto al que x había apuntado previamente. Solo hizo que x apuntara a un nuevo objeto.

Los tipos de datos cuyas instancias son mutables se denominan tipos de datos mutables, y de manera similar para objetos y tipos de datos inmutables.

Ejemplos de tipos de datos inmutables:

  • int, largo, flotante, complejo
  • str
  • bytes
  • tupla
  • congelado

Ejemplos de tipos de datos mutables:

  • rayo byte
  • lista
  • conjunto
  • dict

2: https://stackoverflow.com/questions/1549801/differences- between-isinstance-and-type-in-python

Tipos de colección

Hay una serie de tipos de colección en Python. Mientras que los tipos como int y str contienen un solo valor, los tipos de colección contienen múltiples valores.

Liza

El tipo list es probablemente el tipo de colección más utilizado en Python. A pesar de su nombre, una lista se parece más a una matriz en otros lenguajes, principalmente JavaScript. En Python, una lista es simplemente una colección ordenada de valores de Python válidos. Se puede crear una lista encerrando valores, separados por comas, entre corchetes:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Una lista puede estar vacía:

empty_list = []

Los elementos de una lista no están restringidos a un solo tipo de datos, lo cual tiene sentido dado que Python es un lenguaje dinámico:

mixed_list = [1, 'abc', True, 2.34, None]

Una lista puede contener otra lista como su elemento:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

Se puede acceder a los elementos de una lista a través de un índice o representación numérica de su posición. Las listas en Python tienen índice cero, lo que significa que el primer elemento de la lista está en el índice 0, el segundo elemento está en el índice 1 y así sucesivamente:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

Los índices también pueden ser negativos, lo que significa contar desde el final de la lista (-1 es el índice del último elemento). Entonces, usando la lista del ejemplo anterior:

print(names[-1]) # Eric
print(names[-4]) # Bob

Las listas son mutables, por lo que puede cambiar los valores en una lista:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Además, es posible agregar y/o eliminar elementos de una lista:

Agregue el objeto al final de la lista con L.append (objeto), devuelve Ninguno.

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Agregue un nuevo elemento a la lista en un índice específico. L.insertar(índice, objeto)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Elimina la primera ocurrencia de un valor con L.remove(value), devuelve Ninguno

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Obtenga el índice en la lista del primer elemento cuyo valor es x. Mostrará un error si no existe tal elemento.

name.index("Alice")
0

Contar la longitud de la lista

len(names)
6

contar la aparición de cualquier elemento en la lista

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Invertir la lista

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Eliminar y devolver el elemento en el índice (predeterminado en el último elemento) con L.pop([index]), devuelve el elemento

names.pop() # Outputs 'Sia'

Puede iterar sobre los elementos de la lista como se muestra a continuación:

for element in my_list:
    print (element)

Tuplas

Una ’tupla’ es similar a una lista excepto que es de longitud fija e inmutable. Por lo tanto, los valores en la tupla no se pueden cambiar ni se pueden agregar o quitar valores de la tupla. Las tuplas se usan comúnmente para pequeñas colecciones de valores que no necesitarán cambiar, como una dirección IP y un puerto. Las tuplas se representan con paréntesis en lugar de corchetes:

ip_address = ('10.20.30.40', 8080)

Las mismas reglas de indexación para las listas también se aplican a las tuplas. Las tuplas también se pueden anidar y los valores pueden ser cualquier Python válido.

Una tupla con un solo miembro debe definirse (nótese la coma) de esta manera:

one_member_tuple = ('Only member',)

o

one_member_tuple = 'Only member',   # No brackets

o simplemente usando la sintaxis tuple

one_member_tuple = tuple(['Only member'])

Diccionarios

Un diccionario en Python es una colección de pares clave-valor. El diccionario está rodeado de llaves. Cada par está separado por una coma y la clave y el valor están separados por dos puntos. Aquí hay un ejemplo:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Para obtener un valor, refiérase a él por su clave:

ca_capital = state_capitals['California']

También puede obtener todas las claves en un diccionario y luego iterar sobre ellas:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

Los diccionarios se parecen mucho a la sintaxis JSON. El módulo json nativo en la biblioteca estándar de Python se puede usar para convertir entre JSON y diccionarios.

establecer

Un conjunto es una colección de elementos sin repeticiones y sin orden de inserción, pero ordenados. Se utilizan en situaciones en las que solo es importante que se agrupen algunas cosas y no el orden en que se incluyeron. Para grandes grupos de datos, es mucho más rápido verificar si un elemento está o no en un “conjunto” que hacer lo mismo para una “lista”.

Definir un conjunto es muy similar a definir un diccionario:

first_names = {'Adam', 'Beth', 'Charlie'}

O puede construir un conjunto usando una lista existente:

my_list = [1,2,3]
my_set = set(my_list)

Comprueba la pertenencia al set usando in:

if name in first_names:
    print(name)

Puede iterar sobre un conjunto exactamente como una lista, pero recuerde: los valores estarán en un orden arbitrario definido por la implementación.

dictado por defecto

Un defaultdict es un diccionario con un valor predeterminado para las claves, por lo que se puede acceder sin errores a las claves para las que no se ha definido explícitamente ningún valor. defaultdict es especialmente útil cuando los valores en el diccionario son colecciones (listas, dictados, etc.) en el sentido de que no necesita inicializarse cada vez que se usa una nueva clave.

Un defaultdict nunca generará un KeyError. Cualquier clave que no existe obtiene el valor predeterminado devuelto.

Por ejemplo, considere el siguiente diccionario

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Si intentamos acceder a una clave inexistente, python nos devuelve un error de la siguiente manera

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

Probemos con un defaultdict. Se puede encontrar en el módulo de colecciones.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

Lo que hicimos aquí es establecer un valor predeterminado (Boston) en caso de que la clave de transferencia no exista. Ahora complete el dictado como antes:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

Si intentamos acceder al dict con una clave inexistente, Python nos devolverá el valor predeterminado, es decir, Boston

>>> state_capitals['Alabama']
'Boston'

y devuelve los valores creados para la clave existente como un diccionario normal

>>> state_capitals['Arkansas']
'Little Rock'

IDLE - interfaz gráfica de usuario de Python

IDLE es el entorno de aprendizaje y desarrollo integrado de Python y es una alternativa a la línea de comandos. Como su nombre lo indica, IDLE es muy útil para desarrollar código nuevo o aprender Python. En Windows, esto viene con el intérprete de Python, pero en otros sistemas operativos es posible que deba instalarlo a través de su administrador de paquetes.

Los propósitos principales de IDLE son:

  • Editor de texto de múltiples ventanas con resaltado de sintaxis, autocompletado y sangría inteligente
  • Python shell con resaltado de sintaxis
  • Depurador integrado con pasos, puntos de interrupción persistentes y llamada visibilidad de la pila
  • Sangría automática (útil para principiantes que aprenden sobre la sangría de Python)
  • Guardar el programa Python como archivos .py y ejecutarlos y editarlos más tarde en cualquiera de ellos usando IDLE.

En IDLE, presione F5 o ejecutar Python Shell para iniciar un intérprete. El uso de IDLE puede ser una mejor experiencia de aprendizaje para los nuevos usuarios porque el código se interpreta a medida que el usuario escribe.

Tenga en cuenta que hay muchas alternativas, consulte, por ejemplo, [esta discusión] (http://stackoverflow.com/questions/81584/what-ide-to-use-for-python) o [esta lista] (https:// wiki.python.org/moin/PythonEditors).

Solución de problemas

  • Ventanas

    If you’re on Windows, the default command is python. If you receive a "'python' is not recognized" error, the most likely cause is that Python’s location is not in your system’s PATH environment variable. This can be accessed by right-clicking on ‘My Computer’ and selecting ‘Properties’ or by navigating to ‘System’ through ‘Control Panel’. Click on ‘Advanced system settings’ and then ‘Environment Variables…’. Edit the PATH variable to include the directory of your Python installation, as well as the Script folder (usually C:\Python27;C:\Python27\Scripts). This requires administrative privileges and may require a restart.

    When using multiple versions of Python on the same machine, a possible solution is to rename one of the python.exe files. For example, naming one version python27.exe would cause python27 to become the Python command for that version.

    You can also use the Python Launcher for Windows, which is available through the installer and comes by default. It allows you to select the version of Python to run by using py -[x.y] instead of python[x.y]. You can use the latest version of Python 2 by running scripts with py -2 and the latest version of Python 3 by running scripts with py -3.

  • Debian/Ubuntu/MacOS

    This section assumes that the location of the python executable has been added to the PATH environment variable.

    If you’re on Debian/Ubuntu/MacOS, open the terminal and type python for Python 2.x or python3 for Python 3.x.

    Type which python to see which Python interpreter will be used.

  • Arco Linux

    The default Python on Arch Linux (and descendants) is Python 3, so use python or python3 for Python 3.x and python2 for Python 2.x.

  • Otros sistemas

Python 3 a veces está vinculado a python en lugar de python3. Para usar Python 2 en estos sistemas donde está instalado, puede usar python2.

Entrada del usuario

Entrada interactiva

Para obtener información del usuario, use la función input (nota: en Python 2.x, la función se llama raw_input, aunque Python 2.x tiene su propia versión de [input] 1 que es completamente diferente):

name = raw_input("What is your name? ")
# Out: What is your name? _

Observación de seguridad No use input() en Python2: el texto ingresado se evaluará como si fuera una expresión de Python (equivalente a eval(input()) en Python3), que podría convertirse fácilmente una vulnerabilidad Consulte este artículo para obtener más información sobre los riesgos de utilizar esta función.

name = input("What is your name? ")
# Out: What is your name? _

El resto de este ejemplo utilizará la sintaxis de Python 3.

La función toma un argumento de cadena, que lo muestra como un indicador y devuelve una cadena. El código anterior proporciona un aviso, esperando que el usuario ingrese.

name = input("What is your name? ")
# Out: What is your name?

Si el usuario escribe “Bob” y presiona enter, la variable name se asignará a la cadena "Bob":

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

Tenga en cuenta que la entrada siempre es del tipo str, lo cual es importante si desea que el usuario ingrese números. Por lo tanto, debe convertir str antes de intentar usarlo como un número:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: Se recomienda usar [bloques try/except](https://www.wikiod.com/es/python/excepciones Catching-Exceptions#t=201607241956183569764) para [atrapar excepciones cuando se trata de entradas del usuario] (https://www.wikiod.com/es/python/excepciones#Ejemplos prácticos de manejo de excepciones). Por ejemplo, si su código quiere convertir un raw_input en un int, y lo que el usuario escribe no se puede convertir, genera un ValueError.

Módulos y funciones integrados

Un módulo es un archivo que contiene definiciones y declaraciones de Python. La función es una pieza de código que ejecuta alguna lógica.

>>> pow(2,3)    #8

Para verificar la función incorporada en Python, podemos usar dir(). Si se llama sin un argumento, devuelve los nombres en el ámbito actual. De lo contrario, devuelve una lista alfabética de nombres que comprenden (algunos de) el atributo del objeto dado y los atributos accesibles desde él.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

Para conocer la funcionalidad de cualquier función, podemos usar la función help incorporada.

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

Los módulos incorporados contienen funcionalidades adicionales. Por ejemplo, para obtener la raíz cuadrada de un número, debemos incluir el módulo matemáticas.

>>> import math
>>> math.sqrt(16) # 4.0

Para conocer todas las funciones de un módulo, podemos asignar la lista de funciones a una variable y luego imprimir la variable.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

parece que __doc__ es útil para proporcionar algo de documentación en, por ejemplo, funciones

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

Además de las funciones, la documentación también se puede proporcionar en módulos. Entonces, si tiene un archivo llamado helloWorld.py como este:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

Puede acceder a sus cadenas de documentos de esta manera:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'
  • Para cualquier tipo definido por el usuario, sus atributos, los atributos de su clase y recursively the attributes of its class’s base classes can be retrieved using dir()

    class MyClassObject(object): … pass … dir(MyClassObject) [’class’, ‘delattr’, ‘dict’, ‘doc’, ‘format’, ‘getattribute’, ‘hash’, ‘init’, ‘module’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’]

Cualquier tipo de datos se puede convertir simplemente en una cadena usando una función integrada llamada str. Esta función se llama de forma predeterminada cuando se pasa un tipo de datos a imprimir

>>> str(123)    # "123"

Creando un módulo

Un módulo es un archivo importable que contiene definiciones y sentencias.

Se puede crear un módulo creando un archivo .py.

# hello.py
def say_hello():
    print("Hello!")

Las funciones de un módulo se pueden utilizar importando el módulo.

Para los módulos que haya creado, deberán estar en el mismo directorio que el archivo al que los está importando. (Sin embargo, también puede colocarlos en el directorio lib de Python con los módulos incluidos previamente, pero debe evitarlos si es posible).

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

Los módulos pueden ser importados por otros módulos.

# greet.py
import hello
hello.say_hello()

Se pueden importar funciones específicas de un módulo.

# greet.py
from hello import say_hello
say_hello()

Los módulos pueden tener alias.

# greet.py
import hello as ai
ai.say_hello()

Un módulo puede ser un script ejecutable independiente.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

¡Ejecutarlo!

$ python run_hello.py
=> "Hello!"

Si el módulo está dentro de un directorio y necesita ser detectado por python, el directorio debe contener un archivo llamado __init__.py.

Instalación de Python 2.7.x y 3.x

Nota: Las siguientes instrucciones están escritas para Python 2.7 (a menos que se especifique lo contrario): las instrucciones para Python 3.x son similares.

VENTANAS

Primero, descargue la última versión de Python 2.7 del sitio web oficial (https://www.python.org/downloads/). La versión se proporciona como un paquete MSI. Para instalarlo manualmente, simplemente haga doble clic en el archivo.

De forma predeterminada, Python se instala en un directorio:

 C:\Python27\

Advertencia: la instalación no modifica automáticamente la variable de entorno PATH.

Asumiendo que su instalación de Python está en C:\Python27, agregue esto a su RUTA:

C:\Python27\;C:\Python27\Scripts\

Ahora para verificar si la instalación de Python es válida, escriba cmd:

python --version

Python 2.x y 3.x en paralelo

Para instalar y usar Python 2.x y 3.x en paralelo en una máquina con Windows:

  1. Instale Python 2.x usando el instalador MSI.

    • Ensure Python is installed for all users.
    • Optional: add Python to PATH to make Python 2.x callable from the command-line using python.
  2. Instale Python 3.x usando su respectivo instalador.

    • Again, ensure Python is installed for all users.
    • Optional: add Python to PATH to make Python 3.x callable from the command-line using python. This may override Python 2.x PATH settings, so double-check your PATH and ensure it’s configured to your preferences.
    • Make sure to install the py launcher for all users.

Python 3 instalará el iniciador de Python que se puede usar para iniciar Python 2.x y Python 3.x indistintamente desde la línea de comandos:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Para usar la versión correspondiente de pip para una versión específica de Python, use:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

Las últimas versiones de CentOS, Fedora, Redhat Enterprise (RHEL) y Ubuntu vienen con Python 2.7.

Para instalar Python 2.7 en Linux manualmente, simplemente haga lo siguiente en la terminal:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

También agregue la ruta del nuevo python en la variable de entorno PATH. Si el nuevo python está en /root/python-2.7.X, ejecute export PATH = $PATH:/root/python-2.7.X

Ahora para verificar si la instalación de Python es válida, escriba en la terminal:

python --version

Ubuntu (De la fuente)

Si necesita Python 3.6, puede instalarlo desde la fuente como se muestra a continuación (Ubuntu 16.10 y 17.04 tienen la versión 3.6 en el repositorio universal). Se deben seguir los pasos a continuación para Ubuntu 16.04 y versiones inferiores:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

Mac OS

Mientras hablamos, macOS viene instalado con Python 2.7.10, pero esta versión está desactualizada y ligeramente modificada con respecto a Python normal.

La versión de Python que viene con OS X es genial para aprender pero no es bueno para el desarrollo. La versión enviada con OS X puede ser desactualizado desde el lanzamiento oficial actual de Python, que es considerada la versión de producción estable. (fuente)

Instalar Homebrew:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Instale Python 2.7:

brew install python

Para Python 3.x, use el comando brew install python3 en su lugar.

Función de cadena - str() y repr()

Hay dos funciones que se pueden utilizar para obtener una representación legible de un objeto.

repr(x) llama a x.__repr__(): una representación de x. eval generalmente convertirá el resultado de esta función al objeto original.

str(x) llama a x.__str__(): una cadena legible por humanos que describe el objeto. Esto puede eludir algunos detalles técnicos.


repr()

Para muchos tipos, esta función intenta devolver una cadena que generaría un objeto con el mismo valor cuando se pasa a eval(). De lo contrario, la representación es una cadena encerrada entre corchetes angulares que contiene el nombre del tipo de objeto junto con información adicional. Esto a menudo incluye el nombre y la dirección del objeto.

cadena()

Para cadenas, esto devuelve la propia cadena. La diferencia entre esto y repr(object) es que str(object) no siempre intenta devolver una cadena que sea aceptable para eval(). Más bien, su objetivo es devolver una cadena imprimible o ’legible por humanos’. Si no se da ningún argumento, esto devuelve la cadena vacía, ''.


Ejemplo 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

Ejemplo 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

Al escribir una clase, puede anular estos métodos para hacer lo que quiera:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

Usando la clase anterior podemos ver los resultados:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

Instalar módulos externos usando pip

pip es su amigo cuando necesita instalar cualquier paquete de la gran cantidad de opciones disponibles en el índice de paquetes de python (PyPI). pip ya está instalado si está usando Python 2 >= 2.7.9 o Python 3 >= 3.4 descargado de python.org. Para computadoras que ejecutan Linux u otro * nix con un administrador de paquetes nativo, pip a menudo debe instalarse [manualmente.] 1

En instancias con Python 2 y Python 3 instalados, pip a menudo se refiere a Python 2 y pip3 a Python 3. El uso de pip solo instalará paquetes para Python 2 y pip3 solo instalará paquetes para Python 3.

Encontrar/instalar un paquete

Buscar un paquete es tan simple como escribir

$ pip search <query>
# Searches for packages whose name or summary contains <query>

Instalar un paquete es tan simple como escribir (en una terminal/símbolo del sistema, no en el intérprete de Python)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

donde x.x.x es el número de versión del paquete que desea instalar.

Cuando su servidor está detrás de un proxy, puede instalar el paquete usando el siguiente comando:

$ pip --proxy http://<server address>:<port> install

Actualización de paquetes instalados

Cuando aparecen nuevas versiones de paquetes instalados, no se instalan automáticamente en su sistema. Para obtener una descripción general de cuáles de sus paquetes instalados se han quedado obsoletos, ejecute:

$ pip list --outdated

Para actualizar un paquete específico, use

$ pip install [package_name] --upgrade

Actualizar todos los paquetes obsoletos no es una funcionalidad estándar de pip.

Actualización de pip

Puede actualizar su instalación pip existente usando los siguientes comandos

  • En Linux o macOS X:

    $ pip install -U pip
    

    You may need to use sudo with pip on some Linux Systems

  • En Windows:

    py -m pip install -U pip
    

    or

    python -m pip install -U pip
    

Para obtener más información sobre pip, haga [leer aquí] 2.

Utilidad de ayuda

Python tiene varias funciones integradas en el intérprete. Si desea obtener información de palabras clave, funciones integradas, módulos o temas, abra una consola de Python e ingrese:

>>> help()

Recibirá información ingresando directamente las palabras clave:

>>> help(help)

o dentro de la utilidad:

help> help

que mostrará una explicación:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

También puede solicitar subclases de módulos:

help(pymysql.connections)

Puede usar la ayuda para acceder a las cadenas de documentación de los diferentes módulos que ha importado, por ejemplo, intente lo siguiente:

>>> help(math)

y obtendrás un error

>>> import math
>>> help(math)

Y ahora obtendrá una lista de los métodos disponibles en el módulo, pero solo DESPUÉS de haberlo importado.

Cierra el asistente con quit