Machine Translated by Google

Os dicionários armazenam conexões entre informações.

Listar compreensões
Cada item em um dicionário é um par chave-valor.
quadrados = [x**2 para x no intervalo(1, 11)] Um dicionário simples
Fatiando uma lista
alien = {'cor': 'verde', 'pontos': 5}
finalizadores = ['sam', 'bob', 'ada', 'bea'] primeiro_dois Acessando um valor
= finalizadores[:2]
print("A cor do alien é " + alien['cor'])
Variáveis são usadas para armazenar valores. Uma string é Copiando uma lista
uma série de caracteres, entre aspas simples ou duplas. Adicionando um novo par de valor-
copy_of_bikes = bicicletas[:]
Olá Mundo
chave alien['x_position'] = 0
print("Olá mundo!") Percorrendo todos os pares chave-valor
Olá mundo com uma variável
As tuplas são semelhantes às listas, mas os itens em uma tupla não podem ser fav_numbers = {'eric': 17, 'ever': 4} for name,
modificados. number in fav_numbers.items(): print(name + ' loves '
msg = "Olá mundo!"
+ str(number))
imprimir(mensagem) Fazendo uma
Percorrendo todas as teclas
Concatenação (combinando strings) tupla dimensões = (1920, 1080)
fav_numbers = {'eric': 17, 'ever': 4} for name in
first_name = 'albert'
fav_numbers.keys(): print(name + 'loves a number')
last_name = 'einstein'
' '
full_name = first_name + + sobrenome As declarações if são usadas para testar condições específicas e
print(full_name) responder adequadamente. Percorrendo todos os valores

testes condicionais fav_numbers = {'eric': 17, 'ever': 4} for number in

