A ciência de dados está mudando o mercado atual de maneiras inimagináveis. Desde que começou a crescer, ele se aprimorou continuamente e se tornou a ferramenta mais indispensável para organizações de todos os setores. Desde a análise do comportamento do cliente até a previsão das tendências do mercado, a ciência de dados oferece às empresas informações poderosas que podem ajudá-las a tomar melhores decisões e obter uma vantagem competitiva em seus respectivos setores.

Python para Ciência de Dados

Python é uma linguagem de programação versátil e fácil de usar que oferece uma variedade de bibliotecas e ferramentas para inteligência artificial, aprendizado de máquina e análise de dados. Seu extenso ecossistema de bibliotecas inclui módulos conhecidos como NumPy, Pandas, Matplotlib, Scikit-learn e TensorFlow, que são frequentemente usados ​​por cientistas de dados para criar modelos e visualizações de dados complexos. Além de suas capacidades técnicas, também possui uma comunidade grande e solidária que contribui continuamente para seu crescimento e desenvolvimento. Devido a tudo o que ele tem a oferecer, os cientistas de dados podem obter uma vantagem competitiva ao dominar o Python antes de entrar no setor.

Conceitos essenciais ao aprender sobre os fundamentos do Python

A. Tipos de Dados

Embora Python seja uma linguagem de tipagem dinâmica onde os tipos de dados são determinados durante o tempo de execução, ainda é essencial conhecer as diferenças entre os tipos de dados, pois determina as operações que podem ser executadas em uma determinada variável.

Tipos de dados básicos em Python

1. Numérico

Inteiros vs Floats

Um número inteiro é simplesmente um número inteiro, enquanto um número de ponto flutuante , ou float , é um número que consiste em casas decimais. Isso torna o valor 11 um número inteiro e o valor decimal 2,5 um flutuante.

Usar a função type() ajudaria você a confirmá-la.

num = 11
print(f"num is a \"{type(num)}\"")

decimal = 1.1
print(f"decimal is a \"{type(decimal)}\"")

Strings são valores de texto compostos por uma sequência de caracteres (letras, dígitos e outros caracteres válidos).

name = "S@r4!1l"
print(f"name is a \"{type(name)}\"")

Booleanos são usados ​​para armazenar os valores lógicos “True” e “False” . Esses valores são frequentemente vistos em declarações condicionais, pois são usados ​​para controlar o fluxo da programação.

found = True
print(f"found is a \"{type(found)}\"")

1. Lista

As listas são coleções ordenadas de itens que são mutáveis , o que significa que o objeto pode ser modificado depois de criado. Ele é criado usando colchetes [] onde todos os seus elementos estão separados por uma vírgula.

Por exemplo,

colors = ["Red", "Yellow", "Blue"]

empty_list = []
print(f"empty_list is a \"{type(empty_list)}\"")

Tuplas são coleções ordenadas de itens que são imutáveis , o que significa que o objeto não pode ser modificado depois de criado. Ele é criado usando parênteses () onde todos os seus elementos estão separados por vírgula.

Por exemplo,

fruits = ("Mango", "Pineapple", "Strawberry")

empty_tuple = ()
print(f"empty_tuple is a \"{type(empty_tuple)}\"")

Dicionários coleção ordenada mutável de itens que não permite duplicatas. Ele consiste em pares chave-valor dentro de chaves {} onde dois pontos ( :) são usados ​​para separar as chaves de seu valor correspondente.

Por exemplo,

my_dict = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g', 8:'h', 9:'i', 10:'j', 11:'k', 12:'l', 13:'m', 14:'n', 15:'o', 16:'p', 17:'q', 18:'r', 19:'s', 20:'t', 21:'u', 22:'v', 23:'w', 24:'x', 25:'y', 26:'z'}

empty_dict = {}
print(f"empty_dict is a \"{type(empty_dict)}\"")

Os conjuntos são coleções não ordenadas mutáveis ​​de dados exclusivos que não permitem duplicatas. Ele é criado usando chaves {} onde todos os seus elementos estão dentro separados por uma vírgula.

Por exemplo,

even = {2, 4, 6, 8, 10}

empty_set = set()
print(f"empty_set is a \"{type(empty_set)}\"")

O fluxo de controle de um programa é a sequência na qual as instruções são avaliadas e executadas. A sequência pode ser alterada dependendo das instruções de fluxo de controle usadas. Ser proficiente com esse conceito permite que os programadores executem operações complexas e escrevam códigos legíveis e de fácil manutenção.

Declarações de Seleção

1. Se declaração

As instruções if são usadas para executar um corpo de código quando certas condições são atendidas. A sintaxe de uma instrução if é:

if condition:
    # code to be executed if True

if grade > 75 and grade <= 100:
    print("Passed")

