Introdução 2

Características iniciais - 2ª Parte

O que mais a considerar sobre a Linguagem Python:

Tipagem dinâmica: define que o tipo de uma variável é inferido pelo interpretador em tempo de execução (duck typing). Assim que uma variável é criada através de atribuição, o interpretador define o tipo da variável e as operações que podem ser aplicadas.
--------------------------------------------------------------------
Tipagem forte: o interpretador verifica se as operações são válidas e não faz conversões automáticas entre tipos incompatíveis. Para realizar operações entre tipos incompatíveis é necessário converter explicitamente o tipo da variável antes da operação.
Conversões automáticas apenas entre tipos compatíveis como por exemplo, um inteiro e um inteiro longo.
--------------------------------------------------------------------
Compilação e interpretação: 
O código fonte é traduzido pelo Python para bytecode, que é um formato binário com instruções para o interpretador. O bytecode é multiplataforma e pode ser distribuído e executado sem fonte original.

Por padrão, o interpretador compila o código e armazena o bytecode (código binário) em disco, para que a próxima vez que o executar, não precise compilar novamente o programa, reduzindo o tempo de carga na execução. Se os arquivos fontes forem alterados, o interpretador se encarregará de regerar o bytecode automaticamente. Quando um programa ou um módulo é evocado, o interpretador realiza a análise do código, converte para símbolos, compila (se não houver bytecode atualizado em disco) e executa na máquina virtual Python.
O bytecode é armazenado em arquivos com extensão “.pyc” (bytecode normal) ou “.pyo” (bytecode otimizado). O bytecode também pode ser empacotado junto com o interpretador em um executável, para facilitar a distribuição da aplicação, eliminando a necessidade de instalar Python em cada computador.

Código fonte (.py) Símbolos Árvore sintática da Linguagem
--------------------------------------------------------------------
Modo interativo
O interpretador Python pode ser usado de forma interativa, na qual as linhas de código são digitadas em um prompt do próprio Python, semelhante a um shell do sistema operacional. 
No Windows tem 2 formas básicas de executar o interpretador.
1º: linha de comando do prompt do DOS, digite: python
Caso não execute, verifique o path do sistema operacional.
2º: Procure por IDLE Python e execute.

O modo interativo é uma característica diferencial da linguagem, pois é possível testar e modificar trechos de código antes da inclusão do código em programas, além de diversas outras possibilidades. 
--------------------------------------------------------------------
Ferramentas de Desenvolvimento:
Existem muitas ferramentas de desenvolvimento para Python, como IDEs, editores e shells.

Obs.: Shell é o nome dado aos ambientes interativos para execução de comandos, que podem ser usados para testar pequenas porções de código.
--------------------------------------------------------------------Empacotadores:
são utilitários usados para construir executáveis que englobam o bytecode, o interpretador e outras dependências, para que o aplicativo rode em computadores sem o Python instalado, o que facilita a distribuição de programas.
Entre empacotadores feitos para Python, estão disponíveis:

• Py2exe (apenas para Windows).
• cx_Freeze (portável).

-------------------------------------------------------------------- Frameworks: coleções de componentes de software (bibliotecas, utilitários e outros) que foram projetados para serem utilizados por outros sistemas. Alguns frameworks disponíveis mais conhecidos:

• Web: Django, TurboGears, Zope e web2py.
• Interface gráfica: wxPython, PyGTK e PyQt.
• Processamento cientifico: NumPy e SciPy.
• Processamento de imagens: PIL.
• 2D: Matplotlib e SVGFig.
• 3D: Visual Python, PyOpenGL e Python Ogre.
• Mapeamento objeto-relacional: SQLAlchemy e SQLObject.

--------------------------------------------------------------------
Cultura:
Repositório oficial de pacotes do Python:
Python Package Index11 (PYPI) http://pypi.python.org/pypi
--------------------------------------------------------------------
Expressões da comunidade Python:
Pythonic: usado para indicar que algo é compatível com as premissas de projeto do Python; Unpythonic é o oposto. 
Pythonist: usuário da linguagem.
--------------------------------------------------------------------
Metas do Projeto por Tim Peters:
Texto 'Zen of Python', acessível através do comando:
import this
--------------------------------------------------------------------
Fontes de informação:
Site oficial: https://www.python.org/
Comunidade Python Brasil: http://www.python.org.br/
Códigos prontos: http://code.activestate.com/recipes/langs/python/

