Básico de Python II

Em geral, quando estamos eliminando código repetitivo por meio de funções também temos algumas variáveis ​​repetidas neste código. No Python, variáveis ​​podem ter tratamentos diferentes dependendo de onde eles estão. Todas as variáveis ​​que vimos até agora.agora eles são chamados de variáveis ​​globais, ou seja, a qualquer momento ou a qualquer momento parte do código do programa, você pode usá-los (para ler o conteúdo ou atribuir valores).

Funções tem um tipo especial de variáveis que são chamadas de variáveis locais. Estas variáveis existem apenas dentro da função, de forma que caso o programador determine uma função e armazene um certo dado em uma variável local, ao término desta função a variável será destruída, não sendo possível recuperar seu valor.

Mas como então, pode-se recuperar um valor de uma função? Para isto usamos o comando return seguido de algum valor ou uma variável. Neste caso, a variável local "esconderá" a variável global, enquanto a função estiver rodando. Um pouco confuso? Então confira o exemplo abaixo:

>>>a = 4
>>>def print_func():
... a = 17
... print 'in print_func a = ', a
...

Agora chame a função print_func() e peça o valor a utilizando o comando print, seu resultado deve ser este:

>>>print_func()
in print_func a = 17
>>>print 'a = ', a
a = 4

Com isso, podemos concluir que as variáveis ​​criadas dentro de uma função (variáveis local), não afeta as variáveis ​​externas (variáveis ​​globais). Variáveis ​​locais existe apenas dentro do espaço limitado pela função e, portanto, não pode ser usado, nem afeta nada fora deste espaço.

A recursividade é uma maneira de iteração (repetição) na qual uma função chama a si mesma repetidamente até que uma condição de saída seja satisfeita.A seguir mostraremos um exemplo de uma função responsável por calcular o fatorial de números positivos inteiros e demonstra como uma função pode chamar a ela mesma utilizando a propriedade recurssiva.

>>>def fatorial(n):
... if n <= 1:
... return 1
... return n * fatorial(n - 1)

...
>>>print '2! = ',fatorial(2)
2! = 2
>>>print '3! = ',fatorial(3)
3! - 6
>>>print '4! = ',fatorial(4)
4! = 24::
>>>print '5! = ',fatorial(5)
5! = 120

Um passo-a-passo de como a função é executada, utilizando o comando fatorial(n), para n = 3:

1. Quando chamamos a função fatorial(3), fornecemos à função o valor 3 para o parâmetro de entrada n.
2. O comando if testa se n é menor ou igual a 1, como este não é, a função continua.
3. Nesta parte a função pretende retornar o valor n*fatorial(n-1), ou seja, 3*fatorial(2). Entretanto, ela ainda não possui o valor de fatorial(2). Para isso, a função fatorial é novamente chamada com n = 2, retornando o valor 2*fatorial(1).
4. Como ainda não temos fatorial(1), a função chama a si mesma mais uma vez para calculá-lo.
5. Com isto, atingimos a condição de saída do if que está na função fatorial e então o valor retornado é 1.

Vamos fazer uma retrospectiva do que aconteceu ao se executar esta função:

fatorial(3)
3 * fatorial(2)
3 * 2 * fatorial(1)
3 * 2 * 1 = 6

Pensando na reutilização de código, a linguagem Python já possui um conjunto de funções prontas para serem usadas ou agregadas em seus programas. Essas funções estão agrupadas em estruturas chamadas módulos. Para a utilização desses módulos é preciso utilizar o comando import nome_do_módulo.

Após ter importado o módulo, qualquer função pertencente a ele pode ser utilizada através do comando nome_do_módulo.função(argumento).É possível importar do módulo apenas a função desejada. Para isso, utilizamos o comando from nome_do_módulo import função, e a função estará disponível para utilização.

Você pode também definir o seu próprio módulo.Defina-se as funções desejadas e ao final,você salva o seu módulo com a extensão, py. Exemplo:

Digite em um editor de texto simples:

#IMC.py
def indice(altura,peso):
imc = peso/(altura**2)
return imc
def estado(imc):
if imc < 24.9:
print 'NORMAL'
elif 24.9 < imc < 29.9:
print 'PESO A MAIS'
elif 29.9 < imc < 40:
print 'LIGEIRA OBESIDADE'
elif imc > 40:
print 'OBESIDADE'
else:
print 'MAGRO DEMAIS'
def pesoideal(peso,altura):
a = 20*(altura**2)
b = 24.9*(altura**2)
print 'Seu peso ideal se encontra entre %f e %f' %(a,b)

Agora, salve o seu arquivo como IMC.py . De agora em diante, o módulo já pode ser utilizado por qualquer programa em Python.

Listas são sequências de variáveis. Após definidas, podem ser modificadas de várias maneiras, pois são mutáveis.
Para definir uma lista basta digitar:

lista = [9,8,7]

O endereçamento dos componentes começa no 0. Então, se você deseja usar um determinado elemento da lista, basta chamá-lo: lista[x]. Com isso, você está se referindo ao elemento de posição x na lista. Alguns comandos referentes a listas:

len(lista) informa o tamanho da lista

lista.append(x) adiciona o elemento x no nal da sua lista
lista.extend([6,5,4]) adiciona uma lista inteira no nal da sua lista
lista[y]= x insere o valor y na posição x da lista

Nós já vimos anteriormente que variáveis comuns armazenam um único valor. Entretanto, existem outros tipos de variáveis capazes de armazenar mais de um valor. Em Python, chamamos essas variáveis com capacidade de armazenamento de listas ou vetores. Vamos explicar a sintaxe de uma lista através das linhas de código exibidas abaixo:

>>> meses = ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho','Agosto', 'Setembro', 'Outubro', 'Novembro',
'Dezembro']
>>> while 1:
... qual_mes = input("Escolha um mês (1-12)? )
... if 1 <= which_one <= 12:
... print "O mês é ", meses[qual_mes - 1]

Ao rodar este programa obteremos a seguinte saída como exemplo:

>>> Escolha um mês (1-12)? 5
O mês é Maio
>>> Escolha um mês (1-12)? 12
O mês é Dezembro
>>> Escolha um mês (1-12)?

Primeiro criamos a nossa lista,a definição de uma lista é análoga a de uma variável qualquer, porém isolando o conteúdo com colchetes. O uso de aspas (duplas ou simples) apenas é necessário caso estejamos inserindo na lista uma string, se armazenássemos apenas um número, não seria necessário.

Exemplo:

teste = ['vida', 42, 'universo', 6, 'e', 7]

Depois colocamos o comando "while 1:" que faz com que o nosso programa entre em loop. O programa vai rodar indefinidamente até ser dado o comando Ctrl+D, ou até que o programa seja fechado. Uma vez nesse loop, é definida pelo usuário a variável "qual_mes", e depois de um tratamento de erros, feito com a utilização de um comando if, é nos devolvido o nome do mês selecionado, Na última linha do código utilizamos uma propriedade da lista, que é buscar um dado da lista, que se dá escrevendo o nome da lista e entre colchetes o número referente ao local da lista onde está o dado requerido (lista[número]). Observe que na nossa linha de código print é dado pelo mês escolhido
menos um, ou seja: o Python indexa suas listas partindo do zero.Além de selecionar um elemento de uma lista, temos algumas outras propriedades que apresentaremos em seguida.

Para colocar um novo arquivo a uma lista qualquer, chamamos uma método chamado .append:

>>>teste = []
>>>teste.append('zero')
>>>teste.append('um')
>>>teste
['zero','um']

Infelizmente o comando .append só consegue adicionar um dado na lista por vez ,mas se desejarmos adicionar mais dados podemos simplesmente somar listas,multiplicá-las,ou utilizar o comando .extend:

>>>teste.extend(['dois','três',]
>>>soma = ['quatro','cinco']
>>>teste += soma
>>>teste + ['seis']
['zero','um','dois','três','quatro','cinco','seis']
>>>teste*2
[zero','um','dois','três','quatro','cinco','seis',zero','um','dois','três','quatro','cinco','seis']

Observação: o código teste += soma é o mesmo que escrever teste = teste + soma.

Quando chamamos a lista teste sem referenciarmos nenhum elemento específico estamos lidando com todos os elementos dessa lista.Também podemos imprimir somente alguns valores de dentro da lista,precisando apenas indicar o local:

>>>print 'As variavéis na lista teste são ',teste
As variavéis na lista teste são ['zero','um','dois','três','quatro']
>>>print 'As variavéis 0 e 3 da lista teste são ',teste[0],' e ',teste[3]
As variavéis 0 e 3 da lista teste são zero e três

Também podemos utilizar o comando for

>>>for valor in teste:
... print valor
...
zero
um
dois
três
quatro

A função .index retorna o índice da primeira ocorrência do valor especicado, ou seja,para imprimirmos na tela a posição em que a string "quatro" aparece utilizaríamos o código:

>>>print lista.index("quatro")

Observação: É importante notar que a lista inicia sua contagem a partir do 0 (zero) o que explica o número 2 obtido acima.

Para remover um elemento de uma lista utilizamos o comando del, referenciando o index,ou posição da lista, onde haverá a remoção.

>>>print 'Antes a lista 'teste' era: ',teste
Antes a lista 'teste' era: ['zero','um','dois','três','quatro']
>>>del teste[3]
>>>print 'Agora a lista 'teste' é: ',teste
Agora a lista 'teste' é: ['zero','um','dois','quatro']

Conseguimos obter o mesmo efeito utilizando o método remove,que procuraria a primeira ocorrência na lista para um dado valor ou string:

>>>lista += ['um']
>>>print 'Antes a lista 'teste' era: ',teste
Antes a lista 'teste' era: ['zero','um','dois','quatro','um']
>>>teste.remove("um")
>>>print 'Agora a lista 'teste' é: ',teste
Agora a lista 'teste' é: ['zero','dois','quatro','um']

Para descobrir o tamanho de uma lista, usamos o comando len(), como exemplificado no código abaixo:

>>>print 'O tamanho da lista teste é: ', len(teste)
4

Nos dizendo que a lista "teste" possui 4 variáveis

Essa função gera um vetor contendo números (inteiros) sequenciais,obedecendo a regra da escrita:

range(inicio,fim)

É de grande importância observar que o número finalizador descrito acima não é incluído no vetor por exemplo:

>>>vetor = range(1,11)
>>>print vetor

O código acima nos dará como saída o vetor: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] . Em outras palavras o último número é excluído do vetor, portanto o 11 não entra na composição deste.A função range aceitará quaisquer números inteiros desde que o número inicial seja maior que o número final, bem como quando apenas o número final é passado para a função, portanto são válidas as construções:

>>> range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(5)
[0, 1, 2, 3, 4]
>>> range(21, 5)
[ ]

No último exemplo foi retornado um vetor vazio, isso se deu porque o elemento inicial era maior que o final.Outra importante característica desse comando é a de adicionar uma terceira variável no range,indicando o incremento entre os números delimitados.

>>>range(0,24,4)
[0, 4, 8, 12, 16, 20, 24]

Expressões Booleanas são sentenças lógicas que seguem as leis da Álgebra de Boole. A Álgebra Booleana trabalha com valores lógicos, interpretando esse valores através de números binários, ao oposto do decimal, utilizando o valor 0 para definir uma operação FALSA e o valor 1 para definir uma operação VERDADEIRA. As operações entre valores lógicos são feitas de forma análoga às operações feitas entre conjuntos de elementos, sendo que cada um desses elementos é tratado como uma situação, podendo ser verdadeiros ou falsos.

No python esses seguintes valores são interpretados como falso:

False None 0 () []

Ou seja, os valores False e None, o valor numérico 0 e as sequências vazias são denominadas falsas enquanto todos os outros valores possíveis são interpretados como verdadeiro. Como na maioria das linguagens de programação, temos a possibilidade de utilizar a Álgebra Booleana para realizar testes lógicos usados em estruturas de controle, com esses testes podemos conferir a veracidade de operações, além de podermos montar funções condicionais if, laços de repetição while e for, entre outros, que podem ser inseridos em qualquer lugar de seu programa. Observem o exemplo abaixo:

>>> a = 6
>>> b = 7
>>> c = 42
>>> print 1, a == 6
>>> print 2, a == 7
>>> print 3, a == 6 and b == 7
>>> print 4, a == 7 and b == 7
>>> print 5, not a == 7 and b == 7
>>> print 6, a == 7 or b == 7
>>> print 7, a == 7 or b == 6
>>> print 8, not (a == 7 and b == 6)
>>> print 9, not a == 7 and b == 6

Teríamos como saída o seguinte resultado:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Para entender a lógica do que foi feito acima, devemos relembrar alguns conceitos de álgebra booleana. Abaixo temos uma breve descrição sobre os operadores lógicos:

• Operador "and": (em portugês "e") significa que ambas as afirmações devem ser verdadeiras, caso contrário a expressão é falsa.
• Operador "or": (em português "ou") significa que se ao menos uma das afirmações
for verdadeira, então toda a expressão também o será.
• Operador "not": (em português "não") significa uma inversão lógica em uma expressão, o que era verdadeiro, se torna falso, e viceversa.

As tabelas abaixo podem ajudar a clarificar alguns desses conceitos:

O programa abaixo mostra um exemplo de aplicação de expressões booleanas. Vamos dizer que precisamos de um programa que indique a situação de um aluno ao nal do ano, sendo que elas são assim:

• Se o aluno obtiver nota maior ou igual e seis e não tiver mais de 10 faltas, ele passa direto;
• Se o aluno obtiver nota maior ou igual e seis e tiver mais de 10 faltas, ele fica de recuperação por falta;
• Se o aluno obtiver nota maior que quatro e menor que seis e não tiver mais de 10 faltas, ele fica de recuperação por nota;
• Se o aluno obtiver nota menor que quatro, ele repete direto;
• Se o aluno obtiver nota maior que quatro e menor que seis e tiver mais de 10 faltas, ele repete por não obter nota e por excesso de faltas;

Para montar esse programa precisaremos utilizar as Expressões Booleanas, já que precisamos fazer a vericação de duas situações, temos que vericar se o aluno tem nota e se ele tem presença.

>>> alunos = ['Fred','Suzana','Claudio','Puga','Robson','Gustavo']
>>> nota = [5.4, 6.2, 2.9, 9.9, 7.8, 4.9]

>>> faltas = [9, 5, 15, 2, 11, 12]
>>> contador = 0
>>> for aluno in alunos:
... if nota[contador] >= 6.0 and faltas[contador] <= 10:
... print 'Aluno: ',aluno
... print 'Nota nal: ',nota[contador]
... print 'Faltas: ',faltas[contador]
... print 'Resltado: Passou de ano'
... elif nota[contador] >= 6.0 and faltas[contador] > 10:
... print 'Aluno: ',aluno
... print 'Nota nal: ',nota[contador]
... print 'Faltas: ',faltas[contador]
... print 'Resltado: Recuperação por falta'
... elif nota[contador] >= 4.0 and nota[contador] < 6.0 and faltas[contador] <= 10:
... print 'Aluno: ',aluno
... print 'Nota nal: ',nota[contador]
... print 'Faltas: ',faltas[contador]
... print 'Resultado: Recuperação por nota'
... elif nota[contador] >= 4.0 and nota[contador] < 6.0 and faltas[contador] > 10:
... print 'Aluno: ',aluno
... print 'Nota nal: ',nota[contador]
... print 'Faltas: ',faltas[contador]
... print 'Resultado: Repetiu direto por não obter nota e por excesso de faltas'
... elif nota[contador] < 4.0:
... print 'Aluno: ',aluno
... print 'Nota nal: ',nota[contador]
... print 'Faltas: ',faltas[contador]
... print 'Resultado: Repetiu direto por nota'
... "
... contador+=1