E.E.

B Romildo Czepanhick
Curso técnico em informática

Python

Professor: Dênis Torres

Aluno (a): Kemily de Almeida
Série:2° ano do ensino médio TEC

Xanxerê,17 de fevereiro de 2025

1
Sumário
1. Introdução................................................................................................................4
1.1. O que é...............................................................................................................4
2. Qual são os benefícios do python...........................................................................4
2.1. Código Fácil de Ler e Manter..........................................................................4
2.2. Alta Compatibilidade.......................................................................................4
2.3. Biblioteca Padrão Poderosa.............................................................................5
2.4. Numerosos Modelos de Programação.............................................................5
2.5. Simplificar o Desenvolvimento de Software Complexo.................................5
2.6. Vários Frameworks e Ferramentas Open-source..........................................5
2.7. Desenvolvimento Orientado a Testes..............................................................5
2.8. Prós e Contras do Python.................................................................................5
3. História do python...................................................................................................6
3.1. O início de Python.............................................................................................6
3.2. Guido van Rossum e a criação de Python.......................................................6
3.3. O lançamento da primeira versão de Python.................................................7
3.4. O crescimento e a popularidade de Python....................................................7
3.5. Python e sua influência na indústria de programação..................................8
3.6. Marcos Importantes no Desenvolvimento do Python (2000 - 2020)............9
4. Recursos do python.................................................................................................9
4.1. Quais são os principais recursos do python....................................................9
4.2.1. O Poder da Else em Loops..........................................................................10
4.2.2. A Ordem dos Imports Impacta o Código..................................................10
4.2.3. O Uso de _ como Variável Temporária.....................................................11
4.2.4. O Método __repr__() Esquecido nos Objetos...........................................11
4.2.5. O Decorador @staticmethod é subutilizado.............................................12
4.2.6. Dataclasses e a Simplificação de Classes...................................................12
5. SDK.........................................................................................................................13
5.1. Qual é a diferença entre um SDK e uma API?............................................14
5.2. Cinco exemplos de SDKs................................................................................14
5.2.1. SDKs de listras.........................................................................................14
5.2.2. SDKs do Twilio........................................................................................15
5.2.3. SDKs de API de vitrine do Shopify........................................................15
5.2.4. SDKs da AWS..........................................................................................16
5.2.5. SDKs quadrados......................................................................................16
5.3. SDKs do lado do cliente vs. do lado do servidor..........................................17
 SDKs do lado do cliente..................................................................................17

2
  SDKs do lado do servidor...............................................................................17
6. O que é o Boto3?....................................................................................................18
6.1. Introdução.......................................................................................................18
6.2. Instalação do Boto3.........................................................................................18
6.3. Exemplo Prático: Listando Buckets no Amazon S3....................................18
7. Strings.....................................................................................................................19
7.1. Concatenação de strings.................................................................................19
7.2. Manipulação de strings..................................................................................19
7.3. Fatiamento de strings.....................................................................................20
8. O que é PyCharm?................................................................................................21
8.1. IDE...................................................................................................................21
8.2. Pycharm...........................................................................................................22
9. Quais considerações ao escolher uma biblioteca GUI PYTHON......................22
9.1. Principais considerações antes de escolher uma estrutura de GUI............22
9.1.1. Compatibilidade......................................................................................22
9.1.2. Comunidade e suporte............................................................................22
9.1.3. Desempenho.............................................................................................23
9.1.4. Documentação..........................................................................................23
9.1.5. Licenciamento..........................................................................................23
9.2. Frameworks populares de GUI em Python: prós e contras........................23
9.2.1. Tkinter......................................................................................................23
9.2.2. PyQt/PySide.............................................................................................24
9.2.3. Kivy...........................................................................................................24
9.2.4. wxPython..................................................................................................25
Obras Citadas...................................................................................................................26

3
1. Introdução

A linguagem de programação Python foi criada em 1991 por Guido Van Rossumem,
com a finalidade de ser uma linguagem simples e de fácil compreensão. Apesar de
simples, Python é uma linguagem muito poderosa, que pode ser usada para desenvolver
e administrar grandes sistemas. Uma das principais características que diferencia a
linguagem Python das outras é a legibilidade dos programas escritos. Isto ocorre porque,
em outras linguagens, é muito comum o uso excessivo de marcações (ponto ou ponto e
vírgula), de marcadores (chaves, colchetes ou parênteses) e de palavras especiais
(begin/end), o que torna mais difícil a leitura e compreensão dos programas. Já em
Python, o uso desses recursos é reduzido, deixando a linguagem visualmente mais
limpa, de fácil compreensão e leitura.
Entre outras características existentes na linguagem Python, destaca-se a
simplicidade da linguagem, que facilita o aprendizado da programação. Python também
possui uma portabilidade muito grande para diversas plataformas diferentes, além de ser
possível utilizar trechos de códigos em outras linguagens.
(ADS, 2024)

1.1. O que é

Python é um software livre, ou seja, permite que usuários e colaboradores possam

modificar seu código fonte e compartilhar essas novas atualizações, contribuindo para o
constante aperfeiçoamento da linguagem. A especificação da linguagem é mantida pela
empresa Python Software Foundation (PSF).
Se alguém estiver começando a programar, há poucas linguagens melhores para
começar do que Python. Sua sintaxe é simples, os comandos são baseados em inglês e
seu layout é relativamente direto, facilitando a compreensão de cada linha de código e
sua finalidade, seja o usuário experiente ou não.
Sua simplicidade também significa que Python é a linguagem ideal quando é
necessário um desenvolvimento rápido.
(O que é Python? - A linguagem de programação mais versátil, 2024)

2. Qual são os benefícios do python

Python não alcançou popularidade à toa. Ele oferece diversos recursos e vantagens
úteis para desenvolvedores de diferentes níveis.

2.1. Código Fácil de Ler e Manter

A sintaxe do Python é estruturada e clara, o que facilita tanto a escrita quanto a
manutenção do código. A filosofia de design da linguagem valoriza o uso de
espaços em branco para aumentar a legibilidade. Isso diminui o número de erros que
um desenvolvedor pode cometer e facilita a compreensão do código por quem não o
escreveu, mesmo à primeira vista.

2.2. Alta Compatibilidade

