Python
Овладение .loc в Python: Руководство для начинающих

Овладение .loc в Python: Руководство для начинающих

MoeNagy Dev

Понимание аксессора .loc

Что такое аксессор .loc?

Аксессор .loc в pandas - это мощный инструмент для выбора и доступа к данным в DataFrame или Series на основе меток строк и столбцов. Он позволяет выбирать данные, явно указывая метки строк и столбцов, а не используя числовые индексы, как с аксессором .iloc.

Доступ к данным с использованием меток строк и столбцов

Для доступа к данным с помощью аксессора .loc вам нужно предоставить метки строк и столбцов в качестве аргументов. Вот простой пример:

import pandas as pd
 
# Создание примерного DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=['row1', 'row2', 'row3', 'row4', 'row5'])
 
# Доступ к одному элементу
print(df.loc['row2', 'B'])  # Вывод: 20
 
# Доступ к строке
print(df.loc['row3'])
# Вывод:
# A    3
# B   30
# Name: row3, dtype: int64
 
# Доступ к столбцу
print(df.loc[:, 'A'])
# Вывод:
# row1    1
# row2    2
# row3    3
# row4    4
# row5    5
# Name: A, dtype: int64

В приведенном выше примере мы создаем примерный DataFrame с метками строк от 'row1' до 'row5' и метками столбцов 'A' и 'B'. Затем мы демонстрируем, как использовать аксессор .loc для выбора одного элемента, целой строки и целого столбца.

Выбор отдельных элементов, строк и столбцов

Аксессор .loc позволяет выбирать отдельные элементы, строки и столбцы, предоставляя соответствующие метки. Вот несколько примеров:

# Выбор одного элемента
print(df.loc['row2', 'B'])  # Вывод: 20
 
# Выбор строки
print(df.loc['row3'])
# Вывод:
# A    3
# B   30
# Name: row3, dtype: int64
```Вот перевод на русский язык с сохранением комментариев:
 
# Имя: row3, dtype: int64
 
# Выбрать столбец
print(df.loc[:, 'A'])
# Вывод:
# row1    1
# row2    2
# row3    3
# row4    4
# row5    5
# Имя: A, dtype: int64
 
### Выбор нескольких строк и столбцов
Вы также можете использовать аксессор `.loc` для выбора нескольких строк и столбцов, предоставив список или диапазон меток:
 
```python
# Выбрать несколько строк
print(df.loc[['row2', 'row4']])
#    A   B
# row2  2  20
# row4  4  40
 
# Выбрать несколько столбцов
print(df.loc[:, ['A', 'B']])
#        A   B
# row1   1  10
# row2   2  20
# row3   3  30
# row4   4  40
# row5   5  50
 
# Выбрать диапазон строк
print(df.loc['row2':'row4'])
#        A   B
# row2   2  20
# row3   3  30
# row4   4  40

В приведенных выше примерах мы демонстрируем, как выбирать несколько строк и столбцов, используя списки или диапазоны меток.

Условные выборки с .loc

Фильтрация строк и столбцов на основе условий

Аксессор .loc также может использоваться для фильтрации строк и столбцов на основе конкретных условий. Это особенно полезно, когда вам нужно выбрать данные, которые соответствуют определенным критериям.

# Фильтровать строки на основе условия
print(df.loc[df['A'] > 3])
#        A   B
# row4   4  40
# row5   5  50
 
# Фильтровать столбцы на основе условия
print(df.loc[:, df.columns.str.startswith('A')])
#        A
# row1   1
# row2   2
# row3   3
# row4   4
# row5   5

В первом примере мы фильтруем DataFrame, чтобы включить только строки, где значение в столбце 'A' больше 3. Во втором примере мы фильтруем DataFrame, чтобы включить только столбцы, названия которых начинаются с 'A'.

Комбинирование нескольких условий с использованием логических операторов

Вы также можете комбинировать несколько условий с использованием логических операторов, таких как & (и) и | (или), чтобы создавать более сложные фильтры.

