<jupyter_start><jupyter_text>COMANDOS AUXILIARES  Declaração de Variáveis Auxiliares<jupyter_code>soma = 0
a = 1
b = 1<jupyter_output><empty_output><jupyter_text>FUNDAMENTOS BÁSICOS  Comentários Basicamente existem duas maneiras de fazermos comentários no Python: Comentário de Linha e Comentário de Bloco.Comentários não são lidos/executados pelo interpretadorAlém disso, temos também comentários de documentação. Comentários de Documentação são utilizados para descrever o que uma função ou classe fará, e eles seguem a mesma idéia dos comentários, ou seja, temos comentários de documentação de bloco e de linha  Comentário de Linha `soma = a + b   Comentário de Linha`<jupyter_code>soma = a + b # Comentarios de Linha
soma<jupyter_output><empty_output><jupyter_text>Comentário de Bloco ` Este é um exemplo de comentário de`  ` bloco. Cada linha contém um símbolo de`  ` "jogo da velha" separado por um espaço`  ` do conteúdo de desejamos escrever`  `soma = a + b`<jupyter_code># Este é um exemplo de comentário de
# bloco. Cada linha contém um símbolo de
# "jogo da velha" separado por um espaço
# do conteúdo de desejamos escrever
soma = a + b
soma<jupyter_output><empty_output><jupyter_text>Documentação  Documentação de Linha `def soma(a, b):`  &emsp;`"""Exemplo de Documentação de linha."""`<jupyter_code>def soma(a, b):
    """Exemplo de Documentação de linha."""
    return a + b<jupyter_output><empty_output><jupyter_text>Documentação de Bloco `def soma(a, b):`  &emsp;`"""Exemplo de Documentação de Bloco`  &emsp;`No geral, a primeira linha da documentação`  &emsp;`é utilizada para definirmos o que será retornado`  &emsp;`na função. Fora isso, cada linha deve ficar sempre`  &emsp;`na mesa identação do inicío do bloco de documentação`  &emsp;`"""`<jupyter_code>def soma(a, b):
    """Retorna a soma de a e b
    
    Argumentos:
    a -- número real qualquer
    b -- número real qualquer
    
    Retorno
    soma dos argumentos
    
    Exemplo de Comentário de Documentação em Bloco
    No geral, a primeira linha da documentação
    é utilizada para definirmos o que será retornado
    na função. Fora isso, cada linha deve ficar sempre
    na mesa identação do inicío do bloco de documentação
    """
    return a + b<jupyter_output><empty_output><jupyter_text>Variáveis e Tipos Primitivos | Tipo de Dado | Tipo no Python| | :----------: | :-----------: || Número Inteiro | int || Número Fracional (Decimal) | float || Texto (Cadeia de Caracteres) | String (str) || Verdadeiro ou Falso | bool |<jupyter_code>i = 10
i
type(i)
i = 1.1
i
type(i)
i = 'Pedro'
i
type(i)
i = True
i
type(i)<jupyter_output><empty_output><jupyter_text>Como podemos observar, o objeto *i* recebeu todos os valores que desejamos inserir nele. Isso ocorre pois o objeto *i* é uma variável. Ou seja, o seu conteúdo pode variar de acordo com a necessidade do fluxo da aplicação, e quem define isso é, como esse conteúdo irá varia, é o desenvolvedor.Outro ponto importante do Python é que ele possuí inferencia de tipo. Ou seja, sempre que colocamos um tipo de dados dentro de uma variável, o Python irá inferir qual é o tipo daquele dado e irá configurar a variável para aquele tipo.O que nos impede de realizarmos operações em variáveis com tipos de dados diferentes. Podemos realizar operaões aritméticas somente em valores númericos (*int* e *float*). Caso tentemos realizar uma operação com dados de tipos diferentes, ocorrerá um erro de tipo:<jupyter_code>nome = 'Pedro'
print(type(nome))

idade = 32
print(type(idade))