O Python é compatível com uma ampla variedade de plataformas, incluindo
Windows, macOS, Linux e UNIX. Esse suporte multiplataforma o torna ideal para
equipes que operam em diferentes ambientes, permitindo que os desenvolvedores
escrevam códigos que geralmente funcionam com poucas modificações em diversos
sistemas. Para os usuários de macOS, utilizar um VPS MacOS pode oferecer

4
 flexibilidade adicional e recursos dedicados necessários para um desenvolvimento
contínuo em Python.

2.3. Biblioteca Padrão Poderosa

Uma das principais vantagens do Python é sua biblioteca padrão. A grande
quantidade de módulos e pacotes disponíveis na biblioteca padrão permite que os
desenvolvedores realizem diversas tarefas, desde manipulação de arquivos e redes
até gerenciamento e manipulação de bancos de dados, sem a necessidade de recorrer
a bibliotecas de terceiros. Isso resulta numa economia de tempo e esforço durante o
processo de desenvolvimento.

2.4. Numerosos Modelos de Programação

O Python não está restrito a um paradigma de programação específico. Ele se
adapta bem a métodos de programação orientados a objetos, procedimentais e
funcionais. Essa flexibilidade permite que o desenvolvedor escolha a abordagem
mais adequada para seu projeto, oferecendo a adaptabilidade necessária para
diversos tipos de aplicações.

2.5. Simplificar o Desenvolvimento de Software Complexo

O Python é prático e acessível, o que o torna muito útil em projetos complexos
de desenvolvimento de software. Ele possui várias estruturas de dados internas de
alto nível, além de tipagem e vinculação dinâmicas, tornando-o adequado para
grandes aplicações.

2.6. Vários Frameworks e Ferramentas Open-source

O Python também se destaca em comparação com outras linguagens devido ao
seu incrível e crescente ecossistema de frameworks e ferramentas open-source,
como Django, Flask, Pandas, NumPy e TensorFlow. Esses frameworks agilizam o
desenvolvimento, pois oferecem soluções prontas para diversos problemas em
desenvolvimento web, análise de dados, inteligência artificial, entre outros.

2.7. Desenvolvimento Orientado a Testes

O Python apoia o desenvolvimento orientado a testes, uma prática em que os
testes são elaborados antes do código propriamente dito. Frameworks de teste, como
unittest e pytest, tornam a escrita e a execução de testes mais fáceis, assegurando
que seu código seja sempre mais testado e seguro.

2.8. Prós e Contras do Python

Vantagens Desvantagens
Fácil de ler e manter Velocidade de execução mais lenta
Alta compatibilidade entre Alto consumo de memória
plataformas
Biblioteca padrão poderosa Fraco em computação móvel
Suporta múltiplos modelos de Propenso a erros em tempo de execução
programação
Simplifica o desenvolvimento de
software complexo
Extensos frameworks e ferramentas

5
 open-source
Forte suporte da comunidade
(Barreira, 2024)

3. História do python

3.1. O início de Python

O Python teve sua origem na década de 1980, quando Guido van Rossum, um
programador holandês, começou a trabalhar em um projeto chamado Amoeba. Esse
projeto tinha o objetivo de criar uma linguagem de programação intuitiva e fácil de
usar, voltada para fins acadêmicos e tarefas cotidianas de automação.
Ao longo do desenvolvimento do Amoeba, Guido percebeu a necessidade de
uma linguagem mais robusta e decidiu iniciar o desenvolvimento de uma nova
linguagem, que inicialmente chamou de “Python”, inspirado pelo seu amor pelo
grupo de comédia britânico Monty Python.
A primeira versão do Python foi lançada em 1991 e já contava com várias
características que são marcas registradas da linguagem, como a sintaxe clara e
legível, a ênfase na legibilidade do código-fonte e a adoção de uma abordagem
modular.

“Eu queria uma linguagem que fosse poderosa e expressiva, mas também
fácil de ler e entender. O Python foi desenvolvido com o objetivo de ser uma
linguagem que combinasse eficiência e clareza, e acredito que conseguimos
alcançar esse objetivo. ” – Guido van Rossum

A partir de seu lançamento, o Python começou a ganhar popularidade e atrair

uma comunidade crescente de desenvolvedores, que se encantaram com sua
simplicidade e poder de expressão. A linguagem foi rapidamente adotada em
instituições de ensino e projetos de pesquisa, e seu sucesso começou a se espalhar
para além desse cenário acadêmico.

3.2. Guido van Rossum e a criação de Python

Nesta seção, vamos destacar Guido van Rossum, o brilhante desenvolvedor que
deu vida à linguagem Python. Conheceremos suas motivações, influências e como
ele transformou sua visão em uma das linguagens de programação mais populares
do mundo.
Guido van Rossum, nascido na Holanda em 31 de janeiro de 1956, começou a
programar desde jovem e sempre teve um grande interesse em desenvolver
ferramentas que tornassem a programação mais acessível e eficiente. Em 1989,
enquanto trabalhava no Centro para Matemática e Informática na Holanda, ele criou
o Python com o objetivo de criar uma linguagem de programação fácil de ler, com
uma sintaxe clara e simples.
A criação do Python foi influenciada por várias outras linguagens de
programação, como ABC, Modula-3, C, Lisp e Perl. Van Rossum combinou as
características que considerava mais poderosas e úteis de cada linguagem para criar
uma nova linguagem que pudesse ser usada em uma ampla gama de contextos.

6
 “Eu queria que o Python fosse uma linguagem de programação fácil de
aprender e usar, mas também poderosa o suficiente para lidar com problemas
complexos. Acredito que a simplicidade é a chave para a legibilidade e a
produtividade no desenvolvimento de software. ”

A simplicidade e clareza da sintaxe do Python ajudaram a atrair uma

comunidade crescente de desenvolvedores ao redor do mundo. Van Rossum
continuou a liderar o desenvolvimento do Python até 2018, quando decidiu se
aposentar do cargo de “Benevolente Ditador Vitalício”. No entanto, sua influência e
impacto na linguagem continuam sendo uma parte fundamental de sua história.
Ao longo dos anos, Python se tornou uma das linguagens de programação mais
populares devido à sua facilidade de aprendizado, versatilidade e capacidade de lidar
com uma ampla variedade de tarefas. De grandes empresas de tecnologia a
pequenos projetos de código aberto, Python encontrou seu lugar e se tornou uma
ferramenta indispensável para desenvolvedores em todo o mundo.

