В мире программирования на Python обработка пользовательского ввода - это как встреча с новым знакомым: нужно понять, о чем он говорит, и ответить соответствующе. Инструментом, который помогает в этом начинании, является функция input(). Она ждет, когда пользователь что-то введет, и возвращает эту строку, словно маленькая посылка с неизвестным содержимым. Давайте разберемся, как можно с этой посылкой работать.

Начнем с простого примера. Представьте, что мы пишем программу, в которой пользователь вводит свое имя, и программа возвращает приветствие. Это легко реализовать с помощью input():

name = input("Enter your name: ")
print(f"Hello, {name}!")

Но что делать, если мы хотим, чтобы пользователь ввел число? input() всегда возвращает строку, так что придется превратить ее в целое число или число с плавающей точкой. Здесь на помощь приходит int() или float():

age = int(input("Enter your age: "))
print(f"In 5 years, you will be {age + 5} years old.")

Но что, если пользователь случайно или намеренно введет не число? В этом случае наша программа сломается, как хрустальная ваза на бетонном полу. Чтобы избежать такого сценария, стоит использовать конструкцию try-except, которая позволяет ловить ошибки:

try:
    age = int(input("Enter your age: "))
    print(f"In 5 years, you will be {age + 5} years old.")
except ValueError:
    print("That doesn't look like a valid number!")

Кроме того, порой бывает полезно превращать ввод в более сложные объекты. Допустим, нам нужно получить список чисел. Можно попросить пользователя ввести их через запятую, а затем разобрать строку с помощью метода split():

numbers = input("Enter numbers separated by commas: ")
numbers_list = [int(num) for num in numbers.split(',')]
print(f"You entered: {numbers_list}")

Таким образом, input() и некоторые базовые инструменты языка Python позволяют превратить ввод пользователя в практическую информацию. Нам остается лишь проявить немного фантазии и быть готовыми к неожиданностям, которые иногда может преподнести неосмотрительный ввод. В мире Python даже самая простая строка может стать основой сложного и интересного приложения. Так что смело экспериментируйте и создавайте!

Что такое строковые методы и как их использовать

Привет, друзья! Если вы только начали свой путь в изучении Python, то наверняка уже столкнулись со строками. Строки — это то, что мы используем каждый день, от написания сообщений в мессенджерах до кодирования секретных шифров (шучу, конечно). Python любит строки так же сильно, как и мы, поэтому предлагает целый арсенал методов для работы с ними.

Итак, что же такое строковые методы и почему они такие важные? Строковые методы — это специальные функции, которые помогают манипулировать текстом. Представьте, что у вас есть волшебная палочка, которая может преобразовывать текст, изменять его форму, собирать и разбивать на кусочки. Давайте рассмотрим несколько наиболее популярных из них.

Первый в нашем волшебном списке — метод upper(). Если вам нужно написать что-то важное и хотите, чтобы это было подчеркнуто, просто примените upper(), и строка мгновенно станет заглавной. Например, message = "hello world".upper() превратит всё в "HELLO WORLD". Теперь мир услышит вас!

Если вы, наоборот, хотите расслабить текст после кричащих заглавных, lower() поможет вам успокоить нервы. С его помощью "HELLO WORLD" вновь станет "hello world".

Но что если вам нужна аккуратность, и вы хотите лишь первым символом подчеркнуть значимость строки? Добро пожаловать к capitalize()! Он превращает первую букву в заглавную, оставляя остальные строчные: title = "python", после применения title.capitalize(), станет "Python".

Когда дело доходит до объединения строк, join() — ваш лучший друг. Возьмем список слов и соберём их в строку через пробел: words = ['Hello', 'world'], sentence = " ".join(words). Результатом станет "Hello world". Простое, но элегантное решение.

