Python Language Tutorial
Empezando con Python Language

Observaciones

Versiones

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 cuenta con un sistema de tipo dinámico y gestión automática de memoria y soporta múltiples paradigmas de programación, incluyendo imperativo, orientado a objetos. Programación funcional, y estilos procesales. 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 siguen utilizando Python 2, aunque la migración a Python 3 es cada vez más sencilla.

Puede descargar e instalar cualquiera de las versiones de Python aquí . Ver Python 3 contra Python 2 para una comparación entre ellos. Además, algunos terceros ofrecen versiones reenvasadas de Python que agregan bibliotecas de uso común y otras características para facilitar la configuración de casos de uso comunes, como matemáticas, análisis de datos o uso científico. Vea la lista en el sitio oficial .

Verificar si Python está instalado

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

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Si ha instalado Python 3, pero $ python --version genera una versión de Python 2, también tiene Python 2 instalado. Este es a menudo el caso de MacOS y muchas distribuciones de Linux. Use $ python3 en $ python3 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.
  • En versiones anteriores de Windows, se puede encontrar en All Programs en el menú de Windows.
  • En Windows 8+, busque IDLE o encuéntrelo en las aplicaciones que están presentes en su sistema.
  • En sistemas basados ​​en Unix (incluyendo Mac), puede abrirlo desde el shell escribiendo $ idle python_file.py .
• Se abrirá una concha con opciones a lo largo de la parte superior.

En la cáscara, hay un indicador de tres corchetes de ángulo recto:

>>>

Ahora escriba el siguiente código en el indicador:

>>> print("Hello, World")

Presiona Enter .

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

Hola archivo de World Python

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

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

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

Escriba python hello.py , luego python hello.py la tecla Intro .

$ python hello.py
Hello, World

Deberías 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 .

Ejecutar un shell interactivo de Python

Al ejecutar (ejecutar) el comando python en su terminal, se le presenta un shell interactivo de Python. Esto también se conoce como el intérprete de Python o REPL (para 'Leer Evaluar Imprimir 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 la solicitud interactiva 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 pondrá nuevamente en la línea de comando de su terminal.

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

Pruebe un shell interactivo de Python en línea .

Otras conchas en línea

Varios sitios web proporcionan acceso en línea a las conchas de Python.

Los depósitos 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 la instalación de Python (teléfonos inteligentes, tabletas, etc.).
• Aprende o enseña Python básico.
• Resolver problemas de jueces en línea.

Ejemplos:

Descargo de responsabilidad: los autores de la documentación no están afiliados a los recursos que se enumeran 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/ : se utiliza ampliamente en la red para ilustrar el comportamiento del fragmento de código.
• https://repl.it/languages/python3 - Compilador en línea, IDE e intérprete en línea potente y simple. Codifique, compile y ejecute el 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

Python puede pasar un código arbitrario como una cadena en el shell:

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

Esto puede ser útil cuando se concatenan los resultados de los scripts juntos en el shell.

Conchas y mas alla

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 <the package name> . 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 <the package name> )

Shells : hasta ahora, hemos discutido diferentes formas de ejecutar código usando el shell interactivo nativo de Python. Los shells utilizan el poder interpretativo de Python para experimentar con el código en tiempo real. Los shells alternativos incluyen IDLE , una GUI pre-empaquetada, IPython , conocida por extender la experiencia interactiva, etc.

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

El tutor de Python te permite recorrer el código de Python para que puedas visualizar cómo fluirá el programa, y ​​te ayuda a entender dónde salió mal tu programa.

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

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), al asignar un valor a una variable, se 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. Así que lo siguiente te dará un error de sintaxis.

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

No puede utilizar palabras clave de python como un nombre de variable válido. Puedes 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 de su nombre de variable puede consistir en letras, números y guiones bajos.

has_0_in_it = "Still Valid" 

3. Los nombres son 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, mientras se asigna el área necesaria en la memoria para la variable, el intérprete de Python selecciona automáticamente el tipo incorporado 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, dejemos de lado esta sutileza acerca de la asignación en python.

Cuando usa = para realizar 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 a la derecha al nombre a la izquierda.

Es decir:

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

Entonces, de los muchos ejemplos de asignación anteriores, si seleccionamos pi = 3.14 , pi es un nombre (no el nombre, ya que un objeto puede tener varios nombres) para el objeto 3.14 . Si no entiende algo a continuación, vuelva a este punto y lea esto nuevamente. Además, puedes echarle 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 en el último ejemplo puede obviarse asignando valores restantes a un número igual de variables arbitrarias. Esta variable ficticia puede tener cualquier nombre, pero es convencional usar el subrayado ( _ ) 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 lanzan 'demasiados valores para descomprimir 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 solo valor a varias variables simultáneamente.

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

