Python Handout · ⁨Anotação Python⁩

Python executa seu código uma linha por vez. Cada linha é uma declaração 语句. Um programa 程序 é apenas uma lista de declarações que rodam de cima para baixo.

A função print() exibe texto na tela. Isso é chamado output 输出. Texto entre aspas é uma string 字符串.

print("Hello, world!")
print("I am learning Python")

• Cada print() inicia uma nova linha.
• As aspas podem ser simples "double" ou duplas 'single' — ambas criam uma string.
• Um programa não faz nada até você executá-lo.

Um comentário 注释 começa com #. Python ignora tudo depois do # naquela linha. Comentários explicam seu código para pessoas; eles não mudam o que o código faz.

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

Bom estilo torna o código fácil de ler:

• Use nomes claros que digam o que um valor significa.
• Coloque uma declaração por linha.
• Não adicione espaços no início de uma linha normal. Em Python, espaçamento no início (indentation 缩进) tem um significado especial, então um espaço errado gera um erro 错误.

Muitos programas seguem um plano simples: entrada 输入 → processo → saída. Você obtém alguns dados, faz algo com eles, depois mostra um resultado.

A função input() lê o texto que o usuário digita. Ela sempre retorna uma string.

name = input("What is your name? ")
print("Hello, " + name)

• input() espera o usuário digitar e pressionar Enter.
• Armazene o texto digitado em uma variável 变量 para usá-la depois.
• Como input() retorna uma string, altere-a com int(...) primeiro se precisar de um número.

Erros comuns

• Esquecer as aspas: print(Hello) procura uma variável chamada Hello e levanta um NameError. Texto precisa de aspas: print("Hello").
• Um espaço solto no início de uma linha: Python lê a indentação como estrutura, então levanta um IndentationError.
• Assumir que input() retorna um número. Ela sempre retorna uma string, então envolva-a em int(...) antes de fazer qualquer matemática.

Uma variável 变量 é um nome para um valor 值. Você cria uma com =, que é chamado de atribuição 赋值. O nome vai à esquerda; o valor vai à direita.

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

Agora age contém 17. Use o nome onde quer que precise do valor, e altere-o depois:

age = 17
age = age + 1   # age is now 18
print(age)

• O sinal = não significa "igual". Significa "armazenar o lado direito sob o nome da esquerda".
• Para testar se dois valores são iguais, use == (veja abaixo).

Python tem dois tipos principais de números. Um inteiro 整数 (int) é um número inteiro como 17. Um float 浮点数 (float) tem ponto decimal como 9.99.

Estes operadores 运算符 funcionam em números:

• / sempre dá um float, então 4 / 2 é 2.0.
• // e % andam juntos: 17 // 5 é 3, e 17 % 5 é 2.

Uma expressão 表达式 é qualquer coisa que tem um valor, como 3 + 4 * 2. Python usa a ordem matemática normal (* e / antes de + e -); adicione parênteses para deixar a ordem clara.

input() retorna uma string, então converta-a antes de fazer matemática. Mudar um valor de um tipo para outro é conversão 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") falha, então converta apenas texto que pareça um número.
• Misturar tipos também falha: "age: " + 17 é um erro; escreva "age: " + str(17).

Um Boolean 布尔值 é um de apenas dois valores: True ou False. Uma comparação 比较 retorna um Boolean.

print(7 > 2)        # True
print(3 == 3.0)     # True
age = 20
print(age >= 18)    # True

Junte comparações com and, or, not:

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

Erros comuns

• / sempre dá um float, mesmo 4 / 2 sendo 2.0. Use // quando quiser um número inteiro.
• Usar = onde quer dizer ==: = atribui um valor, == testa se dois valores são iguais.
• Juntar uma string e um número: "age: " + 5 levanta um TypeError. Converta primeiro com str(5).
• Floats não são exatos, então 0.1 + 0.2 não é exatamente 0.3 — evite == em resultados float.

Uma string 字符串 é texto entre aspas. Cada caractere 字符 tem uma posição, chamada seu índice 索引. O primeiro índice é 0, não 1.