soma = nome + idade
soma<jupyter_output><class 'str'>
<class 'int'>
<class 'int'><jupyter_text>Conversão de Tipos Primitivos Básicos Dessa forma, sempre que desejarmos realizar alguma operação com variáves com tipos de dados distintos, podemos realizar a conversão de tipo para realizarmos essa operação, desde que o conteúdo seja similar ao tipo de dados que desejamos.Ou seja, conseguimos realizar conversões de tipo desde que a varialvél em questão possua o conteúdo compatível como tipo final. Por exemplo, se tentarmos converter uma String qualquer em um número, teremos o seguinte erro:<jupyter_code>nome = 'Pedro'
nome_convertido = int(nome)
nome_convertido<jupyter_output><empty_output><jupyter_text>Porém, é possível realizar essa conversão se o conteúdo da String for um número ou um valor numérico:<jupyter_code>idade = '32'
idade_convertida = int(idade)
idade_convertida
type(idade_convertida)<jupyter_output><empty_output><jupyter_text>Podemos converter textos em tipos numéricos decimais (fração) também, basta utilizarmos a função `float()` no lugar da função `int()`:<jupyter_code>idade = '32'
idade_convertida = float(idade)
idade_convertida
type(idade_convertida)<jupyter_output><empty_output><jupyter_text>O mesmo vale para valores númericos. Conseguimos converter qualquer valor numérico para texto:<jupyter_code>idade = 32
idade_convertida = str(idade)
idade_convertida
type(idade_convertida)<jupyter_output><empty_output><jupyter_text>Veracidade no Python Outro ponto importante dentro da linguagem são os conceitos de Verdadeiro ou falso.Como podemos observar, é necessário fazermos conversões quando desejamos somar númeroq que o Python entende como tipos *int* e *str*. Mas e quando desejamos converter um número ou texto em um tipo booleano. Como fazemos isso?É nesse ponto que devemos falar sobre Veracidade em Python. Ou o que o Python entende como Verdadeira (True) e Falso (False).Para convertermos qualquer conteúdo para booleano em Python, basta utilizarmos a função `bool()`:<jupyter_code>idade = 32
idade_convertida = bool(idade)
idade_convertida<jupyter_output><empty_output><jupyter_text>Observe que o valor `32` foi convertido para `True`. Isso ocorre por conta da função `bool()` converter qualquer variável ou tipo de dado que tenha "conteúdo" para `True`, e qualquer variável ou tipo que não tenha "conteúdo" para `False`. Por exemplo<jupyter_code>print(f'Utilizando a função sem Parâmetro algum. Retorno => {bool()}')
print(f'Utilizando a função e passando uma String Vazia como Parâmetro. Retorno => {bool("")}') 
print(f'Utilizando a função e passando o valor zero como Parâmetro. Retorno => {bool(0)}')
print(f'Utilizando a função e passando o valor zero como Parâmetro. Retorno => {bool(0.0)}')
print(f'Utilizando a função e passando uma lista vazia como Parâmetro. Retorno => {bool([])}') 
print(f'Utilizando a função e passando um dicionário vazio como Parâmetro. Retorno => {bool({})}')
print(f'Utilizando a função e passando None como Parâmetro. Retorno => {bool(None)}')<jupyter_output>Utilizando a função sem Parâmetro algum. Retorno => False
Utilizando a função e passando uma String Vazia como Parâmetro. Retorno => False
Utilizando a função e passando o valor zero como Parâmetro. Retorno => False
Utilizando a função e passando o valor zero como Parâmetro. Retorno => False
Utilizando a função e passando uma lista vazia como Parâmetro. Retorno => False
Utilizando a função e passando um dicionário vazio como Parâmetro. Retorno => False
Utilizando a função e passando None como Parâmetro. Retorno => False<jupyter_text>Por outro lado, qualquer tipo de dado ou variável que tenha "conteúdo", será entendido como `True` pelo Python:<jupyter_code>print(f'Utilizando a função e passando uma String Vazia como Parâmetro. Retorno => {bool("P")}') 
print(f'Utilizando a função e passando o valor zero como Parâmetro. Retorno => {bool(1)}')
print(f'Utilizando a função e passando o valor zero como Parâmetro. Retorno => {bool(0.000001)}')
print(f'Utilizando a função e passando uma lista vazia como Parâmetro. Retorno => {bool([0])}') 
print(f'Utilizando a função e passando um dicionário vazio como Parâmetro. Retorno => {bool({"id": 0})}')
# Verifica se a variavel tem conteúdo

altura = 0.0
print(altura)

if(altura): # if(bool(idade))
    print(idade)
else:
    print('false')<jupyter_output>0.0
