Python 3 - Guia rápido

O módulo future

Python 3.x introduziu algumas palavras-chave e recursos incompatíveis com Python 2 que podem ser importados por meio do módulo __future__ integrado no Python 2. É recomendado usar importações __future__, se você estiver planejando suporte Python 3.x para seu código.

Por exemplo, se quisermos o comportamento da divisão inteira do Python 3.x no Python 2, adicione a seguinte instrução de importação.

from __future__ import division

A função de impressão

A mudança mais notável e mais amplamente conhecida no Python 3 é como o printfunção é usada. O uso de parênteses () com a função de impressão agora é obrigatório. Era opcional no Python 2.

print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()

A função print () insere uma nova linha no final, por padrão. No Python 2, ele pode ser suprimido colocando ',' no final. No Python 3, "end = ''" acrescenta espaço em vez de nova linha.

print x,           # Trailing comma suppresses newline in Python 2
print(x, end=" ")  # Appends a space instead of a newline in Python 3

Ler entrada do teclado

Python 2 tem duas versões de funções de entrada, input() e raw_input(). A função input () trata os dados recebidos como string se estiverem incluídos entre aspas '' ou "", caso contrário, os dados são tratados como um número.

No Python 3, a função raw_input () está obsoleta. Além disso, os dados recebidos são sempre tratados como string.

In Python 2

>>> x = input('something:') 
something:10 #entered data is treated as number
>>> x
10

>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'

>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'

>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"

In Python 3

>>> x = input("something:")
something:10
>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"

>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
   File "<pyshell#3>", line 1, in 
  <module>
   x = raw_input("something:")
NameError: name 'raw_input' is not defined

Divisão Inteira

No Python 2, o resultado da divisão de dois inteiros é arredondado para o inteiro mais próximo. Como resultado, 3/2 mostrará 1. Para obter uma divisão de ponto flutuante, o numerador ou denominador deve ser usado explicitamente como flutuante. Portanto, 3,0 / 2 ou 3 / 2,0 ou 3,0 / 2,0 resultará em 1,5

Python 3 avalia 3/2 como 1.5 por padrão, o que é mais intuitivo para novos programadores.

Representação Unicode

O Python 2 requer que você marque uma string com au se quiser armazená-la como Unicode.

O Python 3 armazena strings como Unicode, por padrão. Temos strings Unicode (utf-8) e classes de 2 bytes: byte e arrays de bytes.

Função xrange () removida

No Python 2, range () retorna uma lista, e xrange () retorna um objeto que irá gerar apenas os itens no intervalo quando necessário, economizando memória.

No Python 3, a função range () foi removida e xrange () foi renomeado como range (). Além disso, o objeto range () oferece suporte ao fatiamento no Python 3.2 e posterior.

levantar exceção

Python 2 aceita ambas as notações, a sintaxe 'antiga' e a 'nova'; Python 3 levanta um SyntaxError se não colocarmos o argumento de exceção entre parênteses.

raise IOError, "file error" #This is accepted in Python 2
raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3

Argumentos em exceções

No Python 3, os argumentos para exceção devem ser declarados com a palavra-chave 'as'.

except Myerror, err: # In Python2
except Myerror as err: #In Python 3

Função next () e Método .next ()