Cuando se utiliza dicha 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 int objeto con el valor de 1. En otras palabras, a , b y c son tres nombres diferentes dado al mismo objeto int. Asignar un objeto diferente a uno de ellos después no cambia los otros, 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 válido para los tipos mutables (como list , dict , etc.), al igual que para los 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 ahora tan bueno. Las cosas son un poco diferentes cuando se trata de modificar el objeto (en contraste con asignar el nombre a un objeto diferente, como hicimos anteriormente) cuando la asignación en cascada se usa para tipos mutables. Echa un vistazo a continuación, y lo verá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 un 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 ser del mismo tipo de las que se definieron 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 un nombre para un objeto. En primer lugar se llama a la int objeto con valor de 2 a , a continuación, cambia de opinión y decide dar el nombre a a una string objeto, que tiene un valor 'Valor nuevo'. Simple, ¿verdad?

Entrada del usuario

Entrada interactiva

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

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

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 una solicitud 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 pulsa enter, el name la variable 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 input siempre es de tipo str , lo que es importante si desea que el usuario ingrese números. Por lo tanto, necesita convertir el 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 utilizar los bloques de try / except para detectar excepciones cuando se trata de entradas de usuario . Por ejemplo, si su código quiere convertir un raw_input en un int , y lo que el usuario escribe es inasible, genera un ValueError .

IDLE - GUI de Python

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

Los principales propósitos 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 visibilidad de la pila de llamadas
• Sangría automática (útil para los principiantes que aprenden sobre la sangría de Python)
• Guardando el programa Python como archivos .py, ejecútelos y edítelos más tarde en cualquiera de ellos usando IDLE.

En IDLE, presione F5 o run Python Shell para iniciar un intérprete. Usar 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, vea, por ejemplo, esta discusión o esta lista .

Solución de problemas

• Windows

  Si estás en Windows, el comando predeterminado es python . Si recibe un error "'python' is not recognized" Python "'python' is not recognized" , la causa más probable es que la ubicación de Python no se encuentre en la PATH entorno PATH su sistema. Se puede acceder a esto haciendo clic con el botón derecho en 'Mi PC' y seleccionando 'Propiedades' o navegando a 'Sistema' a través de 'Panel de control'. Haga clic en 'Configuración avanzada del sistema' y luego en 'Variables de entorno ...'. Edite la variable PATH para incluir el directorio de su instalación de Python, así como la carpeta Script (generalmente C:\Python27;C:\Python27\Scripts ). Esto requiere privilegios administrativos y puede requerir un reinicio.

  Cuando se usan varias versiones de Python en la misma máquina, una posible solución es cambiar el nombre de uno de los archivos python.exe . Por ejemplo, nombrar una versión python27.exe haría que python27 convierta en el comando de Python para esa versión.

  También puede usar el Lanzador de Python para Windows, que está disponible a través del instalador y viene por defecto. Le permite seleccionar la versión de Python para ejecutar usando py -[xy] lugar de python[xy] . Puede usar la última versión de Python 2 ejecutando scripts con py -2 y la última versión de Python 3 ejecutando scripts con py -3 .

• Debian / Ubuntu / MacOS

  Esta sección asume que la ubicación del ejecutable de python se ha agregado a la PATH entorno PATH .

  Si estás en Debian / Ubuntu / MacOS, abre el terminal y escribe python para Python 2.xo python3 para Python 3.x.

  Escriba which python para ver qué intérprete de Python se utilizará.

• Arco de linux

  El Python predeterminado en Arch Linux (y sus descendientes) es Python 3, así que usa python o python3 para Python python2 para Python 2.x.

• Otros sistemas

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

Tipos de datos

Tipos incorporados

Booleanos

bool : Un valor booleano de True o False . Las operaciones lógicas como and , or , not se pueden realizar en valores 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.xy en Python 3.x, un booleano es también 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 usan valores booleanos en operaciones aritméticas, sus valores enteros ( 1 y 0 para True y False ) se usará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
  

  Los enteros en Python son de tamaños arbitrarios.

  Nota: en versiones anteriores de Python, había un tipo long disponible y esto era distinto de int . Los dos se han unificado.

• 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 float corresponde a un C doble.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : 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.

Instrumentos de cuerda

Secuencias y colecciones.

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

• Las cadenas ( str , bytes , unicode ) son secuencias.

• reversed : un orden invertido de str con función reversed

  a = reversed('hello')
  

