Etiquetas

Breve introducción a la sintaxis de Python 3 | Parte 1

Variables

En programación, una variable está formada por un espacio en el sistema de almacenaje (memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una cantidad de información, es decir un valor. El nombre de la variable es la forma usual de referirse al valor almacenado: esta separación entre nombre y contenido permite que el nombre sea usado independientemente de la información exacta que representa.
En la mayoría de los lenguajes de computadora, el valor puede modificarse, pero no el tipo. Esto no es así en Python, donde las variables se escriben "dinámicamente", (con esto nos referimos a que pueden cambiar de tipo). Veamos un ejemplo.
  1. >>> b = 2 # b es un numero entero
  2. >>> print(b)
  3. 2
  4. >>> b = b*2.0 # Ahora b es un numero de tipo flotante
  5. >>> print(b)
  6. 4.0
En este ejemplo, notamos que la sentencia print() muestra el valor de b, en la primera linea se asigno a b el valor 2, el cual es un numero entero, posteriormente se reasigno su valor en la linea 4 al multiplicar por un numero flotante, este pasó a convertirse a un flotante también. En Python se utilizan los 3 mayor que (>>>) para representar una linea de código, las lineas 3 y 6 no lo tienen, estos son los resultados que nos muestra python después de ejecutar los comandos que hay en 1,2,4 y 5.
El símbolo de gato (#) representa el comienzo de un comentario, y lo que este escrito sera ignorado por el interprete. Los números enteros (por ejemplo 2, 4, 20) son de tipo int, aquellos con una parte fraccional (por ejemplo 5.0, 1.6) son de tipo float.

Cadenas

Una cadena es una secuencia de caracteres entre comillas simples o dobles. Las cadenas se concatenan con el operador más (+), mientras que el corte (:) se usa para extraer una parte de la cadena. Aquí hay un ejemplo:
  1. >>> cadena1= "Python es"
  2. >>> cadena2= "mi lenguaje favorito"
  3. >>> print(cadena1+' '+cadena2) #Concatenacion
  4. Python es mi lenguaje favorito
  5. >>> print(cadena1[0:6]) #corte
  6. Python
Las cadenas de texto literales pueden contener múltiples líneas. Una forma es usar triple comillas: """...""" o '''...'''. Los fin de línea son incluidos automáticamente, pero es posible prevenir esto agregando una \ al final de la línea. Por ejemplo:
  1. >>> print("""\
  2. >>> Uso: algo [OPTIONS]
  3. >>>      -h                        Muestra el mensaje de uso
  4. >>>      -H nombrehost             Nombre del host al cual
  5. >>> conectarse
  6. >>> """)
Lo cual produce la siguiente salida
  1. Uso: algo [OPTIONS]
  2.     -h                        Muestra el mensaje de uso
  3.     -H nombrehost             Nombre del host al cual conectarse
Las cadenas de texto se pueden indexar, el primer carácter de la cadena tiene el índice 0. No hay un tipo de dato para los caracteres; un carácter es simplemente una cadena de longitud uno:
  1. >>> palabra = 'Python'
  2. >>> palabra[0]  # caracter en la posición 0
  3. 'P'
  4. >>> palabra[5]  # caracter en la posición 5
  5. 'n'
Los índices quizás sean números negativos, para empezar a contar desde la derecha:
  1. >>> palabra[-1]  # último caracter
  2. 'n'
  3. >>> palabra[-2]  # ante último caracter
  4. 'o'
  5. >>> palabra[-6]
  6. 'P'
Nota que -0 es lo mismo que 0, los índice negativos comienzan desde -1.
Una forma de recordar cómo funcionan las rebanadas es pensar en los índices como puntos entre caracteres, con el punto a la izquierda del primer carácter numerado en 0. Luego, el punto a la derecha del último carácter de una cadena de n caracteres tienen índice n, por ejemplo:
  1.  +---+---+---+---+---+---+
  2.  | P | y | t | h | o | n |
  3.  +---+---+---+---+---+---+
  4.  0   1   2   3   4   5   6
  5. -6  -5  -4  -3  -2  -1
La primer fila de números da la posición de los índices 0...6 en la cadena; la segunda fila da los correspondientes índices negativos. La rebanada de i a j consiste en todos los caracteres entre los puntos etiquetados i y j, respectivamente.
Para índices no negativos, la longitud de la rebanada es la diferencia de los índices, si ambos entran en los límites. Por ejemplo, la longitud de palabra[1:3] es 2.
La función incorporada len() devuelve la longitud de una cadena de texto:
  1. >>> s = 'supercalifrastilisticoespialidoso'
  2. >>> len(s)
  3. 33
Una cadena es un objeto inmutable: sus caracteres individuales no se pueden modificar con una instrucción de asignación y tiene una longitud fija. Un intento de violar la inmutabilidad dará como resultado TypeError, de la siguiente manera:
  1. >>> s = ’Presiona el botón para salir’
  2. >>> s[0] = ’p’
  3. Traceback (most recent call last):
  4. File ’’<pyshell#1>’’, line 1, in ?
  5. s[0] = ’p’
  6. TypeError: object doesn’t support item assignment

Tuplas

Una tupla es una secuencia de objetos arbitrarios separados por comas y encerrados entre paréntesis. Si la tupla contiene un solo objeto, se requiere una coma final; por ejemplo, x = (2,). Las tuplas admiten las mismas operaciones que las cadenas; También son inmutables. Aquí hay un ejemplo donde la tupla rec la cual contiene otra tupla (1,1,1926):
  1. >>> rec = (’Levenspiel’,’Octave’,(1,1,1926)) # Esto es una tupla
  2. >>> lastName,firstName,birthdate = rec # Desempaquetar elementos de la tupla
  3. >>> print(firstName)
  4. Octave
  5. >>> birthYear = birthdate[2]
  6. >>> print(birthYear)
  7. 1926
  8. >>> name = rec[1] + ’ ’ + rec[0]
  9. >>> print(name)
  10. Octave Levenspiel
  11. # Fue el autor de importantes libros de texto de Ingeniería de reacción química
  12. >>> print(rec[0:2])
  13. (’Levenspiel’, ’Octave’)

Listas

Una lista es similar a una tupla, pero es mutable, por lo que sus elementos y longitud pueden modificarse. Una lista se identifica encerrándola entre paréntesis. Aquí hay una muestra de operaciones que se pueden realizar en listas:
  1. >>> a = [1.0, 2.0, 3.0] # Creamos una lista
  2. >>> a.append(4.0) # Con Append añadimos 4.0 a la lista
  3. >>> print(a)
  4. [1.0, 2.0, 3.0, 4.0]
  5. >>> a.insert(0,0.0) # Con Insert agregamos 0.0 en la posición 0
  6. >>> print(a)
  7. [0.0, 1.0, 2.0, 3.0, 4.0]
  8. >>> print(len(a)) # Len para determinar la longitud de la lista
  9. 5
  10. >>> a[2:4] = [1.0, 1.0, 1.0] # Modificamos los elementos seleccionados
  11. >>> print(a)
  12. [0.0, 1.0, 1.0, 1.0, 1.0, 4.0]
Si a es un objeto mutable, como una lista, la instrucción de asignación b = a no da como resultado un nuevo objeto b, sino que simplemente crea una nueva referencia a a. Por lo tanto, cualquier cambio realizado en b se reflejará en a. Para crear una copia independiente de una lista a, use la instrucción c=a[:], como se muestra en el siguiente ejemplo:
  1. >>> a = [1.0, 2.0, 3.0] #Creamos una lista
  2. >>> b = a # Aquí ’b’ se convierte en un alias para ’a’
  3. >>> b[0] = 5.0 # Aplicamos un cambio en ’b’
  4. >>> print(a)
  5. [5.0, 2.0, 3.0] # Los cambios son reflejados en ’a’
  6. >>> c = a[:] # Aquí ’c’ es una copia independiente de ’a’
  7. >>> c[0] = 1.0 # Aplicamos un cambio a ’c’
  8. >>> print(a)
  9. [5.0, 2.0, 3.0] # Notamos que ’a’ no se vio afectada por ’c’
Es posible anidar listas (crear listas que contengan otras listas), por ejemplo:
  1. >>> a = ['a', 'b', 'c'] #Creamos una lista
  2. >>> n = [1, 2, 3] #Creamos otra lista
  3. >>> x = [a, n] #Anidamos las listas
  4. >>> x
  5. [['a', 'b', 'c'], [1, 2, 3]]
  6. >>> x[0] #Pedimos nos muestre la primer lista de x o sea a
  7. ['a', 'b', 'c']
  8. >>> x[0][1] #Pedimos nos muestre el segundo elemento de la primer lista
  9. 'b'
Las matrices se pueden representar como listas anidadas, y cada fila es un elemento de la lista. Aquí hay una matriz 3 × 3 llamada a en forma de lista:
  1. >>> a = [[1, 2, 3], \
  2.          [4, 5, 6], \
  3.          [7, 8, 9]]
  4. >>> print(a[1]) # Muestra la segunda fila (elemento 1)
  5. [4, 5, 6]
  6. >>> print(a[1][2])# Muestra el tercer elemento de la segunda fila
  7. 6
La barra invertida (\) es el carácter de continuación de Python. Recuerde que las secuencias de Python tienen desplazamiento cero, de modo que a [0] representa la primera fila, a [1], representa la segunda fila, etc. Usualmente no se utilizan listas para matrices numéricas, solo con algunas pocas excepciones. Es mucho más conveniente emplear objetos de matriz proporcionados por el módulo o librería numpy. Los objetos de matriz los analizaremos en otra publicación, más adelante.


Hasta aqui concluye la primera parte de esta introducción, en la segunda parte veremos como realizar las operaciones aritméticas basicas, operaciones comparativas, boleanos y diversas herramientas para control de flujo en ciclos.

Referencias

Etiquetas:

Comentarios

Publicar un comentario