Saltar al contenido
Temas
  • 1 Introducción
    1.1

    Tu primer programa

    Python ejecuta tu código línea por línea. Cada línea es una declaración 语句. Un programa 程序 es simplemente una lista de declaraciones que se ejecutan de arriba hacia abajo.

    La función print() muestra texto en la pantalla. Esto se denomina salida 输出. El texto entre comillas es una cadena 字符串.

    print("Hello, world!")
    print("I am learning Python")
    
    • Cada print() inicia una nueva línea.
    • Las comillas pueden ser "double" o 'single' — ambas crean una cadena.
    • Un programa no hace nada hasta que lo ejecutas.
    El código fuente pasa por el intérprete para producir salida
    El código fuente pasa por el intérprete para producir salida
    1.2

    Comentarios y estilo del código

    Un comentario 注释 comienza con #. Python ignora todo lo que hay después del # en esa línea. Los comentarios explican tu código a las personas; no cambian lo que hace el código.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    Un buen estilo hace que el código sea fácil de leer:

    • Usa nombres claros que indiquen qué significa un valor.
    • Coloca una declaración por línea.
    • No agregues espacios al inicio de una línea normal. En Python, los espacios al principio (indentación 缩进) tienen un significado especial, por lo que un espacio incorrecto provoca un error 错误.
    1.3

    Entrada, proceso, salida

    Muchos programas siguen un plan simple: entrada 输入 → proceso → salida. Obtienes datos, haces algo con ellos y luego muestras un resultado.

    La función input() lee el texto que el usuario escribe. Siempre devuelve una cadena.

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() espera a que el usuario escriba y presione Enter.
    • Almacena el texto escrito en una variable 变量 para poder usarlo más tarde.
    • Dado que input() devuelve una cadena, conviértela con int(...) primero si necesitas un número.

    Errores comunes

    • Olvidar las comillas: print(Hello) busca una variable llamada Hello y genera un NameError. El texto necesita comillas: print("Hello").
    • Un espacio suelto al inicio de una línea: Python interpreta la indentación como estructura, por lo que genera un IndentationError.
    • Asumir que input() devuelve un número. Siempre devuelve una cadena, así que envuélvela en int(...) antes de hacer cualquier cálculo matemático.
  • 2 Variables, tipos y operadores
    2.1

    Variables y asignación

    Una variable es un nombre para un valor. Se crea con =, que se llama asignación. El nombre va a la izquierda; el valor va a la derecha.

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    Ahora age contiene 17. Usa el nombre donde necesites el valor, y cámbialo más adelante:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    Una variable es un nombre vinculado a un valor almacenado
    Cada nombre de variable apunta a un valor en la memoria
    • El signo = no significa "igual". Significa "almacenar el lado derecho bajo el nombre del lado izquierdo".
    • Para probar si dos valores son iguales, usa == (ver abajo).
    2.2

    Números: int y float

    Python tiene dos tipos principales de números. Un entero (int) es un número completo como 17. Un punto flotante (float) tiene un punto decimal como 9.99.

    Estos operadores funcionan sobre números:

    Operador Significado Ejemplo Resultado
    + sumar 3 + 2 5
    - restar 3 - 2 1
    * multiplicar 3 * 2 6
    / dividir (siempre float) 7 / 2 3.5
    // división entera 7 // 2 3
    % residuo (módulo) 7 % 2 1
    ** potencia 2 ** 3 8
    • / siempre da un float, así que 4 / 2 es 2.0.
    • // y % van juntos: 17 // 5 es 3, y 17 % 5 es 2.
    2.3

    Expresiones y conversión de tipo

    Una expresión es cualquier cosa que tenga un valor, como 3 + 4 * 2. Python usa el orden matemático normal (* y / antes que + y -); añade paréntesis para que el orden sea claro.

    input() devuelve una cadena, así que conviértela antes de hacer matemáticas. Cambiar un valor de un tipo a otro es conversión de tipo:

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc") falla, así que solo convierte textos que parezcan números.
    • Mezclar tipos también falla: "age: " + 17 es un error; escribe "age: " + str(17).
    2.4

    Booleanos y comparación

    Un booleano es uno de solo dos valores: True o False. Una comparación devuelve un booleano.

    Operador Significado
    == igual a
    != distinto de
    < > menor que / mayor que
    <= >= menor o igual que / mayor o igual que
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    Une las comparaciones con and, or, not:

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    Errores comunes

    • / siempre da un float, incluso 4 / 2 es 2.0. Usa // cuando quieras un número entero.
    • Usar = donde querías usar ==: = asigna un valor, == prueba si dos valores son iguales.
    • Unir una cadena y un número: "age: " + 5 genera un TypeError. Convierte primero con str(5).
    • Los floats no son exactos, así que 0.1 + 0.2 no es exactamente 0.3 — evita usar == en resultados de float.
  • 3 Cadenas
    3.1

    Indexación

    Una cadena 字符串 es texto entre comillas. Cada carácter 字符 tiene una posición, llamada su índice 索引. El primer índice es 0, no 1.

    Lee un carácter con corchetes:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • La cuenta comienza en 0, por lo que el último índice es len(word) - 1.
    • Un índice negativo cuenta hacia atrás desde el final: word[-1] es el último carácter.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • Un índice demasiado grande produce un error 错误 (un IndexError).
    s[start:stop] es una ventana de caracteres semiabierta
    s[start:stop] es una ventana de caracteres semiabierta
    3.2

    Rebanado

    Un rebanado 切片 toma una parte de una cadena. Escribe word[start:end]. El rebanado mantiene start pero se detiene antes de end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • Omite start para comenzar en 0; omite end para ir hasta el final.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • Un tercer número es el paso 步长. word[::-1] invierte 反转 la cadena.
    print("Python"[::-1])   # nohtyP
    
    3.3

    Métodos de cadena y longitud

    Un método 方法 es una función que pertenece a un valor. Se llama con un punto:

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    Las cadenas son inmutables 不可变: un método devuelve una cadena nueva y nunca cambia la original 原始.

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    Métodos comunes (cada uno devuelve un nuevo valor):

    Método Significado Ejemplo Resultado
    .upper() / .lower() cambiar mayúsculas/minúsculas "Hi".lower() hi
    .strip() eliminar espacios en los bordes " hi ".strip() hi
    .replace(a, b) intercambiar texto "cat".replace("c", "b") bat
    .split(sep) dividir en una lista "a,b".split(",") ['a', 'b']

    Une cadenas con +. Esto se llama concatenación 拼接:

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    Cadenas f

    Una cadena f 格式化字符串 construye texto a partir de valores. Coloca f antes de la comilla, luego escribe {...} alrededor de un valor.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • Cualquier expresión 表达式 puede ir dentro de las llaves.
    • {value:.2f} redondea a 2 decimales 小数位.
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    Errores comunes

    • Las cadenas no se pueden modificar in situ: s[0] = "x" genera un error. En su lugar, construya una nueva cadena.
    • La indexación comienza en 0; el último carácter está en s[-1], y s[len(s)] está fuera de rango.
    • Un corte s[a:b] incluye a pero se detiene antes de b.
    • Los métodos de cadena devuelven una NUEVA cadena: s.upper() no hace nada a menos que almacene el resultado.
  • 4 Selección
    4.1

    if / elif / else

    Un programa elige qué hacer con if. Ejecuta un bloque con sangría solo cuando una condición es verdadera. La línea if termina con dos puntos.

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    Agrega elif (else-if) para más casos y else para "cualquier otra cosa". Python ejecuta la primera rama verdadera, luego salta al resto.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • Compara valores con == (igual a), != (diferente de), <, >, <=, >=.
    • Una comparación da un valor booleano — ya sea True o False.
    if / elif / else: solo se ejecuta una rama
    if / elif / else: solo se ejecuta una rama
    4.2

    Combinar condiciones

    Une condiciones con and, or, not. and requiere que ambos lados sean verdaderos; or requiere que al menos uno de los lados sea verdadero; not invierte un booleano.

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • Usa paréntesis para dejar claro el orden: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    Errores comunes

    • Escribe elif, no else if.
    • Cada línea if / elif / else termina con dos puntos :, y su cuerpo debe tener sangría.
    • if x = 5: es un error — usa == para comparar.
    • else no recibe ninguna condición; solo if y elif lo hacen.
  • 5 Iteración
    5.1

    bucles for y range

    Un bucle repite código. Un for bucle se repite una vez por cada elemento en una secuencia. range(n) genera los números 0 hasta n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) va desde a hasta (sin incluir) b.
    • range(a, b, step) añade un paso cada vez.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): el cuerpo se ejecuta con i = 0 … n-1
    for i in range(n): el cuerpo se ejecuta con i = 0 … n-1
    5.2

    El patrón acumulador

    Para construir un resultado a través de un bucle, inicia una variable antes del bucle, luego actualízala en cada vuelta. Este es el patrón acumulador.

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • La misma idea cuenta cuántos elementos coinciden con una prueba.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    Bucle while

    Un while bucle se repite mientras una condición permanezca verdadera. Cambia algo dentro, o nunca terminará —un bucle infinito.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break sale del bucle inmediatamente.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    Buces anidados

    Un bucle dentro de otro bucle es un bucle anidado. El bucle interno se ejecuta completamente por cada vuelta del bucle externo.

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    Errores comunes

    • range(n) va desde 0 hasta n - 1, no desde 1 hasta n —el clásico error off-by-one.
    • Modificar una lista mientras se itera sobre ella salta elementos; itera sobre una copia si debes eliminar cosas.
    • Olvidar cambiar la variable del bucle en un while hace que se ejecute para siempre.
    • La sangría decide qué está dentro del bucle; una línea mal sangrada se ejecuta solo una vez, después del bucle.
  • 6 Listas y listas 2-D
    6.1

    Listas

    Una lista contiene muchos valores en orden, dentro de []. Cada ítem tiene un índice (desde 0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • Change an item by its index: scores[1] = 100.
    • Una lista puede crecer y encogerse; una cadena de texto (string) no puede.

    The everyday list tools:

    Tool Does
    a.append(x) adds x at the end
    a.insert(i, x) inserts x at position i
    a.remove(x) removes the first x
    a.pop() / a.pop(i) removes and returns the last item / item i
    a.sort() sorts the list in place
    sorted(a) returns a NEW sorted list
    x in a is x in the list?
    len(a), sum(a), max(a), min(a) size and quick maths
    List indices start at 0
    Los índices de las listas comienzan en 0
    6.2

    Recorrer una lista

    Recorrer una lista es visitar cada ítem. Un bucle for hace esto sin necesidad de índice.

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • Use enumerate when you also need the index.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    Listas 2-D (cuadrículas)

    Una lista bidimensional 2-D es una lista de listas — una cuadrícula de filas y columnas. Use dos índices: grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • Un bucle anidado visita cada celda.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    Comprensiones de lista

    Una comprensión de lista construye una nueva lista en una sola línea: [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • Add if to keep only some items.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    Tuples y sets

    Una tupla es una secuencia fija entre paréntesis redondos. No puede cambiarse después de crearse — use uno para valores que pertenecen juntos, y despléguelo en nombres.

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    Una función que necesita devolver dos resultados devuelve un tuple:

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

    Un conjunto almacena cada valor una sola vez, sin orden. Es perfecto para eliminar duplicados y para pruebas rápidas de membresía.

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    Errores comunes

    • b = a comparte una misma lista. a.copy() o a[:] crean una nueva lista externa, pero los elementos mutables anidados siguen compartidos (copia superficial).
    • El último elemento es a[-1]; a[len(a)] está fuera de rango.
    • append añade UN solo elemento; usa extend o + para unir otra lista.
    • Construir una cuadrícula con [[0]*3]*3 crea tres copias de la misma fila. Construye las filas dentro de un bucle en su lugar.
    • Un tuple con un solo elemento necesita una coma: (5,), no (5).
    • Un set no tiene orden ni duplicados, por lo que no puedes indexarlo con s[0].
  • 7 Diccionarios
    7.1

    Diccionarios

    Un diccionario 字典 (dict) almacena pares de clave 键 → valor 值. Se busca un valor por su clave, no mediante un índice numérico.

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    Agregar y actualizar

    Asigne a una clave para agregarla o para modificar una existente.

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    Consultar y iterar

    Use in para verificar si existe una clave. Itere sobre las claves, o sobre .items() para obtener tanto la clave como el valor.

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • .get(key, default) devuelve un valor predeterminado 默认值 cuando falta la clave — sin generar error.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    El patrón clásico de examen: contar cuántas veces aparece cada valor:

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • .get(letter, 0) proporciona 0 la primera vez que se ve una clave, evitando así un KeyError.

    Errores comunes

    • Leer una clave inexistente con d[key] genera un KeyError; use d.get(key) o verifique primero if key in d.
    • Asignar d[key] nuevamente sobrescribe el valor anterior — las claves son únicas.
    • Las claves deben ser inmutables, como una cadena o un número — una lista no puede ser clave.
    A dictionary maps each key to one value
    Un diccionario mapea cada clave a un único valor
  • 8 Funciones y abstracción
    8.1

    Definir y llamar a funciones

    Una función es un bloque de código con nombre que puedes reutilizar. Defínela con def y llámala por su nombre.

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • El código dentro se ejecuta solo cuando llamas a la función.
    def define; call runs; return sends a value back
    def define; call runs; return sends a value back
    8.2

    Valores de retorno

    Una función puede devolver un valor con return. La llamada entonces equivale a ese valor.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return termina la función inmediatamente. Una función sin return devuelve None.
    8.3

    Parámetros, argumentos y ámbito

    Un parámetro es el nombre en la definición def. Un argumento es el valor que pasas.

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    Una variable creada dentro de una función es local: existe solo allí. Esa región es su ámbito.

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    Un parámetro puede tener un valor predeterminado, utilizado cuando quien llama omite el argumento:

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    Abstracción procedural

    La abstracción procedural significa ocultar detalles detrás de un nombre. Usas una función por su nombre y lo que hace, no por cómo funciona internamente.

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • Una buena función realiza una sola tarea, tiene un nombre claro y evita repetir código.
    8.5

    Módulos e importaciones

    Un módulo es un archivo de funciones predefinidas. Inclúyelo con import.

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    Errores comunes

    • Una función devuelve None a menos que escribas return. Imprimir no es lo mismo que devolver.
    • Nunca uses un valor predeterminado mutable como def f(x=[]): la misma lista se comparte entre todas las llamadas.
    • Una variable creada dentro de una función es local y no puede verse desde fuera.
    • Ejecuta una función con f(); escribir f solo le asigna un nombre pero no la ejecuta.
  • 9 Errores, excepciones y pruebas
    9.1

    Errores y depuración

    El código puede fallar de tres formas. Un error de sintaxis rompe las reglas de Python, por lo que nunca se ejecuta. Un error de tiempo de ejecución ocurre mientras se ejecuta, como dividir por cero. Un error lógico se ejecuta pero da la respuesta incorrecta.

    Errores comunes de Python: Sintaxis, Nombre, Tipo, Índice
    Errores comunes de Python: Sintaxis, Nombre, Tipo, Índice
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • Python imprime un rastreo de pila que muestra dónde falló. Léalo de abajo hacia arriba.
    9.2

    try / except / raise

    Coloque el código riesgoso dentro de try; si falla, except captura la excepción en lugar de provocar una caída del programa.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • Capture un tipo específico (ValueError, ZeroDivisionError, …).
    • raise genera su propio error a propósito.
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    Pruebas y robustez

    Una prueba verifica que el código produzca la respuesta correcta. Pruebe casos normales y casos extremos: entrada vacía, ceros, valores muy grandes.

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • El código robusto maneja entradas inusuales con elegancia en lugar de colapsar.

    Errores comunes

    • No use un except: sin especificar nada; capture el error específico, ej. except ValueError:.
    • Un error de sintaxis detiene todo el programa antes de que se ejecute, así que corríjalos primero.
    • Pruebe los casos límite (entrada vacía, cero, el valor más grande), no solo el fácil.
  • 10 Archivos
    10.1

    Lectura y escritura de archivos de texto

    Un archivo de texto 文本文件 almacena texto en el disco. Ábrelo con open(name, mode) donde mode 模式 indica leer o escribir. Siempre usa with, que cierra el archivo por ti.

    Escritura

    El modo "w" escribe un archivo nuevo y borra cualquier archivo anterior.

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    Lectura

    El modo "r" (el predeterminado) lee. .read() devuelve todo el archivo como una sola cadena.

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    Línea por línea

    Recorre el archivo para obtener una línea a la vez. .strip() elimina 去除 el salto de línea 换行符 al final.

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    Append

    El modo "a" appendea 追加 — añade al final sin borrar.

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    Mode Significado
    "r" read (predeterminado)
    "w" write (borra primero)
    "a" append (añadir al final)

    Errores comunes

    • Cierra siempre un archivo, o usa with open(...) as f: que lo cierra por ti.
    • read() da todo el archivo como una sola cadena, y cada línea aún termina con \n.
    • Abrir con "w" borra el archivo primero; usa "a" para añadir al final.
    open → read/write → close (with auto-closes)
    open → read/write → close (with auto-closes)
  • 11 Diseño de algoritmos
    11.1

    Algoritmos y descomposición

    Un algoritmo es una lista clara de pasos que resuelve un problema. La descomposición significa dividir un problema grande en partes más pequeñas que puedes resolver una a la vez.

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • La abstracción significa ignorar detalles: usas largest(...) sin volver a leer cómo funciona.
    11.2

    Pseudocódigo y diagramas de flujo

    La pseudocódigo es inglés plano y estructurado para un algoritmo, escrito antes del código real. No se ejecuta.

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

    Un diagrama de flujo dibuja el mismo plan: un cuadro para cada paso, un rombo para cada decisión y flechas para el orden.

    11.3

    Recursión y pila de llamadas

    La recursión es cuando una función se llama a sí misma. Necesita un caso base (una entrada simple que devuelva inmediatamente) y un caso recursivo (se llama a sí misma con una entrada más pequeña).

    La pila de llamadas para factorial(3): cada llamada espera, luego regresa en orden inverso
    La pila de llamadas para factorial(3): cada espera, luego retorna en orden inverso
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • Cada llamada pausada permanece en la pila de llamadas hasta que la llamada superior retorna.

    Errores comunes

    • La recursión necesita un caso base; de lo contrario, se llamará a sí misma indefinidamente y colapsará la pila de llamadas.
    • El pseudocódigo sirve para planificar — no necesita ejecutarse, pero cada paso debe ser inequívoco.
    • Divide un problema grande en pasos pequeños y nombrados antes de escribir cualquier código.
  • 12 Estructuras de datos
    12.1

    Tipos de Datos Abstractos (ADT)

    Un tipo de dato abstracto (ADT) describe datos junto con las operaciones sobre ellos, independientemente de cómo se implementen internamente. Se accede a él mediante sus operaciones, no a través de su almacenamiento interno.

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    Pilas (Stacks)

    Una pila es último-en, primero-salido (LIFO). Empujar (push) ocurre en la parte superior y popear (pop) también desde la parte superior.

    Una pila elimina desde la parte superior (LIFO); una cola elimina desde el frente (FIFO)
    Una pila elimina desde la parte superior (LIFO); una cola elimina desde el frente (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    Colas (Queues)

    Una cola es primero-en, primero-salido (FIFO). Encolar (enqueue) ocurre en la parte trasera y desencolar (dequeue) ocurre desde el frente.

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    Listas enlazadas

    Una lista enlazada es una cadena de nodos. Cada nodo contiene datos y un puntero al siguiente nodo; el último apunta a None.

    Una lista enlazada: cada nodo contiene datos y un puntero al siguiente nodo, terminando en None
    Una lista enlazada: cada nodo contiene datos y un puntero al siguiente nodo, terminando en None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    Tablas hash

    Una tabla hash mapea una clave a una ranura mediante una función hash. Dos claves pueden caer en la misma ranura — esto se denomina colisión. El tipo dict de Python es una tabla hash, por lo que la búsqueda es rápida.

    Una función hash mapea cada clave a una ranura; dos claves pueden colisionar en una misma ranura
    Una función hash mapea cada clave a una ranura; dos claves pueden colisionar en una misma ranura
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    Árboles binarios de búsqueda

    Un árbol binario de búsqueda (BST) mantiene un orden: cada hijo izquierdo es menor que su nodo, y cada hijo derecho es mayor. La búsqueda permanece rápida.

    Un árbol binario de búsqueda: los valores menores van a la izquierda, los mayores van a la derecha
    Un árbol binario de búsqueda: los valores menores van a la izquierda, los mayores van a la derecha
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    Grafos

    Un grafo es un conjunto de vértices unidos por aristas. Una lista de adyacencia — un diccionario de listas de vecinos — es una forma común de almacenarlo.

    Un grafo de vértices y aristas, con su forma de lista de adyacencia
    Un grafo de vértices y aristas, con su forma de lista de adyacencia
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    Errores comunes

    • Una pila es último-en-primer-salido; una cola es primero-en-primer-salido. No los confunda.
    • Verifique si una estructura está vacía antes de hacer pop o dequeue en ella.
    • En una lista enlazada, perder el puntero head (cabeza) hace perder toda la lista.
  • 13 Búsqueda, ordenamiento y eficiencia
    13.1

    Búsqueda lineal y binaria

    Una búsqueda busca dónde se encuentra un valor. La búsqueda lineal revisa cada elemento en secuencia, por lo que funciona con cualquier lista.

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

    La búsqueda binaria es mucho más rápida pero necesita una lista ordenada. Reduce a la mitad el rango en cada paso.

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    La búsqueda binaria reduce a la mitad el rango en cada paso — O(log n) en una lista ordenada
    La búsqueda binaria reduce a la mitad el rango en cada paso — O(log n) en una lista ordenada
    13.2

    Ordenamiento (burbuja e inserción)

    Ordenar es colocar los elementos en un orden específico. El ordenamiento burbuja intercambia repetidamente vecinos que están en el orden incorrecto.

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

    El ordenamiento por inserción construye una parte ordenada elemento a elemento, desplazando cada nuevo elemento hacia atrás hasta su lugar:

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • En código real, use sorted() de Python:
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    Eficiencia algorítmica

    La eficiencia pregunta cómo crece el trabajo conforme crece la entrada. Lo describimos con Big-O.

    Cómo crece el número de pasos con el tamaño de la entrada para las complejidades comunes
    Cómo crece el número de pasos con el tamaño de la entrada para las complejidades comunes
    Big-O Nombre Ejemplo
    $O(1)$ constante buscar una clave en un diccionario
    $O(\log n)$ logarítmica búsqueda binaria
    $O(n)$ lineal búsqueda lineal
    $O(n^2)$ cuadrática ordenamiento burbuja
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    Aleatoriedad y simulación

    El módulo random genera números aleatorios. Use una semilla para hacer que los resultados sean reproducibles. Una simulación ejecuta muchas pruebas aleatorias para estimar una respuesta.

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    Errores comunes

    • La búsqueda binaria solo funciona en una lista ordenada.
    • Big-O indica cómo crece el tiempo, no el tiempo exacto; un método O(n²) supera a uno O(n) solo para entradas muy pequeñas.
    • El ordenamiento burbuja es O(n²) — adecuado para aprender, pero lento en listas grandes.
  • 14 POO y paradigmas
    14.1

    Clases y objetos

    Una clase es un plano. Un objeto es una entidad construida a partir de él (una instancia). __init__ es el constructor que configura cada objeto; self es el objeto en sí.

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name es un atributo (datos sobre el objeto); speak es un método (una acción).

    Agrega __str__ para controlar lo que muestra print(obj):

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    Una clase es una plantilla; al llamarla se crea un objeto
    Una clase es una plantilla; al llamarla se crea un objeto
    14.2

    Herencia, encapsulamiento y polimorfismo

    La herencia permite que una subclase reutilice una superclase. Usa super() para llamar al padre; sobreescribe un método para modificarlo.

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

    El encapsulamiento agrupa datos con métodos y expone una interfaz deseada. En Python, un guion bajo inicial marca por convención un nombre no público (a menudo llamado privado); esto no impide que el código externo lo acceda. El enmascaramiento de nombres con doble guion bajo ayuda a evitar colisiones accidentales en subclases, no a garantizar seguridad.

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

    El polimorfismo significa un mismo nombre, muchos comportamientos: se ejecuta el speak correcto para cada objeto.

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    Paradigmas de programación

    Un paradigma es un estilo de escribir programas. El código procedural es una secuencia de pasos y funciones. El código orientado a objetos agrupa datos y métodos en objetos. El código declarativo dice qué quieres, no cómo (una comprensión de listas o SQL).

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    Errores comunes

    • Todo método necesita self como su primer parámetro.
    • __init__ configura un nuevo objeto y se ejecuta automáticamente al crearlo.
    • Dos objetos de la misma clase tienen atributos separados; modificar uno no modifica el otro.
  • 15 Representación de datos
    15.1

    Bits y binario

    Un bit (比特) es un único 0 o 1. El binario (二进制) es el sistema numérico de base 2: cada posición vale el doble que la de su derecha (1, 2, 4, 8, …). El decimal (十进制) son nuestros números habituales.

    Valores posicionales binarios: 1101 significa 8 + 4 + 1 = 13
    Valores posicionales binarios: 1101 significa 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 bits forman un byte (字节). Un ancho fijo puede desbordarse (溢出) (dar la vuelta al número) cuando este es demasiado grande.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    El hexadecimal (十六进制) (base 16) es una forma compacta de leer binario: un dígito hexadecimal equivale exactamente a cuatro bits. Python escribe hexadecimales con 0x:

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    Compresión

    La compresión (压缩) hace que los datos sean más pequeños. La compresión sin pérdida (无损) conserva todos los bits, por lo que se reconstruye el original exactamente. La compresión con pérdida (有损) descarta detalles —es más pequeña pero no exacta— y se utiliza para fotos y música.

    La codificación por recuento de secuencias (游程编码) es un método simple sin pérdida: almacena una secuencia (游程) (una repetición) como un contador más el valor.

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    Errores comunes

    • n bits almacenan 2**n valores diferentes, desde 0 hasta 2**n - 1.
    • La compresión con pérdida elimina detalles y no puede revertirse; la compresión sin pérdida se puede invertir exactamente.
  • 16 Conceptos de computación
    16.1

    ¿Qué es la computación y el ciclo de diseño

    La computación significa resolver problemas con computadoras: entrada, procesamiento y salida. El buen software se construye mediante un ciclo de diseño —planificar, escribir, probar, mejorar— que se repite muchas veces.

    • Descomponga un problema, construya una parte pequeña, pruébela y luego agregue más.
    • Los programadores trabajan en equipos y reutilizan el código de sus compañeros.
    16.2

    Internet

    Internet es una red de redes. Los datos se dividen en paquetes que viajan por separado y se reconstruyen en el extremo destino. Reglas compartidas llamadas protocolos (como TCP/IP) hacen posible esto. Si se interrumpe una ruta, los paquetes toman otra trayectoria; esto es redundancia, lo que otorga tolerancia a fallos.

    Un mapa de Internet: cada línea representa una ruta entre dos redes
    Un mapa de Internet: cada línea representa una ruta entre dos redes
    Capa Función
    HTTP solicitar y enviar páginas web
    TCP entrega confiable, en orden
    IP direccionamiento y enrutamiento
    16.3

    Computación paralela y distribuida

    El código secuencial ejecuta un paso a la vez. La computación paralela realiza varios pasos simultáneamente en múltiples núcleos, lo que puede generar una aceleración. La computación distribuida reparte la carga de trabajo entre varias computadoras, como las de una nube.

    • No todo puede ejecutarse en paralelo: algunos pasos deben esperar un resultado previo.
    16.4

    Impacto de la computación

    La computación conlleva tanto beneficios como perjuicios. La brecha digital significa que no todos tienen acceso igualitario a ella. El software puede transmitir sesgos derivados de los datos con los que aprende. Respete la propiedad intelectual (licencias), y proteja los datos personales y la privacidad de las personas.

    Errores comunes

    • Internet y World Wide Web no son lo mismo: la Web es un servicio que funciona sobre Internet.
    • Más núcleos del procesador solo ayudan si la tarea puede dividirse en partes que se ejecuten al mismo tiempo.
  • 17 Poniéndolo en práctica
    17.1

    Mini-proyectos de extremo a extremo

    Un mini-proyecto 小项目 combina ideas anteriores: datos en una lista, una función con selección dentro de un bucle y salida impresa. Esta también es la estructura de la Tarea de Rendimiento del AP Create.

    Proyecto: nota media

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    Proyecto: contar aprobados

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    Proyecto: filtrar a una nueva lista

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

    La tarea AP Create pide una lista, un procedimiento parametrizado 过程 que utilice selección 选择 e iteración 迭代, y alguna entrada/salida. Cada uno de los proyectos anteriores tiene exactamente esa estructura: construye piezas pequeñas y luego únelas.

    Errores comunes

    • Construye paso a paso y prueba cada parte antes de pasar a la siguiente; no escribas todo de una vez.
    • Lee toda la tarea primero, luego planifica la entrada → proceso → salida antes de escribir el código.
    Mini-proyecto: datos → función → resultado impreso
    Mini-proyecto: datos → función → resultado impreso

Iniciar sesión o crear cuenta

IGCSE, A-Level & AP