DataScienceWithPython Ed2018

44444444444.
EUGENIA BAHIT
CIÊNCIA DE DADOS
COM PYTHON
MATERIAL DE ESTUDO
Informações e inscrições:Curso:
http://escuela.eugeniabahit.com | Certificações: http://python.laeci.org
Introdução à Ciência de Dados com Python - Escuela de Informática Eugenia Bahit
RESUMO
MÉTODOS DE MANIPULAÇÃO DE VARIÁVEIS..............................................................................................5
MANIPULANDO CADEIAS DE CARACTERES DE TEXTO.............................................................................5
MÉTODOS DE FORMATAÇÃO........................................................................................................................5
CONVERTER A PRIMEIRA LETRA EM MAIÚSCULAS............................................................................5
CONVERTER UMA CADEIA DE CARACTERES EM MINÚSCULAS......................................................5
CONVERTER UMA CADEIA DE CARACTERES EM MAIÚSCULAS......................................................6
CONVERTER MAIÚSCULAS E MINÚSCULAS E VICE-VERSA..............................................................6
CONVERTER UMA CADEIA DE CARACTERES EM FORMATO DE TÍTULO......................................6
CENTRAR UM TEXTO...................................................................................................................................6
ALINHAR O TEXTO À ESQUERDA.............................................................................................................6
ALINHAR O TEXTO À DIREITA...................................................................................................................7
PREENCHER UM TEXTO COM ZEROS PENDENTES...............................................................................7
MÉTODOS DE BUSCA.......................................................................................................................................7
CONTAR O NÚMERO DE OCORRÊNCIAS DE UMA SUBSTRING.........................................................7
LOCALIZAR UMA SUBSTRING DENTRO DE UMA STRING..................................................................7
MÉTODOS DE VALIDAÇÃO.............................................................................................................................8
SABER SE UMA CADEIA DE CARACTERES COMEÇA COM UMA SUBCADEIA DE
CARACTERES ESPECÍFICA..........................................................................................................................8
SABER SE UMA CADEIA DE CARACTERES TERMINA COM UMA SUBCADEIA DE
CARACTERES ESPECÍFICA..........................................................................................................................8
SABER SE UMA STRING É ALFANUMÉRICA...........................................................................................8
SABER SE UMA CADEIA DE CARACTERES É ALFABÉTICA................................................................8
SABER SE UMA CADEIA DE CARACTERES É NUMÉRICA...................................................................9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MINÚSCULAS................9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MAIÚSCULAS................9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS ESPAÇO EM BRANCO................10
SABER SE UMA CADEIA DE CARACTERES ESTÁ FORMATADA COMO UM TÍTULO..................10
MÉTODOS DE SUBSTITUIÇÃO......................................................................................................................10
FORMATAR UMA CADEIA DE CARACTERES, SUBSTITUINDO O TEXTO DINAMICAMENTE...10
SUBSTITUIR TEXTO EM UMA CADEIA DE CARACTERES.................................................................11
EXCLUIR CARACTERES À ESQUERDA E À DIREITA DE UMA CADEIA DE CARACTERES........11
EXCLUIR CARACTERES À ESQUERDA DE UMA CADEIA DE CARACTERES.................................11
EXCLUIR CARACTERES À DIREITA DE UMA CADEIA DE CARACTERES......................................11
MÉTODOS DE UNIÃO E DIVISÃO.................................................................................................................11
-2-
(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

4.0
JUNTE-SE A UMA CADEIA ITERATIVAMENTE.....................................................................................11

DIVIDIR UMA CORRENTE EM TRÊS PARTES, USANDO UM SEPARADOR.....................................12
DIVIDIR UMA CORRENTE EM VÁRIAS PARTES, USANDO UM SEPARADOR................................12
DIVIDIR UMA CADEIA DE CARACTERES EM LINHAS........................................................................12
MANIPULAÇÃO DE LISTAS E TUPLAS...........................................................................................................14
MÉTODOS AGREGADOS................................................................................................................................14
ADICIONAR UM ITEM AO FINAL DA LISTA..........................................................................................14
ADICIONAR VÁRIOS ITENS AO FINAL DA LISTA................................................................................14
ADICIONAR UM ITEM EM UMA POSIÇÃO ESPECÍFICA......................................................................14
MÉTODOS DE ELIMINAÇÃO.........................................................................................................................14
EXCLUIR O ÚLTIMO ITEM DA LISTA......................................................................................................14
EXCLUIR UM ITEM POR SEU ÍNDICE......................................................................................................15
EXCLUIR UM ITEM POR SEU VALOR......................................................................................................15
MÉTODOS DE ENCOMENDA.........................................................................................................................15
CLASSIFICAR UMA LISTA EM ORDEM INVERSA (ORDEM INVERSA)............................................15
ORDENAR UMA LISTA EM ORDEM CRESCENTE.................................................................................15
CLASSIFICAR UMA LISTA EM FORMATO DECRESCENTE................................................................15
MÉTODOS DE BUSCA.....................................................................................................................................15
ELEMENTOS DE CONTAGEM DO NÚMERO DE OCORRÊNCIAS.......................................................15
OBTER NÚMERO DE ÍNDICE.....................................................................................................................16
ANEXO RELATIVO ÀS LISTAS E TUPLAS..................................................................................................16
CONVERSÃO DE TIPO.................................................................................................................................16
CONCATENAÇÃO DE COLEÇÕES............................................................................................................17
VALOR MÁXIMO E MÍNIMO......................................................................................................................20
CONTAGEM DE ITENS................................................................................................................................20
MANIPULAÇÃO DE DICIONÁRIOS..................................................................................................................22
MÉTODOS DE ELIMINAÇÃO.........................................................................................................................22
ESVAZIAR UM DICIONÁRIO.....................................................................................................................22
ADICIONANDO E CRIANDO MÉTODOS......................................................................................................22
COPIAR UM DICIONÁRIO...........................................................................................................................22
CRIAR UM NOVO DICIONÁRIO A PARTIR DAS CHAVES DE UM......................................................23
SEQÜENCIAR................................................................................................................................................23
DICIONÁRIOS CONCATENADOS..............................................................................................................23
DEFINIR UMA CHAVE E UM VALOR PADRÃO.....................................................................................23
MÉTODOS DE DEVOLUÇÃO..........................................................................................................................24
OBTER O VALOR DE UMA CHAVE..........................................................................................................24
SABER SE EXISTE UMA CHAVE NO DICIONÁRIO...............................................................................24
-3-

OBTER AS CHAVES E VALORES DE UM DICIONÁRIO........................................................................24

OBTER AS CHAVES DE UM DICIONÁRIO...............................................................................................24
OBTER VALORES DE UM DICIONÁRIO..................................................................................................25
OBTER O NÚMERO DE ITENS EM UM DICIONÁRIO............................................................................25
MANIPULAÇÃO E MANIPULAÇÃO DE ARQUIVOS.....................................................................................27
MANEIRAS DE ABRIR UM ARQUIVO..........................................................................................................27
ALGUNS MÉTODOS DO OBJETO FILE........................................................................................................29
MANIPULAÇÃO DE ARQUIVOS CSV..............................................................................................................30
ALGUNS EXEMPLOS DE ARQUIVOS CSV..................................................................................................30
TRABALHANDO COM ARQUIVOS CSV DO PYTHON..............................................................................32
LENDO ARQUIVOS CSV.............................................................................................................................32
GRAVANDO ARQUIVOS CSV....................................................................................................................37
PROBABILIDADE E ESTATÍSTICA COM PYTHON.......................................................................................40
PROBABILIDADE DE EVENTOS SIMPLES E COMPOSTOS MUTUAMENTE EXCLUSIVOS EM
PYTHON.............................................................................................................................................................40
ESPAÇO DE AMOSTRA...............................................................................................................................40
EVENTOS SIMPLES E COMPOSTOS.........................................................................................................40
ATRIBUIÇÃO DE PROBABILIDADE.........................................................................................................41
EVENTOS SIMPLES MUTUAMENTE EXCLUSIVOS...........................................................................41
EVENTOS COMPOSTOS POR EVENTOS SIMPLES E MUTUAMENTE EXCLUSIVOS..................42
FUNÇÕES.......................................................................................................................................................43
PROBABILIDADE CONDICIONAL EM PYTHON........................................................................................43
FUNÇÕES.......................................................................................................................................................44
EVENTOS DEPENDENTES..........................................................................................................................44
TEORIA DOS CONJUNTOS EM PYTHON..............................................................................................46
EVENTOS INDEPENDENTES......................................................................................................................46
TEOREMA DE BAYES EM PYTHON.............................................................................................................47
TEOREMA DE BAYES E PROBABILIDADE DE CAUSAS......................................................................47
FATOS: ESTUDO DE CASO.....................................................................................................................47
ANÁLISE.....................................................................................................................................................48
PROCEDIMENTO......................................................................................................................................49
FUNÇÕES.......................................................................................................................................................54
BIBLIOGRAFIA ADICIONAL......................................................................................................................54
ANEXO I: CÁLCULOS COMPLEXOS................................................................................................................60
ESTATÍSTICAS POPULACIONAIS E AMOSTRAIS: CÁLCULO DE..........................................................60
VARIÂNCIA E DESLOCAMENTO PADRÃO................................................................................................60
PRODUTO ESCALAR DE DOIS VETORES...................................................................................................61
-4-

CÁLCULOS DE FREQUÊNCIA RELATIVA, ABSOLUTA E CUMULATIVA............................................61

ANEXO II: CRIAÇÃO DE UM MENU DE OPÇÕES..........................................................................................63
MÉTODOS DE MANIPULAÇÃO DE VARIÁVEIS

Em Python, cada variável é considerada um objeto. Em cada objeto, diferentes tipos de ações chamadas métodos
podem ser executados. Métodos são funções, mas seguem de uma variável. Portanto, essas funções são acessadas
através da sintaxe:
variável.função()
Em alguns casos, esses métodos (funções de um objeto) aceitarão parâmetros como qualquer outra função.
variável.função(parâmetro)
MANIPULANDO CADEIAS DE CARACTERES DE TEXTO

Em seguida, você verá os principais métodos que podem ser aplicados em uma cadeia de caracteres de texto,
organizados por categorias.
MÉTODOS DE FORMATAÇÃO
CONVERTER A PRIMEIRA LETRA EM MAIÚSCULAS

Método: capitalize()
Retornos: uma cópia da cadeia de caracteres com a primeira letra em maiúsculas
> >> string = "Bem-vindo ao meu aplicativo"
> >> resultado = string.capitalize()
> >> resultado
Bem-vindo à minha candidatura
CONVERTER UMA CADEIA DE CARACTERES EM MINÚSCULAS

Método: lower()
Retornos: uma cópia minúscula da cadeia de caracteres
> >> string = "Hello World"
> >> cadeia. inferior()
-5-

Olá, mundo
CONVERTER UMA CADEIA DE CARACTERES EM MAIÚSCULAS

Método: upper()
Retornos: uma cópia da cadeia de caracteres em maiúsculas
> >> cadeia. superior()
OLÁ, MUNDO
CONVERTER MAIÚSCULAS E MINÚSCULAS E VICE-VERSA

Método: swapcase()
Retornos: uma cópia da cadeia de caracteres convertida em maiúsculas para minúsculas e vice-versa
> >> cadeia. caso de troca()
Olá, mundo
CONVERTER UMA CADEIA DE CARACTERES EM FORMATO DE TÍTULO

Método: title()
Retornos: uma cópia da cadeia de caracteres convertida
> >> string = "Olá mundo"
> >> cadeia. título()
Olá, mundo
CENTRAR UM TEXTO
Método: center(length[, "caractere de preenchimento"])
Retorna: uma cópia da cadeia de caracteres centralizada
> >> string = "Bem-vindo ao meu aplicativo".maiúscula()
> >> cadeia.centro(50, "=")
===========Bem-vindo à minha candidatura============
> >> cadeia.centro(50, " ")

ALINHAR O TEXTO À ESQUERDA

Método: ljust(length[, "caractere de preenchimento"])
Retornos: uma cópia alinhada à esquerda da cadeia de caracteres
>>> cadeia.ljust(50, "=")
Bem-vindo à minha candidatura======================
-6-

4.0
ALINHAR O TEXTO À DIREITA

Método: rjust(length[, "caractere de preenchimento"])
Retorna: uma cópia da cadeia de caracteres alinhada à direita
>>> string = "Bem-vindo ao meu aplicativo".maiúscula()
>>> cadeia.rjust(50, "=")
========================Bem-vindo à minha candidatura
>>> cadeia.rjust(50, " ")

PREENCHER UM TEXTO COM ZEROS PENDENTES

Método: zfill (comprimento)
Retornos: uma cópia da cadeia preenchida com zeros à esquerda até atingir o comprimento final indicado
>>> numero_factura = 1575
>>> str(numero_factura). Zfill(12)
000000001575
MÉTODOS DE BUSCA
CONTAR O NÚMERO DE OCORRÊNCIAS DE UMA SUBSTRING

Método: count("substring"[, posicion_inicio, posicion_fin])
Retornos: um inteiro que representa o número de ocorrências de subcadeia de caracteres dentro de uma cadeia
de caracteres
>>> cadeia. contagem("a")
3
LOCALIZAR UMA SUBSTRING DENTRO DE UMA STRING

Método: find("substring"[, posicion_inicio, posicion_fin])
Retornos: um inteiro que representa a posição em que a subcadeia de caracteres começa dentro
cadeia. Se não encontrar, retorne -1
>>> cadeia. encontrar("meu")
13
>>> cadeia.find("meu", 0, 10)
-1
-7-

4.0
MÉTODOS DE VALIDAÇÃO

CARACTERES ESPECÍFICA
Método: startswith("substring"[, posicion_inicio, posicion_fin])
Retorna: Verdadeiro ou Falso
> >> cadeia.começa com
Verdadeiro
> >> cadeia.startswith("aplicação")
Falso
> >> cadeia.startswith("aplicação", 16)
Verdadeiro

CARACTERES ESPECÍFICA
Método: endswith("substring"[, posicion_inicio, posicion_fin])
> >> cadeia.termina com("aplicação")
Verdadeiro
> >> cadeia.termina com
Falso
> >> cadeia.endswith("Bem-vindo", 0, 10)
Verdadeiro
SABER SE UMA STRING É ALFANUMÉRICA

Método: isalnum()
> >> corrente = "pepegrillo 75"
> >> cadeia. isalnum()
Falso
> >> cadeia = "pepegrillo"
Verdadeiro
> >> string = "pepegrillo75"
Verdadeiro
SABER SE UMA CADEIA DE CARACTERES É ALFABÉTICA

Método: isalpha()
> >> cadeia. isalfa()
Falso
-8-

4.0
> >> cadeia = "pepegrillo"

Verdadeiro
Falso
SABER SE UMA CADEIA DE CARACTERES É NUMÉRICA

Método: isdigit()
> >> cadeia. isdigit()
Falso
> >> string = "7584"
Verdadeiro
> >> string = "75 84"
Falso
> >> string = "75,84"
Falso
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MINÚSCULAS

Método: islower()
> >> cadeia = "pepe grillo"
> >> cadeia. émenor()
Verdadeiro
> >> cadeia = "Pepe Grillo"
Falso
> >> cadeia = "Pepegrillo"
Falso
Verdadeiro
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MAIÚSCULAS

Método: isupper()
> >> string = "PEPE GRILLO"
> >> cadeia. isupper()
Verdadeiro
Falso
-9-

4.0
> >> cadeia = "Pepegrillo"

Falso
> >> string = "PEPEGRILLO"
Verdadeiro
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS ESPAÇO EM BRANCO

Método: isspace()
> >> cadeia = "pepe grillo"
> >> cadeia. isspace()
Falso
> >> string = " "
> >> cadeia. isspace()
Verdadeiro
SABER SE UMA CADEIA DE CARACTERES ESTÁ FORMATADA COMO UM TÍTULO

Método: istitle()
> >> cadeia. istitle()
Verdadeiro
> >> corrente = "Pepe grillo"
> >> cadeia. istitle()
Falso
MÉTODOS DE SUBSTITUIÇÃO
FORMATAR UMA CADEIA DE CARACTERES, SUBSTITUINDO O TEXTO DINAMICAMENTE

Método: format(*args, **kwargs)
Retornos: a cadeia de caracteres formatada
> >> string = "Bem-vindo ao meu aplicativo {0}"
> >> cadeia.format("em Python")
bem-vindo à minha aplicação em Python
> >> string = "Valor bruto: ${0} + IVA: ${1} = Valor líquido: {2}"
> >> cadeia.formato(100, 21, 121)
Valor bruto: $100 + IVA: $21 = Valor líquido: 121
> >> string = "Valor bruto: ${bruto} + IVA: ${VAT} = Valor líquido: {líquido}"
> >> cadeia.formato(bruto=100, VAT=21, líquido=121)
> >> cadeia.formato(bruto=100, VAT=100 * 21 / 100, líquido=100 * 21 / 100 + 100)

- 10 -

4.0
SUBSTITUIR TEXTO EM UMA CADEIA DE CARACTERES

Método: replace("substring para localizar", "substring para substituir")
Retorna: a cadeia de caracteres substituída
> >> search = "nomesobrenome"
> >> reemplazar_por = "João Doe"
> >> "Prezado Sr. Sobrenome:". substituir(Pesquisar, reemplazar_por) Prezado Sr. Juan Perez:
EXCLUIR CARACTERES À ESQUERDA E À DIREITA DE UMA CADEIA DE CARACTERES

Método: strip(["caractere"])
Retornos: a cadeia de caracteres substituída
> >> string = " www.eugeniabahit.com "
> >> cadeia. tira()
www.eugeniabahit.com
> >> cadeia. tira(' ')
EXCLUIR CARACTERES À ESQUERDA DE UMA CADEIA DE CARACTERES

Método: lstrip(["caractere"])
> >> string = "www.eugeniabahit.com"
> >> cadeia.lstrip("w." )
eugeniabahit.com
> >> string = " www.eugeniabahit.com"

> >> cadeia. lstrip()
EXCLUIR CARACTERES À DIREITA DE UMA CADEIA DE CARACTERES

Método: rstrip(["caractere"])
> >> string = "www.eugeniabahit.com "
> >> cadeia. rstrip( )
MÉTODOS DE UNIÃO E DIVISÃO
JUNTE-SE A UMA CADEIA ITERATIVAMENTE

Método: join(iterable)
Retornos: a cadeia unida com o iterável (a cadeia é separada por cada um dos elementos do iterável)
>>> formato_numero_factura = ("Nº 0000-0", "-0000 (ID: ", ")")
- 11 -

4.0
>>> número = "275"

> >> numero_factura = número.junte-se(formato_numero_factura)
> >> numero_factura
No. 0000-0275-0000 (ID: 275)
DIVIDIR UMA CORRENTE EM TRÊS PARTES, USANDO UM SEPARADOR

Método: partition("separador")
Retornos: uma tupla de três elementos onde o primeiro é o conteúdo da cadeia antes do separador, o segundo, o
próprio separador e o terceiro, o conteúdo da cadeia após o separador
> >> tupla = "http://www.eugeniabahit.com". partição("www.")
> >> tupla
('http://', 'www.', 'eugeniabahit.com')
> >> protocolo, separador, domínio = tupla

>>>> "Protocolo: {0}\nDomínio: {1}".format(protocolo, domínio) Protocolo: http://
Domínio: eugeniabahit.com
DIVIDIR UMA CORRENTE EM VÁRIAS PARTES, USANDO UM SEPARADOR

Método: split("separador")
Retornos: uma lista de todos os itens encontrados dividindo a cadeia de caracteres por um separador
>>> palavras-chave = "python, guia, curso, tutorial". split(", ")
> >> palavras-chave
['python', 'guia', 'curso', 'tutorial']
DIVIDIR UMA CADEIA DE CARACTERES EM LINHAS

Método: splitlines()
Retornos: uma lista onde cada item é uma fração da cadeia de caracteres dividida em linhas
>>> texto = """Linha 1
Linha 2
Linha 3
Linha 4 """
> >> texto.linhas divididas()
['Linha 1', 'Linha 2', 'Linha 3', 'Linha 4']
> >> texto = "Linha 1\nLinha 2\nLinha 3"

> >> texto.linhas divididas()
['Linha 1', 'Linha 2', 'Linha 3']
- 12 -

4.0
(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons 4.0
MANIPULAÇÃO DE LISTAS E TUPLAS
Neste capítulo, você verá os métodos que o objeto de lista tem. Alguns deles também estão
disponíveis para tuplas.
MÉTODOS AGREGADOS
ADICIONAR UM ITEM AO FINAL DA LISTA

Método: append("novo item")
> >> nombres_masculinos = ["Álvaro", "Jacinto", "Miguel", "Edgardo", "David"]
> >> nombres_masculinos. append("José")
> >> nombres_masculinos
['Álvaro', 'David', 'Edgardo', 'Jacinto', 'José', 'Ricky', 'José']
ADICIONAR VÁRIOS ITENS AO FINAL DA LISTA

Método: extend(otra_lista)
> >> nombres_masculinos.estender(["José", "Gerardo"])
['Álvaro', 'David', 'Edgardo', 'Jacinto', 'José', 'Ricky', 'José', 'José', 'Gerardo']
ADICIONAR UM ITEM EM UMA POSIÇÃO ESPECÍFICA

Método: insert(position, "novo elemento")
> >> nombres_masculinos. insert(0, "Ricky")
['Ricky', 'Álvaro', 'David', 'Edgardo', 'Jacinto', 'José', 'Ricky', 'José', 'José', 'Gerardo']
MÉTODOS DE ELIMINAÇÃO
EXCLUIR O ÚLTIMO ITEM DA LISTA

Método: pop()
Devoluções: o item excluído
> >> nombres_masculinos. pop()
'Geraldo'
['Ricky', 'Álvaro', 'David', 'Edgardo', 'Jacinto', 'José', 'Ricky', 'José', 'José']

4.0
EXCLUIR UM ITEM POR SEU ÍNDICE

Método: pop(index)
Devoluções: o item excluído
>>> nombres_masculinos. Pop(3)
'Edgardo'
>>> nombres_masculinos
['Ricky', 'Álvaro', 'David', 'Jacinto', 'José', 'Ricky', 'José', 'José']
EXCLUIR UM ITEM POR SEU VALOR

Método: remove("value")
>>> nombres_masculinos. remove("José")
['Ricky', 'Álvaro', 'David', 'Jacinto', 'Ricky', 'José', 'José']
MÉTODOS DE ENCOMENDA
CLASSIFICAR UMA LISTA EM ORDEM INVERSA (ORDEM INVERSA)

Método: reverse()
>>> nombres_masculinos. reverso()
['José', 'José', 'Ricky', 'Jacinto', 'David', 'Álvaro', 'Ricky']
ORDENAR UMA LISTA EM ORDEM CRESCENTE

Método: sort()
>>> nombres_masculinos. ordenar()
['Álvaro', 'David', 'Jacinto', 'José', 'José', 'Ricky', 'Ricky']
CLASSIFICAR UMA LISTA EM FORMATO DECRESCENTE

Método: sort(reverse=True)
>>> nombres_masculinos. sort(reverse=True)
['Ricky', 'Ricky', 'José', 'José', 'Jacinto', 'David', 'Alvaro']
MÉTODOS DE BUSCA
ELEMENTOS DE CONTAGEM DO NÚMERO DE OCORRÊNCIAS

Método: count(element)
>>> nombres_masculinos = ["Álvaro", "Miguel", "Edgardo", "David", "Miguel"]
- 15 -

>>> nombres_masculinos. conde("Miguel ") 2 >>> nombres_masculinos = ("Álvaro", "Miguel", "Edgardo", "David",
"Miguel")
>>> nombres_masculinos. Conde("Michael")
2
OBTER NÚMERO DE ÍNDICE

Método: index(element[, indice_inicio, indice_fin])
>>> nombres_masculinos. índice("Michael") 1
>>> nombres_masculinos. índice("Michael", 2, 5) 4
ANEXO RELATIVO ÀS LISTAS E TUPLAS
CONVERSÃO DE TIPO
No conjunto de funções internas do Python, é possível encontrar duas funções que permitem converter listas em
tuplas e vice-versa. Essas funções são lista e tupla, para converter tuplas em listas e listas em tuplas,
respectivamente.
Um dos usos mais frequentes é a conversão de tuplas em listas, que precisam ser modificadas. Isso geralmente
acontece com resultados obtidos de uma consulta ao banco de dados.
>>> tupla = (1, 2, 3, 4)

>>> tupla (1, 2, 3, 4)
>>> list(tupla)
[1, 2, 3, 4]
>>> lista = [1, 2, 3, 4]

>>> lista [1, 2, 3, 4]
>>> tupla (lista)

(1, 2, 3, 4)
- 16 -

4.0
CONCATENAÇÃO DE COLEÇÕES
Você pode concatenar (ou juntar) duas ou mais listas ou duas ou mais tuplas, usando o sinal de adição +.
Não é possível anexar uma lista a uma tupla. As coleções a serem unidas devem ser do mesmo tipo.
>>> lista1 = [1, 2, 3, 4]

> >> lista2 = [3, 4, 5, 6, 7, 8]
> >> list3 = list1 + list2
> >> lista3
[1, 2, 3, 4, 3, 4, 5, 6, 7, 8]
MÉTODOS DE MANIPULAÇÃO DE VARIÁVEIS 5

MANIPULANDO CADEIAS DE CARACTERES DE TEXTO 5
MÉTODOS DE FORMATAÇÃO 5
CONVERTER A PRIMEIRA LETRA EM MAIÚSCULAS 5
CONVERTER UMA CADEIA DE CARACTERES EM MINÚSCULAS 5
CONVERTER UMA CADEIA DE CARACTERES EM MAIÚSCULAS 6
CONVERTER MAIÚSCULAS E MINÚSCULAS E VICE-VERSA 6
CONVERTER UMA CADEIA DE CARACTERES EM FORMATO DE TÍTULO 6
CENTRAR UM TEXTO 6
ALINHAR O TEXTO À ESQUERDA 6
ALINHAR O TEXTO À DIREITA 7
PREENCHER UM TEXTO COM ZEROS PENDENTES 7
MÉTODOS DE BUSCA 7
CONTAR O NÚMERO DE OCORRÊNCIAS DE UMA SUBSTRING 7
LOCALIZAR UMA SUBSTRING DENTRO DE UMA STRING 7
MÉTODOS DE VALIDAÇÃO 8
CARACTERES ESPECÍFICA 8
SABER SE UMA STRING É ALFANUMÉRICA 8
SABER SE UMA CADEIA DE CARACTERES É ALFABÉTICA 8
SABER SE UMA CADEIA DE CARACTERES É NUMÉRICA 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MINÚSCULAS 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MAIÚSCULAS 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS ESPAÇO EM BRANCO 10
SABER SE UMA CADEIA DE CARACTERES ESTÁ FORMATADA COMO UM TÍTULO 10
MÉTODOS DE SUBSTITUIÇÃO 10
FORMATAR UMA CADEIA DE CARACTERES, SUBSTITUINDO O TEXTO DINAMICAMENTE 10
- 17 -

SUBSTITUIR TEXTO EM UMA CADEIA DE CARACTERES 11

EXCLUIR CARACTERES À ESQUERDA E À DIREITA DE UMA CADEIA DE CARACTERES 11
EXCLUIR CARACTERES À ESQUERDA DE UMA CADEIA DE CARACTERES 11
EXCLUIR CARACTERES À DIREITA DE UMA CADEIA DE CARACTERES 11
MÉTODOS DE UNIÃO E DIVISÃO 11
JUNTE-SE A UMA CADEIA ITERATIVAMENTE 11
DIVIDIR UMA CORRENTE EM TRÊS PARTES, USANDO UM SEPARADOR 12
DIVIDIR UMA CORRENTE EM VÁRIAS PARTES, USANDO UM SEPARADOR 12
DIVIDIR UMA CADEIA DE CARACTERES EM LINHAS 12
MANIPULAÇÃO DE LISTAS E TUPLAS 14
MÉTODOS AGREGADOS 14
ADICIONAR UM ITEM AO FINAL DA LISTA 14
ADICIONAR VÁRIOS ITENS AO FINAL DA LISTA 14
ADICIONAR UM ITEM EM UMA POSIÇÃO ESPECÍFICA 14
MÉTODOS DE ELIMINAÇÃO 14
EXCLUIR O ÚLTIMO ITEM DA LISTA 14
EXCLUIR UM ITEM POR SEU ÍNDICE 15
EXCLUIR UM ITEM POR SEU VALOR 15
MÉTODOS DE ENCOMENDA 15
CLASSIFICAR UMA LISTA EM ORDEM INVERSA (ORDEM INVERSA) 15
ORDENAR UMA LISTA EM ORDEM CRESCENTE 15
CLASSIFICAR UMA LISTA EM FORMATO DECRESCENTE 15
MÉTODOS DE BUSCA 15
ELEMENTOS DE CONTAGEM DO NÚMERO DE OCORRÊNCIAS 15
OBTER NÚMERO DE ÍNDICE 16
ANEXO RELATIVO ÀS LISTAS E TUPLAS 16
CONVERSÃO DE TIPO 16
CONCATENAÇÃO DE COLEÇÕES 17
VALOR MÁXIMO E MÍNIMO 20
CONTAGEM DE ITENS 20
MANIPULAÇÃO DE DICIONÁRIOS 22
ESVAZIAR UM DICIONÁRIO 22
ADICIONANDO E CRIANDO MÉTODOS 22
COPIAR UM DICIONÁRIO 22
CRIAR UM NOVO DICIONÁRIO A PARTIR DAS CHAVES DE UM 23
SEQÜENCIAR 23
- 18 -

4.0
DICIONÁRIOS CONCATENADOS 23
DEFINIR UMA CHAVE E UM VALOR PADRÃO 23
MÉTODOS DE DEVOLUÇÃO 24
OBTER O VALOR DE UMA CHAVE 24
SABER SE EXISTE UMA CHAVE NO DICIONÁRIO 24
OBTER AS CHAVES E VALORES DE UM DICIONÁRIO 24
OBTER AS CHAVES DE UM DICIONÁRIO 24
OBTER VALORES DE UM DICIONÁRIO 25
OBTER O NÚMERO DE ITENS EM UM DICIONÁRIO 25
MANIPULAÇÃO E MANIPULAÇÃO DE ARQUIVOS 27
MANEIRAS DE ABRIR UM ARQUIVO 27
ALGUNS MÉTODOS DO OBJETO FILE 29
MANIPULAÇÃO DE ARQUIVOS CSV 30
ALGUNS EXEMPLOS DE ARQUIVOS CSV 30
TRABALHANDO COM ARQUIVOS CSV DO PYTHON 32
LENDO ARQUIVOS CSV 32
GRAVANDO ARQUIVOS CSV 37
PROBABILIDADE E ESTATÍSTICA COM PYTHON 40
PROBABILIDADE DE EVENTOS SIMPLES E COMPOSTOS MUTUAMENTE EXCLUSIVOS EM
PYTHON 40
ESPAÇO DE AMOSTRA 40
EVENTOS SIMPLES E COMPOSTOS 40
ATRIBUIÇÃO DE PROBABILIDADE 41
EVENTOS SIMPLES MUTUAMENTE EXCLUSIVOS 41
EVENTOS COMPOSTOS POR EVENTOS SIMPLES E MUTUAMENTE EXCLUSIVOS 42
FUNÇÕES 43
PROBABILIDADE CONDICIONAL EM PYTHON 43
FUNÇÕES 44
EVENTOS DEPENDENTES 44
TEORIA DOS CONJUNTOS EM PYTHON 46
EVENTOS INDEPENDENTES 46
TEOREMA DE BAYES EM PYTHON 47
TEOREMA DE BAYES E PROBABILIDADE DE CAUSAS 47
FATOS: ESTUDO DE CASO 47
ANÁLISE 48
PROCEDIMENTO 49
FUNÇÕES 54
- 19 -

BIBLIOGRAFIA ADICIONAL 54
ANEXO I: CÁLCULOS COMPLEXOS 60
ESTATÍSTICAS POPULACIONAIS E AMOSTRAIS: CÁLCULO DE 60
VARIÂNCIA E DESLOCAMENTO PADRÃO 60
PRODUTO ESCALAR DE DOIS VETORES 61
CÁLCULOS DE FREQUÊNCIA RELATIVA, ABSOLUTA E CUMULATIVA 61
ANEXO II: CRIAÇÃO DE UM MENU DE OPÇÕES 63
>
> >> tupla4 = tupla1 + tupla2 + tupla3
> >> tupla4
(1, 2, 3, 4, 5, 4, 6, 8, 10, 3, 5, 7, 9)
VALOR MÁXIMO E MÍNIMO

Você pode obter o valor máximo e mínimo de listas e tuplas:
> >> máx(tupla4)

10
> >> máx(tupla1)
5
> >> min(tupla1)
1
> >> max(lista3)
8
> >> min(lista1)
1
CONTAGEM DE ITENS
A função len() é usada para contar elementos de uma lista ou tupla, como caracteres de uma cadeia de caracteres
de texto:
> >> len(lista3)

10
> >> len(lista1)
4
- 20 -

4.0
MANIPULAÇÃO DE DICIONÁRIOS
MÉTODOS DE ELIMINAÇÃO
ESVAZIAR UM DICIONÁRIO
Método: clear()
>>> dicionário = {"color": "violet", "size": "XS", "price": 174.25}
> >> dicionário
{'cor': 'violeta', 'preço': 174,25, 'tamanho': 'XS'}
> >> dicionário.clear()

> >> dicionário
{}
ADICIONANDO E CRIANDO MÉTODOS
COPIAR UM DICIONÁRIO
Método: copy()
> >> dicionário = {"color": "violeta",
> >> camisa = dictionary.copy()
> >> dicionário
{'cor': 'violeta', 'preço': 174,25,
> >> camisa {'cor': 'violeta', 'preço':
> >> dicionário.clear()

"Tamanho": "XS", "Preço": 174.25}
> >> dicionário {}
> >> camiseta

'tamanho': 'XS'}
{'cor': 'violeta', 'preço':
> >> músculo = camisa

> >> camiseta 174.25, 'tamanho': 'XS'}
{'cor': 'violeta', 'preço':
> >> musculoso {'cor': 'violeta', 'preço':
>>> remera.clear()
>>> camisa {} muscle >>> {}
174.25, 'tamanho': 'XS'}
174.25, 'tamanho': 'XS'}
174.25, 'tamanho': 'XS'}

4.0
CRIAR UM NOVO DICIONÁRIO A PARTIR DAS CHAVES DE UM

SEQÜENCIAR
Método: dict.fromkeys(sequence[, default])
>>> sequência = ["cor", "tamanho", "marca"]
>>> dicionário1 = dict.fromkeys(sequence)
>>> dicionário1
{'cor': Nenhuma, 'marca': Nenhuma, 'tamanho': Nenhuma}
>>> dictionary2 = dict.fromkeys(sequence, 'default x value')

>>> dicionário2
{'cor': 'valor x padrão', 'marca': 'valor x padrão', 'tamanho': 'valor x padrão'}
DICIONÁRIOS CONCATENADOS
Método: update(dictionary)
>>> dicionário1 = {"cor": "verde", "preço": 45}
>>> dicionário2 = {"size": "M", "brand": "Lacoste"}
>>> dictionary1.update(dictionary2)
>>> dicionário1
{'cor': 'verde', 'preço': 45, 'marca': 'Lacoste', 'tamanho': 'M'}
DEFINIR UMA CHAVE E UM VALOR PADRÃO

Método: setdefault("key"[, None|valor_por_defecto])
Se a chave não existir, ela será criada com o valor padrão. Sempre retorna o valor da chave passada como
um parâmetro.
>>> camisa = {"cor": "rosa", "marca": "Zara"}

>>> chave = camiseta.setdefault("tamanho", "U")
> >> chave
'U'
> >> camiseta

{'cor': 'rosa', 'marca': 'Zara', 'tamanho': 'U'}
> >> camisa2 = t-shirt.copy()

> >> T-shirt2
{'cor': 'rosa', 'marca': 'Zara', 'tamanho': 'U'}
> >> chave = T-shirt2.setdefault("carimbo")

> >> chave
> >> T-shirt2
{'cor': 'rosa', 'estampa': Nenhuma, 'marca': 'Zara', 'tamanho': 'U'}
> >> chave = T-shirt2.setdefault("marca", "Lacoste")

> >> chave
'Zara'
- 23 -

4.0
>>> T-shirt2
{'cor': 'rosa', 'estampa': Nenhuma, 'marca': 'Zara', 'tamanho': 'U'}
MÉTODOS DE DEVOLUÇÃO
OBTER O VALOR DE UMA CHAVE

Método: get(key[, "default x value if key does not exist"])
>>> camisa.get("cor")
'Rosa'
>>> camisa.get("estoque")
>>> camisa.get("estoque", "fora de estoque")
'Esgotado'
SABER SE EXISTE UMA CHAVE NO DICIONÁRIO

Método: 'chave' no dicionário
> >> existe = 'preço' na camisa
> >> existe
Falso
> >> existe = 'cor' na camisa

> >> existe
Verdadeiro
OBTER AS CHAVES E VALORES DE UM DICIONÁRIO

Método: items()
dicionário = {'color': 'pink', 'brand': 'Zara', 'size': 'U'}
para chave, valor em dictionary.items():

chave, valor
Sair:
('cor', 'rosa')
('marca', 'Zara')
('tamanho', 'U')
OBTER AS CHAVES DE UM DICIONÁRIO

Método: keys()
dicionário = {'color': 'pink', 'brand': 'Zara', 'size': 'U'} para clave em diccionario.keys():
.key
'marca'
'tamanho'
'Cor'
Obter chaves em uma lista
- 24 -

4.0
> >> dicionário = {'color': 'pink', 'brand': 'Zara', 'size': 'U'}

> >> chaves = list(dictionary.keys())
> >> chaves
['cor', 'marca', 'tamanho']
OBTER VALORES DE UM DICIONÁRIO

Método: values()
dicionário = {'color': 'pink', 'brand': 'Zara', 'size': 'U'}
para clave em diccionario.values():
.key
'Rosa'
'Zara'
'U'
Obter valores em uma lista

> >> chaves = list(dictionary.values())
OBTER O NÚMERO DE ITENS EM UM DICIONÁRIO

Para contar os itens em um dicionário, como acontece com listas e tuplas, a função len() interna é usada.
> >> len(dicionário)
3
- 25 -

4.0
MANIPULAÇÃO E MANIPULAÇÃO DE ARQUIVOS
Python permite que você trabalhe em dois níveis diferentes com relação ao sistema de arquivos e
diretórios.
Um deles é através do módulo OS, que facilita o trabalho com todo o sistema de arquivos e
diretórios, no nível do próprio sistema operacional.
O segundo nível é aquele que permite trabalhar com arquivos manipulando sua leitura e gravação a partir do
próprio aplicativo ou script, tratando cada arquivo como um objeto.
MANEIRAS DE ABRIR UM ARQUIVO

A maneira como um arquivo é aberto está relacionada ao objetivo final que responde à pergunta "por que este
arquivo está sendo aberto?". As respostas podem ser várias: ler, escrever ou ler e escrever.
Cada vez que você "abre" um arquivo, você está criando um ponteiro na memória.
Esse ponteiro posicionará um cursor (ou ponto de acesso) em um lugar específico na memória (simplificando,
ele posicionará o cursor em um determinado byte do conteúdo do arquivo).
Esse cursor se moverá dentro do arquivo, à medida que for lido ou gravado no arquivo.
Quando um arquivo é aberto no modo de leitura, o cursor é posicionado no byte 0 do arquivo (ou seja, no início
do arquivo). Depois que o arquivo é lido, o cursor se move para o byte final do arquivo (equivalente ao número
total de bytes no arquivo). O mesmo acontece quando ele é aberto no modo de gravação. O cursor se moverá à
medida que você digita.

4.0
Quando você deseja gravar no final de um arquivo não nulo, use o modo de acréscimo . Isso abre o arquivo com
o cursor no final do arquivo.
O símbolo + como um sufixo de um modo, adiciona o modo oposto ao modo de abertura uma vez que a ação de
abertura é executada. Por exemplo, o modo r (leitura) com o sufixo + (r+), abre o arquivo para leitura e, após a
leitura, retorna o cursor para o byte 0.
A tabela a seguir mostra as diferentes maneiras de abrir um arquivo:

Indicador Modo de abertura Localização do ponteiro
r Somente leitura No início do arquivo
Rb Somente leitura no modo binário No início do arquivo
R+ Leitura e escrita No início do arquivo

RB+ Leitura e gravação no modo binário No início do arquivo
Somente gravação.
Substitui o arquivo, se ele existir.
w No início do arquivo
Cria o arquivo se ele não existir.
Escreva apenas no modo binário. Substitui o

Wb arquivo, se ele existir. Cria o arquivo se ele No início do arquivo
não existir.
Escrita e leitura.
c+ Substitui o arquivo, se ele existir. No início do arquivo
Cria o arquivo se ele não existir.
Escrita e leitura em modo binário. Substitui o
WB+ arquivo, se ele existir. Cria o arquivo se ele No início do arquivo
não existir.
Se o arquivo existir, no final
Adicionado (adicionar conteúdo). dele.
Para Cria o arquivo se ele não existir. Se o arquivo não existir, no
início.
Adicionado no modo binário (adicionar dele.
Ab conteúdo). Se o arquivo não existir, no
Cria o arquivo se ele não existir. início.
a+ Adicionar (adicionar conteúdo) e ler. Se o arquivo existir, no final do
- 28 -

4.0
este.
Cria o arquivo se ele não existir. Se o arquivo não existir, no
início.
Adicionado (adicionar conteúdo) e lido no dele.
AB+ modo binário. Se o arquivo não existir, no
Cria o arquivo se ele não existir. início.
ALGUNS MÉTODOS DO OBJETO FILE

O objeto file, entre seus métodos, tem o seguinte:
Método Descrição
Lê todo o conteúdo de um arquivo.
leitura([bytes]) Se o comprimento do byte for excedido, ele lerá somente o
conteúdo até o comprimento especificado.
linhas de leitura() Lê todas as linhas em um arquivo
Gravação(String) Gravar cadeia de caracteres dentro do arquivo

Sequência será qualquer iterável cujos elementos serão
linhas de escrita(sequência)
escritos um por linha
ACESSANDO ARQUIVOS USANDO A ESTRUTURA WITH Com a estrutura with e a função

open(), você pode abrir um arquivo em qualquer modo e trabalhar com ele, sem precisar fechá-lo ou destruir o
ponteiro, pois isso é feito pelo com estrutura.
Leia um arquivo:
com open("file.txt", " r") como arquivo: content = file.read()
Gravar em um arquivo:
conteúdo = """
Este será o conteúdo do novo arquivo.
O arquivo terá várias linhas.
- 29 -

4.0
"""
com open("file.txt", "r") como arquivo: file.write(content)
MANIPULAÇÃO DE ARQUIVOS CSV

O formato CSV deriva seu nome do inglês "valores separados por vírgula", definidos na RFC 4180. Estes são
arquivos de texto simples, destinados ao armazenamento de dados em massa. É um dos formatos mais simples
para realizar análise de dados. Na verdade, muitos formatos de arquivo não livres (ou gratuitos, mas mais
complexos) são frequentemente convertidos para o formato CSV para aplicar ciência de dados complexa com
várias linguagens.
Um arquivo CSV consiste em um cabeçalho que define nomes de coluna, e as linhas a seguir têm os dados
correspondentes a cada coluna, separados por uma vírgula. No entanto, muitos outros símbolos podem ser
usados como separadores de células. Entre eles, tabulação e ponto-e-vírgula são tão frequentes quanto vírgulas.
ALGUNS EXEMPLOS DE ARQUIVOS CSV

Dados meteorológicos (separados por ;)
ID;DADOS; VV;DV;T;HR;PPT; RS; P

0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
Pontuações obtidas pelos jogadores em um torneio (separadas por ,) nome,quantidade,ano
- 30 -

4.0
Maria,858,1930
José,665,1930
Rosa,591,1930
João Carlos,522,1930
Antônio,509,1930
Maria Ester,495,1930
Maria Luísa,470,1930
Joana,453,1930
João,436,1930
Empresas registradas na Inspetoria Geral de Justiça da Argentina (separadas por , e dados citados)
"numero_correlativo","tipo_societario","descripcion_tipo_societario","razon_soci
para","dada_de_baja","codigo_baja","detalle_baja"
"10","10","SOCIEDAD COLECTIVA","A A VALLE Y COMPA¥IA","S","42014","PERTENCE A ENTIDADES INATIVAS DE
REGISTO"
"11","10","PARCERIA","A LUCERO Y H CARATOLI","S","42014","PERTENCE A
CADASTRAR ENTIDADES INATIVAS"
"12","10","SOCIEDAD COLECTIVA","A PUIG E HIJOS","S","42014","PERTENCE A
"13","10","PARCERIA","A C I C A","S","42014","PERTENCE AO REGISTRO
ENTIDADES INATIVAS"
"14","10","PARCERIA","A¥ON BEATRIZ S Y CIA","S","42014","PERTENCE A
"15","10","PARCERIA","ABA DIESEL","S","42014","PERTENCE AO REGISTRO
ENTIDADES INATIVAS"
"16","10","SOCIEDAD COLECTIVA","ABADA L JOSE Y JORGE JOSE
ABADAL","S","42014","PERTENCE A ENTIDADES INATIVAS DE REGISTRO"
"17","10","SOCIEDAD COLECTIVA","ABADAL JOSE E HIJO","S","42014","PERTENCE AO REGISTO ENTIDADES
INACTIVAS"
"18","10","SOCIEDAD COLECTIVA","ABATE Y MACIAS","S","42014","PERTENCE A
Também é possível encontrar dados armazenados em arquivos de texto (TXT) com formatos muito semelhantes
ao que se espera encontrar em um CSV. Às vezes é possível desenvolver um script de formato para corrigir esses
arquivos e, assim, ser capaz de trabalhar com um CSV.
Observações meteorológicas em TXT
DATA TMAX TMIN NOME

--------------------------------------------------------------------
07122017 28.0 19.0 AEROPARQUE AERO
07122017 26.8 12.4 AERO AZUL
- 31 -

4.0
07122017 29.6 7.8 BAHIA BLANCA AERO

07122017 22.7 6.7 BARILOCHE AERO
07122017 3.0 -8.5 BASE BELGRANO II
07122017 2.4 -0.2 BASE CARLINI (EX JUBANY)
07122017 3.9 -0.6 BASE DE ESPERANÇA
07122017 0.7 -3.6 BASE MARAMBIO
TRABALHANDO COM ARQUIVOS CSV DO PYTHON

Python fornece seu próprio módulo chamado csv, que facilita a análise de dados de arquivos CSV, tanto para
leitura quanto para gravação.
Este módulo é usado em combinação com a estrutura com e a função aberta, para ler ou gerar o arquivo, e o
módulo CSV para análise.
LENDO ARQUIVOS CSV
Conteúdo do arquivo.csv
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;
Do leitor de importação CSV
com open("file.csv", "r") como arquivo: document = reader(file, delimiter=';', para linha no documento:
' '.join(linha) quotechar='"')
Sair:
'0 2016-03-01 00:00:00 9.9 73

'1 2016-03-01 00:30:00 9.0 67
'2 2016-03-01 01:00:00 8.3 64
'3 2016-03-01 01:30:00 8.0 61
'4 2016-03-01 02:00:00 7.4 62
'5 2016-03-01 02:30:00 8.3 47
'6 2016-03-01 03:00:00 7.7 50
'7 2016-03-01 03:30:00 9.0 39
'8 2016-03-01 04:00:00 8.7 39
- 32 -

4.0
Quando o arquivo CSV tem um cabeçalho, é necessário ignorar esse cabeçalho:
Conteúdo do arquivo.csv
ID;DADOS; VV;DV;T;HR;PPT; RS; P

0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;
Do leitor de importação CSV
com open("file.csv", "r") como arquivo: document = reader(file, delimiter=';', headers = next(document)
Para Fila in Documento: quotechar='"')
' '.join(linha)
Sair:
MÉTODOS DE MANIPULAÇÃO DE VARIÁVEIS 5

MANIPULANDO CADEIAS DE CARACTERES DE TEXTO 5
MÉTODOS DE FORMATAÇÃO 5
CONVERTER A PRIMEIRA LETRA EM MAIÚSCULAS 5
CONVERTER UMA CADEIA DE CARACTERES EM MINÚSCULAS 5
CONVERTER UMA CADEIA DE CARACTERES EM MAIÚSCULAS 6
CONVERTER MAIÚSCULAS E MINÚSCULAS E VICE-VERSA 6
CONVERTER UMA CADEIA DE CARACTERES EM FORMATO DE TÍTULO 6
CENTRAR UM TEXTO 6
ALINHAR O TEXTO À ESQUERDA 6
ALINHAR O TEXTO À DIREITA 7
PREENCHER UM TEXTO COM ZEROS PENDENTES 7
MÉTODOS DE BUSCA 7
CONTAR O NÚMERO DE OCORRÊNCIAS DE UMA SUBSTRING 7
LOCALIZAR UMA SUBSTRING DENTRO DE UMA STRING 7
MÉTODOS DE VALIDAÇÃO 8
- 33 -

4.0
SABER SE UMA STRING É ALFANUMÉRICA 8
SABER SE UMA CADEIA DE CARACTERES É ALFABÉTICA 8
SABER SE UMA CADEIA DE CARACTERES É NUMÉRICA 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS
MINÚSCULAS 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS
MAIÚSCULAS 9
SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS ESPAÇO EM
BRANCO 10
SABER SE UMA CADEIA DE CARACTERES ESTÁ FORMATADA COMO UM TÍTULO
10
MÉTODOS DE SUBSTITUIÇÃO 10
FORMATAR UMA CADEIA DE CARACTERES, SUBSTITUINDO O TEXTO
DINAMICAMENTE 10
SUBSTITUIR TEXTO EM UMA CADEIA DE CARACTERES 11
EXCLUIR CARACTERES À ESQUERDA E À DIREITA DE UMA CADEIA DE
CARACTERES 11
EXCLUIR CARACTERES À ESQUERDA DE UMA CADEIA DE CARACTERES 11
EXCLUIR CARACTERES À DIREITA DE UMA CADEIA DE CARACTERES 11
MÉTODOS DE UNIÃO E DIVISÃO 11
JUNTE-SE A UMA CADEIA ITERATIVAMENTE 11
DIVIDIR UMA CORRENTE EM TRÊS PARTES, USANDO UM SEPARADOR 12
DIVIDIR UMA CORRENTE EM VÁRIAS PARTES, USANDO UM SEPARADOR 12
DIVIDIR UMA CADEIA DE CARACTERES EM LINHAS 12
MANIPULAÇÃO DE LISTAS E TUPLAS 14
MÉTODOS AGREGADOS 14
ADICIONAR UM ITEM AO FINAL DA LISTA 14
ADICIONAR VÁRIOS ITENS AO FINAL DA LISTA 14
ADICIONAR UM ITEM EM UMA POSIÇÃO ESPECÍFICA 14
EXCLUIR O ÚLTIMO ITEM DA LISTA 14
EXCLUIR UM ITEM POR SEU ÍNDICE 15
EXCLUIR UM ITEM POR SEU VALOR 15
MÉTODOS DE ENCOMENDA 15
CLASSIFICAR UMA LISTA EM ORDEM INVERSA (ORDEM INVERSA) 15
ORDENAR UMA LISTA EM ORDEM CRESCENTE 15
- 34 -

4.0
CLASSIFICAR UMA LISTA EM FORMATO DECRESCENTE 15

MÉTODOS DE BUSCA 15
ELEMENTOS DE CONTAGEM DO NÚMERO DE OCORRÊNCIAS 15
OBTER NÚMERO DE ÍNDICE 16
ANEXO RELATIVO ÀS LISTAS E TUPLAS 16
CONVERSÃO DE TIPO 16
CONCATENAÇÃO DE COLEÇÕES 17
VALOR MÁXIMO E MÍNIMO 20
CONTAGEM DE ITENS 20
MANIPULAÇÃO DE DICIONÁRIOS 22
ESVAZIAR UM DICIONÁRIO 22
ADICIONANDO E CRIANDO MÉTODOS 22
COPIAR UM DICIONÁRIO 22
CRIAR UM NOVO DICIONÁRIO A PARTIR DAS CHAVES DE UM 23
SEQÜENCIAR 23
DICIONÁRIOS CONCATENADOS 23
DEFINIR UMA CHAVE E UM VALOR PADRÃO 23
MÉTODOS DE DEVOLUÇÃO 24
OBTER O VALOR DE UMA CHAVE 24
SABER SE EXISTE UMA CHAVE NO DICIONÁRIO 24
OBTER AS CHAVES E VALORES DE UM DICIONÁRIO 24
OBTER AS CHAVES DE UM DICIONÁRIO 24
OBTER VALORES DE UM DICIONÁRIO 25
OBTER O NÚMERO DE ITENS EM UM DICIONÁRIO 25
MANIPULAÇÃO E MANIPULAÇÃO DE ARQUIVOS 27
MANEIRAS DE ABRIR UM ARQUIVO 27
ALGUNS MÉTODOS DO OBJETO FILE 29
MANIPULAÇÃO DE ARQUIVOS CSV 30
ALGUNS EXEMPLOS DE ARQUIVOS CSV 30
TRABALHANDO COM ARQUIVOS CSV DO PYTHON 32
LENDO ARQUIVOS CSV 32
GRAVANDO ARQUIVOS CSV 37
PROBABILIDADE E ESTATÍSTICA COM PYTHON 40
PROBABILIDADE DE EVENTOS SIMPLES E COMPOSTOS MUTUAMENTE
- 35 -

4.0
EXCLUSIVOS EM PYTHON 40
ESPAÇO DE AMOSTRA 40
EVENTOS SIMPLES E COMPOSTOS 40
ATRIBUIÇÃO DE PROBABILIDADE 41
EVENTOS SIMPLES MUTUAMENTE EXCLUSIVOS 41
EVENTOS COMPOSTOS POR EVENTOS SIMPLES E MUTUAMENTE EXCLUSIVOS
42
FUNÇÕES 43
PROBABILIDADE CONDICIONAL EM PYTHON 43
FUNÇÕES 44
EVENTOS DEPENDENTES 44
TEORIA DOS CONJUNTOS EM PYTHON 46
EVENTOS INDEPENDENTES 46
TEOREMA DE BAYES EM PYTHON 47
TEOREMA DE BAYES E PROBABILIDADE DE CAUSAS 47
FATOS: ESTUDO DE CASO 47
ANÁLISE 48
PROCEDIMENTO 49
FUNÇÕES 54
BIBLIOGRAFIA ADICIONAL 54
ANEXO I: CÁLCULOS COMPLEXOS 60
ESTATÍSTICAS POPULACIONAIS E AMOSTRAIS: CÁLCULO DE 60
VARIÂNCIA E DESLOCAMENTO PADRÃO 60
PRODUTO ESCALAR DE DOIS VETORES 61
CÁLCULOS DE FREQUÊNCIA RELATIVA, ABSOLUTA E CUMULATIVA 61
ANEXO II: CRIAÇÃO DE UM MENU DE OPÇÕES 63
Outra maneira de ler arquivos CSV com cabeçalhos é usar o objeto DictReader em vez de leitor e,
assim, acessar apenas o valor das colunas desejadas, pelo nome:
de csv importar DictReader
com open("file.csv", "r") como arquivo: document = DictReader(file, delimiter=';', para linha no documento:
row['DADOS'] quotechar='"')
- 36 -

4.0
Sair:
'2016-03-01 00:00:00'
'2016-03-01 00:30:00'
'2016-03-01 01:00:00'
'2016-03-01 01:30:00'
'2016-03-01 02:00:00'
'2016-03-01 02:30:00'
'2016-03-01 03:00:00'
'2016-03-01 03:30:00'
'2016-03-01 04:00:00'
GRAVANDO ARQUIVOS CSV
Escrevendo um CSV sem um cabeçalho:
Do CSV Import Writer com Open("Data.csv", "W") como arquivo:

documento = writer(file, delimiter=';', quotechar='"') document.writerows(array)
No exemplo acima, uma matriz pode ser uma lista de listas com um número igual de itens. Por
exemplo: matriz = [
['João', 373, 1970],

['Ana', 124, 1983],
['Pedro', 901, 1650],
['Rosa', 300, 2000],
['Juana', 75, 1975],
]
Isso geraria um arquivo chamado dados.csv com o seguinte conteúdo:
eugenia@bella:~$ dados do gato.csv

João;373;1970
Anne;124;1983
Pedro;901;1650
Rosa;300;2000
Joana;75;1975
- 37 -

4.0
Escrevendo um CSV com cabeçalho:
Nesse caso, a matriz a ser escrita precisará ser uma lista de dicionários cujas chaves correspondam
aos cabeçalhos indicados.
matriz = [
dict(player='John', points=373, anium=1970), dict(player='Ana', points=124, anium=1983),
dict(player='Peter', points=901, anium=1650), dict(player='Rose', points=300, anium=2000),
dict(player='Joan', points=75, year=1975), ] de csv import DictWriter
headers = ['player', 'points', 'anium'] com open("data.csv", "w") como arquivo:

documento = DictWriter(arquivo, delimitador=';', quotechar='"',
fieldnames=headers)
document.writeheader()
document.writerows(matriz)
Funções estatísticas simples
Em listas e tuplas obtidas ou não de um CSV, funções estatísticas simples podem ser executadas,
tais como:
Contagem de itens len(coleção)

Adicionar itens soma(coleção)
Obter maior número max(coleção)
Obter número menor min(coleção)
- 38 -

4.0
PROBABILIDADE E ESTATÍSTICA COM PYTHON
PROBABILIDADE DE EVENTOS SIMPLES E COMPOSTOS
MUTUAMENTE EXCLUSIVOS EM PYTHON
ESPAÇO DE AMOSTRA
Um espaço de amostra é um conjunto de eventos possíveis, como aqueles que podem resultar do
lançamento de um dado:
E=(1,2,3,4,5,6)
espacio_muestral = [1, 2, 3, 4, 5, 6]
Refere-se a cada elemento em um espaço de amostra como um ponto de amostragem . O número
de pontos amostrais é indicado por n tal que para o espaço amostralE=11,2,3,4,5,6/

, n=6 .
n = len(espacio_muestral)
EVENTOS SIMPLES E COMPOSTOS

Um evento é um conjunto de resultados dentro de um espaço de amostra. Por exemplo:
• O rolo de um dado é um acontecimento
• a probabilidade de que neste lançamento saia o número 5, é um evento simples A = {5} e é

exclusiva: se sai 5, nenhum outro número pode sair simultaneamente.
• a probabilidade de que um número ímpar saia no lançamento é o evento

compostoB=11,3,5}
que, por sua vez, dependerá dos acontecimentos
exclusões simples ^ = {1} , B2 = {2} e B3 = {3}

4.0
ATRIBUIÇÃO DE PROBABILIDADE
A atribuição de probabilidade é aquela que fornece modelos matemáticos para calcular as chances
de eventos específicos ocorrerem ou não.
A probabilidade de um evento é denotada por P( evento)

.
Os eventos podem ser:
• simples ou composto
• mutuamente excludentes ou independentes
EVENTOS SIMPLES MUTUAMENTE EXCLUSIVOS

Se um espaço amostral A for considerado, cada um dos pontos de amostra k é denotado por Ak e a
probabilidade destes, designada como P(Ak), é determinada por:
P(A,) = -
n
probabilidade = 1,0 / n
Em Python, pelo menos um elemento da equação é necessário para ser um número real se o
que é necessário como resultado é um número real.
A probabilidade de cada ponto amostral, como eventos mutuamente exclusivos, é a mesma para
cada evento.
P^) = P(5) = P(4) = P(3) = P(2) = P(1)
- 41 -