Leia um caractere com colchetes:

word = "Python"
print(word[0])    # P  (the first character)
print(word[2])    # t
print(len(word))  # 6  (how many characters)

• A contagem começa em 0, então o último índice é len(word) - 1.
• Um índice negativo conta de trás para frente: word[-1] é o último caractere.

word = "Python"
print(word[-1])   # n
print(word[-2])   # o

• Um índice muito grande dá um erro 错误 (um IndexError).

Um slice 切片 pega uma parte de uma string. Escreva word[start:end]. O slice mantém start mas para antes de end.

word = "Python"
print(word[0:3])   # Pyt   (positions 0, 1, 2)
print(word[2:5])   # tho

• Deixe fora start para começar em 0; deixe fora end para ir até o fim.

word = "Python"
print(word[:3])    # Pyt
print(word[3:])    # hon

• Um terceiro número é o step 步长. word[::-1] inverte 反转 a string.

print("Python"[::-1])   # nohtyP

Um método é uma função pertencente a um valor. Você o chama com um ponto:

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

Cadeias de caracteres são imutáveis: um método retorna uma nova cadeia e nunca altera a original.

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

Métodos comuns (cada um retorna um novo valor):

Junte cadeias usando +. Isso se chama concatenação:

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

Uma f-string constrói texto a partir de valores. Coloque f antes da aspa, depois escreva {...} ao redor de um valor.

name = "Mei"
age = 17
print(f"{name} is {age} years old")   # Mei is 17 years old

• Qualquer expressão pode ficar dentro das chaves.
• {value:.2f} arredonda para 2 casas decimais.

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

Erros comuns

• Cadeias não podem ser alteradas no local: s[0] = "x" gera um erro. Construa uma nova cadeia em vez disso.
• A indexação começa em 0; o último caractere é s[-1], e s[len(s)] está fora do intervalo.
• Um fatiamento s[a:b] inclui a mas para antes de b.
• Métodos de string retornam UMA NOVA string: s.upper() não faz nada a menos que você armazene o resultado.

Um programa escolhe o que fazer com base em if. Ele executa um bloco indentado apenas quando uma condição é verdadeira. A linha if termina com dois-pontos.

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

Adicione elif (else-if) para mais casos e else para "qualquer outra coisa". Python executa apenas o primeiro ramo verdadeiro e ignora os demais.

score = 72
if score >= 80:
    print("A")
elif score >= 60:
    print("B")
else:
    print("fail")
# B

• Compare valores com == (igual a), != (diferente de), <, >, <=, >=.
• Uma comparação resulta em um valor Booleano — ou seja, True ou False.

Junte condições com and, or, not. and exige que ambos os lados sejam verdadeiros; or exige que qualquer lado seja verdadeiro; not inverte um Boolean.

age = 16
has_ticket = True
if age >= 18 and has_ticket:
    print("entry allowed")
else:
    print("entry refused")
# entry refused

• Use parênteses para deixar a ordem clara: (a or b) and c.

temp = 30
if temp > 25 and not temp > 35:
    print("warm but ok")
# warm but ok

Erros comuns

• Escreva elif, não else if.
• Cada linha if / elif / else termina com dois-pontos :, e seu corpo deve estar indentado.
• if x = 5: é um erro — use == para comparar.
• else não requer condição; apenas if e elif exigem.

Um laço repete código. Um laço for repete uma vez para cada item em uma sequência. range(n) gera os números 0 até n - 1.

for i in range(5):
    print(i)
# 0, then 1, 2, 3, 4 (each on its own line)

• range(a, b) vai de a até (mas sem incluir) b.
• range(a, b, step) adiciona um passo a cada iteração.

for n in range(2, 11, 2):
    print(n)        # 2 4 6 8 10

Para construir um resultado ao longo de um laço, inicie uma variável antes do laço e atualize-a a cada volta. Este é o padrão acumulador.

total = 0
for n in range(1, 6):
    total = total + n
print(total)        # 15

• A mesma ideia serve para contar quantos itens atendem a um teste.

count = 0
for letter in "banana":
    if letter == "a":
        count = count + 1
