Python Handout · ⁨Material de Python⁩

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.

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 错误.

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.

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)

• 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).

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:

• / siempre da un float, así que 4 / 2 es 2.0.
• // y % van juntos: 17 // 5 es 3, y 17 % 5 es 2.

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).

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

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.

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).

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

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):

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

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

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.

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.

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.

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

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

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

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.

Una lista 列表 holds many values in order, inside []. Each item 元素 has an index (from 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:

Para traversing 遍历 a list es visitar cada elemento. 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

A 2-D list 二维列表 es una lista de listas — una grid 网格 de filas y columnas. Usa dos índices: grid[row][col].

grid = [[1, 2, 3],
        [4, 5, 6]]
print(grid[0][2])     # 3
print(grid[1][0])     # 4

• A nested loop 嵌套循环 visita cada celda.

grid = [[1, 2], [3, 4]]
for row in grid:
    for value in row:
        print(value, end=" ")
print()               # 1 2 3 4

Una list comprehension 列表推导式 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]

Un tuple 元组 es una secuencia fija entre paréntesis redondos. No se puede cambiar después de su creación — úsalo para valores que pertenecen juntos, y desempaquetalo 解包 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 set 集合 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 no copia una lista: ambos nombres apuntan a la misma lista, por lo que cambiar uno cambia el otro. Usa a.copy() o a[:].
• 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].

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.

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.

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.

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

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.

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.

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 en tiempo de ejecución ocurre mientras el programa se ejecuta, como dividir por cero. Un error lógico se ejecuta pero da la respuesta incorrecta.

# 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 (traceback) mostrando dónde falló. Léalo de abajo hacia arriba.

Encierre el código riesgoso en try. Si falla, except captura la excepción y la maneja, en lugar de provocar una caída del sistema.

def to_int(text):
    try:
        return int(text)
    except ValueError:
        return 0

print(to_int("42"))    # 42
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

Una prueba verifica que el código produzca la respuesta correcta. Pruebe casos normales y casos límite — entrada vacía, cero, 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 no se cae con entradas extrañas; las maneja con elegancia.

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.

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

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.

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 se pueden 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 los detalles: usas largest(...) sin tener que releer cómo funciona internamente.

El pseudocódigo 伪代码 es un inglés estructurado y sencillo para describir 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 recuadro para cada paso, un rombo para cada decisión 判断, y flechas para indicar el orden.

La recursión 递归 ocurre cuando una función se llama a sí misma. Necesita un caso base 基准情形 (una entrada simple que devuelve inmediatamente) y un caso recursivo 递归情形 (se llama a sí misma con una entrada más pequeña).

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 a ella 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.

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)

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

stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack.pop())   # a

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

Una lista enlazada es una cadena de nodos. Cada nodo contiene datos y un puntero al siguiente nodo; el último apunta a 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

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.

table = {}
table["Mei"] = 88
table["Sam"] = 71
print(table["Mei"])   # 88  (fast lookup by key)

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.

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]

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.

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.

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

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]

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

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)

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.

Una clase 类 es una plantilla. Un objeto 对象 es algo construido a partir de ella (una instancia 实例). __init__ es el constructor 构造方法 que configura cada objeto; self es el propio objeto.

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 en 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

La herencia 继承 permite que una subclase 子类 reutilice una superclase 父类. Usa super() para llamar al padre; sobreescribe 重写 un método para cambiarlo.

class Animal:
    def speak(self):
        return "some sound"

class Cat(Animal):
    def speak(self):                # override
        return "meow"

print(Cat().speak())   # meow

El encapsulamiento 封装 oculta los datos detrás de métodos; un guion bajo inicial lo marca como privado 私有.

class Account:
    def __init__(self):
        self._balance = 0           # private
    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 con muchos comportamientos — el speak correcto se ejecuta 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

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 lista 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.

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.

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

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.

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.

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.

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.

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.

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.