Introdução 8

Características Iniciais - 8ª Parte

Exercícios do Livro: 
"Python para Desenvolvedores" 2ª Ed. Autor: Luiz Eduardo Borges
Livro TOP!

1. Implementar duas funções:
1. Uma que converta temperatura em graus Celsius para Fahrenheit.
2. Outra que converta temperatura em graus Fahrenheit para Celsius.
3. Lembrando que: F=(9/5*C)+32
2. Implementar uma função que retorne verdadeiro se o número for primo (falso caso contrário). Testar de 1 a 100.
3. Implementar uma função que receba uma lista de listas de comprimentos quaisquer e retorne uma lista de uma dimensão.
4. Implementar uma função que receba um dicionário e retorne a soma, a média e a variação dos valores.
5. Escreva uma função que:
1. Receba uma frase como parâmetro.
2. Retorne uma nova frase com cada palavra com as letras invertidas.
6. Crie uma função que:
1. Receba uma lista de tuplas (dados), um inteiro (chave, zero por padrão igual) e um booleano (reverso, falso por padrão).
2. Retorne dados ordenados pelo item indicado pela chave e em ordem decrescente se reverso for verdadeiro.

--------------------------------------------------------------------
Soluções:

#EXERCICIO 1
def converte_c_to_f(c):
    f = (9/5*c)+32
    return f

def converte_f_to_c(f):
    c = (5*f-160)/9
    return c

print(converte_c_to_f(50))
#122.0
print(converte_f_to_c(122))
#50.0
####################################################################
#EXERCICIO 2
def verifica_se_numero_primo(numero):
    status='primo'
    for x in range(2,numero):     
        resto = numero % x
        if resto == 0:
            status=''
    if status=='primo':
        return True
    else:
        return False     
                 
for x in range(2,100):
    if verifica_se_numero_primo(x)==True:
        print(x, ' Primo? ', verifica_se_numero_primo(x))
####################################################################
#EXERCICIO 3
def soma_comprimentos(lista):
    #print(lista(0))
    soma=0
    for x in lista:
        soma+=x
    return soma

comprimentos=[10,15,35]
print(soma_comprimentos(comprimentos))
#60
####################################################################
#EXERCICIO 4
def calculos_com_dicionario(dicionario):
    soma_valor=0
    media_valor=0
    tamanho_dicionario=(len(dicionario))
    for chave,valor in dicionario.items():
        print(chave,'=>',valor)
        soma_valor+=valor
    print('Soma:',soma_valor)
    print('Média:',soma_valor/tamanho_dicionario)

dicio={'v1':10,'v2':20,'v3':55,'v4':90}
calculos_com_dicionario(dicio)
print(type(dicio))
####################################################################
#EXERCICIO 5
def inverte_frase(frase):
    lista_palavras=frase.split()
    resultado=''
    for palavra in lista_palavras:
        if len(palavra)>1:                       
            palavra=palavra[::-1]
        resultado = resultado + ' ' + palavra
    return resultado

texto='o Brasil é a minha pátria'
print(inverte_frase(texto))
#o lisarB é a ahnim airtáp

#Sobre enumerate():
#So, in the for index, item in enumerate(choices): expression index, item is the pair of count, value of each tuple: (0, 'pizza'), (1, 'pasta'), ...
#We may easily change the start count/index with help of enumerate(sequence, start=0)
####################################################################
#EXERCICIO 6
def ordena_dados(dados, chave=0, reverso=False):
    lista_dados=list(dados)
   
    lista_dados.sort(reverse=reverso)
    print(lista_dados)
    #[9, 7, 4, 2, 1]
    tupla_dados=tuple(lista_dados)
    return tupla_dados

tupla=(4,7,1,9,2)
print(ordena_dados(tupla,reverso=True))
#(9, 7, 4, 2, 1)