# Комбинировать несколько условий с использованием логических операторов
print(df.loc[(df['A'] > 2) & (df['B'] < 40)])
#        A   B
# row3   3  30

В этом примере мы выбираем строки, где значение в столбце 'A' больше 2 и значение в столбце 'B' меньше 40.Вот перевод на русский язык с сохранением комментариев к коду:

Выбор строк и столбцов на основе сложных условий

Аксессор .loc позволяет создавать сложные условия, объединяя несколько фильтров и используя логические операторы. Это может быть особенно полезно, когда вам нужно выполнять более сложный выбор и извлечение данных.

# Выбрать строки и столбцы на основе сложных условий
print(df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']])
#        A   B
# row3   3  30

В этом примере мы выбираем строки, где значение в столбце 'A' больше 2, а значение в столбце 'B' меньше 40, и возвращаем только столбцы 'A' и 'B'.

Изменение данных с помощью .loc

Присвоение значений конкретным элементам

Аксессор .loc также может использоваться для присвоения значений конкретным элементам в DataFrame или Series.

# Присвоить значение конкретному элементу
df.loc['row2', 'B'] = 25
print(df)
#        A   B
# row1   1  10
# row2   2  25
# row3   3  30
# row4   4  40
# row5   5  50

В этом примере мы используем аксессор .loc для присвоения значения 25 элементу в строке 'row2' и столбце 'B'.

Обновление нескольких строк и столбцов

Вы также можете использовать аксессор .loc для обновления нескольких строк и столбцов одновременно.

# Обновить несколько строк и столбцов
df.loc[['row2', 'row4'], ['A', 'B']] = [[12, 125], [42, 420]]
print(df)
#         A    B
# row1    1   10
# row2   12  125
# row3    3   30
# row4   42  420
# row5    5   50

В этом примере мы используем аксессор .loc для обновления значений в столбцах 'A' и 'B' для строк 'row2' и 'row4'.

Работа с пропущенными данными с помощью .loc

Аксессор .loc также может использоваться для работы с пропущенными данными в DataFrame или Series.

# Создать DataFrame с пропущенными данными
df = pd.DataFrame({'A': [1, 2, None, 4, 5],
                   'B': [10, 20, 30, None, 50]},
                  index=['row1', 'row2', 'row3', 'row4', 'row5'])
 
# Заполнить пропущенные значения с помощью .loc
df.loc[:, 'A'] = df['A'].fillna(0)
df.loc[:, 'B'].
```Вот перевод на русский язык:
 
= df['B'].fillna(0)
print(df)
#        A   B
# row1   1  10
# row2   2  20
# row3   0  30
# row4   4   0
# row5   5  50
 
В этом примере мы создаем DataFrame с пропущенными значениями в столбцах 'A' и 'B'. Затем мы используем .loc-доступор, чтобы заполнить пропущенные значения 0 для обоих столбцов.
 
## Продвинутые техники с .loc
 
### Объединение .loc с другими операциями pandas
Доступор .loc можно объединять с другими операциями pandas для создания более сложных рабочих процессов выбора и манипулирования данными.
 
```python
# Объединение .loc с другими операциями pandas
filtered_df = df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']]
filtered_df['C'] = filtered_df['A'] + filtered_df['B']
print(filtered_df)
#        A   B   C
# row3   3  30  33

В этом примере мы сначала используем доступор .loc, чтобы отфильтровать DataFrame по условию, а затем создаем новый столбец 'C', который является суммой столбцов 'A' и 'B' для отфильтрованных строк.

Работа с иерархическими (многоуровневыми) индексами

Доступор .loc также можно использовать для работы с DataFrames или Series, имеющими иерархические (многоуровневые) индексы.

# Создание DataFrame с многоуровневым индексом
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=pd.MultiIndex.from_tuples([('group1', 'row1'), ('group1', 'row2'),
                                                  ('group2', 'row1'), ('group2', 'row2'),
                                                  ('group2', 'row3')],
                                                 names=['group', 'row']))
 
