Python Básico

3 - Sintaxe e Semântica

No Python a sintaxe se refere ao uso correto das palavras reservadas, das declarações de variáveis, funções, classes e outros recursos, nas instruções da linguagem, enquanto a semântica se refere ao uso correto da lógica na programação.

Se a instrução contiver um erro de sintaxe, o erro será apresentado no console e o programa será encerrado na linha de instrução em que ocorreu o erro, se estiver rodando um Script-Python.

Já se o programa contiver algum código com um erro de semântica, o código funcionará sem causar excessões críticas que interrompam o programa, entretanto não atendendo corretamente ao objetivo desejado.

O código Python a seguir exemplifica operações de atribuição de textos para as variáveis a, b e c, com a ocorrência de um erro de sintaxe na atribuição de c.

Textos são sequências de caracteres entre aspas simples ou duplas.

Declaramos a usando uma aspas simples e b usando uma aspas duplas.

a = 'A'
b = "B"
print(f"a={a} ({type(a)})")
print(f"b={b} ({type(b)})")

a=A (<class 'str'>)
b=B (<class 'str'>)

A sintaxe está correta nas declarações das variáveis a e b, que recebem textos delimitados de modo uniforme por aspas simples e duplas, respectivamente.

Entretanto na atribuição da variável c o texto inicia com aspas simples e finaliza com aspas duplas, causando erro de sintaxe durante a interpretação da instrução, e a interrupção do programa.

c = "C'
print(f"c={c} ({type(c)})")

SyntaxError: unterminated string literal (detected at line 1) (<string>, line 1) <traceback object at 0x0000018D431CA5C0>

O código Python a seguir apresenta um erro semântico em um laço de repetição, ocorrendo enquanto a condição da variável i, iniciada com 0, estiver menor que 1000.

Neste código a variável recebendo o incremento de i é a variável j, com o valor de i permanecendo zerado durante todos o tempo de execução do laço.

Sem o incremento de i, o laço se torna-se "infinito", as instruções no seu bloco são executadas indefinidamente, até ocorrer algum tipo de erro fatal que interrompa o programa, por exemplo excesso de consumo de memória.

i = 0
total = 0.0
while i < 1000:
    j = i + 1
    total = total + i
print("Total = ", total)

No exemplo acima, o código não apresenta erros de sintaxe, mas sim de semântica, pois a variável j é utilizada sem causar erro, recebendo todas as vezes o valor do incremento que deveria ser de i.

Sem a variável i ser incrementada, jamais a condição do laço será atendida.

Os erros de sintaxe são detectados assim que ocorrem, durante a execução do programa, enquanto os erros de semântica dependem do programador para não ocorrerem, utilizando corretamento os recursos de programação disponíveis e aplicando a lógica correta na declaração das instruções necessárias para o processo desejado ser realizado precisamente.

Construções

Nos idiomas em geral, a sintaxe é a parte da gramática que estuda as palavras enquanto elementos de uma frase, as suas relações de concordância, de subordinação e de ordem, sendo componente do sistema linguístico que determina as relações formais que interligam os constituintes da sentença, atribuindo-lhe uma estrutura.

A sintaxe do Python tem palavras reservadas, literais, siglas e simbolos que estabelecem relações uns com os outros construindo a funcionalidade da linguagem através de estruturas de código.

O Python executa comandos que disparam uma instrução ou conjuntos de instruções executadas em sequência.

A programação básica do Python é realizada com a declaração de instruções simples e em estruturas de blocos de instruções.

Construções de Python incluem instruções com:

• Operações de atribuição, aritméticas, comparação, lógica e bitwise
• Manipulação de textos, vetores, arquivos, bases de dados, objetos, arquitetura, redes, processos
• Estruturas de seleção if... else... elif e match... case...case _
• Estruturas de repetição while e for, iterando elementos em coleções
• Construções de classes (class), sub-rotinas (def) e escopo (with) na aquisição de recursos de contexto.

Tipos de Dados

A tipagem de Python é forte, pois os valores e objetos têm tipos bem definidos e não sofrem coerções como em C ou Perl. São disponibilizados diversos tipos de dados nativos:

Python também permite a definição dos tipos de dados próprios, através de classes.

Instâncias são construídas invocando a classe, e as classes são instância da classe type, o que permite metaprogramação e reflexão.

Reflexão é um mecanismo que dá informações sobre o próprio código e permite modificá-lo, em tempo de compilação ou em tempo de execução, mais comum de ocorrer, sendo frequentemente usada para obter as informações necessárias e alterar o que precisa, embora não seja a única forma. O importante é o acesso à informação para manipulá-la (se não manipular é só introspecção).