No Python 2, next () como um método de objeto gerador é permitido. No Python 2, a função next (), para iterar sobre o objeto gerador, também é aceita. No Python 3, entretanto, next (0 como método gerador é descontinuado e gera AttributeError.

gen = (letter for letter in 'Hello World') # creates generator object
next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3

Utilitário 2to3

Junto com o interpretador Python 3, o script 2to3.py geralmente é instalado na pasta tools / scripts. Ele lê o código-fonte do Python 2.x e aplica uma série de fixadores para transformá-lo em um código Python 3.x válido.

Here is a sample Python 2 code (area.py):

def area(x,y = 3.14): 
   a = y*x*x
   print a
   return a

a = area(10)
print "area",a

To convert into Python 3 version:

$2to3 -w area.py

Converted code :

def area(x,y = 3.14): # formal parameters
   a = y*x*x
   print (a)
   return a

a = area(10)
print("area",a)

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 os outros idiomas usam pontuações. Possui menos construções sintáticas do que outras linguagens.

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.
Python 1.0 foi lançado em novembro de 1994. Em 2000, Python 2.0 foi lançado. Python 2.7.11 é a edição mais recente do Python 2.
Enquanto isso, Python 3.0 foi lançado em 2008. Python 3 não é compatível com Python 2. A ênfase em Python 3 foi na remoção de construções e módulos de programação duplicados para que "Deve haver um - e de preferência apenas um - maneira óbvia de fazer isso. " Python 3.5.1 é a versão mais recente do Python 3.

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. A, alguns 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 3 está disponível para Windows, Mac OS e a maioria dos sistemas operacionais Linux. Embora o Python 2 esteja disponível para muitos outros sistemas operacionais, o suporte ao Python 3 não foi disponibilizado para eles ou foi abandonado.

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.

Obtendo Python

Plataforma Windows

Binários da última versão do Python 3 (Python 3.5.1) estão disponíveis nesta página de download

As seguintes opções de instalação diferentes estão disponíveis.

Arquivo zip incorporável do Windows x86-64
Instalador executável do Windows x86-64
Instalador baseado na web do Windows x86-64
Arquivo zip incorporável do Windows x86
Instalador executável do Windows x86
Instalador baseado na web do Windows x86

Note- Para instalar o Python 3.5.1, os requisitos mínimos de SO são Windows 7 com SP1. Para as versões 3.0 a 3.4.x, o Windows XP é aceitável.

Plataforma Linux

Diferentes tipos de Linux usam diferentes gerenciadores de pacotes para a instalação de novos pacotes.

No Ubuntu Linux, o Python 3 é instalado usando o seguinte comando do terminal.

$sudo apt-get install python3-minimal

Instalação da fonte

Baixe o tarball do código-fonte Gzipado do URL de download do Python - https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz

Extract the tarball
tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix = /opt/python3.5.1
make  
sudo make install

Mac OS

Baixe instaladores do Mac OS a partir deste URL - https://www.python.org/downloads/mac-osx/

Instalador do Mac OS X 64 bits / 32 bits - python-3.5.1-macosx10.6.pkg
Instalador do Mac OS X i386 / PPC de 32 bits - python-3.5.1-macosx10.5.pkg

Clique duas vezes neste arquivo de pacote e siga as instruções do assistente para instalar.

O código-fonte mais atualizado e atual, binários, documentação, notícias, etc., está disponível no site oficial do Python -

Python Official Website - https://www.python.org/

Você pode baixar a documentação do Python no seguinte site. A documentação está disponível nos formatos HTML, PDF e PostScript.

Python Documentation Website- www.python.org/doc/

Configurando PATH

Os programas e outros arquivos executáveis podem estar em vários diretórios. Conseqüentemente, os sistemas operacionais fornecem um caminho de pesquisa que lista os diretórios nos quais pesquisa os executáveis.

Os recursos importantes são -

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.
A variável de caminho é nomeada como PATH em Unix ou Path no Windows (o Unix diferencia maiúsculas de minúsculas; o 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.

Configurando 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 / python3" e pressione Enter.
In the bash shell (Linux) - digite export PYTHONPATH = / usr / local / bin / python3.4 e pressione Enter.
In the sh or ksh shell - digite PATH = "$ PATH: / usr / local / bin / python3" e pressione Enter.

Note - / usr / local / bin / python3 é 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 são 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 fornecer saída de depuração
2	-O gerar 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 em declaraçõ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, conforme mostrado no exemplo 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 você não conseguir configurar o ambiente adequadamente, poderá obter a ajuda do 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 3.4.1 disponível no Windows 7 e Ubuntu Linux.

Já configuramos o ambiente de programação Python online, para que você possa executar todos os exemplos disponíveis online enquanto aprende a 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 os 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 3.3.2 (default, Dec 10 2013, 11:35:01)
[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>

On Windows:

Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "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 a versão mais antiga do Python (Python 2.x), use parênteses como inprintfunção é opcional. 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. Os arquivos Python têm a extensão.py. Digite o seguinte código-fonte em um arquivo test.py -

print ("Hello, Python!")

Presumimos que você tenha o interpretador Python definido em PATHvariável. Agora, tente executar este programa da seguinte maneira -

On Linux

$ python test.py

Isso produz o seguinte resultado -

Hello, Python!

On Windows

C:\Python34>Python test.py

Isso produz o seguinte resultado -

Hello, Python!

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

#!/usr/bin/python3
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 privado forte.
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
Como	finalmente	ou
afirmar	para	passar
pausa	de	impressão
classe	global	levantar
continuar	E se	Retorna
def	importar	experimentar
del	dentro	enquanto
elif	é	com
outro	lambda	produção
exceto

Linhas e recuo

Python não usa 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 blocos, mesmo que eles não tenham chaves.

#!/usr/bin/python3
import sys

file_finish = "end"
file_text = ""
contents=[]

file_name=input("Enter filename: ")
if len(file_name) == 0:
   print("Please enter filename")
   sys.exit()

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 = input("Enter text: ")
   contents.append(file_text)

   if file_text == file_finish:
      # close the file
      file.close()
      break

print(contents)
data = ' '.join([str(elem) for elem in contents])  
print(data)
file.write(data)
file.close()
file_name = 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 denotar 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 é o início de um comentário. Todos os caracteres após o #, até o final da linha física, fazem parte do comentário e o interpretador Python os ignora.

#!/usr/bin/python3

# 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

Python não possui recurso de comentários de várias linhas. Você deve comentar cada linha individualmente 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 linha a seguir do programa exibe o prompt e a instrução dizendo “Pressione a tecla Enter para sair” e, em seguida, aguarda a ação do usuário -

#!/usr/bin/python3

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

Grupos de instruções individuais, que formam um único bloco de código, são chamados 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. Vamos entender isso.

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/python3

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 o deldeclaração. A sintaxe dodel declaração é -

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

Você pode excluir um único objeto ou vários objetos usando o del declaração.

Por exemplo -

del var
del var_a, var_b

Python oferece suporte a três tipos numéricos diferentes -

int (inteiros com sinal)
float (valores reais de ponto flutuante)
complexo (números complexos)

Todos os inteiros em Python3 são representados como inteiros longos. Portanto, não há nenhum tipo de número separado, contanto.

Exemplos

Aqui estão alguns exemplos de números -

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

Um número complexo consiste em um par ordenado de números reais de ponto flutuante denotados por x + yj, onde xey são 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 slice ([] e [:]) com índices começando em 0 no início da string e trabalhando de -1 até o final.

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

#!/usr/bin/python3

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 das diferenças 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/python3

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.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 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.

A principal diferença entre listas e tuplas é - 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/python3

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

print (tuple)           # Prints complete tuple
print (tuple[0])        # Prints first element of the tuple
print (tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print (tuple[2:])       # Prints elements starting from 3rd element
print (tinytuple * 2)   # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple

Isso produz o seguinte resultado -

('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 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/python3

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 de 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/python3

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
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])

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

Os 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

Assumir variável a possui o valor 10 e variável b detém o valor 21, então -

Mostrar exemplo

Operador	Descrição	Exemplo
+ Adição	Adiciona valores em qualquer lado do operador.	a + b = 31
- Subtração	Subtrai o operando direito do operando esquerdo.	a - b = -11
* Multiplicação	Multiplica os valores em ambos os lados do operador	a * b = 210
/ Divisão	Divide operando esquerdo pelo operando direito	b / a = 2,1
% Módulo	Divide operando esquerdo pelo operando direito e retorna o resto	b% a = 1
** 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 é reduzido, 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.

Assumir variável a possui o valor 10 e variável b mantém o valor 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 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

Assumir variável a possui o valor 10 e variável b mantém o valor 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 / ac / = 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 a operação bit a bit. Suponha que a = 60; e b = 13; Agora, em formato binário, eles serão os seguintes -

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

A função interna do Python bin () pode ser usada para obter a representação binária de um número inteiro.

Os seguintes operadores bit a bit são suportados pela linguagem Python -

Mostrar exemplo

Operador	Descrição	Exemplo
& Binário E	O operador copia um bit, para o resultado, se existir em ambos os operandos	(a & b) (significa 0000 1100)
\| Binário OU	Ele copia um bit, 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 do operando esquerdo é movido para a esquerda pelo número de bits especificado pelo operando direito.	a << 2 = 240 (significa 1111 0000)
>> Deslocamento para a direita binário	O valor do operando esquerdo é movido para a direita pelo número de bits especificado pelo operando direito.	a >> 2 = 15 (significa 0000 1111)

Operadores lógicos Python

Os seguintes operadores lógicos são suportados pela linguagem Python. Assumir variávela é verdadeiro e variável b detém False então -

Mostrar exemplo

Operador	Descrição	Exemplo
e lógico E	Se ambos os operandos forem verdadeiros, a condição se torna verdadeira.	(a e b) é falso.
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) é verdadeiro.

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, conforme explicado 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 de um programa e as ações específicas executadas de acordo com as condições.

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

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 qualquer zero ou null values como valor FALSE.

A linguagem de programação Python fornece os seguintes tipos de instruções de tomada de decisão.

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 examinar cada declaração de tomada de decisão rapidamente.

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.

Exemplo

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

#!/usr/bin/python3

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

Resultado

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 loop dentro de qualquer outro while ou for loop.

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 criados nesse escopo são destruídos.

Python suporta as seguintes instruções de controle.

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.

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

Iterador e gerador

Iteratoré um objeto que permite a um programador percorrer todos os elementos de uma coleção, independentemente de sua implementação específica. Em Python, um objeto iterador implementa dois métodos,iter() e next().

Objetos String, List ou Tuple podem ser usados para criar um Iterator.

list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
   print (x, end=" ")
or using next() function
while True:
   try:
      print (next(it))
   except StopIteration:
      sys.exit() #you have to import sys module for this

UMA generator é uma função que produz ou produz uma sequência de valores usando o método de rendimento.

Quando uma função geradora é chamada, ela retorna um objeto gerador sem nem mesmo iniciar a execução da função. Quando o método next () é chamado pela primeira vez, a função começa a ser executada até atingir a instrução de rendimento, que retorna o valor gerado. O rendimento mantém o controle, ou seja, lembra a última execução e a segunda chamada de next () continua a partir do valor anterior.

Exemplo

O exemplo a seguir define um gerador, que gera um iterador para todos os números de Fibonacci.

#!usr/bin/python3

import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n): 
         return
      yield a
      a, b = b, a + b
      counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
      print (next(f), end=" ")
   except StopIteration:
      sys.exit()

Os tipos de dados numéricos armazenam valores numéricos. Eles são tipos de dados imutáveis. Isso 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 dodel declaração é -

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 diferentes tipos numéricos -

int (signed integers) - Eles são frequentemente chamados de inteiros ou ints. Eles são números inteiros positivos ou negativos sem vírgula decimal. Os inteiros em Python 3 têm tamanho ilimitado. Python 2 tem dois tipos inteiros - int e long. Não há 'long integer'em Python 3 mais.
float (floating point real values)- Também chamados de floats, eles representam números reais e são escritos com um ponto decimal dividindo o inteiro e as partes 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.

É possível representar um inteiro na forma hexa-decimal ou octal

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

Exemplos

Aqui estão alguns exemplos de números.

int	flutuador	complexo
10	0,0	3,14j
100	15,20	45.j
-786	-21,9	9.322e-36j
080	32,3 + e18	.876j
-0490	-90.	-.6545 + 0J
-0 × 260	-32.54e100	3e + 26J
0 × 69	70.2-E12	4.53e-7j

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. À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. Deprecated em Python 3. Em vez disso, use return (x>y)-(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/python3

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/python3

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/python3

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% -

Sr. Não.	Símbolo de formato e conversão
1	%c personagem
2	%s conversão de string via str () antes da formatação
3	%i inteiro decimal com sinal
4	%d inteiro decimal com sinal
5	%u inteiro decimal sem sinal
6	%o inteiro octal
7	%x inteiro hexadecimal (letras minúsculas)
8	%X inteiro hexadecimal (letras MAIÚSCULAS)
9	%e notação exponencial (com 'e' minúsculo)
10	%E notação exponencial (com maiúscula 'E')
11	%f número real de ponto flutuante
12	%g o mais curto de% f e% e
13	%G o mais curto de% f e% E

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

Sr. Não.	Símbolo e funcionalidade
1	* argumento especifica largura ou precisão
2	- justificação à esquerda
3	+ mostrar o sinal
4	<sp> deixe um espaço em branco antes de um número positivo
5	# adicione o zero inicial octal ('0') ou o inicial hexadecimal '0x' ou '0X', dependendo se 'x' ou 'X' foram usados.
6	0 preencha da esquerda com zeros (em vez de espaços)
7	% '%%' deixa você com um único literal '%'
8	(var) variável de mapeamento (argumentos de dicionário)
9	m.n. 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/python3

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/python3

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/python3

print (r'C:\\nowhere')

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

C:\\nowhere

String Unicode

No Python 3, todas as strings são representadas em Unicode. No Python 2, são armazenadas internamente como ASCII de 8 bits, portanto, é necessário anexar 'u' para torná-lo Unicode. Não é mais necessário agora.

Métodos de string integrados

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

Sr. Não.	Métodos e Descrição
1	capitalizar() Capitaliza a primeira letra da string
2	centro (largura, fillchar) Retorna uma string preenchida com fillchar 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 () Returns true if string has at least one cased character and all cased characters are in uppercase and false otherwise.
18	join(seq) Merges (concatenates) the string representations of elements in sequence seq into a string, with separator string.
19	len(string) Returns the length of the string
20	ljust(width[, fillchar]) Returns a space-padded string with the original string left-justified to a total of width columns.
21	lower() Converts all uppercase letters in string to lowercase.
22	lstrip() Removes all leading whitespace in string.
23	maketrans() Returns a translation table to be used in translate function.
24	max(str) Returns the max alphabetical character from the string str.
25	min(str) Returns the min alphabetical character from the string str.
26	replace(old, new [, max]) Replaces all occurrences of old in string with new or at most max occurrences if max given.
27	rfind(str, beg = 0,end = len(string)) Same as find(), but search backwards in string.
28	rindex( str, beg = 0, end = len(string)) Same as index(), but search backwards in string.
29	rjust(width,[, fillchar]) Returns a space-padded string with the original string right-justified to a total of width columns.
30	rstrip() Removes all trailing whitespace of string.
31	split(str="", num=string.count(str)) Splits string according to delimiter str (space if not provided) and returns list of substrings; split into at most num substrings if given.
32	splitlines( num=string.count('\n')) Splits string at all (or num) NEWLINEs and returns a list of each line with NEWLINEs removed.
33	startswith(str, beg=0,end=len(string)) Determines if string or a substring of string (if starting index beg and ending index end are given) starts with substring str; returns true if so and false otherwise.
34	strip([chars]) Performs both lstrip() and rstrip() on string
35	swapcase() Inverts case for all letters in string.
36	title() Returns "titlecased" version of string, that is, all words begin with uppercase and the rest are lowercase.
37	translate(table, deletechars="") Translates string according to translation table str(256 chars), removing those in the del string.
38	upper() Converts lowercase letters in string to uppercase.
39	zfill (width) Returns original string leftpadded with zeros to a total of width characters; intended for numbers, zfill() retains any sign given (less one zero).
40	isdecimal() Returns true if a unicode string contains only decimal characters and false otherwise.

The most basic data structure in Python is the sequence. Each element of a sequence is assigned a number - its position or index. The first index is zero, the second index is one, and so forth.

Python has six built-in types of sequences, but the most common ones are lists and tuples, which we would see in this tutorial.

There are certain things you can do with all the sequence types. These operations include indexing, slicing, adding, multiplying, and checking for membership. In addition, Python has built-in functions for finding the length of a sequence and for finding its largest and smallest elements.

Python Lists

The list is the most versatile datatype available in Python, which can be written as a list of comma-separated values (items) between square brackets. Important thing about a list is that the items in a list need not be of the same type.

Creating a list is as simple as putting different comma-separated values between square brackets. For example −

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

Similar to string indices, list indices start at 0, and lists can be sliced, concatenated and so on.

Accessing Values in Lists

To access values in lists, use the square brackets for slicing along with the index or indices to obtain value available at that index. For example −

#!/usr/bin/python3

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])