4.0
EVENTOS COMPOSTOS POR EVENTOS SIMPLES E MUTUAMENTE

EXCLUSIVOS
Quando os eventos simples que constituem o evento composto A são mutuamente exclusivos, a
probabilidade do evento composto é dada pela soma das probabilidades de cada evento simples
P(Ak) tal que:
P(A) = P(A1)—P(A2)—.-P(Ak)
Por exemplo, para estimar a probabilidade de que, em um único rolo de dados, um número par saia,
obtemos o evento . 4 = {2. 4,. 6}
, dada pela soma das
probabilidades de cada um dos eventos simples P(2)—P(3)—P(4,do espaço
amostralE=11,2,3,4,5,6}
tal que:
P(A) = P(2) - P(4) +P(6)

P(A) =1+1+1=8
P(A) - |
3
No primeiro resultado 6 (na segunda etapa, antes de encontrar o máximo comum)
1
divisor [MCD] e reduzir a fração para 2 ), o denominador é equivalente ao número de eventos
simples dentro do evento composto "números pares" e é denotado por h . O denominador, 6 , é n , o
total de todos os eventos no espaço amostral. Assim, a probabilidade de um evento composto A por
eventos mutuamente exclusivos é dada pelo quociente de hen tal que:

p(a) = • n
numeros_pares = [i para i em espacio_muestral se i % 2 é 0] h = len(numeros_pares) probabilidade =

