mini curso iot - sieng 2016 - dia 1

IoT – Primeiros passos utilizandoPython com embarcados

Vinicius J. Leódido Correia | Engº Voluntário

Engenheiros Sem Fronteiras – Núcleo Rio de Janeiro

Agenda

Dia 1: Introdução, usos mais comuns, estrutura de dados em Python, leitura e

escrita de arquivos

Dia 2: Iniciando os passos básicos nas placas, GPIOs, as bibliotecas MRAA /

UPM, ligações seriais USB/TTL.

Dia 3: Lendo os dados dos sensores, encaminhando os dados para a nuvem,

entendendo e adaptando os dados no script Python para gravação via REST, realizando comunicações via MQTT.

www.sieng.ctc.puc-rio.brwww.sieng.ctc.puc-rio.br

Dia 1 – Introdução e Características

A linguagem foi criada em 1990 por Guido van Rossum, no Instituto Nacional de Pesquisa para Matemática e Ciência da Computação da Holanda (CWI) e tinha originalmente foco em usuários como físicos e engenheiros. O Python foi concebido a partir de outra linguagem existente na época, chamada ABC.



O nome Python foi tirado por Guido van Rossum do programa da TV britânica Monty Python Flying Circus, e existem várias referências ao programa na própria documentação da linguagem, como, por exemplo, o repositório oficial de pacotes do Python se chamava Cheese Shop, que era o nome de um dos quadros do programa.Atualmente, o nome do repositório é Python Package Index11 (PyPI - pypi.python.org).



Linguagem de Alto Nível

Sintaxe Clara e Concisa

Favorece Legibilidade do Cógido Fonte

Favorece o uso de estruturas de alto nível

Diversas bibliotecas prontas para uso

Portabilidade

Multiparadigma, funcional, orientada a objetos

Software Open Source (GPL)

Utilizada também para Scripts e execução de tarefas, comoPerl e Ruby

Frameworks Python para Web (Django é o mais conhecido)



Integração com outras Linguagens

Implementação official pela PSF é escrita em C – Conhecidocomo CPython

Curiosidades: Utilizado para renderização de Vídeos e uso em VFX

LucasFilm’s, Pixar e outras Grandes companhias utilizam motor de renderização em Python



IDE’s: PyCharm (JetBrains)



Execução de comandos no Python:

Obs.: Python opera somente com o código identado!Lembre-se de manter sempre a identação em seu código(padronizado com 4 espaços “ “).



Execução em blocos de códigos



Tipagem Dinâmica – Duck Typing

No momento em que uma variável é criada através de atribuição, o interpretador define um tipo para a variável, com as operações que podem ser aplicadas.

Tipagem Forte o interpretador verifica se as operações são válidas e não faz coerções

automáticas entre tipos incompatíveis. Para realizar a operação entre tipos não compatíveis, é necessário converter explicitamente o tipo da variável ou variáveis antes da operação.


>>> s = 5>>> t = “3”>>> print 'A soma de %d + %s e %d' %(s, t, (s+int(t)))

A soma de 5 + 3 e 8


Controle de Fluxo

A partir da Versão 2.5, deu suporte ao Operador ternário:


print 'a é menor' if a < b else 'a não é menor‘ #Uso de Operador Ternário

>>> if a < b: #Uso padrão do controle de fluxo... print 'a é menor‘... else:... print 'a não é menor'


Laços Estruturas de repetição para controle e processamento de coleções de

dados.



Laços Uso de Laços com FOR


#Soma de 0 a 99s = 0for x in range(1, 100):

s = s + xprint s

4950


Laços Uso de Laços com WHILE


#Soma de 0 a 99s = 0x = 1while x < 100:

s = s + xx = x + 1

print s

4950


Tipos de Dados

Tipos de Dados pré definidos no Python: Números (inteiros, reais, complexos, etc…)

Texto

Tipos de Dados que atuam como Coleções: Lista

Tupla

Dicionário

Tipos de Dados no Python podem ser: Mutáveis – Seu conteúdo pode ser alterado

Imutáveis – Quando seu conteúdo não se altera

