Introdução à programação e ambiente Python

Objetivos: Instalar e configurar ambiente, apresentar filosofia Python, executar primeiros programas.

Apresentação do Curso

O presente curso de Lógica de Programação com Python tem como propósito introduzir o estudante ao pensamento estruturado necessário para formular, decompor e resolver problemas por meio de algoritmos. Em uma sociedade cada vez mais orientada por dados, sistemas digitais e processos automatizados, a capacidade de compreender logicamente como a informação é transformada em resultados torna-se competência essencial para a formação cidadã e profissional. Tal compreensão não depende apenas de saber programar, mas de internalizar os princípios lógicos que sustentam toda a computação contemporânea, como bem discutem Cormen et al. (2012) e Farrer (2008).

O pensamento computacional — termo amplamente difundido por Jeannette Wing — consiste em um conjunto de habilidades cognitivas que incluem abstração, decomposição, reconhecimento de padrões e elaboração de algoritmos. Ele transcende o domínio da programação para tornar-se uma forma moderna de raciocínio, aplicável à ciência, à engenharia, às humanidades e à vida cotidiana. Ao desenvolver essas competências, o estudante passa a compreender que programar não é apenas escrever instruções para um computador, mas estruturar ideias de maneira precisa, lógica e verificável. Assim, esta disciplina não se limita ao aspecto técnico, mas contribui para a formação integral do aluno.

A escolha da linguagem Python como base do curso fundamenta-se tanto em sua estrutura sintática simples quanto em sua elevada expressividade. Python reduz ao mínimo a complexidade inicial enfrentada pelo aprendiz, permitindo que o foco recaia sobre os aspectos conceituais da lógica de programação, como variáveis, controle de fluxo, estruturas de dados e modularização. Além disso, sua ampla aceitação em áreas como ciência de dados, inteligência artificial, automação e desenvolvimento web a torna uma linguagem estratégica para o aluno que pretende continuar sua formação técnica ou superior. Conforme discutem autores contemporâneos da área, Python consolidou-se como a principal porta de entrada para a programação no ensino básico e técnico.

Por fim, é imprescindível destacar que a aprendizagem de programação exige prática constante e sistemática. A habilidade de transformar raciocínio lógico em código executável só se desenvolve por meio da escrita regular de programas, testes, correções e análise dos próprios erros. Cada exercício, cada algoritmo e cada projeto contribuem para fortalecer a compreensão dos conceitos estudados e consolidar a autonomia intelectual do estudante — objetivo central desta disciplina. Assim, desde o primeiro encontro, será incentivado um ambiente de experimentação responsável, no qual o estudante aprende fazendo, construindo e refinando suas soluções de forma progressiva e crítica.

Avaliações

Com base no documento do PCC do nosso curso, o processo avaliativo prevê a realização de provas obrigatórias identificadas como A1 e A2, cada uma com peso 40%, complementadas por outras atividades avaliativas de natureza diversificada que representam 20% da nota total da unidade formativa. Assim, a média final de cada unidade é calculada combinando essas três dimensões, assegurando que tanto o desempenho em avaliações formais quanto a participação contínua e atividades práticas sejam contempladas no processo. O PPC estabelece ainda que o estudante deve atender aos objetivos de aprendizagem definidos para obter aprovação direta na unidade curricular.

Em caso de desempenho insuficiente, o documento determina a existência de um processo de recuperação paralela e contínua, articulado ao planejamento pedagógico e voltado para suprir dificuldades diagnosticadas ao longo do percurso formativo, evitando a dependência exclusiva de avaliações finais. Entretanto, caso o estudante não alcance a média necessária ao término da unidade, poderá realizar uma avaliação final, a qual visa oportunizar nova verificação das competências essenciais previstas. A combinação entre avaliações periódicas, recuperação processual e prova final reflete a orientação do PPC para uma avaliação diagnóstica, formativa e somativa, coerente com a perspectiva de aprendizagem integral.

Instalando o Python

Abaixo um vídeo de como instalar o Python no Windows (Versão 11):

Abaixo um vídeo de como instalar o Python no Linux (Ubuntu):

Uma vez que o Pythom esteja instalado podemos verificar a versão na linha de comando (console ou terminal) como o comando pyhton –version (Windows) ou python3 –version (Linux).

O que é o Python?

Python é uma linguagem de programação de alto nível, interpretada e de propósito geral, conhecida por sua sintaxe clara e legível, o que a torna ideal para iniciantes. É amplamente utilizada em desenvolvimento web, ciência de dados, inteligência artificial, automação e outras áreas. Por ser de código aberto, gratuita e multiplataforma (funciona em Windows, macOS e Linux), é uma escolha popular para diversos projetos, desde os mais simples aos mais robustos.

Entendendo o parágrafo anterior:

1. Alto nível – Significa que Python foi projetada para ser próxima da linguagem humana. Ela esconde muitos detalhes internos do hardware — como gerenciamento manual de memória, registradores da CPU ou instruções específicas da máquina — permitindo que o programador pense no problema, e não nos mecanismos internos do computador. Isso favorece aprendizado mais rápido, código mais limpo e menor chance de erros.
2. Interpretada – Em vez de precisar ser convertida previamente em código de máquina (como acontece em linguagens compiladas), o código Python é executado linha por linha por um interpretador. Isso traz grande flexibilidade: você pode testar pequenos trechos rapidamente, depurar com facilidade e trabalhar de forma interativa. O custo é que, em geral, programas interpretados tendem a ser um pouco mais lentos que programas compilados, mas para a maioria dos usos essa diferença é irrelevante.
3. De propósito geral – Isso significa que Python não foi criada para uma área específica, como engenharia numérica, sistemas embarcados ou páginas web. Em vez disso, ela pode ser usada praticamente em qualquer domínio: ciência de dados, desenvolvimento web, automação, análise de textos, robótica, ensino de programação e até inteligência artificial. A vasta biblioteca padrão e o enorme ecossistema de pacotes tornam isso possível.

Características principais

• Sintaxe clara e fácil: O código Python se parece com o inglês, facilitando a leitura e a escrita.
• Alto nível: Isso significa que é mais fácil para os humanos entenderem e escreverem do que linguagens de baixo nível.
• Interpretada: O código Python é executado linha por linha, em vez de ser compilado para um código de máquina antes da execução.
• Orientada a objetos: É uma linguagem que usa o conceito de objetos, como dados e funções, para organizar o código.
• Gratuita e de código aberto: Pode ser baixada e usada gratuitamente, com um código que pode ser compartilhado e modificado.
• Multiplataforma: Funciona em diferentes sistemas operacionais, como Windows, macOS e Linux.

Para que serve?

• Desenvolvimento web: Criar aplicações web robustas.
• Ciência de dados e aprendizado de máquina (ML): Realizar análise de dados e construir modelos de inteligência artificial.
• Automação: Criar scripts para automatizar tarefas repetitivas.
• Desenvolvimento de software: Construir software de diferentes tipos, desde aplicativos móveis até sistemas complexos.
• Testes de software: Usado em frameworks de teste como pytest e unittest.

Básico de Python

Você executa o shell interativo abrindo o IDLE, que você instalou com o Python na introdução. No Windows, abra o menu Iniciar, selecione Todos os Programas ▸ Python 3.3 e, em seguida, selecione IDLE (Interface Gráfica do Python). No macOS, selecione Aplicativos ▸ MacPython 3.3 ▸ IDLE. No Linux, abra uma nova janela do Terminal e digite idle3.

A verdadeira compreensão em programação nasce do ato de escrever código. Ler sobre o assunto é apenas o primeiro passo; o domínio real surge quando você coloca as mãos no teclado e transforma teoria em prática. Assim como na matemática, onde a resolução de exercícios consolida o raciocínio, em programação o conhecimento só se fixa quando é experimentado.
Digite cada exemplo, teste, erre, corrija, observe o comportamento do programa. Esse é o caminho seguro para evoluir, fortalecer sua lógica e adquirir autonomia. Praticar é mais do que um hábito: é o meio pelo qual o aprendiz se torna mestre.

A IDLE do Python funciona como “interpretador”, ou seja, resolve (o termo correto é avalia) cada linha digitada e mostra o resultado. Veja os exemplos abaixo:

>>> 2 + 2
4

Na IDLE:

Em Python, 2 + 2 é chamado de expressão, que é o tipo mais básico de instrução de programação na linguagem. Expressões consistem em valores (como 2) e operadores (como +), e sempre podem ser avaliadas (ou seja, reduzidas) a um único valor. Isso significa que você pode usar expressões em qualquer lugar no código Python onde também usaria um valor.

Se o interpretador não conseguir avaliar uma linha digitada, teremos uma mensagem de erro que trará informações úteis para a solução do problema. Veja o exemplos abaixo:

>>2+a
Traceback (most recent call last):
    File “/usr/lib/python3.12/idlelib/run.py”, line 580, in runcode
        exec(code, self.locals)
    File “<pyshell#1>”, line 1, in <module>
NameError: name ‘a’ is not defined

Entenderemos esse erro e sua mensagem mais adiante.

Operadores matemáticos da maior para a menor precedência

Operador	Operação	Example	Resultado
**	Exponenciação	2 ** 3	8
%	Módulo	22 % 8	6
//	Divisão inteira/quociente arredondado para baixo	22 // 8	2
/	Divisão	22 / 8	2.75
*	Multiplicação	3 * 5	15
–	Subtração	5 - 2	3
+	Adição	2 + 2	4

 

