---
# System prepended metadata

title: Python
tags: [' Alura', Socket, ' Formação']

---

---
title: "Python"
tags: "Socket, Formação, Alura"
---

# Python

- `print` para escrever modo texto
- `display` para escrever tabela formatada

==ALURA==

# Python 3 parte 1: Introdução a nova versão da linguagem

## 01- Introdução e instalação do Python 3
---

[Link formatação Python](https://pyformat.info/)
- Instalando o Python no windows
- Instalando em outras plataformas
- Usar o Python sem instalá-lo
  - [Python on-line](https://replit.com/languages/python3)
- Função print e variáveis
  > print()
  
    ```python=
    pais = "Italila"
    print(pais)
    titulos = 4
    print(pais, "ganhou", titulos, "titulos mundiais")
    ```
  - Descobrir o tipo da variável
  > type()
  
```python=
#string interpolation
print("Tentativa {} de {}".format(rodada, total_tentativoas))
#for com range
for rodada in range(1,10,2):
  print(rodada)
```
- Modulos
  
  ```python=
  import random
  ```

:::important Funções built-in
Estão automaticamente disponíveis e podem ser chamadas em todos lugares
:::

- Tipagem do Python (dinâmica)
  - Variáveis dinâmicas

## 02- Lidando com a entrada do usuário
---
- Instalando e conhecendo o PyCharm
- Comparando variáveis

- Diferenças entre o Python 2 e 3
  > print "" - print("")

## 03- Testando valores
---
- Condição `elif`

# Python 3 parte 2: Avançando na linguagem

## 01- Preparando o jogo da forca
---
- Introdução
- Ajustando a infraestrutura
- Game loop

## 02- Manipulando strings
---
- Encontrando letras
  - função `find()`
    ```python=
    palavra.find("b")
    ```
    > retorno `-1` se não econtrou
    > 
    > retorno `2` posição encontrada 

- Funções importantes da String

## 03- Conhecendo e trabalhando com listas
---
- Estrutura de dados `List` **listas**
  > podem ser alteradas (mutáveis)

  ```PYTHON=
  valores = ["S","T","Q","Q","S","S","D"]
  ```
- Guardando as letras acertadas

## 04- Conhecendo e trabalhando com tuplas
---
- O que são `tuple` **tuplas**
  > Não podem ser alteradas (imutável)
  
  ```python=
  dias = ("S","T","Q","Q","S","S","D")
  ```
- Listas e tuplas juntas
  ```python
  lista = [("Nico",39),("Jose",31)]
  idade = instrutures [0][1]
  ```
  > $ 39
- `set`
  ```python=
  colecao = {1122334455, 2233445566, 7788991122}
  ```
- `dictionary`
  ```python=
  instrutores = {"Nico" : 39, "Flavio" : 37, "Marcos" : 30}
  ```
## 05- Implementando o encerramento do jogo
---
- Estipulando tentativas de erros
- Compressão de lista `List Comprehension`
  - Exemplo lista de números pares
  - Código com `List Comprehension`
    ```python=
    inteiros = [1,3,4,5,7,8,9]
    pares = [x for x in inteiros if x % 2 == 0]
    ```
  - Código sem  `List Comprehension`
    ```python=
    inteiros = [1,3,4,5,7,8,9]
    pares = []
    for numero in inteiros:
        if numero % 2 == 0:
            pares.append(numero)
    ```
## 06- Escrita e leitura de arquivos
---
- Escrevendo em um arquivo
- Lendo um arquivo
- Escolhendo uma palavra

## 07- Melhorando o código e a apresentação
---
- Organizando o codigo em funções
- Criando mais funções
- Melhorando a aprsentação

# Python: Entendendo a Orientação a Objetos
***

## 01. O problema do paradigma procedural
- Dados da conta
- Dados e comportamento
- O paradigma OO

## 02. Classes e Objetos
- Classe e Objeto
- Construtur
- Acessando atributos

## 03. Implementando métodos
- Usando métodos
- Revisão de conteúdo
- None e coletor de lixos

## 04. Encapsulamento
- Atributos privaados
- Encapsulamento
- Coesão
:::success
**SOLID** 
Falamos nessa aula sobre a ==coesão== que é ligado ao principio de *responsabilidae única*.
Aprendemos que uma classe deve ter apenas uma responsabilidade (ou deve ter apenas uma razão para existir). Em outras palavras, ela não deve assumir responsabilidade que não são delas.
:::
> **SOLID**
> - ==S== Single responsibility principle
> - ==O== Open/closed principle
> - ==L== Liskov substituion principle
> - ==I== Interface segregation principle
> - ==D== Dependency inversion principle

## 05. Usando propriedades
- Getters e Setters
- Propriedades

## 06. Métdos privados e estáticos
- Métodos privados
- Métodos da classe
- Python OO vs Java OO
***

# Converter arquivo Python em executável
***
### Biblioteca com Interface Windows ==auto-py-to-exe==

- [Link auto-py-to-exe](https://pypi.org/project/auto-py-to-exe/)
- Instalar **auto-py-to-exe** (terminnl)
    > $ pip install auto-py-to-exe
- Executar (terminal)
    > $  auto-py-to-exe

:::info
Dar preferência para ambiente virtual

Usar **Pycharm**
:::

### Biblioteca via terminal ==pyinstaller==
- (1) Incluir dentro do arquivo python a ser convertido
  ```python=
  import win32com.client as win32 
  ```
- (2) Instalar **pywin32**
  > $ pip install pywin32

- Instalar **pyinstaller**
  > $ pip install pyinstaller

- Gerar o arquivo executável
  > $ pyinstaller --onefile -w nome_arquivo.py

- Para lilnux
  > $ pyintaller pycopy.py --onefile 
---

## Socket em Python (Enviar e receber arquivos)
==Felipe Dasr==

**PyCharm**
- [Youtube - Como Enviar e Receber arquivos com Socket em Python](https://www.youtube.com/watch?v=j4Drn47pc3o)
- [Link Projeto SOCKET](S:\treinamentos\python)

==Boson Treinamentos==
- [Youtube - Scripts Cliente/Servidor Socket em Python](https://www.youtube.com/watch?v=vbUuJ2_6wqs&t=610)
- [Link do Projeto Scripts](/home/share/treinamentos/python/boson-treinamentos/socket)

## Manipulando arquivos e diretórios Python
==Eduardo Mendes==
- Libraries
    - **os**
        - `listdir` Lista os arquivos em diretório
        - `rmdir` Remove um diretório
        - `walk` Cria uma relação de todos arquivos e diretórios presentes no diretório passado como parâmetro
    - **os.path**
        - `exists` Retorna se o arquivo ou diretório existe
        - `abspath` Retorna o caminho absoluto do arquivo
        - `join` Concatena paths para descrever caminhos
    - **shutil**
        - `copy` Copia um arquivo
        - `rmtree` remove um árvore de diretórios
        - `disk_usage` Retorna a capacidade *total/livre/usada* em bytes do disco a qual o path pertence

## **Logs** em Python
==Eduardo Mendes==
- Import
```python=33
from loggin import basicConfig
from loggin import DEBUG
```
- Níveis ou gravidade
    - DEBUG
    - INFO
    - WARNING
    - ERROR
    - CRITICAL

- Configurar/parametrizar
```python=5
basicConfig(
    level=DEBUG,
    filename='meu_log.txt',
    filemode='a',
    enconding='utf-8',
    format='%(levelname)s:%(asctime)s:%(message)s'
)
```

- Saída do Log (Arquivo/padrão) - Handlers
```python=4
from logging import basicConfig   # configuração
from logging import DEBUG         # level
from logging import debug, info, error # camadas
from logging import FileHandler, StreamHandler # handlers

basicConfig(
    level=DEBUG,
    encoding='utf08',
    format='%(levelname)s:%(asctime)s:%(message)s',
    handlers=[FileHandler('meu_log.txt', 'w', StreamHandler())]
)
```
- Variedade de Handlers
    - StreamHandler
        - Escreve no shell (terminal)
    - FileHandler
        - Escreve em um arquivo
    - RotatingFileHandler
        - Rotaciona o arquivo, qdo ficar grande demais
    - SMTPHandler
        - Envia um email com a mensagem de log
    - HTTPHandler
        - Envia um request
    - SysLogHandler
        - Passa o log para os logs do sistema

## **loguru** Logs mais simples!
- Instalar loguru
    > $ pip install loguru
- Exemplo código loguru
```python=17
from sys import stderr
from loguru import logger
logger.remove()

logger.add(
    sink=stderr,
    format='{time} {level} {message} {file}',
    filter=lambda rec: 'senha' not in rec['message'].lower(),
    level='INFO'
)

logger.critical('critical')
logger.debug('debug')
logger.info('info')
logger.warning('warning')
```

## **Regex** (Expressões regulares) Python

==pythonando==
- [Youtube - Guia completo REGEX Python](https://www.youtube.com/watch?v=l712xxSWSi4&t=1532)
- [Link Projeto REGEX](/home/share/treinamentos/python/regex)

- Criar um padrão `compile` 
    ```py=2
    pattern = re.compile("[\w\s]")
    ```
- Comparar os padrões
    - `fullmatch` compare se a string inteira segue o padrao definido
    - `search` busca o primeiro local da string na qual corresponde com o padrao
    - `findall` busca em uma string aquilo que segue o padrao criado
    ```py=3
    x = re.findall(pattern, string)
    print(x)
    ```
- Representações
- `.` representa qualquer caracter menos \n
- `[]`  conjunto de algumas operacoes
- `^` representa o inicio da string
- `$` representa o final da string
- `[^]` diferente de um caractere
- `\w` is alfanum
- `\W` not is alfanum
- `\s` caracter vazio
- `\S` nao vazio
- `\d` numeros de 0 a 9
- `\D` not in 0 a 9
- `[]` conjunto de possibilidades

- Quantificadores
    - `+` Uma ou mais
    - `*` 0 ou mais
    - `?` 0 ou 1
    - `{x}` x vezes
    - `{z, y}` z minimo y máximo

- Exemplos de padrões: CPF, E-mail
---

# Injector em Python - **Socket** Python (Cliente e Servidor)
==Marcone==
- Escrever caracteres especiais 
    > `# coding: utf-8`
---

# Módulo **_socket_**
==Boson Treiaamentos==
[](https://)
- O módulot _socket_ do Python fornece uma interface para a API de sockets BSD.
- Principais métodos:
    - `socket()`
        - aceita uma concexão de cliente
    - `bind(endereco)`
        - associa o socket servidor a um endereço
    - `listen([backlog])`
        - ccmeça a escutar pedidos de conexão
    - `accept()`
    - `connect(endereco)`
        - conecta um cliente a um endereço
    - `connect_ex(endereco)`
        - idem anterior, retornando um indicador de erro, em vez de uma exceção, na ocorrência da chamada do connect em baixo nível
    - `send(bytes[,flags])`
        - solicita o envio dos bytes pelo socket até que um certo conjunto de bytes seja enviado (buffer suficiente para garantir o envio)
    - `sendall(bytes[,flags])`
        - envia todos os bytes passados como parâmetro, o que ocasiona sucessivos envios em chamadas de sistema até que todos os bytes sejam enviados.
    - `recvfrom(bufsize,[,flags])`
        - (UDP) lê os bytes recebidos, retornando-os em uma string, até o limite de buffer defenido por _buffsize_
    - `recv(bufsize,[,flags])`
        - lê os bytes recebidos, retornando-os em uma string, até o limite de buffer definido por _buffsize_.
    - `close()`
        - fecha um soce, liberando todos os recursos alocados
    - `geteername()`
        - retorna o endereço do socket remoto com o qual um socket local está associado
    - `getsockname()`
        - retorna o endereço do socket local
### Interfaces de sockets
:::success
A interface de soquetes se diferencia pelos diferentes serviços que são forneceidos
:::
- Interface de soquetes de fluxo (_stream_): Define um serviço orientado à conexão confiável (sobre _TCP_). Dados sãao enviados sem erros ou duplicação, e recebidos na mesma ordem em que foram enviados. _**SOCK_STREAM**_.
- Interface de soquetes de datagrama: Define um serviço sem conexão (sobre _UDP_). Os Datagramas são enviados como pacotes independentes. Não há garantias, pois os dados podem ser pedidos ou duplicados, e ainda chegarem fora da ordem. _**SOCK_DGRAM**_.
- Interface de soquetes brutos: Permite acesso direto a protocolos na camada inferior, como por exemplo _ICMP_ e _IP_. Exemplo de aplicação: programa _ping_. _**SOCK_RAW**_.
- Constantes e atributos de sockets
    - `socket.family` família do socket criado
    - `socket.type` tipo do socket criado
    - `socket.proto` protocolo associado ao socket
- Criar objeto **socket**
    - Criamos um objeto do tipo socket usando o método `socket.socket()`, o qual recebe dois ou três parâmetros (um é opcional):
        - Família endereços
            - **AF_INET** (endereço IPv4)
            - **AF_INET6** (endereço IPv6)
        - Tipo do Socket
            - **SOCK_STREAM** (para socket _TCP_)
            - **SOCK_DGRAM** (para socket _UDP_)
        - Protocolo (variação do protocolo em uma família)
            - Geralmento (zero)
- Sequência de chamadas à API socket: 
![](https://i.imgur.com/8QsYCQi.png)

- [PDF - API sockets sobre TCP/IP](S:\markdown\TcpIp.pdf)
- [Documentação SOCKET Python](https://docs.python.org/3/library/socket.html?highlight=socket#module-socket)
---
# **Pathlib** (Python)
:::success
Caminhos de pastas para qualquer sistema operacioanl.
(absolute = completo)
:::

## Ambiente virtual em Python
- Criar ambiente
> $ python -m venv venv
- Ativar ambiente
    - PS (PowerShell)
    > $ .\venv\Scripts\Activate.ps1
    - Cmd
    > $ .\venv\Scripts\Activate.bat
- Desativar ambiente
> $ deactivate
---

# **PySimpleGUI** (Janelas/Form no Python)

---
# Compactar arquivos (**ZipFile**)
==Programação Dinâmica==

---

# **Argparse** arguments (Python)
==anthonywritescode==
- [Youtube - python argparse tutorial (beginner - intermediate)](https://www.youtube.com/watch?v=-Sgw-6a1HjU&t=830)
- Tipos de argumentos
    - positional
    - optional
    - short vs long opts
    - aliases
    - help
    - defaults
    - types
    - custom types
    - count
    - append
    - boolean options
    - choces
    - sub-commands
- Print argumentos
```py=3
args = parser.parse_args(argv)
print(vars(args))
```
---

# Curso **Python**
==Otávio Miranda==

## Funções (def) - **args** e **kwargs**
- Exemplo código funções
```python=34
"""
Funções (def) em PYton *arg **kwargs
@author = gibruch
"""

def func(*args):
    # Converter de tupla para lista
    arqs = list(args)
    print(f'Todos argumentos: {args}')         # todos args
    print(args[0])      # primeiro valor
    print(args[-1])     # último valor
    print(len(args))    # tamoho lista/tupla (quantidade de valores)
    print(f'Lista inteiro: {args}')
    # listar itens da lista
    print('Argumentos da lista:')
    for a in args:
        print(a)

print('---Chamando a function "func"---: ')
func(1,3,4,6,7,8,9)

print('---Lista desempacotada---: ')
lista = [1,3,4,5,6,7,8]
func(*lista) # Desempacotar lista
```

## Escopo de variáveis
- Exemplo codigo variáveis
```python=33
# Escopo de variáveis
print('---Escopo de variáves---:')
variavel = 'valor'

def val():
    print(variavel)

def val2():
    variavel = 'outro valor'
    print(variavel)

val()
val2()
print(variavel)
```
## Módulo **shutil**

# Framework **Flask** x **django**
==Hashtag Programação==
- Youtube

## Flask (web development, one drop at a time)
- Desenvolvimento rápido e fácil de aplicações
- Aprendizado mais passo a passo
- Minimalista e Simples - Muito flexível
- Boa comunidade, apoiado por grandes empresas
- Facilidade de usar extensões

## django
- Desenvolvimento rápido e escalável de aplicações maiores
- Aprendizado mais estruturado
- Estrutura completa e Padronizada
- Comunidade muito completa
- Muita coisa pronta pra você

# Python do Básico ao Avançado
==Udemy - Programando Ideias==

## Instalando Python e Ferramentas
- Windows
    - Instalando/atualizando `pip`
        > $ python -m pip install --upgrade pip
    - Instalando `virtualenv` (ambiente virtual)
        > $ pip install virtualenv virtualenvwrapper-win 

    - Criar ambiente virtual (windows)
        > $ mkvirtualenv 'nome da pasta'
    - Remover ambiente virtual 
        > $ rmvirtualenv 'nome da pasta'
- Linux
    - Atualizando pacotes linux
        > $ sudo apt update && apt upgrade
    - Instalando git curl
        > $ sudo apt install git curl
    - Instalando `python`
        > $ sudo apt install python3.10
- Configurar Python
    > $ sudo apt install python3.10-dev python3.10-venv python3-venv python3-pip virtualenv gcc libssl-dev -y 

# Python: Avançando na orientação a objetos
==Alura==

## 01. Relembrando classes e objetos
- Introdução
- Relembrando classes e objetos
- Com e sem inicializador
- Adicionando atributos e métodos
- Titularizando nomes
- Encapsulando comportamemto
- Vantagens do property
- Atributos de classes

## 02. Removendo duplicação com herança
- Removendo duplicação
- Sobre Herança
- Reutilizando ainda mais
- Vantagens de Herança
- Explicando a Herança
- Estendendo a superclasse

## 03. Reduzindo `ifs` com polimorfismo
- Polimorfismo
- Reduzundi ifs
- Identificado o polimorfismo
- Representação textual de objetos
- Representação String

### Projeto Playlist de programas
- Playlist
    - nome
    - programas
    - tamanho()

## 04. Quando não usar herança
- Criando Playlist
- Herdando list
- Reaproveitando um list
- Fugindo da complexidade
- Desvantagens na herança