# Доступ к данным с использованием .loc с многоуровневыми индексами
print(df.loc[('group2', 'row1'), 'A'])  # Вывод: 3
print(df.loc[('group1', slice(None)), 'B'])
# Вывод:
# ('group1', 'row1')    10
# ('group1', 'row2')    20
# Name: B, dtype: int64

В этом примере мы создаем DataFrame с многоуровневым индексом, а затем демонстрируем, как использовать доступор .loc для выбора данных на основе иерархического индекса.

Комбинирование .loc .Вот перевод на русский язык:

с другими аксессорами pandas (например, .at, .iat) Аксессор .loc может быть объединен с другими аксессорами pandas, такими как .at и .iat, чтобы обеспечить более точный и эффективный доступ к данным.

# Объединение .loc с .at и .iat
print(df.at[('group2', 'row1'), 'A'])  # Вывод: 3
print(df.iat[2, 0])  # Вывод: 3

В этом примере мы используем аксессор .at для выбора одного элемента на основе меток строк и столбцов, и аксессор .iat для выбора одного элемента на основе целочисленных позиций строк и столбцов.

Соображения производительности с .loc

Понимание эффективности .loc

Аксессор .loc, как правило, более эффективен, чем использование булевой индексации или индексации на основе целых чисел (.iloc) для больших наборов данных, так как он избегает ненужных вычислений и копирования данных.

# Сравнение .loc, .iloc и булевой индексации
import pandas as pd
import numpy as np
 
# Создание большого DataFrame
df = pd.DataFrame(np.random.rand(1000000, 5), columns=['A', 'B', 'C', 'D', 'E'])
 
# Сравнение времени выполнения
%timeit df.loc[df['A'] > 0.5, ['B', 'C']]
%timeit df.iloc[df['A'] > 0.5, [1, 2]]
%timeit df[(df['A'] > 0.5) & (df['B'] < 0.7)]

В этом примере мы создаем большой DataFrame и сравниваем производительность использования .loc, .iloc и булевой индексации для выбора подмножества строк и столбцов. Аксессор .loc, как правило, является наиболее эффективным из трех методов.

Сравнение .loc с другими методами выбора (например, .iloc, булевая индексация)

Хотя аксессор .loc обычно эффективен, могут быть случаи, когда другие методы выбора, такие как .iloc или булевая индексация, могут быть более уместными в зависимости от вашего конкретного варианта использования и структуры данных.

# Сравнение .loc, .iloc и булевой индексации
# Когда использовать каждый метод
# .loc: Когда у вас есть данные с метками и вы хотите выбирать на основе меток
# .iloc: Когда у вас есть числовые индексы и вы хотите выбирать на основе позиции
# Булевая индексация: Когда вы хотите фильтровать данные на основе сложных условий
.
```Вот перевод на русский язык с сохранением комментариев к коду:
 
Важно понимать компромиссы и выбирать подходящий метод выбора для ваших конкретных потребностей.
 
###
 
## Списки и кортежи
 
Списки и кортежи - оба являются последовательными типами данных в Python, но они имеют некоторые ключевые различия. Списки изменяемы, что означает, что вы можете изменять их элементы, в то время как кортежи неизменяемы, что означает, что их элементы не могут быть изменены.
 
### Списки
Списки определяются с использованием квадратных скобок `[]`. Вот пример:
 
```python
fruits = ['яблоко', 'банан', 'вишня']

Вы можете получить доступ к отдельным элементам списка, используя их индекс, который начинается с 0:

print(fruits[0])  # Вывод: 'яблоко'
print(fruits[1])  # Вывод: 'банан'

Вы также можете изменять элементы в списке:

fruits[1] = 'апельсин'
print(fruits)  # Вывод: ['яблоко', 'апельсин', 'вишня']

Списки имеют много полезных методов, таких как append(), insert(), remove() и pop(). Вот пример:

fruits.append('виноград')
fruits.insert(1, 'груша')
fruits.remove('апельсин')
last_fruit = fruits.pop()
print(fruits)  # Вывод: ['яблоко', 'груша', 'вишня']
print(last_fruit)  # Вывод: 'виноград'

