Aprendizaje de Python (activado)

Pitón

1. El papel de Python

Si trabaja mucho con su computadora, eventualmente encontrará que hay algunas tareas que preferiría automatizar. Por ejemplo, desea realizar una búsqueda/reemplazo en una gran cantidad de archivos de texto, o cambiar el nombre y organizar una gran cantidad de imágenes de forma compleja. Tal vez desee escribir una pequeña base de datos personalizada, una aplicación GUI especial o un pequeño juego simple.

Si es un desarrollador de software profesional, tal vez tenga que usar varias bibliotecas de clases C/C++/JAVA y descubra que el ciclo de escritura/compilación/prueba/recompilación suele ser muy largo. Tal vez esté escribiendo casos de prueba para estas bibliotecas, pero encuentre que este es un trabajo molesto. O tal vez haya terminado un programa que puede usar un lenguaje de extensión, pero no desea rediseñarlo e implementar un lenguaje completamente nuevo para él.

Entonces Python es justo el lenguaje que necesitas.

Si bien puede escribir secuencias de comandos de shell de Unix o archivos por lotes de Windows para manejar algunas de estas tareas, las secuencias de comandos de shell son más adecuadas para mover archivos o modificar datos de texto, no para escribir aplicaciones GUI o juegos; aunque puede escribir programas en C/C++/JAVA, escribir incluso un programa simple de primer borrador puede consumir mucho tiempo de desarrollo. Por el contrario, Python es más fácil de usar y lo ayudará a hacer las cosas más rápido, ya sea en los sistemas operativos Windows, Mac OS X o Unix.

Aunque Python es fácil de usar, es un lenguaje de programación completo; proporciona más estructura y soporte para escribir programas grandes que los scripts de shell o los archivos por lotes. Por otro lado, Python ofrece más verificación de errores que C y, al ser un lenguaje de alto nivel, tiene soporte incorporado para tipos de estructuras de datos avanzados. Por ejemplo: arreglos flexibles y diccionarios. Debido a sus tipos de datos más generales, Python es aplicable a más dominios problemáticos que Awk o incluso Perl, y al menos la mayoría de las cosas son tan fáciles en Python como en otros lenguajes.

Python le permite dividir su programa en diferentes módulos para reutilizarlos en otros programas de Python. Python viene con una gran cantidad de módulos estándar que puede usar como base de sus programas o como ejemplos para aprender a programar en Python. Estos módulos proporcionan funciones como E/S de archivos, llamadas al sistema, compatibilidad con sockets e incluso una interfaz de kit de herramientas de interfaz gráfica de usuario (GUI) similar a Tk.

Python es un lenguaje interpretado y, dado que no es necesario compilar ni vincular, puede ahorrar un tiempo valioso en el desarrollo del programa. El intérprete de Python se puede utilizar de forma interactiva, lo que facilita experimentar con funciones del lenguaje, escribir programas ad-hoc o probar métodos en el desarrollo de programas de abajo hacia arriba. Incluso puedes usarlo como una calculadora de escritorio.

Python hace que los programas sean compactos y legibles. Los programas escritos en Python son generalmente más cortos que los programas equivalentes en C, C++ o Java por varias razones:

• Las estructuras de datos avanzadas le permiten expresar operaciones complejas en una sola declaración;

• Los grupos de declaraciones se organizan usando sangría en lugar de llaves de apertura y cierre;

• No es necesario declarar variables o parámetros.

Python es extensible: si puede programar en C, puede agregar fácilmente funciones integradas o módulos al intérprete, optimizar cuellos de botella en el rendimiento o vincular programas de Python con bibliotecas que solo están en forma binaria (como una biblioteca de gráficos comercial profesional). Una vez que realmente lo domine, puede integrar el intérprete de Python en una aplicación C y usarlo como una extensión o lenguaje de línea de comandos para ese programa.

Por cierto, el nombre del idioma proviene del programa "Monty Python's Flying Cirecus" de la BBC y no tiene nada que ver con los reptiles. Citar alusiones a Monty Python en su documentación no solo es posible, ¡sino recomendable!

Ahora que está entusiasmado con Python, ¡probablemente quiera ver más detalles! La mejor manera de aprender un idioma es usarlo, y esta guía recomienda que practique el uso del intérprete de Python mientras lee.

2. Usando el intérprete de Python

2.1 Invocando al intérprete de Python

