Introdução à Linguagem Python para Engenharia Mecânica

Prévia do material em texto

ENGENHARIA MECÂNICA
10º SEMESTRE – TURMA TUTELADA
APS – ATIVIDADES PRÁTICAS SUPERVISIONADAS
Ribeirão Preto – SP
SUMÁRIO
1. INTRODUÇÃO ..................................................................................................4
2. HISTÓRIA .........................................................................................................5
3. LINGUAGENS DE PYTHON ...............................................................................6
3.1.0. Variáveis ........................................................................................6
3.1.1. Valor nulo (null) .............................................................................6
	3.1.2. Saídas .............................................................................................6
	3.1.3. Entradas .........................................................................................6
3.1.4. Endentação ....................................................................................7
	3.1.5. Blocos ............................................................................................7
	3.1.6. Comentários .....................................................................................8
	3.1.7. Tipos de dados básicos ....................................................................8
	3.1.8. Números ...........................................................................................9
	3.1.9. Strings ...............................................................................................9
	3.2.0. Métodos básicos de string .............................................................10	
	3.2.1. Acessando pelo index .....................................................................10
	3.2.2. Percorrendo strings (string lopping) ..............................................10
	3.2.3. Controle de fluxo (condicionais) ....................................................11
	3.2.4. Laços de repetição ..........................................................................11
	3.2.5. Funções ..............................................................................................12
	3.2.6. Imports ............................................................................................12
	3.2.7. Datas ...............................................................................................12
	3.2.8. Listas (lists) ......................................................................................13
	3.2.9. range() .............................................................................................13
	3.3.0. Lambdas ..........................................................................................13
	3.3.1. OOP - Programação Orientada a Objetos ......................................14
4. MODULOS .........................................................................................................15
	4.1. Escrevendo módulos ..........................................................................15
5. POLIMORFISMO ................................................................................................16
	5.1. Polimorfismo em Python .........................................................................16
	5.2. Exemplo de polimorfismo em Python ............................................17
	5.3. Implementação de uma interface em Python ...............................17
	5.4. Desenvolvimento das classes concretas ........................................18
	5.5. Como utilizar o polimorfismo em Python ......................................18
	5.6. Duck Tiping ......................................................................................19
6. EXCEÇÕES .......................................................................................................20
	6.1. Onde isso prejudica o bom design de programas ..........................20
	6.2. Como funciona o mecanismo de exceções .....................................21
	6.3. Como construir e como lançar uma exceção ..................................22
	6.4. Exemplo ...........................................................................................22
7. CONCORRENCIA E PARALELISMO ..................................................................23
	7.1. Paralelismo ......................................................................................23