Кортежи

Кортежи определяются с использованием круглых скобок (). Вот пример:

point = (3, 4)

Вы можете получить доступ к отдельным элементам кортежа, используя их индекс, так же, как и со списками:

print(point[0])  # Вывод: 3
print(point[1])  # Вывод: 4

Однако, вы не можете изменять элементы кортежа:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

Кортежи часто используются для представления неизменяемых данных, таких как координаты или пары ключ-значение.

Словари

Словари - еще одна важная структура данных в Python. Они используются для хранения пар ключ-значение, где ключи уникальны, а значения могут быть любого типа данных.

Словари определяются с использованием фигурных скобок {}, а пары ключ-значение разделяются двоеточиями :.

person = {
    'name': 'Джон Доу',
    'age': 35,
    'occupation': 'Программист'
}

Вы.Вот перевод на русский язык:

Вы можете получить доступ к значениям в словаре, используя их ключи:

print(person['name'])  # Вывод: 'John Doe'
print(person['age'])   # Вывод: 35

Вы также можете добавлять, изменять и удалять пары ключ-значение в словаре:

person['email'] = 'john.doe@example.com'
person['age'] = 36
del person['occupation']
print(person)  # Вывод: {'name': 'John Doe', 'age': 36, 'email': 'john.doe@example.com'}

Словари имеют много полезных методов, таких как keys(), values() и items(), которые позволяют работать с ключами и значениями в словаре.

print(list(person.keys()))   # Вывод: ['name', 'age', 'email']
print(list(person.values())) # Вывод: ['John Doe', 36, 'john.doe@example.com']
print(list(person.items()))  # Вывод: [('name', 'John Doe'), ('age', 36), ('email', 'john.doe@example.com')]

Словари очень универсальны и могут использоваться для хранения сложных структур данных, таких как вложенные словари или списки словарей.

Условные операторы

Условные операторы в Python позволяют выполнять различные блоки кода в зависимости от определенных условий.

Наиболее распространенным условным оператором является оператор if-elif-else:

x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

Вы также можете использовать операторы and, or и not для объединения нескольких условий:

age = 25
if age >= 18 and age < 65:
    print("You are an adult")
else:
    print("You are not an adult")

Еще одним полезным условным оператором является тернарный оператор, который позволяет записать простой if-else оператор в одну строку:

is_student = True
status = "Student" if is_student else "Not a student"
print(status)  # Вывод: "Student"

Условные операторы важны для построения сложной логики в ваших программах на Python.

Циклы

Циклы в Python позволяют выполнять блок кода повторно, пока определенное условие не будет выполнено.

Наиболее распространенным циклом является цикл for.Вот перевод на русский язык:

for цикл, который используется для итерации по последовательности (такой как список, кортеж или строка):

fruits = ['яблоко', 'банан', 'вишня']
for fruit in fruits:
    print(fruit)

Вы также можете использовать функцию range() для создания последовательности чисел, по которой можно итерироваться:

for i in range(5):
    print(i)  # Вывод: 0, 1, 2, 3, 4

while цикл используется, когда вы не знаете заранее количество итераций, и цикл должен продолжаться до тех пор, пока не будет выполнено определенное условие:

count = 0
while count < 3:
    print("Привет")
    count += 1

Вы можете использовать операторы break и continue для управления потоком выполнения цикла:

for i in range(10):
    if i % 2 == 0:
        continue  # Пропустить четные числа
    if i > 7:
        break     # Остановить цикл, когда i больше 7
    print(i)      # Вывод: 1, 3, 5, 7

Циклы важны для автоматизации повторяющихся задач и обработки больших объемов данных в ваших программах на Python.

Функции

Функции в Python - это блоки повторно используемого кода, которые выполняют определенную задачу. Они позволяют организовать ваш код и сделать его более модульным и поддерживаемым.