When the above code is executed, it produces the following result −

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

Updating Lists

You can update single or multiple elements of lists by giving the slice on the left-hand side of the assignment operator, and you can add to elements in a list with the append() method. For example −

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

Note − The append() method is discussed in the subsequent section.

When the above code is executed, it produces the following result −

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

Delete List Elements

To remove a list element, you can use either the del statement if you know exactly which element(s) you are deleting. You can use the remove() method if you do not know exactly which items to delete. For example −

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print (list)

del list[2]
print ("After deleting value at index 2 : ", list)

When the above code is executed, it produces the following result −

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

Note − remove() method is discussed in subsequent section.

Basic List Operations

Lists respond to the + and * operators much like strings; they mean concatenation and repetition here too, except that the result is a new list, not a string.

In fact, lists respond to all of the general sequence operations we used on strings in the prior chapter.

Python Expression	Results	Description
len([1, 2, 3])	3	Length
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Concatenation
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	Repetition
3 in [1, 2, 3]	True	Membership
for x in [1,2,3] : print (x,end = ' ')	1 2 3	Iteration

Indexing, Slicing and Matrixes

Since lists are sequences, indexing and slicing work the same way for lists as they do for strings.

Assuming the following input −

L = ['C++'', 'Java', 'Python']

Python Expression	Results	Description
L[2]	'Python'	Offsets start at zero
L[-2]	'Java'	Negative: count from the right
L[1:]	['Java', 'Python']	Slicing fetches sections

Built-in List Functions and Methods

Python includes the following list functions −

Sr.No.	Function & Description
1	len(list) Gives the total length of the list.
2	max(list) Returns item from the list with max value.
3	min(list) Returns item from the list with min value.
4	list(seq) Converts a tuple into list.

Python includes the following list methods −

Sr.No.	Methods & Description
1	list.append(obj) Appends object obj to list
2	list.count(obj) Returns count of how many times obj occurs in list
3	list.extend(seq) Appends the contents of seq to list
4	list.index(obj) Returns the lowest index in list that obj appears
5	list.insert(index, obj) Inserts object obj into list at offset index
6	list.pop(obj = list[-1]) Removes and returns last object or obj from list
7	list.remove(obj) Removes object obj from list
8	list.reverse() Reverses objects of list in place
9	list.sort([func]) Sorts objects of list, use compare func if given

A tuple is a collection of objects which ordered and immutable. Tuples are sequences, just like lists. The main difference between the tuples and the lists is that the tuples cannot be changed unlike lists. Tuples use parentheses, whereas lists use square brackets.

Creating a tuple is as simple as putting different comma-separated values. Optionally, you can put these comma-separated values between parentheses also. For example −

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

The empty tuple is written as two parentheses containing nothing −

tup1 = ();

To write a tuple containing a single value you have to include a comma, even though there is only one value −

tup1 = (50,)

Like string indices, tuple indices start at 0, and they can be sliced, concatenated, and so on.

Accessing Values in Tuples

To access values in tuple, use the square brackets for slicing along with the index or indices to obtain the value available at that index. For example −

#!/usr/bin/python3

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])