Теперь о поиске и замене. Метод find() поможет добраться до истины: text = "find your destiny", position = text.find("destiny") покажет вам индекс, с которого начинается слово "destiny". Если же вам необходимо что-то заменить, replace() станет незаменимым помощником: например, text.replace("destiny", "fortune") превратит текст в "find your fortune".

И, конечно, не забудем про команду split(), которая разложит строку на части. Скажем, у вас есть строка data = "apple,banana,cherry", fruits = data.split(",") превратит её в список ['apple', 'banana', 'cherry'].

С этими замечательными инструментами строки больше не будут казаться вам чем-то сложным или скучным. Напротив, играйте с ними, творите и экспериментируйте. Python как волшебник всегда готов прийти на помощь с новым заклинанием — а точнее методом — позволяющим найти нужное решение. Enjoy coding!

Файлы в Python: Чтение и запись данных на ваш диск

Когда мы говорим о программировании, особенно на языке Python, работа с файлами — это как мастерство повара. Уметь открыть файл, внести изменения и аккуратно закрыть его — значит понимать и чувствовать силу кулинарии данных. Сегодня я расскажу вам, как обращаться с файлами в Python, используя несколько примеров, которые покажут всю мощь этого инструмента.

Начнем с открытия файлов. Да, звучит просто, но это важный первый шаг, от которого зависит весь последующий процесс. В Python открыть файл можно с помощью функции open(). Вот так:

file = open('example.txt', 'r')  # 'r' означает режим чтения (read)

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

file.close()

Но что, если вы хотите записать в файл немного данных? Здесь Python также готов помочь вам, как хороший шеф-повар, всегда имеющий под рукой нужные ингредиенты. Для записи используйте режим w или a:

file = open('example.txt', 'w')  # 'w' означает режим записи (write)
file.write('Hello, world!\n')
file.close()

Здесь мы открыли файл для записи. Если файла не существует, Python создаст его для вас. Однако, будьте осторожны: режим w перезапишет файл, если он уже существует. Если вы хотите добавить данные, не стирая старые, воспользуйтесь режимом a:

file = open('example.txt', 'a')  # 'a' означает режим добавления (append)
file.write('Hello again!\n')
file.close()

Теперь, когда ваш файл содержит данные, пришло время научиться читать его. Это как изучение книги рецептов — вы же хотите прочитать каждую строку, правда? Для этого используем метод read() или readline():

file = open('example.txt', 'r')
content = file.read()  # Чтение всего файла
print(content)
file.close()

Попробуем и readline(), которая позволяет прочитать одну строку за раз:

file = open('example.txt', 'r')
line = file.readline()
while line:
    print(line, end='')  # end='' чтобы избежать добавления лишних переводов строки
    line = file.readline()
file.close()

В завершение, стоит упомянуть про with — контекстный менеджер, который автоматически закроет файл за вас, словно заботливый помощник, очищающий кухню после праздника:

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

Суть в том, что работа с файлами в Python может стать не только простой, но и приятной. Ваша задача теперь — практиковаться и открывать все больше возможностей, добавляя в свою программу нотки мастерства. Пускай ваш код будет таким же аппетитным, как блюда на страницах дорогого поваренного журнала!

Основы работы с датой и временем в Python

Привет, друзья! Сегодня предлагаю погрузиться в увлекательный мир времени и дат с Python. Временные парадоксы оставим для научной фантастики, а сами разберем как манипулировать с временными данными в нашем коде, используя возможности знаменитого модуля datetime.

### Начнем с настоящего

Первое, с чего стоит начать — это узнать текущее время. Почему бы и нет? В Python это проще простого. Давайте взглянем на пример:

from datetime import datetime

current_time = datetime.now()
print("Сейчас:", current_time)

Этот магический datetime.now() извлечёт информацию о текущем моменте до мельчайших деталей — от года до секунды.

### Назад в прошлое или шаг в будущее

OK, настоящее познано. Что, если нужно узнать, что будет (или было) в другой время? Для этого в модуле есть класс timedelta. Давайте, например, убедимся, что Python способен отправить нас на неделю вперед:

from datetime import datetime, timedelta

one_week_later = datetime.now() + timedelta(weeks=1)
print("Неделя спустя:", one_week_later)

С помощью объекта timedelta мы можем свободно перемещаться по временной шкале, играючи добавляя или вычитая часы, дни, недели и даже секунды.

### Ох, эта дата!

Работа с датой на старом добром календаре? Легкотня. Но как насчет форматирования? Посмотрите на это:

some_date = datetime(2023, 5, 17)
formatted_date = some_date.strftime("%A, %d %B %Y")
print("Красиво оформленная дата:", formatted_date)

С помощью strftime мы формируем строку, отражая день недели, число, месяц и год в подходящем формате. Гибкость таких операций открывает двери к борьбе с временными данными на лету.

### Не потеряться во времени

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

current_time = datetime.now().time()
print("Текущее время:", current_time)

Здесь мы вызвали time(), чтобы просто получить время без даты. Это удобно, если дата уже не столь критична.

### Заключение

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

Так что, если вдруг под руки попалась задача, где нужно поиграть со временем, вспомните о нашем хорошем друге datetime. Удачного кодинга и не забывайте вовремя отдыхать, ведь в жизни все наладится, пока Python контролирует ваши часы!

Как писать простые скрипты для автоматизации задач

# Как писать простые скрипты для автоматизации задач на Python

Привет, друзья! Сегодня я поделюсь с вами тем, как Python может стать вашим надежным помощником в автоматизации рутинных задач. Если вы еще не пробовали использовать программирование для упрощения своей жизни, самое время начать. Python — это не только язык для профессионалов, но и отличный инструмент для новичков, позволяющий быстро создавать простые и эффективные скрипты.

### Почему Python?

Python популярен благодаря своей простоте и широкой экосистеме. А значит, для ваших задач уже может существовать готовое решение в виде библиотеки, что значительно сэкономит время и усилия.

### Начнем с простого примера

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

import os

def rename_files(directory_path, prefix):
    for index, filename in enumerate(os.listdir(directory_path)):
        new_name = f"{prefix}_{index}{os.path.splitext(filename)[1]}"
        os.rename(os.path.join(directory_path, filename), os.path.join(directory_path, new_name))

rename_files('/path/to/your/files', 'new_name')

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

### Скачивание данных из Интернета

Еще одна распространенная задача — автоматическое скачивание данных. Python отлично справляется и с этим, благодаря библиотеке requests.

import requests

def download_file(url, save_path):
    response = requests.get(url)
    with open(save_path, 'wb') as file:
        file.write(response.content)

download_file('https://example.com/data.csv', 'data.csv')

Этот простой скрипт загружает файл по указанному URL и сохраняет его на вашем компьютере. Библиотека requests делает процесс взаимодействия с веб-ресурсами невероятно удобным.

### Отправка автоматических писем

Представьте, что вам нужно ежедневно отправлять отчеты по электронной почте. Вместо того чтобы делать это вручную, вы можете написать скрипт с использованием модуля smtplib:

import smtplib
from email.mime.text import MIMEText

def send_email(subject, body, to_email):
    from_email = "your_email@gmail.com"
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = from_email
    msg['To'] = to_email

    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login(from_email, 'your_password')
        server.send_message(msg)

send_email("Daily Report", "Here is the report for today.", "recipient@example.com")

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

### Заключение

Python предлагает множество инструментов для автоматизации, от простых скриптов до сложных систем. Главное — понять, какую задачу вы хотите решить. Затем можно начать с небольших и простых программ, постепенно совершенствуя их. Удачи в автоматизации ваших задач, и пусть рутинная работа станет для вас прошлым!

Работа с графикой: Визуализация данных с помощью matplotlib

