Variaveis, Comentários, print() e input()

Variaveis

A declaração de variaveis em Python é bem simples, basta associar o nome da variavel ao valor desejado, seguindo este modelo:

{NOME_DA_VARIAVEL} = {VALOR}

o nome de uma variavel não deve conter espaços, virgulas ou pontos

veja alguns exemplos no bloco de codigo a seguir:

1nome = "Mirai"
2idade = 17
3linguagem = "Python"
4

Também se é possivel associar varios valores a varias variaveis em uma mesma linha, assim como tambem se é possivel associar variaveis a outras variaveis

1nome, idade = "Mirai", 17
2nome1 = nome
3

Constantes

Em programação, constantes são variaveis que não devem ser alteradas durante o programa, vide o nome, elas são CONSTANTES

uma constante em Python é bem parecida com uma variavel em sua declaração, a unica diferença é que uma constante será sempre toda em MAIUSCULO

1PI = 3.1415
2NUMERO_SEIS = 6
3

Comentários

Os comentários são uma funcionalidade das linguagens de programação, eles são linhas que serão ignoradas na execução do código

em Python, os comentários começam com #, após isso, tudo será ignorado

1# Podemos escrever qualquer coisa que ela não será executada
2nome = "Mirai"  # Os comentários não precisam estar no inicio da linha, mas perceba, mesmo que coloquemos um codigo aqui, ele será ignorado
3

Uma das ultilidades dos comentários é, além de comentar e adicionar informações ao codigo, a de "salvar" um codigo, frequentemente você irá se deparar com a seguinte situação:

"Preciso que este pedaço de codigo não execute, mas não posso apaga-lo pois certamente irei perde-lo, o que devo fazer?"

A resposta é simples, comente o codigo, isso mesmo, adicione # no inicio das linhas, assim o codigo não irá ser executado e você ainda o terá

1# nome = "Mirai"
2

SheBang (Sistemas UNIX)

Esta parte não tem muito a ver com a linguagem, mas você verá este comentário especial na primeira linha de meus scripts então irei explica-lo

os SheBangs são comentários especiais que começam com #! adicionados na primeira linha de um script em sistemas baseados em UNIX (Linux e MacOS)

eles apontam para o executavel a ser usado pelo script, um exemplo seria:

#!/usr/bin/env python3.10 neste SheBang nós usamos o programa env para localizar um executavel para o python3.10, dessa forma asseguramos compatibilidade dentre as plataformas UNIX

print()

As funções em são reconhecidas pela adição de () ao seu final, essas funções, como o nome sugere, performam funções, funcionalidades, ações

a função print() é usada quando queremos mostrar algo ao usuário, um exemplo seria:

1print("Olá Mundo")  # Aqui Mostramos a mensagem "Olá Mundo"
2
3mensagem = "Tambem funciona com variaveis"
4
5print(
6    mensagem
7)  # após temos associado a um valor a variavel `mensagem` nós a exibimos ao usuário
8

Saida
 
Olá Mundo
Tambem funciona com variaveis
 

input()

A função input(), de certa forma é "oposta" a função print(), o input() serve para pegar uma informação do usuário, enquanto a print() serve para exibir

1input()  # ao executar este bloco, o programa irá esperar que o usuário aperte a tecla ENTER para enviar a informação digitada
2input(
3    "Insira seu nome: "
4)  # Ao adicionarmos um texto dentro dos parenteses, este texto será exibido antes do cursor do usuário
5

Saida
 
'Nome Legal'
 

caso nós queiramos guardar as informações providas pelo input(), nós devemos associa-lo a uma variavel

1idade = input("Insira sua idade: ")
2print("Sua idade é: ", idade)
3

Saida
 
Sua idade é:  99
 

Pequena curiosidade

nós podemos associar funções a variaveis, e usar as variaveis ao invés da função (mas isso não é recomendado por ser extremamente desnecessario)

exemplo:

1imprimir = print
2
3imprimir("Olá mundo")
4

Saida
 
Olá mundo
 

Tipos de Dado

O que é um Dado?

Dado é tudo aquilo que guarda informação, ou seja, um numero, um texto, Verdadeiro ou Falso, uma letra, qualquer coisa que seja informação