float(h) / n
- 42 -

4.0
Um evento composto pode ser denotado pela união de seus eventos simples (símbolo u , lido como
"ou"), tal que:
P(A, u A u ... A,) = P(A, ) + P(A2) + ... Para
Por exemplo, para o caso do evento "números pares", obtém-se que:
P(2U4U 6) = P(2)+P(4)+P(6)
P(2U4U6) = 1++1+1 =8
P(2 U 4 U 6) = |
De tal forma que P(2U4U 6)

é um evento e P(2), P( 4) e P(6) são as probabilidades de
os três eventos que a compõem. Em um novo contexto, U 4 U 6)
Talvez
tratado como evento A.
FUNÇÕES
# Probabilidade de eventos compostos simples mutuamente exclusivos pssme = lambda e: 1.0 / len (e) #
Probabilidade de eventos compostos mutuamente exclusivos def pscme(e, sc):
n = len(e)
retorno len(sc) / float(n)
PROBABILIDADE CONDICIONAL EM PYTHON

B= {2,4,6}
c. Probabilidade de B: P(B) =$=6=2
d. Probabilidade de interseção:
P(ARB) = P(A)P(B)
P(A n B) = 1 I
P(A n B) = I
e = espacio_muestral = [1, 2, 3, 4, 5, 6] n = len(e) # amostra total
# probabilidade de A
a = [i para i em e se i % 2 não for 0] pa = len(a) / float(n)
- 43 -