Привет, друзья-программисты! Сегодня мы погрузимся в увлекательный мир визуализации данных с помощью одного из самых популярных инструментов в мире Python — библиотеки matplotlib. Представьте, что ваша программа — это футуристическая лаборатория, в которой можно оживить цифры и таблицы, превратив их в красочные графики, иллюстрирующие скрытые закономерности и тенденции. Это не просто возможность, а настоящая суперсила для любого программиста!

Matplotlib — библиотека, которая предоставляет невероятные возможности для создания графиков. С ней вы сможете воплотить в жизнь самые смелые идеи визуализации. Она настолько мощная и гибкая, что на первый взгляд может показаться немного сложной. Но не волнуйтесь, ведь для начала работы вам понадобятся всего несколько простых команд.

Давайте начнем с малого и создадим классический линейный график. Для этого нам понадобится matplotlib и numpy. Numpy поможет нам сгенерировать набор данных, а matplotlib — визуализировать их.

import matplotlib.pyplot as plt
import numpy as np

# Генерация данных
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Создание графика
plt.plot(x, y)

# Добавление заголовка и меток
plt.title('Простой линейный график')
plt.xlabel('Значения X')
plt.ylabel('Значения Y')

# Отображение графика
plt.show()

Наконец-то, вместо скучных цифр на экране, вы видите прекрасную линию, танцующую вдоль оси X! А теперь добавим немного цвета и стиля.

Хотите чего-то более яркого? Давайте создадим диаграмму разброса — отличный способ показать корреляцию в ваших данных.

import matplotlib.pyplot as plt
import numpy as np

# Генерация данных
x = np.random.rand(50)
y = np.random.rand(50)
colors = np.random.rand(50)
sizes = 1000 * np.random.rand(50)

# Создание диаграммы разброса
plt.scatter(x, y, c=colors, s=sizes, alpha=0.5, cmap='viridis')

# Добавление заголовка и меток
plt.title('Цветастая диаграмма разброса')
plt.xlabel('Значения X')
plt.ylabel('Значения Y')

# Отображение графика
plt.show()

О, посмотрите, как цвет красиво передает настроение и объем точек. Матplotlib делает это возможным с легкостью! Настраивайте размер, форму и палитру, чтобы ваши данные заиграли новыми красками.

В завершение, matplotlib — это не просто инструмент, это чудесная палитра для создания ваших шедевров. Что можно добавить, чтобы сделать ваши графики еще круче? Конечно, легенды, штриховки и различные типы линий. Но это уже, как говорится, совсем другая история. Осталось лишь начать экспериментировать, ведь с matplotlib возможности практически безграничны!

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

Как использовать списочные выражения для упрощения кода

### Как использовать списочные выражения для упрощения кода

Привет, друзья! Сегодня мы погрузимся в загадочный и увлекательный мир Python, а именно—в списочные выражения. Эти маленькие джедаи помогают нам писать код, который не только выглядит лучше, но и работает эффективнее!

#### Что такое списочные выражения?

Списочные выражения—это специальный синтаксис в Python, который позволяет создавать списки на лету, словно по волшебной палочке. Вместо использования многострочных циклов, вы можете создать новый список в одну строку. Да-да, всего одной строчкой!

Например, представьте, что вам нужно создать список квадратов чисел от 0 до 9. В традиционном подходе вам бы пришлось использовать цикл for:

squares = []
for num in range(10):
    squares.append(num ** 2)

Списочные выражения упрощают эту задачу:

squares = [num ** 2 for num in range(10)]

Чище, правда?

#### Фильтрация

Но на этом магия не заканчивается! Списочные выражения позволяют встроить условные конструкции. Хотите, чтобы в список попадали только четные числа? Пожалуйста:

even_squares = [num ** 2 for num in range(10) if num % 2 == 0]

Таким образом, мы не только создаем список, но и фильтруем его в процессе.

#### Работать с данными — легко!