Obs.: No Python, nomes de variáveis são referências, que podem seralteradas em tempo de execução!



Tipos de Dados

Números – Funções Padrões de builtins:

Inteiro (int): i=1

Real de Ponto Flutuante (float): f=3.14

Complexo (complex): c = 3 + 4j

Inteiro longo (long) – Python faz gerenciamento automático entre inte long

Com essas funções, podemos realizer conversões para outros tipos:



Conversões Numéricas



Operações Aritméticas

Soma (+).

Diferença (-).

Multiplicação (*).

Divisão (/): entre dois inteiros funciona igual à divisão inteira. Em outros casos, o resultado é real.

Divisão inteira (//): o resultado é truncado para o inteiro imediatamente inferior, mesmo quando aplicado em números reais, porém neste casoo resultado será real também.

Módulo (%): retorna o resto da divisão.

Potência (**): pode ser usada para calcular a raiz, através de expoentes

fracionários (exemplo: 100 ** 0.5).

Positivo (+).

Negativo (-)



Operações Lógicas

Menor (<).

Maior (>).

Menor ou igual (<=).

Maior ou igual (>=).

Igual (==).

Diferente (!=).



Tipos de Dados

Texto:

As strings por si só, já são uma própria função builtin

Strings são imutáveis. Para alterar seu conteúdo, somente criandouma nova String ou adicionando um novo conteúdo

Tipos de Strings String padrão: s = ‘palavras ao vento’

String Unicode: s = u‘São apenas Palavras’

Também podem ser convertidas com a função unicode()

A inicialização de Strings podem ser com aspas simples ou duplas

Em várias linhas, desde que sejam com 3 aspas simples ou duplas



Operações com Strings

# -*- coding: latin1 -*-s = 'Camel‘

# Concatenação print 'The ' + s + ' run away!‘

# Interpolaçãoprint 'tamanho de %s => %d' % (s, len(s))

# String tratada como sequênciafor ch in s:

print ch

# Strings são objetosif s.startswith('C'):

print s.upper()

# o que acontecerá?print 3 * s# 3 * s é consistente com s + s + s



Interpolação de Strings Operador “%” é usado para fazer interpolação de strings. A interpolação

é mais eficiente no uso de memória do que a concatenação convencional.

Símbolos usados na interpolação: %s: string.

%d: inteiro.

%o: octal.

%x: hexacimal.

%f: real.

%e: real exponencial.

%%: sinal de percentagem.



“Fatiando” Strings – Trabalhando com Slices Fatias de Strings podem ser obtidas, simplesmente colocando índices

entre colchetes após a string.

Índices podem ser definidos como: [inicio:fim + 1:intervalo]


Dia 1 – Introdução e Características Listas

Listas são coleções heterogêneas de objetos, que podem ser de qualquer tipo, inclusive outras listas.

As listas são mutáveis e podem ser “fatiadas” como as Strings

# -*- coding: latin1 -*-

# Uma nova lista: Brit Progs dos anos 70progs = ['Yes', 'Genesis', 'Pink Floyd', 'ELP']

# Varrendo a lista inteirafor prog in progs:

print prog

# Trocando o último elementoprogs[-1] = 'King Crimson‘

# Incluindoprogs.append('Camel')

# Removendoprogs.remove('Pink Floyd')



Listas

# Ordena a lista

progs.sort()

# Inverte a lista

progs.reverse()

# Imprime numerado

for i, prog in enumerate(progs):

print i + 1, '=>', prog

# Imprime do segundo item em diante

print progs[1:]



Listas Lista possui método pop(), como opção para uso de filas e pilhas:


lista = ['A', 'B', 'C']

print 'lista:', lista

# A lista vazia é avaliada como falsa

while lista:

# Em filas, o primeiro item é o primeiro a sair

# pop(0) remove e retorna o primeiro item

print 'Saiu', lista.pop(0), ', faltam', len(lista)



Listas# Mais itens na lista

lista += ['D', 'E', 'F']

print 'lista:', lista

while lista:

# Em pilhas, o primeiro item é o último a sair

# pop() remove e retorna o último item

print 'Saiu', lista.pop(), ', faltam', len(lista)

Possuem operações de ordenação (sort) e inversão (reverse) que são realizadas na própria lista, mas seu conteúdo não é alterado nessas operações.



Tuplas São bastante similar as listas, porém, são imutáveis. Não se pode

acrescentar, apagar ou fazer atribuições aos itens

Tupla: t = (a, b, c, d, …, n-1)

Tupla com 1 elemento: t = (1,)

Tupla vazia: t = ()

Elementos podem ser referenciados como na lista:elemento1 = t[0]

Listas podem ser convertidas em Tuplas e vice-versa:tupla = tuple(lista) #Conversão para Tupla

lista = list(tupla) #Conversão para Lista



Tuplas Embora a tupla possa conter elementos mutáveis, esses elementos não

podem sofrer atribuição, pois modificaria a referência ao objeto.


>>> t = ([1,2],4)>>> t[0].append(3)>>> t([1,2,3],4)>>>> t[0] = [1,2,3]

Traceback (most recent call last):File "<input>", line 1, in ?TypeError: object does not support item assignment>>>


Tuplas As tuplas são mais eficientes do que as listas convencionais, pois

consomem menos recursos de memória do que as listas, por seremmais simples.



Outras Funções Seqüenciais de Builtins: Set – Seqüência mutável sem repetições

Frozenset – Seqüência imutável sem repetições

Implementam operações de conjuntos, como União, Intersecção, e diferença.



# Conjuntos de dadoss1 = set(range(3))s2 = set(range(10, 7, -1))s3 = set(range(2, 10, 2))

# Exibe os dadosprint 's1:', s1, '\ns2:', s2, '\ns3:', s3

#Saída

s1: set([0, 1, 2])s2: set([8, 9, 10])s3: set([8, 2, 4, 6])


Outras Funções Seqüenciais de Builtins:


# Uniãos1s2 = s1.union(s2)print 'União de s1 e s2:\n', s1s2

# Diferençaprint 'Diferença com s3:\n', s1s2.difference(s3)

# Interseçãoprint 'Interseção com s3:\n', s1s2.intersection(s3)

# Testa se um set inclui outroif s1.issuperset([1, 2]):

print 's1 inclui 1 e 2'

# Testa se não existe elementos em comumif s1.isdisjoint(s2):

print 's1 e s2 não tem elementos em comum'

#Saída

União de s1 e s2:set([0, 1, 2, 8, 9, 10])

Diferença com s3:set([0, 1, 10, 9])

Interseção com s3:set([8, 2])

s1 inclui 1 e 2

s1 e s2 não tem elementos em comum


Outras Funções Seqüenciais de Builtins:

Obs.: Quando uma lista é convertida para set, as repetições são descartadas.



Dicionários Um dicionário é uma lista de associações compostas por uma chave

única e estruturas correspondentes. Dicionários são mutáveis, tais como as listas.

A chave precisa ser de um tipo imutável, geralmente são usadas strings, mas também podem ser tuplas ou tipos numéricos. Já os itens dos dicionários podem ser tanto mutáveis quanto imutáveis. O dicionário do Python não fornece garantia de que as chaves estarão ordenadas.


dicionario = {'a': a, 'b': b, ..., 'z': z}


Dicionários



Dicionários


dic = {'nome': 'Shirley Manson', 'banda': 'Garbage'}

#Acessando Elementosprint dic['nome']

#Adicionando Elementosdic['album'] = 'Version 2.0'

#Apagando um elementodel dic['album']

#Obtendo itens, chaves e valoresitens = dic.items()chaves = dic.keys()valores = dic.values()

#SaídaShirley Manson


Dicionários Alguns exemplos de operações com Dicionários:


# Progs e seus albunsprogs = {'Yes': ['Close To The Edge', 'Fragile'],

'Genesis': ['Foxtrot', 'The Nursery Crime'],'ELP': ['Brain Salad Surgery']}