print(count)        # 3

Um laço while repete enquanto uma condição permanece verdadeira. Altere algo dentro dele, ou ele nunca terminará — um laço infinito.

n = 1
while n <= 3:
    print(n)
    n = n + 1
# 1 2 3

• break sai do laço imediatamente.

total = 0
while True:
    total = total + 10
    if total >= 30:
        break
print(total)        # 30

Um laço dentro de outro é um laço aninhado. O laço interno executa totalmente para cada volta do laço externo.

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

Erros comuns

• range(n) vai de 0 a n - 1, não de 1 a n — o clássico erro off-by-one.
• Alterar uma lista enquanto itera sobre ela pula itens; itere sobre uma cópia se precisar remover coisas.
• Esquecer de alterar a variável do laço em um while faz com que ele execute para sempre.
• A indentação determina o que está dentro do laço; uma linha mal indentada executa apenas uma vez, após o laço.

Uma lista 列表 mantém muitos valores em ordem, dentro de []. Cada item 元素 tem um índice (começando em 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]

• Altere um item pelo seu índice: scores[1] = 100.
• Uma lista pode crescer e encolher; uma cadeia não pode.

As ferramentas de lista cotidianas:

Percorrer uma lista é visitar cada item. Um laço for faz isso sem necessidade de índice.

scores = [88, 71, 95]
total = 0
for s in scores:
    total = total + s
print(total)          # 254

• Use enumerate quando também precisar do índice.

for i, name in enumerate(["a", "b"]):
    print(i, name)    # 0 a  /  1 b

Uma lista 2-D é uma lista de listas — uma grade de linhas e colunas. Use dois índices: grid[row][col].

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

• Um laço aninhado visita todas as células.

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

Um list comprehension constrói uma nova lista em uma linha: [expression for item in sequence].

squares = [x * x for x in range(5)]
print(squares)        # [0, 1, 4, 9, 16]

• Adicione if para manter apenas alguns itens.

evens = [n for n in range(10) if n % 2 == 0]
print(evens)          # [0, 2, 4, 6, 8]

Um tuple é uma sequência fixa entre parênteses redondos. Não pode ser alterado após criado — use-o para valores que pertencem juntos e desempacote-o em nomes.

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

Uma função que precisa devolver dois resultados retorna um tuple:

def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([5, 2, 9])
print(lo, hi)           # 2 9

Um set armazena cada valor uma única vez, sem ordem. É perfeito para remover duplicatas e para testes rápidos de pertencimento.

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

Erros comuns

• b = a não copia uma lista: ambos os nomes apontam para a mesma lista, então alterar uma altera a outra. Use a.copy() ou a[:].
• O último item é a[-1]; a[len(a)] está fora do intervalo.
• append adiciona UM item; use extend ou + para juntar outra lista.
• Construir uma grade com [[0]*3]*3 cria três cópias da mesma linha. Construa as linhas em um laço em vez disso.
• Um tuple com um item precisa de vírgula: (5,), não (5).
• Um set não tem ordem nem duplicatas, então você não pode indexá-lo com s[0].

Um dicionário 字典 (dict) armazena pares chave 键 → valor 值. Você procura um valor pela sua chave, não por um índice numérico.

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

Adicionar e atualizar

Atribua a uma chave para adicioná-la ou alterar uma existente.

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

Verificar e iterar

Use in para testar se uma chave existe. Itere sobre as chaves, ou sobre .items() para obter tanto a chave quanto o 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) retorna um valor padrão quando a chave está ausente — sem erro.

student = {"name": "Mei"}
print(student.get("age", 0))   # 0

O padrão clássico de prova — contar quantas vezes cada valor aparece:

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) fornece 0 na primeira vez que uma chave é vista, evitando KeyError.

Erros comuns

• Ler uma chave ausente com d[key] levanta um KeyError; use d.get(key) ou teste if key in d primeiro.
• Atribuir d[key] novamente sobrescreve o valor antigo — chaves são únicas.
• Chaves devem ser imutáveis, como uma string ou número — uma lista não pode ser uma chave.