3.3. O lançamento da primeira versão de Python

No dia 20 de fevereiro de 1991, o mundo da programação testemunhou um
marco histórico: o lançamento oficial da primeira versão do Python. Criado por
Guido van Rossum, o Python surgiu com o objetivo de ser uma linguagem de
programação de fácil leitura e compreensão, tornando-se uma alternativa poderosa
para solução de problemas complexos.
Ao lançar o Python, van Rossum deu início a um movimento que transformaria a
forma como os desenvolvedores escrevem código. A primeira versão foi recebida
com entusiasmo pela comunidade de programação, que logo percebeu o potencial do
Python para simplificar e agilizar o desenvolvimento de aplicações.
Com recursos inovadores e uma sintaxe intuitiva, o Python logo conquistou
adeptos ao redor do mundo, que reconheceram suas vantagens em relação a outras
linguagens de programação existentes. A versão inicial do Python foi marcada pelo
seu foco na legibilidade do código e pela sua abordagem modular, permitindo que os
desenvolvedores criassem programas complexos de forma mais eficiente.
Um dos aspectos que tornaram o lançamento da primeira versão do Python tão
impactante foi a filosofia subjacente à linguagem. Van Rossum buscou criar uma
linguagem que incentivasse a colaboração e a simplicidade, promovendo práticas de
desenvolvimento mais eficientes. Essa filosofia, conhecida como “Benevolente
Ditador Vitalício” (BDFL, na sigla em inglês), garantiu que o Python continuasse
evoluindo e se adaptando às necessidades dos programadores ao longo dos anos.

“Python é tão simples que você pode literalmente ler o código e entender o
que ele faz. ” – Guido van Rossum

O lançamento da primeira versão do Python foi apenas o começo de uma jornada

incrível de sucesso para a linguagem. Nos próximos anos, o Python continuou a
evoluir, ganhando novos recursos e conquistando ainda mais popularidade. A
combinação de sua sintaxe clara e simples, o extenso conjunto de bibliotecas
disponíveis e a sua comunidade ativa de desenvolvedores contribuiu para o
crescimento exponencial do Python como uma das principais linguagens de
programação do mundo.

3.4. O crescimento e a popularidade de Python

7
 Ao longo dos anos, a linguagem de programação Python tem experimentado um
crescimento exponencial e se tornou uma das mais populares e amplamente
utilizadas na atualidade. Sua crescente popularidade se deve a uma série de fatores
que tornam Python uma escolha atraente para desenvolvedores e empresas de todo o
mundo.
Uma das razões para a popularidade de Python é a sua facilidade de aprendizado
e uso. Com uma sintaxe simples e intuitiva, Python permite que programadores de
todos os níveis de experiência criem soluções elegantes e eficientes. Além disso, a
vasta quantidade de recursos, documentação e comunidades de Python disponíveis
online facilitam a colaboração e o compartilhamento de conhecimento.
Outro ponto forte é a versatilidade de Python. A linguagem permite desenvolver
uma ampla variedade de aplicações, desde aplicações web e mobile até análise de
dados e inteligência artificial. Com suas bibliotecas especializadas, como NumPy,
pandas, TensorFlow e Django, Python se tornou uma escolha poderosa para
qualquer tipo de projeto.

“Python não apenas cresceu em popularidade, mas também conquistou

a confiança de grandes empresas como Google, Facebook e Amazon. Essa
adoção por parte das gigantes da tecnologia solidificou a posição de Python
como uma linguagem confiável e escalável, garantindo sua relevância em
um mercado altamente competitivo. ”

A popularidade de Python também pode ser atribuída à sua comunidade ativa e

engajada. Desenvolvedores de todo o mundo contribuem com bibliotecas,
frameworks e soluções open source, enriquecendo ainda mais o ecossistema de
Python. Essa colaboração contínua impulsiona o crescimento e a evolução da
linguagem, tornando-a cada vez mais poderosa e relevante.
Com o aumento da demanda por habilidades em Python, muitas instituições de
ensino e empresas estão oferecendo programas de treinamento e certificações em
Python, o que ajuda a impulsionar ainda mais sua popularidade. O mercado de
trabalho valoriza profissionais com experiência em Python, principalmente devido à
sua ampla aplicabilidade e às inúmeras oportunidades de carreira disponíveis.
Em resumo, o crescimento e a popularidade de Python são resultado de seus
benefícios e recursos excepcionais, bem como da dedicação de sua comunidade e do
reconhecimento global de sua utilidade. Com um futuro promissor e perspectivas
incríveis, Python continua a expandir seus horizontes e a transformar a indústria da
programação.

3.5. Python e sua influência na indústria de programação

O uso do Python na indústria de programação teve um impacto significativo ao
longo dos anos. Com sua sintaxe limpa e fácil legibilidade, Python revolucionou a
forma como os desenvolvedores criam e implementam soluções de software.
Uma das principais influências do Python na indústria de programação está
relacionada à sua versatilidade. A linguagem oferece suporte a uma ampla gama de
aplicações, desde desenvolvimento web e análise de dados até inteligência artificial
e aprendizado de máquina.
O Python se tornou uma linguagem muito popular entre programadores,
empresas e organizações de todos os tamanhos devido à sua eficiência e facilidade
de uso. Sua sintaxe simples, sem a necessidade de muito código, permite que os
desenvolvedores escrevam programas de maneira rápida e com menos esforço.

8
 A influência do Python na indústria de programação também se estende à
comunidade de desenvolvedores. A linguagem conta com uma comunidade ativa e
engajada, que contribui constantemente com novas bibliotecas e frameworks,
expandindo ainda mais as possibilidades de uso do Python.
Além disso, Python é amplamente adotado por grandes empresas, como Google,
Facebook e Netflix, que reconhecem a eficiência e o potencial da linguagem para
desenvolver soluções robustas e escaláveis.
Com tantas aplicações e vantagens, Python continua a desempenhar um papel
essencial na indústria de programação. Seja para o desenvolvimento de aplicativos
web, análise de dados ou criação de sistemas de inteligência artificial, Python
continua a ser uma escolha popular e influente entre os programadores.

“Python se destaca não apenas pela sua simplicidade, mas também pela
sua vasta comunidade e ecossistema, proporcionando um ambiente
colaborativo e enriquecedor para os desenvolvedores. ”
– Ana Silva, desenvolvedora sênior
(Mendes, 2024)