# Mais progsprogs['King Crimson'] = ['Red', 'Discipline']

# items() retorna uma lista de# tuplas com a chave e o valorfor prog, albuns in progs.items():

print prog, '=>', albuns

# Se tiver 'ELP', deletaif progs.has_key('ELP'):

del progs['ELP']

#Saída

Yes => ['Close To The Edge', 'Fragile'] ELP => ['Brain Salad Surgery']Genesis => ['Foxtrot', 'The Nursery Crime']King Crimson => ['Red', 'Discipline']


Verdadeiro, Falso e Nulo

Em Python, o tipo booleano (bool) é uma especialização do tipo inteiro (int). O verdadeiro é chamado True e é equivalente a 1, enquanto o falso é chamado False e é equivalente a 0.

Os seguintes valores são considerados como falso (False):• False

• None

• 0 (zero)

• ‘’ ou “” – String vazia

• [ ] lista vazia

• ( ) tupla vazia

• { } dicionário vazio

• Outras estruturas com tamanho igual a zero



Operadores Booleanos Possibilidade de construir condições mais complexas para controlar

desvios condicionais e laços

São os operadores: And, or, not, is, in

• and: retorna verdadeiro se e somente se receber duas expressões verdadeiras.

• or: retorna false se e somente se receber duas expressões falsas.

