programação para advogados - fgv direito...

GRADUAÇÃO 2015.1

Apostila 1

Programação Para advogados

AUTORES: DANIEL CHADA E IVAR HARTMANN

SumárioProgramação para Advogados

IntRODUÇÃO .................................................................................................................................................... 3

MóDUlO 0 - BOAS VInDAS .................................................................................................................................... 4

MóDUlO 1 - VARIáVeIS, núMeROS, StRInGS (Pte. 1) ................................................................................................. 5Literais ........................................................................................................................................... 5Variáveis ........................................................................................................................................ 7Operadores ...................................................................................................................................... 9Expressões ..................................................................................................................................... 10Statements (declarações) ................................................................................................................ 11Strings .......................................................................................................................................... 11O none ........................................................................................................................................ 13Funções úteis: dir(), type(), locals(), globals() .................................................................... 13Tipagem dinâmica ......................................................................................................................... 14

MóDUlO 2 - tUPlA, lIStA, InDexInG e SlIcInG, cOnDIcIOnAIS cOM If ......................................................................... 15Estruturas de Dados ....................................................................................................................... 15Lista e Tupla ................................................................................................................................. 15Indexação (indexing) e Recorte (slicing) ............................................................................................ 16Condicionando a sequência do programa: if, elif, else .......................................................................... 19Operadores Lógicos: not, or, and ....................................................................................................... 23

MóDUlO 3 - fUnÇõeS (Pte. 1) ............................................................................................................................. 25Definindo (‘declarando’): ................................................................................................................. 25Usando (‘chamando’): ..................................................................................................................... 25O que é ‘escopo’? .......................................................................................................................... 27Revendo operadores ........................................................................................................................ 28A palavra reservada pass ............................................................................................................... 29Mudando variáveis dentro de um escopo ---

Pass by Value, Pass by Reference, ** pass-by-object reference ** ...................................... 30Retornando valores (ou não) ............................................................................................................ 31

MóDUlO 4 - IteRAÇÃO cOM for, range(); A “SUA AMIGA A InteRnet” ...................................................................... 34Usando range() .......................................................................................................................... 35Sua Amiga a Internet” ou “Olhe no Stack Overflow Antes!” ................................................................. 36

MóDUlO 5 - IMPORtAÇÃO De MóDUlOS, ABRInDO e MAnIPUlAnDO ARqUIVOS, DIcIOnáRIOS ........................................... 38Arquivos - abrindo, e manipulando, de dentro e de fora ...................................................................... 38Dicionários ................................................................................................................................... 41Importando Módulos ...................................................................................................................... 44Manipulando arquivos em si, não só seu conteúdo (o módulo os) ........................................................... 46

MóDUlO 6 - fUnÇõeS (Pte. 2); BUIlt-InS: zIP, MAP, ReDUce, fIlteR; USAnDO lAMBDA; USAnDO *ARGS, **kwARGS ............. 47Valores default em funções ............................................................................................................... 49Funções anônimas com lambda ....................................................................................................... 51Parâmetros Variáveis com *args, **kwargs ......................................................................................... 54

MóDUlO 7 - StRInGS AVAnÇADOS ........................................................................................................................ 57Unicode strings .............................................................................................................................. 57Formatação ................................................................................................................................... 61Multi-line strings ........................................................................................................................... 63Enfim ...O porque do “#coding: utf-8” no início dos arquivos! ....................................................... 64

MóDUlO 8 - núMeROS BInáRIOS, tABelAS VeRDADe, OR, AnD, xOR, nAnD ................................................................... 65Operadores Bitwise: not, or, xor, and, nand ....................................................................................... 65

MóDUlO 9 - USAnDO APIS exteRnAS .................................................................................................................... 67

AnexO A - RecURSOS OnlIne¶ ............................................................................................................................. 68

RefeRêncIAS¶ ................................................................................................................................................. 69

PROgRAMAçãO PARA ADVOgADOS

FgV DIREITO RIO 3

Introdução

Esta apostila visa prover resumos do conteúdo visto em sala durante as au-las teóricas da Atividade Complementar ‘Programação para Advogados’. Não se visa que esta seja uma referência completa nem aprofundada de nenhum dos temas abordados em seu texto, mas sim uma introdução amena a certos conceitos de utilidede a alunos de graduação de Direito ou de outros temas de ‘Humanas’.

Almeja-se que os temas aqui abordados formem uma base conceitual para posterior aprofundamento tanto na teoria quanto na pratica do desenvolvi-mento de software.


FgV DIREITO RIO 4

Módulo 0 - Boas VIndas

Bem-vindos Advo* ...programadores!Esta apostila segue o material coberto nas aulas teóricas da ATC “Progra-

mação para Advogados”. Teremos exemplos práticos toda semana. O formato desta apostila tem dupla funcionalidade: i. de ser uma referência impressa para acompanhamento e ii. ser um repositório de exemplos de código a serem explorados e editados.

Com este fim, escolhemos oferecer não só a versão impressa da apostila, mas também uma versão em iPython Notebook. iPython Notebook é um framework que permite a edição de texto, junto com a execução de código Python, em células auto-contidas. Desta forma é possível executar e editar, no seu próprio computador, os códigos dos exemplos expostos aqui.

A homepage do Ipython Notebook contém instruções para instalação para Windows, OSX e Linux.

Nosso desejo é que você, leitor e aluno da ATC, use esta funcionalidade para melhor entender o código provido a cada exemplo e tente explorar dife-rentes aspectos do Python.

Boa Sorte!

http://ipython.org/notebook.html


FgV DIREITO RIO 5

Módulo 1 - VarIáVeIs, núMeros, strIngs (pte. 1)

####

Literais

São as expressões e a notação usadas para gerar os valores de tipos built-in como números inteiros, longos (que ocupam mais espaço em memória, mas são maiores), decimais (também conhecidos como floating point ou float), números complexos e strings. Exemplos: 4, 3.2e212, 3.14159, 1+3j,’Ivar’.

Estes são chamados literais pois os objetos são literalmente aquilo que representam: 3, “spam”, 7e4

Literais podem ser declarados, ou convertidos (dentro do possível) com operadores (que veremos abaixo) built-in do Python. isto é:

In [1]:

int(4.5) # gera um inteiro (que geralmente usa até 32 bits

de memória)

out[1]:

4

In [2]:

str(4.5) # gera uma string

out[2]:

“4.5”

In [3]:

long(4.5e21) # gera um número longo, que tem precisão

ilimitada (note o L ao final)


FgV DIREITO RIO 6

out[3]:

4500000000000000000000L

In [4]:

float(3) # gera um decimal, também chamado de ‘ponto

flutuante’ (floating point)

out[4]:

3.0

In [5]:

bool(4.5) # gera um booleano

out[5]:

True

In [6]:

bool(0.000) # zero é sempre falso no Python

out[6]:

false

Python permite uma série de outros formatos literais muito úteis na com-putação e ciência, mas que não cabem no escopo desta apostila, como núme-ros complexos (a + b√-1) octais (0-7), hexadecimais (1-9,A-F) e binários (0,1).

Veremos binários brevemente em uma das últimas unidades.

In [7]:

complex(1,3.14159)


FgV DIREITO RIO 7

out[7]:

(1+3.14159j)

In [8]:

oct(500) # um zero sempre o precede

out[8]:

“0764”

In [9]:

hex(500) # um ‘0x’ sempre o precede

out[9]:

“0x1f4”

In [10]:

bin(500) # um ‘0b’ sempre o precede

out[10]:

“0b111110100”

VariáVeis

Variáveis são nomes que o programador dá a objetos no seu código. Pode-mos pensar em objetos como espaços de memória alocados no computador. Estes espaços têm diferentes tamanhos e são grandes o suficiente para repre-sentar o que quer que cada objeto seja. Um inteiro no Python, por exemplo, geralmente ocupa 32 bits de memória.

Assim, uma variável referencia um objeto. Uma referência é um ponteiro, isto é, uma seta que aponta da variável (nome) ao objeto (lugar).

Veja a figura 1.1: internamente, a variável aponta para o espaço de memó-ria criado por se executar a expressão (veja o que é uma expressão abaixo) do operador 3.


FgV DIREITO RIO 8

Variáveis são criadas no momento que você as atribue um valor (tecni-camente algumas são criadas antes disso, mas para nós basta esta definição). Atribuições subsequentes no código mudam o valor da variável (i.e. mudam para onde ela aponta). Variáveis nunca guardam em si nenhum tipo de infor-mação, elas simplesmente se referem a um lugar onde algo fica. [1]

Quando uma variável aparece em uma expressão, ela é imediatamente substituída pelo objeto para qual aponta:

In [11]:

x = 3 # crio o nome ‘x’ e mando ele apontar para o

objeto ‘3’ gerado na memória

print x # não imprimo ‘x’, e sim o valor para o qual ‘x’

aponta

3

In [12]:

y = “Python para advogados é mole!”

print y

Python para advogados é mole!

A nomenclatura de variáveis deve seguir algumas regras: i. o primeiro caractére da variável deve ser uma letra ou o _ (underscore); ii. nomes de variáveis são case-sensitive; iii. nomes de variáveis só podem conter caracréres alfanuméricos ou o

underscore (a-z,A-Z,0-9,_)


FgV DIREITO RIO 9

In [13]:

_oi_1 = ‘0’; Oi = 1; oi = ‘2’ # exemplos de variáveis

(dica: o ‘;’ funciona igual à quebra de linha: permite um

novo comando)

print _oi_1, oi, oi

0 1 2

OperadOres

Operadores computam algum valor, quando executadas pelo Python. A tabela 1.1 lista todos os operadores do Python, em ordem de precedência.

operador descrição veremos?

yield x protocolo de envio de uma função geradora talvez

lambda args: expressão geração de função anônima sim

x if y else z seleção ternária talvez

x or y ‘ou’ lógico sim

x and y ‘e’ lógico sim

not x negação lógica sim

x in y; x not in y pertence (iteráveis, conjuntos) sim

x is y; x is not y teste de identidade de objeto sim

x >,>=,<,<= y compara magnitude, ou sub/super-conjunto sim

x == y, x != y igualdade/desigualdade de valores sim

x | y ‘ou’ bitwise, união de conjuntos sim

