Python - Séries pandas

Série pandas é um array rotulado unidimensional capaz de conter dados de qualquer tipo (inteiro, string, float, objetos python, etc.). Os rótulos dos eixos são chamados coletivamente de índice. Uma série pandas nada mais é do que uma coluna em uma planilha do Excel.

Os rótulos não precisam ser exclusivos, mas devem ser do tipo hashable. O objeto é compatível com indexação inteira e baseada em rótulo e fornece uma série de métodos para executar operações envolvendo o índice.

Neste artigo, estamos usando o arquivo nba.csv.

Teremos uma breve visão sobre todas essas operações básicas que podem ser realizadas no Pandas série:

• Criando uma série
• Elemento de acesso da série
• Indexação e seleção de dados em série
• Operação binária na série
• Operação de conversão em série

Criando uma série

No mundo real, uma série Pandas será criada carregando os conjuntos de dados do armazenamento existente, o armazenamento pode ser banco de dados SQL, arquivo CSV e arquivo Excel. As séries Pandas podem ser criadas a partir de listas, dicionário e de um valor escalar, etc. As séries podem ser criadas de diferentes maneiras, aqui estão algumas maneiras pelas quais criamos uma série:

Criando uma série de array: Para criar uma série de array, temos que importar o módulo numpy e usar a função array().

# importando pandas com o alias pd
import pandas as pd
 
# importando numpy com o alias np
import numpy as np
 
# uma matriz simples
data = np.array(['A', 'c', 'e', 'r','v', 'o'])

ser = pd.Series(data)
print(ser)

Saída:

0    A
1    c
2    e
3    r
4    v
5    o
dtype: object

Criação de uma série a partir de uma listas:

Para criar uma série a partir de uma lista, temos que primeiro criar uma lista e depois podemos criar uma série da lista.

import pandas as pd
 
# uma lista simples
lista = ['A', 'c', 'e', 'r','v', 'o']
  
# criando uma série a partir de uma lista
ser = pd.Series(lista)
print(ser)

Saída:

0    A
1    c
2    e
3    r
4    v
5    o
dtype: object

Acessando elementos de uma série

Existem duas maneiras pelas quais podemos acessar o elemento da série, são elas:

• Acessando Elemento da Série com Posição.
• Acessando elemento usando rótulo (índice)

Acessando elemento de uma série com a posição: Para acessar o elemento da série refere-se ao número do índice. Use o operador de índice [] para acessar um elemento em uma série. O índice deve ser um número inteiro. Para acessar vários elementos de uma série, usamos a operação Slice.

# Código para acessar os 5
# primeiros elementos de uma série do pandas 
import pandas as pd
import numpy as np
 
# criando uma matriz simples
data = np.array(['A', 'c', 'e', 'r', 'v', 'o', ' ', 'L', 'i', 'm', 'a'])
ser = pd.Series(data)

# Mostra os cinco primeiros elementos da série
print(ser[:5])

Saída:

0    A
1    c
2    e
3    r
4    v
dtype: object

Acessando elemento usando rótulo (índice): Para acessar um elemento da série, temos que definir valores por rótulo de índice. Uma série é como um dicionário de tamanho fixo em que você pode obter e definir valores por rótulo de índice.

import pandas as pd
import numpy as np
 
# Criando matrizes simples
data = np.array(['A', 'c', 'e', 'r', 'v', 'o', ' ', 'L', 'i', 'm', 'a'])
ser = pd.Series(data, index=[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])

# acessando elemento pelo índice
print(ser[17])

Saída:

L

Indexação e seleção de dados em série

Indexar em pandas significa simplesmente selecionar dados específicos de uma série. A indexação pode significar selecionar todos os dados, alguns dos dados de colunas específicas. A indexação também pode ser conhecida como Seleção de subconjunto.

Indexando uma série usando o operador de indexação []: O operador de indexação é usado para referir-se aos colchetes após um objeto. Os indexadores .loc e .iloc também usam o operador de indexação para fazer seleções. Neste operador de indexação para se referir a df[].

 
import pandas as pd

# Criando um dataframe
df = pd.read_csv("nba.csv")

ser = pd.Series(df['Name'])
data = ser.head(10)
data

Saída:

0    Avery Bradley
1      Jae Crowder
2     John Holland
3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
6    Jordan Mickey
7     Kelly Olynyk
8     Terry Rozier
9     Marcus Smart
Name: Name, dtype: object

Agora acessamos o elemento da série usando o operador de índice [].

# Usando o operador de índice
data[3:6] 

Saída:

3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
Name: Name, dtype: object

Indexando uma série usando .loc[]: Esta função seleciona dados referindo-se ao índice explícito. O indexador df.loc seleciona dados de uma maneira diferente do que apenas o operador de indexação. Ele pode selecionar subconjuntos de dados.

import pandas as pd  
     
# Criando o dataframe
df = pd.read_csv("nba.csv")

ser = pd.Series(df['Name'])
data = ser.head(10)
data 

Saída:

0    Avery Bradley
1      Jae Crowder
2     John Holland
3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
6    Jordan Mickey
7     Kelly Olynyk
8     Terry Rozier
9     Marcus Smart
Name: Name, dtype: object

Agora acessamos o elemento da série usando a função .loc[].

# usando a função .loc[]
data.loc[3:6]

Saída:

3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
6    Jordan Mickey
Name: Name, dtype: object

Indexando uma série usando .iloc[]: Esta função nos permite recuperar dados por posição. Para fazer isso, precisamos especificar as posições dos dados que queremos. O indexador df.iloc é muito semelhante ao df.loc, mas usa apenas localizações de inteiros para fazer suas seleções.