When the above code is executed, it produces the following result −

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

Updating Tuples

Tuples are immutable, which means you cannot update or change the values of tuple elements. You are able to take portions of the existing tuples to create new tuples as the following example demonstrates −

#!/usr/bin/python3

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)

When the above code is executed, it produces the following result −

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

Delete Tuple Elements

Removing individual tuple elements is not possible. There is, of course, nothing wrong with putting together another tuple with the undesired elements discarded.

To explicitly remove an entire tuple, just use the del statement. For example −

#!/usr/bin/python3

tup = ('physics', 'chemistry', 1997, 2000);

print (tup)
del tup;
print ("After deleting tup : ")
print (tup)

This produces the following result.

Note − An exception is raised. This is because after del tup, tuple does not exist any more.

('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

Basic Tuples Operations

Tuples respond to the + and * operators much like strings; they mean concatenation and repetition here too, except that the result is a new tuple, not a string.

In fact, tuples respond to all of the general sequence operations we used on strings in the previous chapter.

Python Expression	Results	Description
len((1, 2, 3))	3	Length
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Concatenation
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	Repetition
3 in (1, 2, 3)	True	Membership
for x in (1,2,3) : print (x, end = ' ')	1 2 3	Iteration

Indexing, Slicing, and Matrixes

Since tuples are sequences, indexing and slicing work the same way for tuples as they do for strings, assuming the following input −

T=('C++', 'Java', 'Python')

Python Expression	Results	Description
T[2]	'Python'	Offsets start at zero
T[-2]	'Java'	Negative: count from the right
T[1:]	('Java', 'Python')	Slicing fetches sections

No Enclosing Delimiters

No enclosing Delimiters is any set of multiple objects, comma-separated, written without identifying symbols, i.e., brackets for lists, parentheses for tuples, etc., default to tuples, as indicated in these short examples.

Built-in Tuple Functions

Python includes the following tuple functions −

Sr.No.	Function & Description
1	cmp(tuple1, tuple2) Compares elements of both tuples.
2	len(tuple) Gives the total length of the tuple.
3	max(tuple) Returns item from the tuple with max value.
4	min(tuple) Returns item from the tuple with min value.
5	tuple(seq) Converts a list into tuple.

Each key is separated from its value by a colon (:), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: {}.

Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

Accessing Values in Dictionary

To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value. Following is a simple example −

#!/usr/bin/python3

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

When the above code is executed, it produces the following result −

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

If we attempt to access a data item with a key, which is not a part of the dictionary, we get an error as follows −

#!/usr/bin/python3

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

When the above code is executed, it produces the following result −

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

Updating Dictionary

You can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry as shown in a simple example given below.

#!/usr/bin/python3

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'])

When the above code is executed, it produces the following result −

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

Delete Dictionary Elements

You can either remove individual dictionary elements or clear the entire contents of a dictionary. You can also delete entire dictionary in a single operation.

To explicitly remove an entire dictionary, just use the del statement. Following is a simple example −

#!/usr/bin/python3

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'])

This produces the following result.

An exception is raised because after del dict, the dictionary does not exist anymore.

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 − The del() method is discussed in subsequent section.

Properties of Dictionary Keys

Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.

There are two important points to remember about dictionary keys −

(a) More than one entry per key is not allowed. This means no duplicate key is allowed. When duplicate keys are encountered during assignment, the last assignment wins. For example −

#!/usr/bin/python3

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

When the above code is executed, it produces the following result −

dict['Name']:  Manni

(b) Keys must be immutable. This means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example −

#!/usr/bin/python3

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

When the above code is executed, it produces the following result −

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

Built-in Dictionary Functions and Methods

Python includes the following dictionary functions −

Sr.No.	Function & Description
1	cmp(dict1, dict2) No longer available in Python 3.
2	len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary.
3	str(dict) Produces a printable string representation of a dictionary
4	type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type.

Python includes the following dictionary methods −

Sr.No.	Method & Description
1	dict.clear() Removes all elements of dictionary dict
2	dict.copy() Returns a shallow copy of dictionary dict
3	dict.fromkeys() Create a new dictionary with keys from seq and values set to value.
4	dict.get(key, default=None) For key key, returns value or default if key not in dictionary
5	dict.has_key(key) Removed, use the in operation instead.
6	dict.items() Returns a list of dict's (key, value) tuple pairs
7	dict.keys() Returns list of dictionary dict's keys
8	dict.setdefault(key, default = None) Similar to get(), but will set dict[key] = default if key is not already in dict
9	dict.update(dict2) Adds dictionary dict2's key-values pairs to dict
10	dict.values() Returns list of dictionary dict's values

A Python program can handle date and time in several ways. Converting between date formats is a common chore for computers. Python's time and calendar modules help track dates and times.

What is Tick?

Time intervals are floating-point numbers in units of seconds. Particular instants in time are expressed in seconds since 12:00am, January 1, 1970(epoch).

There is a popular time module available in Python which provides functions for working with times, and for converting between representations. The function time.time() returns the current system time in ticks since 12:00am, January 1, 1970(epoch).

Example

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

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

This would produce a result something as follows −

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

Date arithmetic is easy to do with ticks. However, dates before the epoch cannot be represented in this form. Dates in the far future also cannot be represented this way - the cutoff point is sometime in 2038 for UNIX and Windows.

What is TimeTuple?

Many of the Python's time functions handle time as a tuple of 9 numbers, as shown below −

Index	Field	Values
0	4-digit year	2016
1	Month	1 to 12
2	Day	1 to 31
3	Hour	0 to 23
4	Minute	0 to 59
5	Second	0 to 61 (60 or 61 are leap-seconds)
6	Day of Week	0 to 6 (0 is Monday)
7	Day of year	1 to 366 (Julian day)
8	Daylight savings	-1, 0, 1, -1 means library determines DST

For Example −

import time

print (time.localtime());

This would produce a result as follows −

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9, 
   tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

The above tuple is equivalent to struct_time structure. This structure has following attributes −

Index	Attributes	Values
0	tm_year	2016
1	tm_mon	1 to 12
2	tm_mday	1 to 31
3	tm_hour	0 to 23
4	tm_min	0 to 59
5	tm_sec	0 to 61 (60 or 61 are leap-seconds)
6	tm_wday	0 to 6 (0 is Monday)
7	tm_yday	1 to 366 (Julian day)
8	tm_isdst	-1, 0, 1, -1 means library determines DST

Getting current time

To translate a time instant from seconds since the epoch floating-point value into a timetuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple with all valid nine items.

#!/usr/bin/python3
import time

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

This would produce the following result, which could be formatted in any other presentable form −

Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, 
   tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

Getting formatted time

You can format any time as per your requirement, but a simple method to get time in a readable format is asctime() −

Demonstração ao vivo

#!/usr/bin/python3
import time

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

Isso produziria o seguinte resultado -

Local current time : Mon Feb 15 09:34:03 2016

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/python3
import calendar

cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)

Isso produziria o seguinte resultado -

Here is the calendar:
   February 2016
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

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.	Descrição da funçã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 isto 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.

Existem dois atributos importantes disponíveis com o módulo de tempo. Eles são -

Sr. Não.	Atributo e 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 mudar isso, ligue para ocalendar.setfirstweekday() função.

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

Sr. Não.	Descrição da funçã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 dá a ela 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á um exemplo para chamar oprintme() função -

#!/usr/bin/python3

# 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("This is first call to the user defined function!")
printme("Again second call to the same function")

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

This is first call to the user defined function!
Again second call to the same function

