Introducción a diccionarios

En este código se hace de nuevo un repaso a lo que es el is, is not, in, not in. Los cuales regresan valores de True o False.

En cuanto a un diccionario, éstos relacionan una clave y un valor. Se pone la variable a la que quieres asignar el diccionario, y después del igual entre llaves { } se pone primero la clave, seguido de dos puntos : y después el valor. A diferencia de con las listas y tuplas es que a estos valores se les accede por su clave con el operador [ ].

• Código:

x1= 5
y1= 5
x2= 'Hello'
y2= 'Hello'
x3= [1,2,3]
y3= [1,2,3]

#Output: False
print(x1 is not y1) 

#Output: True
print(x2 is y2) 

#Output: False
print(x3 is y3)

x = 'Hello world'
y= {1:'a',2:'b'}

#Output: True
print('H' in x) 

#Output: True
print('hello' not in x) 

#Output: True
print(1 in y) 

#Output: False
print('a' in y)  

• Ejecución:

Repaso general

Aquí se puede ver en el código con ejemplos sencillos lo que ya se vio anteriormente, como la reasignación de elementos de una lista, poder modificarlos, imprimir ciertos elementos y la mitad de los elementos de ésta.
Para poner los elementos en una tupla no son necesarios los paréntesis, con una simple separación de comas funciona; pero el interprete utiliza paréntesis y hay que respetarlos.

Para poder saber el tipo de dato que estoy ingresando, y si quiero que se imprima se pone: print(type(variable)).

• Código:

I=[22,True, "una lista",[1,2]]

I2=[11,False]

mi_var=I2[0]

print(mi_var)

#cambiar el 11 por un 22

I2[0]=22

print(I2)

I3=["otra cadena",[1,2]]

#cambiar el uno de la lista por un 8

I3[1][0]=8

print(I3)

I4=[99,True, "lista", 22, 14, 25]

#mostrar los dos ultimos

mi_var2=I4[4:]

print(mi_var2)

#mostrar los dos primeros

mi_var3=I4[:2]

print(mi_var3)

#mostrar solo el boleano

mi_var4=I4[1]

print(mi_var4)

#mostrar solo los medios

longi=len(I4)