import pandas as pd  
     
# Criando um dataframe
df = pd.read_csv("nba.csv")

ser = pd.Series(df['Name'])
data = ser.head(10)
data

Saída:

0    Avery Bradley
1      Jae Crowder
2     John Holland
3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
6    Jordan Mickey
7     Kelly Olynyk
8     Terry Rozier
9     Marcus Smart
Name: Name, dtype: object

Agora acessamos o elemento de Series usando a função .iloc[].

# usando a função .iloc[]
data.iloc[3:6]

Saída:

3      R.J. Hunter
4    Jonas Jerebko
5     Amir Johnson
Name: Name, dtype: object

Operação binária na série

Podemos realizar operações binárias em séries como adição, subtração e muitas outras operações. Para realizar a operação binária em série, temos que usar algumas funções como .add(), .sub() etc.

Código #1:

 
import pandas as pd

# Criando uma série
data = pd.Series([5, 2, 3,7], index=['a', 'b', 'c', 'd'])

# Criando outra série
data1 = pd.Series([1, 6, 4, 9], index=['a', 'b', 'd', 'e'])

print(data, "\n\n", data1)

Saída:

a    5
b    2
c    3
d    7
dtype: int64

 a    1
b    6
d    4
e    9
dtype: int64

Agora adicionamos duas séries usando a função .add().

# Adicionando duas séries usando a função .add()
data.add(data1, fill_value=0)

Saída:

a     6.0
b     8.0
c     3.0
d    11.0
e     9.0
dtype: float64

Código #2:

import pandas as pd  
 
# Criando uma série
data = pd.Series([5, 2, 3,7], index=['a', 'b', 'c', 'd'])

# Criando outra série
data1 = pd.Series([1, 6, 4, 9], index=['a', 'b', 'd', 'e'])

print(data, "\n\n", data1)

Saída:

a    5
b    2
c    3
d    7
dtype: int64

 a    1
b    6
d    4
e    9
dtype: int64

Agora subtraímos duas séries usando a função .sub().

# Subtraindo duas séries usando a função .sub()
data.sub(data1, fill_value=0)

Saída:

a    4.0
b   -4.0
c    3.0
d    3.0
e   -9.0
dtype: float64

Operação de conversão em série

Na operação de conversão, realizamos várias operações, como alterar o tipo de dados de uma série, alterar uma série para listar etc. Para realizar a operação de conversão, temos várias funções que ajudam na conversão, como .astype(), .tolist() etc.

Código #1:

# Programa Python usando astype
# para converter um tipo de dados de série
 
import pandas as pd

# Cria o dataframe a partir de um arquivo css
data = pd.read_csv("nba.csv")

# descartando colunas de valor nulo para evitar erros
data.dropna(inplace = True)

# armazenar dtype antes de converter
before = data.dtypes

# convertendo dtypes usando astype
data["Salary"]= data["Salary"].astype(int)
data["Number"]= data["Number"].astype(str)

# armazenar dtype após a conversão
after = data.dtypes

# Imprime para comparação
print("Antes da conversão\n", before, "\n")
print("Depois da conversão\n", after, "\n")

Saída:

Antes da conversão
 Name         object
Team         object
Number      float64
Position     object
Age         float64
Height       object
Weight      float64
College      object
Salary      float64
dtype: object

Depois da conversão
 Name         object
Team         object
Number       object
Position     object
Age         float64
Height       object
Weight      float64
College      object
Salary        int32
dtype: object

Código #2:

# Programa python para converter uma série pasdas numa lista

import pandas as pd  
import re 
     
# Criando um dataframe a partir de uma arquivo csv
data = pd.read_csv("nba.csv")

# removendo valores nulos para evitar erros
data.dropna(inplace = True)

# guardando dtype antes da operação
dtype_before = type(data["Salary"])

# Convertendo para lista
salary_list = data["Salary"].tolist()

# guardando dtype depois da operação
dtype_after = type(salary_list)

# imprimindo dtypes
print("Tipo de dado antes da conversão = {}\nTipode dado depois da conversão = {}"
      .format(dtype_before, dtype_after))

# monstrando lista
salary_list

Saída:

[7730337.0, 6796117.0, 1148640.0, 1170960.0, 2165160.0, 1824360.0, 3431040.0, 2569260.0, 6912869.0, 3425510.0, 1749840.0, 2616975.0, 845059.0, 1500000.0, 1335480.0, 6300000.0, 134215.0, 1500000.0, 19689000.0, 1140240.0, 947276.0, 981348.0, 947276.0, 947276.0, 11235955.0, 8000000.0, 1635476.0, 22875000.0, 845059.0, 845059.0, 1572360.0, 12650000.0, 3750000.0, 1636842.0, 4000000.0, 167406.0, 947276.0, 1000000.0, 4626960.0, 845059.0, 1074169.0, 6500000.0, 2144772.0, 525093.0, 3457800.0, 4582680.0, 947276.0, 2869440.0, 947276.0, 525093.0, 13600000.0, 10050000.0, 2500000.0, 7000000.0, 12000000.0, 6268675.0, 650000.0, 3553917.0, 245177.0, 1509360.0, 3873398.0, 13800000.0, 947276.0, 11370786.0, 2008748.0, 14260870.0, 11710456.0, 1131960.0, 845059.0, 1270964.0, 3815000.0, 15501000.0, 1100602.0, 111444.0, 5675000.0, 525093.0, 9650000.0, 18907726.0, 1100602.0, 19689000.0, 947276.0, 21468695.0, 3376000.0, 7085000.0, 3110796.0, 1159680.0, 3000000.0, 845059.0, 700000.0, 845059.0, 15592217.0, 1724250.0, 1155600.0, 3132240.0, 5103120.0, 981348.0, 947276.0, 5219169.0, 13500000.0, 2127840.0, 206192.0, 1160160.0, 981348.0, 13500000.0, 3807120.0, 1035000.0, 55722.0, 947276.0, 5500000.0, 2041080.0, 83397.0, 981348.0, 1015421.0, 1449187.0, 3398280.0, 5013559.0, 15851950.0, 947276.0, 525093.0, 12403101.0, 7700000.0, 3156600.0, 845059.0, 9500000.0, 845059.0, 2250000.0, 16407500.0, 4500000.0, 8500000.0, 947276.0, 2380440.0, 1015421.0, 13400000.0, 1391160.0, 20093064.0, 1535880.0, 1147276.0, 8193029.0, 16407501.0, 947276.0, 947276.0, 1276000.0, 19689000.0, 111196.0, 8988765.0, 14260870.0, 2100000.0, 2500000.0, 6500000.0, 2170465.0, 111444.0, 1252440.0, 2891760.0, 845059.0, 3272091.0, 16000000.0, 600000.0, 13913044.0, 2841960.0, 6270000.0, 5000000.0, 3000000.0, 4050000.0, 1007026.0, 17120106.0, 8000000.0, 4000000.0, 1358880.0, 211744.0, 1100000.0, 7000000.0, 2357760.0, 845059.0, 1007026.0, 3000000.0, 2399040.0, 947276.0, 1662360.0, 2943221.0, 8000000.0, 14700000.0, 16407500.0, 295327.0, 845059.0, 5152440.0, 2109294.0, 6600000.0, 1733040.0, 1449000.0, 4290000.0, 1100602.0, 3950313.0, 4053446.0, 2085671.0, 16407500.0, 1270964.0, 15361500.0, 845059.0, 947276.0, 5378974.0, 8193030.0, 306527.0, 6486486.0, 8229375.0, 1646400.0, 200600.0, 15756438.0, 1000000.0, 2489530.0, 3189794.0, 947276.0, 1404600.0, 5158539.0, 5000000.0, 3542500.0, 4088019.0, 9588426.0, 700902.0, 845059.0, 1201440.0, 1230840.0, 9638555.0, 9000000.0, 5464000.0, 8500000.0, 1100602.0, 3036927.0, 2850000.0, 7070730.0, 169883.0, 1164858.0, 845059.0, 10734586.0, 845059.0, 1320000.0, 15514031.0, 1015421.0, 10595507.0, 55722.0, 3382023.0, 19689000.0, 1142880.0, 947276.0, 5250000.0, 10000000.0, 16407500.0, 200600.0, 250750.0, 3578947.0, 525093.0, 1499187.0, 2000000.0, 1304520.0, 2854940.0, 12000000.0, 1000000.0, 5746479.0, 18671659.0, 947276.0, 525093.0, 3333333.0, 8000000.0, 947276.0, 189455.0, 947276.0, 525093.0, 6110034.0, 2612520.0, 6331404.0, 3034356.0, 5675000.0, 2139000.0, 12000000.0, 7000000.0, 4204200.0, 22192730.0, 10151612.0, 2854940.0, 261894.0, 845059.0, 5543725.0, 525093.0, 20000000.0, 981348.0, 2481720.0, 947276.0, 4171680.0, 845059.0, 1294440.0, 2380593.0, 5192520.0, 2505720.0, 4300000.0, 11250000.0, 5000000.0, 4000000.0, 5694674.0, 4375000.0, 561716.0, 3300000.0, 273038.0, 8000000.0, 1920240.0, 4662960.0, 2170465.0, 1100602.0, 200600.0, 15851950.0, 2814000.0, 3000000.0, 3533333.0, 10449438.0, 11235955.0, 1584480.0, 947276.0, 4345000.0, 258489.0, 1474440.0, 1282080.0, 2148360.0, 2056920.0, 1938840.0, 947276.0, 5703600.0, 5758680.0, 2279040.0, 3750000.0, 20158622.0, 3135000.0, 1140240.0, 16407500.0, 1463040.0, 222888.0, 3344000.0, 2021520.0, 1210800.0, 4500000.0, 5138430.0, 16744218.0, 525093.0, 8042895.0, 625093.0, 947276.0, 6980802.0, 2894059.0, 6000000.0, 5016000.0, 3075880.0, 4236287.0, 2525160.0, 525093.0, 1415520.0, 2854940.0, 2637720.0, 4775000.0, 2658240.0, 9463484.0, 12000000.0, 15409570.0, 1348440.0, 981348.0, 2239800.0, 2433333.0, 947276.0]

Métodos de operação binária em série:

Função	Descrição
add()	O método é usado para adicionar séries ou listas de objetos com o mesmo comprimento à série do chamador.
sub()	O método é usado para subtrair séries ou listar objetos semelhantes com o mesmo comprimento da série do chamador.
mul()	O método é usado para multiplicar séries ou listar objetos semelhantes com o mesmo comprimento da série do chamador.
div()	O método é usado para dividir séries ou listar objetos semelhantes com o mesmo comprimento pela série do chamador.
sum()	Retorna a soma dos valores do eixo solicitado.
prod()	Retorna o produto dos valores para o eixo solicitado.
mean()	Retorna a média dos valores para o eixo solicitado.
pow()	O método é usado para colocar cada elemento da série passada como potência exponencial da série do chamador e retornar os resultados.
abs()	O método é usado para obter o valor numérico absoluto de cada elemento em Series / DataFrame
cov()	O método é usado para encontrar a covariância de duas séries.