Eles são divididos entre Primitivos (ou Simples, ou Básicos) e Compostos (ou Agrupados, ou Complexos)

Dados Primitivos

Dados Primitivos guardam apenas uma informação, ou seja, um numero, um texto, um Verdadeiro

Eles são divididos em 3 tipos:

• Strings (str)
• Integers e Floats (int & float)
• Booleans (bool)

String (Textos)

Declaração

As Strings representam os textos, sua declaração é feita através de aspas duplas ("") ou unicas ('')

1nome = "Mirai"
2linguagem = "Python"
3print(nome, linguagem)
4

Saida
 
Mirai Python
 

Nós não podemos misturar as aspas, isto é, começar uma declaração com aspas duplas ("") e terminar com aspas unicas ('')

nós podemos dentro da string usar a aspa que não foi usada durante a declaração, isto se torna util em texto em Ingles

1apresentacao = "Hi, my name is Mirai, I'm a Developer"  # Note o uso das aspas unicas dentro da string
2citacao = 'Pois então ela disse, "Não se dirija mais a mim"...'  # Note o uso das aspas duplas dentro da string
3
4# repare que envolta do texto usamos o mesmo tipo de aspas
5print(apresentacao, citacao)
6

Saida
 
Hi, my name is Mirai, I'm a Developer Pois então ela disse, "Não se dirija mais a mim"...
 

porém, nos podemos sim usar o mesmo tipo de aspas dentro e fora da string, basta ultilizarmos o caractere de escapagem (\)

1apresentacao = "Hi, my name is Mirai, I'm a Developer"
2citacao = 'Pois então ela disse, "Não se dirija mais a mim"...'
3print(apresentacao, citacao)
4

Saida
 
Hi, my name is Mirai, I'm a Developer Pois então ela disse, "Não se dirija mais a mim"...
 

Multi-Line

Tambem temos as "Multi-line Strings", elas são declaradas através de 3 aspas, sejam elas unicas ou duplas, elas são textos que se espalham por multiplas linhas, preservando espaços

1multi_line1 = """Olá, eu sou um texto de multiplas linhasl, eu fui declarado usando aspas duplas \"\"
2
3  eu preservo os espaços
4
5    eba
6"""
7
8multi_line2 = """Olá, eu sou um texto de multiplas linhas, eu fui declarado usando aspas unicas \'\'
9
10  eu preservo os espaços
11
12    eba
13"""
14
15print(multi_line1)
16print(multi_line2)
17

Saida
 
Olá, eu sou um texto de multiplas linhasl, eu fui declarado usando aspas duplas ""

  eu preservo os espaços

    eba

Olá, eu sou um texto de multiplas linhas, eu fui declarado usando aspas unicas ''

  eu preservo os espaços

    eba
 

fStrings (Formatted Strings)

as fStrings, são strings formatadas, isto é, strings que contém codigo, sua declaração é feita adicionando um f a frente das aspas, e envolvendo os codigos em chaves {}

1nome = "Mirai"
2linguagem = "Python"
3idade = 17
4apresentacao = (
5    f"Olá, meu nome é {nome}, eu tenho {idade} anos e sei programar em {linguagem}"
6)
7print(apresentacao)
8

Saida
 
Olá, meu nome é Mirai, eu tenho 17 anos e sei programar em Python
 

eu disse codigo, pois podemos adicionar coisas além de variaveis, como funções, operações aritmeticas, metodos, etc...

Eis aqui um exemplo:

1nome = "Mirai"
2linguagem = "Python"
3idade = 17
4apresentacao = f"Olá, meu nome é {nome.upper()}, eu nasci em {2022 - idade} e sei programar em {linguagem}"
5print(apresentacao)
6

Saida
 
Olá, meu nome é MIRAI, eu nasci em 2005 e sei programar em Python
 

As fStrings, podem ser misturadas com as Multi-Line strings, basta adicionar um f a frente

elas tambem podem ser feitas através do string.format(), este metodo pega os argumentos providos e substutui nos espaços reservados em chaves {}

1apresentacao = "Olá, meu nome é {}, eu nasci em {} e sei programar em {}"
2nome = "Mirai"
3linguagem = "Python"
4idade = 17
5print(apresentacao.format(nome, 2022 - idade, linguagem))
6