4.0
# probabilidade de B
b = [i para i em e se i % 2 for 0]
pb = len(b) / float(n)
# Probabilidade da intersecção dos eventos pi = PA * PB
FUNÇÕES
# Probabilidade condicional: eventos dependentes def pscd(e, a, b):
i = lista(set(a).intersection(b))
pi = pscme(e, i)
PA = pscme(e, a)
Retorno Pi / Pa
# Probabilidade condicional: eventos independentes def psci(e, a, b):

PA = pscme(e, a)
pb = pscme(e, b)
retorno pa * pb
EVENTOS DEPENDENTES
Refere-se à probabilidade de que dois eventos ocorram simultaneamente, enquanto o segundo
evento depende da ocorrência do primeiro.
A probabilidade de B ocorrer se A ocorrer, é denotada por P(BA) e lida como "a probabilidade de
B dado A", tal que:
P(BI^ _
1
■ P(A)
Onde PA n B)
é a probabilidade da intersecção dos eventos AeB
— definido como: P{A n B) = P(A )P(B-A,

—, de modo que a interseção é um novo
evento composto de eventos simples. No exemplo abaixo, seria igual a 11,3} (porque 1 e 3 estão em
A e B ).
Exemplo: Qual a probabilidade de rolar um dado resultar em um número ímpar menor que 4?
- 44 -