Рассмотрим пример с данными. Допустим, у нас есть список имён, и мы хотим создать новый список, содержащий только имена, которые начинаются с буквы "А":

names = ['Alice', 'Bob', 'Annie', 'Michael', 'Ann']
a_names = [name for name in names if name.startswith('A')]

Вот и всё! Код не только изящен и читабелен, но и прозрачен в своём намерении.

#### Вложенные списки

Звучит невероятно, но списочные выражения поддерживают вложенность. Хотите создать двумерную матрицу 3x3? Легко:

matrix = [[row * col for col in range(3)] for row in range(3)]

Элегантность и краткость в действии!

#### Заключение

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

Итак, друзья, если вы ещё не использовали списочные выражения в вашем коде, самое время начать! Ведь, как говорил великий учитель Йода: "Делай или не делай, нет тут пробовать". Вперед за красивым и эффективным кодом!

Основы объектно-ориентированного программирования на Python

Привет, друзья! Сегодня мы погрузимся в волшебный мир объектно-ориентированного программирования (ООП) на Python. ООП — это не просто подход к написанию кода, это целая философия, которая позволяет упорядочивать ваш код и делает его более читаемым и модульным. Если вы когда-либо задумывались о том, как создать собственный мир внутри вашего кода, то добро пожаловать в ООП!

### Путешествие начинается: Классы и Объекты

Представьте, что вы — божественный создатель. И у вас есть волшебная возможность создавать собственные объекты на основе абстрактных чертежей. Эти чертежи называются классами. Класс описывает, какие свойства и методы будут у объектов, созданных на его основе.

class Wizard:
    def __init__(self, name, power):
        self.name = name
        self.power = power

    def cast_spell(self):
        print(f"{self.name} casts a spell with power of {self.power}!")

__init__ — это конструктор, с помощью которого мы инициализируем наши объекты. Такие объекты — это конкретные реализации класса, в некотором смысле «живые» сущности вашего кода.

### Магия, заключенная в Инкапсуляции

Инкапсуляция — это концепция, которая позволяет скрыть внутреннюю реализацию классов. Мы можем защитить данные внутри класса и позволить взаимодействие только через методы. Это как если бы вы дарили миру гладко отполированный магический камень, не раскрывая, как он сделан.

### Полиморфизм: Многообразие форм

Теперь представьте, что у вас есть школа магии с различными типами волшебников: одни взымают огонь, другие — воду. Полиморфизм позволяет использовать методы с одинаковыми именами для разных объектов, и каждый объект будет вести себя по-своему. Это как универсальный заклинательный жезл, который работает для всех.

class FireWizard(Wizard):
    def cast_spell(self):
        print(f"{self.name} summons blazing flames!")

class WaterWizard(Wizard):
    def cast_spell(self):
        print(f"{self.name} calls forth a tidal wave!")

### Наследование: Передай свои навыки!

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

Мы лишь поверхностно коснулись магии, заключенной в ООП, но надеюсь, эти примеры увлекли вас и вызвали желание изучать дальше. Объектно-ориентированное программирование — это мощный инструмент, и освоив его, вы сможете создавать поистине удивительные структуры в вашем коде. До встречи в следующем посте, где мы продолжим наши исследования в мире Python!

Что такое исключения и как обрабатывать ошибки в коде

Итак, представьте, что вы путешественник в мире Python, и на вашем пути вам предстоит встретить невидимых врагов — исключения. Это те незаметные препятствия, которые поджидают в вашем коде и могут сорвать всё путешествие. Но не волнуйтесь, я расскажу вам, как превратить этих противников в союзников!

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

Но как же справиться с этими пакостниками? Тут приходит на помощь конструкция try-except. Она — ваш верный компас, который поможет обойти ловушки. Давайте посмотрим на небольшой пример:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Oops! Division by zero is not allowed.")

