Computação I

Prévia do material em texto

Computação I 
(Python) 
Monitor Eduardo de Mello Castanho 
eduardocastanho@poli.ufrj.br 
 
Índice: 
*Índice 1
*Operações em Python 
*Comandos básicos 
*Funções Math e Random 
*Definindo funções 
*Variáveis Booleanas 
*Operadores relacionais e lógicos 
*Comandos condicionais IF-ELSE 
*Comando while 
*Listas 
*Comando for 
*Trabalhando com matrizes 
*Trabalhando com caracteres 
*Docstrings 
*Operadores de formatação 
*Trabalhando com arquivos 
*Exercícios 
2 
2 
2 
3 
3 
4 
4 
4 
5 
6 
7 
7 
8 
9 
10 
12 
 
 
 1 
Operações em Python: 
Soma: + (3+2=5) 
Subtração: - (3-2=1) 
Multiplicação: * (3*2=6) 
Divisão: / (3/2=1) ou (3.0/2.0 = 1.5) 
obs: operações com números inteiros resultarão em um número inteiro - somente nas versões 2.7 ou 
anteriores do Python 
Expoente: ** (3**2=9) 
Divisão inteira: // (3.0//2.0=1.0) 
Resto da divisão: % (7%2=1) 
 
Comandos básicos: 
print (n) – imprime ‘n’ na tela 
n=input(“Orientação”) – imprime a frase “Orienteção” na tela e aguarda que o usuário 
digite o valor de n – pode ser executado sem orientação: n=input() 
n=raw_input(“Orientação”) – igual ao input, porém ao invés de tentar interpretar o valor 
digitado como um número ou uma variável, ele simplesmente transforma o que foi digitado em uma 
string (frase) 
 
Funções math: 
>>> from math import * (Importar do módulo ‘math’ todas as suas funções) 
exp(n) = e**n 
sqrt(n) = √n 
trunc(n) = parte inteira de n (trunc(1.7) = 1) 
round(n) = arredondamento de n (round(1.7) = 2) 
 
Funções random: 
>>> from random import * 
random() – gera número aleatório de 0 a 1 
uniform(A,B) – gera número aleatório de A a B 
randrange(A,B,I) – gera um número aleatório de A a B com intervalo I 
ex: randrange(2,10,2) – números possíveis: 2,4,6,8 
obs: o número B não está incluso. 
 
 2 
Definindo funções: 
>>> def funcao(argumentos): 
 comandos 
 return resultado 
ex: 
>>> def delta (a,b,c): 
 d = (b**2 - 4*(a*c))**0.5 
 return d 
>>> delta (2,5,3) 
1.0 
 
Variáveis Booleanas: 
True - Verdadeiro 
False - Falso 
obs: é necessário que a primeira letra seja maíuscula 
 
Operadores relacionais (de comparação): 
Igual: == 
Diferente: != 
Maior: > 
Menor: < 
Maior ou igual: >= 
Menor ou igual: <= 
 
Operadores Lógicos: 
and – e 
or – ou 
not – não 
ex: 
>>> a,b = 0,1 (modo mais prático de atribuir a=0, b=1) 
>>> a == b 
False 
>>> (a or b) > 0 
True 3 
Comandos condicionais IF-ELIF-ELSE: 
>>> if condição 1: (se a condição 1 for True, executar comando 1) 
 comando 1 
 elif condição 2: ( caso a condição anterior seja falsa, porém a condição 2 for True, 
executar o comando 2 – opcional e pode aparecer múltiplas vezes dentro da sequência, ao contrario 
de if e else) 
 comando 2 
 else: (caso nenhuma das condições acima for True, executar comando 3 - opcional) 
 comando 3 
ex: 
>>> if a==0: 
 print (“neutro”) 
 elif a>0: 
 print (“positivo”) 
 elif a<0: 
 print (“negativo”) 
obs: para cada condição pode-se executar inúmeros comandos 
 
Comando While: 
>>> while condição: (enquanto a condição for True, o comando será repetido) 
 comando 
ex: 
>>> a,b = 0,10 
>>> while a<b: 
 print (“Ainda não...”) 
 a = a + 1 
 print (“Agora sim!”) 
 
 
 
 
 
 
 
 4 