Passagem por referência x 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/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", 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. Portanto, isso produziria o seguinte resultado -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

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/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4] # This would assi 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 Requeridos

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 maneira -

#!/usr/bin/python3

# 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 oprintme() funcionar das seguintes maneiras -

#!/usr/bin/python3

# 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/python3

# 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/python3

# 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 é fornecida abaixo -

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/python3

# 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 o defpalavra-chave. Você pode usar olambda palavra-chave 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 lambdas sejam 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 objetivo é empilhar a alocação passando uma função, durante a chamada por motivos de desempenho.

Sintaxe

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

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

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

#!/usr/bin/python3

# 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 fornecidos abaixo não estão retornando nenhum valor. Você pode retornar um valor de uma função da seguinte maneira -

#!/usr/bin/python3

# 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/python3

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. oimport 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 hello.py, você precisa colocar o seguinte comando no topo do script -

#!/usr/bin/python3

# 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

Python's frominstrução permite importar atributos específicos de um módulo para o namespace atual. ofrom...import 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 -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

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.

Executando Módulos como Scripts

Dentro de um módulo, o nome do módulo (como uma string) está disponível como o valor da variável global __name__. O código no módulo será executado, como se você importasse, mas com o __name__ definido como "__main__".

Adicione este código no final do seu módulo -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

Quando você executa o código acima, a seguinte saída será exibida.

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

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 pesquisará 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 / python3 /.

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:\python34\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/python3

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/python3

# 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 ()

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

E se locals() é chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados localmente a partir dessa função.
E se globals() é 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 okeys() função.

A função reload ()

Quando um 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 possui a seguinte linha de código-fonte -

#!/usr/bin/python3

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

Similarmente, temos outros dois arquivos com funções diferentes com o mesmo nome acima. Eles são -

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 Phone -

Phone/__init__.py

Para disponibilizar todas as suas funções ao importar 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/python3

# 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, pegamos 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 no Python 3. Para 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/python3

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 2 tem duas funções integradas para ler dados de entrada padrão, que por padrão vem do teclado. Essas funções sãoinput() e raw_input()

No Python 3, a função raw_input () está obsoleta. Além disso, as funções input () lêem os dados do teclado como string, independentemente de estarem entre aspas ('' ou "") ou não.

A função de entrada

o input([prompt]) function é 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/python3

>>> x = input("something:")
something:10

>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''

>>> x
"'10'"

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.	Modo 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 a um 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.

Note - o atributo softspace não é compatível com Python 3.x

Exemplo

#!/usr/bin/python3

# 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)
fo.close()

Isso produz o seguinte resultado -

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

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/python3

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

# Close opened 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 usarread() e write() métodos para ler e gravar arquivos.

O método write ()

o write()método 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/python3

# Open a file
fo = open("foo.txt", "w")
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ê abrisse este arquivo, ele teria o seguinte conteúdo -

Python is a great language.
Yeah its great!!

Método read ()

o read()método 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/python3

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

# Close opened 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. ooffsetargumento indica o número de bytes a serem movidos. ofrom argumento especifica a posição de referência de onde os bytes devem ser movidos.

Se de for definido como 0, o início do arquivo é usado como a posição de referência. Se for definido como 1, a posição atual é usada como posição de referência. Se for definido como 2, o final do arquivo será considerado a posição de referência.

Exemplo

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

#!/usr/bin/python3

# 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 opened 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 rename() método 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á um exemplo para renomear um arquivo existente test1.txt -

#!/usr/bin/python3
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 remove() método para excluir arquivos, fornecendo o nome do arquivo a ser excluído como o argumento.

Sintaxe

os.remove(file_name)

Exemplo

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

#!/usr/bin/python3
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 mkdir() método do osmó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á um exemplo para criar um teste de diretório no diretório atual -

#!/usr/bin/python3
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á um exemplo para ir para o diretório "/ home / newdir" -

#!/usr/bin/python3
import os

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

O método getcwd ()

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

Sintaxe

os.getcwd()

Exemplo

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

#!/usr/bin/python3
import os

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

O método rmdir ()

o rmdir() método 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á um 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/python3
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 file objeto fornece funções para manipular arquivos.
Métodos de objeto de sistema operacional

Isso 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 Assertions in Python 3 .

Exceções padrão

Aqui está uma lista de exceções padrão disponíveis em Python. -

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	ZeroDivisonError 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	OSError 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. Se eles não forem tratados, eles encerrarão o programa e produzirão um rastreamento.

Exemplo

Aqui está uma função que converte uma determinada temperatura de graus Kelvin para graus Fahrenheit. Já que 0 ° K é o mais frio possível, a função desiste se vê uma temperatura negativa -

#!/usr/bin/python3

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/python3

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/python3

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. ofinally:bloco é um local para colocar qualquer código que deva ser executado, quer o bloco try tenha gerado 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.
   ......................

Note- Você pode fornecer cláusula (s) except, ou uma cláusula finally, mas não ambas. Você não pode usar a cláusula else também junto com uma cláusula finally.

Exemplo

#!/usr/bin/python3

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")
   fh.close()

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/python3

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")

Isso produz o seguinte resultado -

Going to close the file

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 as 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/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as 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 Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

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

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

O exemplo a seguir ilustra o uso de levantar uma exceção -

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

Isso produzirá o seguinte resultado

error in level argument -10

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 o tempo em que existiu. Devido a isso, 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 à Programação Orientada a Objetos (OOP) para ajudá-lo -

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á um 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 de a nesta 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/python3

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.salary = 7000  # Add an 'salary' attribute.
emp1.name = 'xyz'  # Modify 'age' attribute.
del emp1.salary  # 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, 'salary')    # Returns true if 'salary' attribute exists
getattr(emp1, 'salary')    # Returns value of 'salary' attribute
setattr(emp1, 'salary', 7000) # Set attribute 'salary' at 7000
delattr(emp1, 'salary')    # Delete attribute 'salary'

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/python3

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)

emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
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__: (<class 'object'>,)
Employee.__dict__: {
   'displayCount': <function Employee.displayCount at 0x0160D2B8>, 
   '__module__': '__main__', '__doc__': 'Common base class for all employees', 
   'empCount': 2, '__init__': 
   <function Employee.__init__ at 0x0124F810>, 'displayEmployee': 
   <function Employee.displayEmployee at 0x0160D300>,
   '__weakref__': 
   <attribute '__weakref__' of 'Employee' objects>, '__dict__': 
   <attribute '__dict__' of 'Employee' objects>
}

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. No entanto, 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/python3

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 -

140338326963984 140338326963984 140338326963984
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 import .

No exemplo acima, assumindo que a definição de uma classe Point está contida em point.py e não há nenhum outro código executável nele.

#!/usr/bin/python3
import point

p1 = point.Point()

Herança de classe

Em vez de começar do zero, você pode criar uma classe derivando-a de uma classe pré-existente 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/python3

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 a partir de várias classes pai da seguinte maneira -

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

class B:         # define your calss 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 True, se a subclasse fornecida sub é de fato uma subclasse da superclasse sup.
o isinstance(obj, Class)a função booleana retorna True, se obj é 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 é que você pode desejar uma funcionalidade especial ou diferente em sua subclasse.

Exemplo

#!/usr/bin/python3

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/python3

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/python3

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. ore módulo levanta a exceção re.error se ocorrer um erro ao compilar ou usar uma expressão regular.

Cobriríamos duas funções importantes, que seriam usadas para lidar com expressões regulares. No entanto, 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'.

Padrões básicos que correspondem a caracteres únicos