3.6. Marcos Importantes no Desenvolvimento do Python (2000 - 2020)

Em 2000, foi lançada a versão Python 2.0, que trouxe melhorias importantes,
como:

 Coletor de lixo baseado em contagem de referências

 Suporte para Unicode
 List comprehensions

Apesar dos avanços, o Python 2 foi desenvolvido com algumas limitações que
dificultaram a sua manutenção e evolução. Em 2008, foi anunciada a transição para o
Python 3, o que gerou uma divisão na comunidade, pois muitos pacotes ainda
dependiam do Python 2.
O suporte ao Python 2 foi oficialmente encerrado em 1º de janeiro de 2020,
marcando o fim de uma era e incentivando todos os desenvolvedores a migrarem
para o Python 3.
(Chiodi, 14/02/2025)

4. Recursos do python

4.1. Quais são os principais recursos do python

Os seguintes recursos da linguagem de programação Python a tornam única:

4.1.1. Uma linguagem interpretada

O Python é uma linguagem interpretada, o que significa que executa diretamente o
código linha por linha. Se houver erros no código do programa, ele será interrompido.
Portanto, os programadores podem encontrar rapidamente erros no código.

4.1.2. Uma linguagem fácil de usar

O Python usa palavras semelhantes às do inglês. Ao contrário de outras linguagens
de programação, o Python não usa chaves. Em vez disso, usa recuo.

4.1.3. Uma linguagem com tipos dinâmicos

9
 Os programadores não precisam declarar tipos de variáveis ao escrever o código,
porque o Python os determina no tempo de execução. Dessa forma, é possível escrever
programas Python mais rapidamente.

4.1.4. Uma linguagem de alto nível

O Python está mais próximo das linguagens humanas do que outras linguagens de
programação. Portanto, os programadores não precisam se preocupar com suas
funcionalidades subjacentes, como arquitetura e gerenciamento de memória.

4.1.5. Uma linguagem orientada a objetos

O Python considera tudo como um objeto, mas também aceita outros tipos de
programação, como estruturada e funcional.
(__, 2024)

4.2. Recursos Pouco Lembrados, Mas Poderosos

Python é uma das linguagens mais utilizadas no mundo devido à sua sintaxe simples
e poderosa. No entanto, conforme os desenvolvedores avançam na jornada com a
linguagem, há diversos recursos e detalhes que acabam sendo esquecidos ou
subutilizados.

4.2.1. O Poder da Else em Loops

Muitos desenvolvedores desconhecem que os loops for e while no Python possuem
uma cláusula else, que é executada somente se o loop não for interrompido por um
break.
Exemplo de Uso:

Imagem 1

Se o break for executado, a cláusula else não será acionada. Esse recurso pode ser
útil para verificar se um loop foi concluído sem encontrar um determinado valor. Esse
comportamento é útil, por exemplo, na verificação de listas para encontrar um item
específico. Se o item não for encontrado, a cláusula else pode executar um bloco de
código que trata essa situação de maneira controlada.

4.2.2. A Ordem dos Imports Impacta o Código

A ordem dos imports em Python pode afetar o desempenho e até mesmo causar
problemas inesperados. Por exemplo, importar bibliotecas pesadas no início do código
pode aumentar o tempo de carregamento da aplicação.
Melhor Prática:
 Primeiro, importe bibliotecas padrão do Python.
 Em seguida, importe pacotes de terceiros.
 Por último, importe módulos internos do projeto.
Exemplo:

10
 Imagem 2

Seguir essa estrutura melhora a organização e evita conflitos.

Além disso, importar somente os módulos necessários ao invés de bibliotecas
inteiras pode otimizar a performance do código, economizando memória e tempo de
execução.

4.2.3. O Uso de _ como Variável Temporária

O caractere _ pode ser usado para armazenar valores temporários que não precisam
ser reutilizados.
Exemplo de Uso:

Imagem 3

Isso é útil para ignorar valores ao desempacotar duplas ou listas.

Além disso, no interpretador Python, _ armazena o último resultado calculado:

Imagem 4

Essa funcionalidade pode ser aproveitada ao executar operações matemáticas rápidas

no terminal, sem a necessidade de armazenar variáveis explícitas.

4.2.4. O Método __repr__() Esquecido nos Objetos

O método especial __repr__() é frequentemente ignorado, mas pode tornar a
depuração de código muito mais eficiente.
Exemplo de Uso:

11
 Imagem 5

Ter um __repr__() bem definido facilita a leitura das saídas no console e em logs de
depuração. Muitas bibliotecas populares, como pandas e numpy, utilizam __repr__()
para exibir informações relevantes de maneira organizada.

4.2.5. O Decorador @staticmethod é subutilizado

Muitos programadores usam métodos de instância quando poderiam usar métodos
estáticos, que não precisam de acesso à instância ou à classe.
Exemplo de Uso:

Imagem 6

Isso melhora a organização do código e evita a necessidade de criar instâncias

desnecessárias.
Além disso, métodos estáticos evitam o uso desnecessário de memória, já que não
armazenam estado. Isso pode ser útil em bibliotecas utilitárias ou quando funções
precisam ser agrupadas em uma classe sem que instâncias sejam necessárias.

4.2.6. Dataclasses e a Simplificação de Classes

O Python 3.7 introduziu o módulo dataclasses, que permite criar classes de maneira
simplificada, reduzindo a necessidade de definir métodos repetitivos como __init__ e
__repr__.
Exemplo de Uso:

12
 Imagem 7

Isso torna a escrita de código mais limpa e reduz a repetição de código ao definir
classes simples de dados.

(Chiodi, O Que Todo Mundo Esquece Sobre Python: Recursos Pouco Lembrados, Mas
Poderosos, 14/02/2025)

5. SDK

Os Kits de Desenvolvimento de Software (SDKs) são muito comuns em todo o