Listas: 
L = [a0, a1, a2, ... , an] – Lista com n+1 elementos (os elementos podem ser tanto 
números - inteiros ou floats - quanto strings, ou até mesmo sublistas) 
Acessar primeiro elemento: L[0] ou L[0:1] 
Acessar terceiro elemento: L[2] ou L[2:3] 
Acessar primeiros três elementos: L[0:3] ou L[:3] 
Acessar últimos três elementos: L[n-2:n] ou L[n-2:] 
Acessar intervalo entre dois elementos: L[2:2] 
Acessar todos os elementos: L[:] 
Acessar elementos de sublistas: L[2][0] (primeiro elemento da sublista de índice 2) 
 
Para modificar os valores, basta executar L[n] = [valor] 
Duas listas podem ser concatenadas ou multiplicadas por um inteiro: 
>>> L1,L2 = [1,2,3], [4,5,6] 
>>> L1 + L2 
[1,2,3,4,5,6] 
>>> L2 + L1 
[4,5,6,1,2,3] 
>>> L1 * 3 
[1,2,3,1,2,3,1,2,3] 
obs: os índices podem ser indicados como negativos, partindo do último para o primeiro – último 
elemento: L[-1], penúltimo: L[-2], ... 
obs2: os elementos de uma mesma lista podem ser de natureza diferente, misturando strings com 
números e listas 
 
Funções intrínsecas: 
len(L) – comprimento de L 
min(L) – menor elemento de L 
max(L) – maior elemento de L 
operador in – caso o valor esteja na lista, retorna True, caso contrário, 
retorna False (ex: L=[1,2,3,4] – 10 in L – False) 
 
Deletar ou inserir elementos: 
>>> del L[3] ou L[3:4] = [] 
>>> L[3:3] = [2] 5 
Métodos de Listas: 
lista.index(e) – retorna o índice da primeira ocorrência de e 
lista.count(e) – retorna o número de ocorrências de e 
lista.append(e) – inclui e no final da lista 
lista.insert(i,e) – inclui e no índice i da lista 
lista.remove(e) – remove a primeira ocorrência de e 
lista.pop(i) – remove e imprime na tela a primeira ocorrência de i 
lista.reverse() – inverte a ordem da lista 
lista.sort() – organiza a lista em ordem crescente 
lista.sort(reverse=True) – organiza a lista em ordem decrescente 
- onde ‘lista’ é o nome da lista (ex: L1=[1,2] – L1.index(2)) 
 
Comando for: 
Aplica um comando para todos os elementos da lista. 
Geralmente utiliza-se a função range(A,B,I), que gera uma lista de A a B, 
com intervalo de I. 
obs: o elemento I não precisa ser escrito, sendo como padrão 1 
obs2: o elemento A não precisa ser escrito, sendo como padrão 0 
obs3: o elemento B não será incluindo na lista 
 
ex: 
>>> for e in range(15): (onde ‘e’ é um elemento da lista) 
 print (e**2) 
 
O comando for pode servir para substituir o comando while: 
 
>>> s = 0 >>> s = 0 
 i = 0 for i in range(10): 
 while i < 10: s=s+1 
 s=s+1 
 i=i+1 
 
 
 
 6 
Trabalhando com matrizes: 
Uma Matriz no Python não é mais do que Sublistas dentro de uma Lista: 
|2 3| 
|3 5| 
M = [[2,3],[3,5]], onde o comprimento de M (len(M)) é o número de linhas 
e o comprimento de M[0] (len(M[0])) é o número de colunas; todos as 
sublistas de M devem conter o mesmo número de elementos. 
 
Para acessar todos os elementos de uma matriz, utilizamos um simples 
comando for concatenado: 
>>> for i in range(0,len(M)): 
 for j in range(0,len(M[0])): 
 print (M[i][j]) 
 
Trabalhando com Caracteres: 
String: uma string, ou frase, não passa de uma sequência de caracteres, 
quase como uma lista. Cada caractere pode ser acessado pelo seu índice: 
>>> s=”frase” 
>>> s[0] = “f” 
>>> s[1:3] = “ra” 
 
Ao contrário de listas, as strings não podem ser modificadas. 
Podemos concatenar duas frases ou repetir uma mesma frase, assim como 
nas listas: 
>>> s[3] + [2] + S[0:3] 
safra 
>>> s[0:3]*3 
frafrafra 
 