4.0
O rolo do dado é um acontecimento em si mesmo. Queremos descobrir a probabilidade de B =

{1.2.3} (número menor que 4) já que A = (1,3,5 (número ímpar) ocorreu no espaço amostral E =
{1.2. 3. 4,5,6} .
espacio_muestral = [1, 2, 3, 4, 5, 6]
a = [i para i em espacio_muestral se i % 2 não for 0]
b = [i para i em espacio_muestral se eu < 4]
Para calcular a probabilidade de uma interseção, primeiro obtemos a interseção:
Um ={1,3}
intersec = [i para i em A se i em B]
E então, a probabilidade do novo evento composto é calculada:
112 1
P(AnB)=P(1)+P(3)=+=é=, b0O3
Ou, o que é o mesmo:
poand_1-2_1
n6 3
Também é necessário obter a probabilidade de A , levando em conta que

é também um evento composto:
p_I_2_1
Por fim, obtém-se que:
P(B|A) = P427
P(B|. A) = 1/2
P(B-A) =5=0,6
e = espacio_muestral = [1, 2, 3, 4, 5, 6]
a = [i para i em e se i % 2 não for 0] # números ímpares

b = [i para i em e se i < 4] # números inferiores a 4
- 45 -

4.0
intersec = [i para i em a if i em b] # intersecção de A e B
n = len(e) # Amostra total

ha = len(a) # total de eventos simples em A
hintersec = len(intersec) # Total de eventos simples no cruzamento
# Probabilidade de intersecção
probabilidad_intersec = flutuador (hintersec) / n
# probabilidade de 'a'
probabilidad_a = flutuador (ha) / n
# probabilidade condicional
probabilidad_b_dado_a = probabilidad_intersec / probabilidad_a
TEORIA DOS CONJUNTOS EM PYTHON

Ao obter a intersecção de dois eventos compostos, um método manual foi usado para dizer: retornar
'i' para cada 'i' na lista 'a' se estiver na lista 'b'.
No entanto, como cada evento composto é um conjunto e o Python fornece um tipo de dados
chamado set, é possível obter a interseção manipulando eventos compostos como conjuntos Python.
Com set, você pode converter qualquer iterável em montagem e executar operações de montagem,
como união e interseção, quando necessário. intersec = lista(set(a).intersection(b))
Aqui, o conjunto obtido torna-se uma lista para ser consistente com o resto do código e que o
elemento resultante suporta as operações usuais e o tratamento de uma lista. Em caso de dúvida
sobre se é apropriado usar listas ou conjuntos, o princípio da simplicidade deve ser aplicado e a
solução mais simples implementada.
EVENTOS INDEPENDENTES
Ao contrário do caso anterior, aqui a probabilidade de ocorrência de B não é afetada pela ocorrência
de A . Por exemplo, a probabilidade de rolar um dado
- 46 -

4.0
e a obtenção de um número par (evento B) não é afetada pelo fato de que um número ímpar foi
obtido em um lançamento anterior (evento A). A probabilidade de B é independente de A e é dada
pelo produto da probabilidade de ambos os eventos:
P(AnB) = P(A)P(B)
Aqui, a interseção é a probabilidade de que ambos os eventos convirjam.
Calculada a probabilidade de ambos os eventos independentes, eles são multiplicados obtendo-se:
a. Espaço de amostra (para ambos os eventos):
E = {1,2,3,4,5,0}
b. Probabilidade de A:
.4= {1,3,5}
P(A) = h = 2 = 1
TEOREMA DE BAYES EM PYTHON
TEOREMA DE BAYES E PROBABILIDADE DE CAUSAS

Dada uma série de eventos Ak cuja soma total é um espaço amostral E e qualquer evento B, o
teorema de Bayes nos permite saber a probabilidade de que todo evento Ak de E , é a causa de B .
Por esta razão, também é conhecida como probabilidade de causas.
FATOS: ESTUDO DE CASO

Considerando uma cidade de 50 000 habitantes, com a seguinte distribuição:
- 47 -

4.0
Raparigas Crianças Mulher Homens

11000 9000 16000 14000
E, um relato de 9.000 casos de influenza, distribuídos da seguinte forma:
Meninas Meninos Mulheres Homens

2000 1500 3000 2500
O objectivo é obter a probabilidade de a causa de contrair gripe ser o facto de pertencer a um
determinado sector demográfico (por exemplo, o sector demográfico composto por rapazes ou
raparigas).
ANÁLISE
Do exposto conclui-se que:
• A cidade (total absoluto de habitantes) é o espaço amostral E.

• O número de meninas, meninos, mulheres e homens é cada um dos eventos Ak do espaço de
amostra E
• Como valor de n toma-se a soma do espaço amostral 2 Aa , tal que

n = 50000
• O valor de h para eventos Ak é cada um dos valores dados na tabela de distribuição da

população.
• Ter gripe é evento B.

• A tabela de distribuição dos casos de influenza corresponde às interseções do evento B com
cada evento Ak , ou seja, cada Akn B
Dependendo do cálculo de probabilidade aplicado, será possível obter:
- 48 -

4.0
• A probabilidade de ser menina, menino, mulher ou homem na cidade, por meio de P(Ak) . É
considerada uma probabilidade a priori.
• A probabilidade de ser menina, menino, mulher ou homem e ter gripe, que é obtida com
P(Ak B) e é considerada uma probabilidade condicional.
• A probabilidade de que qualquer habitante, independentemente do setor a que pertença,

tenha gripe, é obtida com
n
P(B)=>P(A)P(BA,)
k=1 e é considerada uma probabilidade total.
• A probabilidade de alguém com gripe ser uma menina, menino, mulher ou homem é obtida
com o Teorema de Bayes. Essa probabilidade é considerada uma probabilidade a posteriori,
permitindo responder a perguntas como qual a probabilidade de um novo caso de
influenza ocorrer em uma criança?
Uma maneira eficaz e ordenada de obter uma probabilidade a posteriori com o Teorema de Bayes é
primeiro obter as três probabilidades anteriores: a priori , condicional e total.
NOTAR:
No futuro, map(float, <list>) será usado no código-fonte, para converter os elementos de uma
lista em números reais, desde que isso não sobrecarregue o código.
PROCEDIMENTO
1. Cálculo de probabilidade a priori
Retornos: probabilidade de um habitante pertencer a um setor demográfico específico.
- 49 -

Fórmula:
Dados necessários:
HK = dados da tabela de distribuição da população
n = é sempre a quantidade total de espaço amostral (50.000)
Resultados:
m) = = 0.22
50000 probabilidade de sergarota
9000
P(A2) = 50000
= 0.18
probabilidade de sercriança
16000
= 0.32
50000
probabilidade de sermulher
14000 = 0.28
50000 probabilidade de serhomem
Código Python:
habitantes = mapa(float, [11000, 9000, 16000, 14000])