Uma função é um bloco de código nomeado que você pode reutilizar. Defina-a com def, depois chame-a pelo nome.

def greet():
    print("Hello!")

greet()        # Hello!
greet()        # Hello!

• O código interno executa apenas quando você chama a função.

Uma função pode retornar um valor com return. A chamada passa a representar esse valor.

def square(n):
    return n * n

print(square(5))          # 25
print(square(3) + 1)      # 10

• return encerra a função imediatamente. Uma função sem return retorna None.

Um parâmetro é o nome na def. Um argumento é o valor que você passa.

def power(base, exp):         # base, exp are parameters
    return base ** exp

print(power(2, 3))            # 8  (2 and 3 are arguments)

Uma variável criada dentro de uma função é local — ela existe apenas lá. Essa região é seu escopo.

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

Um parâmetro pode ter um valor padrão, usado quando o chamador o omite:

def greet(name, greeting="Hello"):
    return greeting + ", " + name

print(greet("Mei"))              # Hello, Mei
print(greet("Sam", "Welcome"))   # Welcome, Sam

Abstração procedural significa ocultar detalhes atrás de um nome. Você usa uma função pelo seu nome e o que ela faz, não por como funciona.

def area_of_rectangle(w, h):
    return w * h

print(area_of_rectangle(4, 5))   # 20

• Uma boa função faz uma única tarefa, tem um nome claro e evita repetição de código.

Um módulo é um arquivo de funções prontas. Traga um com 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

Erros comuns

• Uma função retorna None a menos que você escreva return. Imprimir não é o mesmo que retornar.
• Nunca use um valor padrão mutável como def f(x=[]) — a mesma lista é compartilhada entre todas as chamadas.
• Uma variável criada dentro de uma função é local e não pode ser vista fora dela.
• Execute uma função com f(); escrever f sozinho apenas a nomeia.

O código pode falhar de três maneiras. Um erro de sintaxe quebra as regras do Python, então nunca executa. Um erro de tempo de execução ocorre durante a execução, como divisão por zero. Um erro lógico executa mas dá a resposta errada.

# 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 um traceback mostrando onde falhou. Leia-o de baixo para cima.

Envolva código arriscado em try. Se falhar, except captura a exceção e a trata, em vez de travar.

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

print(to_int("42"))    # 42
print(to_int("abc"))   # 0

• Capture um tipo específico (ValueError, ZeroDivisionError, …).
• raise gera seu próprio erro propositalmente.

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

Um teste 测试 verifica se o código produz a resposta correta. Teste casos normais e casos de borda 边界情形 — entrada vazia, zero, valores muito 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

• Código robusto 健壮 não falha com entradas estranhas; ele as trata com elegância.

Erros comuns

• Não use um except: genérico — capture o erro específico, ex: except ValueError:.
• Um erro de sintaxe para todo o programa antes de ele rodar, então conserte esses primeiro.
• Teste os casos de borda (entrada vazia, zero, o maior valor), não apenas o caso fácil.

Um arquivo de texto 文本文件 armazena texto em disco. Abra-o com open(name, mode) onde mode 模式 diz para ler ou escrever. Sempre use with, que fecha o arquivo por você.

Escrevendo

Mode "w" escreve um novo arquivo e apaga qualquer antigo.

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

Lendo

Mode "r" (o padrão) lê. .read() retorna todo o arquivo como uma única string.

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

Linha por linha

Faça loop sobre o arquivo para obter uma linha de cada vez. .strip() remove 去除 o newline 换行符 no 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

Mode "a" append 追加 — adiciona ao final sem apagar.

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

Erros comuns

• Sempre feche um arquivo, ou use with open(...) as f: que o fecha por você.
• read() dá todo o arquivo como uma única string, e cada linha ainda termina com \n.
• Abrir com "w" apaga o arquivo primeiro; use "a" para adicionar ao final.

Um algoritmo 算法 é uma lista clara de passos que resolve um problema. Decomposição 分解 significa quebrar um grande problema em partes menores que você pode resolver uma de cada 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

• Abstração 抽象 significa ignorar detalhes: você usa largest(...) sem reler como funciona.