Método da série Pandas:

Função	Descrição
Series()	Uma série pandas pode ser criada com o método do construtor Series(). Este método de construtor aceita uma variedade de entradas.
combine_first()	O método é usado para combinar duas séries em uma.
count()	Retorna o número de observações não NA / nulas na série.
size()	Retorna o número de elementos nos dados subjacentes.
name()	Método permite dar um nome a um objeto Série, ou seja, à coluna.
is_unique()	O método retorna booleano se os valores no objeto forem únicos.
idxmax()	Método para extrair as posições de índice dos valores mais altos em uma Série.
idxmin()	Método para extrair as posições de índice dos valores mais baixos em uma Série.
sort_values()	O método é chamado em uma série para classificar os valores em ordem crescente ou decrescente.
sort_index()	O método é chamado em uma série pandas para classificá-lo pelo índice em vez de seus valores.
head()	Método é usado para retornar um número especificado de linhas desde o início de uma série. O método retorna uma nova série.
tail()	O método é usado para retornar um número especificado de linhas do final de uma série. O método retorna uma nova série.
le()	Usado para comparar todos os elementos da série do chamador com as séries passadas. Ele retorna True para cada elemento que é Menor ou Igual ao elemento na série passada.
ne()	Usado para comparar cada elemento da série do autor da chamada com as séries aprovadas. Ele retorna True para cada elemento que não é igual ao elemento na série passada.
ge()	Usado para comparar cada elemento da série do autor da chamada com as séries aprovadas. Ele retorna True para cada elemento que é maior ou igual ao elemento na série passada.
eq()	Usado para comparar cada elemento da série do autor da chamada com as séries aprovadas. Ele retorna True para cada elemento que é igual ao elemento na série passada.
gt()	Usado para comparar duas séries e retornar o valor booleano para cada elemento respectivo.
lt()	Usado para comparar duas séries e retornar o valor booleano para cada elemento respectivo.
clip()	Usado para cortar o valor abaixo e acima para o valor mínimo e máximo passado.
clip_lower()	Usado para recortar valores abaixo de um valor mínimo aprovado.
clip_upper()	Usado para recortar valores acima de um valor máximo aprovado.
astype()	O método é usado para alterar o tipo de dados de uma série.
tolist()	O método é usado para converter uma série em lista.
get()	O método é chamado em uma série para extrair valores de uma série. Esta é uma sintaxe alternativa à sintaxe tradicional de colchetes.
unique()	Pandas unique() é usado para ver os valores únicos em uma coluna particular.
nunique()	Pandas nunique() é usado para obter uma contagem de valores únicos.
value_counts()	Método para contar o número de vezes que cada valor exclusivo ocorre em uma série.
factorize()	O método ajuda a obter a representação numérica de uma matriz identificando valores distintos.
map()	Método para unir os valores de um objeto a outro.
between()	O método Pandas between () é usado em séries para verificar quais valores estão entre o primeiro e o segundo argumento.
apply()	O método é chamado e alimentado com uma função Python como um argumento para usar a função em cada valor de série. Este método é útil para executar operações personalizadas que não estão incluídas no pandas ou numpy.

Artigo traduzido por Acervo Lima de Python | Pandas Series.

Read More

Métodos de entrada Python para programação competitiva

Python é uma linguagem incrivelmente amigável com a única falha de ser lenta. Em comparação com C, C ++ e Java, é bem mais lento. Normalmente, em Java, o tempo fornecido é 2X e em Python, é 5X.
Para melhorar a velocidade de execução do código para problemas intensivos de entrada / saída, as linguagens têm vários procedimentos de entrada e saída.

Um Exemplo de Problema:

Considere a questão de encontrar a soma de N números inseridos pelo usuário. 
Entrada de um número com a quantidade de números. 
Insira os números separados por um único espaço em uma linha.

Exemplos: 

Entrada: 
5
1 2 3 4 5
Resultado:
15

Diferentes soluções para o problema acima em Python: 

Método normal Python: (Python 2.7) 

1. raw_input() recebe um argumento de prompt opcional. Ele também remove o caractere de nova linha final da string que retorna.
2. print é apenas um wrapper fino que formata as strings (espaço entre args e nova linha no final) e chama a função de gravação de um determinado objeto.

# método básico de entrada e saída
# N entradas
n = int(raw_input())

# entre com uma matriz
arr = [int(x) for x in raw_input().split()]

# inicializa variável
summation = 0

# calcula a soma
for x in arr:
    summation += x

# mostra a resposta
print(summation)

Um método um pouco mais rápido usando oa funções internas stdin, stdout: (Python 2.7)

1. sys.stdin por outro lado é um objeto de arquivo. É como criar qualquer outro objeto de arquivo que alguém possa criar para ler a entrada do arquivo. Nesse caso, o arquivo será o buffer de entrada padrão. 
2. stdout.write('D\n') é mais rápido que print('D'). 
3. Ainda mais rápido é escrever tudo de uma vez por stdout.write("".Join(list-comprehension)), mas isso torna o uso da memória dependente do tamanho da entrada.

# importa stdin stdout
from sys import stdin, stdout 

# suponha que uma função chamada main()
# e todas as operações sejam realizadas
def main():

    # entrada via readline
    n = stdin.readline()
 
    # método similar de entrada de array
    arr = [int(x) for x in stdin.readline().split()]

    # inicializa a variável
    summation = 0

    # calcula a soma
    for x in arr:
        summation += x

    # imprimir resposta por escrito
    # método write escreve apenas
    # operações de string
    # então precisamos converter qualquer
    # dados em string para entrada
    stdout.write(str(summation))