Saida
 
Olá, meu nome é Mirai, eu nasci em 2005 e sei programar em Python
 

Concatenação

Concatenação é o ato de juntar duas Strings, veja o mesmo exemplo anterior porém concatenado

1nome = "Mirai"
2linguagem = "Python"
3idade = 17
4apresentacao = (
5    "Olá, meu nome é "
6    + nome
7    + ", eu tenho "
8    + str(idade)
9    + " anos e sei programar em "
10    + linguagem
11)
12print(apresentacao)
13

Saida
 
Olá, meu nome é Mirai, eu tenho 17 anos e sei programar em Python
 

Note que nós devemos fazer a devida conversão para o tipo string (str), e devemos manejar os espaços manualmente, o que pode ser deveras entediante

Numeros (Ints & Floats) e Operações Aritméticas

Ints

INTs, Integers ou Integros, são quaisquer numeros inteiros, eles são passiveis de operações aritmeticas

1idade = 17
2ano_de_nascimento = 2005
3ano_atual = 2022
4print(type(idade))
5

Saida
 
<class 'int'>
 

Floats

FLOATs, Floating Point Numbers ou Numeros de Pontos Flutuantes, são quaisquer numeros com casas decimais, ou um ponto (.) em sua declaração

1PI = 3.1415
2print(type(PI))
3

Saida
 
<class 'float'>
 

Operações Aritméticas

Em Python se é possivel exercer operações aritméticas, eis aqui uma lista das possiveis operações

• + -> soma
• - -> subtração
• ** -> potencia
• * -> mutiplicação
• / -> divisão
• // -> "divisão verdadeira"
• % -> modulo

Python segue sua própria ordem de precedencia baseada nos metodos BODMAS e PEMDAS, eis aqui sua ordem:

• 1 - Parenteses () -> em sequencia, ou seja, externos primeiro
• 2 - Exponenciação, -> **
• 4 - Mutilicativos, -> *, @
• 5 - Divisivos, -> /, // e %
• 6 - Adição -> +
• 7 - Subtração -> -

As operações aritméticas são as mesmas aprendidas na escola, porém irei ressaltar 3, divisão, "divisão verdadeira" e modulo

Divisão

Em Python uma Divisão sempre resultará em um float, mesmo que o resultado seja inteiro:

1print(4 / 2, type(4 / 2))
2print(1 / 3, type(1 / 3))
3

Saida
 
2.0 <class 'float'>
0.3333333333333333 <class 'float'>
 

Isso pode te levar a problemas caso necessite de um numero de tipo int, para isso se existe a "Divisão Verdadeira"

"Divisão Verdadeira"

A "divisão verdadeira" também é conhecida como "divisão arredondada" ou "divisão exclusiva", é uma operação de divisão que converte o resultado para Int

o que ela essencialmente faz é cortar os numeros após o ponto, "arredondando" assim o numero

