Folha de dicas do Python: guia rápido e fácil essencial

Ao programar em Python , ter uma folha de dicas confiável ao seu lado pode mudar o jogo. O Python pode ser conhecido por sua simplicidade e legibilidade, mas não há como negar que sua extensa gama de recursos e funcionalidades é demais para memorizar!

As folhas de dicas do Python servem como uma referência útil para iniciantes e desenvolvedores experientes. Eles fornecem um guia de referência básico para vários comandos, sintaxe, estruturas de dados e muito mais.

Este guia é uma folha de dicas do Python que pode ajudá-lo a navegar por várias funções , bibliotecas, classes e sintaxe que podem ser esmagadoras, especialmente para iniciantes.

Você é da velha escola? Prefira baixar e imprimir, confira o pdf abaixo para ajudá-lo em sua jornada de aprendizado do Python!

Python-Cheat-Sheet-1 Baixar

Índice

• Referência rápida para noções básicas de sintaxe do Python
  • 1. Comentários
  • 2. Variáveis
  • 3. Tipos de dados
  • 4. Declarações condicionais
  • 5. Voltas
  • 6. Funções
• Referência rápida para estruturas de dados Python
  • 1. Listas
  • 2. Tuplas
  • 3 partidas
  • 4. Dicionários
• Referência rápida para E/S de arquivo Python
  • 1. Lendo arquivos
  • 2. Escrevendo arquivos
  • 3. Anexar aos arquivos
• Referência rápida para tratamento de erros em Python
  • 1. Tente e Exceto
  • 2. Finalmente
  • 3. Gerando Exceções
• Referência rápida para módulos e pacotes Python
  • 1. Módulos de importação
  • 2. Criando Pacotes
• Referência rápida para programação orientada a objetos em Python
  • 1. Aulas
  • 2. Herança
  • 3. Encapsulamento
• 4 bibliotecas Python úteis
  • 1. NumPy
  • 2. Pandas
  • 3. Pedidos
  • 4. Bela Sopa
• Pensamentos finais

Referência rápida para noções básicas de sintaxe do Python

Para iniciar nossa folha de dicas do Python, exploraremos alguns princípios básicos da sintaxe do Python. Ter uma forte compreensão dos fundamentos do Python fornecerá uma base sólida para escrever códigos mais complexos.

Para esta referência, incluímos: comentários , variáveis ​​, tipos de dados , instruções condicionais , loops e funções .

1. Comentários

