Guia rápido de Python

Python é uma linguagem de script de alto nível, interpretada, interativa e orientada a objetos. Python foi projetado para ser altamente legível. Ele usa palavras-chave em inglês com frequência, enquanto outros idiomas usam pontuação e tem menos construções sintáticas do que outros idiomas.

• Python is Interpreted- Python é processado em tempo de execução pelo interpretador. Você não precisa compilar seu programa antes de executá-lo. Isso é semelhante ao PERL e PHP.

• Python is Interactive - Você pode realmente sentar em um prompt do Python e interagir com o interpretador diretamente para escrever seus programas.

• Python is Object-Oriented - Python suporta estilo orientado a objeto ou técnica de programação que encapsula código dentro de objetos.

• Python is a Beginner's Language - Python é uma ótima linguagem para programadores iniciantes e oferece suporte ao desenvolvimento de uma ampla gama de aplicativos, desde processamento de texto simples a navegadores WWW e jogos.

História do Python

Python foi desenvolvido por Guido van Rossum no final dos anos oitenta e início dos anos noventa no Instituto Nacional de Pesquisa para Matemática e Ciência da Computação na Holanda.

Python é derivado de muitas outras linguagens, incluindo ABC, Modula-3, C, C ++, Algol-68, SmallTalk e shell Unix e outras linguagens de script.

Python é protegido por direitos autorais. Como o Perl, o código-fonte do Python agora está disponível sob a GNU General Public License (GPL).

Python agora é mantido por uma equipe de desenvolvimento central no instituto, embora Guido van Rossum ainda tenha um papel vital no direcionamento de seu progresso.

Recursos do Python

Os recursos do Python incluem -

• Easy-to-learn- Python tem poucas palavras-chave, estrutura simples e uma sintaxe claramente definida. Isso permite que o aluno aprenda o idioma rapidamente.

• Easy-to-read - O código Python é mais claramente definido e visível aos olhos.

• Easy-to-maintain - O código-fonte do Python é bastante fácil de manter.

• A broad standard library - A maior parte da biblioteca do Python é muito portátil e compatível com várias plataformas em UNIX, Windows e Macintosh.

• Interactive Mode - Python tem suporte para um modo interativo que permite teste interativo e depuração de trechos de código.

• Portable - Python pode ser executado em uma ampla variedade de plataformas de hardware e tem a mesma interface em todas as plataformas.

• Extendable- Você pode adicionar módulos de baixo nível ao interpretador Python. Esses módulos permitem que os programadores adicionem ou personalizem suas ferramentas para serem mais eficientes.

• Databases - Python fornece interfaces para todos os principais bancos de dados comerciais.

• GUI Programming - Python suporta aplicativos GUI que podem ser criados e transferidos para muitas chamadas de sistema, bibliotecas e sistemas Windows, como Windows MFC, Macintosh e o sistema X Window do Unix.

• Scalable - Python fornece uma estrutura e suporte melhores para programas grandes do que scripts de shell.

Além dos recursos mencionados acima, Python tem uma grande lista de bons recursos, poucos estão listados abaixo -

• Ele suporta métodos de programação funcionais e estruturados, bem como OOP.

• Ele pode ser usado como uma linguagem de script ou pode ser compilado em código de bytes para a construção de grandes aplicativos.

• Ele fornece tipos de dados dinâmicos de alto nível e oferece suporte à verificação de tipo dinâmico.

• Ele oferece suporte à coleta de lixo automática.

• Pode ser facilmente integrado com C, C ++, COM, ActiveX, CORBA e Java.

Python está disponível em uma ampla variedade de plataformas, incluindo Linux e Mac OS X. Vamos entender como configurar nosso ambiente Python.

Configuração de ambiente local

Abra uma janela de terminal e digite "python" para descobrir se já está instalado e qual versão está instalada.

• Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX, etc.)
• Win 9x / NT / 2000
• Macintosh (Intel, PPC, 68K)
• OS/2
• DOS (várias versões)
• PalmOS
• Telefones celulares Nokia
• Windows CE
• Acorn / RISC OS
• BeOS
• Amiga
• VMS/OpenVMS
• QNX
• VxWorks
• Psion
• Python também foi portado para as máquinas virtuais Java e .NET

Obtendo Python

O código-fonte, binários, documentação, notícias, etc. mais atualizados e atuais estão disponíveis no site oficial do Python https://www.python.org/

Você pode baixar a documentação do Python em https://www.python.org/doc/. A documentação está disponível nos formatos HTML, PDF e PostScript.

Instalando Python

A distribuição Python está disponível para uma ampla variedade de plataformas. Você precisa baixar apenas o código binário aplicável à sua plataforma e instalar o Python.

Se o código binário para sua plataforma não estiver disponível, você precisa de um compilador C para compilar o código-fonte manualmente. Compilar o código-fonte oferece mais flexibilidade em termos de escolha de recursos que você precisa em sua instalação.

Aqui está uma rápida visão geral da instalação do Python em várias plataformas -

Instalação Unix e Linux

Aqui estão as etapas simples para instalar o Python em uma máquina Unix / Linux.

• Abra um navegador da Web e vá para https://www.python.org/downloads/.

• Siga o link para baixar o código-fonte compactado disponível para Unix / Linux.

• Baixe e extraia arquivos.

• Editando o arquivo Módulos / Configuração se desejar personalizar algumas opções.

• execute o script ./configure

• make

• faça a instalação

Isso instala o Python no local padrão / usr / local / bin e suas bibliotecas em / usr / local / lib / pythonXX onde XX é a versão do Python.

Instalação Windows

Aqui estão as etapas para instalar o Python na máquina Windows.

• Abra um navegador da Web e vá para https://www.python.org/downloads/.

• Siga o link para o arquivo python-XYZ.msi do instalador do Windows, em que XYZ é a versão que você precisa instalar.

• Para usar este instalador python-XYZ.msi , o sistema Windows deve suportar o Microsoft Installer 2.0. Salve o arquivo do instalador em sua máquina local e execute-o para descobrir se sua máquina oferece suporte a MSI.

• Execute o arquivo baixado. Isso abre o assistente de instalação do Python, que é realmente fácil de usar. Apenas aceite as configurações padrão, espere até que a instalação seja concluída e você esteja pronto.

Instalação Macintosh

Macs recentes vêm com o Python instalado, mas pode estar desatualizado há vários anos. Vejohttp://www.python.org/download/mac/para obter instruções sobre como obter a versão atual junto com ferramentas extras para apoiar o desenvolvimento no Mac. Para Mac OS anteriores ao Mac OS X 10.3 (lançado em 2003), o MacPython está disponível.

Jack Jansen o mantém e você pode ter acesso total a toda a documentação em seu site - http://www.cwi.nl/~jack/macpython.html. Você pode encontrar detalhes de instalação completos para a instalação do Mac OS.

Configurando PATH

Os programas e outros arquivos executáveis ​​podem estar em vários diretórios, portanto, os sistemas operacionais fornecem um caminho de pesquisa que lista os diretórios em que o sistema operacional pesquisa executáveis.

O caminho é armazenado em uma variável de ambiente, que é uma string nomeada mantida pelo sistema operacional. Esta variável contém informações disponíveis para o shell de comando e outros programas.

o path variável é nomeada como PATH no Unix ou Path no Windows (Unix diferencia maiúsculas de minúsculas; Windows não).

No Mac OS, o instalador lida com os detalhes do caminho. Para invocar o interpretador Python de qualquer diretório específico, você deve adicionar o diretório Python ao seu caminho.

Definir caminho em Unix / Linux

Para adicionar o diretório Python ao caminho para uma sessão particular no Unix -

• In the csh shell - digite setenv PATH "$ PATH: / usr / local / bin / python" e pressione Enter.

• In the bash shell (Linux) - digite export PATH = "$ PATH: / usr / local / bin / python" e pressione Enter.

• In the sh or ksh shell - digite PATH = "$ PATH: / usr / local / bin / python" e pressione Enter.

• Note - / usr / local / bin / python é o caminho do diretório Python

Configurando caminho no Windows

Para adicionar o diretório Python ao caminho para uma sessão específica no Windows -

At the command prompt - digite path% path%; C: \ Python e pressione Enter.

Note - C: \ Python é o caminho do diretório Python

Variáveis ​​de ambiente Python

Aqui estão variáveis ​​de ambiente importantes, que podem ser reconhecidas pelo Python -

Sr. Não.	Variável e Descrição
1	PYTHONPATH Ele tem uma função semelhante a PATH. Esta variável informa ao interpretador Python onde localizar os arquivos de módulo importados para um programa. Deve incluir o diretório da biblioteca de origem do Python e os diretórios que contêm o código-fonte do Python. PYTHONPATH às vezes é predefinido pelo instalador Python.
2	PYTHONSTARTUP Ele contém o caminho de um arquivo de inicialização contendo o código-fonte Python. Ele é executado toda vez que você inicia o interpretador. É denominado .pythonrc.py no Unix e contém comandos que carregam utilitários ou modificam PYTHONPATH.
3	PYTHONCASEOK É usado no Windows para instruir o Python a encontrar a primeira correspondência sem distinção entre maiúsculas e minúsculas em uma instrução de importação. Defina esta variável com qualquer valor para ativá-la.
4	PYTHONHOME É um caminho alternativo de pesquisa de módulo. Geralmente é incorporado aos diretórios PYTHONSTARTUP ou PYTHONPATH para facilitar a troca de bibliotecas de módulos.

Executando Python

Existem três maneiras diferentes de iniciar o Python -

Intérprete Interativo

Você pode iniciar o Python a partir do Unix, DOS ou qualquer outro sistema que forneça um interpretador de linha de comando ou janela de shell.

Entrar python a linha de comando.

Comece a codificar imediatamente no interpretador interativo.

$python # Unix/Linux
or
python% # Unix/Linux
or
C:> python # Windows/DOS

Aqui está a lista de todas as opções de linha de comando disponíveis -

Sr. Não.	Opção e descrição
1	-d Ele fornece saída de depuração.
2	-O Ele gera bytecode otimizado (resultando em arquivos .pyo).
3	-S Não execute o site de importação para procurar caminhos Python na inicialização.
4	-v saída detalhada (rastreamento detalhado nas instruções de importação).
5	-X desabilite exceções integradas baseadas em classe (apenas use strings); obsoleto a partir da versão 1.6.
6	-c cmd execute o script Python enviado como string cmd
7	file execute o script Python a partir do arquivo fornecido

Script da linha de comando

Um script Python pode ser executado na linha de comando invocando o interpretador em seu aplicativo, como a seguir -

$python script.py # Unix/Linux

or

python% script.py # Unix/Linux

or 

C: >python script.py # Windows/DOS

Note - Certifique-se de que o modo de permissão de arquivo permite a execução.

Ambiente de desenvolvimento integrado

Você também pode executar o Python a partir de um ambiente de interface gráfica do usuário (GUI), se tiver um aplicativo GUI em seu sistema que suporte Python.

• Unix - IDLE é o primeiro IDE Unix para Python.

• Windows - PythonWin é a primeira interface do Windows para Python e é um IDE com uma GUI.

• Macintosh - A versão do Python para Macintosh junto com o IDLE IDE está disponível no site principal, para download como arquivos MacBinary ou BinHex.

Se não conseguir configurar o ambiente adequadamente, você pode pedir ajuda ao administrador do sistema. Certifique-se de que o ambiente Python esteja configurado corretamente e funcionando perfeitamente bem.

Note - Todos os exemplos dados nos capítulos subsequentes são executados com a versão Python 2.4.3 disponível no tipo CentOS do Linux.

Já configuramos o ambiente de Programação Python online, para que você possa executar todos os exemplos disponíveis online ao mesmo tempo quando estiver aprendendo teoria. Sinta-se à vontade para modificar qualquer exemplo e executá-lo online.

A linguagem Python tem muitas semelhanças com Perl, C e Java. No entanto, existem algumas diferenças definidas entre os idiomas.

Primeiro programa Python

Vamos executar programas em diferentes modos de programação.

Programação de modo interativo

Invocar o interpretador sem passar um arquivo de script como parâmetro traz o seguinte prompt -