#Parametro key(chave):
#O valor do parâmetro key deve ser uma função que usa um único argumento e retorna uma chave para fins de classificação. Essa técnica é rápida porque a função-chave é chamada exatamente uma vez para cada registro de entrada.
--------------------------------------------------------------------

Introdução 7

Características Iniciais - 7ª Parte

Funções:

são blocos de código identificados por um nome, que podem receber parâmetros pré-determinados. No Python, as funções:

• Podem retornar ou não objetos (como as procedures).
• Aceitam 'Doc Strings'.
• Aceitam parâmetros opcionais (com defaults). Se não for passado o parâmetro será igual ao default definido na função.
• Aceitam que os parâmetros sejam passados com nome. Neste caso, a ordem em que os parâmetros foram passados não importa.
• Tem namespace próprio (escopo local), e por isso podem ofuscar definições de escopo global.
• Podem ter suas propriedades alteradas (geralmente por decoradores).

Doc Strings são strings que estão associadas a uma estrutura do Python. Nas funções, as Doc Strings são colocadas dentro do corpo da função, geralmente no começo. O objetivo das Doc Strings é servir de documentação para aquela estrutura.
Sintaxe:
def func(parametro1, parametro2=padrao):
    """Doc String
    """
    <bloco de código>
    return valor (opcional)

Os parâmetros com default devem ficar após os que não tem default.
Exemplo de procedimento (sem retorno e sem parâmetros):
def imprime_endereco():
    print('Rua: silva messias')
    print('nº: 556')
    print('bairro: Conceição')
#chama a procedure    
imprime_endereco()  
#Rua: silva messias
#nº: 556
#bairro: Conceição  

Exemplo de procedimento (sem retorno e com parâmetros):
def sum(a, b):
   print ("Soma de 2 Valores")
   c = a + b
   print ("Se a é " + str(a) + " e b é " + str(b) + " então a soma deles é " + str(c))

# chama procedure com parâmetros
sum(10, 14)
#Soma de 2 Valores
#Se a é 10 e b é 14 então a soma deles é 24
    

Exemplo de função (fatorial com recursão):

def fatorial(num):
    if num <= 1:
        return 1
    else:
        return num * fatorial(num-1)

# Testa fatorial()
print(fatorial(5))
#120

Exemplo de função (fatorial sem recursão):
def fatorial(n):
    n = n if n > 1 else 1
    j = 1
    for i in range(1, n + 1):
        j = j * i
    return j
# Executa função
for i in range(1, 6):
 print (i, '->', fatorial(i))
#1 -> 1
#2 -> 2
#3 -> 6
#4 -> 24
#5 -> 120

Exemplo (série de Fibonacci com recursão):
def fib(n):
    """Fibonacci:
    fib(n) = fib(n - 1) + fib(n - 2) se n > 1
    fib(n) = 1 se n <= 1
    """
    if n > 1:
        return fib(n - 1) + fib(n - 2)
    else:
        return 1

# Mostrar Fibonacci de 1 a 5
for i in [1, 2, 3, 4, 5]:
    print(i, '=>', fib(i))
    #1 => 1
    #2 => 2
    #3 => 3
    #4 => 5
    #5 => 8

Exemplo (série de Fibonacci sem recursão):
def fib(n):
    """Fibonacci:
    fib(n) = fib(n - 1) + fib(n - 2) se n > 1
    fib(n) = 1 se n <= 1
    """
    # Dois primeiros valores
    l = [1, 1]
    # Calculando os outros
    for i in range(2, n + 1):
        l.append(l[i -1] + l[i - 2])
    return l[n]
# Mostrar Fibonacci de 1 a 5
for i in [1, 2, 3, 4, 5]:
    print (i, '=>', fib(i))
#1 => 1
#2 => 2
#3 => 3
#4 => 5
#5 => 8

Observações:

• Os argumentos com padrão devem vir por último, depois dos argumentos sem padrão.
• O valor do padrão para um parâmetro é calculado quando a função é definida.
• Os argumentos passados sem identificador são recebidos pela função na forma de uma lista.
• Os argumentos passados com identificador são recebidos pela função na forma de um dicionário.
• Os parâmetros passados com identificador na chamada da função devem vir no fim da lista de parâmetros.