7.2. Concorrência ....................................................................................23
7.3. Classificação dos processos .............................................................24
7.4. I/O Bound ........................................................................................25
7.5. CPU E I/O BOUND ............................................................................25
8. PROCESSOS E THREADS ..................................................................................26
8.1. Múltiplos processos .........................................................................26
8.2. Subprocessos ....................................................................................26
8.3. Threads .............................................................................................27
9. DISSERTAÇÃO ..................................................................................................28
10. REFERÊNCIAS BIBLIOGRAFICAS .....................................................................29
1. INTRODUÇÃO
O Python é uma linguagem de programação de alto nível e muito versátil. Ela suporta tanto a programação orientada a objetos quanto a programação estruturada. Com Python, você pode acessar bibliotecas nativas que oferecem funcionalidades para desenvolvimento de projetos e implementação de aplicações complexas. A tecnologia está presente em diversos códigos de grandes empresas tais como: Instagram, Netflix, Spotify, Reddit, Facebook, Google e muitos outros. Os objetivos do projeto da linguagem eram: produtividade e legibilidade. Em outras palavras, Python é uma linguagem que foi criada para produzir código bom e fácil de manter de maneira rápida. Entre as características da linguagem que ressaltam esses objetivos estão:
· baixo uso de caracteres especiais, o que torna a linguagem muito parecida com pseudo-código executável;
· o uso de identação para marcar blocos;
· quase nenhum uso de palavras-chave voltadas para a compilação;
· coletor de lixo para gerenciar automaticamente o uso da memória;
Além disso, Python suporta múltiplos paradigmas de programação. A programação procedimental pode ser usada para programas simples e rápidos, mas estruturas de dados complexas, como tuplas, listas e dicionários, estão disponíveis para facilitar o desenvolvimento de algoritmos complexos. Grandes projetos podem ser feitos usando técnicas de orientação a objetos, que é completamente suportada em Python (inclusive sobrecarga de operadores e herança múltipla). Um suporte modesto para programação funcional existe, o que torna a linguagem extremamente expressiva: é fácil fazer muita coisa com poucas linhas de comando. E possui inúmeras capacidades de meta-programação: técnicas simples para alterar o comportamento de comportamentos da linguagem, permitindo a criação de linguagens de domínio específico.
2. HISTÓRIA 
Desenvolvida pelo matemático holandês Guido van Rossum, atualmente a linguagem faz parte de um modelo de desenvolvimento comunitário, gerenciado pela organização sem fins lucrativos Python Software Foundation. Lançada no começo dos anos 90, a linguagem tem ganhado crescente notoriedade nos últimos anos, tornando-se uma das mais populares entre programadores, principalmente pela sua funcionalidade com dados, big data e inteligência artificial. A linguagem Phyton foi concebida no fim dos anos 80, a primeira ideia de implantar o Phyton surgiu mais especificamente em meados de 1982, quando Guido Van Rossum trabalhava no CWI (CENTRUM WISKUNDE E INFORMATICA, CENTRO DE MATEMÁTICA E CIÊNCIA DA COMPUTAÇÃO) em Amsterdã Holanda, até então no timede desenvolvimento da linguagem ABC. Posteriormente em 1987, com o fim da linguagem ABC, Guido foi transferido para o grupo de trabalho Amoeba, um sistema operacional Microkernel liderado por Andrew Tanenbaum. 
Foi neste grupo que Guido percebeu a necessidade da linguagem para escrever programas intermediários, algo entre o C e o Shell Script. No ano de 1991 Guido foi transferido para grupo Multimídia. De acordo com Guido o ABC deu inspiração crucial para o Phyton, o grupo Amoeba deu-lhe motivação imediata, e o grupo multimídia forneceu todo suporte para seu crescimento profissional. No dia 20 de fevereiro do mesmo ano, foi lançada a primeira versão da linguagem Phyton, então chamada de v0.9.0. Da primeira versão até a versão 1.2, tiveram seu lançamento dentro do CWI. No início de 2000, Guido, Barry Warsaw, Jeremy Hylton e Fred Drake receberam o convite para participarem da então startup, “BeOpen.com”, uma iniciativa que estava recrutando diversos desenvolvedores “Open Source”. 
O início do ciclo de desenvolvimento “Phyton” na “BeOpen.com” formando o grupo “PhytonLabs”, gerando em seguida a versão 2.0 Phyton, sendo lançada em outubro de 2000.
Algum tempo depois, após a companhia “BeOpen.com” falir e ser desmembrada, a “PhytonLabs” foi contratado pela empresa “Digital Creations”, posteriormente mudou seu nome para “Zope Corporation”.
Em 2001 foi criado a Phyton Software Fundation (PSF), uma organização sem fins lucrativos, constituída por membros da equipe de desenvolvimento e por Eric Raymond. A fundação tem como objetivo maior, ser dona de qualquer propriedade intelectual relacionada ao Phyton, e com a missão de promover e proteger o avanço da linguagem Phyton, além de dar todo suporte e auxiliar o crescimento de comunidade de programadores.
3. LINGUAGENS DE PYTHON 
3.1.0. Variáveis
Uma variável é um nome que se refere a um valor. Um comando de atribuição criar  uma nova variável e lhe dá um valor. Variáveis são usadas para guardarmos valores que serão usados mais tarde no programa. Uma variável não pode ser utilizada em uma expressão sem ter sido inicializada. Não existe “criação automática” de variáveis.
Exemplo de atribuição:
reais = euros * taxa
As variáveis euros e taxa devem ser inicializadas, se não o erro name 'euros' is not defined será exibido.
Também podemos inicializar mais de uma variável dessa forma…
>>> a, b = 10, 20 
>>> a 10 
>>> b 20
3.1.1. Valor nulo (null)
Em Python, None equivale ao valor nulo (null).
Podemos iniciar as variáveis com o valor None.
reais = None
3.1.2. Saídas
Saída simples válido para a versão 3 de Python.
print("Welcome to Python!")
Saída mais elaborada.
string_1 = "Camelot" 
string_2 = "place" print("Let's not go to %s. 'Tis a silly %s." % 
(string_1, string_2))
3.1.3. Entradas
name = input("What is your name?") 
quest = input("What is your quest?") 
color = input("What is your favorite color?") 
print("Ah, so your name is %s, your quest is %s, " \ "and your favorite color is %s." % (name, quest, color) )
3.1.4. Endentação
Python usa endentação como delimitação de bloco, portanto devemos endentar corretamente o código fonte.
Abaixo vemos um código endentado de forma errada:
def spam(): eggs = 12 
return eggs
print(spam())
Abaixo, vemos o mesmo código corrigido:
def spam(): eggs = 12 
return eggs p
rint(spam())
3.1.5. Blocos
Como visto acima, Python usa endentação como delimitação de bloco.
Abaixo vemos os comandos que aceitam blocos:
· if/elif/else
· for/else
· while/else
· def
· try/except /finally/else
· class
· with
Se o bloco tem apenas um comando, pode-se escrever tudo em uma linha:
if n < 0: print('Valor inválido')
3.1.6. Comentários
Em linha.
# comentário de linha 
""" Esse é de bloco mas está em uma linha só """
Em bloco.
""" comentários 
comentários 
comentários """
Aspas simples também funciona.
''' this is 
a multi-line 
comment, i am handy for commenting out whole 
chunks of code very fast '''
3.1.7. Tipos de dados básicos
	
	Números:
	int, long, float, complex
	Strings:
	str e unicode
	Listas e tuplas:
	list, tuple
	Dicionários:
	dict
	Arquivos:
	file
	Booleanos:
	bool (True, False)
	Conjuntos:
	set, frozenset
	None:
	
