sistema de arquivos

.

.

Configurador

Desenvolvimento do configurador do Atemga 32 da Atmel faz parte de algumas ideia antigas consolidada agora.

Foi desenvolvidas várias páginas seguindo o manual (doc2503) fornecido pela Atmel em seu site oficial.

Alguns periféricos que são compostos de mais de um permitiram concentrar todos as suas funcionalidades em um único arquivo texto porém outros foram necessários dividi-los em mais de um arquivo.

A página de controle de geração do código.

Arquivamento das informações geradas para uso.

GIT do trabalho:

GIT de casa:

.

Uso do Git

.

.

execução por programa e por interrupção

.

.

Manipulação de arquivos CSV

.

.

Arquivamento

.

.

Escrita e Leitura de CSV como dicionário

class csv.DictReader(csvfile[, fieldnames=None[, restkey=None[, restval=None[, dialect='excel'[, *args, **kwds]]]]])

Criar um objeto que funciona como um leitor regular mas mapeia as informações ler em um dicionário cujas chaves são dadas pelo parâmetro fieldnames opcional.

Se o parâmetro fieldnames for omitido, os valores na primeira linha da csvfile vai ser utilizado como os nomes de campos. [1]

#************************************************************************
#!/usr/bin/python
# -*- coding: utf-8 -*-
#************************************************************************
import csv
#************************************************************************
class Teste(object):
    '''Classe
    '''
    _atributoclasseINVISIVEL = []
    atributoclasseVISIVEL = []
   
    def __init__(self):#trata os diretórios como pacotes.
        '''init
        '''
        vatributolocali = 't'

        print('init')

    def leituraCSV():
        '''leitura
        '''
        vatributolocall = 0
       
        try:
            with open('teste.csv') as csvfile:
                reader = csv.DictReader(csvfile)
                for row in reader:
                    print(row['primeiro_nome'], row['segundo_nome'])
        except:
            print('Erro leitura.')

    def escritaCSV():
        '''escrita
        '''
        vatributolocale = 3
       
        try:
            with open('teste.csv', 'w') as csvfile:
                fieldnames = ['primeiro_nome', 'segundo_nome']
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
               
                writer.writeheader()
                writer.writerow({'primeiro_nome': 'Ubiratan', 'segundo_nome': 'Uaatsim'})
                writer.writerow({'primeiro_nome': 'Lucia', 'segundo_nome': 'Souza'})
                writer.writerow({'primeiro_nome': 'Marina', 'segundo_nome': 'Persona'})
        except:
            print('Erro escrita.')
#************************************************************************


#************************************************************************
if __name__ == '__main__':#pode ser usado como script ou módulo.
    Teste()
    print ('Classe instanciada - Teste.')
#************************************************************************

Execução do script.

Arquivo: teste.csv

#--------------------------------------------------------------------------------------------
    def escritaCSV2():
        '''escrita
        '''
        vatributolocale = 3

        cabecalho = ['PESSOA 1','PESSOA 2','PESSOA 3']
        linha = [{'PESSOA 1':'Lucia Souza','PESSOA 2':'Marina Persona','PESSOA 3':'Marina Persona'}}]
        linha2 = [{'PESSOA 1':'Itzá I','PESSOA 2':'Guaranis','PESSOA 3':'Tupinambás'}]
       
        try:
            with open('teste2.csv', 'w') as f:
                writer = csv.DictWriter(f, fieldnames=cabecalho)
                writer.writeheader()
                writer.writerows(linha)
                writer.writerows(linha2)
        except:
            print('Erro escrita 2.')

    def leituraCSV2():
        '''leitura
        '''
        vatributolocall = 0
       
        try:
            with open('teste2.csv') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    pass
        except:
            print('Erro leitura 2.')
           
        print(row['PESSOA 1'], row['PESSOA 2'],row['PESSOA 3'])
       
#************************************************************************

Arquivo: teste2.csv

Referências
[1] https://docs.python.org/2/library/csv.html
[2]
.

uso do GIT