• tuple : una colección ordenada de n valores de cualquier tipo ( n >= 0 ).

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

  Soporta indexación; inmutable; hashable si todos sus miembros son hashable

• list : una colección ordenada de n valores ( n >= 0 )

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

  No hashable; mudable.

• 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 __hash__() ) y puede compararse con otros objetos (necesita un __eq__() ). Los objetos hashable que comparan la igualdad deben tener el mismo valor hash.

Constantes incorporadas

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

• True : El valor verdadero del tipo incorporado bool
• False : el valor falso del tipo incorporado bool
• None : un objeto singleton utilizado para indicar que un valor está ausente.
• Ellipsis o ... : se utiliza en Python3 + en cualquier lugar y uso limitado en Python2.7 + como parte de la notación de matriz. numpy paquetes numpy y relacionados usan esto como una referencia 'incluir todo' en los arreglos.
• NotImplemented : un singleton utilizado para indicar a Python que un método especial no es compatible con 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

Probando el tipo de variables

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

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

En declaraciones condicionales es posible probar el tipo de datos con isinstance . Sin embargo, generalmente 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 la conversión explícita de tipos de datos.

Por ejemplo, '123' es de tipo str y se puede convertir en 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 float .

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 puedes convertir secuencias o tipos de colección.

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ícita en la definición de literales

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

• b'foo bar' : bytes resultados en Python 3, str en Python 2
• u'foo bar' : results str en Python 3, unicode en Python 2
• 'foo bar' : resultados str
• r'foo bar' : resultados llamados cadenas en bruto, donde no es necesario escapar caracteres especiales, todo se toma literalmente a medida que se 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 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 anteriormente. Solo hizo que x apunte a un nuevo objeto.

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

Ejemplos de tipos de datos inmutables:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

Ejemplos de tipos de datos mutables:

• bytearray
• list
• set
• dict

Construido en módulos y funciones

Un módulo es un archivo que contiene definiciones y declaraciones de Python. La función es un fragmento 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 alcance actual. De lo contrario, devuelve una lista alfabética de nombres que comprenden (algunos de) el atributo del objeto dado y de los atributos a los que se puede acceder.

>>> 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 utilizar la help incorporada de la función.

>>> 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, necesitamos incluir math módulo math .

>>> 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 alguna documentación en, digamos, 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 tienes un archivo llamado helloWorld.py como este:

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

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

Puedes acceder a sus documentos como este:

>>> 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 recursivamente los atributos de las clases base de su clase se pueden recuperar usando 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 a cadena usando una función incorporada llamada str . Esta función se llama de forma predeterminada cuando se pasa un tipo de datos para print

>>> str(123)    # "123"

Sangría de bloque

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

Python usa el símbolo de dos puntos ( : ) y sangría para mostrar dónde bloques de código empiezan y terminan (Si viene de otro idioma, no confunda esto con alguna manera estar relacionado con el operador ternario ). Es decir, los bloques en Python, tales 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 de él.

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 instrucción de una sola línea se pueden colocar en la misma línea, aunque esta forma generalmente no se considera un buen estilo:

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

Intentar hacer esto con más de una sola 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 causa un IndentationError . Use pass (un comando que no hace nada) cuando tiene un bloque sin contenido:

def will_be_implemented_later():
    pass

Espacios vs. Pestañas

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

El uso exclusivo de pestañas es posible, pero PEP 8 , la guía de estilo para el código Python, indica que se prefieren los espacios.

Muchos editores tienen configuración de "pestañas a espacios". Al configurar el editor, uno debe diferenciar entre el carácter de la pestaña ('\ t') y la tecla Tab .

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

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 colección

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

Liza

El tipo de list es probablemente el tipo de colección más utilizado en Python. A pesar de su nombre, una lista es más como una matriz en otros idiomas, principalmente JavaScript. En Python, una lista es simplemente una colección ordenada de valores válidos de Python. 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 que 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:

Agregar objeto al final de la lista con L.append(object) , devuelve None .

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.insert(index, object)

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

Elimine la primera aparición de un valor con L.remove(value) , devuelve None

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. Se mostrará un error si no hay tal elemento.

name.index("Alice")
0

Cuenta la longitud de la lista

len(names)
6

cuenta la ocurrencia de cualquier artículo en la lista

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

Revertir la lista

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

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

names.pop() # Outputs 'Sia'

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

for element in my_list:
    print (element)

Tuplas