A função intrínseca len(s) também é válida para strings, retornando o 
número de caracteres que a string possui. 
 
 
7 
Métodos de strings: 
s.lower() – transforma todos os caracteres em minúsculas 
s.upper() – transforma todos os caracteres em maiúsculas 
s.capitalize() – transforma o primeiro caractere em maiúscula 
s.title() – transforma o primeiro caractere de cada palavra em maiúscula 
s.count(e) – númerode ocorrências de e 
s.find(e) – índice da primeira ocorrência de e 
s.replace(old,new,n) – troca as primeiras n ocorrências de old por new 
s.strip() – remove os possíveis espaços no início e no fim da string 
s.split(e) – retorna uma lista com todas as substrings separadas por e 
(ex: s=”papibaquígrafo” – s.split(“a”) – [“p”,”pib”,”quígr”,”fo”]) 
s.join(lista) – concatena todas as strings de uma lista 
 
Docstrings: 
Docstring é uma maneira de escrever dentro de um programa para 
explicar, identificar ou evidenciar certas partes do programa. O Python não 
irá interpretar as docstrings, elas serão ignoradas e servem somente para 
o leitor. Basta começar com o símbolo # e digitar o que quiser que o 
Python não vai ler o que estiver depois, até chegar na linha seguinte. 
 
ex: 
>>> #programa para imprimir na tela os divisíveis de um número dado 
 def div(n): 
 for i in range (1,n+1): #para todos os números de 1 a n 
 if n%i==0: #caso a divisão não tenha resto 
 print(i) #imprimir o número na tela 
 #fim do for 
 
 
 
 
 
 
 8 
Operadores de formatação: 
Ao imprimir elementos da tela, não temos controle de como estes 
elementos serão impressos. Para isto, utilizamos os operadores de 
formatação: 
%d – para números inteiros 
%f – para números float 
%e – para notação científica 
%g – coloca em notação científica se necessário 
%c – para caracteres 
%s – para strings 
 
ex: 
>>> PF = 7.5 
>>> print (“tirei %f na PF” %PF) 
Tirei 7.5 na PF 
 
Podemos colocar após o % alguns comandos para formatar o print: 
%5d – imprime com 5 caracteres (ex: print (“%5d”%PF) – “ 7.5”) 
%-d – alinha à esquerda 
%+d – alinha à direita 
%0d – completa com 0 os espaços disponíveis 
%.3f – imprime f com estritamente 3 números após a vírgula 
 
ex geral: 
>>> print (“%+07.3f” %0.12345) 
+00.012 
Obs: o + indica que ele será alinhado à direita, o 0 indica que os espaços vazios serão completados 
com 0, o 7 indica que serão utilizadas sete casas (incluindo o ponto), o .3 indica que serão utilizadas 
três casas decimais e o f indica que trata-se de um número float. 
 
 
 
 
 
9 
Trabalhando com arquivos: 
Operações: Abrir – Ler – Gravar – Fechar 
 
1) Abrir – utiliza-se a função “open” 
f = open(nome, modo) 
O nome nada mais é do que uma string com o nome/endereço do arquivo. 
O modo depende da maneira que se quer trabalhar com o arquivo. Os 
casos mais comuns são: “r”, “w”, “a”. 
O “r” (do inglês, “read” – “leitura”) é utilizado quando se quer somente ler 
o conteúdo do arquivo, sem alterá-lo. 
O “w” (do inglês, “write” – “escrever”) é utilizado quando se quer escrever 
em cima de um arquivo, apagando necessariamente seu conteúdo original. 
O “a” (do inglês, “append” – “anexar”) é utilizado quando se quer escrever 
abaixo do conteúdo do arquivo, mantendo seu conteúdo original. Serão 
apenas acrescentadas linhas adicionais ao arquivo. 
Obs: se o nome do arquivo não acompanhar o seu endereço, apenas o nome.terminação (ex: 
“arquivo.txt”), o python irá buscar o arquivo na pasta onde estiver salvo o progama.py. Se eles não 
estiverem na mesma pasta, o arquivo não será encontrado. Pode-se, então, escrever todo o 
endereço, porém isso pode ser inconveniente (ex: “C:\\User\\Desktop\\arquivo.txt”). 
Obs2: caso seja utilizado o modo “w” ou o modo “a” e o python não encontrar um arquivo com o 
nome indicado, este arquivo será automaticamente criado, em branco, para que possa ser feita a 
gravação. 
 