Exemplo de como receber todos parâmetros:
# *args - argumentos sem nome (lista)
# **kargs - argumentos com nome (dicionário)
def func(*args, **kargs):
    print (args)
    print (kargs)

func('peso', 10, unidade='k')
#('peso', 10)
#{'unidade': 'k'}
--------------------------------------------------------------------
Função built-in eval():

Avalia código (fonte ou objeto) retornando o valor.
A função também interpreta uma string como um código.
Exemplo:
print eval('12. / 2 + 3.3')
#9.3

eval('print(10)')
#10

Com isso é possível montar código para ser passado para o interpretador durante a execução de um programa. Esse recurso deve ser usado com cuidado, pois código montados a partir de entradas do sistema abrir brechas de segurança.
--------------------------------------------------------------------
Pedindo Ajuda no Python:

Comando dir():
Exemplo (no terminal):
>>> my_list=[]
>>> dir(my_list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> dir(my_list)[0:5]

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__']

Comando help():
Exemplo (no terminal):
>>> help(list)
Help on class list in module builtins:
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)

 |      Return self+value.
...

Outro exemplo: 
>>> help(my_list.append) ou help(list.append)
Help on built-in function append:
append(...) method of builtins.list instance
    L.append(object) -> None -- append object to end

Mais um exemplo:
>>>help(string.split)
...

Ajuda on-line: 
A documentação do Python também está disponível em: http://www.python.org/doc/

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

PyDOC:

PyDOC é a ferramenta de documentação do Python. Ela pode ser utilizada tanto para acessar a documentação dos módulos que acompanham o Python, quanto a documentação dos módulos de terceiros.

O módulo PyDOC gera automaticamente documentação dos módulos do Python. A documentação pode ser apresentada como páginas de texto no console, em um navegador Web ou arquivos HTML.

Para módulos, classes, funções e métodos, a documentação exibida é derivada da docstring (isto é, o atributo __doc__) do objeto e recursivamente de seus membros documentáveis. Se não houver docstring, o PyDOC tenta obter uma descrição do bloco de linhas de comentário logo acima da definição da classe, função ou método no arquivo de origem, ou na parte superior do módulo.

Para executar o PyDOC num terminal DOS/Windows:
Exemplo:
python -m pydoc os


Obs.: A função help() chama o sistema de ajuda no interpretador interativo, que usa o PyDOC para gerar sua documentação como texto no console. 
--------------------------------------------------------------------

Introdução 6

Características iniciais - 6ª Parte

Continuando mais... Tipos de Dados...

Listas:

Listas são coleções heterogêneas de objetos, que podem ser de qualquer tipo, inclusive outras listas.
As listas no Python são mutáveis, podendo ser alteradas a qualquer momento. Listas podem ser fatiadas da mesma forma que as strings, mas como as listas são mutáveis, é possível fazer atribuições a itens da lista.
Sintaxe:
lista = [a, b, ..., z]

Exemplos:
lista_alimentos = ['Cebola', 'Tomate', 'Alho', 'Laranja']
# imprime toda a lista
for alimento in lista_alimentos:
    print (alimento)
    #Cebola
    #Tomate
    #Alho
    #Laranja    

# Troca o último item
lista_alimentos[-1] = 'Abacate'

# Inclui item
lista_alimentos.append('Manga')

# Remove item
lista_alimentos.remove('Alho')

# Ordena a lista
lista_alimentos.sort()

# Inverte a lista
lista_alimentos.reverse()

# Imprime novamente
for i, alimento in enumerate(lista_alimentos):
    print (i + 1, '=>', alimento)
    #1 => Tomate
    #2 => Manga
    #3 => Cebola
    #4 => Abacate    