Una tuple es similar a una lista, excepto que es de longitud fija e inmutable. Por lo tanto, los valores de la tupla no se pueden cambiar ni los valores se pueden agregar o quitar de la tupla. Las tuplas se usan comúnmente para pequeñas colecciones de valores que no será necesario 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 válidos para cualquier Python válido.

Una tupla con un solo miembro debe definirse (tenga en cuenta la coma) de esta manera:

one_member_tuple = ('Only member',)

o

one_member_tuple = 'Only member',   # No brackets

o simplemente usando la sintaxis de la tuple

one_member_tuple = tuple(['Only member'])

Los diccionarios

Un dictionary 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, consúltelo por su clave:

ca_capital = state_capitals['California']

También puede obtener todas las claves en un diccionario y luego repetirlas:

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.

conjunto

Un set es una colección de elementos sin repeticiones y sin orden de inserción pero ordenado. Se usan en situaciones en las que solo es importante que algunas cosas se agrupen y no en qué orden se incluyeron. Para grupos grandes de datos, es mucho más rápido verificar si un elemento está o no en un set que hacer lo mismo para una list .

Definir un set es muy similar a definir un dictionary :

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

O puedes construir un set usando una list existente:

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

Verifique la membresía del set usando in :

if name in first_names:
    print(name)

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

sentencia por defecto

Un defaultdict es un diccionario con un valor por defecto para las llaves, por lo que las claves para el que ha sido definida explícitamente ningún valor se puede acceder sin errores. defaultdict es especialmente útil cuando los valores del diccionario son colecciones (listas, dicts, etc.) en el sentido de que no es necesario inicializar cada vez que se usa una nueva clave.

Un defaultdict nunca generará un KeyError. Cualquier clave que no exista 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 que no existe, 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 asignación no exista. Ahora rellena el dict 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 que no existe, Python nos devolverá el valor predeterminado, es decir, Boston

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

y devuelve los valores creados para la clave existente al igual que un dictionary normal

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

Utilidad de ayuda

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

>>> help()

Recibirá información ingresando palabras clave directamente:

>>> 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 puedes 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.

Cerrar el ayudante con quit

Creando un modulo

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

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

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

Las funciones en 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 en el que los está importando. (Sin embargo, también puede colocarlos en el directorio lib de Python con los módulos pre-incluidos, pero debe evitarse 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 ser 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 .

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

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

repr(x) llama a x.__repr__() : una representación de x . eval general, eval 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 ocultar algunos detalles técnicos.

repr ()

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

str ()

Para las cadenas, esto devuelve la cadena en sí. 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 para 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

Instalación de módulos externos utilizando pip

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

En instancias con Python 2 y Python 3 instalados, pip 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

La búsqueda de 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 escribirlo (en un 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 xxx es el número de versión del paquete que desea instalar.

Cuando su servidor está detrás de 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 están desactualizados, ejecute:

$ pip list --outdated

Para actualizar el uso de un paquete específico

$ 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
  

  Es posible que necesite usar sudo con pip en algunos sistemas Linux

• En Windows:

  py -m pip install -U pip
  

  o

  python -m pip install -U pip
  

Para más información sobre pip, lea aquí .

Instalación de Python 2.7.xy 3.x

Nota : las siguientes instrucciones están escritas para Python 2.7 (a menos que se especifique): 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.

Por defecto, Python se instala en un directorio:

 C:\Python27\

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

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

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

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

python --version

Python 2.xy 3.x lado a lado

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

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

   • Asegúrese de que Python esté instalado para todos los usuarios.
   • Opcional: agregue Python a PATH para hacer que Python 2.x se pueda llamar desde la línea de comandos usando python .

2. Instala Python 3.x usando su respectivo instalador.

   • Una vez más, asegúrese de que Python esté instalado para todos los usuarios.
   • Opcional: agregue Python a PATH para que Python 3.x se pueda llamar desde la línea de comandos usando python . Esto puede anular la configuración de Python 2.x PATH , por lo tanto, vuelva a verificar su PATH y asegúrese de que esté configurado según sus preferencias.
   • Asegúrate de instalar el py launcher para todos los usuarios.

Python 3 instalará el iniciador de Python que se puede usar para lanzar Python 2.xy 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 comprobar si la instalación de Python es válida, escriba en el terminal:

python --version

Ubuntu (desde 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). Deben seguirse los siguientes pasos 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 de Python regular.

La versión de Python que se incluye con OS X es excelente para el aprendizaje, pero no es buena para el desarrollo. La versión enviada con OS X puede estar desactualizada de la versión oficial actual de Python, que se considera la versión de producción estable. ( fuente )

Instalar Homebrew :

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

Instala Python 2.7:

brew install python

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