Se, por exemplo, você digitar no console dict ele retornará:
<class 'dict'>
A função type() mostra o tipo do dado, veja alguns exemplos.
ype("text") # <class 'str'> 
type(1) # <class 'int'> 
type(0.99) # <class 'float'>
Também é possível elaborar as seguintes expressões.
type(1) == int # True 
type(0.99) == float # True
3.1.8. Números
Python possui + - * /, nem precisava falar!.
Mas talvez você se pergunte como calcular uma potência.
10 ** 2 # print(100)
u o resto da divisão com o operador módulo %.
3 % 2 = 1 5 % 2 = 1
Veja também algumas funções matemáticas:
max(5, 6, 7) # 7 
min(5, 6, 7) # 5 
abs(-1) # 1
Para trabalhar com números randômicos será preciso importar o módulo random.
import random 
random.randint(1, 10)
O código acima irá gerar números randômicos entre 1 e 10 (incluindo o 1 e o 10).
3.1.9. Strings
Concatenamos strings com o sinal +.
"Spam " + "and" + " eggs" 
Quando concatenamos com um número, precisamos fazer a conversão.
The value of pi is around " + str(3.14)
Escapamos (scape) caracters com o sinal \
'There's a snake in my boot!' # errado 'There\'s a snake in my boot!' # correto
3.2.0. Métodos básicos de string
	função
	descrição
	len()
	mostra o tamanho da string
	lower()
	caixa baixa
	upper()
	caixa alta
	str()
	converte em string
	isalpha()
	retorna False se a string contiver algum caracter que não seja letras