n = soma(habitantes)
pa = [h/n para h em habitantes]
2. Probabilidade condicional
Retornos: Probabilidade de ter gripe por demografia

específico.
Certeza: Ak (a demografia)
Gol: B (a probabilidade de ter gripe)
- 50 -

4.0
P(AknB)
P(BAk)= P(A,)
Fórmula:
Dados necessários:
h=B,
P(Ak n B) =
h = interseções (dados da tabela de distribuição de casos de influenza)
Resultados:
. .....
P(AB1)= LÃ1 ___ 0 18
0.22 ' Chance de contrair gripe quando criança
IWO
P(BI A) = 50000 = 0.16
0.18
Probabilidade de ter gripe quando criança
3000
P(BI A3) = Ai _____0 19
0.32 '
Probabilidade de ter gripe como mulher
2500
P(BI A) = LÃ _____0 18
0.28 ' Probabilidade de ter gripe como homem
Código Python:
afetado = map(float, [2000, 1500, 3000, 2500]) pi = [k / n para k em afetado]

PBA = [pi[i] / pa[i] para i no intervalo(len(pi))]
3. Probabilidade total
Retornos: probabilidade de que algum dos habitantes, independentemente da demografia a que
pertença, possa estar gripado.
- 51 -

4.0
n
P(B ) = >P(A,) P(BA,)
Fórmula: k=1
Dados necessários:
Probabilidade a priori
probabilidade condicional
Resultados:
P(B) = PA,) PBA)) PBA)) (])+() PB])
P(B") = 0,22 ■ 0,18-0,18 ■ 0,16+0,32 ■ 0,19 — 0,28 ■ 0,18
PiB] = 0,04 - 0,03 - 0,06 - 0,05
P(B) = 0,18
Código Python:
Produtos = [PA[i] * PBA[I] para I na gama(len(pa))] PB = SOMA(PRODUTOS)
Observações:
(a) Observe que na saída anterior haverá uma diferença de .01 em relação à solução manual. Isso
se deve ao arredondamento realizado na solução manual. Essa diferença pode ser erradicada usando
3 casas decimais nos valores da probabilidade condicional (em vez de duas) na solução manual.
- 52 -