--------------------------------------------------------------------
A função enumerate() é usada para percorrer uma lista enquanto mantém o controle dos índices dos itens da lista. Nos permite fazer um loop em algo e ter um contador automático. A função retorna um objeto enumerado. Exemplos:
my_list = ['apple', 'banana', 'grapes', 'pear']
for c, value in enumerate(my_list,1): #2º parâmetro: início da enum.

    print(c, value)
    #1 apple
    #2 banana
    #3 grapes

    #4 pear

No próximo exemplo, o objeto counter_list é uma lista de tuplas (listas imutáveis), cada uma contendo um par de índice e valor. Lembrando que a Lista é mutável, mas as Tuplas não. Exemplo:
my_list = ['apple', 'banana', 'grapes', 'pear']
counter_list = list(enumerate(my_list, 1))
print(counter_list)

#[(1, 'apple'), (2, 'banana'), (3, 'grapes'), (4, 'pear')]
--------------------------------------------------------------------
# Imprime do segundo item em diante
print (lista_alimentos[1:])
#['Manga', 'Cebola', 'Abacate']

Obs.: As operações de ordenação (sort) e inversão (reverse) são realizadas na própria lista, sendo assim, não geram novas listas.
Listas possuem o método pop() que facilita a implementação de filas e pilhas:
Exemplo:
lista = ['A', 'B', 'C']
print ('lista:', lista)
#lista: ['A', 'B', 'C']

# A lista vazia é avaliada como falsa
while lista:
    # Em filas, o primeiro item é o primeiro a sair
    # pop(0) remove e retorna o primeiro item
    print ('Saiu', lista.pop(0), ', faltam', len(lista))
    #Saiu A , faltam 2
    #Saiu B , faltam 1
    #Saiu C , faltam 0

# Mais itens na lista
lista += ['D', 'E', 'F']
print ('lista:', lista)
#lista: ['D', 'E', 'F']

while lista:
    # Em pilhas, o primeiro item é o último a sair
    # pop() remove e retorna o último item
    print ('Saiu', lista.pop(), ', faltam', len(lista))
    #Saiu F , faltam 2
    #Saiu E , faltam 1
    #Saiu D , faltam 0
--------------------------------------------------------------------
Tuplas: 

Semelhantes as listas, porém são imutáveis: não se pode acrescentar, apagar ou fazer atribuições aos itens.
Sintaxe:
tupla = (a, b, ..., z) #Os parênteses são opcionais.

Obs.: tupla com apenas um elemento é representada como: t1 = (1,)

Os itens de uma tupla são referenciados como os itens de uma lista: 
primeiro_item = tupla[0]

Listas podem ser convertidas em tuplas: tupla = tuple(lista)
Tuplas podem ser convertidas em listas: lista = list(tupla)

Embora a tupla possa conter elementos mutáveis, esses elementos não podem sofrer atribuição, pois isto modificaria a referência ao objeto.
Exemplo: 
t = ([1, 2], 4)
t[0].append(3)
print(t)
#([1, 2, 3], 4)
t[0] = [1, 2, 3] #'tuple' object does not support item assignment.

As tuplas são mais eficientes do que as listas, consome menos memória, por serem estruturas mais simples, como as strings imutáveis em relação às strings mutáveis.
--------------------------------------------------------------------
Dicionários:

É uma lista de associações formada por uma chave única e valores correspondentes. Dicionários são mutáveis, tais como as listas. A chave de um Dicionário precisa ser de um tipo imutável, geralmente são usadas strings, mas também podem ser tuplas ou tipos numéricos. Já os itens dos dicionários podem ser tanto mutáveis quanto imutáveis. O dicionário do Python não fornece garantia de que as chaves estarão ordenadas.
Sintaxe: 
dicionario = {'a': a, 'b': b, ..., 'z': z}

Exemplos:
cadastro = {'nome': 'Miriam', 'sexo': 'Feminino'}
#Acessar itens:
print (cadastro['nome'])
#Miriam