# chama o método principal
if __name__ == "__main__":
    main()

Diferença no tempo:

Resumo do tempo (100k linhas cada)
——————————–
Imprimir: 6.040s
Gravar no arquivo: 0.122s
Imprimir com saída padrão: 0.121s

Como vimos até agora, obter dados do sistema padrão e dar saída ao sistema padrão é sempre uma boa ideia para melhorar a eficiência do código, o que é sempre uma necessidade na programação competitiva. Mas espere! gostaria de escrever essas longas linhas sempre que precisar delas? Então, qual é a vantagem de usar Python.
Vamos discutir a solução para este problema. O que podemos fazer é criar funções separadas para pegar entradas de vários tipos e apenas chamá-las sempre que precisar.

Quando você deseja obter a entrada de números inteiros específicos fornecidos em uma única linha

Suponha que a entrada tenha o seguinte formato:

5 7 19 20

e queremos variáveis separadas para referenciá-los. o que queremos é:

a = 5
b = 7
c = 19
d = 20

então, podemos criar uma função chamada get_ints() da seguinte maneira:

import sys
def get_ints():
    return map(int, sys.stdin.readline().strip().split())
 
a, b, c, d = get_ints()

Agora você não precisa escrever esta linha novamente e novamente. Você apenas tem que chamar a função get_ints() para receber a entrada neste formulário. Na função get_ints, estamos usando a função map().

Quando você deseja obter a entrada de uma lista de inteiros fornecida em uma única linha

Suponha que a entrada tenha o seguinte formato

1 2 3 4 5 6 7 8

e queremos que uma única variável mantenha toda a lista de inteiros. O que queremos é:

Arr = [1, 2, 3, 4, 5, 6, 7, 8]

Então, aqui vamos criar uma função chamada get_list() da seguinte maneira:

import sys
def get_ints():
    return list(map(int, sys.stdin.readline().strip().split()))
 
Arr = get_ints()

Agora você não precisa escrever esta linha novamente e novamente. Você apenas tem que chamar a função get_ints() para receber a entrada neste formulário.

Quando você deseja inserir uma string

Suponha que a entrada tenha o seguinte formato:

Acerov Lima é a melhor plataforma para praticar a codificação.

e queremos que uma única variável de referência mantenha esta string. O que queremos é:

string = "Acerov Lima é a melhor plataforma para praticar a codificação."

Então, aqui vamos criar uma função chamada get_string() da seguinte maneira:

import sys
def get_string():
    return sys.stdin.readline().strip()
 
string = get_string()

Agora você não precisa escrever esta linha novamente e novamente. Você apenas tem que chamar a função get_string() para receber a entrada neste formulário
Adicionando um pipe em buffer io: (Python 2.7) 
1. Simplesmente, Adicionando o código IO em buffer antes de seu código de envio para tornar a saída mais rápida. 
2. O benefício dos objetos io.BytesIO é que eles implementam uma interface comum (comumente conhecida como um objeto 'semelhante a um arquivo'). Os objetos BytesIO têm um ponteiro interno e para cada chamada para read(n) o ponteiro avança. 
3. O módulo atexit fornece uma interface simples para registrar funções a serem chamadas quando um programa fecha normalmente. O módulosys também fornece um gancho, sys.exitfunc, mas apenas uma função pode ser registrada lá. O registro atexit pode ser usado por vários módulos e bibliotecas simultaneamente.

# importar bibliotecas para manipulação de entrada / saída em nível genérico
import atexit, io, sys
 
# Uma implementação de fluxo usando um buffer de bytes na memória.
# Ele herda BufferedIOBase.
buffer = io.BytesIO()
sys.stdout = buffer
 
# print
@atexit.register
def write():
    sys.__stdout__.write(buffer.getvalue())
 
# método normal seguido de entrada N
n = int(raw_input())
 
# insira o array
arr = [int(x) for x in raw_input().split()]
 
summation = 0

for x in arr:
    summation += x

print(summation)

Ao lidar com uma grande quantidade de dados normalmente, o método normal falha ao executar dentro do limite de tempo. O Método 2 ajuda a manter uma grande quantidade de dados de E / S. O Método 3 é o mais rápido. Normalmente, o manuseio de arquivos de dados de entrada maiores que 2 ou 3 MBs é auxiliado pelos métodos 2 e 3.
Nota: Os códigos de menção acima estão em Python 2.7, para uso em versões Python 3.X. Simplesmente substitua raw_input() pela sintaxe input() do Python 3.X. O descanso deve funcionar bem.
Referências: 
1. Mais sobre a entrada em Python 2.7 
2. Saída via biblioteca sys e outros comandos.  
3. Entrada via biblioteca sys e outros comandos.  
4. Documentos do Módulo Python atexit.
Este artigo é uma contribuição de Shubham Saxena.

Artigo escrito por GeeksforGeeks e traduzido por Acervo Lima de Python Input Methods for Competitive Programming.

Read More

Função Python map()

A função map() retorna um objeto de map (que é um iterador) dos resultados depois de aplicar a função dada a cada item de um determinado iterável (lista, tupla etc.)

Sintaxe:

map(fun, iter)

Parâmetros:

fun: é uma função para a qual a função map passa cada elemento de determinado iterável.
iter: é um iterável que deve ser mapeado.

NOTA: Você pode passar um ou mais iteráveis para a função map().

Retorna:

Retorna uma lista dos resultados após aplicar a função fornecida  
para cada item de um determinado iterável (lista, tupla etc.) 

  NOTA: O valor retornado de map() (objeto de mapa) pode ser passado para funções como list () (para criar uma lista), set () (para criar um conjunto).