Sr. Não.	Expressão e correspondências
1	a, X, 9, < caracteres comuns apenas combinam com eles mesmos.
2	. (a period) corresponde a qualquer caractere único, exceto nova linha '\ n'
3	\w corresponde a um caractere de "palavra": uma letra ou dígito ou barra [a-zA-Z0-9_].
4	\W corresponde a qualquer caractere diferente de palavra.
5	\b limite entre palavra e não palavra
6	\s corresponde a um único caractere de espaço em branco - espaço, nova linha, retorno, tabulação
7	\S corresponde a qualquer caractere diferente de espaço em branco.
8	\t, \n, \r guia, nova linha, retorno
9	\d dígito decimal [0-9]
10	^ corresponde ao início da string
11	$ coincidir com o final da corda
12	\ inibir o "especialismo" de um personagem.

Sinalizadores de compilação

Sinalizadores de compilação permitem modificar alguns aspectos de como as expressões regulares funcionam. Sinalizadores estão disponíveis no módulo re sob dois nomes, um nome longo, comoIGNORECASE e uma forma curta de uma letra, como I.

Sr. Não.	Bandeira e Significado
1	ASCII, A Faz com que vários escapes, como \ w, \ b, \ se \ d correspondam apenas em caracteres ASCII com a respectiva propriedade.
2	DOTALL, S Faça, combine qualquer caractere, incluindo novas linhas
3	IGNORECASE, I Faça correspondências que não diferenciam maiúsculas de minúsculas
4	LOCALE, L Faça uma correspondência de acordo com a localidade
5	MULTILINE, M Correspondência multilinha, afetando ^ e $
6	VERBOSE, X (for ‘extended’) Habilite REs verbosos, que podem ser organizados de forma mais limpa e compreensível

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/python3
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é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/python3
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 -

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.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/python3
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 --> matchObj.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 em string por repl , substituindo todas as ocorrências, a menos que max seja fornecido. Este método retorna uma string modificada.

Exemplo

#!/usr/bin/python3
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 os 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 -

Aqui está a lista de sintaxe de expressão regular em Python.

Sr. Não.	Parâmetro 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 não-palavra.
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 Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')

Note- A primeira linha do script deve ser o caminho para o executável Python. No Linux, deve ser #! / Usr / bin / python3

Insira o seguinte URL no seu navegador

http://localhost:8080/cgi-bin/hello.py

Hello Word! 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
SQLite

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

Python tem um suporte embutido para SQLite. Nesta seção, aprenderíamos todos os conceitos usando MySQL. O módulo MySQLdb, uma interface popular com MySQL, não é compatível com Python 3. Em vez disso, usaremos o módulo PyMySQL .

O que é PyMySQL?

PyMySQL é 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 contém uma biblioteca de cliente MySQL em Python puro. O objetivo do PyMySQL é ser um substituto imediato para o MySQLdb.

Como faço para instalar o PyMySQL?

Antes de prosseguir, verifique se o PyMySQL está instalado em sua máquina. Basta digitar o seguinte em seu script Python e executá-lo -

#!/usr/bin/python3

import pymysql

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 pymysql
ImportError: No module named pymysql

A última versão estável está disponível no PyPI e pode ser instalada com pip -

pip install pymysql

Alternativamente (por exemplo, se o pip não estiver disponível), um tarball pode ser baixado do GitHub e instalado com Setuptools da seguinte maneira -

$ # X.X is the desired pymysql version (e.g. 0.5 or 0.6).
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL*
$ python setup.py install $ # The folder PyMySQL* can be safely removed now.

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 dos seguintes pontos -

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.
Módulo Python PyMySQL está instalado corretamente em sua máquina.
Você passou pelo tutorial do MySQL para entender os fundamentos do MySQL.

Exemplo

A seguir está um exemplo de conexão com o banco de dados MySQL "TESTDB" -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.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 produz o seguinte resultado.

Database version : 5.5.20-log

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. Finalmente, antes de sair, ele garante que a conexão com o banco de dados seja fechada e os recursos sejam 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 uma tabela de banco de dados EMPLOYEE -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.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

A operação INSERT é necessária 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/python3

import pymysql

# Open database connection
db = pymysql.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/python3

import pymysql

# Open database connection
db = pymysql.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

O segmento de código a seguir é 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 a conexão com o banco de dados for estabelecida, você estará pronto para fazer uma consulta a esse banco de dados. Você pode usar qualquerfetchone() método para buscar um único registro ou fetchall() método para buscar 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/python3

import pymysql

# Open database connection
db = pymysql.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 = "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 fetch data")

# disconnect from server
db.close()

Resultado

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/python3

import pymysql

# Open database connection
db = pymysql.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/python3

import pymysql

# Open database connection
db = pymysql.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á 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 é uma 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 o 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 o rollback() método.

Aqui está um exemplo simples para chamar o 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 aos 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 uma compreensão sobre o conceito mais famoso em Rede - Programação de Soquete.

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. Não.	Método e Descrição
1	s.bind() Este método liga o endereço (nome do host, par de número da porta) ao soquete.
2	s.listen() Este método configura e inicia o listener TCP.
3	s.accept() Isso aceita passivamente a conexão do cliente TCP, aguardando até que a conexão chegue (bloqueio).

Métodos de soquete de cliente

Sr. Não.	Método e Descrição
1	s.connect() Este método inicia ativamente a conexão do servidor TCP.

Métodos Gerais de Soquete

Sr. Não.	Método e Descrição
1	s.recv() Este método recebe mensagem TCP
2	s.send() Este método transmite mensagem TCP
3	s.recvfrom() Este método recebe mensagem UDP
4	s.sendto() Este método transmite mensagem UDP
5	s.close() Este método fecha o soquete
6	socket.gethostname() Retorna o nome do host.

Um servidor simples

Para escrever servidores de Internet, usamos o socketfunção disponível no módulo de soquete para criar um objeto de soquete. Um objeto de soquete é então usado para chamar outras funções para configurar um servidor de soquete.

Agora chame o bind(hostname, port)função para especificar uma porta para seu serviço no host fornecido.

Em seguida, chame o método de aceitação do objeto retornado. Este método espera até que um cliente se conecte à porta que você especificou e, em seguida, retorna um objeto de conexão que representa a conexão com esse cliente.

#!/usr/bin/python3           # This is server.py file
import socket                                         