$ python
Python 2.4.3 (#1, Nov 11 2010, 13:34:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Digite o seguinte texto no prompt do Python e pressione Enter -

>>> print "Hello, Python!"

Se você estiver executando uma nova versão do Python, precisará usar a instrução print com parênteses, como em print ("Hello, Python!");. No entanto, na versão 2.4.3 do Python, isso produz o seguinte resultado -

Hello, Python!

Programação em modo script

Chamar o interpretador com um parâmetro de script começa a execução do script e continua até que o script seja concluído. Quando o script é concluído, o intérprete não está mais ativo.

Vamos escrever um programa Python simples em um script. Arquivos Python têm extensão.py. Digite o seguinte código-fonte em um arquivo test.py -

print "Hello, Python!"

Assumimos que você tem um interpretador Python definido na variável PATH. Agora, tente executar este programa da seguinte maneira -

$ python test.py

Isso produz o seguinte resultado -

Hello, Python!

Vamos tentar outra maneira de executar um script Python. Aqui está o arquivo test.py modificado -

#!/usr/bin/python

print "Hello, Python!"

Presumimos que você tenha um interpretador Python disponível no diretório / usr / bin. Agora, tente executar este programa da seguinte maneira -

$ chmod +x test.py     # This is to make file executable
$./test.py

Isso produz o seguinte resultado -

Hello, Python!

Identificadores Python

Um identificador Python é um nome usado para identificar uma variável, função, classe, módulo ou outro objeto. Um identificador começa com uma letra de A a Z ou a a z ou um sublinhado (_) seguido por zero ou mais letras, sublinhados e dígitos (0 a 9).

Python não permite caracteres de pontuação como @, $ e% nos identificadores. Python é uma linguagem de programação que diferencia maiúsculas de minúsculas. Portanto,Manpower e manpower são dois identificadores diferentes em Python.

Aqui estão as convenções de nomenclatura para identificadores Python -

• Os nomes das classes começam com uma letra maiúscula. Todos os outros identificadores começam com uma letra minúscula.

• Iniciar um identificador com um único sublinhado inicial indica que o identificador é privado.

• Iniciar um identificador com dois sublinhados iniciais indica um identificador fortemente privado.

• Se o identificador também terminar com dois sublinhados à direita, o identificador é um nome especial definido pelo idioma.

Palavras reservadas

A lista a seguir mostra as palavras-chave Python. Estas são palavras reservadas e você não pode usá-las como constantes ou variáveis ​​ou qualquer outro nome de identificador. Todas as palavras-chave Python contêm apenas letras minúsculas.

e	exec	não
afirmar	finalmente	ou
pausa	para	passar
classe	de	impressão
continuar	global	levantar
def	E se	Retorna
del	importar	experimentar
elif	dentro	enquanto
outro	é	com
exceto	lambda	produção

Linhas e recuo

Python não fornece chaves para indicar blocos de código para definições de classe e função ou controle de fluxo. Blocos de código são denotados por recuo de linha, que é rigidamente aplicado.

O número de espaços no recuo é variável, mas todas as instruções dentro do bloco devem ser recuadas da mesma forma. Por exemplo -

if True:
   print "True"
else:
   print "False"

No entanto, o bloco a seguir gera um erro -

if True:
print "Answer"
print "True"
else:
print "Answer"
print "False"

Assim, em Python, todas as linhas contínuas recuadas com o mesmo número de espaços formariam um bloco. O exemplo a seguir tem vários blocos de instrução -

Note- Não tente entender a lógica neste momento. Apenas certifique-se de ter entendido os vários bloqueios, mesmo que eles não tenham chaves.

#!/usr/bin/python

import sys

try:
   # open file stream
   file = open(file_name, "w")
except IOError:
   print "There was an error writing to", file_name
   sys.exit()
print "Enter '", file_finish,
print "' When finished"
while file_text != file_finish:
   file_text = raw_input("Enter text: ")
   if file_text == file_finish:
      # close the file
      file.close
      break
   file.write(file_text)
   file.write("\n")
file.close()
file_name = raw_input("Enter filename: ")
if len(file_name) == 0:
   print "Next time please enter something"
   sys.exit()
try:
   file = open(file_name, "r")
except IOError:
   print "There was an error reading file"
   sys.exit()
file_text = file.read()
file.close()
print file_text

Declarações de várias linhas

As instruções em Python geralmente terminam com uma nova linha. Python, entretanto, permite o uso do caractere de continuação de linha (\) para indicar que a linha deve continuar. Por exemplo -

total = item_one + \
        item_two + \
        item_three

As instruções contidas nos colchetes [], {} ou () não precisam usar o caractere de continuação de linha. Por exemplo -

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

Cotação em Python

Python aceita aspas simples ('), duplas (") e triplas (' '' ou" "") para denotar literais de string, desde que o mesmo tipo de aspas inicie e termine a string.

As aspas triplas são usadas para estender a string em várias linhas. Por exemplo, todos os itens a seguir são legais -

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

Comentários em Python

Um sinal de hash (#) que não está dentro de um literal de string inicia um comentário. Todos os caracteres após o # e até o final da linha física fazem parte do comentário e o interpretador Python os ignora.

#!/usr/bin/python

# First comment
print "Hello, Python!" # second comment

Isso produz o seguinte resultado -

Hello, Python!

Você pode digitar um comentário na mesma linha após uma declaração ou expressão -

name = "Madisetti" # This is again comment

Você pode comentar várias linhas da seguinte forma -

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

Usando linhas em branco

Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é conhecida como linha em branco e o Python a ignora totalmente.

Em uma sessão de intérprete interativa, você deve inserir uma linha física vazia para encerrar uma instrução multilinha.

Esperando pelo Usuário

A seguinte linha do programa exibe o prompt, a instrução dizendo "Pressione a tecla Enter para sair" e espera que o usuário execute uma ação -

#!/usr/bin/python

raw_input("\n\nPress the enter key to exit.")

Aqui, "\ n \ n" é usado para criar duas novas linhas antes de exibir a linha real. Assim que o usuário pressiona a tecla, o programa termina. Este é um bom truque para manter uma janela do console aberta até que o usuário conclua o aplicativo.

Várias declarações em uma única linha

O ponto e vírgula (;) permite várias instruções em uma única linha, visto que nenhuma instrução inicia um novo bloco de código. Aqui está um recorte de amostra usando o ponto-e-vírgula -

import sys; x = 'foo'; sys.stdout.write(x + '\n')

Vários grupos de extrato como suítes

Um grupo de instruções individuais, que formam um único bloco de código, são chamadas suitesem Python. Instruções compostas ou complexas, como if, while, def e class requerem uma linha de cabeçalho e um conjunto.

As linhas de cabeçalho começam a declaração (com a palavra-chave) e terminam com dois pontos (:) e são seguidas por uma ou mais linhas que compõem o conjunto. Por exemplo -

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Argumentos de linha de comando

Muitos programas podem ser executados para fornecer algumas informações básicas sobre como devem ser executados. Python permite que você faça isso com -h -

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

Você também pode programar seu script de forma que aceite várias opções. Argumentos da linha de comando é um tópico avançado e deve ser estudado um pouco mais tarde, uma vez que você tenha passado pelo restante dos conceitos do Python.

As variáveis ​​nada mais são do que locais de memória reservados para armazenar valores. Isso significa que, ao criar uma variável, você reserva algum espaço na memória.

Com base no tipo de dado de uma variável, o interpretador aloca memória e decide o que pode ser armazenado na memória reservada. Portanto, ao atribuir diferentes tipos de dados às variáveis, você pode armazenar inteiros, decimais ou caracteres nessas variáveis.

Atribuição de valores a variáveis

Variáveis ​​Python não precisam de declaração explícita para reservar espaço de memória. A declaração acontece automaticamente quando você atribui um valor a uma variável. O sinal de igual (=) é usado para atribuir valores às variáveis.

O operando à esquerda do operador = é o nome da variável e o operando à direita do operador = é o valor armazenado na variável. Por exemplo -

#!/usr/bin/python

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print counter
print miles
print name

Aqui, 100, 1000,0 e "John" são os valores atribuídos às variáveis counter , miles e name , respectivamente. Isso produz o seguinte resultado -

100
1000.0
John

Atribuição múltipla

Python permite que você atribua um único valor a várias variáveis ​​simultaneamente. Por exemplo -

a = b = c = 1

Aqui, um objeto inteiro é criado com o valor 1 e todas as três variáveis ​​são atribuídas ao mesmo local de memória. Você também pode atribuir vários objetos a várias variáveis. Por exemplo -

a,b,c = 1,2,"john"

Aqui, dois objetos inteiros com valores 1 e 2 são atribuídos às variáveis ​​aeb respectivamente, e um objeto string com o valor "john" é atribuído à variável c.

Tipos de dados padrão

Os dados armazenados na memória podem ser de vários tipos. Por exemplo, a idade de uma pessoa é armazenada como um valor numérico e seu endereço é armazenado como caracteres alfanuméricos. Python tem vários tipos de dados padrão que são usados ​​para definir as operações possíveis neles e o método de armazenamento para cada um deles.

Python tem cinco tipos de dados padrão -

• Numbers
• String
• List
• Tuple
• Dictionary

Números Python

Os tipos de dados numéricos armazenam valores numéricos. Objetos de número são criados quando você atribui um valor a eles. Por exemplo -

var1 = 1
var2 = 10

Você também pode excluir a referência a um objeto de número usando a instrução del. A sintaxe da instrução del é -

del var1[,var2[,var3[....,varN]]]]

Você pode excluir um único objeto ou vários objetos usando a instrução del. Por exemplo -

del var
del var_a, var_b

Python suporta quatro tipos numéricos diferentes -

• int (inteiros com sinal)
• long (inteiros longos, eles também podem ser representados em octal e hexadecimal)
• float (valores reais de ponto flutuante)
• complexo (números complexos)

Exemplos

Aqui estão alguns exemplos de números -

int	grandes	flutuador	complexo
10	51924361L	0,0	3,14j
100	-0x19323L	15,20	45.j
-786	0122L	-21,9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32,3 + e18	.876j
-0490	535633629843L	-90.	-.6545 + 0J
-0x260	-052318172735L	-32.54e100	3e + 26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Python permite que você use um l minúsculo com long, mas é recomendado que você use apenas um L maiúsculo para evitar confusão com o número 1. Python exibe inteiros longos com um L maiúsculo.

• Um número complexo consiste em um par ordenado de números reais de ponto flutuante denotados por x + yj, onde xey são os números reais ej é a unidade imaginária.

Python Strings

Strings em Python são identificadas como um conjunto contíguo de caracteres representados entre aspas. Python permite pares de aspas simples ou duplas. Subconjuntos de strings podem ser obtidos usando o operador de fatia ([] e [:]) com índices começando em 0 no início da string e trabalhando de -1 no final.

O sinal de mais (+) é o operador de concatenação de string e o asterisco (*) é o operador de repetição. Por exemplo -

#!/usr/bin/python

str = 'Hello World!'

print str          # Prints complete string
print str[0]       # Prints first character of the string
print str[2:5]     # Prints characters starting from 3rd to 5th
print str[2:]      # Prints string starting from 3rd character
print str * 2      # Prints string two times
print str + "TEST" # Prints concatenated string

Isso produzirá o seguinte resultado -

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Listas Python

As listas são os mais versáteis dos tipos de dados compostos do Python. Uma lista contém itens separados por vírgulas e colocados entre colchetes ([]). Até certo ponto, as listas são semelhantes às matrizes em C. Uma diferença entre elas é que todos os itens pertencentes a uma lista podem ser de tipos de dados diferentes.

Os valores armazenados em uma lista podem ser acessados ​​usando o operador de fatia ([] e [:]) com índices começando em 0 no início da lista e trabalhando até o final -1. O sinal de mais (+) é o operador de concatenação de lista e o asterisco (*) é o operador de repetição. Por exemplo -

#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list          # Prints complete list
print list[0]       # Prints first element of the list
print list[1:3]     # Prints elements starting from 2nd till 3rd 
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists

Isso produz o seguinte resultado -

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Python Tuples

Uma tupla é outro tipo de dados de sequência semelhante à lista. Uma tupla consiste em vários valores separados por vírgulas. Ao contrário das listas, no entanto, as tuplas são colocadas entre parênteses.

As principais diferenças entre listas e tuplas são: As listas são colocadas entre colchetes ([]) e seus elementos e tamanho podem ser alterados, enquanto as tuplas são colocadas entre parênteses (()) e não podem ser atualizadas. Tuplas podem ser consideradasread-onlylistas. Por exemplo -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print tuple               # Prints the complete tuple
print tuple[0]            # Prints first element of the tuple
print tuple[1:3]          # Prints elements of the tuple starting from 2nd till 3rd 
print tuple[2:]           # Prints elements of the tuple starting from 3rd element
print tinytuple * 2       # Prints the contents of the tuple twice
print tuple + tinytuple   # Prints concatenated tuples

Isso produz o seguinte resultado -

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

O código a seguir é inválido com tupla, porque tentamos atualizar uma tupla, o que não é permitido. Caso semelhante é possível com listas -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Dicionário Python

Os dicionários do Python são do tipo tabela hash. Eles funcionam como matrizes associativas ou hashes encontrados em Perl e consistem em pares de valores-chave. Uma chave de dicionário pode ser quase qualquer tipo Python, mas geralmente são números ou strings. Os valores, por outro lado, podem ser qualquer objeto Python arbitrário.

Os dicionários são colocados entre colchetes ({}) e os valores podem ser atribuídos e acessados ​​usando colchetes ([]). Por exemplo -

#!/usr/bin/python

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

Isso produz o seguinte resultado -

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Os dicionários não têm conceito de ordem entre os elementos. É incorreto dizer que os elementos estão "fora de ordem"; eles são simplesmente desordenados.

Conversão de Tipo de Dados

Às vezes, pode ser necessário realizar conversões entre os tipos integrados. Para converter entre tipos, você simplesmente usa o nome do tipo como uma função.

Existem várias funções integradas para realizar a conversão de um tipo de dados para outro. Essas funções retornam um novo objeto que representa o valor convertido.

Sr. Não.	Descrição da função
1	int(x [,base]) Converte x em um inteiro. base especifica a base se x for uma string.
2	long(x [,base] ) Converte x em um inteiro longo. base especifica a base se x for uma string.
3	float(x) Converte x em um número de ponto flutuante.
4	complex(real [,imag]) Cria um número complexo.
5	str(x) Converte o objeto x em uma representação de string.
6	repr(x) Converte o objeto x em uma string de expressão.
7	eval(str) Avalia uma string e retorna um objeto.
8	tuple(s) Converte s em uma tupla.
9	list(s) Converte s em uma lista.
10	set(s) Converte s em um conjunto.
11	dict(d) Cria um dicionário. d deve ser uma sequência de tuplas (chave, valor).
12	frozenset(s) Converte s em um conjunto congelado.
13	chr(x) Converte um número inteiro em um caractere.
14	unichr(x) Converte um número inteiro em um caractere Unicode.
15	ord(x) Converte um único caractere em seu valor inteiro.
16	hex(x) Converte um número inteiro em uma string hexadecimal.
17	oct(x) Converte um inteiro em uma string octal.

Operadores são as construções que podem manipular o valor dos operandos.

Considere a expressão 4 + 5 = 9. Aqui, 4 e 5 são chamados de operandos e + é chamado de operador.

Tipos de Operador

A linguagem Python suporta os seguintes tipos de operadores.

• Operadores aritméticos
• Operadores de comparação (relacionais)
• Operadores de atribuição
• Operadores lógicos
• Operadores bit a bit
• Operadores de associação
• Operadores de identidade

Vamos dar uma olhada em todos os operadores, um por um.

Operadores aritméticos Python

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
+ Adição	Adiciona valores em qualquer lado do operador.	a + b = 30
- Subtração	Subtrai o operando direito do operando esquerdo.	a - b = -10
* Multiplicação	Multiplica os valores em ambos os lados do operador	a * b = 200
/ Divisão	Divide operando esquerdo pelo operando direito	b / a = 2
% Módulo	Divide operando esquerdo pelo operando direito e retorna o resto	b% a = 0
** Expoente	Executa cálculo exponencial (potência) nos operadores	a ** b = 10 elevado à potência 20
//	Divisão de chão - A divisão de operandos onde o resultado é o quociente em que os dígitos após a vírgula decimal são removidos. Mas se um dos operandos for negativo, o resultado é arredondado, ou seja, arredondado de zero (em direção ao infinito negativo) -	9 // 2 = 4 e 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0

Operadores de comparação Python

Esses operadores comparam os valores de cada lado deles e decidem a relação entre eles. Eles também são chamados de operadores relacionais.

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
==	Se os valores de dois operandos forem iguais, a condição se torna verdadeira.	(a == b) não é verdade.
! =	Se os valores de dois operandos não forem iguais, a condição se torna verdadeira.	(a! = b) é verdade.
<>	Se os valores de dois operandos não forem iguais, a condição se torna verdadeira.	(a <> b) é verdadeiro. Isso é semelhante ao operador! =.
>	Se o valor do operando esquerdo for maior que o valor do operando direito, a condição se torna verdadeira.	(a> b) não é verdade.
<	Se o valor do operando esquerdo for menor que o valor do operando direito, a condição se torna verdadeira.	(a <b) é verdadeiro.
> =	Se o valor do operando esquerdo for maior ou igual ao valor do operando direito, a condição se torna verdadeira.	(a> = b) não é verdade.
<=	Se o valor do operando esquerdo for menor ou igual ao valor do operando direito, a condição se torna verdadeira.	(a <= b) é verdadeiro.

Operadores de atribuição Python

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
=	Atribui valores de operandos do lado direito para operando do lado esquerdo	c = a + b atribui o valor de a + b em c
+ = Adicionar E	Ele adiciona o operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo	c + = a é equivalente a c = c + a
- = Subtrair E	Ele subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo	c - = a é equivalente a c = c - a
* = Multiplicar E	Ele multiplica o operando direito com o operando esquerdo e atribui o resultado ao operando esquerdo	c * = a é equivalente a c = c * a
/ = Dividir E	Ele divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo	c / = a é equivalente a c = c / a
% = Módulo E	Leva o módulo usando dois operandos e atribui o resultado ao operando esquerdo	c% = a é equivalente a c = c% a
** = Expoente E	Executa cálculo exponencial (potência) nos operadores e atribui valor ao operando esquerdo	c ** = a é equivalente a c = c ** a
// = Divisão de Andar	Ele realiza a divisão de piso nos operadores e atribui valor ao operando esquerdo	c // = a é equivalente a c = c // a

Operadores bit a bit Python

O operador bit a bit funciona em bits e executa operação bit a bit. Suponha que a = 60; e b = 13; Agora, no formato binário, seus valores serão 0011 1100 e 0000 1101, respectivamente. A tabela a seguir lista os operadores bit a bit suportados pela linguagem Python com um exemplo de cada um deles, usamos as duas variáveis ​​acima (aeb) como operandos -

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

Existem os seguintes operadores bit a bit suportados pela linguagem Python

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
& Binário E	O operador copia um bit para o resultado se ele existir em ambos os operandos	(a & b) (significa 0000 1100)
| Binário OU	Ele copia um pouco se existir em qualquer operando.	(a | b) = 61 (significa 0011 1101)
^ Binário XOR	Ele copia o bit se estiver definido em um operando, mas não em ambos.	(a ^ b) = 49 (significa 0011 0001)
~ Complemento dos binários	É unário e tem o efeito de 'inverter' bits.	(~ a) = -61 (significa 1100 0011 na forma de complemento de 2 devido a um número binário com sinal.
<< Deslocamento à esquerda binário	O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita.	a << 2 = 240 (significa 1111 0000)
>> Deslocamento para a direita binário	O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita.	a >> 2 = 15 (significa 0000 1111)

Operadores lógicos Python

Existem os seguintes operadores lógicos suportados pela linguagem Python. Suponha que a variável a tenha 10 e a variável b tenha 20, então

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
e lógico E	Se ambos os operandos forem verdadeiros, a condição se torna verdadeira.	(aeb) é verdade.
ou lógico OU	Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(a ou b) é verdadeiro.
não lógico	Usado para reverter o estado lógico de seu operando.	Não (aeb) é falso.

Operadores de associação Python

Os operadores de associação do Python testam a associação em uma sequência, como strings, listas ou tuplas. Existem dois operadores de adesão, conforme explicado abaixo -

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
dentro	Avalia como verdadeiro se encontrar uma variável na sequência especificada e como falso caso contrário.	x em y, aqui em resulta em 1 se x for um membro da sequência y.
não em	Avalia como verdadeiro se não encontrar uma variável na sequência especificada e como falso caso contrário.	x não em y, aqui não em resulta em 1 se x não for um membro da sequência y.

Operadores de identidade Python

Operadores de identidade comparam as localizações de memória de dois objetos. Existem dois operadores de identidade explicados abaixo -

[ Mostrar exemplo ]

Operador	Descrição	Exemplo
é	Avalia como verdadeiro se as variáveis ​​em qualquer lado do operador apontam para o mesmo objeto e como falso caso contrário.	x é y, aqui is resulta em 1 se id (x) for igual a id (y).
não é	Avalia como falso se as variáveis ​​em qualquer lado do operador apontam para o mesmo objeto e como verdadeiro caso contrário.	x não é y, aqui is not resulta em 1 se id (x) não for igual a id (y).

Precedência de operadores Python

A tabela a seguir lista todos os operadores da mais alta precedência à mais baixa.

[ Mostrar exemplo ]

Sr. Não.	Operador e descrição
1	** Exponenciação (elevar à potência)
2	~ + - Complemento, mais e menos unários (os nomes dos métodos para os dois últimos são + @ e - @)
3	* / % // Multiplique, divida, módulo e divisão de piso
4	+ - Adição e subtração
5	>> << Deslocamento bit a bit para direita e esquerda
6	& 'E' bit a bit
7	^ | "OR" exclusivo bit a bit e "OR" regular
8	<= < > >= Operadores de comparação
9	<> == != Operadores de igualdade
10	= %= /= //= -= += *= **= Operadores de atribuição
11	is is not Operadores de identidade
12	in not in Operadores de associação
13	not or and Operadores lógicos

A tomada de decisão é a antecipação das condições que ocorrem durante a execução do programa e a especificação das ações executadas de acordo com as condições.

As estruturas de decisão avaliam várias expressões que produzem TRUE ou FALSE como resultado. Você precisa determinar qual ação tomar e quais instruções executar se o resultado for VERDADEIRO ou FALSO de outra forma.

A seguir está a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

A linguagem de programação Python assume qualquer non-zero e non-null valores como TRUE, e se for zero ou null, então é assumido como valor FALSE.

A linguagem de programação Python fornece os seguintes tipos de declarações de tomada de decisão. Clique nos links a seguir para verificar seus detalhes.

Sr. Não.	Declaração e descrição
1	declarações if A if statement consiste em uma expressão booleana seguida por uma ou mais instruções.
2	declarações if ... else A if statement pode ser seguido por um opcional else statement, que é executado quando a expressão booleana é FALSE.
3	declarações if aninhadas Você pode usar um if ou else if declaração dentro de outra if ou else if afirmações).

Vamos analisar cada tomada de decisão brevemente -

Suítes de declaração única

Se a suíte de um if cláusula consiste apenas em uma única linha, ela pode ir na mesma linha que a instrução de cabeçalho.

Aqui está um exemplo de um one-line if cláusula -

#!/usr/bin/python

var = 100
if ( var == 100 ) : print "Value of expression is 100"
print "Good bye!"

Quando o código acima é executado, ele produz o seguinte resultado -

Value of expression is 100
Good bye!

Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante. Pode haver uma situação em que você precise executar um bloco de código várias vezes.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes. O diagrama a seguir ilustra uma instrução de loop -

A linguagem de programação Python fornece os seguintes tipos de loops para lidar com os requisitos de loop.

Sr. Não.	Tipo de Loop e Descrição
1	loop while Repete uma instrução ou grupo de instruções enquanto uma determinada condição for TRUE. Ele testa a condição antes de executar o corpo do loop.
2	para loop Executa uma sequência de instruções várias vezes e abrevia o código que gerencia a variável de loop.
3	loops aninhados Você pode usar um ou mais loops dentro de qualquer outro loop while, for ou do..while.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos.

Python suporta as seguintes instruções de controle. Clique nos links a seguir para verificar seus detalhes.

Vamos examinar as instruções de controle de loop brevemente

Sr. Não.	Declaração de controle e descrição
1	declaração de quebra Encerra a instrução de loop e transfere a execução para a instrução imediatamente após o loop.
2	continuar declaração Faz com que o loop pule o restante de seu corpo e teste novamente sua condição imediatamente antes de reiterar.
3	declaração de aprovação A instrução pass em Python é usada quando uma instrução é necessária sintaticamente, mas você não deseja que nenhum comando ou código seja executado.

Os tipos de dados numéricos armazenam valores numéricos. Eles são tipos de dados imutáveis, o que significa que alterar o valor de um tipo de dados numérico resulta em um objeto recém-alocado.

Objetos de número são criados quando você atribui um valor a eles. Por exemplo -

var1 = 1
var2 = 10

Você também pode excluir a referência a um objeto de número usando o deldeclaração. A sintaxe da instrução del é -

del var1[,var2[,var3[....,varN]]]]

Você pode excluir um único objeto ou vários objetos usando o deldeclaração. Por exemplo -

del var
del var_a, var_b

Python suporta quatro tipos numéricos diferentes -

• int (signed integers) - Eles geralmente são chamados apenas de inteiros ou ints, são números inteiros positivos ou negativos sem casa decimal.

• long (long integers ) - Também chamados de longos, eles são inteiros de tamanho ilimitado, escritos como inteiros e seguidos por um L maiúsculo ou minúsculo.

• float (floating point real values)- Também chamados de floats, eles representam números reais e são escritos com um ponto decimal dividindo as partes inteiras e fracionárias. Os carros alegóricos também podem estar em notação científica, com E ou e indicando a potência de 10 (2,5e2 = 2,5 x 10 ² = 250).

• complex (complex numbers)- são da forma a + bJ, onde aeb são flutuantes e J (ou j) representa a raiz quadrada de -1 (que é um número imaginário). A parte real do número é a, e a parte imaginária é b. Números complexos não são muito usados ​​na programação Python.

Exemplos

Aqui estão alguns exemplos de números

int	grandes	flutuador	complexo
10	51924361L	0,0	3,14j
100	-0x19323L	15,20	45.j
-786	0122L	-21,9	9.322e-36j
080	0xDEFABCECBDAECBFBAEL	32,3 + e18	.876j
-0490	535633629843L	-90.	-.6545 + 0J
-0x260	-052318172735L	-32.54e100	3e + 26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Python permite que você use um L minúsculo com long, mas é recomendado que você use apenas um L maiúsculo para evitar confusão com o número 1. Python exibe inteiros longos com um L maiúsculo.

• Um número complexo consiste em um par ordenado de números reais de ponto flutuante denotados por a + bj, onde a é a parte real eb é a parte imaginária do número complexo.

Conversão de tipo de número

Python converte números internamente em uma expressão contendo tipos mistos em um tipo comum para avaliação. Mas às vezes, você precisa forçar um número explicitamente de um tipo para outro para satisfazer os requisitos de um operador ou parâmetro de função.

• Tipo int(x) para converter x em um inteiro simples.

• Tipo long(x) para converter x em um inteiro longo.

• Tipo float(x) para converter x em um número de ponto flutuante.

• Tipo complex(x) para converter x em um número complexo com parte real xe zero parte imaginário.

• Tipo complex(x, y)para converter xey em um número complexo com parte real xe parte imaginária y. x e y são expressões numéricas

Funções Matemáticas

Python inclui as seguintes funções que realizam cálculos matemáticos.

Sr. Não.	Função e retornos (descrição)
1	abs (x) O valor absoluto de x: a distância (positiva) entre x e zero.
2	ceil (x) O teto de x: o menor inteiro não inferior a x
3	cmp (x, y) -1 se x <y, 0 se x == y, ou 1 se x> y
4	exp (x) O exponencial de x: e x
5	fabs (x) O valor absoluto de x.
6	andar (x) O piso de x: o maior inteiro não maior que x
7	log (x) O logaritmo natural de x, para x> 0
8	log10 (x) O logaritmo de base 10 de x para x> 0.
9	máx (x1, x2, ...) O maior de seus argumentos: o valor mais próximo do infinito positivo
10	min (x1, x2, ...) O menor de seus argumentos: o valor mais próximo do infinito negativo
11	modf (x) As partes fracionárias e inteiras de x em uma tupla de dois itens. Ambas as partes têm o mesmo sinal de x. A parte inteira é retornada como um float.
12	pow (x, y) O valor de x ** y.
13	rodada (x [, n]) xarredondado para n dígitos da vírgula decimal. Python arredonda a partir de zero como desempate: round (0,5) é 1.0 e round (-0,5) é -1,0.
14	sqrt (x) A raiz quadrada de x para x> 0

Funções de números aleatórios

Números aleatórios são usados ​​para jogos, simulações, testes, aplicativos de segurança e privacidade. Python inclui as seguintes funções que são comumente usadas.

Sr. Não.	Descrição da função
1	escolha (seq) Um item aleatório de uma lista, tupla ou string.
2	randrange ([iniciar,] parar [, passo]) Um elemento selecionado aleatoriamente no intervalo (iniciar, parar, passo)
3	aleatória() Um float aleatório r, tal que 0 é menor ou igual a r e r é menor que 1
4	semente ([x]) Define o valor inicial inteiro usado na geração de números aleatórios. Chame esta função antes de chamar qualquer outra função de módulo aleatório. Retorna nenhum.
5	embaralhar (lst) Randomiza os itens de uma lista no local. Retorna nenhum.
6	uniforme (x, y) Um float aleatório r, tal que x é menor ou igual a r e r é menor que y

Funções trigonométricas

Python inclui as seguintes funções que realizam cálculos trigonométricos.

Sr. Não.	Descrição da função
1	acos (x) Retorne o arco cosseno de x, em radianos.
2	asin (x) Retorne o arco seno de x, em radianos.
3	atan (x) Retorne o arco tangente de x, em radianos.
4	atan2 (y, x) Retorne atan (y / x), em radianos.
5	cos (x) Retorne o cosseno de x radianos.
6	hipot (x, y) Retorne a norma euclidiana, sqrt (x * x + y * y).
7	sin (x) Retorne o seno de x radianos.
8	tan (x) Retorne a tangente de x radianos.
9	graus (x) Converte o ângulo x de radianos em graus.
10	radianos (x) Converte o ângulo x de graus para radianos.

Constantes Matemáticas

O módulo também define duas constantes matemáticas -

Sr. Não.	Constantes e Descrição
1	pi A constante matemática pi.
2	e A constante matemática e.

Strings estão entre os tipos mais populares em Python. Podemos criá-los simplesmente colocando os caracteres entre aspas. Python trata aspas simples da mesma forma que aspas duplas. Criar strings é tão simples quanto atribuir um valor a uma variável. Por exemplo -

var1 = 'Hello World!'
var2 = "Python Programming"

Acessando Valores em Strings

Python não oferece suporte a um tipo de caractere; estes são tratados como strings de comprimento um, portanto, também considerados substring.

Para acessar substrings, use os colchetes para fatiar junto com o índice ou índices para obter sua substring. Por exemplo -

#!/usr/bin/python

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

Quando o código acima é executado, ele produz o seguinte resultado -

var1[0]:  H
var2[1:5]:  ytho

Atualizando Strings

Você pode "atualizar" uma string existente (re) atribuindo uma variável a outra string. O novo valor pode estar relacionado ao seu valor anterior ou a uma string completamente diferente. Por exemplo -

#!/usr/bin/python

var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python'

Quando o código acima é executado, ele produz o seguinte resultado -

Updated String :-  Hello Python

Personagens de Fuga

A tabela a seguir é uma lista de caracteres de escape ou não imprimíveis que podem ser representados com a notação de barra invertida.

Um caractere de escape é interpretado; em strings entre aspas simples e duplas.

Notação de barra invertida	Caráter hexadecimal	Descrição
\uma	0x07	Sino ou alerta
\ b	0x08	Backspace
\ cx		Control-x
\ Cx		Control-x
\ e	0x1b	Escapar
\ f	0x0c	Formfeed
\ M- \ Cx		Meta-Control-x
\ n	0x0a	Nova linha
\ nnn		Notação octal, onde n está no intervalo de 0,7
\ r	0x0d	Retorno de carruagem
\ s	0x20	Espaço
\ t	0x09	Aba
\ v	0x0b	Aba vertical
\ x		Personagem x
\ xnn		Notação hexadecimal, em que n está no intervalo 0,9, af ou AF

Operadores especiais de string

Assumir variável de string a contém 'Olá' e variável b contém 'Python', então -

Operador	Descrição	Exemplo
+	Concatenação - adiciona valores em ambos os lados do operador	a + b dará HelloPython
*	Repetição - Cria novas strings, concatenando várias cópias da mesma string	a * 2 dará -HelloHello
[]	Slice - Dá o personagem do índice dado	a [1] dará e
[:]	Faixa de intervalo - fornece os personagens de um determinado intervalo	a [1: 4] dará ell
dentro	Membership - Retorna verdadeiro se um caractere existir na string fornecida	H em a dará 1
não em	Membership - Retorna verdadeiro se um caractere não existir na string fornecida	M não em a dará 1
r / R	String bruta - suprime o significado real dos caracteres de escape. A sintaxe para strings brutas é exatamente a mesma que para strings normais, com exceção do operador de string bruta, a letra "r", que precede as aspas. O "r" pode ser minúsculo (r) ou maiúsculo (R) e deve ser colocado imediatamente antes da primeira aspa.	imprimir r '\ n' impressões \ n e imprimir R '\ n'impressões \ n
%	Format - executa formatação de string	Veja na próxima seção

Operador de formatação de string

Um dos recursos mais interessantes do Python é o operador de formato de string%. Este operador é exclusivo para strings e compensa o pacote de funções da família printf () de C. A seguir está um exemplo simples -

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)

Quando o código acima é executado, ele produz o seguinte resultado -

My name is Zara and weight is 21 kg!

Aqui está a lista do conjunto completo de símbolos que podem ser usados ​​junto com% -

Símbolo de formato	Conversão
% c	personagem
% s	conversão de string via str () antes da formatação
%Eu	inteiro decimal com sinal
% d	inteiro decimal com sinal
%você	inteiro decimal sem sinal
% o	inteiro octal
% x	inteiro hexadecimal (letras minúsculas)
% X	inteiro hexadecimal (letras MAIÚSCULAS)
% e	notação exponencial (com 'e' minúsculo)
% E	notação exponencial (com maiúscula 'E')
% f	número real de ponto flutuante
% g	o mais curto de% f e% e
% G	o mais curto de% f e% E

Outros símbolos e funcionalidades suportados estão listados na tabela a seguir -

Símbolo	Funcionalidade
*	argumento especifica largura ou precisão
-	justificação à esquerda
+	mostrar o sinal
<sp>	deixe um espaço em branco antes de um número positivo
#	adicione o zero inicial octal ('0') ou o inicial hexadecimal '0x' ou '0X', dependendo se 'x' ou 'X' foram usados.
0	preencha da esquerda com zeros (em vez de espaços)
%	'%%' deixa você com um único literal '%'
(var)	variável de mapeamento (argumentos de dicionário)
mn	m é a largura total mínima e n é o número de dígitos a serem exibidos após o ponto decimal (se aplicável)

Citações Triplas

As aspas triplas do Python ajudam, permitindo que as strings ocupem várias linhas, incluindo NEWLINEs textuais, TABs e quaisquer outros caracteres especiais.

A sintaxe para aspas triplas consiste em três single or double citações.

#!/usr/bin/python

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str

Quando o código acima é executado, ele produz o seguinte resultado. Observe como cada caractere especial foi convertido em sua forma impressa, até a última NEWLINE no final da string entre o "para cima". e fechar aspas triplas. Observe também que NEWLINEs ocorrem com um retorno de carro explícito no final de uma linha ou seu código de escape (\ n) -

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

As strings brutas não tratam a barra invertida como um caractere especial. Cada caractere que você coloca em uma string bruta permanece do jeito que você escreveu -

#!/usr/bin/python

print 'C:\\nowhere'

Quando o código acima é executado, ele produz o seguinte resultado -

C:\nowhere

Agora vamos usar a string bruta. Nós colocaríamos expressão emr'expression' como segue -

#!/usr/bin/python

print r'C:\\nowhere'

Quando o código acima é executado, ele produz o seguinte resultado -

C:\\nowhere

String Unicode