A ordem de operações (também chamada de precedência) dos operadores matemáticos em Python é semelhante à da matemática. O operador ** é avaliado primeiro; os operadores *, /, // e % são avaliados em seguida, da esquerda para a direita; e os operadores + e – são avaliados por último (também da esquerda para a direita). Você pode usar parênteses para alterar a precedência usual, se necessário. Insira as seguintes expressões no shell interativo:

>>> 2 + 3 * 6
20
>>> (2 + 3) * 6
30
>>> 48565878 * 578453
28093077826734
>>> 2 ** 8
256
>>> 23 / 7
3.2857142857142856
>>> 23 // 7
3
>>> 23 % 7
2
>>> 2     +            2
4
>>> (5 - 1) * ((7 + 1) / (3 - 1))
16.0

Em cada caso, você, como programador, deve inserir a expressão, mas o Python faz a parte difícil de avaliá-la até obter um único valor. O Python continuará avaliando partes da expressão até que ela se torne um único valor, como mostrado abaixo:

(5 - 1) * ((7 + 1) / (3 - 1))
4 * ((7 + 1) / (3 - 1))
4 * ( 8 / (3 - 1))
4 * ( 8 / 2 )
4 * 4
16

Os tipos de dados inteiro, ponto flutuante e string.

Lembre-se de que expressões são apenas valores combinados com operadores e sempre resultam em um único valor. Um tipo de dado é uma categoria para valores, e cada valor pertence a exatamente um tipo de dado. Os tipos de dados mais comuns em Python estão listados na tabela abaixo. Os valores -2 e 3, por exemplo, são considerados valores inteiros. O tipo de dado inteiro (ou int) indica valores que são números inteiros. Números com uma casa decimal, como 3,14, são chamados de números de ponto flutuante (ou floats).

Data type	Examples
Integers	-2, -1, 0, 1, 2, 3, 4, 5
Floating-point numbers	-1.25, -1.0, –-0.5, 0.0, 0.5, 1.0, 1.25
Strings	'a', 'aa', 'aaa', 'Hello!', '11 cats'

 

Repare que ’42’ é uma string, 42 um inteiro e 42,0 um float.

Concatenação e replicação de strings

O significado de um operador pode mudar dependendo dos tipos de dados dos valores adjacentes. Por exemplo, + é o operador de adição quando aplicado a dois números inteiros ou de ponto flutuante. No entanto, quando + é usado em duas strings, ele as une, funcionando como o operador de concatenação. Digite o seguinte no shell interativo:

>>> 'Alice' + 'Bob'
'AliceBob'

A expressão resulta em um único novo valor de string que combina o texto das duas strings. No entanto, se você tentar usar o operador + em uma string e um valor inteiro, o Python não saberá como lidar com isso e exibirá uma mensagem de erro.

>>> 'Alice' + 42
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    'Alice' + 42
TypeError: Can't convert 'int' object to str implicitly

A mensagem de erro “Não é possível converter o objeto ‘int’ em str” significa implicitamente que o Python entendeu que você estava tentando concatenar um número inteiro à string ‘Alice’. Seu código precisará converter explicitamente o número inteiro em uma string, pois o Python não consegue fazer isso automaticamente. (A conversão de tipos de dados será explicada mais adiante ao abordarmos as funções str(), int() e float().)

O operador * é usado para multiplicação quando opera entre dois valores inteiros ou de ponto flutuante. Mas quando o operador * é usado entre um valor de string e um valor inteiro, ele se torna o operador de replicação de string. Digite uma string multiplicada por um número no shell interativo para ver isso em ação.

>>> 'Alice' * 5
'AliceAliceAliceAliceAlice'

A expressão resulta em um único valor de string que repete o original um número de vezes igual ao valor inteiro. A replicação de strings é um truque útil, mas não é tão comum quanto a concatenação de strings.

O operador * pode ser usado apenas com dois valores numéricos (para multiplicação) ou com um valor de string e um valor inteiro (para replicação de strings). Caso contrário, o Python exibirá uma mensagem de erro.

>>> 'Alice' * 'Bob'
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    'Alice' * 'Bob'
TypeError: can't multiply sequence by non-int of type 'str'
>>> 'Alice' * 5.0
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    'Alice' * 5.0
TypeError: can't multiply sequence by non-int of type 'float'

Faz sentido que o Python não entenda essas expressões: você não pode multiplicar duas palavras e é difícil replicar uma string arbitrária um número fracionário de vezes.

Armazenando valores em variáveis

Uma variável é como uma caixa na memória do computador onde você pode armazenar um único valor. Se você quiser usar o resultado de uma expressão avaliada posteriormente em seu programa, poderá salvá-lo dentro de uma variável.

Atribuição