• not: retorna falso se receber uma expressão verdadeira e vice-versa

• is: retorna verdadeiro quando duas referências forem idênticas ao mesmo objeto e falso em caso contrário

• in: retorna verdadeiro se receber um item e uma lista e o item ocorrer uma ou mais vezes na lista e falso em caso contrário



Funções São blocos de código identificados por um nome, que podem receber

parâmetros pré-determinados Podem retornar ou não objetos

Aceitam Doc Strings

Parâmetros opcionais. Caso não receba parâmetros em sua chamada, será igual ao default definido em na função

Aceitam parâmetros passados com nome, e para este caso, a ordem em que os parâmetros foram passados não é relevante.

Obs.: Doc Strings são strings que estão associadas a uma estrutura do Python. Nas funções, as Doc Strings são colocadas dentro do corpo da função, geralmente no começo. O objetivo das Doc Strings é servir de documentação para aquela estrutura.


def dobro(x):""“Doc String: Esta função retorna o dobro do número x"""return x*2


Funções São blocos de código identificados por um nome, que podem receber

parâmetros pré-determinados


def func(parametro1, parametro2=padrao):"""Doc String"""<bloco de código>

return valor

def fatorial(num):"""Fatorial implementado de forma recursiva""“

if num <= 1:return 1

else:return(num * fatorial(num – 1))

# Testando fatorial()print fatorial(5)

# Saída

120


Funções Exemplo Fatorial sem recursão


def fatorial(n):n = n if n > 1 else 1j = 1for i in range(1, n):

j = j * ireturn j

# Testandofor i in range(1,6):

print i, ‘->’, fatorial(i)

# Saída

1 -> 12 -> 23 -> 64 -> 245 -> 120


Funções Método Principal: podemos referenciar o nome de uma função ou

chamá-la como método principal


def func1(param1, param2):return value_func1

def func2(param):return value_func2

if __name__== “__main__” :func1(p1, p2)func2(p)

# Saída

value_func1value_func2


Funções


def rgb_html(r=0, g=0, b=0):""“Converte RGB em #RRGGBB"""return “#%02x%02x%02x“, %(r, g, b)