Strings normais em Python são armazenadas internamente como ASCII de 8 bits, enquanto strings Unicode são armazenadas como Unicode de 16 bits. Isso permite um conjunto mais variado de caracteres, incluindo caracteres especiais da maioria dos idiomas do mundo. Vou restringir meu tratamento de strings Unicode ao seguinte -

#!/usr/bin/python

print u'Hello, world!'

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, world!

Como você pode ver, as strings Unicode usam o prefixo u, assim como as strings brutas usam o prefixo r.

Métodos de string integrados

Python inclui os seguintes métodos integrados para manipular strings -

Sr. Não.	Métodos com Descrição
1	capitalizar() Capitaliza a primeira letra da string
2	centro (largura, fillchar) Retorna uma string preenchida com espaço com a string original centralizada em um total de colunas de largura.
3	contagem (str, beg = 0, end = len (string)) Conta quantas vezes str ocorre em string ou em uma substring de string se o índice inicial começar e o fim do índice final forem fornecidos.
4	decodificar (codificação = 'UTF-8', erros = 'estrito') Decodifica a string usando o codec registrado para codificação. codificação padrão para a codificação de string padrão.
5	codificar (codificação = 'UTF-8', erros = 'estrito') Retorna a versão da string codificada; em caso de erro, o padrão é gerar um ValueError, a menos que os erros sejam fornecidos com 'ignorar' ou 'substituir'.
6	endswith (sufixo, beg = 0, end = len (string)) Determina se string ou uma substring de string (se o índice inicial começar e o fim do índice final forem fornecidos) termina com sufixo; retorna verdadeiro se sim e falso caso contrário.
7	expandtabs (tabsize = 8) Expande as tabulações na string para vários espaços; o padrão é 8 espaços por guia se o tamanho da guia não for fornecido.
8	find (str, beg = 0 end = len (string)) Determine se str ocorre em string ou em uma substring de string se o índice inicial beg e o final do índice recebem o índice de retorno se encontrado e -1 caso contrário.
9	índice (str, beg = 0, end = len (string)) O mesmo que find (), mas gera uma exceção se str não for encontrado.
10	isalnum () Retorna verdadeiro se a string tiver pelo menos 1 caractere e todos os caracteres são alfanuméricos e falso caso contrário.
11	isalpha () Retorna verdadeiro se a string tem pelo menos 1 caractere e todos os caracteres são alfabéticos e falso caso contrário.
12	isdigit () Retorna verdadeiro se a string contém apenas dígitos e falso caso contrário.
13	é inferior() Retorna verdadeiro se a string tem pelo menos 1 caractere maiúsculo e todos os caracteres maiúsculos estão em minúsculas e falso caso contrário.
14	isnumeric () Retorna verdadeiro se uma string Unicode contém apenas caracteres numéricos e falso caso contrário.
15	isspace () Retorna verdadeiro se a string contém apenas caracteres de espaço em branco e falso caso contrário.
16	istitle () Retorna verdadeiro se a string está devidamente "titlecased" e falso caso contrário.
17	isupper () Retorna verdadeiro se a string tem pelo menos um caractere maiúsculo e todos os caracteres maiúsculos estão em maiúsculas e falso caso contrário.
18	juntar (seq) Mescla (concatena) as representações de string de elementos em seqüência seq em uma string, com string separadora.
19	len (string) Retorna o comprimento da string
20	ljust (largura [, fillchar]) Retorna uma string preenchida com espaço com a string original justificada à esquerda para um total de colunas de largura.
21	mais baixo() Converte todas as letras maiúsculas da string em minúsculas.
22	lstrip () Remove todos os espaços em branco iniciais na string.
23	Maketrans () Retorna uma tabela de tradução a ser usada na função de tradução.
24	max (str) Retorna o caractere alfabético máximo da string str.
25	min (str) Retorna o min caractere alfabético da string str.
26	substituir (antigo, novo [, máximo]) Substitui todas as ocorrências do antigo na string por novas ou no máximo ocorrências se máximo fornecido.
27	rfind (str, beg = 0, end = len (string)) O mesmo que find (), mas pesquisa para trás na string.
28	rindex (str, beg = 0, end = len (string)) O mesmo que index (), mas pesquisa para trás na string.
29	rjust (largura, [, fillchar]) Retorna uma string preenchida com espaço com a string original justificada à direita para um total de colunas de largura.
30	rstrip () Remove todos os espaços em branco à direita da string.
31	dividir (str = "", num = string.count (str)) Divide a string de acordo com o delimitador str (espaço se não for fornecido) e retorna a lista de substrings; dividido em no máximo num substrings, se fornecido.
32	linhas de divisão (num = string.count ('\ n')) Divide string em todas (ou num) NEWLINEs e retorna uma lista de cada linha com NEWLINEs removidas.
33	startwith (str, beg = 0, end = len (string)) Determina se string ou uma substring de string (se o índice inicial beg e o final do índice final forem fornecidos) começa com a substring str; retorna verdadeiro se sim e falso caso contrário.
34	strip ([chars]) Executa lstrip () e rstrip () na string.
35	swapcase () Inverte maiúsculas e minúsculas para todas as letras da string.
36	título() Retorna a versão "titlecased" da string, ou seja, todas as palavras começam em maiúsculas e o resto em minúsculas.
37	traduzir (tabela, deletechars = "") Traduz a string de acordo com a tabela de tradução str (256 caracteres), removendo aqueles na string del.
38	superior() Converte letras minúsculas em uma string em maiúsculas.
39	zfill (largura) Retorna a string original com zeros à esquerda para um total de caracteres de largura; destinado a números, zfill () retém qualquer sinal dado (menos um zero).
40	isdecimal () Retorna verdadeiro se uma string Unicode contém apenas caracteres decimais e falso caso contrário.

A estrutura de dados mais básica em Python é a sequence. Cada elemento de uma sequência recebe um número - sua posição ou índice. O primeiro índice é zero, o segundo índice é um e assim por diante.

Python tem seis tipos de sequências embutidos, mas os mais comuns são listas e tuplas, que veríamos neste tutorial.

Existem certas coisas que você pode fazer com todos os tipos de sequência. Essas operações incluem indexação, divisão, adição, multiplicação e verificação de associação. Além disso, o Python tem funções integradas para encontrar o comprimento de uma sequência e para encontrar seus maiores e menores elementos.

Listas Python

A lista é um tipo de dados mais versátil disponível em Python, que pode ser escrita como uma lista de valores separados por vírgulas (itens) entre colchetes. O importante sobre uma lista é que os itens em uma lista não precisam ser do mesmo tipo.

Criar uma lista é tão simples quanto colocar diferentes valores separados por vírgula entre colchetes. Por exemplo -

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]

Semelhante aos índices de string, os índices de lista começam em 0 e as listas podem ser fatiadas, concatenadas e assim por diante.

Acessando Valores em Listas

Para acessar os valores nas listas, use os colchetes para fatiar junto com o índice ou índices para obter o valor disponível naquele índice. Por exemplo -

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

Quando o código acima é executado, ele produz o seguinte resultado -

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

Atualizando Listas

Você pode atualizar elementos únicos ou múltiplos de listas, dando a fatia no lado esquerdo do operador de atribuição, e você pode adicionar elementos em uma lista com o método append (). Por exemplo -

#!/usr/bin/python

list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2]
list[2] = 2001;
print "New value available at index 2 : "
print list[2]

Note - o método append () é discutido na seção subsequente.

Quando o código acima é executado, ele produz o seguinte resultado -

Value available at index 2 :
1997
New value available at index 2 :
2001

Excluir elementos da lista

Para remover um elemento de lista, você pode usar a instrução del se souber exatamente quais elementos está excluindo ou o método remove () se não souber. Por exemplo -

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
print list1
del list1[2];
print "After deleting value at index 2 : "
print list1

Quando o código acima é executado, ele produz o seguinte resultado -

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

Note - O método remove () é discutido na seção subsequente.

Operações básicas de lista

As listas respondem aos operadores + e * como strings; eles significam concatenação e repetição aqui também, exceto que o resultado é uma nova lista, não uma string.

Na verdade, as listas respondem a todas as operações gerais de sequência que usamos em strings no capítulo anterior.

Expressão Python	Resultados	Descrição
len ([1, 2, 3])	3	comprimento
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Concatenação
['Olá!'] * 4	['Oi!', 'Oi!', 'Oi!', 'Oi!']	Repetição
3 em [1, 2, 3]	Verdadeiro	Filiação
para x em [1, 2, 3]: imprimir x,	1 2 3	Iteração

Indexação, divisão e matrizes

Como as listas são sequências, a indexação e o fracionamento funcionam para listas da mesma forma que para strings.

Assumindo a seguinte entrada -

L = ['spam', 'Spam', 'SPAM!']

Expressão Python	Resultados	Descrição
L [2]	SPAM!	Os deslocamentos começam em zero
L [-2]	Spam	Negativo: contar da direita
L [1:]	['Spam', 'SPAM!']	Fatiar busca seções

Funções e métodos de lista integrados

Python inclui as seguintes funções de lista -

Sr. Não.	Função com Descrição
1	cmp (lista1, lista2) Compara elementos de ambas as listas.
2	len (lista) Fornece o comprimento total da lista.
3	max (lista) Retorna o item da lista com valor máximo.
4	min (lista) Retorna o item da lista com valor mínimo.
5	lista (seq) Converte uma tupla em lista.

Python inclui os seguintes métodos de lista

Sr. Não.	Métodos com Descrição
1	list.append (obj) Anexa objeto obj à lista
2	list.count (obj) Retorna a contagem de quantas vezes obj ocorre na lista
3	list.extend (seq) Acrescenta o conteúdo de seq à lista
4	list.index (obj) Retorna o índice mais baixo na lista que obj aparece
5	list.insert (índice, obj) Insere objeto obj na lista no índice de deslocamento
6	list.pop (obj = list [-1]) Remove e retorna o último objeto ou obj da lista
7	list.remove (obj) Remove objeto obj da lista
8	list.reverse () Inverte objetos da lista no lugar
9	list.sort ([func]) Classifica os objetos da lista, use a função de comparação se fornecida

Uma tupla é uma sequência imutável de objetos Python. Tuplas são sequências, assim como listas. As diferenças entre tuplas e listas são: as tuplas não podem ser alteradas, ao contrário das listas e as tuplas usam parênteses, enquanto as listas usam colchetes.

Criar uma tupla é tão simples quanto colocar diferentes valores separados por vírgula. Opcionalmente, você também pode colocar esses valores separados por vírgula entre parênteses. Por exemplo -

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

A tupla vazia é escrita como dois parênteses contendo nada -

tup1 = ();

Para escrever uma tupla contendo um único valor, você deve incluir uma vírgula, mesmo que haja apenas um valor -

tup1 = (50,);

Como os índices de string, os índices de tupla começam em 0 e podem ser fatiados, concatenados e assim por diante.

Acessando valores em tuplas

Para acessar valores na tupla, use os colchetes para fatiar junto com o índice ou índices para obter o valor disponível naquele índice. Por exemplo -

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0];
print "tup2[1:5]: ", tup2[1:5];

Quando o código acima é executado, ele produz o seguinte resultado -

tup1[0]:  physics
tup2[1:5]:  [2, 3, 4, 5]

Atualizando tuplas

As tuplas são imutáveis, o que significa que você não pode atualizar ou alterar os valores dos elementos da tupla. Você é capaz de pegar partes de tuplas existentes para criar novas tuplas como o exemplo a seguir demonstra -

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3;

Quando o código acima é executado, ele produz o seguinte resultado -

(12, 34.56, 'abc', 'xyz')

Excluir elementos de tupla

A remoção de elementos individuais da tupla não é possível. É claro que não há nada de errado em juntar outra tupla com os elementos indesejáveis ​​descartados.

Para remover explicitamente uma tupla inteira, basta usar o deldeclaração. Por exemplo -

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : ";
print tup;

Isso produz o seguinte resultado. Observe uma exceção levantada, porque apósdel tup tupla não existe mais -

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print tup;
NameError: name 'tup' is not defined

Operações básicas de tuplas

As tuplas respondem aos operadores + e * da mesma forma que as strings; eles significam concatenação e repetição aqui também, exceto que o resultado é uma nova tupla, não uma string.

Na verdade, as tuplas respondem a todas as operações gerais de sequência que usamos em strings no capítulo anterior -

Expressão Python	Resultados	Descrição
len ((1, 2, 3))	3	comprimento
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Concatenação
('Olá!',) * 4	('Oi!', 'Oi!', 'Oi!', 'Oi!')	Repetição
3 in (1, 2, 3)	Verdadeiro	Filiação
para x em (1, 2, 3): imprimir x,	1 2 3	Iteração

Indexação, divisão e matrizes

Como as tuplas são sequências, a indexação e o fracionamento funcionam para tuplas da mesma maneira que para strings. Assumindo a seguinte entrada -

L = ('spam', 'Spam', 'SPAM!')

 

Expressão Python	Resultados	Descrição
L [2]	'SPAM!'	Os deslocamentos começam em zero
L [-2]	'Spam'	Negativo: contar da direita
L [1:]	['Spam', 'SPAM!']	Fatiar busca seções

Sem delimitadores envolventes

Qualquer conjunto de vários objetos, separados por vírgulas, escritos sem símbolos de identificação, ou seja, colchetes para listas, parênteses para tuplas, etc., padrão para tuplas, conforme indicado nestes exemplos curtos -

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

Quando o código acima é executado, ele produz o seguinte resultado -

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

Funções de tupla integradas

Python inclui as seguintes funções de tupla -

Sr. Não.	Função com Descrição
1	cmp (tupla1, tupla2) Compara elementos de ambas as tuplas.
2	len (tupla) Fornece o comprimento total da tupla.
3	max (tupla) Retorna o item da tupla com valor máximo.
4	min (tupla) Retorna o item da tupla com valor mínimo.
5	tupla (seq) Converte uma lista em tupla.

Cada chave é separada de seu valor por dois pontos (:), os itens são separados por vírgulas e tudo está entre colchetes. Um dicionário vazio sem nenhum item é escrito com apenas duas chaves, como este: {}.

As chaves são exclusivas em um dicionário, enquanto os valores podem não ser. Os valores de um dicionário podem ser de qualquer tipo, mas as chaves devem ser de um tipo de dados imutável, como strings, números ou tuplas.

Acessando Valores no Dicionário

Para acessar os elementos do dicionário, você pode usar os familiares colchetes junto com a chave para obter seu valor. A seguir está um exemplo simples -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']

Quando o código acima é executado, ele produz o seguinte resultado -

dict['Name']:  Zara
dict['Age']:  7

Se tentarmos acessar um item de dados com uma chave, que não faz parte do dicionário, obteremos o seguinte erro -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Alice']: ", dict['Alice']

Quando o código acima é executado, ele produz o seguinte resultado -

dict['Alice']:
Traceback (most recent call last):
   File "test.py", line 4, in <module>
      print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

Atualizando Dicionário

Você pode atualizar um dicionário adicionando uma nova entrada ou um par de valores-chave, modificando uma entrada existente ou excluindo uma entrada existente, conforme mostrado abaixo no exemplo simples -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Quando o código acima é executado, ele produz o seguinte resultado -

dict['Age']:  8
dict['School']:  DPS School

Excluir Elementos do Dicionário

Você pode remover elementos individuais do dicionário ou limpar todo o conteúdo de um dicionário. Você também pode excluir o dicionário inteiro em uma única operação.

Para remover explicitamente um dicionário inteiro, basta usar o deldeclaração. A seguir está um exemplo simples -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name']; # remove entry with key 'Name'
dict.clear();     # remove all entries in dict
del dict ;        # delete entire dictionary

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Isso produz o seguinte resultado. Observe que uma exceção é levantada porque apósdel dict dicionário não existe mais -

dict['Age']:
Traceback (most recent call last):
   File "test.py", line 8, in <module>
      print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

Note - O método del () é discutido na seção subsequente.

Propriedades das chaves do dicionário

Os valores do dicionário não têm restrições. Eles podem ser qualquer objeto Python arbitrário, tanto objetos padrão quanto objetos definidos pelo usuário. No entanto, o mesmo não é verdade para as chaves.

Existem dois pontos importantes a serem lembrados sobre as chaves do dicionário -

(a)Mais de uma entrada por chave não permitida. O que significa que nenhuma chave duplicada é permitida. Quando chaves duplicadas são encontradas durante a atribuição, a última atribuição vence. Por exemplo -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print "dict['Name']: ", dict['Name']

Quando o código acima é executado, ele produz o seguinte resultado -

dict['Name']:  Manni

(b)As chaves devem ser imutáveis. O que significa que você pode usar strings, números ou tuplas como chaves de dicionário, mas algo como ['chave'] não é permitido. A seguir está um exemplo simples -

#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']

Quando o código acima é executado, ele produz o seguinte resultado -

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {['Name']: 'Zara', 'Age': 7};
TypeError: unhashable type: 'list'

Funções e métodos de dicionário integrados

Python inclui as seguintes funções de dicionário -

Sr. Não.	Função com Descrição
1	cmp (dict1, dict2) Compara elementos de ambos os dict.
2	len (dict) Fornece o comprimento total do dicionário. Isso seria igual ao número de itens no dicionário.
3	str (dict) Produz uma representação de string para impressão de um dicionário
4	tipo (variável) Retorna o tipo da variável passada. Se a variável passada for um dicionário, ela retornará um tipo de dicionário.

Python inclui os seguintes métodos de dicionário -

Sr. Não.	Métodos com Descrição
1	dict.clear () Remove todos os elementos do dicionário dict
2	dict.copy () Retorna uma cópia superficial do dicionário dict
3	dict.fromkeys () Crie um novo dicionário com as chaves de seq e os valores definidos como valor .
4	dict.get (chave, padrão = Nenhum) Para a chave da chave, retorna o valor ou padrão se a chave não estiver no dicionário
5	dict.has_key (chave) Retorna verdadeiro se chave no dicionário dict , falso caso contrário
6	dict.items () Retorna uma lista de pares de tupla de dict (chave, valor)
7	dict.keys () Retorna a lista das chaves do dicionário
8	dict.setdefault (chave, padrão = Nenhum) Semelhante a get (), mas irá definir dict [key] = default se a chave ainda não estiver em dict
9	dict.update (dict2) Adiciona pares de valores-chave do dicionário dict2 a dict
10	dict.values ​​() Retorna a lista de dicionário dict valores 's

Um programa Python pode lidar com data e hora de várias maneiras. Converter entre formatos de data é uma tarefa comum para computadores. Os módulos de tempo e calendário do Python ajudam a rastrear datas e horas.

O que é o Tick?

Os intervalos de tempo são números de ponto flutuante em unidades de segundos. Instantes específicos no tempo são expressos em segundos desde 00:00:00 horas de 1º de janeiro de 1970 (época).

Há um popular timeMódulo disponível em Python que fornece funções para trabalhar com tempos e para converter entre representações. A função time.time () retorna a hora atual do sistema em tiques desde 00:00:00 horas de 1º de janeiro de 1970 (época).

Exemplo

#!/usr/bin/python
import time;  # This is required to include time module.

ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

Isso produziria um resultado como o seguinte -

Number of ticks since 12:00am, January 1, 1970: 7186862.73399

A aritmética de datas é fácil de fazer com carrapatos. No entanto, datas anteriores à época não podem ser representadas neste formulário. Datas em um futuro distante também não podem ser representadas dessa forma - o ponto de corte é em algum momento em 2038 para UNIX e Windows.

O que é TimeTuple?

Muitas das funções de tempo do Python lidam com o tempo como uma tupla de 9 números, conforme mostrado abaixo -

Índice	Campo	Valores
0	Ano de 4 dígitos	2008
1	Mês	1 a 12
2	Dia	1 a 31
3	Hora	0 a 23
4	Minuto	0 a 59
5	Segundo	0 a 61 (60 ou 61 são segundos bissextos)
6	Dia da semana	0 a 6 (0 é segunda-feira)
7	Dia do ano	1 a 366 (dia juliano)
8	Horário de verão	-1, 0, 1, -1 significa que a biblioteca determina DST

A tupla acima é equivalente a struct_timeestrutura. Esta estrutura possui os seguintes atributos -

Índice	Atributos	Valores
0	tm_year	2008
1	tm_mon	1 a 12
2	tm_mday	1 a 31
3	tm_hour	0 a 23
4	tm_min	0 a 59
5	tm_sec	0 a 61 (60 ou 61 são segundos bissextos)
6	tm_wday	0 a 6 (0 é segunda-feira)
7	tm_yday	1 a 366 (dia juliano)
8	tm_isdst	-1, 0, 1, -1 significa que a biblioteca determina DST

Obtendo a hora atual

Para traduzir um instante de tempo de segundos desde o valor de ponto flutuante de época em uma tupla de tempo, passe o valor de ponto flutuante para uma função (por exemplo, localtime) que retorna uma tupla de tempo com todos os nove itens válidos.

#!/usr/bin/python
import time;

localtime = time.localtime(time.time())
print "Local current time :", localtime

Isso produziria o seguinte resultado, que poderia ser formatado em qualquer outra forma apresentável -