comando git status
comando git add .
comando git.commit -m 'mensagem"
comando git log

.

tkinter - habilitação do botão

try:
    import tkinter
    from tkinter import ttk
    from tkinter import messagebox
    from tkinter import StringVar
    from tkinter import IntVar
    from tkinter import BooleanVar
    print('Instanciados os módulos do tkinter.')
except ImportError:
    print('Erro na importação dos módulos do tkinter.')

Neste código o botão é ofuscado e a função é executada:

        self._bt1 = ttk.Button(self._pagina1, text="Ambiente")
        self._bt1.bind("<Button-1>", self._fbt1)
        self._bt1.configure(state=tkinter.DISABLED)

Neste código o botão é ofuscado e a função não é executada:

        self._bt1 = tkinter.Button(self._pagina1, text='Ambiente', command=self._fbt1)
        self._bt1.configure(state=tkinter.DISABLED)

Logo é necessário habilitá-lo com o seguinte código:

self._bt1.configure(state=tkinter.NORMAL)

Técnicas e ferramentas

.

 Uso do GIT

Inserção de logging, arquivos INI e arquivos CSV.

try:
    import csv
    print('Instanciados os módulos do csv.')
except ImportError:
    print('Erro nas importações dos módulos do csv.')

try:
    from configparser import ConfigParser
    print('Instanciados os módulos do configparser.')
except ImportError:
    print('Erro nas importações dos módulos do configparser.')

try:
    import logging
    import logging.config
    from logging.config import fileConfig
    print('Instanciados os módulos do logging.')
except ImportError:
    print('Erro nas importações dos módulos do logging.')


A manipulação de arquivos .ini é muito facilitado pela biblioteca configparser do Python.

.

sqlite3

#*********************************************************************
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#*********************************************************************
import sqlite3 as lite
import sys
import os
#------------------------------------------------------------------------------------------
con = None
#------------------------------------------------------------------------------------------
class PreSistema():
    def __init__(self):
        self.vpresistema = 'p'
        print('Atributos instanciados - Presistema!')
#------------------------------------------------------------------------------------------

#------------------------------------------------------------------------------------------
    def sqliteVersao():
        '''Versão do sqlite.
        '''
       
        try: 
            con = lite.connect('test.db')
            cur = con.cursor()
            cur.execute('SELECT SQLITE_VERSION()')
            data = cur.fetchone()
            print ('Versão do SQLite: %s' % data)
        except (lite.Error, e):
            print ('Erro %s:' % e.args[0])
            sys.exit(1)
        finally:
            if con:
                con.close()
                print('Fechado com erro.')
        print('Método sqliteVersao.')
#------------------------------------------------------------------------------------------
    def verificaConexao(arkivo):
        '''Verifica conexão do BD.
        '''
        dbfilename = arkivo
        dbis_new = not os.path.exists(dbfilename)

        if dbis_new:
            try:
                con = lite.connect(dbfilename)#cria
                print ('Conexão criada.')
            except (lite.Error, e):
                print('Sai com erro.')
                sys.exit(1)
            finally:
                if con:
                    con.close()
                    print('conexã encerrada.')
            print ('Caminha não econtrado. Foi criado o esquema.')
        else:
            print ('Banco de dados existente e assumido o esquema atual.')
           
        print('Método verificaConexao.')
#------------------------------------------------------------------------------------------


#************************************************************************
if __name__ == '__main__':
    PreSistema()
    print ('Classe instanciada - PreSistemas!')
#************************************************************************
.

código pronto - configurador

.

#*********************************************************************
#
try:
    import tkinter
    from tkinter import ttk
    from tkinter import messagebox
    from tkinter import StringVar
    import time
    print('Instanciado os módulos tkinter no Paginador.')
except ImportError:
    print('Erro na importação dos módulos no Paginador.')
#
#*********************************************************************
vcaminhoimagens = '../bildoj/'
#*********************************************************************
class Paginador():
    def __init__(self):
        self.root = tkinter.Tk()
        self.root.title("Condigurador")
       
        self.style = ttk.Style()
        self.style.configure("BW.TLabel", foreground="black", background="white")
