Empezando con Python Language

Download python eBook

Observaciones

Logo de python
Python
es un lenguaje de programación muy utilizado. Es:

  • Alto nivel : Python automatiza las operaciones de bajo nivel, como la administración de memoria. Deja al programador con un poco menos de control, pero tiene muchos beneficios que incluyen la legibilidad del código y expresiones de código mínimas.

  • Propósito general : Python está diseñado para ser utilizado en todos los contextos y entornos. Un ejemplo de un lenguaje de uso no general es PHP: está diseñado específicamente como un lenguaje de script de desarrollo web del lado del servidor. En contraste, Python puede usarse para el desarrollo web del lado del servidor, pero también para crear aplicaciones de escritorio.

  • Escrito dinámicamente : cada variable en Python puede hacer referencia a cualquier tipo de datos. Una sola expresión puede evaluar datos de diferentes tipos en diferentes momentos. Debido a eso, el siguiente código es posible:

    1 + '1'  # raises an error
    1 + int('1')  # results with 2
    
  • Se escribe con fuerza : durante la ejecución del programa, no se le permite hacer nada que sea incompatible con el tipo de datos con los que está trabajando. Por ejemplo, no hay conversiones ocultas de cadenas a números; una cadena hecha de dígitos nunca se tratará como un número a menos que la conviertas explícitamente:

    1 + '1'  # raises an error
    1 + int('1')  # results with 2
    
  • Amigable para principiantes :) : la sintaxis y la estructura de Python son muy intuitivas. Es de alto nivel y proporciona construcciones destinadas a permitir la escritura de programas claros tanto a pequeña como a gran escala. Python es compatible con múltiples paradigmas de programación, incluidos la programación orientada a objetos, la imperativa y funcional o los estilos de procedimiento. Tiene una biblioteca estándar grande y completa y muchas bibliotecas de terceros fáciles de instalar.

Sus principios de diseño se describen en el Zen de Python .

Actualmente, hay dos ramas principales de lanzamiento de Python que tienen algunas diferencias significativas. Python 2.x es la versión heredada, aunque sigue teniendo un uso generalizado. Python 3.x realiza un conjunto de cambios incompatibles con versiones anteriores que tienen como objetivo reducir la duplicación de características. Para obtener ayuda para decidir qué versión es la mejor para usted, consulte este artículo .

La documentación oficial de Python también es un recurso completo y útil, que contiene documentación para todas las versiones de Python, así como tutoriales para ayudarlo a comenzar.

Existe una implementación oficial del lenguaje suministrado por Python.org, generalmente denominado CPython, y varias implementaciones alternativas del lenguaje en otras plataformas de tiempo de ejecución. Estos incluyen IronPython (que ejecuta Python en la plataforma .NET), Jython (en el tiempo de ejecución de Java) y PyPy (que implementa Python en un subconjunto de sí mismo).

Versiones

Python 3.x

Versión Fecha de lanzamiento
[3.7] 2017-05-08
3.6 2016-12-23
3.5 2015-09-13
3.4 2014-03-17
3.3 2012-09-29
3.2 2011-02-20
3.1 2009-06-26
3.0 2008-12-03

Python 2.x

Versión Fecha de lanzamiento
2.7 2010-07-03
2.6 2008-10-02
2.5 2006-09-19
2.4 2004-11-30
2.3 2003-07-29
2.2 2001-12-21
2.1 2001-04-15
2.0 2000-10-16

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 3.6.0
 
Python 3.x 3.0

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

$ python --version
Python 3.6.0
 
Python 2.x 2.7

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

$ python --version
Python 3.6.0
 

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:

$ python --version
Python 3.6.0
 

Ahora escriba el siguiente código en el indicador:

$ python --version
Python 3.6.0
 

Presiona Enter .

$ python --version
Python 3.6.0
 

Hola archivo de World Python

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

Python 3.x 3.0
$ python --version
Python 3.6.0
 
Python 2.x 2.6

Puede usar la función de print Python 3 en Python 2 con la siguiente declaración de import :

$ python --version
Python 3.6.0
 

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

Python 2.x 2.7

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

$ python --version
Python 3.6.0
 

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

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

$ python --version
Python 3.6.0
 

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 --version
Python 3.6.0
 

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

$ python --version
Python 3.6.0
 

Alternativamente, inicie la solicitud interactiva y cargue el archivo con python -i <file.py> .

En la línea de comando, ejecute:

$ python --version
Python 3.6.0
 

Hay varias formas de cerrar el shell de Python:

$ python --version
Python 3.6.0
 

o

$ python --version
Python 3.6.0
 

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.

Ejecutar comandos como una cadena

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

$ python --version
Python 3.6.0
 

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.

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:

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
 

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:             # 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
 

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

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
 

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

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
 

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.

Python 3.x 3.0

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: Inconsistent use of tabs and spaces in indentation y el programa no se ejecutará.

Python 2.x 2.7

Python 2 permite mezclar tabulaciones y espacios en sangría; Esto es fuertemente desalentado. El carácter de la pestaña completa la sangría anterior para ser un múltiplo de 8 espacios . Como 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 el PEP 8 :

Cuando se invoca al intérprete de línea de comandos de Python 2 con la opción -t , emite advertencias sobre el código que mezcla de forma ilegal las pestañas y los espacios. Al usar -tt estas advertencias se convierten en errores. Estas opciones son muy recomendables!

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 )

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.

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

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

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 .

>>> 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 todas las funciones de un módulo, podemos asignar la lista de funciones a una variable y luego imprimir la variable.

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

Parece que __doc__ es útil para proporcionar alguna documentación en, digamos, funciones

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

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:

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