Local current time : time.struct_time(tm_year=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Obtendo tempo formatado

Você pode formatar a qualquer hora conforme sua necessidade, mas o método simples para obter a hora em um formato legível é asctime () -

#!/usr/bin/python
import time;

localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

Isso produziria o seguinte resultado -

Local current time : Tue Jan 13 10:17:09 2009

Obtendo calendário por um mês

O módulo de calendário oferece uma ampla gama de métodos para jogar com calendários anuais e mensais. Aqui, imprimimos um calendário para um determinado mês (janeiro de 2008) -

#!/usr/bin/python
import calendar

cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

Isso produziria o seguinte resultado -

Here is the calendar:
   January 2008
Mo Tu We Th Fr Sa Su
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

O Módulo de Tempo

Há um popular timemódulo disponível em Python que fornece funções para trabalhar com tempos e para converter entre representações. Aqui está a lista de todos os métodos disponíveis -

Sr. Não.	Função com Descrição
1	time.altzone O deslocamento do fuso horário DST local, em segundos a oeste do UTC, se houver um definido. Isso é negativo se o fuso horário local do DST estiver a leste do UTC (como na Europa Ocidental, incluindo o Reino Unido). Use somente se a luz do dia for diferente de zero.
2	time.asctime ([tupletime]) Aceita uma tupla de tempo e retorna uma string legível de 24 caracteres, como 'Tue Dez 11 18:07:14 2008'.
3	Rélogio de ponto( ) Retorna o tempo de CPU atual como um número de segundos de ponto flutuante. Para medir os custos computacionais de diferentes abordagens, o valor de time.clock é mais útil do que time.time ().
4	time.ctime ([segs]) Como asctime (localtime (secs)) e sem argumentos é como asctime ()
5	time.gmtime ([segs]) Aceita um instante expresso em segundos desde a época e retorna uma tupla de tempo t com a hora UTC. Nota: t.tm_isdst é sempre 0
6	time.localtime ([segs]) Aceita um instante expresso em segundos desde a época e retorna uma tupla de tempo t com a hora local (t.tm_isdst é 0 ou 1, dependendo se o DST se aplica a segundos instantâneos pelas regras locais).
7	time.mktime (tupletime) Aceita um instante expresso como uma tupla de tempo no horário local e retorna um valor de ponto flutuante com o instante expresso em segundos desde a época.
8	tempo.sono (segundos) Suspende o thread de chamada por segundos e segundos.
9	time.strftime (fmt [, tupletime]) Aceita um instante expresso como uma tupla de tempo no horário local e retorna uma string que representa o instante, conforme especificado pela string fmt.
10	time.strptime (str, fmt = '% a% b% d% H:% M:% S% Y') Analisa str de acordo com a string de formato fmt e retorna o instante no formato de tupla de tempo.
11	time.time () Retorna o instante de tempo atual, um número de segundos de ponto flutuante desde a época.
12	time.tzset () Redefine as regras de conversão de tempo usadas pelas rotinas da biblioteca. A variável de ambiente TZ especifica como isso é feito.

Vamos examinar as funções brevemente -

Existem dois atributos importantes disponíveis com o módulo de tempo -

Sr. Não.	Atributo com Descrição
1	time.timezone O atributo time.timezone é a diferença em segundos do fuso horário local (sem DST) do UTC (> 0 nas Américas; <= 0 na maior parte da Europa, Ásia, África).
2	time.tzname O atributo time.tzname é um par de strings dependentes da localidade, que são os nomes do fuso horário local sem e com DST, respectivamente.

O Módulo Calendário

O módulo de calendário fornece funções relacionadas ao calendário, incluindo funções para imprimir um calendário de texto para um determinado mês ou ano.

Por padrão, o calendário considera a segunda-feira como o primeiro dia da semana e o domingo como o último. Para alterar isso, chame a função calendar.setfirstweekday ().

Aqui está uma lista de funções disponíveis com o módulo de calendário -

Sr. Não.	Função com Descrição
1	calendar.calendar(year,w=2,l=1,c=6) Retorna uma string multilinha com um calendário para ano ano formatado em três colunas separadas por c espaços. w é a largura em caracteres de cada data; cada linha tem comprimento 21 * w + 18 + 2 * c. l é o número de linhas para cada semana.
2	calendar.firstweekday( ) Retorna a configuração atual para o dia da semana que começa cada semana. Por padrão, quando o calendário é importado pela primeira vez, é 0, significando segunda-feira.
3	calendar.isleap(year) Retorna True se o ano for um ano bissexto; caso contrário, False.
4	calendar.leapdays(y1,y2) Retorna o número total de dias bissextos nos anos dentro do intervalo (y1, y2).
5	calendar.month(year,month,w=2,l=1) Retorna uma string multilinha com um calendário para mês, mês, ano, ano, uma linha por semana mais duas linhas de cabeçalho. w é a largura em caracteres de cada data; cada linha tem comprimento 7 * w + 6. l é o número de linhas para cada semana.
6	calendar.monthcalendar(year,month) Retorna uma lista de listas de ints. Cada sublista denota uma semana. Os dias fora do mês do ano do ano são definidos como 0; os dias do mês são definidos como o dia do mês, 1 e acima.
7	calendar.monthrange(year,month) Retorna dois inteiros. O primeiro é o código do dia da semana para o primeiro dia do mês mês no ano ano; o segundo é o número de dias do mês. Os códigos dos dias da semana são 0 (segunda-feira) a 6 (domingo); os números dos meses são de 1 a 12.
8	calendar.prcal(year,w=2,l=1,c=6) Como imprimir calendar.calendar (ano, w, l, c).
9	calendar.prmonth(year,month,w=2,l=1) Como imprimir calendar.month (year, month, w, l).
10	calendar.setfirstweekday(weekday) Define o primeiro dia de cada semana como dia da semana de código de dia da semana. Os códigos dos dias da semana são 0 (segunda-feira) a 6 (domingo).
11	calendar.timegm(tupletime) O inverso de time.gmtime: aceita um instante de tempo na forma de tupla de tempo e retorna o mesmo instante como um número de ponto flutuante de segundos desde a época.
12	calendar.weekday(year,month,day) Retorna o código do dia da semana para a data fornecida. Os códigos dos dias da semana são 0 (segunda-feira) a 6 (domingo); os números dos meses vão de 1 (janeiro) a 12 (dezembro).

Outros Módulos e Funções

Se estiver interessado, aqui você encontrará uma lista de outros módulos e funções importantes para brincar com data e hora em Python -

• O Módulo datetime

• O Módulo pytz

• O Módulo dateutil

Uma função é um bloco de código organizado e reutilizável que é usado para realizar uma única ação relacionada. As funções fornecem melhor modularidade para seu aplicativo e um alto grau de reutilização de código.

Como você já sabe, Python oferece muitas funções integradas, como print (), etc., mas você também pode criar suas próprias funções. Essas funções são chamadas de funções definidas pelo usuário.

Definindo uma função

Você pode definir funções para fornecer a funcionalidade necessária. Aqui estão regras simples para definir uma função em Python.

• Os blocos de função começam com a palavra-chave def seguido pelo nome da função e parênteses (()).

• Quaisquer parâmetros de entrada ou argumentos devem ser colocados entre parênteses. Você também pode definir parâmetros dentro desses parênteses.

• A primeira instrução de uma função pode ser uma instrução opcional - a string de documentação da função ou docstring .

• O bloco de código em cada função começa com dois pontos (:) e é indentado.

• A instrução return [expression] sai de uma função, opcionalmente, passando de volta uma expressão para o chamador. Uma instrução de retorno sem argumentos é igual a return None.

Sintaxe

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Por padrão, os parâmetros possuem um comportamento posicional e é necessário informá-los na mesma ordem em que foram definidos.

Exemplo

A função a seguir pega uma string como parâmetro de entrada e a imprime na tela padrão.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Chamando uma função

Definir uma função apenas lhe dá um nome, especifica os parâmetros que devem ser incluídos na função e estrutura os blocos de código.

Depois que a estrutura básica de uma função é finalizada, você pode executá-la chamando-a de outra função ou diretamente do prompt do Python. A seguir está o exemplo para chamar a função printme () -

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Quando o código acima é executado, ele produz o seguinte resultado -

I'm first call to user defined function!
Again second call to the same function

Passe por referência vs valor

Todos os parâmetros (argumentos) na linguagem Python são passados ​​por referência. Isso significa que se você alterar a que um parâmetro se refere dentro de uma função, a alteração também se refletirá na função de chamada. Por exemplo -

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Aqui, estamos mantendo a referência do objeto passado e acrescentando valores no mesmo objeto. Então, isso produziria o seguinte resultado -

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

Há mais um exemplo em que o argumento está sendo passado por referência e a referência está sendo substituída dentro da função chamada.

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

O parâmetro mylist é local para a função changeme. Alterar minha lista dentro da função não afeta minha lista . A função não realiza nada e, finalmente, isso produziria o seguinte resultado -

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

Argumentos de função

Você pode chamar uma função usando os seguintes tipos de argumentos formais -

• Argumentos necessários
• Argumentos de palavras-chave
• Argumentos padrão
• Argumentos de comprimento variável

Argumentos necessários

Os argumentos necessários são os argumentos passados ​​para uma função na ordem posicional correta. Aqui, o número de argumentos na chamada da função deve corresponder exatamente à definição da função.

Para chamar a função printme () , você definitivamente precisa passar um argumento, caso contrário, ocorrerá um erro de sintaxe da seguinte forma -

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme()

Quando o código acima é executado, ele produz o seguinte resultado -

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Argumentos de palavras-chave

Os argumentos de palavra-chave estão relacionados às chamadas de função. Quando você usa argumentos de palavra-chave em uma chamada de função, o chamador identifica os argumentos pelo nome do parâmetro.

Isso permite pular argumentos ou colocá-los fora de ordem porque o interpretador Python pode usar as palavras-chave fornecidas para combinar os valores com os parâmetros. Você também pode fazer chamadas de palavras-chave para a função printme () das seguintes maneiras -

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme( str = "My string")

Quando o código acima é executado, ele produz o seguinte resultado -

My string

O exemplo a seguir fornece uma imagem mais clara. Observe que a ordem dos parâmetros não importa.

#!/usr/bin/python

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )

Quando o código acima é executado, ele produz o seguinte resultado -

Name:  miki
Age  50

Argumentos padrão

Um argumento padrão é um argumento que assume um valor padrão se um valor não for fornecido na chamada de função para esse argumento. O exemplo a seguir dá uma ideia sobre os argumentos padrão, ele imprime a idade padrão se não for passado -

#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Quando o código acima é executado, ele produz o seguinte resultado -

Name:  miki
Age  50
Name:  miki
Age  35

Argumentos de comprimento variável

Você pode precisar processar uma função para mais argumentos do que você especificou ao definir a função. Esses argumentos são chamados de argumentos de comprimento variável e não são nomeados na definição da função, ao contrário dos argumentos obrigatórios e padrão.

A sintaxe para uma função com argumentos variáveis ​​sem palavra-chave é esta -

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

Um asterisco (*) é colocado antes do nome da variável que contém os valores de todos os argumentos de variáveis ​​não-palavra-chave. Essa tupla permanece vazia se nenhum argumento adicional for especificado durante a chamada da função. A seguir está um exemplo simples -

#!/usr/bin/python

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

Quando o código acima é executado, ele produz o seguinte resultado -

Output is:
10
Output is:
70
60
50

As funções anônimas

Essas funções são chamadas de anônimas porque não são declaradas da maneira padrão usando a palavra-chave def . Você pode usar a palavra-chave lambda para criar pequenas funções anônimas.

• As formas lambda podem receber qualquer número de argumentos, mas retornam apenas um valor na forma de uma expressão. Eles não podem conter comandos ou expressões múltiplas.

• Uma função anônima não pode ser uma chamada direta para imprimir porque lambda requer uma expressão

• As funções Lambda têm seu próprio namespace local e não podem acessar variáveis ​​diferentes daquelas em sua lista de parâmetros e aquelas no namespace global.

• Embora pareça que os lambda são uma versão de uma linha de uma função, eles não são equivalentes a instruções embutidas em C ou C ++, cujo propósito é passar a alocação da pilha de funções durante a invocação por motivos de desempenho.

Sintaxe

A sintaxe das funções lambda contém apenas uma única instrução, que é a seguinte -

lambda [arg1 [,arg2,.....argn]]:expression

A seguir está o exemplo para mostrar como a forma lambda da função funciona -

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

Quando o código acima é executado, ele produz o seguinte resultado -

Value of total :  30
Value of total :  40

A declaração de retorno

A instrução return [expression] sai de uma função, opcionalmente, passando de volta uma expressão para o chamador. Uma instrução de retorno sem argumentos é igual a return None.

Todos os exemplos acima não estão retornando nenhum valor. Você pode retornar um valor de uma função da seguinte maneira -

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total

Quando o código acima é executado, ele produz o seguinte resultado -

Inside the function :  30
Outside the function :  30

Escopo das Variáveis

Todas as variáveis ​​em um programa podem não estar acessíveis em todos os locais desse programa. Isso depende de onde você declarou uma variável.

O escopo de uma variável determina a parte do programa onde você pode acessar um identificador específico. Existem dois escopos básicos de variáveis ​​em Python -

• Variáveis ​​globais
• Variáveis ​​locais

Variáveis ​​globais vs. locais

Variáveis ​​que são definidas dentro de um corpo de função têm um escopo local e aquelas definidas fora têm um escopo global.

Isso significa que as variáveis ​​locais podem ser acessadas apenas dentro da função na qual são declaradas, enquanto as variáveis ​​globais podem ser acessadas em todo o corpo do programa por todas as funções. Quando você chama uma função, as variáveis ​​declaradas dentro dela são trazidas para o escopo. A seguir está um exemplo simples -

#!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total

Quando o código acima é executado, ele produz o seguinte resultado -

Inside the function local total :  30
Outside the function global total :  0

Um módulo permite que você organize logicamente seu código Python. O agrupamento do código relacionado em um módulo torna o código mais fácil de entender e usar. Um módulo é um objeto Python com atributos nomeados arbitrariamente que você pode ligar e fazer referência.

Simplesmente, um módulo é um arquivo que consiste em código Python. Um módulo pode definir funções, classes e variáveis. Um módulo também pode incluir código executável.

Exemplo

O código Python para um módulo denominado aname normalmente reside em um arquivo denominado aname.py . Aqui está um exemplo de um módulo simples, support.py

def print_func( par ):
   print "Hello : ", par
   return

A declaração de importação

Você pode usar qualquer arquivo-fonte Python como um módulo, executando uma instrução de importação em algum outro arquivo-fonte Python. A importação tem a seguinte sintaxe -

