sábado, 2 de maio de 2015

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)

sexta-feira, 1 de maio de 2015

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.

.

domingo, 12 de abril de 2015

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!')
#************************************************************************
.

sexta-feira, 10 de abril de 2015

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!')
#************************************************************************
.

terça-feira, 31 de março de 2015

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

domingo, 29 de março de 2015

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