Uma condição else pode ser adicionada após uma instrução if . A sintaxe de uma instrução if-else é:

if condition:
    # code to be executed if True 
else:
    # code to be executed if False

if grade > 75 and grade <= 100:
    print("Passed")
else:
    print("Failed")

Adicionar uma palavra-chave elif permite várias alternativas. A sintaxe de uma instrução if-elif-else é:

if condition1:
    # code to be executed if condition1 is True 
elif condition2:
    # code to be executed if condition2 is True
else:
    # code to be executed when both condition1 and condition2 are False

if grade > 75 and grade <= 100:
    print("Passed")
elif grade == 0:
    print("Incomplete")
else:
    print("Failed")

1. Para Loop

For loops são usados ​​para iterar por meio de um objeto iterável , como uma string, lista ou tupla. A seguir, criaremos um loop que itera por uma lista de nomes e imprimiremos cada elemento da lista.

for name in name_list:
    print(name)

Enquanto os loops são usados ​​para executar um bloco de código até que certas condições sejam atendidas. Abaixo estaremos criando um loop que imprime o valor de i até chegar a 5.

while i <= 5:
    print(i)
    i += 1

Funções são blocos de código reutilizáveis ​​que executam uma tarefa específica. Isso permite que os programadores decomponham suas soluções para tarefas específicas, evitem a repetição de códigos e mantenham os programas legíveis.

A sintaxe de declaração de uma função em Python pode ser a seguinte:

# without parameters
def function_name1():
    # function body 

# with parameters
def function_name2(parameter):
    # function body

def greeting(name):
    print(f"Hello {name}!")

Veja como é feito:

greeting("Mary")

Programação Orientada a Objetos (OOP) é ​​uma abordagem para escrever programas de computador em que as classes de objetos estão intimamente ligadas aos atributos (variáveis) e comportamentos (métodos) aos quais estão associados. Compreender OOP fornece uma melhor compreensão por trás das bibliotecas python e nos permite criar programas legíveis e sustentáveis.

Quatro Pilares da OOP

1. Herança

Herança é a derivação de uma nova classe a partir de uma classe existente. Essa nova classe (também conhecida como classe filha) herda os métodos e propriedades de uma classe existente (chamada de classe pai).

Vamos dar um exemplo,

# Parent class
class Fruit:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# Child class 
class Mango:
    def __init__(self, name, price, state):
        # Access methods and properties of the parent class using super()
        super().__init__(name, price)
        self.state = state

2. Encapsulamento

O encapsulamento é o agrupamento de atributos e métodos relacionados em uma única classe. Por meio do encapsulamento , as classes externas não podem alterar os atributos e métodos disponíveis para uma classe. Isso ocorre porque as variáveis ​​geralmente são tornadas “privadas” para ocultar os dados.

Em Python, os atributos privados são indicados usando sublinhados duplos ( __ ).

Um exemplo seria,

class Fruit:
    def __init__(self, name):
        self.name = name
        self.__price = 10

    def sell(self, payment):
        print(f"Selling price: {self.__price}")
        print(f"Change: {payment - self.__price}")

    def set_price(self, price):
        self.__price = price

orange = Fruit("orange")
orange.sell(12)

# Changing the price
orange.__price = 5
orange.sell(12)

# Using the setter method
orange.set_price(3)
orange.sell(12)

3. Polimorfismo

Polimorfismo é o uso de uma única entidade para executar diferentes tipos de comportamentos. Digamos que temos o exemplo abaixo:

class Cat:
    def make_sound(self):
        print("Meow")

class Frog:
    def make_sound(self):
        print("Ribbit")

class Cow:
    def make_sound(self):
        print("Moo")

4. Abstração

A abstração é a ocultação de detalhes sem importância do usuário para reduzir a complexidade do programa e garantir que os programadores se concentrem apenas naqueles que são importantes.

Aqui está um exemplo de sua implementação,

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def drive(self):
        pass

class Car(Vehicle):
    def drive(self):
        print("Driving a car")

class Motorcycle(Vehicle):
    def drive(self):
        print("Driving a motorcycle")

#vehicle = Vehicle()
car = Car()
motorcycle = Motorcycle()

#vehicle.drive()
car.drive()
motorcycle.drive()

Conclusão

Em resumo, adquirir uma base sólida dos fundamentos do Python é vital para indivíduos que desejam ingressar no campo da ciência de dados. Python é uma linguagem de programação altamente adequada para ciência de dados por causa de sua natureza amigável, extensas bibliotecas, versatilidade e comunidade de suporte. Além disso, o amplo uso do Python no campo cria inúmeras oportunidades de carreira para os proficientes nele. Portanto, aprender os fundamentos do Python pode se tornar um passo crucial para uma carreira de sucesso em ciência de dados para aspirantes a profissionais de ciência de dados.