import module1[, module2[,... moduleN]

Quando o interpretador encontra uma instrução import, ele importa o módulo se o módulo estiver presente no caminho de pesquisa. Um caminho de pesquisa é uma lista de diretórios que o intérprete pesquisa antes de importar um módulo. Por exemplo, para importar o módulo support.py, você precisa colocar o seguinte comando no topo do script -

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Quando o código acima é executado, ele produz o seguinte resultado -

Hello : Zara

Um módulo é carregado apenas uma vez, independentemente do número de vezes que é importado. Isso evita que a execução do módulo aconteça repetidamente se ocorrerem várias importações.

A declaração de ... import

A instrução from do Python permite importar atributos específicos de um módulo para o namespace atual. A importação de ... tem a seguinte sintaxe -

from modname import name1[, name2[, ... nameN]]

Por exemplo, para importar a função fibonacci do módulo fib, use a seguinte instrução -

from fib import fibonacci

Esta instrução não importa todo o módulo fib para o namespace atual; ele apenas introduz o item fibonacci do módulo fib na tabela de símbolos global do módulo de importação.

A declaração from ... import *

Também é possível importar todos os nomes de um módulo para o namespace atual usando a seguinte instrução de importação -

from modname import *

Isso fornece uma maneira fácil de importar todos os itens de um módulo para o namespace atual; no entanto, essa instrução deve ser usada com moderação.

Localizando Módulos

Quando você importa um módulo, o interpretador Python procura o módulo nas seguintes sequências -

• O diretório atual.

• Se o módulo não for encontrado, o Python pesquisa cada diretório na variável shell PYTHONPATH.

• Se tudo mais falhar, o Python verifica o caminho padrão. No UNIX, esse caminho padrão é normalmente / usr / local / lib / python /.

O caminho de pesquisa do módulo é armazenado no sistema do módulo do sistema como o sys.pathvariável. A variável sys.path contém o diretório atual, PYTHONPATH, e o padrão dependente da instalação.

A variável PYTHONPATH

O PYTHONPATH é uma variável de ambiente que consiste em uma lista de diretórios. A sintaxe de PYTHONPATH é a mesma da variável shell PATH.

Aqui está um PYTHONPATH típico de um sistema Windows -

set PYTHONPATH = c:\python20\lib;

E aqui está um PYTHONPATH típico de um sistema UNIX -

set PYTHONPATH = /usr/local/lib/python

Namespaces e escopo

Variáveis ​​são nomes (identificadores) que mapeiam para objetos. Um namespace é um dicionário de nomes de variáveis ​​(chaves) e seus objetos correspondentes (valores).

Uma instrução Python pode acessar variáveis ​​em um namespace local e no namespace global . Se uma variável local e uma global tiverem o mesmo nome, a variável local sombreia a variável global.

Cada função tem seu próprio namespace local. Os métodos de classe seguem a mesma regra de escopo das funções comuns.

Python faz suposições fundamentadas sobre se as variáveis ​​são locais ou globais. Ele assume que qualquer variável atribuída a um valor em uma função é local.

Portanto, para atribuir um valor a uma variável global dentro de uma função, você deve primeiro usar a instrução global.

A declaração global VarName informa ao Python que VarName é uma variável global. Python para de pesquisar o namespace local para a variável.

Por exemplo, definimos uma variável Money no namespace global. Dentro da função Money , atribuímos a Money um valor, portanto, Python assume Money como uma variável local. No entanto, acessamos o valor da variável local Money antes de defini-la, portanto, um UnboundLocalError é o resultado. Descomentar a declaração global corrige o problema.

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

A função dir ()

A função interna dir () retorna uma lista classificada de strings contendo os nomes definidos por um módulo.

A lista contém os nomes de todos os módulos, variáveis ​​e funções que são definidas em um módulo. A seguir está um exemplo simples -

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Quando o código acima é executado, ele produz o seguinte resultado -

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Aqui, a variável de string especial __name__ é o nome do módulo e __file__ é o nome do arquivo a partir do qual o módulo foi carregado.

As funções globals () e locals ()

As funções globals () e locals () podem ser usadas para retornar os nomes nos namespaces globais e locais, dependendo do local de onde são chamados.

Se locals () for chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​localmente a partir dessa função.

Se globals () for chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​globalmente a partir dessa função.

O tipo de retorno de ambas as funções é dicionário. Portanto, os nomes podem ser extraídos usando a função keys ().

A recarga () Função

Quando o módulo é importado para um script, o código na parte de nível superior de um módulo é executado apenas uma vez.

Portanto, se você deseja reexecutar o código de nível superior em um módulo, pode usar a função reload () . A função reload () importa um módulo importado anteriormente novamente. A sintaxe da função reload () é esta -

reload(module_name)

Aqui, module_name é o nome do módulo que você deseja recarregar e não a string que contém o nome do módulo. Por exemplo, para recarregar o módulo hello , faça o seguinte -

reload(hello)

Pacotes em Python

Um pacote é uma estrutura de diretório de arquivo hierárquica que define um único ambiente de aplicativo Python que consiste em módulos e subpacotes e subpacotes e assim por diante.

Considere um arquivo Pots.py disponível no diretório Phone . Este arquivo tem a seguinte linha de código-fonte -

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

De forma semelhante, temos outros dois arquivos com funções diferentes com o mesmo nome acima -

• Arquivo Phone / Isdn.py com a função Isdn ()

• Arquivo Phone / G3.py com função G3 ()

Agora, crie mais um arquivo __init__.py no diretório do telefone -

• Phone/__init__.py

Para tornar todas as suas funções disponíveis quando você importou o telefone, você precisa colocar instruções de importação explícitas em __init__.py da seguinte maneira -

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Depois de adicionar essas linhas a __init__.py, você terá todas essas classes disponíveis ao importar o pacote Phone.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Quando o código acima é executado, ele produz o seguinte resultado -

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

No exemplo acima, tomamos o exemplo de uma única função em cada arquivo, mas você pode manter várias funções em seus arquivos. Você também pode definir diferentes classes Python nesses arquivos e, em seguida, criar seus pacotes a partir dessas classes.

Este capítulo cobre todas as funções básicas de I / O disponíveis em Python. Para obter mais funções, consulte a documentação padrão do Python.

Imprimir para a tela

A maneira mais simples de produzir saída é usar a instrução print , onde você pode passar zero ou mais expressões separadas por vírgulas. Esta função converte as expressões que você passa em uma string e grava o resultado na saída padrão da seguinte maneira -

#!/usr/bin/python

print "Python is really a great language,", "isn't it?"

Isso produz o seguinte resultado em sua tela padrão -

Python is really a great language, isn't it?

Ler entrada de teclado

Python fornece duas funções integradas para ler uma linha de texto da entrada padrão, que por padrão vem do teclado. Essas funções são -

• raw_input
• input

A função raw_input

A função raw_input ([prompt]) lê uma linha da entrada padrão e a retorna como uma string (removendo a nova linha final).

#!/usr/bin/python

str = raw_input("Enter your input: ")
print "Received input is : ", str

Isso solicita que você insira qualquer string e a mesma será exibida na tela. Quando digitei "Olá, Python!", Sua saída é assim -

Enter your input: Hello Python
Received input is :  Hello Python

A função de entrada

A função input ([prompt]) é equivalente a raw_input, exceto que assume que a entrada é uma expressão Python válida e retorna o resultado avaliado para você.

#!/usr/bin/python

str = input("Enter your input: ")
print "Received input is : ", str

Isso produziria o seguinte resultado em relação à entrada inserida -

Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is :  [10, 20, 30, 40]

Abrindo e fechando arquivos

Até agora, você leu e gravou na entrada e na saída padrão. Agora, veremos como usar arquivos de dados reais.

Python fornece funções e métodos básicos necessários para manipular arquivos por padrão. Você pode fazer a maior parte da manipulação de arquivos usando umfile objeto.

A função aberta

Antes de ler ou escrever um arquivo, você deve abri-lo usando a função open () embutida do Python . Esta função cria umfile objeto, que seria utilizado para chamar outros métodos de suporte associados a ele.

Sintaxe

file object = open(file_name [, access_mode][, buffering])

Aqui estão os detalhes dos parâmetros -

• file_name - O argumento file_name é um valor de string que contém o nome do arquivo que você deseja acessar.

• access_mode- O access_mode determina o modo em que o arquivo deve ser aberto, ou seja, ler, escrever, anexar, etc. Uma lista completa de valores possíveis é fornecida abaixo na tabela. Este é um parâmetro opcional e o modo de acesso ao arquivo padrão é read (r).

• buffering- Se o valor do buffer for definido como 0, nenhum buffer ocorrerá. Se o valor do buffer for 1, o buffer de linha é executado durante o acesso a um arquivo. Se você especificar o valor de buffer como um número inteiro maior que 1, a ação de buffer é executada com o tamanho de buffer indicado. Se negativo, o tamanho do buffer é o padrão do sistema (comportamento padrão).

Aqui está uma lista dos diferentes modos de abrir um arquivo -

Sr. Não.	Modos e descrição
1	r Abre um arquivo apenas para leitura. O ponteiro do arquivo é colocado no início do arquivo. Este é o modo padrão.
2	rb Abre um arquivo para leitura apenas em formato binário. O ponteiro do arquivo é colocado no início do arquivo. Este é o modo padrão.
3	r+ Abre um arquivo para leitura e gravação. O ponteiro do arquivo colocado no início do arquivo.
4	rb+ Abre um arquivo para leitura e gravação em formato binário. O ponteiro do arquivo colocado no início do arquivo.
5	w Abre um arquivo apenas para gravação. Substitui o arquivo se ele existir. Se o arquivo não existir, cria um novo arquivo para gravação.
6	wb Abre um arquivo para gravação apenas em formato binário. Substitui o arquivo se ele existir. Se o arquivo não existir, cria um novo arquivo para gravação.
7	w+ Abre um arquivo para escrita e leitura. Substitui o arquivo existente se o arquivo existir. Se o arquivo não existir, cria um novo arquivo para leitura e gravação.
8	wb+ Abre um arquivo para gravação e leitura em formato binário. Substitui o arquivo existente se o arquivo existir. Se o arquivo não existir, cria um novo arquivo para leitura e gravação.
9	a Abre um arquivo para anexar. O ponteiro do arquivo está no final do arquivo, se o arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o arquivo não existir, ele cria um novo arquivo para gravação.
10	ab Abre um arquivo para anexar em formato binário. O ponteiro do arquivo está no final do arquivo, se o arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o arquivo não existir, ele cria um novo arquivo para gravação.
11	a+ Abre um arquivo para anexar e ler. O ponteiro do arquivo está no final do arquivo, se o arquivo existir. O arquivo é aberto no modo anexar. Se o arquivo não existir, ele cria um novo arquivo para leitura e gravação.
12	ab+ Abre um arquivo para anexar e ler em formato binário. O ponteiro do arquivo está no final do arquivo, se o arquivo existir. O arquivo é aberto no modo anexar. Se o arquivo não existir, ele cria um novo arquivo para leitura e gravação.

O arquivo Object Attributes

Depois que um arquivo é aberto e você tem um objeto de arquivo , pode obter várias informações relacionadas a esse arquivo.

Aqui está uma lista de todos os atributos relacionados ao objeto de arquivo -

Sr. Não.	Atributo e descrição
1	file.closed Retorna verdadeiro se o arquivo está fechado, falso caso contrário.
2	file.mode Retorna o modo de acesso com o qual o arquivo foi aberto.
3	file.name Retorna o nome do arquivo.
4	file.softspace Retorna falso se o espaço for explicitamente necessário com print, verdadeiro caso contrário.

Exemplo

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name
print "Closed or not : ", fo.closed
print "Opening mode : ", fo.mode
print "Softspace flag : ", fo.softspace

Isso produz o seguinte resultado -

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb
Softspace flag :  0

O método close ()

O método close () de um objeto de arquivo elimina qualquer informação não escrita e fecha o objeto de arquivo, após o qual nenhuma outra gravação pode ser feita.

O Python fecha automaticamente um arquivo quando o objeto de referência de um arquivo é reatribuído a outro arquivo. É uma boa prática usar o método close () para fechar um arquivo.

Sintaxe

fileObject.close()

Exemplo

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name

# Close opend file
fo.close()

Isso produz o seguinte resultado -

Name of the file:  foo.txt

Ler e gravar arquivos

O objeto de arquivo fornece um conjunto de métodos de acesso para tornar nossas vidas mais fáceis. Veríamos como usar os métodos read () e write () para ler e escrever arquivos.

O método write ()

O método write () grava qualquer string em um arquivo aberto. É importante observar que as strings Python podem ter dados binários e não apenas texto.

O método write () não adiciona um caractere de nova linha ('\ n') ao final da string -

Sintaxe

fileObject.write(string)

Aqui, o parâmetro passado é o conteúdo a ser escrito no arquivo aberto.

Exemplo

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

O método acima criaria o arquivo foo.txt e escreveria determinado conteúdo nesse arquivo e, finalmente, fecharia esse arquivo. Se você abrir este arquivo, ele terá o seguinte conteúdo.

Python is a great language.
Yeah its great!!

O read () Método

O método read () lê uma string de um arquivo aberto. É importante observar que as strings Python podem ter dados binários. além de dados de texto.

Sintaxe

fileObject.read([count])

Aqui, o parâmetro passado é o número de bytes a serem lidos do arquivo aberto. Este método inicia a leitura desde o início do arquivo e se não houver contagem , ele tenta ler o máximo possível, talvez até o final do arquivo.

Exemplo

Vamos pegar um arquivo foo.txt , que criamos acima.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend file
fo.close()

Isso produz o seguinte resultado -

Read String is :  Python is

Posições de arquivo

O método tell () informa a posição atual dentro do arquivo; em outras palavras, a próxima leitura ou gravação ocorrerá naquela quantidade de bytes a partir do início do arquivo.

O método de busca (deslocamento [, de]) altera a posição atual do arquivo. O argumento offset indica o número de bytes a serem movidos. O argumento from especifica a posição de referência de onde os bytes devem ser movidos.

Se de for definido como 0, isso significa usar o início do arquivo como a posição de referência e 1 significa usar a posição atual como a posição de referência e se for definido como 2, então o final do arquivo será tomado como a posição de referência .

Exemplo

Vamos pegar um arquivo foo.txt , que criamos acima.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print "Read String is : ", str

# Check current position
position = fo.tell()
print "Current file position : ", position

# Reposition pointer at the beginning once again
position = fo.seek(0, 0);
str = fo.read(10)
print "Again read String is : ", str
# Close opend file
fo.close()

Isso produz o seguinte resultado -

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

Renomeando e Excluindo Arquivos

Pitão os O módulo fornece métodos que ajudam a executar operações de processamento de arquivo, como renomear e excluir arquivos.

Para usar este módulo, você precisa primeiro importá-lo e, em seguida, pode chamar quaisquer funções relacionadas.

O método rename ()

O método rename () leva dois argumentos, o nome do arquivo atual e o novo nome do arquivo.

Sintaxe

os.rename(current_file_name, new_file_name)

Exemplo

A seguir está o exemplo para renomear um arquivo existente test1.txt -

#!/usr/bin/python
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

O método remove ()

Você pode usar o método remove () para excluir arquivos, fornecendo o nome do arquivo a ser excluído como argumento.

Sintaxe

os.remove(file_name)

Exemplo

A seguir está o exemplo para excluir um arquivo existente test2.txt -

#!/usr/bin/python
import os

# Delete file test2.txt
os.remove("text2.txt")

Diretórios em Python

Todos os arquivos estão contidos em vários diretórios, e o Python também não tem problemas em lidar com eles. oos O módulo possui vários métodos que ajudam a criar, remover e alterar diretórios.

O método mkdir ()

Você pode usar o método mkdir () doosmódulo para criar diretórios no diretório atual. Você precisa fornecer um argumento para este método que contém o nome do diretório a ser criado.

Sintaxe

os.mkdir("newdir")

Exemplo

A seguir está o exemplo para criar um teste de diretório no diretório atual -

#!/usr/bin/python
import os

# Create a directory "test"
os.mkdir("test")

O método chdir ()

Você pode usar o método chdir () para alterar o diretório atual. O método chdir () recebe um argumento, que é o nome do diretório que você deseja tornar o diretório atual.

Sintaxe

os.chdir("newdir")

Exemplo

A seguir está o exemplo para ir para o diretório "/ home / newdir" -

#!/usr/bin/python
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

O método getcwd ()

O método getcwd () exibe o diretório de trabalho atual.

Sintaxe

os.getcwd()

Exemplo

A seguir está o exemplo para fornecer o diretório atual -

#!/usr/bin/python
import os

# This would give location of the current directory
os.getcwd()

O método rmdir ()

O método rmdir () exclui o diretório, que é passado como um argumento no método.

Antes de remover um diretório, todo o conteúdo dele deve ser removido.

Sintaxe

os.rmdir('dirname')

Exemplo

A seguir está o exemplo para remover o diretório "/ tmp / test". É necessário fornecer o nome completo do diretório, caso contrário, ele pesquisaria esse diretório no diretório atual.

#!/usr/bin/python
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

Métodos relacionados a arquivos e diretórios

Existem três fontes importantes, que fornecem uma ampla gama de métodos utilitários para manipular e manipular arquivos e diretórios nos sistemas operacionais Windows e Unix. Eles são os seguintes -

• Métodos de objeto de arquivo : O objeto de arquivo fornece funções para manipular arquivos.

• Métodos de objeto do sistema operacional : fornece métodos para processar arquivos e diretórios.

Python fornece dois recursos muito importantes para lidar com qualquer erro inesperado em seus programas Python e adicionar recursos de depuração a eles -

• Exception Handling- Isso seria abordado neste tutorial. Aqui está uma lista de exceções padrão disponíveis em Python: Exceções padrão .

• Assertions- Isso seria abordado no tutorial Asserções no Python .

Lista de exceções padrão -

Sr. Não.	Nome e descrição da exceção
1	Exception Classe base para todas as exceções
2	StopIteration Gerado quando o método next () de um iterador não aponta para nenhum objeto.
3	SystemExit Gerado pela função sys.exit ().
4	StandardError Classe base para todas as exceções integradas, exceto StopIteration e SystemExit.
5	ArithmeticError Classe base para todos os erros que ocorrem no cálculo numérico.
6	OverflowError Gerado quando um cálculo excede o limite máximo para um tipo numérico.
7	FloatingPointError Gerado quando um cálculo de ponto flutuante falha.
8	ZeroDivisionError Gerado quando a divisão ou módulo por zero ocorre para todos os tipos numéricos.
9	AssertionError Gerado em caso de falha da declaração Assert.
10	AttributeError Gerado em caso de falha de referência ou atribuição de atributo.
11	EOFError Gerado quando não há entrada da função raw_input () ou input () e o final do arquivo é alcançado.
12	ImportError Gerado quando uma instrução de importação falha.
13	KeyboardInterrupt Gerado quando o usuário interrompe a execução do programa, geralmente pressionando Ctrl + c.
14	LookupError Classe base para todos os erros de pesquisa.
15	IndexError Gerado quando um índice não é encontrado em uma sequência.
16	KeyError Gerado quando a chave especificada não é encontrada no dicionário.
17	NameError Gerado quando um identificador não é encontrado no namespace local ou global.
18	UnboundLocalError Gerado ao tentar acessar uma variável local em uma função ou método, mas nenhum valor foi atribuído a ela.
19	EnvironmentError Classe base para todas as exceções que ocorrem fora do ambiente Python.
20	IOError Gerado quando uma operação de entrada / saída falha, como a instrução print ou a função open () ao tentar abrir um arquivo que não existe.
21	IOError Gerado para erros relacionados ao sistema operacional.
22	SyntaxError Gerado quando há um erro na sintaxe do Python.
23	IndentationError Gerado quando o recuo não é especificado corretamente.
24	SystemError Gerado quando o interpretador encontra um problema interno, mas quando esse erro é encontrado, o interpretador Python não fecha.
25	SystemExit Gerado quando o interpretador Python é encerrado usando a função sys.exit (). Se não for tratado no código, faz com que o interpretador saia.
26	TypeError Gerado quando uma operação ou função é tentada e inválida para o tipo de dados especificado.
27	ValueError Gerado quando a função interna para um tipo de dados tem o tipo válido de argumentos, mas os argumentos têm valores inválidos especificados.
28	RuntimeError Gerado quando um erro gerado não se enquadra em nenhuma categoria.
29	NotImplementedError Gerado quando um método abstrato que precisa ser implementado em uma classe herdada não é realmente implementado.

Asserções em Python

Uma asserção é uma verificação de integridade que você pode ativar ou desativar quando terminar de testar o programa.

A maneira mais fácil de pensar em uma afirmação é compará-la a um raise-ifdeclaração (ou para ser mais preciso, uma declaração de aumento se não). Uma expressão é testada e, se o resultado for falso, uma exceção é levantada.

As asserções são realizadas pela instrução assert, a palavra-chave mais recente do Python, introduzida na versão 1.5.

Os programadores costumam colocar asserções no início de uma função para verificar se há uma entrada válida e depois de uma chamada de função para verificar se há uma saída válida.

A declaração de afirmação

Ao encontrar uma declaração assert, o Python avalia a expressão que a acompanha, o que é verdade. Se a expressão for falsa, o Python gerará uma exceção AssertionError .

A sintaxe para assert é -

assert Expression[, Arguments]

Se a declaração falhar, Python usará ArgumentExpression como argumento para AssertionError. As exceções AssertionError podem ser capturadas e tratadas como qualquer outra exceção usando a instrução try-except, mas se não forem tratadas, encerrarão o programa e produzirão um rastreamento.

Exemplo

Aqui está uma função que converte uma temperatura de graus Kelvin em graus Fahrenheit. Uma vez que zero graus Kelvin é o mais frio possível, a função falha se vê uma temperatura negativa -

#!/usr/bin/python
def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

Quando o código acima é executado, ele produz o seguinte resultado -

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

O que é exceção?

Uma exceção é um evento que ocorre durante a execução de um programa que interrompe o fluxo normal das instruções do programa. Em geral, quando um script Python encontra uma situação com a qual não pode lidar, ele levanta uma exceção. Uma exceção é um objeto Python que representa um erro.

Quando um script Python levanta uma exceção, ele deve tratar a exceção imediatamente, caso contrário, ele termina e fecha.

Lidando com uma exceção

Se você tiver algum código suspeito que possa gerar uma exceção, você pode defender seu programa colocando o código suspeito em umtry:quadra. Após o bloco try:, inclua umexcept: declaração, seguida por um bloco de código que trata o problema da forma mais elegante possível.

Sintaxe

Aqui está a sintaxe simples de try .... except ... else blocks -

try:
   You do your operations here;
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Aqui estão alguns pontos importantes sobre a sintaxe mencionada acima -

• Uma única instrução try pode ter várias instruções except. Isso é útil quando o bloco try contém instruções que podem lançar diferentes tipos de exceções.

• Você também pode fornecer uma cláusula exceto genérica, que trata de qualquer exceção.

• Após a (s) cláusula (s) except, você pode incluir uma cláusula else. O código no bloco else é executado se o código no bloco try: não gerar uma exceção.

• O bloco else é um bom lugar para código que não precisa da proteção do bloco try :.

Exemplo

Este exemplo abre um arquivo, grava conteúdo no arquivo e sai normalmente porque não há nenhum problema -

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"
   fh.close()

Isso produz o seguinte resultado -

Written content in the file successfully

Exemplo

Este exemplo tenta abrir um arquivo onde você não tem permissão de gravação, por isso levanta uma exceção -

#!/usr/bin/python

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"

Isso produz o seguinte resultado -

Error: can't find file or read data

A cláusula except sem exceções

Você também pode usar a instrução except sem exceções definidas como segue -

try:
   You do your operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Este tipo de try-exceptdeclaração captura todas as exceções que ocorrem. Usar este tipo de instrução try-except não é considerado uma boa prática de programação, porque captura todas as exceções, mas não faz o programador identificar a causa raiz do problema que pode ocorrer.

A cláusula except com múltiplas exceções

Você também pode usar a mesma instrução except para lidar com várias exceções da seguinte forma -

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

A cláusula try-finally

Você pode usar um finally: bloquear junto com um try:quadra. O bloco finally é um local para colocar qualquer código que precise ser executado, independentemente de o bloco try gerar uma exceção ou não. A sintaxe da instrução try-finally é esta -

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Você não pode usar a cláusula else também junto com uma cláusula finally.

Exemplo

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print "Error: can\'t find file or read data"

Se você não tiver permissão para abrir o arquivo no modo de gravação, isso produzirá o seguinte resultado -

Error: can't find file or read data

O mesmo exemplo pode ser escrito de forma mais limpa da seguinte maneira -

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print "Going to close the file"
      fh.close()
except IOError:
   print "Error: can\'t find file or read data"

Quando uma exceção é lançada no bloco try , a execução passa imediatamente para o bloco finally . Depois que todas as instruções no bloco finally são executadas, a exceção é gerada novamente e tratada nas instruções except se presente na próxima camada superior da instrução try-except .

Argumento de uma exceção

Uma exceção pode ter um argumento , que é um valor que fornece informações adicionais sobre o problema. O conteúdo do argumento varia por exceção. Você captura o argumento de uma exceção fornecendo uma variável na cláusula except da seguinte forma -

try:
   You do your operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

Se você escrever o código para tratar uma única exceção, poderá ter uma variável após o nome da exceção na instrução except. Se você estiver capturando várias exceções, poderá fazer com que uma variável siga a tupla da exceção.

Esta variável recebe o valor da exceção contendo principalmente a causa da exceção. A variável pode receber um único valor ou vários valores na forma de uma tupla. Essa tupla geralmente contém a string de erro, o número do erro e uma localização do erro.

Exemplo

A seguir está um exemplo para uma única exceção -

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError, Argument:
      print "The argument does not contain numbers\n", Argument

# Call above function here.
temp_convert("xyz");

Isso produz o seguinte resultado -

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Levantando uma exceção

Você pode levantar exceções de várias maneiras usando a instrução raise. A sintaxe geral para oraise declaração é a seguinte.

Sintaxe

raise [Exception [, args [, traceback]]]

Aqui, Exception é o tipo de exceção (por exemplo, NameError) e argument é um valor para o argumento de exceção. O argumento é opcional; se não for fornecido, o argumento de exceção é Nenhum.

O argumento final, traceback, também é opcional (e raramente usado na prática) e, se presente, é o objeto traceback usado para a exceção.

Exemplo

Uma exceção pode ser uma string, uma classe ou um objeto. A maioria das exceções que o núcleo do Python levanta são classes, com um argumento que é uma instância da classe. Definir novas exceções é muito fácil e pode ser feito da seguinte forma -

def functionName( level ):
   if level < 1:
      raise "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

Note:Para capturar uma exceção, uma cláusula "except" deve referir-se à mesma exceção lançada ou objeto de classe ou string simples. Por exemplo, para capturar a exceção acima, devemos escrever a cláusula except da seguinte forma -

try:
   Business Logic here...
except "Invalid level!":
   Exception handling here...
else:
   Rest of the code here...

Exceções definidas pelo usuário

Python também permite que você crie suas próprias exceções derivando classes das exceções internas padrão.

Aqui está um exemplo relacionado a RuntimeError . Aqui, é criada uma classe que é uma subclasse de RuntimeError . Isso é útil quando você precisa exibir informações mais específicas quando uma exceção é detectada.

No bloco try, a exceção definida pelo usuário é gerada e capturada no bloco except. A variável e é usada para criar uma instância da classe Networkerror .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Assim, depois de definir a classe acima, você pode gerar a exceção da seguinte maneira -

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

Python tem sido uma linguagem orientada a objetos desde que existiu. Por causa disso, criar e usar classes e objetos são extremamente fáceis. Este capítulo ajuda você a se tornar um especialista no uso do suporte de programação orientada a objetos do Python.

Se você não tem nenhuma experiência anterior com programação orientada a objetos (OO), pode consultar um curso introdutório sobre ela ou pelo menos um tutorial de algum tipo para que você tenha uma compreensão dos conceitos básicos.

No entanto, aqui está uma pequena introdução de Programação Orientada a Objetos (OOP) para trazê-lo em velocidade -

Visão geral da terminologia OOP

• Class- Um protótipo definido pelo usuário para um objeto que define um conjunto de atributos que caracterizam qualquer objeto da classe. Os atributos são membros de dados (variáveis ​​de classe e variáveis ​​de instância) e métodos, acessados ​​via notação de ponto.

• Class variable- Uma variável que é compartilhada por todas as instâncias de uma classe. Variáveis ​​de classe são definidas dentro de uma classe, mas fora de qualquer um dos métodos da classe. Variáveis ​​de classe não são usadas com tanta frequência quanto as variáveis ​​de instância.

• Data member - Uma variável de classe ou variável de instância que contém dados associados a uma classe e seus objetos.

• Function overloading- A atribuição de mais de um comportamento a uma função específica. A operação executada varia de acordo com os tipos de objetos ou argumentos envolvidos.

• Instance variable - Uma variável que é definida dentro de um método e pertence apenas à instância atual de uma classe.

• Inheritance - A transferência das características de uma classe para outras classes que dela derivam.

• Instance- Um objeto individual de uma determinada classe. Um objeto obj que pertence a uma classe Circle, por exemplo, é uma instância da classe Circle.

• Instantiation - A criação de uma instância de uma classe.

• Method - Um tipo especial de função que é definido em uma definição de classe.

• Object- Uma instância única de uma estrutura de dados definida por sua classe. Um objeto compreende membros de dados (variáveis ​​de classe e variáveis ​​de instância) e métodos.

• Operator overloading - A atribuição de mais de uma função a um determinado operador.

Criação de classes

A instrução de classe cria uma nova definição de classe. O nome da classe segue imediatamente a palavra-chave class seguida por dois pontos da seguinte forma -

class ClassName:
   'Optional class documentation string'
   class_suite

• A classe tem uma string de documentação, que pode ser acessada via ClassName .__ doc__ .

• O class_suite consiste em todas as instruções do componente que definem os membros da classe, atributos de dados e funções.

Exemplo

A seguir está o exemplo de uma classe Python simples -

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• A variável empCount é uma variável de classe cujo valor é compartilhado entre todas as instâncias desta classe. Isso pode ser acessado como Employee.empCount de dentro ou fora da classe.

• O primeiro método __init __ () é um método especial, que é chamado de construtor de classe ou método de inicialização que o Python chama quando você cria uma nova instância dessa classe.

• Você declara outros métodos de classe como funções normais, com a exceção de que o primeiro argumento para cada método é self . Python adiciona o argumento self à lista para você; você não precisa incluí-lo ao chamar os métodos.

Criação de objetos de instância

Para criar instâncias de uma classe, você chama a classe usando o nome da classe e passa quaisquer argumentos que seu método __init__ aceite.

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

Acessando Atributos

Você acessa os atributos do objeto usando o operador ponto com objeto. A variável de classe seria acessada usando o nome da classe da seguinte forma -

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Agora, juntando todos os conceitos -

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Quando o código acima é executado, ele produz o seguinte resultado -

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Você pode adicionar, remover ou modificar atributos de classes e objetos a qualquer momento -

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

Em vez de usar as instruções normais para acessar atributos, você pode usar as seguintes funções -

• o getattr(obj, name[, default]) - para acessar o atributo do objeto.

• o hasattr(obj,name) - para verificar se um atributo existe ou não.

• o setattr(obj,name,value)- para definir um atributo. Se o atributo não existir, ele será criado.

• o delattr(obj, name) - para excluir um atributo.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

Atributos de classe integrados

Cada classe Python segue os atributos embutidos e eles podem ser acessados ​​usando o operador ponto como qualquer outro atributo -

• __dict__ - Dicionário contendo o namespace da classe.

• __doc__ - String de documentação da classe ou nenhum, se indefinido.

• __name__ - Nome da classe.

• __module__- Nome do módulo no qual a classe é definida. Este atributo é "__main__" no modo interativo.

• __bases__ - Uma tupla possivelmente vazia contendo as classes base, na ordem de sua ocorrência na lista de classes base.

Para a classe acima, vamos tentar acessar todos esses atributos -

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Quando o código acima é executado, ele produz o seguinte resultado -

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

Destruindo objetos (coleta de lixo)

Python exclui objetos desnecessários (tipos internos ou instâncias de classe) automaticamente para liberar o espaço de memória. O processo pelo qual o Python recupera periodicamente blocos de memória que não estão mais em uso é denominado Coleta de Lixo.

O coletor de lixo do Python é executado durante a execução do programa e é disparado quando a contagem de referência de um objeto chega a zero. A contagem de referência de um objeto muda conforme o número de aliases que apontam para ele muda.

A contagem de referência de um objeto aumenta quando ele recebe um novo nome ou é colocado em um contêiner (lista, tupla ou dicionário). A contagem de referência do objeto diminui quando ele é excluído com del , sua referência é reatribuída ou sua referência sai do escopo. Quando a contagem de referência de um objeto chega a zero, o Python a coleta automaticamente.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

Normalmente, você não notará quando o coletor de lixo destrói uma instância órfã e recupera seu espaço. Mas uma classe pode implementar o método especial __del __ () , chamado de destruidor, que é invocado quando a instância está para ser destruída. Este método pode ser usado para limpar quaisquer recursos que não sejam de memória usados ​​por uma instância.

Exemplo

Este destruidor __del __ () imprime o nome da classe de uma instância que está prestes a ser destruída -

#!/usr/bin/python

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3

Quando o código acima é executado, ele produz o seguinte resultado -

3083401324 3083401324 3083401324
Point destroyed

Note- Idealmente, você deve definir suas classes em um arquivo separado, então você deve importá-los em seu arquivo de programa principal usando a instrução de importação .

Herança de classe

Em vez de começar do zero, você pode criar uma classe derivando-a de uma classe preexistente listando a classe pai entre parênteses após o nome da nova classe.

A classe filha herda os atributos de sua classe pai e você pode usar esses atributos como se estivessem definidos na classe filha. Uma classe filha também pode substituir membros de dados e métodos do pai.

Sintaxe

As classes derivadas são declaradas de maneira muito semelhante à classe pai; no entanto, uma lista de classes base para herdar é fornecida após o nome da classe -

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Exemplo

#!/usr/bin/python

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print "Calling parent constructor"

   def parentMethod(self):
      print 'Calling parent method'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print "Calling child constructor"

   def childMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

Quando o código acima é executado, ele produz o seguinte resultado -

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

De maneira semelhante, você pode conduzir uma classe de várias classes pai da seguinte maneira -

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

Você pode usar as funções issubclass () ou isinstance () para verificar os relacionamentos de duas classes e instâncias.

• o issubclass(sub, sup) a função booleana retorna verdadeiro se a subclasse fornecida sub é de fato uma subclasse da superclasse sup.

• o isinstance(obj, Class)a função booleana retorna verdadeiro se obj for uma instância da classe Class ou uma instância de uma subclasse de Class

Métodos de substituição

Você sempre pode substituir seus métodos de classe pai. Uma razão para sobrescrever os métodos parent é porque você pode desejar funcionalidades especiais ou diferentes em sua subclasse.

Exemplo

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Quando o código acima é executado, ele produz o seguinte resultado -

Calling child method

Métodos de sobrecarga de base

A tabela a seguir lista algumas funcionalidades genéricas que você pode substituir em suas próprias classes -

Sr. Não.	Método, descrição e amostra de chamada
1	__init__ ( self [,args...] ) Construtor (com quaisquer argumentos opcionais) Chamada de amostra: obj = className (args)
2	__del__( self ) Destruidor, apaga um objeto Amostra de chamada: del obj
3	__repr__( self ) Representação de string avaliável Chamada de amostra: repr (obj)
4	__str__( self ) Representação de string para impressão Amostra de chamada: str (obj)
5	__cmp__ ( self, x ) Comparação de objetos Chamada de amostra: cmp (obj, x)

Operadores de sobrecarga

Suponha que você tenha criado uma classe Vector para representar vetores bidimensionais, o que acontece quando você usa o operador de adição para adicioná-los? O mais provável é que Python grite com você.

Você poderia, no entanto, definir o método __add__ em sua classe para realizar a adição de vetores e, em seguida, o operador mais se comportaria de acordo com a expectativa -

Exemplo

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

Quando o código acima é executado, ele produz o seguinte resultado -

Vector(7,8)

Ocultação de dados

Os atributos de um objeto podem ou não ser visíveis fora da definição da classe. Você precisa nomear os atributos com um prefixo de sublinhado duplo, e esses atributos não ficarão diretamente visíveis para os de fora.

Exemplo

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

Quando o código acima é executado, ele produz o seguinte resultado -

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python protege esses membros alterando internamente o nome para incluir o nome da classe. Você pode acessar atributos como object._className__attrName . Se você substituir sua última linha como a seguir, isso funcionará para você -

.........................
print counter._JustCounter__secretCount

Quando o código acima é executado, ele produz o seguinte resultado -

1
2
2

Uma expressão regular é uma sequência especial de caracteres que o ajuda a encontrar ou encontrar outras strings ou conjuntos de strings, usando uma sintaxe especializada mantida em um padrão. Expressões regulares são amplamente utilizadas no mundo UNIX.

O módulo refornece suporte completo para expressões regulares semelhantes a Perl em Python. O módulo re levanta a exceção re.error se ocorrer um erro durante a compilação ou o uso de uma expressão regular.

Cobriríamos duas funções importantes, que seriam usadas para lidar com expressões regulares. Mas uma pequena coisa primeiro: Existem vários caracteres, que teriam um significado especial quando usados ​​em expressões regulares. Para evitar qualquer confusão ao lidar com expressões regulares, usaríamos Raw Strings comor'expression'.

A função de correspondência

Esta função tenta corresponder o padrão RE à string com sinalizadores opcionais .

Aqui está a sintaxe para esta função -

re.match(pattern, string, flags=0)

Aqui está a descrição dos parâmetros -

Sr. Não.	Parâmetro e Descrição
1	pattern Esta é a expressão regular a ser correspondida.
2	string Esta é a string, que seria pesquisada para corresponder ao padrão no início da string.
3	flags Você pode especificar sinalizadores diferentes usando OR bit a bit (|). Esses são modificadores, que estão listados na tabela a seguir.

A função re.match retorna ummatch objeto de sucesso, Noneem caso de falha. Usamos a função group (num) ou groups () dematch objeto para obter a expressão correspondente.

Sr. Não.	Método e descrição do objeto de correspondência
1	group(num=0) Este método retorna a correspondência inteira (ou número de subgrupo específico)
2	groups() Este método retorna todos os subgrupos correspondentes em uma tupla (vazio se não houver nenhum)

Exemplo

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

Quando o código acima é executado, ele produz o seguinte resultado -

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

A função de pesquisa

Esta função procura a primeira ocorrência do padrão RE dentro da string com sinalizadores opcionais .

Aqui está a sintaxe para esta função -

re.search(pattern, string, flags=0)

Aqui está a descrição dos parâmetros -

Sr. Não.	Parâmetro e Descrição
1	pattern Esta é a expressão regular a ser correspondida.
2	string Esta é a string, que seria pesquisada para corresponder ao padrão em qualquer lugar da string.
3	flags Você pode especificar sinalizadores diferentes usando OR bit a bit (|). Esses são modificadores, que estão listados na tabela a seguir.

A função re.search retorna ummatch objeto de sucesso, noneem caso de falha. Usamos a função group (num) ou groups () dematch objeto para obter a expressão correspondente.

Sr. Não.	Métodos e descrição do objeto de correspondência
1	group(num=0) Este método retorna a correspondência inteira (ou número de subgrupo específico)
2	groups() Este método retorna todos os subgrupos correspondentes em uma tupla (vazio se não houver nenhum)

Exemplo

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

Quando o código acima é executado, ele produz o seguinte resultado -

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

Correspondência versus pesquisa

Python oferece duas operações primitivas diferentes baseadas em expressões regulares: match verifica se há uma correspondência apenas no início da string, enquanto search verifica se há uma correspondência em qualquer lugar da string (isso é o que Perl faz por padrão).

Exemplo

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

Quando o código acima é executado, ele produz o seguinte resultado -

No match!!
search --> searchObj.group() :  dogs

Pesquisar e substituir

Um dos mais importantes re métodos que usam expressões regulares é sub.

Sintaxe

re.sub(pattern, repl, string, max=0)

Este método substitui todas as ocorrências do padrão RE na string por repl , substituindo todas as ocorrências, a menos que max seja fornecido. Este método retorna uma string modificada.

Exemplo

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Quando o código acima é executado, ele produz o seguinte resultado -

Phone Num :  2004-959-559
Phone Num :  2004959559

Modificadores de expressão regular: sinalizadores de opção

Literais de expressão regular podem incluir um modificador opcional para controlar vários aspectos de correspondência. Os modificadores são especificados como um sinalizador opcional. Você pode fornecer vários modificadores usando OU exclusivo (|), conforme mostrado anteriormente e pode ser representado por um destes -

Sr. Não.	Modificador e descrição
1	re.I Executa correspondência que não diferencia maiúsculas de minúsculas.
2	re.L Interpreta palavras de acordo com o local atual. Essa interpretação afeta o grupo alfabético (\ w e \ W), bem como o comportamento dos limites das palavras (\ b e \ B).
3	re.M Faz $ corresponder ao final de uma linha (não apenas ao final da string) e faz ^ corresponder ao início de qualquer linha (não apenas ao início da string).
4	re.S Faz com que um ponto (ponto) corresponda a qualquer caractere, incluindo uma nova linha.
5	re.U Interpreta letras de acordo com o conjunto de caracteres Unicode. Este sinalizador afeta o comportamento de \ w, \ W, \ b, \ B.
6	re.X Permite uma sintaxe de expressão regular "mais bonita". Ele ignora os espaços em branco (exceto dentro de um conjunto [] ou quando escapado por uma barra invertida) e trata # sem escape como um marcador de comentário.

Padrões de Expressão Regular

Exceto para personagens de controle, (+ ? . * ^ $ ( ) [ ] { } | \), todos os personagens correspondem a si mesmos. Você pode escapar de um caractere de controle precedendo-o com uma barra invertida.

A tabela a seguir lista a sintaxe da expressão regular que está disponível em Python -

Sr. Não.	Padrão e Descrição
1	^ Corresponde ao início da linha.
2	$ Corresponde ao final da linha.
3	. Corresponde a qualquer caractere único, exceto nova linha. Usar a opção m permite que ele corresponda a nova linha também.
4	[...] Corresponde a qualquer caractere único entre colchetes.
5	[^...] Corresponde a qualquer caractere único que não esteja entre colchetes
6	re* Corresponde a 0 ou mais ocorrências da expressão anterior.
7	re+ Corresponde a 1 ou mais ocorrências da expressão anterior.
8	re? Corresponde a 0 ou 1 ocorrência da expressão anterior.
9	re{ n} Corresponde exatamente ao número n de ocorrências da expressão anterior.
10	re{ n,} Corresponde a n ou mais ocorrências da expressão anterior.
11	re{ n, m} Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.
12	a| b Corresponde a a ou b.
13	(re) Agrupa expressões regulares e lembra o texto correspondente.
14	(?imx) Alterna temporariamente as opções i, m ou x em uma expressão regular. Se estiver entre parênteses, apenas essa área é afetada.
15	(?-imx) Desativa temporariamente as opções i, m ou x em uma expressão regular. Se estiver entre parênteses, apenas essa área é afetada.
16	(?: re) Agrupa expressões regulares sem lembrar o texto correspondente.
17	(?imx: re) Alterna temporariamente as opções i, m ou x entre parênteses.
18	(?-imx: re) Desativa temporariamente as opções i, m ou x entre parênteses.
19	(?#...) Comente.
20	(?= re) Especifica a posição usando um padrão. Não tem alcance.
21	(?! re) Especifica a posição usando negação de padrão. Não tem alcance.
22	(?> re) Corresponde ao padrão independente sem retrocesso.
23	\w Corresponde a caracteres de palavras.
24	\W Corresponde a caracteres que não sejam palavras.
25	\s Corresponde ao espaço em branco. Equivalente a [\ t \ n \ r \ f].
26	\S Corresponde a espaços não brancos.
27	\d Corresponde a dígitos. Equivalente a [0-9].
28	\D Corresponde a não dígitos.
29	\A Corresponde ao início da string.
30	\Z Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.
31	\z Corresponde ao final da string.
32	\G As partidas apontam onde a última partida terminou.
33	\b Corresponde aos limites da palavra quando fora dos colchetes. Corresponde ao backspace (0x08) quando entre colchetes.
34	\B Corresponde a limites sem palavras.
35	\n, \t, etc. Corresponde a novas linhas, retornos de carro, guias, etc.
36	\1...\9 Corresponde à enésima subexpressão agrupada.
37	\10 Corresponde à enésima subexpressão agrupada se já tiver correspondido. Caso contrário, refere-se à representação octal de um código de caractere.

Exemplos de expressão regular

Personagens literais

Sr. Não.	Exemplo e descrição
1	python Corresponde a "python".

Classes de personagens

Sr. Não.	Exemplo e descrição
1	[Pp]ython Corresponde a "Python" ou "python"
2	rub[ye] Corresponde a "rubi" ou "rube"
3	[aeiou] Corresponde a qualquer vogal minúscula
4	[0-9] Corresponde a qualquer dígito; igual a [0123456789]
5	[a-z] Corresponde a qualquer letra ASCII minúscula
6	[A-Z] Corresponde a qualquer letra ASCII maiúscula
7	[a-zA-Z0-9] Combine com qualquer uma das opções acima
8	[^aeiou] Corresponder a qualquer coisa que não seja uma vogal minúscula
9	[^0-9] Corresponde a qualquer coisa que não seja um dígito

Classes de personagens especiais

Sr. Não.	Exemplo e descrição
1	. Corresponde a qualquer caractere, exceto nova linha
2	\d Corresponde a um dígito: [0-9]
3	\D Corresponde a um não-dígito: [^ 0-9]
4	\s Corresponde a um caractere de espaço em branco: [\ t \ r \ n \ f]
5	\S Corresponder a espaços não-brancos: [^ \ t \ r \ n \ f]
6	\w Corresponde a um caractere de palavra única: [A-Za-z0-9_]
7	\W Corresponde a um caractere diferente de palavra: [^ A-Za-z0-9_]

Casos de Repetição

Sr. Não.	Exemplo e descrição
1	ruby? Corresponde a "rub" ou "ruby": o y é opcional
2	ruby* Corresponde a "esfregar" mais 0 ou mais ys
3	ruby+ Corresponde a "esfregar" mais 1 ou mais ys
4	\d{3} Corresponde exatamente a 3 dígitos
5	\d{3,} Corresponde 3 ou mais dígitos
6	\d{3,5} Corresponder 3, 4 ou 5 dígitos

Repetição nada repetitiva

Isso corresponde ao menor número de repetições -

Sr. Não.	Exemplo e descrição
1	<.*> Repetição gananciosa: corresponde a "<python> perl>"
2	<.*?> Nongreedy: corresponde a "<python>" em "<python> perl>"

Agrupando com parênteses

Sr. Não.	Exemplo e descrição
1	\D\d+ Nenhum grupo: + repete-se \ d
2	(\D\d)+ Agrupado: + repete \ D \ d par
3	([Pp]ython(, )?)+ Corresponde a "Python", "Python, python, python" etc.

Referências anteriores

Isso corresponde a um grupo anteriormente correspondido novamente -

Sr. Não.	Exemplo e descrição
1	([Pp])ython&\1ails Corresponder python e pails ou Python e Pails
2	(['"])[^\1]*\1 String entre aspas simples ou duplas. \ 1 corresponde ao que o primeiro grupo correspondeu. \ 2 corresponde ao que o segundo grupo correspondeu, etc.

Alternativas

Sr. Não.	Exemplo e descrição
1	python|perl Corresponde a "python" ou "perl"
2	rub(y|le)) Corresponde a "rubi" ou "rublo"
3	Python(!+|\?) "Python" seguido por um ou mais! ou um?

Âncoras

Isso precisa especificar a posição de correspondência.

Sr. Não.	Exemplo e descrição
1	^Python Corresponde a "Python" no início de uma string ou linha interna
2	Python$ Corresponde a "Python" no final de uma string ou linha
3	\APython Corresponde a "Python" no início de uma string
4	Python\Z Corresponde a "Python" no final de uma string
5	\bPython\b Corresponde a "Python" em um limite de palavra
6	\brub\B \ B é um limite sem palavras: corresponde a "esfregar" em "rube" e "ruby", mas não sozinho
7	Python(?=!) Corresponde a "Python", se seguido por um ponto de exclamação.
8	Python(?!!) Corresponde a "Python", se não for seguido por um ponto de exclamação.

Sintaxe especial com parênteses

Sr. Não.	Exemplo e descrição
1	R(?#comment) Corresponde a "R". Todo o resto é um comentário
2	R(?i)uby Não diferencia maiúsculas de minúsculas enquanto corresponde a "uby"
3	R(?i:uby) O mesmo que acima
4	rub(?:y|le)) Grupo apenas sem criar \ 1 referência anterior

A Common Gateway Interface, ou CGI, é um conjunto de padrões que definem como as informações são trocadas entre o servidor da web e um script personalizado. As especificações CGI são mantidas atualmente pela NCSA.

O que é CGI?

• A Common Gateway Interface, ou CGI, é um padrão para programas de gateway externo fazerem interface com servidores de informações, como servidores HTTP.

• A versão atual é CGI / 1.1 e CGI / 1.2 está em andamento.

Navegação na web

Para entender o conceito de CGI, vejamos o que acontece quando clicamos em um hiperlink para navegar em uma determinada página da web ou URL.

• Seu navegador entra em contato com o servidor da web HTTP e exige a URL, ou seja, o nome do arquivo.

• O servidor da Web analisa o URL e procura o nome do arquivo. Se ele encontrar o arquivo, o enviará de volta ao navegador; caso contrário, enviará uma mensagem de erro indicando que você solicitou um arquivo errado.

• O navegador da Web obtém a resposta do servidor da Web e exibe o arquivo recebido ou a mensagem de erro.

No entanto, é possível configurar o servidor HTTP de forma que sempre que um arquivo em um determinado diretório for solicitado esse arquivo não seja enviado de volta; em vez disso, ele é executado como um programa, e tudo o que esse programa produz é enviado de volta para seu navegador exibir. Esta função é chamada de Common Gateway Interface ou CGI e os programas são chamados de scripts CGI. Esses programas CGI podem ser um Python Script, PERL Script, Shell Script, programa C ou C ++, etc.

Diagrama de Arquitetura CGI

Suporte e configuração de servidor web

Antes de prosseguir com a Programação CGI, certifique-se de que seu servidor da Web suporta CGI e está configurado para lidar com programas CGI. Todos os programas CGI a serem executados pelo servidor HTTP são mantidos em um diretório pré-configurado. Esse diretório é denominado Diretório CGI e, por convenção, é denominado / var / www / cgi-bin. Por convenção, os arquivos CGI têm extensão como.cgi, mas você pode manter seus arquivos com a extensão python .py também.

Por padrão, o servidor Linux é configurado para executar apenas os scripts no diretório cgi-bin em / var / www. Se você deseja especificar qualquer outro diretório para executar seus scripts CGI, comente as seguintes linhas no arquivo httpd.conf -

<Directory "/var/www/cgi-bin">
   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all
</Directory>

<Directory "/var/www/cgi-bin">
Options All
</Directory>

Aqui, presumimos que você tenha o servidor da Web instalado e funcionando com êxito e seja capaz de executar qualquer outro programa CGI como Perl ou Shell, etc.

Primeiro Programa CGI

Aqui está um link simples, que está vinculado a um script CGI chamado hello.py . Este arquivo é mantido no diretório / var / www / cgi-bin e possui o seguinte conteúdo. Antes de executar seu programa CGI, certifique-se de alterar o modo de arquivo usandochmod 755 hello.py Comando do UNIX para tornar o arquivo executável.

#!/usr/bin/python

print "Content-type:text/html\r\n\r\n"
print '<html>'
print '<head>'
print '<title>Hello World - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello World! This is my first CGI program</h2>'
print '</body>'
print '</html>'

Se você clicar em hello.py, isso produzirá a seguinte saída -

Olá Mundo! Este é o meu primeiro programa CGI

Este script hello.py é um script Python simples, que grava sua saída no arquivo STDOUT, ou seja, na tela. Há um recurso importante e extra disponível que é a primeira linha a ser impressaContent-type:text/html\r\n\r\n. Essa linha é enviada de volta ao navegador e especifica o tipo de conteúdo a ser exibido na tela do navegador.

Agora você deve ter entendido o conceito básico de CGI e pode escrever muitos programas CGI complicados usando Python. Este script pode interagir com qualquer outro sistema externo também para trocar informações como RDBMS.

Cabeçalho HTTP

A linha Content-type:text/html\r\n\r\nfaz parte do cabeçalho HTTP que é enviado ao navegador para entender o conteúdo. Todo o cabeçalho HTTP estará no seguinte formato -

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

Existem alguns outros cabeçalhos HTTP importantes, que você usará com freqüência em sua programação CGI.

Sr. Não.	Cabeçalho e Descrição
1	Content-type: Uma string MIME que define o formato do arquivo que está sendo retornado. O exemplo é Content-type: text / html
2	Expires: Date A data em que a informação se torna inválida. Ele é usado pelo navegador para decidir quando uma página precisa ser atualizada. Uma string de data válida está no formato 01 de janeiro de 1998 12:00:00 GMT.
3	Location: URL O URL que é retornado em vez do URL solicitado. Você pode usar este campo para redirecionar uma solicitação para qualquer arquivo.
4	Last-modified: Date A data da última modificação do recurso.
5	Content-length: N O comprimento, em bytes, dos dados que estão sendo retornados. O navegador usa esse valor para relatar o tempo estimado de download de um arquivo.
6	Set-Cookie: String Defina o cookie passado pela string

Variáveis ​​de ambiente CGI

Todos os programas CGI têm acesso às seguintes variáveis ​​de ambiente. Essas variáveis ​​desempenham um papel importante ao escrever qualquer programa CGI.

Sr. Não.	Nome e descrição da variável
1	CONTENT_TYPE O tipo de dados do conteúdo. Usado quando o cliente está enviando conteúdo anexado ao servidor. Por exemplo, upload de arquivo.
2	CONTENT_LENGTH O comprimento das informações da consulta. Ele está disponível apenas para solicitações POST.
3	HTTP_COOKIE Retorna os cookies definidos na forma de par chave e valor.
4	HTTP_USER_AGENT O campo de cabeçalho de solicitação do Agente do Usuário contém informações sobre o agente do usuário que originou a solicitação. É o nome do navegador da web.
5	PATH_INFO O caminho para o script CGI.
6	QUERY_STRING As informações codificadas por URL que são enviadas com a solicitação do método GET.
7	REMOTE_ADDR O endereço IP do host remoto que está fazendo a solicitação. Este é um registro útil ou para autenticação.
8	REMOTE_HOST O nome totalmente qualificado do host que está fazendo a solicitação. Se esta informação não estiver disponível, REMOTE_ADDR pode ser usado para obter o endereço de IR.
9	REQUEST_METHOD O método usado para fazer a solicitação. Os métodos mais comuns são GET e POST.
10	SCRIPT_FILENAME O caminho completo para o script CGI.
11	SCRIPT_NAME O nome do script CGI.
12	SERVER_NAME O nome de host ou endereço IP do servidor
13	SERVER_SOFTWARE O nome e a versão do software que o servidor está executando.

Aqui está um pequeno programa CGI para listar todas as variáveis ​​CGI. Clique neste link para ver o resultado Get Environment

#!/usr/bin/python

import os

print "Content-type: text/html\r\n\r\n";
print "<font size=+1>Environment</font><\br>";
for param in os.environ.keys():
   print "<b>%20s</b>: %s<\br>" % (param, os.environ[param])

Métodos GET e POST

Você deve ter se deparado com muitas situações em que precisa passar algumas informações de seu navegador para o servidor da web e, finalmente, para o seu programa CGI. Mais freqüentemente, o navegador usa dois métodos: dois para passar essas informações para o servidor web. Esses métodos são o Método GET e o Método POST.

Passando informações usando o método GET

O método GET envia as informações codificadas do usuário anexadas à solicitação de página. A página e as informações codificadas são separadas por? personagem da seguinte forma -

http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2

O método GET é o método padrão para passar informações do navegador para o servidor da web e produz uma longa string que aparece na caixa Location: do seu navegador. Nunca use o método GET se você tiver uma senha ou outras informações confidenciais para passar para o servidor. O método GET tem limitação de tamanho: apenas 1024 caracteres podem ser enviados em uma string de solicitação. O método GET envia informações usando o cabeçalho QUERY_STRING e estará acessível em seu Programa CGI através da variável de ambiente QUERY_STRING.

Você pode passar informações simplesmente concatenando pares de chave e valor com qualquer URL ou pode usar tags HTML <FORM> para passar informações usando o método GET.

Exemplo de URL simples: Método Get

Aqui está uma URL simples, que passa dois valores para o programa hello_get.py usando o método GET.

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

Abaixo está hello_get.pyscript para lidar com a entrada fornecida pelo navegador da web. Vamos usarcgi módulo, o que torna muito fácil acessar as informações passadas -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Isso geraria o seguinte resultado -

Olá ZARA ALI

Exemplo de FORM Simples: Método GET

Este exemplo passa dois valores usando HTML FORM e botão de envio. Usamos o mesmo script CGI hello_get.py para lidar com essa entrada.

<form action = "/cgi-bin/hello_get.py" method = "get">
First Name: <input type = "text" name = "first_name">  <br />

Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>

Aqui está o resultado real do formulário acima, você insere o nome e o sobrenome e, a seguir, clica no botão enviar para ver o resultado.

Passando informações usando o método POST

Um método geralmente mais confiável de passar informações para um programa CGI é o método POST. Isso empacota as informações exatamente da mesma maneira que os métodos GET, mas em vez de enviá-las como uma string de texto após um? no URL, ele o envia como uma mensagem separada. Esta mensagem chega ao script CGI na forma de entrada padrão.

Abaixo está o mesmo script hello_get.py que lida com o método GET e também o método POST.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Tomemos novamente o mesmo exemplo acima, que passa dois valores usando HTML FORM e o botão enviar. Usamos o mesmo script CGI hello_get.py para lidar com essa entrada.

<form action = "/cgi-bin/hello_get.py" method = "post">
First Name: <input type = "text" name = "first_name"><br />
Last Name: <input type = "text" name = "last_name" />

<input type = "submit" value = "Submit" />
</form>

Aqui está o resultado real do formulário acima. Você insere o nome e o sobrenome e, em seguida, clica no botão enviar para ver o resultado.

Passando os dados da caixa de seleção para o programa CGI

As caixas de seleção são usadas quando mais de uma opção deve ser selecionada.

Aqui está um exemplo de código HTML para um formulário com duas caixas de seleção -

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on" /> Maths
<input type = "checkbox" name = "physics" value = "on" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

O resultado deste código é o seguinte formato -

Abaixo está o script checkbox.cgi para lidar com a entrada fornecida pelo navegador da web para o botão de caixa de seleção.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('maths'):
   math_flag = "ON"
else:
   math_flag = "OFF"

if form.getvalue('physics'):
   physics_flag = "ON"
else:
   physics_flag = "OFF"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"

Passando Dados do Botão de Rádio para o Programa CGI

Os botões de rádio são usados ​​quando apenas uma opção deve ser selecionada.

Aqui está um exemplo de código HTML para um formulário com dois botões de opção -

<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">
<input type = "radio" name = "subject" value = "maths" /> Maths
<input type = "radio" name = "subject" value = "physics" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

O resultado deste código é o seguinte formato -

Abaixo está o script radiobutton.py para lidar com a entrada fornecida pelo navegador da web para o botão de rádio -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('subject'):
   subject = form.getvalue('subject')
else:
   subject = "Not set"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Passando dados da área de texto para o programa CGI

O elemento TEXTAREA é usado quando o texto de várias linhas deve ser passado para o programa CGI.

Aqui está um exemplo de código HTML para um formulário com uma caixa TEXTAREA -

<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">
<textarea name = "textcontent" cols = "40" rows = "4">
Type your text here...
</textarea>
<input type = "submit" value = "Submit" />
</form>

O resultado deste código é o seguinte formato -

Abaixo está o script textarea.cgi para lidar com a entrada fornecida pelo navegador da web -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('textcontent'):
   text_content = form.getvalue('textcontent')
else:
   text_content = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"

Passando os dados da caixa suspensa para o programa CGI

A caixa suspensa é usada quando temos muitas opções disponíveis, mas apenas uma ou duas serão selecionadas.

Aqui está um exemplo de código HTML para um formulário com uma caixa suspensa -

<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit"/>
</form>

O resultado deste código é o seguinte formato -

Abaixo está o script dropdown.py para lidar com a entrada fornecida pelo navegador da web.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('dropdown'):
   subject = form.getvalue('dropdown')
else:
   subject = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Usando Cookies em CGI

O protocolo HTTP é um protocolo sem estado. Para um site comercial, é necessário manter as informações da sessão entre as diferentes páginas. Por exemplo, o registro de um usuário termina após completar muitas páginas. Como manter as informações da sessão do usuário em todas as páginas da web?

Em muitas situações, o uso de cookies é o método mais eficiente de lembrar e rastrear preferências, compras, comissões e outras informações necessárias para uma melhor experiência do visitante ou estatísticas do site.

Como funciona?

Seu servidor envia alguns dados para o navegador do visitante na forma de um cookie. O navegador pode aceitar o cookie. Em caso afirmativo, ele é armazenado como um registro de texto simples no disco rígido do visitante. Agora, quando o visitante chega a outra página do seu site, o cookie fica disponível para recuperação. Uma vez recuperado, seu servidor sabe / lembra o que foi armazenado.

Cookies são um registro de dados de texto simples de 5 campos de comprimento variável -

• Expires- A data em que o cookie irá expirar. Se estiver em branco, o cookie irá expirar quando o visitante sair do navegador.

• Domain - O nome de domínio do seu site.

• Path- O caminho para o diretório ou página da web que define o cookie. Isso pode ficar em branco se você quiser recuperar o cookie de qualquer diretório ou página.

• Secure- Se este campo contiver a palavra "seguro", o cookie só poderá ser recuperado com um servidor seguro. Se este campo estiver em branco, não existe tal restrição.

• Name=Value - Os cookies são definidos e recuperados na forma de pares de chave e valor.

Configurando Cookies

É muito fácil enviar cookies para o navegador. Esses cookies são enviados junto com o cabeçalho HTTP antes do campo Content-type. Presumindo que você deseja definir a ID do usuário e a senha como cookies. A configuração dos cookies é feita da seguinte forma -

#!/usr/bin/python

print "Set-Cookie:UserID = XYZ;\r\n"
print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\r\n"
print "Set-Cookie:Domain = www.tutorialspoint.com;\r\n"
print "Set-Cookie:Path = /perl;\n"
print "Content-type:text/html\r\n\r\n"
...........Rest of the HTML Content....

A partir deste exemplo, você deve ter entendido como definir cookies. Nós usamosSet-Cookie Cabeçalho HTTP para definir cookies.

É opcional definir atributos de cookies como Expires, Domain e Path. É notável que os cookies são definidos antes de enviar a linha mágica"Content-type:text/html\r\n\r\n.

Recuperando Cookies

É muito fácil recuperar todos os cookies configurados. Os cookies são armazenados na variável de ambiente CGI HTTP_COOKIE e terão a seguinte forma -

key1 = value1;key2 = value2;key3 = value3....

Aqui está um exemplo de como recuperar cookies.

#!/usr/bin/python

# Import modules for CGI handling 
from os import environ
import cgi, cgitb

if environ.has_key('HTTP_COOKIE'):
   for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
      (key, value ) = split(cookie, '=');
      if key == "UserID":
         user_id = value

      if key == "Password":
         password = value

print "User ID  = %s" % user_id
print "Password = %s" % password

Isso produz o seguinte resultado para os cookies definidos pelo script acima -

User ID = XYZ
Password = XYZ123

Exemplo de upload de arquivo

Para fazer upload de um arquivo, o formulário HTML deve ter o atributo enctype definido como multipart/form-data. A tag de entrada com o tipo de arquivo cria um botão "Navegar".

<html>
<body>
   <form enctype = "multipart/form-data" 
                     action = "save_file.py" method = "post">
   <p>File: <input type = "file" name = "filename" /></p>
   <p><input type = "submit" value = "Upload" /></p>
   </form>
</body>
</html>

O resultado deste código é o seguinte formato -

O exemplo acima foi desabilitado intencionalmente para salvar pessoas fazendo upload de arquivos em nosso servidor, mas você pode tentar o código acima com seu servidor.

Aqui está o roteiro save_file.py para lidar com o upload de arquivos -

#!/usr/bin/python

import cgi, os
import cgitb; cgitb.enable()

form = cgi.FieldStorage()

# Get filename here.
fileitem = form['filename']

# Test if the file was uploaded
if fileitem.filename:
   # strip leading path from file name to avoid 
   # directory traversal attacks
   fn = os.path.basename(fileitem.filename)
   open('/tmp/' + fn, 'wb').write(fileitem.file.read())

   message = 'The file "' + fn + '" was uploaded successfully'
   
else:
   message = 'No file was uploaded'
   
print """\
Content-Type: text/html\n
<html>
<body>
   <p>%s</p>
</body>
</html>
""" % (message,)

Se você rodar o script acima em Unix / Linux, então você precisa tomar o cuidado de substituir o separador de arquivo como segue, caso contrário, em sua máquina Windows, a instrução open () deve funcionar bem.

fn = os.path.basename(fileitem.filename.replace("\\", "/" ))

Como abrir uma caixa de diálogo "Download de arquivo"?

Às vezes, é desejável que você dê a opção de um usuário clicar em um link e abrir uma caixa de diálogo "Download de arquivo" para o usuário em vez de exibir o conteúdo real. Isso é muito fácil e pode ser feito por meio do cabeçalho HTTP. Este cabeçalho HTTP é diferente do cabeçalho mencionado na seção anterior.

Por exemplo, se você quiser fazer um FileName arquivo para download de um determinado link, então sua sintaxe é a seguinte -

#!/usr/bin/python

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go here.
fo = open("foo.txt", "rb")

str = fo.read();
print str

# Close opend file
fo.close()

Espero que tenha gostado desse tutorial. Em caso afirmativo, envie-me seus comentários em: Fale conosco

O padrão Python para interfaces de banco de dados é o Python DB-API. A maioria das interfaces de banco de dados Python segue esse padrão.

Você pode escolher o banco de dados certo para seu aplicativo. A API de banco de dados Python oferece suporte a uma ampla variedade de servidores de banco de dados, como -

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

Aqui está a lista de interfaces de banco de dados Python disponíveis: Interfaces de banco de dados Python e APIs . Você deve baixar um módulo de API de banco de dados separado para cada banco de dados que você precisa acessar. Por exemplo, se você precisar acessar um banco de dados Oracle, bem como um banco de dados MySQL, deverá fazer download dos módulos de banco de dados Oracle e MySQL.

A API DB fornece um padrão mínimo para trabalhar com bancos de dados usando estruturas e sintaxe Python sempre que possível. Esta API inclui o seguinte -

• Importando o módulo API.
• Adquirindo uma conexão com o banco de dados.
• Emissão de instruções SQL e procedimentos armazenados.
• Fechando a conexão

Aprenderíamos todos os conceitos usando MySQL, então vamos falar sobre o módulo MySQLdb.

O que é MySQLdb?

MySQLdb é uma interface para conexão a um servidor de banco de dados MySQL do Python. Ele implementa a API de banco de dados Python v2.0 e é baseado na API C do MySQL.

Como faço para instalar o MySQLdb?

Antes de prosseguir, certifique-se de ter o MySQLdb instalado em sua máquina. Basta digitar o seguinte em seu script Python e executá-lo -

#!/usr/bin/python

import MySQLdb

Se produzir o seguinte resultado, significa que o módulo MySQLdb não está instalado -

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      import MySQLdb
ImportError: No module named MySQLdb

Para instalar o módulo MySQLdb, use o seguinte comando -

For Ubuntu, use the following command -
$ sudo apt-get install python-pip python-dev libmysqlclient-dev For Fedora, use the following command - $ sudo dnf install python python-devel mysql-devel redhat-rpm-config gcc
For Python command prompt, use the following command -
pip install MySQL-python

Note - Certifique-se de ter privilégios de root para instalar o módulo acima.

Conexão de banco de dados

Antes de se conectar a um banco de dados MySQL, certifique-se do seguinte -

• Você criou um banco de dados TESTDB.

• Você criou uma tabela EMPLOYEE em TESTDB.

• Esta tabela contém os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

• O ID do usuário "testuser" e a senha "test123" são definidos para acessar o TESTDB.

• O módulo Python MySQLdb está instalado corretamente em sua máquina.

• Você passou pelo tutorial do MySQL para entender os fundamentos do MySQL.

Exemplo

A seguir está o exemplo de conexão com o banco de dados MySQL "TESTDB"

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print "Database version : %s " % data

# disconnect from server
db.close()

Ao executar este script, ele está produzindo o seguinte resultado em minha máquina Linux.

Database version : 5.0.45

Se uma conexão for estabelecida com a fonte de dados, um objeto de conexão é retornado e salvo em db para uso posterior, caso contrário dbestá definido como Nenhum. Próximo,db objeto é usado para criar um cursorobjeto, que por sua vez é usado para executar consultas SQL. Por fim, antes de sair, ele garante que a conexão com o banco de dados seja fechada e os recursos liberados.

Criando Tabela de Banco de Dados

Uma vez que uma conexão de banco de dados é estabelecida, estamos prontos para criar tabelas ou registros nas tabelas de banco de dados usando execute método do cursor criado.

Exemplo

Vamos criar a tabela de banco de dados EMPLOYEE -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

Operação INSERT

É necessário quando você deseja criar seus registros em uma tabela de banco de dados.

Exemplo

O exemplo a seguir executa a instrução SQL INSERT para criar um registro na tabela EMPLOYEE -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

O exemplo acima pode ser escrito da seguinte forma para criar consultas SQL dinamicamente -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Exemplo

Seguir segmento de código é outra forma de execução onde você pode passar parâmetros diretamente -

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

Operação READ

Operação READ em qualquer banco de dados significa buscar algumas informações úteis do banco de dados.

Assim que nossa conexão de banco de dados for estabelecida, você estará pronto para fazer uma consulta a este banco de dados. Você pode usar qualquerfetchone() método para buscar um único registro ou fetchall() método para obter vários valores de uma tabela de banco de dados.

• fetchone()- Ele busca a próxima linha de um conjunto de resultados de consulta. Um conjunto de resultados é um objeto que é retornado quando um objeto cursor é usado para consultar uma tabela.

• fetchall()- Ele busca todas as linhas em um conjunto de resultados. Se algumas linhas já foram extraídas do conjunto de resultados, ele recupera as linhas restantes do conjunto de resultados.

• rowcount - Este é um atributo somente leitura e retorna o número de linhas que foram afetadas por um método execute ().

Exemplo

O procedimento a seguir consulta todos os registros da tabela EMPLOYEE com salário superior a 1000 -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
             (fname, lname, age, sex, income )
except:
   print "Error: unable to fecth data"

# disconnect from server
db.close()

Isso produzirá o seguinte resultado -

fname=Mac, lname=Mohan, age=20, sex=M, income=2000

Operação de atualização

ATUALIZAR Operação em qualquer banco de dados significa atualizar um ou mais registros, que já estão disponíveis no banco de dados.

O procedimento a seguir atualiza todos os registros tendo SEXO como 'M'. Aqui, aumentamos a IDADE de todos os homens em um ano.

Exemplo

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Operação DELETE

A operação DELETE é necessária quando você deseja excluir alguns registros de seu banco de dados. A seguir está o procedimento para excluir todos os registros do FUNCIONÁRIO onde AGE é maior que 20 -

Exemplo

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Realizando transações

As transações são um mecanismo que garante a consistência dos dados. As transações têm as seguintes quatro propriedades -

• Atomicity - Ou uma transação é concluída ou nada acontece.

• Consistency - Uma transação deve começar em um estado consistente e deixar o sistema em um estado consistente.

• Isolation - Os resultados intermediários de uma transação não são visíveis fora da transação atual.

• Durability - Depois que uma transação foi confirmada, os efeitos são persistentes, mesmo após uma falha do sistema.

O Python DB API 2.0 fornece dois métodos para confirmar ou reverter uma transação.

Exemplo

Você já sabe como implementar transações. Aqui está novamente um exemplo semelhante -

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

Operação COMMIT

Commit é a operação, que dá um sinal verde ao banco de dados para finalizar as alterações e, após esta operação, nenhuma alteração pode ser revertida.

Aqui está um exemplo simples para chamar commit método.

db.commit()

Operação ROLLBACK

Se você não estiver satisfeito com uma ou mais das mudanças e quiser reverter essas mudanças completamente, use rollback() método.

Aqui está um exemplo simples para chamar rollback() método.

db.rollback()

Desconectando banco de dados

Para desconectar a conexão do banco de dados, use o método close ().

db.close()

Se a conexão com um banco de dados for fechada pelo usuário com o método close (), todas as transações pendentes serão revertidas pelo banco de dados. No entanto, em vez de depender de qualquer um dos detalhes de implementação de nível inferior do banco de dados, seria melhor para seu aplicativo chamar commit ou rollback explicitamente.

Tratamento de erros

Existem muitas fontes de erros. Alguns exemplos são um erro de sintaxe em uma instrução SQL executada, uma falha de conexão ou a chamada do método fetch para um identificador de instrução já cancelado ou concluído.

A API DB define uma série de erros que devem existir em cada módulo do banco de dados. A tabela a seguir lista essas exceções.

Sr. Não.	Exceção e descrição
1	Warning Usado para problemas não fatais. Deve subclasse StandardError.
2	Error Classe base para erros. Deve subclasse StandardError.
3	InterfaceError Usado para erros no módulo de banco de dados, não no próprio banco de dados. Deve subclasse Error.
4	DatabaseError Usado para erros no banco de dados. Deve subclasse Error.
5	DataError Subclasse de DatabaseError que se refere a erros nos dados.
6	OperationalError Subclasse de DatabaseError que se refere a erros como a perda de uma conexão com o banco de dados. Esses erros geralmente estão fora do controle do criador de scripts Python.
7	IntegrityError Subclasse de DatabaseError para situações que danificariam a integridade relacional, como restrições de exclusividade ou chaves estrangeiras.
8	InternalError Subclasse de DatabaseError que se refere a erros internos ao módulo de banco de dados, como um cursor que não está mais ativo.
9	ProgrammingError Subclasse de DatabaseError que se refere a erros como um nome de tabela incorreto e outras coisas que podem ser atribuídas a você com segurança.
10	NotSupportedError Subclasse de DatabaseError que se refere à tentativa de chamar uma funcionalidade sem suporte.

Seus scripts Python devem lidar com esses erros, mas antes de usar qualquer uma das exceções acima, certifique-se de que seu MySQLdb tem suporte para essa exceção. Você pode obter mais informações sobre eles lendo a especificação DB API 2.0.

Python fornece dois níveis de acesso a serviços de rede. Em um nível inferior, você pode acessar o suporte de soquete básico no sistema operacional subjacente, que permite implementar clientes e servidores para protocolos orientados a conexão e sem conexão.

O Python também tem bibliotecas que fornecem acesso de nível superior a protocolos de rede de nível de aplicativo específicos, como FTP, HTTP e assim por diante.

Este capítulo fornece a você uma compreensão do conceito mais famoso em Networking - Socket Programming.

O que é Sockets?

Os soquetes são os terminais de um canal de comunicação bidirecional. Os soquetes podem se comunicar dentro de um processo, entre processos na mesma máquina ou entre processos em continentes diferentes.

Os soquetes podem ser implementados em vários tipos de canais diferentes: soquetes de domínio Unix, TCP, UDP e assim por diante. A biblioteca de soquetes fornece classes específicas para lidar com os transportes comuns, bem como uma interface genérica para lidar com o resto.

Os soquetes têm seu próprio vocabulário -

Sr. Não.	Termo e descrição
1	Domain A família de protocolos usada como mecanismo de transporte. Esses valores são constantes como AF_INET, PF_INET, PF_UNIX, PF_X25 e assim por diante.
2	type O tipo de comunicação entre os dois pontos de extremidade, normalmente SOCK_STREAM para protocolos orientados à conexão e SOCK_DGRAM para protocolos sem conexão.
3	protocol Normalmente zero, isso pode ser usado para identificar uma variante de um protocolo dentro de um domínio e tipo.
4	hostname O identificador de uma interface de rede - Uma string, que pode ser um nome de host, um endereço com quatro pontos ou um endereço IPV6 em notação de dois pontos (e possivelmente de ponto) Uma string "<broadcast>", que especifica um endereço INADDR_BROADCAST. Uma string de comprimento zero, que especifica INADDR_ANY, ou Um número inteiro, interpretado como um endereço binário na ordem de bytes do host.
5	port Cada servidor escuta os clientes chamando em uma ou mais portas. Uma porta pode ser um número de porta Fixnum, uma string contendo um número de porta ou o nome de um serviço.

O Módulo de Soquete

Para criar um socket, você deve usar a função socket.socket () disponível no módulo socket , que tem a sintaxe geral -

s = socket.socket (socket_family, socket_type, protocol=0)

Aqui está a descrição dos parâmetros -

• socket_family - Este é AF_UNIX ou AF_INET, conforme explicado anteriormente.

• socket_type - Este é SOCK_STREAM ou SOCK_DGRAM.

• protocol - Isso geralmente é deixado de fora, com o padrão de 0.

Depois de ter o objeto de soquete , você pode usar as funções necessárias para criar seu programa cliente ou servidor. A seguir está a lista de funções necessárias -

Métodos de soquete de servidor

Sr.No.	Method & Description
1	s.bind() This method binds address (hostname, port number pair) to socket.
2	s.listen() This method sets up and start TCP listener.
3	s.accept() This passively accept TCP client connection, waiting until connection arrives (blocking).

Client Socket Methods

Sr.No.	Method & Description
1	s.connect() This method actively initiates TCP server connection.

General Socket Methods

Sr.No.	Method & Description
1	s.recv() This method receives TCP message
2	s.send() This method transmits TCP message
3	s.recvfrom() This method receives UDP message
4	s.sendto() This method transmits UDP message
5	s.close() This method closes socket
6	socket.gethostname() Returns the hostname.

A Simple Server

To write Internet servers, we use the socket function available in socket module to create a socket object. A socket object is then used to call other functions to setup a socket server.

Now call bind(hostname, port) function to specify a port for your service on the given host.

Next, call the accept method of the returned object. This method waits until a client connects to the port you specified, and then returns a connection object that represents the connection to that client.

#!/usr/bin/python           # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

A Simple Client

Let us write a very simple client program which opens a connection to a given port 12345 and given host. This is very simple to create a socket client using Python's socket module function.

The socket.connect(hosname, port ) opens a TCP connection to hostname on the port. Once you have a socket open, you can read from it like any IO object. When done, remember to close it, as you would close a file.

The following code is a very simple client that connects to a given host and port, reads any available data from the socket, and then exits −

#!/usr/bin/python           # This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close()                  # Close the socket when done

Now run this server.py in background and then run above client.py to see the result.

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

This would produce following result −

Got connection from ('127.0.0.1', 48437)
Thank you for connecting

Python Internet modules

A list of some important modules in Python Network/Internet programming.

Protocol	Common function	Port No	Python module
HTTP	Web pages	80	httplib, urllib, xmlrpclib
NNTP	Usenet news	119	nntplib
FTP	File transfers	20	ftplib, urllib
SMTP	Sending email	25	smtplib
POP3	Fetching email	110	poplib
IMAP4	Fetching email	143	imaplib
Telnet	Command lines	23	telnetlib
Gopher	Document transfers	70	gopherlib, urllib

Please check all the libraries mentioned above to work with FTP, SMTP, POP, and IMAP protocols.

Further Readings

This was a quick start with Socket Programming. It is a vast subject. It is recommended to go through the following link to find more detail −

• Unix Socket Programming.

• Python Socket Library and Modules.

Simple Mail Transfer Protocol (SMTP) is a protocol, which handles sending e-mail and routing e-mail between mail servers.

Python provides smtplib module, which defines an SMTP client session object that can be used to send mail to any Internet machine with an SMTP or ESMTP listener daemon.

Here is a simple syntax to create one SMTP object, which can later be used to send an e-mail −

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

Here is the detail of the parameters −

• host − This is the host running your SMTP server. You can specify IP address of the host or a domain name like tutorialspoint.com. This is optional argument.

• port − If you are providing host argument, then you need to specify a port, where SMTP server is listening. Usually this port would be 25.

• local_hostname − If your SMTP server is running on your local machine, then you can specify just localhost as of this option.

An SMTP object has an instance method called sendmail, which is typically used to do the work of mailing a message. It takes three parameters −

• The sender − A string with the address of the sender.

• The receivers − A list of strings, one for each recipient.

• The message − A message as a string formatted as specified in the various RFCs.

Example

Here is a simple way to send one e-mail using Python script. Try it once −

#!/usr/bin/python

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Here, you have placed a basic e-mail in message, using a triple quote, taking care to format the headers correctly. An e-mail requires a From, To, and Subject header, separated from the body of the e-mail with a blank line.

To send the mail you use smtpObj to connect to the SMTP server on the local machine and then use the sendmail method along with the message, the from address, and the destination address as parameters (even though the from and to addresses are within the e-mail itself, these aren't always used to route mail).

If you are not running an SMTP server on your local machine, you can use smtplib client to communicate with a remote SMTP server. Unless you are using a webmail service (such as Hotmail or Yahoo! Mail), your e-mail provider must have provided you with outgoing mail server details that you can supply them, as follows −

smtplib.SMTP('mail.your-domain.com', 25)

Sending an HTML e-mail using Python

When you send a text message using Python, then all the content are treated as simple text. Even if you include HTML tags in a text message, it is displayed as simple text and HTML tags will not be formatted according to HTML syntax. But Python provides option to send an HTML message as actual HTML message.

While sending an e-mail message, you can specify a Mime version, content type and character set to send an HTML e-mail.

Example

Following is the example to send HTML content as an e-mail. Try it once −

#!/usr/bin/python

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Sending Attachments as an E-mail

To send an e-mail with mixed content requires to set Content-type header to multipart/mixed. Then, text and attachment sections can be specified within boundaries.

A boundary is started with two hyphens followed by a unique number, which cannot appear in the message part of the e-mail. A final boundary denoting the e-mail's final section must also end with two hyphens.

Attached files should be encoded with the pack("m") function to have base64 encoding before transmission.

Example

Following is the example, which sends a file /tmp/test.txt as an attachment. Try it once −

#!/usr/bin/python

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print "Error: unable to send email"

Running several threads is similar to running several different programs concurrently, but with the following benefits −

• Multiple threads within a process share the same data space with the main thread and can therefore share information or communicate with each other more easily than if they were separate processes.

• Threads sometimes called light-weight processes and they do not require much memory overhead; they are cheaper than processes.

A thread has a beginning, an execution sequence, and a conclusion. It has an instruction pointer that keeps track of where within its context it is currently running.

• It can be pre-empted (interrupted)

• It can temporarily be put on hold (also known as sleeping) while other threads are running - this is called yielding.

Starting a New Thread

To spawn another thread, you need to call following method available in thread module −

thread.start_new_thread ( function, args[, kwargs] )

This method call enables a fast and efficient way to create new threads in both Linux and Windows.

The method call returns immediately and the child thread starts and calls function with the passed list of args. When function returns, the thread terminates.

Here, args is a tuple of arguments; use an empty tuple to call function without passing any arguments. kwargs is an optional dictionary of keyword arguments.

Example

#!/usr/bin/python

import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"

while 1:
   pass

Quando o código acima é executado, ele produz o seguinte resultado -

Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

Embora seja muito eficaz para threading de baixo nível, o módulo de thread é muito limitado em comparação com o módulo de threading mais recente.

O Módulo de Threading

O módulo de threading mais recente incluído no Python 2.4 oferece suporte de alto nível muito mais poderoso para threads do que o módulo de thread discutido na seção anterior.

O módulo de threading expõe todos os métodos do módulo de thread e fornece alguns métodos adicionais -

• threading.activeCount() - Retorna o número de objetos de thread que estão ativos.

• threading.currentThread() - Retorna o número de objetos de thread no controle de thread do chamador.

• threading.enumerate() - Retorna uma lista de todos os objetos de thread que estão atualmente ativos.

Além dos métodos, o módulo de threading possui a classe Thread que implementa o threading. Os métodos fornecidos pela classe Thread são os seguintes -

• run() - O método run () é o ponto de entrada para um thread.

• start() - O método start () inicia um thread chamando o método run.

• join([time]) - O join () espera que os encadeamentos sejam encerrados.

• isAlive() - O método isAlive () verifica se uma thread ainda está em execução.

• getName() - O método getName () retorna o nome de um thread.

• setName() - O método setName () define o nome de um thread.

Criação de rosca usando módulo de rosqueamento

Para implementar um novo thread usando o módulo de threading, você deve fazer o seguinte -

• Defina uma nova subclasse da classe Thread .

• Substitua o método __init __ (self [, args]) para adicionar argumentos adicionais.

• Em seguida, substitua o método run (self [, args]) para implementar o que o thread deve fazer quando iniciado.

Depois de criar a nova subclasse Thread , você pode criar uma instância dela e iniciar uma nova thread invocando start () , que por sua vez chama o método run () .

Exemplo

#!/usr/bin/python

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      print_time(self.name, self.counter, 5)
      print "Exiting " + self.name

def print_time(threadName, counter, delay):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

print "Exiting Main Thread"

Quando o código acima é executado, ele produz o seguinte resultado -

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2

Sincronizando Threads

O módulo de threading fornecido com Python inclui um mecanismo de bloqueio simples de implementar que permite sincronizar threads. Um novo bloqueio é criado chamando o método Lock () , que retorna o novo bloqueio.

O método de aquisição (bloqueio) do novo objeto de bloqueio é usado para forçar a execução de threads de forma síncrona. O parâmetro opcional de bloqueio permite controlar se o encadeamento espera para adquirir o bloqueio.

Se o bloqueio for definido como 0, a thread retorna imediatamente com um valor 0 se o bloqueio não pode ser adquirido e com 1 se o bloqueio foi adquirido. Se o bloqueio for definido como 1, o thread é bloqueado e espera que o bloqueio seja liberado.

O método release () do novo objeto de bloqueio é usado para liberar o bloqueio quando não for mais necessário.

Exemplo

#!/usr/bin/python

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"

Quando o código acima é executado, ele produz o seguinte resultado -

Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

Fila de prioridade multithread

O módulo Queue permite criar um novo objeto de fila que pode conter um número específico de itens. Existem métodos a seguir para controlar a fila -

• get() - O get () remove e retorna um item da fila.

• put() - A colocação adiciona o item a uma fila.

• qsize() - O qsize () retorna o número de itens que estão atualmente na fila.

• empty()- O empty () retorna True se a fila estiver vazia; caso contrário, False.

• full()- o full () retorna True se a fila estiver cheia; caso contrário, False.

Exemplo

#!/usr/bin/python

import Queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print "Starting " + self.name
      process_data(self.name, self.q)
      print "Exiting " + self.name

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
         if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
         else:
            queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print "Exiting Main Thread"

Quando o código acima é executado, ele produz o seguinte resultado -

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

XML é uma linguagem de código aberto portátil que permite aos programadores desenvolver aplicativos que podem ser lidos por outros aplicativos, independentemente do sistema operacional e / ou linguagem de desenvolvimento.

O que é XML?

A Extensible Markup Language (XML) é uma linguagem de marcação muito parecida com HTML ou SGML. Isso é recomendado pelo World Wide Web Consortium e está disponível como um padrão aberto.

XML é extremamente útil para rastrear pequenas e médias quantidades de dados sem exigir um backbone baseado em SQL.

Arquiteturas XML Parser e APIs

A biblioteca padrão do Python fornece um conjunto mínimo, mas útil de interfaces para trabalhar com XML.

As duas APIs mais básicas e amplamente usadas para dados XML são as interfaces SAX e DOM.

• Simple API for XML (SAX)- Aqui, você registra callbacks para eventos de interesse e, em seguida, permite que o analisador prossiga pelo documento. Isso é útil quando seus documentos são grandes ou você tem limitações de memória, ele analisa o arquivo à medida que o lê do disco e o arquivo inteiro nunca é armazenado na memória.

• Document Object Model (DOM) API - Esta é uma recomendação do World Wide Web Consortium em que todo o arquivo é lido na memória e armazenado em uma forma hierárquica (baseada em árvore) para representar todos os recursos de um documento XML.

SAX obviamente não pode processar informações tão rápido quanto o DOM ao trabalhar com arquivos grandes. Por outro lado, usar o DOM exclusivamente pode realmente matar seus recursos, especialmente se usado em muitos arquivos pequenos.

SAX é somente leitura, enquanto DOM permite alterações no arquivo XML. Visto que essas duas APIs diferentes se complementam literalmente, não há razão para que você não possa usá-las para grandes projetos.

Para todos os nossos exemplos de código XML, vamos usar um arquivo XML simples movies.xml como entrada -

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

Análise de XML com APIs SAX

SAX é uma interface padrão para análise XML baseada em eventos. A análise de XML com SAX geralmente requer que você crie seu próprio ContentHandler criando uma subclasse de xml.sax.ContentHandler.

Seu ContentHandler lida com as tags e atributos específicos de seu (s) tipo (s) de XML. Um objeto ContentHandler fornece métodos para lidar com vários eventos de análise. Seu próprio analisador chama métodos ContentHandler à medida que analisa o arquivo XML.

Os métodos startDocument e endDocument são chamados no início e no final do arquivo XML. Os caracteres do método (texto) são transmitidos aos dados de caracteres do arquivo XML por meio do texto do parâmetro.

O ContentHandler é chamado no início e no final de cada elemento. Se o analisador não estiver no modo de namespace, os métodos startElement (tag, atributos) e endElement (tag) são chamados; caso contrário, os métodos correspondentes startElementNS e endElementNS são chamados. Aqui, tag é a tag do elemento, e attribute é um objeto Attributes.

Aqui estão outros métodos importantes para entender antes de prosseguir -

O método make_parser

O método a seguir cria um novo objeto analisador e o retorna. O objeto analisador criado será do primeiro tipo de analisador que o sistema encontrar.

xml.sax.make_parser( [parser_list] )

Aqui está o detalhe dos parâmetros -

• parser_list - O argumento opcional que consiste em uma lista de analisadores a serem usados, os quais devem implementar o método make_parser.

O método de análise

O método a seguir cria um analisador SAX e o usa para analisar um documento.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

Aqui está o detalhe dos parâmetros -

• xmlfile - Este é o nome do arquivo XML a partir do qual ler.

• contenthandler - Deve ser um objeto ContentHandler.

• errorhandler - Se especificado, errorhandler deve ser um objeto SAX ErrorHandler.

O método parseString

Há mais um método para criar um analisador SAX e analisar o especificado XML string.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

Aqui está o detalhe dos parâmetros -

• xmlstring - Este é o nome da string XML a partir da qual ler.

• contenthandler - Deve ser um objeto ContentHandler.

• errorhandler - Se especificado, errorhandler deve ser um objeto SAX ErrorHandler.

Exemplo

#!/usr/bin/python

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print "*****Movie*****"
         title = attributes["title"]
         print "Title:", title

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print "Type:", self.type
      elif self.CurrentData == "format":
         print "Format:", self.format
      elif self.CurrentData == "year":
         print "Year:", self.year
      elif self.CurrentData == "rating":
         print "Rating:", self.rating
      elif self.CurrentData == "stars":
         print "Stars:", self.stars
      elif self.CurrentData == "description":
         print "Description:", self.description
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

Isso produziria o seguinte resultado -

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

Para obter detalhes completos sobre a documentação da API SAX, consulte as APIs SAX Python padrão .

Analisando XML com APIs DOM

O Document Object Model ("DOM") é uma API de linguagem cruzada do World Wide Web Consortium (W3C) para acessar e modificar documentos XML.

O DOM é extremamente útil para aplicativos de acesso aleatório. O SAX permite apenas a visualização de um bit do documento por vez. Se você estiver olhando para um elemento SAX, não terá acesso a outro.

Esta é a maneira mais fácil de carregar rapidamente um documento XML e criar um objeto minidom usando o módulo xml.dom. O objeto minidom fornece um método analisador simples que cria rapidamente uma árvore DOM a partir do arquivo XML.

A frase de amostra chama a função de análise (arquivo [, analisador]) do objeto minidom para analisar o arquivo XML designado por arquivo em um objeto de árvore DOM.

#!/usr/bin/python

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print "Root element : %s" % collection.getAttribute("shelf")

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print "*****Movie*****"
   if movie.hasAttribute("title"):
      print "Title: %s" % movie.getAttribute("title")

   type = movie.getElementsByTagName('type')[0]
   print "Type: %s" % type.childNodes[0].data
   format = movie.getElementsByTagName('format')[0]
   print "Format: %s" % format.childNodes[0].data
   rating = movie.getElementsByTagName('rating')[0]
   print "Rating: %s" % rating.childNodes[0].data
   description = movie.getElementsByTagName('description')[0]
   print "Description: %s" % description.childNodes[0].data

Isso produziria o seguinte resultado -

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Para obter detalhes completos sobre a documentação da API DOM, consulte as APIs DOM padrão do Python .

Python oferece várias opções para o desenvolvimento de interfaces gráficas com o usuário (GUIs). Os mais importantes estão listados abaixo.

• Tkinter- Tkinter é a interface Python para o kit de ferramentas Tk GUI fornecido com Python. Nós veríamos essa opção neste capítulo.

• wxPython - Esta é uma interface Python de código aberto para wxWindows http://wxpython.org.

• JPython - JPython é uma porta Python para Java que dá aos scripts Python acesso contínuo às bibliotecas de classes Java na máquina local http://www.jython.org.

Existem muitas outras interfaces disponíveis, que você pode encontrar na rede.

Programação Tkinter

Tkinter é a biblioteca GUI padrão para Python. O Python, quando combinado com o Tkinter, fornece uma maneira rápida e fácil de criar aplicativos GUI. O Tkinter fornece uma interface orientada a objetos poderosa para o kit de ferramentas Tk GUI.

Criar um aplicativo GUI usando o Tkinter é uma tarefa fácil. Tudo que você precisa fazer é executar as seguintes etapas -

• Importe o módulo Tkinter .

• Crie a janela principal do aplicativo GUI.

• Adicione um ou mais dos widgets mencionados acima ao aplicativo GUI.

• Entre no loop de evento principal para agir em relação a cada evento disparado pelo usuário.

Exemplo

#!/usr/bin/python

import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

Isso criaria a seguinte janela -

Widgets Tkinter

O Tkinter oferece vários controles, como botões, rótulos e caixas de texto usados ​​em um aplicativo GUI. Esses controles são comumente chamados de widgets.

Existem atualmente 15 tipos de widgets no Tkinter. Apresentamos esses widgets, bem como uma breve descrição na tabela a seguir -

Sr. Não.	Operador e descrição
1	Botão O widget de botão é usado para exibir botões em seu aplicativo.
2	Tela de pintura O widget Canvas é usado para desenhar formas, como linhas, ovais, polígonos e retângulos, em seu aplicativo.
3	Botão de verificação O widget Checkbutton é usado para exibir várias opções como caixas de seleção. O usuário pode selecionar várias opções ao mesmo tempo.
4	Entrada O widget de entrada é usado para exibir um campo de texto de linha única para aceitar valores de um usuário.
5	Quadro, Armação O widget Frame é usado como um widget de contêiner para organizar outros widgets.
6	Rótulo O widget Label é usado para fornecer uma legenda de linha única para outros widgets. Também pode conter imagens.
7	Listbox O widget Listbox é usado para fornecer uma lista de opções para um usuário.
8	Botão de menu O widget Menubutton é usado para exibir menus em seu aplicativo.
9	Cardápio O widget Menu é usado para fornecer vários comandos a um usuário. Esses comandos estão contidos no Menubutton.
10	mensagem O widget Mensagem é usado para exibir campos de texto de várias linhas para aceitar valores de um usuário.
11	Botao de radio O widget Radiobutton é usado para exibir várias opções como botões de rádio. O usuário pode selecionar apenas uma opção por vez.
12	Escala O widget Escala é usado para fornecer um widget de controle deslizante.
13	Barra de rolagem O widget Barra de rolagem é usado para adicionar capacidade de rolagem a vários widgets, como caixas de listagem.
14	Texto O widget Texto é usado para exibir texto em várias linhas.
15	Nível Superior O widget de nível superior é usado para fornecer um contêiner de janela separado.
16	Spinbox O widget Spinbox é uma variante do widget Tkinter Entry padrão, que pode ser usado para selecionar um número fixo de valores.
17	PanedWindow Um PanedWindow é um widget de contêiner que pode conter qualquer número de painéis, organizados horizontalmente ou verticalmente.
18	LabelFrame Um labelframe é um widget de contêiner simples. Seu objetivo principal é atuar como um espaçador ou contêiner para layouts de janela complexos.
19	tkMessageBox Este módulo é usado para exibir caixas de mensagens em seus aplicativos.

Vamos estudar esses widgets em detalhes -

Atributos padrão

Vamos dar uma olhada em como alguns de seus atributos comuns, como tamanhos, cores e fontes, são especificados.

• Dimensions

• Colors

• Fonts

• Anchors

• Estilos de relevo

• Bitmaps

• Cursors

Vamos estudá-los brevemente -

Gestão Geométrica

Todos os widgets Tkinter têm acesso a métodos específicos de gerenciamento de geometria, que têm o propósito de organizar os widgets em toda a área de widgets pai. O Tkinter expõe as seguintes classes de gerenciador de geometria: pacote, grade e local.

• O pack () Método - Este gerenciador de geometria organiza widgets em blocos antes de colocá-los no widget pai.

• A grade () Método - Este gerenciador de geometria organiza os widgets em uma estrutura de tabela, como no widget pai.

• O lugar () Método - Este gerenciador de geometria organiza os widgets, colocando-os em uma posição específica no widget pai.

Vamos estudar os métodos de gerenciamento de geometria brevemente -

Qualquer código que você escrever usando qualquer linguagem compilada como C, C ++ ou Java pode ser integrado ou importado para outro script Python. Este código é considerado uma "extensão".

Um módulo de extensão Python nada mais é do que uma biblioteca C normal. Em máquinas Unix, essas bibliotecas geralmente terminam em.so(para objeto compartilhado). Em máquinas Windows, você normalmente vê.dll (para biblioteca vinculada dinamicamente).

Pré-requisitos para escrever extensões

Para começar a escrever sua extensão, você vai precisar dos arquivos de cabeçalho Python.

• Em máquinas Unix, isso geralmente requer a instalação de um pacote específico do desenvolvedor, como python2.5-dev .

• Os usuários do Windows obtêm esses cabeçalhos como parte do pacote quando usam o instalador binário do Python.

Além disso, presume-se que você tenha um bom conhecimento de C ou C ++ para escrever qualquer extensão Python usando programação C.

Primeiro, olhe para uma extensão Python

Para sua primeira olhada em um módulo de extensão Python, você precisa agrupar seu código em quatro partes -

• O arquivo de cabeçalho Python.h .

• As funções C que você deseja expor como a interface do seu módulo.

• Uma tabela que mapeia os nomes de suas funções conforme os desenvolvedores Python os veem para funções C dentro do módulo de extensão.

• Uma função de inicialização.

O arquivo de cabeçalho Python.h

Você precisa incluir o arquivo de cabeçalho Python.h em seu arquivo de origem C, que dá acesso à API interna do Python usada para conectar seu módulo ao interpretador.

Certifique-se de incluir Python.h antes de qualquer outro cabeçalho que você possa precisar. Você precisa seguir as inclusões com as funções que deseja chamar do Python.

As funções C

As assinaturas da implementação C de suas funções sempre assumem uma das três formas a seguir -

static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

Cada uma das declarações anteriores retorna um objeto Python. Não existe função void em Python como existe em C. Se você não quiser que suas funções retornem um valor, retorne o equivalente em C do PythonNonevalor. Os cabeçalhos Python definem uma macro, Py_RETURN_NONE, que faz isso para nós.

Os nomes de suas funções C podem ser o que você quiser, pois eles nunca são vistos fora do módulo de extensão. Eles são definidos como função estática .

Suas funções C geralmente são nomeadas combinando o módulo Python e nomes de função juntos, como mostrado aqui -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

Esta é uma função Python chamada func dentro do módulo do módulo . Você colocará ponteiros para suas funções C na tabela de métodos do módulo que geralmente vem a seguir em seu código-fonte.

A Tabela de Mapeamento de Método

Esta tabela de métodos é uma matriz simples de estruturas PyMethodDef. Essa estrutura se parece com isto -

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

Aqui está a descrição dos membros desta estrutura -

• ml_name - Este é o nome da função que o interpretador Python apresenta quando é usado em programas Python.

• ml_meth - Este deve ser o endereço de uma função que possua qualquer uma das assinaturas descritas na seção anterior.

• ml_flags - Isso diz ao intérprete qual das três assinaturas ml_meth está usando.

  • Este sinalizador geralmente tem um valor de METH_VARARGS.

  • Este sinalizador pode ser bit a bit OR'ed com METH_KEYWORDS se você deseja permitir argumentos de palavra-chave em sua função.

  • Isso também pode ter um valor de METH_NOARGS que indica que você não deseja aceitar nenhum argumento.

• ml_doc - Esta é a docstring para a função, que pode ser NULL se você não quiser escrever uma.

Esta tabela precisa ser encerrada com uma sentinela que consiste em valores NULL e 0 para os membros apropriados.

Exemplo

Para a função definida acima, temos a seguinte tabela de mapeamento de método -

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

A função de inicialização

A última parte do seu módulo de extensão é a função de inicialização. Esta função é chamada pelo interpretador Python quando o módulo é carregado. É necessário que a função seja nomeadainitModule, onde Módulo é o nome do módulo.

A função de inicialização precisa ser exportada da biblioteca que você irá construir. Os cabeçalhos Python definem PyMODINIT_FUNC para incluir os encantamentos apropriados para que isso aconteça para o ambiente específico no qual estamos compilando. Tudo que você precisa fazer é usá-lo ao definir a função.

Sua função de inicialização C geralmente tem a seguinte estrutura geral -

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Aqui está a descrição da função Py_InitModule3 -

• func - Esta é a função a ser exportada.

• module_methods - Este é o nome da tabela de mapeamento definido acima.

• docstring - Este é o comentário que você deseja fazer em sua extensão.

Juntar tudo isso se parece com o seguinte -

#include <Python.h>

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Exemplo

Um exemplo simples que faz uso de todos os conceitos acima -

#include <Python.h>

static PyObject* helloworld(PyObject* self) {
   return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
   "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
   {"helloworld", (PyCFunction)helloworld, 
      METH_NOARGS, helloworld_docs},
      {NULL}
};

void inithelloworld(void) {
   Py_InitModule3("helloworld", helloworld_funcs,
                  "Extension module example!");
}

Aqui, a função Py_BuildValue é usada para construir um valor Python. Salve o código acima no arquivo hello.c. Veríamos como compilar e instalar este módulo para ser chamado a partir do script Python.

Criação e instalação de extensões

O pacote distutils torna muito fácil distribuir módulos Python, tanto Python puro quanto módulos de extensão, de uma forma padrão. Os módulos são distribuídos na forma de código-fonte e construídos e instalados por meio de um script de configuração geralmente denominado setup.py, como segue.

Para o módulo acima, você precisa preparar o seguinte script setup.py -

from distutils.core import setup, Extension
setup(name='helloworld', version='1.0',  \
      ext_modules=[Extension('helloworld', ['hello.c'])])

Agora, use o seguinte comando, que executaria todas as etapas de compilação e vinculação necessárias, com os comandos e sinalizadores do compilador e do vinculador corretos e copia a biblioteca dinâmica resultante em um diretório apropriado -

$ python setup.py install

Em sistemas baseados em Unix, você provavelmente precisará executar este comando como root para ter permissões para gravar no diretório de pacotes do site. Isso geralmente não é um problema no Windows.

Importando extensões

Depois de instalar sua extensão, você poderá importar e chamar essa extensão em seu script Python da seguinte maneira -

#!/usr/bin/python
import helloworld

print helloworld.helloworld()

Isso produziria o seguinte resultado -

Hello, Python extensions!!

Passando parâmetros de função

Como você provavelmente desejará definir funções que aceitem argumentos, você pode usar uma das outras assinaturas para suas funções C. Por exemplo, a função seguinte, que aceita alguns parâmetros, seria definida assim -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Parse args and do something interesting here. */
   Py_RETURN_NONE;
}

A tabela de métodos contendo uma entrada para a nova função seria semelhante a esta -

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};

Você pode usar a função API PyArg_ParseTuple para extrair os argumentos de um ponteiro PyObject passado para sua função C.

O primeiro argumento para PyArg_ParseTuple é o argumento args. Este é o objeto que você analisará . O segundo argumento é uma string de formato que descreve os argumentos conforme você espera que apareçam. Cada argumento é representado por um ou mais caracteres na string de formato conforme a seguir.

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }
   
   /* Do something interesting here. */
   Py_RETURN_NONE;
}

