Esta página necesita un navegador reciente (con soporte para SharedArrayBuffer). Por favor, actualiza Chrome, Edge, Firefox o Safari a la última versión.
1Introducció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
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.
2Variables, 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)
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.
Una comparación da un valor booleano — ya sea True o False.
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.
5Iteració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
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.
6Listas 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
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]]
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:
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].
7Diccionarios
7.1
Diccionarios
Un diccionario 字典 (dict) almacena pares de clave 键 → valor 值. Se busca un valor por su clave, no mediante un índice numérico.
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.
El código dentro se ejecuta solo cuando llamas a la función.
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.
9Errores, 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
# 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.
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.
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.
10Archivos
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)
11Diseñ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 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.
12Estructuras 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)
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
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
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
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
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.
13Bú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
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
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.
14POO 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
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.
15Representació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.
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:
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.
16Conceptos 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
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.
17Ponié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.
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