LP 05/10/2011

   # # # # # # # # # # # # # #
  # Linguagens de Programação #
  # Prof. Fernando Pereira    #
  # notasdogarcia.blog.com    #
   # # # # # # # # # # # # # #

		// Vamos falar de linguagens imperativas.

  O que diferencia linguagens imperativas de linguagens funcionais?
  As linguagens imperativas são mais semelhantes à algoritimos.
  E são descritas usando estados que são alterados por comandos.
  O que são comandos então?

CONCEITO:
  Um Comando é uma linha de código destinada a alterar o estado de uma estrutura do programa.

  Exemplos de Tipos de comandos:
    Comandos de Desvio     - if, while, for, do-while, repeat, goto, break, throw, call, continue, etc..
    Comandos de Atribuição - a = b, a += b, a = *p
    // Tinha mais um aqui, mas demorei pra copiar e ele já tirou da tela =P

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Python é a linguagem com a qual vamos lidar para descrever linguagens imperativas.
  // Antigamente o professor utilizava Java, porém como hoje nós já temos alguma experiência com Java, ele prefere usar o Python para nós ganharmos prática.

  Python ganhou o nome de um seriado britânico.
  E é uma linguagem bem simples que já foi até usada para ensinar crianças.

  A filosofia de python é:

    beautiful is better than ugly
    Explicit is better than implicit. // apesar de que quanto explicidade SML é bem mais explicito que python né =P.
    Simples is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense
    Readability counts.
    Special cases aren't special enough to ...
    ...tem outras coisas mas o principal é isso aí. (na verdade nem consegui copiar o resto xP)

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

  Exemplo de código em Python:

    if 2 != 3:
      a = "oi"
    else:
      a = 2;

  Vamos então discutir os detalhes desse código, e do python em geral:

  (1) Como o tipo pode variar em tempo de execução? -> Tipagem dinâmica.
      Se voce tentar usar uma variável com o tipo dinâmico incompátivel da erro em tempo de execução e não compilação.

  (2) Para se testar o tipo de a em tempo de execução use type(a), no exemplo acima é retornado str.
      Ou seja voce pode perguntar o tipo em tempo de execução. É uma característica reflexiva de linguagens dinâmicas.

  (3) Blocos em python são definidos pela identação. Assim se eu digitasse else com dois espaços a mais antes dele, daria erro.

  (4) Em python pode-se "compilar e executar" uma string em tempo de execução.
      Ou seja dada uma string com código em python voce pode usar o comando "exec" para executa-la.

      Exemplo disso:
        a = 1
        exec "a = a + 1" # O comando exec é responsável pela execução da string.

       E com isso voce tem que a = 2 ao fim dessa execuçào.
       Ou seja voce consegue interpretar uma string como parte do código, e até mesmo acessar variáveis locais, com ela!
       (isso nem C faz dessa forma)

  As características 1, 2 e 4 são muito importantes lembre bem delas, pois elas definem linguagens dinâmicas.

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

  Notas de python:

    Python é uma linguagem normalmente interpretada, mas pode também ser usada de forma compilada.
    Existe também uma máquina virtual para python.

    O formato dos arquivos fonte de python são da forma: arquivo.py

    Python pode ser usado como uma linguagem script tipo bash.

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

Nota um pouco solta:

  O que é uma linguagem de tipo script?