Compilar a nova versão do seu módulo e importá-la permite que você invoque a nova função com qualquer número de argumentos de qualquer tipo -

module.func(1, s="three", d=2.0)
module.func(i=1, d=2.0, s="three")
module.func(s="three", d=2.0, i=1)

Você provavelmente pode criar ainda mais variações.

A função PyArg_ParseTuple

Aqui está a assinatura padrão para PyArg_ParseTuple função -

int PyArg_ParseTuple(PyObject* tuple,char* format,...)

Esta função retorna 0 para erros e um valor diferente de 0 para sucesso. tupla é o PyObject * que era o segundo argumento da função C. Aqui, o formato é uma string C que descreve os argumentos obrigatórios e opcionais.

Aqui está uma lista de códigos de formato para PyArg_ParseTuple função -

Código	Tipo C	Significado
c	Caracteres	Uma string Python de comprimento 1 torna-se um C char.
d	em dobro	Um float Python se torna um duplo C.
f	flutuador	Um float Python se torna um float C.
Eu	int	Um int Python torna-se um int C.
eu	grandes	Um int Python torna-se um C longo.
eu	longo longo	Um Python int torna-se um C longo
O	PyObject *	Obtém referência não NULL emprestada ao argumento Python.
s	Caracteres*	Cadeia de caracteres Python sem nulos incorporados em C char *.
s #	char * + int	Qualquer string Python para endereço C e comprimento.
t #	char * + int	Buffer de segmento único somente leitura para endereço C e comprimento.
você	Py_UNICODE *	Python Unicode sem nulos incorporados a C.
você#	Py_UNICODE * + int	Qualquer endereço e comprimento Python Unicode C.
W#	char * + int	Leitura / gravação de buffer de segmento único no endereço C e comprimento.
z	Caracteres*	Como s, também aceita Nenhum (define C char * como NULL).
z #	char * + int	Como s #, também aceita Nenhum (define C char * como NULL).
(...)	conforme ...	Uma sequência Python é tratada como um argumento por item.
|		Os seguintes argumentos são opcionais.
:		Fim do formato, seguido pelo nome da função para mensagens de erro.
;		Fim do formato, seguido por todo o texto da mensagem de erro.

