Practica de Python
- Diana Carolina Pérez Acosta
1. Enteros y flotantes: Define dos variables, una con un número entero y otra con un número
flotante. Luego, realiza las operaciones de suma, resta, multiplicación y división entre ellas.
Imprime los resultados.
a=5
b = 3.2
print(a + b)
print(a - b)
print(a * b)
print(a / b)
In
Output
2. Strings: Define una variable con tu nombre y otra con tu apellido. Combina ambas
variables para imprimir tu nombre completo.
nombre = "Juan"
apellido = "Perez"
nombre_completo = nombre + " " + apellido
print(nombre_completo)
In
Output
3. Strings: Toma un string largo y utiliza el método de string `.split()` para dividirlo en una lista
de palabras. Después, utiliza `.join()` para unirlo de nuevo.
texto = "Este es un texto de ejemplo"
palabras = texto.split()
texto_reconstruido = ' '.join(palabras)
print(texto_reconstruido)
In
Output
4. Ejercicio de listas: Crea una lista con los nombres de tus tres películas favoritas. Luego,
añade una cuarta película a la lista usando el método `.append()`.
peliculas = ["Titanic", "Avatar", "Inception", “x”]
peliculas.append({‘s’:gy})
print(peliculas)
In
Output
5. Listas avanzado: Crea una lista con los números del 1 al 10. Luego, utiliza slicing para
obtener los primeros 5 números.
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
primeros_cinco = numeros[:5]
print(primeros_cinco)
In
Output
6. Diccionarios: Crea un diccionario que contenga información sobre una persona: nombre,
edad y ciudad en la que vive. Luego, imprime el valor asociado a 'ciudad'.
persona = {"nombre": "Ana", "edad": 20, "ciudad": "Ibague"}
print(persona["ciudad"])
In
Output
7. Diccionarios: Modifica el diccionario del ejercicio anterior para añadir un nuevo par clave-
valor: 'ocupación' y tu ocupación.
persona["ocupacion"] = "Ingeniera"
print(persona)
In
Output
8. Booleanos: Escribe una expresión que compare dos números y devuelva un valor
booleano. Por ejemplo, puedes comprobar si un número es mayor, menor o igual que otro
número.
a=5
b=7
print(a < b)
In
Output
9. Conversión de tipos: Toma una lista de strings que representan números ("1", "2", "3", etc.)
y conviértelos en enteros o flotantes utilizando la función `int()` o `float()`.
lista_strings = ["1", "2", "3"]
lista_enteros = [int(numero) for numero in lista_strings]
print(lista_enteros)
In
Output
10. Ejercicio integrado: Crea un programa que solicite al usuario ingresar su nombre (string),
edad (entero) y altura (flotante). Almacena estos datos en un diccionario y luego imprime
el diccionario.
nombre = input("Introduce tu nombre: ")
edad = int(input("Introduce tu edad: "))
altura = float(input("Introduce tu altura (en metros): "))
datos_usuario = {"nombre": nombre, "edad": edad, "altura": altura}
print(datos_usuario)
In
Output
En Python, los strings (cadenas de texto) tienen varias funciones o métodos integrados que puedes
usar para manipular y trabajar con ellos. En bioinformática, estos métodos son particularmente
útiles para trabajar con secuencias de ADN, ARN y proteínas.
11. Método upper(): Convierte todos los caracteres de un string a mayúsculas. En
bioinformática, a menudo se utiliza para normalizar las secuencias de ADN o proteínas.
dna_seq = "atgc"
dna_seq = dna_seq.upper()
print(dna_seq) # Imprime: ATGC
In
Output
12. Método lower(): Convierte todos los caracteres de un string a minúsculas. También se usa
para normalizar las secuencias.
dna_seq = "ATGC"
dna_seq = dna_seq.lower()
print(dna_seq) # Imprime: atgc
In
Output
13. Método replace (old, new): Reemplaza todas las ocurrencias de una subcadena por otra.
Este método puede usarse, por ejemplo, para transcribir una secuencia de ADN a ARN.
dna_seq = "ATGC"
rna_seq = dna_seq.replace('T', 'U')
print(rna_seq) # Imprime: AUGC
In
Output
14. Método count(substring): Cuenta las ocurrencias de una subcadena dentro del string. Esto
puede usarse para contar la frecuencia de ciertos nucleótidos o aminoácidos.
dna_seq = "ATGCGC"
a_count = dna_seq.count('A')
print(a_count) # Imprime: 1
ppp.. calcule el porcentaje de G y C de una secuencia de ADN.
In
Output
15. Método find(substring): Encuentra la primera ocurrencia de una subcadena y devuelve su
índice. Si la subcadena no se encuentra, devuelve -1. Esto puede usarse para encontrar la
primera ocurrencia de un patrón en una secuencia.
dna_seq = "ATGCGC"
start_codon_index = dna_seq.find('ATG')
print(start_codon_index) # Imprime: 0
In
Output
16. Método split(delimiter): Divide un string en una lista de substrings utilizando un
delimitador especificado. En bioinformática, esto puede usarse para separar secuencias o
datos en un archivo de texto.
fasta_header = ">seq1|organism|gene"
header_parts = fasta_header.split('|')
print(header_parts) # Imprime: ['>seq1', 'organism', 'gene']
In
Output
17. Traducción de codones a aminoácidos:
En la traducción genética, los codones (grupos de 3 nucleótidos) se traducen a aminoácidos.
Puedes usar un diccionario para representar el código genético, luego usar un bucle y slicing para
traducir una secuencia de ADN en una secuencia de proteínas.
codon_table = {
"ATA": "I", "ATC": "I", "ATT": "I", "ATG": "M",
"ACA": "T", "ACC": "T", "ACG": "T", "ACT": "T",
"AAC": "N", "AAT": "N", "AAA": "K", "AAG": "K",
"AGC": "S", "AGT": "S", "AGA": "R", "AGG": "R",
"CTA": "L", "CTC": "L", "CTG": "L", "CTT": "L",
"CCA": "P", "CCC": "P", "CCG": "P", "CCT": "P",
"CAC": "H", "CAT": "H", "CAA": "Q", "CAG": "Q",
"CGA": "R", "CGC": "R", "CGG": "R", "CGT": "R",
"GTA": "V", "GTC": "V", "GTG": "V", "GTT": "V",
"GCA": "A", "GCC": "A", "GCG": "A", "GCT": "A",
"GAC": "D", "GAT": "D", "GAA": "E", "GAG": "E",
"GGA": "G", "GGC": "G", "GGG": "G", "GGT": "G",
"TCA": "S", "TCC": "S", "TCG": "S", "TCT": "S",
"TTC": "F", "TTT": "F", "TTA": "L", "TTG": "L",
"TAC": "Y", "TAT": "Y", "TAA": "_", "TAG": "_",
"TGC": "C", "TGT": "C", "TGA": "_", "TGG": "W",
dna_seq = "ATGGCGCGTATGAATAGCAATCCGAGCGTAA"
# La secuencia debe ser múltiplo de 3
if len(dna_seq) % 3 == 0:
protein_seq = ""
for i in range(0, len(dna_seq), 3):
codon = dna_seq[i:i+3]
protein_seq += codon_table[codon]
print(protein_seq)
else:
print("La secuencia no es múltiplo de 3")
In
Output
18. Contando el contenido de GC:
El contenido de GC (guanina y citosina) es un importante indicador en estudios de genómica y
bioinformática. Se puede calcular fácilmente usando los métodos de string en Python.
dna_seq = "ATGGCGCGTATGAATAGCAATCCGAGCGTAA
In
Output
Bucles en python
Los ciclos, o bucles, son una parte fundamental de la programación. En Python, los dos tipos
principales de bucles son `for` y `while`.
19. Bucle for: Es un tipo de ciclo que itera sobre una secuencia (que puede ser una lista, una
tupla, un diccionario, un conjunto o una cadena). Este tiene una variable que cambia su
valor a cada elemento de la secuencia en cada iteración del bucle.
# Iterar sobre una lista
for i in [1, 2, 3, 4, 5]:
print(i)
En el ejemplo anterior, `i` toma el valor de cada elemento en la lista `[1, 2, 3, 4, 5]` en cada
iteración del bucle. Primero `i` es 1, luego 2, luego 3, y así sucesivamente hasta que la lista se
agote.
# Calcular la longitud de varias secuencias de ADN
dna_sequences = ["ATGCGTA", "ATCGT", "ATCGTAGCTA"]
for seq in dna_sequences:
print(len(seq))
En este ejemplo, `seq` toma el valor de cada secuencia en la lista `dna_sequences` en cada
iteración del bucle.
In
Output
20. Bucle while: Este bucle se ejecuta mientras se cumpla una condición determinada.
# Imprimir números del 1 al 5
i=1
while i <= 5:
print(i)
i += 1
En el ejemplo anterior, el bucle `while` continúa mientras `i` sea menor o igual a 5. Dentro del
bucle, incrementamos `i` en 1 en cada iteración.
In
Output
21. Bucle while (find seq)
# Buscar una secuencia hasta que se encuentre un codón de parada.
https://pythontutor.com/visualize.html#mode=edit
dna_sequence = "ATCGTAGCTTAGTATAGCTA"
i=0
while dna_sequence[i:i+3] != "TAG":
i += 3
print("El codón de parada se encuentra en la posición:", i)
In
Output
## Condicionales
Los condicionales en Python son una forma de controlar el flujo de tu programa. Permiten que tu
código tome decisiones y realice diferentes acciones dependiendo de si se cumple una condición
específica. Las instrucciones condicionales en Python se crean usando las palabras clave `if`, `elif`
(abreviatura de "else if") y `else`.
22. if: Ejecuta un bloque de código si una condición es verdadera.
edad = 18..000000………………………..
…..
if edad >= 18:
print("Eres mayor de edad")
In
Output
dna_seq = "ATGCGTAC"
if "ATG" in dna_seq:
print("La secuencia contiene un codón de inicio")
In
Output
23. elif: Proporciona una nueva condición que se verifica solo si las condiciones anteriores no
fueron verdaderas.
edad = 16
if edad >= 18:
print("Eres mayor de edad")
elif edad < 18:
print("Eres menor de edad")
In
Output
codon = "ATG"
if codon == "ATG":
print("Este es un codón de inicio")
elif codon == "TAG":
print("Este es un codón de parada")
In
Output
24. else: Se ejecuta un bloque de código si ninguna de las condiciones anteriores es verdadera.
edad = 15ATA
if edad >= 18:
print("Eres mayor de edad")
else:
print("Eres menor de edad")
In
Output
codon = "AGT"
if codon == "ATG":
print("Este es un codón de inicio")
elif codon == "TAG":
print("Este es un codón de parada")
else:
print("Este es un codón regular")
In
Output
Recuerda que las condiciones en los condicionales de Python pueden ser tan complejas como
necesites, utilizando operadores lógicos (`and`, `or`, `not`) y comparativos (`==`, `!=`, `<`, `>`, `<=`,
`>=`).
## leer y escribir archivos
Los archivos FASTA son un formato común para secuencias de ADN, ARN y proteínas. Típicamente,
contienen una línea de encabezado que comienza con un carácter ">" seguido por información
identificativa, y luego líneas de secuencia.
25. Contar el número de secuencias en un archivo FASTA
# Contar el número de secuencias en un archivo FASTA
sequence_count = 0
with open("sequences.fasta", "r") as fasta_file:
for line in fasta_file:
if line.startswith(">"):
sequence_count += 1
print(f"El archivo contiene {sequence_count} secuencias.")
En este ejemplo, se abre el archivo FASTA para lectura ("r") y luego se lee línea por línea. Si una
línea comienza con ">", se considera el inicio de una nueva secuencia, y se incrementa el contador
de secuencias.
In
Output
26. Filtrar secuencias de un archivo FASTA basándose en su longitud
# Filtrar secuencias de un archivo FASTA que son mayores a una cierta longitud
min_length = 500
with open("sequences.fasta", "r") as fasta_file, open("filtered_sequences.fasta", "w") as
output_file:
sequence = ""
for line in fasta_file:
if line.startswith(">"):
if sequence and len(sequence) >= min_length:
output_file.write(header + sequence)
header = line
sequence = ""
else:
sequence += line.strip()
if sequence and len(sequence) >= min_length:
output_file.write(header + sequence)
In
Output
27. Genere una archivo fasta
# Define tu secuencia de ADN
secuencia_dna = "AGTACACTGGT"
# Define un identificador y descripción para la secuencia
id_secuencia = "mi_secuencia"
descripcion = "Esta es mi secuencia de ADN"
# Crea la cadena del encabezado en formato FASTA
encabezado = f">{id_secuencia} {descripcion}\n"
# Combina el encabezado y la secuencia de ADN
secuencia_fasta = encabezado + secuencia_dna + "\n"
# Escribe la secuencia en un archivo en formato FASTA
with open("mi_secuencia.fasta", "w") as archivo:
archivo.write(secuencia_fasta)
# input en la terminal
Puedes usar la función `input()` para leer datos desde la terminal en Python. A continuación, te
dejo un script que lee un identificador y una descripción desde la terminal, genera una secuencia
de ADN aleatoria y guarda la secuencia en un archivo FASTA:
In
Output
28. import random
# Define las bases posibles en el ADN
bases = ['A', 'T', 'C', 'G']
# Genera una secuencia aleatoria de 200 bases
secuencia_dna = ''.join(random.choice(bases) for _ in range(200))
# Lee un identificador y descripción para la secuencia desde la terminal
id_secuencia = input("Por favor, introduce un identificador para la secuencia: ")
descripcion = input("Por favor, introduce una descripción para la secuencia: ")
# Crea la cadena del encabezado en formato FASTA
encabezado = f">{id_secuencia} {descripcion}\n"
# Combina el encabezado y la secuencia de ADN
secuencia_fasta = encabezado + secuencia_dna + "\n"
# Escribe la secuencia en un archivo en formato FASTA
with open("mi_secuencia.fasta", "w") as archivo:
archivo.write(secuencia_fasta)
Cuando ejecutes este script, te pedirá que introduzcas un identificador y una descripción para la
secuencia. Luego, generará una secuencia aleatoria de ADN y la guardará en un archivo FASTA.
In
Output