#Adicionar itens:
cadastro['idade'] = 32
print(cadastro)
#{'nome': 'Miriam', 'sexo': 'Feminino', 'idade': 32}

#Apagar um item:
del cadastro['sexo']
print(cadastro)
#{'nome': 'Miriam', 'idade': 32}

Obter os itens, chaves e valores:
itens = cadastro.items()
#dict_items([('nome', 'Miriam'), ('idade', 32)])
print(itens)

chaves = cadastro.keys()
print(chaves)
#dict_keys(['nome', 'idade'])

valores = cadastro.values()
print(valores)
#dict_values(['Miriam', 32])

Mais Exemplos com dicionários: 

cadastro_profissional = {
'Advogados': ['Miriam', 'Alexandre'],
'Programadores': ['Marco', 'Antonio']
}
# Mais cadastro_profissional
cadastro_profissional['Pedreiros'] = ['Expedito', 'Andre']
print(cadastro_profissional)
#{'Advogados': ['Miriam', 'Alexandre'], 'Programadores': ['Marco', 'Antonio'], 'Pedreiros': ['Expedito', 'Andre']}

#obs.: has_key() foi removido no Python 3, use in.

for chave, valor in cadastro_profissional.items():
    print (chave, '=>', valor)
    #Advogados => ['Miriam', 'Alexandre']
    #Programadores => ['Marco', 'Antonio']
    #Pedreiros => ['Expedito', 'Andre']

# Se tiver 'ELP' na chave, deleta
if 'Pedreiros' in cadastro_profissional:
    del cadastro_profissional['Pedreiros']
print(cadastro_profissional)
#{'Advogados': ['Miriam', 'Alexandre'], 'Programadores': ['Marco', 'Antonio']}
--------------------------------------------------------------------
Outros tipos de sequências:

O Python possui também os tipos de objetos(built-in):

• set: objeto de sequência mutável unívoca (sem repetições) não ordenada.
• frozenset: objeto de sequência imutável unívoca não ordenada.
• Os dois tipos implementam operações de conjuntos, tais como: união, interseção e diferença.

Exemplo:
# Conjuntos de dados
s1 = set(range(3))
s2 = set(range(10, 7, -1))
s3 = set(range(2, 10, 2))
print ('s1:', s1, '\ns2:', s2, '\ns3:', s3)
#s1: {0, 1, 2} 
#s2: {8, 9, 10} 
#s3: {8, 2, 4, 6}

# União
s1s2 = s1.union(s2)
print ('União de s1 e s2:', s1s2)
#União de s1 e s2: {0, 1, 2, 8, 9, 10}

# Diferença
print ('Diferença com s3:', s1s2.difference(s3))
#Diferença com s3: {0, 1, 10, 9}

# Interseção
print ('Interseção com s3:', s1s2.intersection(s3))
#Interseção com s3: {8, 2}

# Testa se um set inclui outro
if s1.issuperset([1, 2]):
    print ('s1 inclui 1 e 2')
#s1 inclui 1 e 2    

# Testa se não existe elementos em comum
if s1.isdisjoint(s2):
    print ('s1 e s2 não tem elementos em comum')
    #s1 e s2 não tem elementos em comum

Operações sobre set:
Exemplos:
var1 = set('Tutorial de Python')
print(var1)
print(type(var1))
#{'a', 'h', 'd', 'e', 'i', ' ', 'y', 't', 'u', 'l', 'T', 'P', 'o', 'n', 'r'}
#<class 'set'>

#Executar o codigo acima novamente:
#{'d', 'h', 'i', 'T', 'u', 'P', 'n', 'o', 'l', 'y', 'a', ' ', 't', 'e', 'r'}
#<class 'set'>
#Set não tem ordem definida para seus elementos: resultado aleatório

#Passar uma Lista para um set:
x = set(["Perl", "Python", "Java"])
print(x)
#{'Python', 'Java', 'Perl'}