Вы определяете функцию, используя ключевое слово def, за которым следует имя функции и набор скобок. Тело функции отступается и может содержать любой допустимый код Python.

def приветствовать(имя):
    print(f"Привет, {имя}!")
 
приветствовать("Алиса")  # Вывод: "Привет, Алиса!"

Функции также могут принимать аргументы и возвращать значения:

def сложить_числа(a, b):
    return a + b
 
результат = сложить_числа(3, 4)
print(результат)  # Вывод: 7

Вы также можете определять значения по умолчанию для аргументов функции:

def приветствовать(имя, сообщение="Привет"):
    print(f"{сообщение}, {имя}!")
 
приветствовать("Боб")       # Вывод: "Привет, Боб!"
приветствовать("Чарли", "Здравствуй")  # Вывод: "Здравствуй, Чарли!"

Функции также могут быть определены с переменным количеством аргументов, используя синтаксис *args и **kwargs:

def печатать_числа(*args):
    for arg in args:
        print(arg)
 
пе.Вот перевод на русский язык:
 
int_numbers(1, 2, 3)   # Вывод: 1, 2, 3
print_numbers(4, 5, 6, 7, 8)  # Вывод: 4, 5, 6, 7, 8
 
Функции являются фундаментальным строительным блоком программирования на Python и имеют важное значение для создания модульного, многократно используемого и поддерживаемого кода.
 
## Модули и пакеты
В Python модули и пакеты используются для организации и распространения кода.
 
Модуль - это единичный файл Python, который содержит определения и инструкции. Вы можете импортировать модуль, используя ключевое слово `import`:
 
```python
import math
print(math.pi)  # Вывод: 3.141592653589793

Вы также можете импортировать конкретные функции или переменные из модуля:

from math import sqrt
print(sqrt(16))  # Вывод: 4.0

Пакеты - это коллекции связанных модулей. Они организованы в иерархическую структуру каталогов, причем каждый каталог содержит файл __init__.py.

Вот пример использования пакета:

import my_package.my_module
my_package.my_module.my_function()

Вы также можете использовать ключевое слово from для импорта конкретных элементов из пакета:

from my_package.my_module import my_function
my_function()

Модули и пакеты важны для организации и распространения кода Python, так как они позволяют создавать многократно используемый и поддерживаемый код, который можно распространять с другими.

Заключение

В этом руководстве вы узнали о следующих ключевых концепциях в Python:

  • Списки и кортежи: последовательные типы для хранения коллекций данных
  • Словари: структуры данных для хранения пар "ключ-значение"
  • Условные операторы: выполнение кода на основе условий
  • Циклы: повторение блоков кода
  • Функции: многократно используемые блоки кода, выполняющие конкретные задачи
  • Модули и пакеты: организация и распространение кода Python

Эти концепции являются фундаментальными для программирования на Python и послужат прочной основой для построения более сложных приложений. Не забывайте практиковаться и экспериментировать с этими концепциями, чтобы углубить свое понимание и стать более опытным программистом на Python.

[![MoeNagy Dev]Вот перевод на русский язык:

Изображение (opens in a new tab)

Добро пожаловать на мой сайт-портфолио!

Это мой личный сайт-портфолио, где я представляю свои проекты и навыки.

Обо мне

Меня зовут Моэ Нагай, и я начинающий веб-разработчик. Я увлекаюсь программированием и постоянно учусь новому.

Мои навыки

Вот некоторые из моих основных навыков:

// Комментарий: JavaScript
function sayHello() {
  console.log("Привет, мир!");
}
 
// Комментарий: HTML
<h1>Заголовок</h1>
<p>Это абзац текста.</p>
 
// Комментарий: CSS
.my-class {
  color: blue;
  font-size: 16px;
}

Я также знаком с другими технологиями, такими как React, Node.js и базы данных.

Мои проекты

Вы можете ознакомиться с моими проектами на GitHub (opens in a new tab).

Спасибо за посещение моего сайта-портфолио! Если у вас есть какие-либо вопросы или предложения, не стесняйтесь обращаться ко мне.