Pseudocódigo 伪代码 é inglês estruturado simples para um algoritmo, escrito antes do código real. Ele não é executado.

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

Um fluxograma 流程图 desenha o mesmo plano: uma caixa para cada passo, um losango para cada decisão 判断, e setas para a ordem.

Recursão 递归 é quando uma função se chama. Ela precisa de um caso base 基准情形 (uma entrada simples que retorna imediatamente) e um caso recursivo 递归情形 (ela se chama com uma entrada menor).

def fact(n):
    return 1 if n <= 1 else n * fact(n - 1)

print(fact(5))     # 120

• Cada chamada pausada fica na call stack 调用栈 até a chamada acima dela retornar.

Erros comuns

• Recursão precisa de um caso base, ou ela se chama infinitamente e quebra a call stack.
• Pseudocódigo é para planejamento — ele não precisa rodar, mas cada passo deve ser inequívoco.
• Quebre um grande problema em passos pequenos nomeados antes de escrever qualquer código.

Um tipo de dado abstrato 抽象数据类型 (ADT) descreve alguns dados mais as operações sobre eles, separado de como é construído. Você o usa através de suas operações, não através de seu armazenamento interno.

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

Uma pilha 栈 é last-in, first-out (LIFO 后进先出). Você push 压入 no topo e pop 弹出 do topo.

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

Uma fila 队列 é first-in, first-out (FIFO 先进先出). Você enqueue 入队 na traseira e dequeue 出队 da frente.

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

Uma linked list 链表 é uma cadeia de nodes 节点. Cada node segura dados e um pointer 指针 para o próximo node; o último aponta para 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

Uma tabela hash 哈希表 mapeia uma key para uma slot com uma hash function 哈希函数. Duas keys podem cair na mesma slot — uma collision 冲突. Python's dict é uma tabela hash, então lookup é rápido.

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

Uma binary search tree 二叉搜索树 (BST) mantém ordem: todo filho esquerdo é menor que seu nó, todo filho direito é maior. Search permanece rápido.

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]

Um graph 图 é um conjunto de vertices 顶点 unidos por edges 边. Uma adjacency list 邻接表 — um dict de listas de vizinhos — é uma forma comum de armazenar uma.

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)

Erros comuns

• A stack é last-in-first-out; a queue é first-in-first-out. Não as misture.
• Verifique se uma estrutura está vazia antes de pop ou dequeue dela.
• Em uma lista encadeada, perder o ponteiro head perde toda a lista.

Um search 查找 encontra onde um valor está. Linear search 线性查找 verifica cada item por vez, então funciona em qualquer 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

Binary search 二分查找 é muito mais rápido mas precisa de uma lista sorted. Ela divide o range pela metade a cada passo.

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 排序 é colocar itens em ordem. Bubble sort 冒泡排序 troca repetidamente neighbours que estão na ordem errada.

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]

Insertion sort 插入排序 constrói uma parte sorted item por item, deslizando cada novo item de volta para seu 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]

• Em código real, use o built-in Python sorted():

print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]

Eficiência 效率 pergunta como o trabalho cresce conforme a entrada cresce. Descrevemos isso com Big-O 大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)

O módulo random faz números aleatórios. Use um seed 种子 para tornar resultados reprodutíveis. Uma simulation 模拟 roda muitos trials aleatórios para estimar uma resposta.

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

Erros comuns

• Binary search só funciona em uma lista sorted.
• Big-O diz como o tempo CRESCE, não o tempo exato; um método O(n²) bate O(n) apenas para entradas minúsculas.
• Bubble sort é O(n²) — bom para aprender, mas lento em listas grandes.

Uma class 类 é um blueprint. Um object 对象 é uma coisa construída a partir dele (um instance 实例). __init__ é o constructor 构造方法 que configura cada objeto; self é o objeto em si.

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 é um attribute 属性 (dados no objeto); speak é um method 方法 (uma ação).

Adicione __str__ para controlar o que print(obj) mostra:

class Dog:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f"Dog named {self.name}"

print(Dog("Rex"))    # Dog named Rex

