Resumo de Computação

Tipos de dados:
Na linguagem Python, pode-se trabalhar com alguns tipos de dados,
como:
• Numéricos:
Inteiros (int) → (-1, -2, 0, 3, 4, 5)
Números com casas decimais (float) → (1.2, -1.555445, –0.210210)
Complexos (complex) → (2j, 5 + 2j)

Funções matemáticas integradas (math):

Função Chamada Legenda Retorno
2
sqrt >>>math.sqrt(81) √81 9
ceil >>>math.ceil(5+5.5) inteiro maior 11
floor >>>math.floor(5+5.5) inteiro menor 10
pow >>>math.pow(9,2) 92 81
sin >>>math.sin(0) sen0º 0.0
cos >>>math.cos(0) cos0º 1.0
tan >>>math.tan(0) tan0º 0.0
degrees >>>math.degrees(1) rad→graus 0.0174533
radians >>>math.radians(1) graus→rad 57.2958
pi >>>math.pi 𝜋 3.14159
min >>>min(1,5,8,3,6,2) menor valor 1
max >>>max(1,5,8,3,6,2) maior valor 8
abs >>>abs(-2) / (9) valor absoluto 2/9
sum >>>sum((11,4,5)) soma 20
type >>>type(‘’)/([]) tipo de dado <class ‘str’/list>
round >>>round(3.14159,2) arredonda 3.14

• String (str):
A string é um tipo de dados imutável que é uma sequência de caracteres,
ou seja, é uma cadeia ordenada de caracteres, podendo ter qualquer
símbolo, como: letra, número, @, !, acentos etc.
→ É colocada entre aspas:
>>>nome = “Rickzinho”
Isso significa que a variável >nome<, que é um espaço na memória
RAM para armazenar uma informação, está armazenando a informação
“Rickzinho”
 Cada símbolo dentro da string é colocado em uma posição dentro de
nome, que funciona como uma caixa com “setores”
>>> len(nome) = 9
string R i c k z i n h o
>>> nome[0] = “R”
índice 0 1 2 3 4 5 6 7 8
Operações:
→Concatenação de strings (+): →Outras possibilidades:
>>> ‘a’ + ‘b’ >>> int(‘11’)+3
‘ab’ 14
→Autoconcatenação sucessiva >>> ‘11’+str(3)
de uma string (*): ‘113’
>>> ‘olá’*3 >>> ('oi'*3) + ', tudo bem?'
‘oláoláolá’ 'oioioi, tudo bem?'

Fatiamento:
>>>cor= ‘amarelo’ >>>substring = cor [0:4]
>>>len(cor) >>>substring
7 ‘amar’

Função Chamada Retorno

len >>>len(‘tartaruga’) 9
upper >>>str.upper(’cachorro’) ‘CACHORRO’
lower >>>str.lower(‘GATO’) ‘gato’
count >>>str.count(‘calopsita’,’a’) 2
index >>>str.index(‘barata’,’t’) 4
find >>>str.find(‘guepardo’,’f’) 0
replace >>>str.replace(‘leão’, ‘e’, ‘i’) ‘lião’
strip >>>str.strip (‘macaco’,’m’) ‘acaco’
partition >>>str.partition(‘mosquito’, ‘qui’) ('mos', 'qui', 'to')
split >>>str.split(‘golfinho’,’f’) [‘gol’, ‘inho’]
join >>>str.join('o',['2 c','rv','s']) ‘2 corvos’
capitalize >>>str.capitalize(‘papagaio’) ‘Papagaio’
startswith >>>str.startswith(‘hiena’,’h’) True
endswith >>>str.endswith(‘sapo’,’o’) True
swapcase >>>str.swapcase(‘maMutE’) ‘MAmUTe’
zfill >>>str.zfill(‘7’,3) ‘007’
isalpha >>>str.isalpha(‘3 pratos’)/(‘tigre’) False/True
isdecimal >>>str.isdecimal(‘14’) True
isdigit >>>str.isdigit(‘123’)/(‘3.9’) True/ False
• Booleanos (bool):
São expressões compostas por valores que podem ser de diversos tipos
de dados, onde o resultado da expressão é True (1) ou False (0) (‘T’ e ‘F’
sempre maiúsculos).
→ Operadores Relacionais: > (maior), < (menor), == (igual), != (diferente),
>= (maior ou igual), <= (menor ou igual). Chamada Retorno
>>> 2 > 5 False
⚠ X==Y: Compara se X é igual a Y. >>> 3 <= 3.14 True
⚠ X=Y: Atribui o valor de Y a X. >>> 0 + 0j != 0 False
>>> 2 == float(‘2’) True
>>> ‘Rato’ == ‘rato’ False
Quando confundido com o operador de >>> ‘baleia’ != ‘Baleia’ True
atribuição, ocorrerá um erro de sintaxe na >>> 123 = 456 SyntaxError
execução do código. >>> True = False SyntaxError

→ Operadores Lógicos: not (negação), and (e), or (ou).

not: Inverte o valor lógico de uma expressão
and: Retorna True se ambos forem True, caso contrário, False.
or: Retorna True se pelo menos um deles for True.

→ Operadores de Identidade: is (é), is not (não é). >>> x=y=2

is: Retorna True se ambos forem iguais, caso contrário, False. >>> x is y
is not: Retorna True se ambos não forem iguais, caso contrário, True
False.

→ Operadores de Identidade: in (está), not in (não está). >>> x=2

