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