<jupyter_start><jupyter_text>Prof. <NAME> - Set/2021   IntroduçãoExistem duas versões principais da linguagem Python: **Python 2** e **Python 3**, e por sinal, são bem diferentes. Este curso usará a versão **Python 3**, por ela oferecer suporte a recursos mais recentes e pela outra versão que não terá mais suporte a patir de 2022.**Python** é uma linguagem muito simples e tem uma sintaxe muito direta. A instrução mais simples em Python é a que realiza a saída de dados: `print()` - ela imprime uma linha e também inclui a mudança para uma nova linha.Para imprimir uma *string* em Python 3, basta escrever:  (para executar a seguinte célula de código: selecione a célula e tecle `[Shift]+[Enter]` ou `[Ctrl]+[Enter]`)<jupyter_code>print("Curso de Introdução à Linguagem Python 3 - Turma 202109")<jupyter_output>Curso de Introdução à Linguagem Python 3 - Turma 202109<jupyter_text>Elementos da Linguagem PythonVocabulário: nomes de variáveis e palavras reservadas    Sentenças: padrões de sintaxe válida    Textos: programa para resolver um problema    Gramática: regras  1. Palavras ReservadasNão podem ser usadas como identificadores de variáveis, funções ou classes.  | Palavra-chave | Descrição|:---:|:---|and| Um operador lógico|as| Para criar um apelido (*alias*)|assert| Para depuração (*debugging*)|break| Para interromper um laço de repetição|class| Para definir uma classe|continue| Para continuar na próxima iteração de um laço|def| Para definir uma função do usuário|del| Para excluir um objeto|elif| Usado em declarações condicionais (**senão se**)|else| Usado em declarações condicionais (**senão**)|except| Usado no tratamento de exceções (o que fazer quando ocorre uma exceção)|False| Valor booleano, resultado de operações de comparação!finally| Usado em exceções (bloco de cód. sempre executado)|for| Para criar um laço `for`|from| Para importar partes específicas de um módulo|global| Para declarar uma variável global|if| Para fazer uma declaração condicional|import| Para importar um módulo|in| Para verificar se um valor está presente em uma lista, tupla, etc.|is| Para testar se duas variáveis são iguais|lambda| Para criar uma função anônima|None| Representa um valor nulo|nonlocal| Para declarar uma variável não local|not| Um operador lógico|or| Um operador lógico|pass| Uma declaração nula (declaração que não faz nada)|raise| Para levantar (gerar) uma exceção|return| Para sair de uma função e retornar um valor|True| Valor booleano, resultado de operações de comparação|try| Para fazer uma tentativa... com tratamento de exceção|while| Para criar um laço com teste no início|with| Usado para simplificar o tratamento de exceções|yield| Para finalizar uma função, retorna um gerador<jupyter_code>import keyword
print(keyword.kwlist)<jupyter_output>['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']<jupyter_text>2. SentençasPodem ser formadas a partir do uso dos elementos da linguagem, tais como: variáveis, operadores, constantes, palavras reservadas, funções, classes etc.```pythonx = 2                 atribuição de uma constante numérica à variável 'x'x = x + 100           atribuição de expressão aritmética à variável 'x'print(x)              função de apresentação de valor da variável 'x' (saída de dados)```Essas sentenças serão interpretadas pela linguagem na ordem em que são apresentadas, ou seja, de cima para baixo, uma a uma.>* A primeira sentença, **`x = 2`**, armazena a informação à direita do operador de atribuição `=`, nesse caso a constante numérica **`2`**, à variável chamada **`x`**.  >* A segunda sentença, **`x = x + 100`**, armazena o resultado da expressão à direita do operador de atribuição **`=`**, nesse caso o valor **`102`**, à variável chamada **`x`**.  >* E a terceira sentença **`print(x)`** mostra o valor corrente da variável **`x`**, nesse caso o valor **`102`**, na parte inferior da mesma célula do Jupyter Notebook com essa sequência de sentenças (*script*).    3. Textos (*Scripts* Python)* Execuções interativas (usando o interpretador padrão) são boas para experimentos e programas de 3 a 4 linhas.* A maioria dos programas efetivos possuem mais de 4 linhas, e geralmente digitamos os comandos em um arquivo (*script*) e dizemos à Python para executar os comandos existentes naquele arquivo. De certa forma, estamos dando um roteiro (*script*) a ser seguido pelo interpretador Python.* Por convenção, usamos `.py` como extensão dos arquivos com roteiros Python. Interativo  X  ScriptNo modo **interativo** o usuário digita as sentenças Python diretamente na linha de comandos, logo depois do *prompt* **`>>>`**, e finaliza a sentença com um [Enter]. Na sequência o interpretador analisa a sentença, e se estiver correta, ele apresenta o resultado do comando.No modo ***script*** o interpretador Python executará, um a um, os comandos existentes no arquivo informado pelo usuário como *script*.<jupyter_code># Script 1
# Função criada pelo usuário
def dobro(x):
    print(x * 2)