# create a socket object
serversocket = socket.socket(
	        socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999                                           

# bind to the port
serversocket.bind((host, port))                                  

# queue up to 5 requests
serversocket.listen(5)                                           

while True:
   # establish a connection
   clientsocket,addr = serversocket.accept()      

   print("Got a connection from %s" % str(addr))
    
   msg = 'Thank you for connecting'+ "\r\n"
   clientsocket.send(msg.encode('ascii'))
   clientsocket.close()

Um cliente simples

Vamos escrever um programa cliente muito simples que abre uma conexão para uma determinada porta 12345 e um determinado host. É muito simples criar um cliente de soquete usando a função de módulo de soquete do Python .

o socket.connect(hosname, port )abre uma conexão TCP para o nome do host na porta . Depois de ter um soquete aberto, você pode ler dele como qualquer objeto IO. Quando terminar, lembre-se de fechá-lo, da mesma forma que fecharia um arquivo.

Exemplo

O código a seguir é um cliente muito simples que se conecta a um determinado host e porta, lê todos os dados disponíveis do soquete e sai -

#!/usr/bin/python3           # This is client.py file

import socket

# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999

# connection to hostname on the port.
s.connect((host, port))                               

# Receive no more than 1024 bytes
msg = s.recv(1024)                                     

s.close()
print (msg.decode('ascii'))

Agora execute este server.py em segundo plano e execute o client.py acima para ver o resultado.

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

Resultado

Isso produziria o seguinte resultado -

on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting

Módulos de Internet Python

Uma lista de alguns módulos importantes na rede Python / programação da Internet é fornecida abaixo -

Protocolo	Função comum	Port No	Módulo Python
HTTP	paginas web	80	httpplib, urllib, xmlrpclib
NNTP	Notícias Usenet	119	nntplib
FTP	Transferência de arquivos	20	ftplib, urllib
SMTP	Enviando email	25	smtplib
POP3	Buscando e-mail	110	poplib
IMAP4	Buscando e-mail	143	imaplib
Telnet	Linhas de comando	23	telnetlib
Gopher	Transferências de documentos	70	gopherlib, urllib

Verifique todas as bibliotecas mencionadas acima para trabalhar com os protocolos FTP, SMTP, POP e IMAP.

Leituras adicionais

Este foi um início rápido com a Programação de Soquete. É um assunto vasto. Recomenda-se acessar o seguinte link para obter mais detalhes -

Programação de soquetes Unix .
Módulos e biblioteca de soquetes Python .

O protocolo SMTP (Simple Mail Transfer Protocol) é um protocolo que lida com o envio de e-mail e o roteamento de e-mail entre servidores de e-mail.

Python fornece smtplib módulo, que define um objeto de sessão de cliente SMTP que pode ser usado para enviar e-mails a qualquer máquina da Internet com um daemon listener SMTP ou ESMTP.

Esta é uma sintaxe simples para criar um objeto SMTP, que pode ser usado posteriormente para enviar um e-mail -

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

Aqui está o detalhe dos parâmetros -

host- Este é o host que executa seu servidor SMTP. Você pode especificar o endereço IP do host ou um nome de domínio como tutorialspoint.com. Este é um argumento opcional.
port- Se você estiver fornecendo um argumento de host , será necessário especificar uma porta, onde o servidor SMTP está escutando. Normalmente, essa porta seria 25.
local_hostname- Se o seu servidor SMTP estiver sendo executado em sua máquina local, você pode especificar apenas a opção localhost .

Um objeto SMTP tem um método de instância chamado sendmail, que normalmente é usado para fazer o trabalho de enviar uma mensagem. Leva três parâmetros -

O remetente - uma string com o endereço do remetente.
Os destinatários - uma lista de strings, uma para cada destinatário.
A mensagem - uma mensagem como uma string formatada conforme especificado nas várias RFCs.

Exemplo

Esta é uma maneira simples de enviar um e-mail usando o script Python. Experimente uma vez -

#!/usr/bin/python3

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"

Aqui, você colocou um e-mail básico na mensagem, usando aspas triplas, cuidando para formatar os cabeçalhos corretamente. Um e-mail requer umFrom, To, e um Subject cabeçalho, separado do corpo do e-mail por uma linha em branco.

Para enviar o e-mail, use smtpObj para se conectar ao servidor SMTP na máquina local. Em seguida, use o método sendmail junto com a mensagem, o endereço de e o endereço de destino como parâmetros (embora os endereços de e para estejam dentro do próprio e-mail, eles nem sempre são usados para encaminhar o e-mail).

Se você não estiver executando um servidor SMTP em sua máquina local, poderá usar o cliente smtplib para se comunicar com um servidor SMTP remoto. A menos que você esteja usando um serviço de webmail (como gmail ou Yahoo! Mail), seu provedor de e-mail deve ter fornecido a você os detalhes do servidor de correio de saída que você pode fornecer, da seguinte maneira -

mail = smtplib.SMTP('smtp.gmail.com', 587)

Envio de um e-mail HTML usando Python

Quando você envia uma mensagem de texto usando Python, todo o conteúdo é tratado como texto simples. Mesmo se você incluir tags HTML em uma mensagem de texto, ela será exibida como texto simples e as tags HTML não serão formatadas de acordo com a sintaxe HTML. No entanto, o Python oferece uma opção para enviar uma mensagem HTML como uma mensagem HTML real.

Ao enviar uma mensagem de e-mail, você pode especificar uma versão Mime, tipo de conteúdo e o conjunto de caracteres para enviar um e-mail em HTML.

Exemplo

A seguir está um exemplo para enviar o conteúdo HTML como um e-mail. Experimente uma vez -

#!/usr/bin/python3

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"

Envio de anexos por e-mail

Para enviar um e-mail com conteúdo misto, é necessário definir o Content-type cabeçalho para multipart/mixed. Então, o texto e as seções de anexo podem ser especificados dentroboundaries.

Um limite é iniciado com dois hifens seguidos por um número exclusivo, que não pode aparecer na parte da mensagem do e-mail. Um limite final denotando a seção final do e-mail também deve terminar com dois hifens.

Os arquivos anexados devem ser codificados com o pack("m") função para ter codificação de base 64 antes da transmissão.

Exemplo

A seguir está um exemplo, que envia um arquivo /tmp/test.txtcomo um anexo. Experimente uma vez -

#!/usr/bin/python3

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")

Executar vários threads é semelhante a executar vários programas diferentes simultaneamente, mas com os seguintes benefícios -

Vários threads em um processo compartilham o mesmo espaço de dados com o thread principal e podem, portanto, compartilhar informações ou se comunicar uns com os outros mais facilmente do que se fossem processos separados.
Os threads às vezes são chamados de processos leves e não requerem muita sobrecarga de memória; eles são mais baratos do que processos.

Um thread tem um início, uma sequência de execução e uma conclusão. Ele tem um ponteiro de instrução que mantém o controle de onde dentro do contexto ele está sendo executado.

Pode ser antecipado (interrompido).
Ele pode ser temporariamente colocado em espera (também conhecido como suspensão) enquanto outros threads estão em execução - isso é chamado de rendição.

Existem dois tipos diferentes de tópicos -

fio do kernel
discussão do usuário

Os threads do kernel fazem parte do sistema operacional, enquanto os threads do espaço do usuário não são implementados no kernel.

Existem dois módulos que suportam o uso de threads em Python3 -

_thread
threading

O módulo thread está "obsoleto" há muito tempo. Os usuários são incentivados a usar o módulo de threading. Conseqüentemente, no Python 3, o módulo "thread" não está mais disponível. No entanto, ele foi renomeado para "_thread" para compatibilidade com versões anteriores em Python3.

Iniciando um Novo Tópico

Para gerar outro thread, você precisa chamar o seguinte método disponível no módulo de thread -

_thread.start_new_thread ( function, args[, kwargs] )

Essa chamada de método permite uma maneira rápida e eficiente de criar novos threads no Linux e no Windows.

A chamada do método retorna imediatamente e o thread filho inicia e chama a função com a lista de argumentos passada . Quando a função retorna, o thread termina.

Aqui, args é uma tupla de argumentos; use uma tupla vazia para chamar a função sem passar nenhum argumento. kwargs é um dicionário opcional de argumentos de palavras-chave.

Exemplo

#!/usr/bin/python3

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

Resultado

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

Thread-1: Fri Feb 19 09:41:39 2016
Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016

O programa segue em um loop infinito. Você terá que pressionar ctrl-c para parar

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 então iniciar uma nova thread invocando start () , que por sua vez chama o método run () .

Exemplo

#!/usr/bin/python3

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, delay, counter):
   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()
thread1.join()
thread2.join()
print ("Exiting Main Thread")

Resultado

Quando executamos o programa acima, ele produz o seguinte resultado -

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread

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 dos 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/python3

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")

Resultado

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

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
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/python3

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")

Resultado

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 manter o controle de 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 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 dos 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 os detalhes 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 os detalhes 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 os detalhes 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/python3

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")

Resultado

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 scientific 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 os 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 um documento XML rapidamente 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 parse (file [, parser]) do objeto minidom para analisar o arquivo XML, designado por arquivo em um objeto de árvore DOM.

Exemplo

#!/usr/bin/python3

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)

Resultado

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 scientific 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 recursos 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 wxWidgets GUI toolkit. Você pode encontrar um tutorial completo sobre WxPython aqui .
PyQt−Esta é também uma interface Python para uma popular biblioteca Qt de plataforma cruzada GUI. O TutorialsPoint tem um tutorial muito bom sobre PyQt aqui .
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/python3

