Representações de Algoritmos
Linguagem Natural
Linguagem Natural
– Também conhecida como Descrição Narrativa, trata-se da maneira como expressamos nosso raciocínio e trocamos informações.
- Como é a expressão da cultura de uma sociedade, desenvolvida através das gerações e em diferentes situações, raramente constitui um sistema de regras rígidas e estruturadas que possa ser implementada numa máquina ou que possa ser transcrita logicamente.
– Além da linguagem falada, fazem parte da nossa comunicação gestos e posturas, que não podem ser diretamente adaptados para compreensão de uma máquina.
- Ademais, toda a comunicação eficiente pressupõe um conhecimento prévio comum entre os interlocutores, por exemplo: a mesma língua, a mesma bagagem cultura, etc.
- Ao contrário dos seres humanos, as máquinas são projetadas para executar tarefas bem determinadas a partir de determinadas instruções.
– Um computador não é por si só uma máquina inteligente – no sentido de que não pode aprender com a própria experiência para melhorar seu comportamento futuro.
- Ao contrário, um computador é somente capaz de realizar estritamente as tarefas que lhe forem delegadas e que façam parte do conjunto daquelas ações que ele pode executar.
- Neste sentido, é necessário compreender que tipo de instruções podem ser executadas pelos computadores.
– Para que possamos programá-los – instruí-los com a sequência de ações necessárias para resolver um determinado problema – de modo que realizem a tarefa do modo desejado.
- Em suma: basta que eu escreva um conjunto de passos em qualquer língua que o meu computador realiza a tarefa que eu quiser?
- Não, isso é uma descrição narrativa que utiliza a linguagem natural para especificar os passos para a realização das tarefas – são ambíguas e não estruturadas.
Representações de algoritmos
Linguagem de Máquina
Linguagem de Máquina
– Além do fato de o computador necessitar que lhe instruam com ações bem específicas, estas ações devem ser passadas para o computador numa linguagem que ele possa entendê-las, chamada linguagem de máquina.
- Esta linguagem é composta somente por números, representados de forma binária (0 e 1), que – sob o ponto de vista do computador – representam as operações e os operandos que serão usados no processamento do programa.
- Para um ser humano, a linguagem de máquina é extremamente difícil de se compreender.
– Vocês já imaginaram alguém programando na linguagem de máquina? Seria inviável! Existe, portanto, uma linguagem representada por comandos, mas que reproduz as tarefas que serão executadas dentro do computador, chamada Linguagem de Montagem (Assembly).
- No entanto, mesmo a linguagem de montagem é difícil de programar – além de outros problemas como a especificidade do processador.
Representações de algoritmos
Linguagem de programação
Linguagem de programação
– Para facilitar a tarefa de programar um computador, foram criadas várias linguagens de programação.
- Estas linguagens são uma maneira de tentar escrever as tarefas que o computador vai realizar de maneira mais parecida com a linguagem natural.
- Embora ainda seja muitas vezes complexo em comparação com a linguagem natural, um programa escrito em uma linguagem de programação é muito mais fácil de ser implementado, compreendido e modificado.
– As linguagens de programação são um meio termo entre a linguagem de máquina e a linguagem natural.
- As linguagens mais parecidas com a linguagem de máquina são classificadas como linguagens de baixo nível.
- Já as linguagens mais parecidas com a linguagem natural são classificadas como linguagens de alto nível.
- Como um computador não entende diretamente linguagens de programação, ela deve ser traduzida em código de máquina antes de ser executada.
– Esse processo é chamado de tradução e é responsável por converter os comandos da linguagem de programação nas instruções em linguagem de máquina, que o computador é capaz de processar!
- Em suma: as linguagens de programação surgem – portanto – como uma solução para abstrair a comunicação entre seres humanos e computadores de modo que o computador nos entenda e nós os entendamos.
– Assim como seres humanos se comunicam por meio de diversas línguas (Exemplo: português, inglês, francês, japonês, dinamarquês, entre outras), as máquinas também podem se comunicar por meio de diversas linguagens de programação (Exemplo: Java, PHP, C++, Python, Ruby, entre outras).
– Um código-fonte é uma versão do software da forma em que ele foi originalmente escrito – digitado em um computador – por um programador humano em texto puro (caracteres alfanuméricos humanamente legíveis).
- Todo software ou site possui um código-fonte, que é um conjunto de palavras organizadas de acordo com regras específicas.
- Essas palavras que formam o algoritmo são escritas – em geral – utilizando linguagens de programação.
– Uma vantagem interessante da linguagem de programação em relação à linguagem de máquina é que um programa escrito em linguagem de máquina – como contém instruções escritas para um processador específico – só poderá ser utilizado naquele processador ou em similares.
- Em contrapartida, uma linguagem de programação, como contém somente instruções abstratas do que fazer, pode ser executado em qualquer processador ou máquina.
Representações de algoritmos
Pseudocódigo
Pseudocódigo
– O pseudocódigo é uma linguagem intermediária entre a linguagem natural e a linguagem de programação.
- Ela utiliza um conjunto restrito de palavras-chave, em geral na língua nativa do programador, que tem equivalentes nas linguagens de programação.
- Além disso, o pseudocódigo não requer a rigidez sintática necessária numa linguagem de programação, permitindo que um aprendiz se atenha à lógica do algoritmo e, não, ao formalismo da sua representação.
– À medida que se obtém mais familiaridade com os algoritmos, o pseudocódigo pode ser traduzido para uma linguagem de programação.
- Por essa razão, ele é considerado um excelente instrumento pedagógico para ensinar linguagens de programação.
- Em suma, um pseudocódigo é uma representação abstrata de um algoritmo utilizando uma linguagem simples sem necessidade de conhecer a sintaxe correta de nenhuma linguagem de programação.
– Pode-se dizer também que ele é uma simulação de uma linguagem de programação real, mas que – na verdade – é uma linguagem de programação “de mentirinha”.
- Logo, ela não pode ser utilizada para criar softwares de verdade, mas são excelentes para ajudar a entender a lógica.
- Um tipo de pseudocódigo brasileiro é o Portugol ou Português Estruturado.
- É uma pseudolinguagem utilizada para ensinar algoritmos em português.
Representações de algoritmos
Fluxograma
Fluxograma
– Além do português estruturado, é possível representar um algoritmo também por meio de um Fluxograma.
- O fluxograma é uma espécie de diagrama utilizado para documentar processos, ajudando o leitor a visualizá-los, compreendê-los mais facilmente e encontrar falhas ou problemas de eficiência.
– Portanto, nós vimos então que podemos representar algoritmos por meio de Descrições Narrativas, Linguagens de Programação, Pseudocódigos ou Fluxogramas.
- Em geral, os fluxogramas são mais utilizados para leigos; pseudocódigo para usuários um pouquinho mais avançados; e linguagens de programação para os usuários avançados.
Noções de Python
Conceitos básicos
Conceitos básicos
– Python é uma linguagem de programação de alto nível, interpretada, multiparadigma e case-sensitive sendo bastante utilizada para desenvolvimento web, criação de fluxos de trabalho, conexão com bancos de dados, resolução de problemas matemáticos, prototipação de software, entre outros.
=> Principais características
a) Alto nível
– Trata-se de uma linguagem de alto nível porque é uma linguagem com nível de abstração bastante elevado, bem longe do código de máquina e mais próximo da linguagem humana.
- Em outras palavras, o Python está muito mais próximo à forma humana de pensar/escrever do que dos comandos entendidos por um processador.
b) Interpretada
– Trata-se de uma linguagem interpretada porque seu código-fonte é executado linha a linha por um interpretador (software que traduz uma linguagem em outra) e depois pelo sistema operacional, isto é, seu código -fonte não precisa ser totalmente transformado em código de máquina para somente depois ser executado.
c) Multiparadigma
– Trata-se de uma linguagem multiparadigma porque suporta mais de um paradigma de programação.
- No caso, eles são: imperativo, procedural, funcional e orientado a objetos.
- Paradigmas são formas diferentes de resolver problemas – alguns utilizam funções, outros utilizam objetos, outros procedimentos e assim por diante.
d) Case-sensitive
– Trata-se de uma linguagem case-sensitive, isto é, capaz de diferenciar maiúsculas e minúsculas.
- Em outras palavras, isso significa que as variáveis nome, Nome e NOME são diferentes entre si, uma vez que possuem diferenças de caixa em sua grafia.
– Além disso, Python é uma linguagem multiplataforma, podendo ser utilizada no Windows, Linux, MacOS, etc.
- Além disso, ele é fácil de aprender e possui uma linguagem simples extremamente semelhante com o inglês comum.
- Pode-se afirmar também que é uma linguagem menos verbosa, isto é, sua sintaxe permite escrever softwares com menos palavras e linhas que outras linguagens semelhantes.
– Python é uma linguagem de tipagem forte e dinâmica.
- Linguagens de programação possuem um conjunto de regras sobre como tratar tipos de dados, sendo que a tipagem de uma variável pode ser estática/dinâmica ou fraca/forte.
- Linguagens com tipagem estática não permitem alteração de tipo de variável durante a execução do código-fonte; já linguagens com tipagem dinâmica permitem essa alteração.
– No código abaixo, nós declaramos uma variável com nome de var1 e a atribuímos o valor ‘Diego’, logo a linguagem já infere que se trata de uma variável do tipo string (conjunto de caracteres).
- Em seguida, nós atribuímos o valor 2020 (que é do tipo int) a essa mesma variável e não ocorre nenhum erro.
- Ela permite que a variável var1 tenha seu tipo modificado de string para int (inteiros). Se uma linguagem permite esse tipo de alteração durante a execução, trata-se de uma tipagem dinâmica.
- var1 = ‘Diego’
- var1 = 2020
– Linguagens com tipagem forte não permitem realizar algumas operações com variáveis de tipos diferentes sem conversão; já linguagens com tipagem fraca permitem realizar esse tipo de operação.
- No código abaixo, declaramos uma variável com nome de var2 e a atribuímos o valor ‘20’, logo a linguagem já infere que se trata de uma variável do tipo string, uma vez que tudo que vier entre aspas é considerado uma string (até mesmo números).
var2 = ‘20’
print(10 + var2)
– Na linha seguinte, há um comando (print) para imprimir na tela a soma de 10 com var2 – sendo que 10 é do tipo int e var2 é do tipo string.
- Isso resultará em um erro porque o Python não permite realizar uma soma entre variáveis string e int – seria necessário fazer uma conversão antes de realizar a operação desejada.
- Linguagens de programação de tipagem fraca permitem fazer esse tipo de operação sem precisar fazer uma conversão prévia de tipos.
– Python tem tipagem forte, logo teríamos que fazer uma conversão explícita transformando var2 em um inteiro antes de imprimir o valor em tela.
- Se ela tivesse tipagem fraca, faria essa conversão implicitamente, sem a necessidade de o programador indicar que deseja fazer uma conversão.
- Enfim, Python é uma linguagem de tipagem forte e dinâmica, porque não possui conversão implícita de tipos e porque permite alterar o tipo de uma variável durante a execução do código.
– Por fim, essa linguagem de programação apresenta código-fonte agrupado por indentação.
- Indentar é o recuo do texto em relação a sua margem.
- Em outras palavras, se antes de escrevermos uma instrução, utilizarmos quatro espaçamentos da margem esquerda até a instrução propriamente dita, podemos dizer que a indentação utilizada possui quatro espaços.
- Esse termo vem do inglês indentation e é bastante comum em linguagens de programação.
– Todos os blocos são delimitados pela profundidade da indentação e, por conta disso, sua organização é vital para o programa escrito nessa linguagem.
- A sua má utilização acarretará à não execução ou no mal funcionamento do software.
- Assim, se você criar um while e quiser colocar 4 comandos dentro dele, terá que colocar todos com uma indentação de alguns espaços.
- Quantos espaços? Quantos você quiser – desde que seja a mesma quantidade no bloco. Veja o exemplo:
1: i=0
2: while i<3:
3: print(i)
4: if i % 2 == 0:
5: print(“é par”)
6 i = i+1
7: print(“Acabou o loop”)
– No código acima, a linha 2 cria um loop de repetição em que as linhas 3 a 6 serão repetidas enquanto i < 3.
- Sabemos disso porque todas essas linhas estão com indentação interna ao comando while.
- Por sua vez, a linha 5 está em um bloco pertencente ao if da linha 4, pois está quatro espaços para dentro do if.
- Dessa forma, a indentação (ou endentação) em Python é estrutural e não apenas um elemento de organização visual.
Python - Outras características
Python - Outras características
a) Python permite utilizar ponto-e-vírgula (;) para delimitar comandos, mas de forma opcional – assim como em outras linguagens como JavaScript e Typescript.
b) Python é distribuída sob uma licença própria (compatível com a GPL), que permite a distribuição – comercial ou não – tanto da linguagem quanto de aplicações desenvolvidas nela, em formato binário ou código fonte, bastando cumprir a exigência de manter o aviso de copyright.
c) Python permite que programas sejam compilados para um formato portável chamado de bytecode. Essa característica faz com que programas escritos nessa linguagem com uma biblioteca padrão sejam executadas da mesma forma em diversos sistemas operacionais que possuam um software interpretador de Python,
d) Python possui uma interface com muitas bibliotecas e sistemas de janela, sendo extensível em C/C++.
- Além disso, pode ser utilizada como linguagem de extensão para aplicações que necessitam de uma interface programável (muito comum em aplicativos, jogos, processamento de textos, dados científicos e motores de busca).
e) Python possui funcionalidades para expressões regulares; sockets; threads; data/tempo; analisadores XML; analisadores de arquivos de configuração; manipulação de arquivos e diretórios; persistência de dados; unidades de testes; bibliotecas clientes para os protocolos HTTP, FTP, IMAP, SMTP e NNTP.
f) Python suporta o paradigma orientado a objetos com todos os seus componentes, tais como herança (simples ou múltipla), polimorfismo, sobrescrita, encapsulamento, abstração, reflexão, introspecção, etc! Não é necessário entender o que isso significa exatamente, apenas saber que ele suporta e que tudo em Python é um objeto.
– É importante mencionar que houve algumas mudanças introduzidas na virada da versão do Python de 2.x para o Python 3.x.
- Em termos de concurso, acredito que vale mencionar apenas uma mudança: o print mudou de instrução para função. O que isso significa na prática? Significa apenas que agora precisa de parênteses:
- print ‘Olá Mundo’ # até versão 2.7
- print(‘Olá Mundo’)# a partir da versão 3.0
Tipos de operadores
Tipos de operadores
– Assim como na matemática, operadores são elementos utilizados em linguagens de programação para realizar operações.
- Existem quase 40 operadores em Python, mas nós não vamos ver todos porque diversos deles possuem um péssimo custo/benefício e não valerá a pena.
- Vamos nos ater – portanto – aos operadores mais cobrados em prova.
– Abaixo serão apresentadas categorias de operadores com suas descrições e exemplos.
– Operadores Matemáticos são os mais simples e comuns. Nós aprendemos todos eles na época de escola, só basta lembrar da ordem de precedência:
- => Soma => 10 + 10 = 20.
- => Subtração => 20 - 20 = 0.
- => Multiplicação => 15 * 25 = 375.
- / => Divisão 25 / 4 = 6,25.
- // => Divisão com Piso => 25 // 4 = 6 (6,25 arredondado para baixo) .
- ** => Exponenciação => 2 ** 5 = 32.
- % => Módulo => 30 % 7 = 2 (resto da divisão)
– Operadores de Atribuição são usados para atribuir valores a variáveis! Considerem na lista abaixo que as operações seguem uma sequência (o resultado da linha atual depende da linha anterior):
- = Atribuição Simples x = 10 é o mesmo que atribuir o valor 10 a x.
- += Atribuição com Soma x += 1 é o mesmo que x = x + 1, logo x = 10 + 1 = 11.
- -= Atribuição com Subtração x -= 6 é o mesmo que x = x - 6, logo x = 11 – 6 = 5.
- *= Atribuição com Produto x = 2 é o mesmo que x = x2, logo x = 5 * 2 = 10.
- /= Atribuição com Divisão x /= 5 é o mesmo que x = x / 5, logo x = 10 / 5 = 2.
– Operadores de Comparação (também chamados de Operadores Relacionais) são utilizados para comparar valores! Nos exemplos abaixo, considere sempre que x = 1 e y = 2. Vejamos…
- == => Igual => x == y retorna Falso.
- != => Diferente => x != y retorna Verdadeiro.
- > => Maior que => x > y retorna Falso
- < => Menor que => x < y retorna Verdadeiro.
- >= => Maior ou igual a => x >= y retorna Falso.
- < = => Menor ou igual a => x <= y retorna Verdadeiro
– Operadores Lógicos são utilizados para combinar condições em expressões e também são frequentemente utilizados em Python. Nos exemplos abaixo, considerem que x = 10 e y = 20:
- and => Retorna Verdadeiro se ambas condições forem Verdadeiras => x == 10 and y > 20 retorna Falso.
- or => Retorna Verdadeiro se uma das condições for Verdadeira => x == 10 or y > 20 retorna Verdadeiro.
- not => Inverte o resultado de uma condição qualquer => not(x == 10 or y > 20) retorna Falso.
– Operadores de Associação são utilizados para verificar se um conjunto de valores está presente em um objeto. Vejamos como funciona:
a) in =>Retorna Verdadeiro se o conjunto de valores estiver presente no objeto
x = [“Flamengo”, “Vasco”]
y = “Botafogo” in x
print(y) retornará Falso porque Botafogo não está na lista.
b) not in => Retorna Verdadeiro se o conjunto de valores não estiver presente no objeto
x = [“Flamengo”, “Vasco”]
y = “Flamengo” not in x
print(y) retornará Falso porque Flamengo está na lista.
Funções
Retornará o número do parâmetro multiplicado por 5
Funções
– Uma função é um bloco de código que é executado apenas quando é invocado. São três passos bem simples: (1) uma função é invocada; (2) é passado algum dado como parâmetro ou não; (3) e algum dado é retornado como resultado. No Python, uma função é definida utilizando a palavra-chave def. Sempre que você vir essa palavra em um código-fonte, saiba que ela está definindo uma função (lembrando que a utilização de chaves para delimitar o bloco é facultativa). Seguindo…
Sintaxe: def NomeFunção(argumentos):
def BomDia():
print(‘Bom dia!’)
– No código acima, foi definida uma função chamada BomDia(). Toda vez que essa função for invocada, será impresso na tela as palavras “Bom dia!”.
- Invocar significa** chamar essa função** para que ela seja executada.
- Caso eu deseje que essa função seja executada em algum ponto do meu código-fonte, eu posso invocá-la bastando apenas chamar seu nome: BomDia().
– E se a minha função precisar de alguns dados para que ela consiga processar alguma informação e retornar um resultado? Sem problemas! Nós podemos passar alguns parâmetros – também chamados de argumentos – dentro dos parênteses separados por vírgulas. Modificando um pouco a função definida no código anterior, nós podemos inserir um nome como parâmetro de modo que seja impressa uma mensagem que dependerá do parâmetro passado:
def BomDia(nome):
print(‘Bom dia, ‘,nome)
– Note que agora a função precisa de um parâmetro para que possa ser executada! Logo, se eu invoco essa função como BomDia(‘Diego’), será impressa a mensagem “Bom dia, Diego”. Vejam só:
- BomDia(‘Diego Carvalho’)
#Retornará Bom dia, Diego Carvalho - BomDia(‘Renato da Costa’)
#Retornará Bom dia, Renato da Costa - BomDia(‘Ricardo Vale’)
#Retornará Bom dia, Ricardo Vale - BomDia(‘Herbert Almeida’)
#Retornará Bom dia, Herbert Almeida
– É possível também passar mais de um parâmetro para uma função. Para tal, basta separá-los por vírgula dentro dos parênteses:
def BomDia(nome1, nome2):
print(‘Bom dia, ‘ + nome1 + ‘ e ‘ + nome2)
BomDia(‘Diego’,’Renato’)
#Retornará Bom dia, Diego e Renato
– Em todas as funções apresentadas, não se retornou nenhum resultado (dados apenas foram impressos em tela). No entanto, é possível retornar algum valor usando a palavra-chave return:
def MultiplicaPorCinco(numero):
return 5* numero
– print(MultiplicaPorCinco(1))
#Imprimirá 5*1 = 5
- print(MultiplicaPorCinco(2))
#Imprimirá 5*2 = 10 - print(MultiplicaPorCinco(3))
#Imprimirá 5*3 = 15 - print(MultiplicaPorCinco(4))
#Imprimirá 5*4 = 20 - print(MultiplicaPorCinco(5))
#Imprimirá 5*5 = 25
– Um dado importante é que uma variável somente está disponível dentro da região em que ela é criada – chamamos isso de escopo! Veja o código-fonte abaixo:
def minhaFuncao(y):
x = y + y #Escopo Local
print(x)
return x
x = 5 #Escopo Global
minhaFuncao(x)
print(x)
– Notem que definimos inicialmente uma função chamada minhaFuncao( ). Toda variável criada dentro dessa função possui um escopo local, logo somente podem ser utilizadas dentro dessa função.
- Em seguida, temos x = 5 com uma indentação diferente, logo ele não possui escopo local daquela função, ele possui um escopo global.
- Porque ele não foi criado dentro da função, portanto ele existe e pode ser utilizado em qualquer parte do código.
– Dito isso, vamos analisar o código! A função é definida (linhas 1 a 4), depois cria-se uma variável x com valor 5 e chama-se a função com esse parâmetro (linha 7), logo minhaFuncao(5).
- Quando essa variável vai para dentro da função, ela é recebida como y (minhaFuncao(y)).
- E essa função cria uma variável x (que só existe dentro dela) e diz que x = y + y.
- Ora, quanto é y? y = 5, logo x = 5+5 = 10.
- Na linha 3, a função imprime x (logo, imprime 10) e retorna 10.
– Quando voltamos ao corpo principal do código-fonte, temos um print(x).
Ora, quanto é x? Agora que vem o pulo do gato! Aquele x utilizado na função só existe lá dentro porque ele tem escopo local.
- Logo, quando voltamos ao corpo principal, ele não existe!
- No entanto, existe outro x no corpo principal. Qual? Aquele definido na linha 6! Logo, a linha 8 imprimirá 5!
- Legal, né? Imprimimos x duas vezes, mas dentro da função ele tem valor 10 e fora da função ele tem valor 5.
– Programadores tentam escrever algoritmos da forma mais perfeita possível. E mesmo após escrevê-los, os algoritmos passam por uma bateria de testes.
- No entanto, é inevitável que ocorram exceções no fluxo de execução de algoritmos por diversos motivos diferentes. O ponto é: dado que exceções podem ocorrer, o que podemos fazer?
- Se não fizermos nada, o fluxo de execução do algoritmo será interrompido e o sistema parará de funcionar.
– Em linguagens de programação, uma exceção é um evento que ocorre durante a execução de um programa que interrompe o fluxo normal de execução.
- Exceções são geralmente usadas para indicar que algo deu errado ou inesperado aconteceu, como uma operação de divisão por zero, uma tentativa de acesso a um arquivo que não existe, ou uma conexão de rede falha.
- Quando uma exceção é lançada em um programa, o fluxo normal de execução é interrompido.
– A partir daí, o controle é transferido para um bloco de código especial que é projetado para lidar com a exceção.
- Esse bloco de código pode capturar e lidar com a exceção, ou simplesmente reportá-la e encerrar o programa.
- As exceções são uma forma eficaz de lidar com condições de erro e tornar os programas mais robustos.
- Em vez de falhar silenciosamente ou produzir resultados imprevisíveis, os programas podem lançar exceções que indicam exatamente o que deu errado.
– O Python lida com exceções por meio de uma estrutura chamada try-except.
- Imagine que você está escrevendo um código que faz uma operação matemática com dois números, e um usuário do seu programa insere um valor inválido, como a divisão por zero.
- Sem o try-except, o seu código quebraria e o programa iria parar de funcionar.
- No entanto, por meio do try- except, você pode “tentar” executar o código que faz a operação matemática.
– Se ocorrer um erro, você pode “capturar” esse erro e tomar uma ação apropriada como exibir uma mensagem de erro amigável para o usuário. Vejamos a sintaxe básica do try-except:
try:
#Bloco de código que pode gerar uma exceção
except TipoDeExcecao:
#Bloco de código que trata a exceção
– O bloco try contém o código que pode gerar uma exceção;
- O bloco except contém o código que será executado se ocorrer uma exceção do tipo especificado;
- TipoDaExcecao é o nome da exceção que o bloco except pode capturar.
- Pode ser o nome de uma exceção já integrada nativamente do Python (como ZeroDivisionError, TypeError, ValueError, etc) ou o nome de uma exceção definida pelo usuário. Vejamos um exemplo:
try:
x = int(input(“Digite um número inteiro: “))
except ValueError:
print(“Entrada inválida. O valor informado não é um número inteiro.”)
– Neste exemplo, o bloco try tenta converter a entrada do usuário para um número inteiro.
- Se o usuário informar uma entrada que não pode ser convertida para um número inteiro, será lançada uma exceção do tipo ValueError.
- O bloco except captura essa exceção e exibe uma mensagem de erro.
- Em Python, também é possível usar vários blocos except para capturar diferentes tipos de exceções.
– Vejamos outro exemplo clássico:
– Estamos tentando fazer uma divisão por zero, mas ao invés de deixar o programa quebrar, usamos o try-except para capturar o erro e exibir uma mensagem de erro amigável para o usuário.
try:
resultado = 10 / 0 #divisão por zero proposital
except ZeroDivisionError:
print(“Oops! Houve um erro. Você não pode dividir por zero.”)
– Além disso, é possível usar um bloco finally opcional para executar um código após o término do bloco try, independentemente de ter ocorrido uma exceção ou não. Vejamos um exemplo:
try:
arquivo = open(“arquivo.txt”, “r”)
#bloco de código que lê o arquivo
finally:
arquivo.close()
– Note que o bloco try abre o arquivo “arquivo.txt” para leitura e executa o código que lê o arquivo.
- O bloco finally garante que o arquivo será fechado, independentemente de ter ocorrido uma exceção.
– Por fim, é importante falar sobre funções/expressões lambda.
- Funções lambda são pequenas funções anônimas.
- Essas funções são úteis para deixar o código mais simples e legível.
- Elas são funções de uma única linha, isto é, não possuem nome e são declaradas como variáveis.
- Além disso, sua sintaxe não utiliza a palavra-chave def e nem utilizam a palavra return antes do comando porque se considera que haverá um retorno implícito.
Sintaxe: lambda lista_de_argumentos : expressão
– Uma função anônima é útil principalmente nos casos em que precisamos de uma função para ser passada como parâmetro para outra função e que não será mais necessária após isso – como se fosse “descartável”.
– Vejam no exemplo abaixo a criação de uma função anônima que recebe dois parâmetros – x e y – e retorna a soma das duas variáveis. Essa função anônima é atribuída à variável s, que quando é invocada retorna essa soma:
s = lambda x,y : x+y
print(s(10,20)) #Retornará 10+20 = 30
– Para finalizar, vamos ver uma comparação de uma função comum apresentada anteriormente com uma função lambda. Vejamos…
def quadrado(x):
return x*x
print(quadrado(2)) #Retornará 4
– Notem que se trata de uma função comum. Como poderíamos transformar essa função em uma expressão lambda? Basta utilizar a sintaxe apresentada anteriormente. Logo, teríamos…
quadrado = lambda x: x*x
print(quadrado(2)) #Retornará 4
Comentários
Comentário para documentar a função “Olá, Mundo!”
Comentários
– A utilização de comentários é uma prática comum em programação. Seu objetivo é adicionar descrições em partes especificas do código, seja para documentá-lo, seja para descrevê-lo, ou mesmo, para marcar que uma determinada linha, ou um conjunto de linhas, não devem ser executadas. Podem ser utilizados para documentar programas, classes, funções, variáveis, constantes ou o que mais você desejarmos.
– Quando criamos uma funcionalidade, é importante que o código possua uma documentação para que os outros programadores (e até nós mesmos) entendam qual foi a lógica utilizada.
- Para adicionarmos comentários, utilizamos uma marcação especial a fim de informar ao interpretador para não interpretar os caracteres contidos na notação que demarca trechos de comentários.
– No caso do Python, há notações diferentes para comentários de uma única linha e comentários de mais de uma linha.
- Caso você deseje fazer um comentário de apenas uma linha, pode utilizar o caractere cerquilha (#). Tudo que estiver à frente desse caractere deve ser ignorado pelo interpretador.
- Caso você deseje fazer um comentário com mais de uma linha, pode utilizar aspas triplas (simples ou duplas). Vejamos alguns exemplos:
print(“Olá, Mundo!”)
’’’
Comentário para documentar
a função “Olá, Mundo!”
com mais de uma linha
e aspas simples
’’’
print(“Olá, Mundo!”)
”””
Comentário para documentar
a função “Olá, Mundo!”
com mais de uma linha
e aspas duplas
”””
print(“Olá, Mundo!”)
Tipos e Variáveis - Definições
Tipos e Variáveis
Definições
– Em nível de hardware, seu computador possui um componente chamado Memória RAM, que é responsável – grosso modo – por armazenar dados, sendo composta por milhões e milhões de posições ou espaços físicos.
- Em nível de software, dados são armazenados – em geral – em variáveis, que são essas posições na memória responsáveis por armazenar dados e identificadas por um nome.
– O conteúdo de uma variável pode ser alterado, consultado ou apagado diversas vezes durante a execução de um algoritmo, porém o valor apagado será perdido.
- Eu gosto de pensar na variável como uma caixa aberta, em que você pode inserir, retirar ou modificar coisas de dentro.
- Em contraste com uma constante, que seria uma caixa em que – uma vez inserido algo dentro – não mais permite inserções, alterações ou remoções enquanto o programa estiver sendo executado.
– Assim como as línguas faladas, as linguagens de programação possuem o que chamamos de declarações.
- Declarações são pensamentos completos e individuais – por exemplo: “Eu quero café” ou “Está chovendo”.
- Usando palavras diferentes, podemos mudar o significado – por exemplo: “Eu quero café” para “Eu quero unicórnios”.
- No entanto, não podemos mudar de “Eu quero café” para “Eu quero chovendo” – que não faz sentido gramatical.
– O conjunto de regras que governam a estrutura e composição de declarações em uma linguagem é chamado de sintaxe.
- Assim como o idioma Português possui uma sintaxe, todas as linguagens de programação também possuem.
- Vejam só: a é igual a 5 é uma declaração na língua portuguesa; a = 5 também é uma declaração, mas na linguagem de programação Python. Neste caso, a declaração diz que uma variável chamada a armazena o número inteiro 5.
– Quando uma declaração atribui um valor a uma variável, nós chamamos isso de “declaração de atribuição”. É possível também expressar coisas mais complexas como:
- A é 5;
- B é 10;
- C é A mais B;
– O que o algoritmo acima está querendo dizer? Este algoritmo (que não está escrito em Python) diz ao computador para definir a variável A como 5, a variável B como 10, e, finalmente, somar A e B e armazenar o resultado na variável C.
- Note que podemos chamar as variáveis de qualquer coisa que nós quisermos desde que cumpra a sintaxe da linguagem de programação escolhida.
- Em vez de A, B e C, poderíamos chamar de Maçã, Pera e Uva.
– Uma melhor prática seria nomeá-las com coisas que façam sentido no caso de alguém mais tentar entender seu código.
- Imaginem vocês tentando ler um código escrito por outra pessoa.
- Fica mais fácil de compreender Maçã, Pera e Uva do que A, B e C.
- As declarações atribuem identificadores para variáveis, tipos, funções, entre outros.
Identificadores
Identificadores
– Variáveis são uma espécie de contêiner para armazenar valores de dados. No Python, as variáveis possuem duas particularidades: (1) variáveis são consideradas um tipo de objeto; (2) variáveis não precisam ser previamente declaradas.
- Em outras linguagens de programação, é necessário usar um comando para declarar uma variável.
- No Python, não é necessário usar comando nenhum, basta informar o nome e o valor que será armazenado.
- nome = “Diego”
- idade = 31
– Vejam acima que não é necessário usar nenhum comando, eu simplesmente inseri o nome da variável e o seu valor. Em outras linguagens de programação, eu teria que fazer algo como:
- var nome = “Diego”
- var idade = 31
– Além disso, não é necessário informar qual é o tipo da variável, isto é, quais tipos de valores serão armazenados na variável. Em outras linguagens de programação, eu teria que fazer algo como:
- var string nome = “Diego”
- var int idade = 31
– É possível fazer várias atribuições de variáveis em uma mesma linha. Para tal, basta separar os identificadores por vírgula do lado esquerdo da atribuição e manter a mesma ordem no lado direito:
- nome, idade = “Diego”, 31
– Identificadores de variáveis válidos devem obedecer às seguintes regras:
- Começar necessariamente com uma letra ou _ (underline);
- Jamais devem começar com um número;
- Conter caracteres alfanuméricos e undelines (a-z, A-Z, 0-9 e _);
- São Case-Sensitive, isto é, capazes de diferenciar maiúscula de minúscula.
– Essa mesma regra vale também para identificação de funções, classes, módulos, entre outros.
– Vejamos alguns exemplos de nomes válidos e inválidos:
=> NOMES VÁLIDOS DE VARIÁVEIS
- nomevariavel = “Diego”
- nome_variavel = “Diego”
- _nome_variavel = “Diego”
- nomeVariavel = “Diego”
- NOMEVARIAVEL = “Diego”
- nomevariavel2 = “Diego”
=> NOMES INVÁLIDOS DE VARIÁVEIS
- 2nomevariavel = “Diego”
- nome-variavel = “Diego”
- nome variavel = “Diego”
- nome#variavel = “Diego”
- Nome%variavel = “Diego”
- n0m3v@r1@vel = “Diego”
– O Python possui uma função chamada print() responsável por imprimir na tela do computador o valor de uma variável. Vejamos como funciona:
nome = “Diego”
idade = 31
print(nome) #Imprimirá: Diego
print(idade) #Imprimirá: 31
– Para imprimir um texto junto com o valor de uma variável, basta utilizar o caractere +. Lembrando que esse caractere serve tanto para somar o valor de variáveis quanto para realizar concatenações.
nome = “Diego”
idade = 31
print(“Prof. “ + nome + “ tem “ + str(idade) + “ anos”) #Imprimirá: Prof. Diego tem 31 anos
Tipos de dados
Exemplos:
Tipos de dados
– É importante mencionar alguns detalhes sobre os tipos booleano, numérico e textual.
- O tipo booleano não tem nada demais – ele só representa dois valores: True ou False.
- Isso é extremamente útil em programação para avaliar se alguma expressão é verdadeira ou falsa.
- Quando você compara dois valores, por exemplo, retorna-se um valor verdadeiro ou falso.
– É importante ressaltar que existe também uma função chamada bool().
- Essa função retorna um valor True ou False dado um determinado parâmetro de entrada.
- Em regra, ela retornará sempre True, com algumas exceções: bool(), bool(0) e bool(False) – nesse caso, ela retornará False.
- Isso já foi tema de questão de prova da Polícia Federal (2021) com pegadinha ainda! Lembre-se que “False” é diferente de False – o primeiro é uma string e o segundo é um booleano.
– Já os números podem ser inteiros, ponto flutuante ou complexos.
- Inteiro é um número positivo ou negativo sem decimais (Ex: 2, -50, 137);
- Ponto Flutuante é um número positivo ou negativo com um ou mais decimais (Ex: -0.5, 3.1415, 137.0);
- Complexo é um número escrito com a letra j para indicar a parte imaginária (Ex: 8j, -14j, 500j).
– Por fim, variáveis textuais/literais são cadeias de caracteres chamadas de string.
- Trata-se de uma sequência de caracteres geralmente utilizada para representar caracteres, palavras, frases ou textos.
- Os valores podem vir dentro de aspas simples ou aspas duplas (Ex: ‘Diego’ ou “Diego”).
- Além disso, os caracteres que compõem uma string podem ser acessados individualmente. Para tal, basta utilizar colchetes. Vejamos…
nome = “Diego”
print(nome[0]) #Retornará o caractere de índice 0 = “D”
– Nós falamos que uma string é uma cadeia de caracteres.
- Logo, no exemplo acima, é como se nome fosse uma variável que armazenasse [“D”,”i”,”e”,”g”,“o”].
- Cada letra nessa cadeia está associada a um índice sequencial: nome[0] = “D”; nome[1] = “i”; nome[2] = “e”; nome[3] = “g”; nome[4] = “o”.
- E se você quisesse retornar apenas os caracteres do meio dessa string? Nesse caso, bastaria utilizar a instrução print(nome[1:4] = “ieg”).
– Vamos ver agora algumas funções textuais úteis:
a) capitalize() => Converte o primeiro caractere em maiúscula.
- x = “olá, mundo!” print(x.capitalize()) #retorna “Olá, mundo!”
b) find() => Retorna a posição da primeira ocorrência de um valor em uma string ou -1 se não existir.
- x = “Uma vez Flamengo, sempre Flamengo!” print(x.find(“vez”)) #retorna 4
c) index() => Semelhante ao find(), mas retorna uma exceção caso o valor não exista.
x = “Uma vez Flamengo, sempre Flamengo!” print(x.index(“vasco”)) #retorna ValueError
d) len() => Retorna o tamanho da string.
- x = “Uma vez Flamengo, sempre Flamengo!” print(len(x)) #retorna 34
e) split() => Divide substrings encontradas a partir de um separador especificado e retorna uma lista.
- x = “Olá, Mundo!” print(x.split(“,”)) #retorna [‘Olá’, ‘ Mundo!’]
f) strip() => Remove espaços em branco (ou caracteres dentro do parêntese) do início e no fim da string.
- x = “ Olá, Mundo! ” print(x.strip()) #retorna “Olá, Mundo!”
– É importante falar rapidamente sobre casting! Esse é um recurso que permite definir ou converter o tipo de uma variável. Em geral, isso é feito por meio de três funções:
a) int() => Converte variáveis do tipo inteiro, ponto flutuante ou string em um inteiro.
x = int(100) #x será 100
y = int(4.8) #y será 4
z = int(‘5’) #z será 5
b) float () => Converte variáveis do tipo inteiro, ponto flutuante ou string em um ponto flutuante.
x = float(100) #x será 100.0
y = float(3.6) #y será 3.6
z = float(‘2’) #z será 2.0
c) str () => Converte variáveis do tipo inteiro, ponto flutuante ou string em uma string.
x = str(‘Diego’) #x será ‘Diego’
y = str(1234567) #y será ‘1234567’
z = str(3.14159) #z será ‘3.14159’
Estrutura de dados
Estrutura de dados
– Nós estudamos cinco tipos de dados no tópico anterior (booleano, inteiro, ponto flutuante, complexo e textual).
- Todos eles possuem uma característica em comum: são capazes de armazenar um único dado.
- No entanto, para armazenar múltiplos itens dentro de uma única estrutura, utilizamos estruturas de dados.
- No caso do Python, essas estruturas de dados são chamadas de coleções (collections).
– Uma coleção é um contêiner utilizado para armazenar uma coleção de dados.
- Em outras palavras, trata-se de uma estrutura de dados utilizada para armazenar objetos.
- Em algumas situações você precisa armazenar um conjunto de valores e – não apenas – um único valor.
- Para escolher qual coleção será utilizada, é importante entender as propriedades de cada tipo a fim de tirar o melhor possível de cada estrutura. Bem, existem quatro tipos de coleção.
a) LIST (LISTA) => Trata-se de uma coleção de valores ordenados, mutáveis e indexáveis que pode conter valores duplicados. São delimitados por colchetes
b) TUPLE (TUPLA) => Trata-se de uma coleção de valores ordenados, imutáveis e indexáveis que pode conter valores duplicados (também podem ser chamadas de sequências). São delimitados por parênteses.
c) SET (CONJUNTO) => Trata-se de uma coleção de valores desordenados, mutáveis e não indexáveis que não pode conter valores duplicados.
d) DICTIONARY (DICIONÁRIO) => Trata-se de uma coleção de valores ordenados, mutáveis e indexáveis que não pode conter valores duplicados.
Listas
Listas
– Uma lista é uma coleção de valores ordenados, mutáveis e indexáveis que pode conter valores duplicados e são delimitadas por colchetes. Vejamos um exemplo:
ListaFrutas = [“maçã”, “carambola”, “banana”]
print(ListaFrutas) #Retornará [‘maçã’, ‘carambola’, ‘banana’]
– Vejam que realmente se trata de uma coleção, uma vez que armazena múltiplos valores em uma única variável. Mas e se eu quiser acessar uma fruta específica? Vejamos…
ListaFrutas = [“maçã”, “carambola”, “banana”]
print(ListaFrutas[1]) #Retornará carambola
– Cada valor em uma lista é indexado por um número inteiro.
- Significa que existe um número inteiro que referencia cada valor da lista com o intuito de facilitar seu acesso.
–* Não deveria ter retornado maçã em vez de carambola, uma vez que foi utilizado o índice [1]*? Não, porque – por convenção – adotou-se que o índice de lista começa sempre pelo [0] (zero). Vejam só o que aconteceria se o código fosse assim:
ListaFrutas = [“maçã”, “carambola”, “banana”]
print(ListaFrutas[0]) #retornará maçã
print(ListaFrutas[1]) #retornará carambola
print(ListaFrutas[2]) #retornará banana
print(ListaFrutas[3]) #retornará IndexError: list index out range
– Note que se eu tentar acessar o índice [3], retornará Erro de Índice: índice da lista fora de alcance. E se eu quiser modificar algum valor dessa lista?
ListaFrutas[0] = “manga”
ListaFrutas[2] = “carambola”
print(ListaFrutas) #retornará [‘manga’, ‘carambola’, carambola]
– Percebam que eu mudei o valor armazenado no índice [0] e índice [2] da lista e o resultado correspondeu aos novos valores.
- Uma lista é uma coleção de valores ordenados, mutáveis e indexáveis que pode conter valores duplicados.
- Uma lista é uma coleção de valores? Sim, nós vimos que ele é capaz de armazenar múltiplos dados.
- Os valores de uma lista são ordenados? Sim, ser ordenado significa que há uma ordem qualquer.
– O que acontece se eu utilizar um índice negativo em uma lista? Um índice negativo significa que a lista começa do fim para o início. É só ver a lista de modo invertido.
ListaFrutas = [“maçã”, “carambola”, “banana”]
print(ListaFrutas[-1]) #retornará banana
print(ListaFrutas[-2]) #retornará carambola
print(ListaFrutas[-3]) #retornará maçã
print(ListaFrutas[-4]) #retornará IndexError: list index out range
– Note que há uma observação: “maçã” está no índice [0] e no índice [-3]. Além disso, é possível especificar uma extensão de índices também.
ListaFrutas = [“maçã”, “carambola”, “banana”, “pera”, “laranja”, “amora”]
print(ListaFrutas[1:2]) #retornará [‘carambola’]
print(ListaFrutas[1:3]) #retornará [‘carambola’, ‘banana’]
print(ListaFrutas[1:4]) #retornará [‘carambola’, ‘banana’, ‘pera’]
print(ListaFrutas[1:5]) #retornará [‘carambola’, ‘banana’, ‘pera’, ‘laranja’]
– Note que o valor contido na posição do índice à esquerda dos dois-pontos é retornado, mas o valor contido na posição do índice à direita, não. Há também algumas variações:
ListaFrutas = [“maçã”, “carambola”, “banana”, “pera”, “laranja”, “amora”]
print(ListaFrutas[:2]) #retornará [‘maçã’, ‘carambola’]
print(ListaFrutas[3:]) #retornará [‘pera’, ‘laranja’, ‘amora’]
– Note que – se não inserirmos nenhum valor à esquerda – considera-se como [0] ; e – se não inserirmos nenhum valor à direita, considera-se até o final da lista.
- Temos visto diversos exemplos em que todos os valores da lista são do tipo texto, mas eles poderiam ter outros tipos (inclusive tipos diferentes em uma mesma lista).
- Por essa razão, dizemos que uma lista é um tipo de coleção heterogênea.
– Nós já vimos que é possível criar funções em Python, mas já existem diversas funções (ou métodos) prontos para serem utilizados.
a) len( ) => Função utilizada para retornar quantos itens uma lista possui.
ListaQualquer = [2020, “Flamengo”, True]
print(len(ListaQualquer))
#Retornará 3
b) append( ) => Função utilizada para adicionar um item ao final da lista. Pensando como uma pilha, de modo inverso a uma lista, ele adiciona um item no topo.
ListaQualquer = [2020, “Flamengo”, True]
ListaQualquer.append(5)
print(ListaQualquer)
#Retornará [2020, “Flamengo”, True, 5]
c) insert( ) => Função utilizada para adicionar um item a um índice especificado.
ListaQualquer = [2020, “Flamengo”, True, 5]
ListaQualquer.insert(3,”Bola”)
print(ListaQualquer)
#Retornará [2020, “Flamengo”, True, ‘Bola’, 5]
d) remove( ) => Função utilizada para remover a primeira ocorrência de um item especificado em uma lista.
ListaQualquer = [2020, “Flamengo”, True, “Bola”, 5]
ListaQualquer.remove(2020)
print(ListaQualquer)
#Retornará [“Flamengo”, True, “Bola”, 5]
e) pop( ) => Função utilizada para remover item especificado (ou o último item se nenhum item for especificado). Pensando como uma pilha, de modo inverso a uma lista, essa função recupera o primeiro item quando não é espeficiado.
=> Exemplo 1
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
ListaQualquer.pop()
print(ListaQualquer)
#Retornará [“Flamengo”, True, “Bola”]
=> Exemplo 2
ListaQualquer.pop(2)
print(ListaQualquer)
#Retornará [“Flamengo”, True”]
f) del( ) => Função utilizada para remover um item especificado (ou a lista inteira se o nenhum índice for especificado). Caso a lista seja excluída, ela não poderá mais ser referenciada.
=> Exemplo 1
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
del ListaQualquer[3]
print(ListaQualquer)
#Retornará [“Flamengo”, True, “Bola”]
=> Exemplo 2
del ListaQualquer #Excluirá a lista
g) clear( ) => Função utilizada para esvaziar uma lista.
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
ListaQualquer.clear()
print(ListaQualquer)
#Retornará a lista vazia []
h) copy( ) => Função utilizada para copiar uma lista.
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
ListaQualquer2 = ListaQualquer.copy()
print(ListaQualquer2)
#Retornará [“Flamengo”, True, “Bola”, 5]
i) list( ) => Função utilizada para criar uma nova lista.
ListaQualquer = list((“Flamengo”, True, “Bola”, 5))
print(ListaQualquer)
#Note que deve ter parênteses duplos
j) count( ) => Função utilizada para retornar a quantidade de vezes que um valor específico aparece em uma lista.
ListaQualquer = [“Flamengo”, True, “Flamengo”, 5]
print(ListaQualquer.count(“Flamengo”))
#Retornará 2 (“Flamengo aparece duas vezes”)
k) extend( ) => Função utilizada para adicionar elementos específicos de uma lista ao final de outra lista.
ListaQualquer1 = [“Bola”, 5]
ListaQualquer2 = [“Flamengo”, True]
ListaQualquer1.extend(ListaQualquer2)
print(ListaQualquer1)
#Retornará [“Bola”, 5, “Flamengo”, True]
l) index( ) => Função utilizada para retornar o índice da primeira ocorrência de um valor especificado.
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
print(ListaQualquer.index(“Flamengo”)) #Retornará 0
print(ListaQualquer.index(True)) #Retornará 1
print(ListaQualquer.index(“Bola”)) #Retornará 2
print(ListaQualquer.index(5)) #Retornará 3
m) reverse( ) => Função utilizada para inverter a ordem dos elementos de uma lista.
ListaQualquer = [“Flamengo”, True, “Bola”, 5]
ListaQualquer.reverse()
print(ListaQualquer)
#Retornará [5, ‘Bola’, True, ‘Flamengo’]
n) sort( ) => Função utilizada para ordenar uma simples em ordem ascendente (por padrão – sem necessidade de parâmetros) ou descendente (parâmetro reverse=True).
=> Exemplo 1
ListaQualquer = [“Flamengo”, “Vasco”, “Santos”, “Bahia”]
ListaQualquer.sort()
print(ListaQualquer)
#Retornará [‘Bahia’, ‘Flamengo’, ‘Santos’, ‘Vasco’]
=> Exemplo 2
ListaQualquer.sort(reverse=True)
print(ListaQualquer)
#Retornará [‘Vasco’, ‘Santos’, ‘Flamengo’, ‘Bahia’]
o) range() => Função utilizada para retornar uma lista de números, começando do zero (por padrão) e incrementando em uma unidade (por padrão) e parando em um número especificado.
- Sua sintaxe é: range(start, stop, step) – sendo que start é opcional e incluso; step é opcional e pode ser negativo; e stop é obrigatório e não é incluso.
listaQualquer = range(5, 20, 3)
print(list(listaQualquer)) #retorna [5, 8, 11, 14, 17]
listaQualquer = range(4, 10)
print(list(listaQualquer)) #retorna [4, 5, 6, 7, 8, 9]
listaQualquer = range(6)
print(list(listaQualquer)) #retorna [0, 1, 2, 3, 4, 5]
– Vamos resumir as características básicas de uma lista (list) em uma tabelinha que será incrementada à medida que estudarmos os outros tópicos sobre coleções:
- Ordenação: Ordenada
- Modificação: mutável
- Duplicatas: Permite duplicatas
- Indexação: Por inteiro
- Delimitador: Entre colchetes [ ]
– Por fim, é importante falar sobre List Comprehension: trata-se de uma maneira concisa e eficiente de criar listas.
- Ela permite construir uma nova lista aplicando uma expressão a cada item de uma sequência ou iterável (como listas, strings ou ranges) e, opcionalmente, filtrando itens com base em uma condição. A sua sintaxe básica é:
- [expressão for item in iterável]
– Pode ser também condição (opcional):
- [expressão for item in iterável if condição]
– Vamos ver um exemplo de utilização de List Comprehension para criação de uma lista de quadrados de números de 0 a 9:
- quadrados = [x ** 2 for x in range(10)]
– Em range(10), gera-se uma sequência de números de 0 a 9 (não inclui o 10) – isso serve como o iterável sobre o qual a list comprehension será aplicada;
- for x in range(10) itera sobre cada número x na sequência gerada pelo range(10) – aqui, x assume os valores de 0 a 9; x ** 2 significa que, para cada valor de x, ele calcula o quadrado de x (x elevado a 2). O resultado de x**2 para cada valor de x é armazenado na nova lista chamada quadrados. O resultado do código acima será:
- quadrados = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Tuplas
Tuplas
– Uma tupla (ou sequência) é uma coleção de valores ordenados, imutáveis e indexáveis que pode conter valores duplicados e são delimitadas por parênteses. Vejamos um exemplo:
TuplaFrutas = (“maçã”, “carambola”, “banana”)
print(TuplaFrutas) #Retornará (‘maçã’, ‘carambola’, ‘banana’)
– Vejam que realmente se trata de uma coleção, uma vez que armazena múltiplos valores em uma única variável. Legal, mas e se eu quiser acessar uma fruta específica? Vejamos…
TuplaFrutas = (“maçã”, “carambola”, “banana”)
print(TuplaFrutas[0]) #Retornará maçã
print(TuplaFrutas[1]) #Retornará carambola
print(TuplaFrutas[2]) #Retornará banana
print(TuplaFrutas[3]) #Retornará IndexError: list index out range
– Note que a tupla é delimitada por parênteses, mas o índice sempre será representado entre colchetes.
- Tuplas são muito parecidas com listas, isto é, a forma de acessar é semelhante, existem índices negativos, é possível acessar uma extensão de índices.
- No entanto, há uma diferença fundamental: tuplas são imutáveis! Isso significa que – uma vez criada – você não poderá mais modificar seus itens.
-Caso seja necessário, a única alternativa seria convertê-la em lista.
TuplaFrutas = (“maçã”, “carambola”, “banana”)
print(TuplaFrutas) #Retornará (‘maçã’, ‘carambola’, ‘banana’)
– Para modificar itens, é preciso converter a tupla em lista:
ListaFrutas = list(TuplaFrutas) #Converte a Tupla em uma Lista
– Modificando o item desejado:
ListaFrutas[1] = “abacate”
print(ListaFrutas) #Retornará [‘maçã’, ‘abacate’, ‘banana’]
– Vejamos agora algumas funções (ou métodos) que podem ser utilizadas com tuplas (ou sequências).
a) len( ) => Função utilizada para retornar
quantos itens uma tupla possui.
TuplaQualquer = (2020, “Flamengo”, True)
print(len(TuplaQualquer)) #Retornará 3
b) count( ) => Função utilizada para retornar a quantidade de vezes que um valor específico ocorre em uma tupla.
TuplaQualquer = (8, 6, 1, 9, 1, 9, 1, 6, 5, 1)
print(TuplaQualquer.count(2)) #Retornará 0
print(TuplaQualquer.count(6)) #Retornará 2
print(TuplaQualquer.count(1)) #Retornará 4
print(TuplaQualquer.count(9)) #Retornará 2
c) index( ) => Função utilizada para buscar por um valor específico e retornar o índice de sua primeira ocorrência na tupla.
TuplaQualquer = (8, 6, 1, 9, 1, 9, 1, 6, 5, 1)
print(TuplaQualquer.index(5)) #Retornará 8
print(TuplaQualquer.index(6)) #Retornará 1
print(TuplaQualquer.index(1)) #Retornará 2
print(TuplaQualquer.index(9)) #Retornará 3
d) tuple( ) => Função utilizada para criar uma nova tupla.
TuplaQualquer = tuple((“Flamengo”, True, “Bola”, 5))
print(TuplaQualquer)
#Note que deve ter parênteses duplos
– Vamos resumir as características básicas de uma tupla (tuple):
- Ordenação: Ordenada
- Modificação: imutável
- Duplicatas: Permite duplicatas
- Indexação: Por inteiro
- Delimitador: Entre parênteses ( )
Sets
Sets
– Um set (ou conjunto) é uma coleção de valores desordenados, mutáveis e não indexáveis que não pode conter valores duplicados e são delimitadas por chaves. Vejamos um exemplo:
SetFrutas = {“maçã”, “carambola”, “banana”}
print(SetFrutas)
#Retornará uma sequência desses três valores em ordem aleatória
– Apesar de termos declarado o conjunto acima como maçã, carambola e banana, não existe uma ordem!
- Se eu executar várias vezes o comando print acima, poderíamos ter resultados diferentes para cada execução.
- No caso acima, poderíamos ter uma das seis possibilidades apresentadas abaixo. Como não há uma ordenação, não há como indexar os valores por nenhum número inteiro.
{“maçã”, “carambola”, “banana”} ou
{“maçã”, “banana”, “carambola”} ou
{“carambola”, “maçã”, “banana”} ou
{“carambola”, “banana”, “maçã”} ou
{“banana”, “maçã”, “carambola”} ou
{“banana”, “carambola”, “maçã”}
– Vejamos algumas funções usadas com esse tipo de coleção:
a) len( ) => Função utilizada para retornar quantos itens um conjunto possui.
SetQualquer = {2020, “Flamengo”, True}
print(len(SetQualquer)) #Retornará 3
b) add( ) => Função utilizada para adicionar um item a um conjunto.
SetQualquer = {2020, “Flamengo”, True, 5}
SetQualquer.add(“Bola”)
print(SetQualquer)
#Retornará o set original com “Bola” dentro do conjunto
c) update( ) => Função utilizada para adicionar elementos específicos de um conjunto ao final de outro conjunto.
SetQualquer1 = {“Bola”, 5}
SetQualquer2 = {“Flamengo”, True}
SetQualquer1.update(SetQualquer2)
print(SetQualquer1)
#Retornará a união dos dois conjuntos em alguma ordem
d) remove( ) => Função utilizada para remover a primeira ocorrência de um item especificado em um conjunto.
SetQualquer = {2020, “Flamengo”, True, “Bola”, 5}
SetQualquer.remove(2020)
print(SetQualquer)
#Retornará o set original sem 2020 dentro do conjunto
e) clear( ) => Função utilizada para esvaziar um conjunto.
SetQualquer = {“Flamengo”, True, “Bola”, 5}
SetQualquer.clear()
print(SetQualquer)
#Retornará o set vazio {}
f) del( ) => Função utilizada para remover um conjunto (set) inteiro.
SetQualquer = {“Flamengo”, True, “Bola”, 5}
del SetQualquer
#Excluirá o set
– Vamos resumir as características básicas de um conjunto (set):
- Ordenação: Não ordenada
- Modificação: Mutável
- Duplicatas: Não permite duplicatas
- Indexação: Não indexada
- Delimitador: Entre chaves {}
Dicionários
Outra forma de implementar seria usando dict():
Dicionários
– Um dicionário é uma coleção de valores ordenados, mutáveis e indexáveis que pode não conter valores duplicados e são delimitadas por chaves.
- Como funciona um dicionário de língua portuguesa? Você basicamente procura uma palavra e encontra seu significado.
- Aqui o dicionário funciona de maneira semelhante, no entanto – em vez de utilizar uma estrutura de palavra:significado – utiliza uma estrutura de chave:valor.
– Essa é uma primeira diferença sobre as coleções dos tópicos anteriores – as chaves delimitam um conjunto de chave:valor.
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
print(DicioQualquer) #Retornará {‘marca’: ‘Ford’, ‘modelo’: ‘Fiesta’, ‘ano’: 2015}
– Vejam que realmente se trata de uma coleção, uma vez que armazena múltiplos valores em uma única variável. Mas se eu quiser acessar um valor específico? Vejamos…
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
print(DicioQualquer[“modelo”]) #Retornará Fiesta
– Observem que eu passei como parâmetro uma chave e ele me retornou um valor. O acesso a esse valor específico também poderia ser feito utilizando a função get():
print(DicioQualquer.get(“modelo”)) #Retornará Fiesta
– E se eu quiser modificar um valor do meu dicionário, também é muito simples! Basta informar o valor da chave e o nome valor a ser atribuído:
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
DicioQualquer[“modelo”] = “Ranger” print(DicioQualquer) #Retornará {‘marca’: ‘Ford’, ‘modelo’: ‘Ranger’, ‘ano’: 2015}
– E para adicionar um novo valor ou deletar um valor existente? Também é completamente possível, porque lembrem-se que essa coleção é do tipo mutável:
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
DicioQualquer[“cor”] = “Prata”
print(DicioQualquer)
#Retornará ‘marca’: ‘Ford’, ‘modelo’: ‘Fiesta’, ‘ano’: 2015, ‘cor’: ‘Prata’}
del DicioQualquer[“ano”]
print(DicioQualquer)
#Retornará marca’: ‘Ford’, ‘modelo’: ‘Fiesta’, ‘cor’: ‘Prata’}
– Por fim, é importante mencionar os itens são indexados por string e, não, por inteiros.
- Além disso, ele não pode conter duplicatas nas chaves, mas pode conter duplicadas nos valores.
=> Algumas funções:
a) len( ) => Função utilizada para retornar quantos itens um dicionário possui.
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
print(len(DicioQualquer) ) #Retornará 3
b) copy => Função utilizada para copiar um dicionário para outro.
DicioQualquer = {
“marca”: “Ford”,
“modelo”: “Fiesta”,
“ano”: 2015
}
DicioQualquer1 = DicioQualquer.copy()
DicioQualquer1 = dict(DicioQualquer)
– Principais características dos Dicionários:
- Ordenação: Ordenada
- Modificação: Mutável
- Duplicatas: Não permite duplicatas
- Indexação: Por String
- Delimitador: Entre chaves {}
Controle de fluxo
Controle de fluxo
– Vocês se lembram que uma forma de representar algoritmos é por meio de um fluxograma?
- Pois é, um fluxograma representa os possíveis fluxos ou caminhos que um programa pode tomar.
- Eu disse que as instruções de um software são lidas verticalmente uma após a outra, mas isso não significa que todas as instruções devem ser executadas na ordem apresentada.
- Por que? Por conta das Estruturas de Controle de Fluxo!
– Vamos estudar a seguir as principais estruturas de controle de fluxo: Estruturas de Decisão (If) e Estruturas de Repetição (While e For).
Controle de fluxo
Estrutura de Decisão (If-Elif-Else)
Estrutura de Decisão (If-Elif-Else)
– Também chamadas de Estruturas de Seleção ou Condição, elas permitem interferir na sequência natural de instruções executadas dependendo de uma condição de teste.
- Nós vimos que a execução de instruções em geral ocorre em uma sequência uma após a outra, porém – por meio de condições – é possível mudar a sequência natural de execução.
– A estrutura de condição mais simples em algoritmos é conhecida como If (Se) e é utilizada da seguinte forma:
if expressão-lógica:
bloco-de-instruções
– A < expressão-lógica > é uma expressão/condição que retorna um valor verdadeiro ou falso e, caso o resultado dessa expressão seja verdadeiro, será executado o bloco de comandos que está dentro dessa estrutura; caso seja falso, a execução do programa ignora o bloco de comandos e continua na linha seguinte à estrutura de condição.
- Uma condição falsa poderia ser: 10 > 20; e uma condição verdadeira poderia ser 30 = 30.
– O bloco-de-instruções é uma sequência de código que será executada somente quando o resultado da expressão lógica for verdadeiro.
- Por fim, é preciso tomar cuidado com a indentação (o recuo no começo da linha) para definir o escopo dessa instrução.
– Dito isso, vamos analisar o código apresentado abaixo. Note que ele define duas variáveis (a e b) e – em seguida – apresenta uma **instrução if **que avalia uma expressão lógica.
a = 20
b = 50
if b > a:
print(“b é maior que a”) #Retornará b é maior que a
– Perceba que b é realmente maior que a, logo a expressão lógica é verdadeira. Se ela é verdadeira, o comando na linha abaixo – que possui um recuo maior – será executado. E se não tiver recuo?
a = 20
b = 50
if b > a:
print(“b é maior que a”) #Retornará IndentationError: expected na indented block
– Caso não haja esse recuo (indentação), o código retornará um erro porque é obrigatório que haja um bloco de instruções indentado para executar a instrução. Dessa forma, podemos dizer que a instrução se é como uma bifurcação na estrada. O caminho que você toma depende da avaliação da expressão lógica (se é verdadeira ou falsa).
– Há uma outra palavra-chave utilizada quando uma condição não foi satisfeita, mas eu gostaria de fazer outro teste. Para tal, utiliza-se a palavra-chave elif.
if expressão-lógica1:
bloco-de-instruções1
elif expressão-lógica2:
bloco-de-instruções2
– Vamos ver um exemplo semelhante ao apresentado anteriormente, mas agora o código testará
uma condição e, se ela não for verdadeira, ele testará outra condição:
a = 50
b = 50
if b > a:
—-print(“b é maior que a”)
elif a == b:
—-print(“a e b são iguais”) #Retornará a e b são iguais
– No exemplo acima, analisa-se a primeira expressão lógica (linha 4): b > a. Essa expressão é verdadeira ou falsa? É falsa, logo não se executa a instrução da linha 5.
- Em seguida, analisa-se a segunda expressão lógica (linha 6): a == b. Essa expressão é verdadeira ou falsa? É verdadeira, logo executa-se a instrução da linha 7 e imprime na tela a mensagem: a e b são iguais.
– Agora vamos aprender mais uma palavra-chave: else.
if expressão-lógica1:
—-bloco-de-instruções1
elif expressão-lógica2:
—-bloco-de-instruções2
else:
—-bloco-de-instruções3
– Para ficar mais claro, imagine o software de uma faculdade que calcula se um aluno qualquer foi aprovado, reprovado ou se ficou de recuperação a partir de expressões lógicas:
if media < 5.0:
—-print(“Aluno Reprovado”)
elif media >= 7.0:
—-print(“Aluno Aprovado”)
else:
—-print(“Aluno de Recuperação”)
– Suponha que um aluno qualquer tenha uma nota média de 5.1.
- A primeira expressão lógica é falsa porque a média do aluno não é menor que 5.0 e a segunda expressão lógica é falsa porque a média do aluno não é maior ou igual a 7.0, logo o terceiro bloco de instruções será necessariamente executado porque se a média do aluno não é menor que 5.0 e não é maior ou igual a 7.0, então a média dele é entre 5.0 e 6.9, portanto ele está de recuperação.
– Nós vimos exemplos em que há apenas uma instrução dentro do bloco de cada expressão lógica, mas você pode colocar quantas desejar. Caso tenha apenas uma instrução, pode escrever assim:
if media < 5.0: print(“Aluno Reprovado”)
elif media >= 7.0: print(“Aluno Aprovado”)
else: print(“Aluno de Recuperação”)
– Lembrando também que você não é obrigado a usar o elif. Caso só haja duas opções, você pode utilizar apenas if e else. Veja só o código abaixo:
if idade >= 18:
—-print(“Maior de Idade”)
else:
—-print(“Menor de Idade”)
– Se você tiver apenas uma instrução para executar, uma para if e outra para else, poderá colocar tudo na mesma linha conforme apresentado a seguir:
if idade >= 18: print(“Maior de Idade”)
else: print(“Menor de Idade”)
– Por fim, é importante saber que é possível ter um if dentro de outro if (e assim por diante). Quando isso ocorre, dizemos que temos um if aninhado ou encadeado.
if x > 10:
—-print(“Número acima de 10!”)
—-if x > 20:
——–print(“E também acima de 20!”)
——–if x > 30:
————print(“E também acima de 30!”)
——–else:
————print(“Mas abaixo de 30!”)
—-else:
——–print(“Mas abaixo de 20!”)
else:
—-print(“Número abaixo de 10!”)
Estrutura de repetição (While)
Estrutura de repetição (While)
– Uma das principais características que consolidaram o sucesso na utilização dos computadores para a resolução de problemas foi a sua capacidade de repetir o processamento de um conjunto de operações para grandes quantidades de dados.
- Exemplos de conjuntos de tarefas que repetimos diversas vezes dentro de uma situação específica podem ser observados invariavelmente no nosso dia a dia.
– As estruturas de repetição nos fornecem um modo de repetir instruções até que determinado objetivo seja atingido, quando a repetição se encerra.
- Todas as estruturas de repetição têm em comum o fato de haver uma condição de controle, expressa através de uma expressão lógica, que é testada em cada ciclo para determinar se a repetição prossegue ou não.
- Em outras palavras, se você manda o computador repetir algo, você tem que dizer quando ele deve parar!
– Por exemplo: um sistema que vende ingressos para um show deve armazenar em alguma variável a quantidade de ingressos disponíveis.
- A cada ingresso vendido, esse valor deve ser decrementado e, quando o valor chegar a zero, a venda de ingressos deve ser interrompida uma vez que a carga de ingressos acabou.
- Há infinitas utilidades e é uma estrutura extremamente comum em qualquer algoritmo de qualquer linguagem de programação.
– As estruturas de repetição são basicamente duas: while e for.
- A diferença básica é que a estrutura while é iterada/repetida (em loop) baseada em uma expressão lógica (True ou False) e a estrutura for é iterada/repetida (em loop) baseada em coleções (ou objetos multivalorados).
- A estrutura de repetição while avalia uma expressão lógica e só executa os comandos do bloco de instruções se essa expressão for considerada verdadeira.
– Após a execução dos comandos, a expressão lógica é novamente avaliada. Caso o resultado seja falso, o algoritmo sai da estrutura de repetição (chamada de loop) e segue para a próxima linha:
while expressão-lógica:
—-bloco-de-instruções
– Vamos imaginar um contexto em que um candidato precisa de 100 votos para ser eleito síndico de um condomínio de apartamentos. Vejamos como funciona:
voto = 0
while voto < 100:
—-print(“Votos Insuficientes”)
—-voto = voto + 1
print(“Habemus Síndico!”)
#Imprimirá “Votos Insuficientes” 100 vezes (0 a 99) e, por fim, imprimirá “Habemus Síndico!”
– Notem que eu inicializo a variável voto com valor 0. Em seguida, há uma expressão lógica que avalia se o valor armazenado na variável é menor que 100. Como inicialmente essa expressão é verdadeira, executa-se o bloco de instruções imprimindo uma mensagem de “Votos Insuficientes” e incrementando em uma unidade o valor da variável voto.
- Isso se repete diversas vezes até um momento em que a variável armazenará o valor 99.* O que acontece nesse momento*?
– Quando voto = 99, analisamos: 99 < 100? Sim, isso é verdadeiro! Imprime a mensagem de “Votos Insuficientes” e incrementamos a variável voto em uma unidade, logo voto = 100.
- Voltamos no loop e analisamos: 100 < 100? Não, isso é falso! Se é falso, imprime-se a mensagem “Habemus Síndico!”, saímos desse bloco de instruções e prosseguimos com o nosso código normalmente.
- A variável dentro do bloco de instruções sendo incrementada/decrementada é chamada de contador.
– Se não houver um contador ou alguma outra forma de escape do nosso bloco de instruções, o algoritmo ficará em repetição para sempre – isso é chamado de loop infinito.
- Vejam no exemplo apresentado abaixo que – como não há um escape do bloco de instrução – não existe uma condição de saída da estrutura de repetição.
- Logo, esse bloco de instruções continuará sendo repetido indefinidamente causando problemas de memória ao computador.
voto = 0
while voto < 100:
—-print(“Eu nunca mais vou sair daqui! MUA-HA-HA-HA-HA”)
#Esse código imprimirá infinitamente “Eu nunca mais vou sair daqui! MUA-HA-HA-HA-HA”
– Existe uma outra forma de escapar do loop. Utilizando a declaração break! Essa declaração permite interromper um loop mesmo que a expressão lógica ainda seja verdadeira:
contador = 0;
while contador < 6:
—-print(contador)
—-if contador == 3:
——–break
—-contador = contador + 1
#Esse código imprimirá 0 1 2 3
– Note que o while será executado incrementando o contador normalmente. No entanto, se em algum momento o contador for 3, ele interrompe o loop (break). Da mesma forma que existe um comando específico para parar, há também um comando específico para continuar!
- Como assim? Por vezes, você não quer que o restante do bloco de instruções seja executado dada determinada condição. Vamos ver um exemplo para ficar mais claro:
contador = 0;
while contador < 6:
—-contador = contador + 1
—-if contador == 3:
——–continue
—-print(contador)
#Esse código imprimirá 1 2 4 5 6
– Notem que, quando contator = 3, o continue esquece tudo que há abaixo dele dentro do bloco de instrução e retorna para a expressão lógica do while, logo não imprime o número 3.
Estrutura de repetição (for)
Estrutura de repetição (for)
– Na estrutura de repetição while, a iteração (loop) era realizada baseado em uma expressão lógica, que poderia ser verdadeira ou falsa.
- A estrutura de repetição for funciona de maneira um pouco diferente – a iteração é realizada baseado em uma coleção (ou objeto iterável).
- Logo, a iteração é realizada sobre itens de listas, tuplas, sets, dicionários ou – até mesmo – strings.
for variável-de-controle in variavel-colecao:
—-bloco-de-instruções
– Percebam que – em contraste com a estrutura while – não é necessário declarar uma variável de controle antecipadamente porque a própria estrutura necessita de uma variável de controle.
listaFrutas = [“maçã”, “carambola”, “banana”]
for x in listaFrutas:
print(x) #Imprimirá maçã carambola banana
– Essa estrutura percorre todos os elementos da lista. O interessante é que isso vale para outras coleções como tuplas e conjuntos – vejam alguns exemplos:
TuplaFrutas = (“maçã”, “carambola”, “banana”)
for x in TuplaFrutas:
print(x) #Imprimirá maçã carambola banana
————//——————–//—————
SetFrutas = {“maçã”, “carambola”, “banana”}
for x in SetFrutas:
print(x) #Imprimirá maçã carambola banana
– Também funciona para o dicionário. No entanto, vocês devem se lembrar que o dicionário apresenta um conjunto de chave-valor, então você pode escolher apresentar a chave ou o valor:
DicioFrutas = {“fruta1”: “maçã”, “fruta2”: “carambola”, “fruta3”: “banana”}
for x in DicioFrutas:
print(x) #Imprimirá fruta1 fruta2 fruta 3
————-//———————-//————-
DicioFrutas = {“fruta1”: “maçã”, “fruta2”: “carambola”, “fruta3”: “banana”}
for x in DicioFrutas:
print(DicioFrutas[x]) #Imprimirá maçã carambola banana
– Por fim, essa estrutura de repetição também é capaz de iterar sobre uma string. Ora, a string é um conjunto de caracteres, logo é possível iterar sobre cada caractere. Vejam só:
for x in “Estratégia Concursos”:
print(x) #Imprimirá E s t r a t é g i a C o n c u r s o s
– Note que ele imprimirá letra por letra!
– Essa estrutura de repetição também permite utilizar break e continue.
– É importante mencionar também que essa estrutura também é utilizada frequentemente com a função range().
- Ela retorna uma sequência de números, começando do 0 (por padrão), incrementando por 1 (por padrão) e termina no número especificado.
– Ela pode ser utilizada em conjunto com a função for para iterar sobre um bloco de instruções por um número específico de vezes.
for x in range(6):
print(x) #Imprimirá 0 1 2 3 4 5
– Lembrem-se também que essa função pode ser um pouco mais complexa quando possui todos os seus três parâmetros: start, stop e step. Vejamos…
for x in range(2, 20, 3):
print(x) #Imprimirá 2 5 8 11 14 17
– Note que o for itera sobre o conjunto de valores que se inicia em 2 (incluso) até 20 (não incluso), pulando de três em três unidades.
Orientação a objetos
Orientação a objetos
– O paradigma orientado a objetos é um estilo de programação que se baseia na ideia de objetos, que contêm dados (também conhecidos como atributos) e comportamentos (também conhecidos como métodos).
- Os objetos são criados a partir de classes, que funcionam como modelos ou plantas para os objetos.
- Na programação orientada a objetos, o foco está na representação dos elementos do mundo real como objetos e na interação entre esses objetos.
– Python é uma linguagem de programação orientada a objetos.
- Quase tudo em Python é um objeto, com suas propriedades e métodos.
- Uma classe é como um construtor de objeto ou um projeto para criar objetos.
- Para criar uma classe, usamos a palavra-chave class, seguida do nome da classe e, opcionalmente, dos nomes das classes pai entre parênteses.
- Dentro da classe, podemos definir atributos (variáveis associadas ao objeto) e métodos (funções que atuam no objeto).