cenário de desenvolvimento. A maioria dos provedores de API oferece SDKs para
ajudar a dar suporte às linguagens de programação específicas e paradigmas de
desenvolvimento de aplicativos, tornando-os parte integrante de uma estratégia geral de
suporte ao desenvolvedor.
SDK significa Software Development Kit. Um SDK é um kit de ferramentas que
ajuda os desenvolvedores a criar aplicativos, adicionar novas funcionalidades ou fazer
integrações. Esses pacotes especiais variam de acordo com a forma e a função em cada
caso, mas geralmente podem ser baixados e estão em conformidade com uma
linguagem ou plataforma específica, oferecendo componentes de código reutilizáveis
para tornar as tarefas de engenharia mais simples.
Os SDKs podem ser específicos da plataforma, como suporte a experiências móveis
nativas (Android SDK, iOS SDK, Windows SDKs) ou frameworks baseados na web
(JavaScript, React Native, Flutter). Muitos SDKs também são específicos da linguagem,
oferecendo suporte para linguagens de programação como C#, Java, Node.js, PHP,
Python, Ruby, Go e outras. Eles são frequentemente chamados de SDKs do lado do
servidor ou bibliotecas de código. As empresas de Software como Serviço API-first
implantam regularmente SDKs para melhorar a experiência do desenvolvedor de
integração.
Então, o que há em um SDK? Um SDK pode ser composto de código, conhecimento e
capacidades interativas:

 Bibliotecas de código auxiliar e métodos reutilizáveis

 Documentação de referência
 Instruções de configuração e autenticação
 Amostras de código, projetos de amostra ou modelos de projeto
 Ambientes de teste virtuais ou sandboxes
 Utilitários de interface de linha de comando (CLI)
 Componentes de design de IU
 Materiais de suporte adicionais

13
5.1. Qual é a diferença entre um SDK e uma API?
Outra confusão comum é a diferença entre um SDK e uma API. Então, vamos
dividir os dois.
Primeiramente, uma Application Programming Interface (API) permite a
comunicação entre sistemas. Uma API é estruturada como um conjunto de métodos
e parâmetros. Ao chamar esses métodos, um aplicativo pode integrar dados e
funcionalidades de forma reutilizável. As APIs de sistema são intrínsecas ao
desenvolvimento de software desde o surgimento do PC, permitindo que bibliotecas
atuem como interfaces compartilhadas. No entanto, hoje, quando discutimos APIs,
normalmente nos referimos a APIs baseadas na web que seguem o estilo de design
REST e atendem clientes por HTTP. Essas interfaces funcionais leves, diretas e
independentes do cliente se tornaram um método padrão para comunicação de
máquina para máquina em rede — algumas são até mesmo produtos por si só. No
entanto, as APIs ainda são usadas internamente, como no sistema operacional de um
dispositivo.
Enquanto a integração de API requer expertise específica em integração, SDKs,
por outro lado, são mais intuitivos. Eles atendem os desenvolvedores onde eles
estão. APIs frequentemente requerem esquemas de autenticação, cabeçalhos
complexos, métodos HTTP e outras nuances. Um SDK poderia abstrair essa
complexidade, substituindo código desajeitado para chamar algo como
api.com/V1/customer/lastnamecom uma função reutilizável simples, como
storeSDK.getCustomer.lastname.
Os SDKs também são tecnicamente distintos. Enquanto as APIs da web servem
dados por uma rede, os SDKs são baixados e mais integrados dentro do ambiente de
desenvolvimento local. Enquanto as APIs REST são independentes de plataforma,
os SDKs tornam os serviços gnósticos, atendendo a linguagens e plataformas
específicas. Os SDKs são mais como uma camada de abstração para uma API,
incluindo faculdades mais robustas. Claro, nem todos os SDKs incluem acesso à
API — alguns não lidam com redes e focam somente no processamento local. Sobre
isso, algumas APIs são até mesmo enviadas dentro dos SDKs.

5.2. Cinco exemplos de SDKs

5.2.1. SDKs de listras

Stripe, a popular plataforma de processamento de pagamentos online, fornece
vários SDKs para integrar seus serviços, atuando como wrappers para as principais
APIs do Stripe. Por exemplo, o Stripe iOS SDK e o Stripe Android SDK atraem
desenvolvedores móveis. O Stripe também fornece um SDK JavaScript do lado do
navegador, Stripe.js, bem como outras bibliotecas de cliente para Ruby, Python,
PHP, Java, Node.js, Go e .NET. Bibliotecas comunitárias não oficiais ajudam a
estender os serviços do Stripe para ambientes de nicho, como Angular, Elixir e
Flutter.

14
 Imagem 8

5.2.2. SDKs do Twilio

Twilio, o conhecido serviço API-first para texto, chat, voz e vídeo, fornece
muitas extensões além de suas principais APIs REST. Assim como o Stripe, o
Twilo separa seus SDKs por função, oferecendo um iOS SDK, Android SDK e
biblioteca JavaScript por serviço. Por exemplo, o Twilio Programmable Voice SDK
para Android pode ser usado para programar Voice-over-IP (VoIP) em aplicativos
Android nativos.

Imagem 9

5.2.3. SDKs de API de vitrine do Shopify

O Shopify é uma estrutura para comércio eletrônico, oferecendo utilitários
programáveis para colocar uma loja online em funcionamento. O Shopify expõe sua
plataforma por meio de suas APIs, que são tornadas mais acessíveis por meio de
SDKs e bibliotecas de código. Por exemplo, a API do Shopify Storefront ajuda a
criar experiências de compra e checkout voltadas para o cliente. Como as compras
online são onipresentes em ambientes de usuário, os SDKs ajudam a combinar a
aparência de aplicativos nativos. Os SDKs da API do Shopify Storefront incluem
Android, iOS , um JavaScript Buy SDK para sites e até mesmo um Unitiy Buy
SDK para videogames.

15
 Imagem 10

5.2.4. SDKs da AWS

A Amazon Web Services (AWS) fornece muitos SDKs para dar suporte ao seu
vasto cenário de ferramentas. Os SDKs específicos da linguagem da AWS ajudam
os engenheiros a chamar os serviços da AWS usando os idiomas de sua linguagem
preferida. Isso inclui JavaScript, Python, PHP, .NET, Ruby, Java, Go, Node.js e C+
+. Por exemplo, boto, a interface Python para a AWS, pode ser instalada a partir de
uma CLI usando pip install boto3. Usando os SDKs da AWS, os engenheiros
podem iniciar serviços da AWS, como computação em nuvem, entrega de
conteúdo, monitoramento, autenticação, armazenamento em nuvem e outras
funções de dentro de seus aplicativos.

Imagem 11

5.2.5. SDKs quadrados

Square, o popular processador de pagamentos, fornece SDKs para facilitar a
integração de API. O Square suporta SDKs em linguagens de programação