dobro(125)
# Script 2
# Mostra a palavra e a qtde de ocorrências em um texto gravado em arquivo (.txt)
nomearq = input("Arquivo: ")
arq = open(nomearq)
contagens = {}                 # dicionário vazio
for linha in arq:
    palavras = linha.split()
    for palavra in palavras:
        contagens[palavra] = contagens.get(palavra,0) + 1
contmaior = None
palavfreq = None
for palavra, contagem in contagens.items():
    if contmaior is None or contagem > contmaior:
        palavfreq = palavra
        contmaior = contagem
print(f"Palavra mais frequente {palavfreq}, com {contmaior} ocorrências.")
print(contagens)<jupyter_output>{'Echo': 2, 'off': 1, '***': 2, 'Ativando': 1, 'servidor': 1, 'de': 2, 'Jupyter': 1, 'Notebook': 1, 'para': 1, 'Curso': 3, 'Python': 1, '3': 1, 'd:': 1, 'cd': 1, 'D:\\python\\cursos\\curso_ifg\\1_basico\\202003\\1_Basic': 1, '"\\python\\WPy64-3850\\Jupyter': 1, 'Notebook.exe"': 1}<jupyter_text>Estruturas de Controle do Fluxo de Execução do *Script** Sequencial```pythonx = 2print(x)x = x + 100print(x)```* Condicional (Alternativa)```pythonx = 12if x < 10:     print("Menor que 10")if x > 20:     print("Maior que 20")print("Fim.")```* Repetição (Laço)```pythonn = 0while n < 10:     print(n+1)     n = n + 1print("Fim.")```  4. Regras 4.1 Recuo (Indentação)A ling. Python usa **indentação** para delimitar blocos de comandos, em vez de chaves, como na ling.s C/C++. Pode-se usar tabulações ou espaços em branco, mas o recuo padrão determina quatro espaços. Por exemplo:<jupyter_code>x = 1
if x == 1:
    # recuo de 4 espaços em branco
    print("x é 1.")
y = 33<jupyter_output>x é 1.<jupyter_text>4.2 ExercícioUse a função `print()` para imprimir **'Olá, Mundo!'**.<jupyter_code>print("Oi pessoal!")<jupyter_output>Oi pessoal!
{'fraction_non_alphanumeric': 0.11409685299612013, 'fraction_numerical': 0.01695645926138813, 'mean_word_length': 4.943637916310846, 'pattern_counts': {'":': 0, '<': 19, '<?xml version=': 0, '>': 25, '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': '5', 'dir': 'jupyter-structured-clean-dedup', 'id': '256253', 'license': 'Apache-2.0', 'n_tokens_mistral': 2534, 'n_tokens_neox': 2398, 'n_words': 900, 'path': 'notebooks/1_Basic/slides1_Elementos.ipynb', 'repo_name': 'kaw19/python', 'size': '6967'}