Exemplo, "flavio.upper()" equivale a FLAVIO.
3.2.1. Acessando pelo index
+---+---+---+---+---+---+ 
| p | y | t | h | o | n | 
+---+---+---+---+---+---+ 
0 1 2 3 4 5
"python"[0] # 'p'
"python"[1] # 'y' 
"python"[2] # 't'
"python"[3] # 'h' 
"python"[4] # 'o'
"python"[5] # 'n'
3.2.2. Percorrendo strings (string lopping)
for letter in "python": print(letter) 
""" 
p 
y 
t 
h 
o 
n 
"""
3.2.3. Controle de fluxo (condicionais)
if expressao == True: 
print("true") 
else: 
print("false")
if answer > 5: 
return 1 
elif answer < 5: 
return -1
else: 
return 0
3.2.4. Laços de repetição
Exemplo com for…
lista = ["p", "y", "t", "h", "o", "n"] 
for item in lista: 
print item 
""" 
p 
y 
t 
h 
o 
n
"""
Exemplo com while…
count = 0 
while count <= 5: 
print(count) count += 1 
# 0 1 2 3 4 5
3.2.5. Funções
def foo(): 
return "retorno da função"
print(foo()) # "retorno da função"
Outro exemplo:
def add_two(a, b):
c = a + b 
return c
3.2.6. Imports
Para importar um módulo utilizamos o import.
import math 
print(math.sqrt(25))
O código acima importará todos os módulos de math, para importar apenas o necessário utilizamos from.
from math import sqrt
No terminal, para diminuir a digitação, costuma-se importar todas as funções de math dessa forma:
from math import *
Em geral, a prática do import * de um módulo ou pacote é desaprovada, uma vez que muitas vezes dificulta a leitura do código.
3.2.7. Datas
from datetime import datetime 
now = datetime.now() 
print(now) 
print(now.year)
print(now.month) 
print(now.day)
Para imprimir a data no formato brasileiro:
print('%s/%s/%s' % (now.day, now.month, now.year))
Imprimindo as horas:
print('%s:%s:%s' % (now.hour, now.minute, now.second))
3.2.8. Listas (lists)
animals = ["pangolin", "cassowary", "sloth", "dog"]; 
animals[0] # 'pangolin' 
animals[1] # 'cassowary' 
animals[2] # 'sloth' 
animals[3] # 'dog'
Ao acessar um índice inexistente recebemos um erro.
animals[4] # IndexError: list index out of range
A função len() retorna o tamanho da lista.
len(animals) # 4
3.2.9. range()
A função range() retorna uma lista de inteiros. Seu conteúdo é definido pelos argumentos, veja:
· range(terminal)
· range(start, terminal)
· range(start, terminal, step_size)
Exemplos:
range(4) [0, 1, 2, 3] 
range(2, 8) [2, 3, 4, 5, 6, 7] 
range(2, 13, 3) [2, 5, 8, 11]
Percorrendo (lopping):
for i in range(20): print(i)
3.3.0. Lambdas
Exemplo:
g = lambda x: x * 2 
print(g(6)) 
# 12
Para facilitar o entendimento, veja código abaixo, ele é similar.def f(x): 
return x * 2
print(f(6)) 
# 12
3.3.1. OOP - Programação Orientada a Objetos
Abaixo vemos um exemplo de classe em Python.
class Triangle(object):
def __init__(self, angle1, angle2, angle3):
self.angle1 = angle1 
self.angle2 = angle2 
self.angle3 = angle3
def sum_triangle(self): 
return self.angle1 + self.angle2 + self.angle3 
def check_angles(self): 
if(self.triangle() == 180): 
return True
else: 
return False
Abaixo vemos um exemplo simples de como instanciar uma classe em Python.
figure = Triangle(30, 40, 50)
4. MÓDULOS
Módulos são programas feitos para serem reaproveitados em outros programas, eles tipicamente contêm funções, variáveis, classes e objetos que provêm alguma funcionalidade comum. Por exemplo, já vimos que o módulo math contém funções matemáticas como sin, exp etc. Além da constante pi, toda a biblioteca padrão do Python é dividida em módulos e pacotes (veremos mais tarde) Alguns dos mais comuns são: sys, os, time, random, re, shelve.
4.1. Escrevendo módulos 
Na verdade, qualquer programa que você escreva e salve num arquivo pode ser importado como um módulo. Por exemplo, se você salva um programa com o nome prog.py, ele pode ser importado usando o comando import prog. 
· Entretanto, a “importação” só ocorre uma vez.
· Python assume que variáveis e funções não são mudadas e que o código do módulo serve meramente para inicializar esses elementos.
Exemplo (em Unix)
$ cat teste.py 
def f(): 
print "alo" 
f() 
$ python 
... 
>>> import teste 
alo 
>>> import teste 
>>> teste.f() 
alo 
>>>
 $ dir teste* 