1print(4 // 2, type(4 // 2))
2print(1 // 3, type(1 // 3))
3

Saida
 
2 <class 'int'>
0 <class 'int'>
 

Problemas com Numeros de Ponto Flutuante

Bit Overflow

Qual o resultado da soma 0.1 + 0.2?

Caso você performe a soma em uma calculadora o resultado será 0.3, mas observe esta mesma operação em Python

1print(0.1 + 0.2)
2

Saida
 
0.30000000000000004
 

observe que o resultado é 0.30000000000000004 ao invés de apenas 0.3, isto ocorre devido a forma como os numeros de ponto flutuante são convertidos para binário, e devido ao espaço alocado na memoria, nós temos um overflow de bits

esse problema ocorre pois a parte fracionaria de um Float tem um tamanho pré-definido

quando chegamos ao fim desse tamanho e a operação não for solucionada, se existirá uma sobrecarga de bits, que por ventura culminará no numero 4 ao final da cadeia

Performance

os numeros de pontos flutuantes são "menos eficientes" que os numeros integros devido a forma que eles são guardados na memória

a parte inteira se localiza em um endereço, e a parte fracionária (decimal) se localiza em outra, ou seja, para performar operações o sistema deve navegar a varios endereços o que culmina num aumento do tempo de resposta, porém, vale ressaltar que este tempo só se torna perceptivel caso você tenha operações na casa das milhares, (3 milhoes de calculos, 19 milhoes de calculos, etc...) pois essa diferença de performance é na ordem dos nanosegundos

Boolean

O Boolano é o tipo de dado Binário, só pode ter 2 valores, Verdadeiro (True) ou Falso (False)

ele é bastante usado para controlar o Flow do programa através de ifs e whiles

os valores boleanos são dividos em 2 categorias, Verdadeiros e Falsos

• Verdadeiros:
  • True
  • qualquer string que não esteja vazia
  • qualquer numero diferente de 0
  • qualquer outro tipo de dado que não esteja vazio
• Falsos:
  • False
  • Strings vazias ("" ou '')
  • 0
  • qualquer outro tipo de dado vazio

Operadores Lógicos

esses operadores são usados em conjunto dos booleanos, são 3, and, or, not

o and, retorna True caso todos os valores sejam verdadeiros

1print(True and True)
2print(True and False)
3print(False and True)
4print(False and False)
5

Saida
 
True
False
False
False
 

o or retorna True caso um dos valores seja Verdadeiro, ou seja, só retorna Falso caso ambos os valores sejam falsos, informalmente dizendo, podemos presumir que ele exerce o oposto do and

1print(True or True)
2print(True or False)
3print(False or True)
4print(False or False)
5

Saida
 
True
True
True
False
 

o not é o mais simples de todos, ele inverte o valor

1print(not False)
2print(not True)
3

Saida
 
True
False
 

Curto Circuito

o curto circuito em operadores lógicos é uma pratica onde você ordena os valores para que a decisão seja tomada mais rapida

por exemplo, com o and, se você tem algum valor que provavelmente retornará False, o colocar na frente o dará performance, pois o Python irá ignorar o resto da expressão pois o and só retorna True caso TODOS os valores sejam verdadeiros

com o or, se é exatamente o oposto, colocamos um valor que provavelmente retornará True na frente, pois assim a expressão já é validada, retornando True, e o Python por sua vez irá ignorar o resto da expressão, pois o or retorna True caso um dos valores seja verdadeiro

Curiosidades

pequenas curiosidades sobre alguns tipos básicos

Floats

nos floats nós podemos converter as string inf e NaN (Not a Number), para números, sendo inf a representação de um numero infinito e NaN a representação de algo que não é um numero.

1snan = "NaN"
2fnan = float(snan)
3print(fnan, type(fnan))
4
5sinf = "inf"
6finf = float(sinf)
7print(finf, type(finf))
8

Saida
 
nan <class 'float'>
inf <class 'float'>
 

Strings

As string são muito mais que apenas simples textos, elas contem uma serie de operadores especiais, são divididos em 5 grupos:

• Prefixos
• Sequencias de escapagem
• Templates
• Conversores
• Especificações da Mini-linguagem de formatação
• Depuração e padrão printf

Prefixos

os prefixos são os seguintes:

• r ou R -> raw strings (rString)
• u ou U -> unicode strings (uString)
• f ou F -> format strings (fString)
• fr ou Fr ou fR ou FR ou rf ou rF ou Rf ou RF -> raw-format strings (frString ou rfString)

raw strings: não escapam nenhum caractere

1raw_string = r"Uma String\nLiteral com os\tcaracteres de escapagem\r"
2print(raw_string)
3

Saida
 
Uma String\nLiteral com os\tcaracteres de escapagem\r
 

unicode strings: aceitam escapagens de caracteres unicode

1unicode_string = "Runic F: \u5792"
2print(unicode_string)
3

Saida
 
Runic F: 垒
 

format strings: aceitam formatação de código

1format_string = f"2 + 2 = {2 + 2}"
2print(format_string)
3

Saida
 
2 + 2 = 4
 

raw-format strings: a união entre format strings e raw strings

1raw_format_string = rf"2 * 2 =\t{2 * 2}"
2print(raw_format_string)
3

Saida
 
2 * 2 =\t4
 

Sequencias de escapagem

caso não seja uma rString, esses são os caracteres de escape permitidos:

NOTA: o \uXXXX só funciona caso seja uma uString

1print("\tTab\nNewline")
2uString = "Runic Ior: \u16E1"
3print(uString)
4

Saida
 
	Tab
Newline
Runic Ior: ᛡ
 

Templates

Template strings são strings que usam $ para definir locais de substituição, para usa-las você deve importar a classe Template do modulo string, você verá mais sobre modulos e classes no futuro.

1from string import Template
2
3template_string = Template("Olá meu nome é $nome, e eu estou ${acao}ndo")
4print(template_string.substitute(nome="Mirai", acao="Programa"))
5

Saida
 
Olá meu nome é Mirai, e eu estou Programando
 

Conversores

os conversores são mais usados em processos de depuração, eles começam com !, são 3 conversores:

• !a -> Representação ascii
• !r -> o equivalente a repr()
• !s -> o equivalente a str()

1variavel = "Runic Ior: ᛡ"
2conversor_a = f"{variavel!a}"
3conversor_r = f"{variavel!r}"
4conversor_s = f"{variavel!s}"
5
6print(f"Conversor !a:\t{conversor_a}")
7print(f"Conversor !r:\t{conversor_r}")
8print(f"Conversor !s:\t{conversor_s}")
9

Saida
 
Conversor !a:	'Runic Ior: \u16e1'
Conversor !r:	'Runic Ior: ᛡ'
Conversor !s:	Runic Ior: ᛡ
 

Especificações da Mini-linguagem de formatação

O Python contém uma mini-linguagem de formatação de strings, ela nos permite converter, alinhar, definir a precisão e separar.

a o padrão de formatação geral é o seguinte:

1especificação   ::=  [[preenchimento]alinhamento][sinal][#][0][largura][agrupamento][.precisão][tipo]
2preenchimento   ::=  <qualquer caractere>
3alinhamento     ::=  "<" | ">" | "=" | "^"
4sinal           ::=  "+" | "-" | " "
5largura         ::=  digito+
6agrupamento     ::=  "_" | ","
7precisão        ::=  digito+
8tipo            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
9

eles começam com :, eis aqui uma lista:

Opções de Alinhamento:

Opções de Sinalização:

Alternadores e Separadores:

O # (alternador) especifica que a forma alternativa deve ser usada na conversão, a forma alternativa é especificada de acordo com o tipo. Ela só é valida para numeros inteiros (ints), decimais (floats) e complexos (complex).

para ints que usam as formatações hexadecimal, binária ou octal os prefixos Ox ou 0X, 0b e 0o são usadas.

para floats e numeros complexos, o alternador especifica que a conversão sempre deve conter as casas decimais, em adição ao 'g' e 'G', zeros insignificantes não são removidos.

Representações de Strings:

Representações de Ints:

Representações de Floats:

1int_num = 78
2float_num = 3.14151617181920212223242526272829
3big_int = 1234567890987656543211
4string = "essa é uma string"
5
6print(f"int ({int_num})\tb:\t\t{int_num:b}")
7print(f"int ({int_num})\tc:\t\t{int_num:c}")
8print(f"int ({int_num})\tX:\t\t{int_num:X}")
9
10print(f"big_int\t\t(,):\t\t{big_int:,}")
11print(f"big_int\t\t(_):\t\t{big_int:_}")
12
13print(f"float\t\t.2f:\t\t{float_num:.2f}")
14print(f"float\t\t2%:\t\t{float_num:.4%}")
15print(f"float\t\tg:\t\t{float_num:.5g}")
16
17print(f"string \t\t(esquerda):\t{string:-<32}")
18print(f"string \t\t(centro):\t{string:-^32}")
19print(f"string \t\t(direita):\t{string:->32}")
20

Saida
 
int (78)	b:		1001110
int (78)	c:		N
int (78)	X:		4E
big_int		(,):		1,234,567,890,987,656,543,211
big_int		(_):		1_234_567_890_987_656_543_211
float		.2f:		3.14
float		2%:		314.1516%
float		g:		3.1415
string 		(esquerda):	essa é uma string---------------
string 		(centro):	-------essa é uma string--------
string 		(direita):	---------------essa é uma string
 

Depuração e padrão printf

em uma fString, se nós colocarmos um = a direita da variavel, exibimos o nome da variavel junto ao valor, isso é util para depurações, se nos colocarmos espaços, a saida ficará espaçada também.

1verdade_universal = 42
2
3print(f"{verdade_universal=}")
4print(f"{verdade_universal = }")
5print(f"{verdade_universal= }")
6print(f"{verdade_universal =}")
7

Saida
 
verdade_universal=42
verdade_universal = 42
verdade_universal= 42
verdade_universal =42
 

o padrão printf de formatação nos permite fazer fStrings como em C, os tipos devem ser precedidas de %, e nós devemos modular por uma tuple contendo as variaveis, você verá mais sobre tuples a frente, aqui vai a lista:

modificadores:

1nome = "Mirai"
2idade = 17
3
4texto = "meu nome é %s e eu tenho %+04d anos"
5
6print(texto % (nome, idade))
7

Saida
 
meu nome é Mirai e eu tenho +017 anos
 

Tipos Compostos

Os tipos compostos são aqueles que contem mais de um Dado

eles são os seguintes:

• Tuples
• Listas
• Sets
• Dicionarios

Mutabilidade

A Mutabilidade define a capacidade de um tipo ser alterado sem que se seja criado um novo, exemplo:

Listas são mutaveis, pois nós podemos adicionar ou remover elementos sem criar uma lista nova

Tuples são imutaveis pois para podermos adicionar um novo elemento nós devemos criar uma nova

Tuples

As Tuples são imutaveis, elas são comumente usadas na declaração de multiplas variaveis, para declara uma tuple nós podemos fazer de duas formas:

forma 1:

• usamos parenteses ()

1tulipa1 = ("eba", "uma", "tuple")
2print(tulipa1, type(tulipa1))
3

Saida
 
('eba', 'uma', 'tuple') <class 'tuple'>
 

forma 2:

• nas tuples nós podemos omitir o parenteses, apenas separando os argumentos por virgula ,

1tulipa2 = "eba", "mais", "uma", "tuple"
2print(tulipa2, type(tulipa2))
3

Saida
 
('eba', 'mais', 'uma', 'tuple') <class 'tuple'>
 

Para adicionarmos ou removermos elementos de uma tuple nós devemos criar uma nova

1x, y = 1, 2  # uma tuple com 2 valores
2z = 7  # valor que iremos adicionar
3tulipa_nova = x, +y, +z
4print(tulipa_nova, type(tulipa_nova))
5

Saida
 
(1, 2, 7) <class 'tuple'>
 

Listas

Diferente das Tuples, as listas já podem ser alteradas, para declararmos uma lista nós usamos []

1amigos = ["amigo1", "amigo2", "amigo3"]
2print(amigos, type(amigos))
3

Saida
 
['amigo1', 'amigo2', 'amigo3'] <class 'list'>
 

para obtermos um item especifico nós usamos um index iniciado em 0

é simples, basta fazer nome_da_lista[index], e as listas começam pelo 0, ou seja, o primeiro valor é 0, o segundo é 1, o terceiro é 2 e assim por diante

caso nós coloquemos um sinal negativo a frente do index, a lista será invertida, -1 se torna o ultimo, -2 o penultimo, -3 o antepenultimo e assim por diante

eis aqui um exemplo:

1amigos = ["amigo1", "amigo2", "amigo3"]
2print(amigos, type(amigos))
3print(amigos[0], type(amigos[0]))  # mostraremos o amigo1
4print(amigos[2], type(amigos[1]))  # mostraremos o amigo2
5print(amigos[1], type(amigos[2]))  # mostraremos o amigo3
6print(amigos[-3], type(amigos[-3]))  # mostraremos o amigo1
7print(amigos[-2], type(amigos[-2]))  # mostraremos o amigo2
8print(amigos[-1], type(amigos[-1]))  # mostraremos o amigo3
9

Saida
 
['amigo1', 'amigo2', 'amigo3'] <class 'list'>
amigo1 <class 'str'>
amigo3 <class 'str'>
amigo2 <class 'str'>
amigo1 <class 'str'>
amigo2 <class 'str'>
amigo3 <class 'str'>
 

para adicionarmos um item a uma lista nós usamos o metodo append, sua sintaxe é:

lista.append(item), este metodo sempre adicionará o item ao final da lista

1amigos = ["amigo1", "amigo2", "amigo3"]
2print(amigos, type(amigos))
3amigos.append("amigo4")
4print(amigos, type(amigos))
5

Saida
 
['amigo1', 'amigo2', 'amigo3'] <class 'list'>
['amigo1', 'amigo2', 'amigo3', 'amigo4'] <class 'list'>
 

para adicionarmos um item em uma posição especifica nós usamos lista.insert(index, item)

1amigos = ["amigo1", "amigo2", "amigo3"]
2print(amigos, type(amigos))
3amigos.insert(1, "amigo4")  # iremos adicionar o amigo4 na segunda posição
4print(amigos, type(amigos))
5

Saida
 
['amigo1', 'amigo2', 'amigo3'] <class 'list'>
['amigo1', 'amigo4', 'amigo2', 'amigo3'] <class 'list'>
 

para removermos um item, nós temos lista.pop() e lista.remove(item)

o metodo lista.pop() remove o ultimo item, ou em um index especificado lista.pop(index)

o metodo lista.remove(item) remove o item especificado

1amigos = ["amigo1", "amigo2", "amigo3"]
2print(amigos, type(amigos))
3amigos.pop()
4print(amigos, type(amigos))
5amigos.remove("amigo1")
6print(amigos, type(amigos))
7

Saida
 
['amigo1', 'amigo2', 'amigo3'] <class 'list'>
['amigo1', 'amigo2'] <class 'list'>
['amigo2'] <class 'list'>
 

Matrizes (Lista Multi-Dimensional)

Caso você se depare na situação de ter que criar uma matiz, em python isso pode ser feito através de listas multi-dimensionais

1matriz = [
2    # X  0  1  2      Y
3    [1, 2, 3],  # 0
4    [4, 5, 6],  # 1
5    [7, 8, 9],  # 2
6]
7print(matriz, type(matriz))
8# Eixos:     Y  X
9print(matriz[0][0])
10print(matriz[2][1])
11

Saida
 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] <class 'list'>
1
8
 

Sets (Conjuntos)

Sets são essencialmente conjuntos, são declarados através das chaves {}.

Eles tem 2 caracteristicas peculiares:

• não tem ordem
• não possuem valores repetidos

irei começar pela ordem, tomaremos como exemplo um set com 3 nomes.

1set_nomes = {"Joaquim", "Mirai", "Maria"}
2print(set_nomes)
3

Saida
 
{'Mirai', 'Maria', 'Joaquim'}
 

perceba que quando eu executei o código em minha máquina, o resultado foi {'Mirai', 'Maria', 'Joaquim'}, mesmo com a declaração sendo {'Joaquim', 'Mirai', 'Maria'}, isso ocorre porque os sets não tem ordem nenhuma, ou seja, se rodarmos denovo, teremos outra ordem.

agora vamos aos valores, suponha novamente um set de nomes, porém agora com mais pessoas.

1set_nome_pessoas = {"Mirai", "Maria", "Ana", "José", "Joaquim", "Maria"}
2print(set_nome_pessoas)
3

Saida
 
{'Maria', 'Mirai', 'José', 'Ana', 'Joaquim'}
 

perceba que mesmo com nós especificando duas 'Maria's no codigo, só exibimos uma, isso ocorre pois os sets excluem todos os valores repetidos.

agora vamos as operações elas são:

• set.add() -> adiciona elementos ao set
• set.remove() -> remove elementos do set
• set.difference() -> retorna a diferença entre sets
• set.symmetric_difference() -> retorna todos os itens que não estão na interseção
• set.intersection() -> retorna a intersceção dos sets
• set.union() -> retorna a união dos sets

1estudantes_matematica = {"aluno1", "aluno2", "aluno2", "aluno3", "aluno4", "aluno5"}
2
3estudantes_portugues = {"aluno6", "aluno2", "aluno3", "aluno7", "aluno8"}
4
5estudantes_matematica.add("aluno9")
6print(f"ADD:\t\t\t{estudantes_matematica}")
7estudantes_matematica.remove("aluno5")
8print(f"REMOVE:\t\t\t{estudantes_matematica}")
9print(f"DIFFERENCE:\t\t{estudantes_portugues.difference(estudantes_matematica)}")
10print(
11    f"SYMMETRIC_DIFFERENCE:\t{estudantes_portugues.symmetric_difference(estudantes_matematica)}"
12)
13print(f"INTERSECTION:\t\t{estudantes_matematica.intersection(estudantes_portugues)}")
14print(f"UNION:\t\t\t{estudantes_matematica.union(estudantes_portugues)}")
15

Saida
 
ADD:			{'aluno1', 'aluno2', 'aluno4', 'aluno3', 'aluno5', 'aluno9'}
REMOVE:			{'aluno1', 'aluno2', 'aluno4', 'aluno3', 'aluno9'}
DIFFERENCE:		{'aluno7', 'aluno6', 'aluno8'}
SYMMETRIC_DIFFERENCE:	{'aluno1', 'aluno6', 'aluno4', 'aluno7', 'aluno8', 'aluno9'}
INTERSECTION:		{'aluno2', 'aluno3'}
UNION:			{'aluno2', 'aluno4', 'aluno7', 'aluno8', 'aluno1', 'aluno6', 'aluno3', 'aluno9'}
 

Dicionários

Dicionários são listas com chave:valor, onde o valor pode ter um indentificador nomeado chamado chave

a declaração de um dicionário é feita da seguinte forma:

1valor1, valor2, chave1, chave2 = "valor1", "valor2", "chave1", "chave2"
2
3dicionario = {chave1: valor1, chave2: valor2}
4print(dicionario, type(dicionario))
5

Saida
 
{'chave1': 'valor1', 'chave2': 'valor2'} <class 'dict'>
 

para fins de conveniencia e legibilidade, nós dividimos o dicionario entre linhas, ficando desta forma

1valor1, valor2, chave1, chave2 = "valor1", "valor2", "chave1", "chave2"
2
3dicionario = {chave1: valor1, chave2: valor2}
4print(dicionario, type(dicionario))
5

Saida
 
{'chave1': 'valor1', 'chave2': 'valor2'} <class 'dict'>
 

para acessarmos um valor especifico nós usamos sua chave, desta forma dicionario[chave]

1valor1, valor2, chave1, chave2 = "valor1", "valor2", "chave1", "chave2"
2
3dicionario = {chave1: valor1, chave2: valor2}
4print(dicionario[chave1], type(dicionario[chave1]))
5

Saida
 
valor1 <class 'str'>
 

para adicionarmos um valor, ou reassociarmos um valor, basta por dicionario[chave]=novo_valor

1valor1, valor2, valor3 = "valor1", "valor2", "valor3"
2chave1, chave2, chave3 = "chave1", "chave2", "chave3"
3
4dicionario = {chave1: valor1, chave2: valor2}
5
6dicionario[chave3] = valor3
7dicionario[chave1] = valor2
8print(dicionario[chave3], type(dicionario[chave3]))
9print(dicionario[chave1], type(dicionario[chave1]))
10

Saida
 
valor3 <class 'str'>
valor2 <class 'str'>
 

Conversão e Coerção

Um topico relativamente simples, ele consiste em alterar o tipo de um dado, por exemplo:

string -> int

Conversão

Conversão é quando essa alteração é explicita no codigo, por exemplo:

1x = 3
2print(x, type(x))
3y = str(x)  # converte 3 int em "3" string
4print(y, type(y))
5

Saida
 
3 <class 'int'>
3 <class 'str'>
 

existem funções especificas para isso, eis a lista:

• str() -> converte para string
• int() -> converte para int
• float() -> converte para float
• bool() -> converte para booleano
• tuple() -> converte para tuple
• list() -> converte para lista
• set() -> converte para set
• dict() -> converte para dicionario

Coerção

ocorre quando a conversão é implicita, ou seja, você não define expecificamente.

ela ocorrem em flows outros tipos de flow (ifs, whiles, etc..., veremos mais a frente)

sum() & len()

sum() é uma função nativa do python que retorna a soma de todos os valores de um objeto iteravel, ou seja, listas, dicionarios, sets e tuples

len() é uma função nativa do python que retorna o comprimento de um objeto iteravel, ou seja, listas, dicionarios, sets e tuples

seu uso principal seria para calcular médias, pois uma média é dada através da soma de todos os valores dividos pela quantidade de valores