x & y ‘e’ bitwise, interseção de conjuntos sim

x ^ y xor bitwise sim

x <<,>> y shiftar x, y bits para a esquerda/direita sim

x + y adição, concatenação sim

x - y subtração, deferença de conjuntos sim

x y multiplicação, repetição sim

x % y módulo (resto), formatação sim


FgV DIREITO RIO 10

operador descrição veremos?

x /,// y divisão: real e piso sim

-x,+x negação, identidade sim

~x ‘não’ bitwise, inversão sim

x ** y potênciação sim

x[i] indexação (sequências, strings, etc) sim

x[i:j:k] recorte (slicing) sim

x(...) chamada (função, método, classe, ‘chamáveis’) sim

x.attr referência a attr sim

(...) tupla, expressão, expressão geradora sim

[...] lista, list comprehension sim

{...} dicionário sim

fonte: tutorialspoint

expressões

Expressões são combinações de objetos (literais ou outros) e operadores que computam algum valor, quando executadas pelo Python.

Expressões compostas seguem as regras de precedência de operadores. Expressões compostas podem, porém, ser agrupadas por parênteses em su-bexpressões, ignorando as regras de prioridade normalmente aplicadas aos operadores (veja a Tabela 1.1 e o código abaixo).

In [14]:

x = 2 + 3 * 4 # o lado direito do igual é uma expressão

y = (2 + 3) * 4 # aqui também

print x, y

14 20

http://tutorialspoint.com


FgV DIREITO RIO 11

StatementS (decLarações)

Uma statement no Python é qualquer linha de código que o Python con-siga interpretar e executar. Expressões podem ser declarações ou parte delas, mas nem toda expressão é uma statement.

Essa distinção se tornará mais importante quando estudarmos funções anônimas com o operador lambda e as expressões geradas com ele.

strings

Strings são cadeias de caracteres, delimitadas por aspas (simples ou du-plas). Strings são literais de enorme utilidade na programação, e vamos usá--los constantemente neste curso. Esta ‘parte 1’ sobre strings expõe o básico do seu funcionamento, para que possamos começar a criá-los e manipulá-los.

A primeira característica a mencionar é que strings, no Python, podem ser delimitados por aspas simples ('') ou duplas (""), desde que se mantenha a conformidade, isto é, se abrimos uma string com aspas simples, o Python só entenderá que a string se fechou ao ver a próxima aspa simples. Veja:

In [15]:

x = (“A”,’A’) # aspas e aspas duplas são a mesma coisa,

isto é só uma conveniência

print x

(“a”, “a”)

Strings comportam caracteres especiais e difíceis de digitar com sequên-cias de escape. No Python, toda sequência de escape é iniciada pela ‘barra invertida’ (backslash): \

Sequências de escape são consideradas como um único caractere, apesar de, em geral, serem digitadas com dois (a barra invertida e mais um). As prin-cipais sequências de escape são (nova linha), (tab), ' (aspas simples, " (aspas duplas), \\ (a própria barra invertida).

Então, se temos uma string definida com aspas duplas ...e precisamos inse-rir aspas duplas dentro da mesma string, podemos usar a sequencia de escape " que dirá ao Python que esta aspa dupla não deve ser interpretado como o fim da minha string.

Uma lista das sequências de escape permitidas pelo Python está no tutorial de strings do site TutorialsPoint:

http://www.tutorialspoint.com/python/python_strings.htm


FgV DIREITO RIO 12

In [16]:

x = ‘o advogado’

y = ‘o advo\ngado’

# a função built-in len() dá o comprimento do objeto

passado print x,’:’,len(x)

print y,’:’,len(y)

# a sequência de escape \” faz com que a aspa dupla

# não seja interpretada como delimitador da string!

x = “\ndisse\t\”oi\””

print x,’:’,len(x)

o advogado : 10

o advo gado : 11

disse “oi” : 11

Strings são iteráveis (como veremos na seção sobre iteração) e implemen-tam diferentes operadores, incluindo concatenação (via o mais, ‘+’), indexa-ção e slicing (com ‘[]’) e repetição (via o operador de multiplicação, ‘*’:

In [17]:

x = “Dani” + “el” # concatenação com +

print x

x = ‘oi! ‘ * 3 # repetição com *

print x x = “Oi, me chamo Daniel” # slicing com []

print x[0:13] + ‘Felipe’

Daniel

oi! oi! oi!

Oi, me chamo Felipe

Veremos mais sobre estes operadores no módulo sobre listas.


FgV DIREITO RIO 13

O none

O none é uma palavra reservada do Python e uma constante built-in. none implica a ausência de valor. none pode ser usado quando queremos declarar uma variável, mas não lhe dar nenhum valor. Vale ressaltar que none sempre é avaliado como falso (veja o exemplo abaixo).

Veremos mais sobre o none na seção sobre funções.

In [18]:

x = none

print x

print bool(x)

x = 3

print x

none

false

3

Funções Úteis: DIr(), Type(), LocaLs(), gLobaLs()

Existem certas funcionalidades muito úteis no Python, que são disponi-bilizadas como funções do próprio Python, não atreladas a algum módulo ou objeto. Veremos muitas destas no decorrer desta apostila. Vamos começar explorando quatro:

type(x): a função type retorna um objeto type que representa o tipo da variável x em questão (veja a seção tipagem dinâmica para exemplos).

dir(x): retorna uma lista dos atributos (variáveis e funções) internos da variável x em questão

locals(): retorna uma lista co os nomes de todas as variáveis no escopo local (veremos mais sobre escopo no módulo sobre funções)

globals(): retorna uma lista co os nomes de todas as variáveis no escopo global (veremos mais sobre escopo no módulo sobre funções)

print é um statement tão utilizado no Python, que os criadores da lingua-gem não requerem o uso de parênteses para sua chamada (isso mudou no Python 3). Vale notar que o print no Python 2.x não é um operador nem chamada de função.


FgV DIREITO RIO 14

tipagem dinâmica

O Python utiliza uma forma de designação de tipos chamada ‘tipagem dinâmica’ (em contraste à ‘tipagem estática’). Isto significa que toda a infor-mação sobre o tipo de ma variável fica guardada com o objeto ao qual ela aponta, não com a própria variável.

Veja:

In [19]:

x = 3 # x é um número

print type(x)

x = ‘e agora?’ # x é um string

print type(x)

x = None # x agora é o None! (única coisa no

Python que tem o tipo NoneType)

print type(x)

x = len # x agora é a função len, logo seu tipo é

‘função built-in’

print type(x)

x = type # finalmente, x agora é a própria função

type, seu tipo então é ‘type’

print x

<type “int”>

<type “str”>

<type “noneType”>

<type “builtin_function_or_method”>

<type “type”>

Encontramos uma lista dos tipos built-in do Python em python.org

https://docs.python.org/2/library/types.html


FgV DIREITO RIO 15

Módulo 2 - tupla, lIsta, IndexIng e slIcIng, condIcIonaIs coM If

estruturas de dadOs

Uma estrutura de dados é uma forma de se organizar os dados para utilização eficiente. Seja consulta, manipulação ou adição posterior de novos dados de forma rápida, ou até utilizações altamente específicas. Toda lingua-gem de computação se utiliza de estrutura de dados para alcançar seus fins.

O Python (como toda outra linguagem) permite a criação de estruturas de dados por parte do programador. Mas o Python também provê uma série de estruturas genéricas e de forte utilidade. Já vimos uma destas: a string, que é uma forma de se organizar characteres individuais em sequência.

Veremos agora duas outras estruturas que também organizam dados de forma sequencial: a lista e a tupla.

####

Lista e tupLa

A lista é uma das estruturas de dados mais utilizadas no Python, e se de-fine por uma sequência de variáveis, separadas por vírgula e delimitadas por colchetes. Os itens de uma lista podem ser quaisquer variáveis ou objetos do Python, e uma lista não requer que seus elementos sejam uniformes. Veja o código abaixo:

In [20]:

lista1 = [‘lista’,’de’,’strings’]

lista2 = [3.14, ‘heterogeneidade’, ‘de’, type(lista1),

‘valores’, lista1]

A tupla é uma sequência imutável de objetos, separados por vírgula e delimitados por parênteses. Esta é a principal diferença entre a lista e a tupla: uma vez criada, seus membros não podem mais ser alterados. Veja o código abaixo:


FgV DIREITO RIO 16

In [21]:

tupla1 = (‘lista1’,lista1,’lista2’,lista2)

tupla1[0] = ‘blah!’ # vai dar erro!

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

Typeerror

Traceback (most recent call last) <ipython-input-21-

abd7796095f2> in <module>()

1 tupla1 = (“lista1”,lista1,”lista2”,lista2)

----> 2 tupla1[0] = “blah!” # vai dar erro!

Typeerror: “tuple” object does not support item assignment

O erro indica que um item da tupla não pode ser designado, isto é, após a sua criação, seus itens não podem ser modificados!

...note que colocamos uma lista dentro de uma tupla ..este tipo de com-posição de objetos e estruturas de dados não só é permitido como pode ser muito útil!

indexaçãO (indexing) e recOrte (sLicing)

Vimos que listas e tuplas no Python estruturas de dados que permitem guardar coleções de itens, sejam estes variáveis, literais, objetos, funções e até outras listas e tuplas! Estes itens ficam guardados em ordem, na lista ou tupla, e podemos acessá-los via seu índice, isto é sua posição na lista ou tupla.

Este índice, por convenção dos criadores do Python (e seguindo a tradição de outras linguagens) sempre começa com o ZERO...vejamos:

In [22]:

# aqui, Daniel é o segundo item da tupla

equipeSen = (‘Ivar’, ‘Daniel’, ‘Felipe’, ‘Pedro’,

‘Bianca’, ‘Luan’, ‘Mariana’) # como todas as coleções em

Python começam com índice ZERO, acessamos o SEGUNDO item

com o índice 1

print ‘oi!, meu nome é’, equipeSen[1]

oi!, meu nome é Daniel


FgV DIREITO RIO 17

Note que acessamos os itens contido na lista/tupla usando colchetes após o nome da variável que representa a lista/tupla. É assim que indexamos os valores guardados em listas e tuplas. Vale ressaltar que strings também fun-cionam da mesma forma (podemos pensar neles como listas de caracteres!)

