1

Programas

le dois valores e imprime o maior

import os

os.system(‘cls’) # Limpa a Tela no Terminal

a = int(input(“primeiro valor:”))

b = int(input(“segundo valor:”))

if a>b:

print (“o primeiro valor é maior”)

if b>a:

print (“o segundo valor é maior”)

Comandos if, else, elif

Minutos utilizados x preços por minuto

import os

os.system('cls') # Limpa a Tela no Terminal

minutos = int(input("Quantos minutos você utilizou este mês ?: "))

if minutos < 200:

preço = 0.20

elif minutos < 400:

preço = 0.18

else:

preço = 0.15

valor_a_pagar = minutos * preço

print(f"Você vai pagar: R${valor_a_pagar:4.2f}") # f é format

 2

faça no Python o seguinte programa: A valor 1 , B valor 2 e C valor 3

Insira uma letra A, B ou C , se for uma dessas 3, mostre a letra e o valor

correspondente e some com 2 o valor e imprima o resultado. Se for inserida uma letra
inválida, imprima letra inválida.

import os

os.system('cls') # para limpar o terminal. É opcional

#Define valor para A,B e C

valor = {'A':1, 'B':2, 'C':3} # é um dicionário

#Solicita a entrada do usuário

letra = input('Insira uma letra (A, B ou C): ').upper()

#Verificar se a letra está no dicionário

if letra in valor:

valor = valor[letra]

print(f'Letra: {letra}, Valor: {valor}')

resultado = valor + 2

print(f'Resultado: {resultado}')

else:

print('Letra inválida. Insira uma letra Válida.')

-----------------------------------------------------------------------------------------------------------

kill terminal e roda os script

--------------------------------------------------------------------------------------
 3

PARA TIRAR O SUBLINHADO AZUL NAS PALAVRAS

desisntala a extensão que "spell checker " (corretor ortográfico).

Escrever uma rotina com 3 categorias e seus respectivos valores:

categoria=1 , valor = 10 . categoria=2, valor = 18 e categoria=3,valor=23.

Escrevi categoria_x_valor e deu pau no programa.

O Vscode não apareceu o ícone Run . kill terminal que aparece.

Nome do Programa: categoria_valor

import os

os.system('cls') # para limpar o terminal

categoria = int(input("digite um numero de 1 a 3 para a categoria: "))

if categoria == 1:

valor = 10

elif categoria == 2:

valor = 18

elif categoria == 3:

valor = 23

else:

print ("categoria inválida")

print (f"categoria: {categoria:d} valor: {valor:d}" %categoria, valor)

---------------------------------------------------

digite um numero de 1 a 3 para a categoria: 0

categoria inválida

Traceback (most recent call last):

 4

File "d:\Meus Documentos\Python Treinamento com VS_CODE\Categoria_x_Valor.txt", line

12, in <module>

print (f"categoria: {categoria:d} valor: {valor:d}" %categoria, valor)

^^^^^

NameError: name 'valor' is not defined

PS C:\Users\MDF>

O erro ocorre porque a variável valor não foi definida dentro do bloco else, que é
executado quando o usuário insere uma categoria inválida.

Quando você tenta usar a variável valor no print, ela não existe, resultando em um erro
do tipo NameError.

Além disso, há um problema na sintaxe do print dentro do else. A parte f"categoria:

{categoria:d} valor: {valor:d}" %categoria, valor não está correta.

No Python, a sintaxe para formatação de strings usando f-string não deve ser seguida
de um % para interpolação.

Aqui está o código corrigido:

--------------------------------------------------------------------------------------------------

import os

os.system('cls') # para limpar a tela

categoria = int(input("digite um numero de 1 a 3 para a categoria: "))

# Definindo o valor das categorias

if categoria == 1:

valor = 10

elif categoria == 2:

valor = 18

elif categoria == 3:

valor = 23

else:

print("categoria inválida")
 5

valor = None # Define valor como None para evitar o erro

# Caso a categoria seja válida, exibe o valor

if valor is not None:

print(f"categoria: {categoria} valor: {valor}")

Explicações