Herança 继承 deixa um subclass 子类 reutilizar um superclass 父类. Use super() para chamar o parent; override 重写 um method para alterá-lo.

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

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

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

Encapsulamento 封装 esconde dados atrás de methods; um underscore inicial o marca private 私有.

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

Polimorfismo 多态 significa um nome, muitos comportamentos — o certo speak roda 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

Um paradigm 范式 é um estilo de escrever programas. Código procedural 过程式 é uma sequência de passos e functions. Código orientado a objetos 面向对象 agrupa dados e methods em objects. Código declarativo 声明式 diz o que você quer, não como (um list comprehension ou 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)

Erros comuns

• Todo method precisa de self como seu primeiro parâmetro.
• __init__ configura um novo objeto e roda automaticamente quando você cria um.
• Dois objects da mesma class têm attributes separados; alterar um não altera o outro.

Um bit 比特 é um único 0 ou 1. Binário 二进制 é o sistema numérico base-2: cada posição vale o dobro da anterior à direita (1, 2, 4, 8, …). Decimal 十进制 (base-10) são nossos números normais.

print(bin(13))         # 0b1101
print(int("1101", 2))  # 13

• 8 bits fazem um byte 字节. Uma fixed width pode overflow 溢出 (wrap around) quando o número é muito grande.

x = 250
x = (x + 10) % 256     # one byte wraps at 256
print(x)               # 4

Hexadecimal 十六进制 (base 16) é uma forma compacta de ler binário: um dígito hex representa exatamente quatro bits. Python escreve hex com 0x:

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

Compression 压缩 torna dados menores. Lossless 无损 compression mantém todos os bits, então você reconstrói o original exatamente. Lossy 有损 compression joga fora detalhes — menor mas não exato — e é usado para fotos e música.

Run-length encoding 游程编码 é um método lossless simples: armazene um run 游程 (uma repetição) como um count mais o value.

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

Erros comuns

• n bits armazenam 2**n valores diferentes, de 0 até 2**n - 1.
• Lossy compression joga fora detalhes e não pode ser desfeito; lossless pode ser revertido exatamente.

Computação 计算 significa resolver problemas com computadores: input, process, output. Good software é construído em um design cycle 设计循环 — plan, write, test, improve — repetidas muitas vezes.

• Quebre um problema, construa uma parte pequena, teste-a, depois adicione mais.
• Programadores trabalham em equipe e reutilizam o código uns dos outros.

A Internet 互联网 es una red de redes. Los datos se dividen en paquetes 数据包 que viajan por separado y se recombinan en el otro extremo. Las reglas compartidas llamadas protocolos 协议 (como TCP/IP) hacen esto posible. Si un camino se interrumpe, los paquetes toman otra ruta: esto es redundancia 冗余, lo que proporciona tolerancia a fallos 容错.

El código secuencial 顺序 realiza un paso a la vez. El cómputo paralelo 并行 realiza varios pasos a la vez en muchos núcleos 核心, lo que puede proporcionar aceleración 加速. El cómputo distribuido 分布式 reparte el trabajo entre muchas computadoras, como en la nube.

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

El cómputo trae tanto beneficios como perjuicios. La brecha digital 数字鸿沟 significa que no todos tienen acceso igualitario a él. El software puede transportar sesgo 偏见 proveniente de los datos con los que aprende. Respetar la propiedad intelectual 知识产权 (licencias), y proteger los datos personales 个人数据 y la privacidad 隐私 de las personas.

Erros comuns

• La Internet y la World Wide Web no son lo mismo: la Web es un servicio que se ejecuta sobre la Internet.
• Más núcleos de procesador ayudan solo si el trabajo 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 AP Create.

Proyecto: nota promedio

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 use selección 选择 e iteración 迭代, y alguna entrada/salida. Cada proyecto arriba tiene exactamente esa forma: construya piezas pequeñas y luego únalas.

Erros comuns

• Construya en pasos pequeños y pruebe cada parte antes de continuar; no escriba todo de una vez.
• Lea toda la tarea primero, luego planifique la entrada → proceso → salida antes de codificar.