El intérprete de Python generalmente se instala en el directorio /usr/local/bin/python3.5 de la máquina de destino. Incluya el directorio /usr/local/bin en la ruta de búsqueda de shell de Unix para asegurarse de que pueda iniciarse escribiendo: comando python3.5. Dado que la ruta de instalación del intérprete de Python es opcional, son posibles otras rutas y puede consultar con el usuario o administrador del sistema que instaló Python (por ejemplo, /usr/local/python es una opción común).

En las máquinas con Windows, Python generalmente se instala en C:\Python35, aunque puede cambiar este valor al ejecutar el asistente de instalación. Para agregar este directorio a su variable de entorno PATH, puede ingresar el siguiente comando en una ventana de DOS:

establecer ruta=%ruta%;C:\python35

Por lo general, puede ingresar un carácter de fin de archivo (Control-D en sistemas Unix, Control-Z en sistemas Windows) en la ventana principal para que el intérprete salga con un código de estado 0. Si eso no funciona, puede salir del intérprete escribiendo el comando quit().

El intérprete de Python tiene capacidades de edición de línea simples. En los sistemas Unix, cualquier intérprete de Python puede haber agregado soporte para la biblioteca de línea de lectura GNU, que permite una edición interactiva ordenada, historial, etc. Escribir Control-P en la ventana principal de Python es probablemente la forma más fácil de verificar si se admite la edición de la línea de comandos. Si hay un pitido (altavoz de la computadora), significa que puede usar la función de edición de la línea de comando; para obtener más teclas de acceso directo, consulte Retroceso del historial de edición de la línea de entrada interactiva. Si no hay sonido, o si se muestra el carácter ^P, la edición de la línea de comandos está deshabilitada; solo puede eliminar los caracteres escritos de la línea actual con la tecla de retroceso y volver a ingresarlos.

El intérprete de Python funciona como un shell de Unix: cuando se invoca con un dispositivo terminal (tty) como entrada estándar, interpreta y ejecuta comandos de forma interactiva; cuando se invoca con un argumento de nombre de archivo o con un archivo como entrada estándar, lee un archivo y lo ejecuta como un script.

La segunda forma de iniciar el intérprete de Python es el comando python -c [arg]..., este método puede ejecutar sentencias de Python en la línea de comandos, similar a la opción -c en el shell. Dado que las declaraciones de Python a menudo contienen espacios u otros caracteres especiales de shell, generalmente se recomienda encerrar los comandos entre comillas simples.

Hay algunos módulos de Python que también se pueden usar como scripts. Puede invocarlos usando el comando python -m module [arg] ..., que es similar a escribir la ruta completa en la línea de comando para ejecutar el archivo fuente del módulo.

Cuando se trabaja con archivos de script, es común ejecutar el script y luego ingresar al modo interactivo. Esto también se puede hacer anteponiendo el script con el parámetro -i.

2.1.1 Paso de parámetros

Cuando se invoca al intérprete, el nombre del script y los argumentos adicionales se pasan en una lista de cadenas denominada sys.argv. Puede obtener esta lista ejecutando import sys, la longitud de la lista es mayor o igual a 1; cuando no se proporcionan scripts ni parámetros, también tiene al menos un elemento: sys.argv[0] es una cadena vacía en este momento. Cuando el nombre del script se especifica como '-' (entrada estándar), sys.argv[0] se establece en '-', y cuando se usa el comando -c, sys.argv[0] se establece en '-c'. Cuando se usa el argumento del módulo -m, sys.argv[0] se establece en el nombre completo del módulo especificado. Los parámetros que siguen al comando -c o al módulo -m no serán interceptados por el mecanismo de procesamiento de opciones del intérprete de Python, pero permanecerán en sys.argv para las operaciones del comando de script.

2.1.2 Modo interactivo

Al leer comandos de un tty, decimos que el intérprete funciona en modo interactivo. En este modo, se ejecuta desde el indicador maestro, generalmente identificado por tres signos de mayor que (>>>); la continuación se denomina indicador esclavo, identificada por tres puntos (…). Antes de la primera línea, el intérprete imprime un mensaje de bienvenida, un número de versión y un aviso de autorización:

$ python3.5
Python 3.5 (default, Mar 16 2014, 09:25:04)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Ahora se requiere el indicador esclavo al ingresar construcciones de varias líneas, por ejemplo, la siguiente declaración if:

>>> the_world_is_flat = 1
>>> if the_world_is_flat:
...     print("Be careful not to fall off!")
...
Be careful not to fall off!

Para obtener más información sobre los modos interactivos, consulte Modos interactivos.

2.2 El intérprete y su entorno

2.2.1 Código fuente

De forma predeterminada, los archivos fuente de Python están codificados en UTF-8. Bajo esta codificación, los caracteres de la mayoría de los idiomas del mundo se pueden usar en cadenas, identificadores y comentarios al mismo tiempo, aunque la biblioteca estándar de Python usa solo caracteres ASCII como identificadores, que es solo una convención que debe seguir cualquier código portátil. Para mostrar todos los caracteres correctamente, su editor debe poder reconocer que el archivo está codificado en UTF-8 y debe usar una fuente que admita todos los caracteres del archivo.

También puede especificar una codificación de caracteres diferente para los archivos de origen. Para hacer esto, inserte al menos una línea de comentario especial después de la línea #! (primera línea) para definir la codificación del archivo fuente:

# -*- coding: encoding -*-

Con esta declaración, todo el contenido del archivo de origen se tratará como la codificación UTF-8 especificada por encoding. Puede encontrar una lista de codificaciones disponibles en la sección de códecs de la Referencia de la biblioteca de Python.

Por ejemplo, si su editor no admite archivos codificados en UTF-8, pero admite alguna otra codificación como Windows-1252, puede definir:

# -*- coding: cp-1252 -*-

Esto permite que todos los caracteres del conjunto de caracteres de Windows-1252 se utilicen en los archivos de origen. Este comentario de codificación especial debe definirse en la primera o segunda línea del archivo.

3. Introducción a Python

En los siguientes ejemplos, la entrada y la salida están marcadas por indicaciones de mayor que y punto ( >>> y ... ): para reproducir estos ejemplos, ingrese (después de la indicación) las líneas de código que no contienen la indicación, después de la indicación del intérprete. Debe tenerse en cuenta que el indicador de esclavo que se encuentra en el ejercicio indica que debe ingresar una línea en blanco adicional al final para que el intérprete sepa que este es el final de un comando de varias líneas.

Muchos ejemplos en este manual, incluidos aquellos con indicaciones interactivas, contienen comentarios. Los comentarios en Python comienzan con el carácter # y terminan al final de la línea. Los comentarios pueden comenzar al principio de la línea o seguir espacios en blanco o código, pero no aparecen en la cadena. Un carácter # en una cadena de texto simplemente significa #. Los comentarios en el código no serán interpretados por Python, pueden ignorarse al ingresar el ejemplo.

Por ejemplo:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1 Usando Python como calculadora

Probemos algunos comandos simples de Python. Inicie el intérprete y espere a que aparezca el indicador principal >>> (no tarda mucho).

3.1.1 Números

El intérprete se comporta como una simple calculadora: puede introducir algunas expresiones en él y devuelve un valor. La sintaxis de la expresión es sencilla: los operadores +, -, * y / son los mismos que en otros lenguajes (por ejemplo, Pascal o C); los paréntesis (()) se utilizan para agrupar. Por ejemplo:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

Los números enteros (p. ej., 2, 4, 20) son de tipo int, los números con partes fraccionarias (p. ej., 5,0, 1,6) son de tipo float. Veremos más sobre los tipos numéricos más adelante en este tutorial.

La división (/) siempre devuelve un número de coma flotante. Para usar la división mínima y obtener un resultado entero (eliminando cualquier parte fraccionaria), puede usar el operador //; para calcular el resto puede usar %

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17

Con Python, las potencias también se pueden calcular usando el operador **:

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

El signo igual ('=') se utiliza para asignar valores a las variables. Después de la asignación, no se mostrarán resultados hasta el siguiente mensaje:

>>> width = 20
>>> height = 5*9
>>> width * height
900

Las variables deben estar "definidas" (asignadas) antes de que puedan usarse; de ​​lo contrario, se producirá un error:

>>> # try to access an undefined variable
... n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Los números de punto flotante son totalmente compatibles; en los cálculos mixtos de números enteros y de punto flotante, los números enteros se convierten en números de punto flotante:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

En modo interactivo, el valor de la expresión más reciente se asigna a la variable _. De esta forma, podemos usarla como una calculadora de escritorio, lo cual es muy conveniente para cálculos continuos, como por ejemplo:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