Correção do erro NameError:

Eu adicionei valor = None dentro do else para evitar o erro quando a categoria não for
válida.

Uso correto de f-string:

Quando a categoria é inválida, o print foi corrigido para usar f-string diretamente,

o que é a forma mais moderna e segura de formatação no Python.

Exibição do valor:

Após a verificação da categoria, o valor só será exibido se for definido corretamente,

evitando problemas quando a categoria não for válida.

Agora, se você digitar 0 ou qualquer número fora do intervalo de 1 a 3, o código vai

imprimir "categoria inválida" e "valor: None" (já que a variável valor não foi definida para
categorias inválidas).

Para valores válidos de categoria, ele vai exibir o número correspondente e o valor
associado.

Condição_While_nValor.py

Cálcular a soma de(valor a ser inserido)

import os

os.system ('cls') # limpa o terminal

n = int(input("soma de: "))

 6

x = 1 # valor inicial do contador

while x <= n:

print (n + x)

x += 1 # contador ( x = x+1 )

-------------------------------------------------------------------

Adicionando a Opção de pedir para inserir um número válido caso o valor inserido
seja < do que o Valor inicial do Contador

import os

os.system('cls') # limpa o terminal

n = int(input("soma de: "))

x = 1 # valor inicial do contador

if n < x:

print("Por favor, insira um número válido.")

else:

while x <= n:

print(n + x)

x += 1 # contador ( x =x + 1 )

Questões e respostas usado o While – if – else – elif

questão 1 resposta b, questão 2 resposta a e questão 3 resposta d

# Contar as respostas certas de múltipla escolha de um teste com 3 questões

pontos = 0

questão = 1

while questão <= 3:

resposta = input(f"Resposta da questão {questão}: ")

 7

if questão == 1 and (resposta == "b" or resposta == “B”) :

pontos += 1

elif questão == 2 and resposta == "a":

pontos += 1

elif questão == 3 and resposta == "d":

pontos += 1

questão += 1

print(f"O aluno fez {pontos} ponto(s)")

Mesma rotina agora com o else na última iteração. While – if – elif – else

Pode usar o else,porém, usar elif torna o código mais explícito e fácil de manter.

pontos = 0

questão = 1

while questão <= 3:

resposta = input(f"A resposta da questão {questão}: ")

if questão == 1 and resposta == "b":

pontos += 1

elif questão == 2 and resposta == "a":

pontos += 1

else:

if resposta == "d":

pontos += 1

questão += 1