--------------------------------------------------------------------
Referência Bibliográfica: 
Internet
Python para Desenvolvedores 2ª Edição - Luiz Eduardo Borges

Introdução 1

Características iniciais - 1ª Parte

O que considerar sobre a Linguagem Python:

• Linguagem de altíssimo nível (interpretada).
• OO.
• Tipagem Dinâmica (forte).
• Interpretada.
• Interativa.
• Clara, Concisa.
• Possui estruturas como listas, tuplas, dicionários, complexos, unidades de teste, recursos para persistência, módulos diversos (ex: data/hora) e também possibilidade de utilzar frameworks de terceiros, etc.
• Tudo em Python são Objetos.
• Além de OO, suporta também programação modular e funcional.
• Processamento: Linguagem interpretada através de bytecode por VM Python para determinado SO.
• É possível compilar aplicações um SO e executar em outros.
• É possível executar diretamente o código-fonte.
• É um software de código aberto, licença compatível com a GPL (General Public License), porém menos restritiva.
• A Especificação da Linguagem é mantida pela Python Software Foundation (PSF): https://www.python.org/psf/
• Além de Linguagem principal, o Python pode ser utilizado também como linguagem de Script, para automatizar tarefas e adicionar funcionalidades (ex: BrOffice, PostgreSQL, etc).
• É possível integrar o Python com outras Linguagens, como C.
• Página Oficial: https://www.python.org/
• É escrito em C, mantida pela PSF.
• Usos:
• Windows: Necessário instalar para executar. (foco atual).
• Linux: Já disponível no prompt.
• MacOS: Já disponível também.
• Identificação de arquivos fonte: extensão 'py'.
• Podem ser executados diretamente pelo interpretador:
• python programa1.py

--------------------------------------------------------------------

Dia 16

Python - Visão Geral

Ainda mais alguns Módulos:

Módulo random: Gera números aleatórios, sorteios, sequências, distribuições reais, uniformes, etc.

Função choice: escolhe de forma aleatória um elemento de uma lista.
Exemplo:
import random
print(random.choice(['laranja','abacate','cenoura','beterraba']))
# abacate  # cenoura

Função randrange: gera um inteiro aleatório entre 0 e n-1 (n é o parâmetro informado)
Exemplo:
import random
print(random.randrange(10)) # 2  # 5

Função randint: gera um inteiro aleatório entre m e n, incluindo os extremos, onde m e n são os parâmetros informados.

Exemplo:
import random
print(random.randint(3, 6))

Função sample: gera uma lista com x elementos da lista, sem a repetição dos elementos.

Exemplos:

from random import sample

print(sample([0,1,2,3], 4)) # [1,3,0,2]  # [1,2,3,0]

from random import sample

print(sample([0,1,2,3], 2)) # [0, 2]  # [2,1]

--------------------------------------------------------------------

Para saber mais sobre o random, digite:
print (random.__doc__)

--------------------------------------------------------------------

Módulo datetime: fornece classes para manipulação de datas e horas.

Função date(ano, mês, dia): cria um objeto data.
Exemplo:
from datetime import date
hoje = date.today()
nascimento = date(1977, 5, 25)
idade = hoje - nascimento
print('Você tem %d dias de vida' % idade.days)
print('Idade: %d anos' % int(idade.days/365)) # Idade: 40 anos
--------------------------------------------------------------------
Para saber mais sobre o objeto date, digite:
dir (date)
# ['__add__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__radd__', '__reduce__', '__reduce_ex__', '__repr__', '__rsub__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', 'ctime', 'day', 'fromordinal', 'fromtimestamp', 'isocalendar', 'isoformat', 'isoweekday', 'max', 'min', 'month', 'replace', 'resolution', 'strftime', 'timetuple', 'today', 'toordinal', 'weekday', 'year']
--------------------------------------------------------------------
Módulo timeit: Permite monitorar o desempenho na execução de comandos Python.

Função Timer: Gera um objeto com os dados do cálculo de tempo de execução de pequenos códigos.

Função timeit: Executa o código do objeto timeit e retorna o tempo de execução, em segundos, como float.

Função repeat: Executa o código do objeto timeit 3 vezes (default) e retorna os tempos de execução.

Exemplo:
import timeit
t = timeit.Timer('range(100)')
print(t) # <timeit.Timer object at 0x025C0BF0>
print(t.timeit()) # 0.46328055209243424
print(t.repeat()) # [0.444389609624671, 0.7409117235753929, 0.5889149577390125]
--------------------------------------------------------------------