Esta variable es de solo lectura para los usuarios. No intente asignarle un valor; simplemente creará una variable local separada con el mismo nombre, que bloquea la magia de las variables integradas del sistema.

Además de int y float, Python también admite otros tipos numéricos, como Decimal y Fraction. Python también tiene soporte incorporado para números complejos, usando el sufijo j o J para indicar la parte imaginaria (por ejemplo, 3+5j).

3.1.2 Cuerdas

En comparación con los números, Python también proporciona cadenas que se pueden representar de varias formas diferentes. Se pueden identificar mediante comillas simples ('…') o comillas dobles (“…”). \ se puede usar para escapar de las comillas:

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

En el intérprete interactivo, las cadenas de salida están entre comillas y los caracteres especiales se escapan con barras invertidas. Aunque puede que no se vea igual que la entrada, las dos cadenas son iguales. Si solo hay comillas simples en la cadena pero no comillas dobles, use comillas dobles; de lo contrario, use comillas simples. La función print() produce una salida más legible al omitir las comillas e imprimir caracteres especiales escapados:

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

Si su carácter precedido por una \ se trata como un carácter especial, puede usar una cadena sin formato precediendo la primera comilla con una r:

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

Los literales de cadena se pueden dividir en varias líneas. Una forma es usar comillas triples: """…""" o '''…'''. Los saltos de línea al final de la línea se incluyen automáticamente en la cadena, pero este comportamiento se puede evitar agregando \ al final de la línea. El siguiente ejemplo: puede usar una barra invertida como una cadena continua al final de la línea, lo que significa que la siguiente línea es lógicamente el contenido de seguimiento de esta línea:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

generará el siguiente resultado (nota, la primera línea sin el principio):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

Las cadenas se pueden concatenar (pegar juntas) con el operador + y repetir con *:

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Dos literales de cadena adyacentes se concatenan automáticamente:

>>> 'Py' 'thon'
'Python'

Solo funciona con dos literales de cadena, no con expresiones de cadena:

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

Si desea concatenar varias variables o concatenar una variable y un literal de cadena, use +:

>>> prefix + 'thon'
'Python'

Esta función es especialmente útil cuando desea dividir una cadena muy larga:

>>> text = ('Put several strings within parentheses '
            'to have them joined together.')
>>> text

'Ponga varias cadenas entre paréntesis para que se unan.'
Las cadenas también se pueden interceptar (recuperar). Similar a C, el primer carácter de una cadena tiene índice 0. Python no tiene un tipo de carácter separado; un carácter es simplemente una cadena de longitud 1:

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

El índice también puede ser negativo, lo que hará que el conteo comience desde la derecha. Por ejemplo:

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

Tenga en cuenta que -0 es en realidad 0, por lo que no hace que los cálculos comiencen desde la derecha.

Además de la indexación, también se admite el corte. La indexación se usa para obtener un solo carácter, el corte le permite obtener una subcadena:

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

Tenga en cuenta que el carácter inicial está incluido, pero el último carácter no está incluido. Esto hace que s[:i] + s[i:] siempre sea igual a s:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

Los índices de sector tienen valores predeterminados muy útiles; un primer índice omitido tiene un valor predeterminado de cero y un segundo índice omitido tiene un valor predeterminado del tamaño de la cadena dividida:

>>> word[:2]  # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]  # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'

Hay una manera de recordar fácilmente cómo funciona el corte: al cortar, el índice está entre dos caracteres. El primer carácter de la izquierda tiene el índice 0 y el último carácter de una cadena de longitud n tiene el índice n de la derecha. Por ejemplo:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

La primera fila de números en el texto da puntos de índice 0...6 en la cadena. La segunda línea da los índices negativos correspondientes. Un segmento son todos los caracteres de i a j entre los dos límites indicados numéricamente.

Para índices no negativos, la longitud del segmento es la diferencia entre los dos índices si tanto la parte superior como la inferior están dentro de los límites. Por ejemplo, palabra[1:3] es 2.

Intentar usar un índice demasiado grande dará como resultado un error:

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Python puede manejar con gracia esos índices de sectores sin sentido: un valor de índice que es demasiado grande (es decir, el valor del subíndice es mayor que la longitud real de la cadena) será reemplazado por la longitud real de la cadena, y se devolverá una cadena vacía cuando el límite superior sea mayor que el límite inferior (es decir, el valor de la parte izquierda del segmento es mayor que el valor r):