false<jupyter_text>I/O - Leitura e Escrita Básica Como já vimos e utilizamos, tanto nessa aula quanto na aula passada, a maneira mais básica de lermos algo do usuário em Python é utilizando a função `input('Mensagem')`. Por exemplo:<jupyter_code>dado_inserido = input("Digite a sua idade: ")
dado_inserido<jupyter_output>Digite a sua idade: 32<jupyter_text>Outro ponto importante é que tudo que for lido pela função `input()` é lido como `str`. Para utilizarmos esse conteúdo digitado como número, devemos utilizar a conversão de tipo:<jupyter_code>idade = int( input('Informe a sua Idade: ') )
idade
altura = float( input('Informe a sua Altura: ') )
altura<jupyter_output>Informe a sua Altura: 1.80<jupyter_text>OBS.: Lembrando que para fazermos a conversão para tipo `float`, o caractere separador da unidade inteira da decimal **DEVE** ser o ponto (`.`) e não a vírgula (`,`).<jupyter_code>altura = float(input('Informe a sua Altura: '))
altura<jupyter_output>Informe a sua Altura: 1,82<jupyter_text>ERROS MAIS COMUNS Os erros mais comuns ao iniciarmos os estudos na linguagem Python são:* Erros de Indentação* Utilizar Palavras Reservadas para nomear variáveis, funções e classes* Erros de digitação    * Python é Case Sensitive    * Digitação  Erros de Indentação Erros de indentação são bastante comuns dentro da linguagem Python. O Python utiliza espaços para designar o que nós chamamos de "blocos" de cósigo. Por exemplo, como vimos anteriormente, quando utilizamos a estrutura condicional `if()`, temos que inserir um "bloco" de código logo abaixo da declaração da estrutura condicional. E esse bloco será executado caso o teste feito no `if()` seja verdadeiro.<jupyter_code>teste = True

if(teste):
    # Bloco Entra aqui
    print('Passou no teste do if')<jupyter_output>Passou no teste do if<jupyter_text>Se não utilizarmos a identação de forma correta, o Python não entenderá os blocos de forma correta, o que ocasionará comportamentos indesejados na nossa aplicação, os famosos **BUGS**, ou pior ainda, quebrar nossa aplicação.<jupyter_code>teste = True

if(teste):
print('Passou no teste do if')<jupyter_output><empty_output><jupyter_text>Se observarmos a descrição do erro, podemos notar que o interpretador do Python está nos dizendo que ele estava esperando um bloc de código logo abaixo `if()`.Dessa forma, temos sempre que prestar atenção nos blocos de código que criamos quando estamos programando.  Palavras Reservadas Outro erro bastante comum mas não menos importante que o anterior é o uso de uma palavra reservada para nomear uma variável, função ou classe.As principais palavras reservadas que não devemos utilizar para nomear nossas variáveis, funções e classes são: * False	* def* if* raise* None* del* import* return* True* elif* in* try* and* else* is* while* as * except* lambda* with* assert* finally* nonlocal* yield* break* for* not* class* from* or* continue* global* pass  Erros de Digitação  Case Sensitive O Python é uma linguagem de programação *Case Sensitive*, ou seja, o tamanho das letras (Maíscula e Minúscula) diferem. Desse modo, se declararmos uma variável chamada `Nome` e depois tentarmos utilizá-la com a palavra `nome`, o Python não entenderá o que desejamos, pois `nome ≠ Nome`<jupyter_code>Sobrenome = 'Ferraresi'
print(sobrenome)<jupyter_output><empty_output><jupyter_text>Como podemos observar, a mensagem do erro nos informa que o "nome" *sobrenome* não está definidio. Isso quer dizer que a variável que tem o nome *sobrenome*, com todas as letras minúsculas, não está definida, ou seja, não foi declarada.  Digitação Outro ponto extremamente importante são os erros de digitação. Além do Python ser *Case Sensitive*, ele não conseguirá entender ou decifrar uma variável ou função que está escrita errada. Por exemplo<jupyter_code>variavelcomonomemuitograndeecomplexo = 'Ufa'
variavelcomonomemuitograndeecomplexo
variavelcomonomemuitogradeecomplexo<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07745762711864407, 'fraction_numerical': 0.003728813559322034, 'mean_word_length': 5.46276013143483, 'pattern_counts': {'":': 1, '<': 81, '<?xml version=': 0, '>': 100, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '576985', 'license': 'MIT', 'n_tokens_mistral': 4157, 'n_tokens_neox': 4074, 'n_words': 1500, 'path': '01-Fundamentos-Programacao-DS/Scripts/Mod-01/aula_02/aula_02.ipynb', 'repo_name': 'fgandrade/Estudos-Comunidade-DS', 'size': '11800'}