print(I4[longi//2])

#...................

#TUPLAS

#Declare los valores para una tupla que contenga:

#1 2 verdadero y python

tupli=(1, 2, True, "Python")

#imprima el tipo de dato de la tupla

print(type(tupli))

#de la pagina 58 cree un tupla de un solo valor que sea 55 el valor

tupli2=(55,)

#cree una variable de tipo cadena que contenga hola mundo

cadenita="Hola Mundo"

• Ejecución:

del y .remove

Desde esta entrada todos los programas serán probados en la Raspberry. 

Cuando ponemos del variable [posición], borra la posición de la lista que queremos dentro de los corchetes.

Ahora, cuando ponemos variable.remove("Cadena"), nos borra la cadena que ingresamos dentro del paréntesis.

• Código:

lista=["Primavera", "verano", "otoño", "invierno"]

print(lista)

li=[] #lista vacia

li=list()

print(li)

diassem=["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"]

print(diassem)

#la funcion "del" borra posiciones

del diassem[1] 

print(diassem)

#.remove borra una cadena

diassem.remove("miercoles")

print(diassem)

otro=["elem1","elem2","elem3","elem4","elem5"]

print(otro)

del otro[2]

print(otro)

otro.remove('elem4')

print(otro)

print(len(otro))

• Ejecución:

                                          

Operadores a nivel de bit

También se les puede llamar operadores lógicos, porque son los que conocemos como AND, NOT, OR. Estos se pueden ingresar con su símbolo, o simplemente escribiendolo con letra.

• Código:

x=True
y=False

#Output: x and y is False
print('x and y', x and y)

#Output: x or y is True
print('x or y', x or y)

#Output: not x is False
print('not x', not x)

• Ejecución:

                                          

Operadores relacionales

Como ya se vio con anterioridad, al igual que los operadores lógicos, los operadores relaciones comparan variables y devuelven valores de True o False. En los comentarios esta escrito que significa cada operador relacional.

• Código:

x= 10
y=12

#output x>y is false (mayor que)
print('x > y is ', x>y)

#output x<y is true (menor que)
print('x < y is ', x<y)

#output x==y is false (igualdad)
print('x == y is ', x==y)

#output x!=y is true (negación)
print('x != y is ', x!=y)

#output x>=y is false (mayor igual que)
print('x >= y is ', x>=y)

#output x<=y is true (menor igual que)
print('x <= y is ', x<=y)

• Ejecución:

Operaciones aritméticas

En el código a continuación, en los comentarios se puede entender más claramente lo que realiza cada operador aritmético.

• Código:

x=15

y=4

#output x+y =19

print('x+y =', x+y)

#output x-y =11

print('x-y =', x-y)

#output x*y =60

print('x*y =', x*y)

#output x/y =3.75

print('x/y =', x/y)

#output x//y =3 division entera

print('x//y =', x//y)

#output x**y =50625 exponente

print('x**y =', x**y)

#output x%y =3  módulo

print('x moudulo y =', x%y)

• Ejecución:

Cambiar elementos de lista dentro de una Tupla

Como ya se dijo, dentro de una tupla pueden ir listas, que se ingresan con [ ]. Se puede acceder a estos elementos, o incluso a los de la tupla mediante su posición puesta entre corchetes [ ]. 

Pero no se puede modificar el dato de una tupla, porque lo que ingreses dentro de ésta no se puede modificar, al menos que este dentro de una lista.

• Código:

n_tuple=("mouse", [8, 4, 6],(1, 2, 3))

#nested index
#output: 's'
print(n_tuple[0][3])

#nested index
#output: 's'
print(n_tuple[1][1])

my_tuple= (4, 2, 3, [6, 5])
#we cannot change an element, #if you uncomment line
#you will get an error:, #type error: "tuple object does not
#my_tuple[1]= 9, #but item of mutable lement can be changed
#output: (4, 2, 3, [9, 5])
my_tuple[3][0]= 9
print(my_tuple)

#tuples can be reassigned, #output: ('p', 'r', 'o','g', 's', 'm', 'i', 'z')
my_tuple= ('p', 'r', 'o','g', 's', 'm', 'i', 'z')
print(my_tuple)

• Ejecución:

Tuplas con datos mezclados

Dentro de una Tupla se pueden poner datos de diferentes tipo. 

Se puede poner:

1. Listas con números.
2. Cadenas de caracteres.
3. Listas vacías

Además se puede ingresar a cierta posición dentro de la tupla, para solo imprimir ese dato, mediante posición numérica o de letras (a, b, c); a esto se le llama Tuple Unpacking. También se pueden poner todas las tuplas creadas en una sola, solo hay que sumarlas y asignarlas a otra variable.

• Código:

my_tuple=()

print(my_tuple)

#tuple having integers

#Output: (1,2,3)

my_tuple=(1, 2, 3)

print(my_tuple)

#tuple with mixed datatypes

#Output: (1,"Hello",3.4)

my_tuple=(1,"Hello",3.4)

print(my_tuple)

#nested tuple

#Output: ("mouse",[8,4,6],(1,2,3))

my_tuple=("mouse", [8, 4, 6],(1, 2, 3))

lista=[1,2,3]

tup=(lista)

print(tup)

#tuple can be created without parentheses

#also called tuple packing

#output: 3, 4.6, "dog"

my_tuple=3,4.6,"dog"

print(my_tuple)

#Tuple Unpacking is also possible, Output: 3, 4.6, dog

#Las letras son las posiciones de cada cosa en my_tuple

a,b,c=my_tuple

print(a)

print(b)

print(c)

tupla1=(1,2,3)

tupla2=(4,5,6)

tupla3=(7,8,9)

#Junta todas las tuplas en una

tuplat=tupla1+tupla2+tupla3

print(tuplat)

• Ejecución:

Tabla con Tuplas

Aqui se puede volver a ver el uso de Tuplas, pero ahora para poder imprimir una tabla con datos y formato más entendible.

• Código:

titulos="{} \t{} \t{}".format('Estudiante','Edad','Estatura')

fila1="{}  \t\t{}  \t{}".format('Susi','19','1.60')

fila2="{}  \t\t{}  \t{}".format('Zac','27','1.73')

fila3="{}  \t\t{}  \t{}".format('Eddie','40','1.72')

print("Tabla de estudiantes")

print(titulos)

print(fila1)

print(fila2)

print(fila3)

• Ejecución:

Cadenas de caracteres y formatos de filas con Tuplas.

También con los strings (cadenas de caracteres) se pueden hacer como "operaciones", pero en realidad pasa algo diferente. Es decir, si pongo str1*3, la cadena que esta en str1 se imprimirá 3 veces, y si pongo que se sume a otra cadena, se pondrán juntas las dos cadenas que sume. 

Para poder imprimir filas en una tabla se puede poner {} dentro de una tupla; después con el constructor .format, se le asignaran en esos corchetes lo que ponga dentro del format. Ademas de que puedo poner que se impriman según la posición en que las declare en el format.
En el código se pueden apreciar como se ponen los comandos especiales, están como comentarios, para un comentario muy largo se ponen las ''' al inicio y al final del comentario.

*Dato Curioso*: si a una variable le asignas \a y luego pides imprimirla por 3, al ejecutar se producirá un sonido de bip.

• Código:

str1= 'Hello'

str2='Mundo!'

#using +

print('str1 + str2 = ',str1,str2)

#using *

print('str1 * 3 = ',str1*3)

str='Frio'

# enumerate []

list_enumerate = list (enumerate(str))

print('list(enumerate(str) = ',list_enumerate)

#character count

print('len(str) = ', len(str))

#Crea un sonido al ejecutar

var1="\a"

print(var1*3)

'''

\ new line

\\ Backlash

\' single quote

\" double quote

\a ASCII Bell

\b ACII Backspace

\f ASCII Formfeed

\n ASCII Linefeed

\r ASCII Carriage Return

\t ASCII Horizontal Tab

\v ASCII vertical tab

\ooo Character with octal value value ooo'''

#f\xHH Character with hexadecimal value HH

#default(implicit) order

default_order= "{}, {} y {}".format('Juan','Pedro','Jose')

print('\n---Default Order ---')

print(default_order)

#order using positional argument

Positional_order= "{1}, {0} y {2}".format('Juan','Pedro','Jose')

print('\n---Positional Order ---')

print(Positional_order)

#order using keyword argument

Keyword_order= "{j}, {p} y {jo}".format(j='Juan',p='Pedro',jo='Jose')

print('\n---Keyword Order ---')

print(Keyword_order)

• Ejecución:

                                          

Tuplas

Las tuplas son listas donde sus valores no se pueden modificar. Para ingresar una tupla se ponen los valores entre paréntesis ( ). Imprime lo dentro del paréntesis tal cual y fue ingresado, como se ve en el código.

• Código:

soytupla=(1,2,3,4,5)
print(type(soytupla))
lista=[1,2,3]
print(type(lista))

otratupla=("Hola",1,"soy",2,"algo lista","""podra \n con tres \n""")
print(otratupla)
print(otratupla[0])
print(otratupla[:3])
print(otratupla[2:])
print(otratupla[1:4])
#las listas son contenedores de elementos modificables
#las tuplas son contenedores de elementos inmutables                             

• Ejecución:

Comparación de variables

Se pueden comparar variables para ver si son o no iguales las variables y tener como resultado valores boleanos (True, False).

Para ello en el mismo print se puede poner; usando is o is not para tener un resultado negado.

• Código: 

x1=5

y1=5

x2='Hello'

y2='Hello'

x3= [1,2,3]

y3=[1,2,3]

#output: false

print("son 5 y 5 la pregunta es si no: ",x1 is not y1)

#output: true

print("son 5 y 5 la pregunta es si: ",x1 is y1)

#output: True

print("verdadero: ",x2 is y2)

#output: Falso

print("falso: ",x2 is not y2)

#output: false

print(x3 is y3)

• Ejecución:

Imprimir cierto rango de caracteres

Ya se vio anteriormente que cada carácter tiene una posición, entonces también puedo imprimir rango de esos caracteres. Poniendo entre corchetes y con : de donde a donde se va a imprimir, pero el ultimo numero que ingreses no lo imprime. 

Es decir, si pongo [0:4], la posición 4 no se imprime.

• Código:

nombre="susana"
print(len(nombre))
print(nombre[1:4])
print(nombre[0:6])
#si no tiene limite de inicio es hasta el limite superior
print(nombre[:3])
#si no tiene limite final es desde el limite inferior
print(nombre[3:])

#imprime la letra inicial, media y final
print(nombre[0])
media=len(nombre)//2
#print ("media",media)
print(nombre[media])
print(nombre[-1])

• Ejecución:

Operador "in"

Con el operador in podemos comprobar si un carácter esta o no en una cadena. Esto devolverá valores de True o False. 

Además, si ponemos not in, se nos dará la negación del valor que pedimos. Para saber si se encuentra el carácter, pero que nos imprima su posición se usa el constructor find.

Existen comandos especiales que hacen saltos de línea, tabulaciones entre otros que se pueden ver en el código.

• Código:

blog="Mi diario en python"
print("python" in blog)
print("ari" in blog)
print("hola" in blog)

print("hola soy un salto de \n linea")
print("hola soy un \ttabulador")
print("hola soy una contra barra \\")
print("hola soy una comilla simple \'")
print("hola soy una \" comilla doble")

print("Encuentra",blog.find("en"))
print("en" not in blog)
print("hola" not in blog)

• Ejecución:

Acceder a los caracteres de una cadena

Cada carácter de una palabra tiene una posición especifica, el cual Python permite tomar un carácter en especifico. Si se lee de izquierda a derecha se empieza en 0, si se lee de derecha a izquierda se empieza desde -1. Además se puede ver la longitud de la cadena con len.

•  Código:

fruta="Manzana"
print(fruta[0])
print(fruta[1])
print(fruta[2])
print(fruta[3])
print(fruta[4])
print(fruta[5])
print(fruta[6])
print()
print(fruta[-1])
print(fruta[-2])
print(fruta[-3])
print(fruta[-4])
print(fruta[-5])
print(fruta[-6])
print(fruta[-7])

print("Longitud de la cadena fruta",len(fruta))
lon =len(fruta)
print(fruta[(lon)-1])

• Ejecución:

Imprimir cadena de caracteres

A las variables se les puede asignar una cadena de caracteres, si usas una comilla sencilla ' o doble ", funcionan para palabras simples en una sola línea. 

Ya si quieres poner saltos de línea en un solo print se debe poner triple comilla """. Se ve claramente en los dos programas.

• Códigos:

#parte1
#comentario no hace nada

x=5

a=5.2

b="hola\thola\thola"

c=""" esto es uno \n que es de mas \n de una linea"""

print(c)

print(b)

#\n es un enter y \t es un tabulador de 5 espacios

#parte2
cadena="Hola"
cadena2='otro hola'
cadena3="""Mas holas\npero difr\nente"""
print(cadena)
print(cadena2)
print(cadena3)

tupla=("",'',"""""")

• Ejecuciones:

                                         

Imprimir y realizar operaciones con variables

Las operaciones con las variables se pueden realizar dentro del mismo paréntesis del print,  y si solo queremos dejar un salto de línea se deja el paréntesis vacío.

• Código: 

a=4

nombre="juan perez"

gravedad=9.81

print(a*gravedad/2)

print()

print(nombre)

• Ejecución:

                                       

Imprimir una variable

Se le asigna a una variable, que puede ser nombrada como queramos, un valor.

Después solo se pone que imprima ese valor con print, así como se ve a continuación.

• Código:

a=10
print(a)

• Ejecución:

Programa para calcular números complejos

Este programa te realiza una operación usando números complejos, para necesitas sympy.

Para ello tienes que importar el valor del complejo a tu programa; que es "i", pero en python se representa como "I". 

Y ya de ahí ya puedes usar operaciones, empleando simplify y el número complejo como I.

• Código:

#importar sympy

from sympy import I, simplify

print(simplify(((1+I) / (1+2 * I))))

•  Ejecución:

Mi Primera Experiencia con Python

Hoy fue la primera vez que utilice Python. Fue algo nuevo poder asignar valores y modificar variables desde el cmd, porque siempre que hacemos programas (o lo que hemos aprendido) ha sido en una interfaz algo diferente, como Borland.

Me di cuenta que Python no requiere ni del ";" ni de la declaración del tipo del variable, porque el programa ya solo sabe que tipo es, lo cual se me hace algo más fácil a la hora de escribir un programa, porque así no me entretendría poniendo el tipo de la variable y además sería más rápido programar. 

Lo único malo que le vi, fue que no puedo limpiar la pantalla, pero no es mucho problema, solo bajó el cursor y listo. En general, me gustó este compilador y creo que será más fácil que Borland C++ .