16
 Java, .NET, NodeJS, PHP, Python e Ruby. Como o Square incorpora dispositivos
de leitura para vendas presenciais, ele também fornece SDKs móveis que focam
nesse recurso. Uma parte interessante dos SDKs do Square é que eles vêm pré-
empacotados com um servidor isolado, para que os consumidores possam testar
facilmente chamadas de API em endpoints de não produção e visualizar respostas.
Além disso, o Square oferece uma API Explorer online para gerar solicitações de
API em várias linguagens — um modelo para fácil experiência do desenvolvedor e
integração de API.

Imagem 12

5.3. SDKs do lado do cliente vs. do lado do servidor

As diferenças entre SDKs do lado do cliente e do lado do servidor ajudam você a
determinar qual tipo de SDK integrar, dependendo da linguagem de programação e da
estrutura dentro da sua pilha.
 SDKs do lado do cliente
Esses são SDKs destinados a serem usados em um ambiente não confiável, como
um navegador da web ou dispositivo móvel. Isso também inclui SDKs móveis.
Bibliotecas de clientes populares: JavaScript, Typescript, Android, React e muitas
outras.
 SDKs do lado do servidor
Esses SDKs são usados em um ambiente confiável onde você mantém as chaves e
os segredos da API seguros, como dentro de um servidor web.
SDKs populares do lado do servidor: Node.js, C++, PHP, Python e muitos mais.

17
 Imagem 13
(__, O que é um SDK?, 2024)

6. O que é o Boto3?

O Boto3 é a biblioteca oficial da AWS para Python, projetada para simplificar a

interação com os serviços da AWS usando a linguagem de programação Python. Com o
Boto3, os desenvolvedores podem automatizar tarefas comuns, como criar instâncias
EC2, gerenciar buckets no Amazon S3, configurar serviços de banco de dados e muito
mais, tudo por meio de chamadas de API simples e intuitivas.

6.1. Introdução
O Amazon Web Services (AWS) é uma plataforma de computação em nuvem
amplamente utilizada por empresas e desenvolvedores para hospedar aplicativos e
serviços. Para interagir programaticamente com os serviços AWS, muitos
desenvolvedores recorrem ao Boto3, uma biblioteca Python que simplifica o processo
de chamadas de API para os serviços AWS. Neste artigo, exploraremos o Boto3,
fornecendo uma visão geral e um exemplo prático de uso.

6.2. Instalação do Boto3

Antes de começarmos, é importante garantir que o Boto3 esteja instalado em seu
ambiente Python. Você pode instalá-lo facilmente usando o pip:

pip install boto3

6.3. Exemplo Prático: Listando Buckets no Amazon S3

Vamos criar um exemplo prático usando o Boto3 para listar os buckets no Amazon
S3. Certifique-se de ter suas credenciais da AWS configuradas antes de prosseguir.
Sugestão: rodar o script no cloud9.

Import boto3
# Criando uma instância do cliente S3
s3_client = boto3.client('s3')
# Listando buckets
response = s3_client.list_buckets()
# Extraindo informações dos buckets
buckets = response['Buckets']

18
# Imprimindo os nomes dos buckets
print("Buckets na conta AWS:")
for bucket in buckets:
print(f"- {bucket['Name']}")

Imagem 14

Neste exemplo, criamos uma instância do cliente S3 usando o Boto3 e, em seguida,

usamos o método list_buckets para obter informações sobre todos os buckets na conta.
A resposta é processada para extrair os nomes dos buckets, que são então impressos.

Imagem 15
(Habbema, 2024)

7. Strings

Uma string é uma sequência de caracteres simples. Na linguagem Python, as strings

são utilizadas
com aspas simples ('... ') ou aspas duplas ("...").
Para exibir uma string, utiliza-se o comando print().

7.1. Concatenação de strings

19
Para concatenar strings, utiliza-se o operador +.

7.2. Manipulação de strings

Em Python, existem várias funções (métodos) para manipular strings.

Imagem 16

20
 7.3. Fatiamento de strings
O fatiamento é uma ferramenta usada para extrair apenas uma parte dos elementos
de uma string.
Nome_String [Limite_Inferior : Limite_Superior]
Retorna uma string com os elementos das posições do limite inferior até o limite
superior - 1.
(IFSP, 2024)

8. O que é PyCharm?

O Pycharm é uma IDE - Integrated Development Environment - ou Ambiente de

Desenvolvimento Integrado em tradução livre. Essa ferramenta foi criada pela empresa
Tcheca JetBrains, que é conhecida pelos seus produtos nesse nicho de mercado, sendo
alguns deles, o IntelliJ para desenvolvimento Java, o WebStorm para desenvolvimento
JavaScript e o RubyMine para desenvolvimento Ruby, entre outros.
Pycharm é multiplataforma, rodando em Windows, Mac e Linux, além disso, ele possui
uma versão premium e uma versão community gratuita.
Ela é uma excelente ferramenta para o desenvolvimento Python criando uma
estrutura coesa de projeto, gerenciando os interpretadores Python disponíveis na sua
máquina, as ferramentas para criação de ambientes virtuais, snippets de código,
sugestões e teclas de atalho, entre muitas outras funcionalidades. Vale muito a pena
explorar os recursos dessa fantástica IDE.
(Neto, 2023)

8.1. IDE
Ao adentrarmos em códigos que requerem maior complexidade, vemos que nem
sempre o modo script de execução de códigos em Python não conseguirá atender
todas as nossas necessidades durante a criação de nossas aplicações. Dessa forma,
será necessário nos aprofundarmos a escrever nosso código em arquivos externos,
de maneira a executar todo o código de uma vez de maneira mais estruturada e
organizada.
Ao iniciar o primeiro contato com programação, uma das principais dúvidas de
iniciantes é: "qual ferramenta vou utilizar para escrever código?". A maioria dos
códigos das principais linguagens de programação permitem desenvolver em um
arquivo utilizando um editor de texto comum.
Alguns editores de texto possuem ferramentas mais sofisticadas que dão maior
auxílio na hora de desenvolver como: indentação de código, diferenciação de
funções, autocompletamento de código, dentre outras.
Outra ferramenta, mais utilizada para desenvolver código, é o que chamamos de
Ambiente Integrado de Desenvolvimento ou IDE (sigla em inglês para Integrated
Development Enviroment). Uma IDE é um software com muitas funcionalidades
que auxiliam no desenvolvimento de código além de possuir a capacidade de rodar o
código.
Uma nova tendência de IDE's para desenvolvimento em Python, especialmente
para a área de Data Science, envolvem a utilização de ambientes computacionais
diretamente utilizados na web, possibilitando uma interação mais dinâmica e
colaborativa entre os seus parceiros de equipe. Sendo muitas vezes definidos como
Notebooks, os mesmos possibilitam a execução de scripts em Python em blocos
separados de código, facilitando a visualização e documentação do seu código, e
observando os resultados em tempo real com maior eficácia. Um dos exemplos mais