CÓDIGO 1

# Programa python para demostrar o funcionamento da função map() 
  
# Retorna o dobro de n 
def addition(n): 
    return n + n 

# Dobramos todos os números usando map() 
numbers = (1, 2, 3, 4) 
result = map(addition, numbers) 
print(list(result)) 

Resultado:

[2, 4, 6, 8]

CÓDIGO 2

Também podemos usar expressões lambda com mapa para obter o resultado acima.

# Dobramos todos os números usando map e lambda 
  
numbers = (1, 2, 3, 4) 
result = map(lambda x: x + x, numbers) 
print(list(result)) 

Resultado:

[2, 4, 6, 8]

CÓDIGO 3

# Adiciona duas listas usando map e lambda 
  
numbers1 = [1, 2, 3] 
numbers2 = [4, 5, 6] 
  
result = map(lambda x, y: x + y, numbers1, numbers2) 
print(list(result)) 

Resultado:

[5, 7, 9]

CÓDIGO 4

# List of strings 
l = ['sat', 'bat', 'cat', 'mat'] 
  
# map() pode listar a lista de strings individualmente
test = list(map(list, l)) 
print(test) 

Resultado:

[['s', 'a', 't'], ['b', 'a', 't'], ['c', 'a', 't'], ['m', 'a ',' t ']]

Artigo escrito por pawan_asipu e traduzido por Acervo Lima de Python map() function.

Read More

Funções Lambda em Python

Em Python, uma função anônima significa que uma função não tem nome. Como já sabemos, a palavra-chave def é usada para definir uma função normal em Python. Da mesma forma, a palavra-chave lambda é usada para definir uma função anônima em Python. Possui a seguinte sintaxe: 

Sintaxe: argumentos lambda: expressão

• Essa função pode ter qualquer número de argumentos, mas apenas uma expressão, que é avaliada e retornada.
• Um é livre para usar funções lambda sempre que os objetos de função são necessários.
• Você precisa estar ciente de que as funções lambda são sintaticamente restritas a uma única expressão.
• Ele tem vários usos em campos específicos de programação, além de outros tipos de expressões em funções.

Vamos examinar este exemplo e tentar entender a diferença entre uma função definida por def normal e uma função lambda. Este é um programa que retorna o cubo de um determinado valor:

# Código Python para ilustrar o cubo de um número
# mostrando a diferença entre def () e lambda (). 
def cube(y): 
    return y*y*y 
  
lambda_cube = lambda y: y*y*y 
  
# usando a definição normal de uma função
print(cube(5)) 
  
# usando uma função lambda
print(lambda_cube(5)) 

Resultado:

125
125

Como podemos ver no exemplo acima, a função cube() e lambda_cube() se comportam da mesma forma e conforme pretendido. Vamos analisar o exemplo acima um pouco mais:

• Sem usar Lambda: aqui, ambos retornam o cubo de um determinado número. Mas, ao usar def, precisamos definir uma função com um cubo de nome e passar um valor para ele. Após a execução, também precisamos retornar o resultado de onde a função foi chamada usando a palavra-chave return .
• Usando Lambda: a definição de Lambda não inclui uma declaração de “retorno”, ela sempre contém uma expressão que é retornada. Também podemos colocar uma definição lambda em qualquer lugar em que uma função seja esperada e não precisamos atribuí-la a nenhuma variável. Essa é a simplicidade das funções lambda.

As funções lambda podem ser usadas junto com funções integradas como filter(), map() e reduce().

Usando a função lambda() com filter()

A função filter() em Python recebe uma função e uma lista como argumentos. Isso oferece uma maneira elegante de filtrar todos os elementos de uma sequência “sequência”, para a qual a função retorna True. Aqui está um pequeno programa que retorna os números ímpares de uma lista de entrada: 
 

Exemplo 1:

# Código python para ilustrar o uso de
# filter() com lambda() 
li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61] 
  
final_list = list(filter(lambda x: (x%2 != 0) , li)) 
print(final_list) 

Resultado:

[5, 7, 97, 77, 23, 73, 61]

Exemplo 2:

# Pessoas acima de 18 anos
ages = [13, 90, 17, 59, 21, 60, 5] 
  
adults = list(filter(lambda age: age>18, ages)) 
  
print(adults)

Resultado:

[90, 59, 21, 60]

Usando a função lambda() com map()

A função map() em Python recebe uma função e uma lista como argumento. A função é chamada com uma função lambda e uma lista e uma nova lista é retornada que contém todos os itens modificados por lambda retornados por aquela função para cada item. Exemplo: 
 

Exemplo 1:

# Código python para ilustrar o funcionamento da função
# map() com lambda() 
# para obter o dobro de uma lista
li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61] 
  
final_list = list(map(lambda x: x*2, li)) 
print(final_list) 

Resultado:

[10, 14, 44, 194, 108, 124, 154, 46, 146, 122]

Exemplo 2:

# Python program to demonstrate 
# use of lambda() function 
# with map() function 
animals = ['cão', 'gato', 'papagaio', 'coelho'] 
  
# aqui pretendemos mudar todos os nomes de animais
# para maiúsculas e retorna o mesmo
uppered_animals = list(map(lambda animal: str.upper(animal), animals)) 
  
print(uppered_animals)

Resultado:

['CÃO', 'GATO', 'PAPAGAIO', 'COELHO']

Usando a função lambda() com reduce()

