пїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅ пїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅпїЅ
Слишком длинный поисковый запрос.
По вашему запросу ничего не найдено :(
Убедитесь, что запрос написан правильно, или посмотрите другие
наши статьи:
100 примеров, с помощью которых вы сможете рационализировать ваш обычный рабочий процесс.
Python славится свой простотой и легкостью в изучении. Эти два фактора делают его идеальным вариантом для разработчиков любого уровня квалификации. Здесь я составил полезный список однострочников Python, с которыми, вы, скорее всего, будете сталкиваться, работая над своими обычными задачами разработки. Все эти однострочники являются практическими решениями самых распространённых задач, и, я думаю, что вы сочтете их для себя крайне полезными. Этот список никак не структурирован, так что не стесняйтесь изучать его в удобное для вас время. Без лишних слов, давайте окунемся в эту тему и откроем для себя магию однострочников Python, которые, без каких-либо сомнений, упростят процесс написания кода и дадут вам возможности для решения ваших повседневных задач!
Создание нового списка с помощью кода в одну строку
squares = [x**2 for x in range(10)]
Генерирует список квадратов целых чисел от 0 до 9
Создание нового списка, содержащего элементы, которые соответствуют условию
evens = [x for x in range(10) if x % 2 == 0]
Генерирует список четных в диапазоне от 0 до 9
Лямбда-функция
Определим небольшую анонимную функцию
add = lambda x, y: x + y
Создает простую функцию для сложения двух чисел
Фильтрация списка
Создадим новый список из элементов, удовлетворяющих условию
evens = [x for x in range(10) if x % 2 == 0]
Генерирует список четных чисел из диапазона от 0 до 9
(CSV-файл)
Функция map
Применим функцию к каждому итерируемому элементу
squares = list(map(lambda x: x**2, range(10)))
Функция filter
Профильтруем итерируемые элементы с учетом условия
evens = list(filter(lambda x: x % 2 == 0, range(10)))
Генерирует список четных цифр от 0 до 9 с помощью функции
filter
Переворот строки
Поменяем порядок символов в строке
reversed_string = 'Hello, World!'[::-1]
Переворачивает строку «Hello, world!» в строку «!dlrow ,olleH»
Цепочка сравнений
Проверим выполнение нескольких сравнений
x < y < z
Проверяет, что «x» меньше «y», а «y» меньше «z»
Тернарный оператор
Присвоим значение с учетом условия
x = a if condition else b
Присваивает переменной «х» значение «а», если условие верно, в противном случае – «b»
Перечисление списка
Переберем список по индексу и значению.
for i, item in enumerate(my_list):
Проходит по списку «my_list» и получает доступ как к индексу, так и к значению
«Упаковка» списков
Объединим элементы нескольких списков попарно
for a, b in zip(list_a, list_b):
Проходит по спискам «list_a» и «list_b», объединяя в пары числа с одинаковыми индексами
Сведение списка, состоящего из списков
Объединим элементы вложенных списков в один
flat_list = [item for sublist in list_of_lists for item in sublist]
Сводит «list_of_lists» в один единый список «flat_list»
# Sample data { # Выборочные данные }
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9, 10]]
# Flatten the list { # Сводим список }
flat_list = [item for sublist in list_of_lists for item in sublist]
# Output { # Результат }
print(flat_list)
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Перестановка значений переменных
Поменяем значения двух переменных
a, b = b, a
Меняет значения переменных «а» и «b»
Преобразование списка из строк в одну строку
Соединим элементы списка в одну единую строку
s = ' '.join(['hello', 'world'])
Объединяет элементы списка в строку «hello world»
Поиск индекса максимального значения в списке
max_index = max(range(len(my_list)), key=my_list.__getitem__)
Ищет индекс максимального значения в списке «my_list»
Поиск максимального значения и его индекса в списке
max_value, max_index = max((val, idx) for idx, val in enumerate(my_list))
Ищет максимальное значение и его индекс в списке «my_list»
Поиск минимального значения и его индекса в списке
`min_value, min_index = min((val, idx) for idx, val in enumerate(my_list))`
Ищет минимальное значение и его индекс в списке «my_list»
Печать списка через запятую
print(*my_list, sep=', ')
Печатает элементы списка «my_list» через запятую
Вычисление факториала
import math; math.factorial(5)
Вычисляет факториал числа 5
Вычисление n-го числа Фибоначчи
fib = lambda n: n if (n <= 1) else (fib(n-1) + fib(n-2))
Определяет лямбда-функцию для вычисления n-го числа Фибоначчи
Подсчет количество вхождений элемента в список
count = my_list.count(element)
Подсчитывает количество вхождений значений «element» в список «my_list»
Удаление дубликатов из списка
unique_list = list(set(my_list))
Создает список «unique_list» с дубликатами, удаленными из списка «my_list»
Сортировка списка по пользовательскому ключу
Отсортируем список по конкретному атрибуту или функции
sorted_list = sorted(my_list, key=lambda x: x[1])
Сортирует список «my_list» по второму элементу каждого элемента списка
Проверка, удовлетворяют ли все элементы условию
all(x > 0 for x in my_list)
Проверяет, все ли элементы списка «my_list» больше, чем 0
Проверка, удовлетворяют ли какие-нибудь элементы условию
Проверим, все ли элементы в итерируемом списке соответствуют условию
any(x > 0 for x in my_list)
Проверяет, все ли элементы списка «my_list» больше, чем 0
(CSV-файл)
Преобразование списка кортежей в словарь
Преобразуем список пар ключ-значение в словарь
my_dict = dict([('a', 1), ('b', 2), ('c', 3)])
Создает словарь из списка кортежей
Печать форматированной строки
Воспользуемся f-строкой для печати переменных в строке
print(f'Hello, {name}!')
Печатает строку с включенной переменной «name»
Создание псевдонима функции
Присвоим существующую функцию к новому имени
alias = original_function
Создает псевдоним для функции «original_function»
Поиск самого распространенного элемента в списке
most_common = max(set(my_list), key=my_list.count)`
# Sample data { # Выборочные данные }
my_list = [1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5]
# Find the most common element { # Находим самый распространенный элемент }
most_common = max(set(my_list), key=my_list.count)
# Output { # Результат }
print(most_common)
# 5
Ищет самый часто встречающийся элемент в списке «my_list»
(CSV-файл)
Ввод в виде списка целых чисел
Прочитаем строку ввода и преобразуем ее в список целых чисел
numbers = list(map(int, input().split()))
Преобразует пользовательский ввод в список целых чисел под названием «numbers»
# Prompt the user to enter a space-separated string of numbers { # Предлагаем пользователю ввести строку чисел, разделенных пробелом }
input_string = input("Enter some numbers separated by spaces: ")
# Convert the string to a list of integers { # Преобразовываем строку в список целых чисел }
numbers = list(map(int, input_string.split()))
# Output the list of numbers { # Выводим список чисел }
print(numbers)
#Enter some numbers separated by spaces: 10 20 30 40 50 { # Вводим некоторые числа через пробелы: 10 20 30 40 50 }
#[10, 20, 30, 40, 50]
Транспонирование матрицы
Перевернем матрицу относительно ее диагонали
transposed = list(zip(*matrix))
Транспонирует матрицу и сохраняет результат в переменной «transposed»
# Sample data { # Выборочные данные }
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# Transpose the matrix { # Транспонируем матрицу }
transposed = list(zip(*matrix))
# Output { # Результат }
print(transposed)
#[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
Проверка строки, является ли она палиндромом
Проверим, читается ли строка справа налево так же, как и слева направо
is_palindrome = s == s[::-1]
Проверяет, является ли строка «s» палиндромом
# Sample data { # Выборочные данные }
s = "racecar"
# Check if the string is a palindrome { # Проверяем, является ли строка палиндромом }
is_palindrome = s == s[::-1]
# Output { # Результат }
print(is_palindrome)
#True
Слияние двух словарей
Объединим два словаря путем обновления значений второго словаря
merged_dict = {**dict1, **dict2}
Объединяет словари «dict1» и «dic2» в один словарь «merged_dict»
Сумма элементов списка
Подсчитаем сумму элементов списка
total = sum(my_list)
Считает сумму элементов списка «my_list»
Вычисление среднего значения списка
Подсчитаем среднее значение элементов списка
average = sum(my_list) / len(my_list)
Считает среднее значение элементов списка «my_list»
Ввод в виде списка чисел с плавающей точкой
Прочитаем строку ввода и преобразуем ее в список чисел с плавающей точкой
floats = list(map(float, input().split()))
Преобразует пользовательский ввод в список чисел с плавающей точкой под названием «floats»
# Prompt the user to enter a space-separated string of numbers { # Предлагаем пользователю ввести строку чисел, разделенных пробелами }
input_string = input("Enter some floating-point numbers separated by spaces: ")
# Convert the string to a list of floats { # Преобразуем строку в список чисел с плавающей точкой }
floats = list(map(float, input_string.split()))
# Output the list of floats { # Выводим список чисел с плавающей точкой }
print(floats)
#Enter some floating-point numbers separated by spaces: 3.14 2.718 1.414 0.577 { # Вводим некоторые числа с плавающей точкой через пробелы: 3.14 2.718 1.414 0.577 }
#[3.14, 2.718, 1.414, 0.577]
Сортировка списка строк по их длине
Организуем список строк с учетом их длин
sorted_strings = sorted(my_list, key=len)
Сортирует список «my_list» по длине его строк
Преобразование строки в список символов
Разделим строку и получим список отдельных символов
char_list = list('hello')
Преобразует строку «hello» в список символов
# Convert a string to a list of characters { # Преобразовываем строку в список символов }
char_list = list('hello')
# Output the list of characters { # Выводим список символов }
print(char_list)
#['h', 'e', 'l', 'l', 'o']
Разделение строки по пробелам
Разделим строку по пробелам и получим список слов
words = s.split()
Разделяет строку «s» в список слов
# Sample data { # Выборочные данные }
s = "This is a sentence."
# Split the string into words { # Разделяем строку на слова }
words = s.split()
# Output the list of words { # Выводим список слов }
print(words)
#['This', 'is', 'a', 'sentence.']
(CSV_файл)
Конкатенация списка, состоящего из списков
Объединим несколько списков в один
merged_list = sum(list_of_lists, [])
Конкатенирует список, состоящий из списков, в один список под названием «merged_list»
# Sample data { # Выборочные данные }
list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
# Flatten the list of lists { # Объединяем список, состоящий из списков }
merged_list = sum(list_of_lists, [])
# Output the merged list { # Выводим объединенный список }
print(merged_list)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]
Проверка числа на простоту
Проверим, делится ли число только на 1 и на самого себя
is_prime = all(n % i for i in range(2, int(n**0.5) + 1))
Проверяет, является ли число «n» простым
# Sample data { # Выборочные данные }
n = 17
# Check if the number is prime { # Проверяем, является ли число простым }
is_prime = all(n % i for i in range(2, int(n**0.5) + 1))
# Output the result { # Выводим результат }
print(is_prime)
#True
Создание диапазона чисел с заданным шагом
Сгенерируем диапазон чисел с заданным размером шага
my_range = list(range(0, 10, 2))
Создает список четных чисел от 0 до 9
Преобразование строки в нижний/верхний регистр
Преобразуем символы строки в нижний регистр
lower_string = s.lower()
upper_string = s.upper()
Преобразует строку «s» в нижний регистр
Создание списка кортежей из нескольких списков
Сгенерируем список кортежей путем объединения элементов из нескольких списков
tuples_list = list(zip(list1, list2))
Создает список кортежей путем объединения элементов из списков «list1» и «list2»
# Sample data { # Выборочные данные }
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
# Combine the two lists into a list of tuples { # Объединяем два списка с один список кортежей }
tuples_list = list(zip(list1, list2))
# Output the list of tuples { # Выводим список кортежей }
print(tuples_list)
# [('a', 1), ('b', 2), ('c', 3)]
Проверка строки на наличие подстроки
Проверим, содержит ли строка другую строку
substring_present = substring in main_string
Проверяет, содержит ли строка «main_string» подстроку «substring»
Разделение строки по определенному символу
Разобьем строку в список подстрок по определенному символу
split_list = s.split(',')
Делит строку «s» в список подстрок по запятым
Поэлементное сложение двух списков
Объединим два списка путем сложения соответствующих элементы вместе
combined_list = [a + b for a, b in zip(list1, list2)]
Создаем список «combined_list», складывая элементы из списков «list1» и «list2»
# Sample data { # Выборочные данные }
list1 = [1, 2, 3]
list2 = [10, 20, 30]
# Combine the two lists element-wise { # Объединяем два списка поэлементно }
combined_list = [a + b for a, b in zip(list1, list2)]
# Output the combined list { # Выводим объединенный список }
print(combined_list)
#[11, 22, 33]
Поиск уникальных элементов в списке
Выведем различные элементы списка с сохранением порядка
unique_list = list(dict.fromkeys(my_list))
Создает список «unique_list» с уникальными элементами из списка «my_list», сохраняя порядок
# Sample data { # Выборочные данные }
my_list = [1, 2, 2, 3, 3, 3, 4, 5, 5]
# Remove duplicates from the list { # Удаляем дубликаты из списка }
unique_list = list(dict.fromkeys(my_list))
# Output the unique list { # Выводим список уникальных значений }
print(unique_list)
#[1, 2, 3, 4, 5]
Для создания нового словаря мы используем метод
dict.fromkeys()
, поскольку в словаре не может быть повторяющихся ключей, а этот метод эффективно удаляет дубликаты из списка
my_list
.
Получение длины списка без использования len()
Подсчитаем количество элементов в списке без применения функции len()
list_length = sum(1 for _ in my_list)
Вычисляет длину списка «my_list» без использования функции len()
# Sample data { # Выборочные данные }
my_list = ['a', 'b', 'c', 'd', 'e']
# Count the number of elements in the list { # Подсчитываем количество элементов в списке }
list_length = sum(1 for _ in my_list)
# Output the list length { # Выводим длину списка }
print(list_length)
#5
Поиск различий в двух списках
Выведем элементы, которые есть только в одном из двух списков
difference = list(set(list1) - set(list2))
Ищет различия межу списками «list1» и «list2»
# Sample data { # Выборочные данные }
list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
# Find the difference between the two lists { # Ищем различия между двумя списками }
difference = list(set(list1) - set(list2))
# Output the difference { # Выводим различия }
print(difference)
#[1, 2]
Создание списка символов из строки без пробелов
Сгенерируем список символов из строки, исключив пробелы
char_list = [c for c in s if c != ' ']
Создает список символов из строки «s», пропуская пробелы
# Sample data { # Выборочные данные }
s = "The quick brown fox"
# Remove spaces from the string { # Удаляем пробелы из строки }
char_list = [c for c in s if c != ' ']
# Output the list of characters { # Выводим список символов }
print(char_list)
#['T', 'h', 'e', 'q', 'u', 'i', 'c', 'k', 'b', 'r', 'o', 'w', 'n', 'f', 'o', 'x']
Замена всех вхождений подстроки в строку
Заменим все экземпляры подстроки в строке другой строкой
new_string = s.replace(old_substring, new_substring)
Заменяет все вхождения подстроки «old_substring» в строку «s» новой подстрокой «new_substring»
# Sample data { # Выборочные данные }
s = "The quick brown fox jumps over the lazy dog."
old_substring = "fox"
new_substring = "cat"
# Replace the old substring with the new substring { # Заменяем старую подстроку новой }
new_string = s.replace(old_substring, new_substring)
# Output the new string { # Выводим новую строку }
print(new_string)
#The quick brown cat jumps over the lazy dog.
Разделение строки на список строк
lines = s.splitlines()
Делит строку «s» и преобразует в список строк
Создание строки из списка символов
my_string = ''.join(char_list)
Конкатенирует список символов в строку
# Sample data { # Выборочные данные }
char_list = ['T', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b', 'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x']
# Concatenate the list of characters into a string { # Конкатенируем список символов в строку }
my_string = ''.join(char_list)
# Output the resulting string { # Выводим получившуюся строку }
print(my_string)
#The quick brown fox
Получение последнего элемента списка
last_element = my_list[-1]
Извлекает последний элемент списка «my_list»
(CSV-файл)
Поворот списка с n-ой позиции
rotated_list = my_list[-n:] + my_list[:-n]
Разворачивает список «my_list» с n-ой позиции
# Sample data { # Выборочные данные }
my_list = [1, 2, 3, 4, 5]
n = 2
# Rotate the list by n positions to the left { # Переворачиваем список со смещением на n позиций влево }
rotated_list = my_list[-n:] + my_list[:-n]
# Output the rotated list { # Выводим перевернутый список }
print(rotated_list)
#[3, 4, 5, 1, 2]
Вырезка массива
sliced_list = my_list[start:stop:step]
Вырезает часть массива с помощью значений «start», «stop» и «step»
Получение кода символа в ASCII
ascii_value = ord(char)
#Find the ASCII value of the character ‘char’ { # Найдем код ASCII символа char }
# Sample data { # Выборочные данные }
char = 'A'
# Get the ASCII value of the character { # Получаем код ASCII символа char }
ascii_value = ord(char)
# Output the ASCII value { # Выводим код ASCII }
print(ascii_value)
#65
Подсчет количества слов в строке
len(string.split())
string = "This is a sample string for demonstration purposes"
word_count = len(string.split())
print(f"The string '{string}' contains {word_count} words.")
#The string 'This is a sample string for demonstration purposes' contains 8 words. { # Строка «This is a sample string for demonstration purposes» содержит 8 слов. }
Перемешивание списка
import random; random.shuffle(list)
import random
# Create a list of numbers from 1 to 10 { # Создадим список чисел от 0 до 10 }
my_list = list(range(1, 11))
print("Original list:", my_list)
# Shuffle the list { # Перемешаем список }
random.shuffle(my_list)
print("Shuffled list:", my_list)
#Original list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] { # Первоначальный список: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] }
#Shuffled list: [6, 10, 3, 9, 8, 5, 2, 4, 7, 1] { # Перемешанный список: [6, 10, 3, 9, 8, 5, 2, 4, 7, 1] }
Генерация всех возможных комбинаций элементов списка
import itertools; [list(comb) for i in range(len(list)+1) for comb in itertools.combinations(list, i)]
import itertools
# Define a list of letters { # Определим список букв }
my_list = ['a', 'b', 'c']
# Generate all possible combinations of the letters { # Сгенерируем все возможные комбинации этих букв }
combinations = [list(comb) for i in range(len(my_list)+1) for comb in itertools.combinations(my_list, i)]
# Print the combinations { # Напечатаем комбинации }
print(combinations)
#[[], ['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]
Поиск пересечения/объединения двух списков
list(set(list1) & set(list2)) # intersection { # пересечение }
list(set(list1) | set(list2)) # union { # объединение }
Проверка, является ли список подмножеством/надмножеством другого списка
set(list1).issubset(set(list2))
set(list1).issuperset(set(list2))
Различия и сходства двух списков
#Find the difference between two lists: { # Найдем различия двух списков }
list(set(list1) - set(list2))
#Check if two lists have at least one element in common: { # Проверим, есть ли хотя бы один общий элемент у двух списков }
bool(set(list1) & set(list2))
Подсчет количества вхождений каждого слова в строку
import collections; collections.Counter(string.split())
import collections
# Define a sentence { # Определим предложение }
my_sentence = "Python is a powerful programming language. Python is easy to learn and use."
# Count the occurrences of each word in the sentence { # Подсчитаем количество вхождений каждого слова в предложение }
word_counts = collections.Counter(my_sentence.split())
# Print the word counts { # Напечатаем количество слов }
print(word_counts)
#Counter({'Python': 2, 'is': 2, 'a': 1, 'powerful': 1, 'programming': 1, 'language.': 1, 'easy': 1, 'to': 1, 'learn': 1, 'and': 1, 'use.': 1})
Поиск самого часто встречающегося слова в строке
import collections; collections.Counter(string.split()).most_common(1)[0][0]
import collections
# Define a sentence { # Определим предложение }
my_sentence = "Python is a powerful programming language. Python is easy to learn and use."
# Find the most common word in the sentence { # Найдем самое часто встречающееся слова в предложение }
most_common_word = collections.Counter(my_sentence.split()).most_common(1)[0][0]
# Print the most common word { # Напечатаем самое часто встречающееся слово }
print("The most common word is:", most_common_word)
#The most common word is: Python { # Самое часто встречающееся слово: Python }
Генерация случайного пароля
import random, string; ''.join(random.choices(string.ascii_letters + string.digits + string.punctuation, k=n))
import random
import string
# Define the length of the random string { # Определим длину случайной строки }
n = 10
# Generate a random string of length n { # Сгенерируем случайную строку длиной n }
random_string = ''.join(random.choices(string.ascii_letters + string.digits + string.punctuation, k=n))
# Print the random string { # Напечатаем случайную строку }
print("Random string:", random_string)
#Random string: vJ76*,T<~j { # Случайная строка: vJ76*,T<~j }
Преобразование строки в объект DateTime
import datetime; datetime.datetime.strptime(string, format_string)
#Convert a datetime object to a string: { # Преобразуем объект типа DateTime в строку }
datetime_object.strftime(format_string)
#Calculate the difference between two datetime objects: { # Вычислим разность двух объектов типа DateTime }
datetime2 - datetime1
#Get the current date and time: { # Получим текущие дату и время }
import datetime; datetime.datetime.now()
#Get the day of the week for a given date: { # Получим день недели для заданной даты }
datetime_object.strftime('%A')
#Get the month name for a given date: { # Получим названием месяца для заданной даты }
datetime_object.strftime('%B')
import datetime
# Define a string representing a date and time { # Определим строку, представляющую дату и время }
date_string = '2023-07-01 09:30:00'
# Define the format string for the date and time { # Определим формат строки для даты и времени }
format_string = '%Y-%m-%d %H:%M:%S'
# Parse the date and time string { # Разберем строку даты и времени }
parsed_date = datetime.datetime.strptime(date_string, format_string)
# Print the parsed date and time { # Напечатаем разобранные дату и время }
print("Parsed date:", parsed_date)
# Parsed date: 2023-07-01 09:30:00 { # Разобранные дата и время: 2023-07-01 09:30:00 }
Поиск индекса первого вхождения элемента в список с помощью бинарного поиска
import bisect; bisect.bisect_left(list, element)
import bisect
# Define a sorted list of numbers { # Определим отсортированный список чисео }
my_list = [1, 3, 4, 7, 9]
# Define an element to insert into the list { # Определим элемент, входящего в список }
my_element = 5
# Find the insertion point of the element in the list { # Ищем точку вхождения элемента в список }
insertion_point = bisect.bisect_left(my_list, my_element)
# Print the insertion point { # Печатаем точку вхождения }
print("Insertion point:", insertion_point)
#Insertion point: 2 { # Точка вхождения: 2 }
#Find the index of the last occurrence of an element in a list using binary search: { # Находим индекс последнего вхождения элемента в список с помощью бинарного поиска }
import bisect; bisect.bisect_right(list, element) - 1
Подсчет количества вхождений каждого элемента в список и сохранение результата в словаре
import collections; collections.Counter(list)
import collections
# Define a list of elements { # Определяем список элементов }
my_list = ['apple', 'banana', 'orange', 'apple', 'banana', 'banana']
# Count the occurrences of each element in the list { # Подсчитываем количество вхождений каждого элемента в список }
element_counts = collections.Counter(my_list)
# Print the element counts { # Печатаем количество элементов }
print(element_counts)
#Counter({'banana': 3, 'apple': 2, 'orange': 1})
Поиск моды/медианы списка
import statistics; statistics.mode(list)
import statistics; statistics.median(list)
Проверка, является ли строка панграммой (то есть содержит все буквы алфавита)
set('abcdefghijklmnopqrstuvwxyz').issubset(set(string.lower()))
Удаление всех неалфавитных символов из строки
import re; re.sub('[^0-9a-zA-Z]+', '', string)
import re
# Define a string with non-alphanumeric characters { # Определяем строку, в которой есть неалфавитные символы }
my_string = "This is an example string with spaces, punctuation marks, and digits (like 123)."
# Remove all non-alphanumeric characters from the string { # Удаляем все неалфавитные символы из строки }
clean_string = re.sub('[^0-9a-zA-Z]+', '', my_string)
# Print the clean string { # Печатаем «очищенную» строку }
print(clean_string)
#Thisisanexamplestringwithspacespunctuationmarksanddigitslike123
Разворот списка на месте
list.reverse()
Вычисление векторного произведения двух векторов
import numpy; numpy.cross(vector1, vector2)
Получения имя хост-системы текущего компьютера
import socket; socket.gethostname()
Проверка доступности порта на удаленном компьютере
import socket; sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM); result = sock.connect_ex((ip_address, port)); sock.close(); result == 0
Получение IP-адреса текущего компьютера
import socket; socket.gethostbyname(socket.gethostname())
Проверка, является ли строка приемлемым адресом электронной почты
import re; bool(re.match(r'^[\w\.\+\-]+\@[\w]+\.[a-z]{2,3}$', email))
Создание zip-файла
import zipfile; with zipfile.ZipFile('filename.zip', 'w', zipfile.ZIP_DEFLATED) as zip: zip.write('filename.txt')
Извлечение данных из zip-файла
import zipfile; with zipfile.ZipFile('filename.zip', 'r') as zip: zip.extractall('dirname')
Проверка наличия установленного модуля
import importlib; importlib.util.find_spec('modulename') is not None
Получение переменных окружения
import os; os.environ
Выполнение команды оболочки
import os; os.system('command')
Получение текущей версии Python
import platform; platform.python_version()
Получение имени текущего пользователя
import getpass; getpass.getuser()
Копирование файла
import shutil; shutil.copy('sourcefile', 'destinationdir')
Подсчет количества слов в файле
import re; len(re.findall(r'\w+', open('filename.txt').read()))
Переименование файла
import os; os.rename('oldname', 'newname')
Удаление каталога и всего его содержимого
import shutil; shutil.rmtree('dirname')
Получение текущего рабочего каталога
import os; os.getcwd()
Создание каталога
import os; os.mkdir('dirname')
Проверка существования файла
import os; os.path.exists('filename.txt')
# Get the size of a file in bytes: { # Получаем размер файла в битах }
import os; os.path.getsize('filename.txt')
# Get the last modified time of a file: { # Получаем время последнего изменения файла }
import os; os.path.getmtime('filename.txt')
# Delete a file: { # Удаляем файл }
import os; os.remove('filename.txt')
Переход в спящий режим на заданное количество секунд
import time; time.sleep(seconds)
Генерация случайного целого числа между a и b
import random; random.randint(a, b)
Проверка, находится ли число в диапазоне
in_range = lower_bound <= value <= upper_bound
Проверяет, находится ли значение «value» в диапазоне между «lower_bound» и «upper_bound»
Проверка, начинается ли строка с определенной подстроки
starts_with = s.startswith(substring)
Проверяет, начинается ли строка «s» с подстроки «substring»
ends_with = s.endswith(substring)
Проверяет, заканчивается ли строка «s» подстрокой «substring»
Вычисление евклидового пространства между двумя точками
distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
Вычисляет евклидово пространство между точками (x
1
, y
1
) и (x
2
, y
2
)
import math
# Define two points in two-dimensional space { # Определяем две точки в двумерном пространстве }
x1, y1 = 2, 3
x2, y2 = 5, 7
# Calculate the Euclidean distance between the two points { # Вычисляем эвклидово пространство между двумя точками }
distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(f"The distance between ({x1}, {y1}) and ({x2}, {y2}) is {distance:.2f}.")
#The distance between (2, 3) and (5, 7) is 4.24. { # Расстояние между точками (2, 3) и (5, 7) – 4.24. }
Заключение
Я надеюсь, что эта статья была для вас познавательной и интересной. В Python есть огромное количество мощных однострочников, и то, что я продемонстрировал здесь, - лишь верхушка айсберга.
Python часто называют «языком программирования с батарейками в комплекте», или, иначе говоря, полностью укомплектованным. Это лишь означает, что в него встроен ряд готовых библиотек, которые разработчики могут использовать, чтобы облегчить свою работу. Как вы, наверное, уже догадались, существует огромное количество библиотек для этого интерпретируемого высокоуровневого языка программирования общего назначения.
Нет никаких сомнений в том, что одна из причин такой популярности Python – это наличие более ста тысяч библиотек на любой вкус. Чем больше библиотек и пакетов в своем распоряжении имеет язык программирования, тем больше существует различных вариантов его использования.
Трудно сказать, какие из тысяч доступных библиотек Python на самом деле хороши, а какие не стоят не вашего внимания. Для того, чтобы помочь вам, мы перечислили в этой статье некоторые лучшие библиотеки Python. Ваш фаворит есть в этом списке? Читайте дальше, чтобы это узнать!
Что такое библиотека Python?
Прежде чем мы сможем ответить на этот вопрос, нам нужно понять, что такое библиотека – по крайней мере, с точки зрения программирования. Библиотеки состоят из классов, служебных методов и модулей. Когда вы пишете код для своего приложения, эти вещи могут вам пригодиться. Вместо того, чтобы писать код с нуля, вы можете воспользоваться готовыми компонентами библиотеки, чтобы выполнить какие-то определенные задачи в вашем коде. Благодаря этому вы сэкономите много времени и сил. Более того, библиотеки позволяют использовать код повторно и в то же время устанавливают некоторые стандарты для разработчиков. Так что же такое библиотеки Python?
Так как Python стал наиболее широко используемым языком программирования за последние годы, то его используют для самых различных целей и приложений. Одна из главных причин, по которой Python так популярен, заключается в том, что он имеет огромное количество различных библиотек с открытым исходным кодом в своем арсенале, которые являются не только бесплатными, но и достаточно простыми в использовании.
Библиотеки Python – это наборы полезных модулей, функций, классов и многого другого. Эти библиотеки помогают разработчикам ускорить процесс написания кода, предоставляя возможность работать с уже существующим кодом без лишних телодвижений. Стоит ли говорить, что библиотеки позволяют разработчикам сконцентрироваться на важных частях своих приложений, так как им больше не нужно писать код с нуля.
Стоит отметить, что, так как Python используется в самых разных отраслях, то существуют топ библиотек Python практически для любых целей, которые вы только можете себе представить.
Что следует учитывать при выборе библиотеки Python
Теперь, когда вы знаете, чем вам может помочь библиотека в Python, у вас может возникнуть следующий вопрос: «Как мне выбрать правильную библиотеку?» Это вполне нормальный вопрос – в конце концов, на сегодняшний день доступно более 137 000 библиотек Python. И как тут решить, какая из них лучше всего подходит для ваших целей?
Может оказаться трудным принять решение, когда вы сталкиваетесь с таким огромным выбором. Некоторые даже могут почувствовать себя беспомощными, не зная, что выбрать. А для некоторых выходом может стать даже то, что они решат просто написать все то, что им нужно, с нуля. Делать это, конечно же, не нужно.
Вот некоторые вещи, которые следует учитывать при выборе лучших библиотек Python:
Какова ваша предполагаемая цель? Понимание основной цели вашего проекта необходимо для того, чтобы помочь сузить круг подходящих библиотек Python. Для того, чтобы еще сократить список потенциальных кандидатов, рассмотрите любые второстепенный области, цели и особенности, которые так или иначе могут быть связаны с основной целью. Например, если ваш проект ориентирован на науку о данных, то вам может понадобиться библиотека, которая сможет поддерживать управление данными и их визуализацию.
Какую версию Python вы используете? Есть множество различных версий Python, которые вы можете использовать для своих проектов. Когда вы выбрали определенную версию для своего приложения, вы должны убедиться, что все библиотеки, которые вы используете, совместимы с этой версией.
Будет ли эта библиотека работать совместно с другими библиотеками, которые вы используете? Если вы используете несколько библиотек, то рекомендуется убедиться, что они могут работать вместе. Если вдруг вы используете несовместимые или пересекающиеся библиотеки, то они могут доставить вам больше вреда, чем пользы.
Соответствует ли библиотека вашему бюджету? Есть огромное количество библиотек Python с открытым исходным кодом, которые вы можете использовать совершенно бесплатно. Если вы найдете среди них те, которые идеально подходят для вашего проекта, то вам, возможно, и не придется покупать какие-либо еще библиотеки. Однако все же есть библиотеки, за доступ к которым вам нужно будет заплатить.
Топ библиотек Python
1. Requests
Основное назначение: упрощение HTTP-запросов
Одна из самых популярных общедоступных библиотек Python – это Requests. Ее цель – сделать HTTP-запросы более простыми и удобными для восприятия. Библиотека Requests имеет лицензию Apache2 и написана на Python. Она является фактическим стандартом, который используют разработчики для выполнения HTTP-запросов в Python.
Помимо того, что библиотека Requests может использоваться для отправки HTTP-запросов на сервер, она также позволяет добавлять в них данные формы, содержимое, заголовок, файлы, состоящие из нескольких частей, и т.д. С этой библиотекой разработчикам не нужно добавлять запрос к URL-адресу или кодировать данные POST вручную.
Библиотека Requests абстрагируется от многочисленных сложностей создания HTTP-запросов в простом API, поэтому разработчики могут больше сосредоточится на взаимодействии со службами. Библиотека поддерживает Python 2.7, 3.4 и выше, а также отлично работает с PyPy.
Основные моменты:
Разрешает загрузку нескольких файлов и потоковую загрузку
Автоматическая расшифровка содержимого и автоматическое развертывание
Проверка SSL в браузере
Функции могут быть настроены и оптимизированы в соответствии с требованиями
Постоянное соединение и объединенное подключение
Поддерживает международные домены и URL-адреса
2. Pillow
Основное назначение: обработка изображений
Дополнительные назначения: архивирование изображений, отображение изображений
Python Imaging Library, или PIL – это бесплатная библиотека Python, которая позволяет интерпретатору Python обрабатывать изображения. Иными словами, PIL дает возможность обрабатывать, открывать и сохранять различные форматы изображений в Python. Pillow была создана Алексом Кларком и его соавторами, и она является ответвлением библиотеки PIL.
Помимо мощных возможностей обработки изображений, Pillow предлагает эффективное внутреннее представление информации и всестороннюю поддержку форматов файлов. Стандартная библиотека Python обеспечивает быстрый доступ к данным, которые хранятся в нескольких основных форматах пикселей.
Основные моменты:
Поддержка отладки с помощью метода show()
Идеально подходит для приложений пакетной обработки данных
Распознает и читает большое количество различных форматов файлов изображений
Предлагает интерфейсы BitmapImage, PhotoImage и Window DIB
Поддерживает произвольные аффинные преобразования, преобразования пространства цветов, фильтрацию с помощью набора встроенных ядер свертки, изменение размера и поворот изображения, а также поточечные операции
Гистограммы позволяют извлечь некоторую статистику из изображения, а также могут использоваться для автоматического повышения контрастности и глобального статистического анализа
3. Scrapy
Основное назначение: веб-скрейпинг
Дополнительные назначения: автоматизированное тестирование, интеллектуальных анализ данных, сканирование веб-страниц (веб-краулинг)
Scrapy – это бесплатный фреймворк Python с открытым исходным кодом, который широко используется для веб-скрейпинга и ряда других задач, в том числе автоматического тестирования и интеллектуального анализа данных.
Изначально Scrapy был разработан именно для веб-скрейпинга, а позже был доработан для выполнения других задач. Библиотека предлагает быстрый и высокоуровневый метод сбора данных с веб-сайтов и извлечения структурированных данных с веб-страниц.
Scrapy написан на Python и построен на основе «пауков», или автономных поисковых роботов, которым предоставляется набор инструкций. Scrapy соблюдает принцип DRY (don’t repeat yourself – не повторяйся) и тем самым упрощает создание и масштабирование готовых проектов веб-сканирования.
Основные моменты:
«Паука» для обхода веб-сайта и извлечения данных легко написать
Следует принципу DRY
Предлагает оболочку для сбора данных, которая позволяет разработчикам тестировать поведение веб-сайта
Поддерживает экспорт собранных данных с помощью командной строки
4. Asyncio
Основное назначение: работа с асинхронным кодом
Разработчики Python по всему миру используют библиотеку asyncio для написания параллельного кода с помощью синтаксиса async/await. Библиотека asyncio больше всего подходит для кода, который связан с вводом-выводом, а также для высокоуровневого структурированного сетевого кода.
Asyncio используется для создания различных асинхронных фреймворков Python, которые предлагают библиотеки подключения к базам данных, распределенные очереди задач, высокопроизводительные сетевые и веб-серверы и многое другое. В библиотеку встроен ряд высокоуровневых и низкоуровневых API.
Основные моменты:
Позволяет контролировать подпроцессы, распределять задачи по очередям, выполнять сетевой ввод-вывод и межпроцессное взаимодействие, а также синхронизировать параллельный код.
Объединение библиотек и кода на основе обратных вызовов с помощью синтаксиса async/await и низкоуровневых API.
Включает в себя набор высокоуровневых API для одновременного запуска сопрограмм Python и полного контроля над их выполнением.
Упрощает работу с асинхронным кодом.
Поддерживает создание циклов событий и управление ими, реализуя эффективные протоколы передачи данных.
5. Tkinter
Основное назначение: разработка графического интерфейса
Tkinter позволяет просто и быстро создавать приложения с графическим интерфейсом. Tkinter – это стандартная библиотека графического интерфейса для языка программирования Python. Она предлагает мощный объектно-ориентированный интерфейс для инструментария графического интерфейса "Tk".
Процесс создания приложения с графическим интерфейсом с помощью Tkinter очень прост. Все, что от вас требуется, это выполнить следующие простые шаги:
Импортировать Tkinter
Создать главное окно для разрабатываемого приложения с графическим интерфейсом
Добавить один или несколько графических элементов Tkinter
Войти в основной цикл обработки событий, чтобы выполнить действий по каждому событию, инициированному пользователем
В Tkinter есть более 15 типов графических элементов, в том числе кнопки, метки и текстовые поля. Каждый из них имеет доступ к определенных методам управления геометрией, которые необходимы для их организации в основной области графических элементов.
Основные моменты:
Включает в себя набор графических элементов, которые поддерживают методы управления геометрией
Упрощает разработку приложений с графическим интерфейсом
Поддерживает эффективный объектно-ориентированный интерфейс
6. Six
Основное назначение: библиотека совместимости (сглаживание различий между Python 2 и Python 3)
Несмотря на незамысловатость названия, Six – это мощная библиотека Python, которая предназначена для сглаживания различий между двумя версиями Python: 2 и 3. Библиотека Six поддерживает кодовые базы, которые могут работать как на Python 2, так и на Python 3 без внесения каких-либо изменений.
Библиотека Six очень проста в использовании, поскольку представляет собой всего один файл Python. Поэтому скопировать библиотеку в проект Python до смешного просто. Название Six отражает следующее: (Python) 2 умножить на (Python) 3.
Основные моменты:
Простые служебные функции для обеспечения совместимости кода Python с Python 2 и Python 3.
Поддерживает все версии, начиная с Python 2.6.
Очень проста в использовании, так как содержится в одном файле Python.
7. aiohttp
Основное назначение: служит асинхронным HTTP-клиентом/сервером
Библиотека aiohttp – это еще одна простая, но при этом широко используемая библиотека Python. По сути, это асинхронный HTTP-клиент или сервер в Python. Эта библиотека выполняет только эту функцию и поддерживает клиентские и серверные веб-сокеты.
Основные моменты:
Предлагает веб-сервер с промежуточным ПО, подключаемой маршрутизацией и сигналами.
Обеспечивает поддержку клиентских и серверных веб-сокетов
Поддерживает HTTP-клиента и сервер
8. Pygame
Основное назначение: разработка 2D-игр
Дополнительное назначение: разработка мультимедийных приложений
Pygame – это бесплатная библиотека Python с открытым исходным кодом. Она предназначена для разработки мультимедийных приложений на Python, в частности, двумерных игр. И как результат, она популярна среди как обычных, так и профессиональных разработчиков игр на Python.
За кадром Pygame использует библиотеку SDL (Simple DirectMedia Layer). Как и SDL, библиотека Pygame отличается высокой переносимостью, а значит, обеспечивает поддержку большого количества платформ и операционных систем.
Приложения, которые были разработаны с помощью Pygame можно портировать на Android-устройства, такие как смартфоны и планшеты. Для этого необходимо использовать pgs4a (версия Pygame для Android).
Основные моменты:
Не требует OpenGL
Упрощает использование многоядерных процессоров
Для использования всех доступных функций графический интерфейс не нужен
Обеспечивает поддержку большого количества платформ и операционных систем
Простая и удобная в использовании
Использует код ассемблера и оптимизированный код С для реализации основных функций
9. Kivy
Основное назначение: разработка приложений (с инновационными пользовательскими интерфейсами)
При создании мобильных приложений и программного обеспечения мультитач-приложений с NUI (Natural User Interface – естественный пользовательский интерфейс) разработчики Python опираются на библиотеку Kivy. Kivy – это бесплатная библиотека Python с открытым исходным кодом. Она распространяется по лицензии MIT (лицензии свободного ПО, разработанной Массачусетским технологическим институтом) и работает на Android, iOS, Linux, macOS и Windows.
На самом деле Kivy – это эволюционировавший проект PyMT. Эта библиотека содержит все элементы, которые необходимы для создания интуитивно понятного мультитач-приложения, а именно графическую библиотеку, большой набор графических элементов с поддержкой мультитач, промежуточный язык (Kv) и всестороннюю поддержку ввода.
Kv, или язык Kivy, - это промежуточный язык, который предназначен для описания действий со стороны пользователя и интерфейса. Это позволяет легко создавать пользовательские интерфейсы и добавлять к ним способы взаимодействия. Kivy также обеспечивает поддержку Raspberry Pi.
Основные моменты:
Возможность по умолчанию использовать большинство устройств, входов и протоколов
Кроссплатформенность
Предлагает более 20 графических элементов с возможностью изменения их размеров
Поддержка графического механизма, созданного на базе OpenGL ES 2.
10. Bokeh
Основное назначение: разработка приложений, основанных на визуализации
Дополнительное назначение: визуализация данных, наука о данных
Bokeh – это интерактивная библиотека визуализации для языка программирования Python. Она позволяет красиво и понятно визуализировать данные в современных веб-браузерах. Библиотека визуализации данных упрощает создание информационных панелей, приложений данных и интерактивных графиков.
Помимо лаконичного и изящного построения разнообразной графики, библиотека Bokeh также имеет дополнительные возможности благодаря высокопроизводительной интерактивности при потоковой передаче данных или при очень больших наборах данных.
Основные моменты:
Позволяет строить сложные статистические графики с помощью простых команд
Визуализация, полученная с помощью Bokeh, может быть легко встроена в две самые популярные платформы Python – Django и Flask
Возможность создавать изящные и интерактивные визуализации данных
Несколько привязок к языку (Julia, Lua, Python и R)
Различные форматы вывода
11. NumPy
Основное назначение: научные и численные вычисления
Дополнительные назначения: анализ данных, формирование основ других библиотек Python, таких как SciPy
NumPy – это один из лучших модулей Python с открытым исходным кодом для научных и числовых вычислений и анализа данных. Более того, эта библиотека является основой для нескольких других библиотек Python, таких как SciPy и Sci-Kit Learn. NumPy чаще всего используется для математических операций с матрицами и массивами. Эту библиотеку очень часто используют ученые, которые выполняют анализ данных, из-за ее эффективных и быстрых вычислений.
Также NumPy может обрабатывать многомерные массивы, поэтому большое количество разработчиков и специалистов по обработке данных используют ее для проектов в областях искусственного интеллекта и машинного обучения.
Основные моменты:
Повышение эффективность за счет вычислений с массивами
Использует векторизацию для компактных и более быстрых вычислений
Поддерживает объектно-ориентированный подход
Предоставляет числовые подпрограммы в виде быстрых и предварительно скомпилированных функций
12. SciPy
Основное назначение: визуализация данных и их обработка
Дополнительные назначения: линейная алгебра, алгоритмы оптимизации, операции с изображениями (многомерными)
Аналогично NumPy, SciPy является бесплатным модулем с открытым исходным кодом, что делает его общедоступным. SciPy основан на NumPy и также может использоваться для технических и научных вычислений с большими наборами данных. Эта библиотека играет важную роль в техническом и научном анализе данных. Именно поэтому она считается довольно важной библиотекой в Python. Некоторые даже называют ее основополагающей библиотекой для языка программирования Python.
SciPy хорошо подходит для обработки изображений. Она имеет высокоуровневые команды, которые можно использовать для обработки данных и их визуализации.
Основные моменты:
Наборы функций и алгоритмов построены на основе NumPy
Имеет встроенные функции, которые предназначены для решения дифференциальных уравнений
Есть подмодуль SciPy ndimage, предназначенный для обработки изображений (многомерных)
13. Sci-Kit Learn
Основное назначение: приложения машинного обучения
Дополнительное назначение: статистическое моделирование
Sci-Kit Learn основан на Numpy и SciPy и прежде был известен как Sklearn. Это бесплатная библиотека Python, и она очень часто воспринимается как расширение библиотеки SciPy. Sci-Kit Learn была создана специально с целью разработки алгоритмов машинного обучения и моделирования данных.
Для многих Sci-Kit Learn – это одна из лучших библиотек Python, а все из-за ее последовательного, простого и интуитивно понятного интерфейса. Поскольку она очень удобна в использовании, многие считают, что она идеально подходит для новичков.
Основные моменты:
Библиотека машинного обучения
Предлагает практически все алгоритмы, которые необходимы для машинного обучения
Создана на основе SciPy, NumPy и Matplotlib
14. Theano
Основное назначение: машинное и глубокое обучение
Дополнительные назначения: оценка, анализ и обработка математических выражений
Библиотека численных вычислений, которая известна как Theano, была создана специально для машинного обучения. Многие разработчики используют эту библиотеку для моделей глубокого обучения из-за ее функций. Подавляющее большинство пользователей Theano – это разработчики глубокого и машинного обучения.
Theano предлагает возможность интеграции с NumPy при необходимости. Когда Theano используется совместно с графическим процессором (таким как видеокарта) вместо центрального процессора (такого как Intel Core i5 или i7 или AMD Ryzen), то она может выполнять вычисления в 140 раз быстрее.
Основные моменты:
Интегрируется с NumPy
Работает с центральными процессорами, но намного эффективнее работает с графическими процессорами; может выполнять вычисления намного быстрее, работая с графическим процессором
Оптимизирована для сохранения стабильности и скорости
Использует многомерные массивы для создания моделей глубокого обучения
15. TensorFlow
Основное назначение: глубокое обучение и машинное обучение; большие численные вычисления
Дополнительные назначения: текстовые приложения, обнаружение видео, распознавание речи/изображений, анализ временных рядов
TensorFlow – это библиотека с открытым исходным кодом, которая первоначально была разработана исследователями из Google.
Ее специализация - дифференцируемое программирование, но основная цель ее создания – это машинное и глубокое обучение, а также другие рабочие нагрузки в прогнозной и статистической аналитике.
Возможности и набор встроенных инструментов TensorFlow упрощают процесс создания моделей машинного и глубокого обучения. TensorFlow также упрощает процесс создания нейронных сетей, независимо от того, занимаются ли эти профессионалы или новички.
Платформа и архитектура TensorFlow очень гибкие. Это позволяет использовать библиотеку как с центральными процессорами, так и с графическими. Но если вы хотите раскрыть всю мощь TensorFlow, то вам лучше работать с TPU (Tensor processing unit – тензорный процессор). Эта библиотека не ограничивается настольными устройствами, вы также можете использовать ее на смартфонах и серверах.
Основные моменты:
Частые обновления и новые выпуски – залог того, что у вас будут новые функции и чистый код
Поддерживается Google
Улучшенная визуализация вычислительных графиков
16. PyTorch
Основное назначение: наука о данных
Дополнительные назначения: исследования в области глубокого обучения
PyTorch – еще одна библиотека с открытым исходным кодом, которую часто используют для обработки данных. Эта библиотека основана на Torch (фреймворк для языка программирования C), и она может интегрироваться с другими библиотеками Python, такими как NumPy. PyTorch способна незаметно для пользователя создавать графы вычислений, которые можно менять, пока программа запущена.
PyTorch чаще всего используется в приложениях машинного и глубокого обучения, в том числе обработки естественного языка и компьютерного зрения. Эта библиотека хорошо известна тем, что способна быстро выполнять команды даже при больших нагрузках. Библиотека PyTorch достаточно гибкая, что позволяет ей работать на центральных, графических и упрощенных процессорах.
Пользователи могут расширять PyTorch с помощью своих наборов API.
Основные моменты:
Тензорные вычисления с помощью графического процессора для более быстрой и эффективной обработки
Простой и удобный API
Использует динамические графы вычислений
Имеет большое сообщество
17. Keras
Основное назначение: машинное и глубокое обучение
Дополнительное назначение: визуализация данных
Keras – это библиотека Python с открытым исходным кодом, которая была создана преимущественно для разработки и оценки нейронных сетей в моделях машинного и глубокого обучения. Эта библиотека может работать наряду с TensorFlow и Theano, а это значит, что разработчики могут начать обучение своих нейронных сетей с небольшого количества кода.
Keras – гибкая, расширяемая и модульная, поэтому она отлично подходит для новичков. Эта библиотека также является переносимой, что означает, что вы можете использовать ее в различных средах как на графических, так и на центральных процессорах.
Часто разработчики используют эту библиотеку для визуализации данных или моделирования.
Основные моменты:
Поддерживает серверные части Theano и TensorFlow
Предусматривает предварительно размеченные наборы данных, которые разработчики могут использовать непосредственно для загрузки/импорта
Предлагает простые и согласующиеся API
Проста в освоении и использовании, небольшая кривая обучения
18. Pandas
Основное назначение: наука о данных
Дополнительные назначения: анализ данных и машинное обучение
Pandas – это одна из самых популярных библиотек Python на сегодняшний день, как минимум, в области науки о данных. Pandas – это еще одна библиотека, созданная на основе NumPy. Эта библиотека позволяет пользователям создавать комплексные, но интуитивно понятные высокоуровневые структуры данных. Pandas используется в различных отраслях – от статистики до инженерии (и даже в финансовой сфере).
Есть одна вещь, которая делает библиотеку Pandas просто замечательной, - это ее гибкость и возможность использования с другими научными библиотеками и библиотеками численного анализа Python.
Основные моменты:
Используется во многих коммерческих областях, включая финансовую сферу, нейронауки и статистику.
Используется в научных областях
Создана на основе NumPy
Помогает в решении большого количества громоздких и трудоемких задач, связанных с данными
19. Matplotlib
Основное назначение: визуализация данных
Дополнительное назначение: машинное обучение
Matplotlib – это библиотека Python с открытым исходным кодом, которую часто приводят в пример, как альтернативу платному MATLAB. Matplotlib – это расширение SciPy, и оно было создано для визуализации данных в силу того, того, что она используется для создания диаграмм и графиков. Matplotlib может работать со сложными моделями данных, которые выводит Pandas, и со структурами данных, которые создает NumPy.
У Matplotlib есть ограничение – она может создавать только 2D-графики. Но несмотря на это, эта библиотека может создавать готовые к публикации визуализации данных в виде графиков, диаграмм, гистограмм, точечных диаграмм, диаграмм ошибок, и конечно, линейчатых диаграмм.
Эта библиотека очень проста в использовании и интуитивно понятна, поэтому многие новички предпочитают работать именно с ней, когда только пробуют себя в визуализации данных. Matplotlib также выбирает немалое количество разработчиков, которые уже имеют опыт работы с другими инструментами визуализации данных.
Основные моменты:
Открытый исходный код, хорошая замена MATLAB (платное приложение)
Малое потребление памяти
Поддержка большого сообщества
Предлагает различные типы визуализации данных (коробчатые диаграммы, точечные диаграммы, гистограммы, диаграммы ошибок и т.д.)
20. Seaborn
Основное назначение: визуализация данных
Дополнительное назначение: машинное обучение
Аналогично Matplotlib, Seaborn – это библиотека Python, которая была создана для построения графиков и визуализации данных. По сути, эта библиотека была основана на самой Matplotlib, хотя она также включает в себя некоторые структуры данных Pandas. Seaborn имеет высокоуровневый интерфейс с огромным количеством функций, которые позволяют пользователям создавать не просто точные, но и информативные статистические графики.
Большое количество разработчиков и пользователей Seaborn согласятся с тем фактом, что эта библиотека создает одни из самых красивых визуализаций данных. Именно поэтому она идеально подходит для использования в маркетинговых и издательских приложениях.
Пользователи также любят Seaborn за ее способность создавать графики и диаграммы с помощью простых команд и минимального количества программного кода, что экономит им время.
Основные моменты:
Создана на основе Matplotlib
Позволяет разработчикам создавать красивые информативные графики с помощью высокоуровневого интерфейса
Позволяет создавать такие графики, как попарные графики, гистограммы, линейчатые диаграммы, точечные диаграммы и т.д.
21. BeautifulSoup
Основное назначение: наука о данных
Дополнительное(-ые) назначение(-я): веб-скрейпинг
Beautiful Soup получила свое название благодаря своей способности анализировать документы HTML и XML (даже с некорректной разметкой, которую называют «tag soup» - «суп из тегов»). Этот пакет Python обходит веб-сайты, собирает данные и подготавливает их для дальнейшей работы. Beautiful Soup – это универсальный пакет, и поэтому его выбирают многие аналитики данных и ученые. Разработчики, занимающиеся вопросами машинного и глубокого обучения, также используют Beautiful Soup для получения данных для обучения своих моделей машинного/глубокого обучения.
Основные моменты:
Позволяет извлекать данные из HTML и XML, даже из документов с некорректной или неполной разметкой (например, с незакрытыми тегами)
Задумывалась как средство синтаксического анализа HTML, которое могло бы сделать «суп из тегов» работоспособным и даже «красивым»
22. PyCaret
Основное назначение: машинное обучение
PyCaret получила свое название от библиотеки Python, основанной на Caret, - библиотеке машинного обучения на языке программирования R. Это библиотека с открытым исходным кодом, и она была создана для машинного обучения. Она предлагает функции, которые помогают упростить и автоматизировать программы машинного обучения.
Несмотря на наличие небольшой кривой обучения, PyCaret относительно прост в использовании.
Основные моменты:
Высокоуровневая и малокодовая библиотека
Автоматизирует рабочие процессы в машинном обучении
Помогает ускорить циклы экспериментов, повышая тем самым производительность
Позволяет разработчикам развертывать модели машинного обучения с малым количеством кода
23. OpenCV
Основное назначение: компьютерное зрение и обработка изображений
Дополнительное назначение: машинное обучение
Как и любая библиотека Python, OpenCV имеет большой количество различных функций. Это делает ее отличным инструментом для программ компьютерного зрения в режиме реального времени. Эта высокоэффективная библиотека способна обрабатывать различные входные данные с визуальной информацией, взятой не только из изображений, но и из видеоданных. OpenCV может распознавать лица, почерк и объекты.
Основные моменты:
Выполняет такие задачи, как отслеживание угроз, обнаружение лиц, обнаружение ориентиров и многое другое
Предоставляет разработчикам доступ к более чем 2500 классическим современным алгоритмам
Широко используется даже такими технологическими гигантами, как Google, IBM, Toyota и другими
Используется для анализа изображений/видео
24. LightGBM
Основное назначение: машинное обучение
LightGBM расшифровывается как Light Gradient Boosting Machine. Это бесплатный фреймворк градиентного бустинга, разработанный Microsoft для машинного обучения. Он удобен и интуитивно понятен. Изучить его намного проще, чем некоторые другие библиотеки для глубокого обучения.
Основные моменты:
Обеспечивает эффективное использование памяти и высокую вычислительную мощность
Первоначально разработан Microsoft
Возможность работы с большими объемами данных
Обеспечивает высокую точность результатов
Вот и все!
Приведенный выше список содержит одни из самых лучших библиотек из сотен тысяч других. Приятно осознавать, что все эти библиотеки часто обновляются и улучшаются, чтобы не отставать от Python и его растущей популярности.
Если вы изучите хотя бы одну из этих библиотек, это сможет помочь вам в изучении языка, а также стать хорошим разработчиком Python во всех отношениях.
Часто задаваемые вопросы
1. Что такое библиотеки Python?
Библиотеки Python – это наборы функций, модулей и других компонентов, которые позволяют разработчикам использовать уже существующий код для определенных задач. Библиотеки могут быть как общими, так и более специализированными. Они могут помочь разработчикам сэкономить время и силы, избавив от необходимости писать огромную часть приложения с нуля.
2. Какие есть примеры библиотек Python?
Есть большое количество очень популярных пакетов и библиотек Python. Если вам нужны примеры таких библиотек, то вот вам несколько громких наименований:
Requests
Numpy, SciPy, SciKit-Learn
PyTorch
Pandas
Seaborn
Theano
TensorFlow
3. Где можно найти список всех библиотек Python?
Если вы имеете в виду список всех модулей, пакетов и библиотек, установленных сейчас в вашей версии Python, то это можно сделать с помощью команды help(“modules”), pip list или pip freeze
4. Для чего нужны библиотеки Python?
Библиотеки Python необходимы для того, чтобы упростить и оптимизировать работу разработчика. Вместо того, чтобы писать какие-то части проекта с нуля, разработчики могут воспользоваться модулями и связками кода из библиотек. Также библиотеки могут устанавливать стандарты написания программного кода, что упрощает сопровождение кода.
5. Все ли библиотеки Python являются бесплатными?
Большая часть крупных библиотек допускают бесплатное коммерческое использование. Однако не все библиотеки так просты в использовании и освоении. Поэтому, даже если библиотека бесплатная, возможно, вам придется заплатить за какие-либо лицензионные или платные модули, или программное обеспечение, чтобы упростить отладку и сопровождение в долгосрочной перспективе. Кроме того, даже если библиотека является бесплатной для коммерческого использования, вам, вероятно, придется доплатить, если вы хотите включить какие-то модули в свои приложения, которые в дальнейшем будете распространять среди будущих клиентов.
6. Как работают библиотеки в Python?
Библиотеки Python позволяют разработчикам использовать модули и связки кода в своих проектах многократно. Библиотеки позволяют вам использовать уже готовый код и добавить его к своему вместо того, чтобы каждый раз писать кода с нуля.
Протокол RIP (Routing Information Protocol)
Протокол Routing Information Protocol (RIP) был первоначально указан в RFC1058. Протокол Routing Information Protocol опубликован в 1998 году. Протокол был обновлен в серии более поздних RFC, включая RFC2435, RIP версии 2,3 и RFC2080, RIP Next Generation для IPv6.
Рисунок 1 используется для объяснения работы RIP.
Работа RIP обманчиво проста. На рисунке 1:
A обнаруживает 2001:db8:3e8:100::/64, поскольку он настроен на непосредственно подключенный интерфейс.
A добавляет этот пункт назначения в свою локальную таблицу маршрутизации со стоимостью 1.
Поскольку 100 :: / 64 установлен в локальной таблице маршрутизации, A будет анонсировать этот достижимый пункт назначения (маршрут) для B и C.
Когда B получает этот маршрут, он добавляет стоимость входящего интерфейса, чтобы путь через A имел стоимость 2, и проверяет свою локальную таблицу на предмет любых других более дешевых маршрутов к этому месту назначения. Поскольку у B нет другого пути к 100::/64, он установит маршрут в своей таблице маршрутизации и объявит маршрут к E.
Когда C получает этот маршрут, он добавит стоимость входящего интерфейса, чтобы путь через A имел стоимость 2, и проверит свою локальную таблицу на предмет любых более дешевых маршрутов к этому пункту назначения. Поскольку у C нет другого пути к 100 :: / 64, он установит маршрут в своей таблице маршрутизации и объявит маршрут D и E.
Когда D получает этот маршрут, он добавляет стоимость входящего интерфейса от C, чтобы путь через C имел стоимость 3, и проверяет свою локальную таблицу на предмет любых более дешевых маршрутов к этому месту назначения. Поскольку у D нет другого пути к 100 :: / 64, он установит маршрут в свою таблицу маршрутизации и объявит маршрут к E.
E теперь получит три копии одного и того же маршрута; один через C со стоимостью 3, один через B со стоимостью 4 и один через D со стоимостью 5. E выберет путь через C со стоимостью 2, установив этот путь на 100 :: / 64 в свою локальную таблицу маршрутизации.
E не будет объявлять какой-либо путь к 100 :: / 64 к C, потому что он использует C как лучший путь для достижения этого конкретного пункта назначения. Таким образом, E выполнит split horizon своего объявления 100 :: / 64 в сторону C.
В то время как E будет объявлять свой лучший путь через C как D, так и B, ни один из них не выберет путь через E, поскольку у них уже есть лучшие пути к 100 :: / 64.
RIP объявляет набор пунктов назначения и определяет стоимость в один прыжок за раз через сеть. Следовательно, он считается протоколом вектора расстояния. Процесс, который RIP использует для поиска набора безцикловых путей через сеть, считается распределенной формой алгоритма Беллмана-Форда, но не совсем ясно, как процесс, который использует RIP, связан с Беллманом-Фордом.
Связь Bellman-Ford с RIP
Чтобы увидеть соединение, лучше всего представить каждый переход в сети как одну строку в таблице топологии. Это отображено на рисунке 2.
Раздел «Пути одноадресной передачи без петель», описывает работу Bellman-Ford с таблицей топологии, организованной как набор столбцов и строк. Используя номера строк, показанные на рисунке 2, вы можете построить аналогичную таблицу топологии для этой сети, как показано в таблице 1.
Предположим, что каждая строка таблицы проходит через алгоритм Беллмана-Форда другим узлом. Например, A вычисляет Беллмана-Форда по первой строке и передает результат B. Аналогичным образом, B вычисляет Bellman-Ford по соответствующим строкам и передает результат C. Беллман-Форд по-прежнему будет алгоритмом, используемым для вычисления набор без петель в сети. Он просто будет распределен по узлам в сети. Фактически, так работает RIP. Учтите следующее:
A вычисляет первую строку в таблице, устанавливая предшественника для 100::/64 в A и стоимость в 1. A передает этот результат B для второго раунда обработки.
B обрабатывает вторую строку в таблице, устанавливая для предшественника 100 :: / 64 значение B, а стоимость - 2. B передает этот результат C для третьего раунда обработки.
C обрабатывает вторую строку в таблице, устанавливая для предшественника 100 :: / 64 значение C, а стоимость - 2. C передает этот результат в D.
Распределенную обработку Беллмана-Форда труднее увидеть в более сложных топологиях, потому что по сети передается более одной «таблицы результатов». Однако эти «таблицы результатов» в конечном итоге объединятся на исходном узле. Рисунок 3 иллюстрирует это.
На рисунке 3 A вычислит предварительную таблицу результатов в качестве первого «раунда» алгоритма Беллмана-Форда, передав результат как B, так и E. B вычислит предварительный результат на основе локальной информации, передав его в C, а затем из C в D. Таким же образом E вычислит предварительную таблицу результатов на основе локальной информации, передав ее в F, а затем F в D. В D два предварительных результата объединяются в окончательную таблицу с точки зрения D. Конечно, предварительная таблица считается окончательной для устройства на каждом шаге. С точки зрения E, таблица, которую он вычисляет на основе локально доступной информации и объявления от A, является финальной таблицей путей без петель для достижения 100::/64.
Весь распределенный процесс имеет тот же эффект, что и хождение по каждой строке в таблице топологии столько же раз, сколько записей в самой таблице топологии, медленно сортируя поля предшественника и стоимости для каждой записи на основе вновь установленных предшественников в предыдущем раунде вычислений.
Реакция на изменения топологии
Как RIP удаляет информацию о доступности из сети в случае отказа узла или канала? Рисунок 4 используется для объяснение этого случая.
В зависимости от версии и конфигурации RIP, работающего в этой сети, существует две возможные реакции на потерю канала [A, B]. Первая возможная реакция - просто дать тайм-аут информации о 100::/ 64. Предполагая, что недействительный таймер (форма таймера удержания) для любого заданного маршрута составляет 180 секунд (обычная настройка в реализациях RIP):
B немедленно заметит сбой связи, поскольку он подключен напрямую, и удалит 100 :: / 64 из своей локальной таблицы маршрутизации.
B прекратит объявлять достижимость 100 :: / 64 в направлении C.
C удалит доступность к этому месту назначения из своей локальной таблицы маршрутизации и прекратит объявлять достижимость от 100 :: / 64 до D через 180 секунд после того, как B перестанет объявлять достижимость до 100 :: / 64.
D удалит доступность к этому месту назначения из своей локальной таблицы маршрутизации через 180 секунд после того, как C прекратит объявлять достижимость до 100 :: / 64.
На этом этапе сеть сконцентрировалась на новой информации о топологии. Очевидно, что это довольно медленный процесс, так как каждый переход должен ждать, пока каждый маршрутизатор, ближайший к месту назначения, отсчитает время, прежде чем обнаружит потерю соединения.
Чтобы ускорить этот процесс, большинство реализаций RIP также включают инициированные обновления. Если инициированные обновления реализованы и развернуты в этой сети, когда канал [A, B] выйдет из строя (или будет удален из службы), B удалит доступность 100 :: / 64 из своей локальной таблицы и отправит инициированное обновление в C, информацию C о неудавшейся достижимости к месту назначения. Это инициируемое обновление обычно принимает форму объявления с бесконечной метрикой, или, скорее, того, что известно как ядовитый реверс. Инициируемые обновления часто выполняются с заданной скоростью, поэтому колеблющееся соединение не приведет к тому, что сами инициированные обновления не будут перегружать канал или соседний маршрутизатор.
Два других таймера указаны в RIP для использования во время схождения: flush timer и hold-down timer. По истечении времени ожидания маршрута (как описано выше) он не удаляется сразу из локальной таблицы маршрутизации. Вместо этого устанавливается другой таймер, который определяет, когда маршрут будет удален из локальной таблицы. Это flush timer. Кроме того, существует отдельный период времени, в течение которого любой маршрут с метрикой хуже, чем ранее известная, не будет приниматься. Это hold-down timer.
Подведение итогов- RIP
RIP несет информацию о локально достижимых пунктах назначения соседям, а также стоимость для каждого пункта назначения. Следовательно, это протокол вектора расстояния. Достижимые пункты назначения изучаются через локальную информацию на каждом устройстве и передаются по сети протоколом независимо от потока трафика; следовательно, RIP-это проактивная плоскость управления.
RIP не формирует смежности для надежной передачи данных по сети. Скорее, RIP полагается на периодически передаваемые обновления, чтобы гарантировать, что информация не устарела или не была случайно сброшена. Количество времени, в течение которого хранится любая часть информации, основано на таймере удержания (hold-down timer), а частота передач основана на таймере обновления (lush timer). Таймер удержания обычно устанавливается в три раза больше значения таймера обновления.
Поскольку RIP не имеет истинного процесса смежности, он не определяет, существует ли двусторонняя связь- следовательно, нет двусторонней проверки подключения (Two-Way Connectivity Check-TWCC). В RIP также не встроен метод проверки MTU между двумя соседями.
Enhanced Interior Gateway Routing Protocol
Enhanced Interior Gateway Routing Protocol (EIGRP) был выпущен в 1993 году для замены протокола Interior Gateway Routing Protocol (IGRP) компании Cisco. Основной причиной замены IGRP была его неспособность передавать информацию о классовой маршрутизации. В частности, IGRP не может переносить маски подсети. Вместо того, чтобы перестраивать протокол для поддержки длины префикса, инженеры Cisco (в частности, Дино Фариначчи и Боб Олбритсон) решили создать новый протокол, основанный на алгоритме диффузного обновления Гарсиа-Луны (Diffusing Update Algorithm-DUAL). Дэйв Кац перестроил транспорт, чтобы решить некоторые часто встречающиеся проблемы в середине 1990-х годов. Основываясь на этой первоначальной реализации, команда под руководством Донни Сэвиджа в 2000-х годах сильно изменила работу протокола, добавив ряд функций масштабирования и переписав ключевые части реакции EIGRP на изменения топологии. Протокол EIGRP был выпущен вместе с практически всеми этими улучшениями в RFC7868 в 2013 году.
В то время как EIGRP не часто рассматривается для активного развертывания в большинстве сетей поставщиков услуг (большинство операторов предпочитают протокол состояния канала), DUAL вводит некоторые важные концепции в обсуждение о безцикловых путях. DUAL также используется в других протоколах, таких как BABEL (указанный в RFC 6126 и используемый в простых домашних сетях).
Метрики EIGRP
Первоначально протокол EIGRP был разработан для считывания полосы пропускания, задержки, частоты ошибок и других факторов с каналов в режиме, близком к реальному времени, и передачи их в качестве метрик. Это позволит EIGRP реагировать на изменение сетевых условий в реальном времени и, следовательно, позволит сетям, на которых запущен EIGRP, более эффективно использовать доступные сетевые ресурсы. Однако в при первоначальном развертывании EIGRP, не существовало «защитных ограждений» для предотвращения петель обратной связи между, например, реакцией протокола на изменения доступной полосы пропускания и сдвигами в трафике в зависимости от доступной полосы пропускания. Если пара каналов с доступной полосой пропускания, близкой к реальному времени, была размещена параллельно друг другу, трафик переключится на канал с наиболее доступной полосой пропускания, в результате чего протокол будет реагировать, показывая большую доступную полосу пропускания на другом канале, улучшая его метрики и следовательно, трафик переместится на другую линию связи. Этот процесс переключения трафика между линиями может быть решен различными способами, но он вызывал достаточно проблем в ранних развертываниях EIGRP для того, чтобы эту возможность почти реального времени можно было удалить из кода. Вместо этого EIGRP считывает характеристики интерфейса в определенное время и объявляет эти показатели для интерфейса независимо от сетевых условий.
EIGRP несет пять различных атрибутов маршрута, включая полосу пропускания, задержку, нагрузку, надежность и MTU. Четыре показателя объединяются по формуле, показанной на рисунке 5.
Значения K по умолчанию в этой формуле приводят к сокращению всей формулы до (107/throughput) * delay. Замена пропускной способности (throughput) минимальной полосой пропускания (bandwidth) дает версию, с которой знакомо большинство инженеров: (107 / bandwidth) * delay.
Однако значения пропускной способности (bandwidth) и задержки (delay) масштабируются в более поздних версиях EIGRP для учета каналов с пропускной способностью более 107 кбит/с.
Примечание.В ходе этого обсуждения EIGRP предполагается, что полоса пропускания каждого канала установлена на 1000, а значения K установлены на значения по умолчанию, оставляя задержку в качестве единственного компонента, влияющего на метрику. Учитывая это, только значение задержки используется в качестве метрики в этих примерах для упрощения расчетов.
Рисунок 6 используется для описания работы EIGRP.
Работа EIGRP в этой сети на первый взгляд очень проста:
A обнаруживает 2001: db8: 3e8: 100 :: / 64, потому что он напрямую подключен (например, через настройки интерфейса).
A добавляет к маршруту стоимость входящего интерфейса, которая здесь показана как задержка (delay) 100, и устанавливает ее в свою локальную таблицу маршрутизации.
A объявляет 100 :: / 64 B и C через два других подключенных интерфейса.
B получает этот маршрут, добавляет стоимость входящего интерфейса (общая задержка 200) и проверяет свою локальную таблицу на предмет любых других (или лучших) маршрутов к этому месту назначения. У B нет маршрута к 100 ::/64, поэтому он устанавливает маршрут в своей локальной таблице маршрутизации.
B объявляет 100 :: / 64 для D.
C получает этот маршрут, добавляет стоимость входящего интерфейса (общая задержка 200) и проверяет свою локальную таблицу на предмет любых других (или лучших) маршрутов к этому месту назначения. У C нет маршрута к 100 :: / 64, поэтому он устанавливает маршрут в своей локальной таблице маршрутизации.
C объявляет 100 :: / 64 для D.
D получает маршрут к 100 ::/64 от B, добавляет стоимость входящего интерфейса (общая задержка 300) и проверяет свою локальную таблицу на предмет любых других (или лучших) маршрутов к этому месту назначения. D не имеет маршрута к этому месту назначения, поэтому он устанавливает маршрут в своей локальной таблице маршрутизации.
D получает маршрут к 100 :: / 64 от C, добавляет стоимость входящего интерфейса (общая задержка 400) и проверяет свою таблицу на предмет любых других (или лучших) маршрутов к этому месту назначения. D действительно имеет лучший маршрут к 100 :: / 64 через B, поэтому он вставляет новый маршрут в свою локальную таблицу топологии.
D объявляет маршрут от 100 :: / 64 до E.
E получает маршрут к 100 :: / 64 от D, добавляет стоимость входящего интерфейса (общая задержка 400) и проверяет свою локальную таблицу на предмет любых других (или лучших) маршрутов к этому месту назначения. E не имеет маршрута к этому месту назначения, поэтому он устанавливает маршрут в своей локальной таблице маршрутизации.
Все это очень похоже на работу RIP. Шаг 9, однако, требует более подробного рассмотрения. После шага 8 у D есть путь к 100 :: / 64 с общей стоимостью 300. Это допустимое расстояние до пункта назначения, а B - преемник, так как это путь с наименьшей стоимостью. На шаге 9 D получает второй путь к тому же месту назначения. В RIP или других реализациях Bellman-Ford этот второй путь либо игнорируется, либо отбрасывается. EIGRP, основанный на DUAL, однако, проверит этот второй путь, чтобы определить, свободен ли он от петель или нет. Можно ли использовать этот путь, если основной путь не работает?
Чтобы определить, является ли этот альтернативный путь свободным от петель, D должен сравнить допустимое расстояние с расстоянием, которое C сообщила как стоимость достижения 100 :: / 64 - заявленное расстояние. Эта информация доступна в объявлении, которое D получает от C (помните, что C объявляет маршрут с его стоимостью до пункта назначения. D добавляет к нему стоимость канала [B, D], чтобы найти общую стоимость через C для достижения 100: : / 64). Сообщаемое расстояние через C составляет 200, что меньше локального допустимого расстояния, равного 300. Следовательно, маршрут через C не имеет петель и помечен как возможный преемник.
Реакция на изменение топологии.
Как используются эти возможные преемники? Предположим, что канал [B, D] не работает, как показано на рисунке 7.
Когда этот канал выходит из строя, D проверяет свою таблицу локальной топологии, чтобы определить, есть ли у нее другой путь без петель к месту назначения. Поскольку путь через C отмечен как возможный преемник, у D есть альтернативный путь. В этом случае D может просто переключиться на использование пути через C для достижения 100 :: / 64. D не будет пересчитывать допустимое расстояние в этом случае, так как он не получил никакой новой информации о топологии сети.
Что, если вместо этого произойдет сбой соединения между C и A, как показано на рисунке 8?
В этом случае до сбоя у C есть два пути к 100 :: / 64: один через A с общей задержкой 200 и второй через D с общей задержкой 500. Возможное расстояние в C будет установлено на 200 , поскольку это стоимость наилучшего пути, доступного после завершения сходимости. Сообщаемое расстояние в D, 300, больше, чем возможное расстояние в C, поэтому C не будет отмечать путь через D как возможный преемник. После сбоя канала [A, C], поскольку C не имеет альтернативного пути, он пометит маршрут как активный и отправит запрос каждому из своих соседей, запрашивая обновленную информацию о любом доступном пути к 100 :: / 64.
Когда D получает этот запрос, он проверяет свою таблицу локальной топологии и обнаруживает, что его лучший путь к 100 :: / 64 все еще доступен. Поскольку этот путь все еще существует, процесс EIGRP на D может предположить, что на текущий лучший путь через B не повлиял отказ канала [A, C]. D отвечает на этот запрос своей текущей метрикой, которая указывает, что этот путь все еще доступен и не имеет петель с точки зрения D.
Получив этот ответ, C заметит, что он не ждет ответа от других соседей (поскольку у него только один сосед, D). Поскольку C получил все ответы, которых он ожидает, он пересчитает доступные пути без петель, выбрав D в качестве преемника, а стоимость через D в качестве допустимого расстояния.
Что произойдет, если D никогда не ответит на запрос C? В более старых реализациях EIGRP C устанавливал таймер, называемый Stuck in Active Timer. Если D не отвечает на запрос C в течение этого времени, C объявит маршрут как Stuck in Active (SIA), и сбросит соседнюю смежность с помощью D. В новых реализациях EIGRP C установит таймер, называемый таймером запроса SIA (Query timer). Когда этот таймер истечет, он повторно отправит запрос к D. Пока D отвечает, что он все еще работает над ответом на запрос, C будет продолжать ждать ответа.
Где заканчиваются эти запросы? Как далеко будет распространяться запрос EIGRP в сети? Запросы EIGRP завершаются в одной из двух точек:
Когда у маршрутизатора нет других соседей для отправки запросов;
Когда маршрутизатор, получающий запрос, не имеет никакой информации о пункте назначения, на который ссылается запрос.
Это означает, что, либо на «конце сети EIGRP» (называемой автономной системой), либо на одном маршрутизаторе, за пределами какой-либо политики или конфигурации, скрывающей информацию о конкретных местах назначения. Например, один переход после точки, в которой маршрут агрегируется.
Диапазон запросов EIGRP и дизайн сети.
EIGRP всегда был известен как «протокол, который будет работать в любой сети» из-за его больших свойств масштабирования и очевидной способности работать в «любой» топологии без особой настройки. Однако основным фактором, определяющим масштабирование EIGRP, является диапазон запросов. Основная задача проектирования сети в сети EIGRP - ограничение объема запросов через сеть. Во-первых, диапазон запросов влияет на скорость схождения EIGRP: каждый дополнительный переход диапазона запроса добавляет небольшое количество времени к общему времени конвергенции сети (в большинстве случаев около 200 мс). Во-вторых, диапазон запросов влияет на стабильность сети. Чем дальше по сети должны проходить запросы, тем больше вероятность того, что какой-то маршрутизатор не сможет сразу ответить на запрос. Следовательно, наиболее важным моментом при проектировании сети на основе EIGRP в качестве протокола является ограничение запросов посредством агрегации или фильтрации определенного типа.
Обнаружение соседей и надежная передача.
EIGRP проверяет двустороннюю связь между соседями, канал MTU, и обеспечивает надежную передачу информации плоскости управления через сеть путем формирования отношений соседей. Рисунок 9 демонстрирует процесс формирования соседей EIGRP.
Шаги, показанные на рисунке 9, следующие:
A отправляет многоадресное приветствие (multicast hello) по каналу, совместно используемому между A и B.
B переводит A в состояние ожидания. Пока A находится в состоянии ожидания, B не будет отправлять стандартные обновления или запросы к A и не будет принимать ничего, кроме специально отформатированных обновлений от A.
B передает пустое обновление с битом инициализации, установленным в A. Этот пакет отправляется на адрес одноадресного интерфейса A.
При получении этого обновления A отвечает пустым обновлением с установленным битом инициализации и подтверждением. Этот пакет отправляется на адрес одноадресного интерфейса B.
Получив это одноадресное обновление, B переводит A в состояние подключения и начинает отправлять обновления, содержащие отдельные записи таблицы топологии, в сторону A. В каждый пакет добавляется подтверждение для предыдущего пакета, полученного от соседа.
Поскольку EIGRP не формирует смежности с наборами соседей, а только с отдельными соседями, этот процесс обеспечивает доступность как одноадресной, так и многоадресной рассылки между двумя маршрутизаторами, образующими смежность. Чтобы гарантировать, что MTU не совпадает ни на одном конце канала, EIGRP заполняет определенный набор пакетов во время формирования соседа. Если эти пакеты не принимаются другим маршрутизатором, MTU не совпадает, и отношения соседства не должны формироваться.
Примечание. EIGRP отправляет многоадресные приветствия (multicast hellos) для обнаружения соседей по умолчанию, но будет использовать одноадресные приветствия, если соседи настроены вручную.
Подведение итогов – EIGRP.
EIGRP представляет ряд интересных решений проблем, с которыми сталкиваются протоколы маршрутизации при отправке информации по сети, вычислении путей без петель и реагировании на изменения топологии. EIGRP классифицируется как протокол вектора расстояния, использующий DUAL для вычисления путей без петель и альтернативных путей без петель через сеть. EIGRP объявляет маршруты без привязки к потокам трафика через сеть, поэтому это проактивный протокол.
Протоколы вектора расстояния и таблица маршрутизации.
В большинстве дискуссий о протоколах вектора расстояния- эти протоколы объясняются таким образом, что подразумевает, что они работают полностью отдельно от таблицы маршрутизации и любых других процессов маршрутизации, запущенных на устройстве. Однако это не так. Протоколы векторов расстояний взаимодействуют с таблицей маршрутизации не так, как протоколы состояния каналов. В частности, протокол вектора расстояния не объявляет маршрут к пункту назначения, который он не установил в локальной таблице маршрутизации.
Например, предположим, что EIGRP и RIP работают на одном маршрутизаторе. EIGRP узнает о некотором пункте назначения и устанавливает маршрут к этому пункту назначения в локальной таблице маршрутизации. RIP узнает о б этом же месте назначения и пытается установить маршрут, который он узнал, в локальную таблицу маршрутизации, но ему это не удается - маршрут EIGRP перезаписывает (или переопределяет) маршрут, полученный RIP. В этом случае RIP не будет анонсировать этот конкретный маршрут ни одному из своих соседей.
Для такого поведения есть две причины. Во-первых, маршрут, полученный через EIGRP, может указывать на совершенно другой следующий переход, чем маршрут, полученный через RIP. Если метрики установлены неправильно, два протокола могут образовать постоянную петлю пересылки в сети. Во-вторых, RIP не может узнать, насколько действителен маршрут EIGRP. Возможно, RIP объявляет маршрут, заставляя другие маршрутизаторы отправлять трафик локального устройства, предназначенный для объявленного пункта назначения, а затем локальное устройство фактически отбрасывает пакет, а не пересылает его. Это один из примеров black hole.
Чтобы предотвратить возникновение любой из этих ситуаций, протоколы вектора расстояния не будут объявлять маршруты, которых сам протокол не имеет в локальной таблице маршрутизации. Если маршрут протокола вектора расстояния будет перезаписан по какой-либо причине, он остановит объявление о доступности пункта назначения.