Variables en Python.

por Miércoles, Agosto 12, 2015 0 No tags Permalink 0

He seguido de forma acelerada este repaso de Python siguiendo el curso de Udemy Python for beginners. El curso no es nada profundo y se sigue a toda velocidad si se tienen conocimientos previos de programación. Por otro lado, no es completo, por lo que debe ser ampliado con otras fuentes. Tal vez la parte más complicada es el comienzo, en lo relativo a la instalación de PyDev en Eclipse para Mac.

 

 

Variables.

Es recomendable escribir las variables como CamelCaising o under_score para recordar mejor el significado de la variable.

Para asignar un valor numérico a una variable usamos el símbolo igual ( ) y puede visualizarse mediante el comando print:

Una variable se considera un objeto en Python, al ser un lenguaje orientado a objetos. Cada variable ocupa una posición de memoria que podemos conocer con la función id(NombreVariable). El tipo de variable se conoce mediante la función type(NombreVariable).

number = 500;
print(number);
print(id(number));
print(type(number));

Es posible declarar más de una variable en una sola línea:

a,b,c = 1,2,3
print a,b,c

Vemos que no es necesario incluir el paréntesis en la función print, pero si incluimos varias variables en el mismo print, estas deben ir separadas por comas.

Números

Los números pueden representarse como enteros (int)o como números en coma flotante (float).

Se puede convertir un número en coma flotante en un entero con la función int(NombreVariable). El número se trunca, no se redondea. Si se quiere redondear debe usarse la función round(NombreVariable) que deja el número con un real en coma flotante.

Igualmente para convertir un entero en coma flotante se utiliza la función float(NombreVariable).

a = 50
b = 50.75
print(type(a),a)
print(type(b),b)
c = int(b)
d = round (b)
print(type(c),c)
print(type(d),d)
e = float(a)
print(type(e),e)

Cadenas

Las cadenas (strings ) deben ir entre comillas simples o dobles.

También pueden usarse comillas triples para indicar multiples líneas.

a = "Esto es una cadena"
b = 'Esto es otra cadena'
c = '''
Esto en una cadena 
en varias
líneas '''
print(type(a),a) 
print(type(b),b)
print(c)

Es interesante poder introducir una variable dentro de otra cadena. Para ello usamos el símbolo % y una estructura especial:

a = "1960"
b = 'Naci en Madrid en %s ' %a
print(b)

Tuplas y Listas

Deben distinguirse entre tuplas y listas propiamente dichas. Las tuplas son como constantes, es decir, no pueden modificarse, mientras que las listas son como variables que podemos modificar y operar sobre ellas. Para declarar una u otra se usan paréntesis (tuplas) o corchetes (listas), respectivamente:

a = (1,2,3,4,5)
b = [1,2,3,4,5]
print (type(a),a)
print (type(b),b)
b.append(6)
print (b)

Podemos recuperar elementos de una lista mediante su índice, teniendo en cuenta que dichos índices comienzan en cero. Puede recuperarse un sólo elemento de la lista o un grupo de ellos.

a = [1,2,3,4,5]
print (a[2])
print (a[2:4])
print (a[2:5])
print (a[:4])

Nótese que el último valor del índice indicado no aparece. Es decir, indica el elemento de parada, pero ese elemento no aparece.

Al recuperar un grupo de elementos, puede  incluirse un tercer elemento entre los corchetes para indicar el salto entre un elemento y el siguiente:

a = [1,2,3,4,5,6,7,8,9,10,11]
print (a[2:8:2])
print (a[2::2])
print ([::2])
print ([:6:2]

En este caso estaremos recogiendo elementos de dos en dos. En el primer caso estamos indicando un elemento de comienzo y uno de parada; en el segundo solo el de comienzo, con lo que aparecerá los elementos de dos en dos desde el indicado para comenzar hasta el final de la lista; en el tercero no aparece ni comienzo ni parada, con lo que aparecerán todos los elementos de principio a fin de dos en dos. El último caso se deduce lógicamente de lo anterior.

También pueden recuperarse elementos en orden inverso usando índices negativos. De este modo empezamos a contar desde la derecha en lugar desde la izquierda de la lista, siendo el primer elemento el de índice -1. Es decir de izqueirda a derecha el primer índice es el 0 y de derecha a izquierda el -1.

a = [1,2,3,4,5]
print (a[-1])
print (a[-3])

Esto mismo también puede realizarse conociendo la longitud de la lista (el número de elementos) mediante la sentencia len, obteniendo el mismo resultado:

a = [1,2,3,4,5]
length = len(list)
print (length-1)
print (length-3)

Sin embargo, el primer método es más adecuado, ya que utiliza menos código.

Diccionarios

La forma de escribir los diccionarios es mediante llaves:

a = {'one':1,'two':2}
print (type(a),a)
b = {'id':7,'name':'Jose manuel'}
print (type(b),b)

Una forma alternativa de escribir los diccionarios es mediante la función dict:

dictiorany = dict(
                  one   =   1,
                  two   =   'two'
                  )
print (type(dictiorany),dictiorany)

Booleanos

Las variables booleanas solo pueden tomar dos valores, truefalse.

a = True
print (type(a),a)
b,c = 1,0
if b==c: 
        print( True) 
else: 
        print (False)

Una forma alternativa de escribir los diccionarios es mediante la función dict:

dictiorany = dict(
                  one   =   1,
                  two   =   'two'
                  )
print (type(dictiorany),dictiorany)

Alcance de las variables

Las variables pueden ser declaradas globaleslocales.  Las variables globales afectan a todas las funciones del código, mientras que las variables locales solamente afectan a aquella función donde han sido declaradas. Esto significa que si una variable global es modificada dentro de una función, el nuevo valor será el utilizado en una función posterior en la ejecución del código. Sin embargo, si una variable es local, será empleada únicamente dentro de la función en que la que se ha declarado.

Las variables locales son más seguras, dado que un error en una función sólo afectará a las variables locales de dicha función. Las variables globales son adecuadas por ejemplo cuando se trata de constantes que van a utilizar el mismo valor en cualquier punto del código.

Operadores

Operadores aritméticos

Python tiene los operadores aritméticos habituales. Supongamos que a=9 y b=2.  La siguiente tabla muestra los operadores aritméticos principales:

Operador Símbolo Descripción Ejemplo
Suma + Suma los valores a ambos lados del operador a+b=11
Resta Resta el valor a la derecha del operador del valor a la izquierda a–b=7
Multiplicacion * Multiplica los valores a ambos lados del operador a*b=18
Division / Divide el valor a la derecha del operador entre el valor a la izquierda a/b=4.5
Módulo % Entrega el resto de la división entre el valor a la derecha y el valor a la izquierda del operador a%b=1
Exponente ** Calcula la potencia del valor a la izquierda del operador, siendo el valor a la derecha el exponente a**b=81
Cociente redondeado // Entrega el cociente de la división entre los dos operandos, eliminando los decimales. a//b=4

El orden de los operadores es el habitual en matemáticas y lenguajes de programación: el producto y la división tiene prioridad sobre la suma y la resta, y en caso de utilizar paréntesis, estos marcan la prioridad.

Operadores condicionales

Python tiene los operadores condicionales habituales. Supongamos que a=9 y b=2.  La siguiente tabla muestra los operadores aritméticos principales:

Operador Descripción Ejemplo
== Si los dos operandos son iguales el resultado es True y False en caso contrario (a == b) False
!= Si los dos operandos no son iguales el resultado es True y False en caso contrario (a != b) True
<> Si los dos operandos no son iguales el resultado es True y False en caso contrario (a <> b) True
> Si el valor a la izquierda del operador es mayor que el de la derecha el resultado es True y False en caso contrario (a > b) True
< Si el valor a la derecha del operador es mayor que el de la izquierda el resultado es True y False en caso contrario (a < b) False
>= Si el valor a la izquierda del operador es mayor o igual que el de la derecha el resultado es True y False en caso contrario (a >= b) True
<= Si el valor a la izquierda del operador es menor o igual que el de la derecha el resultado es True y False en caso contrario (a <= b) False

 Comentarios

Los comentarios en una línea se incluyen con el símbolo #.

# Esto es un comentario y no se procesará en el código

Toma de decisiones

Sentencias if… else … elif

La forma de crear las sentencias ifif… else es sencilla:

  • Después de la condición if, else o elif debe ir el símbolo dos puntos (:).
  • Las sentencias anidadas se crean mediante tabulaciones.

Aquí vemos algunos ejemplos:

a,b = 4.0,5.0
if ab: 
    c=a*b
    print c
elif (b>a): print (a+b)


var = 100
if var > 50:
   print "La variable es mayor de 50"
   if var == 100:
      print "La variable es 100"
   elif var == 150:
      print "La variable es 150"
   elif var == 200:
      print "La variable es 200"
elif var < 50:
   print "La variable es menor que 50"
else:
   print "No se ha podido encontrar la variable"

Una forma alternativa de escribir las sentencias if en una sola línea es la siguiente:

a,b = 0,1
var = "La sentencia es cierta" if a == b else "La sentencia no es verdadera"
print (var)

Resulta mucho más compacto y legible.

Sentencia switch

Python no tiene la función switch como por ejemplo PHP. Una forma de emular la sentencia switch es usar la función dict (diccionario). Aquí tenemos algunos ejemplos:

switch = dict( 
              one ="uno",
              two ="dos",
              three = "tres"
              )
var1 = "two"
print(switch[var1])

print(switch.get(var1,'no encontrada (valor por defecto)'))

var2 = "four"
print(switch.get(var2,'no encontrada (valor por defecto)'))

Bucles

Bucle while

La forma de escribir el bucle while es la habitual, utilizando el símbolo dos puntos (:) tras finalizar la condición a cumplir para ejecutar el bucle y antes de indicar la acción a realizar durante el mismo. Dicha condición debe variar para que el bucle pueda cerrarse. Aquí vemos un ejemplo:

a = 0
while a<=20:
    print(a)
    a+=1
print ("Bucle terminado")

Bucle for

La forma de escribir un bucle for es siempre la siguiente:

for (nombre_del_dato) in (cadena, array, etc.) :
acción a ejecutarse

Aquí vemos algunos ejemplos:

a = [0,1,2,3,4,5]
for data in a:
    print(data)
print ("Bucle 1 for terminado")

for data in [0,1,2,3,4,5]:
    print(data)
print ("Bucle 2 for terminado")

for letter in 'string':
    print(letter)
print ("Bucle 3 for terminado")

for key,data in enumerate('cadena'):
    if key % 2 == 0:
        print data
print ("Bucle 4 for terminado")

Excepciones

Python permite el uso de excepciones mediante las sentencias tryexcept. Básicamente, estas sentencias permiten tomar un camino alternativo en caso de que se presente un error, además de permitir visualizar de un modo más amigable el tipo error que aparece en la ejecución. La estructura es la siguiente:

tuple = (0,1,2,3,4,5) # create a tuple
try:
    tuple.append(6) # try to add a new value to a
except: 
    print("Ha ocurrido un error") # exception appear
else:
    for each in tuple:
        print (each)

También puede escribirse como:

tuple = (0,1,2,3,4,5) # create a tuple
try:
    tuple.append(6) # try to add a new value to a
    for each in tuple:
        print (each)
except AttributeError as e: # mark the exception type as e
    print 'Ha ocurrido un error: ',  e # exception appear

Break, continue y else

Break es la sentencia para interrumpir un bucle. Aquí vemos un ejemplo:

list = [0,1,2,3,4,5] # create a list
for int in list:
    if int == 3:
        break
    else:
        print (int)

Del mismo modo, continue se utiliza para continuar el bucle:

list = [0,1,2,3,4,5] # create a list
for int in list:
    if int == 3:
        continue
    else:
        print (int)

Operaciones con listas

Vamos a ver diferentes operaciones con listas:

  • Añadir un nuevo elemento: append.
  • Extender una lista o unir dos listas: extend.
  • Añadir un nuevo elemento en un índice determinado de la lista: insert.
  • Editar un elemento en un índice determinado de la lista: =.
  • Borrar elementos de la lista identificados por su índice: del.
  • Borrar elementos de la lista identificados por su valor: remove.
  • Invertir el orden de los índices en la lista: reverse.
  • Ordenar una lista: sort.
  • Crear una nueva lista ordenada a partir de otra lista no ordenada: sorted.

Estos son algunos ejemplos:

list = [0,1,2,3,4,5,6,7,8,9,10,11] # create a list
list2 = [13,14,15,16,17,18,19,20] # create a second list
list.append(12)
print (list)
list.extend(list2)
print (list)
list.insert (6,5.5)
print(list)
list[6] = 33
print (list)
list[6] = 33/3
print(list)
del list[6]
print(list)
list.remove(11)
print (list)
list.reverse()
print(list)
list.sort()
print(list)
list.reverse()
list2 = sorted(list)
print(list2)

Recibiendo datos

Existe una diferencia importante en el comando a utilizar para recibir datos ya usemos Python 2.7 o Python 3.0 o superior. Para solicitar una entrada mediante el teclado se emplean dos sentencias diferentes:

  • Python 2.7: raw_imput.
  • Python 3.0: input.

Este es un ejemplo sencillo para Python 2.7:

print ('Hello JM')
raw_input('Press any key to continue')
print('Thanks')

Sin embargo, si podemos usar input en Python 2.7 para asignar el valor de una entrada a una variable:

data = input('What\'s your favorite number?\n')
data = int(data)*20
print('Your favorite number times 20 is {}'.format(data))

Funciones con cadenas de caracteres

Cuando una variable es una cadena de caracteres es tratada como si dichos caracteres formasen una lista. De este modo, cuando operamos sobre cualquiera de las dos líneas del siguiente ejemplo, string1string2, obtenemos el mismo resultado:

string1 = ['s','t','r','i','n','g']
string2 = 'string'
for letter in string1:
    print(letter)
for letter in string2:
    print(letter)

Otras funciones disponibles son las siguientes:

  • Contar el número de veces que aparece un carácter en una cadena: count.
  • Hacer que todas las iniciales de cada palabra aparezcan en mayúscula: title.
  • Convertir en mayúsculas sólo la primera leta de la cadena: capitalize.
  • Formar una cadena con los caracteres de una lista o una tupla: join.
  • Separar una cadena a partir de un carácter, creando una lista con cada uno de os elementos resultantes: split.
string = 'this is an example of a text string'
print(string.count('s'))
print(string.title())
print(string.capitalize())
string2 ='-'
sequence = ['j','o','s','e']
print(string2.join(sequence))
string3 =''
print(string3.join(sequence))
print(''.join(sequence))
data = string2.join(sequence)
sequence = data.split('-')
print (sequence)

Funciones de usuario

Estas son las funciones creadas por el usuario y que no están predefinidas en Python. La ventaja de las funciones es que las escribimos una vez y podemos usarlas tantas veces como deseemos.

La sintaxis básica de una función es la siguiente:

def function_name():
    string ='Hello'
    return string

print (function_name())

Dentro de la función pueden realizarse las operaciones que se deseen.

A la función se le pueden pasar tantos parámetros, separados por comas, como se deseen:

mylist = [1,2,3,4,5]
def my_function_name(list):
    list.append(6)
    return list

print (my_function_name(mylist))

otherlist = [7,8,9,10]

def other_function_name(list1,list2):
    list1.extend(list2)
    return list1

print(other_function_name(mylist,otherlist))

Comments are closed.