Puedes acceder a sus documentos como este:

>>> 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 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 ()
>>> 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'
]
 

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

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

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:

empty_list = []
 

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:

empty_list = []
 

Una lista puede contener otra lista como su elemento:

empty_list = []
 

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:

empty_list = []
 

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:

empty_list = []
 

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

empty_list = []
 

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 .

empty_list = []
 

Agregue un nuevo elemento a la lista en un índice específico. L.insert(index, object)

empty_list = []
 

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

empty_list = []
 

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

empty_list = []
 

Cuenta la longitud de la lista

empty_list = []
 

cuenta la ocurrencia de cualquier artículo en la lista

empty_list = []
 

Revertir la lista

empty_list = []
 

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

empty_list = []
 

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

empty_list = []
 

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:

empty_list = []
 

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:

empty_list = []
 

o

empty_list = []
 

o simplemente usando la sintaxis de la tuple

empty_list = []
 

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:

empty_list = []
 

Para obtener un valor, consúltelo por su clave:

empty_list = []
 

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

empty_list = []
 

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 :

empty_list = []
 

O puedes construir un set usando una list existente:

empty_list = []
 

Verifique la membresía del set usando in :

empty_list = []
 

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

empty_list = []
 

Si intentamos acceder a una clave que no existe, Python nos devuelve un error de la siguiente manera

empty_list = []
 

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

empty_list = []
 

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:

empty_list = []
 

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

empty_list = []
 

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

empty_list = []
 

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 .

$ python
>>> import hello
>>> hello.say_hello()
=> "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.

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

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

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

Los módulos pueden ser alias.

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

Un módulo puede ser un script ejecutable independiente.

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

¡Ejecutarlo!

$ python
>>> import hello
>>> hello.say_hello()
=> "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 .

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.

# 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
 

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.

# 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
 

No puede utilizar palabras clave de python como un nombre de variable válido. Puedes ver la lista de palabras clave por:

# 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
 

Reglas para nombrar variables:

  1. Los nombres de las variables deben comenzar con una letra o un guión bajo.
# 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
 
  1. El resto de su nombre de variable puede consistir en letras, números y guiones bajos.
# 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
 
  1. Los nombres son mayúsculas y minúsculas.
# 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
 

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:

# 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
 

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:

# 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
 

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 = :

# 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
 

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:

# 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
 

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:

# 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
 

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

# 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
 

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:

# 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
 

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.):

# 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
 

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:

# 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
 

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

# 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
 

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.

# 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
 

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?

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.

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # 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:

issubclass(bool, int) # True

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

Números

  • int : número entero

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

    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.

    issubclass(bool, int) # True
    
    isinstance(True, bool) # True
    isinstance(False, bool) # True
     
  • complex : números complejos

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

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

Instrumentos de cuerda

Python 3.x 3.0
  • str : una cadena de Unicode . El tipo de 'hello'
  • bytes : una cadena de bytes . El tipo de b'hello'
Python 2.x 2.7
  • str : una cadena de bytes . El tipo de 'hello'
  • bytes : sinónimo de str
  • unicode : una cadena de Unicode . El tipo de u'hello'

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

    issubclass(bool, int) # True
    
    isinstance(True, bool) # True
    isinstance(False, bool) # True
     
  • tuple : una colección ordenada de n valores de cualquier tipo ( n >= 0 ).

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

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

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

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

    No hashable; mudable.

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

    issubclass(bool, int) # True
    
    isinstance(True, bool) # True
    isinstance(False, bool) # True
     
  • dict : una colección desordenada de pares clave-valor únicos; Las claves deben ser hashable .

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

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.
issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True
 
Python 3.x 3.0

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

Python 2.x 2.7

None siempre es menor que cualquier número ( None < -32 evalúa como True ).

Probando el tipo de variables

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

issubclass(bool, int) # True

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

En declaraciones condicionales es posible probar el tipo de datos con isinstance . Sin embargo, generalmente no se recomienda confiar en el tipo de variable.

issubclass(bool, int) # True

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

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 :

issubclass(bool, int) # True

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

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 .

issubclass(bool, int) # True

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

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

issubclass(bool, int) # True

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

También puedes convertir secuencias o tipos de colección.

issubclass(bool, int) # True

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

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
issubclass(bool, int) # True

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

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:

issubclass(bool, int) # True

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

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:

issubclass(bool, int) # True

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

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

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(help)
 

Recibirá información ingresando palabras clave directamente:

>>> help(help)
 

o dentro de la utilidad:

>>> help(help)
 

que mostrará una explicación:

>>> help(help)
 

También puedes solicitar subclases de módulos:

>>> help(help)
 

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(help)
 

y obtendrás un error

>>> help(help)
 

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

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 .

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\;C:\Python27\Scripts\
 

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:

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

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:

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

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

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

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:

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

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:

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

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:

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

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 :

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

Instala Python 2.7:

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

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

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

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

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

Para actualizar el uso de un paquete específico

$ 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
 

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

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

  • En Windows:

    $ 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
     

    o

    $ 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
     

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

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:

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

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:

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

Usando la clase anterior podemos ver los resultados:

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

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):

Python 2.x 2.3
name = 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 en una vulnerabilidad. Consulte este artículo para obtener más información sobre los riesgos de usar esta función.

Python 3.x 3.0
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? _
 

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:

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

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 .

Stats

22687 Contributors: 210
Friday, August 4, 2017
Licenciado bajo: CC-BY-SA

No afiliado a Stack Overflow
Rip Tutorial: info@zzzprojects.com

Descargar eBook