Valores de Retorno

Py_BuildValue recebe uma string de formato muito parecido com PyArg_ParseTuple . Em vez de passar os endereços dos valores que você está construindo, você passa os valores reais. Aqui está um exemplo que mostra como implementar uma função add -

static PyObject *foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

Isso é o que pareceria se implementado em Python -

def add(a, b):
   return (a + b)

Você pode retornar dois valores de sua função da seguinte maneira, isso seria descoberto usando uma lista em Python.

static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("ii", a + b, a - b);
}

Isso é o que pareceria se implementado em Python -

def add_subtract(a, b):
   return (a + b, a - b)

A função Py_BuildValue

Aqui está a assinatura padrão para Py_BuildValue função -

PyObject* Py_BuildValue(char* format,...)

Aqui, format é uma string C que descreve o objeto Python a ser construído. Os seguintes argumentos de Py_BuildValue são valores C a partir dos quais o resultado é construído. O resultado PyObject * é uma nova referência.

A tabela a seguir lista as strings de código comumente usadas, das quais zero ou mais são unidas no formato de string.

Código	Tipo C	Significado
c	Caracteres	AC char torna-se uma string Python de comprimento 1.
d	em dobro	AC double se torna um float Python.
f	flutuador	Float AC torna-se um float Python.
Eu	int	AC int se torna um Python int.
eu	grandes	AC long torna-se um Python int.
N	PyObject *	Passa um objeto Python e rouba uma referência.
O	PyObject *	Passa um objeto Python e o INCREFA normalmente.
O &	converter + anular *	Conversão arbitrária
s	Caracteres*	C 0-terminado char * para Python string, ou NULL para Nenhum.
s #	char * + int	C char * e comprimento para a string Python ou NULL para Nenhum.
você	Py_UNICODE *	Cadeia de caracteres terminada em nulo em todo o C para Python Unicode ou NULL para Nenhum.
você#	Py_UNICODE * + int	Cadeia de caracteres ampla de C e comprimento para Python Unicode ou NULL para Nenhum.
W#	char * + int	Leitura / gravação de buffer de segmento único no endereço C e comprimento.
z	Caracteres*	Como s, também aceita Nenhum (define C char * como NULL).
z #	char * + int	Como s #, também aceita Nenhum (define C char * como NULL).
(...)	conforme ...	Constrói tupla Python a partir de valores C.
[...]	conforme ...	Constrói uma lista Python a partir de valores C.
{...}	conforme ...	Constrói dicionário Python a partir de valores C, alternando chaves e valores.

Code {...} constrói dicionários a partir de um número par de valores C, chaves e valores alternados. Por exemplo, Py_BuildValue ("{issi}", 23, "zig", "zag", 42) retorna um dicionário como o {23: 'zig', 'zag': 42} do Python.