Что здесь происходит? Мы вставляем потенциально опасный код в блок try. Если возникает исключение, Python ищет блок except, соответствующий типу исключения. В нашем случае это ZeroDivisionError, и программа выводит дружественное сообщение, вместо того чтобы упасть с громким стуком.

Но это ещё не всё! Исключений бывает множество, и иногда вам нужно отловить их всех разом. Используйте простое except, чтобы поймать любую неожиданность:

try:
    int_value = int("not_a_number")
except:
    print("An error occurred!")

Однако будьте осторожны! Такой подход может скрыть важные детали об ошибке. Лучше обрабатывать исключения более конкретно и добавлять несколько блоков except при необходимости.

Ещё одна мощная техника — блоки finally и else. Они помогут завершить вашу одиссею на высокой ноте. Блок finally исполняется после всех остальных, независимо от исхода. Это идеальное место, чтобы освободить ресурсы или закрыть файлы.

try:
    file = open("data.txt")
    content = file.read()
except FileNotFoundError:
    print("File not found!")
else:
    print("File successfully read.")
finally:
    file.close()

Этот пример демонстрирует использование всех четырёх блоков. else выполняется, если ошибок не произошло, и finally закрывает файл, гарантируя отсутствие утечек ресурсов.

Теперь, когда вы знаете, что исключения — это не враги, а предупреждающие сигналы, вы вооружены знанием и готовы к любым неожиданностям на вашем пути. Впереди вас ждет ещё много удивительных открытий в мире Python!

Как парсить веб-страницы и извлекать данные с BeautifulSoup

Привет, друзья! Сегодня я хочу рассказать вам о магии, которая позволяет извлекать данные из веб-страниц, и имя этой магии — BeautifulSoup. Мы окунёмся в увлекательный мир парсинга и узнаем, как легко можно с помощью Python достать нужную информацию с любого сайта.

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

Первое, что нам нужно, это установить библиотеку. Если её у вас еще нет, быстро устанавливаем с помощью команды:

pip install beautifulsoup4

Также, для получения HTML-кода страниц, нам понадобится библиотека requests. Установить её можно аналогичным образом:

pip install requests

Теперь, когда всё готово, давайте напишем небольшой код, который извлечет заголовки статей с какой-нибудь интересной страницы. Например, возьмем "https://example.com".

import requests
from bs4 import BeautifulSoup

# Отправляем GET-запрос к странице
response = requests.get("https://example.com")

# Проверяем, что страница загрузилась успешно
if response.status_code == 200:
    page_content = response.text
    soup = BeautifulSoup(page_content, 'html.parser')

    # Ищем все заголовки на странице
    titles = soup.find_all('h2')  # предположим, наши заголовки — это теги <h2>

    # Печатаем все найденные заголовки
    for title in titles:
        print(title.get_text())

else:
    print("Не удалось загрузить страницу")    

Что здесь происходит? Мы отправляем запрос на веб-страницу и проверяем, что она была загружена успешно. Затем передаем содержимое страницы в BeautifulSoup. После чего начинаем извлекать информацию. В нашем случае, это все теги <h2>, которые содержат заголовки статей.

Конечно, это всего лишь верхушка айсберга. BeautifulSoup обладает множеством функций для поиска и навигации по HTML-документу. Например, можно использовать метод find, чтобы найти первый элемент с заданным тегом, или метод find_all для поиска всех элементов с таким тегом. Можно также использовать CSS-селекторы для более сложных запросов.

Хотите выделить текстовое содержимое всех параграфов с классом intro? Нет ничего проще:

intro_paragraphs = soup.select('p.intro')

for paragraph in intro_paragraphs:
    print(paragraph.get_text())

Вот так просто можно извлечь нужные данные! BeautifulSoup — это мощный инструмент для веб-скрейпинга, и с его помощью можно автоматизировать множество рутинных задач. Надеюсь, этот краткий экскурс открыл перед вами новые возможности!

Удачного парсинга, друзья!

Интерактивные графики и визуализация данных с Plotly