#Passar um Tupla para um set (Valores repetidos no set não são mostrados):
cities = set(("Paris", "Lyon", "London","Berlin","Paris","Birmingham"))
print(cities)
#{'Paris', 'Birmingham', 'Lyon', 'London', 'Berlin'}

Converter tupla e list em set: 
cities = set((("Python","Perl"), ("Paris", "Berlin", "London")))
cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))
#list não é possivel pois set nao permite objetos mutaveis: gera o erro abaixo:
#Traceback (most recent call last):
#  File "C:\Users\M\Desktop\Python\exemplo.py", line 26, in <module>
#    cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))
#TypeError: unhashable type: 'list'

Exemplo de Frozensets (sets imutáveis):    
cities = frozenset(["Frankfurt", "Basel","Freiburg"])
cities.add("Strasbourg")
#Gera erro o método add():
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#AttributeError: 'frozenset' object has no attribute 'add'
--------------------------------------------------------------------
Verdadeiro, falso e nulo:

Em Python, o tipo booleano (bool) é uma especialização do tipo inteiro (int). O verdadeiro é chamado True e é igual a 1, enquanto o falso é chamado False e é igual a zero.
Os seguintes valores são considerados falsos:

• False (falso).
• None (nulo).
• 0 (zero).
• '' (string vazia).
• [] (lista vazia).
• () (tupla vazia).
• {} (dicionário vazio).
• Outras estruturas com o tamanho igual a zero.

São considerados V todos os outros objetos fora dessa lista. 
O objeto None, que é do tipo NoneType, do Python representa o nulo e é avaliado como falso.
--------------------------------------------------------------------
Operadores booleanos:

Utilizados para especificar condições, controlar desvios condicionais e laços. Os operadores booleanos no Python são: 

• and: retorna V se e somente se receber duas expressões que forem V.
• or: retorna F se e somente se receber duas expressões que forem F.
• not: retorna F se receber uma expressão V e vice-versa.
• is: retorna V se receber duas referências ao mesmo objeto e F caso contrário.
• in: retorna V se receber um item e uma lista e o item ocorrer uma ou mais vezes na lista e F em caso contrário.

Cálculos do valor em operações lógicas:

• Com and ocorre da seguinte forma: se a 1ª expressão for V, o resultado será a 2ª expressão, senão será a 1ª. 
• Com or, se a 1ª expressão for F, o resultado será a 2ª expressão, senão será a 1ª. 

Exemplos:
print(0 and 3)
#0
print(2 and 3)
#3
print(0 or 3)
#3
print(2 or 3)
#2
print(not 0)
#True
print(not 2)
#False
print(2 in (2, 3))
#True
print(2 is 3)
#False

Além dos operadores booleanos, existe a função all(), que retorna V quando todos os itens forem V na sequência usada como parâmetro, e any(), que retorna V se algum item for igual.
Exemplos:
print(any(l == 't' for l in 'python'))
#Retorna True. É o mesmo que: 't' in 'python'
print(all(l == 't' for l in 'python'))
#Retorna False. Nem todas as letras são 't'
print(all(l == 'x' for l in 'xxx'))
#Retorna True. Todas as letras são 'x'
--------------------------------------------------------------------

Introdução 5

Características iniciais - 5ª Parte

Continuando... Tipos de Dados...

Texto:

O Python fornece o tipo string para armazenar texto. São imutáveis, isto é, para realizar alguma operação com uma string, é necessária criar nova string. Uma string pode ser definida entre aspas simples ou entre aspas duplas.
Tipos de strings:

• String padrão: s = 'Led Zeppelin'
• String unicode: u = u'Björk'

Operações com Strings.
Exemplo:
# Concatenação
s = 'Carro'
print( 'Meu ' + s + ' é prata!')
#Meu Carro é prata!

# Interpolação
print( 'tamanho de %s => %d' % (s, len(s)))
#tamanho de Carro => 5

# String tratada como sequência
for ch in s: print(ch)
#C
#a
#r
#r
#o