fav_numbers.values(): print(str(number) + ' is a
igual a x == 42
Uma lista armazena uma série de itens em uma ordem específica. favorite')
não igual x != 42
Você acessa itens usando um índice ou dentro de um loop.
maior que x > 42 ou igual a x
Faça uma lista
>= 42 menor que x < 42 ou
igual a x <= 42
bikes = ['trek', 'redline', 'gigante'] Seus programas podem solicitar entrada do usuário. Todas as entradas são
armazenadas como uma string.
Obter o primeiro item de uma lista
Teste condicional com listas
Solicitando um valor
first_bike = bicicletas[0] 'trek' em bicicletas
nome = input("Qual é o seu nome? ") print("Olá,
Obter o último item de uma lista 'grosseiro' não em bicicletas " + nome + "!")
Atribuindo valores booleanos
last_bike = bicicletas[-1] Solicitando entrada numérica

Percorrendo uma lista game_active = idade = input("Quantos anos você tem?")

Verdadeiro can_edit = Falso idade = int(idade)
para bicicleta em bicicletas:
Um simples teste if
imprimir(bicicleta)
pi = input("Qual é o valor de pi?") pi = float(pi)
Adicionando itens a uma lista if age >= 18:
print("Você pode votar!")
bikes = []
Instruções if-elif-else
bikes.append('trek')
bikes.append('redline')
if age < 4:
bikes.append('gigante')
ticket_price = 0 elif
Fazendo listas numéricas age < 18: ticket_price = 10 Abrange Python 3 e Python 2
else:
squares = []
para x in range(1, 11): preço_bilhete = 15
squares.append(x**2)
Machine Translated by Google

Um loop while repete um bloco de código enquanto uma determinada Uma classe define o comportamento de um objeto e o tipo de Seus programas podem ler de arquivos e gravar em arquivos. Os arquivos
condição for verdadeira. informação que um objeto pode armazenar. As informações em são abertos no modo de leitura ('r') por padrão, mas também podem ser
uma classe são armazenadas em atributos e as funções que abertos no modo de gravação ('w') e no modo de acréscimo ('a').
Um loop while simples pertencem a uma classe são chamadas de métodos. Uma classe
filha herda os atributos e métodos de sua classe pai. Lendo um arquivo e armazenando suas linhas
valor_atual = 1
enquanto valor_atual <= 5: nome do arquivo = 'siddhartha.txt'
Criando uma classe de cachorro
imprimir(valor_atual) com open(filename) como file_object:
valor_atual += 1 classe Cachorro(): linhas = file_object.readlines()
"""Representa um cachorro."""
Permitir que o usuário escolha quando sair para linha em linhas:
'' def __init__(auto, nome): imprimir(linha)
msg =
while msg != 'sair': """Inicializar objeto cachorro."""
self.name = nome Escrevendo em um arquivo
msg = input("Qual é a sua mensagem?")
imprimir(mensagem) nome do arquivo = 'journal.txt'
def sentar(auto): com open(filename, 'w') como file_object:
"""Simular sentado.""" file_object.write("Eu amo programar.")
print(self.name + " está sentado.")
As funções são blocos de código nomeados, projetados para realizar Anexando a um arquivo
um trabalho específico. A informação passada para uma função é meu_cachorro = Cachorro('Peso')
nome do arquivo = 'journal.txt'
chamada de argumento, e a informação recebida por uma função é
com open(filename, 'a') como file_object:
chamada de parâmetro. print(meu_cachorro.nome + "é um ótimo cachorro!")
file_object.write("\nEu adoro fazer jogos.")
meu_cachorro.sentado()
Uma função simples
Herança
def cumprimentar_usuário():
"""Mostrar uma saudação simples.""" class SARDog(Cachorro): As exceções ajudam você a responder adequadamente a erros
print("Olá!") """Representa um cão de busca.""" que provavelmente ocorrerão. Você coloca um código que pode
causar um erro no bloco try. O código que deve ser executado em
cumprimentar_usuário() def __init__(auto, nome): resposta a um erro vai no bloco except. O código que deve ser
"""Inicializar o sardog.""" executado somente se o bloco try for bem-sucedido vai para o bloco else.
Passando um argumento
super().__init__(nome)
def greet_user(nome de usuário): Capturando uma exceção
"""Exibir uma saudação personalizada.""" busca def (auto): prompt = "De quantos ingressos você precisa?"
print("Olá, " + usuario + "!") """Simular pesquisa.""" num_tickets = input(prompt)
print(self.name + " está procurando.")
cumprimentar_user('jesse') tentar:
meu_cachorro = SARDog('Willie') num_tickets = int(num_tickets)
Valores padrão para parâmetros
exceto ValueError:
def make_pizza(topping='bacon'): print(my_dog.name + " é um cão de busca.") print("Tente novamente.")
"""Faça uma pizza de cobertura única.""" meu_cachorro.sentado() senão:
"
print("Coma + cobertura + " pizza!") my_dog.search() print("Seus tickets estão sendo impressos.")

make_pizza()
make_pizza('calabresa')
Se você tivesse infinitas habilidades de programação, o que você Simples é melhor que complexo
Retornando um valor construiria?
Se você puder escolher entre uma solução simples e uma complexa, e
def add_numbers(x, y): À medida que você aprende a programar, é útil pensar nos projetos
"""Somar dois números e retornar a soma.""" ambas funcionarem, use a solução simples. Seu código será mais fácil
do mundo real que gostaria de criar. É um bom hábito manter um de manter e será mais fácil para você e outras pessoas desenvolverem
retornar x + y caderno de "idéias" que você pode consultar sempre que quiser iniciar
esse código posteriormente.
um novo projeto.
soma = add_numbers (3, 5)
Se ainda não o fez, reserve alguns minutos e descreva três projetos
imprimir(soma) Mais folhas de dicas disponíveis em
que gostaria de criar.
Machine Translated by Google

Você pode adicionar elementos ao final de uma lista ou inseri-los onde O método sort() altera a ordem de uma lista permanentemente.
quiser em uma lista. A função sorted() retorna uma cópia da lista, deixando a lista original
inalterada. Você pode classificar os itens em uma lista em ordem
Adicionando um elemento ao final da lista
alfabética ou ordem alfabética inversa. Você também pode inverter a
users.append('amy') ordem original da lista. Lembre-se de que letras minúsculas e
maiúsculas podem afetar a ordem de classificação.
Começando com uma lista vazia
Classificando uma lista permanentemente
usuários = []
Uma lista armazena uma série de itens em uma ordem específica. users.append('val') users.sort()
As listas permitem que você armazene conjuntos de informações em users.append('bob') Classificando uma lista permanentemente em ordem alfabética reversa
um só lugar, quer você tenha apenas alguns itens ou milhões de itens. As users.append('mia')
listas são um dos recursos mais poderosos do Python, facilmente acessíveis
Inserindo elementos em uma posição específica
a novos programadores e unem muitos conceitos importantes da programação. users.sort(reverse=True)
users.insert(0, 'joe')
Classificando uma lista temporariamente
users.insert(3, 'bea')
print(ordenado(usuários))
print(classificado(usuários, reverse=True))

Use colchetes para definir uma lista e use vírgulas para separar
itens individuais na lista. Use nomes plurais para listas, para tornar
seu código mais fácil de ler.
Fazendo uma lista
usuários = ['val', 'bob', 'mia', 'ron', 'ned']
Elementos individuais em uma lista são acessados de acordo com sua
posição, chamada de índice. O índice do primeiro elemento é 0, o índice
do segundo elemento é 1 e assim por diante.
Índices negativos referem-se a itens no final da lista. Para obter um
determinado elemento, escreva o nome da lista e, em seguida, o índice
do elemento entre colchetes.
Obtendo o primeiro elemento
primeiro_usuário = usuários[0]
Você pode remover elementos por sua posição em uma lista ou pelo
valor do item. Se você remover um item por seu valor, o Python
removerá apenas o primeiro item que tiver esse valor.
Excluindo um elemento por sua posição
dos usuários[-1]
Removendo um item por seu valor
users.remove('mia')
Se você quiser trabalhar com um elemento que está removendo da
lista, você pode "abrir" o elemento. Se você pensar na lista como uma
pilha de itens, pop() retira um item do topo da pilha. Por padrão, pop()
retorna o último elemento da lista, mas você também pode remover
elementos de qualquer posição na lista.
Aparecer o último item de uma lista
Invertendo a ordem de uma lista
usuários.reverso()
As listas podem conter milhões de itens, portanto, o Python fornece
uma maneira eficiente de percorrer todos os itens de uma lista.
Quando você configura um loop, o Python extrai cada item da lista, um
por vez, e os armazena em uma variável temporária, para a qual você
fornece um nome. Esse nome deve ser a versão singular do nome da
lista.
O bloco de código recuado compõe o corpo do loop, onde você
pode trabalhar com cada item individual. Todas as linhas que não
são recuadas são executadas após a conclusão do loop.
Imprimindo todos os itens em uma lista
para usuário em usuários:
imprimir(usuário)

Obtendo o segundo elemento Imprimindo uma mensagem para cada item e uma mensagem separada
most_recent_user = users.pop()
depois
segundo_usuário = usuários[1] print(most_recent_user)
para usuário em usuários:
Mostrar o primeiro item em uma lista
Obtendo o último elemento
print("Bem-vindo, " + usuario + "!")
mais novo_usuário = usuários[-1] first_user = users.pop(0)
print(first_user) print("Bem-vindos, estamos felizes em ver todos vocês!")

Depois de definir uma lista, você pode alterar elementos

individuais na lista. Você faz isso consultando o índice do item que A função len() retorna o número de itens em uma lista.
deseja modificar.
Encontrar o comprimento de uma lista
Abrange Python 3 e Python 2
Mudando um elemento
num_users = len(usuários)
usuários[0] = 'Valerie' print("Temos " + str(num_users) + " usuários.")
usuários[-2] = 'ronald'
Machine Translated by Google

Você pode usar a função range() para trabalhar com um
conjunto de números de forma eficiente. A função range()
começa em 0 por padrão e para um número abaixo do número
passado para ela. Você pode usar a função list() para gerar com
eficiência uma grande lista de números.
Imprimindo os números de 0 a 1000
para o número no intervalo (1001):
imprimir(número)
Para copiar uma lista, faça uma fatia que comece no primeiro item
e termine no último item. Se você tentar copiar uma lista sem usar
essa abordagem, tudo o que você fizer na lista copiada também
afetará a lista original.
Fazendo uma cópia de uma lista
finalizadores = ['kai', 'abe', 'ada', 'gus', 'zoe']
copy_of_finisers = finalizadores[:]
Uma tupla é como uma lista, exceto que você não pode alterar os
valores em uma tupla depois de definida. As tuplas são boas para
armazenar informações que não devem ser alteradas ao longo da
vida de um programa. As tuplas são designadas por parênteses em
vez de colchetes. (Você pode substituir uma tupla inteira, mas não
pode alterar os elementos individuais em uma tupla.)
Definindo uma tupla
dimensões = (800, 600)

Imprimindo os números de 1 a 1000 Percorrendo uma tupla

para o número no intervalo (1, 1001):
imprimir(número)
Fazendo uma lista de números de 1 a um milhão
numeros = lista(intervalo(1, 1000001))
Há várias estatísticas simples que você pode executar em uma lista
contendo dados numéricos.
Você pode usar um loop para gerar uma lista com base em um intervalo de para dimensão em dimensões:
números ou em outra lista. Essa é uma operação comum, então o Python imprimir(dimensão)
oferece uma maneira mais eficiente de fazer isso. As compreensões de lista
podem parecer complicadas no início; em caso afirmativo, use a abordagem Sobrescrevendo uma tupla
do loop for até que esteja pronto para começar a usar as compreensões.
dimensões = (800, 600)
imprimir(dimensões)
Para escrever uma compreensão, defina uma expressão para os
valores que deseja armazenar na lista. Em seguida, escreva um loop for
dimensões = (1200, 900)
para gerar os valores de entrada necessários para fazer a lista.
Usando um loop para gerar uma lista de números quadrados

Encontrando o valor mínimo em uma lista quadrados = [] Quando você está aprendendo sobre estruturas de dados, como
para x no intervalo (1, 11): listas, ajuda a visualizar como o Python está trabalhando com as
idades = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
quadrado = x**2 informações em seu programa. pythontutor.com é uma ótima
mais novo = min(idade)
squares.append(square) ferramenta para ver como o Python controla as informações em uma
Encontrando o valor máximo lista. Tente executar o código a seguir em pythontutor.com e execute
Usando uma compreensão para gerar uma lista de números quadrados
seu próprio código.
idades = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
mais velho = max(idade) Crie uma lista e imprima os itens na lista
quadrados = [x**2 para x no intervalo(1, 11)]
Encontrando a soma de todos os valores cães = []
Usando um loop para converter uma lista de nomes em letras maiúsculas
cães.append('willie')
idades = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
nomes = ['kai', 'abe', 'ada', 'gus', 'zoe'] cães.append('hootz')
total_anos = soma(idades)
cães.append('peso')
nomes_superiores = [] cães.append('goblin')
para nome em nomes:
Você pode trabalhar com qualquer conjunto de elementos de uma lista. upper_names.append(name.upper()) para cão em cães:
Uma parte de uma lista é chamada de fatia. Para dividir uma lista, print("Olá " + cachorro + "!")
Usando uma compreensão para converter uma lista de nomes em letras print("Eu amo esses cachorros!")
comece com o índice do primeiro item desejado e, em seguida, adicione
maiúsculas
dois pontos e o índice após o último item desejado. Deixe de lado o
primeiro índice para começar no início da lista e deixe de lado o último print("\nEstes foram meus dois primeiros cachorros:")
nomes = ['kai', 'abe', 'ada', 'gus', 'zoe']
índice para cortar o final da lista. cachorros_velhos = cachorros[:2]
para old_dog em old_dogs:
upper_names = [name.upper() para nome em nomes]
Obtendo os três primeiros itens print(velho_cachorro)

finalizadores = ['kai', 'abe', 'ada', 'gus', 'zoe']

dos cachorros[0]
first_three = finalizadores[:3]
Contagens de legibilidade cães.remove('peso')
Obtendo os três itens do meio imprimir(cachorros)
• Use quatro espaços por nível de recuo.
middle_three = finalizadores[1:4]
• Mantenha suas linhas em 79 caracteres ou menos.
Obtendo os últimos três itens • Use linhas em branco simples para agrupar partes de seu Mais folhas de dicas disponíveis em
programa visualmente.
last_three = finalizadores[-3:]
Machine Translated by Google

Você pode armazenar quantos pares chave-valor quiser em
um dicionário, até que seu computador fique sem memória.
Para adicionar um novo par chave-valor a um dicionário
existente, forneça o nome do dicionário e a nova chave entre
colchetes e defina-o igual ao novo valor.
Isso também permite que você comece com um dicionário vazio e adicione
pares de valores-chave conforme eles se tornam relevantes.
Você pode percorrer um dicionário de três maneiras: você pode
percorrer todos os pares chave-valor, todas as chaves ou todos
os valores.
Um dicionário apenas rastreia as conexões entre as chaves
e valores; ele não rastreia a ordem dos itens no
dicionário. Se você deseja processar as informações em
ordem, pode classificar as chaves em seu loop.

Adicionando um par chave-valor Percorrendo todos os pares chave-valor

alien_0 = {'cor': 'verde', 'pontos': 5} # Armazene os idiomas favoritos das pessoas.

idiomas_favoritos = {
alienígena_0['x'] = 0 'jen': 'python',
Os dicionários do Python permitem que você conecte informações
alien_0['s'] = 25 'sara': 'c',
relacionadas. Cada pedaço de informação em um dicionário é 'edward': 'rubi',
alien_0['velocidade'] = 1,5
armazenado como um par chave-valor. Quando você fornece uma 'phil': 'python',
chave, o Python retorna o valor associado a essa chave. Você pode Adicionando a um dicionário vazio }
percorrer todos os pares chave-valor, todas as chaves ou todos os
alienígena_0 = {}
valores. alien_0['cor'] = 'verde' # Mostre o idioma favorito de cada pessoa.
alien_0['pontos'] = 5 para nome, idioma em fav_languages.items():
print(nome + ": " + idioma)

Use chaves para definir um dicionário. Use dois-pontos
para conectar chaves e valores e use vírgulas para separar
pares de valores-chave individuais.
Fazendo um dicionário
alien_0 = {'cor': 'verde', 'pontos': 5}
Para acessar o valor associado a uma chave individual,
forneça o nome do dicionário e coloque a chave entre colchetes.
Se a chave que você está pedindo não estiver no dicionário,
ocorrerá um erro.
Você também pode usar o método get(), que retorna None
em vez de um erro se a chave não existir. Você também pode
especificar um valor padrão a ser usado se a chave não estiver no
dicionário.
Obtendo o valor associado a uma chave
alien_0 = {'cor': 'verde', 'pontos': 5}
print(alien_0['cor'])
print(alien_0['pontos'])
Obtendo o valor com get()
alien_0 = {'cor': 'verde'}
alien_color = alien_0.get('cor')
alien_points = alien_0.get('pontos', 0)
Percorrendo todas as teclas
Você pode modificar o valor associado a qualquer chave em # Mostre a todos que responderam à pesquisa.
um dicionário. Para fazer isso, forneça o nome do dicionário e para nome em fav_languages.keys():
coloque a chave entre colchetes e, em seguida, forneça o novo imprimir(nome)
valor para essa chave.
Percorrendo todos os valores
Modificando valores em um dicionário
# Mostrar todos os idiomas que foram escolhidos.
alien_0 = {'cor': 'verde', 'pontos': 5} para idioma em fav_languages.values():
print(alien_0) imprimir(idioma)
# Altere a cor e o valor do ponto do alienígena. Percorrendo todas as teclas em ordem
alien_0['cor'] = 'amarelo'
# Mostra o idioma favorito de cada pessoa, # em
alien_0['pontos'] = 10 ordem pelo nome da pessoa.
print(alien_0) para nome em sorted(fav_languages.keys()):
print(nome + ": " + idioma)
Você pode remover qualquer par chave-valor que
desejar de um dicionário. Para fazer isso, use a palavra-chave
Você pode encontrar o número de pares chave-valor em um dicionário.
del e o nome do dicionário, seguidos da chave entre colchetes.
Isso excluirá a chave e seu valor associado. Encontrando o comprimento de um dicionário
Excluindo um par chave-valor num_responses = len(fav_idiomas)
alien_0 = {'cor': 'verde', 'pontos': 5}
print(alien_0)
del alien_0['pontos']
print(alien_0)
Abrange Python 3 e Python 2

print(alien_color)
print(alien_points) Tente executar alguns desses exemplos em pythontutor.com.
Machine Translated by Google

Às vezes é útil armazenar um conjunto de dicionários em uma lista; isso
é chamado de nidificação.
Armazenando dicionários em uma lista
# Comece com uma lista vazia.
usuários = []
# Crie um novo usuário e adicione-o à lista. new_user =
{ 'last': 'fermi', 'first': 'enrico', 'username': 'efermi', }
users.append(new_user)
# Crie outro novo usuário e adicione-o também. new_user =
{ 'last': 'curie', 'first': 'marie', 'username': 'mcurie', }
users.append(new_user)
# Mostrar todas as informações sobre cada usuário.
for user_dict in users: for k, v in user_dict.items():
print(k + ": " + v) print("\n")
Você também pode definir uma lista de dicionários diretamente, sem
usar append():
Armazenar uma lista dentro de um dicionário permite
associar mais de um valor a cada chave.
Armazenando listas em um dicionário
# Armazene vários idiomas para cada pessoa.
fav_languages = { 'jen': ['python', 'ruby'], 'sarah': ['c'],
'edward': ['ruby', 'go'], 'phil': ['python', 'haskel'],
} controle de quem respondeu primeiro. fav_idiomas =
# Mostrar todas as respostas para cada pessoa.
para nome, langs em fav_languages.items():
print(nome + ": ") for
lang in langs: print("- " +
lang)
Você pode armazenar um dicionário dentro de outro dicionário. Nesse
caso, cada valor associado a uma chave é ele próprio um dicionário.
Armazenando dicionários em um dicionário
users =
{ 'aeinstein': { 'first':
'albert', 'last': 'einstein',
'location': 'princeton', },
'mcurie': { 'first': 'marie', 'last' :
'curie', 'localização': 'paris', },
Os dicionários padrão do Python não acompanham a ordem em
que as chaves e os valores são adicionados; eles apenas
preservam a associação entre cada chave e seu valor. Se você
quiser preservar a ordem na qual as chaves e os valores são
adicionados, use um OrderedDict.
Preservando a ordem de chaves e valores
das coleções importar OrderedDict
# Armazene os idiomas de cada pessoa, mantendo #
OrderedDict()
fav_languages['jen'] = ['python', 'ruby']
fav_languages['sarah'] = ['c'] fav_languages['edward'] =
['ruby', 'go'] fav_languages['phil'] = ['python', 'haskell']
# Exibe os resultados, na mesma ordem em que # foram
inseridos.
for name, langs in fav_languages.items(): print(name +
":") for lang in langs: print("- " + lang)
Você pode usar um loop para gerar um grande número de
dicionários de forma eficiente, se todos os dicionários começarem com
dados semelhantes.
um milhão de alienígenas

# Defina uma lista de usuários, onde cada usuário # é alienígenas = []

representado por um dicionário. usuários = [{
# Faça um milhão de alienígenas verdes, valendo 5 pontos #
} cada. Faça com que todos comecem em uma linha. para
'último': 'fermi',
alien_num in range(1000000): new_alien = {} new_alien['color']
'primeiro': 'enrico', 'nome = 'green' new_alien['points'] = 5 new_alien['x'] = 20 *
para nome de usuário, user_dict em users.items():
de usuário': 'efermi',
print("\nUsername: " + username)
user_dict['first']
full_name += alien_num new_alien['y'] = 0 aliens. append(new_alien)
}, ""

full_name += user_dict['last'] location =

{
user_dict['location']
'último': 'curie',
'primeiro': 'marie',
'nome de usuário': 'mcurie', "
print("\tNome completo: + nome_completo.title())
}, # Prove que a lista contém um milhão de alienígenas.
print("\tLocal: " + location.title())
] num_aliens = len(aliens)
# Mostrar todas as informações sobre cada usuário.
print("Número de alienígenas criados:")
for user_dict in users: for k, v print(num_aliens)
O aninhamento é extremamente útil em determinadas situações. No
in user_dict.items(): print(k + ": " + v)
entanto, esteja ciente de tornar seu código excessivamente complexo. Se
print("\n") você estiver aninhando itens muito mais profundamente do que o que vê
aqui, provavelmente existem maneiras mais simples de gerenciar seus Mais folhas de dicas disponíveis em
dados, como usar classes.
Machine Translated by Google

Testar valores numéricos é semelhante a testar valores de string. Existem vários tipos de instruções if. Sua escolha de qual usar
depende do número de condições que você precisa testar.
Testando igualdade e desigualdade
Você pode ter quantos blocos elif precisar, e o bloco else é
>>> idade = 18 sempre opcional.
>>> idade == 18 Declaração if simples
Verdadeiro >>>
idade != 18 Falso idade = 19

if age >= 18:

Operadores de comparação
print("Você já tem idade para votar!")
>>> idade = 19 declarações if-else
>>> idade < 21
Verdadeiro idade = 17
>>> idade <= 21
Verdadeiro if age >= 18:
As instruções if permitem que você examine o estado atual de um programa >>> idade > 21 print("Você já tem idade para votar!") else:
e responda apropriadamente a esse estado.
Falso
Você pode escrever uma instrução if simples que verifica uma condição ou >>> idade >= 21 print("Você ainda não pode votar.")
Falso
pode criar uma série complexa de instruções if que identificam as condições A cadeia if-elif-else
exatas que você está procurando.
idade = 12

Você pode verificar várias condições ao mesmo tempo. O se idade < 4:

Enquanto os loops são executados desde que certas condições permaneçam operador and retorna True se todas as condições listadas forem preço = 0
verdadeiras. Você pode usar loops while para permitir que seus programas True. O operador or retorna True se qualquer condição for True. elif idade < 18:
sejam executados enquanto seus usuários desejarem. preço = 5
Usando e para verificar várias condições
senão:
>>> idade_0 = 22 preço = 10
>>> idade_1 = 18
Um teste condicional é uma expressão que pode ser avaliada como >>> idade_0 >= 21 e idade_1 >= 21 print("Seu custo é $" + str(preço) + ".")
Verdadeiro ou Falso. Python usa os valores True e False para decidir Falso
se o código em uma instrução if deve ser executado. >>> idade_1 = 23
>>> idade_0 >= 21 e idade_1 >= 21
Verificando a igualdade Um
Verdadeiro Você pode testar facilmente se um determinado valor está em uma
único sinal de igual atribui um valor a uma variável. Um sinal de igual duplo lista. Você também pode testar se uma lista está vazia antes de
Usando ou para verificar várias condições
(==) verifica se dois valores são iguais. tentar percorrê-la.
>>> idade_0 = 22 Testando se um valor está em uma lista
>>> carro = 'bmw'
>>> idade_1 = 18
>>> carro == 'bmw'
>>> idade_0 >= 21 ou idade_1 >= 21 >>> jogadores = ['al', 'bea', 'cyn', 'dale'] >>> 'al' em jogadores
Verdadeiro
Verdadeiro
>>> carro = 'audi' >>>
>>> idade_0 = 18
carro == 'bmw'
>>> idade_0 >= 21 ou idade_1 >= 21 Verdadeiro >>> 'eric' em jogadores
Falso
Falso Falso
Ignorando maiúsculas e minúsculas ao fazer uma comparação

>>> carro = 'Audi' >>>

carro.lower() == 'audi' Um valor booleano é True ou False. Variáveis com valores
Verdadeiro
booleanos são freqüentemente usadas para controlar certas
condições dentro de um programa.
Verificando a desigualdade Abrange Python 3 e Python 2
Valores booleanos simples
>>> cobertura = 'cogumelos' >>>
cobertura != 'anchovas' game_active = Verdadeiro
Verdadeiro can_edit = Falso
Machine Translated by Google

Testando se um valor não está em uma lista Permitir que o usuário escolha quando sair Usando continuar em um loop

banidos_usuários = ['ann', 'chad', 'dee'] prompt = "\nDiga-me uma coisa, e eu" banidos_usuários = ['eve', 'fred', 'gary', 'helen']
usuário = 'erin' prompt += "repita de volta para você."
" prompt = "\nAdicione um jogador ao seu time."
prompt += "\nDigite 'quit' para encerrar o programa.
se o usuário não estiver em ban_users: prompt += "\nDigite 'quit' quando terminar. "
""
print("Você pode jogar!") message =
while message != 'sair': jogadores = []
Verificando se uma lista está vazia enquanto verdadeiro:
mensagem = input(prompt)
jogador = input(prompt)
jogadores = []
se mensagem != 'sair': se jogador == 'sair':
parar
se os jogadores: imprimir(mensagem)
jogador elif em banidos_usuários:
para jogador em jogadores: Usando uma bandeira
print(jogador + " foi banido!")
print("Jogador: " + jogador.título())
Prosseguir
senão: prompt = "\nDiga-me uma coisa, e eu"
senão:
print("Ainda não temos jogadores!") prompt += "repita de volta para você."
" jogadores.append(jogador)
prompt += "\nDigite 'quit' para encerrar o programa.

ativo = Verdadeiro print("\nSua equipe:")

Você pode permitir que seus usuários insiram entradas usando a instrução enquanto ativo: para jogador em jogadores:
input(). No Python 3, todas as entradas são armazenadas como uma string. imprimir(jogador)
mensagem = input(prompt)
Entrada simples
se mensagem == 'sair':
nome = input("Qual é o seu nome?") ativo = falso
Todo loop while precisa de uma maneira de parar a execução para
print("Olá, " + nome + ".") senão:
que não continue a ser executado para sempre. Se não houver como a
imprimir(mensagem) condição se tornar falsa, o loop nunca parará de ser executado.
Aceitando entrada numérica
Usando break para sair de um loop um loop infinito
idade = input("Quantos anos você tem?")
idade = int(idade) prompt = "\nQue cidades você visitou?" enquanto verdadeiro:
prompt += "\nDigite 'quit' quando terminar. " nome = input("\nQuem é você?")
se idade >= 18: "
print("Prazer em conhecê-lo, + nome + "!")
print("\nVocê pode votar!") enquanto verdadeiro:
senão: cidade = input(prompt)
print("\nVocê ainda não pode votar.")
if cidade == 'sair': O método remove() remove um valor específico de uma lista, mas
Aceitando entrada no Python 2.7
parar remove apenas a primeira instância do valor que você fornece.
Use raw_input() no Python 2.7. Essa função interpreta todas as entradas como
senão: Você pode usar um loop while para remover todas as instâncias de
uma string, assim como input() faz no Python 3. "
print("Eu estive em + cidade + "!") um valor específico.
nome = raw_input("Qual é o seu nome?")
Removendo todos os gatos de uma lista de animais de estimação
print("Olá, " + nome + ".")
pets = ['cachorro', 'gato', 'cachorro', 'peixe', 'gato',
O Sublime Text não executa programas que solicitam entrada do
'coelho', 'gato']
usuário. Você pode usar o Sublime Text para escrever programas que
imprimir(animais de estimação)
Um loop while repete um bloco de código enquanto uma condição solicitam entrada, mas precisará executar esses programas a partir de
for True. um terminal.
enquanto 'gato' em animais de estimação:
contando até 5 animais de estimação.remove('gato')

número_atual = 1 Você pode usar a instrução break e a instrução continue imprimir(animais de estimação)

com qualquer um dos loops do Python. Por exemplo, você pode

enquanto current_number <= 5:
usar break para sair de um loop for que está trabalhando em uma
imprimir(número_atual) Mais folhas de dicas disponíveis em
lista ou dicionário. Você pode usar continue para pular certos itens
número_atual += 1
ao percorrer uma lista ou dicionário também.
Machine Translated by Google

Os dois principais tipos de argumentos são argumentos Uma função pode retornar um valor ou um conjunto de valores.
posicionais e palavras-chave. Quando você usa argumentos Quando uma função retorna um valor, a linha de chamada deve
fornecer
posicionais, o Python corresponde ao primeiro argumento na chamada de função com uma variável na qual armazenar o valor de retorno. Uma
o primeiro parâmetro na definição da função e assim por diante. função para de executar quando atinge uma instrução de retorno.
Com argumentos de palavra-chave, você especifica a qual
parâmetro cada argumento deve ser atribuído na chamada de função. Retornando um único valor
Quando você usa argumentos de palavra-chave, a ordem def get_full_name(primeiro, último):
dos argumentos não importa. """Retorna um nome completo bem formatado."""
' '
full_name = primeiro + + último
Usando argumentos posicionais
return full_name.title()
def describe_pet(animal, nome):
"""Exibir informações sobre um animal de estimação.""" músico = get_full_name('jimi', 'hendrix')
As funções são blocos nomeados de código projetados para realizar um "
print("\nEu tenho um + animal + ".") imprimir(músico)
trabalho específico. As funções permitem que você escreva um código uma
print("Seu nome é " + nome + ".")
vez que pode ser executado sempre que você precisar realizar a mesma Retornando um dicionário
tarefa. As funções podem receber as informações de que precisam e retornar describe_pet('hamster', 'harry') def build_person(primeiro, último):
as informações que geram. O uso eficaz de funções torna seus programas describe_pet('cachorro', 'willie') """Retorna um dicionário de informações
mais fáceis de escrever, ler, testar e corrigir. sobre uma pessoa.
Usando argumentos de palavra-chave """
def describe_pet(animal, nome): pessoa = {'primeiro': primeiro, 'último': último}
"""Exibir informações sobre um animal de estimação.""" pessoa de retorno
"
A primeira linha de uma função é sua definição, marcada print("\nEu tenho um + animal + ".")
pela palavra-chave def. O nome da função é seguido por um print("Seu nome é " + nome + ".") músico = build_person('jimi', 'hendrix')
conjunto de parênteses e dois pontos. Uma docstring, entre imprimir(músico)
aspas triplas, descreve o que a função faz. O corpo de uma describe_pet(animal='hamster', name='harry')
função é recuado um nível. describe_pet(name='willie', animal='cachorro') Retornando um dicionário com valores opcionais

Para chamar uma função, forneça o nome da função seguido por def build_person(primeiro, último, idade=Nenhum):
um conjunto de parênteses. """Retorna um dicionário de informações
sobre uma pessoa.
Fazendo uma função Você pode fornecer um valor padrão para um parâmetro. Quando """
as chamadas de função omitem este argumento, o valor padrão
def cumprimentar_usuário(): será usado. Os parâmetros com valores padrão devem ser listados pessoa = {'primeiro': primeiro, 'último': último}
"""Mostrar uma saudação simples.""" se idade:
após os parâmetros sem valores padrão na definição da função para
print("Olá!") que os argumentos posicionais ainda funcionem corretamente.
pessoa['idade'] = idade
pessoa de retorno
cumprimentar_usuário() Usando um valor padrão
músico = build_person('jimi', 'hendrix', 27)
def describe_pet(nome, animal='cachorro'):
imprimir(músico)
"""Exibir informações sobre um animal de estimação."""
"
As informações passadas para uma função são print("\nEu tenho um + animal + ".")
músico = build_person('janis', 'joplin')
chamadas de argumento; as informações recebidas por uma função print("Seu nome é " + nome + ".")
imprimir(músico)
são chamadas de parâmetro. Os argumentos são incluídos entre
parênteses após o nome da função e os parâmetros são listados describe_pet('harry', 'hamster')
entre parênteses na definição da função. descreva_pet('willie')
Tente executar alguns desses exemplos em pythontutor.com.
Passando um único argumento Usando None para tornar um argumento opcional

def greet_user(nome de usuário): def describe_pet(animal, name=None):

"""Mostrar uma saudação simples.""" """Exibir informações sobre um animal de estimação."""
"
print("Olá, " + usuario + "!") print("\nEu tenho um + animal + ".")
se nome:
Abrange Python 3 e Python 2
cumprimentar_user('jesse') print("Seu nome é " + nome + ".")
cumprimentar_user('diana')
cumprimentar_user('brandon') describe_pet('hamster', 'harry')
descreva_pet('cobra')
Machine Translated by Google

Você pode passar uma lista como um argumento para uma Às vezes, você não saberá quantos argumentos uma função Você pode armazenar suas funções em um arquivo separado
função e a função pode trabalhar com os valores na lista. precisará aceitar. Python permite que você colete um número arbitrário chamado módulo e, em seguida, importar as funções necessárias para o
Qualquer alteração que a função fizer na lista afetará a lista de argumentos em um parâmetro usando o operador. Um parâmetro que arquivo que contém seu programa principal. Isso permite arquivos de
*
original. Você pode evitar que uma função modifique uma lista aceita um número arbitrário de argumentos deve vir por último na programa mais limpos. (Certifique-se de que seu módulo esteja armazenado
passando uma cópia da lista como um argumento. definição da função. no mesmo diretório que seu programa principal.)
**
o O operador permite que um parâmetro colete um número
Passando uma lista como um argumento Armazenando uma função em um módulo
arbitrário de argumentos de palavra-chave.
Arquivo: pizza.py
def cumprimentar_usuários(nomes): Coletando um número arbitrário de argumentos
"""Imprima uma saudação simples para todos.""" def make_pizza(tamanho, *toppings):
para nome em nomes: def make_pizza(tamanho, *toppings): """Faça uma pizza."""
"
msg = "Olá, " print(msg) + nome + "!" """Faça uma pizza.""" print("\nFazendo uma + tamanho + " pizza.")
"
print("\nFazendo uma + tamanho + " pizza.") impressão("Coberturas:")
impressão("Coberturas:") para cobertura em coberturas:
nomes de usuário = ['hannah', 'ty', 'margot'] para cobertura em coberturas: print("-" + cobertura)
greet_users(nomes de usuário) print("-" + cobertura)
Importando um módulo inteiro
Permitir que uma função modifique uma lista Arquivo: making_pizzas.py
# Faça três pizzas com coberturas diferentes. Cada função no módulo está disponível no arquivo do programa.
O exemplo a seguir envia uma lista de modelos para uma função para
make_pizza('pequena', 'calabresa')
impressão. A lista original é esvaziada e a segunda lista é preenchida.
make_pizza('grande', 'pedaços de bacon', 'abacaxi') importar pizza
def print_models(não impresso, impresso): make_pizza('médio', 'cogumelos', 'pimentão',
"""Impressão 3D de um conjunto de modelos.""" 'cebola', 'queijo extra') pizza.make_pizza('médio', 'calabresa')
enquanto não impresso: pizza.make_pizza('pequeno', 'bacon', 'abacaxi')
Coletando um número arbitrário de argumentos de palavras-chave
current_model = não impresso.pop()
Importando uma função específica
print("Imprimindo " + modelo_atual) def build_profile(primeiro, último, **user_info): Apenas as funções importadas estão disponíveis no arquivo do programa.
impresso.append(modelo_atual) """Criar um dicionário de perfil de usuário."""
# Construa um dict com as chaves necessárias. da importação de pizza make_pizza
# Armazene alguns designs não impressos, perfil = {'primeiro': primeiro, 'último': último}
# e imprima cada um deles. make_pizza('médio', 'calabresa')
não impresso = ['capa de telefone', 'pingente', 'anel'] # Adicione quaisquer outras chaves e valores. make_pizza('pequeno', 'bacon', 'abacaxi')
impresso = [] para chave, valor em user_info.items(): Dando um alias a um módulo
print_models(não impresso, impresso) perfil[chave] = valor
importar pizza como p
print("\nNão impresso:", não impresso) perfil de retorno
print("Impresso:", impresso) p.make_pizza('médio', 'calabresa')
# Crie dois usuários com tipos diferentes p.make_pizza('pequeno', 'bacon', 'abacaxi')
Impedir que uma função modifique uma lista
# de informação.
O exemplo a seguir é igual ao anterior, exceto que a lista original permanece inalterada Dando um alias a uma função
após a chamada de print_models(). user_0 = build_profile('albert', 'einstein',
localização='princeton') de pizza importar make_pizza como mp
def print_models(não impresso, impresso): user_1 = build_profile('marie', 'curie',
"""Impressão 3D de um conjunto de modelos.""" localização='paris', campo='química') mp('médio', 'calabresa')
enquanto não impresso:
mp('pequeno', 'bacon', 'abacaxi')
current_model = não impresso.pop() imprimir(usuário_0)
print("Imprimindo " + modelo_atual) Importando todas as funções de um módulo
imprimir(usuário_1)
impresso.append(modelo_atual) Não faça isso, mas reconheça-o quando o vir no código de outras pessoas. Isso
pode resultar em conflitos de nomenclatura, o que pode causar erros.

# Armazene alguns designs não impressos, da importação de pizza *

# e imprima cada um deles. Como você pode ver, existem muitas maneiras de escrever e
original = ['capa de telefone', 'pingente', 'anel'] chamar uma função. Quando você está começando, aponte para algo make_pizza('médio', 'calabresa')
impresso = [] que simplesmente funcione. À medida que você ganha experiência, make_pizza('pequeno', 'bacon', 'abacaxi')
você desenvolverá uma compreensão das vantagens mais sutis de
print_models(original[:], impresso) diferentes estruturas, como argumentos posicionais e palavras-chave,
print("\nOriginal:", original) e as várias abordagens para importar funções. Por enquanto, se suas Mais folhas de dicas disponíveis em
print("Impresso:", impresso) funções fazem o que você precisa, você está indo bem.
Machine Translated by Google

Se a classe que você está escrevendo for uma versão especializada

Criando um objeto de uma classe
de outra classe, você pode usar a herança. Quando uma classe
meu_carro = Carro('audi', 'a4', 2016) herda de outra, ela assume automaticamente todos os atributos e
métodos da classe pai. A classe filha é livre para introduzir novos
Acessando valores de atributos atributos e métodos e substituir atributos e métodos da classe pai.
print(meu_carro.marca)
Para herdar de outra classe inclua o nome da
print(meu_carro.modelo)
classe pai entre parênteses ao definir a nova classe.
print(meu_carro.ano)
As classes são a base da programação orientada a objetos. O método __init__() para uma classe filha
Métodos de chamada
As classes representam coisas do mundo real que você deseja
classe ElectricCar(Carro):
modelar em seus programas: por exemplo, cachorros, carros e meu_carro.fill_tank()
"""Um modelo simples de carro elétrico."""
robôs. Você usa uma classe para criar objetos, que são instâncias meu_carro.drive()
específicas de cachorros, carros e robôs. Uma classe define o def __init__(auto, marca, modelo, ano):
Criando vários objetos
comportamento geral que toda uma categoria de objetos pode ter e as """Inicializar um carro elétrico."""
informações que podem ser associadas a esses objetos. meu_carro = Carro('audi', 'a4', 2016) super().__init__(marca, modelo, ano)
my_old_car = Car('subaru', 'outback', 2013)
meu_caminhão = Carro('toyota', 'tacoma', 2010) # Atributos específicos para carros elétricos.
As classes podem herdar umas das outras - você pode
escreva uma classe que estenda a funcionalidade de uma # Capacidade da bateria em kWh.
classe existente. Isso permite que você codifique com eficiência para self.battery_size = 70
# Nível de carga em %.
uma ampla variedade de situações. Você pode modificar o valor de um atributo diretamente ou pode
self.charge_level = 0
escrever métodos que gerenciam a atualização de valores com mais cuidado.
Adicionando novos métodos à classe filha
Modificando um atributo diretamente
Considere como podemos modelar um carro. Que informação classe ElectricCar(Carro):
meu_novo_carro = Carro('audi', 'a4', 2016)
associaríamos a um carro e que comportamento ele teria? As --recorte--
informações são armazenadas em variáveis chamadas de atributos, my_new_car.fuel_level = 5
carga def (auto):
e o comportamento é representado por funções. Escrevendo um método para atualizar o valor de um atributo """Carregue totalmente o veículo."""
As funções que fazem parte de uma classe são chamadas de métodos. self.charge_level = 100
def update_fuel_level(self, new_level):
A classe Carro print("O veículo está totalmente carregado.")
"""Atualizar o nível de combustível."""
if new_level <= self.fuel_capacity: Usando métodos filhos e métodos pais
classe Carro():
self.fuel_level = new_level
"""Uma simples tentativa de modelar um carro.""" my_ecar = ElectricCar('tesla', 'modelos', 2016)
senão:
print("O tanque não aguenta tanto!")
def __init__(auto, marca, modelo, ano): my_ecar.charge()
"""Inicializar os atributos do carro.""" Escrevendo um método para incrementar o valor de um atributo meu_ecar.drive()
self.make = fazer
self.model = modelo def add_fuel(auto, quantidade):
"""Adicione combustível ao tanque."""
auto.ano = ano
if (self.fuel_level + quantidade
# Capacidade e nível de combustível em galões. <= self.fuel_capacity): Há muitas maneiras de modelar objetos e situações do mundo
self.fuel_capacity = 15 self.fuel_level += quantidade real no código e, às vezes, essa variedade pode parecer
self.fuel_level = 0 print("Combustível adicionado.") esmagadora. Escolha uma abordagem e tente – se sua primeira
senão: tentativa não funcionar, tente uma abordagem diferente.
def fill_tank(self): print("O tanque não vai aguentar tanto.")
"""Encha o tanque de gasolina até a capacidade máxima."""
self.fuel_level = self.fuel_capacity
print("O tanque de combustível está cheio.")

Em Python, os nomes das classes são escritos em CamelCase e os nomes Abrange Python 3 e Python 2
unidade def (auto): dos objetos são escritos em letras minúsculas com sublinhados. Os módulos
"""Simular condução.""" que contêm classes ainda devem ser nomeados em letras minúsculas com
print("O carro esta em movimento.") sublinhados.
Machine Translated by Google

Os arquivos de turma podem ficar longos à medida que você adiciona

Substituindo métodos pais As classes devem herdar do objeto
informações e funcionalidades detalhadas. Para ajudar a manter seus arquivos
class ElectricCar(Car): --snip-- de programa organizados, você pode armazenar suas aulas em módulos e class ClassName(objeto):
def fill_tank(self): """Exibe importar as aulas necessárias para seu programa principal.
A classe Car no Python 2.7
uma mensagem de erro.""" Armazenando classes em um
print("Este carro não tem tanque de arquivo car.py classe Carro(objeto):
combustível!")
"""Representam carros a gasolina e elétricos.""" O método __init__() da classe filha é diferente

class ChildClassName(ParentClass): def

Uma classe pode ter objetos como atributos. Isso permite que as
classes trabalhem juntas para modelar situações complexas.
Uma classe de bateria
class Battery():
"""Uma bateria para um carro elétrico."""
def __init__(self, size=70): """Inicializar
atributos da bateria."""
# Capacidade em kWh, nível de carga em %.
self.size = tamanho self.charge_level = 0
def get_range(self):
"""Retorna o alcance da bateria.""" if self.size
== 70: retorna 240
elif self.size == 85:
retornar 270
Usando uma instância como um atributo
class ElectricCar(Carro): --
snip--
def __init__(self, make, model, year): """Inicializar
um carro elétrico.""" super().__init__(marca,
modelo, ano)
# Atributo específico para carros elétricos.
self.bateria = Bateria()
class Car():
__init__(self): super(ClassName,
"""Uma tentativa simples de modelar um carro.""" --
self).__init__()
snip—
A classe ElectricCar na classe Python 2.7
class Battery():
"""Uma bateria para um carro elétrico.""" --snip-- ElectricCar(Car): def __init__(self, make,
model, year): super(ElectricCar, self).__init__( make,
model, year)
classe ElectricCar(Carro):
"""Um modelo simples de um carro elétrico.""" --snip--
Importando classes individuais de um módulo Uma lista pode conter quantos itens você quiser, então você
meus_carros.py pode criar um grande número de objetos de uma classe e
armazená-los em uma lista.
da importação de carros Car, ElectricCar Aqui está um exemplo mostrando como fazer uma frota de aluguel
carros e verifique se todos os carros estão prontos para dirigir.
my_beetle = Car('volkswagen', 'beetle', 2016)
Uma frota de carros alugados
my_beetle.fill_tank() my_beetle.drive()
da importação de carros Car, ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2016) # Faça listas para manter uma frota de carros.
my_tesla.charge() my_tesla.drive() gas_fleet = [] electric_fleet = []
Importando um módulo inteiro # Faça 500 carros a gasolina e 250 carros elétricos. por
_ in range(500): car
carro importado = Car('ford', 'focus', 2016)
gas_fleet.append(car) in range(250):
my_beetle = por _
car.Car( 'volkswagen', 'beetle', 2016) ecar = ElectricCar('nissan', 'folha', 2016)
my_beetle.fill_tank() my_beetle.drive() electric_fleet.append(ecar)

def charge(self): # Encha os carros a gás e carregue os carros elétricos. para

"""Carregue totalmente o veículo.""" my_tesla = car.ElectricCar( 'tesla', carro em gas_fleet: car.fill_tank() para ecar em electric_fleet:
self.battery.charge_level = 100 print("O 'model s', 2016) my_tesla.charge() ecar.charge()
veículo está totalmente carregado.") my_tesla.drive()

Usando a instância
Importando todas as classes de um módulo
my_ecar = ElectricCar('tesla', 'modelo x', 2016) (não faça isso, mas reconheça quando o vir). print("Carros a gasolina:", len(gas_fleet))
print("Carros elétricos:", len(electric_fleet))
da importação do carro *
my_ecar.charge()
print(my_ecar.battery.get_range()) Mais folhas de dicas disponíveis em
meu_fusca = Carro('volkswagen', 'fusca', 2016)
my_ecar.drive()
Machine Translated by Google

Armazenando as linhas em uma lista Abrindo um arquivo usando um caminho absoluto

nome do arquivo = 'siddhartha.txt' f_path = "/home/ehmatthes/books/alice.txt"

com open(filename) como f_obj: com open(f_path) como f_obj:

linhas = f_obj.readlines() linhas = f_obj.readlines()

para linha em linhas: Abrindo um arquivo no Windows

Às vezes, o Windows interpreta as barras incorretamente. Se você se deparar
print(line.rstrip())
com isso, use barras invertidas em seus caminhos de arquivo.

f_path = "C:\Users\ehmatthes\books\alice.txt"
Seus programas podem ler informações de arquivos e podem gravar dados
Passar o argumento 'w' para open() informa ao Python que você com open(f_path) como f_obj:
em arquivos. A leitura de arquivos permite que você trabalhe com uma ampla deseja gravar no arquivo. Tome cuidado; isso apagará o conteúdo linhas = f_obj.readlines()
variedade de informações; gravar em arquivos permite que os usuários do arquivo, se ele já existir. Passar o argumento 'a' informa ao
continuem de onde pararam na próxima vez que executarem seu programa. Python que você deseja anexar ao final de um arquivo existente.
Você pode gravar texto em arquivos e armazenar estruturas Python, como
Escrevendo em um arquivo vazio
listas em arquivos de dados. Quando você acha que pode ocorrer um erro, pode escrever
nome do arquivo = 'programação.txt' um bloco try except para lidar com a exceção que pode ser levantada.
O bloco try diz ao Python para tentar executar algum código, e o
com open(filename, 'w') como f: bloco except diz ao Python o que fazer se o código resultar em um
Exceções são objetos especiais que ajudam seus programas a
f.write("Eu amo programar!") determinado tipo de erro.
responder a erros de maneira apropriada. Por exemplo, se o seu programa
tentar abrir um arquivo que não existe, você pode usar exceções para exibir Escrevendo várias linhas em um arquivo vazio Manipulando a exceção ZeroDivisionError
uma mensagem de erro informativa em vez de travar o programa.
tentar:
nome do arquivo = 'programação.txt'
imprimir(5/0)
com open(filename, 'w') como f: exceto ZeroDivisionError:
f.write("Eu amo programar!\n") print("Você não pode dividir por zero!")
f.write("Adoro criar novos jogos.\n") Manipulando a exceção FileNotFoundError
Para ler um arquivo, seu programa precisa abrir o arquivo e ler o
Anexando a um arquivo f_name = 'siddhartha.txt'
conteúdo do arquivo. Você pode ler todo o conteúdo do arquivo
de uma vez ou ler o arquivo linha por linha. A instrução with nome do arquivo = 'programação.txt'
garante que o arquivo seja fechado corretamente quando o tentar:

programa terminar de acessar o arquivo. com open(filename, 'a') como f: com open(f_name) como f_obj:
f.write("Também adoro trabalhar com dados.\n") linhas = f_obj.readlines()
Lendo um arquivo inteiro de uma só vez exceto FileNotFoundError:
f.write("Eu também adoro criar aplicativos.\n")
nome do arquivo = 'siddhartha.txt' msg = "Não foi possível encontrar o arquivo {0}.".format(f_name)
imprimir(mensagem)

com open(filename) como f_obj:

conteúdo = f_obj.read() Quando o Python executa a função open(), ele procura o arquivo no
mesmo diretório onde está armazenado o programa que está sendo
Pode ser difícil saber que tipo de exceção lidar ao escrever
executado. Você pode abrir um arquivo de uma subpasta usando um
imprimir(conteúdo) código. Tente escrever seu código sem um bloco try e gere um
caminho relativo. Você também pode usar um caminho absoluto para abrir
Lendo linha por linha qualquer arquivo em seu sistema.
erro. O traceback informará que tipo de exceção seu programa
Cada linha lida do arquivo possui um caractere de nova linha no final da linha precisa tratar.
e a função de impressão adiciona seu próprio caractere de nova linha. O Abrindo um arquivo de uma subpasta
método rstrip() elimina as linhas em branco extras que isso resultaria ao imprimir
f_path = "text_files/alice.txt"
no terminal.

nome do arquivo = 'siddhartha.txt' com open(f_path) como f_obj:

Abrange Python 3 e Python 2
linhas = f_obj.readlines()
com open(filename) como f_obj:
para linha em f_obj: para linha em linhas:
print(line.rstrip()) print(line.rstrip())
Machine Translated by Google

O bloco try deve conter apenas código que pode causar um erro. Às vezes, você deseja que seu programa continue em execução quando O módulo json permite despejar estruturas de dados Python simples
Qualquer código que dependa da execução bem-sucedida do bloco encontrar um erro, sem relatar o erro ao usuário. Usar a instrução pass em um arquivo e carregar os dados desse arquivo na próxima vez que
try deve ser colocado no bloco else. em um bloco else permite que você faça isso. o programa for executado. O formato de dados JSON não é específico
do Python, portanto, você também pode compartilhar esse tipo de
Usando um bloco else
dados com pessoas que trabalham em outras linguagens.
Usando a instrução pass em um bloco else
print("Digite dois números. Vou dividi-los.")
f_names = ['alice.txt', 'siddhartha.txt', Saber como gerenciar exceções é importante ao trabalhar com
x = input("Primeiro número: ") 'moby_dick.txt', 'little_women.txt'] dados armazenados. Você geralmente deseja certificar-se de que os
y = input("Segundo número: ") dados que está tentando carregar existem antes de trabalhar com eles.
para f_name em f_names: Usando json.dump() para armazenar dados
tentar: # Informa o comprimento de cada arquivo encontrado.
resultado = int(x) / int(y) tentar: """Armazenar alguns números."""

exceto ZeroDivisionError: com open(f_name) como f_obj:

print("Você não pode dividir por zero!") linhas = f_obj.readlines() importar json
senão: exceto FileNotFoundError:
imprimir(resultado) # Basta passar para o próximo arquivo. números = [2, 3, 5, 7, 11, 13]
passar
Evitando travamentos da entrada do usuário senão: nome do arquivo = 'numbers.json'
Sem o bloco exceto no exemplo a seguir, o programa falharia se o
num_lines = len(linhas) com open(filename, 'w') como f_obj:
usuário tentasse dividir por zero. Conforme escrito, ele lidará com
msg = "{0} tem {1} linhas.".format( json.dump(números, f_obj)
o erro normalmente e continuará em execução.
f_name, num_lines)
Usando json.load() para ler dados
"""Uma calculadora simples apenas para divisão.""" imprimir(mensagem)

"""Carregar alguns números armazenados anteriormente."""

print("Digite dois números. Vou dividi-los.")
print("Digite 'q' para sair.") importar json
O código de tratamento de exceção deve capturar exceções específicas
enquanto verdadeiro: que você espera que aconteçam durante a execução do programa.
nome do arquivo = 'numbers.json'
x = input("\nPrimeiro número: ") Um bloco exceto simples capturará todas as exceções, incluindo
com open(filename) como f_obj:
se x == 'q': interrupções de teclado e saídas do sistema que você pode precisar ao
números = json.load(f_obj)
parar forçar o fechamento de um programa.
y = input("Segundo número: ") imprimir(números)
se y == 'q': Se você quiser usar um bloco try e não tiver certeza de qual
parar exceção capturar, use Exception. Ele capturará a maioria das Certificando-se de que os dados armazenados existem
exceções, mas ainda permitirá que você interrompa programas
intencionalmente. importar json
tentar:
resultado = int(x) / int(y) Não use nu, exceto blocos f_name = 'numbers.json'
exceto ZeroDivisionError:
print("Você não pode dividir por zero!") tentar:
tentar:
senão: # Faça alguma coisa
com open(f_name) como f_obj:
imprimir(resultado) exceto:
números = json.load(f_obj)
passar
exceto FileNotFoundError:
Use exceção em vez disso msg = "Não foi possível encontrar {0}.".format(f_name)
imprimir(mensagem)
Um código bem escrito e devidamente testado não é muito tentar: senão:
propenso a erros internos, como sintaxe ou erros lógicos. Mas toda # Faça alguma coisa
vez que seu programa depende de algo externo, como a entrada do imprimir(números)
exceto Exceção:
usuário ou a existência de um arquivo, existe a possibilidade de uma
passar
exceção ser levantada. Pratique com exceções
Imprimindo a exceção Pegue um programa que você já escreveu que solicita entrada do usuário
Cabe a você como comunicar os erros aos seus usuários. e adicione algum código de tratamento de erros ao programa.
tentar:
Às vezes, os usuários precisam saber se um arquivo está
# Faça alguma coisa
faltando; às vezes é melhor lidar com o erro silenciosamente. Um Mais folhas de dicas disponíveis em
exceto Exceção como e:
pouco de experiência o ajudará a saber quanto relatar.
print(e, digite(e))
Machine Translated by Google

Construindo um caso de teste com um teste de unidade Executando o teste

Para construir um caso de teste, crie uma classe herdada de Quando você altera seu código, é importante executar os testes existentes. Isso
unittest.TestCase e escreva métodos que comecem com test_. informará se as alterações feitas afetaram o comportamento existente.
Salve isso como test_full_names.py

importar unidade de teste E

de full_names importar get_full_name ================================================
ERRO: test_first_last (__main__.NamesTestCase)
class NamesTestCase(unittest.TestCase): Nomes de teste como Janis Joplin.
------------------------------------------------
"""Testes para names.py."""
Traceback (última chamada mais recente):
def test_first_last(self): Arquivo "test_full_names.py", linha 10,
Ao escrever uma função ou uma classe, você também pode """Nomes de teste como Janis Joplin.""" em test_first_last
escrever testes para esse código. O teste prova que seu código nome_completo = get_nome_completo('janis', 'joplin')
funciona como deveria nas situações para as quais foi projetado 'joplin') TypeError: get_full_name() faltando 1 argumento posicional
e também quando as pessoas usam seus programas de maneiras self.assertEqual(nome_completo, obrigatório: 'last'
inesperadas. Escrever testes dá a você a confiança de que seu 'Janis Joplin')
------------------------------------------------
código funcionará corretamente à medida que mais pessoas
unittest.main() Realizou 1 teste em 0,001s
começarem a usar seus programas. Você também pode adicionar
novos recursos aos seus programas e saber que não quebrou o
Executando o teste FALHA (erros = 1)
comportamento existente. O Python relata cada teste de unidade no caso de teste. O ponto relata uma única
passagem no teste. O Python nos informa que executou 1 teste em menos de 0,001
Corrigindo o código
segundos e o OK nos informa que todos os testes de unidade no caso de teste foram Quando um teste falha, o código precisa ser modificado até que o teste passe
Um teste de unidade verifica se um aspecto específico do seu
aprovados. novamente. (Não cometa o erro de reescrever seus testes para ajustá-los ao seu novo
código funciona como deveria. Um caso de teste é uma coleção
. código.) Aqui podemos tornar o nome do meio opcional.
de testes de unidade que verificam o comportamento do seu
---------------------------------------
código em uma ampla variedade de situações. def get_full_name(primeiro, último, meio=''):
Realizou 1 teste em 0,000s """Retorne um nome completo."""
se meio:
OK full_name = "{0} {1} {2}".format(primeiro,
O módulo unittest do Python fornece ferramentas para testar seu meio, último)
código. Para experimentar, criaremos uma função que retorna um nome senão:
completo. Usaremos a função em um programa regular e, em seguida, full_name = "{0} {1}".format(primeiro,
criaremos um caso de teste para a função. A reprovação nos testes é importante; eles informam que uma alteração no
último)
código afetou o comportamento existente. Quando um teste falha, você
Uma função para testar return full_name.title()
precisa modificar o código para que o comportamento existente ainda funcione.
Salve isso como full_names.py
Executando o teste
Modificando a função Agora o teste deve passar novamente, o que significa que nossa
def get_full_name(primeiro, último): Modificaremos get_full_name() para que ele lide com nomes do meio, mas faremos
"""Retorne um nome completo.""" funcionalidade original ainda está intacta.
isso de uma forma que interrompa o comportamento existente.
full_name = "{0} {1}".format(primeiro, último) .
def get_full_name(primeiro, meio, último): ---------------------------------------
return full_name.title()
"""Retorne um nome completo."""
Realizou 1 teste em 0,000s
Usando a função full_name = "{0} {1} {2}".format(primeiro,
Salve isso como names.py meio, último)
OK
return full_name.title()
de full_names importar get_full_name
Usando a função
janis = get_full_name('janis', 'joplin')
print(janis) de full_names importar get_full_name

bob = get_full_name('bob', 'dylan') john = get_full_name('john', 'lee', 'prostituta')

Abrange Python 3 e Python 2
imprimir (bob) imprimir(joão)

david = get_full_name('david', 'lee', 'roth')

imprimir (david)
Machine Translated by Google

Você pode adicionar quantos testes de unidade precisar a um caso de teste. Testar uma classe é semelhante a testar uma função, já que você estará Ao testar uma classe, você geralmente precisa criar uma instância
Para escrever um novo teste, adicione um novo método à sua classe de caso testando principalmente seus métodos. da classe. O método setUp() é executado antes de cada teste.
de teste. Quaisquer instâncias que você criar em setUp() estarão disponíveis em todos os testes
Uma classe para
que você escrever.
Testando nomes do meio testar Salvar como accountant.py
Mostramos que get_full_name() funciona para nomes e Usando setUp() para suportar vários testes A
sobrenomes. Vamos testar se também funciona para nomes do meio. class Accountant(): instância self.acc pode ser usada em cada novo teste.
"""Gerenciar uma conta bancária."""
importar unittest de importar unittest do
full_names importar get_full_name def __init__(self, balance=0): self.balance contador importar contador
= balance
class NamesTestCase(unittest.TestCase): """Testes class TestAccountant(unittest.TestCase):
para names.py.""" def deposit(auto, valor): self.saldo """Testes para a classe Contador."""
+= valor
def test_first_last(self): """Testar def setUp(self):
nomes como Janis Joplin.""" full_name = def saque(auto, valor): self.saldo -= self.acc = Accountant()
get_full_name('janis', 'joplin') valor
self.assertEqual(full_name, 'Janis def test_initial_balance(self):
Joplin') Construindo um caso de # O saldo padrão deve ser 0.
teste Para o primeiro teste, vamos nos certificar de que podemos começar
self.assertEqual(self.acc.balance, 0)
com diferentes saldos iniciais. Salve-o como test_accountant.py.

def test_middle(self): """Nomes importar unittest do # Teste o saldo não padrão. acc =
de teste como David Lee Roth.""" full_name = contador importar contador Contador(100)
get_full_name('david', 'roth', 'lee') self.assertEqual(acc.saldo, 100)
class TestAccountant(unittest.TestCase):
self.assertEqual(nome_completo, """Testes para a classe Contador.""" def test_deposit(self):
'David Lee Roth') # Teste o depósito único.
def test_initial_balance(self): self.acc.deposit(100)
unittest.main() # O saldo padrão deve ser 0. acc = self.assertEqual(self.acc.balance, 100)
Accountant() self.assertEqual(acc.balance,
Executando os testes Os
0) # Teste vários depósitos.
dois pontos representam dois testes aprovados.
self.acc.deposit(100)
.. # Teste o saldo não padrão. self.acc.deposit(100)
--------------------------------------- acc = Contador(100) self.assertEqual(self.acc.balance, 300)
Realizou 2 testes em 0,000s self.assertEqual(acc.saldo, 100)
def test_withdrawal(self):
OK unittest.main() # Teste de retirada única.
self.acc.deposit(1000)
Executando o teste
self.acc.withdraw(100)
. self.assertEqual(self.acc.balance, 900)
O Python fornece vários métodos assert que você pode usar ---------------------------------------
para testar seu código.
Realizou 1 teste em 0,000s unittest.main()
Verifique se a==b ou a != b
OK Executando os testes
assertEqual(a, b)
...
assertNotEqual(a, b) ---------------------------------------
Verifique se x é verdadeiro ou x é falso Realizou 3 testes em 0,001s
Em geral, você não deve modificar um teste depois de escrito.
Quando um teste falha, geralmente significa que o novo código que você
assertTrue(x) OK
escreveu quebrou a funcionalidade existente e você precisa modificar o novo
assertFalse(x)
código até que todos os testes existentes sejam aprovados.
Verifique se um item está em uma lista ou não está em uma lista Se seus requisitos originais foram alterados, pode ser
apropriado modificar alguns testes. Isso geralmente acontece nos Mais folhas de dicas disponíveis em
assertIn(item, lista)
estágios iniciais de um projeto, quando o comportamento desejado
assertNotIn(item, lista)
ainda está sendo resolvido.
Machine Translated by Google

O código a seguir configura uma janela de jogo vazia e inicia um Atributos rect úteis
loop de eventos e um loop que atualiza continuamente a tela. Uma vez que você tenha um objeto reto, há vários atributos que são úteis ao posicionar
objetos e detectar posições relativas de objetos. (Você pode encontrar mais atributos na

Uma janela de jogo vazia documentação do Pygame.)

sistema de importação
# Valores individuais de x e y:
importar pygame como pg
screen_rect.esquerda, screen_rect.direita
Pygame é um framework para fazer jogos usando Python. screen_rect.top, screen_rect.bottom
def run_game():
screen_rect.centerx, screen_rect.centery
Fazer jogos é divertido e é uma ótima maneira de expandir suas # Inicializar e configurar a tela.
screen_rect.width, screen_rect.height
habilidades e conhecimentos de programação. pg.init()
O Pygame cuida de muitas das tarefas de nível inferior na tela = pg.display.set_mode((1200, 800))
# Tuplas
construção de jogos, o que permite que você se concentre nos pg.display.set_caption("Invasão Alienígena")
screen_rect.center
aspectos de seu jogo que o tornam interessante. screen_rect.size
# Inicia o loop principal.
enquanto verdadeiro: Criando um objeto reto
# Inicia o loop de eventos. Você pode criar um objeto reto do zero. Por exemplo, um pequeno objeto reto preenchido
para o evento em pg.event.get(): pode representar um marcador em um jogo. A classe Rect() usa as coordenadas do
O Pygame é executado em todos os sistemas, mas a configuração é canto superior esquerdo e a largura e a altura do retângulo. A função draw.rect() pega
ligeiramente diferente em cada sistema operacional. As instruções aqui if event.type == pg.QUIT:
um objeto de tela, uma cor e um retângulo. Esta função preenche o retângulo dado com
assumem que você está usando o Python 3 e fornecem uma instalação sys.exit()
a cor dada.
mínima do Pygame. Se essas instruções não funcionarem para o seu
# Atualizar tela.
sistema, consulte as notas mais detalhadas em http:// ehmatthes.github.io/ pcc/.
pg.display.flip() bullet_rect = pg.Rect(100, 100, 3, 15)
Pygame no Linux cor = (100, 100, 100)
run_game() pg.draw.rect(tela, cor, bullet_rect)
$ sudo apt-get install python3-dev mercurial
libsdl-image1.2-dev libsdl2-dev Definindo um tamanho de janela personalizado
libsdl-ttf2.0-dev A função display.set_mode() aceita uma tupla que define o tamanho da tela.
$ pip install --user Muitos objetos em um jogo são imagens que se movem pela tela. É
hg+http://bitbucket.org/pygame/pygame mais fácil usar arquivos de imagem bitmap (.bmp), mas você também
screen_dim = (1200, 800)
Pygame no OS X pode configurar seu sistema para trabalhar com arquivos jpg, png e gif.
tela = pg.display.set_mode(screen_dim)
Isso pressupõe que você usou o Homebrew para instalar o Python 3.
Definir uma cor de fundo personalizada
Carregando uma imagem
$ brew install hg sdl sdl_image sdl_ttf As cores são definidas como uma tupla de valores de vermelho, verde e azul. Cada
valor varia de 0-255.
$ pip install --user ship = pg.image.load('images/ship.bmp')
hg+http://bitbucket.org/pygame/pygame
bg_color = (230, 230, 230) Obtendo o objeto reto de uma imagem
Pygame no Windows screen.fill(bg_color)
Encontre um instalador em ship_rect = ship.get_rect()
https:// bitbucket.org/ pygame/ pygame/ downloads/ ou http://
www.lfd.uci.edu/ ~gohlke/ pythonlibs/ #pygame que corresponda à sua versão do Posicionando uma imagem
Python. Execute o arquivo do instalador se for um arquivo .exe ou .msi. Com rects, é fácil posicionar uma imagem onde quiser na tela ou em relação a outro
Muitos objetos em um jogo podem ser tratados como
Se for um arquivo .whl, use pip para instalar o Pygame: objeto. O código a seguir posiciona um objeto de navio na parte inferior central da tela.
retângulos simples, em vez de sua forma real. Isso simplifica o
código sem afetar visivelmente o jogo. Pygame tem um objeto rect que
> python –m pip install --user
facilita o trabalho com objetos de jogo. ship_rect.midbottom = screen_rect.midbottom
pygame-1.9.2a0-cp35-none-win32.whl
Obtendo o objeto de tela reta
Testando sua instalação
Já temos um objeto de tela; podemos acessar facilmente o objeto rect associado à
Para testar sua instalação, abra uma sessão de terminal e tente importar o Pygame.
tela.
Se você não receber nenhuma mensagem de erro, sua instalação foi bem-sucedida.

screen_rect = screen.get_rect()
$ python
Abrange Python 3 e Python 2
Encontrando o centro da tela
>>> importar pygame Os objetos Rect possuem um atributo center que armazena o ponto central.
>>>
screen_center = screen_rect.center
Machine Translated by Google

O loop de eventos do Pygame registra um evento sempre que

Desenhar uma imagem na tela Removendo um item de um grupo
o mouse se move ou um botão do mouse é pressionado ou liberado.
Depois que uma imagem é carregada e posicionada, você pode desenhá-la na É importante deletar elementos que nunca mais irão aparecer no jogo, para não
tela com o método blit(). O método blit() atua no objeto de tela e recebe o objeto de Respondendo ao botão do mouse desperdiçar memória e recursos.
imagem e o retângulo de imagem como argumentos.
para o evento em pg.event.get(): balas.remove(bala)
# Desenhe o navio na tela. if event.type == pg.MOUSEBUTTONDOWN:
screen.blit(ship, ship_rect) ship.fire_bullet()
O método blitme() Encontrando a posição do mouse Você pode detectar quando um único objeto colide com
Objetos de jogo, como navios, geralmente são escritos como classes. Em seguida, qualquer membro de um grupo. Você também pode detectar quando
A posição do mouse é retornada como uma tupla.
geralmente é definido um método blitme(), que desenha o objeto na tela. algum membro de um grupo colide com um membro de outro grupo.
mouse_pos = pg.mouse.get_pos()
Colisões entre um único objeto e um grupo
def blitme(auto): Clicando em um botão A função spritecollideany() pega um objeto e um grupo e retorna True se o objeto
"""Desenhar navio no local atual.""" Você pode querer saber se o cursor está sobre um objeto como um botão. O se sobrepõe a qualquer membro do grupo.
self.screen.blit(self.image, self.rect) método rect.collidepoint() retorna true quando um ponto está dentro de um objeto
rect. if pg.sprite.spritecollideany(nave, alienígenas):
ship_left -= 1
if button_rect.collidepoint(mouse_pos):
O Pygame observa eventos como pressionamentos de teclas Começar o jogo() Colisões entre dois grupos
A função sprite.groupcollide() aceita dois grupos e dois booleanos. A função
e ações do mouse. Você pode detectar qualquer evento de seu Escondendo o mouse retorna um dicionário contendo informações sobre os membros que colidiram. Os
interesse no loop de eventos e responder com qualquer ação
booleanos dizem ao Pygame se devem excluir os membros de qualquer um dos
apropriada para o seu jogo. pg.mouse.set_visible(Falso)
grupos que colidiram.

Respondendo a teclas pressionadas colisões = pg.sprite.groupcollide(

O loop de evento principal do Pygame registra um evento KEYDOWN sempre que balas, alienígenas, Verdadeiro, Verdadeiro)
uma tecla é pressionada. Quando isso acontece, você pode verificar chaves Pygame tem uma classe Group que facilita o trabalho com um
específicas.
grupo de objetos semelhantes. Um grupo é como uma lista, pontuação += len(colisões) * alien_point_value
para o evento em pg.event.get(): com algumas funcionalidades extras que são úteis na criação de jogos.
if event.type == pg.KEYDOWN:
Fazendo e preenchendo um grupo
if event.key == pg.K_RIGHT:
Um objeto que será colocado em um grupo deve herdar de Sprite. Você pode usar o texto para uma variedade de propósitos em um
ship_rect.x += 1
de pygame.sprite importar Sprite, Grupo jogo. Por exemplo, você pode compartilhar informações com os
elif event.key == pg.K_LEFT:
jogadores e exibir uma pontuação.
ship_rect.x -= 1
elif event.key == pg.K_SPACE: bala def (Sprite): Exibindo uma mensagem
ship.fire_bullet() ... O código a seguir define uma mensagem, uma cor para o texto e a cor de fundo para
elif event.key == pg.K_q: def draw_bullet(self): a mensagem. Uma fonte é definida usando a fonte padrão do sistema, com um
sys.exit() ... tamanho de fonte de 48. A função font.render() é usada para criar uma imagem da
atualização def(auto): mensagem e obtemos o objeto reto associado à imagem. Em seguida, centralizamos
Respondendo a chaves liberadas ... a imagem na tela e a exibimos.
Quando o usuário libera uma tecla, um evento KEYUP é acionado.

if event.type == pg.KEYUP: balas = Grupo() msg = "Jogar novamente?"

if event.key == pg.K_RIGHT: msg_color = (100, 100, 100)
ship.moving_right = Falso new_bullet = Bullet() bg_color = (230, 230, 230)
bullets.add(new_bullet)
f = pg.font.SysFont(Nenhuma, 48)
Percorrendo os itens em um grupo
msg_image = f.render(msg, True, msg_color,
A documentação do Pygame é realmente útil ao criar seus O método sprites() retorna todos os membros de um grupo.
bg_color)
próprios jogos. A página inicial do projeto Pygame está em para marcador em bullets.sprites(): msg_image_rect = msg_image.get_rect()
http:// pygame.org/ e a página inicial da documentação está bullet.draw_bullet() msg_image_rect.center = screen_rect.center
em http:// pygame.org/ docs/. screen.blit(msg_image, msg_image_rect)
A parte mais útil da documentação são as páginas Chamando update () em um grupo
sobre partes específicas do Pygame, como a classe Rect() e Chamar update() em um grupo chama automaticamente update() em cada
o módulo sprite. Você pode encontrar uma lista desses elementos membro do grupo. Mais folhas de dicas disponíveis em
no topo das páginas de ajuda. bullets.update()
Machine Translated by Google
A visualização de dados envolve a exploração de dados por meio de
representações visuais. O pacote matplotlib ajuda a fazer representações
visualmente atraentes dos dados com os quais você está trabalhando. matplotlib
é extremamente
flexível; esses exemplos ajudarão você a começar com algumas visualizações
simples.
matplotlib é executado em todos os sistemas, mas a configuração é
um pouco diferente dependendo do seu sistema operacional. Se as
instruções mínimas aqui não funcionarem para você, consulte as
instruções mais detalhadas em http:// ehmatthes.github.io/ pcc/. Você
também deve considerar a instalação da distribuição Anaconda do
Python em https:// continuum.io/ downloads/, que inclui matplotlib.
matplotlib no Linux
$ sudo apt-get install python3-matplotlib
matplotlib no OS X
Inicie uma sessão de terminal e digite import matplotlib para ver se ele já
está instalado em seu sistema. Se não, tente este comando:
$ pip install --user matplotlib
matplotlib no Windows
Primeiro você precisa instalar o Visual Studio, que pode ser feito em
https:// dev.windows.com/. A edição Community é gratuita. Em seguida, vá
para https:// pypi.python.org/ pypi/ matplotlib/ ou http:// www.lfd.uic.edu/
~gohlke/ pythonlibs/ #matplotlib e baixe um arquivo de instalação apropriado.
Fazendo um gráfico de linhas
importar matplotlib.pyplot como plt
x_values = [0, 1, 2, 3, 4, 5]
quadrados = [0, 1, 4, 9, 16, 25]
plt.plot(x_values, squares)
plt.show()
Fazendo um gráfico de dispersão Pontos de ênfase
A função scatter() recebe uma lista de valores x e uma lista de valores y e Você pode plotar quantos dados quiser em um gráfico. Aqui, plotamos o
uma variedade de argumentos opcionais. O argumento s=10 controla o primeiro e o último pontos maiores para enfatizá-los.
tamanho de cada ponto.
importar matplotlib.pyplot como plt
importar matplotlib.pyplot como plt
x_values = lista(intervalo(1000))
x_values = lista(intervalo(1000)) quadrados = [x**2 para x em x_values]
quadrados = [x**2 para x em x_values] plt.scatter(x_values, quadrados, c=quadrados,
cmap=plt.cm.Blues, edgecolor='nenhum',
plt.scatter(x_values, squares, s=10) s=10)
plt.show()
plt.scatter(x_values[0], squares[0], c='green',
edgecolor='nenhum', s=100)
plt.scatter(x_values[-1], squares[-1], c='vermelho',
Os gráficos podem ser personalizados de várias maneiras. Praticamente
edgecolor='nenhum', s=100)
qualquer elemento de um enredo pode ser personalizado.
Adicionando títulos e rótulos e dimensionando eixos plt.title("Números Quadrados", tamanho da fonte=24)
--recorte--
importar matplotlib.pyplot como plt
Removendo eixos
x_values = lista(intervalo(1000)) Você pode personalizar ou remover os eixos inteiramente. Veja como
quadrados = [x**2 para x em x_values] acessar cada eixo e ocultá-lo.
plt.scatter(x_values, squares, s=10) plt.axes().get_xaxis().set_visible(Falso)
plt.axes().get_yaxis().set_visible(False)
plt.title("Números Quadrados", tamanho da fonte=24)
plt.xlabel("Valor", tamanho da fonte=18) Definindo um tamanho de figura personalizado
plt.ylabel("Quadrado de Valor", tamanho da fonte=18) Você pode fazer seu enredo tão grande ou pequeno quanto quiser.
Antes de plotar seus dados, adicione o seguinte código. O argumento
plt.tick_params(eixo='ambos', qual='maior',
dpi é opcional; se você não conhece a resolução do seu sistema, você
labelsize=14)
pode omitir o argumento e ajustar o argumento figsize de acordo.
plt.axis([0, 1100, 0, 1100000])
plt.figure(dpi=128, figsize=(10, 6))
plt.show()
Salvando um enredo
Usando um mapa de cores O visualizador matplotlib tem um botão de salvamento interativo, mas
você também pode salvar suas visualizações programaticamente. Para
Um mapa de cores varia as cores dos pontos de um tom para outro,
com base em um determinado valor para cada ponto. O valor usado fazer isso, substitua plt.show() por plt.savefig(). O bbox_inches='apertado'
para determinar a cor de cada ponto é passado para o argumento c , e o argumento corta espaço em branco extra do gráfico.
argumento cmap especifica qual mapa de cores usar.
plt.savefig('squares.png', bbox_inches='apertado')
O argumento edgecolor='none' remove o contorno preto de cada
ponto.
plt.scatter(x_values, quadrados, c=quadrados,
cmap=plt.cm.Blues, edgecolor='nenhum', A galeria e a documentação do matplotlib estão em
s=10) http:// matplotlib.org/. Certifique-se de visitar os exemplos,
galeria e links pyplot .
Abrange Python 3 e Python 2
Machine Translated by Google

Você pode fazer quantos gráficos quiser em uma figura. Você pode incluir quantos gráficos individuais quiser em uma
Argumentos de formatação de data e hora
Ao fazer vários gráficos, você pode enfatizar as relações figura. Isso é útil, por exemplo, ao comparar conjuntos de dados
A função strftime() gera uma string formatada a partir de um objeto datetime, relacionados.
nos dados. Por exemplo, você pode preencher o espaço entre dois
e a função strptime() gera um objeto datetime a partir de uma string. Os
conjuntos de dados.
códigos a seguir permitem trabalhar com datas exatamente como você precisa. Compartilhando um eixo x
Plotando dois conjuntos de dados O código a seguir plota um conjunto de quadrados e um conjunto de cubos em
Aqui usamos plt.scatter() duas vezes para plotar números quadrados e cubos dois gráficos separados que compartilham um eixo x comum.
%UMA
Nome do dia da semana, como segunda-feira
na mesma figura. A função plt.subplots() retorna um objeto figure e uma tupla
%B Nome do mês, como janeiro
de eixos. Cada conjunto de eixos corresponde a um gráfico separado na
importar matplotlib.pyplot como plt %m Mês, como um número (01 a 12) figura. Os dois primeiros argumentos controlam o número de linhas e colunas
%d Dia do mês, como um número (01 a 31) geradas na figura.
%Y Ano de quatro dígitos, como 2016
x_values = lista(intervalo(11))
%y Ano de dois dígitos, como 16 importar matplotlib.pyplot como plt
quadrados = [x**2 para x em x_values]
%H Hora, no formato de 24 horas (00 a 23)
cubos = [x**3 para x em x_values]
%EU Hora, no formato de 12 horas (01 a 12) x_vals = lista(intervalo(11))
%p AM ou PM quadrados = [x**2 para x em x_vals]
plt.scatter(x_values, squares, c='blue',
%M Minutos (00 a 59) cubos = [x**3 para x em x_vals]
edgecolor='nenhum', s=20)
%S Segundos (00 a 61)
plt.scatter(x_values, cubos, c='vermelho',
fig, axarr = plt.subplots(2, 1, sharex=True)
edgecolor='nenhum', s=20)
Convertendo uma string em um objeto datetime
axarr[0].scatter(x_vals, quadrados)
plt.axis([0, 11, 0, 1100]) new_years = dt.strptime('1/1/2017', '%m/%d/%Y')
axarr[0].set_title('Quadrados')
plt.show()
Convertendo um objeto datetime em uma string
Preenchendo o espaço entre os conjuntos de dados axarr[1].scatter(x_vals, cubos, c='vermelho')
O método fill_between() preenche o espaço entre dois conjuntos de dados. É
ny_string = dt.strftime(new_years, '%B %d, %Y') axarr[1].set_title('Cubos')
preciso uma série de valores de x e duas séries de valores de y. Também é preciso print(ny_string)
uma cor de face para usar no preenchimento e um alfa opcional plt.show()
Traçando altas temperaturas
argumento que controla a transparência da cor.
O código a seguir cria uma lista de datas e uma lista correspondente de altas Compartilhando um eixo y
plt.fill_between(x_values, cubos, quadrados, temperaturas. Em seguida, ele plota as altas temperaturas, com os rótulos de
Para compartilhar um eixo y, usamos o argumento sharey=True .
facecolor='azul', alpha=0.25) data exibidos em um formato específico.
importar matplotlib.pyplot como plt
from datetime importar datetime como dt

x_vals = lista(intervalo(11))
importar matplotlib.pyplot como plt
Muitos conjuntos de dados interessantes têm uma data ou hora quadrados = [x**2 para x em x_vals]
from matplotlib importar datas como mdates
como valor x. O módulo datetime do Python ajuda você a trabalhar com cubos = [x**3 para x em x_vals]
esse tipo de dados.
datas = [
fig, axarr = plt.subplots(1, 2, sharey=Verdadeiro)
Gerando a data atual dt(2016, 6, 21), dt(2016, 6, 22),
A função datetime.now() retorna um objeto datetime que representa a dt(2016, 6, 23), dt(2016, 6, 24),
data e hora atuais. axarr[0].scatter(x_vals, quadrados)
]
axarr[0].set_title('Quadrados')
from datetime importar datetime como dt
altos = [57, 68, 64, 59]
axarr[1].scatter(x_vals, cubos, c='vermelho')
hoje = dt.agora() axarr[1].set_title('Cubos')
date_string = dt.strftime(hoje, '%m/%d/%Y') fig = plt.figure(dpi=128, figsize=(10,6))
print(data_string) plt.plot(datas, máximos, c='vermelho')
plt.show()
plt.title("Altas Temperaturas Diárias", fontsize=24)
Gerando uma data específica plt.ylabel("Temp (F)", tamanho da fonte=16)
Você também pode gerar um objeto datetime para qualquer data e hora que
desejar. A ordem posicional dos argumentos é ano, mês e dia. x_axis = plt.axes().get_xaxis()
Os argumentos hora, minuto, segundo e microssegundo são opcionais.
x_axis.set_major_formatter(
mdates.DateFormatter('%B %d %Y')
from datetime importar datetime como dt )
fig.autofmt_xdate()
new_years = dt(2017, 1, 1) Mais folhas de dicas disponíveis em
fall_equinox = dt(ano=2016, mês=9, dia=22) plt.show()
Machine Translated by Google

Você pode adicionar quantos dados quiser ao criar uma

Fazendo um gráfico de dispersão
visualização.
Os dados para um gráfico de dispersão precisam ser uma lista contendo tuplas da
forma (x, y). O argumento stroke=False diz a Pygal para fazer um gráfico XY sem
Plotando quadrados e cubos
nenhuma linha conectando os pontos.
importar pygal
importar pygal
x_values = list(range(11)) squares
quadrados = = [x**2 for x in x_values] cubes = [x**3 for x
[ (0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, in x_values]
A visualização de dados envolve a exploração de dados por meio de 25), ]
representações visuais. O Pygal ajuda você a fazer representações visualmente
chart = pygal.Line()
atraentes dos dados com os quais está trabalhando. Pygal é particularmente
chart.force_uri_protocol = 'http' chart.title =
adequado para visualizações que serão apresentadas online, porque suporta chart = pygal.XY(stroke=False) "Quadrados e Cubos" chart.x_labels =
elementos interativos. chart.force_uri_protocol = 'http' x_values
chart.add('x^2', squares)
chart.render_to_file('squares.svg') chart.add('Squares', squares)
Usando uma compreensão de lista para um gráfico de dispersão Uma
chart.add('Cubes', cubes)
Pygal pode ser instalado usando pip. compreensão de lista pode ser usada para criar com eficiência um conjunto de dados para chart.render_to_file('squares_cubes.svg')
um gráfico de dispersão.
Preenchendo a área sob uma série de dados Pygal
Pygal no Linux e OS X
quadrados = [(x, x**2) para x no intervalo(1000)] permite preencher a área sob ou sobre cada série de dados.
$ pip install --user pygal O padrão é preencher do eixo x para cima, mas você pode preencher a partir de
Fazendo um gráfico de barras qualquer linha horizontal usando o argumento zero .
Pygal no Windows Um gráfico de barras requer uma lista de valores para os tamanhos das barras. Para
rotular as barras, passe uma lista do mesmo comprimento para x_labels. gráfico = pygal.Line(fill=True, zero=0)
> python –m pip install --user pygal
importar pygal

resultados = [1, 2, 3, 4, 5, 6]
Para fazer um gráfico com Pygal, você especifica o tipo de gráfico e frequências = [18, 16, 18, 17, 18, 13]
depois adiciona os dados.
chart = pygal.Bar()
Fazendo um gráfico de linhas
chart.force_uri_protocol = 'http'
Para visualizar a saída, abra o arquivo squares.svg em um navegador.
chart.x_labels = resultados chart.add('D6',
importar pygal frequências) chart.render_to_file('rolling_dice.svg')

x_values = [0, 1, 2, 3, 4, 5] quadrados

= [0, 1, 4, 9, 16, 25] Fazendo um gráfico de barras a partir de um dicionário
Como cada barra precisa de um rótulo e um valor, um dicionário é uma ótima A documentação do Pygal está disponível em
maneira de armazenar os dados de um gráfico de barras. As chaves são http:// www.pygal.org/.
chart = pygal.Line()
usadas como rótulos ao longo do eixo x e os valores são usados para
chart.force_uri_protocol = 'http' determinar a altura de cada barra.
chart.add('x^2', squares)
chart.render_to_file('squares.svg') importar pygal Se você estiver visualizando a saída SVG em um navegador, o Pygal
precisa renderizar o arquivo de saída de uma maneira específica. O
Adicionando rótulos e um título resultados = atributo force_uri_protocol para objetos de gráfico precisa ser definido
{ 1:18, 2:16, 3:18, como 'http'.
--snip--
4:17, 5:18, 6:13, }
chart = pygal.Line()
chart.force_uri_protocol = 'http' chart.title =
"Quadrados" chart.x_labels = x_values
chart.x_title = "Valor" chart.y_title = chart = pygal.Bar()
"Quadrado de valor" chart.add ('x^2', chart.force_uri_protocol = 'http' Abrange Python 3 e Python 2
quadrados) chart.render_to_file('squares.svg') chart.x_labels = results.keys() chart.add('D6',
results.values())
chart.render_to_file('rolling_dice.svg')
Machine Translated by Google

Pygal permite personalizar muitos elementos de um enredo. Pygal pode gerar mapas mundiais e você pode adicionar quaisquer dados
Definições de configuração
Existem alguns temas padrão excelentes e muitas opções para que desejar a esses mapas. Os dados são indicados por cores, por rótulos e
Algumas configurações são controladas por um objeto Config .
estilizar elementos de plotagem individuais. por dicas de ferramentas que mostram os dados quando os usuários passam
my_config = pygal.Config() o mouse sobre cada país no mapa.
Usando estilos integrados
my_config.show_y_guides = False my_config.width
Para usar estilos integrados, importe o estilo e crie uma instância da classe de Instalando o módulo de mapa-múndi O módulo de
estilo. Em seguida, passe o objeto de estilo com o argumento de estilo ao criar o = 1000 my_config.dots_size = 5 mapa-múndi não é incluído por padrão no Pygal 2.0. Pode ser instalado com pip:
objeto de gráfico.

importar pygal de chart = pygal.Line(config=my_config) --snip-- $ pip install --user pygal_maps_world

pygal.style importar LightGreenStyle
Fazendo um mapa-múndi O código
a seguir cria um mapa-múndi simples mostrando os países da América do Norte.
x_values = list(range(11)) squares = Estilizando séries Você
pode atribuir diferentes configurações de estilo a cada série em um gráfico.
[x**2 for x in x_values] cubes = [x**3 for x in x_values]
de pygal.maps.world import World
chart.add('Quadrados', quadrados, dots_size=2) chart.add('Cubos',
cubos, dots_size=3)
chart_style = LightGreenStyle() chart = wm = World()
pygal.Line(style=chart_style) chart.force_uri_protocol = Estilizando pontos de dados individuais wm.force_uri_protocol = 'http' wm.title =
'http' chart.title = "Quadrados e cubos" chart.x_labels = Você também pode estilizar pontos de dados individuais. Para fazer isso, 'América do Norte' wm.add('América do Norte',
x_values escreva um dicionário para cada ponto de dados que deseja personalizar. ['ca', 'mx', 'nos'])
Uma chave 'valor' é necessária e outras propriedades são opcionais.

importar pygal wm.render_to_file('north_america.svg')

chart.add('Squares', squares) chart.add('Cubes',
Mostrando todos os códigos de país Para fazer
cubes) chart.render_to_file('squares_cubes.svg') repositórios = mapas, você precisa conhecer os códigos de país de Pygal.
[{ O exemplo a seguir imprimirá uma lista alfabética de cada país e seu código.
'valor': 20506, 'cor':
Estilos integrados paramétricos Alguns
estilos integrados aceitam uma cor personalizada e geram um tema com base nessa cor. '#3333CC', 'xlink': 'http://
de pygal.maps.world importar PAÍSES
djangoproject.com/',
},
de pygal.style import LightenStyle para código em sorted(COUNTRIES.keys()): print(code,
20054,
COUNTRIES[code])
12607,
--snip-- 11827, ] Plotando dados numéricos em um mapa-múndi Para plotar
chart_style = LightenStyle('#336688') chart =
dados numéricos em um mapa, passe um dicionário para add() ao invés
pygal.Line(style=chart_style) --snip-- de uma lista.
chart = pygal.Bar()
de pygal.maps.world import World
Personalizando propriedades de estilo individuais Os objetos de
chart.force_uri_protocol = 'http' chart.x_labels =
estilo têm várias propriedades que podem ser definidas individualmente. [ 'django', 'requests', 'scikit-learn', 'tornado', ]
populações = { 'ca':
chart.y_title = 'Estrelas' chart.add(' Python Repos', repos)
chart_style = LightenStyle('#336688') 34126000, 'nós':
chart.render_to_file('python_repos.svg')
chart_style.plot_background = '#CCCCCC' 309349000, 'mx':
chart_style.major_label_font_size = 20 113423000, }
chart_style.label_font_size = 16 --recorte--

wm = World()
Classe de estilo personalizada wm.force_uri_protocol = 'http' wm.title =
Você pode começar com uma classe de estilo simples e, em seguida, definir
'População da América do Norte' wm.add('América do Norte',
apenas as propriedades de seu interesse.
populações)
chart_style = Style()
chart_style.colors = [ '#CCCCCC', wm.render_to_file('na_populations.svg')
'#AAAAAA', '#888888'] chart_style.plot_background
= '#EEEEEE'

chart = pygal.Line(style=chart_style) --snip-- Mais folhas de dicas disponíveis em

Machine Translated by Google

Os dados em um projeto Django são estruturados como um conjunto
de modelos.
Definindo um modelo
Para definir os modelos para seu aplicativo, modifique o arquivo models.py que
foi criado na pasta do seu aplicativo. O método __str__() diz ao Django como
representar objetos de dados com base neste modelo.
Os usuários interagem com um projeto por meio de páginas da Web, e
a página inicial de um projeto pode começar como uma página simples sem
dados. Uma página geralmente precisa de um URL, uma exibição e um modelo.
Mapeando as URLs de um projeto
O arquivo urls.py principal do projeto diz ao Django onde encontrar os arquivos
urls.py associados a cada aplicativo no projeto.

de modelos de importação django.db de django.conf.urls import include, url

do admin de importação django.contrib
Django é um framework web que ajuda você a construir sites
classe Tópico(modelos.Modelo):
interativos usando Python. Com o Django, você define o tipo de """Um tópico sobre o qual o usuário está aprendendo.""" urlpadrões = [
dados com os quais seu site precisa trabalhar e define as maneiras text = models.CharField(max_length=200) url(r'^admin/', include(admin.site.urls)),
pelas quais seus usuários podem trabalhar com esses dados. date_added = models.DateTimeField( url(r'', include('learning_logs.urls',
auto_now_add=Verdadeiro) namespace='learning_logs')),
]
def __str__(auto):
retornar self.text Mapeando os URLs de um aplicativo
Geralmente é melhor instalar o Django em um ambiente virtual, O arquivo urls.py de um aplicativo diz ao Django qual visualização usar para cada
onde seu projeto pode ser isolado de seus outros projetos Python. Ativando um modelo URL no aplicativo. Você mesmo precisará criar esse arquivo e salvá-lo na pasta do
A maioria dos comandos assume que você está trabalhando em Para usar um modelo, o aplicativo deve ser adicionado à tupla aplicativo.
um ambiente virtual ativo. INSTALLED_APPS, que é armazenada no arquivo settings.py do projeto.
de django.conf.urls url de importação
Crie um ambiente virtual INSTALADO_APPS = (
--recorte-- a partir de . importar visualizações
$ python –m venv ll_env 'django.contrib.staticfiles',
Ative o ambiente (Linux e OS X) urlpadrões = [
# Meus aplicativos url(r'^$', views.index, name='index'),
$ fonte ll_env/bin/ativar 'learning_logs', ]
)
Ative o ambiente (Windows) Escrevendo uma visão simples
Migrando o banco de dados Uma exibição obtém informações de uma solicitação e envia dados para o
> ll_env\Scripts\ativar O banco de dados precisa ser modificado para armazenar o tipo de dados que o navegador, geralmente por meio de um modelo. As funções de exibição são
modelo representa. armazenadas no arquivo views.py de um aplicativo. Essa função de exibição
Instale o Django no ambiente ativo
simples não extrai nenhum dado, mas usa o modelo index.html para renderizar a página ini
(ll_env)$ pip instalar Django $ python manage.py makemigrations learning_logs
$ python manage.py migrar de django.shortcuts import render

Criando um superusuário índice def(solicitação):

Um superusuário é uma conta de usuário que tem acesso a todos os aspectos do """A página inicial do Learning Log."""
Para iniciar um projeto, criaremos um novo projeto, criaremos um banco
projeto. return render(solicitação,
de dados e iniciaremos um servidor de desenvolvimento.
$ python manage.py createsuperuser 'learning_logs/index.html')
Criar um novo projeto
Registrando um modelo
$ django-admin.py startproject learning_log . Você pode registrar seus modelos no site de administração do Django, o que
Criar um banco de dados torna mais fácil trabalhar com os dados em seu projeto. Para fazer isso,
modifique o arquivo admin.py do aplicativo. Visualize o site de administração A documentação do Django está disponível em
em http:// localhost:8000/ admin/. http:// docs.djangoproject.com/. A documentação do Django é
$ python manage.py migrar
completa e fácil de usar, então confira!
Veja o projeto
do admin de importação django.contrib
Depois de emitir este comando, você pode visualizar o projeto em
http:// localhost:8000/. de learning_logs.models import Topic

$ python manage.py runserver admin.site.register(Tópico)

Abrange Python 3 e Python 2
Criar um novo aplicativo
Um projeto Django é composto de um ou mais aplicativos.

$ python manage.py startapp learning_logs

Machine Translated by Google

Um novo modelo pode usar um modelo existente. O atributo

Escrevendo um modelo simples
Um modelo configura a estrutura de uma página. É uma mistura de html e
código de modelo, que é como o Python, mas não tão poderoso. Crie uma
pasta chamada templates dentro da pasta do projeto. Dentro da pasta templates
crie outra pasta com o mesmo nome do app. É aqui que os arquivos de modelo
devem ser salvos.
<p>Registro de aprendizado</p>
<p>O Learning Log ajuda você a acompanhar seu aprendizado,
para qualquer tópico que esteja aprendendo
sobre.</p>
ForeignKey estabelece uma conexão entre as instâncias dos dois Usando dados em um modelo
Os dados no dicionário de contexto da função de exibição estão disponíveis
modelos relacionados. Certifique-se de migrar o banco de dados
no modelo. Esses dados são acessados usando variáveis de modelo, que
depois de adicionar um novo modelo ao seu aplicativo.
são indicadas por chaves duplas.
A linha vertical após uma variável de modelo indica um filtro. Nesse caso, um
Definindo um modelo com uma chave estrangeira
filtro chamado data formata objetos de data e as quebras de linha do filtro
classe Entrada(modelos.Modelo): renderizam os parágrafos adequadamente em uma página da web.
"""Entradas de log de aprendizagem para um tópico."""
{% estende 'learning_logs/base.html' %}
topic = models.ForeignKey(Topic)
texto = modelos.TextField()
{% bloquear conteúdo %}
date_added = models.DateTimeField(
auto_now_add=Verdadeiro)
<p>Tópico: {{ tópico }}</p>

def __str__(auto):
<p>Entradas:</p>
Muitos elementos de uma página da Web são repetidos em todas return auto.texto[:50] + "..." <ul>
as páginas do site ou em todas as páginas de uma seção do site. {% para entrada nas entradas %}
Ao escrever um modelo pai para o site e um para cada seção, <li>
você pode modificar facilmente a aparência de todo o site. <p>
A maioria das páginas em um projeto precisa apresentar dados
específicos do usuário atual. {{entrada.data_adicionada|data:'M d, YH:i' }}
O modelo pai
O modelo pai define os elementos comuns a um conjunto de páginas e
</p>
define os blocos que serão preenchidos por páginas individuais. Parâmetros de URL <p>
Uma URL geralmente precisa aceitar um parâmetro informando quais dados {{entrada.texto|quebras de linha}}
<p> acessar do banco de dados. O segundo padrão de URL mostrado aqui </p>
<a href="{% url 'learning_logs:index' %}"> procura o ID de um tópico específico e o armazena no parâmetro topic_id. </li>
Registro de aprendizado
{% vazio %}
</a>
urlpadrões = [ <li>Ainda não há entradas.</li>
</p> {% endfor %}
url(r'^$', views.index, name='index'),
url(r'^topics/(?P<topic_id>\d+)/$', </ul>
{% conteúdo do bloco %}{% conteúdo do bloco final %}
visualizações.tópico, nome='tópico'),
] {% conteúdo do bloco final %}
O modelo filho
O modelo filho usa a tag de modelo {% extends %} para extrair a estrutura do
Usando dados em uma exibição
modelo pai. Em seguida, define o conteúdo de quaisquer blocos definidos no
A exibição usa um parâmetro da URL para extrair os dados corretos do banco
modelo pai.
de dados. Neste exemplo, a visualização está enviando um contexto
{% estende 'learning_logs/base.html' %} dicionário ao template, contendo os dados que devem ser exibidos na página. Você pode explorar os dados em seu projeto na linha de comando.
Isso é útil para desenvolver consultas e testar trechos de código.
{% bloquear conteúdo %} def tópico(solicitação, topic_id):
<p> """Mostrar um tópico e todas as suas entradas.""" Iniciar uma sessão de shell
O Learning Log ajuda você a acompanhar seu tópico = Topics.objects.get(id=topic_id)
aprendizado, para qualquer tópico que você esteja entradas = topic.entry_set.order_by( $ python manage.py shell
aprendendo sobre. '-data adicionada')
</p> Acessar dados do projeto
contexto = {
{% conteúdo do bloco final %} 'tópico': tópico, >>> do tópico de importação learning_logs.models
'entradas': entradas, >>> Topic.objects.all()
[<Tópico: Xadrez>, <Tópico: Escalada>]
} return render(solicitação, >>> tópico = Topic.objects.get(id=1)
'learning_logs/topic.html', contexto) >>> tópico.texto
'Xadrez'

O código Python geralmente é recuado por quatro espaços.

Em modelos, você frequentemente verá dois espaços usados para recuo, Se você fizer uma alteração em seu projeto e a alteração
Mais folhas de dicas disponíveis em
porque os elementos tendem a ser aninhados mais profundamente nos não surtir efeito, tente reiniciar o servidor:
modelos. $ python manage.py runserver
Machine Translated by Google

Definindo as URLs Mostrando o status de login atual

Os usuários precisarão ser capazes de fazer login, sair e se registrar. Crie um novo Você pode modificar o modelo base.html para mostrar se o usuário está conectado no
arquivo urls.py na pasta de aplicativos do usuário . A visualização de login é uma momento e fornecer um link para as páginas de login e logout. O Django disponibiliza um
visualização padrão fornecida pelo Django. objeto de usuário para cada template, e este template tira vantagem deste objeto.

de django.conf.urls url de importação A tag user.is_authenticated permite que você forneça conteúdo específico para
de django.contrib.auth.views import login usuários, dependendo se eles estão logados ou não.
A propriedade {{ user.username }} permite que você cumprimente os usuários que
a partir de . importar visualizações fizeram login. Os usuários que não fizeram login veem os links para se registrar ou
fazer login.

urlpadrões = [ <p>
url(r'^login/$', login, <a href="{% url 'learning_logs:index' %}">
A maioria dos aplicativos da Web precisa permitir que os usuários {'template_name': 'users/login.html'}, Registro de aprendizado
criem contas. Isso permite que os usuários criem e trabalhem com seus nome='login'), </a>
próprios dados. Alguns desses dados podem ser privados e alguns podem ser url(r'^logout/$', views.logout_view, {% if user.is_authenticated %}
públicos. Os formulários do Django permitem que os usuários insiram e
nome='logout'), Olá, {{ usuário.nome de usuário }}.
url(r'^register/$', views.register, <a href="{% url 'users:logout' %}">
modifiquem seus dados.
nome='registro'), sair
] </a>
O modelo de login {% senão %}
As contas de usuário são gerenciadas por um aplicativo dedicado
A exibição de login é fornecida por padrão, mas você precisa fornecer seu próprio modelo <a href="{% url 'users:register' %}">
chamado users. Os usuários precisam ser capazes de se registrar, fazer
de login. O modelo mostrado aqui exibe um formulário de login simples e fornece registro
login e sair. O Django automatiza muito desse trabalho para você. mensagens de erro básicas. Crie uma pasta de modelos na pasta de usuários e, em </a> -
seguida, crie uma pasta de usuários na pasta de modelos. Salve este arquivo como <a href="{% url 'users:login' %}">
Fazendo um aplicativo de usuários
login.html.
Depois de criar o aplicativo, certifique-se de adicionar 'usuários' a INSTALLED_APPS Conecte-se
A tag {% csrf_token %} ajuda a prevenir um tipo comum de ataque com formulários.
no arquivo settings.py do projeto. </a>
O elemento {{ form.as_p }} exibe o formulário de login padrão em formato de
parágrafo. O elemento <input> nomeado a seguir redireciona o usuário para a página
{% fim se %}
$ python manage.py usuários do startapp
inicial após um login bem-sucedido. </p>
Incluindo URLs para o aplicativo de usuários
Adicione uma linha ao arquivo urls.py do projeto para que os URLs do aplicativo dos {% conteúdo do bloco %}{% conteúdo do bloco final %}
usuários sejam incluídos no projeto. {% extends "learning_logs/base.html" %}
A visualização de logout
urlpadrões = [ {% bloquear conteúdo %} A função logout_view() usa a função logout() do Django e então redireciona o usuário
url(r'^admin/', include(admin.site.urls)), {% if form.errors %} de volta para a página inicial. Como não há página de logout, não há modelo de logout.

url(r'^users/', include('users.urls', Certifique-se de escrever este código no arquivo views.py que está armazenado na pasta
<p>
de aplicativos dos usuários.
namespace='usuários')), Seu nome de usuário e senha não correspondem.
url(r'', include('learning_logs.urls', Por favor, tente novamente. de django.http import HttpResponseRedirect
namespace='learning_logs')), </p> de django.core.urlresolvers import reverse
] {% fim se %} de django.contrib.auth import logout

<form method="post" def logout_view(pedido):

action="{% url 'users:login' %}"> """Deslogue o usuário."""
{% token csrf %} sair (solicitação)
Existem várias maneiras de criar formulários e trabalhar com eles. Você {{ form.as_p }} return HttpResponseRedirect(
pode usar os padrões do Django ou personalizar completamente seus <button name="submit">fazer login</button> reverse('learning_logs:index'))
formulários. Para uma maneira simples de permitir que os usuários
insiram dados com base em seus modelos, use um ModelForm. Isso cria <input type="hidden" name="next"
um formulário que permite aos usuários inserir dados que preencherão os value="{% url 'learning_logs:index' %}"/>
campos em um modelo. </form>
A visualização do registro no verso desta folha mostra uma abordagem Abrange Python 3 e Python 2
simples para o processamento de formulários. Se a exibição não receber {% conteúdo do bloco final %}
dados de um formulário, ela responderá com um formulário em branco.
Se receber dados POST de um formulário, ele valida os dados e os salva
no banco de dados.
Machine Translated by Google

A visualização do registro O modelo de registro Restringindo o acesso a usuários logados

A exibição de registro precisa exibir um formulário de registro em branco quando a O modelo de registro exibe o formulário de registro em formatos de parágrafo. Algumas páginas são relevantes apenas para usuários registrados. As exibições
página é solicitada pela primeira vez e, em seguida, processar os formulários de dessas páginas podem ser protegidas pelo decorador @login_required .
registro preenchidos. Um registro bem-sucedido conecta o usuário e o redireciona para Qualquer exibição com este decorador redirecionará automaticamente os usuários não
a página inicial. {% estende 'learning_logs/base.html' %} logados para uma página apropriada. Aqui está um exemplo de arquivo views.py.

de django.contrib.auth import login {% bloquear conteúdo %} de django.contrib.auth.decorators import /

de django.contrib.auth importar autenticar login_required
de django.contrib.auth.forms importar \ <form method='post' --recorte--
UserCreationForm
action="{% url 'users:register' %}">
@login_required
def registrar (solicitação): {% csrf_token %} def tópico(solicitação, topic_id):
"""Cadastre um novo usuário.""" {{ form.as_p }} """Mostrar um tópico e todas as suas entradas."""
if request.method != 'POST':
# Mostrar formulário de registro em branco. Definindo o URL de redirecionamento
<button name='submit'>registrar</button> O decorador @login_required envia usuários não autorizados para a página de login.
form = UserCreationForm() <input type='hidden' name='next' Adicione a seguinte linha ao arquivo settings.py do seu projeto para que o Django saiba
senão:
value="{% url 'learning_logs:index' %}"/> como encontrar sua página de login.
# Processar formulário preenchido.
form = UserCreationForm( </form> LOGIN_URL = '/users/login/'
dados=pedido.POST)
Prevenção de acesso inadvertido
{% conteúdo do bloco final %} Algumas páginas fornecem dados com base em um parâmetro na URL. Você pode
if form.is_valid(): verificar se o usuário atual possui os dados solicitados e retornar um erro 404 se não
new_user = form.save() for. Aqui está um exemplo de visualização.
# Faça login, redirecione para a página inicial.
pw = request.POST['senha1'] Os usuários terão dados que pertencem a eles. Qualquer modelo que deva ser de django.http importar Http404
conectado diretamente a um usuário precisa de um campo conectando instâncias do
autenticado_usuário = autenticar(
nome de usuário=novo_usuário.nome de usuário,
modelo a um usuário específico. --recorte--
senha=pw def tópico(solicitação, topic_id):
Fazendo um tópico pertencer a um usuário """Mostrar um tópico e todas as suas entradas."""
) Somente os dados de nível mais alto em uma hierarquia precisam ser conectados
login(pedido, autenticado_usuário) diretamente a um usuário. Para fazer isso, importe o modelo User e adicione-o como
tópico = Topics.objects.get(id=topic_id)
return HttpResponseRedirect( uma chave estrangeira no modelo de dados. if topic.owner != request.user:
reverse('learning_logs:index')) Depois de modificar o modelo, você precisará migrar o banco de dados. aumentar Http404
Você precisará escolher um ID de usuário para conectar cada instância existente. --recorte--
contexto = {'forma': forma}
return render(solicitação, de modelos de importação django.db
'users/register.html', contexto) de django.contrib.auth.models importar Usuário
Se você fornecer alguns dados iniciais, o Django gera um formulário
classe Tópico(modelos.Modelo): com os dados existentes do usuário. Os usuários podem então modificar
"""Um tópico sobre o qual o usuário está aprendendo.""" e salvar seus dados.
O aplicativo django-bootstrap3 permite que você use a biblioteca Bootstrap text = models.CharField(max_length=200)
para tornar seu projeto visualmente atraente. O aplicativo fornece tags que Criando um formulário com dados iniciais
date_added = models.DateTimeField(
O parâmetro de instância permite que você especifique dados iniciais para um formulário.
você pode usar em seus modelos para estilizar elementos individuais em uma auto_now_add=Verdadeiro)
página. Saiba mais em http:// django-bootstrap3.readthedocs.io/. proprietário = models.ForeignKey(User) form = EntryForm(instância=entrada)

def __str__(auto): Modificando dados antes de salvar

O argumento commit=False permite que você faça alterações antes de gravar dados no
retornar self.text
banco de dados.

O Heroku permite que você envie seu projeto para um servidor ativo, Consultando dados para o usuário atual new_topic = form.save(commit=False)
tornando-o disponível para qualquer pessoa com conexão à Internet. O Em uma exibição, o objeto de solicitação possui um atributo de usuário . Você pode usar
new_topic.owner = request.user
Heroku oferece um nível de serviço gratuito, que permite que você esse atributo para consultar os dados do usuário. A função filter() puxa os dados que
new_topic.save()
pertencem ao usuário atual.
aprenda o processo de implantação sem nenhum compromisso. Você
precisará instalar um conjunto de ferramentas heroku e usar o git para tópicos = Topic.objects.filter( Mais folhas de dicas disponíveis em
rastrear o estado do seu projeto. Consulte http:// devcenter.heroku.com/ proprietário=pedido.usuário)
e clique no link Python.