21
 famosos é o Jupyter Notebook, que possui suporte a diversas bibliotecas e é de fácil
instalação do ambiente na sua máquina, sendo utilizado por diversas empresas no
ramo de dados até hoje.
Outra IDE que está cada vez mais disseminada na atualidade para a geração de
códigos Python é o Google Colaboratory, que possibilita a criação de Notebooks
interativos diretamente através de sua conta Google. Uma das maiores vantagens do
Colaboratory a outras IDE's é que tudo é feito através da nuvem, desde o
armazenamento dos dados dentro da sua conta Google até o processamento de dados
feito pela GPU fornecida pela mesma.
Por fim, um outro ambiente bastante consolidado na comunidade Python nos
últimos anos é o IDLE, que possui bem menos recursos do que o PyCharm mas
ainda é bastante utilizado por diversos usuários.

8.2. Pycharm
O Pycharm é multiplataforma com versões para Windows, MacOS e Linux. O
PyCharm é desenvolvido pela empresa JetBrains e fornece análise de código,
depurador gráfico, autocompletamento de código e capacidades de navegação que
facilitam a escrita de código.
IDE's foram desenvolvidas para criar código mais rapidamente e com maior
eficiência. Veremos aqui os principais recursos do PyCharm. Você perceberá que
ele evita ao máximo atrapalhar e apenas gera trechos de códigos óbvios, sempre ao
seu comando.
Com o PyCharm você pode desenvolver em Python. A versão Profissional dá
suporte para desenvolvimento de aplicações web com Django, Flask e Pyramid. O
Pycharm também suporta HTML, CSS, JavaScript e XML. Suporte para outras
linguagens também podem ser adicionadas baixando plugins.
(Introdução ao Pycharm, 2024)

9. Quais considerações ao escolher uma biblioteca GUI PYTHON

Como a pedra fundamental para criar interfaces de usuário envolventes e intuitivas,

selecionar a biblioteca GUI certa é essencial para desenvolvedores que buscam
preencher a lacuna entre código complexo e aplicativos amigáveis ao usuário. Essa
decisão pode influenciar significativamente a eficiência, a estética e o sucesso geral de
um projeto.

9.1. Principais considerações antes de escolher uma estrutura de GUI

9.1.1. Compatibilidade
Antes de selecionar uma estrutura de GUI, é essencial garantir que ela esteja
alinhada aos requisitos de plataforma do seu projeto. Não importa se você está
desenvolvendo para Windows, macOS, Linux ou ambientes multiplataforma, a
estrutura escolhida deve oferecer suporte a essas plataformas para garantir que seu
aplicativo possa operar perfeitamente nos ecossistemas desejados. Investigue a
compatibilidade da estrutura não apenas com os sistemas operacionais, mas
também com as versões do Python que você pretende usar, pois isso pode impactar
significativamente a viabilidade e a longevidade do seu projeto.

9.1.2. Comunidade e suporte

22
 A presença de uma comunidade vibrante e ativa em torno de uma estrutura de
GUI não pode ser exagerada. Uma comunidade forte significa acesso a uma riqueza
de conhecimento compartilhado, dicas e conselhos de solução de problemas, o que
pode ser especialmente benéfico para resolver problemas complexos ou aprender
técnicas avançadas. Além disso, considere a disponibilidade de canais de suporte
oficiais, fóruns ou documentação. Esses recursos são inestimáveis para
desenvolvedores novatos e experientes, fornecendo orientação e atualizações para
aprimorar seu processo de desenvolvimento.

9.1.3. Desempenho
O desempenho de uma estrutura de GUI é um fator crítico, particularmente para
aplicativos que exigem alta responsividade ou que exigem muitos recursos. Avalie
como a estrutura lida com a carga e sua eficiência de uso de memória e CPU.
Algumas estruturas são mais adequadas para aplicativos leves, enquanto outras são
projetadas para suportar aplicativos complexos de alto desempenho. Entender as
características de desempenho de cada estrutura ajudará você a escolher uma que
corresponda aos requisitos da sua aplicação.

9.1.4. Documentação
Documentação de qualidade é essencial para qualquer ferramenta de
desenvolvimento de software, e frameworks GUI não são exceção. Documentação
abrangente e clara pode acelerar significativamente o aprendizado e ajudar os
desenvolvedores a evitar armadilhas comuns. Procure tutoriais atualizados,
referências de API e projetos de exemplo. Frameworks bem documentados são
mais fáceis de trabalhar e podem reduzir significativamente o tempo de
desenvolvimento, fornecendo orientação clara e melhores práticas.

9.1.5. Licenciamento
Por fim, o licenciamento do framework pode impactar substancialmente seu
projeto, especialmente se você estiver desenvolvendo software comercial. Alguns
frameworks são de código aberto e gratuitos para uso sob certas condições,
enquanto outros podem exigir uma licença comercial para desenvolvimento
proprietário. Entenda os termos de licenciamento para garantir que eles estejam
alinhados com os objetivos e o orçamento do seu projeto. Considerar os requisitos
de licenciamento logo no início pode evitar complicações legais e financeiras mais
tarde no desenvolvimento. Ao avaliar cuidadosamente essas considerações, os
desenvolvedores podem tomar uma decisão informada ao escolher uma estrutura de
GUI Python, garantindo que sua ferramenta esteja alinhada com as necessidades e
objetivos do projeto. Essa abordagem estratégica facilita um processo de
desenvolvimento mais suave e contribui para a criação de aplicativos mais robustos
e amigáveis.

9.2. Frameworks populares de GUI em Python: prós e contras

9.2.1. Tkinter
Tkinter, o kit de ferramentas GUI padrão para Python, é conhecido por sua
simplicidade e está incluso com Python. É ideal para aplicações de pequeno a
médio porte e propósitos educacionais.