CONCEITO:
  Linguagens de tipo Script
  São linguagens que gerenciam a ordem de chamada de outros programas, como um script de teatro.

  Uma linguagem puramente script é o bash que é o script usado pelo linux.
  E praticamente todo sistema operacional que se preze tem uma linguagem desse tipo associado, para
  que o gerenciamento dos programa possa ser feito de forma mais fácil.

  Tipos primitivos em Python:
    inteiros, strings, reais, boleanos. (mas assim como na linguagem C, um booleano = 0 é um false, e um !=0 é um true)

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

  Existem operações sobre bits em python também, assim como em C:
    40 >> 2
    Que shift é esse? O lógico ou o aritimético?
    (ele não terminou de falar, mas acho que é o aritimético que preserva o sinal do número) ( faça um teste se estiver com vontade :P )

  Não existe o operador "i++" em Phyton.

  Em Phyton pode-se escrever booleans resumidos: "2 <= 3 <= 4" e isso retornaria verdadeiro (poucas linguagens permitem isso).
  enquanto fazer "2 <= 3 == 4" retornaria falso.
  Ou seja, é um jeito mais economico para escrever expressões booleanas mais compridas.

  Assim como em C pode-se fazer: x = y = z = 0;
  Significando x=0; y=0; z=0;

  Em python existem tipos compostos, como (x,y,z) sendo uma tupla.

  Existem listas em python na forma:
  a = ['a', 'b', 'c']
  Uma lista pode ser usada como arranjo, diferentemente de SML.
  a[0] == 'a', isso retorna true.

  Existem umas notações interessantes em listas, seja a lista:
  a = [0,1,2,3,4,5];

  a[2:5] retorna [2,3,4] (pode pensar que ele rodou um for de (i=2; i<5; i++) e foi coletando os elementos da lista)
  a[:3] retorna [0,1,2]
  a[3:] retorna [3,4,5]
  a[3:] + ['bacon', 4] retonaria:
  [3,4,5, 'bacon', 4]

  Eu posso fazer uma atribuição usando essas notações:
  a[1:3] = ['a', 'b', 'c'] insere sobre as posições 1, 2 a lista [a, b, c] retornando: [0,'a','b','c',3,4,5] (repare que 1 e 2 foram deletados da lista)
  a[0:2] = [] apaga as duas primeiras posições da lista.
  a função duplist0([1,2,3]) retorna [1,2,3,1,2,3]

  Como já falei antes tuplas são da forma:
  t = 1,2,3
  E podem ser acessadas como arranjos também.

  o professor disse que uma tupla com um único elemento seria da forma u = (2,)
  não sei porque não poderia ser (2)

  Uma coisa interessante:
  Dicionários:
    u = ['abc': 2344, 'efg' : 51551]
  Assim se eu acessar u['abc'] eu terei como retorno 2344.
  Em outras palavras isso é uma tabela hash.

  Veja uma função:

  def fact(n):
    if n>1:
      return n * fact(n-1)
    elif n == 1 or n==0:    # else if
      return 1
    else:
      raise ArithmeticError("Numero negativo!") // lançando uma exceção

  Em phyton não importa muito o quão grande é o inteiro, ele deve ser capaz de armazena-lo em memória.
  Ex:
    fact(1) retorna um tipo inteiro mas.
    fact(999) apesar de não da erro de estouro de memória, é retornado um "long" (mas na verdade esse long teria mais de 64 bits para caber tudo)
    Posso até imprimir isso na tela, da um número imenso.
    Porém se eu chamar fact(1000) da erro, porque?
    É porque existe um número máximo de chamadas recursivas e esse número é 999.
    Para que eu pudesse calcular o fact(1000) eu precisaria de uma abordagem iterativa.

  Veja uma implementação iterativa:

  def factW(n):
    ans = 1
    while n > 1:
      ans *= n
      n-=1
    return ans

  Note que se eu mudasse apenas um detalhe, isso podia dar erro:

  def factW(n):
    ans = 1
    while n > 1:
      ans *= n
    n-=1
    return ans

  O motivo do erro caso ainda não tenha percebido é que o bloco do while é definido pela identação.
  Mudar isso faria a atribuição n-=1 ficar fora do while, e o programa entraria em loop infinito.

  def sum(a, b): return a + b
  f = sum
  Nesse caso f é uma função que é retornada por sum, assim como em sml.
  // Em outras palavras existem funções de alta ordem em python!.

  O professor chamou isso de "funções também serem de primeira classe".
  Ou seja também são objetos que podem ser retornados e recebidos como parâmetros.
  Também se pode fazer closures:
  def make_inc(n):
    def inc(x):
      return x + n
    return inc

  Assim make_inc(2) retorna um closure com o n definido na tabela de simbolos da função inc.
  // (para quem não lembra um closure é a função juntamente com uma tabela com os valores das variáveis)

  Outra forma de se declarar isso:
    def make_inc2(n):
      return lambda x : x + n
  # assim como o fn em SML.

  Veja um outro modo de se declarar uma função:

  f = lambda x: lambda y: x+y
  a = f(3)
  a(4)
  e por fim isso retorna 7 (ou seja a soma de 3+4).

  Também posso chamar f na forma:
  f(3)(4) que também retornaria 7.

  Uma expressão interessante em python:

  a = [1,2,3,4]
  b = [3*x for x in a]
  Assim b retornaria:
  b = [3, 6, 9, 12]
  ou seja multiplicou tudo em a por 3.
  Isso é chamado de expressões currificadas eu acho.
  // Sugiro que testem isso, pois me pareceu muito vago com poucos exemplos.

  Veja uma função filtro:
    def filterC(c,1):
      return [s for s in l if c(s)]

  Assim:
    filterC(lambda x: x > 1, [1,2,3,4])

  retornaria: [2,3,4]

  Veja alguma funções built in:

  map(lambda n: n * n * n, range (1,4))
  Isso retorna:
  [1,8, 27]

  Ou seja range(1,4) retorna um arranjo com [1,2,3]
  E map aplica a função lambda n: n³ para cada elemento.

  sum ([1,2,3,4]) retorna 10.

  Em python existe um "atomo" que é chamado de None.

  a = None

  É o único valor que não tem tipo. É o equivalente ao void do C e C++ imagino.

  Toda função que não retorna nada, de fato retorna "None".

  // Comentários pessoais: Em python uma função pode retornar qualquer coisa, em tempo de execução, string ou inteiro não é preciso um tipo de retorno estático.

  Em python eu posso fazer isso:
  if type(a) == type(None): ...
  Ou seja esse é uma "meta-operação" que existe em python mas não existe em C por exemplo.

  // fim da aula.