03-LINGUAGEM-PYTHON-pte-A

Prévia do material em texto

FATEC-SP - ADS - alp / ial002 pág. 1
Linguagem Python:
Linguagem de alto nível, interpretada, que suporta vários paradigmas de programação
(imperativo, orientado a objetos, estruturado, modular, funcional), pode ser utilizada como
scripting language ou ser compilada (Byte-code). Possui tipagem dinâmica (o tipo da
variável não é descrito explicitamente) e forte (restringe operações com variáveis de tipos
incompatíveis), fornecendo ainda um interpretador interativo que facilita tarefas de testes. 
Para executar um programa Python a partir de um arquivo texto, deve-se digitar 
 python3 nome-do-arquivo 
ou, para executar o programa digitando apenas seu nome:
chmod +x nome-do-arquivo (uma única vez)
 ./nome-do-arquivo
Neste caso as duas primeira linhas do arquivo devem ser: 
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
Interpretador interativo:
Para utilizar o interpretador interativo basta digitar python3 na linha de comando e digitar os
comandos no prompt do interpretador (>>>). O prompt secundário (…) é apresentado ao
usuário quando o comando possui várias linhas, sendo encerrado por um enter sem
instruções no prompt secundário. Para sair do interpretador digite quit(), exit() ou pressione
ctrl+d. 
Exemplo: python3
>>> print (“ olá python “)
>>> 5 + 2 * 3
>>> quit()
Se houver erro de sintaxe, é importante ler atentamente a mensagem de erro exibida na tela. 
Tipos de dados:
Os programas utilizam dados de entrada e dados intermediários para a obtenção dos dados
de saída. Esses dados são armazenados em áreas de memória RAM chamadas de variáveis,
ocupando tantos bytes quantos necessários para a representação desses dados. Essas
variáveis são de diferentes tipos, em função do dado a ser representado. Os tipos de dados
padrão utilizados em Python são: números, strings, listas, tuplas e dicionários. Os tipos de
dados são automaticamente determinados, em função do valor atribuído aos dados. 
Números: 
Python suporta três diferentes tipos de números:
 Int (Números inteiros com sinal).
 Float (Números reais, internamente representados em ponto flutuante)
 Complex (Números complexos). 
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 2
Bases numéricas: 0b = Binário; 0o = Octal; 0x = Hexadecimal. Ex.: 0b1010 = 10(10) 
Exemplo: Digite na linha de comando: 
python3 # executa o interpretador interativo.
>>> a = 10 # atribui 10 à variável a.
>>> print (a) # mostra na tela o valor corrente da variável a.
>>> type (a) # mostra na tela o tipo da variável a. 
Repita para: b = 9597838897999876 ; c = 9.3 ; d = 3.14j 
 >>>w = 0xA ; w