Metaprogramação é um paradigma que permite a manipulação do código de forma mais geral, você programa como o código deve ser programado. É mais comum ocorrer em tempo de compilação.

Métodos são definidos como funções anexadas à classe, e a sintaxe instância.método(argumento) é um atalho para Classe.método(instância, argumento).

Os métodos devem referenciar explicitamente a referência para o objeto incluindo o parâmetro self como o primeiro argumento do método.

Palavras reservadas

O Python 3 define as seguintes palavras reservadas:

and, as, assert, async, await
break
case, class, continue
def, del
elif, else, except
False, finally, for, from
global
if, import, in, is
lambda
match
None, nonlocal, not
or
pass
raise, return
True, try
while, with
yield

Para saber quais são as palavras reservadas em Python, você pode usar o módulo keyword que vem com a Biblioteca-Padrão do Python:

import keyword

# Lista todas as palavras reservadas em Python
palavras_reservadas = keyword.kwlist
print(palavras_reservadas)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

A versão 3.10.0 implementou a correspondência de Padrão Estrutural, semelhante ao Switch-Case de outras linguagens, e por isso as palavras match e case passaram a ser reservadas.

Símbolos Reservados

Não há uma função direta no Python que liste os operadores e símbolos reservados, mas você pode criar uma lista manualmente para referência.

Aqui está um exemplo de como você pode fazer isso:

# Lista de símbolos de operadores reservados em Python
operadores = {
    'Aritméticos':['+', '-', '*', '/', '%', '**', '//'],
    'Atribuição':['=', '+=', '-=', '*=', '//=', '/=', '%=', '**=', '&=', '|=','^=', '>>=', '<<=', '@='], 
    'Relacionais':['==', '|=', '>', '<', '>=', '<='],
    'Lógicos':['&', '|', '^', '~','<<', '>>'],
    'Agrupamento':['(', ')', '[', ']', '{', '}'],
    'Outros':['@', ',', ':', '.','`', '->']
}

for key in operadores.keys():
    print(f"{key:<12}: {' '.join(operadores[key])}")