print(f"O aluno fez {pontos} ponto(s)"

Razões para o input Estar Dentro do while:

Repetição para Cada Questão:
 8

O loop while itera enquanto questão for menor ou igual a 3. Isso significa que queremos
obter

uma resposta para cada uma das 3 questões. Se o input estivesse fora do loop while, só
seria solicitado

uma vez e o programa não teria como coletar respostas para as demais questões.

Atualização da Questão:

A cada iteração do loop, o valor de questão é incrementado (questão += 1).

Isso permite que a próxima pergunta seja feita na próxima iteração. Se o input estivesse fora
do loop, o programa não saberia qual questão está sendo respondida.

Fluxo de Controle:

O input dentro do while garante que o programa aguarde a entrada do usuário antes de
continuar.

Isso é crucial para a interação com o usuário, pois o programa precisa saber a resposta
antes de verificar se está correta.

Resumo

Portanto, manter o input dentro do bloco while é essencial para que o programa funcione
corretamente,

permitindo que o usuário responda a cada pergunta de forma sequencial.

Se você o movesse para fora do loop, o programa não conseguiria coletar as respostas para
todas as questões.

6 - Cálculo da soma de 3 números, com o while

#soma de 3 números com o while

import os

os.system ('cls')

n=1 # valor inicial do contador

soma=0 # valor inicial da soma

 9

while n<=3: # enquanto o contador for menor ou igual a 10

x=int(input(f"Digite o {n}º número: "))

soma=soma+x

n=n+1

print(f"Soma: {soma}")

A instrução break é utilizada para interromper a execução de while ou a execução for

independentemente do valor atual de sua condição. Vejamos o exemplo da leitura de valores
até que digitemos O(zero):

Gerador de Números aleatórios

Aqui está um script simples em Python para gerar números aleatórios de 1 a 99:

import random

# Gerar número aleatório entre 1 e 99

numero_aleatorio = random.randint(1, 99)

print(f"Número aleatório: {numero_aleatorio}")

----------------------------------------------------------------------------------

Se você quiser gerar vários números aleatórios, pode colocar o código em um loop:

import random

# Quantidade de números que você quer gerar

quantidade = 5

for i in range(quantidade):
 10

numero_aleatorio = random.randint(1, 99)

print(f"Número aleatório {i+1}: {numero_aleatorio}")

Este segundo exemplo vai gerar 5 números aleatórios diferentes. Você pode mudar o valor
da variável quantidade para gerar mais ou menos números.

8 -Média aritmética com 5 números de uma lista [ ] usando o comando for

import os

os.system ('cls')

#média aritmética com 5 números de uma lista

lista = [2,2,2,4,5]

soma = 0

for i in lista:

soma += i

media = soma/len(lista) # len() retorna o número de itens de um objeto

print (f"A média aritmética dos números da lista é: {media}")

Tabuada usando o comando For in range ( )

vide explicação do comando for in range no autocad.

Nessa Rotina tem como imprimir o resultado de forma tabulado?

#Tabuada usando o comando for

import os

os.system('cls')

for x in range(1,4):

for y in range(1,4):

print(x, " x ", y, " = ", x*y)

-------------------------------------------------------------------------------------------------
 11

Vou ajudar você a formatar a tabuada de forma mais organizada e tabulada. Existem
algumas maneiras de fazer isso:

Usando f-strings com alinhamento:

import os

os.system('cls')

for x in range(1,4):

for y in range(1,4):

print(f"{x} x {y} = {x*y:2}")

--------------------------------------------------------------------------------------------

Ou podemos criar uma formatação ainda mais organizada:

import os

os.system('cls')

for x in range(1,4):

for y in range(1,4):

print(f"{x:2} x {y:2} = {x*y:3}")

---------------------------------------------------------------------------------------------------

Se você quiser algo ainda mais estruturado, com linhas separadoras:

import os

os.system('cls')

print("-" * 15) # Linha separadora

for x in range(1,4):

for y in range(1,4):

print(f"|{x:2} x {y:2} = {x*y:2}|")

print("-" * 15) # Linha separadora entre números

Na formatação f-string:

:2 significa que o número ocupará 2 espaços

:3 significa que o número ocupará 3 espaços

 12

Tabuada com o comando While

Está dando erro no print

O erro no seu código está no indentação do print e na forma como a string está sendo
formatada dentro do print.

Você está usando aspas simples dentro de uma string com aspas duplas, o que não permite
que o Python interprete as variáveis corretamente.

Tabuada de 1 a 3

import os

os.system('cls')

x=1

while x <=3:

y = 1 (está identado)

while y <= 3: (está identado)

print("f'{x} x {y} = {x*y}'"). (print não está identado)

y += 1 (está identado)

x += 1 (está identado)

-------------------------------------------------------------------------------------------------

Aqui está a versão corrigida do seu código:

# Tabuada de 1 a 3

import os

os.system('cls')

x=1

while x <= 3:

y=1

while y <= 3:
 13

print(f'{x} x {y} = {x * y}') # Corrigido: indentação e formatação da string

y += 1

x += 1

Mudanças realizadas:

Indentação: O print estava fora do escopo do while interno porque não estava identado.

O Python depende da indentação para definir os blocos de código. A linha com o print agora
está corretamente indentada.

Formatação da string: Eu corrigi a forma de interpolar as variáveis dentro da string. O f'{x} x

{y} = {x * y}' usa um f antes da string

para permitir que as variáveis sejam interpretadas corretamente dentro dela.

Agora o código vai imprimir a tabuada de 1 a 3 corretamente.

Armazena 5 números na lista com o comando for e solicita que escolha

um número para mostrar
um script no Python que lê cinco números, armazena-os em uma lista

e depois solicita ao usuário que escolha um número a mostrar.

O objevo é, por exemplo, ler 15, 12, 5, 7 e 9 e armazená-los na lista.

Depois, se o usuário digitar 2, ele imprimirá o segundo número digitado, 3, o terceiro, e

assim sucessivamente.

-----------------------------------------------------------------------------------------

#lê cinco números, armazena-os em uma lista

#e depois solicita ao usuário que escolha um número a mostrar através do índice.

import os

os.system ('cls')

lista = []

# Lendo 5 números e adiciona à lista

for i in range(5): #range(5) é uma lista de índices 0 a 4, ou seja, 5 números.

numero = int(input("Digite o {}º número: ".format(i+1))) # (0+1)=1, (1+1)=2, (2+1)=3,

(3+1)=4, (4+1)=5. No Python os números estão guardados nos índices 0 a 4 .
 14

lista.append(numero) #append significa adicionar numero digitado à lista

print("Números digitados:", lista)

[# Solicitando o índice do número a ser mostrado.

indice = int(input("Digite o índice do número que deseja ver (1 a 5): "))

# Verificando se o índice está dentro do intervalo válido

if 0 < indice <= 5:

# Exibindo o número correspondente ao índice5

print("O número escolhido é:", lista[indice-1]) #como foi acrescentado 1 no format(i+1),

agora tem que diminuir o índice de 1,pois, os índices em Lista começam com 0.

else:

print("Índice inválido. Por favor, digite um número entre 1 e 5.")

-----------------------------------------------------------------------------

Explicação:

Criação da lista: Uma lista vazia chamada numeros é criada para armazenar os números
digitados pelo usuário.

Leitura dos números: Um loop for é utilizado para iterar 5 vezes ( de 0 a 4, que são os
índices no Python), solicitando ao usuário que digite um número em cada iteração. O
número digitado é convertido para um inteiro e adicionado à lista numeros utilizando o
método append().

Solicitação do índice: O usuário é solicitado a digitar o índice do número que deseja ver. O
índice é armazenado na variável indice.

Verificação do índice: Uma condição if verifica se o índice digitado está entre 1 e 5

(lembrando que os índices em Python começam em 0).

Exibição do número: Se o índice for válido, o número correspondente é exibido utilizando a

sintaxe numeros[indice-1].

É necessário subtrair 1 do índice, pois os índices em listas começam em 0.

Mensagem de erro: Se o índice for inválido, uma mensagem de erro é exibida.

Como executar:

Salvar o código: Salve este código em um arquivo com extensão .py, por exemplo,
exibir_numeros.py.
 15

Executar o código: Abra seu terminal ou prompt de comando, navegue até o diretório onde
você salvou o arquivo e execute o comando python exibir_numeros.py.

Seguir as instruções: O programa irá solicitar os 5 números e, em seguida, pedir o índice do

número que você deseja ver.

Exemplo de execução:

numero = int(input("Digite o {}º número: ".format(i+1)))

Digite o 1º número: 15

Digite o 2º número: 12

Digite o 3º número: 5

Digite o 4º número: 7

Digite o 5º número: 9

Digite o índice do número que deseja ver (1 a 5): 3

O número escolhido é: 5

--------------------------------------------------------------------------

numero = int(input("Digite o {}º número: ".format(i+1))) .

Se não fosse usado o .format(i+1), apareceria da seguinte forma,

Digite o 0º número: 15. Para o usuário ficaria confuso dessa maneira.Por isso

Digite o 1º número: 12 foi usado format(i+1)

Digite o 2º número: 5

Digite o 3º número: 7

Digite o 4º número: 9

Os índices de listas no Python sempre começam com 0.

Armazena 5 números na lista com o comando while, while true e break e

solicita que escolha um número para mostrar

import os

os.system ('cls')

lista = [] #lista vazia

 16

i = 0 # valor inicial do contador

while i < 5:

n = int(input(f'Digite um número: '))

lista.append(n) # acrescenta o número do contador à lista

i += 1

while True:

indice = int(input('Digite o indice entre 1 e 5: '))

if indice == 0 or indice > 5:

break

print(f'O número no indice {indice} é {lista[indice-1]}')

print('Índice inválido. Programa encerrado.')

-----------------------------------------------------------------------------------------------------

equacaoSegundoGrau_Raizes

#Raízes da equação de segundo grau.

#Este código define uma função calcular_raizes que recebe os coeficientes a, b e c da

equação ax² + bx + c = 0,

#calcula o discriminante e, dependendo do valor do discriminante, retorna as raízes.

#Se o discriminante for positivo, há duas raízes reais;

#se for zero, há uma raiz real (2 raízes iguais);

#e se for negativo, as raízes serão complexas, então o código retorna None para indicar que
não há raízes reais

import os

os.system (‘cls’) # limpa o terminal

import math

def calculoDasRaizes(a, b, c): #é um comando para definir a função. Nome da

função(parâmetros)

delta = b**2 - 4*a*c em Azul é o corpo da função

 17

if delta < 0:

return None # Por último, é adicionada a palavra reservada return para

devolver um resultado.

elif delta == 0:

x = -b / (2*a)

return x, # Por último, é adicionada a palavra reservada return para devolver o resultado.

else: em Azul é o corpo da função

x1 = (-b + math.sqrt(delta)) / (2*a)

x2 = (-b - math.sqrt(delta)) / (2*a)

return x1, x2 # Por último, é adicionada a palavra reservada return para devolver os 2
resultados.
Aqui termina a função

------------------------------------------------------------------------------------------------------------------

def main(): # a função main é o ponto de entrada principal, é aqui que começa a
execução da função calculoDasRaizes(a,b,c)

a = float(input("Digite o valor de a: "))

b = float(input("Digite o valor de b: "))

c = float(input("Digite o valor de c: "))

raizes = calculoDasRaizes(a, b, c) # main chama a função para calcular as raízes.A

função calcula e guarda os resultados na variável raizes.

if raizes:

print("As raízes são:", raizes)

else:

print("Não há raízes reais.")

if __name__ == "__main__":

main()
 18

 A condição if __name__ == "__main__": garante que a função main() seja

executada apenas quando o script for executado diretamente.
 ----------------------------------------------------------------------------------------------------------

O uso de funções em algum momento no script ou no Python interativo recebe o nome de

chamada. Quando uma função é chamada, geralmente recebe argumentos, que são
passados como parâmetros, dentro de parênteses. As respostas da função, quando há, são
chamados de retornos.

retorno1;retorno2 = funçao (parâmetro1;parâmetro2)

adicionaElementos_a_UmaListaVazia
#Adiciona elementos a lista uma lista vazia e imprime os elementos digitados

#usando o método append() e o laço while

import os

os.system ('cls')

lista = []

while True:

n = int(input('Digite um número (zero sai): '))

if n == 0:

break

lista.append(n)

x =0

while x < len(lista): # o comprimento da lista é = 4

print(lista[x], end = ', ')

x += 1

------------------------------------------------

Digite um número (zero sai): 5

Digite um número (zero sai): 3

Digite um número (zero sai): 7

Digite um número (zero sai): 45

Digite um número (zero sai): 0

 19

5, 3, 7, 45,

x = 0 imprime 5, x =1 imprime 3, x = 2 imprime 7, x = 3 imprime 45 .

se colocar while x <= len(lista) dá error porque o programa conta os índices dos números

e no Python o índice começa com 0.

emprestimoBancario.py
#Script que verifica se o usuário pode ou não fazer um empréstimo bancário

import os

os.system ("cls")

print ("Empréstimo bancário")

print ( "Responda: 0 para Não e 1 para Sim")

nomeNegat = int(input("Possui nome negativado? "))

if nomeNegat == 0:

cartAssin = int(input ('Tem carteira assinada? '))

if cartAssin == 1:

casaPropria = int(input('Possui casa própria? '))

if casaPropria == 1 and cartAssin == 1:

print ('Empréstimo aprovado')

else:

print ('Empréstimo negado')

else:

print ('Empréstimo negado')

else:print ('Empréstimo negado')

print ('Fim do programa')

 20

Programa 6.9 - Pesquisa sequencial. Livro 10 pág.109

L = [15, 7, 27, 39]

p = int(input("Digite o valor a procurar: ")) # Recebe o valor a ser procurado na lista

achou = False # Variável para verificar se o valor foi encontrado

x = 0 # Variável para controlar o índice da lista

# Loop para percorrer a lista e buscar o valor

while x < len(L):

if L[x] == p: # Verifica se o valor no índice x é igual ao valor procurado

achou = True

break # Se encontrar, interrompe o laço

x += 1 # Aumenta o índice para verificar o próximo item

# Verifica se o valor foi encontrado e imprime a posição

if achou:

print(f"{p} achado na posição {x}")

else:

print(f"{p} não encontrado")

======================================================================

Explicação do código:

Lista L: A lista contém os valores [15, 7, 27, 39], que são os elementos onde vamos
procurar.

Entrada do valor a ser procurado (p): O programa pede para o usuário digitar um valor (p)
que será procurado na lista L.

Inicialização de variáveis:
 21

achou: Variável booleana (verdadeira ou falsa) usada para indicar se o valor foi encontrado
ou não.

x: Índice da lista. Inicialmente é 0, ou seja, começamos a procurar no primeiro item da lista.

Laço while: A estrutura while percorre a lista L até encontrar o valor p ou até acabar a lista
(ou seja, quando x for maior que o índice máximo da lista).

if L[x] == p: Verifica se o valor atual da lista (L[x]) é igual ao valor procurado.

Se sim, a variável achou é marcada como True, e o laço é interrompido com break.

x += 1: Caso o valor não seja encontrado na posição atual, o índice x é incrementado para
verificar o próximo item da lista.

Verificação final:

Se achou for True, significa que o valor foi encontrado e o programa imprime a posição onde
ele foi encontrado.

Caso contrário, o programa informa que o valor não foi encontrado na lista.

=====================================================================

Programa 6.9 - Pesquisa sequencial. Livro 10 pág.109

sem utilizar a variável achou.

L = [15, 7, 27, 39]

 22

p = int(input("Digite o valor a procurar: ")) # Recebe o valor a ser procurado na lista

x = 0 # Variável para controlar o índice da lista

# Loop para percorrer a lista e buscar o valor

while x < len(L) and L[x] != p: # ! retorna True se os operandos forem diferentes

x += 1 # Aumenta o índice para verificar o próximo item

# Verifica se o valor foi encontrado e imprime a posição

if x < len(L):

print(f"{p} achado na posição {x}")

else:

print(f"{p} não encontrado")

faça um script no python que pesquise 2 valores na lista L = [a,8,b,6,5] via input e informe

a posição onde p e v foram encontrados e os seus respectivos valores através do print.

Caso não encontre um valor, imprima a posição e esse valor.Converter a entrada para
mínúsculo.

nome do script: pesquisaDoisValores_Strings

L = ['a', 8, 'b', 6, 5] #Lista de dados a pesquisar

# Receber os valores de entrada e converter para minúsculas

p = input("Digite o primeiro valor a ser pesquisado: ").lower()

v = input("Digite o segundo valor a ser pesquisado: ").lower()

# Função para encontrar a posição de um valor na lista

# Return: Este método retorna o índice do primeiro item na lista que corresponde ao valor
procurado.
 23

# Exceção ValueError: Se o valor não for encontrado na lista, lst.index(value) levanta uma
exceção do tipo ValueError

def find_position(lst, value): # find_position é o nome da função

try:

return lst.index(value), value

except ValueError:

return None, value

# Procurar e imprimir as posições e valores de p e v

pos_p, val_p = find_position(L, p)

pos_v, val_v = find_position(L, v)

if pos_p is not None:

print(f"Valor '{val_p}' encontrado na posição {pos_p}")

else:

print(f"Valor '{val_p}' não encontrado. Posição seria: N/A")

if pos_v is not None:

print(f"Valor '{val_v}' encontrado na posição {pos_v}")

else:

print(f"Valor '{val_v}' não encontrado. Posição seria: N/A")

----------------------------------------------------------------------------------

este script:
 24

Solicita ao usuário dois valores para pesquisa e converte a entrada para minúsculas para
garantir a consistência

na comparação com os elementos da lista que são strings.

Utiliza uma função find_position para tentar localizar cada valor na lista.

Imprime a posição e o valor se encontrado, ou uma mensagem indicando que não foi
encontrado juntamente com o valor pesquisado.

----------------------------------------------------------------------------------------------------------------------------
--

o que significa lst.index(value)

lst.index(value) é um método em Python usado em listas (ou arrays) que retorna a posição
(índice) do primeiro

elemento na lista lst que é igual ao value especificado.

Aqui estão alguns pontos chave sobre lst.index(value):

Índice Baseado em Zero: Os índices em Python começam em 0, então o primeiro elemento

da lista está na posição 0, o segundo na posição 1, e assim por diante.

Retorno: Este método retorna o índice do primeiro item na lista que corresponde ao valor
procurado.

Exceção ValueError: Se o valor não for encontrado na lista, lst.index(value) levanta uma
exceção do tipo ValueError.

Por isso, geralmente é usado dentro de um bloco try/except para tratar essa situação.

Exemplo:

python

lst = [1, 2, 3, 4, 5]

print(lst.index(3)) # Saída: 2

Uso Com Strings: Quando usado com listas que contêm strings, é case-sensitive:

python

lst = ['A', 'B', 'a', 'b']

print(lst.index('a')) # Saída: 2
 25

print(lst.index('A')) # Saída: 0

Portanto, lst.index(value) é útil para encontrar a posição de um elemento específico dentro

de uma lista, mas é necessário estar ciente de que ele pode lançar uma exceção se o valor
não for encontrado.

Qual a diferença entre a função def e a função main no Python

Em Python, a função def e a função main desempenham papéis distintos, embora ambas
estejam relacionadas ao conceito de funções.

Vamos entender cada uma delas separadamente.

Função def

A palavra-chave def é usada em Python para definir funções. Uma função é um bloco de
código reutilizável que executa uma determinada tarefa. O objetivo de criar funções é
encapsular um comportamento específico que pode ser chamado em diferentes partes do
programa, ajudando a tornar o código mais organizado, legível e fácil de manter.

A sintaxe básica para definir uma função em Python é a seguinte:

def nome_da_funcao(parametros):

# Corpo da função

# Instruções a serem executadas

• nome_da_funcao é o nome que você dá à sua função. Esse nome deve seguir as
regras de nomenclatura de identificadores em Python.

• parametros são os argumentos que a função pode aceitar, separados por vírgulas.
Eles são opcionais.

• O corpo da função é onde você escreve o código que realiza a tarefa da função.

Função main

A função main em Python não é uma palavra-chave ou uma função especial do ponto de
vista da linguagem. Ao contrário de algumas outras linguagens de programação, como C ou
Java, onde a função main é o ponto de entrada obrigatório de um programa, em Python não
 26

há a necessidade de uma função main para iniciar a execução do script. No entanto, é uma
convenção comum entre os desenvolvedores Python definir uma função main para organizar
o código, especialmente em scripts que podem ser executados diretamente ou importados
como módulos.

A convenção de usar uma função main geralmente segue o seguinte padrão:

def main():

# Código que você gostaria de executar se o script for chamado diretamente

if __name__ == "__main__":

main()

• A condição if __name__ == "__main__": verifica se o script está sendo executado

diretamente (como um programa principal) ou se está sendo importado como um módulo.

• Se o script estiver sendo executado diretamente, a função main será chamada e o

código dentro dela será executado.

Resumo

• def é uma palavra-chave usada para definir funções em Python.

• A função main, por outro lado, é uma convenção de nome de função usada para
organizar o ponto de entrada de um script Python, mas não é uma exigência da linguagem.

Ambas são ferramentas úteis para organizar e estruturar o código Python, mas servem a
propósitos diferentes