Strings:
Strings são identificadas pela atribuição de um ou mais caracteres consecutivos,
representados entre aspas (“), apóstrofos (') ou entre três aspas ou apóstrofos, neste caso não
é necessário indicar quebra de linha (\n). Podemos acessar os caracteres individualmente ou
em grupos, utilizando um índice entre colchetes. O primeiro caractere tem índice 0. Os
caracteres de strings não podem ser modificados.
Exemplos:
python3
>>> frase = “isto-é-uma-string”
>>> type (frase)
>>> print (“\n”,frase)
>>> print (“ frase [0]= “, frase [0])
>>> print (“frase [1:5]= “, frase [1:5])
>>> print (“frase [1:6]= “, frase [1:6])
 >>> print (“frase [:7]= “,frase [:7])
>>> frase2=frase+” adicionar literal”
>>> print (frase2)
 >>> print (frase,end=””) >>> print (frase,” adicionando literal”)
Muitas vezes é necessário formatar um texto, mesclando seu conteúdo com valores de
variáveis, por exemplo em uma saída impressa ou mostrada no monitor de vídeo,
genericamente, o formato em Pascal para isso é:
 >>>X = 5 ; Y = 10.543789
 >>>print ('o valor de X é ', X, 'e o valor de Y é ', Y)
 
ou, ao estilo da linguagem C, utilizar o caractere % (operador de interpolação), seguido por
caracteres opcionais de tamanho, precisão de valores e do tipo de conversão (d,f,s para
inteiros, float e strings respectivamente) 
 >>>print ('o valor de X é %d e o valor de Y é %.2f ' %(X , Y))
ou, no novo estilo, utilizando o método format(), com os caracteres {} para interpolação,
que facilita dimensionar e inverter a ordem dos parâmetros posicionais.
 >>>print (“x = {} e Y = {}, {}”.format(X,Y,' correto?')) 
 >>>print (“{2} pois X={0:4d} e Y= {1:6.2f} c/ 6 posições”.format(X,Y,'correto?')) 
 >>>print (“{:>10}”.format(X)) # Imprime X alinhado pela direita em 10 colunas.
 >>>print (“{:^12}”.format('TESTE')) # Imprime string centralizada em 12 colunas.
 >>>print (“ y= {:11.5}”.format(Y)) # Imprime Y em 11 colunas, com 5 dígitos, à direita.
 >>>print (“ y= {:11.5f}”.format(Y)) # Imprime Y em 11 colunas, com 5 decimais. 
 >>>print (“ y={:<11.6}”.format(Y)) #Mostra Y em 11 colunas, com 6 dígitos, à esquerda.
 >>>print (“{:-<12}”.format('teste')) # Imprime 12 colunas, à esquerda e preenche com -.
 >>>print (“{:.2}”.format('teste')) # Trunca a string para 2 posições
 >>>print (“{:04d}”.format(X)) # Mostra X em 4 colunas, com zeros à esquerda.
 >>>print (“{:04}”.format(X)) # Mostra X em 4 colunas, com zeros à esquerda.
 >>>print ("Y={:10.2f}".format(Y)) # Mostra Y em 10 colunas com 2 casas decimais.
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 3
Observe que em alguns casos podemos omitir os caracteres de conversão (d, f, s). 
 Listas:
Listas são estruturas de dados semelhantes a vetores, sem a restrição de que todos os
elementos devem ser do mesmo tipo. 
Listas são formadas por um conjunto de elementos separados por vírgula, delimitadas por
colchetes ( [ ] ), onde cada elemento representa um valor, podendo esses valores serem de
diferentes tipos (inteiro, real, strings, listas). Cada elemento de uma lista tem um número ou
índice que determina a sua posição dentro da lista, o que possibilita a manipulação e
modificação dos valores de cada elemento da lista. Os índices das listas iniciam em zero. 
 Exemplos: 
python3 >>> lista2=[0] * 10
>>> lista = ['A', 'B', 'C', 1, 2, 5.9] >>> lista2
>>> type (lista) >>> lista3 = lista + lista2
>>> lista >>> type(lista3)
>>> lista [0] >>> lista3
>>> lista [3] >>> lista4=[]
>>> lista [1:3] >>> lista4
>>> lista[2] = lista [3]
>>> lista
….....
Tuplas:
Tuplas são como listas, com a diferença de que, como as strings, não podem ser modificas.
Os valores dos elementos de tuplas são delimitados por ( ) (abre e fecha parênteses).
Exemplo: 
$ python3
>>>lis= [128, 256, 512, 1024] 
>>>tup = (1, 2, 'A', 'B', 'C', lis)
>>> type (tup)
>>> tup
>>> tup [3] 
Operadores e Operandos:
Para formar as instruções do programa utilizamos os operandos, que são os dados que a
instrução vai manipular, e os operadores, que são construções que permitem manipular o
valor dos operandos.
Considere a expressão X = 5 + 7. Aqui temos X, 5 e7 como operandos e, + e = como
operadores.
Temos diversos tipos de operadores para manipular os diversos tipos de dados representados
nos operandos. 
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 4
Operadores aritméticos:
Os operadores aritméticos do python são semelhantes aos de várias linguagens de alto nível,
cuja precedência de execução, da maior para a menor, é:
 Exponenciação (**); 
Complemento de 1 (~); 
Multiplicação(*); Divisão real e inteira (/ e //); Módulo(%); 
Soma (+) e Subtração (-)
Podemos alterar essa precedência com o uso de parênteses: (5 + 2) * 2 = 14
 
 Considere as variáveis x=15 e y = 30
 Operador Significado Exemplo
 + Soma x + y = 45
 - Subtração y - x = 15
 * Multiplicação x * y = 450
 / Divisão real y / x = 2.0
 % Módulo (resto da divisão) y % x = 0
 ** Exponenciação x ** 2 = 225
 // Divisão inteira 7.0 // 2 = 3.0
Operadores Relacionais:
São utilizados para comparar os valores dos operandos envolvidos na instrução. O resultado
dessa comparação indica se a relação entre os operandos é falsa ou verdadeira. 
 Considere as variáveis x=15 e y=30 
 Operador Significado Exemplo
 == Se os dois operandos são iguais, resulta verdadeiro. (x == y) é falso 
 != Se os dois operandos são diferentes, resulta verdadeiro. (x != y) é verdadeiro
 < Se o primeiro operando é menor que o segundo, é verdadeiro (x < y) é verdadeiro
 > Se o primeiro operando é maior que o segundo, é verdadeiro (x > y) é falso.
 >= Se o primeiro operando é maior ou igual ao segundo, é 
verdadeiro 
 (x >= y) é falso.
 <= Se o primeiro operando é menor ou igual ao segundo, é 
verdadeiro 
 (x <= y) é verdadeiro
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 5
Operadores de atribuição:
São utilizados para designar um valor para a variável à esquerda do operador.
 Operador Descrição Exemplo
 =
 Igualdade
O primeiro operando recebe o valor do 
segundo operando ou expressão. 
x = y + z resultado de
y + z em x 
Operadores lógicos:
Permitem a construção de instruções com diversas condições relacionais, cujos resultados
(falso ou verdadeiro) são avaliados conjuntamente para determinar um resultado lógico final
como falso ou verdadeiro, que vai determinar a execução ou não de ações do programa
(Instruções condicionais).
Os principais operadores lógicos são: OR, XOR, NOT e AND, com a seguinte precedência
(Preferência de avaliação), da maior para a menor: NOT, AND, OR e XOR
Abaixo os resultados das condições relacionais, associadas pelos operadores lógicos. 
 NOT AND OR XOR
 A NOT A A B A AND B A B A OR B A B A XOR B
 F V F F F F F F F F F
 V F F V F F V V F V V
 --- --- V F F V F V V F V
 --- --- V V V V V V V V F
Obs.: Python oferece o operador lógico xor apenas para operações bit a bit.
Quando aplicados sobre variáveis, qualquer valor diferente de zero é considerado verdadeiro
e valores iguais a zero são considerados falso. Quando aplicados sobre bits individuais, os 
bits desligados (zero) são considerados falso e os ligados (um) considerados verdadeiro.
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 6
Exemplos de uso dos operadores lógicos binários:
Considere os valores das variáveis a = 60 e b = 13. (a = 0011 1100(2) e b = 0000 1101(2) )
 Operadores lógicos aplicados bit a bit
 Operador Resultado da avaliação bit a bit Exemplos
& (and binário) Verdadeiro se ambos bits =1 (a & b)= 0000 1100
| (or binário) Verdadeiro se um ou dois bits = 1 (a | b) = 61 (0011 1101)
 ^ (xor binário) Verdadeiro se um bit = 1, mas não
ambos
(a ^ b) = 49 (0011 0001)
 ~ (NOT binário) 
(complemento de 
um)
Inverte os bits do segundo 
operando, resultado no primeiro 
operando 
(~a ) = -61 (1100 0011 )
<< (desloca bits à 
esquerda)
Desloca no primeiro operando a 
quantidade de bits indicada no 
segundo operando 
(a << 2) = 240 
 (1111 0000)
>> (desloca bits à 
direita)
Desloca no primeiro operando a 
quantidade de bits indicada no 
segundo operando
(a >> 2) = 15 
 (0000 1111)
Exemplo de uso dos operadores lógicos sobre variáveis:
Considere os valores das variáveis x= 10 e y = 20
 Operador Descrição Exemplo
 AND lógico Se ambos operandos são verdadeiros, 
resulta verdadeiro.
(x and y) resulta 
verdadeiro. 
 OR lógico Se um dos dois operandos for 
diferente de zero, resulta verdadeiro.
(x or y) resulta 
verdadeiro
 NOT lógico Reverte o resultado. Not (x and y) resulta 
falso
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 7
Instruções básicas de entrada e saída (I/O): 
Utilizamos a instrução (função) print para apresentar dados no monitor e a instrução
(função) input para entrada de dados pelo teclado.
Saída no monitor:
Para apresentar dados no monitor utilizamos a instrução print com zero ou mais expressões
separadas por vírgula, que são convertidas em string e mostradas na tela:
Exemplos: 
#!/usr/bin/python3
print (“ Python é uma boa linguagem \n”, “ concorda?”) 
x = 5
y = 7
print (“ o produto entre “, x, “ e “, y, “ é : “ , (x*y)) 
print (“ o produto de %8i e %i é %.2f “ %(x, y, x*y))
Entrada de dados pelo teclado:
Para a leitura dos dados de entrada do programa, usamos a instrução input.
A instrução input lê uma linha pelo teclado e recebe-a como uma string, na variável à
esquerda do sinal de =, removendo o caractere de nova linha (\n).
Exemplo:
#!/usr/bin/python3
str = input("Digite sua entrada: ");
print ("A entrada recebida é : “, str)
Execute o programa acima, digitando uma frase sem utilizar aspas e, após, digite-a
novamente entre aspas.
Para transformar strings em valores numéricos inteiros ou reais (float), o python oferece
duas funções: int() e float().
Exs.:
x = “5” y = “3.14”
x = int(x) y = float(y)
Observe que ocorrerá um erro se o conteúdo da string for inválido.
Quando um dado é inserido pelo teclado convém assegurar que esse dado é do tipo esperado
pelas instruções do programa, ou teremos problemas. Por exemplo, quando esperamos um
valor numérico para realizar algum cálculo. Isso será visto adiante.
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág.8
Estrutura de sequência simples: 
É formada por um trecho do programa, composto por uma ou mais instruções que são
executadas incondicionalmente (instruções imperativas) quando alcançado pelo fluxo de
execução do programa.
Exemplo:
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
divddo = int(input (' informe o dividendo ')) 
divsr = int(input (' informe o divisor '))
quoc = divddo // divsr
print ( 'o quociente é = ', quoc)
print (' tchau ' )
exercício:
Crie um programa que calcule o custo total da tinta necessária para pintar uma área
informada, como descrito abaixo:
Entradas: Os lados da área a ser pintada devem ser informados pelo teclado.
Processamento: Sabendo que cada litro de tinta custa R$ 14,00 e que cada litro de tinta
pinta 2 m² da área, calcule quantos litros serão necessários e o custo com a tinta (considere
frações de litros), para a pintura da área. 
 
Saídas: No final mostre na tela a metragem da área, a quantidade de litros de tinta
necessários e o custo da tinta necessária. 
Estrutura de seleção:
As estruturas de seleção permitem a tomada de decisões sobre quais ações devem ou não ser
executadas, a partir da avaliação de condições que ocorrem durante a execução do
programa. Podem ser avaliadas múltiplas expressões condicionais que produzem como
única resposta falso ou verdadeiro, as quais podem ser associadas para a formação de
decisões mais elaboradas.
Abaixo a forma geral de uma estrutura típica de seleção.
 Verdadeiro 
 condição 
 
 falso 
 código para 
 código para o if
 o else
 
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 9
Três formas de uso da instrução if para a construção de estruturas de seleção:
 
 Construção if Descrição
 Decisão simples: 
 if … : ações
 If é seguido por uma condição (expressão) seguida
por “:” e uma ou mais instruções (indentadas) que
serão executadas se a condição é verdadeira.
 Decisão composta:
 if … : ações else : ações
 If é seguido por uma condição e por uma ou mais
instruções que serão executadas se a condição é
verdadeira, seguidas por um else (seguido por “:”) que
é seguido por uma ou mais instruções que serão
executadas se a condição for falsa.
 Decisões aninhadas:
 if ...if … elif … elif ... else
 If é seguido por sucessivos if ou elif, seguidos por
uma ou mais instruções que serão executadas ou não,
dependendo das condição serem verdadeiras ou falsas. 
Python fornece duas constantes internas True (verdadeiro) e False (falso) que podem ser
usadas no lugar de condições em algumas situações, assim, If True resulta verdadeiro e if
False resulta falso
Indentação: Diferentemente de outras linguagens, Python não utiliza caracteres para
delimitar os blocos verdeiro/falso do código, fazendo isso por indentação, que é obrigatória
nos blocos dependentes de outras instruções do programa. 
Exemplos:
#!/usr/bin/python3
x=0
if x == 0 :
print (“ o valor de x é zero”)
print (“ terminando execução”)
As duas linhas com a instrução print devem ser executadas se a condição x == 0 é
verdadeira, então devem estar indentadas.
Decisão simples:
 Formada por apenas uma condição e pelo bloco verdade, que será executado somente se a
condição (expressão) for verdadeira.
a) b)
var1 = 100 
if var1 : a = “5999999”
 print (" A expressão retorna verdadeiro") b = “6”
 print (var1) if b > a 
if var1 == 100 : print (“b maior pois são strings”)
 print (“ var1 é igual a 100 “ )
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 10
Decisão composta: 
Formada por uma condição inicial associada a um bloco verdadeiro de instruções, e por um
bloco falso, declarado após a cláusula else, que será executado se a condição inicial for
falsa.
Exs.:
 
>>>var1 = 100
>>>if var1 == 100 : 
 ... print ("var1 vale 100 (expr. verdadeira)")
 ... print (var1) 
… else :
 … print (“var1 difere de 100 (expr. falsa)”)
 … print (var1)
… print (" Encerrando")
… 
 #!/usr/bin/python3
 # -*- coding : UTF-8 -*-
 n1 = input (“digite o primeiro num”)
 n2 = input (“digite o segundo num”)
 if n1 > n2 :
print (“ O primeiro número é maior”)
 else :
 if n1 < n2 :
print (“ O primeiro número é menor”)
 else :
 print (“ Os números são iguais”)
 
Desafio: Podemos retirar algum else?
Decisão com ifs aninhados: 
Ifs aninhados permitem o teste de múltiplas condições através de sucessivos ifs,
subordinando a execução das ações, em parte ou no todo, às condições serem verdadeiras
ou, cada if pode ser seguido pela construção elif para iniciar outro teste caso o if precedente
(alinhado ao elif) resulte falso. elif é forma abreviada para “else if” e é útil para prevenir
excessiva indentação.
Sintaxe para a construção de ifs aninhados (if ...elif...else):
if expression1:
 statement(s)
 if expression2:
 statement(s)
 elif expression3:
 statement(s)
 else :
 statement(s)
elif expression4:
 statement(s)
else:
 statement(s)
 
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 11
Exemplo 1
#!/usr/bin/python3
var = 100
if var < 200:
 print ("Expressão menor que 200")
 if var == 150:
 print ("igual a 150")
 elif var == 100:
 print ("igual a 100")
 elif var == 50:
 print ("igual a 50")
elif var < 50: ## vai executar?
 print ("Expressão menor que 50")
else:
 print ("Nenhuma expressão verdadeira”)
print ("fim!")
Exemplo 2 ( observe a mensagem de erro ) 
x = input("Digite um inteiro: ")
if x < 0:
 x = 0
 print ('Negativo alterado para zero')
elif x == 0:
 print ('Zero')
elif x == 1:
 print ('Unidade')
else:
 print ('Maior')
print (“fim!!”) 
 
 
 
Exercício:
Faça um programa para verificar se um ano, digitado pelo teclado na forma AAAA, trata-se
de um ano bissexto ou não. Considerar como bissexto os anos divisíveis por 4 e não
divisíveis por 100, ou divisíveis por 400. Informar o resultadopor uma mensagem “ O ano
é bissexto” ou “ O ano não é bissexto”.
Decisão utilizando operadores lógicos 
As condições a serem testadas podem ser associadas entre si com o uso de operadores
lógicos (NOT, AND, e OR), para construir decisões mais elaboradas.
Exemplos:
a) b) 
python3 >>> x = 5
>>>a = 5 ; b = 6 ; c = 7 >>> if x != 5 or x!= 6 :
>>>if a == 5 and b >= 7 and c < 8 : print (“sempre V”)
 … print (“ a condição 1 é verdadeira”) 