4.0
(b) a probabilidade de NÃO ter gripe será dada por 1 - P(B'l tal que
1 -0,18 = 0,82 mas não será necessário usá-lo para este exemplo com o
Teorema de Bayes.
4. Probabilidade a posteriori
Retornos: probabilidade de pertencer a um grupo demográfico específico e ter gripe.
Certeza: B (gripe)
Objectivo: Ak (probabilidade de pertencer a um sector demográfico específico)
_ . 2P(A,)P(BA+)
Fórmula: k=1
Dados necessários:
PAk) P(BAk,
= o produto obtido em cada um dos termos da probabilidade total
2P(AL)P(B|A)
k=1 = a probabilidade total
Resultados:
= 0.22
Chance de ser uma menina com gripe
0.03
P(A2B)= 0.18
= 0.16
Probabilidade de ser uma criança com gripe
- 53 -

4.0
0.06 —
P(A3B)= = 0.33
0,18 chance de ser mulher gripada
0.05 -
P(A4B)= = 0.27
0,18 chance de ser do sexo masculino gripado
Código Python:
Pab = [p/pb para p em produtos]
FUNÇÕES
# Teorema de Bayes
DEF Bayes(E, B):
n = flutuação(soma(e))
pa = [h/n para h em e]
pi = [k / n para k em b]
PBA = [pi[i] / pa[i] para i no intervalo(len(pi))]
prods = [pa[i] * pba[i] para i no intervalo(len(pa))]
ptb = soma(prods)
Pab = [p/pb para p em prods]
Retorno PAB
BIBLIOGRAFIA ADICIONAL
[0] Probabilidade e Estatística, Murray Spiegel. McGraw-Hill, México 1988. versão impressa ISBN:
968-451-102-7
- 54 -

4.0
ANEXO I: CÁLCULOS COMPLEXOS
ESTATÍSTICAS POPULACIONAIS E AMOSTRAIS: CÁLCULO DE
VARIÂNCIA E DESLOCAMENTO PADRÃO
Da Importação de Matemática SQRT
amostras = [12, 23, 24, 22, 10, 17] # lista de exemplos
n = len(amostras)
média = soma(amostras) / flutuação(n)
Meia
Variância populacional
2 _ H(,2)2
" n
Variância da amostra
Desvio padrão da amostra
Desvio padrão da população
diferenças = [xi - média para xi nas amostras]

potências = [x ** 2 para x em diferenças]
soma = soma(poderes)
varianza_muestral = somatório / (n - 1) varianza_poblacional = soma / n
desvio_muestral = sqrt(varianza_muestral) desvio_poblacional = sqrt(varianza_poblacional)

4.0
PRODUTO ESCALAR DE DOIS VETORES

vetor1 = [3, 0]
vvector2 = [4, 3]
pe = soma([x * y para x, y em zip(vector1, vector2)])
CÁLCULOS DE FREQUÊNCIA RELATIVA, ABSOLUTA E CUMULATIVA

# FREQUÊNCIA ABSOLUTA
# Número de vezes que um valor aparece em uma amostra
Amostras = [1, 2, 3, 4, 3, 2, 6, 7, 3, 3, 1, 8, 5, 9] absoluto = []

frequências = []
para n em amostras:
se não n em absolutos:
absolutos.apêndice(n)
fi = amostras.contagem(n)
frequências.apêndice(fi)
N = soma(frequências) # == len(amostras)
# FREQUÊNCIA RELATIVA
# Razão entre frequência absoluta e N relativo = [float(fi) / N para fi em frequências] soma relativa =
round(sum(relative)) # == 1
# FREQUÊNCIA CUMULATIVA
# Soma de todas as frequências menores ou iguais às frequências absolutas.sort()
cumulativo = [soma(frequências[:i+1]) para i, fi em enumerar(frequências)]
# FREQUÊNCIA RELATIVA ACUMULADA

# Razão entre a frequência acumulada e a quantidade total de dados acumulados = [float(f) / N para f no
acumulado]
- 61 -