in: Retorna True se o valor especificado estiver presente em >>> y=3
um objeto, caso contrário, False. >>> z=(x,y)
not in: Retorna True se o valor especificado estiver presente >>> x in z
em um objeto, caso contrário, False. True
~~Objeto é uma referência a um local da memória que possui um valor. >>> x not in z
Um objeto pode ser uma variável, função, ou estrutura de dados~~ False

→ Operadores Condicionais: if (se), else (caso contrário), elif (se caso

contrário).
if: comandos executados caso a expressão seja verdadeira.
elif: comandos executados caso o if seja falso.
else: comandos executados caso if ou elif seja falso.
 def condicionais (x,y): >>>condicionais (2,4)
if x > y:
'2 é menor que 4'
return str(x) + 'é maior que ' + str(y)
elif x < y: >>> condicionais (2,1)
return str(x) + 'é menor que ' + str(y) '2 é maior que 1'
else: >>> condicionais (2,2)
return str(x) + 'é igual a ' + str(y) '2 é igual a 2'

• Listas (list):
Lista é uma estrutura de dados que serve para armazenar uma série de
valores, podendo variar o tipo de dado dentro da lista, são usados os
colchetes para armazenar os elementos.
>>>lista = [1,2,3,4,5]
Como na string, também pode-se acessar o item por meio do índice,
começando do 0.
lista[0] = 1 lista 1 2 3 4 5
lista[1] = 2
índice 0 1 2 3 4
lista[2] = 3
…
No caso das listas, pode-se mudar os valores dentro dela, diferentemente
da string.
>>>lista[0] = 10
Agora, o elemento na posição 0 vale 10, e não 1, então:
>>>lista = [10,2,3,4,5]
Exemplo:
>>>lista2 = [“Meg”, 3j, 3.0, (“Fred”), [“Zeus”,”Taz”], 2]
>>>lista3 = [-1,3j]
Função Entrada Retorno
append >>>list.append(lista3, ‘oi’) lista3 = [-1, 3j,’oi’]
extend >>>list.extend(lista3, [‘eca’]) lista3 = [-1, 3j,’eca’]
insert >>>list.insert(lista3,1,9) lista3 = [-1, 9, 3j]
remove >>>list.remove(lista3, 3j) lista3 = [-1]
del >>>del(lista3[0]) lista3 = [3j]
pop >>>list.pop(lista3,1) 3j / lista3 = [-1]
clear >>>list.clear(lista3) lista3 = []
count >>>list.count(lista3, 3j) 1
index >>>list,index(lista3, -1) 0
in >>>3j in lista3/ 9 in lista3 True/ False
reverse >>>list.reverse(lista3) lista3 = [3j,-1]
sort >>>list.sort(lista) lista = [2, 3, 4, 5, 10]
 • Tuplas (tuple):
A tupla é muito parecida com a lista, podendo conter qualquer tipo de
dado dentro da lista, porém, seus dados são imutáveis, não se pode alterar
os valores depois de tê-la declarada. É representada por parênteses.
>>>tupla = (1,2,3,4)
Também são acessadas por índices numéricos inteiros, sendo cada índice,
um item da tupla.
tupla[0] = 1
tupla 1 2 3 4
tupla[1] = 2
tupla[2] = 3 índice 0 1 2 3
...
Toda vez que acessar o índice, é o nome da tupla com [] ao lado. Dentro
dos colchetes, coloca-se o índice que deseja acessar.
>>>tupla2 = (“Morty”, “Rick”, 23)
>>>tupla2[0]
“Morty”
>>>tupla2[1]
“Rick”
>>>tupla2[2]
23
A grande diferença entre listas e tuplas é que a tupla não pode ser
alterada depois de criada, e seus itens são representados dentro de
parênteses (), já na lista, pode-se alterar os valores e é representada por
colchetes [].

• Dicionários (dict):
Dicionários são estruturas de dados muito parecidas com as duas anteriores,
porém, sua estrutura é diferente e, em vez de ter um índice número, tem-se
o que se chama de “chave”, é como se a gente pudesse criar qualquer tipo
de índice.
>>>dicionario = {“nome”: “Newton”, “idade”: 25}
O dicionário trabalha com sistema chave-valor, a cada chave, é associado
um valor, neste caso, a chave “nome” tem o valor “Newton” associada a ela.
Para acessar por índice, em vez de ser o índice número, a própria chave
dentro do dicionário é passada como índice.
>>>dicionario[“nome”]
“Newton”
 Em vez de passar uma posição com índice número, a chave é quem é o
índice.
>>> tabela_campeonato = {“Corinthians”: 100, “Grêmio”: 90}
>>> tabela_campeonato[“Corinthians”]
100
Diferentemente das tuplas, o dicionário pode ser modificado após a sua
criação. Outra diferença é que a estrutura de inicialização é bem diferente,
sendo usadas as chaves {}.

Função Entrada Retorno

len >>> len(dicionario) 2
keys >>> dict.keys(dicionario) ([‘nome’,’idade’])
values >>> dict.values(dicionario) ([‘Newton’,’25’])
items >>> dict.items(dicionario) ([('nome','Newton'),('idade','25')])
get >>> dict.get(dicionario,’nome’) ‘Newton’
del >>> del(dicionario[‘idade’]) {‘nome’:’Newton’}
clear >>> dict.clear(dicionario) {}
copy >>> d = dict.copy(dicionario) d = {'nome':'Newton', 'idade':'25'}
pop >>> dict.pop(dicionario, ‘idade’) ‘25’ / {‘nome’:’Newton’}
update >>> dict.update(dicionario,{‘idade’:’1’} {‘nome’:’Newton’, ’idade’:’1’}