… else : print (“ a condição 1 é falsa”) 
… 
>>>if a == 5 and b >= 7 or c < 8 : 
 … print (“ a condição 1 é verdadeira”) 
… elif a == 5 : 
 ... print (“ a condição 1 é falsa e a = 5“) 
 
….............................
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 12
Validação de dados:
Quando executamos uma instrução input para ler um dado, a variável que recebe esse dado
é definida como string. Se formos executar uma operação aritmética com esse dado, é
necessário verificar se o conteúdo da variável tipo string é numérico, para podermos
transformar a string em int ou float. Execute os comandos abaixo: 
python3
>>>print (“digite dois números para calcular o produto entre ambos”)
>>>n1 = input (“digite o primeiro número: “) # digite um número ou letras
>>>n2 = input (“digite o segundo número: “) # digite um número ou letras 
 
Execute os comandos abaixo e observe as mensagens no monitor.
>>>print (“Cuidado! Com strings, n1 + n2 = “,n1+n2)
>>>print (“o produto entre ”,n1,” e ”,n2,” é igual a:”,(n1*n2))
>>>print (“o produto entre %i e %i é igual a %d” %(n1,n2,n1*n2))
Observe que se utilizarmos a forma: n3=int(input (“ Digite um número inteiro”) caso o
dado digitado não seja um número inteiro, ocorrerá erro em tempo de execução. 
Teste para validar dados do tipo inteiro (int):
A função isdigit() é uma função do tipo String e retorna um boolean (True ou False) que
indica se o string é formado apenas por números (True) ou não (False). 
Note que se o string tiver um “.”, ou seja, se representar um float, como “3.4323”, a função
isdigit() retorna False. Abaixo um exemplo de teste usando da função isdigit() 
 
 python3
 >>> x=input("digite x ") 
 >>> print("x é = ",x) 
 >>> if x.isdigit() : 
 >>> print ("x é um número inteiro") 
 >>> x = int(x)
 >>> else : print (" x NÃO é um número inteiro") 
Testes para validar dados do tipo real (float):
Python3 não oferece uma função para indicar se o string é um float válido. Assim, devemos
fazer essa verificação ao converter um String para um float. 
Exemplos
1. python3 
 >>> try : 
 >>> sal = float (input ("digite o salário ")) 
 >>> print (" O valor é numérico") 
>>> except ValueError : 
 >>> print (" valor invalido") 
 
 prof. Arnaldo
FATEC-SP - ADS - alp / ial002 pág. 13
2. python3
>>> def testa_float(valor) : 
... try : 
... float(valor) 
... return True 
... except ValueError : 
... return False 
... 
>>> nota_str = input ("digite a nota") 
digite a nota 5 
>>>if testa_float (nota_str) :
 nota_f = float(nota_str) 
... print ("representa float") 
... else : 
... print ("nota invalida") 
... 
>>> nota_str
>>> nota_f
No exemplo 2 criamos uma função (testa_float) que realiza o teste e retorna True se o valor
é float / inteiro, ou retorna False se o valor não representa um dado numérico. 
 
 prof. Arnaldo