Introdução 4

Características iniciais - 4ª Parte

Controle de fluxo (comando if):

Exemplo 1:
temp = int(input('Entre com a temperatura: '))
if temp < 0:
    print ('Congelando...')
elif 0 <= temp <= 20:
    print ('Frio')
elif 21 <= temp <= 25:
    print ('Normal')
elif 26 <= temp <= 35:
    print ('Quente')
else:
    print ('Muito quente!')

Exemplo 2:
temp = int(input('Entre com a temperatura: '))
if temp == 0: print("Zero")
if temp < 0: print("Frio")

Exemplo 3:
condicao_tempo = 'frioooo' if temp < 0 else 'calorrrr'
print(condicao_tempo)
--------------------------------------------------------------------
#raw_input() foi renomeado para input() no python 3.
--------------------------------------------------------------------
Laços:

Exemplo para for:
total = 0
total_soma = 0
for valor in range(1, 10):
    total_soma = total_soma + valor
print (total_soma)

Exemplo para while:
total_soma = 0
conta_iteracao = 1
while conta_iteracao < 10:
    total_soma = total_soma + conta_iteracao
    conta_iteracao = conta_iteracao + 1
print (total_soma)

Obs.: A clausula break interrompe o laço e a clausula continue passa para a próxima iteração. No caso do while, o código dentro do else é executado ao final do laço, a não ser que o laço tenha sido interrompido por break.
--------------------------------------------------------------------
Variáveis:

No Python, as variáveis são criadas no momento da atribuição e destruídas (pelo garbage colector) quando não existem mais referências para elas. 
Os nomes das variáveis devem começar com letra ou _ e seguido por letras (sem acentuação), dígitos ou _, lembrando que o Python é 'Case Sensitive' e não aceita acentuação.
--------------------------------------------------------------------
Tipos de Dados:

Pré-Definidos: 

• Números (inteiros, reais e complexos).
• Texto.

Existem tipos que funcionam como coleções. Os principais são:

• Lista.
• Tupla.
• Dicionário.

Os tipos de Dados podem ser:

• Mutáveis: permitem que os conteúdos das variáveis sejam alterados.
• Imutáveis: não permitem que os conteúdos das variáveis sejam alterados.

Em Python, os nomes de variáveis são referências, que podem ser alteradas em tempos de execução. Os tipos e funções mais comuns estão implementados na forma de 'built-in', ou seja, eles estão sempre disponíveis em tempo de execução, sem a necessidade de importar nenhuma biblioteca.

Números (built-in):

• Inteiro (int): i = 1
• Real de ponto flutuante (float): f = 3.14
• Complexo (complex): c = 3 + 4j

A função long() utilizada para converter números inteiros em longos, já não existe no Python 3. A função int() abrange os números longos também. O seu tamanho vai ser limitado pelo tamanho da memória disponível.

A função builtin int() pode ser usada para converter outros tipos para inteiro, incluindo mudanças de base.
Exemplo:
# Convertendo de real para inteiro
print('int(3.14) =', int(3.14))
#int(3.14) = 3

# Convertendo de inteiro para real
print('float(5) =', float(5))
#float(5) = 5.0

# Calculo entre inteiro e real resulta em real
print('5.0 / 2 + 3 = ', 5.0 / 2 + 3)
#5.0 / 2 + 3 =  5.5

# Inteiros em outra base
print("int('20', 8) =", int('20', 8)) # base 8
#int('20', 8) = 16
print("int('20', 16) =", int('20', 16)) # base 16
#int('20', 16) = 32

# Operações com números complexos:
c = 3 + 4j
print('c =', c)
print('Parte real:', c.real)
print('Parte imaginária:', c.imag)
print('Conjugado:', c.conjugate())
#c = (3+4j)
#Parte real: 3.0
#Parte imaginária: 4.0
#Conjugado: (3-4j)

Número real (ponto flutuante) é qualquer número com um ponto decimal ou que contenha a notação cientifica na base 10 (e) ou (E). Exemplos:
2.34       
.009       
2e4  #2*10^4
5E-3 #5*10^-3
--------------------------------------------------------------------
Obs.:
Como em qualquer linguagem podemos ter problemas com as casas decimais. Veja o exemplo abaixo. Na multiplicação 0.1 * 0.2, não terá o valor 0.02 como esperado, mas algo muito próximo. Isto é comum nas linguagens de programação, o motivo é como os computadores realizam os cálculos, utilizando números na base binaria.
Exemplo:
print(0.1*0.2,2)
#0.020000000000000004
print(round(0.1*0.2,2))
#0.02

Obs.:
Durante as operações, os números serão convertidos de forma adequada
Exemplo: (1.5+4j) + 3 resulta em 4.5+4j.
-------------------------------------------------------------------- O Python tem uma série de operadores definidos para manipular números, através de cálculos aritméticos, operações lógicas ou processamento bit-a-bit (em que os números são tratados na forma binária).

Operações aritméticas:

• Soma (+)
• Diferença (-)
• Multiplicação (*)
• Divisão (/): 
• entre dois inteiros funciona igual à divisão inteira. Em outros casos, o resultado é real. 
• Divisão inteira (//): 
• se feito por inteiros, o resultado é truncado para o inteiro imediatamente inferior, 
• se feito por pelo menos um real, o resultado também será truncado como acima, mas o resultado será um real. 
• Módulo (%): 
• retorna o resto da divisão.
• Potência (**): 
• usada também para calcular a raiz do número, basta usar expoentes Fracionários:
• Exemplo: print(100 ** 0.5) #Saída: 10.0
• Positivo (+).
• Negativo (-).

Operações lógicas:

• Menor (<).
• Maior (>).
• Menor ou igual (<=).
• Maior ou igual (>=).
• Igual (==).
• Diferente (!=).

Operações bit-a-bit:

• Deslocamento para esquerda (<<).
• Deslocamento para direita (>>).
• E bit-a-bit (&).
• Ou bit-a-bit (|).
• Ou exclusivo bit-a-bit (^).
• Inversão (~).

--------------------------------------------------------------------
Algumas funções buit-in para tipos numéricos:

• abs(): retorna o valor absoluto do número
• oct(): converte para octal
• hex(): converte para hexadecimal
• pow(): eleva um número por outro
• round(): retorna um número real com o arredondamento definido.

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