A função reduce() em Python leva em uma função e uma lista como um argumento. A função é chamada com uma função lambda e um iterável e um novo resultado reduzido é retornado. Isso executa uma operação repetitiva sobre os pares do iterável. A função reduce() pertence ao módulo functools . 

Exemplo 1:

# Código Python para ilustrar a reduce()
# com lambda() para obter a soma de uma lista
  
from functools import reduce
li = [5, 8, 10, 20, 50, 100] 
sum = reduce((lambda x, y: x + y), li) 
print (sum) 

Resultado:

193

Aqui, os resultados dos dois elementos anteriores são adicionados ao próximo elemento e isso continua até o final da lista como (((((5+8)+10)+20)+50)+100).

Exemplo 2:

# código python para demonstrar o funcionamento de reduce()
# com uma função lambda

import functools  
  
# initializing list  
lis = [ 1 , 3, 5, 6, 2, ]  
  
# usando reduce para calcular o elemento máximo da lista
print("O elemento máximo da lista é: ",end="")  
print(functools.reduce(lambda a,b : a if a > b else b,lis))  

Resultado:

O elemento máximo da lista é: 6

Este artigo é uma contribuição de Chinmoy Lenka.

Artigo escrito por GeeksforGeeks e traduzido por Acervo Lima de Python Lambda Functions.

Read More

Recebendo várias entradas do usuário em Python

O desenvolvedor geralmente deseja que um usuário insira vários valores ou entradas em uma linha. Em C ++ / C, o usuário pode receber várias entradas em uma linha usando scanf, mas no usuário Python pode receber vários valores ou entradas em uma linha por dois métodos. 

Usando o método split(): 
esta função ajuda a obter várias entradas do usuário. Ele quebra a entrada fornecida pelo separador especificado. Se um separador não for fornecido, qualquer espaço em branco será um separador. Geralmente, o usuário usa um método split() para dividir uma string Python, mas pode-se usá-lo para obter várias entradas.

Sintaxe: 

input().split(separador, maxsplit)

Exemplo: 

# Python program showing how to
# multiple input using split
 
# taking two inputs at a time
x, y = input("Enter a two value: ").split()
print("Number of boys: ", x)
print("Number of girls: ", y)
print()
 
# taking three inputs at a time
x, y, z = input("Enter a three value: ").split()
print("Total number of students: ", x)
print("Number of boys is : ", y)
print("Number of girls is : ", z)
print()
 
# taking two inputs at a time
a, b = input("Enter a two value: ").split()
print("First number is {} and second number is {}".format(a, b))
print()
 
# taking multiple inputs at a time 
# and type casting using list() function
x = list(map(int, input("Enter a multiple value: ").split()))
print("List of students: ", x)

Resultado: 
 

Usando a compreensão de listas: A compreensão de
listas é uma maneira elegante de definir e criar listas em Python. Podemos criar listas como afirmações matemáticas em apenas uma linha. Ele também é usado para obter várias entradas de um usuário. 

Exemplo: 

# Python program showing
# how to take multiple input
# using List comprehension
 
# taking two input at a time
x, y = [int(x) for x in input("Enter two value: ").split()]
print("First Number is: ", x)
print("Second Number is: ", y)
print()
 
# taking three input at a time
x, y, z = [int(x) for x in input("Enter three value: ").split()]
print("First Number is: ", x)
print("Second Number is: ", y)
print("Third Number is: ", z)
print()
 
# taking two inputs at a time
x, y = [int(x) for x in input("Enter two value: ").split()]
print("First number is {} and second number is {}".format(x, y))
print()
 
# taking multiple inputs at a time 
x = [int(x) for x in input("Enter multiple value: ").split()]
print("Number of list is: ", x) 

Resultado : 
 

Observação: os exemplos acima aceitam entradas separadas por espaços. No caso de desejarmos ter a entrada separada por vírgula (,), podemos usar o seguinte: 

# taking multiple inputs at a time separated by comma
x = [int(x) for x in input("Enter multiple value: ").split(",")]
print("Number of list is: ", x) 

Artigo escrito por ABHISHEK TIWARI 13 e traduzido por Acervo Lima de Taking multiple inputs from user in Python.

Read More

Python String - split()

O método split() retorna uma lista de strings após quebrar a string dada pelo separador especificado.

Sintaxe: str.split (separador, maxsplit)
Parâmetros:
separador: este é um delimitador. A string se divide neste separador especificado. Se não for fornecido, qualquer espaço em branco será um separador.
maxsplit: é um número, que nos diz para dividir a string no máximo do número de vezes fornecido. Se não for fornecido, não há limite.
Retorna: Retorna uma lista de strings depois de quebrar a string fornecida pelo separador especificado.

CÓDIGO 1

text = 'geeks for geeks'
  
# quebra a string nos epaços em branco
print(text.split()) 

word = 'geeks, for, geeks'
  
# quebra a string quando encontra ',' 
print(word.split(',')) 
  
word = 'geeks:for:geeks'
  
# quebra a string quando encontra ':' 
print(word.split(':')) 
  
word = 'CatBatSatFatOr'
  
# quebra em 3 
print([word[i:i+3] for i in range(0, len(word), 3)]) 

Resultado :

['geeks', 'para', 'geeks']
['geeks', 'para', 'geeks']
['geeks', 'para', 'geeks']
['Gato', 'Morcego', 'Sáb', 'Gordo', 'Ou']

CÓDIGO 2

word = 'geeks, for, geeks, pawan'
  
# maxsplit: 0 
print(word.split(', ', 0)) 
  
# maxsplit: 4 
print(word.split(', ', 4)) 
  
# maxsplit: 1 
print(word.split(', ', 1)) 

Resultado :

