Dia 15

Python - Visão Geral

Mais alguns Módulos do Python:
Módulo re (Regular Expression): Possui funções para filtrar strings através de Expressões Regulares:
Função findall: procura uma string, com base na expressão regular.
Exemplo:
import re
print(re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest'))
# ['foot', 'fell', 'fastest']
--------------------------------------------------------------------
Função sub: 
Uso 1: substitui uma string por outra.
Exemplo:
import re
print(re.sub(r'\bAMD', r'AuthenticAMD', 'AMD Turion(tm) 64 X2 Mobile'))
# 'AuthenticAMD Turion(tm) 64 X2 Mobile'

Uso 2: substitui 2 strings por uma.
Exemplos:
import re
print(re.sub(r'(\b[a-z]+) \1', r'\1', 'cat cat the the hat hat, and my my shoes'))
# 'cat the hat, and my shoes'
--------------------------------------------------------------------
Módulo math: fornece diversas funções matemáticas.
Para conhecer o que este módulo fornece, digite:
import math
dir (math)
# ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

Algumas mais usadas:
sqrt(num): retorna a raíz quadrada do número.
cos(num): retorna o cosseno do número em radiano.
sin(num): retorna o seno do número em radiano.
tan(num): retorna a tangente do número em radiano.
radians(num): converte o angulo de graus para radiano.
pi: retorna a constante com o número pi (3.1415926535897931).
hypot(cat_a,cat_b): retorna a hipotenusa dos catetos.
pow(x,y): calcula a potência x^y.

Exemplos:
Exibindo a constante Pi:
import math
print(math.pi) # 3.141592653589793

Função de Cálculo do Seno:
import math
def Sin(a):
  'Calcula seno de angulo em graus'
  ang_rad = math.radians(a)
  return math.sin(ang_rad)
print(Sin(30)) # 0.49999999999999994
print(Sin(60)) # 0.8660254037844386

Raíz quadrada de um número:
import math
print(math.sqrt(81)) # 9.0

Potência de um número:
import math
a = math.pow(3,4)
print(a) # 81.0
--------------------------------------------------------------------

Dia 14

Python - Visão Geral

Alguns Módulos Padrões do Python:
Módulo sys: Este módulo possui várias funções que permitem interagir com o interpretador do Python.
Alguns Métodos/Objetos:
ps1 e ps2: definem os prompts do Python.

argv: retorna os argumentos passados pela linha de comandos na lista de strings argv[]; o 1º elemento retornado é o nome do programa em execução, os demais são os argumentos, caso exista.

path: retorna os caminhos utilizados pelo Python para buscar os módulos solicitados pelo comando import.

platform: retorna o sistema operacional.

prefix: retorna o path da instalação do Python.

version: retorna a versão do Python em uso.

stdin, stdout, stderr: entrada, saída e saída de erro padrões. Permite redirecionar as entradas e saídas padrões do sistema.

exit: finaliza uma seção do Python.
--------------------------------------------------------------------
Exemplo:
import sys
sys.ps1 = '> ' 
print (sys.argv)
print (sys.path)
print(sys.modules)
sys.stdout.write('hello')
print (sys.platform) 
print (sys.prefix) 
print (sys.version)
sys.stderr.write('Ocorreu um erro!\n')
--------------------------------------------------------------------
Para saber quais são os métodos disponíveis em sys, digite:
dir(sys)
# ['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']
--------------------------------------------------------------------

Dia 13

Python - Visão Geral

Módulos:
Cada arquivo em Python é chamado de módulo. 
Um Módulo é um conjunto de códigos (funções,classes,variáveis, etc).
Para acessar um Módulo temos 2 formas:
Exemplos:
Inicialmente crie um arquivo 'fibonacci.py' com o código abaixo:
""" Modulo Fibonacci
  Funcoes:
    fib(n)
    fib2(n)
"""
def fib(n):
  " Write Fibonacci series up to n "
  a, b = 0, 1
  while b < n:
    print (b,)
    a, b = b, a+b

def fib2(n):
  " Return Fibonacci series up to n "
  result = []
  a, b = 0, 1
  while b < n:
    result.append(b)
    a, b = b, a+b
  return result

Para termos acesso a este Módulo 'fibonacci.py, faça o seguinte: 
import fibonacci
fibonacci.fib(1000) # 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Outra forma para utilizar o Módulo: 
Importando tudo para a raiz:
from fibonacci import * # O * importa tudo do Módulo
fib(1000) 
Ou:
from fibonacci import fib # importa todas as funções passadas
fib(1000)  

Podemos dar um apelido para o Módulo:
import fibonacci as fibo
fibo.fib(1000) # 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Para importar mais de um Módulo:
import modulo_1, modulo_2, modulo_3
--------------------------------------------------------------------

Dia 12

Python - Visão Geral

Orientação a Objetos:
Testes de Segurança:
Alguns cuidados devem ser tomados ao se alterar atributos em um objeto. 
Exemplo:
class Classe_1:
  a = [5, 3]
h = Classe_1()
h.a.append(2) # Alterando atributo da Classe 
print(h.a) # [5, 3, 2] 
g = Classe_1()
print(g.a) # [5, 3, 2]

class Classe_2:
  a = 1
h = Classe_2()
h.a = 2; # Alterando apenas o atributo do objeto
print(h.a) # 2 
g = Classe_2()
print(g.a) # 1

Na 1ª parte do código com a Classe Classe_1, por ter um atributo mutável (listas e dicionários), ocorre a possibilidade de alteração do atributo da Classe.
Já para atributos não mutáveis (Classe_2), as atribuições são sempre feitas na variável da instância local, e não da classe.
Evite usar estas variáveis mutáveis como atributos de Classe, são fontes de erros de programação difíceis de serem encontrados.
--------------------------------------------------------------------
Funções úteis para OO:
Exemplos:
class Retangulo:
  lado_a = None
  lado_b = None
  def __init__(self, lado_a, lado_b):
    self.lado_a = lado_a
    self.lado_b = lado_b
    print ('Criando uma nova instância retângulo.')
  def calcula_area(self):
    return self.lado_a * self.lado_b
  def calcula_perimetro(self):
    return 2 * (self.lado_a + self.lado_b)

class Quadrado(Retangulo):
  def __init__(self, lado):
    self.lado_a = self.lado_b = lado
--------------------------------------------------------------------
isinstance(): verifica se um Objeto é uma instância da Classe.
obj1 = Quadrado(15)
print(isinstance(obj1, Quadrado)) # True
print(isinstance(obj1, Retangulo)) # True
--------------------------------------------------------------------
issubclass(): verifica se uma Classe é uma Subclasse (Herança).
print(issubclass(Quadrado, Retangulo)) # True
print(issubclass(Retangulo, Quadrado)) # False
--------------------------------------------------------------------
hasattr(): verifica se um Objeto possui um dado Atributo.
print(hasattr(f1, 'lado_a')) # True
print(hasattr(f1, 'lado')) # False
--------------------------------------------------------------------
Introspecção e reflexão: 
em tempo de execução, conseguimos informações a respeito do tipo dos objetos, incluindo informações sobre a hierarquia de classes.
Comandos:
dir(): permite conhecer todos os atributos e métodos de
uma classe ou instância.
print(dir(obj2)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'calcula_area', 'calcula_perimetro', 'lado_a', 'lado_b']
--------------------------------------------------------------------
__class__: este atributo da instância armazena o seu objeto classe correspondente.
print(obj2.__class__) # <class '__main__.Quadrado'>
--------------------------------------------------------------------
__dict__: apresenta um dicionário com os atributos de uma instância.
print(obj2.__dict__) # {'lado_a': 20, 'lado_b': 20}
--------------------------------------------------------------------
__module__: retorna uma String com o nome do módulo onde a Instância ou a Classe foi importada.
print(obj2.__module__) # __main__
--------------------------------------------------------------------
__bases__: apresenta uma tupla com as classes herdadas por Classe.
print(Quadrado.__bases__) # (<class '__main__.Retangulo'>,)
--------------------------------------------------------------------
__name__:  apresenta uma string com o nome da Classe.
print(Quadrado.__name__) # Quadrado
--------------------------------------------------------------------

Dia 11

Python - Visão Geral

Encapsulamento - Atributos Privados/Protegidos:
Um Atributo Privado não pode ser acessado fora da Classe, isto é, este Atributo está disponível apenas dentro da própria Classe.
Para definir um Atributo como privado em uma Classe, usa-se o "_" ou "__" no início do nome do Atributo.
Exemplo:
class teste:
  atr1 = "atributo publico"
  _atr2 = "atributo privado por convenção"
  __atr3 = "atributo privado"

a = teste
print(a.atr1) # 'atributo publico'
print(a._atr2) # 'atributo privado por convenção
print(a.__atr3) # 'ERRO'

Apesar do uso de "__", existe uma forma de acessar este Atributo fora da Classe:
print(a._teste__atr3) # atributo privado
--------------------------------------------------------------------
Herança:
É uma forma de criar classes novas a partir de outras Classes.
Python suporta herança simples e herança múltiplas. 
Exemplo:
Criação da Classe Quadrado estendendo da Classe Retangulo.
Exemplo:
class Retangulo:
  lado_a = None
  lado_b = None
  def __init__(self, lado_a, lado_b):
    self.lado_a = lado_a
    self.lado_b = lado_b
    print ('Criando uma nova instância retângulo.')
  def calcula_area(self):
    return self.lado_a * self.lado_b
  def calcula_perimetro(self):
    return 2 * (self.lado_a + self.lado_b)

class Quadrado(Retangulo):
  def __init__(self, lado):
    self.lado_a = self.lado_b = lado

obj1= Quadrado(10)
print(dir(obj1)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'calcula_area', 'calcula_perimetro', 'lado_a', 'lado_b']
print(obj1.lado_a, obj1.lado_b) # (10. 10)
print(obj1.calcula_area(), obj1.calcula_perimetro()) # (100, 40)

Com a Herança, a Classe Quadrado tem disponível os atributos e métodos da Classe Retangulo.
--------------------------------------------------------------------
Outra forma de criar a Classe Quadrado: A partir da Classe Quadrado invocamos o método Construtor da Classe Retangulo: 
Exemplo:
class Quadrado(Retangulo):
  def __init__(self, lado):
    Retangulo.__init__(self, lado, lado)

obj2 = Quadrado(10) # Criando uma nova instância retângulo.
print(obj2.lado_a, obj2.lado_b) # (10, 10)
print(obj2.calcula_area(), obj2.calcula_perimetro()) # (100, 40) 

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

Dia 10

Python - Visão Geral

Orientação a Objetos:
Introdução:
É uma série de técnicas para estruturar soluções para problemas
computacionais. É uma forma de entender a programação no qual um
programa é construído com base em objetos e que traz consigo aspectos como abstração, encapsulamento, polimorfismo e herança.
--------------------------------------------------------------------
Em Python tudo é um Objeto. 
Um Objeto pode ter atributos é métodos em sua estrutura.
Um Objeto é uma instância de uma Classe.
--------------------------------------------------------------------
Classe: é a estrutura utilizada para definir uma objeto.
Exemplo:
class Retangulo:
  lado_a = None
  lado_b = None
  def __init__(self, lado_a, lado_b):
    self.lado_a = lado_a
    self.lado_b = lado_b
    print ('Criando uma nova instância retângulo.')
  def calcula_area(self):
    return self.lado_a * self.lado_b
  def calcula_perimetro(self):
    return 2 * (self.lado_a + self.lado_b)

A Classe Retangulo possui 3 métodos. O método __init__() é conhecido como método construtor. Este Método é invocado automaticamente quando uma classe é instanciada. Sua codificação é opcional.
--------------------------------------------------------------------
"self": é a ideia do próprio objeto a ser manipulado dentro da Classe. Para ser manipulado dentro de um Método, deve ser passado como argumento.
--------------------------------------------------------------------
Instâncias: Uma Instância é o Objeto criado com base em uma classe.
É uma Variável do tipo da Classe informada.

Utilizando a Classe:
obj = Retangulo(4,10) # Cria uma instância da Classe Retangulo

Acessando os metodos:
print(obj.calcula_perimetro())
print(obj.calcula_area())
# Criando uma nova instância retângulo.
# 28
# 40
--------------------------------------------------------------------

Dia 9

Python - Visão Geral

Manipulação de Arquivos:

Principal método: open():
Retorna um objeto da classe file, que permite fazer leitura e escrita em arquivos. Por padrão, o arquivo é aberto somente para leitura.

Exemplo:
f = open('arq.txt')
print (f) 
# <_io.TextIOWrapper name='arq.txt' mode='r' encoding='cp1252'>
--------------------------------------------------------------------
Conhecendo os métodos disponíveis para o objeto da classe file: 
dir(f) # Resultado: imprime na tela: ['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines']
--------------------------------------------------------------------
Sintaxe básica:
objeto = open(filename,mode), onde:
filename: nome do arquivo a ser manipulado.
mode: modo como o arquivo será aberto, opções: 
r: leitura (valor padrão, assumido se omitido)
w: escrita
a: escrita + append
r+: leitura e escrita
b: binário

Se o nome do arquivo informado não existir, se o modo for o 'w' ou 'a', o arquivo será criado. 
-------------------------------------------------------------------- Principais métodos da classe file:
open(): abre arquivo
read(): lê todo o conteúdo do arquivo e retorna como string
readline(): lê uma linha
readlines(): lê todas as linhas
seek(): posiciona o cursor de leitura
write(): escreve texto.
tell(): retorna a posição corrente do cursor
name: retorna o nome do arquivo aberto
mode: retorna o modo do arquivo aberto
closed: verifica se o arquivo está fechado
close(): fecha o arquivo aberto
-------------------------------------------------------------------- Exemplo de read():
Lendo 10 bytes de um arquivo e imprimindo na tela:
f=open('arq.txt')
print('>>%s<<' % f.read(10)) # marco anto
f.close()
-------------------------------------------------------------------- Exemplo de seek():
f=open('arq.txt')
# f.read() # alcança o final do arquivo
f.seek(1) # posiciona o cursor no byte 1 do arquivo
print(f.read(2)) # ler 2 bytes a partir da posição atual
f.close()
-------------------------------------------------------------------- Exemplo de readline():
f=open('arq.txt')
print(f.readline()) # lê a próxima linha do arquivo
print(f.readline()) # lê a próxima linha do arquivo
f.close()
--------------------------------------------------------------------
Exemplo de readlines(), name, mode e closed:
f = open('arq.txt','r')
for linha in f.readlines():
  linha_arq = linha.strip('\n')
  print(linha_arq)
  print(f.name) # retorna o nome do arquivo
  print(f.mode) # retorna o modo do arquivo
  print(f.closed) # verifica se arquivo está fechado
f.close()
-------------------------------------------------------------------- Exemplo de write():
f = open('arq.txt', 'r+')
f.seek(0, 2) # avança para o final do arquivo
f.write('texto da nova linha\n') # conteúdo a ser gravado no arquivo
f.seek(0) # posiciona o cursor no inicio do arquivo
print (f.read()) # lendo todo o arquivo a partir do início
f.close()
-------------------------------------------------------------------- Exemplo de tell():
f=open('arq.txt')
f.seek(0, 2);
end = f.tell()
f.seek(0);
pos = f.tell()
line = 1
while pos != end:
  print ('Linha %d - posição %d' % (line, pos))
  line += 1
  l = f.readline()
  pos = f.tell()
f.close()
# Linha 1 - posição 0
# Linha 2 - posição 15
# Linha 3 - posição 23
# Linha 4 - posição 44
--------------------------------------------------------------------

Dia 8

Python - Visão Geral

Funções Pré-definidas - Conversões:
Função int(): converte número real ou string em inteiro:
print(int(12.67)) # 12
print(int('12')) # 12

Função float(): converte inteiro ou string em número real:
print(float(5)) # 5.0
print(float('10')) # 10.0

Função str(): converte inteiro, complexo ou real em string:
print(str(12.5)) # '12.5'
print(str(12)) # '12'
print(str(12+4j)) # '(12+4j)'

Função complex(): converte string, inteiro ou real em complexo:
print(complex(2)) # (2+0j)
print(complex('12')) # (12+0j)
print(complex('12.1')) # (12.1+0j)
print(complex(6.5)) # (6.5+0j)

Função list(): converte string em uma lista:
print(list('abacate')) # ['a', 'b', 'a', 'c', 'a', 't', 'e']

Função tuple(): converte string em uma tupla
print(tuple('abacate')) # ('a', 'b', 'a', 'c', 'a', 't', 'e')
--------------------------------------------------------------------
Funções Pré-definidas - Leitura do Teclado:
Função input(): Lê a entrada de dados do Teclado. 
Exemplos:
a = input('Entre com o seu nome: ')
# Entre com o seu nome: 
print (a) # marco antonio

num = input("Digite um número: ")
str = input("Digite uma string: ")
print ("num =", num) # num = 6
print ("Tipo de num: ", type(num)) # Tipo de num:  <class 'str'>
print ("num * 2 =", num * 2) # num * 2 = 66
print ("num * 2 =", int(num) * 2) # num * 2 = 12
print ("str =", str) # str = a
print ("str é do tipo: ", type(str)) # str é do tipo:  <class 'str'>
print ("str * 2 =", str * 2) # str * 2 = aa
--------------------------------------------------------------------
raw_input(): Descontinuada no Python.
--------------------------------------------------------------------
DocString - Documentação:
O Python possui suporte nativo à documentação de código. 
Strings de documentação (docstrings) podem ser adicionadas no início de módulos, funções e classes, para instruir o funcionamento e funcionalidades dos programas.
Existem 2 tipos de Docstrings:
Para uma linha (uma aspas duplas):
"mensagens de uma única linha"

Para duas ou mais linhas (3 aspas duplas):
""" mensagem com mais de
uma linha devem ser
escritas entre três aspas duplas """

Exemplo:
Programa fibonacci.py:
#-*- coding: iso-8859-1 -*-
# Módulo Sequência de Fibonacci: fibonacci.py
""" Modulo Fibonacci
  Funcoes:
    fib(n)
    fib2(n)
"""
def fib(n):
  " Write Fibonacci series up to n "
  a, b = 0, 1
  while b < n:
    print (b,)
    a, b = b, a+b

def fib2(n):
  " Return Fibonacci series up to n "
  result = []
  a, b = 0, 1
  while b < n:
    result.append(b)
    a, b = b, a+b
  return result

Teste.py:
import fibonacci
print(fibonacci.__doc__)

Impressão na Tela:
Modulo Fibonacci
  Funcoes:
    fib(n)
    fib2(n)

Outro Exemplo:
print (open.__doc__)
# imprime toda informação docstring da função open()

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

Dia 7

Python - Visão Geral

Funções Pré-Definidas:
O Python possui algumas funções pré-definidas, que não necessitam de importações externas. 
--------------------------------------------------------------------
Função range():
Permite especificar o início de uma sequência, o passo, e o valor final. O único parâmetro obrigatório é o que define quem será o último elemento da sequência. Parâmetros:
start - início da sequência (incluso)
stop - último elemento da sequência (não incluso)
step - intervalo entre os elementos
Exemplos:
for x in range(10): # gera uma lista com elementos de 0 a 9
  print(x) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for x in range(3,10): # gera uma lista de 3 a 9
  print(x) # [3, 6, 9, 12, 15, 18, 21, 24, 27]

for x in range(30,3,-3): # gera uma lista de 30 a 4 com step -3
  print(x) # [30, 27, 24, 21, 18, 15, 12, 9, 6]

from time import time as t
def xrange(x):
  return iter(range(x))
def count():
  st = t()
  [x for x in xrange(10000000) if x%4 == 0]
  et = t()
  print (et-st)
count()
--------------------------------------------------------------------
Função len(): 
Retorna o comprimento da variável. 
Se for uma lista, tupla ou dicionário, retorna o nº de elementos.
Exemplos:
a = 'Míriam de F. A.'
print(len(a)) # 15

a = [1,2,3]
print(len(a)) # 3
--------------------------------------------------------------------
Função round(): 
Arredonda o número real com 'n' casas decimais. 
Se 'n' for omitido, é considerado n = 0.
Exemplos:
print(round(5.48)) # 5.0
print(round(5.548)) # 6.0
print(round(5.548,1)) # 5.5
print(round(5.548,2)) # 5.55
--------------------------------------------------------------------
Função pow():
Retorna a potência p de um número n. 
É o mesmo que n**p.
Exemplos:
print(pow(2,3)) # 8
print(pow(2.0,3.3)) # 9.8491553067593287
print(pow(2.0,3.3j)) # (-0.65681670994609054+0.75405026989955604j)
--------------------------------------------------------------------
Função chr():
Retorna o caracter ascii correspondente ao código informado. 
Exemplo:
for i in range(10):
  print (chr(65+i),) # A B C D E F G H I J # 65+: Maiúsculo
--------------------------------------------------------------------
Função ord():
Retorna o código ascii do caracter informado.
O valor de a deve ser apenas um caracter.
Exemplos:
print(ord('A')) # 65

for i in range(5):
  a = chr(i+65);
  print ('%s : %d' % (a, ord(a)))
# A : 65
# B : 66
# C : 67
# D : 68
# E : 69
--------------------------------------------------------------------
Função min():
Retorna o menor valor entre os dados informados. 
Funciona para qualquer tipo de variável. 
Exemplos:
print(min(2,3,1,4)) # 1
print(min('abacate', 'flores')) # abacate
--------------------------------------------------------------------
Função max():
Exemplos:
print(min(2,3,1,4)) # 4
print(min('abacate', 'flores')) # flores
--------------------------------------------------------------------
Função abs():
Retorna o valor absoluto de um número (módulo). 
Exemplos:
print(abs(-3)) # 3
print(abs(-3.0)) # 3.0
print(abs(3-4j)) # 5.0 - módulo de um complexo
--------------------------------------------------------------------
Função hex():
Converte um número inteiro para um hexadecimal string.
Exemplos:
print(hex(22)) # 0x16 (expressão válida no Python)
print(int(0x16)) # 22
--------------------------------------------------------------------
Função oct():
Converte um número inteiro para um octal string. 
Exemplos:
print(oct(22)) # 0o26 (expressão válida no Python)
print(int(0o26)) # 22
--------------------------------------------------------------------
Função bin():
Converte um número inteiro para um binário string. 
Exemplos:
print(bin(22)) # 0b10110 (expressão válida no Python)
print(int(0b10110)) # 22

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

Função xrange(): Descontinuada no Python.
--------------------------------------------------------------------
Função unichr(): Descontinuada no Python.

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

Dia 6

Python - Visão Geral

Funções: Com Retorno:
Exemplo:
def fibonacci(n):
  a, b, f = 0, 1, ''
  while b < n:
    a, b, f = b, a+b, f+str(b)+' '
  return f

print(fibonacci(20)) # 1 1 2 3 5 8 13

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

Funções: Argumento com Valor Padrão:
Podemos definir valores default para argumentos de entrada. 
Não utilize como valor default, listas, dicionários ou outros elementos mutáveis, podemos ter diferença nos resultados.
Exemplos:
def aplicar_multa(valor, taxa=0.15):
  return valor*(1. + taxa)

print ('Valor a pagar: %5.2f' % aplicar_multa(100))
print ('Valor a pagar: %5.2f' % aplicar_multa(100, .25))
# Valor a pagar: 115.00
# Valor a pagar: 125.00

from math import sqrt
def eq2grau(a, b = .0, c = .0): # o ponto informa parâmetro float
  #print(type(a),type(b),type(c))
  delta = b**2 - 4*a*c
  if delta > 0:
    r1 = (-b + sqrt(delta))/(2*a)
    r2 = (-b - sqrt(delta))/(2*a)
  else:
    r1 = complex(-b/(2*a), sqrt(-delta)/(2*a))
    r2 = complex(-b/(2*a), -sqrt(-delta)/(2*a))
  return ( r1, r2 )
print(eq2grau(2))           # ((-0-0j), (-0+0j))
print(eq2grau(2,4))         # (0.0, -2.0)
print(eq2grau(2,5,3))       # (-1.0, -1.5)
print(eq2grau(2,c=2))       # ((-0+1j), (-0-1j))
print(eq2grau(a=2))         # ((-0-0j), (-0+0j))
print(eq2grau(b=4,a=2))     # (0.0, -2.0)
print(eq2grau(c=3,a=2,b=5)) # (-1.0, -1.5)
print(eq2grau(c=2,a=2))     # ((-0+1j), (-0-1j))

As variáveis b e c possuem valor padrão (opcionais).
Já a variável a é obrigatória e deve ser informada na chamada. Veja:
print(eq2grau(b=2, c=4))

Traceback (most recent call last):
File "<stdin>", line 12, in <module>
    print(eq2grau(b=2, c=4))
TypeError: eq2grau() missing 1 required positional argument: 'a'
--------------------------------------------------------------------
Funções: Conjunto de Argumentos:
Um conjunto de argumentos opcionais podem ser passados com o auxílio do curinga “*”.
Exemplo:
def media(*valores):
  soma = 0.
  for n in valores:
    soma += n
  return soma/len(valores)

print(media(1,2,3,4,5,6))

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

Funções: 2 Conjuntos de Argumentos:
Podemos passar 2 conjuntos de argumentos opcionais, utilize '**'.
Este 2º conjunto deve ter a seguinte estrutura:
var_0='valor_0', var_1='valor_1', etc.
Se for usar '*' e '**', use sempre o '*' antes do '**'.
Exemplo:
def fnc2arg(nome, **numeros):
  print (nome + ':')
  for i in numeros.keys():
    print ('%10s : %d' % (i, numeros[i]))

def fnc3arg(nome, *strings, **numeros):
  print (nome + ':')
  for i in strings:
    print ('> ', i)
  keys = numeros.keys()
  for i in keys:
    print ('%10s : %d' % (i, numeros[i]))

print(fnc2arg('Numeros', um=1, dois=2, tres=3, quatro=4, cinco=5))
print(fnc3arg('Numeros', 'Os números são ordenados', 'pelos seus nomes', um=1, dois=2, tres=3, quatro=4, cinco=5))
print(fnc3arg('Numeros', um=1, dois=2, tres=3, quatro=4, cinco=5))
# Numeros:
#         um : 1
#       dois : 2
#       tres : 3
#     quatro : 4
#      cinco : 5
# None
# Numeros:
# >  Os números são ordenados
# >  pelos seus nomes
#         um : 1
#       dois : 2
#       tres : 3
#     quatro : 4
#      cinco : 5
# None
# Numeros:
#         um : 1
#       dois : 2
#       tres : 3
#     quatro : 4
#      cinco : 5
# None
--------------------------------------------------------------------
Escopo da Variável:
Se uma variável é definida no bloco principal do programa, ela estará disponível no escopo de todas as funções definidas adiante
Exemplo:
a = 5
b = 8
def soma(x,y):
  print ('a =',a, 'b =', b)
  return x+y

print(soma(2, 7))
# a = 5 b = 8
# 9

Os valores de a e b são exibidos, mesmo elas não tendo sido passadas para a função soma(). 
Assim, estas variáveis fazem parte do escopo da função soma().

Ao atribuirmos valores para a e b dentro da função produto(), os valores iniciais de a e b não são alterados, por causa do seu escopo original. 
Exemplo:
a = 5
b = 8
def produto(x,y):
  a, b = x, y
  print ('produto: a =',a, 'b =', b)
  return a * b

print(produto(2, 7))
# produto: a = 2 b = 7
# 14
print ('a =',a, 'b =', b)
# a = 5 b = 8
--------------------------------------------------------------------
Globals() e Locals():
A função globals() retorna um dicionário com todo o escopo global e os seus valores.
A função locals() retorna um dicionário semelhante ao da função glocals(), mas para escopo local.
Exemplo: 
a = 5
b = 8
def produto(x,y):
  print(locals())
  a, b = x, y
  print ('produto: a =',a, 'b =', b)
  return a * b

print(produto(2, 7))
print('a =',a, 'b =', b)
print(globals())
# {'y': 7, 'x': 2}
# produto: a = 2 b = 7
# 14
# a = 5 b = 8
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:\\Users\\M\\Desktop\\teste.py', 'a': 5, 'b': 8, 'produto': <function produto at 0x031D1B70>}
--------------------------------------------------------------------

Função Global():

Permite definir uma variável de escopo global de dentro da função.

Exemplo:
def potencia(x,n):

  global p

  p = n

  return x**p, locals()

print(potencia(3,3)) # (27, {'n': 3, 'x': 3})

print (p) # 3

print (n) #ERRO

#Traceback (most recent call last):

#File "<stdin>", line 8, in <module>

#NameError: name 'n' is not defined

Executando a função locals() para observar os argumentos passados:

**numeros é passado como um dicionário e *strings como uma tupla.
Veja a impressão na tela.
Exemplo:

def fnc3arg(nome, *strings, **numeros):

  print (nome + ":")

  for i in strings:

    print ('> ', i)

  keys = numeros.keys()

  for i in keys:

    print ('%10s : %d' % (i, numeros[i]))

  return locals()

print(fnc3arg('Numeros', 'Os números são ordenados', 'pelos seus nomes', um=1, dois=2, tres=3, quatro=4, cinco=5))
# Numeros:

# >  Os números são ordenados

# >  pelos seus nomes

#         um : 1

#       dois : 2

#       tres : 3

#     quatro : 4

#      cinco : 5

# {'keys': dict_keys(['um', 'dois', 'tres', 'quatro', 'cinco']), 'i': 'cinco', 'numeros': {'um': 1, 'dois': 2, 'tres': 3, 'quatro': 4, 'cinco': 5}, 'strings': ('Os números são ordenados', 'pelos seus nomes'), 'nome': 'Numeros'}

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