In [23]:

cidade = ‘Rio de Janeiro’ print cidade[7]

J

Se quisermos acessar uma sublista dos valores guardados em uma lista ou tupla, podemos vazer um recorte dela:

In [24]:

lideresSen = equipeSen[0:2] # note que eu defino até o dois

para pegar o índice 1, pois o python é indexado em ZERO

print lideressen

(“Ivar”, “Daniel”)

A indexação pode ser feita da esquerda para a direita, começando do zero, ou da direita para a esquerda, começando do -1. Assim, o último item do objeto iterável (lista, tupla ou string) pode ser acessado pelo seu valor positivo (que podemos pegar com len()) ou pelo número -1 ...vejamos um exemplo:

In [25]:

ultimosen = equipesen[-1]

print ultimosen

penultimosen = equipesen[-2]

print penultimosen

novosSen = equipeSen[-2:]

print novosSen

Mariana

Luan

(“Luan”, “Mariana”)


FgV DIREITO RIO 18

algumas das principais funções de listas são:

In [26]:

“””easter egg: os primeiros 4 que me mandarem um e-mail

explicando corretamente o que estou fazendo na linha abaixo e

porque, ganham um chocolate”””

senList = list(equipesen)

# adiciona um objeto ao final da lista. CUIDADO: se adicionar uma

lista, a própria lista, e não seus membros, será adicionada

SeNList.append(‘Fabio’)

print ‘adicionei mesmo:\n’,SeNList

# extend extrai os MEMBROS de uma coleção, e os adiciona ...note

que é uma TUPLA sendo passada

SeNList.extend((‘Gabriel’, ‘Daniel’))

print ‘\nadicionei os membros da tupla:\n’,SeNList

# podemos concatenar listas

SeNList = SeNList + [‘Fred’,’Livia’]

# podemos repetir seus membros

print ‘\nmultiplicando:’,[‘Oi’,’SeN’] * 3

# remove retira o objeto

SeNList.remove(‘Pedro’)

print ‘\nremovi:\n’,SeNList

# acho a posição de um objeto

aSair = ‘Fabio’

print ‘\nQual a posição do membro ‘+aSair+’?’,SeNList.

index(asair)

# insere o objeto passado na posição x (opcional, default 0)

SeNList.insert(-1,’Pedro’)

# podemos deletar um objeto de dentro da lista

del(senList[senList.index(asair)])

# podemos contar?

print ‘\nquantos Danieis?’, SeNList.count(‘Daniel’)

print ‘\npor fim:’, SeNList


FgV DIREITO RIO 19

adicionei mesmo: [“Ivar”, “Daniel”, “Felipe”, “Pedro”,

“Bianca”, “Luan”, “Mariana”, “Fabio”]

adicionei os membros da tupla: [“Ivar”, “Daniel”,

“Felipe”, “Pedro”, “Bianca”, “Luan”, “Mariana”, “Fabio”,

“gabriel”, “Daniel”]

multiplicando: [“oi”, “sen”, “oi”, “sen”, “oi”, “sen”]

removi: [“Ivar”, “Daniel”, “Felipe”, “Bianca”, “Luan”,

“Mariana”, “Fabio”, “Gabriel”, “Daniel”, “Fred”, “Livia”]

Qual a posição do membro Fabio? 6

quantos Danieis? 2

por fim: [“Ivar”, “Daniel”, “Felipe”, “Bianca”, “Luan”,

“Mariana”, “Gabriel”, “Daniel”, “Fred”, “Pedro”, “Livia”]

cOndiciOnandO a sequência dO prOgrama: iF, eLiF, eLse

Vamos mudar o foco agora de estruturas de dados para o fluxo dos nossos programas.

Até agora, os nossos programas todos seguem uma sequência lógica única, isto é, executamos um comando por vez, um atrás do outro (A), contudo, po-demos usar a estrutura condicional if para que nosso programa possa tomar caminhos alternativos (B) a sintaxe é:

if [[condição a ser avaliada]] : <- note o ‘dois pontos’ [[instruções avaliadas...]]

[[...se a condição for verdadeira...]]

[[...ficam dentro de um novo escopo (com tab)]]

ao terminar, retorna-se ao escopo normal, escrevendo instruções sem tab (ou com um tab a menos!)


FgV DIREITO RIO 20

fig_1.svgVejam o código abaixo:

In [27]:

minhalista = [‘Lucas’, 16, ‘RS’]

if minhalista[1] < 18: # não esqueçam o ‘dois pontos’!

minhalista.append(‘menor de idade’) # notem que uso

a função append() para colocar uma nova informação na

lista print minhalista

[“Lucas”, 16, “rs”, “menor de idade”]

Podemos adicionar mais condicionais, com elif e else.Com elif [[nova condicional]]:, podemos encadear condicionais de for-

ma que se a condicional do primeiro if der falso, a condicional do primeiro elif será avaliada. Se esta der falso também, a segunda será avaliada, e assim por diante. Veja o código abaixo:

In [28]:

genteNaSala = [] # inicio uma lista vazia

if ‘Ivar’ in genteNaSala:

genteNaSala.extend([‘Luan’,’Gabriel’,’Livia’])

elif ‘Daniel’ in genteNaSala:

genteNaSala.extend([‘Mariana’,’Fred’,’Bianca’])

print genteNaSala # como nem o Daniel nem o Ivar estão, a

sala fica vazia!

[]

Aproveite para brincar com os valores iniciais da lista e com as condicio-nais do if e do elif.

O else por sua vez, oferece uma última opção de instruções para o caso que nenhuma das condicionais de true. Seri o caso do senão ...passamos pelo if e quaisquer elifs dizendo “se isso acontecer, ou então se isso acontecer,


FgV DIREITO RIO 21

ou então se isso acontecer” ...com o else, colocamos um senão ao final, caso nenhuma outra condicional seja preenchida. Vamos ver um exemplo:

In [29]:

genteNaSala = [] # inicio uma lista vazia

if ‘Ivar’ in genteNaSala: #

genteNaSala.extend([‘Luan’,’Gabriel’,’Livia’,’Feli

pe’])

elif ‘Daniel’ in genteNaSala:

genteNaSala.extend([‘Mariana’,’Fred’,’Bianca’,’Feli

pe’])

else:

genteNaSala.append(‘Felipe’)

print genteNaSala # o Felipe está SEMPRE na sala.

[“felipe”]

PERGUNTA: Qual a diferença entre usar elif e encadear condições if? Parece dar no mesmo!¶

Boa pergunta! vamos ver qual a diferença...Digamos que eu tenho uma lista dos professores que vão sair para almoçar.

Como cada professor tem o seu apelido favorito para o professor Ivar, vamos reeditar a lista com ifs encadeados e com elifs, para ver qual será o apelido utilizado em um dado almoço para o prof. Ivar.


FgV DIREITO RIO 22

In [30]:

# notem que aqui uso uma lista, não uma tupla, pois vou

alterar os seus valores!

quemAlmoca = [‘Ivar’, ‘Daniel’, ‘Leandro’]

if ‘Daniel’ in quemAlmoca:

quemAlmoca[0] = ‘Ivair’ # note aqui uma mudança para

escopo interno

if ‘Leandro’ in quemAlmoca:

quemAlmoca[0] = ‘Ivan’ # o else também

if ‘Fernando’ in quemAlmoca:

quemAlmoca[0] = ‘Ismar’

print quemAlmoca # qual será o nome do Ivar neste almoço??

[“Ivan”, “Daniel”, “Leandro”]

...se usarmos outra lista, vejam:

In [31]:

quemAlmoca = [‘Ivar’, ‘Daniel’, ‘Leandro’, ‘Fernando’] #

mudei a lista!

if ‘Daniel’ in quemAlmoca:

quemAlmoca[0] = ‘Ivair’

elif ‘Leandro’ in quemAlmoca: # só mudei o if para elif

aqui...

quemAlmoca[0] = ‘Ivan’

elif ‘Fernando’ in quemAlmoca: # ...e aqui

quemAlmoca[0] = ‘Ismar’

print quemAlmoca # qual será o nome do Ivar neste almoço??

[“Ivair”, “Daniel”, “Leandro”, “Fernando”]

Os dois exemplos de código mostram a diferença entre usar elif ao invés de encadear ifs.


FgV DIREITO RIO 23

OperadOres LógicOs: nOt, Or, and

Os operadores lógicos nos permitem encadear avaliações lógicas. Já sa-bemos que True e false são literais essenciais à programação e que podemos modificar o curso do nosso programa com condicionais e avaliações lógicas.

Com operadores lógicos podemos criar avaliações mais complexas, e de maior utilidade.

vejamos:In [32]:

idade = 79 sexo = ‘feminino’

hc = “” # posso fazer...

if (idade > 65 and sexo == “feminino”):

hc = hc + “a senhora, sendo de idade avançada...”

elif(idade > 65 and sexo == “masculino”):

hc = hc + “o senhor, sendo de idade avançada...”

print hc

a senhora, sendo de idade avançada...

a ordem de avaliação de operadores é: not, and, ornot: é usado para inverter a avaliação de uma proposição, se é True o not

o tornará falso.and: retorna True somente se ambos os seus operandos forem verdadeiros.or: retorna True se qualquer um ou ambos os operandos foram verdadei-

ros.No caso do and as proposições são avaliadas da esquerda para a direita,

sendo que a primeira que dê false interrompe a avaliação.O caso do or é similar mas oposto: avalia-se da esquerda para a direita,

sendo que o primeiro True interrompe a avaliação.Podemos brincar um pouco com essas propriedades:

In [33]:

x = 25 y = None #lembrem que é igual a falso!

z = x or y print z

25


FgV DIREITO RIO 24

In [34]:

z = x and y print z

none

In [35]:

l = []

s = “”

n = none

z = l and s and n

print z

z = l or s or n

print z

[] none

Surerimos que vocês usem a funcionalidade do iPython Notebook para explorar as possibilidade de operadores lógicos, partindo dos exemplos acima.


FgV DIREITO RIO 25

Módulo 3 - funções (pte. 1)

Funções são blocos de código reutilizável, organizado de forma a ser reu-tilizado e reduzir a repetição de código.