Os comentários são uma parte importante do seu código, pois permitem que você explique seu processo de pensamento e torne seu código mais legível. Em Python, você pode criar comentários de linha única usando o símbolo de cerquilha (#).

# This is a single-line comment.

Para comentários de várias linhas, você pode usar aspas triplas (simples ou duplas).

""" This is a
multi-line
comment. """

2. Variáveis

Variáveis ​​em Python são usadas para armazenar dados. Você pode atribuir valores a variáveis ​​usando o sinal de igual (=).

x = 5
name = "John"

Os nomes das variáveis ​​devem ser descritivos e seguir a convenção de nomenclatura de usar letras minúsculas e sublinhados para espaços.

user_age = 25
favorite_color = "blue"

3. Tipos de dados

A linguagem Python vem com vários tipos de dados integrados por padrão. Alguns dos mais comuns incluem:

• Tipos de texto : str

• Tipo booleano : bool

• Tipos numéricos : int, float, complex

• Tipos de sequência : lista, tupla, intervalo

• Nenhum Tipo: Nenhum tipo

Para descobrir o tipo de dados de qualquer objeto Python, você pode usar a função type() . Por exemplo:

name = 'jane'
print(type(name))

#Output: 'str'

4. Declarações condicionais

As instruções condicionais em Python permitem que você execute o código somente quando certas condições forem atendidas. As declarações condicionais comuns são ' if ', 'elif ' e ' else '.

if condition:
    # Code to execute if the condition is true
elif another_condition:
    # Code to execute if the another_condition is true
else:
    # Code to execute if none of the conditions are true

5. Voltas

Um loop é usado para executar repetidamente um bloco de código. Python tem dois tipos de loops: um loop ' for ' e um loop ' while '.

Vamos dar uma olhada em ambos:

Para loops:

for variable in iterable:
    # Code to execute for each element in the iterable

Enquanto loops:

while condition:
    # Code to execute while the condition is true

Dentro desses loops, você pode usar instruções condicionais e de controle para controlar o fluxo do seu programa.

6. Funções

Funções em Python são blocos de código que executam tarefas específicas. Você pode definir uma função usando a palavra-chave ' def ', seguida pelo nome da função e parênteses contendo quaisquer parâmetros de entrada.

def function_name(parameters):
    # Code to execute
    return result

Para chamar uma função, use o nome da função seguido de parênteses contendo os argumentos necessários.

function_name(arguments)

Agora que examinamos os fundamentos do Python, vamos passar para alguns tópicos mais avançados na próxima seção.

Referência rápida para estruturas de dados Python

A seguir, em nossa folha de dicas do Python, discutiremos algumas das estruturas de dados mais usadas em Python. Essas estruturas de dados são essenciais para gerenciar e organizar os dados em seus projetos de programação.

Existem muitas estruturas de dados em Python que desenvolvedores avançados podem usar. No entanto, vamos nos concentrar em Lists , Tuples , Sets e Dictionaries .

1. Listas

Uma lista em Python é uma sequência mutável e ordenada de elementos. Para criar uma lista, use colchetes e separe os elementos com vírgulas.

As listas do Python podem conter uma variedade de tipos de dados, como strings, inteiros, booleanos, etc. Aqui estão alguns exemplos de operações que você pode executar com as listas do Python:

• Crie uma lista:

  my_list = [1, 2, 3]

• Elementos de acesso:

  my_list[0]

• Adicione um elemento:

  my_list.append(4)

2. Tuplas

Uma tupla é semelhante a uma lista, mas é imutável, o que significa que você não pode alterar seus elementos depois de criados. Você pode criar uma tupla usando parênteses e separando os elementos com vírgulas.

Aqui estão alguns exemplos de operações de tupla:

• Crie uma tupla:

  my_tuple = (1, 2, 3)

• Elementos de acesso:

  my_tuple[0] #Output: 1

3 partidas

Um conjunto é uma coleção não ordenada de elementos únicos. Você pode criar um conjunto usando a função set() ou chaves.

Ele também pode conter uma variedade de tipos de dados, desde que sejam exclusivos. Aqui estão alguns exemplos de operações de conjunto:

• Crie um conjunto:

   my_set = {1, 2, 3}

• Adicione um elemento:

  my_set.add(4)

• Remover um elemento:

  my_set.remove(1)

4. Dicionários

Um dicionário é uma coleção não ordenada de pares chave-valor, onde as chaves são únicas. Você pode criar um dicionário usando chaves e separando as chaves e valores com dois pontos. Aqui estão alguns exemplos de operações de dicionário:

• Crie um dicionário:

  my_dict = {'key1': 'value1', 'key2': 'value2'}

• Elementos de acesso:

  my_dict['key1'] #Output:'value1'

• Adicione um par chave-valor:

  my_dict['key3'] = 'value3'

• Remova um par chave-valor:

  del my_dict['key1']

Lembre-se de praticar e explorar essas estruturas de dados em seus projetos Python para se tornar mais proficiente em seu uso! Em seguida, forneceremos uma referência para tarefas de E/S de arquivo.

Quick Reference for Python File I/O

In this section of the Python cheat sheet, we’ll focus on some common tasks related to working with files in Python, such as reading, writing, and appending data.

1. Reading Files

To read a file, you first need to open it using the built-in open() function, with the mode parameter set to ‘r‘ for reading:

file_obj = open('file_path', 'r')

Now that your file is open, you can use different methods to read its content:

• read(): Reads the entire content of the file.

• readline(): Reads a single line from the file.

• readlines(): Returns a list of all lines in the file.

It’s important to remember to close the file once you’ve finished working with it:

file_obj.close()

Alternatively, you can use the with statement, which automatically closes the file after the block of code completes:

with open('file_path', 'r') as file_obj:
    content = file_obj.read()

2. Writing Files

To create a new file or overwrite an existing one, open the file with mode ‘w‘:

file_obj = open('file_path', 'w')

Write data to the file using the write() method:

file_obj.write('This is a line of text.')

Don’t forget to close the file:

file_obj.close()

Again, consider using the with statement for a more concise and safer way to handle files:

with open('file_path', 'w') as file_obj:
    file_obj.write('This is a line of text.')

3. Appending to Files

To add content to an existing file without overwriting it, open the file with mode ‘a‘:

file_obj = open('file_path', 'a')

Use the write() method to append data to the file:

file_obj.write('This is an extra line of text.')

And, as always, close the file when you’re done:

file_obj.close()

For a more efficient and cleaner approach, use the with statement:

with open('file_path', 'a') as file_obj:
    file_obj.write('This is an extra line of text.')

By following these steps and examples, you can efficiently navigate file operations in your Python applications. Remember to always close your files after working with them to avoid potential issues and resource leaks!

In the next section, we provide a reference for error handling in Python.

Quick Reference for Error Handling in Python

In this section, you’ll learn about error handling in Python, which plays a crucial role in preventing the abrupt termination of your programs when it encounters an error.

We’ll cover the following sub-sections: Try and Except, Finally, and Raising Exceptions.

1. Try and Except

To handle exceptions in your code, you can use the try and except blocks. The try block contains the code that might raise an error, whereas the except block helps you handle that exception, ensuring your program continues running smoothly.

Here’s an example:

try:
    quotient = 5 / 0

except ZeroDivisionError as e:
    print("Oops! You're trying to divide by zero.")

In this case, the code inside the try block will raise a ZeroDivisionError exception. Since we have an except block to handle this specific exception, it will catch the error and print the message to alert you about the issue.

2. Finally

The finally block is used when you want to ensure that a specific block of code is executed, no matter the outcome of the try and except blocks. This is especially useful for releasing resources or closing files or connections, even if an exception occurs, ensuring a clean exit.

Here’s an example:

try:
    # Your code here
except MyException as e:
    # Exception handling
finally:
    print("This will run no matter the outcome of the try and except blocks.")

3. Raising Exceptions

You can also raise custom exceptions in your code to trigger error handling when specific conditions are met. To do this, you can use the raise statement followed by the exception you want to raise (either built-in or custom exception).

For instance:

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be a negative value.")

try:
    validate_age(-3)
except ValueError as ve:
    print(ve)

In this example, we’ve defined a custom function to validate an age value. If the provided age is less than zero, we raise a ValueError with a custom message. When calling this function, you should wrap it in a try-except block to handle the exception properly.

Next, we’re going to provide a quick reference for popular Python modules and packages. Let’s go!

Quick Reference for Python Modules and Packages

This section of our cheat sheet is for Python packages and modules, which are essential for structuring and organizing your code cleanly and efficiently.

You’ll learn about importing modules and creating packages.

1. Importing Modules

Modules in Python are files containing reusable code, such as functions, classes, or variables. Python offers several modules and packages for different tasks like data science, machine learning, robotics, etc.

To use a module’s contents in your code, you need to import it first. Here are a few different ways to import a module:

• import : This imports the entire module, and you can access its contents using the syntax ‘module_name.content_name.’
  For example:

  import random
  
  c = random.ranint()

• from import : This imports a specific content (function or variable) from the module, and you can use it directly without referencing the module name.

  from math import sin
  
  c = sin(1.57)

• from import *: This imports all contents of the module. Be careful with this method as it can lead to conflicts if different modules have contents with the same name.

Some commonly used built-in Python modules include:

1. math: Provides mathematical functions and constants

2. random: Generates random numbers and provides related functions

3. datetime: Handles date and time operations

4. os: Interacts with the operating system and manages files and directories

2. Creating Packages

Packages in Python are collections of related modules. They help you organize your code into logical and functional units. To create a package:

1. Create a new directory with the desired package name.

2. Add an empty file named init.py to the directory. This file indicates to Python that the directory should be treated as a package.

3. Add your module files (with the .py extension) to the directory.

Now, you can import the package or its modules into your Python scripts. To import a module from a package, use the syntax:

import 

Structure your code with modules and packages to make it more organized and maintainable. This will also make it easier for you and others to navigate and comprehend your codebase.

In the next section, we provide a reference for object-oriented programming concepts in Python.

Quick Reference for Object-Oriented Programming in Python

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects“, which can contain data and code.

The data is in the form of fields, often known as attributes or properties, and the code is in the form of procedures, often known as methods.

In this section of the cheat sheet, we’ll delve into the fundamental concepts of OOP in Python, including classes, inheritance, and encapsulation.

1. Classes

A class is a blueprint for creating objects. It defines the data (attributes) and functionality (methods) of the objects. To begin creating your own class, use the “class” keyword followed by the class name:

class ClassName:
    # Class attributes and methods

To add attributes and methods, simply define them within the class block. For example:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

Neste exemplo, um novo objeto Dog pode ser criado com um nome e raça, e possui um método bark que imprime “ Woof! ” quando chamado.

2. Herança

A herança permite que uma classe herde atributos e métodos de outra classe, permitindo a reutilização e a modularidade do código. A classe que herda é chamada de subclasse ou classe derivada, enquanto a classe que está sendo herdada é chamada de classe base ou superclasse.

Para implementar a herança, adicione o nome da superclasse entre parênteses após o nome da subclasse:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Por exemplo, você pode criar uma subclasse “Poodle” de uma classe “Dog”:

class Poodle(Dog):
    def show_trick(self):
        print("The poodle does a trick.")

Um objeto Poodle agora teria todos os atributos e métodos da classe Dog, bem como seu próprio método show_trick.

3. Encapsulamento

O encapsulamento é a prática de agrupar dados e métodos que operam nesses dados em uma única unidade, um objeto neste caso. Isso promove uma clara separação entre a implementação interna de um objeto e sua interface externa.

Python emprega alteração de nome para obter encapsulamento para membros de classe adicionando um prefixo de sublinhado duplo ao nome do atributo, tornando-o aparentemente privado.

class Example:
    def __init__(self):
        self.__private_attribute = "I'm private!"

    def __private_method(self):
        print("You can't see me!")

Embora você ainda possa tecnicamente acessar esses membros privados em Python, isso é fortemente desencorajado, pois viola os princípios de encapsulamento.

Compreendendo e implementando classes, herança e encapsulamento em seus programas Python, você pode utilizar o poder e a flexibilidade da OOP para criar código limpo, modular e reutilizável.

Para nossa seção final da folha de dicas, forneceremos uma referência rápida para quatro bibliotecas Python populares.

4 bibliotecas Python úteis

Várias bibliotecas Python podem ajudá-lo a realizar uma variedade de tarefas ou obter ferramentas para vários tópicos, como matemática, ciência de dados, web scraping, etc.

Nesta seção, discutiremos brevemente as seguintes bibliotecas: NumPy , Pandas , Requests e Beautiful Soup .

1. NumPy

NumPy é uma biblioteca Python popular para computação matemática e científica. Com seu poderoso objeto de matriz N-dimensional, você pode lidar com uma ampla gama de operações matemáticas, como:

• Funções matemáticas básicas

• Álgebra Linear

• análise de Fourier

• Geração de números aleatórios

As manipulações de matriz eficientes do NumPy o tornam particularmente adequado para projetos que exigem cálculos numéricos.

2. Pandas

Pandas é uma poderosa biblioteca de análise e manipulação de dados que você pode usar para trabalhar com dados estruturados. Também é muito popular na comunidade de ciência de dados devido à ampla gama de ferramentas que fornece para lidar com dados.

Algumas de suas características incluem:

• Estruturas de dados como Series (1D) e DataFrame (2D)

• Limpeza e preparação de dados

• Análise estatística

• Funcionalidade de série temporal

Ao utilizar o Pandas, você pode facilmente importar, analisar e manipular dados em vários formatos, como CSV, Excel e bancos de dados SQL.

Se você estiver interessado em Pandas, pode conferir nosso vídeo sobre como reamostrar dados de séries temporais usando Pandas para aprimorar a análise:

3. Pedidos

A biblioteca Requests simplifica o processo de manipulação de solicitações HTTP em Python. Com esta biblioteca, você pode facilmente enviar e receber solicitações HTTP, como GET, POST e DELETE.

Alguns recursos principais incluem:

• Manipulando redirecionamentos e seguindo links em páginas da web

• Adicionando cabeçalhos, dados de formulário e parâmetros de consulta por meio de bibliotecas Python simples

• Gerenciando cookies e sessões

Usando Requests, você pode interagir de forma rápida e eficiente com vários serviços web e APIs.

4. Bela Sopa

Beautiful Soup é uma biblioteca Python para web scraping, que permite extrair dados de documentos HTML e XML. Alguns de seus principais recursos incluem:

• Procurando por tags específicas ou classes CSS

• Navegando e modificando árvores analisadas

• Extraindo informações relevantes com base nos atributos da tag

Ao usar o Beautiful Soup em conjunto com Requests, você pode criar aplicativos poderosos de raspagem da web que coletam informações de uma ampla variedade de sites.

Pensamentos finais

E isso nos leva ao fim de nossa rápida viagem pela Python Lane. Esta folha de dicas é seu guia de bolso, seu ajudante de confiança para quando você precisar de um lembrete rápido das principais funções e comandos do Python.

Nossa lista não é exaustiva, mas é um começo sólido, uma base sobre a qual você pode construir. Então vá em frente, marque-o, imprima-o, cole-o na parede - apenas certifique-se de que esteja à mão quando estiver codificando. Boa programação!