Prós Contras

23
Simplicidade e facilidade de uso: o Widgets e personalização limitados:
Tkinter é fácil de aprender e usar, o que o Comparado a estruturas mais avançadas,
torna ideal para iniciantes e para o rápido o Tkinter tem um conjunto mais limitado
desenvolvimento de aplicativos GUI de widgets e menos flexibilidade para
simples. personalização.
Inclusão de biblioteca padrão: incluída Aparência: a aparência padrão pode
com o Python, não requer instalação parecer desatualizada em comparação
adicional, garantindo disponibilidade aos aplicativos GUI modernos, a menos
imediata. que um esforço significativo seja feito
para personalizar as aparências.
Compatibilidade entre plataformas: Desempenho: embora geralmente
funciona em Windows, MacOS e Linux, adequado, pode não ser tão eficiente
oferecendo uma experiência de quanto outras estruturas para aplicativos
desenvolvimento consistente em todas as mais complexos ou que exigem muitos
plataformas. recursos.
Suficiente para aplicações básicas:
Oferece widgets suficientes para criar
aplicações GUI padrão para fins
educacionais ou pequenos projetos.

9.2.2. PyQt/PySide
PyQt e PySide são ligações Python para a biblioteca Qt, oferecendo ferramentas
e widgets extensivos. Eles são adequados para criar aplicativos multiplataforma
altamente funcionais e visualmente atraentes. Enquanto PyQt está disponível sob a
GPL e uma licença comercial, PySide (oficialmente conhecido como Qt para
Python) é oferecido sob a LGPL.

Prós Contras
Amplo conjunto de widgets: oferece uma Licenciamento: PyQt requer uma licença
ampla variedade de widgets pré-criados comercial para aplicações comerciais, o
para criar aplicativos GUI altamente que pode ser uma limitação para alguns
funcionais e complexos. projetos. PySide é licenciado de forma
mais permissiva sob LGPL.
Multiplataforma: suporta Windows, Curva de aprendizado: a ampla
MacOS e Linux, garantindo que os funcionalidade vem com uma curva de
aplicativos tenham uma aparência aprendizado mais íngreme do que
consistente em diferentes sistemas estruturas mais diretas como o Tkinter.
operacionais.
Recursos avançados: suporta recursos Intensidade de recursos: aplicativos com
avançados de GUI, incluindo animações, mais recursos podem exigir mais dos
widgets personalizados e plugins de recursos do sistema.
terceiros.
Comunidade e documentação fortes:
tanto o PyQt quanto o PySide têm ampla
documentação e comunidades ativas.

9.2.3. Kivy

24
 Kivy é projetado para aplicativos multitoque e é uma excelente escolha para
desenvolver aplicativos que exigem gestos e suporte multitoque. É de código aberto
e funciona em Windows, MacOS, Linux, iOS e Android.

Prós Contras
Projetado para toque: otimizado para Aparência: a aparência padrão é mais
multitoque, tornando-o ideal para adequada para aplicativos de toque e
aplicativos móveis e habilitados para pode não estar alinhada às expectativas
toque. da interface gráfica do usuário (GUI) do
desktop sem personalização.
Multiplataforma: funciona em Windows, Curva de aprendizado: Padrões e
macOS, Linux, iOS e Android, com a abordagens de design exclusivos podem
capacidade de executar a mesma base de exigir mais tempo para aprender do que
código em todas as plataformas. estruturas mais tradicionais.
Código aberto: gratuito para uso e Comunidade e suporte: Embora esteja
contribuição, além de ser de fácil crescendo, os recursos da comunidade e
licenciamento para aplicações do suporte são menos extensos do que
comerciais. aqueles do PyQt/PySide.
Widgets personalizados: suporta a
criação de widgets personalizados,
permitindo interfaces de usuário
altamente personalizadas e dinâmicas.

25
 9.2.4. wxPython
wxPython é um wrapper para a biblioteca wxWidgets C++, fornecendo uma
aparência nativa em várias plataformas. É uma boa escolha para aplicativos que
precisam corresponder às convenções de GUI nativas do sistema operacional.

Prós Contras
Aparência nativa: Integra-se Curva de aprendizado: o amplo conjunto
estreitamente com o sistema operacional, de widgets e recursos pode introduzir
fornecendo aplicativos que correspondem uma curva de aprendizado mais íngreme
às convenções da GUI nativa. para novos desenvolvedores.
Rich widget wet: oferece um conjunto Instalação e configuração: pode exigir
abrangente de widgets para criar mais esforço para instalar e configurar
aplicativos GUI complexos. em comparação ao Tkinter, que vem
junto com o Python.
Compatibilidade entre plataformas: Flexibilidade de design: embora seja
suporta Windows, macOS e Linux, excelente na criação de aplicativos com
mantendo a aparência nativa em cada aparência nativa, personalizar além da
plataforma. aparência nativa pode ser mais
desafiador.
Comunidade forte: Beneficie-se de uma
comunidade de apoio e de uma riqueza
de documentação e tutoriais.

(Escolhendo as melhores bibliotecas de GUI Python: um guia essencial para

desenvolvedores, 2024)

Obras Citadas
__. (2024). O que é Python? aws.
__. (2024). O que é um SDK? apideck.
ADS, G. P. (2024). Programa de Educação Tutorial. IFSP - Câmpus São Carlos.
Barreira, J. (2024). Vantagens e Desvantagens do Python: Um Guia Compreensivo
Para Desenvolvedores. ultahost.
Chiodi, M. (14/02/2025). A História do Python: Da Criação à Popularidade Global.
dio.me.
Chiodi, M. (14/02/2025). O Que Todo Mundo Esquece Sobre Python: Recursos Pouco
Lembrados, Mas Poderosos. dio.me.
Escolhendo as melhores bibliotecas de GUI Python: um guia essencial para
desenvolvedores. (2024). curotec.
Habbema, H. (2024). O que é PyCharm? medium.
IFSP. (2024). INTRODUÇÃO À PROGRAMAÇÃO. IFSP - Câmpus São Carlos: IFSP.
Introdução ao Pycharm. (2024). Alura.
Mendes, M. (2024). quando python foi criado: conheça a história da linguagem. portal
desenvolvedor.
Neto, R. (2023). O que é PyCharm? dio.me.
O que é Python? - A linguagem de programação mais versátil. (2024). datacamp.

26
27