#-----------------------------------------------------------------------------------------------
Código para criar as páginas:
#-----------------------------------------------------------------------------------------------
        self.n = ttk.Notebook(self.root)
        self.pagina0 = ttk.Frame(self.n);
        self.pagina1 = ttk.Frame(self.n);
        self.pagina2 = ttk.Frame(self.n);
        self.pagina3 = ttk.Frame(self.n);
        self.pagina4 = ttk.Frame(self.n);
        self.pagina5 = ttk.Frame(self.n);

        self.n.add(self.pagina0, text='Página 1')
        self.n.add(self.pagina2, text='Página 2')
        self.n.add(self.pagina3, text='Página 3')
        self.n.add(self.pagina4, text='Página 4')
        self.n.add(self.pagina5, text='Página 5')
        self.n.pack()
#-----------------------------------------------------------------------------------------------
Código para particionar a página em linhas e colunas:
#-----------------------------------------------------------------------------------------------
        self.paginapessoa.columnconfigure(0, weight=3)
        self.paginapessoa.columnconfigure(1, weight=3)
        self.paginapessoa.columnconfigure(2, weight=3)
        self.paginapessoa.columnconfigure(3, weight=3)
        self.paginapessoa.columnconfigure(4, weight=3)
        self.paginapessoa.columnconfigure(5, weight=3)
        self.paginapessoa.columnconfigure(6, weight=3)
       
        self.paginapessoa.rowconfigure(0, weight=3)
        self.paginapessoa.rowconfigure(1, weight=3)
        self.paginapessoa.rowconfigure(2, weight=3)
        self.paginapessoa.rowconfigure(3, weight=3)
        self.paginapessoa.rowconfigure(4, weight=3)
        self.paginapessoa.rowconfigure(5, weight=3)
        self.paginapessoa.rowconfigure(6, weight=3)
#-----------------------------------------------------------------------------------------------
Código que posiciona os objetos na página:
#-----------------------------------------------------------------------------------------------
        self.lbl1.grid(column=0, row=0)
        self.entra1.grid(column=0, row=1)
        self.lbl2.grid(column=0, row=2)
        self.entra2.grid(column=0, row=3)
         
        self.opc3.grid(column=4, row=0)
        self.opc1.grid(column=4, row=1)
        self.opc2.grid(column=5, row=1)
        self.opc3.grid(column=4, row=2)
        self.opc4.grid(column=5, row=2)

        self.lbl4.grid(column=4, row=3)
        self.opc5.grid(column=4, row=4)
        self.opc6.grid(column=5, row=4)
        self.opc7.grid(column=4, row=5)
        self.opc8.grid(column=5, row=5)
      
        self.bt1.grid(column=0, row=5)