Uma função pode ser vista como uma unidade de código que executa uma única tarefa.

O Python disponibiliza uma série de funções ao programador (veja as built-in functions aqui), mas podemos também criar as nossas próprias fun-ções, a fim de organizar, e poder reutilizar o nosso código.

Já viemos trabalhando informalmente com funções desde o Módulo 1, porém agora vamos definir mais rigorosamente a sintaxe e funcionamento de uma função:

deFinindO (‘decLarandO’):

Definimos uma função com a palavra reservada def, seguida do nome que queremos dar à função, depois colocamos quaisquer argumentos que queiramos passar à função entre parênteses (ou deixamos eles vazios). Por fim, usamos dois pontos para fechar a linha de definição e abrir o novo escopo (vide seção abaixo, para a definição de ‘escopo’).

In [36]:

def foo(): # def <nome da função> <parênteses vazios ou

com parâmetros> <dois pontos>

# <<instruções aqui>>

# <<instruções aqui>> <- note o novo escopo!

(veja abaixo)

# <<instruções aqui>>

pass # posso usar ‘pass’ como placeholder, vamos

falar sobre o pass já já

usandO (‘chamandO’):

Após declarar uma função, podemos utilizar o seu código simplesmente chamando a função por nome, e passando quaisquer argumentos que lhe sejam necessários:

https://docs.python.org/2/library/functions.html


FgV DIREITO RIO 26

In [37]:

def mostrar_frase(nome, sobrenome, idade):

print ‘Oi, meu nome é’,nome, sobrenome, ‘e

tenho’,idade,’anos’

mostrar_frase(‘Daniel’,’Chada’,’34’)

mostrar_frase(‘Ivar’,’Hartmann’,’28’)

mostrar_frase(‘Felipe’,’Silva’,’25’)

Oi, meu nome é Daniel Chada e tenho 34 anos

Oi, meu nome é Ivar Hartmann e tenho 28 anos

Oi, meu nome é Felipe Silva e tenho 25 anos

Aqui passamos os argumentos ‘nome’ e ‘idade’ a cada vez que chamamos a função mostrar_frase. Como mostrar_frase foi definida para receber dois parâmetros, que dentro dela são chamados pelos nomes nome e idade se a chamarmos sem passar os argumentos necessários, receberemos um erro!

In [38]:

mostrar_frase(‘Mari’) # uh oh! falta argumento!

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

Typeerror


a5ee942457ef> in <module>()

----> 1 mostrar_frase(“Mari”) # uh oh! falta argumento!

Typeerror: mostrar_frase() takes exactly 3 arguments (1 given)

Além de passarmos os argumentos definidos utilizando a ordem (no caso de mostrar_frase ‘nome’ em primeiro, depois ‘idade’) também podemos pas-sar argumentos ‘dando nome aos bois’. Isso se chamar usar keyword arguments ...vejamos


FgV DIREITO RIO 27

In [39]:

mostrar_frase(idade=’25’,nome=’Mari’, sobrenome=’Bedran’)

Oi, meu nome é Mari Bedran e tenho 25 anos

Mas cuidado, uma vez que começamos a nomear, não podemos voltar a utilizar a ordenação (até porque o Python não saberia poe onde recomeçar).

In [40]:

mostrar_frase(idade=’25’, ‘Mari’, ‘Bedran’) # po Mari,

para de quebrar o Python!

file “<ipython-input-40-164c6b628553>”, line 1

mostrar_frase(idade=”25”, “Mari”, “Bedran”) # po Mari,

para de quebrar o Python!

syntaxerror: non-keyword arg after keyword arg

O que é ‘escoPo’?

Vimos anteriormente que variáveis são somente nomes dados a objetos, isto é, tags que damos a objetos e referenciam os objetos para nós. Porém, nem toda referência que fazemos fica válida por todo o decorrer do nosso programa.

Uma definição intuitiva de escopo é a parte, ou subseção do nosso progra-ma em que certas junções nome-->objeto se mantém válidas.

Variáveis declaradas dentro de um determinado escopo em geral não se mantém válidas uma vez que o processamento daquele escopo termina.

O Python tem regras muito bem definidas de escopo, que são fáceis de lembrar via o mnemonico: LEGB:* Local, Enclosing, Global, Built-in*.

-Local: nomes de variável definidos dentro da função na qual estamos trabalhando

-Enclosing: nomes de variável definidos na função que cerca o atual esco-po local (no caso de aninhamento de funções, ou funções lambda que veremos

-Global: o escopo global do arquivo .py em que estamos trabalhando-Built-in: nativas ao Python, acessíveis de qualquer programa Python


FgV DIREITO RIO 28

In [41]:

# CUIDADO COM O ESCOPO LOCAL!

var = ‘foo’

def ex1():

var = ‘bar’

print ‘dentro temos’, var

ex1()

print ‘fora temos’, var

dentro temos bar

fora temos foo

Este blog post: http://www.saltycrane.com/blog/2008/01/python-varia-ble-scope-notes/ contém um ótimo tutorial sobre escopo no Python.

reVendO OperadOres

Agora que já conhecemos o suficiente sobre funções, podemos revelar a verdade! (TAM TAM TAAAAAM!)

Os operadores no Python são o que chamamos de “açúcar sintático” (syn-tactic sugar) ...eles são atalhos: formas mais rápidas e fáceis de digitar coisas que na realidade, têm outro nome.

o operador ‘+’ para números, na realidade pega o objeto referenciado pelo primeiro número e chama a sue função interna __add__(), passando o segun-do número

Já o operador ‘*’ chama a função __mul__()....veja:

In [42]:

x = 3

y = x.__add__(4)

z = y.__mul__(x)

print x, y

print z

3 7 21

http://www.saltycrane.com/blog/2008/01/python-variable-scope-notes/

http://www.saltycrane.com/blog/2008/01/python-variable-scope-notes/


FgV DIREITO RIO 29

Listas, tuplas e strings, ao usar operadores, também usam syntactic sugar:

In [43]:

l = [‘syntactic’,’sugar’]

print l.__getitem__(1)

print l.__getitem__(1) == l[1]

l.__setitem__(0,’salt’)

print l

sugar

True

[“salt”, “sugar”]

Podemos dizer que quase tudo no Python se reverte a executar alguma função.

a paLaVra reserVada pass

A palavra reservada pass no Python é uma operação nula (como mul-tiplicar por 1). Ela é útil como preenchimento quando algum comando é necessário sintaticamente mas não temos código para executar naquele lugar.

In [44]:

def foo():

pass # não dá erro como daria se só continuassemos o

código

print ‘123’

123


FgV DIREITO RIO 30

mudandO VariáVeis dentrO de um escOpO --- PaSS by Value, PaSS by RefeRence, ** PaSS-by-object RefeRence **

Para literais, Python usa pass-by-value , enquanto para estruturas de da-dos, pass-by-reference ...vejamos as diferenç

Em pass-by-value, passamos o valor, isto é, o lugar onde o objeto está guardado. Em pass-by-reference passamos, como o nome implica, a referên-cia, isto é, o ponteiro que aonte para onde o objeto está.

A diferença deve ficar mais clara nos exemplos abaixo

In [45]:

# pass-by-value

def ex1(nome_interno):

print ‘primeiro dentro temos’,nome_interno

var = ‘bar’

print ‘depois temos’, nome_interno

var = ‘foo’

ex1(var)

print ‘fora temos’, var

primeiro dentro temos foo

depois temos foo

fora temos foo


FgV DIREITO RIO 31

In [46]:

# exemplo de pass-by-reference

def ex2(aqui_dentro_chamo_disso):

print ‘aqui temos’,aqui_dentro_chamo_disso

aqui_dentro_chamo_disso[1] = ‘ih, mudou?’

print ‘depois temos’, aqui_dentro_chamo_disso

var = [‘foo’,’bar’]

ex2(var)

print ‘e aqui fora’,var

aqui temos [“foo”, “bar”]

depois temos [“foo”, “ih, mudou?”]

e aqui fora [“foo”, “ih, mudou?”]

Este comportamento do Python, na literatura, o define como nem pass--by-value nem pass-by-reference ..mas omo *pass-by-object-reference. No fundo não importa muito o que se chama, desde que os conceitos estejam sólidamente compreendidos.

Este link pode ajudar, e este também

retOrnandO VaLOres (Ou nãO)

A palavra-chave return imediatamente finaliza a execução de código den-tro de qualquer função e efetua a saída do escopo vigente.

Isto é, o return termina e retorna ao escopo externo (de onde se chamou a função) o valor que o sucede. Um return sem nada em sua frente implica em retornar none.

por default a finalização de qualquer função, sem o uso da palavra-chave return tem o mesmo efeito que return none

vejamos exemplos:

http://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-as-explained-by-philip-k-dick/

http://www.tutorialspoint.com/python/python_functions.htm


FgV DIREITO RIO 32

In [47]:

def eh_string(input):

if isinstance(input, str):

# caso seja uma string, não preciso continuar com

a função

return True

elif input:

print ‘\t...not empty, not False, not None, but

not a string!’

return false

elif input is none:

print ‘\t...recebi um None.’

return false

print ‘\t...recebi algo, mas conta como falso.’

return false

x = eh_string(None)

y = eh_string(“oi!”)

z = eh_string(21234)

w = eh_string(())

# veremos mais sobre o que é False e o que é True em

breve!

print x,y,z,w

...recebi um none.

...not empty, not False, not None, but not a string!

...recebi algo, mas conta como falso. false True

false false

Veja que a execução pára quando se chega a um return.vejamos outro exemplo:


FgV DIREITO RIO 33

In [48]:

def find_x(input):

for item in input:

if item == ‘x’:

return True

print ‘cheguei ao fim e nada...nada de xiiiiiis!!!’

return false

print find_x([123,’Daniel’,’x’,’Ivar’])

print ‘\nsegunda tentativa:’

print find_x([123,’Daniel’,’y’,’Ivar’])

True

segunda tentativa:

cheguei ao fim e nada...nada de xiiiiiis!!!

false


FgV DIREITO RIO 34

Módulo 4 - Iteração coM for, range(); a “sua aMIga a Internet”

O LOOp FOr:

O loop for nos permite iterar uma série de comandos e funções, sem pre-cisar repeti-los seguidamente. Isto é uma ferramenta tremendamente útil em qualquer tarefa repetitiva, especialmente em tarefas que não sabemos quantas vezes teremos que repetir um dado grupo de comandos.

O loop for introduz uma nova possibilidade no caminho do nosso pro-grama, em que voltamos e repetimos um dado conjunto de comandos. Veja a fig_2.

A sintaxe de um loop for é:for [[nome de uma ou mais variáveis que serão iteradas]] in [[coleção

iterável]]:

[[instruções em um novo escopo interno aqui]]



[[instruções sem tab indicam a volta saída do escopo do for]]

Vejamos na prática:

In [49]:

equipeSen = (‘Ivar’, ‘Daniel’, ‘Felipe’, ‘Pedro’,

‘Mariana’, ‘Bianca’, ‘Luan’, ‘Gabriel’, ‘Livia’)

for y in equipesen:

print ‘oi, ‘+ y

oi, Ivar

oi, Daniel

oi, felipe

oi, pedro

oi, Mariana

oi, bianca

oi, Luan

oi, gabriel

oi, Livia


FgV DIREITO RIO 35

usandO range()

a função range() é uma função built-in do Python (como a len(), locals() ou str()) que retorna uma lista de numeros, em sequência:

In [50]:

print range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A função range() pode ser usada para listar números de um certo x a um certo y, ou até pular certos intervalos:

In [51]:

print range(3,15) # a função range cria uma lista de 3 a

14 e a retorna como entrada da função print.

print range(3,15,3) # ‘imprima do 2 ao 15 (parando um

antes), com intervalo de 3’