# Strings são objetos (possui diversos métodos)
if s.startswith('C'): print(s.upper())
#CARRO

print(3 * s)
# 3 * s é consistente com s + s + s
#CarroCarroCarro
--------------------------------------------------------------------
Interpolação de Strings:

O Operador “%” é usado para fazer interpolação de strings. A interpolação é mais eficiente no uso de memória do que a concatenação convencional. Símbolos usados na interpolação:

• %s: string.
• %d: inteiro.
• %o: octal.
• %x: hexadecimal.
• %f: real.
• %e: real exponencial.
• %%: sinal de percentagem.

Exemplos:
# Zeros a esquerda
print('Agora são %02d:%02d.' % (6, 30))
#Agora são 06:30.
print('Agora são %02d:%02d.' % (16, 30))
#Agora são 16:30.

# Real (número após o ponto controla as casas decimais)
print('Percentagem: %.1f%%, Exponencial:%.2e' % (5.333, 0.00314))
#Percentagem: 5.3%, Exponencial:3.14e-03

# Octal e hexadecimal
print('Decimal: %d, Octal: %o, Hexadecimal: %x' % (10, 10, 10))
# Decimal: 10, Octal: 12, Hexadecimal: a

Há outra forma de interpolação: a função format() de string.
Exemplos:
musicos = [('Page', 'guitarrista', 'Led Zeppelin'), ('Fripp', 'guitarrista', 'King Crimson')]

# Parâmetros identificados pela ordem
msg = '{0} é {1} do {2}'
for nome, funcao, banda in musicos:
    print(msg.format(nome, funcao, banda))
    #Page é guitarrista do Led Zeppelin
    #Fripp é guitarrista do King Crimson

# Parâmetros identificados pelo nome
msg = '{saudacao}, são {hora:02d}:{minuto:02d}'
print (msg.format(saudacao='Bom dia', hora=7, minuto=30))
#Bom dia, são 07:30

# Função built-in format()
print ('Pi =', format(3.14159, '.3e'))
#Pi = 3.142e+00

Format() pode ser usada para formatar apenas um dado por vez. 
--------------------------------------------------------------------
Fatias de strings (slices):

Podem ser obtidas colocando índices entre colchetes após a string.
Os índices no Python:

• Começam em 0.
• Contam a partir do fim se forem negativos.
• Podem ser definidos como trechos:
• Na forma [posição inicial: tamanho (fim +1) : intervalo]. 
• Se não for definido o inicio, será considerado como 0. 
• Se não for definido o tamanho, será considerado o tamanho do objeto. 
• Se não for definido o intervalo (entre caracteres), será 1.

Exemplos:
texto="Python"
print(texto[0])
#P
print(texto[1])
#y
print(texto[5])
#n
print(texto[-1])
#n
print(texto[-2])
#o
print(texto[-6])
#P
print(texto[:2])
#Py
print(texto[2:])
#thon

print(texto[6])

#string index out of range
print(texto[0:5+1:2])
#Pto

Operações com intervalo negativo:
print ('Python'[::-1])
#nohtyP
print (texto[::-2])
#nhy
--------------------------------------------------------------------
Vários conteúdos para tratar com texto estão no módulo string, como funções e até um tipo de dado chamado Template, que é um modelo
de string que pode ser preenchido através de um dicionário. Os
identificadores são inciados por cifrão ($) e podem ser cercados por chaves, para evitar confusões.

Exemplos:
# importa o módulo string
import string
# O alfabeto
a = string.ascii_letters
print(a)
#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

#Executa o alfabeto um caractere para a esquerda
b = a[1:] + a[0]
print(b)
#bcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZa

#Cria uma string template
st = string.Template('$aviso aconteceu em $quando')

#Preenche o modelo com um dicionário
s = st.substitute({'aviso': 'Falta de eletricidade', 'quando': '03 de Abril de 2018'})
print (s)
#Falta de eletricidade aconteceu em 03 de Abril de 2018
--------------------------------------------------------------------