>>> word[4:42]
'on'
>>> word[42:]
''

Las cadenas de Python no se pueden cambiar, son inmutables. Por lo tanto, la asignación a la posición de un índice de cadena da como resultado un error:

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

Si necesita una cadena diferente, debe crear una nueva:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

La función integrada len() devuelve la longitud de la cadena:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
See also

Tipo de secuencia de texto — str: las cadenas son ejemplos de tipos de secuencia que admiten operaciones comunes a este tipo.
Métodos de cadena: las cadenas y las cadenas Unicode admiten una gran cantidad de métodos para conversiones y búsquedas básicas.
Formato de cadenas: aquí se describe información sobre el formato de cadenas usando str.format().
Operaciones de formato de cadena: esto describe las operaciones de formato de cadena de estilo antiguo que se invocan cuando las cadenas y las cadenas Unicode son el operando izquierdo del operador %.

3.1.3 Listas

Python tiene varios tipos de datos compuestos para representar otros valores. La más general es list (lista), que se puede escribir como una lista de valores separados por comas entre corchetes. Los elementos de la lista no tienen por qué ser del mismo tipo:

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Al igual que las cadenas (y todos los demás tipos de secuencias integradas), las listas se pueden indexar y dividir:

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

Todas las operaciones de división devuelven una nueva lista que contiene los elementos solicitados. Esto significa que la siguiente operación de división devuelve una copia nueva (superficial) de la lista:

>>> squares[:]
[1, 4, 9, 16, 25]

Las listas también admiten operaciones como la concatenación:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

A diferencia de las cadenas inmutables, las listas son mutables, lo que permite modificar los elementos:

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

También puede usar el método append() (veremos más sobre los métodos de lista más adelante) para agregar nuevos elementos al final de la lista:

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

A los sectores también se les pueden asignar valores, que pueden cambiar el tamaño de la lista o vaciarla:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

La función integrada len() también funciona para listas:

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Se permiten listas anidadas (crear una lista que contiene otras listas), por ejemplo:

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2 Primeros pasos en la programación

Por supuesto, podemos usar Python para realizar tareas más complejas que sumar dos a dos. Por ejemplo, podemos escribir un programa que genere subsecuencias de Fibonacci de la siguiente manera:

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

Este ejemplo presenta varias características nuevas.

La primera línea contiene una asignación múltiple: las variables a y b obtienen los nuevos valores 0 y 1 al mismo tiempo, y la última línea se usa nuevamente. En esta demostración, el lado derecho se evalúa primero antes de asignar la variable. Las expresiones de la derecha se evalúan de izquierda a derecha.

El ciclo while se ejecuta mientras la condición (aquí b < 10) es verdadera. En Python, similar a C, cualquier número entero distinto de cero es verdadero, 0 es falso, las condiciones también pueden ser cadenas o listas, de hecho, cualquier secuencia;

Todas las longitudes distintas de cero son verdaderas, las secuencias vacías son falsas. La prueba en el ejemplo es una comparación simple. Los operadores de comparación estándar son los mismos que en C: < , > , == , <= , >= y !=.

Los cuerpos de los bucles tienen sangría: la sangría es la forma en que Python organiza las declaraciones. Python (todavía) no proporciona edición de línea integrada, por lo que debe escribir TAB o espacio para cada línea sangrada.

En la práctica, se recomienda que encuentre un editor de texto para ingresar a programas complejos de Python, y la mayoría de los editores de texto brindan sangría automática. Al ingresar interactivamente una declaración compuesta, debe ingresar una línea en blanco al final para marcar el final (porque el intérprete no tiene forma de adivinar qué línea ingresó es la última línea). Cabe señalar que los bloques de declaración en el mismo bloque de declaración deben sangrar con la misma cantidad de espacios en blanco.

La declaración de palabra clave print() genera el valor de una expresión dada. Controla múltiples expresiones y salida de cadena a la cadena que desea (como hicimos en el ejemplo anterior de la calculadora).

Las cadenas se imprimen sin comillas y se insertan espacios entre cada dos subelementos, por lo que puede hacer un formato bonito como este:

>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536
用一个逗号结尾就可以禁止输出换行:

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,