2) Ler – utiliza-se as funções read, readline, readlines 
A função f.read(), onde f é a variável criada ao abrir o arquivo, lê o arquivo 
todo, transformando-o em uma única string. As quebras de linha são lidas 
como ‘\n’. O resultado tem este formato: “linha 1\nlinha 2\nlinha 3...” 
 A função f.readline() lê uma única, também no formato de string, 
incluindo a quebra de linha no final. Ao usar este comando, o python grava 
na memória em qual linha ele parou; portanto, caso o comando seja 
executado novamente, será lida a linha seguinte. 
A função f.readlines() lê o arquivo todo, transformando-o em uma lista, 
onde cada elemento equivale a um f.readline(). O resultado tem este 
formato: [“linha 1\n”, “linha 2\n”, “linha 3\n”, ...] 
Obs: caso seja executado um comando readline e, em seguida, um comando read ou readlines, as 
linhas lidas anteriormente pelo readline não serão incluídas no read ou no readlines. 10 
 
3) Gravar – usa-se as funções write e writelines 
A função f.write(string) grava uma string ao final de um arquivo. 
A função f.writelines(lista) grava uma lista de strings no final de um 
arquivo. Para que os elementos sejam gravados cada um em uma linha 
diferente, é necessário inserir o ‘\n’ ao final de cada string. Funciona como 
o inverso da função f.readlines(). 
 
4) Fechar – usa-se as funções flush e close 
A função f.flush() garante que todas as alterações feitas nos arquivos 
foram salvas. 
A função f.close() fecha o arquivo, para que não seja mais possível efetuar 
alterações nele. É importante para evitar problemas de gravação em caso 
de programas extensos. 
 
ex: 
>>> f=open(“refrao.txt”,”r+”) 
>>> a = f.readlines() 
>>> f.writelines(a[-4:]) 
>>> f.close() 
(O programa abre o arquivo, transforma-o em uma lista de strings e 
reescreve ao final do arquivo somente as últimas quatro linhas, que 
ficarão repetidas.) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
11 
Exercícios: 
 
(1) Crie uma função que receba as coordenadas x, y e z de um ponto e 
imprima na tela se este ponto está dentro ou fora do cubo de aresta 
1 que começa na origem e segue os eixos positivos x, y e z. 
 
(2)Crie uma função que retorne a soma de duas listas de números 
dados (de mesmo tamanho) usando o comando while. 
 
(3)Crie uma função que receba uma lista de números e retorne o 
resultado do somatório: ∑xᵢ² , onde xᵢ é cada elemento da lista. 
 
(4)Crie uma função que receba três matrizes A, B e C e retorne A-B+C e 
imprima na tela a soma dos elementos da última coluna da matriz 
resultante 
 
(5)Crie uma função que receba uma frase e retorne True se ela for um 
palíndromo ou False caso contrário, sem usar as funções intrínsecas de 
strings. (Um palíndromo é uma palavra ou frase que é igual de trás pra 
frente, ex: Subi no Onibus) 
 
 
 
 
 
Respostas: 
def e1(x,y,z): 
 if 0<=x<=1: 
 if 0<=y<=1: 
 if 0<=z<=1: 
 return ‘Dentro do cubo.’ 
 else: 
 return ‘Fora do Cubo’ 
 12 
 def e2(L1,L2): 
 i=0 
 L3=[None]*len(L1) 
 while i<len(L1): 
 L3[i]=L1[i]+L2[i] 
 i=i+1 
 return L3 
 
 def e3(L): 
 s=0 
 for i in L: 
 s+=i**2 (obs: s+=1 é o mesmo que s=s+1) 
 return s 
 
 def e4(A,B,C): 
 for i in range(len(A)): 
 for j in range(len(A[0])): 
 A[i][j] = A[i][j] – B[i][j] + C[i][j] 
 s=0 
 for i in range(len(A)): 
 s+=A[i][-1] 
 return A,s 
 
def e5(f): 
 f2="" 
 for e in range (len(f)): 
 f2=f[e]+f2 
 if f2==f: 
 return True 
 else: 
 return False 
 
 
13