Você armazenará valores em variáveis ​​com uma instrução de atribuição. Uma instrução de atribuição consiste em um nome de variável, um sinal de igual (chamado operador de atribuição) e o valor a ser armazenado. Se você inserir a instrução de atribuição spam = 42, então uma variável chamada spam terá o valor inteiro 42 armazenado nela.

A linha de comando:

>>> spam = 42
>>> print(spam)
    42

Em Python podemos alterar a vontade os valores de uma variável.

>>> spam = 'Hello!'
>>> print(spam)
    Hello!

Podemos criar quantas variáveis quisermos(regras de criação de variáveis em pyhon).

>>> xxx = 'Python'
>>> print(xxx)
    Python

Nomes de variáveis

Você pode dar qualquer nome a uma variável, desde que ela obedeça às três regras a seguir:

1. Pode ser apenas uma palavra.
2. Pode usar apenas letras, números e o caractere sublinhado (_).
3. Não pode começar com um número.

Os nomes das variáveis ​​diferenciam maiúsculas de minúsculas, o que significa que spam, SPAM, Spam e sPaM são quatro variáveis ​​diferentes. É uma convenção do Python começar as variáveis ​​com uma letra minúscula(mais sobre notação de variáveis).

Primeiro programa

Vamos fazer algo bem simples criar um programa que armazene o nosso nome e depois nos cumprimente usando o nome fornecido.

>>> print(‘Digite seu nome’)

>>> nome = input()

>>>print(‘Ola ‘ + nome)

Veja na figura abaixo os comandos executados como ficou esquisito:

O ideal para esse programa seria que todos os comandos pudessem ser mandados para o interpretador de uma vez e executados, como podemos fazer isso?

A IDLE do Python, fornece um editor de textos bem simples para podermos escrever nossos programas. Execute a sequência File > New File e teremos uma janela nova como a da figura abaixo:

Repare que na barra de títulos está escrito ‘untitled’ (sem título) pois não fornecemos um nome para o nosso programa ainda. Acione a sequência File > Save e coloque o nome primeiroprograma na caixa de diálogos. Veja a figira abaixo:

Repare que os nossos programas em Python devem ter a extensão py. O seu programa será salvo com o seguinte nome ‘primeiroprograma.py’. Agora na área de trabalho do editor vamos escrever o nosso código e salvar (ctrl+S). Veja a figura abaixo:

Feito isso, devemos ir para a linha de comando (console ou terminal) da pasta onde se encontra o nosso programa e na linha de comando digitar python primeiroprograma.py (Ou python3 em alguns casos). Veja a figura abaixo:

Podemos fornecer o nome para o programa poder continuar (o comando input() para o programa e aguarda entrada do teclado). Veja a figura abaixo:

O editor do Python é muito simples, existem vários editores especiais para programação. Sugiro que utilizam o VSCode da Microsoft (https://code.visualstudio.com/) é open (gratuit0) e muito poderoso. Mas o programador deve construir sua própria caixa de ferramentas e um editor é uma das escolhas que o programador deve fazer para facilitar o proprio trabalho e não por que o editor foi recomendado ou todos estão usando, pesquise e encontre o seu melhor editor para Python (normalmente se muda de editor quando mudamos de linguagem).

Funções

1. Definição de Função em Python

Em Python, uma função é um bloco nomeado de código que encapsula um conjunto de instruções projetadas para realizar uma tarefa específica. Sua forma geral é:

def nome_da_funcao(parâmetros):
    instruções
    return valor

Do ponto de vista teórico, funções são abstrações computacionais: mecanismos que permitem agrupar operações sob uma designação única, tornando possível reutilizar lógica, reduzir redundância e criar estruturas conceituais mais claras. Segundo Abelson & Sussman (1985), funções constituem o fundamento da composição de procedimentos, elemento essencial para o pensamento computacional.

---

2. Importância das Funções em Programação

As funções são cruciais por motivos estruturais, cognitivos e de engenharia de software:

2.1 Modularização

Funções permitem dividir programas complexos em componentes menores, cada qual responsável por uma tarefa específica. Isso melhora a legibilidade e facilita a manutenção.

2.2 Reutilização

Uma função bem escrita pode ser utilizada inúmeras vezes, tanto dentro de um projeto quanto em diferentes projetos. Esse aspecto é um dos pilares da eficiência no desenvolvimento de software.

2.3 Abstração

Funções permitem pensar em um problema em níveis conceituais mais elevados. O programador não precisa se preocupar com como cada tarefa é implementada, mas apenas com o que ela faz.

2.4 Redução de Erros

Trechos de código encapsulados em funções são testados uma vez e reutilizados com segurança. Isso minimiza erros decorrentes de duplicação.

2.5 Colaboração

Projetos maiores dependem da divisão de responsabilidades. Funções bem estruturadas e documentadas permitem que equipes distintas trabalhem simultaneamente sem interferência.

---

3. Funções Nativas (Built-in) do Python

Python possui uma vasta coleção de funções nativas (built-ins), disponíveis sem necessidade de importação. Elas conferem à linguagem um caráter altamente expressivo e pragmático.

Exemplos notáveis:

• print(): saída de dados.
• len(): tamanho de coleções.
• type(): inspeção de tipos.
• range(): geração de sequências numéricas.
• sum(), min(), max(): operações matemáticas básicas.
• isinstance(): verificação de tipos.
• sorted(): ordenação.

Essas funções são implementadas em C (no CPython), o que garante eficiência e robustez. Em termos teóricos, elas formam uma base funcional mínima que oferece ao programador um kit de ferramentas prontas para uso imediato.

A documentação oficial lista mais de 60 funções internas — uma demonstração da preocupação do Python com a produtividade e acessibilidade do programador.

---

4. O Poder da Importação de Funções

Além das funções nativas, Python permite importar funções de módulos externos, sejam eles:

• módulos padrão (stdlib);
• módulos desenvolvidos pela comunidade (via pip);
• módulos privados criados pelo próprio programador.

Essa capacidade transforma Python em uma linguagem praticamente ilimitada.

4.1 Biblioteca Padrão (Standard Library)

A biblioteca padrão oferece centenas de funções organizadas em módulos. Exemplos:

• math → funções matemáticas: sqrt(), cos(), log().
• random → geração pseudoaleatória.
• os e pathlib → manipulação de arquivos e diretórios.
• datetime → manipulação de datas.
• statistics → média, variância e mediana.

Importação básica:

import math
print(math.sqrt(25))

4.2 Ecosistema Científico

A verdadeira revolução do Python advém da possibilidade de importar bibliotecas científicas como:

• NumPy — arrays e álgebra linear;
• Pandas — manipulação de dados;
• Matplotlib — visualização;
• SciPy — computação científica.

Cada uma dessas bibliotecas expande o Python muito além de uma linguagem de propósito geral; torna-se uma plataforma científica completa.

4.3 Modularidade Máxima

Quando você cria suas próprias funções e as distribui em módulos, está construindo uma base personalizada que pode ser importada conforme necessidade.

Exemplo autorreferente:

from meus_modulos.funcoes_auxiliares import calcula_media

Esse mecanismo dá origem a projetos de alta complexidade, todos organizados por meio da importação de funções.

---

5. Por que funções enriquecem profundamente a linguagem

Funções representam:

• expressividade,
• capacidade de composição,
• organização lógica,
• eficiência cognitiva,
• manutenção simplificada,
• reuso de código.

Sem funções, um programa seria um bloco monolítico e caótico de instruções sequenciais — impróprio para a ciência da computação moderna.

Exemplos

1. Conversão de texto para maiúsculas usando input() e print()

# Programa 1: Lê um texto do usuário e exibe em maiúsculas
texto = input("Digite algo: ")
resultado = texto.upper()          # upper() é método de string, mas input() e print() são built-in
print(resultado)

Funções built-in utilizadas: input(), print().

---

2. Cálculo da soma de três números usando sum()

# Programa 2: Soma três números informados pelo usuário
a = float(input("Primeiro número: "))
b = float(input("Segundo número: "))
c = float(input("Terceiro número: "))
resultado = sum([a, b, c])   # sum() é built-in
print("A soma é:", resultado)

Funções built-in utilizadas: input(), print(), sum(), float().

---

3. Verificar o tipo de um valor usando type()

# Programa 3: Mostra o tipo do valor digitado
valor = input("Digite algo: ")
print("O tipo do valor digitado é:", type(valor))

Funções built-in utilizadas: input(), print(), type().

---

4. Ordenação de uma lista simples com sorted()

# Programa 4: Organiza três palavras em ordem alfabética
p1 = input("Primeira palavra: ")
p2 = input("Segunda palavra: ")
p3 = input("Terceira palavra: ")
ordenadas = sorted([p1, p2, p3])     # sorted() é built-in
print("Palavras em ordem alfabética:", ordenadas)

Funções built-in utilizadas: input(), print(), sorted().

---

5. Conversão de número para inteiro e cálculo de módulo com abs() e int()

# Programa 5: Converte um número para inteiro e exibe seu valor absoluto
valor = float(input("Digite um número: "))
inteiro = int(valor)     # int() é built-in
resultado = abs(inteiro)     # abs() é built-in
print("Valor absoluto do inteiro:", resultado)

Funções built-in utilizadas: input(), print(), float(), int(), abs().

---

 

1. Exercícios Progressivos sobre Funções Built-in

Os exercícios abaixo são lineares, diretos e focados em built-ins, adequados tanto para iniciantes quanto para um curso introdutório.

Exercício 1 — Uso de print() e input()

Peça ao usuário seu nome completo e apresente uma saudação formal utilizando print().
Objetivo: manipulação básica de entrada/saída.

---

Exercício 2 — Uso de len()

Solicite ao usuário uma palavra e exiba quantas letras ela possui usando len().
Objetivo: medir tamanho de strings.

---

Exercício 3 — Conversão com int() e float()

Peça ao usuário um número, converta-o para int e depois para float, imprimindo ambos os valores.
Objetivo: compreender coerção de tipos.

---

Exercício 4 — Cálculo com abs()

Peça ao usuário um número negativo e exiba o valor absoluto.
Objetivo: utilização de função matemática simples.

---

Exercício 5 — Ordenação com sorted()

Solicite três palavras e exiba a lista ordenada alfabeticamente com sorted().
Objetivo: perceber como built-ins manipulam coleções.

---

Exercício 6 — Verificação com type()

Peça ao usuário para digitar qualquer coisa e mostre na tela seu tipo.
Objetivo: observação do sistema dinâmico de tipos do Python.

---

Exercício 7 — Soma com sum()

Solicite ao usuário quatro valores numéricos e exiba a soma usando sum().
Objetivo: operações numéricas básicas.

---

Exercício 8 — Conversão de caixa usando str() e método .upper()

Peça ao usuário um texto e converta para string explicitamente com str(), depois exiba em maiúsculas.
Objetivo: reforçar o papel de built-ins que manipulam tipos primários.

---

Exercício 9 — Separação com max() e min()

Receba três números do usuário e exiba o maior e o menor utilizando max() e min().
Objetivo: compreensão de operações comparativas sem uso de if.

---

Exercício 10 — Função round()

Receba do usuário um número decimal e exiba o número arredondado para 0 casas decimais.
Objetivo: uso de arredondamento nativo.

---

2. Lista Comentada com 30 Funções Built-in Essenciais

A seguir apresento uma lista selecionada de 30 funções internas que compõem o núcleo funcional da linguagem.

1. print()

Exibe dados no console. Fundamental para depuração e interação.

2. input()

Coleta dados digitados pelo usuário. Base da interação textual.

3. len()

Retorna o tamanho de listas, strings, tuplas e outros iteráveis.

4. type()

Retorna o tipo do objeto; útil para estudo e verificação.

5. int()

Converte valores para inteiro, quando possível.

6. float()

Converte valores para ponto flutuante.

7. str()

Converte qualquer objeto em sua representação textual.

8. bool()

Converte valores para booleano.

9. sum()

Retorna a soma de elementos numéricos de um iterável.

10. abs()

Retorna o valor absoluto.

11. max()

Retorna o maior elemento de um iterável.

12. min()

Retorna o menor elemento de um iterável.

13. sorted()

Ordena elementos e retorna uma nova lista ordenada.

14. round()

Arredonda números de ponto flutuante.

15. pow()

Retorna a potência base**expoente.

16. range()

Gera uma sequência numérica (embora seja mais útil em loops, é um built-in importante).

17. id()

Retorna o identificador único do objeto na memória.

18. help()

Abre o sistema de ajuda interativo; valioso para documentação.

19. dir()

Lista atributos e métodos de um objeto.

20. isinstance()

Verifica se um objeto é instância de um tipo.

21. callable()

Verifica se um objeto é chamável (função, método etc.).

22. hash()

Retorna o valor de hash do objeto.

23. enumerate()

Associa índices a elementos de iteráveis (embora usado geralmente em loops, é built-in fundamental).

24. all()

Retorna True se todos os elementos de um iterável forem verdadeiros.

25. any()

Retorna True se pelo menos um elemento for verdadeiro.

26. repr()

Retorna a representação oficial de um objeto (útil para depuração).

27. eval()

Avalia expressões em string como código Python (com cautela).

28. open()

Abre arquivos e retorna um objeto de arquivo.

29. bytes()

Cria uma sequência de bytes imutável.

30. bytearray()

Cria uma sequência de bytes mutável.

---

Sugestão de solução para os exercícios

Exercício 1 — Saudar com input() e print()

Objetivo: usar input() e print() para interação básica.

# Exercício 1 - Gabarito
# Lê o nome do usuário e exibe uma saudação formal.

nome = input("Digite seu nome completo: ")   # coleta de dados do usuário como string
saudacao = "Bom dia, Sr(a). " + nome         # concatenação simples de strings
print(saudacao)                              # exibe a saudação no console

Comentário linha a linha

• input(...) retorna sempre uma str. Mesmo que o usuário digite números, o valor será string.

• Construímos saudacao por concatenação com +. Poderia usar f-strings (f"Bom dia, Sr(a). {nome}") — equivalente e mais legível.

• print() converte automaticamente objetos para string (via str()), e os envia ao stdout.

Exemplo

• Entrada: João da Silva

• Saída: Bom dia, Sr(a). João da Silva

Observações

• Não há validação (pois sem if/loops). Em contexto real, validar se o nome não é vazio seria desejável.

---

Exercício 2 — len() para tamanho de string

Objetivo: utilizar len() para obter o número de caracteres.

# Exercício 2 - Gabarito
# Pede uma palavra e mostra quantas letras ela possui.

palavra = input("Digite uma palavra: ")
tamanho = len(palavra)                      # len() retorna o número de caracteres
print("A palavra tem", tamanho, "caracteres.")

Comentário

• len() devolve o número de unidades de código (caracteres em Python str que são sequências de Unicode). Para contagem de “letras” e comportamentos com acentos/combinações, considerar normalização Unicode (métodos do módulo unicodedata) em casos avançados.

• print() aqui recebe múltiplos argumentos; o separador padrão é um espaço.

Exemplo

• Entrada: ação

• Saída: A palavra tem 4 caracteres.

Observação

• len("ação") == 4 porque ç, ã são caracteres únicos em Unicode; porém combinações de base+diacrítico podem alterar contagem — tópico avançado.

---

Exercício 3 — Conversões com int() e float()

Objetivo: demonstrar coerção explícita de tipos.

# Exercício 3 - Gabarito
# Recebe um número, converte para int e float, imprime ambos.

entrada = input("Digite um número (ex: 42 ou 3.14): ")
inteiro = int(float(entrada))   # converte primeiro para float para aceitar "3.0", depois para int
flutuante = float(entrada)

print("Valor como inteiro:", inteiro)
print("Valor como float:", flutuante)

Comentário

• O encadeamento int(float(entrada)) permite que entradas como 3.0 ou 3,0 (este último inválido sem substituição de vírgula) sejam primeiro interpretadas como float e depois convertidas.

• int() truncará a parte decimal (não arredonda). Para arredondamento, usar round().

Exemplo

• Entrada: 7.9

• Saída:

  Valor como inteiro: 7
  Valor como float: 7.9
  

Observações

• Se o usuário digitar algo não numérico (por exemplo "abc"), ocorrerá ValueError. Em ambiente real, envolveria try/except, mas isso sairia do escopo “sem condicionais/loops”.

---

Exercício 4 — abs() para valor absoluto

Objetivo: uso de função matemática nativa.

# Exercício 4 - Gabarito
# Recebe um número negativo e retorna o valor absoluto.

entrada = input("Digite um número (pode ser negativo): ")
valor = float(entrada)          # interpreta a entrada como float
absoluto = abs(valor)           # abs() retorna o valor absoluto
print("O valor absoluto é:", absoluto)

Comentário

• abs() aceita int, float e tipos que implementem __abs__.

• Convertemos para float para aceitar números com casa decimal.

Exemplo

• Entrada: -12.5

• Saída: O valor absoluto é: 12.5

Observações

• Se desejar inteiro, usar int() em vez de float(), mas cuidado com perda de precisão.

---

Exercício 5 — sorted() com três palavras

Objetivo: demonstrar ordenação de coleções com sorted().

# Exercício 5 - Gabarito
# Recebe três palavras e exibe a lista ordenada

p1 = input("Primeira palavra: ")
p2 = input("Segunda palavra: ")
p3 = input("Terceira palavra: ")

lista = [p1, p2, p3]
ordenadas = sorted(lista)       # sorted() retorna nova lista ordenada
print("Palavras em ordem alfabética:", ordenadas)

Comentário

• sorted() por padrão usa ordenação lexicográfica via Unicode code points. Para ordenação “case-insensitive”, pode usar sorted(lista, key=str.lower) (ainda sem if/loops).

• sorted() não modifica lista original — ela retorna nova lista.

Exemplo

• Entrada: banana, Abacaxi, laranja

• Saída (padrão Unicode): ['Abacaxi', 'banana', 'laranja']

• Se quiser ignorar maiúsculas: sorted(lista, key=str.lower) resultaria ['Abacaxi', 'banana', 'laranja'] — aqui a diferença pode ser sutil dependendo de casos.

Observação

• Ordenação envolvendo acentuação segue regras Unicode; para ordenação “natural” em português considerar bibliotecas de internacionalização (locale) — tópico avançado.

---

Exercício 6 — type() para inspeção de tipo

Objetivo: mostrar o tipo de um valor digitado.

# Exercício 6 - Gabarito
# Recebe qualquer coisa e mostra seu tipo.

entrada = input("Digite algo: ")
print("O tipo de dados recebido é:", type(entrada))

Comentário

• Como input() sempre retorna str, type(entrada) será str. Este exercício ilustra o sistema dinâmico de tipos e serve de gancho para demonstrar conversões com int()/float() quando necessário.

• Para demonstrar tipos diferentes, poderíamos converter explicitamente e aplicar type() nas novas variáveis (type(int(entrada))), mas o exercício original busca observação básica.

Exemplo

• Entrada: 123

• Saída: O tipo de dados recebido é: <class 'str'>

Observação

• Importante sublinhar para alunos que type() é informativo; isinstance() é preferível para verificações em código produtivo.

---

Exercício 7 — sum() com quatro valores

Objetivo: somar elementos de um iterável usando sum().

# Exercício 7 - Gabarito
# Solicita quatro valores e calcula a soma com sum().

v1 = float(input("Valor 1: "))
v2 = float(input("Valor 2: "))
v3 = float(input("Valor 3: "))
v4 = float(input("Valor 4: "))

total = sum([v1, v2, v3, v4])   # sum() faz a soma dos elementos do iterável
print("A soma dos quatro valores é:", total)

Comentário

• sum() aceita um iterável de números. Pode-se passar uma lista, tupla ou gerador.

• Conversão para float permite valores com casas decimais.

Exemplo

• Entradas: 1, 2.5, 3, 4

• Saída: A soma dos quatro valores é: 10.5

Observação

• Para somas de alta precisão em finanças, considerar decimal.Decimal.

---

Exercício 8 — str() e .upper()

Objetivo: conversão explícita para string e manipulação de caixa.

# Exercício 8 - Gabarito
# Recebe um texto, converte explicitamente para str e exibe em maiúsculas.

entrada = input("Digite um texto: ")
texto = str(entrada)            # conversão explícita (aqui redundante, pois input já retorna str)
texto_maiusculo = texto.upper() # método de string para maiúsculas
print("Texto em maiúsculas:", texto_maiusculo)

Comentário

• str() é útil quando recebemos objetos de outros tipos; com input() é redundante, porém didaticamente mostra coerção explícita.

• .upper() é método de instância de str, não uma função built-in isolada, mas amplamente usado em combinação com built-ins.

Exemplo

Entrada: Olá Mundo!

Saída: Texto em maiúsculas: OLÁ MUNDO!

Observação

• Para operações que preservem acentuação/internacionalização, .upper() usa regras Unicode e geralmente funciona adequadamente.

---

Exercício 9 — max() e min() com três números

Objetivo: identificar valores extremos usando built-ins.

# Exercício 9 - Gabarito
# Recebe três números e mostra o maior e o menor.

n1 = float(input("Número 1: "))
n2 = float(input("Número 2: "))
n3 = float(input("Número 3: "))

maior = max(n1, n2, n3)   # max aceita múltiplos argumentos ou um iterável
menor = min(n1, n2, n3)   # min idem
print("Maior:", maior)
print("Menor:", menor)

Comentário

• max() e min() aceitam tanto max(a,b,c) quanto max([a,b,c]).

• Trabalham com tipos comparáveis; misturar int e float é seguro (serão convertidos conforme necessidade).

Exemplo

• Entradas: 3, 7.2, -1

• Saída:

  Maior: 7.2
  Menor: -1.0
  

Observação

• Para coleções vazias, max()/min() levantam ValueError. Aqui sempre passamos três argumentos, logo seguros.

---

Exercício 10 — round() para arredondamento

Objetivo: demonstrar arredondamento nativo.

# Exercício 10 - Gabarito
# Recebe um decimal e exibe o valor arredondado para 0 casas decimais.

entrada = input("Digite um número decimal: ")
valor = float(entrada)
arredondado = round(valor)     # round(x) retorna inteiro arredondado ao mais próximo
print("Valor arredondado (0 casas):", arredondado)

Comentário

• round(x) sem segundo argumento retorna um int (ou float em algumas implementações; em CPython round(2.5) -> 2.0 historicamente, comportamento ligado à “bankers rounding” — ao ensinar, vale comentar sutilidades de arredondamento).

• Pode-se usar round(valor, 2) para manter duas casas decimais.

Exemplo

• Entrada: 2.6
• Saída: Valor arredondado (0 casas): 3

Observação

• Arredondamento de x.5 pode surpreender: round(2.5) pode dar 2 (arredondamento para par). Esclarecer esse ponto ao ensinar.

---

Observações pedagógicas gerais

1. Erros de conversão: todos os exercícios que fazem int()/float() assumem entrada válida; em ambiente de produção sempre tratar ValueError (com try/except), mas isto adiciona fluxo condicional que ainda não foi visto.
2. Unicode e acentuação: funções como len(), sorted() e .upper() interagem com Unicode; resultados podem variar em detalhes para alfabetos e combinações diacríticas.
3. Boas práticas: comentar código e usar f-strings (f"Texto {variavel}") são recomendáveis para legibilidade e manutenção (será visto com profundidade mais adiante).
4. Sugestão didática: após dominar esses exercícios lineares, avance para versões com validação (try/except), condicionais e laços, além de tratar arquivos com open().

Fim da aula 01