#-----------------------------------------------------------------------------------------------
Código que cria os objetos:
#-----------------------------------------------------------------------------------------------
        self.ventra1 = tkinter.StringVar()
        self.ventra1.set('sem nome')
        self.ventra2 = tkinter.StringVar()
        self.ventra2.set('sem senha')
       
        self.vlbl1 = tkinter.StringVar()
        self.vlbl1.set('Nome')
        self.lbl1 = tkinter.Label(self.pagina1, text="Pessoa x", textvariable=self.vlbl1, bg='yellow')
        self.entra1 = tkinter.Entry(self.pagina1)
        self.entra1.config(textvariable=self.ventra1)
       
        self.vlbl2 = tkinter.StringVar()
        self.vlbl2.set('Senha')
        self.lbl2 = tkinter.Label(self.pagina1, text="Senha", textvariable=self.vlbl2, bg='yellow')
        self.entra2 = tkinter.Entry(self.pagina1, textvariable=self.ventra2, show='*')

        self.bt1 = ttk.Button(self.pagina1, text="Registrar")
        self.bt1.bind("<Button-1>", self._fbt1)
      
        self.v3 = tkinter.StringVar()
        self.v3.set("3")
        self.lbl3 = tkinter.Label(self.pagina1, text="Quantidade", bg='yellow')
        self.opc1 = ttk.Radiobutton(self.pagina1, text='Um', variable=self.vqtdepessoas, value='1', command=self._fopc)
        self.opc2 = ttk.Radiobutton(self.pagina1, text='Dois', variable=self.vqtdepessoas, value='2', command=self._fopc)
        self.opc3 = ttk.Radiobutton(self.pagina1, text='Três', variable=self.v3, value='3', command=self._fopc)
        self.opc4 = ttk.Radiobutton(self.pagina1, text='Quatro', variable=self.v3, value='4', command=self._fopc)

        self.v4 = tkinter.StringVar()
        self.v4.set("opc6")
        self.lbl4 = tkinter.Label(self.pagina1, text="Opções", bg='yellow')
        self.opc5 = ttk.Radiobutton(self.pagina1, text='opc 5', variable=self.v4, value='opc5', command=self._opc2)
        self.opc6 = ttk.Radiobutton(self.pagina1, text='opc 6', variable=self.v4, value='opc6', command=self._opc2)
        self.opc7 = ttk.Radiobutton(self.pagina1, text='opc 7', variable=self.v4, value='opc7', command=self._opc2)
        self.opc8 = ttk.Radiobutton(self.pagina1, text='opc 8', variable=self.v4, value='opc8', command=self._opc2)
#-----------------------------------------------------------------------------------------------

#-----------------------------------------------------------------------------------------------

#************************************************************************
if __name__ == '__main__':
    Configurador()
    print ('Classe instanciada - Configurador!')
#************************************************************************
.

estrutura do Python

Quando um nome é referenciado a um objeto em um programa o espaço de nome (namespaces) serão procurados na seguinte ordem para encontrar a ligação para esse nome: espaço de nomes local primeiramente, então o espaço de nome global, e depois o espaço de nome interno. Este processo é chamado de regra de LGB.

Python fornece somente um método da passagem de parâmetro o método de passagem-por-referência.

Os argumentos especificados em uma chamada do método são chamados parâmetros reais.

Os argumentos que aparecem na definição do método são chamados parâmetros formais.

O primeiro argumento do método é sempre referenciado no início do processo.

Um método que acessa uma instância mas não modifica a instância é chamado de accessor ou acessor. Um método que modifica uma instância é um mutator ou modificador. Um property é um atributo de classe que promove o método de acesso e/ou método modificador.


Referências

[1] http://wiki.python.org.br/ProgramacaoOrientadaObjetoPython

[2] http://pythonclub.com.br/introducao-classes-metodos-python-basico.html

[3] http://www3.ifrn.edu.br/~jurandy/fdp/doc/aprenda-python/capitulo_14.html

Módulos em Python

Dentro de um módulo Python, o nome do módulo está disponível na variável global __name__.

Com o comando import importa-se o módulo: import time

coloca somente o módulo na tabela de símbolos atual. não seus métodos todos.

time.time()

cada módulo tem sua própria tabela de símbolos privada que é global para todos os métodos do módulo.

para acessar os atributos de outro método usa-se: nomedomodulo.nomedoitem

o comando from classe import métodosX importa diretamente para a tabela de símbolos. logo teremos acesso com o nome métodosX.

from classe import * somente os sublinhados que não.

pode ser usado tanto como um script (python nome.py <argumentos>) quanto como um módulo (import nome) com:
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

python nome.py 50

módulo.pacote
pacotes livram os autores de se preocupem com colisão entre os nomes de seus módulos e os nomes de módulos de outros autores.
pacotes: coleção de módulos

Os arquivos __init__.py são necessários para que Python trate os diretórios como pacotes

import nome.nome.nome
from nome.nome import nome
from nome.nome.nome. import nome

from package import item
import item.subitem.subsubitem

Fonte: http://turing.com.br/pydoc/2.7/tutorial/modules.html

Mitos e fatos no desenvolvimento de programas

Foram acrescentadas algumas considerações sobre o método ágil de produção de programas na aba Metódos Ágil com base em um livro que leio.