4.0
ANEXO II: CRIAÇÃO DE UM MENU DE OPÇÕES
No scripting, pode ser útil dar ao usuário um menu de opções e fazer o script agir de acordo com a
opção escolhida pelo usuário. Abaixo está um truque para resolver isso de forma simples e
engenhosa.
1) Primeiro é necessário que todo o script seja organizado em funções.
2) Em segundo lugar, é necessário que todas as funções tenham sua documentação
correspondente, definindo o que exatamente a função faz:
def leer_archivo():
"""Ler arquivo CSV"""
retornar "leitura"
def escribir_archivo():
"""Gravar arquivo CSV"""
retornar "gravar"
def _sumar_numeros(lista):
"""Adicionar os números de uma lista""" retornar " privado"
3) Em seguida, é definida uma lista com o nome de todas as funções que serão acessíveis pelo
usuário, a partir do menu:
funções = ['leer_archivo', 'escribir_archivo']
A dica será automatizar tanto a geração do menu quanto a chamada para a função.
Para automatizar a geração de menus, a dica é usar:
▪ A lista da etapa 3

4.0
▪ A função locals()
▪ O atributo doc
número = 1 # será então usado para acessar a função

menu = "Escolha uma opção:\n"
para função em funções:

menu += "\t{}. {}\n".format(number, locals()[function].__doc__) number = número + 1 # incrementa o
número em cada iteração
echo(menu)
option = int(get("Sua escolha: "))
# Echo and Get: Hacks aprendidos no curso introdutório
Por fim, para acessar dinamicamente a função escolhida pelo usuário, a dica será usar a opção
escolhida pelo usuário, como um índice para acessar o nome da função da lista, e recorrer
novamente aos locais para invocar a função:
function = funções[opção – 1] locais() # obtém o nome da função

[função]() # A função é invocada usando locals()
- 64 -

4.0
CERTIFICADO
Mostre o quanto você aprendeu!
Se você chegou ao final do curso, você pode obter uma certificação tripla:
- Certificado de frequência (emitido pela escola Eugenia Bahit)

- Certificado de realização (emitido pelo CLA Linux)
- Aprovação de certificação (emitida pela LAECI)
Verifique com seu professor ou visite o site de certificações em http://python.eugeniabahit.org.
Se você precisa se preparar para o seu exame, você pode se inscrever para o
Curso de Ciência de Dados com Python na
Eugenia Bahit
School of Informaticswww.eugeniabahit.com

DataScienceWithPython Ed2018

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

DataScienceWithPython Ed2018

Enviado por

Direitos autorais:

Formatos disponíveis

44444444444.

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

JUNTE-SE A UMA CADEIA ITERATIVAMENTE.....................................................................................11

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

OBTER AS CHAVES E VALORES DE UM DICIONÁRIO........................................................................24

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

CÁLCULOS DE FREQUÊNCIA RELATIVA, ABSOLUTA E CUMULATIVA............................................61

MÉTODOS DE MANIPULAÇÃO DE VARIÁVEIS

MANIPULANDO CADEIAS DE CARACTERES DE TEXTO

organizados por categorias.

CONVERTER A PRIMEIRA LETRA EM MAIÚSCULAS

CONVERTER UMA CADEIA DE CARACTERES EM MINÚSCULAS

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

CONVERTER UMA CADEIA DE CARACTERES EM MAIÚSCULAS

CONVERTER MAIÚSCULAS E MINÚSCULAS E VICE-VERSA

CONVERTER UMA CADEIA DE CARACTERES EM FORMATO DE TÍTULO

> >> cadeia.centro(50, " ")

ALINHAR O TEXTO À ESQUERDA

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

ALINHAR O TEXTO À DIREITA

>>> cadeia.rjust(50, " ")

PREENCHER UM TEXTO COM ZEROS PENDENTES

CONTAR O NÚMERO DE OCORRÊNCIAS DE UMA SUBSTRING

LOCALIZAR UMA SUBSTRING DENTRO DE UMA STRING

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

SABER SE UMA CADEIA DE CARACTERES COMEÇA COM UMA SUBCADEIA DE

SABER SE UMA CADEIA DE CARACTERES TERMINA COM UMA SUBCADEIA DE

SABER SE UMA STRING É ALFANUMÉRICA

SABER SE UMA CADEIA DE CARACTERES É ALFABÉTICA

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

> >> cadeia = "pepegrillo"

SABER SE UMA CADEIA DE CARACTERES É NUMÉRICA

SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MINÚSCULAS

SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS LETRAS MAIÚSCULAS

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

> >> cadeia = "Pepegrillo"

SABER SE UMA CADEIA DE CARACTERES CONTÉM APENAS ESPAÇO EM BRANCO

SABER SE UMA CADEIA DE CARACTERES ESTÁ FORMATADA COMO UM TÍTULO

FORMATAR UMA CADEIA DE CARACTERES, SUBSTITUINDO O TEXTO DINAMICAMENTE

> >> cadeia.formato(bruto=100, VAT=100 * 21 / 100, líquido=100 * 21 / 100 + 100)

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

SUBSTITUIR TEXTO EM UMA CADEIA DE CARACTERES

EXCLUIR CARACTERES À ESQUERDA E À DIREITA DE UMA CADEIA DE CARACTERES

EXCLUIR CARACTERES À ESQUERDA DE UMA CADEIA DE CARACTERES

> >> string = " www.eugeniabahit.com"

EXCLUIR CARACTERES À DIREITA DE UMA CADEIA DE CARACTERES

MÉTODOS DE UNIÃO E DIVISÃO

JUNTE-SE A UMA CADEIA ITERATIVAMENTE

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

>>> número = "275"

DIVIDIR UMA CORRENTE EM TRÊS PARTES, USANDO UM SEPARADOR

> >> protocolo, separador, domínio = tupla

DIVIDIR UMA CORRENTE EM VÁRIAS PARTES, USANDO UM SEPARADOR

DIVIDIR UMA CADEIA DE CARACTERES EM LINHAS

> >> texto = "Linha 1\nLinha 2\nLinha 3"

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

ADICIONAR UM ITEM AO FINAL DA LISTA

ADICIONAR VÁRIOS ITENS AO FINAL DA LISTA

ADICIONAR UM ITEM EM UMA POSIÇÃO ESPECÍFICA

EXCLUIR O ÚLTIMO ITEM DA LISTA

(C) 2011 - 2018 Eugênia Bahit. Atribuição Creative Commons

EXCLUIR UM ITEM POR SEU ÍNDICE

EXCLUIR UM ITEM POR SEU VALOR