Aritméticos : + - * / % ** //
Atribuição  : = += -= *= //= /= %= **= &= |= ^= >>= <<= @=
Relacionais : == |= > < >= <=
Lógicos     : & | ^ ~ << >>
Agrupamento : ( ) [ ] { }
Outros      : @ , : . ` ->

Operadores

Os operadores básicos de comparação como ==, <, >=, entre outros são usados em todos os tipos de dados, como números, cadeias de texto, listas e mapeamentos. Comparações em cadeia como a < b < c possuem o mesmo significado básico que na matemática: os termos são comparadas na ordem. É garantido que o processamento da expressão lógica irá terminar tão cedo o veredito seja claro, o princípio da avaliação mínima. Usando a expressão anterior, se a < b é falso, c não é avaliado.

Os operadores lógicos tratam "", 0, None, 0.0, [] e {} como falso, enquanto o restante é tratado como verdadeiro de modo geral. As constantes True e False representam 1 e 0, respectivamente. A comparação binária retorna uma das duas constantes acima.

Os operadores booleanos and e or também seguem a avaliação mínima. Por exemplo, (y == 0 and x/y > 100) nunca lançará a exceção de divisão por zero, pois (y == 0) retornará false e a cláusula and determinará que a expressão será avaliada automaticamente para falso e encerrada, e a expressão x/y > 100 não necessitará ser avaliada.

Interpretador interativo

O interpretador interativo é uma característica diferencial da linguagem, porque há a possibilidade de testar o código de um programa e receber o resultado em tempo real, antes de iniciar a compilação ou incluí-las nos programas.

Por exemplo:

>>> 1 + 1
2
>>>
>>> a = 1 + 1
>>> print(a)
2
>>>

Se uma expressão não for atribuida a uma variável ou impressa com a função print, o valor do objeto do seu resultado será apresentado direcionado ao console e descartado em seguida.

Análise Lexica

A análise léxica é uma análise do interpretador em si, os programas são lidos por um analisador sintático que divide o código em tokens.

Todo programa é dividido em linhas lógicas que são separadas pelo token NEWLINE (NOVA LINHA), as linhas físicas são trechos de código divididos pelo caractere ENTER.

Linhas lógicas não podem ultrapassar linhas físicas com exceção de junção de linhas.

Exemplo:

resultado = 4
if resultado > 2 and \
    resultado <= 5  and \
    (resultado * 2) < 10:
        print (f'Resultado: {resultado}')

ou

MESES_DO_ANO = [
    'janeiro', 'fevereiro', 'março',
    'abril',   'maio',      'junho',
    'julho',   'agosto',    'setembro',
    'outubro', 'novembro',  'dezembro'
]

Para a delimitação de blocos de códigos, os delimitadores são colocados em uma pilha e diferenciados por sua indentação, iniciando a pilha com valor 0 (zero) e colocando valores maiores que os anteriores na pilha.

Para cada começo de linha, o nível de indentação é comparado com o valor do topo da pilha. Se o número da linha for igual ao topo da pilha, a pilha não é alterada.

Se o valor for maior, a pilha recebe o nível de indentação da linha e o nome INDENT (empilhamento).

Se o nível de indentação for menor, então é desempilhado até chegar a um nível de indentação recebendo o nome DEDENT (desempilhamento).

Se não encontrar nenhum valor, é gerado um erro de indentação.

Abaixo um exemplo de permutação, sobre a estrutura de linhas na análise léxica:

         def perm(l):                   NOVA LINHA
INDENT        if len(l) <= 1:           NOVA LINHA
INDENT           return[1]              NOVA LINHA
DEDENT        r = [ ]                   NOVA LINHA
              for i in range(len(l)):   NOVA LINHA
INDENT            s = l[:i] + l[i+1:]   NOVA LINHA
                  p = perm(s)           NOVA LINHA
DEDENT        for x in p:               NOVA LINHA
INDENT            r.append(l[i:i+1]+x)  NOVA LINHA
DEDENT        return r

Indentação

Python foi desenvolvido para ser uma linguagem de fácil leitura, com um visual agradável, frequentemente usando palavras e não pontuações como em outras linguagens.

Para a separação de blocos de código, a linguagem usa espaços em branco e indentação ao invés de delimitadores visuais como chaves (C, Java) ou palavras (BASIC, Fortran, Pascal).

Diferente de linguagens com delimitadores visuais de blocos, em Python a indentação é obrigatória.

O aumento da indentação indica o início de um novo bloco, que termina da diminuição da indentação.

Usando um editor de texto comum é muito fácil existir erros de indentação, o recomendado é configurar o editor conforme a análise léxica do Python ou utilizar uma IDE. Todas as IDE que suportam a linguagem fazem indentação automaticamente.

Exemplo: Indentação correta.

def valor1():
    while True:
        try:
            c = int(input('Primeiro Valor: '))
            return c
        except ValueError:
            print 'Inválido!'

Exemplo: Indentação incorreta.

def valor1():
    while True:
    try:
        c = int(input('Primeiro Valor: '))
        return c
    except ValueError:
        print 'Inválido!'

O código está correto para os dois exemplos, mas o analisador léxico verificará se a indentação está coerente.

O analisador reconhecerá as palavras reservadas while, def, try, except, return, print e as cadeias de caracteres entre aspas simples e a indentação, e se não houver problemas o programa executará normalmente, senão apresentará a exceção: "Seu programa está com erro no bloco de indentação".

Compilador de bytecode

A linguagem Python é de altíssimo nível, e o Programa-Interpretador pode também compilar seus programas, para que na próxima vez que os executar não precise os compilar, reduzindo o tempo de carga na execução.

Utilizando o interpretador interativo não é necessário a criação do arquivo de Python compilado, os comandos são executados interativamente. Porém quando um programa ou um módulo é evocado, o interpretador realiza a análise léxica e sintática, compila o código de alto nível se necessário e o executa na Máquina-Virtual da linguagem.

O bytecode é armazenado em arquivos com extensão '.pyc' ou '.pyo', este último no caso de bytecode otimizado. Interessante notar que o bytecode da linguagem também é de alto nível, ou seja, é mais legível aos seres humanos que o código de byte do C, por exemplo. Para descompilar um código de byte é utilizado o módulo dis da biblioteca padrão da linguagem e existem módulos de terceiros que tornam o bytecode mais confuso, tornando a descompilação ineficaz.

Normalmente, o Python trabalha com dois grupos de arquivos:

• Os módulos do núcleo da linguagem, sua biblioteca padrão e os módulos independentes, criados pelo usuário.
• No núcleo do interpretador existe o analisador léxico, o analisador sintático que utiliza Estruturas de Objetos (tempo de execução), o Compilador que aloca memória (tempo de execução) e depois do Avaliador de código que modifica o estado atual do programa (tempo de execução), mostrando resultado para o usuário.

Orientação a objetos

Python suporta a maioria das técnicas da programação orientada a objeto. Qualquer objeto pode ser usado para qualquer tipo, e o código funcionará enquanto haja métodos e atributos adequados. O conceito de objeto na linguagem é bastante abrangente: classes, funções, números e módulos são todos considerados objetos. Também há suporte para metaclasses, polimorfismo e herança (inclusive herança múltipla). Há um suporte limitado para variáveis privadas.

Na versão 2.2 de Python foi introduzido um novo estilo de classes em que objetos e tipos foram unificados, permitindo a especialização de tipos. Já a partir da versão 2.3 foi introduzido um novo método de resolução de ambiguidades para heranças múltiplas.

Uma classe é definida com a palavra-chave class seguida do nome da classe e dois-pontos. O corpo da classe define os atributos e os métodos, e o código seguinte é a composição dos atributos. Todos os métodos da classe recebem uma referência a uma instância da própria classe como seu primeiro argumento, e a convenção é que se chame este argumento self. Assim os métodos são chamados objeto.método(argumento1, argumento2, ...) e são definidos iguais a uma função, como método(self, argumento1, argumento2, ...). Veja que o parâmetro self conterá uma referência para a instância da classe definida em objeto quando for efetuada esta chamada. Os atributos da classe podem ser acessados em qualquer lugar da classe, e os atributos de instância (ou variável de instância) devem ser declarados dentro dos métodos utilizando a referência à instância atual (self) (ver código contextualizado em anexo).

Em Python não existe proteção dos membros duma classe ou instância pelo interpretador, o chamado encapsulamento. Convenciona-se que atributos com o nome começando com um _ são de uso privado da classe, mas não há um policiamento do interpretador contra acesso a estes atributos. Uma exceção são nomes começando com __, no caso em que o interpretador modifica o nome do atributo (ver código contextualizado em anexo).

Python permite polimorfismo, que condiz com a reutilização de código. É fato que funções semelhantes em várias partes do software sejam utilizadas várias vezes, então definimos esta função como uma biblioteca e todas as outras funções que precisarem desta a chamam sem a necessidade de reescrevê-la (ver código contextualizado em anexo).

Python não possui overloading; não é possível criar duas funções com o mesmo nome, pois elas são consideradas atributos da classe. Caso o nome da função se repita em outra assinatura, o interpretador considera esta última como override e sobrescreve a função anterior. Algumas operações entre diferentes tipos são realizadas através de coerção (ex.: 3.2 + 3).

É possível encapsular abstrações em módulos e pacotes. Quando um arquivo é criado com a extensão .py, ele automaticamente define um módulo. Um diretório com vários módulos é chamado de pacote e deve conter um modulo chamado __init__, para defini-lo como principal. Estas diferenciações ocorrem apenas no sistema de arquivos. Os objetos criados são sempre módulos. Caso o código não defina qual dos módulos será importado, o padrão é o __init__.

Programação funcional

Uma das construções funcionais de Python é compreensão de listas, uma forma de construir listas. Por exemplo, pode-se usar a técnica para calcular as cinco primeiras potências de dois. O algoritmo quicksort também pode ser expressado usando a mesma técnica (ver códigos contextualizados para ambos os casos em anexo).

Em Python, funções são objetos de primeira classe que podem ser criados e armazenados dinamicamente. O suporte a funções anônimas está na construção lambda (cálculo Lambda). Não há disponibilidade de funções anônimas de fato, pois os lambdas contêm somente expressões e não blocos de código.

Python também suporta clausuras léxicas desde a versão 2.2 (ver códigos contextualizados para ambos os casos em anexo). Já geradores foram introduzidos na versão 2.2 e finalizados na versão 2.3, e representam o mecanismo de Python para a avaliação preguiçosa de funções (ver códigos contextualizados para ambos os casos em anexo).

Tratamento de exceções

Python suporta e faz uso constante de tratamento de exceções como uma forma de testar condições de erro e outros eventos inesperados no programa. É inclusive possível capturar uma exceção causada por um erro de sintaxe. O estilo da linguagem apóia o uso de exceções sempre que uma condição de erro pode aparecer. Por exemplo, ao invés de testar a disponibilidade de acesso a um recurso, a convenção é simplesmente tentar usar o recurso e capturar a exceção caso o acesso seja rejeitado (recurso inexistente, permissão de acesso insuficiente, recurso já em uso, ...).

Exceções são usadas frequentemente como uma estrutura de seleção, substituindo blocos if-else, especialmente em situações que envolvem threads. Uma convenção de codificação é o EAFP, do inglês, "é mais fácil pedir perdão que permissão". Isso significa que em termos de desempenho é preferível capturar exceções do que testar atributos antes de os usar. Segue abaixo exemplos de código que testam atributos ("pedem permissão") e que capturam exceções ("pedem perdão"):

Teste de atributo:

if hasattr(spam, 'eggs'):
    ham = spam.eggs
else:
    handle_error()

Captura de exceção:

try:
    ham = spam.eggs
except AttributeError:
    handle_error()

Ambos os códigos produzem o mesmo efeito, mas há diferenças de desempenho. Quando spam possui o atributo eggs, o código que captura exceções é mais rápido. Caso contrário, a captura da exceção representa uma perda considerável de desempenho, e o código que testa o atributo é mais rápido. Na maioria dos casos o paradigma da captura de exceções é mais rápido, e também pode evitar problemas de concorrência.[32] Por exemplo, num ambiente multitarefa, o espaço de tempo entre o teste do atributo e seu uso de fato pode invalidar o atributo, problema que não acontece no caso da captura de exceções.

Biblioteca padrão

Python possui uma grande biblioteca padrão, geralmente citada como um dos maiores trunfos da linguagem,[33] fornecendo ferramentas para diversas tarefas. Por conta da grande variedade de ferramentas fornecida pela biblioteca padrão, combinada com a habilidade de usar linguagens de nível mais baixo como C e C++, Python pode ser poderosa para conectar componentes diversos de software.

A biblioteca padrão conta com facilidades para escrever aplicações para a Internet, contando com diversos formatos e protocolos como MIME e HTTP. Também há módulos para criar interfaces gráficas, conectar em bancos de dados relacionais e manipular expressões regulares.

Algumas partes da biblioteca são cobertas por especificações (por exemplo, a implementação WSGI da wsgiref segue o PEP 333[34]), mas a maioria dos módulos não segue.

Interoperabilidade

Um outro ponto forte da linguagem é sua capacidade de interoperar com várias outras linguagens, principalmente código nativo. A documentação da linguagem inclui exemplos de como usar a Python C-API para escrever funções em C que podem ser chamadas diretamente de código Python - mas atualmente esse sequer é o modo mais indicado de interoperação, havendo alternativas tais como Cython, Swig ou cffi. A biblioteca Boost do C++ inclui uma biblioteca para permitir a interoperabilidade entre as duas linguagens, e pacotes científicos fazem uso de bibliotecas de alta performance numérica escritos em Fortran e mantidos há décadas.

Comentários

Python fornece duas alternativas para documentar o código. A primeira é o uso de comentários para indicar o que certo código faz. Comentários começam com # e são terminados pela quebra da linha. Não há suporte para comentários que se estendem por mais de uma linha; cada linha consecutiva de comentário deve indicar #. A segunda alternativa é o uso de cadeias de caractere, literais de texto inseridos no código sem atribuição. Cadeias de caracteres em Python são delimitadas por " ou ' para única linha e por """ ou ''' para múltiplas linhas. Entretanto, é convenção usar o métodos de múltiplas linhas em ambos os casos.

Diferente de comentários, a cadeias de caracteres usadas como documentação são objetos Python e fazem parte do código interpretado. Isso significa que um programa pode acessar sua própria documentação e manipular a informação. Há ferramentas que extraem automaticamente essa documentação para a geração da documentação de API a partir do código. Documentação através de cadeias de caracteres também pode ser acessada a partir do interpretador através da função help().

3.1 - Classes e Objetos

x = 10
print(f"x = {x}, tipo '{type(x)}'")
print(f"representação de x com o endereço do objeto = '{(x.__repr__)}'")

x = 10, tipo '<class 'int'>'
representação de x com o endereço do objeto = '<method-wrapper '__repr__' of int object at 0x0000018D7CE40210>'

print(dir(10))

['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

print(f"int = {int}, tipo '{type(int)}'")
print(f"float = {float}, tipo '{type(float)}'")
print(f"str = {str}, tipo '{type(str)}'")
print(f"bool = {bool}, tipo '{type(bool)}'")
print(f"list = {list}, tipo '{type(list)}'")
print(f"tuple = {tuple}, tipo '{type(tuple)}'")
print(f"set = {set}, tipo '{type(set)}'")
print(f"dict = {dict}, tipo '{type(dict)}'")
print(f"range = {range}, tipo '{type(range)}'")
print(f"bytes = {bytes}, tipo '{type(bytes)}'")
print(f"bytearray = {bytearray}, tipo '{type(bytearray)}'")
print(f"memoryview = {memoryview}, tipo '{type(memoryview)}'")

int = <class 'int'>, tipo '<class 'type'>'
float = <class 'float'>, tipo '<class 'type'>'
str = <class 'str'>, tipo '<class 'type'>'
bool = <class 'bool'>, tipo '<class 'type'>'
list = <class 'list'>, tipo '<class 'type'>'
tuple = <class 'tuple'>, tipo '<class 'type'>'
set = <class 'set'>, tipo '<class 'type'>'
dict = <class 'dict'>, tipo '<class 'type'>'
range = <class 'range'>, tipo '<class 'type'>'
bytes = <class 'bytes'>, tipo '<class 'type'>'
bytearray = <class 'bytearray'>, tipo '<class 'type'>'
memoryview = <class 'memoryview'>, tipo '<class 'type'>'

for x in [10, 10.1, "10", True, [10], (10,), {10}, {"x":10}, range(10), bytes(10), bytearray(10), memoryview(bytes(10))]:
    print(f"x = {x}, tipo '{type(x)}'")

x = 10, tipo '<class 'int'>'
x = 10.1, tipo '<class 'float'>'
x = 10, tipo '<class 'str'>'
x = True, tipo '<class 'bool'>'
x = [10], tipo '<class 'list'>'
x = (10,), tipo '<class 'tuple'>'
x = {10}, tipo '<class 'set'>'
x = {'x': 10}, tipo '<class 'dict'>'
x = range(0, 10), tipo '<class 'range'>'
x = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', tipo '<class 'bytes'>'
x = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'), tipo '<class 'bytearray'>'
x = <memory at 0x0000018D42A91300>, tipo '<class 'memoryview'>'

3.2 - Literais

3.3 - Variáveis

a = 1
b = True
c = "ABC"
print(a,b,c)

1 True ABC

i = None
print(i)
print(type(i))

None
<class 'NoneType'>

x = 5
y = "Alô, mundo!"
print("x = {}, y = {}".format(x,y))

x = 5, y = Alô, mundo!

x = 4         # x é do tipo int
print(x)
x = "Roberto" # x agora é do tipo str
print(x)

4
Roberto

x = 5
y = "John"
print(f"x={x} ({type(x)})")
print(f"y={y} ({type(y)})")

x=5 (<class 'int'>)
y=John (<class 'str'>)

x = str(3)    # x será '3'
y = int(x)    # y será 3
z = float(y)  # z será 3.0
print(f"x={x} ({type(x)})")
print(f"y={y} ({type(y)})")
print(f"z={z} ({type(z)})")

x=3 (<class 'str'>)
y=3 (<class 'int'>)
z=3.0 (<class 'float'>)

x = "Roberto"
# é o mesmo que
y = 'Roberto'
print(x)
print(y)

Roberto
Roberto

x = 4
X = "Roberto"
# X não irá sobrepor x
print("x =",x)
print("X =",X)

x = 4
X = Roberto

3.4 - Tipos de Dados

x = 5
print(type(x))

<class 'int'>

3.5 - Operações, Operandos e Operadores

print(10 + 5)

15

3.6 - Programação Estruturada de Blocos

x = 2
y = 3
print (x + y)

5

a = 10
b = 5
if (a > b):
    c = a / b
    print(c)

2.0

a = 1
b = 2
if (a > b):
    print("a > b")
elif (a < b):
    print("a < b")
else:
    print("a = b")

a < b

a = 10
match a:
    case 1:
        print("a = 1")
    case 2:
        print("a = 2")
    case 3:
        print("a = 3")
    case _:
        print("a não é 1, 2 ou 3")

a não é 1, 2 ou 3

lista = [1,2,3]
for item in lista:
    print(item)

1
2
3

for i in range(10): # de 0 a 9
    print(i)

0
1
2
3
4
5
6
7
8
9

i = 0
while i < 10: # de 0 a 9
    print(i)
    i += 1

0
1
2
3
4
5
6
7
8
9

      x = 5

IndentationError: unexpected indent (<string>, line 1) <traceback object at 0x0000018D43540180>

if 5 > 2:
  print("Cinco é maior que dois!")

Cinco é maior que dois!

if 5 > 2:
print("Cinco é maior que dois!")

IndentationError: expected an indented block after 'if' statement on line 1 (<string>, line 2) <traceback object at 0x0000018D43547AC0>

if 5 > 2:
 print("Um espaço!") # um espaço em branco, no bloco
if 5 > 2:
        print("Oito espaços!") # oito espaços no bloco

Um espaço!
Oito espaços!

if 5 > 2:
 print("Cinco é maior que dois!")
        print("Cinco é maior que dois!")

IndentationError: unexpected indent (<string>, line 3) <traceback object at 0x0000018D427FF8C0>

def funcao_x_local():
    x = 300
    print(x)
#
funcao_x_local()

300

def minha_funcao():
    x = 300
    #
    def minha_funcao_interna():
        print(x)
    #
    minha_funcao_interna()
#
minha_funcao()

300

x = 300
#
def funcao_x_global():
    global x
    print(x)
#
funcao_x_global()

300

x = 300

def minha_funcao():
  x = 200
  print('x dentro da função =', x)

minha_funcao()

print('x fora da função =', x)

x dentro da função = 200
x fora da função = 300

3.7 - Funções nativas do Python

3.8 - Comentários

# Este é um comentário.
print("Alô, mundo!")

Alô, mundo!

# Este é um comentário
print("Alô, mundo!")

Alô, mundo!

print("Alô, mundo!") # Este é um comentário

Alô, mundo!

# print("Alô, mundo!")
print("Abraço, companheiro!")

Abraço, companheiro!

# Este é um comentário
# escrito em
# mais de uma linha
print("Alô, mundo!")

Alô, mundo!

"""
Este é um texto
funcionando como comentário
escrito em mais do que
apenas uma linha
"""
print("Alô, mundo!")

Alô, mundo!

3.9 - Erros Semânticos

# Intenção: Calcular a soma dos números de 1 a 5
total = 0
# Erro: a variável 'contador' está sendo usada no lugar de 'total'
for i in range(1, 6):
    contador = total + i
# Esperado que total seja 15, mas vamos verificar o valor de 'total' e 'contador'
print("Total:", total)  # Saída será 0
print("Contador:", contador)  # Saída será 15

Total: 0
Contador: 5

# Correção: Usar a variável 'total' corretamente para acumular a soma
total = 0
for i in range(1, 6):
    total += i  # Correção: atualizar 'total' diretamente
# Agora 'total' deve ser 15, que é a soma de 1+2+3+4+5
print("Total:", total)  # Saída será 15

Total: 15

idade = 20

# Erro de lógica: a condição deveria verificar se a pessoa é menor de 18 anos
if idade > 18:
    print("Você é menor de idade.")  # Esta mensagem está logicamente incorreta

Você é menor de idade.

idade = 20

# Correção: verificar se a pessoa é menor de 18 anos
if idade < 18:
    print("Você é menor de idade.")
else:
    print("Você é maior de idade.")  # Mensagem correta para quem tem 18 anos ou mais

Você é maior de idade.

numero = 10

# Erro: Uso incorreto do operador lógico
if numero > 1 and numero < 10:
    print("O número está fora do intervalo 1-10.")
else:
    print("O número está dentro do intervalo 1-10.")  # Esta saída é incorreta dado o erro lógico.

O número está dentro do intervalo 1-10.

numero = 10

# Correção: Uso correto do operador OR para verificar se o número está fora do intervalo
if numero < 1 or numero > 10:
    print("O número está fora do intervalo 1-10.")
else:
    print("O número está dentro do intervalo 1-10.")  # Corrigido

O número está dentro do intervalo 1-10.

numeros = [10, -1, 3, -2, 5, -6, 7]

# Tentativa errada de remover números negativos enquanto itera
for numero in numeros:
    if numero < 0:
        numeros.remove(numero)

print(numeros)  # Saída pode não ser o esperado

[10, 3, 5, 7]

numeros = [10, -1, 3, -2, 5, -6, 7]
numeros_positivos = [numero for numero in numeros if numero >= 0]

print(numeros_positivos)  # Saída será [10, 3, 5, 7]

[10, 3, 5, 7]

numeros = [10, -1, 3, -2, 5, -6, 7]

# Iterar sobre uma cópia da lista original
for numero in numeros[:]:  # O fatiamento cria uma cópia da lista
    if numero < 0:
        numeros.remove(numero)

print(numeros)  # Saída será [10, 3, 5, 7]

[10, 3, 5, 7]

def concatenar_elementos(lista):
    resultado = ""
    for elemento in lista:
        resultado += elemento  # Erro: tentando concatenar inteiro com string

lista_de_inteiros = [1, 2, 3, 4, 5]
concatenar_elementos(lista_de_inteiros)  # Isso vai levantar uma exceção TypeError

TypeError: can only concatenate str (not "int") to str <traceback object at 0x0000018D43547440>

def concatenar_elementos(lista):
    resultado = ""
    for elemento in lista:
        resultado += str(elemento)  # Correção: converter elemento para string

lista_de_inteiros = [1, 2, 3, 4, 5]
resultado = concatenar_elementos(lista_de_inteiros)
print(resultado)  # Saída será '12345'

None

numeros = [10, 20, 30, 40, 50]

# Tentativa de acessar um índice que não existe
indice = 5
print(numeros[indice])  # Erro: IndexError, pois não há um elemento no índice 5

IndexError: list index out of range <traceback object at 0x0000018D434CA9C0>

numeros = [10, 20, 30, 40, 50]

indice = 5
if indice < len(numeros):
    print(numeros[indice])
else:
    print("Índice fora de alcance")  # Saída segura que evita o erro

Índice fora de alcance

numeros = [10, 20, 30, 40, 50]

# Uso de slice para evitar IndexError
indice = 5
elemento = numeros[indice:indice+1]  # Retorna uma lista vazia se o índice estiver fora de alcance
print(elemento if elemento else "Índice fora de alcance")  # Saída segura

Índice fora de alcance

def calcular_media(numeros):
    soma = sum(numeros)
    media = soma / len(numeros)
    # Esquecido de retornar o valor da média

# Lista de números
numeros = [10, 20, 30, 40, 50]

# Tentativa de usar o resultado da função
resultado = calcular_media(numeros)
print("A média é:", resultado)  # Saída será "A média é: None"

A média é: None

def calcular_media(numeros):
    soma = sum(numeros)
    media = soma / len(numeros)
    return media  # Correção: incluir retorno do valor calculado

# Lista de números
numeros = [10, 20, 30, 40, 50]

# Usando o resultado da função corretamente
resultado = calcular_media(numeros)
print("A média é:", resultado)  # Saída será "A média é: 30.0"

A média é: 30.0

import pandas as pd

# Criando um DataFrame de exemplo
data = {
    'ID': [1, 2, 2, 3, 4],
    'Valor': [10, 20, 20, 30, 40]
}
df = pd.DataFrame(data)

# Tentativa errada de remover duplicatas
df.drop_duplicates('ID')
print(df)

   ID  Valor
0   1     10
1   2     20
2   2     20
3   3     30
4   4     40

import pandas as pd

# Criando um DataFrame de exemplo
data = {
    'ID': [1, 2, 2, 3, 4],
    'Valor': [10, 20, 20, 30, 40]
}
df = pd.DataFrame(data)

# Correção: removendo duplicatas corretamente
df = df.drop_duplicates(subset='ID')
print(df)

   ID  Valor
0   1     10
1   2     20
3   3     30
4   4     40

import pandas as pd
import numpy as np

# Criando um DataFrame de exemplo
df = pd.DataFrame({
    'Valor': [1, 10, 100, 1000, 10000]
})

# Uso inadequado: usando apply()
df['Log'] = df['Valor'].apply(np.log)

# Uso mais eficiente: operação vetorial
df['Log'] = np.log(df['Valor'])
print(df)

   Valor       Log
0      1  0.000000
1     10  2.302585
2    100  4.605170
3   1000  6.907755
4  10000  9.210340

def calcular_media(numeros):
    if len(numeros) == 0:
        return "Lista vazia, não é possível calcular a média."
    return sum(numeros) / len(numeros)

# Lista de números está vazia
numeros_vazios = []

# Tentativa de calcular a média de uma lista vazia
resultado = calcular_media(numeros_vazios)
print(resultado)  # Saída pode ser um erro se não manuseado corretamente

Lista vazia, não é possível calcular a média.

def calcular_media(numeros):
    if not numeros:  # Verifica se a lista está vazia
        return "Lista vazia, não é possível calcular a média."
    return sum(numeros) / len(numeros)

# Lista de números está vazia
numeros_vazios = []

# Tentativa segura de calcular a média de uma lista vazia
resultado = calcular_media(numeros_vazios)
print(resultado)  # Saída correta sem erro

Lista vazia, não é possível calcular a média.

numero = "10"
incremento = 5

# Erro: tentando somar uma string com um inteiro
resultado = numero + incremento
print(resultado)

TypeError: can only concatenate str (not "int") to str <traceback object at 0x0000018D43547F80>

numero = "10"
incremento = 5

# Correção: converter a string para inteiro antes da soma
resultado = int(numero) + incremento
print(resultado)  # Saída será 15

15

Arduino

Coautor

Betobyte

Autor

Autores