├── .gitattributes ├── root ├── arquivos │ ├── saida_lista1_ex2.txt │ ├── entrada_lista1_ex2.txt │ ├── entrada_q3.txt │ ├── saida_q3.txt │ ├── exemplo_1.py │ ├── pratica_q1.py │ ├── pratica-q2.py │ ├── README.md │ └── intro_arquivos.ipynb ├── functions │ ├── exemplo.py │ └── README.md ├── modulos │ └── README.md ├── loops │ └── README.md ├── dicionarios │ └── README.md ├── pilhas │ └── README.md ├── alocacao_dinamica │ └── README.md ├── class │ └── README.md ├── listas │ └── README.md ├── variaveis │ └── README.md ├── vetores │ └── README.md ├── matrizes │ └── README.md ├── busca │ └── README.md ├── ponteiros │ └── README.md ├── condicional │ └── README.md ├── complexidade │ └── README.md └── ordenacao │ └── README.md ├── .gitignore └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | *.ipynb linguist-language=Python 2 | -------------------------------------------------------------------------------- /root/arquivos/saida_lista1_ex2.txt: -------------------------------------------------------------------------------- 1 | Menor elemento: 1 Maior elemento: 19 Media: 7.9 -------------------------------------------------------------------------------- /root/arquivos/entrada_lista1_ex2.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 2 3 | 8 4 | 1 5 | 12 6 | 8 7 | 10 8 | 5 9 | 4 10 | 19 -------------------------------------------------------------------------------- /root/arquivos/entrada_q3.txt: -------------------------------------------------------------------------------- 1 | Amanda 7.0 6.5 9.0 2 | Alberto 5.0 7.0 3.5 3 | Jane 8.0 6.8 4.5 4 | Igor 9.0 9.0 8.5 5 | Samara 10.0 10.0 7.0 6 | Maria Luiza 10.0 10.0 10.0 7 | Cesar 10.0 9.0 8.0 8 | Pedro Felipe 7.0 7.0 7.0 -------------------------------------------------------------------------------- /root/arquivos/saida_q3.txt: -------------------------------------------------------------------------------- 1 | Amanda 7.5 Aprovado Alberto 5.166666666666667 Reprovado Jane 6.433333333333334 Reprovado Igor 8.833333333333334 Aprovado Samara 9.0 Aprovado Maria Luiza 10.0 Aprovado Cesar 9.0 Aprovado Pedro Felipe 7.0 Aprovado -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore all files with the specified extension. 2 | *.ini 3 | *.exe 4 | 5 | 6 | ### VisualStudioCode ### 7 | .vscode/* 8 | .vscode/settings.json 9 | .vscode/tasks.json 10 | .vscode/launch.json 11 | .vscode/extensions.json 12 | *.code-workspace 13 | 14 | ### VisualStudioCode Patch ### 15 | # Ignore all local history of files 16 | .history -------------------------------------------------------------------------------- /root/arquivos/exemplo_1.py: -------------------------------------------------------------------------------- 1 | #Exercício: Crie um arquivo e escreva nele os dados informados pelo o usuario: nome e telefone 2 | 3 | # Importando o modulo os 4 | import os 5 | 6 | # Criando uma variavel para armazenar o nome do arquivo 7 | arquivo = input('Digite o nome do arquivo: ') 8 | 9 | # abrindo o arquivo para escrita 10 | arquivo = open(arquivo, 'w') 11 | 12 | # Criando uma variavel para armazenar o nome do usuario 13 | nome = input('Digite o nome do usuario: ') 14 | 15 | # Criando uma variavel para armazenar o telefone do usuario 16 | telefone = input('Digite o telefone do usuario: ') 17 | 18 | # Escrevendo os dados no arquivo 19 | arquivo.write(nome + ' ' + telefone) 20 | 21 | # Fechando o arquivo 22 | arquivo.close() 23 | 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /root/functions/exemplo.py: -------------------------------------------------------------------------------- 1 | # Exemplo de funções em Python 2 | 3 | def soma(a, b): 4 | """ 5 | Função que soma dois números 6 | """ 7 | return a + b 8 | 9 | def subtracao(a, b): 10 | """ 11 | Função que subtrai dois números 12 | """ 13 | return a - b 14 | 15 | def multiplicacao(a, b): 16 | """ 17 | Função que multiplica dois números 18 | """ 19 | return a * b 20 | 21 | def divisao(a, b): 22 | """ 23 | Função que divide dois números 24 | """ 25 | return a / b 26 | 27 | def main(): 28 | """ 29 | Função principal 30 | """ 31 | print(soma(1, 2)) 32 | print(subtracao(1, 2)) 33 | print(multiplicacao(1, 2)) 34 | print(divisao(1, 2)) 35 | 36 | 37 | if __name__ == '__main__': 38 | main() 39 | 40 | 41 | -------------------------------------------------------------------------------- /root/modulos/README.md: -------------------------------------------------------------------------------- 1 | # Módulos em Python 2 | 3 | Módulos são arquivos Python que podem ser importados em outros arquivos Python. 4 | 5 | ## Criando um módulo 6 | 7 | Para criar um módulo, criamos um arquivo com a extensão .py e escrever o código desejado. Além disso, é necessário criar um arquivo chamado __init__.py para que o Python reconheça o diretório como um módulo. 8 | 9 | Exemplo de um módulo: 10 | 11 | ```python 12 | # modulos\meu_modulo.py 13 | 14 | def soma(a, b): 15 | return a + b 16 | ``` 17 | 18 | ```python 19 | # modulos\__init__.py 20 | 21 | # arquivo vazio 22 | ``` 23 | 24 | ## Importando um módulo 25 | 26 | Para importar um módulo, utilizamos a palavra reservada import seguida do nome do módulo. 27 | 28 | ```python 29 | # importando o módulo criado anteriormente 30 | import meu_modulo 31 | 32 | # chamando a função soma do módulo 33 | resultado = meu_modulo.soma(1, 2) 34 | print(resultado) 35 | ``` 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /root/loops/README.md: -------------------------------------------------------------------------------- 1 | # Laços de repetição em Python 2 | 3 | Os laços de repetição são estruturas de controle que permitem executar um bloco de código várias vezes. 4 | 5 | ## Laço for 6 | 7 | O laço for é usado para iterar sobre uma sequência (lista, tupla, dicionário, conjunto ou string). 8 | 9 | ### Exemplo 1 10 | 11 | ```python 12 | >>> for i in range(5): 13 | ... print(i) 14 | 15 | saída: 16 | ... 17 | 0 18 | 1 19 | 2 20 | 3 21 | 4 22 | ``` 23 | 24 | ### Exemplo 2 25 | 26 | ```python 27 | >>> for i in range(5, 10): 28 | ... print(i) 29 | 30 | saída: 31 | ... 32 | 5 33 | 6 34 | 7 35 | 8 36 | 9 37 | ``` 38 | 39 | ### Exemplo 3 40 | 41 | ```python 42 | 43 | >>> for i in range(0, 10, 3): 44 | ... print(i) 45 | 46 | saída: 47 | ... 48 | 0 49 | 3 50 | 6 51 | 9 52 | ``` 53 | 54 | ### Exemplo 4 55 | 56 | ```python 57 | >>> for i in range(-10, -100, -30): 58 | ... print(i) 59 | 60 | saída: 61 | ... 62 | -10 63 | -40 64 | -70 65 | ``` 66 | 67 | ## Laço while 68 | 69 | O laço while é usado para executar um bloco de código enquanto uma condição for verdadeira. 70 | 71 | ### Exemplo 1 72 | 73 | ```python 74 | >>> i = 1 75 | >>> while i < 6: 76 | ... print(i) 77 | ... i += 1 78 | 79 | saída: 80 | ... 81 | 1 82 | 2 83 | 3 84 | 4 85 | 5 86 | ``` 87 | 88 | -------------------------------------------------------------------------------- /root/dicionarios/README.md: -------------------------------------------------------------------------------- 1 | # Dicionários em Python 2 | 3 | Os dicionários são uma estrutura de dados que permite armazenar uma coleção de itens não ordenados. Cada item é composto por uma chave e um valor. Os itens podem ser de qualquer tipo, como números, strings, objetos, outras listas, etc. 4 | 5 | Dicionários são estruturas de dados que podem armazenar vários valores. São mutáveis, ou seja, podemos alterar seus valores. 6 | 7 | Em Python, os dicionários podem ser declarados da seguinte forma: 8 | 9 | ```python 10 | 11 | dicionario = {"chave1": "valor1", "chave2": "valor2"} 12 | 13 | ``` 14 | 15 | ou ainda 16 | 17 | ```python 18 | 19 | dicionario = dict() 20 | 21 | ``` 22 | 23 | Os dicionários são comumente utilizados em diversas aplicações no mundo real. Por exemplo, podemos armazenar os nomes e idades de todos os alunos de uma turma em um dicionário. 24 | 25 | ```python 26 | 27 | alunos = {"João": 20, "Maria": 19, "José": 21, "Ana": 18, "Pedro": 20} 28 | 29 | ``` 30 | 31 | Para acessar um valor de um dicionário, basta informar a chave correspondente. 32 | 33 | ```python 34 | 35 | alunos["João"] # 20 36 | 37 | ``` 38 | 39 | Os dicionários são mutáveis, o que significa que você pode adicionar, remover e alterar itens depois de criá-los. Exemplos: 40 | 41 | ```python 42 | 43 | frutas = {"maçã": 2, "banana": 3, "laranja": 4} 44 | 45 | # adicionar um item 46 | frutas["manga"] = 5 47 | 48 | # remover um item 49 | del frutas["laranja"] 50 | 51 | ``` 52 | 53 | 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /root/arquivos/pratica_q1.py: -------------------------------------------------------------------------------- 1 | """ 2 | Questão 1: 3 | 4 | Escreva um programa que leia do arquivo entrada_q3.txt 5 | as notas dos alunos de uma turma e calcule a média de cada 6 | aluno. O programa deve escrever o nome do aluno e sua média 7 | em um arquivo de saída chamado saida_q3.txt, bem como 8 | a situação do aluno (aprovado ou reprovado). A média para 9 | aprovação é 7.0. O arquivo de entrada possui o seguinte 10 | formato: 11 | 12 | João da Silva 8.0 7.0 6.0 13 | Maria da Silva 9.0 8.0 7.0 14 | José da Silva 6.0 5.0 4.0 15 | 16 | O arquivo de saída deve ter o seguinte formato: 17 | 18 | João da Silva 7.0 Aprovado 19 | Maria da Silva 8.0 Aprovado 20 | José da Silva 5.0 Reprovado 21 | 22 | """ 23 | 24 | # Abrindo o arquivo de entrada 25 | arquivo_entrada = open('arquivos/entrada_q3.txt', 'r') 26 | 27 | # Abrindo/Criando o arquivo de saída 28 | arquivo_saida = open('arquivos/saida_q3.txt', 'w') 29 | 30 | # Lendo o arquivo de entrada 31 | linhas = arquivo_entrada.readlines() 32 | 33 | # Percorrendo as linhas do arquivo de entrada 34 | for linha in linhas: 35 | # Separando o nome do aluno das notas os dados da linha estão separados por \t 36 | nome, nota1, nota2, nota3 = linha.split('\t') 37 | # Calculando a média 38 | media = (float(nota1) +float(nota2)+float(nota3)) / 3 39 | # Escrevendo no arquivo de saída 40 | arquivo_saida.write(f'{nome} {media} {"Aprovado" if media >= 7 else "Reprovado"}\r ' ) 41 | 42 | # Fechando os arquivos 43 | arquivo_entrada.close() 44 | arquivo_saida.close() 45 | 46 | -------------------------------------------------------------------------------- /root/pilhas/README.md: -------------------------------------------------------------------------------- 1 | # Estrutura de dados: Pilha 2 | 3 | ## Pilha 4 | 5 | Uma pilha é uma estrutura de dados que segue o princípio LIFO (Last In, First Out), ou seja, o último elemento a entrar é o primeiro a sair. Podemos fazer analogia com uma pilha de pratos, onde o último prato a ser colocado na pilha é o primeiro a ser retirado. 6 | 7 | Imagine você em um restaurante com self-service, você vai até a pilha de pratos e o prato que você vai pegar é o que está no topo da pilha. 8 | 9 | Para implementar uma pilha, podemos utilizar uma lista, uma vez que a lista já possui os métodos necessários para a manipulação de uma pilha. 10 | 11 | Vamos criar uma classe Pilha que herda de list, e que implementa os métodos push e pop. 12 | 13 | ### Classe Pilha 14 | 15 | ```python 16 | class Pilha(list): 17 | def push(self, item): 18 | self.append(item) 19 | 20 | def pop(self): 21 | return super().pop() 22 | ``` 23 | 24 | No exemplo a seguir, vamos criar uma pilha e inserir alguns elementos nela. Em seguida, vamos retirar os elementos da pilha, e veremos que o último elemento a entrar é o primeiro a sair. 25 | 26 | ### Exemplo 27 | 28 | ```python 29 | from pilhas import Pilha 30 | 31 | pilha = Pilha() 32 | 33 | pilha.push(1) 34 | pilha.push(2) 35 | pilha.push(3) 36 | 37 | print(pilha.pop()) # 3 38 | print(pilha.pop()) # 2 39 | print(pilha.pop()) # 1 40 | ``` 41 | 42 | ## Métodos 43 | 44 | ### push 45 | 46 | O método push insere um elemento no topo da pilha. 47 | 48 | ### pop 49 | 50 | O método pop remove o elemento do topo da pilha e o retorna. 51 | 52 | 53 | # Exercícios 54 | 55 | 56 | Crie uma classe Pilha que implemente os métodos push e pop, utilizando uma lista como atributo. A classe Pilha deve ter um atributo que indique o tamanho máximo da pilha. A classe Pilha deve ter um atributo que indique o tamanho atual da pilha. 57 | 58 | 59 | -------------------------------------------------------------------------------- /root/arquivos/pratica-q2.py: -------------------------------------------------------------------------------- 1 | """ 2 | Questão 02 : 3 | Escreva um programa em python que preencha 4 | um vetor de 10 inteiros com informações vindas de um arquivo 5 | e escreva em outro arquivo o menor elemento, o maior elemento, 6 | bem como a média dos elementos do vetor 7 | """ 8 | 9 | # Importando biblioteca 10 | import numpy as np 11 | 12 | # Abrindo arquivo 13 | arquivo = open('arquivos\entrada_lista1_ex2.txt', 'r') 14 | 15 | # Lendo arquivo 16 | conteudo = arquivo.read() 17 | 18 | # Fechando arquivo 19 | arquivo.close() 20 | 21 | # Separando conteudo 22 | conteudo = conteudo.split() # o conteudo será um vetor de caracteres 23 | 24 | # Convertendo conteudo para int 25 | conteudo = [int(i) for i in conteudo] 26 | 27 | # Calculando menor elemento com a função min() 28 | menor = min(conteudo) 29 | 30 | """ 31 | Outra forma de calcular o menor elemento sem usar min() 32 | 33 | menor = conteudo[0] 34 | for i in conteudo: 35 | if i < menor: 36 | menor = i 37 | else: 38 | pass 39 | """ 40 | 41 | # Calculando maior elemento com a função max() 42 | maior = max(conteudo) 43 | 44 | """ 45 | Outra forma de calcular o maior elemento sem usar max() 46 | 47 | maior = conteudo[0] 48 | for i in conteudo: 49 | if i > maior: 50 | maior = i 51 | else: 52 | pass 53 | """ 54 | 55 | # Calculando media com a função mean() da biblioteca numpy 56 | media = np.mean(conteudo) 57 | """ 58 | Outra forma de calcular a media sem usar a função mean() 59 | 60 | media = sum(conteudo) / len(conteudo) 61 | 62 | len(conteudo) é tamanho do vetor 63 | """ 64 | 65 | 66 | # Escrevendo arquivo 67 | arquivo = open('arquivos\saida_lista1_ex2.txt', 'w') 68 | 69 | # Escrevendo conteudo 70 | 71 | arquivo.write('Menor elemento: ' + str(menor) + ' ' + 'Maior elemento: ' + str(maior) + ' ' + 'Media: ' + str(media)) 72 | 73 | # Fechando arquivo 74 | arquivo.close() 75 | 76 | 77 | -------------------------------------------------------------------------------- /root/alocacao_dinamica/README.md: -------------------------------------------------------------------------------- 1 | # Alocação dinâmica em Python 2 | 3 | Alocação dinâmica é um conceito que se aplica a qualquer linguagem de programação. 4 | 5 | A alocação dinâmica de memória não é um problema em Python. Isso porque a linguagem é interpretável e não compilável. O gerenciador de memória Python gerencia a alocação ou desalocação do espaço de memória por meio das funções da API. 6 | 7 | 8 | 9 | ## O que é alocação dinâmica? 10 | 11 | Alocação dinâmica é o processo de alocar memória em tempo de execução. Em outras palavras, é o processo de criar variáveis em tempo de execução. 12 | 13 | Na linguagem python não realizamos alocação dinâmica explicitamente. A alocação é feita automaticamente quando criamos uma variável. 14 | 15 | ```python 16 | x = 10 # x é uma variável inteira 17 | ``` 18 | 19 | ## Alocação com Cython 20 | 21 | A biblioteca Cython é uma extensão do Python que permite escrever código em C e C ++ dentro do Python para entender melhor o que é alocação dinâmica. 22 | 23 | Vamos importar a biblioteca Cython e criar uma função que aloca memória para um inteiro. 24 | 25 | ```python 26 | from cython cimport malloc, free 27 | 28 | cdef int *x = malloc(sizeof(int)) 29 | ``` 30 | 31 | A função malloc() aloca memória para um inteiro. A função free() libera a memória alocada. 32 | 33 | ```python 34 | free(x) 35 | ``` 36 | 37 | ## Alocação com ctypes 38 | 39 | A biblioteca ctypes é uma biblioteca Python que permite chamar funções em bibliotecas dinâmicas C. 40 | 41 | Vamos importar a biblioteca ctypes e criar uma função que aloca memória para um inteiro. 42 | 43 | ```python 44 | from ctypes import * 45 | 46 | c_int_p = POINTER(c_int) 47 | 48 | x = c_int_p() 49 | ``` 50 | 51 | A função POINTER() aloca memória para um inteiro. A função free() libera a memória alocada. 52 | 53 | ```python 54 | free(x) 55 | ``` 56 | 57 | ## Alocação com Numpy 58 | 59 | A biblioteca Numpy é uma biblioteca Python que permite realizar operações matemáticas em arrays multidimensionais. 60 | 61 | Vamos importar a biblioteca Numpy e criar uma função que aloca memória para um inteiro. 62 | 63 | ```python 64 | import numpy as np 65 | 66 | x = np.empty(1, dtype=np.int32) 67 | ``` 68 | 69 | A função empty() aloca memória para um inteiro. 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | -------------------------------------------------------------------------------- /root/class/README.md: -------------------------------------------------------------------------------- 1 | # Class na Liguagem Python 2 | 3 | ## O que é uma classe? 4 | 5 | Na programação orientada a objetos, uma classe é um modelo que define os atributos e métodos comuns a todos os objetos de um determinado tipo. Uma classe é uma estrutura que contém dados e métodos que podem ser utilizados por todos os objetos criados a partir dela. 6 | 7 | Se fizermos analogia com uma linguagem estruturada como a linguagem C, podemos dizer que uma classe é uma estrutura que contém dados e métodos que podem ser utilizados por todos os objetos criados a partir dela. 8 | 9 | ## O que é um objeto? 10 | 11 | Um objeto pode ser definido como uma instância de uma classe. Um objeto é uma entidade que possui estado e comportamento. O estado de um objeto é armazenado em campos (variáveis) de dados e o comportamento é definido por métodos. 12 | 13 | ## O que é um método? 14 | 15 | Um método pode ser definido como um bloco de código que é executado quando é chamado. Um método é basicamente um procedimento associado a um objeto. Um método é semelhante a uma função, com a diferença de que um método está associado a um objeto e é executado quando é chamado por um objeto. 16 | 17 | Exemplo: 18 | 19 | ```python 20 | class Pessoa: 21 | def __init__(self, nome, idade): 22 | """ 23 | Construtor da classe Pessoa 24 | """ 25 | self.nome = nome 26 | self.idade = idade 27 | 28 | def falar(self): 29 | """ Método que imprime o nome e a idade da pessoa """ 30 | 31 | print(f'Olá, meu nome é {self.nome} e tenho {self.idade} anos.') 32 | ``` 33 | Declaração de uma classe chamada Pessoa. A classe possui dois atributos: nome e idade. A classe também possui um método chamado falar. 34 | 35 | A seguir, criamos um objeto da classe Pessoa e chamamos o método falar. 36 | 37 | ```python 38 | p1 = Pessoa('João', 32) 39 | p1.falar() 40 | ``` 41 | 42 | Se fizermos analogia com a linguagem C, podemos dizer que um método é uma função que está associada a uma estrutura. E que o construtor é como a estrutura em si, onde fazemos a declaração dos campos (variáveis) de dados. 43 | 44 | 45 | Exemplo em C: 46 | 47 | ```c 48 | struct Pessoa { 49 | char nome[50]; 50 | int idade; 51 | }; 52 | 53 | void falar(struct Pessoa p) { 54 | printf("Olá, meu nome é %s e tenho %d anos.", p.nome, p.idade); 55 | } 56 | ``` 57 | 58 | A seguir, criamos um objeto da estrutura Pessoa e chamamos a função falar. 59 | 60 | ```c 61 | struct Pessoa p1 = {"João", 32}; 62 | falar(p1); 63 | ``` 64 | 65 | -------------------------------------------------------------------------------- /root/listas/README.md: -------------------------------------------------------------------------------- 1 | # Listas em Python 2 | 3 | ## Listas 4 | 5 | As listas são uma estrutura de dados que permite armazenar uma coleção de itens em ordem. Os itens podem ser de qualquer tipo, como números, strings, objetos, outras listas, etc. 6 | 7 | Listas são estruturas de dados que podem armazenar vários valores. São mutáveis, ou seja, podemos alterar seus valores. 8 | 9 | Em Python, as listas podem ser declaradas da seguinte forma: 10 | 11 | ```python 12 | 13 | lista = [1, 2, 3, 4, 5] 14 | 15 | ``` 16 | 17 | 18 | 19 | 20 | Veja que a lista acima armazena valores inteiros. Podemos armazenar qualquer tipo de dado em uma lista, inclusive outras listas. 21 | 22 | ```python 23 | 24 | lista = [1, 2, 3, 4, 5, [6, 7, 8]] 25 | 26 | ``` 27 | 28 | Podemos declarar um lista vazia em Python da seguinte forma: 29 | 30 | ```python 31 | 32 | numeros = list() 33 | 34 | ``` 35 | 36 | ou ainda 37 | 38 | ```python 39 | 40 | numeros = [] 41 | 42 | ``` 43 | 44 | As lista são comumente utilizadas em diversas aplicações no mundo real. Por exemplo, podemos armazenar os nomes de todos os alunos de uma turma em uma lista. 45 | 46 | ```python 47 | 48 | alunos = ["João", "Maria", "José", "Ana", "Pedro"] 49 | 50 | ``` 51 | 52 | As listas são mutáveis, o que significa que você pode adicionar, remover e alterar itens depois de criá-las. Exemplos: 53 | 54 | 55 | ```python 56 | 57 | frutas = ["maçã", "banana", "laranja"] 58 | 59 | # adicionar um item 60 | frutas.append("manga") 61 | 62 | # remover um item 63 | frutas.remove("banana") 64 | 65 | # alterar um item 66 | frutas[1] = "kiwi" 67 | 68 | ``` 69 | 70 | ## Acessando elementos de uma lista 71 | 72 | Para acessar um elemento de uma lista, basta informar o índice do elemento desejado. 73 | 74 | ```python 75 | 76 | frutas = ["maçã", "banana", "laranja"] 77 | 78 | # acessando o primeiro elemento da lista 79 | frutas[0] # maçã 80 | 81 | # acessando o segundo elemento da lista 82 | frutas[1] # banana 83 | 84 | # acessando o terceiro elemento da lista 85 | 86 | frutas[2] # laranja 87 | 88 | ``` 89 | 90 | Você pode usar métodos e operadores para trabalhar com listas, como len() para obter o tamanho da lista, in para verificar se um item está na lista, + para concatenar listas, etc. 91 | 92 | ```python 93 | 94 | frutas = ["maçã", "banana", "laranja"] 95 | 96 | # tamanho da lista 97 | len(frutas) # 3 98 | 99 | # verificar se um item está na lista 100 | "maçã" in frutas # True 101 | 102 | # concatenar listas 103 | frutas + ["manga"] # ["maçã", "banana", "laranja", "manga"] 104 | 105 | ``` 106 | 107 | ## Iterando sobre uma lista 108 | 109 | Você pode iterar sobre uma lista usando um laço for. 110 | 111 | ```python 112 | 113 | # percorrer a lista 114 | for fruta in frutas: 115 | print(fruta) 116 | 117 | # acessar um item 118 | primeira_fruta = frutas[0] 119 | ``` 120 | -------------------------------------------------------------------------------- /root/variaveis/README.md: -------------------------------------------------------------------------------- 1 | # Variáveis em Python 2 | 3 | As variáveis são espaços na memória do computador que armazenam valores. 4 | 5 | ## Declaração de variáveis 6 | 7 | Em Python, a declaração de variáveis é feita de forma implícita, ou seja, não é necessário declarar o tipo da variável. 8 | 9 | ### Exemplo 1 10 | 11 | ```python 12 | >>> x = 5 13 | >>> y = "Hello, World!" 14 | >>> print(x) 15 | 5 16 | >>> print(y) 17 | Hello, World! 18 | ``` 19 | 20 | ### Exemplo 2 21 | 22 | ```python 23 | >>> x = 4 # x é do tipo int 24 | >>> x = "Sally" # x é do tipo str 25 | >>> print(x) 26 | Sally 27 | ``` 28 | 29 | ## Tipos de variáveis em Python 30 | 31 | ### Tipos numéricos 32 | 33 | Os tipos numéricos em Python são `int`, `float` e `complex`. 34 | 35 | #### Exemplo 1 36 | 37 | ```python 38 | >>> x = 1 # int 39 | >>> y = 2.8 # float 40 | >>> z = 1j # complex 41 | ``` 42 | 43 | ### Tipos de sequência 44 | 45 | Os tipos de sequência em Python são `list`, `tuple`, `range` e `str`. 46 | 47 | #### Exemplo 1 48 | 49 | ```python 50 | >>> x = ["apple", "banana", "cherry"] # list 51 | >>> y = ("apple", "banana", "cherry") # tuple 52 | >>> z = range(6) # range 53 | >>> w = "banana" # str 54 | ``` 55 | 56 | ### Tipos de mapeamento 57 | 58 | O tipo de mapeamento em Python é `dict`. 59 | 60 | #### Exemplo 1 61 | 62 | ```python 63 | >>> x = {"name" : "John", "age" : 36} # dict 64 | ``` 65 | 66 | ### Tipos de conjunto 67 | 68 | Os tipos de conjunto em Python são `set` e `frozenset`. 69 | 70 | #### Exemplo 1 71 | 72 | ```python 73 | >>> x = {"apple", "banana", "cherry"} # set 74 | >>> y = frozenset({"apple", "banana", "cherry"}) # frozenset 75 | ``` 76 | 77 | ### Tipos booleanos 78 | 79 | O tipo booleano em Python é `bool`. 80 | 81 | #### Exemplo 1 82 | 83 | ```python 84 | >>> x = True 85 | >>> y = False 86 | ``` 87 | 88 | ### Tipos binários 89 | 90 | O tipo binário em Python é `bytes`. 91 | 92 | #### Exemplo 1 93 | 94 | ```python 95 | >>> x = b"Hello" 96 | ``` 97 | 98 | ### Tipos byte 99 | 100 | O tipo byte em Python é `bytearray`. 101 | 102 | #### Exemplo 1 103 | 104 | ```python 105 | >>> x = bytearray(5) 106 | ``` 107 | 108 | ### Tipos de memória 109 | 110 | Os tipos de memória em Python são `memoryview` e `buffer`. 111 | 112 | #### Exemplo 1 113 | 114 | ```python 115 | >>> x = memoryview(bytes(5)) 116 | ``` 117 | 118 | ### Tipos de dados definidos pelo usuário 119 | 120 | Os tipos de dados definidos pelo usuário em Python são `class` e `module`. 121 | 122 | #### Exemplo 1 123 | 124 | ```python 125 | >>> class MyClass: 126 | ... x = 5 127 | ... 128 | >>> p1 = MyClass() 129 | >>> print(p1.x) 130 | 5 131 | ``` 132 | 133 | ## Variáveis globais 134 | 135 | Variáveis globais são variáveis que podem ser usadas por qualquer parte do código. 136 | 137 | ### Exemplo 1 138 | 139 | ```python 140 | >>> x = "awesome" 141 | 142 | >>> def myfunc(): 143 | ... print("Python is " + x) 144 | 145 | >>> myfunc() 146 | Python is awesome 147 | ``` 148 | -------------------------------------------------------------------------------- /root/vetores/README.md: -------------------------------------------------------------------------------- 1 | # Vetores em Python 2 | 3 | ## O que é um vetor? 4 | 5 | Um vetor é uma estrutura de dados que armazena um conjunto de valores do mesmo tipo. 6 | 7 | ## Vetores em Python 8 | 9 | Em Python, um vetor é representado por uma lista. 10 | 11 | ```python 12 | x = [1, 2, 3, 4, 5] 13 | ``` 14 | 15 | ## Biblioteca Numpy 16 | 17 | A biblioteca Numpy é uma biblioteca Python que permite realizar operações matemáticas em arrays multidimensionais. 18 | 19 | Vamos importar a biblioteca Numpy e criar um vetor com 5 elementos. 20 | 21 | ```python 22 | import numpy as np 23 | 24 | x = np.empty(5, dtype=np.int32) 25 | ``` 26 | 27 | A função empty() aloca memória para um vetor de 5 elementos do tipo inteiro. 28 | 29 | ### Acessando elementos de um vetor 30 | 31 | Vamos acessar o primeiro elemento do vetor. 32 | 33 | ```python 34 | print(x[0]) 35 | ``` 36 | 37 | ### Alterando elementos de um vetor 38 | 39 | Vamos alterar o primeiro elemento do vetor. 40 | 41 | ```python 42 | x[0] = 10 43 | ``` 44 | 45 | ### Percorrendo um vetor 46 | 47 | Vamos percorrer o vetor e imprimir cada elemento. 48 | 49 | ```python 50 | for i in range(len(x)): 51 | print(x[i]) 52 | ``` 53 | 54 | ### Vetores com np.array() 55 | 56 | Vamos criar um vetor com 5 elementos. 57 | 58 | ```python 59 | x = np.array([1, 2, 3, 4, 5]) 60 | ``` 61 | 62 | ### Vetores com np.zeros() 63 | 64 | Vamos criar um vetor com 5 elementos preenchidos com zeros. 65 | 66 | ```python 67 | x = np.zeros(5, dtype=np.int32) 68 | ``` 69 | 70 | ### Vetores com np.ones() 71 | 72 | Vamos criar um vetor com 5 elementos preenchidos com uns. 73 | 74 | ```python 75 | x = np.ones(5, dtype=np.int32) 76 | ``` 77 | 78 | ### Vetores com np.full() 79 | 80 | Vamos criar um vetor com 5 elementos preenchidos com o número 10. 81 | 82 | ```python 83 | x = np.full(5, 10, dtype=np.int32) 84 | ``` 85 | 86 | ### Vetores com np.arange() 87 | 88 | Vamos criar um vetor com 5 elementos preenchidos com os números de 0 a 4. 89 | 90 | ```python 91 | x = np.arange(5) 92 | ``` 93 | 94 | ### Vetores com np.linspace() 95 | 96 | Vamos criar um vetor com 5 elementos preenchidos com os números de 0 a 4. 97 | 98 | ```python 99 | x = np.linspace(0, 4, 5) 100 | ``` 101 | 102 | ### Vetores com np.random.randint() 103 | 104 | Vamos criar um vetor com 5 elementos preenchidos com números aleatórios entre 0 e 10. 105 | 106 | ```python 107 | x = np.random.randint(0, 10, 5) 108 | ``` 109 | 110 | ### Vetores de strings 111 | 112 | Vamos criar um vetor com 5 elementos do tipo string. 113 | 114 | ```python 115 | x = np.array(['a', 'b', 'c', 'd', 'e']) 116 | ``` 117 | 118 | ### Vetores de booleanos 119 | 120 | 121 | Vamos criar um vetor com 5 elementos do tipo booleano. 122 | 123 | ```python 124 | x = np.array([True, False, True, False, True]) 125 | ``` 126 | 127 | ### Vetores com np.random.choice() 128 | 129 | Vamos criar um vetor com 5 elementos preenchidos com números aleatórios entre 0 e 10. 130 | 131 | ```python 132 | x = np.random.choice(10, 5) 133 | ``` 134 | 135 | -------------------------------------------------------------------------------- /root/matrizes/README.md: -------------------------------------------------------------------------------- 1 | # Manipulando matrizes com Python 2 | 3 | ## Matrizes 4 | 5 | Uma matriz é um array bidimensional, ou seja, uma tabela com linhas e colunas. 6 | 7 | ## Biblioteca Numpy 8 | 9 | A biblioteca Numpy é uma biblioteca Python que permite realizar operações matemáticas em arrays multidimensionais. 10 | 11 | Vamos importar a biblioteca Numpy e criar uma matriz com 3 linhas e 2 colunas. 12 | 13 | ```python 14 | import numpy as np 15 | 16 | x = np.empty((3, 2), dtype=np.int32) 17 | ``` 18 | 19 | A função empty() aloca memória para uma matriz de 3 linhas e 2 colunas do tipo inteiro. 20 | 21 | ### Acessando elementos de uma matriz 22 | 23 | Vamos acessar o primeiro elemento da primeira linha da matriz. 24 | 25 | ```python 26 | print(x[0][0]) 27 | ``` 28 | 29 | ### Alterando elementos de uma matriz 30 | 31 | Vamos alterar o primeiro elemento da primeira linha da matriz. 32 | 33 | ```python 34 | x[0][0] = 10 35 | ``` 36 | 37 | ### Percorrendo uma matriz 38 | 39 | Vamos percorrer a matriz e imprimir cada elemento. 40 | 41 | ```python 42 | for i in range(len(x)): 43 | for j in range(len(x[i])): 44 | print(x[i][j]) 45 | ``` 46 | 47 | ### Matrizes com np.array() 48 | 49 | Vamos criar uma matriz com 3 linhas e 2 colunas. 50 | 51 | ```python 52 | x = np.array([[1, 2], [3, 4], [5, 6]]) 53 | ``` 54 | 55 | ### Matrizes com np.zeros() 56 | 57 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com zeros. 58 | 59 | ```python 60 | x = np.zeros((3, 2), dtype=np.int32) 61 | ``` 62 | 63 | ### Matrizes com np.ones() 64 | 65 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com uns. 66 | 67 | ```python 68 | x = np.ones((3, 2), dtype=np.int32) 69 | ``` 70 | 71 | ### Matrizes com np.full() 72 | 73 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com o número 10. 74 | 75 | ```python 76 | x = np.full((3, 2), 10, dtype=np.int32) 77 | ``` 78 | 79 | ### Matrizes com np.eye() 80 | 81 | Vamos criar uma matriz identidade 3x3. 82 | 83 | ```python 84 | x = np.eye(3, dtype=np.int32) 85 | ``` 86 | 87 | ### Matrizes com np.random.random() 88 | 89 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com números aleatórios. 90 | 91 | ```python 92 | x = np.random.random((3, 2)) 93 | ``` 94 | 95 | ### Matrizes com np.arange() 96 | 97 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com números de 0 a 5. 98 | 99 | ```python 100 | x = np.arange(6).reshape(3, 2) 101 | ``` 102 | 103 | ### Matrizes com np.linspace() 104 | 105 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com números de 0 a 5. 106 | 107 | ```python 108 | x = np.linspace(0, 5, 6).reshape(3, 2) 109 | ``` 110 | 111 | ### Matrizes com np.random.randint() 112 | 113 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com números inteiros aleatórios de 0 a 10. 114 | 115 | ```python 116 | x = np.random.randint(0, 10, 6).reshape(3, 2) 117 | ``` 118 | 119 | ### Matrizes com np.random.normal() 120 | 121 | Vamos criar uma matriz com 3 linhas e 2 colunas preenchidas com números aleatórios de uma distribuição normal. 122 | 123 | ```python 124 | x = np.random.normal(0, 1, 6).reshape(3, 2) 125 | ``` 126 | 127 | -------------------------------------------------------------------------------- /root/busca/README.md: -------------------------------------------------------------------------------- 1 | # Algoritmos de Busca 2 | 3 | Os algoritmos de busca são algoritmos que tem como objetivo encontrar um elemento em uma lista ou em outra estrutura de dados. 4 | 5 | Existem diversos algoritmos de busca, cada um com sua particularidade. Neste capítulo, iremos estudar alguns dos algoritmos mais comuns. 6 | 7 | ## Busca Sequencial 8 | 9 | A busca sequencial é um algoritmo de busca que percorre a lista de elementos até encontrar o elemento desejado. Caso o elemento não seja encontrado, o algoritmo retorna um valor especial, como -1. 10 | 11 | ```python 12 | 13 | def busca_sequencial(lista, elemento): 14 | for i in range(len(lista)): 15 | if lista[i] == elemento: 16 | return i 17 | return -1 18 | 19 | ``` 20 | 21 | ## Busca Binária 22 | 23 | A busca binária é um algoritmo de busca que funciona apenas em listas ordenadas. O algoritmo funciona da seguinte forma: 24 | 25 | 1. Encontra o elemento do meio da lista 26 | 2. Compara o elemento do meio com o elemento desejado 27 | 3. Se o elemento do meio for igual ao elemento desejado, retorna o índice do elemento do meio 28 | 4. Se o elemento do meio for menor que o elemento desejado, repete o processo na metade da lista à direita do elemento do meio 29 | 5. Se o elemento do meio for maior que o elemento desejado, repete o processo na metade da lista à esquerda do elemento do meio 30 | 6. Se o elemento não for encontrado, retorna um valor especial, como -1 31 | 32 | ```python 33 | 34 | def busca_binaria(lista, elemento): 35 | inicio = 0 36 | fim = len(lista) - 1 37 | 38 | while inicio <= fim: 39 | meio = (inicio + fim) // 2 40 | if lista[meio] == elemento: 41 | return meio 42 | elif lista[meio] < elemento: 43 | inicio = meio + 1 44 | else: 45 | fim = meio - 1 46 | return -1 47 | 48 | ``` 49 | 50 | ## Busca Interpolação 51 | 52 | A busca por interpolação é um algoritmo de busca que funciona apenas em listas ordenadas. O algoritmo funciona da seguinte forma: 53 | 54 | 1. Encontra o elemento de acordo com a fórmula: `posicao = inicio + ((fim - inicio) // (lista[fim] - lista[inicio])) * (elemento - lista[inicio])` 55 | 2. Compara o elemento encontrado com o elemento desejado 56 | 3. Se o elemento encontrado for igual ao elemento desejado, retorna o índice do elemento encontrado 57 | 4. Se o elemento encontrado for menor que o elemento desejado, repete o processo na metade da lista à direita do elemento encontrado 58 | 5. Se o elemento encontrado for maior que o elemento desejado, repete o processo na metade da lista à esquerda do elemento encontrado 59 | 60 | ```python 61 | 62 | def busca_interpolacao(lista, elemento): 63 | inicio = 0 64 | fim = len(lista) - 1 65 | 66 | while inicio <= fim: 67 | posicao = inicio + ((fim - inicio) // (lista[fim] - lista[inicio])) * (elemento - lista[inicio]) 68 | if lista[posicao] == elemento: 69 | return posicao 70 | elif lista[posicao] < elemento: 71 | inicio = posicao + 1 72 | else: 73 | fim = posicao - 1 74 | return -1 75 | 76 | ``` 77 | 78 | A busca por interpolação é mais eficiente que a busca binária, porém, é necessário que a lista esteja ordenada. Caso a lista não esteja ordenada, a busca por interpolação pode retornar um índice inválido. 79 | 80 | 81 | -------------------------------------------------------------------------------- /root/ponteiros/README.md: -------------------------------------------------------------------------------- 1 | # Ponteiros em Python 2 | 3 | Um ponteiro é uma variável que armazena o endereço de memória de outra variável. Em Python, não há ponteiros, mas podemos simular o comportamento de ponteiros usando o módulo `ctypes`. 4 | 5 | ## O módulo `ctypes` 6 | 7 | O módulo `ctypes` é um módulo Python que fornece uma maneira de usar tipos de dados C em Python. Ele fornece uma maneira de carregar bibliotecas dinâmicas e acessar seus recursos. Ele pode ser usado para criar arrays de dados e manipular strings. 8 | 9 | ## Criando um ponteiro 10 | 11 | Para criar um ponteiro, usamos a função `pointer()` do módulo `ctypes`. Essa função recebe como parâmetro o tipo de dado que o ponteiro irá apontar. 12 | 13 | ```python 14 | from ctypes import pointer, c_int 15 | 16 | ponteiro = pointer(c_int(10)) # ponteiro apontando para um inteiro 17 | 18 | ``` 19 | 20 | ## Acessando o valor apontado 21 | 22 | Para acessar o valor apontado, usamos a função `contents` do módulo `ctypes`. 23 | 24 | ```python 25 | from ctypes import pointer, c_int 26 | 27 | ponteiro = pointer(c_int(10)) 28 | 29 | print(ponteiro.contents) 30 | ``` 31 | 32 | ## Alterando o valor apontado 33 | 34 | Para alterar o valor apontado, usamos a função `contents` do módulo `ctypes`. 35 | 36 | ```python 37 | from ctypes import pointer, c_int 38 | 39 | ponteiro = pointer(c_int(10)) 40 | 41 | ponteiro.contents = 20 # alterando o valor apontado 42 | 43 | print(ponteiro.contents) 44 | ``` 45 | 46 | ## Acessando o endereço de memória 47 | 48 | Para acessar o endereço de memória, usamos a função `addressof` do módulo `ctypes`. 49 | 50 | ```python 51 | from ctypes import pointer, c_int, addressof 52 | 53 | ponteiro = pointer(c_int(10)) 54 | 55 | print(addressof(ponteiro.contents)) 56 | ``` 57 | 58 | ## Acessando o tipo de dado apontado 59 | 60 | Para acessar o tipo de dado apontado, usamos a função `type` do módulo `ctypes`. 61 | 62 | ```python 63 | from ctypes import pointer, c_int, addressof 64 | 65 | ponteiro = pointer(c_int(10)) 66 | 67 | print(type(ponteiro.contents)) 68 | ``` 69 | 70 | ## Acessando o tamanho do tipo de dado apontado 71 | 72 | Para acessar o tamanho do tipo de dado apontado, usamos a função `sizeof` do módulo `ctypes`. 73 | 74 | ```python 75 | from ctypes import pointer, c_int, addressof, sizeof 76 | 77 | ponteiro = pointer(c_int(10)) 78 | 79 | print(sizeof(ponteiro.contents)) 80 | ``` 81 | 82 | ## Acessando o valor apontado por um ponteiro 83 | 84 | Para acessar o valor apontado por um ponteiro, usamos a função `value` do módulo `ctypes`. 85 | 86 | ```python 87 | from ctypes import pointer, c_int, addressof, sizeof, value 88 | 89 | ponteiro = pointer(c_int(10)) 90 | 91 | print(value(ponteiro)) 92 | ``` 93 | 94 | ## Acessando o valor apontado por um ponteiro 95 | 96 | Para acessar o valor apontado por um ponteiro, usamos a função `value` do módulo `ctypes`. 97 | 98 | ```python 99 | from ctypes import pointer, c_int, addressof, sizeof, value 100 | 101 | ponteiro = pointer(c_int(10)) 102 | 103 | print(value(ponteiro)) 104 | ``` 105 | 106 | 107 | Ponteiros em Python são implementados como referências. Referências são ponteiros que apontam para objetos. Ou seja, uma referência é um endereço de memória que armazena o endereço de um objeto. 108 | 109 | ## Exemplo 1 110 | 111 | ```python 112 | >>> x = 5 113 | >>> y = x 114 | >>> x = 10 115 | >>> print(y) 116 | 5 117 | ``` 118 | 119 | ## Exemplo 2 120 | 121 | ```python 122 | >>> x = ["apple", "banana"] 123 | >>> y = x 124 | >>> x[0] = "cherry" 125 | >>> print(y) 126 | ['cherry', 'banana'] 127 | ``` 128 | 129 | ## Exemplo 3 130 | 131 | ```python 132 | >>> x = ["apple", "banana"] 133 | >>> y = x 134 | >>> x = ["cherry", "orange"] 135 | >>> print(y) 136 | ['apple', 'banana'] 137 | ``` 138 | 139 | -------------------------------------------------------------------------------- /root/condicional/README.md: -------------------------------------------------------------------------------- 1 | # Condicionais em Python 2 | 3 | ## IF 4 | 5 | O if é uma estrutura de decisão que permite executar um bloco de código caso uma condição seja verdadeira. 6 | 7 | ```python 8 | if condicao: 9 | # bloco de código 10 | ``` 11 | 12 | ## ELSE 13 | 14 | O else é uma estrutura de decisão que permite executar um bloco de código caso uma condição seja falsa. 15 | 16 | ```python 17 | if condicao: 18 | # bloco de código 19 | else: 20 | # bloco de código 21 | ``` 22 | 23 | ## ELIF 24 | 25 | O elif é uma estrutura de decisão que permite executar um bloco de código caso uma condição seja verdadeira. 26 | 27 | ```python 28 | 29 | if condicao: 30 | # bloco de código 31 | elif condicao: 32 | # bloco de código 33 | else: 34 | # bloco de código 35 | ``` 36 | 37 | ## Operadores de comparação 38 | 39 | | Operador | Descrição | 40 | |:--------:|:---------:| 41 | | == | Igual | 42 | | != | Diferente | 43 | | > | Maior que | 44 | | < | Menor que | 45 | |<= | Menor ou igual a | 46 | |>= | Maior ou igual a | 47 | 48 | 49 | ## Operadores lógicos 50 | 51 | | Operador | Descrição | 52 | |:--------:|:---------:| 53 | | and | E | 54 | | or | Ou | 55 | | not | Negação | 56 | 57 | ## Operadores de identidade 58 | 59 | | Operador | Descrição | 60 | |:--------:|:---------:| 61 | | is | É | 62 | | is not | Não é | 63 | 64 | ## Operadores de associação 65 | 66 | | Operador | Descrição | 67 | |:--------:|:---------:| 68 | | in | Está contido | 69 | | not in | Não está contido | 70 | 71 | ## Exemplos 72 | 73 | ### IF 74 | 75 | ```python 76 | if 1 == 1: 77 | print("1 é igual a 1") 78 | ``` 79 | 80 | ### ELSE 81 | 82 | ```python 83 | if 1 == 2: 84 | print("1 é igual a 2") 85 | else: 86 | print("1 é diferente de 2") 87 | ``` 88 | 89 | ### ELIF 90 | 91 | ```python 92 | 93 | if 1 == 2: 94 | print("1 é igual a 2") 95 | elif 1 == 1: 96 | print("1 é igual a 1") 97 | else: 98 | print("1 é diferente de 2") 99 | ``` 100 | 101 | ### Operadores de comparação 102 | 103 | ```python 104 | if 1 == 1: 105 | print("1 é igual a 1") 106 | 107 | if 1 != 2: 108 | print("1 é diferente de 2") 109 | 110 | if 1 > 2: 111 | print("1 é maior que 2") 112 | 113 | if 1 < 2: 114 | print("1 é menor que 2") 115 | 116 | if 1 <= 2: 117 | print("1 é menor ou igual a 2") 118 | 119 | if 1 >= 2: 120 | print("1 é maior ou igual a 2") 121 | ``` 122 | 123 | ### Operadores lógicos 124 | 125 | ```python 126 | if 1 == 1 and 2 == 2: 127 | print("1 é igual a 1 e 2 é igual a 2") 128 | 129 | if 1 == 1 or 2 == 2: 130 | print("1 é igual a 1 ou 2 é igual a 2") 131 | 132 | if not 1 == 2: 133 | print("1 é diferente de 2") 134 | ``` 135 | 136 | ### Operadores de identidade 137 | 138 | ```python 139 | if 1 is 1: 140 | print("1 é igual a 1") 141 | 142 | if 1 is not 2: 143 | print("1 é diferente de 2") 144 | ``` 145 | 146 | ### Operadores de associação 147 | 148 | ```python 149 | lista = [1, 2, 3, 4, 5] 150 | 151 | if 1 in lista: 152 | print("1 está contido na lista") 153 | 154 | if 6 not in lista: 155 | print("6 não está contido na lista") 156 | ``` 157 | 158 | ## Exercícios 159 | 160 | 1. Crie um programa que receba um número e verifique se ele é par ou ímpar. 161 | 162 | 2. Crie um programa que receba um número e verifique se ele é positivo ou negativo. 163 | 164 | 3. Crie um programa que receba um número e verifique se ele é maior que 10. 165 | 166 | 4. Crie um programa que receba um número e verifique se ele é maior que 10 e menor que 20. 167 | 168 | 5. Crie um programa que receba um número e verifique se ele é maior que 10 e menor que 20 ou se ele é igual a 30. 169 | 170 | 6. Crie um programa que receba um número e verifique se ele é maior que 10 e menor que 20 ou se ele é igual a 30 ou se ele é maior que 40. 171 | 172 | 173 | -------------------------------------------------------------------------------- /root/functions/README.md: -------------------------------------------------------------------------------- 1 | # Definição de Funções com Python 3 2 | 3 | ## Definição de Funções 4 | 5 | Uma função é um bloco de código que executa uma tarefa específica. Uma função é definida usando a palavra-chave def. A sintaxe é a seguinte: 6 | 7 | ```python 8 | def nome_da_funcao(): 9 | # código da função 10 | ``` 11 | 12 | As funções são importantes para a reutilização de código. Por exemplo, se você precisar executar a mesma tarefa várias vezes, você pode definir uma função para executar essa tarefa e, em seguida, chamar a função sempre que você precisar executar a tarefa. 13 | 14 | ## Chamando uma Função 15 | 16 | Para chamar uma função, digite o nome da função seguido de parênteses: 17 | 18 | ```python 19 | nome_da_funcao() 20 | ``` 21 | 22 | ## Argumentos 23 | 24 | As funções podem receber argumentos. Os argumentos são especificados após o nome da função, dentro dos parênteses. Você pode adicionar quantos argumentos quiser, basta separá-los com uma vírgula. 25 | 26 | Os argumentos são frequentemente abreviados como args. 27 | 28 | O exemplo abaixo tem uma função com um argumento (fname). Quando a função é chamada, passamos um argumento, ou valor, que é usado dentro da função para imprimir o nome completo: 29 | 30 | ```python 31 | def nome_completo(fname): 32 | print(fname + " Santos") 33 | 34 | nome_completo("João") 35 | nome_completo("Maria") 36 | nome_completo("José") 37 | ``` 38 | 39 | ## Número Arbitrário de Argumentos 40 | 41 | Se você não souber quantos argumentos que serão passados para sua função, adicione um * antes do nome do parâmetro na definição da função. 42 | 43 | Isso fará com que o parâmetro receba uma tupla de argumentos e você pode acessar os itens de acordo com a necessidade. 44 | 45 | ```python 46 | def nome_completo(*nomes): 47 | print("O nome completo é: " + nomes[0] + " " + nomes[1]) 48 | 49 | nome_completo("João", "Santos") 50 | nome_completo("Maria", "Santos") 51 | nome_completo("José", "Santos") 52 | ``` 53 | 54 | ## Parâmetros de Palavra-chave 55 | 56 | Se você quiser que uma função receba um número fixo de argumentos, adicione dois pontos (:) após o parâmetro e, em seguida, defina os valores padrão para os parâmetros. Isso fará com que o parâmetro seja opcional. 57 | 58 | ```python 59 | def nome_completo(nome, sobrenome = "Santos"): 60 | print(nome + " " + sobrenome) 61 | 62 | nome_completo("João") 63 | nome_completo("Maria") 64 | nome_completo("José") 65 | ``` 66 | 67 | ## Retornando Valores 68 | 69 | Para deixar uma função retornar um valor, use a instrução return: 70 | 71 | ```python 72 | def soma(x, y): 73 | return x + y 74 | 75 | print(soma(5, 3)) 76 | ``` 77 | 78 | ## Recursão 79 | 80 | Uma função pode chamar a si mesma. Isso é chamado de recursão. 81 | 82 | A função abaixo imprime uma sequência de números, começando em 0, e terminando em 10: 83 | 84 | ```python 85 | def recursao(i): 86 | if (i < 10): 87 | print(i) 88 | recursao(i + 1) 89 | 90 | recursao(0) 91 | ``` 92 | 93 | ## Exemplo:Resolvendo o Fatorial com recursão 94 | 95 | O fatorial de um número é o produto de todos os inteiros inferiores a e incluindo ele mesmo. O fatorial de 5 é escrito como 5! e é igual a 1 * 2 * 3 * 4 * 5 = 120. Escreva uma função que calcule o fatorial de um número. 96 | 97 | ```python 98 | def fatorial(n): 99 | if n == 1: 100 | return 1 101 | else: 102 | return n * fatorial(n - 1) 103 | 104 | print(fatorial(5)) 105 | ``` 106 | 107 | ## Exemplo: Resolvendo o Fibonacci com recursão 108 | 109 | O número de Fibonacci é uma sequência de números inteiros, começando normalmente por 0 e 1, na qual, cada termo subsequente corresponde à soma dos dois anteriores. Escreva uma função que calcule o n-ésimo número de Fibonacci. 110 | 111 | ```python 112 | 113 | def fibonacci(n): 114 | if n <= 1: 115 | return n 116 | else: 117 | return(fibonacci(n-1) + fibonacci(n-2)) 118 | 119 | print(fibonacci(9)) 120 | 121 | ``` 122 | 123 | ## Função Lambda 124 | 125 | Uma função lambda é uma pequena função anônima. 126 | 127 | Uma função lambda pode receber qualquer número de argumentos, mas pode ter apenas uma expressão. 128 | 129 | ```python 130 | 131 | x = lambda a : a + 10 132 | print(x(5)) 133 | 134 | ``` 135 | 136 | ## Função Map 137 | 138 | A função map() aplica uma função a todos os itens de um iterável. 139 | 140 | ```python 141 | 142 | def dobro(x): 143 | return x * 2 144 | 145 | valores = [1, 2, 3, 4, 5] 146 | 147 | valores_dobrados = map(dobro, valores) 148 | 149 | print(list(valores_dobrados)) 150 | 151 | ``` 152 | 153 | ## Função Filter 154 | 155 | A função filter() cria uma lista de elementos para os quais uma função retorna True. 156 | 157 | ```python 158 | 159 | def maior_que_5(x): 160 | if x > 5: 161 | return True 162 | else: 163 | return False 164 | 165 | valores = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 166 | 167 | valores_maiores_que_5 = filter(maior_que_5, valores) 168 | 169 | print(list(valores_maiores_que_5)) 170 | 171 | ``` 172 | 173 | 174 | 175 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |
2 | 3 | 4 | 5 | 6 | 7 | icon 8 | 9 |
10 | 11 | # Algorithms and Data Structure with Python 3 12 | ###### Professora: [Rosana Rego](https://github.com/roscibely) 13 | 14 | ### PEX1241 - Algoritmos e Estrutura de dados I 15 | #### Bacharelado Interdisciplinar em Tecnologia da Informação - UFERSA 16 | 17 | --- 18 | #### Parte 0 19 | - Curso auxiliar: 🤜 [Dataquest](https://www.dataquest.io/course/introduction-to-python/) 20 | - :hourglass_flowing_sand: Tempo estimado: 5h 21 | 22 | 1. [Variáveis](https://github.com/roscibely/data-structure-with-python/tree/develop/root/variaveis) 23 | 2. [If-else-elif](https://github.com/roscibely/data-structure-with-python/tree/develop/root/condicional) 24 | 3. [Laços de repetição](https://github.com/roscibely/data-structure-with-python/tree/root/develop/loops) 25 | - Curso auxiliar: 🤜 [Dataquest](https://www.dataquest.io/course/for-loops-and-conditional-statements-in-python/) 26 | - :hourglass_flowing_sand: Tempo estimado: 7h 27 | --- 28 | 29 | #### Parte I 30 | 1. [Funções](https://github.com/roscibely/data-structure-with-python/tree/main/root/functions) 31 | - Curso auxiliar: 🤜 [Dataquest](https://www.dataquest.io/course/python-functions-and-jupyter-notebook/) 32 | - :hourglass_flowing_sand: Tempo estimado: 7h 33 | 2. [Ponteiros](https://github.com/roscibely/data-structure-with-python/tree/develop/root/ponteiros) 34 | 3. [Alocação dinâmica](https://github.com/roscibely/data-structure-with-python/tree/main/root/alocacao_dinamica) 35 | 4. [Vetores](https://github.com/roscibely/data-structure-with-python/tree/develop/root/vetores) 36 | 5. [Matrizes](https://github.com/roscibely/data-structure-with-python/tree/develop/root/matrizes) 37 | 6. [Class](https://github.com/roscibely/data-structure-with-python/tree/develop/root/class) 38 | 39 | --- 40 | #### Parte II 41 | 42 | 1. [Arquivos](https://github.com/roscibely/data-structure-with-python/tree/develop/root/arquivos) 43 | 2. [Módulos](https://github.com/roscibely/data-structure-with-python/tree/develop/root/modulos) 44 | 3. [Complexidade de Algoritmos](https://github.com/roscibely/data-structure-with-python/blob/develop/root/complexidade/README.md) 45 | - Curso auxiliar: 🤜 [Dataquest](https://www.dataquest.io/course/algorithm-complexity/) 46 | - :hourglass_flowing_sand: Tempo estimado: 9h 47 | 4. [Algoritmos de Busca](https://github.com/roscibely/data-structure-with-python/tree/develop/root/busca) 48 | 5. [Algoritmos de Ordenação](https://github.com/roscibely/data-structure-with-python/tree/develop/root/ordenacao) 49 | --- 50 | #### Parte III 51 | 52 | 1. [Dicionários](https://github.com/roscibely/data-structure-with-python/tree/develop/root/dicionarios) 53 | 2. [Estrutura de dados: Lista](https://github.com/roscibely/data-structure-with-python/tree/main/root/listas) 54 | 3. [Estrutura de dados: Pilha](https://github.com/roscibely/data-structure-with-python/tree/develop/root/pilhas) 55 | 4. [Estrutura de dados: Fila] 56 | 57 | - Curso auxiliar: 🤜 [Dataquest](https://www.dataquest.io/course/data-structures-fundamentals/) 58 | - :hourglass_flowing_sand: Tempo estimado: 6h 59 | --- 60 | #### DataCamp Curso 61 | - [Data Structures and Algorithms in Python](https://app.datacamp.com/learn/courses/data-structures-and-algorithms-in-python) 62 | --- 63 | #### Extra 64 | - Git e controle de versão: 🤜 [curso](https://www.dataquest.io/course/git-and-vcs/) 65 | --- 66 | 67 | - Materiais complementares 68 | - Introdução ao Google Colab [![Open in Loom](https://img.shields.io/badge/-Video-83DA77?style=flat-square&logo=loom)](https://www.loom.com/share/8a4f0d34b3cb4d9ea04b6dcf0b3d1aca) 69 | - Google Colab Cont. [opcional ] [![Open in Loom](https://img.shields.io/badge/-Video-83DA77?style=flat-square&logo=loom)](https://www.loom.com/share/d96cb0af7d9c4416bfe8145c93248a11) 70 | - :hourglass_flowing_sand: Tempo estimado: 2h 71 | 72 | --- 73 | #### Inspiração para Projetos Estruturados com Python 3 74 | - Aplicativos móveis 75 | - [Kivy Guide](https://kivy.org/doc/stable/gettingstarted/intro.html) — Kivy é uma ferramenta que permite criar aplicativos móveis com Python. Eles têm um guia para começar. 76 | 77 | - Desenvolvimento Web 78 | - [Bottle Tutorial](https://bottlepy.org/docs/dev/tutorial_app.html) — Bottle é outro framework web para Python. Aqui está um guia para começar a usá-lo. 79 | - [How To Tango With Django](https://www.tangowithdjango.com/) — Um guia para usar o Django, uma complexa estrutura da web em Python. 80 | 81 | - Jogos 82 | - [Pygame Tutorials](https://www.pygame.org/wiki/tutorials) — Aqui está uma lista de tutoriais para Pygame, uma popular biblioteca Python para fazer jogos. 83 | - [Making Games with Pygame](https://www.amazon.com/Making-Games-Python-Pygame-Sweigart/dp/1469901730) — Um livro que ensina como fazer jogos em Python. 84 | 85 |
86 | 87 |
88 | UFERSA - Campus Pau dos Ferros 89 | -------------------------------------------------------------------------------- /root/complexidade/README.md: -------------------------------------------------------------------------------- 1 | # Complexidade de Algoritmos 2 | 3 | ## O que é complexidade de algoritmos? 4 | 5 | Complexidade de algoritmos é uma medida de desempenho de um algoritmo. É uma medida de tempo e espaço de memória que um algoritmo consome para executar uma tarefa. 6 | 7 | ## Como medir a complexidade de algoritmos? 8 | 9 | Existem duas formas de medir a complexidade de algoritmos: 10 | 11 | - Tempo de execução 12 | - Espaço de memória 13 | 14 | ### Tempo de execução 15 | 16 | O tempo de execução de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa. Para medir o tempo de execução de um algoritmo, é necessário executar o algoritmo com diferentes entradas e calcular o tempo de execução para cada entrada. O tempo de execução de um algoritmo é a soma dos tempos de execução para cada entrada. 17 | 18 | ### Espaço de memória 19 | 20 | O espaço de memória de um algoritmo é a quantidade de memória que o algoritmo consome para executar uma tarefa. Para medir o espaço de memória de um algoritmo, é necessário executar o algoritmo com diferentes entradas e calcular o espaço de memória para cada entrada. O espaço de memória de um algoritmo é a soma dos espaços de memória para cada entrada. 21 | 22 | ## Como calcular a complexidade de algoritmos? 23 | 24 | Existem duas formas de calcular a complexidade de algoritmos: 25 | 26 | - Complexidade de tempo 27 | 28 | - Complexidade de espaço 29 | 30 | ### Complexidade de tempo 31 | 32 | A complexidade de tempo de um algoritmo é denotada por T(n), em que n é o tamanho da entrada. A complexidade de tempo de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa com uma entrada de tamanho n. 33 | 34 | Normalmente, utilizamos a notação big-O para denotar a complexidade de tempo de um algoritmo. A notação big-O denota o limite superior da complexidade de tempo de um algoritmo. 35 | 36 | Por exemplo, se T(n) = 2n + 1, então T(n) = O(n). 37 | 38 | ### Complexidade de espaço 39 | 40 | A complexidade de espaço de um algoritmo é denotada por S(n), em que n é o tamanho da entrada. A complexidade de espaço de um algoritmo é a quantidade de memória que o algoritmo consome para executar uma tarefa com uma entrada de tamanho n. 41 | 42 | Normalmente, utilizamos a notação big-O para denotar a complexidade de espaço de um algoritmo. A notação big-O denota o limite superior da complexidade de espaço de um algoritmo. 43 | 44 | 45 | ### Exemplo de complexidade de tempo: 46 | 47 | ```python 48 | # complexidade.py 49 | 50 | def soma(n): 51 | resultado = 0 52 | for i in range(n): 53 | resultado += i 54 | return resultado 55 | 56 | print(soma(10)) 57 | ``` 58 | 59 | O código acima calcula a soma dos números de 0 a n-1. Para calcular a soma dos números de 0 a n-1, o algoritmo soma os números de 0 a n-1. Para cada número de 0 a n-1, o algoritmo soma o número atual com o resultado. O algoritmo faz isso n vezes, uma vez para cada número de 0 a n-1. Portanto, o algoritmo leva n vezes para calcular a soma dos números de 0 a n-1. 60 | 61 | A complexidade de tempo de soma(n) é denotada por T(n). T(n) = O(n), pois o algoritmo leva n vezes para calcular a soma dos números de 0 a n-1. 62 | 63 | ### Exemplo de complexidade de espaço: 64 | 65 | ```python 66 | # complexidade.py 67 | 68 | def soma(n): 69 | resultado = 0 70 | for i in range(n): 71 | resultado += i 72 | return resultado 73 | 74 | print(soma(10)) 75 | 76 | ``` 77 | 78 | A complexidade de espaço de soma(n) é denotada por S(n). S(n) = O(1), pois o algoritmo consome uma quantidade constante de memória para calcular a soma dos números de 0 a n-1. 79 | 80 | ## Exercícios 81 | 82 | 1. Considere o seguinte algoritmo que realiza a multiplicação de matrizes: 83 | 84 | ```python 85 | # multiplicacao.py 86 | 87 | def multiplicacao(A, B): 88 | C = [] 89 | for i in range(len(A)): 90 | C.append([]) 91 | for j in range(len(B[0])): 92 | C[i].append(0) 93 | for k in range(len(B)): 94 | C[i][j] += A[i][k] * B[k][j] 95 | return C 96 | 97 | A = [[1, 2], [3, 4]] 98 | B = [[5, 6], [7, 8]] 99 | print(multiplicacao(A, B)) 100 | ``` 101 | 102 | a) Qual é a complexidade de tempo de multiplicacao(A, B)? 103 | 104 | b) Qual é a complexidade de espaço de multiplicacao(A, B)? 105 | 106 | 2. Considere o seguinte algoritmo que realiza a busca binária em uma lista ordenada: 107 | 108 | ```python 109 | # busca.py 110 | 111 | def busca(lista, elemento): 112 | inicio = 0 113 | fim = len(lista) - 1 114 | while inicio <= fim: 115 | meio = (inicio + fim) // 2 116 | if lista[meio] == elemento: 117 | return meio 118 | elif lista[meio] < elemento: 119 | inicio = meio + 1 120 | else: 121 | fim = meio - 1 122 | return -1 123 | 124 | lista = [1, 2, 3, 4, 5, 6, 7, 8, 9] 125 | print(busca(lista, 5)) 126 | ``` 127 | 128 | a) Qual é a complexidade de tempo de busca(lista, elemento)? 129 | 130 | b) Qual é a complexidade de espaço de busca(lista, elemento)? 131 | 132 | Respostas: 133 | 134 | 1. 135 | - a) T(n) = O(n^3) 136 | 137 | - b) S(n) = O(n^2) 138 | 139 | 2. 140 | - a) T(n) = O(log n) 141 | 142 | - b) S(n) = O(1) 143 | 144 | 145 | 146 | 147 | 148 | -------------------------------------------------------------------------------- /root/arquivos/README.md: -------------------------------------------------------------------------------- 1 | # Manipulando arquivos na linguagem Python 2 | 3 | ## O que é um arquivo? 4 | 5 | Um arquivo é um conjunto de dados gravados em um dispositivo de armazenamento permanente. Um arquivo pode ser qualquer tipo de dado, como um documento, uma imagem, um vídeo, um programa, etc. 6 | 7 | ## Como abrir um arquivo? 8 | 9 | Para abrir um arquivo, utilizamos a função `open()`. Essa função recebe dois parâmetros: o nome do arquivo e o modo de abertura do arquivo. 10 | 11 | ```python 12 | arquivo = open('arquivo.txt', 'r') 13 | ``` 14 | 15 | O primeiro parâmetro é o nome do arquivo que queremos abrir. O segundo parâmetro é o modo de abertura do arquivo. O modo de abertura do arquivo é uma string que pode ser: 16 | 17 | - `'r'`: abre o arquivo para leitura (padrão); 18 | - `'w'`: abre o arquivo para escrita. Se o arquivo não existir, cria um novo arquivo. Se o arquivo existir, apaga o conteúdo do arquivo; 19 | - `'a'`: abre o arquivo para escrita. Se o arquivo não existir, cria um novo arquivo. Se o arquivo existir, escreve o conteúdo no final do arquivo; 20 | - `'x'`: abre o arquivo para escrita. Se o arquivo não existir, cria um novo arquivo. Se o arquivo existir, retorna um erro; 21 | - `'t'`: abre o arquivo em modo texto (padrão); 22 | - `'b'`: abre o arquivo em modo binário. 23 | 24 | ## Como ler um arquivo? 25 | 26 | Para ler um arquivo, utilizamos a função `read()`. Essa função não recebe parâmetros. 27 | 28 | ```python 29 | arquivo = open('arquivo.txt', 'r') 30 | conteudo = arquivo.read() 31 | ``` 32 | 33 | ## Como escrever em um arquivo? 34 | 35 | Para escrever em um arquivo, utilizamos a função `write()`. Essa função recebe um parâmetro: o conteúdo que queremos escrever no arquivo. 36 | 37 | ```python 38 | arquivo = open('arquivo.txt', 'w') 39 | arquivo.write('Olá, mundo!') 40 | ``` 41 | 42 | ## Como fechar um arquivo? 43 | 44 | Para fechar um arquivo, utilizamos a função `close()`. Essa função não recebe parâmetros. 45 | 46 | ```python 47 | arquivo = open('arquivo.txt', 'r') 48 | conteudo = arquivo.read() 49 | arquivo.close() 50 | ``` 51 | 52 | ## Como ler uma linha de um arquivo? 53 | 54 | Para ler uma linha de um arquivo, utilizamos a função `readline()`. Essa função não recebe parâmetros. 55 | 56 | ```python 57 | arquivo = open('arquivo.txt', 'r') 58 | linha = arquivo.readline() 59 | ``` 60 | 61 | ## Como ler todas as linhas de um arquivo? 62 | 63 | Para ler todas as linhas de um arquivo, utilizamos a função `readlines()`. Essa função não recebe parâmetros. 64 | 65 | ```python 66 | arquivo = open('arquivo.txt', 'r') 67 | linhas = arquivo.readlines() 68 | ``` 69 | 70 | A função `readlines()` retorna uma lista com todas as linhas do arquivo. Dessa forma, podemos percorrer a lista com um laço de repetição `for`. 71 | 72 | ```python 73 | arquivo = open('arquivo.txt', 'r') 74 | linhas = arquivo.readlines() 75 | for linha in linhas: 76 | print(linha) 77 | ``` 78 | 79 | Ou ainda podemos ler as linhas do arquivo diretamente com um laço de repetição `for`. 80 | Para ler um arquivo linha a linha utilizamos o laço de repetição `for`. O laço de repetição `for` percorre cada linha do arquivo. 81 | 82 | ```python 83 | arquivo = open('arquivo.txt', 'r') 84 | for linha in arquivo: 85 | print(linha) 86 | ``` 87 | 88 | ## Escrevendo em um arquivo 89 | 90 | Para escrever em um arquivo, utilizamos a função `write()`. Essa função recebe um parâmetro: o conteúdo que queremos escrever no arquivo. 91 | 92 | ```python 93 | arquivo = open('arquivo.txt', 'w') 94 | arquivo.write('Olá, mundo!') 95 | ``` 96 | 97 | ## Exemplo 98 | 99 | ### Exemplo 1 100 | 101 | Escreva um programa que leia um arquivo texto e imprima o conteúdo do arquivo na tela. 102 | 103 | #### Arquivo texto 104 | 105 | ```python 106 | arquivo = open('arquivo.txt', 'r') 107 | conteudo = arquivo.read() 108 | print(conteudo) 109 | ``` 110 | 111 | #### Resultado 112 | 113 | ```python 114 | Olá, mundo! 115 | ``` 116 | 117 | ### Exemplo 2 118 | 119 | Escreva um programa que leia um arquivo texto e imprima o conteúdo do arquivo na tela linha a linha. 120 | 121 | #### Arquivo texto 122 | 123 | ```python 124 | arquivo = open('arquivo.txt', 'r') 125 | for linha in arquivo: 126 | print(linha) 127 | ``` 128 | 129 | ### Exemplo 3 130 | 131 | Escreva um programa que escreva o conteúdo de uma lista em um arquivo texto. 132 | 133 | #### Arquivo texto 134 | 135 | ```python 136 | lista = ['Olá', 'mundo', '!'] 137 | arquivo = open('arquivo.txt', 'w') 138 | for item in lista: 139 | arquivo.write(item + '\n') 140 | ``` 141 | 142 | 143 | 144 | 1. Prática 01 ✅[(clique aqui para ver as questões)](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/arquivos/quest%C3%B5es-pr%C3%A1tica-01-arquivos.pdf): 145 | 146 | 1️⃣ [Acesse a resposta em Python da questão 1](https://github.com/roscibely/data-structure-with-python/blob/main/arquivos/pratica_q1.py) 147 | 148 | 149 | 2️⃣ [Acesse a resposta em Python da questão 2](https://github.com/roscibely/data-structure-with-python/blob/main/arquivos/pratica-q2.py) 150 | 151 | ## [Veja mais exemplos](https://github.com/roscibely/data-structure-with-python/blob/main/arquivos/intro_arquivos.ipynb) 152 | 153 | Veja um exemplo [aqui](https://github.com/roscibely/data-structure-with-python/blob/develop/arquivos/exemplo_1.py) 154 | -------------------------------------------------------------------------------- /root/arquivos/intro_arquivos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# Arquivos com Python 3 \n", 9 | "\n", 10 | "\n", 11 | "Aula sobre manipulação de arquivos com Python 3." 12 | ] 13 | }, 14 | { 15 | "attachments": {}, 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "## Conteúdo\n", 20 | "\n", 21 | "### Introdução\n", 22 | "\n", 23 | "Os arquivos são uma das formas mais comuns de armazenamento de dados. Em Python, podemos manipular arquivos de forma simples e eficiente. Nesta aula, vamos aprender como ler e escrever arquivos com Python 3.\n", 24 | "\n", 25 | "### Lendo arquivos\n", 26 | "\n", 27 | "Para ler um arquivo, usamos a função `open()`. Essa função recebe dois parâmetros: o nome do arquivo e o modo de abertura. O modo de abertura pode ser `r` para leitura, `w` para escrita e `a` para anexar. Por exemplo, para ler o arquivo `arquivo.txt`, usamos:\n" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "# Importando o modulo os\n", 37 | "import os" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "arquivo = open(\"arquivo.txt\", \"r\")" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "# Lendo o conteudo do arquivo\n", 56 | "conteudo = arquivo.read()" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "# Imprimindo o conteudo do arquivo\n", 66 | "print(conteudo)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "# Escrevendo no arquivo\n", 76 | "arquivo.write(\"Escrevendo no arquivo\")\n", 77 | "\n", 78 | "#imprimindo o conteudo do arquivo\n", 79 | "conteudo = arquivo.read()\n", 80 | "print(conteudo)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [ 89 | "# Fechando o arquivo\n", 90 | "arquivo.close()" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "# Escrevendo no arquivo\n", 100 | "arquivo = open(\"arquivo.txt\", \"w\")\n", 101 | "\n", 102 | "# Escrevendo no arquivo\n", 103 | "arquivo.write(\"Escrevendo no arquivo\")\n", 104 | "\n", 105 | "# Fechando o arquivo\n", 106 | "arquivo.close()" 107 | ] 108 | }, 109 | { 110 | "attachments": {}, 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "## Manipulação de arquivos planilhas com Python 3\n", 115 | "\n", 116 | "Para manipular arquivos em formato de planilha, podemos usar a biblioteca `pandas`. Para instalar essa biblioteca, usamos o comando: `pip install pandas`. Para ler um arquivo em formato de planilha, primeiro precisamos importar a biblioteca:\n", 117 | "\n", 118 | "\n", 119 | "\n", 120 | "\n", 121 | "\n" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "import pandas" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "# Lendo o arquivo csv\n", 140 | "\n", 141 | "df = pandas.read_csv(\"arquivo.csv\")\n", 142 | "\n", 143 | "# Imprimindo o conteudo do arquivo\n", 144 | "\n", 145 | "print(df)\n", 146 | "\n", 147 | "# Lendo o arquivo xlsx\n", 148 | "\n", 149 | "df = pandas.read_excel(\"arquivo.xlsx\")\n", 150 | "\n", 151 | "# Imprimindo o conteudo do arquivo\n", 152 | "\n", 153 | "print(df)\n", 154 | "\n", 155 | "# Lendo o arquivo json\n", 156 | "\n", 157 | "df = pandas.read_json(\"arquivo.json\")\n", 158 | "\n", 159 | "# Imprimindo o conteudo do arquivo\n", 160 | "\n", 161 | "print(df)\n", 162 | "\n", 163 | "# Lendo arquivo txt \n", 164 | "arquivo = pandas.read_csv(\"arquivo.txt\")\n", 165 | "\n" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [ 174 | "# Salvando o arquivo csv\n", 175 | "\n", 176 | "df.to_csv(\"arquivo.csv\")\n", 177 | "\n", 178 | "# Salvando o arquivo xlsx\n", 179 | "\n", 180 | "df.to_excel(\"arquivo.xlsx\")" 181 | ] 182 | } 183 | ], 184 | "metadata": { 185 | "kernelspec": { 186 | "display_name": "Python 3", 187 | "language": "python", 188 | "name": "python3" 189 | }, 190 | "language_info": { 191 | "name": "python", 192 | "version": "3.10.7" 193 | }, 194 | "orig_nbformat": 4, 195 | "vscode": { 196 | "interpreter": { 197 | "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77" 198 | } 199 | } 200 | }, 201 | "nbformat": 4, 202 | "nbformat_minor": 2 203 | } 204 | -------------------------------------------------------------------------------- /root/ordenacao/README.md: -------------------------------------------------------------------------------- 1 | # Algoritmos de Ordenação 2 | 3 | Os algoritmos de ordenação são algoritmos que tem como objetivo ordenar um conjunto de dados. Em situações práticas, tais como, busca de dados em um banco de dados, é necessário que os dados estejam ordenados para que a busca seja feita de forma eficiente. 4 | 5 | No mundo real, os algoritmos de ordenação são utilizados para ordenar dados de forma crescente ou decrescente. Por exemplo, uma lista de nomes, um conjunto de números, etc. 6 | 7 | ## Tipos de Ordenação 8 | 9 | Existem diversos tipos de ordenação, porém, os mais comuns são: 10 | 11 | - Ordenação por Intercalação 12 | - Ordenação por Seleção 13 | - Ordenação por Inserção 14 | - Ordenação por Troca 15 | - Ordenação por Contagem 16 | - Ordenação por Distribuição 17 | 18 | ## Ordenação por Intercalação 19 | 20 | A ordenação por intercalação, também conhecido como merge sort, é um algoritmo de ordenação que consiste em dividir o conjunto de dados em partes, ordenar cada uma das partes e depois intercalar as partes ordenadas. 21 | 22 | Exemplo de implementação com Python: 23 | 24 | ```python 25 | 26 | # implementação recursiva 27 | def merge_sort(lista): 28 | if len(lista) <= 1: 29 | return lista 30 | 31 | meio = len(lista) // 2 32 | lado_esquerdo = merge_sort(lista[:meio]) 33 | lado_direito = merge_sort(lista[meio:]) 34 | 35 | return merge(lado_esquerdo, lado_direito) 36 | 37 | # implementação da função merge 38 | def merge(lado_esquerdo, lado_direito): 39 | if not lado_esquerdo: 40 | return lado_direito 41 | 42 | if not lado_direito: 43 | return lado_esquerdo 44 | 45 | if lado_esquerdo[0] < lado_direito[0]: 46 | return [lado_esquerdo[0]] + merge(lado_esquerdo[1:], lado_direito) 47 | 48 | return [lado_direito[0]] + merge(lado_esquerdo, lado_direito[1:]) 49 | 50 | ``` 51 | 52 | A complexidade de tempo do algoritmo de ordenação por intercalação é O(n log n). Para entender melhor a complexidade, vamos analisar o algoritmo de ordenação por intercalação de forma recursiva. O algoritmo de ordenação por intercalação é composto por duas funções: a função merge_sort e a função merge. A função merge_sort é responsável por dividir o conjunto de dados em partes, ordenar cada uma das partes e depois intercalar as partes ordenadas. A função merge é responsável por intercalar as partes ordenadas. A função merge_sort é chamada recursivamente até que o conjunto de dados seja dividido em partes com apenas um elemento. A função merge é chamada até que todas as partes ordenadas sejam intercaladas. A complexidade do algoritmo de ordenação por intercalação é O(n log n) porque a função merge_sort é chamada recursivamente log n vezes e a função merge é chamada n vezes. 53 | 54 | Para chegar a complexidade O(n log n), podemos utilizar o teorema mestre. O teorema mestre é um teorema que estabelece uma relação entre a complexidade de um algoritmo recursivo e a complexidade de seus subproblemas. O teorema mestre é composto por três casos: 55 | 56 | - Caso 1: T(n) = aT(n/b) + f(n), onde a >= 1, b > 1 e f(n) é uma função polinomial. Neste caso, a complexidade do algoritmo é O(n log b a). 57 | - Caso 2: T(n) = T(n/b) + f(n), onde b > 1 e f(n) é uma função polinomial. Neste caso, a complexidade do algoritmo é O(n log b). 58 | - Caso 3: T(n) = T(n/b) + f(n), onde b > 1 e f(n) é uma função exponencial. Neste caso, a complexidade do algoritmo é O(n log n). 59 | 60 | O algoritmo de ordenação por intercalação é do tipo Caso 2. Pois a função custo do algoritmo de ordenação por intercalação é T(n) = T(n/2) + n. Logo, b = 2 e f(n) = n. 61 | 62 | Matematicamente, podemos escrever a complexidade do algoritmo de ordenação por intercalação como: 63 | 64 | O(n log n) = O(n) * O(log n) 65 | 66 | 67 | 68 | 69 | ## Ordenação por Seleção 70 | 71 | A ordenação por seleção é um algoritmo de ordenação que consiste em percorrer o conjunto de dados e selecionar o menor elemento, trocando-o com o elemento da primeira posição. Em seguida, percorre o conjunto de dados novamente, selecionando o menor elemento e trocando-o com o elemento da segunda posição. O processo é repetido até que todos os elementos estejam ordenados. 72 | 73 | Exemplo de implementação com Python: 74 | 75 | ```python 76 | 77 | def selection_sort(lista): 78 | fim = len(lista) 79 | 80 | for i in range(fim - 1): 81 | # inicialmente, o menor elemento já visto é o i-ésimo 82 | posicao_do_minimo = i 83 | 84 | for j in range(i + 1, fim): 85 | if lista[j] < lista[posicao_do_minimo]: 86 | posicao_do_minimo = j 87 | 88 | # Coloca o menor elemento encontrado no início da sub-lista 89 | # para ordenar os elementos até a posição i 90 | lista[i], lista[posicao_do_minimo] = lista[posicao_do_minimo], lista[i] 91 | 92 | ``` 93 | 94 | A complexidade de tempo do _selection sort_ é O(n²). 95 | 96 | Para entender melhor a complexidade, vamos analisar o algoritmo de ordenação por seleção. Dentro da função selection_sort, temos dois laços de repetição: 97 | 98 | - O primeiro laço de repetição é responsável por percorrer o conjunto de dados e selecionar o menor elemento. Este laço de repetição é executado n vezes, pois o conjunto de dados é percorrido n vezes. 99 | - O segundo laço de repetição é responsável por percorrer o conjunto de dados e verificar se o elemento atual é menor que o menor elemento já visto. O segundo laço de repetição é executado n vezes, pois o conjunto de dados é percorrido n vezes. 100 | - Logo, a complexidade do algoritmo de ordenação por seleção é n*n, ou seja, O(n²). 101 | 102 | 103 | 104 | ## Ordenação por Inserção 105 | 106 | A ordenação por inserção é um algoritmo de ordenação que consiste em percorrer o conjunto de dados e inserir cada elemento na posição correta. Para isso, é necessário percorrer a lista até o elemento anterior ao elemento que está sendo inserido e verificar se o elemento que está sendo inserido é menor que o elemento anterior. Caso seja, o elemento anterior é deslocado para a direita e o elemento que está sendo inserido é inserido na posição anterior. 107 | 108 | Exemplo de implementação com Python: 109 | 110 | ```python 111 | 112 | def insertion_sort(lista): 113 | for i in range(1, len(lista)): 114 | chave = lista[i] 115 | j = i - 1 116 | while j >= 0 and chave < lista[j]: 117 | lista[j + 1] = lista[j] 118 | j -= 1 119 | lista[j + 1] = chave 120 | 121 | ``` 122 | 123 | A complexidade de tempo do _insertion sort_ é O(n²). Na função insertion_sort, temos dois laços de repetição: 124 | 125 | - O primeiro laço de repetição é responsável por percorrer o conjunto de dados e inserir cada elemento na posição correta. Este laço de repetição é executado n vezes, pois o conjunto de dados é percorrido n vezes. 126 | 127 | - O segundo laço de repetição é responsável por percorrer a lista até o elemento anterior ao elemento que está sendo inserido e verificar se o elemento que está sendo inserido é menor que o elemento anterior. O segundo laço de repetição é executado n vezes, pois o conjunto de dados é percorrido n vezes. 128 | 129 | - Logo, a complexidade do algoritmo de ordenação por inserção é n*n, ou seja, O(n²) no pior caso. 130 | 131 | No melhor caso, a complexidade de tempo é O(n). Pois, no melhor caso, a lista já está ordenada e o algoritmo não precisa fazer nenhuma troca. Ou seja, o laço de repetição interno não é executado nenhuma vez. 132 | 133 | ## Ordenação por Troca 134 | 135 | A ordenação por troca é um algoritmo de ordenação que consiste em percorrer o conjunto de dados e trocar dois elementos de posição se o primeiro elemento for maior que o segundo elemento. O processo é repetido até que todos os elementos estejam ordenados. 136 | 137 | Exemplo de implementação com Python: 138 | 139 | ```python 140 | 141 | def bubble_sort(lista): 142 | fim = len(lista) 143 | 144 | for i in range(fim - 1, 0, -1): 145 | for j in range(i): 146 | if lista[j] > lista[j + 1]: 147 | lista[j], lista[j + 1] = lista[j + 1], lista[j] 148 | 149 | ``` 150 | 151 | A complexidade de tempo do _bubble sort_ é O(n²). 152 | 153 | 154 | 155 | 156 | --------------------------------------------------------------------------------