import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Python 3
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 The Scrollbar widget is used to add scrolling capability to various widgets, such as list boxes.
14	Text The Text widget is used to display text in multiple lines.
15	Toplevel The Toplevel widget is used to provide a separate window container.
16	Spinbox The Spinbox widget is a variant of the standard Tkinter Entry widget, which can be used to select from a fixed number of values.
17	PanedWindow A PanedWindow is a container widget that may contain any number of panes, arranged horizontally or vertically.
18	LabelFrame A labelframe is a simple container widget. Its primary purpose is to act as a spacer or container for complex window layouts.
19	tkMessageBox This module is used to display message boxes in your applications.

Standard attributes

Let us look at how some of their common attributes, such as sizes, colors and fonts are specified.

Dimensions
Colors
Fonts
Anchors
Relief styles
Bitmaps
Cursors

Geometry Management

All Tkinter widgets have access to the specific geometry management methods, which have the purpose of organizing widgets throughout the parent widget area. Tkinter exposes the following geometry manager classes: pack, grid, and place.

The pack() Method − This geometry manager organizes widgets in blocks before placing them in the parent widget.
The grid() Method − This geometry manager organizes widgets in a table-like structure in the parent widget.
The place() Method − This geometry manager organizes widgets by placing them in a specific position in the parent widget.

Any code that you write using any compiled language like C, C++, or Java can be integrated or imported into another Python script. This code is considered as an "extension."

A Python extension module is nothing more than a normal C library. On Unix machines, these libraries usually end in .so (for shared object). On Windows machines, you typically see .dll (for dynamically linked library).

Pre-Requisites for Writing Extensions

To start writing your extension, you are going to need the Python header files.

On Unix machines, this usually requires installing a developer-specific package such as .
Windows users get these headers as part of the package when they use the binary Python installer.

Additionally, it is assumed that you have a good knowledge of C or C++ to write any Python Extension using C programming.

First look at a Python Extension

For your first look at a Python extension module, you need to group your code into four part −

The header file Python.h.
The C functions you want to expose as the interface from your module.
A table mapping the names of your functions as Python developers see them as C functions inside the extension module.
An initialization function.

The Header File Python.h

You need to include Python.h header file in your C source file, which gives you the access to the internal Python API used to hook your module into the interpreter.

Make sure to include Python.h before any other headers you might need. You need to follow the includes with the functions you want to call from Python.

The C Functions

The signatures of the C implementation of your functions always takes one of the following three forms −

static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

Each one of the preceding declarations returns a Python object. There is no such thing as a void function in Python as there is in C. If you do not want your functions to return a value, return the C equivalent of Python's None value. The Python headers define a macro, Py_RETURN_NONE, that does this for us.

The names of your C functions can be whatever you like as they are never seen outside of the extension module. They are defined as static function.

Your C functions usually are named by combining the Python module and function names together, as shown here −

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

This is a Python function called func inside the module module. You will be putting pointers to your C functions into the method table for the module that usually comes next in your source code.

The Method Mapping Table

This method table is a simple array of PyMethodDef structures. That structure looks something like this −

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

Here is the description of the members of this structure −

ml_name − This is the name of the function as the Python interpreter presents when it is used in Python programs.
ml_meth − This is the address of a function that has any one of the signatures described in the previous section.
ml_flags − This tells the interpreter which of the three signatures ml_meth is using.
- This flag usually has a value of METH_VARARGS.
- This flag can be bitwise OR'ed with METH_KEYWORDS if you want to allow keyword arguments into your function.
- This can also have a value of METH_NOARGS that indicates you do not want to accept any arguments.
ml_doc − This is the docstring for the function, which could be NULL if you do not feel like writing one.

This table needs to be terminated with a sentinel that consists of NULL and 0 values for the appropriate members.

Example

For the above-defined function, we have the following method mapping table −

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

The Initialization Function

The last part of your extension module is the initialization function. This function is called by the Python interpreter when the module is loaded. It is required that the function be named initModule, where Module is the name of the module.

The initialization function needs to be exported from the library you will be building. The Python headers define PyMODINIT_FUNC to include the appropriate incantations for that to happen for the particular environment in which we are compiling. All you have to do is use it when defining the function.

Your C initialization function generally has the following overall structure −

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Here is the description of Py_InitModule3 function −

func − This is the function to be exported.
module_methods − This is the mapping table name defined above.
docstring − This is the comment you want to give in your extension.

Putting all this together, it looks like the following −

#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...");
}

Example

A simple example that makes use of all the above concepts −

#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!");
}

Here the Py_BuildValue function is used to build a Python value. Save above code in hello.c file. We would see how to compile and install this module to be called from Python script.

Building and Installing Extensions

The distutils package makes it very easy to distribute Python modules, both pure Python and extension modules, in a standard way. Modules are distributed in the source form, built and installed via a setup script usually called setup.py as.

For the above module, you need to prepare the following setup.py script −

from distutils.core import setup, Extension
setup(name = 'helloworld', version = '1.0',  \
   ext_modules = [Extension('helloworld', ['hello.c'])])

Now, use the following command, which would perform all needed compilation and linking steps, with the right compiler and linker commands and flags, and copies the resulting dynamic library into an appropriate directory −

$ python setup.py install

On Unix-based systems, you will most likely need to run this command as root in order to have permissions to write to the site-packages directory. This usually is not a problem on Windows.

Importing Extensions

Once you install your extensions, you would be able to import and call that extension in your Python script as follows −

Example

#!/usr/bin/python3
import helloworld

print helloworld.helloworld()

Output

This would produce the following result −

Hello, Python extensions!!

Passing Function Parameters

As you will most likely want to define functions that accept arguments, you can use one of the other signatures for your C functions. For example, the following function, that accepts some number of parameters, would be defined like this −

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;
}

Resultado

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 o 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 foi 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 o 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 capturado 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 em um 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.

Python 3 - Guia rápido

O módulo __future__

A função de impressão

Ler entrada do teclado

Divisão Inteira

Representação Unicode

Função xrange () removida

levantar exceção

Argumentos em exceções

Função next () e Método .next ()

Utilitário 2to3

História do Python

Recursos do Python

Configuração de ambiente local

Obtendo Python

Plataforma Windows

Plataforma Linux

Mac OS

Configurando PATH

Configurando caminho em Unix / Linux

Configurando Caminho no Windows

Variáveis ​​de ambiente Python

Executando Python

Intérprete Interativo

Script da linha de comando

Ambiente de desenvolvimento integrado

Primeiro programa Python

Programação de modo interativo

Programação em modo script

Identificadores Python

Palavras reservadas

Linhas e recuo

Declarações de várias linhas

Cotação em Python

Comentários em Python

Usando linhas em branco

Esperando pelo Usuário

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

Vários grupos de extrato como suítes

Argumentos de linha de comando

Atribuição de valores a variáveis

Atribuição múltipla

Tipos de dados padrão

Números Python

Exemplos

Python Strings

Listas Python

Python Tuples

Dicionário Python

Conversão de Tipo de Dados

Tipos de Operador

Operadores aritméticos Python

Operadores de comparação Python

Operadores de atribuição Python

Operadores bit a bit Python

Operadores lógicos Python

Operadores de associação Python

Operadores de identidade Python

Precedência de operadores Python

Suítes de declaração única

Exemplo

Resultado

Declarações de controle de loop

Iterador e gerador

Exemplo

Exemplos

Conversão de tipo de número

Funções Matemáticas

Funções de números aleatórios

Funções trigonométricas

Constantes Matemáticas

Acessando Valores em Strings

Atualizando Strings

Personagens de Fuga

Operadores especiais de string

Operador de formatação de string

Citações Triplas

String Unicode

Métodos de string integrados

Python Lists

O módulo future

Variáveis de ambiente Python

Variáveis globais vs. locais