teste.py teste.pyc
5. POLIMORFISMO 
O polimorfismo é uma palavra que deriva do Grego que significa “algo que assume muitas formas”. Na programação orientada ao objeto o polimorfismo permite que os objetos de diferentes tipos, cada um com seus comportamentos específicos, possam serem tratados a partir de uma classe, comum a todos as diferentes classes, mais abstrata. Ou seja, um objeto, de uma classe A mais abstrata, pode assumir o papel de diferentes tipos de objetos de classes derivadas, mais concretas. Para fixar, deixar mais claro, esse conceito para um exemplo.
5.1. Polimorfismo em Python
Polimorfismo é a ferramenta da programação orientada ao objeto que permite implementações elegantes de software. Porém, muito mais importante que isso é que essa ferramenta permite, caso seja necessário, que o software seja facilmente modificado. Nesse post, de 5 minutos, vamos explorar definir o que é polimorfismo em Python e exemplificar o uso do polimorfismo.
Para entender o polimorfismo é de suma importância que você já tenha entendido: como fazer uma classe em Python, como utilizar a herança em Python. Mesmo que, para o Python, o recurso do polimorfismo não seja alcançado, necessariamente, a partir da herança como vamos discutir no post sobre “tipagem de pato”. Nesse post vamos abordar de uma forma mais clássica, geralmente como é abordada em outras linguagens, esse recurso.
5.2. Exemplo de polimorfismo em Python
Por exemplo, vamos definir que o círculo, quadrado e triangulo são formas geométricas. Assim, podemos pensar que uma classe que implemente um círculo, um quadrado ou um triangulo tem uma relação “.. (são) um(a)…” com uma classe que constrói formas geométrica. Como vimos, no post sobre herança em Python, quando encontramos esse tipo de relação entre diferentes classes podemos utilizar o recurso de herança. Assim, a classe que constrói quadrados, a que constrói triangulo e a que constrói círculos são classes filhas, mais abstratas, de uma classe pai que define o que é uma forma geométrica, figura 1.
Figura 1 : Diagrama UML de um exemplo de polimorfismo em Python
5.3. Implementação de uma interface em Python
A classe que implementara a classe abstrata de uma forma geométrica, de nome “Forma Geométrica” será determinada com uma interface – classe 100% abstrata que apenas tem os métodos bem delimitados. Essa classe tem 1 método demarcado: cal. Área, que serve para calcular a área da forma geométrica. Como cada forma geométrica terá sua própria forma de calcular a sua área esse método, na classe pai, apenas terá a palavra “pass”, código 1.
5.4. Desenvolvimento das classes concretas
A classe “Quadrado” e “círculo” herdaram a classe “FormaGeometrica” e cada uma delas irá implementar a sua forma particular de calcular a área no método “calc_area”, codigo2.
5.5. Como utilizar o polimorfismo em Python
Agora, após toda essa construção, vamos utilizar o recurso do polimorfismo para calcular a soma de todas as diferentes formas geométricas de uma lista código 3.
No código 3, construímos uma lista com 4 figuras geométricas e em um for looping a inteiramos e somamos todas as áreas. O objeto polimórfico “forma” assumiu tanto o comportamento da classe “Quadrado”, quanto da classe “Circulo” e por isso conseguiu calcular de forma correta a soma de todas as áreas.
5.6. Duck Tiping
Geralmente, em outras linguagens inclusive, é necessário fazer todo esse processo para se poder utilizar o recurso de polimorfismo. Geralmente se faz todo esse processo no Python porque fica mais explicito quais métodos são comuns a todas as classes que irão ser listadas junto. Porém, no Python, não é necessário realizar todo esse processo para utilizar o recurso do polimorfismo.
Duck typing é um estilo de codificação de linguagens dinamicamente tipadas onde o tipo de uma variável não importa, contanto que seu comportamento seja o desejado. O nome "tipagem de pato" vem da expressão "se anda como pato, nada como um pato e faz quack como um pato, então provavelmente é um pato".
Quando criamos uma função ou um método em Python o tipo do parâmetro não é a parte importante, mas o que realmente importa é se ele vai possuir os métodos e atributos esperados:
A função realizar_operacao é um exemplo de como duck typing é aplicado: ela recebe como parâmetro o objeto operacao e executa o método realiza sem se importar com o tipo do objeto. É interessante notar que realizar_operacao utiliza a variável mágica **kwargs, que recebe qualquer número de parâmetros nominais após passado o objeto referente à operação, não importando quais sejam. Essa função pode ser implementada para realizar uma transferência, como vemos a seguir:
6. EXCEÇÕES 
Uma exceção é um objeto da classe Exception, ou de uma de suas subclasses. Ele permite armazenar informações sobre situações excepcionais que venham a ocorrer durante a execução de comandos dentro de algum método. O uso de exceções permite separar a detecção da ocorrência de uma situação excepcional dentro de um módulo, do seu tratamento (ou seja, o que fazer com a situação de erro).
 Tradicionalmente, quando queremos detectar e tratar a ocorrência de um ou mais erros em alguma função h(), fazemos algo assim:
6.1. Onde isso prejudica o bom design de programas?
As funções ou métodos de classes estão dentro de módulos. E podem ser usadas em aplicações diferentes. É provável que cada aplicação precise reagir a uma mesma situação excepcional de maneira diferente. Mas a forma acima obriga que a reação a um tipo de erro será sempre a mesma, determinada pelo bloco do if que trata esse erro. A alternativa seria alterar a parte que trata o erro cada vez que fôssemos usar a função em uma aplicação diferente. Mas isso obrigaria a testar toda a função de novo, a cada uso, com aumento de custos e riscos.
Além de tudo isso, a forma acima torna o código da função muito maior e complicado, dificultando a sua compreensão, complicando a documentação, e aumentando a chance de outros erros passarem despercebidos. 
6.2. Como funciona o mecanismo de exceções: 
O mecanismo de exceções permite escrever funções “limpas”, que só se preocupam com a sua finalidade principal, sem risco de se tornarem obscuras por excesso de tratamento de erros. 
Suponha uma função (digamos, para ilustrar, f(), mas poderia ser qualquer outra) que chama outra função g():
Suponha também que, de dentro de g(), a função h() seja chamada:
Usando exceções, a função h() ficariacom a forma abaixo:
Agora a função h() não precisa mais determinar o que fazer quando cada caso de erro ocorrer. Ela precisa apenas detectar que o caso de erro ocorreu. A partir daí, para cada caso de erro, ela irá construir um objeto especial de uma classe apropriada de exceção, e usará o comando raise para lançar (ou levantar) essa exceção para a função que a chamou. No nosso exemplo, esse objeto poderá ser "capturado" pela função g() que chamou h(), e "tratado" lá, ou mesmo ser novamente lançado por g() para ser capturado e tratado por quem a chamou, no caso f().
6.3. Como construir e como lançar uma exceção.
A linguagem Python já possui uma grande quantidade de classes de exceção pré-definidas. Todas descendem da classe Exception. Exceções são objetos comuns, instâncias da classe Exception, ou de alguma subclasse dela. Para ver todas as classes de exceção, digite no Idle: import exceptions dir(exceptions). Para lançar uma exceção de dentro de uma função ou método, usa-se o comando raise. Capturando e tratando exceções: os blocos try e except:
Quando programamos um módulo em Java, e dentro desse módulo existem comandos ou chamadas de funções ou métodos onde podem ocorrer exceções, os comandos devem ser colocados dentro de um bloco try, que tem a forma: try: No caso de ocorrer uma exceção dentro de alguma função ou comando do bloco try, ela será lançada, e os demais comandos do bloco serão suspensos. O controle da execução passará para o primeiro bloco except que tenha uma classe de exceção de tipo compatível com a exceção lançada. Podem existir zero, um ou mais blocos except após um bloco try.
6.4. Exemplo 
No exemplo abaixo, o programa ficará rodando no laço while até que o usuário entre com 2 números, com o segundo diferente de zero:
Note o seguinte: 
a) Se b for zero, o comando a/b lançará (levantará) automaticamente uma exceção do tipo ZeroDivisionError. Se isso ocorrer, o bloco try será imediatamente interrompido neste ponto, e o controle passará para o primeiro comando do bloco except para essa classe de exceção. Logo, o comando fim = True não chegará a ser executado e o laço não terminará, voltando o programa a solicitar os números ao usuário. 
b) Se a ou b não for do tipo de um número, o comando a/b levantará uma exceção do tipo TypeError.
7. CONCORRENCIA E PARALELISMO
Pode parecer a mesma coisa, mas não é. Vamos as definições:
7.1. Paralelismo
Acontece quando duas ou mais tarefas são executadas, literalmente, ao mesmo tempo. Necessita, obviamente, de um processador com múltiplas cores, ou múltiplos processadores para que mais de um processo ou thread seja executado ao mesmo tempo.
7.2. Concorrência 
Quando duas ou mais tarefas podem começar a ser executadas e terminar em espaços de tempo que se sobrepõem, não significando que elas precisam estar em execução necessariamente no mesmo instante. Ou seja, você tem concorrência quando:
· mais de uma tarefa progride ao mesmo tempo em um ambiente com múltiplos CPUs/núcleos;
· ou no caso de um ambiente single core, duas ou mais tarefas podem não progredir no mesmo exato momento, mas mais de uma tarefa é processada em um mesmo intervalo de tempo, não esperando que uma tarefa termine por completo antes de dar início a outra.
É a possibilidade do processador executar instruções ao mesmo tempo que outras operações, como, por exemplo I/O, permitindo que tarefas sejam executadas concorrentemente pelo sistema. A concorrência é o princípio básico para permitir o projeto e implementação de sistemas multitarefas.
“Sistemas multitarefas são sistemas em que mais de um programa pode estar em execução ao mesmo tempo. Ou seja, é o contrário do monotarefa, onde somente um programa pode estar em execução por vez, deixando o processador dedicado exclusivamente a essa tarefa.”
7.3. Classificação dos processos 
Processos podem ser classificados como CPU Bound ou I/O Bound, de acordo com a utilização de CPU ou I/O. Saber distinguir entre as duas situações é muito importante para conseguirmos arquitetar adequadamente uma solução.
Um tipo de computação em uma aplicação, cujo maior fator determinante para o tempo no qual ela vai levar para terminar, é determinado pela velocidade da CPU, pois passam a maior parte do tempo em estado de execução, utilizando o processador. Ou seja: CPUs mais rápidos fazem com que a computação seja mais rápida, terminando em um tempo menor. São exemplos de atividades/aplicações com soluções CPU Bound:
· Computações matemáticas intensas
· Algoritmos de busca e ordenação em memória
· Processamento e reconhecimento de imagem
7.4. I/O Bound
Ao contrário de computações CPU Bound, passa a maior parte em estado de espera por realizar muitas operações de I/O. Esse tipo de computação é, obviamente, determinado pelo tempo gasto esperando por operações de input/output. São exemplos de atividades/aplicações I/O Bound, e suas velocidades de execução são afetadas por :
· Transferência de dados pela rede
· Copiar/Mover arquivo em disco
· Consultar um banco de dados remoto
· Consultar uma API HTTP
7.5. CPU E I/O BOUND
Aplicações que fazem uso intenso de CPU e dispositivos de I/O. São exemplos:
· Compressão de arquivos
· Desfragmentação de disco
8. PORCESSOS E THREADS 
8.1. Múltiplos processos 
Múltiplos processos, ou processos independentes, é uma maneira simples e sem vínculo de se implementar a concorrência. O processo criador não possui nenhuma relação com o processo criado e gera a criação de um novo Processos Control Block (PCB), possuindo contextos de software e hardware completamente diferentes, assim como espaços de endereçamento de memória. Por esse motivo, o compartilhamento de estado de objetos de uma aplicação, e comunicações em geral entre processos, são operações muito custosas e devem ser evitadas.
8.2. Subprocessos
Em python, chamados simplesmente de múltiplos processos. Subprocessos são processos criados com vínculo hierárquico, ou seja: O processo criador é chamado de pai e, novos processos, de filho. Subprocessos não são independentes, e sua existência é condicional a existência do processo pai. A finalização do processo pai -por qualquer motivo-, automaticamente finaliza o processo filho. Subprocessos também podem ter outros Subprocessos.
A criação de processos e subprocessos é sempre um custo para o sistema operacional como um todo. É preciso alocar contexto de hardware, contexto de software e espaço em memória para cada um.
Em python, utiliza-se o módulo built-in multiprocessing para criar novos processos e aproveitar todo os núcleos disponíveis.
Normalmente, faz-se uso de múltiplos processos sempre que for possível dividir o trabalho de uso intenso de CPU (CPU Bound), a ser executado de forma cooperativa sem que seja necessária comunicação entre as partes (ou seja, sem compartilhamento de estado). Operações no modelo MapReduce são um bom exemplo de uso.
8.3. Threads
Threads foram criadas com o intuito de reduzir a criação, troca de contexto de processos (que como já falamos anteriormente, é algo custoso) e para economizar outros recursos do sistema. Threads estão sempre associadas a um único processo, que por sua vez, pode possuir múltiplas threads. Threads compartilham o processador da mesma maneira que um processo, ou seja: cada thread tem o seu próprio contexto de hardware, mas threads de um mesmo processo compartilham entre si o mesmo contexto de software e memória. Resumindo:
Basicamente, forçando um pouco a barra, threads são como se fossem “processos leves” que compartilham memória entre si. Como threads de um mesmo processo compartilham o mesmo gerenciamento de memória, não existe proteção por parte do SO a acesso de memória, sendo possível que mais de uma thread acesse e manipule o mesmo endereço de memória ao mesmo tempo. O uso desorganizado obviamente causaria inconsistências, e mecanismos de controle devem ser implementados para threads colaborem ordenadamente. Essa ordem é comumente aplicada através de exclusão mútua, que também ganha o nome de mutex (mutualexclusion semaphores), semáforos binários ou, o mais popular, Lock. O que nos leva ao famigerado, mistificado, mas pouco entendido Global Interpreter Lock (GIL).
GIL, nada mais é do que um Lock em nível de interpretador. Ou seja, o GIL existe para proteger a memória do INTERPRETADOR (aquele que lê o texto do seu código, paresia as instruções e estruturas lógicas e transforma em bytecode), e faz com que todas as threads tenham que adquirir esta lock por baixo dos panos, pra garantir a integridade das estruturas básicas. Isso parece causar um grande overhead e uma grande sensação de que, na verdade, você acaba não tendo multiplas threads de fato, tendo por consequência possivelmente com um código mais lento do que single thread, o que não é verdade. Threads são sempre mais lentas e ruins por culpa do GIL? NÃO! Especificamente em python, se esse é o caso, você está utilizando threads pra coisa errada. Existem várias situações onde threads podem ser empregadas para ganho de performance em aplicações I/O Bound. Inclusive, a documentação é muito clara sobre isso. Infelizmente, muitas pessoas que tive contato ao longo do meu tempo de programador Python, insistem em criticar laranjas por não terem gosto de banana.
9. DISSERTAÇÃO
O Python é uma das principais linguagens para se trabalhar no ano de 2020. Muito disso por conta da sua polivalência, já que é possível utilizá-la nas áreas de Big Data, Machine Learning, Análise de Dados, desenvolvimento web e muitas outras, áreas essas que estão em constante crescimento nos últimos anos e tendem a continuar assim.
Python é uma linguagem cuja comunidade não tem brincado em serviço. Com uma grande facilidade de aprendizado, ela invadiu centros de estudo e conquistou um espaço muito grande em áreas científicas se tornando referência para quem quer atuar com algum ramo da IA. Mesmo sendo interpretada, o Python tem sido interface para ferramentas com maior poder de processamento como a linguagem R e a C.
Resumidamente podemos dizer que:
· Python é uma linguagem com vasta área de aplicação. 
· Fácil programação e legibilidade.
· Linguagem dinâmica e de fácil migração.
10. REFERÊNCIAS BIBLIOGRAFICAS
https://diogommartins.wordpress.com/2017/04/07/concorrencia-e-paralelismo-threads-multiplos-processos-e-asyncio-parte-1/
https://dcc.ufrj.br/~jonathan/python/docs/Excecoes%20em%20Python.pdf
https://panda.ime.usp.br/aulasPython/static/aulasPython/aula02.html
http://pyscience-brasil.wikidot.com/python:python-oq-e-pq
https://www.python.org/
https://pt.wikipedia.org/wiki/Python
https://www.devmedia.com.br/guia/python/37024
http://www.estruturas.ufpr.br/disciplinas/pos-graduacao/introducao-a-computacao-cientifica-com-python/introducao-python/1-8-tratamento-de-excecoes-em-python/
https://panda.ime.usp.br/pythonds/static/pythonds_pt/01-Introducao/11-exceptions.html
http://turing.com.br/pydoc/2.7/tutorial/errors.html
http://devfuria.com.br/python/erros-excecoes/
https://medium.com/rafaeltardivo/exce%C3%A7%C3%B5es-de-onde-v%C3%AAm-para-onde-v%C3%A3o-e-como-organiz%C3%A1-las-em-python-3d50bee2b317
https://www.impacta.com.br/blog/conheca-a-linguagem-python-e-saiba-como-e-possivel-usa-la/
https://olhardigital.com.br/noticia/python-lidera-ranking-entre-as-10-melhores-linguagens-de-programacao-de-2020/104123
https://cio.com.br/carreira/python-domina-ranking-de-linguagens-de-programacao-de-2020/
https://www.ufrgs.br/reamat/CalculoNumerico/livro-py/riap-sobre_a_linguagem_python.html
https://www.devmedia.com.br/python-trabalhando-com-variaveis/38644
https://reulison.com.br/python-variaveis-e-valores/
https://curso-intro-python.readthedocs.io/variaveis.html
https://professormarcolan.com.br/variaveis-em-python/
https://blog.ffelix.eti.br/como-criar-variaveis-em-python/
https://www.inf.pucrs.br/pinho/PCB/Variaveis/Variaveis.html
https://panda.ime.usp.br/pensepy/static/pensepy/02-Conceitos/conceitos.html
https://wiki.python.org.br/ModulosPacotes
http://fabiomascarenhas.github.io/mab225/12modulos.pdf
https://cadernoscicomp.com.br/tutorial/introducao-a-programacao-em-python-3/modulos/
https://cafeinacodificada.com.br/modulos-em-python/
2