python

história:
O Python foi concebido no final de 1989 por Guio van Rossum no Instituto de Pesquisa
Nacional para Matemática e Ciência da Computação (CWI), nos Países Baixos, como um
sucessor da ABC capaz de tratar exceções e prover interface com o sistema operacional
Amoeba através de scripts.

Sobre:

Python e uma linguagem de tipagem dinâmica( não e preciso declara o que vai entra na
variável)

Dados:
No python temos string dado em texto sempre entre ‘’ ou “”;

Int números inteiros;

Float números quebrados usando sempre o ponto ex: 23.45;

Bool nesse temos os dados que vão retornar True ou False.

Você pode muda os tipos dos dados( essa ação e chamada de type convertion, type casting,
coercion)

A = int(a) interpolação e quando vc coloca a %f por exemplo

List as famosas listas feita usando os []

Print(‘testando %f’, (variável)

Comandos mais usados:

Print (‘vai escrever o que vc quiser na tela’) tudo entre as () são argumentos;

Input e a adição de dados;

Type vai dizer o tipo do dado;

Pass ou ellipis(...) usado para deixa um espaço vago no código;

Len vai conta os índices desse dado;

Comentários:
De uma linha #;

Sep vao colocar alguma coisa entres os espaços;

End junta as linhas;

\n faz uma quebra de linha;

Também temos as docstrings pra usa múltiplas linha (isso não e um comentário e uma
docstrig) elas podem ser “”” ou ‘’’

Operadores:
+ além de soma ele faz a concatenação;

-:

/ divisão;

** potencia;

== igual;

!= diferente;

And e or;

// divisão inteiras

<, >, <=, >= ;

Precedência () depois ** , depois * , //,/, % e depois +, -

Operadores lógicos:
If true;

If else;

If a not in;

Is not , is geralmente são muito usado com none

Laços de repetição temos apenas o while

Formatando valores:

Vc pode usar a função print(‘{}’.format(variável)) ou a mais pratica print(f’{variável}’)

:f para diminuir um numero float;

Print(f’variavel:.2f)

:s texto;

:d int.

< esquerda

> direita

- centro

Esse comandos vão adiciona elementos na sua variável

Print(f’{a;g>34})

Try and except :

onde vc coloca um bloco de código que executa ignorando um erro ou talvez esse dado não
execute algum comando do seu código

Se ele não executa nada esse código acaba caindo em no except

Boas praticas:

Constantes são variáveis que nunca mudam

Muitas condições em if faz o código se torna complexo

Não declare a variável fora do bloco

Laços de repetição :

While e for

Quando vc sai do while sem ser forçado ou por uma quebra vc pode coloca um else em baixo
para ser executado

While True:

Print(‘hello word’)

Else:

Print(‘certo’)

If isinstance(variável, str) pra validar o tipo no tipo e possível coloca uma tupla e coloca um ou
mais valores

If isinstance(variável, (str, int))

Range:

Um dos inteiráveis mais interessantes

Range(start, stop, step)

Indices = range(len(lista)

Também funciona

Listas:

Esse espaço vai ser voltado a escrever tudo sobre listas já que e um dado mais complexo e
mais usado um dado mutável

Feita com []

Del [] usado para remover um item da lista

Srt ou lista.Split() vai quebra as str no espaço criando uma lista lembrando que tem que joga
isso em uma variável ou direto no print

Lista.append(item ou variável) adiciona coisas

Lista.pop(item ou variável) remove o ultimo valor ou onde vc escolhe

Lista.insert(0, valor que você vai coloca)

Variável’’.join(variavel) Join vai junta as listas, str, duplas com elemento que vc coloca

List.clear() limpa a sua lista

Tambem e possível concatena as listas transformando elas em uma

Lista.extend(lista_x)

Alguns cuidados que se teve toma com dados mutáveis quando vc muda uma coisa vc acaba
mudando ele em todas as áreas

Listab = listaA.copy()

Copinha a lista a assim você faze alterações na a e ter um copia solida da A

E possível coloca a *resto isso coloca todas os índices que não serão usados em uma variável

Geralmente quando essa ferramenta e usada essa variável e definida como *_

Tuplas:

Tuplas são listas imutáveis mais rápida que lista

Criada com () ou apenas não colocando nada

E possível altera uma lista pra tupla e Vice-versa com o tupla(list)

Imprecisão de numero flutuante:

Como as linguagens salvam esse números fazem aparecer um erro no seu código

se a soma de 0.1 + 0.7 for feita o numero que aparecera será 0.7999999999999 e não 0.8

pra resolver isso você vai ter que ir no arquivo imprecisao.py

Interpretado python:

"""

python mod.py (executa o mod)

python -u (unbuffered)

python -m mod (lib mod como script)

python -c 'cmd' (comando)

python -i mod.py (interativo com mod)

The Zen of Python, por Tim Peters

Bonito é melhor que feio.

Explícito é melhor que implícito.

Simples é melhor que complexo.

Complexo é melhor que complicado.

Plano é melhor que aglomerado.

Esparso é melhor que denso.

Legibilidade conta.

Casos especiais não são especiais o bastante para quebrar as regras.

Embora a praticidade vença a pureza.

Erros nunca devem passar silenciosamente.

A menos que sejam explicitamente silenciados.

Diante da ambiguidade, recuse a tentação de adivinhar.

Deve haver um -- e só um -- modo óbvio para fazer algo.

Embora esse modo possa não ser óbvio à primeira vista a menos que você seja holandês.

Agora é melhor que nunca.

Embora nunca frequentemente seja melhor que *exatamente* agora.

Se a implementação é difícil de explicar, é uma má ideia.

Se a implementação é fácil de explicar, pode ser uma boa ideia.

Namespaces são uma grande ideia -- vamos fazer mais dessas!

"""

Ternária:

E mais fácil so printa

Funções :

Uma função pode ou não receber valores se e coloca valores e obrigado a coloca os
valores(também chamados de parâmetros)

Argumentos nomeados são aqueles que vc indica a ordem, a partir que um argumento e
nomeado todos a frente dele são obrigados ao mesmo

e valores padrão são definidos na base do código

quando e usado *args e possível receber um a quantidade ilimitada de argumento posicionais

ou não nomeados qundo * kwargs e possível receber uma quantidade ilimitada de argumento
nomeados

Argumentos nomeados e não nomeados em funções Python

Argumento nomeado tem nome com sinal de igual

Argumento não nomeado recebe apenas o argumento (valor)

Escopo:
Quando e definido uma variável ela e definida em um espoco específico

nos temos o escopo global sem estar e nenhum lugar específico

Temos os escopos dentro de funções, que podendo ter funções dentro de outras funções a
mesma com seu próprio escopo

Se a variável não estiver definida naquela função ela ira pegar a externa mais próxima. Esse
movimento só acontece de interno pra externo nunca de externo pra interno

Call Stack é uma ferramenta que usa pequenas partes da memoria do pc para fazer o código
roda

Termos técnicos: Higher Order Functions e First-Class Functions

Academicamente, os termos Higher Order Functions e First-Class Functions têm

significados diferentes.

 Higher Order Functions - Funções que podem receber e/ou retornar outras
funções
 First-Class Functions - Funções que são tratadas como outros tipos de dados
comuns (strings, inteiros, etc...)

Não faria muita diferença no seu código, mas penso que deveria lhe informar isso.

Observação: esses termos podem ser diferentes e ainda refletir o mesmo significado.

Dicionário:
Estrutura de dados com chave e valor
Também e possível construir com base na função dict()

Se for criado chaves iguais o valor da ultima que sera usado

Temos algumas funções principais para dicionários

Como Keys()

Que mostra as a chaves, com isso podemos pegar essas chaves e transforma em uma tuple ou
list qualquer coisa pra visualização fica melhor

No lugar de Keys pode ser usado values() e items()

Temos também e get() que e feito para tratar um erro

Setdefault() também trata erros, mas se aquela chave que for chamada não existir e possível
escolher um valor padrão
Se a chave gênero não existir o valor padrão dela será ‘ não declarado’ também pode fazer isso
com get()

Copys em dicionários:

Temos 3 tipos de copia a primeira

Nessa não esta feito uma copia. As duas listas estão conectadas tudo que for mudado em uma
e mudado na outra

Com essa e feita uma shallow copy nessa os dados imutáveis (str,int,...) que forem mudados na
original não serão afetados, dados mutáveis como lista são modificados nas duas

Duas listas completamente independes

Com pop() e tirado a chave, mas o valor continua

Popitem() remove a ultima chave(e item) apenas a ultima

Dic.upadate()
introdução à List comprehension:

Mapeamento quando você pega um valor de uma lista e transforma ou não esse dado

Fazendo isso os índices serão o mesmos (com valor modificado)

Essa nova lista poder ter items a mais, mas os que já estava continua no mesmo lugar

Para fazer a modificação de valores e preciso desempacotar a lista

Filtro e um if após o for que não tem else feito para filtrar o que vai pra sua nova lista

No primeiro if o dado vai ser modificado ou não, e vai entra

O segundo e uma condição pra ver se o dado vai entra na lista

Esse if são sempre pegando o dado original

Podem ser feita com dicionário e dupla mas vc tem que usar dupla com{}
Falsy e truthy

São apenas os valores valor falso e verdadeiro dado a alguns elementos

lista = []

dicionario = {}

conjunto = set()

tupla = ()

string = ''

inteito = 0

flutuante = 0.0

nada = None

falso = False

intervalo = range(0)

todos esse são falsy

Chegando atributos/ nomes:

Quando e declarado um objeto o mesmo tem nomes que pode ser observados

Todos o atributos definidos no seu objeto

Obs a formas de usar o modulo __init__ estão no arquivo init

Use o debug console pra ver e usar isso

O comando hasttr() vai ver se o objeto tem o não aquela método sem quebra o código

com o getattr e possível usar os métodos diretos do objetos como uma variável que o método
foi colocado ou uma lista

Interavel e interator :
Os objetos interavel ele dá os elementos um por vez

O interator apenas sabe o próximo elemento. Interador não sabe o ultimo elemento não sabe
o primeiro apenas o próximo

Cada vez que dá um next e gastado esse elemento e quando ele gasta todos para no ultimo e
aparece um erro na tela

Generator:

Generator e uma função que sabe pausa. Todo genator e um interad, mas nem todo interator
e um generator

Então o generator não vai salvar toda a informação na memoria ele vai entrega a informação
em partes

A lista aqui e maior que o generator

Só que a lista vai ter toda a informação dela índices, começo e fim, len ...

O generator so tem o próximo elemento

E possível fazer a fução generator

Try e except:

ja foi visto que eles são usados para tratar erros

Tem inúmeros nomes de erros como o Zero

A class mais alta de erros e a Exception

Nesse casa ele ira pegar qualquer erro que não esteja especificado acima e joga pra ela

Esse __class__ e __name__ são usados para falar o erro e seu nome, esse as joga o erro e uma
variável que no caso e error

Finally sempre vai ser executado

hierarquia de erros

módulos:

existe alguma forma de fazer o import

Nessa e feito todo o import de tudo, com o name espac com isso e possível usar variáveis dos
nomes da função

Com o from e possível importa funções especificas

E possível troca o nome da função ou ate do import

Agora uma má pratica e importa tudo sem o name space

Modularização:

Quando e feito o import dos seu próprios arquivos o arquivo que você e seu arquivo main
geralmente quando se faz um programa você faz uma pasta main e seu programa funciona em
torno dela

Só e possível puxa pacotes da mesma pasta(package)

Importando um package:
Quando e possível usar __all__ na pasta que não e o main que ira ser importado e possível
limitar o que vai sair desse modulo

Aqui apenas a essa variável será usada

Todas a formas de importa um modulo em package

Curiosidades sobre convenções de nomes

Como você viu na aula anterior, usamos certas convenções para nomes de variáveis,
funções, classes e assim por diante. Essas convenções tem um nome que podemos usar
para nos referir ao modo como estamos nomeando determinados objetos em nosso
programa: PascalCase, camelCase e snake_case.

 PascalCase - significa que todas as palavras iniciam com letra maiúscula e nada
é usado para separá-las, como
em: MinhaClasse , Classe , MeuObjeto , MeuProgramaMuitoLegal .
Essa á a convenção utilizada para classes em Python;
 camelCase - a única diferença de camelCase para PascalCase é a
primeira letra. Em camelCase a primeira letra sempre será minúscula e o
restante das palavras deverá iniciar com letra maiúscula. Como
em: minhaFuncao , funcaoDeSoma , etc... Essa conversão não é usada em
Python (apesar de eu confundir as duas e às vezes acabar
chamando camelCase de PascalCase ou vice-versa, mas agora você sabe a
diferença);
 snake_case - este é o padrão usado em Python para definir qualquer coisa que
não for uma classe. Todas as letras serão minúsculas e separadas por um
underline, como em: minha_variavel , funcao_legal , soma .

Os padrões usados em Python são: snake_case para qualquer

coisa e PascalCase para classes.

Qualquer importação feita tem que ser relacionada ao seu main quando se tem uma package

Esse ponto antes do modulo representa o package que você esta pode ser colocado o próprio
nome também
Variável livre e quando a variável não esta no escopo que a função chama

Letra aqui e uma variável livre para função soma. Um variável livre pode ser usada, mas
modificada, mas quando e colocado o comando nonlocal isso se torna possível

Decoradoras e decoradores:

Decoradoras são as funções que são usadas para passa o código agora os decoradores são
ferramentas que ajudam a usar os decoradores os syntax_sugar usado com o @

Tambem e possível cria uma fabrica de decoradores e parâmetros a ela como visto na
aula40.py’
Count:

Count e um interador do intertools

Veja na aula44

Combinations , permutations e product:

Uma forma fácil de fazer a misturas dos dados em um plano cartesiano

Aula45

Outro comando do itertoools e o groupby:

Que e possível ver na aula47 e 46

Os métodos partial, reduce, map e filter estão na aula48

Funções recursivas ou recursividade:

Usadas quando se tem quando se tem um problema grande, e possível dividir esse problema
em várias partes

Na prática e uma função que retorna ela mesma

Essas funções têm alguns elementos

Como o caso recursivo que e o problema que o código vai resolver

O caso recursivo aqui e multiplicação de 2 até 44, mas esse código esta errado porque ele vai
geral uma quantidade de call Stack(o limite de call Stack e 1k no python) absurdas uma Stack
overflow pra isso vamos precisa de um caso base, que vai fazer o código para de retorna a
própria função.
Nessa função têm um loop então ela irá passar por todos os elementos. Fazendo ser possível
mudar esses elementos

Ambient virtual:

A muitas maneiras de se utilizar ambientes virtuais em python, mas aqui a que vamos usar e
venv.

Na pasta venv e colocado a sua versão de python e todas as bibliotecas de terceiros. Isso e
usado para não ter um acúmulo de versões e documentos de cada trabalho no seu pc e
também utilizado para ser usado novamente em outra época por exemplo dá manutenção em
um site antigo.

E possível dá qualquer nome ao ambiente, mas os mais comuns são: venv, env

Se e colocando um ponto antes do nome sua pasta do ambiente virtual fica oculta

Lembrando que quando o ambiente virtual for executado ele vai usar o python que foi
guardado que pode ser diferente do python global da sua máquina

Quando e criando o venv ele tem algumas pastas:

Lib: tudo que for instalado de terceiros vai pra la

Para ativar o ambiente virtual primeiro e preciso cria o ambiente com python -m venv nome
do ambiente

E logo depois e so usa nome\scripts\activate e deactivate para desativar

Agora com seu ambiente virtual instalado e ativo e possível baixar coisas de fora do python
para e somente o ambiente virtual sem afeta o python global.

Utilizando o pypi onde vai ter uma série de ferramentas para serem usada em python

Usando por exemplo pip install PyMySQL para instalar uma biblioteca sql

Ser quiser atualizar e so colocar um pip install –upgrade e se tiver algum problema de erro e
so tentar python -m pip install o que você quiser.

Para desinstalar e necessário apenas o comando pip uninstall pymysql se quiser pular a
confirmação e só coloca um -y na frente
Pip freeze vai dizer o qtem instalado na no seu ambiente virtual

pip index versions pymysql para ver todas as versões pymysql

geralmente a pessoas tem várias coisas instalada nos ambientes virtuais então e possível fazer
um pip freeze > requiments.txt para pode baixar tudo de uma forma mais fácil

fazendo um pip install -r .\requirements.txt

criando arquivos com python:

Quando e criada uma pasta e possível especificar o caminho que a pasta vai ou não. Se não for
colocada a pasta ficara no arquivo que você está, mas e possível especificar o caminho

Essas duas barras são usadas apenas no Windows(ser não der certo e so coloca um r antes do
caminho).

Porem não e possível apenas abrir o arquivo como editar ele com os context manager

W usado para escrever

R leitura

W+ para escrita e leitura

Quando o ‘’w’’ e usado ele apaga tudo que já tem no arquivo. O ‘’a’’ escreve tudo abaixo do
conteúdo que já existe no arquivo

Sempre que um arquivo e aperto ele TEM quer ser fechado

With vai ser usado como o open só que mais seguro porque ele abre e fecha o arquivo sozinho

Json:
Uma estrutura de envio de arquivos baseada em js. Json só e bem simples no seu uso não
consegue enviar métodos nem estruturas muitos complexas com um set

Aqui estávamos enviando o arquivo e possível usar om encoding= ‘utf8’ para usa acentos e
caracteres especiais

Aqui estou abrindo o json que não tem mais no meu python é uma coisa de fora. Lembrando
que o json pode modifica um pouco os dados nesse caminho uma tupla pode se torna uma
lista por exemplo

Positional-only parametrs:

Um forma de limitar o usuário tudo que estive antes de barra tem que ser posicional

Tudo depois pode ser nomeado ou posicional

Keyword-only-Arguments:

Todos que estiverem na frente do * so poderão ser nomeados

Mas isso não que dizer que os de traz não podem ser nomeados esse * so indica que os da
frente tem que ser obrigatoriamente nomeados

Mas para fazer o código ficar mais limitado e possível usar a / e * juntos

Com isso os antes da / so podem ser posicionais e das frente do * so podem ser nomeados

Programação orientada a objetos poo:

A partir daqui e uma novo tópico que vai render muitas aulas e conhecimentos

Class:

Class vão reunir um grupo de objetos(instâncias). As class vão ter atributos(dados) e métodos,
para usar as classe temos o padrão de usar Pascalcase.

Obs: da uma olhada em calme case

As calss tem seus próprio escopo junto com os métodos

Esse funções iram ter seus escopos entao não posso usar valor em acelera

Como também não posso buscar aquele nome no escopo class sem mencionar a mesmo como
fiz no print comentado. E essa variável valor só pode ser nos métodos da class

As instancias são guardadas em com um formato de em dicionários como dic com isso e
possível visualizar e editar essa instancias de uma forma diferente
Uma coisa bastante interessante e que e possível manter o estados dentro da class

Nesse caso depois que self.tipo passa por andar o self.tipo ganha um estado

Nesse caso True isso pode ser usado e modificado com o código
Class method

Invés de pegar a instancia e cria e modificar ela com os method e possível pegar a própria class
e fazer uma extensão dela

Static method

Que não e nada mais que uma função normal só que protegida pelo namespace da class

Property
E normal em linguagens de programação usar atributos em forma de métodos para proteger
os atributos os famosos getter

Mas no python de uma forma específica de fazer isso com @property

Assim e possível chamar esse atributo protegido em função em forma de atributo

Setter

Setter e um método para tratar o atributo para usa um setter tem que ter um property so
olhar na aula67.py
 Encapsulamento:
(modificadores de acesso: public, protected, private)

# Python NÃO TEM modificadores de acesso

# Mas podemos seguir as seguintes convenções

# (sem underline) = public

# pode ser usado em qualquer lugar

# _ (um underline) = protected

# não DEVE ser usado fora da classe

# ou suas subclasses.

# __ (dois underlines) = private

# "name mangling" (desfiguração de nomes) em Python

# _NomeClasse__nome_attr_ou_method

# só DEVE ser usado na classe em que foi

# declarado.

Relações entre classes

Associação: e uma relação que um elemento com outro do tipo fraca que um não depende do
outro

Agregação: uma associação do tipo fraca um elemento conecta a outro, mas um elemento
existe sem outro um sendo necessário de outro para realiza certa tarefa.

Dessa foram uma agregação geralmente envolve 1 para muitos

Composição: e uma forma agregação de forma mais específica nesse termo tudo vai ser mais
ou menos iguala a agregação, só que aqui uma depende da outra pra existir

Teoria de herança
Na era um objeto não depende de outro, mas sim um objeto e outro

Como cliente nesse caso ele faz parte de uma classe mais genérica que e Pessoa

O cliente não depende não usa ele faz parte de pessoa

Class Pessoa

Super class, base class, parent class

Class filha

Sub class, child class, derived class

Obs: um exemplo de herança simples na aula70.py

Sobreposição

Quando e escrito um method em uma derived class com o mesmo nome de um method na
super class da mesma, fazendo esse method ser rescrito.

Claro que esse fenômeno também acontece com atributos também

Herança múltipla

Quando uma class recebe varias classe fazendo um seu código ser genial usando e otimizando
ferramentas, como também pode deixar seu código desnecessariamente complexo e confuso

E tão confuso que o python usa um próprio sistema para organizar esssa ordem o famoso
c3 linearization um algoritmo que vai fazer o mro do código

Obs: explicação do problema do diamante na aula73.py

Abstração

Quando o programador não quer que uma class seja usada diretamente,

Pra isso existe o mixin uma class que reuni funções para serem usadas naquela família de class
ou em outra herança não conectada a aquela.
Abstract Base Class (abc):

Em python class abstratas não podem ser instanciadas diretamente, essa class tem property ,
setter .. (usando o @ abstractmethod como decorador interno) métodos concretos e
abstratos. @ abstractmethod não tem corpo e podem ser implementados mais tardes em
subclass lembrando que a abc e um molde de método e coisa que as subs class devem seguir

Exemplos de como usar o abstractmethod com property e setter estão na aula 76 e 77