['geeks, for, geeks, pawan']
['geeks', 'para', 'geeks', 'pawan']
['geeks', 'para, geeks, pawan']

Artigo escrito por pawan_asipu e traduzido por Acervo Lima de Python String | split().

Read More

Compreensão e segmentação da lista Python

A compreensão de listas é uma maneira elegante de definir e criar uma lista em python. Podemos criar listas apenas como declarações matemáticas e em apenas uma linha. A sintaxe de compreensão de lista é mais fácil de entender.

A compreensão de uma lista geralmente consiste nestas partes:

Por exemplo :

lst = [x ** 2 para x no intervalo (1, 11) se x% 2 == 1] 

aqui, x ** 2 é a expressão de saída, 
      intervalo (1, 11) é a sequência de entrada, 
      x é variável e   
      se x % 2 == 1 é parte do predicado.

Exemplo 1:

# Programa Python para demonstrar compreensão de listas em Python

# A lista abaixo contém o quadrado de todos os números ímpares do
# intervalo 1 a 10  
odd_square = [x ** 2 for x in range(1, 11) if x % 2 == 1]  
print (odd_square)  
  
# para compreensão, a geração acima é igual a,  
odd_square = []  
for x in range(1, 11):  
    if x % 2 == 1:  
        odd_square.append(x**2)  
print(odd_square)  
  
# a lista abaixo contém potência de 2 de 1 a 8
power_of_2 = [2 ** x for x in range(1, 9)]  
print(power_of_2)  
  
# a lista abaixo contém primos e não primos no intervalo de 1 a 50
noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]  
primes = [x for x in range(2, 50) if x not in noprimes]  
print(primes)  
  
# lista para diminuir os personagens
print([x.lower() for x in ["A","B","C"]]) 
  
# lista que extrai o número
string = "my phone number is : 11122 !!"
  
print("\nExtracted digits")  
numbers = [x for x in string if x.isdigit()]  
print (numbers)  
  
# Uma lista de lista para tabuada
a = 5
table = [[a, b, a * b] for b in range(1, 11)]  
  
print("\nMultiplication Table")  
for i in table:  
    print (i)  

Resultado:

[1, 9, 25, 49, 81]
[1, 9, 25, 49, 81]
[2, 4, 8, 16, 32, 64, 128, 256]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
['a', 'b', 'c']

Dígitos extraídos
['1', '1', '1', '2', '2']

Tabela de multiplicação
[5, 1, 5]
[5, 2, 10]
[5, 3, 15]
[5, 4, 20]
[5, 5, 25]
[5, 6, 30]
[5, 7, 35]
[5, 8, 40]
[5, 9, 45]
[5, 10, 50]

Depois de obter a lista, podemos obter uma parte dela usando o operador de fatiamento do python, que tem a seguinte sintaxe:

[start : stop : steps]

o que significa que o corte começará do início do índice
 subirá até stop no paso steps.
 O valor padrão de start é 0, a stop é o último índice da lista
 e para step é 1 

Assim, [:stop] dividirá a lista do início ao fim do índice e [start:] dividirá a lista do índice inicial até o final O valor negativo das etapas mostra o percurso da direita para a esquerda em vez de o percurso da esquerda para a direita. É por isso que [::-1] imprime a lista na ordem inversa.

Exemplo 2:

# Vamos primeiro criar uma lista para demonstrar o fatiamento
# lst contém todos os números de 1 a 10
lst =list(range(1, 11)) 
print (lst) 
   
# a lista abaixo tem números de 2 a 5
lst1_5 = lst[1 : 5] 
print (lst1_5) 
   
# a lista abaixo tem números de 6 a 8
lst5_8 = lst[5 : 8] 
print (lst5_8) 
   
# a lista abaixo tem números de 2 a 10
lst1_ = lst[1 : ] 
print (lst1_) 
   
# a lista abaixo tem números de 1 a 5
lst_5 = lst[: 5] 
print (lst_5) 
   
# a lista abaixo tem números de 2 a 8 na etapa 2
lst1_8_2 = lst[1 : 8 : 2] 
print (lst1_8_2) 
   
# a lista abaixo tem números de 10 a 1
lst_rev = lst[ : : -1] 
print (lst_rev) 
   
# a lista abaixo tem números de 10 a 6 na etapa 2
lst_rev_9_5_2 = lst[9 : 4 : -2] 
print (lst_rev_9_5_2) 

Resultado:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5]
[6, 7, 8]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5]
[2, 4, 6, 8]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[10, 8, 6]

Podemos usar a função filter para filtrar uma lista com base em alguma condição fornecida como uma expressão lambda como primeiro argumento e lista como o segundo argumento, exemplo dos quais é mostrado a seguir:

Exemplo 3:

import functools 
  
#  filtering odd numbers 
lst = filter(lambda x : x % 2 == 1, range(1, 20)) 
print (list(lst)) 
   
#  filtering odd square which are divisible by 5 
lst = filter(lambda x : x % 5 == 0,  
      [x ** 2 for x in range(1, 11) if x % 2 == 1]) 
print (list(lst)) 
   
#   filtering negative numbers 
lst = filter((lambda x: x < 0), range(-5,5)) 
print (list(lst)) 
   
#  implementing max() function, using 
print (functools.reduce(lambda a,b: a if (a > b) else b, [7, 12, 45, 100, 15])) 

Resultado:

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
[25]
[-5, -4, -3, -2, -1]
100

Este artigo é uma contribuição de Utkarsh Trivedi. Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima.

Artigo escrito por GeeksforGeeks e traduzido por Acervo Lima de Python List Comprehension and Slicing.

Read More