cd /mnt/c/users/ihernandez/documents/scripts\ phyton/
user: ihl
pass: lhi
*********NOTAS****************
******************************
SNAKE KEYS = es unir mas de 1 palabra con guion bajo _
ejem: hola_mundo
------------------------------------------------------------
CONSTANTE = es un valor que nunca cambia y la constante siempre
va en lestras mayusculas
variable = nos ayuda a almacenar un valor y este puede variar
-------------------------------------------------------------
En python el listado de palabras reservadas es el siguiente:
False class is return
None continue lambda try
True def nonlocal while
and del not with
as elif or yield
assert else pass *
break except raise *
------------------------------------------------------------
operadores relacionales
mayor = >
menor = <
mayor_igual = >=
menor_igual = <=
igual = ==
diferente = !=
operadores logicos and, or y not = para sacra true (verdadero) y false (falso)
podemos usar la palabra --is-- para saber si tienen el mismo valor en la variable
puede ser palabras o numeros
-------------------------------------------------------------------
****funciones***
input()= agregar respuesta
int = para valores enteros
float = para valores no enteros
\n = ayuda a dar salto en lineas
# = para colocar comenarios en una sola linea
""" = colocar comentarios de mas de una linea (parrafo)
Se pueden usar “” dentro de las ‘ ’simples y viceversa
-----------------------------------------------------------------------
---------------------listas------------------------------------
las listas pueden almacenar cualquier tipo de elememto
lista(o nombres de la variable)=[]se usan corchetes
listas similares a los arreglos
pero pueden crecer o decrecer
indices y sublistas
Estas son las formas en las cuales podemos crear una nueva lista (sublistas) a partir de otra.
[:] Todos los elementos.
[start:] Todos los elementos desde el índice establecido(start).
[:end] Todos los elementos desde el índice cero hasta el índice establecido(end).
[start:end] Todos los elementos de un rango de índices.
[start:end:step] Todos los elementos de un rango de índices con saltos.
De igual forma, este listado es aplicable a las tuplas y los strings.
--------------------------tuplas-----------------------------
las tuplas son similares a las listas solo que estas no se pueden modificar.
las tuplas se usan con parentesis = tupla=()
las tuplas sus elementos se pueden separar por comas sin espacios
Desempaquetado de tuplas
Lo lees en 1 Min.
En ciertas ocasiones tendremos la necesidad de obtener algunos elementos de
nuestras tuplas, por ejemplo, teniendo la siguiente tupla.
tupla = (10, 20, 30, 40, 50)
Necesito obtener el primero, el segundo y el último elemento; Para lograr esto
tendremos un par de opciones; trabajando con índices y sin ellos. Veamos.
Si trabajamos con índices podemos hacerlo lo siguiente.
primero = tupla[0]
segundo = tupla[1]
ultimo = tupla[-1]
o simplemente podemos reducir las líneas de código y dejarlo en una sola.
primero, segundo, ultimo = tupla[0], tupla[1], tupla[-1]
La segunda opción es dejar de trabajar con las los índices y utilizar el guión bajo _ .
primero, segundo, _, _, ultimo = tupla
Como observamos he colocado dos guiones bajos que hacen referencia a el
número 30 y el número 40 , valores que no necesitamos, por en de, no necesito
almacenarlos en alguna variable; simplemente los ignoramos.
Ahora, que pasa si tengo una tupla mucho más grande y nuevamente necesito
obtener esos tres elementos (el primero, el segundo y el último).
tupla = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200,
300, 400)
Lo que podemos hacer es utilizar el guión bajo _ junto con el asterisco * y aplicar lo
que hemos visto anteriormente.
primero, segundo, *_, ultimo = tupla
De esta forma podemos trabajar de una forma más eficiente con las tuplas.
-----------------------------CADENA DE CARACTERES--------------------------------------------------
Manejo de texto
Strings: tipo de dato, son cadenas de caracteres los cuale ya tienen un orden definido
Se pueden trabajar de la misma manera que con las tuplas y listas con índices etc..
Son inmutables (no se pueden corregir) solo hacer nuevos apartir de un existente
Métodos para trabajar texto strings join y Split (ver ejemplos)
---------------------------FORMATOS-----------------------------------------------------------------------
texto.capitalize()
##dar formatos para distintas visualizacions pdf consola pagina web
## metodo capitalize
nos genera un string pero con la primer letra mayúscula
##metodo swapcase
## este metodo conviete de min a may y viceversa
texto = "curso de python 3"
resultado = texto.swapcase()
print(resultado)## nos genera un string pero con la primer letra mayuscula
###upper todas a mayusculas
###lower todas a minusculas
texto = "cuRso de Python 3"
resultado = texto.upper()
print(resultado)
texto = "cuRso de Python 3"
resultado = texto.lower()
print(resultado)
##si queremos saber si nuestro string se encuentra en mayusculas o minusculas
texto = "cuRso de Python 3"
resultado = texto.upper()
print(resultado.isupper())##nos regresa valores booleanos TRUE O FALSE
print(resultado.islower())
print(resultado)
##metodo title , formato de titulo
texto = "cuRso de Python 3"
resultado = texto.title()
print(resultado)
##metodo replace, remplaza uno por otro
## se nececsita dos valores el q se va remplazar y por el q se remplaza
texto = "cuRso de Python 3, Python Basico"
resultado = texto.replace("Python", "ruby")##cambiara todo lo que se encuentre con esa palabra
print(resultado)
##de igual manera podemos especificar cuantas veces queremos que remplace la palabra
## de la siguiente manera ejemplo
texto = "cuRso de Python 3, Python Basico"
resultado = texto.replace("Python", "ruby", 1)##solo va remplazar una sola vez
print(resultado)
curso = "python"
version = "3"
resultado = "curso de %s %s"%(curso, version) ## aqui lo que hacemos es imprimir
##lo que hay dentro de nuestras variables
##remplazando los %%
print (resultado)
################### otra forma
curso = "python"
version = "3"
resultado = "curso de {} {}".format(curso, version)
print (resultado)
##de esta sig forma no alteraremos el orden ya que respeta la de la variables
## y ademas nos ayuda a no confundirnos
##recomendado para el uso de diccionarios
curso = "python"
version = "3"
resultado = "curso de {a} {b}".format(b=version, a=curso)
print (resultado)
-----------------------------------------CONCATENAR-----------------------------------------------------------------------
## + esta funcion nos sirve ara unir mas strin en una sola salida
## es importante mencionar que si deseamos unir numeros float enteros y booleanos
## aesos van en () y con la palabra str
EJEMPLO:
curso = "Curso de python"
curso = "c" + curso [1:] + str(3)+ " " + "en codigo facilito."
print(curso)
----------------------------------BUSQUEDA DE CADENAS---------------------------------------------------------
##FORMAS DE COMO SABES SI UN STRING SE ENCUENTRA DENTRO DE OTRO
##
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.count("texto")
print(resultado)## nos va arrojar como resultado un 1
########################
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.count("a")
print(resultado)## nos va arrojar como resultado un 5
######################
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.count("z")
print(resultado)## nos va arrojar como resultado un 0
##############uso de la palabra reservada in
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = "texto" in mensaje
print(resultado)## nos va arrojar como resultado un valor booleano TRUE O FALSE
##########################
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = "texto" not in mensaje
print(resultado)## nos va arrojar como resultado un valor booleano TRUE O FALSE
####si quiero saber en que posicion se encuentra
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.find("texto")
print(resultado)## nos va arrojar como resultado un valor booleano TRUE O FALSE
####si quiero saber en que posicion se encuentra
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.find("codigo")
print(resultado)## nos va arrojar como resultado un valor -1 esto es debido a que no se encuentra
el string
##si queremos saber si un string empieza en otro
####si quiero saber en que posicion se encuentra
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.startswith("este")
print(resultado)## nos va arrojar como resultado un valor booleano TRUE O FALSE
####si quiero saber en que posicion se encuentra
mensaje = "este es un texto un poco grande en cuanto a longitud de caracteres se refiere"
resultado = mensaje.endswith("este")
print(resultado)## nos va arrojar como resultado un valor booleano TRUE O FALSE
-------------------------------------diccionarios-------------------------------------
## DICCIONARIOS ES UNA ESTRUCTURA
diccionario ={}
diccionario["nombre"]= "codi" ##para agregar una llave con su valor diccionario=[llave puede ser
tipo string o float entero etc]
valor = diccionario["nombre"] = 90 ###mandamos llamar el diccionario
print(diccionario)
print(valor)
Se manejan obre llaves y cada llave no puede tener valores duplicados asi que si se duplica este
solo reflejara el ultimo valor agregado
EJEMPLO
##########################3333333
diccionario = {"a":1, "b":2, "c":3, "a":4}
print(diccionario)
*************como encontrara si existe dentro del diccionario*******************
diccionario = {"1":1, "b":2, "c":3, "a":4} ##las llaves van en ""y dentro de {} en los diccionarios
resultado = diccionario["1"]## de esta manera mandamos a llamar el valor que se encuentra de
ese diccionario
print(resultado)
####encontrar una llave dentro de un diccionario
## utilizaremos la palabra in en el cual nos imprimira un valor boolenao
diccionario = {"1":1, "b":2, "c":3, "a":4}
resultado ="z" in diccionario
print(resultado)
##METODO RECOMENDADO
####otra forma es hacer uso del metodo get
##si la llave existe nos arroja su valor de lo contrario nos arrojara un valor None
diccionario = {"1":1, "b":2, "c":3, "a":4}
resultado = diccionario.get("a")
print(resultado)
### incluso con el metodo get podemos decidir si queremos nos arroje
##otro resultado que no se none ya que podemos modificarlo por un strong un bolleano entero
float lista
##ejemplo
diccionario = {"1":1, "b":2, "c":3, "a":4}
resultado = diccionario.get("z", "el valor no existe")
print(resultado)
##metodo set default
##este metodo nos ayuda arrojar el valor de la llave en caso de existir
##de lo contrario nos ayuda a generar una nueva llave y con un valor
diccionario = {"1":1, "b":2, "c":3, "a":4}
resultado = diccionario.setdefault("z", {})
print(resultado)
print(diccionario)
********************LLAVES ITEMS Y VALORES**************************************
## en ocasiones tendremos la necesidad de conocer que valores o llaves
##exiten en nuestro diccionario
##para ello existen 3 metodos
## 1
###obtener todas las llaves de nuestro diccionario
##diccionario.keys
diccionario = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8}
resultado = diccionario.keys()
print (resultado)
diccionario = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8}
resultado = diccionario.keys()
resultado = tuple(resultado) ##esto nos ayuda si queremos verlo en forma de tuples
print (resultado)
###obtener todas los valores de nuestro diccionario
##diccionario.values
diccionario = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8}
resultado = diccionario.values()
print (resultado)
###metodo items lo que nos ayuda es que nos separa mediante llaves y su valores
diccionario = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8}
resultado = diccionario.items()
print (resultado)
***********************ELIMINAR ELEMENTOS**************************************+