def html_rgb(color=“#000000"):""“Converte #RRGGBB em RGB"""if color.startswitch(‘#’): color = color [1:]

r = int(color[:2], 16)g = int(color[2:4], 16)b = int(color[4:], 16)return r, g, b

if __name__== “__main__” :print rgb_html(200, 200, 255)print rgb_html(b=200, g=200, r=255)print html_rgb('#c8c8ff')

# Saída

#c8c8ff #ffc8c8(200, 200, 255)


Estrutura de Dados Abordaremos aqui alguns dos pontos falados anteriormente, citados em

usos com Listas, porém, descreveremos alguns métodos adicionais.

list.append(x): Adiciona um elemento ao fim da lista.

list.extend(L): Prolonga a lista, adicionando ao fim da lista atual os demais elementos da lista L.

list.insert(i, x): Insere um item em uma posição especificada, onde i = índice do elemento antes da inserção e x = o valor a ser inserido.

list.remove(x):Remove o primeiro item encontrado na lista cujo valor é igual a X

list.pop([i]): Remove o item na posição dada e o devolve. Se nenhum índice for especificado, list.pop() remove e devolve o último item na lista.

list.index(x): Devolve o índice do primeiro item cujo valor é igual a x, gerando ValueError se este valor não existe



Estrutura de Dados list.count(x): Devolve o número de vezes que o valor x aparece na lista.

list.sort(): Ordena os itens na própria lista.

list.reverse(): Inverte a ordem dos elementos na lista (sem gerar uma nova lista).


>>> a = [66.25, 333, 333, 1, 1234.5]>>> print a.count(333), a.count(66.25), a.count('x')2 1 0>>> a.insert(2, -1)>>> a.append(333)>>> a [66.25, 333, -1, 333, 1, 1234.5, 333]>>> a.index(333)1>>> a.remove(333)>>> a[66.25, -1, 333, 1, 1234.5, 333]>>> a.reverse()>>> a[333, 1234.5, 1, 333, -1, 66.25]>>> a.sort()>>> a[-1, 1, 66.25, 333, 333, 1234.5]


Estrutura de Dados Usando Lista como Pilha (LIFO – Last In, First Out).


>>> pilha = [3, 4, 5]>>> pilha.append(6)>>> pilha.append(7)>>> pilha[3, 4, 5, 6, 7]>>> pilha.pop()7>>> pilha[3, 4, 5, 6]>>> pilha.pop()6>>> pilha.pop()5>>> pilha[3, 4]


Estrutura de Dados Usando Lista como Fila (FIFO – First In, First Out).

Devemos fazer o uso da Classe collections.deque


>>> from collections import deque>>> fila = deque(["Eric", "John", "Michael"])>>> fila.append("Terry") # Terry chega>>> fila.append("Graham") # Graham chega>>> fila.popleft() # O primeiro a chegar parte'Eric'>>> fila.popleft() # O segundo a chegar parte'John'>>> fila # O resto da fila, em ordem de chegadadeque(['Michael', 'Terry', 'Graham'])

Dia 1 – Introdução e Características Arquivos e I/O

Os arquivos no Python são representados por objetos do tipo file Arquivos podem ser abertos para leitura ('r'), gravação ('w') ou adição ('a'), em modo texto ou binário('b').


import sys

# Criando um objeto do tipo filetemp = open('temp.txt', 'w')

# Escrevendo no arquivofor i in range(100):

temp.write('%03d\n' % i)

# Fechandotemp.close()

temp = open('temp.txt')

# Escrevendo no terminalfor x in temp:

# Escrever em sys.stdout envia# o texto para a saída padrãosys.stdout.write(x)

temp.close()

Exemplo de Escrita:

Dia 1 – Introdução e Características Arquivos e I/O

Os arquivos no Python são representados por objetos do tipo file Arquivos podem ser abertos para leitura ('r'), gravação ('w') ou adição ('a'), em modo texto ou binário('b').


import sysimport os.path

# raw_input() retorna a string digitadafn = raw_input('Nome do arquivo: ').strip()

if not os.path.exists(fn):print 'Tente outra vez...'sys.exit()

# Numerando as linhasfor i, s in enumerate(open(fn)):

print i + 1, s,

# Imprime uma lista contendo linhas do arquivoprint open('temp.txt').readlines()

Exemplo de leitura:

Dia 1 – Introdução e Características Sistemas de Arquivos

Algumas funções para manipular Diretórios de Arquivos (fyle systems):

Muitas destas funcionalidades estão implementadas no módulo os.path:

os.path.basename(): retorna o componente final de um caminho

os.path.dirname(): retorna um caminho sem o componente final

os.path.exists(): verifica se um caminho existe (True), caso contrário acusa como inexistente (False).

os.path.getsize(): retorna o tamanho do arquivo em bytes



Exercícios!


OBRIGADO


Vinícius J. L. CorreiaE-mail: [email protected]/in/vinileodido


Realização

Organização

Apoio

mini curso iot - sieng 2016 - dia 1

Technology