[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

[3, 6, 9, 12]

O principal uso da função range() é em conjunto à iteração com um loop for (e a função len())


FgV DIREITO RIO 36

In [52]:

SeNDev = [‘Daniel’, “Felipe”, “Mariana”]

SeNJur = [‘Ivar’, ‘Livia’, ‘Gabriel’, ‘Bianca’, ‘Luan’]

def digaoi(x):

# posso usar o range() em conjunto com len() se não

sei o tamanho

for i in range(len(x)):

# note que o for tem seu próprio escopo!

print ‘oi, ‘ + x[i] +”!”,

# para que serve este print? tente comentá’-lo!

print ‘’

digaOi(SeNDev)

digaOi(SeNJur)

oi, Daniel! oi, Felipe! oi, Mariana! oi, Ivar! oi,

Livia! oi, Gabriel! oi, Bianca! oi, Luan!

sua amiga a internet” Ou “OLhe nO stack OVerFLOw antes!”

Python é uma linguagem muito rica, com uma extensa comunidade de de-senvolvedores do mundo todo que contribuem para o seu desenvolvimento. Enquanto alguns contribuem para o desenvolvimento do core da linguagem, outros contribuem escrevendo módulos e disponibilizando-os gratuitamente na internet.

Assim, existe uma enorme quantidade de ferramentas prontas em python, na forma de módulos que podem ser baixados e instalados no seu python local.

Quase nenhum projeto no Python precisa ser iniciado do zero. Com um pouco de pesquisa na internet, vocês provavelmetne encontrarão algum mó-dulo ou pedaço de código que já resolve alguma parte do problema que você tem a reselver.

Recomendamos que vocês utilizem o site http://stackoverflow.com e leiam a documentação oficial da linguagem python http://bit.ly/Pe9lfA.

O Stack Overflow é um repositório de dúvidas e respostas sobre todas as linguagens e áreas da programação (não só Python!), mas tudo é identificado via tags, e todos os membros (tanto os que perguntam quanto os que respon-

http://stackoverflow.com

http://bit.ly/Pe9lfA


FgV DIREITO RIO 37

dem) prezam pela clareza e legibilidade, fazendo do site uma ótima primeira instância para pesquisa sobre qualquer dúvida.

O site oficial do Python http://python.org e a documentação do Python http://python.org/doc são as referências oficiais sobre o core da linguagem.

Finalmente, na data de escrita desta apostila - v1.0 (Set/2014) o site Tu-torials Point http://www.tutorialspoint.com/python/ oferece bons e rápidos tutoriais sobre diferentes aspectos do Python.

http://python.org

http://python.org/doc

http://www.tutorialspoint.com/python/


FgV DIREITO RIO 38

Módulo 5 - IMportação de Módulos, aBrIndo e ManIpulando arquIVos, dIcIonárIos

Neste módulo vamos ver as duas últimas estruturas de dados do conjunto fundamental provido pelo python. Nós vimos números, strings, listas e tu-plas ...hoje veremos arquivos e dicionários.

Veremos também como importar módulos, para utilizar código criado por outros dentro de nossos programas

arquiVOs - abrindO, e manipuLandO, de dentrO e de FOra

Arquivos são outra estrutura de dados importantíssima para o programa-dor Python. Tudo que se manipula como usuário de computador toma a forma de um arquivo: imagens, PDFs, planilhas e até outros programas. De fato, todos os dados que ficam guardados em um computador de forma per-manente (isto é, no disco e não na memória) tomam a forma de arquivos. Até os próprios sistemas operacionais (Windows, Linux, OSX, etc) são coleções de arquivos que ficam guardados no disco rígido (hard disk, HD) são carre-gados quando ocomputador se inicia.

O Acesso e manipulação de arquivos permitem ao nossos programas in-teragir com bases de dados, imagens e outros até programas no computador. Em Python abrimos arquivos com a chamada open que retorna um objeto arquivo.

meu_arq = open([[nome do arquivo]], [[modo]])

Outro modo de abertura de arquivo (ntem que inicializa um novo esco-po!) é:

with open([[nome do arquivo]], [[modo]]) as meu_arq: [[expressões em

novo escopo]][[expressões em novo escopo]] [[expressões em novo escopo]]

O parâmero modo lida com o que será feito com o arquivo, a tabela 5.1 lista os principais parâmetros que podem ser passados. Se nada for passado, o arquivo é aberto para leitura, isto é, o default é ‘r’:


FgV DIREITO RIO 39

modes description

r Opens a file for reading only. The file pointer is placed at the beginning of the file. This is the default mode.

rb Opens a file for reading only in binary format. The file pointer is placed at the beginning of the file. This is the default mode.

r+ Opens a file for both reading and writing. The file pointer will be at the beginning of the file.

rb+ Opens a file for both reading and writing in binary format. The file pointer will be at the begin-ning of the file.

w Opens a file for writing only. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing.

wb Opens a file for writing only in binary format. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing.

w+ Opens a file for both writing and reading. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing.

wb+ Opens a file for both writing and reading in binary format. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing.

a Opens a file for appending. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.

ab Opens a file for appending in binary format. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.

a+ Opens a file for both appending and reading. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for rea-ding and writing.

ab+ Opens a file for both appending and reading in binary format. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing.

fonte: http://www.tutorialspoint.com/python/python_files_io.htm

In [53]:

f = open(‘arq.csv’,’r+’) # neste exemplo, o arquivo deve

estar na mesma pasta do programa sendo rodado

# a função ‘open’ retorna um objeto tipo arquivo

print f

print type(f)

http://www.tutorialspoint.com/python/python_files_io.htm


FgV DIREITO RIO 40

<open file “arq.csv”, mode “r+” at 0x103e67930>

<type “file”>

Uma vez ‘abertos’, podemos usar as funções dos objetos arquivo para ma-nipular o conteúdo dos arquivos, os exemplos abaixo mostram as principais funções para manipular o conteúdo de arquivos:

In [54]:

f = open(‘arq.csv’,’r’)

# read() le e retorna o conteudo inteiro do arquivo ..se

o arquivo for maior que a memória utilizável, corta a

leitura

# podemos também passar um número, que será o número de

bytes a serem lidos do arquivo.

x = f.read()

print x

f.close()

Ivar,28,Harvard

Daniel,34,PUC

felipe,24,fgV

In [55]:

f = open(‘novoarq.csv’,’w+’)

x = ‘Mariana,25,UFF’

# write() (sobre)escreve o conteudo da variável passada

para o arquivo. Não retorna nada.

nada = f.write(x)

print nada

f.close()

none


FgV DIREITO RIO 41

Quando um arquivo é aberto para leiura, o Python aponta um ‘pointeiro de arquivo’ (eu chamo de ‘cursor’) para o conteúdo do arquivo. À medida que lemos ou editamos o conteúdo do arquivo, este ‘cursor’ é movido para a frente (ou para trás). Cada função de leitura ou escrita move o ‘cursor’ para frente, de forma que uma leitura (ou escrita) subsequente retornará outro resultado.

Dependendo do modo utilizado ao abrir o arquivo, podemos já abri-lo com o cursor apontando para o final (modo ‘a’)

Outras funções de escrita e leitura de arquivo são:readline() – retorna uma linha do arquivo, e passa o cursor para a próxi-

ma linhareadlines() – devolve lista em que cada item é uma linhawritelines() – recebe uma lista ou tupla ou iterável e cada item será inse-

rido como se chamando writeline()f.tell() – retorna em que parte do arquivo o cursor parouf.seek(from, offset) – muda o cursor do from (0 pega do começo do arqui-

vo, 1 usa a posição atual e 2 usa o final do arquivo como referência ..o default é 0) e avança tantos bytes quanto indicado no offset

Encorajamos o leitor a explorar a manipulação dos dados de arquivos com estas funções, e buscar mais aprofundadamente sobre seu funcionamento na seção sobre arquivos da python.org

diciOnáriOs

Dicionários trazem uma nova forma de guardar coleções de dados/obje-tos. Listas e tuplas nos dão uma forma ordinal de guardar dados, e podemos acessálos pela sua posição na ordem (i.e. nomes[3] retorna o segundo item da lista nomes). Já dicionários indexam seus valores de outra forma: por chaves. Ao invés de utilizar ordem, o dicionário usa uma função chamad função hash para decidir onde melhor colocar cada novo item que é adicionado. Isso tor-na o seu tempo de resposta muito mais rápido ao localizar um valor associado a uma chave.

Há algumas restrições no que é passível de ser uma chave (quem quiser estudar mais as premissas, pode ler em https://wiki.python.org/moin/Dic-tionaryKeys) mas aqui explicitamos que números, tuplas e strings podem ser chaves, enquanto listas não podem.

Note que isso não implica o que pode ser guardado como valor, qualquer variável ou objeto pode ser guardado em um dicionário, até funções inteiras e módulos ...somente a chave tem restrições.

Definimos dicionários com: {} e acessamos seus itens da mesma forma que listas:

https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files

https://wiki.python.org/moin/DictionaryKeys

https://wiki.python.org/moin/DictionaryKeys


FgV DIREITO RIO 42

In [56]:

x = { ‘Ivar’ : [27,’Nova Hamburgo’, ‘Inter’], ‘Daniel’ :

[34, ‘Rio de Janeiro’, ‘Flamengo’] }

# podemos adicionar valores aos dicionários, eles são

*mutáveis*

x[‘Felipe’] = [24, ‘Matrix’, ‘C’]

print x[‘Felipe’]

print x[‘Ivan’] # notem que dá erro, o Python nos diz que

não existe a chave ‘Ivan’

[24, “Matrix”, “C”]

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

Keyerror


bc4cee0fac11> in <module>()

9 print x[“felipe”]

10

---> 11 print x[“Ivan”] # notem que dá erro, o Python

nos diz que não existe a chave “Ivan”

12 Keyerror: “Ivan”

Como em todas as estruturas que guardam múltiplos dados, podemos guardar outros dicionários dentro de dicionários:


FgV DIREITO RIO 43

In [57]:

x = { ‘Ivar’ : {‘idade’:28,’cidade’:’Nova Hamburgo’,

‘time’:’Inter’, ‘lingua’:’Legagese’}

, ‘Daniel’ : {‘idade’:float(‘Inf’), ‘cidade’:’Barad Dur’,

‘lingua’:’Black Speech’, ‘time’:’Mordor’}

, ‘Felipe’ : {‘cidade’:’Xion’, ‘time’:’Morpheus’,

‘idade’:float(‘NaN’) , ‘lingua’:’CUDA’} }

print x[‘Felipe’][‘time’]

print x[‘Daniel’][‘idade’] # professores malvados são

eternos!

# PS: quem consegue explicar a minha idade e a do Felipe??

Morpheus

inf

Dicionários têm funções muito úteis, a saber:

In [58]:

# a função get() evita que o erro anterior aconteça,

retornando None quando a chave não é encontrada

print x.get(‘Ivar’)

# para obter todas as chaves do dicionário, usamos keys(),

que retorna uma lista

print ‘\nKEYS:\t’,x.keys()

# para obter os valores, a função values(), que retorna

uma lista

print ‘\nVALUES:\t’,x.values()

# já a função items() retorna uma lista de tuplas na forma

(chave,valor)

print ‘\nITEMS:\t’,x.items()


FgV DIREITO RIO 44

{“idade”: 28, “cidade”: “Nova Hamburgo”, “lingua”:

“Legagese”, “time”: “Inter”}

KEYS: [“Felipe”, “Daniel”, “Ivar”]

VALUES: [{“idade”: nan, “cidade”: “Xion”, “lingua”:

“CUDA”, “time”: “Morpheus”}, {“idade”: inf, “cidade”:

“Barad Dur”, “lingua”: “Black Speech”, “time”: “Mordor”},

{“idade”: 28, “cidade”: “Nova Hamburgo”, “lingua”:

“Legagese”, “time”: “Inter”}]

ITEMS: [(“Felipe”, {“idade”: nan, “cidade”: “Xion”,

“lingua”: “CUDA”, “time”: “Morpheus”}), (“Daniel”,

{“idade”: inf, “cidade”: “barad Dur”, “lingua”: “black

Speech”, “time”: “Mordor”}), (“Ivar”, {“idade”: 28,

“cidade”: “Nova Hamburgo”, “lingua”: “Legagese”, “time”:

“Inter”})]

Vale notar que o print das chaves e valores não é nem alfabético, nem em função da ordem da adição dos registros, mas sim de acordo com a função hash mencionada.

Estas listas retornadas pelas funções permitem iterar as chaves, os valores, ou AMBOS com loops. Os dicionários em si, porém, não são iteráveis (uma explicação básica seria que eles não têm ordenação intrínseca, como as listas e as tuplas).

impOrtandO móduLOs

Modulos são a forma de importar código de outros programas seus e de outros para dentro do seu programa. Nós importamos módulos para usar funcionalidades já programados (por nós mesmos ou outros) dentro do nosso código, sem re-escrever.

o jeito de importar módulos é:

In [59]:

import sys # importando o módulo inteiro

from glob import glob # importando uma função específica de

um módulo

from math import * # importando todas as funções do módulo

para o escopo local


FgV DIREITO RIO 45

FAQ: Qual é a diferença entre importar o módulo todo e importar todas as funções com o asterisco?

Ao importar um módulo inteiro usando só o comando import, importa-se o módulo como um objeto, e as funções do módulo ficam acessíveis via este objeto:

In [60]:

# um detalhe: posso renomear o módulo ao importar, para

facilitar a sua chamada!

import os as o

print o.getcwd() # getcwd() foi importada como função do

objeto ‘os’!

from math import sqrt, pi

print sqrt(pi) # note que não preciso usar ‘math<ponto>’!

/Users/cyg/Documents/work/code/atc_2014

1.77245385091

In [61]:

# mas cuidado!

from math import *

# aqui eu redefino a variavel ‘pi’ importada antes do math,

e perco a original!

pi = ‘principal investigação’

print pi

# já aqui, não corro este risco, pois fica como parte do

módulo!

import math

print pi, math.pi

principal investigação

principal investigação 3.14159265359


FgV DIREITO RIO 46

manipuLandO arquiVOs em si, nãO só seu cOnteÚdO (O móduLO Os)

Já vimos como manipular o conteúdo de arquivos, e como trazer código Python externo na forma de módulo para dentro do nosso próprio código. Agora usaremos um módulo do Python para manipular arquivos e diretórios (‘pastas’ para os que falam Windows®)

Import os .mkdir() – make directory .chdir() – change directory .getcwd() – get current working directory .remove() .rename(a,b) .rmdir() – remove directory


FgV DIREITO RIO 47

Módulo 6 - funções (pte. 2); BuIlt-Ins: zIp, Map, reduce, fIlter; usando laMBda; usando *args, **kwargs

Outras Funcões buiLt-in

Vamos agora continuar a ver funções built-in úteis no dia-a-dia da progra-mação Python. Uma lista completa pode ser encontrada aqui.

a função map recebe um objeto função e um objeto iterável (i.e. uma sequ-ência...tupla, lista, string, etc) e aplica a função a cada membro do iterável, um de cada vez, coletando os resultados em uma lista. veja:

In [62]:

equipe = (‘Ivar’,’Felipe’, ‘Daniel’, ‘Mariana’, ‘Fred’,

‘Luan’)

# passo a função len e a minha tupla

tamanhos_de_cada = map(len, equipe)

print tamanhos_de_cada

[4, 6, 6, 7, 4, 4]

A função zip retorna uma lista de tuplas, onde a n-ésima tupla contém os n-ésimos itens de cada iterável passado para ela:

https://docs.python.org/2/library/functions.html


FgV DIREITO RIO 48

In [63]:

idades = [28, float(‘NaN’), float(‘Inf’), 25, 22, 22]

# passo dois iteráveis

agrupados = zip(equipe,idades)

print ‘agrupados:\t’, agrupados

abc = ‘abcdefghijklmnopqrstuvwxyz’

# agora um terceiro, note o que acontece quando os

tamanhos são

# diferentes e quando os itens JÁ SÃO iteráveis em si

agrup = zip(agrupados, abc)

print ‘\nnovo agrup:\t’,agrup

# posso DESAGRUPAR com o ‘*’:

desagrup = zip(*agrupados)

print ‘\ndesagrup:\t’,desagrup

# assim...

final = zip(zip(*agrupados)[0],zip(*agrupados)[1],abc)

print ‘\nfinal:\t’,final # qual a diferença entre ‘final’ e

‘novo agrup’??

agrupados: [(“Ivar”, 28), (“Felipe”, nan), (“Daniel”,

inf), (“Mariana”, 25), (“Fred”, 22), (“Luan”, 22)]

novo agrup: [((“Ivar”, 28), “a”), ((“Felipe”, nan),

“b”), ((“Daniel”, inf), “c”), ((“Mariana”, 25), “d”),

((“fred”, 22), “e”), ((“Luan”, 22), “f”)]

desagrup: [(“Ivar”, “Felipe”, “Daniel”, “Mariana”,

“fred”, “Luan”), (28, nan, inf, 25, 22, 22)]

final: [(“Ivar”, 28, “a”), (“Felipe”, nan, “b”),

(“Daniel”, inf, “c”), (“Mariana”, 25, “d”), (“Fred”, 22,

“e”), (“Luan”, 22, “f”)]

reduce aplica uma função que recebe dois valores e retorna um a um iterável, cada vez pegando o resultado da iteração anterior omo primeiro parâmetro:


FgV DIREITO RIO 49

In [64]:

def add(x,y):

return x+y

print reduce(add, [2,4,6,8])

20

filter recebe uma função que retorna True ou false e um iterável. Constrói uma lista com os membros do iterável para os quais a função responde True

In [65]:

CUT_OFF = 5 def maior(x): return x >= CUT_OFF y

= filter(maior,tamanhos_de_cada) print y def maior_

que(x): return x[0] >= CUT_OFF # agora posso fazer

algo mais desafiador... o que estou fazendo aqui?? print

zip(*filter(maior_que, zip(tamanhos_de_cada, equipe)))

[1] #seja um dos 5 primeiros e um email explicando com o

subject [explicação do filter]

[6, 6, 7] (“Felipe”, “Daniel”, “Mariana”)

VaLOres defAulT em Funções

O Python permite que argumentos de funções tenham valores default, de forma que, se nada for passado naquele parametro, a função provê um valor pre-definido ao invés de dar erro.

Em código:

In [66]:

def meu_time(nome, time=’Mordor’): return nome + ‘

torce por ‘ + time print meu_time(‘Ivar’,’Inter’) # na

ausência do valor, vai o default print meu_time(‘Daniel’)

Ivar torce por Inter Daniel torce por Mordor


FgV DIREITO RIO 50

Cuidado que passar none ainda é passar alguma coisa:

In [67]:

print meu_time(‘Felipe’, None) # uh oh!

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

Typeerror

Traceback (most recent call last)

<ipython-input-67-387ca642fad3> in <module>()

----> 1 print meu_time(“felipe”, none) # uh oh!

<ipython-input-66-c198612e6fc7> in meu_time(nome, time)

1 def meu_time(nome, time=”Mordor”):

----> 2 return nome + “ torce por “ + time

3

4 print meu_time(“Ivar”,”Inter”)

5 # na ausência do valor, vai o default

Typeerror: cannot concatenate “str” and “noneType” objects

IMPORTANTE: É um erro comum utilizar um objeto mutável como valor default. Lembra, de pass-by-value, pass-by-reference?

Vejamos um exemplo:

In [68]:

def bad_append(new_item, a_list=[]):

a_list.append(new_item)

return a_list

print bad_append(‘one’)

print bad_append(‘two’)

[“one”]

[“one”, “two”]


FgV DIREITO RIO 51

Uh oh! Por que que o ‘one’ ainda está lá?!O problema é que o valor default, isto é, a lista vazia, é definida na decla-

ração da função, e para sempre aponta para o mesmo objeto default, ou seja, o mesmo lugar na memória ...que é modificado!

A forma correta de se criar uma lista (ou dicionário, ou qualquer objeto mutável) default é criá-lo durante a execução ...dentro de função.

In [69]:

def good_append(new_item, a_list=none):

if a_list is none:

a_list = []

a_list.append(new_item)

return a_list

print good_append(‘one’)

print good_append(‘two’)

[“one”]

[“two”]

Funções anônimas cOm lambda

Há casos em que podemos querer aplicar uma expressão a uma coleção de objetos. Ou usar uma função simples apenas uma vez. Para estes casos, existe o operador lambda.

Podemos usar o operador lambda para criar funções pequenas anônimas. Estas funções são chamadas anônimas pois não precisam de um def e um nome de chamada, isto é, não precisam ser declaradas na forma padrão.

Expressões lambda podem aceitar qualquer quntidade de argumentos (como funções) mas devem conter apenas uma única expressão. Elas não podem aceitar statements ou múltiplas expressões.

Aqui se torna importante que uma chamada print não se qualifica como uma expressão, e sim um statement mais abrangente; logo, chamadas print não são permitidas dentro de lambda.

An anonymous function cannot be a direct call to print because lambda requires an expression.

funções lambda têm seus próprios escopos internos, mas conseguem aces-sar variáveis da função ou escopo que a chama.


FgV DIREITO RIO 52

Vamos ver um exemplo:

In [70]:

li = [‘Ivar’,’Daniel’,’Felipe’]

# ao invés de definir uma função só para chamar dentro

# do meu map ou fazer um for loop, uso uma função anônima

quad = map(lambda inp: inp + ‘ ama Python’, li)

quad

out[70]:

[“Ivar ama Python”, “Daniel ama Python”, “Felipe ama

Python”]

IMPORTANTE: É necessário tomar cuidado ao usar lambda e def dentro de loops for.

Este cuidado é necessário pois, se a função aninhada referencia algum valor que é modificado pelo loop, a regra de escopo dita que este será modifi-cado e os ponteiros (isto é, as variáveis) criados acabarão por apontar ao valor final do loop.

Vejamos:

In [71]:

def make():

items = []

for i in [‘Ivar’,’Daniel’,’Felipe’,’Mari’]:

# cada item é um FUNÇÃO criada com lambda

items.append(lambda x: i + x)

return items

# populei uma lista onde cada item é uma ***FUNÇÃO***

functions = make() # note...

functions[0] # mas agora ao chamar as funções...


FgV DIREITO RIO 53

out[71]:

<function __main__.<lambda>>

In [72]:

# esta deve me dar ‘Ivar ama python’ functions[0](‘ ama

Python’)

out[72]:

“Mari ama Python”

In [73]:

# esta deve me dar ‘Daniel ama C’

functions[1](‘ ama C’)

out[73]:

“Mari ama C”

In [74]:

# esta deve me dar

‘Felipe ama LISP’ functions[2](‘ ama LISP’)

out[74]:

“Mari ama LISP”

Mas todas só se lembram do último i que foi criado no for, pois este fica no escopo externo e foi modificado lá.

Para reslver este problema, podemos usar um valor default, como vimos acima:


FgV DIREITO RIO 54

In [75]:

def make():

items = []

for i in [‘Ivar’,’Daniel’,’Felipe’,’Mari’]:

# cada item é um FUNÇÃO criada com lambda

#

# só que agora i é passado para dentro do

# lambda como valor default, e existe lá dentro!!

items.append(lambda x, i=i: i + x)

return items

# populei uma lista onde cada item é uma ***FUNÇÃO***

functions = make()

# agora ao chamar as funções...

functions[0](‘ ama Python’), functions[1](‘ ama C’),

functions[2](‘ ama LISP’)

out[75]:

(“Ivar ama Python”, “Daniel ama C”, “Felipe ama LISP”)

FAQ: Mas se lambda só aceita uma expressão, qual a diferença entre ‘expression’ e ‘statement’?

Volte e leia a parte sobre expressões e statements

parâmetrOs VariáVeis cOm *args, **kwargs

O Python nos permite a flexibilidade de montar funções que não precisam saber o números de argumentos que lhes serão passadas. Para isso usamos os operadores ‘*’ e ‘**’ ao declarar a função.

O operador ‘*’ faz com que a variável que o segue (quase sempre chamada ‘args’ pela comunidade Python) seja interpretada como uma tupla contendo todos os argumentos da função passados dali em diante. Veja:


FgV DIREITO RIO 55

In [76]:

def foo(primeiroarg, *args):

print ‘eis o primeiro:’,primeiroarg,’\n’

# todos os outros args são empacotados em uma tupla

por cause do ‘*’!

for i in args:

# EASTER-EGG: quem me explica a vírgula aqui?

# os primeiros 5 a mandar um email para daniel.

chada<arroba>fgv<ponto>br

# explicando (corretamente) ganham chocolate!

print i,

# note que estou passando 6 argumentos, mas a função

só recebe dois!

# ...não dá erro??

foo(3, ‘Daniel’,’é’, 10, ‘ou’, 3.14)

eis o primeiro: 3

Daniel é 10 ou 3.14

Já o operador ‘**’ acolhe todos os valores nomeados, isto é, que recebem nome na chamada (não na declaração) em um dicionário (sempre nomeado ‘kwargs’ pela comunidade Python), com as chaves sendo os nomes das variá-veis, e os valores seus valores.

veja:

In [77]:

def bar(primeiroarg, **kwargs):

print ‘eis o primeiro:’,primeiroarg,’\n’

for key,val in kwargs.items():

print ‘a chave:’,key,’...tem valor:’,val

bar(‘1o’, trabalho=’diversão’, python=’legal’,

Daniel=’melhor professor DO MUNDO!’, Ivar=’Ivan’)


FgV DIREITO RIO 56

eis o primeiro: 1o

a chave: python ...tem valor: legal

a chave: Ivar ...tem valor: Ivan

a chave: trabalho ...tem valor: diversão

a chave: Daniel ...tem valor: melhor professor DO MUNDO!

O site http://freepythontips.wordpress.com/2013/08/04/args-and-kwar-gs-in-python-explained/ contém uma boa explicação sobre o assunto.

http://freepythontips.wordpress.com/2013/08/04/args-and-kwargs-in-python-explained/

http://freepythontips.wordpress.com/2013/08/04/args-and-kwargs-in-python-explained/


FgV DIREITO RIO 57

Módulo 7 - strIngs aVançados

Neste módulo veremos um pouco mais sobre strings, e as diferentes for-mas de interpretá-los.

String é um subtipo de sequência, de fato, uma string é um sequência imutável, tal qual uma tupla.

String não são apenas para guardar e procesar informação em texto. No Python, string podem servir para guardar e processar informação em qual-quer formato binário, até imagens e outras mídias. Isso os torna fortemente flexíveis, mas um pouco mais difíceis de lidar quando saímos das interpreta-ções triviais (isto é, 8 bits = um caractére).

OBS: para referência, eis todos os tipos Python que são sequências: str, unicode, list, tuple, bytearray, buffer, xrange. Leia mais sobre eles em https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list--tuple-bytearray-buffer-xrange

unicOde strings

Python também nos permite utilizar caracteres fora do ‘básico’ provido pelo código ASCII (veja a lista ASCII completa em http://www.asciitable.com), permitindo quaisquer caracteres do Unicode (cuja espcificação fica em http://www.unicode.org). O site da Unicode explica: “Unicode provides a unique number for every character, no matter what the platform, no matter what the program, no matter what the language”.

O Livro Referência [1], descreve: “non-Unicode strings are sequences of 8-bit bytes that print with ASCII characters when possible, and Unicode strings are sequences of Unicode code points - identifying numbers for characters, which do not necessarily map to single bytes when encoded to files or stored in memory. In fact, the notion of bytes doesn’t apply to Unicode”.

Vejamos um exemplo um pouco mais concreto:

https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange



http://www.asciitable.com

http://www.asciitable.com

http://www.unicode.org


FgV DIREITO RIO 58

In [78]:

# o caractere em Unicode não é automaticamente lido no

Python 2.x

print ‘sp\xc4m’

# se colocarmos o ‘u’ na frente da string, o Python sabe

que deve ler como # Unicode

print u’sp\xc4m’

sp◊m

spÄm

As funções encode() e decode() funcionam para mapear strings para que sejam interpretados de certo jeito.

Vejamos alguns outros exemplos de mapeamento:

In [79]:

’\xc3\xa1’ # um string de um bando de caracteres

out[79]:

“\xc3\xa1”

In [80]:

print ‘\xc3\xa1’ # a função print é esperta e interpreta o

utf-8

>>> print ‘á’

á

á

In [81]:

u’\xe1’ # um unicode sem muito sentido

out[81]:

u”\xe1”


FgV DIREITO RIO 59

In [82]:

print u’\xe1’ # mas a função print já interpreta diferente

á

In [83]:

u’\xe1’.encode(‘utf-8’) # mapeando

out[83]:

“\xc3\xa1”

In [84]:

print u’\xe1’.encode(‘utf-8’)

á

In [85]:

’\xc3\xa1’.decode(‘utf-8’) # ...e de volta

out[85]:

u”\xe1”

In [86]:

print ‘\xc3\xa1’.decode(‘utf-8’)

á

Para quem quiser ler um pouco mais sobre a função print, busque aqui: https://docs.python.org/2/library/functions.html#print

https://docs.python.org/2/library/functions.html#print


FgV DIREITO RIO 60

In [87]:

s = ‘ö’

>>> s.decode(‘utf-8’) # estou usando o ‘>>>’ para emular o

terminal python que imprime as operações sem usar o print

out[87]:

u”\xf6”

In [88]:

>>> ‘spam’.encode(‘utf-16’) # mapeie para utf-16 (16 bytes

por caractere)

out[88]:

“\xff\xfes\x00p\x00a\x00m\x00”

In [89]:

>>> print ‘sp\xc4m’ # uh oh, estou tentando considerar

como string normal

sp◊m

In [90]:

>>> print u’sp\xc4m’ # considere como um unicode

spÄm

In [91]:

>>> u’sp\xc4\u00c4\U000000c4m’ # unicode hexadecimal,

unicode ‘curto’ (16) e unicode ‘longo’ (32)

out[91]:

u”sp\xc4\xc4\xc4m”


FgV DIREITO RIO 61

In [92]:

>>> print u’sp\xc4\u00c4\U000000c4m’

spÄÄÄm

Há codecs (mapeamentos) que não tem nada à ver com texto, mas sim com como interpretar uma sequência de bytes (i.e. arquivos zip), veja https://docs.python.org/2/library/codecs.html#python-specific-encodings

Uma lista dos codecs padrão que o Python lida como built-in existe aqui: https://docs.python.org/2/library/codecs.html#standard-encodings

In [93]:

>>> s.encode(‘zip’)

out[93]:

“x\x9c;\xbc\r\x00\x02>\x01z”

FOrmataçãO

Python permite a formatação de strings via a função str.format(). O string sendo formatado (isto é, que chama a sua própria função format() poe conter texto literal (como sempre) ou campos de ‘substituição’, delimitados por chaves {}.

Cada campo de substituição contém ou o índice numérico de um argu-mento posicional ou o nome de um argumento (veja o exemplo).

A função retorna uma cópia da string onde cada campo de substituição é trocado pelo valor string (str()) do argumento correspondente.

Vejamos:

In [94]:

x = ‘O melhor professor de Python é {} e o triste segundo

é {}.’

print x

y = x.format(‘Daniel’,’Ivar’)

print y

https://docs.python.org/2/library/codecs.html#python-specific-encodings

https://docs.python.org/2/library/codecs.html#python-specific-encodings

https://docs.python.org/2/library/codecs.html#standard-encodings


FgV DIREITO RIO 62

O melhor professor de Python é {} e o triste segundo é {}.

O melhor professor de Python é Daniel e o triste segundo

é Ivar.

Vejamos colocando informação, junto ao delimitador:

In [95]:

print ‘O melhor professor de Python é {1}\ e o triste

segundo é {0}.’.format(‘Daniel’, ‘Ivar’)

O melhor professor de Python é Ivar e o triste segundo é

Daniel.

Também aceita-se valores nomeados, vejamos:

In [96]:

at1 = ‘fazer aluno sofrer’

at2 = ‘fazer aluno chorar’

s = “””olá, sou {nome} e tenho {idade} anos! \ Gosto muito

de {ativ1} e {ativ2}!”””

print s.format(nome=’Daniel’

, idade=’34’

, ativ1=at1

, ativ2=at2)

olá, sou Daniel e tenho 34 anos! Gosto muito de fazer

aluno sofrer e fazer aluno chorar!

Também podemos usar híbridos de posicionamento e nomeação (lem-brem da seção sobre *args e **kwargs)


FgV DIREITO RIO 63

In [97]:

s = “olá, sou {0} e tenho {1} ...gosto do {at1} e {at2}!”

at1 = “programar”

at2 = ‘dar zero a alunos’

print s.format(‘Daniel’,’34’, at1=at1, at2=at2)

olá, sou Daniel e tenho 34 ...gosto do programar e dar

zero a alunos!

A documentação do Python contém varios exemplos de formatação ...aqui: (https://docs.python.org/2/library/string.html#format-examples)e aqui: (https://docs.python.org/2/tutorial/inputoutput.html#fancier-

-output-formatting)

muLti-Line strings

String multi-linha são bastante simples no Python: usamos três aspas para defini-los:

In [98]:

>>> x = “””Ei! Eu

sou uma

string multi-linha!”””

>>> x

out[98]:

“Ei! Eu\n\nsou uma\n\nstring multi-linha!”

https://docs.python.org/2/library/string.html#format-examples

https://docs.python.org/2/tutorial/inputoutput.html#fancier-output-formatting

https://docs.python.org/2/tutorial/inputoutput.html#fancier-output-formatting


FgV DIREITO RIO 64

In [99]:

print x

Ei! Eu

sou uma

string multi-linha!

enFim ...O pOrque dO “#coding: utf-8” nO iníciO dOs arquiVOs!

O coding: utf-8 no início dos nossos arquivos .py indica que aquele có-digo python deve ser interpretado como uma série de caracteres utf-8, não ASCII (que não permite acentos, e uma série de outros caracteres).

a definição formal pela comunidade Python descreve: “The encoding in-formation is then used by the Python parser to interpret the file using the given encoding. Most notably this enhances the interpretation of Unicode literals in the source code and makes it possible to write Unicode literals using e.g. UTF-8 directly in an Unicode aware editor”.

Assim, o Python, ao ler nosso arquivo .py, consegue entender caracteres fora do ASCII.

http://legacy.python.org/dev/peps/pep-0263/


FgV DIREITO RIO 65

Módulo 8 - núMeros BInárIos, taBelas Verdade, or, and, xor, nand

A computação como um todo se baseia em números binários. Mas o que queremos dizer quando dizemos ‘binário’, ou ‘base dois’? Sabemos intuiti-vamente que, da mesma forma que a base decimal usa somente zero a nove {0,9}, a base binária se restringe a zeros e uns {0,1}.

Na base decimal, quando chegamos ao final, adicionamos um à próxima casa ‘decimal’ e começamos de novo. Esta próxima casa implica uma outra potência de dez. por exemplo, 243 significa

2 4 3 10^2 10^1 10^0 243 é igual a 2*100 + 4*10 + 3*1

No binário, como só temos o 0 e o 1, fazemos a mesma coisa, mas mui-to mais vezes... ao chegar ao ‘final’ (o 1) adicionamos uma casa ‘binária’ e começamos de novo. Esta próxima casa implica outra potência de dois. Por exemplo 1011 significa:

1 0 1 1 2^3 2^2 2^1 2^0

Assim, 1011 é igual a 1*8 + 0*4 + 1*2 + 1*1 = 8+2+1 = 11

Mais informação e exemplos podem ser encontrados em: https://docs.python.org/2/library/stdtypes.html#truth-value-testing

OperadOres bitwise: nOt, Or, xOr, and, nand

Com binários, podemos utilizar operadores (iguais aos operadores lógicos que já vimos, mas que funcionam bit a bit), chamados bitwise. Vamos en-contrar os mesmos operadores, mas vamos ver alguns outros importantes na computação também.

O ou exclusivo (exclusive or) também chamado xor ...dadas duas proposi-ções A e B, o xor funciona assim:

a b a xor b 0 0 0 0 1 1 1 0 1 1 1 0

https://docs.python.org/2/library/stdtypes.html#truth-value-testing

https://docs.python.org/2/library/stdtypes.html#truth-value-testing


FgV DIREITO RIO 66

O xor é uma operação composta, que pode ser expressa como (a or b) and not(a and b)

O and negado (negated and), também chamado nand ...dadas duas propo-sições A e B, o nand oferece os resultados opostos a um operador and assim:

a b a nand b 0 0 1 0 1 1 1 0 1 1 1 0

In [100]:

a = 0b1011

b = 0b1001

print bin(a | b) # operador ‘or’ bitwise

print bin(a & b) # operador ‘and’ bitwise

0b1011

0b1001


FgV DIREITO RIO 67

Módulo 9 - usando apIs externas

O Python package index é o principal repositório de módulos livremente disponíveis na internet.

no momento da edição desta apostila, o site https://pypi.python.org/pypi descreve: “The Python Package Index is a repository of software for the Python programming language. There are currently 49551 packages here.”

Como baixar e instalar? No Linux e OSX a ferramenta pip do terminal torna trivial a instalação de novos pacotes Python. No Windows, ela também pode ser usada, como descrito aqui.

Muitos módulos disponibilizam instaladores específicos para o Windows, facilitando o processo. Podemos encontrar uma lista extra-oficial de módulos com instaladores para o Windows aqui.

Em certos módulos do Python é necessário construir o módulo a partir do código-fonte original (isso se chama build from source).

https://pypi.python.org/pypi

https://docs.python.org/3.4/installing/index.html

http://www.lfd.uci.edu/~gohlke/pythonlibs/


FgV DIREITO RIO 68

anexo a - recursos onlIne¶

StackOverflow.comPython.orgTutorialspoint.com

http://stackoverflow.com

http://python.org

http://www.tutorialspoint.com/python/index.htm


FgV DIREITO RIO 69

referêncIas¶

[1] Lutz, M.; Learning Python 5th ed.

In [100]:


FgV DIREITO RIO 70

fIcHA tÉcnIcA

fundação Getulio Vargas

carlos Ivan Simonsen lealPReSIDente

fGV DIReItO RIO

Joaquim falcãoDIRetOR

Sérgio GuerraVICE-DIRETOR DE ENSINO, PESQUISA E PÓS-gRADUAçãO

Rodrigo ViannaVICE-DIRETOR ADMINISTRATIVO

thiago Bottino do AmaralCOORDENADOR DA gRADUAçãO

André Pacheco teixeira MendesCOORDENADOR DO NÚCLEO DE PRÁTICA JURÍDICA

cristina nacif AlvesCOORDENADORA DE ENSINO

Marília AraújoCOORDENADORA EXECUTIVA DA gRADUAçãO