Работа с числами в python

Функция any()

Функция возвращает значение True, если хотя бы один элемент во всём итерируемом типе истинный. Например:

item_list = 
print (any(item_list))

Функция вызывается с аргументом итерируемого типа . После запуска приведенного выше кода получим:

Здесь функция вернула True, так как по крайней мере один элемент в списке равен True.

Непустые строковые значения также всегда являются истинными.

item_list = 
print (any(item_list))

Результат:

Если список полностью пуст, всегда будет возвращать False:

item_list = []
print (any(item_list))

Код выведет:

Если в итерируемом объекте содержатся пустые строки, при вызове их значение расценивается как False.

item_list = 
print (any(item_list))

Так как обе пустые строки считаются False, вы получите следующий результат:

В элемент со значением 0 также будет считаться False:

item_list = 
print (any(item_list))

Результат:

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

Для передачи напрямую в функцию значения True/False, используем синтаксис списковых включений:

item_list = 
print (any(item > 2 for item in item_list))

В функции этот синтаксис применяется в момент, когда цикл проходится по . Каждое число в сравнивается с 2: больше 2 — True, иначе — False. Затем функция проверяет истинность каждого элемента. После запуска данного кода вы получите следующий результат:

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

item_list = 
print (any(item > 2 for item in item_list))
print ()

Результат:

Наличие хотя бы одного «истинного» элемента приводит к тому, что возвращает True.

Использование оператора != в блоках if-else

В приведенных выше примерах мы использовали оператор . На этот раз давайте воспользуемся оператором .

Напишем следующий код. Прежде всего, инициализируем переменную целочисленного типа , значение которой равно 10. После этого мы запускаем условие .

Условие использует оператор неравенства для сравнения переменной со значением 20. Если условие удовлетворяется, мы получим результат «Values ​​are not Equal». В противном случае программа перейдет к и выведет «Values are Equal».

a = 10
if a is not 20:
    print('Values are not Equal')
else:
    print('Values are Equal')

Запустим наш код. Вы можете видеть, что условие в операторе выполнено и в выводе мы получаем сообщение о том, что значения не равны – «Values are not Equal».

Давайте взглянем на другой пример. Объявим строку , имеющую значение . Если наша равна , то нам выведется на экран . Если же условие оператора не выполняется, программа переходит на следующую строчку кода – оператор . В таком случае мы получим сообщение .

str = 'Aqsa'
if str == 'Aqsa':
    print('Hy Aqsa')
elif str != 'Aqsa':
    print('Bye')

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

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

str = 'Yasin'
if str == 'Aqsa':
    print('Hy Aqsa')
elif str != 'Aqsa':
    print('Bye')

Запустив код теперь, мы получим результат работы print() в блоке – .

Перегрузка

Python поддерживает перегрузку операторов. Существуют определенные методы перегрузки оператора для объекта.

Посмотрим, что произойдет, если оператор не поддерживается для класса.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Вывод:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/operators_examples.py", line 9, in <module>
    d3 = d1 + d2
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

Если нам нужно поддерживать оператор + для класса Data, мы должны определить для него метод __add __(). Посмотрим обновленный код и результат.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __add__(self, other):
        return Data(self.id + other.id)


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Выход: 30

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

Функции и реализация

Различные арифметические операции могут выполняться с десятичными или числовыми данными для улучшения результата.

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

Синтаксис:

import decimal
variable = decimal.Decimal(decimal-number)

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

Синтаксис:

decimal.getcontext().prec = precision value

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

Функции генерации псевдослучайных чисел

Во многих
программах требуется генерировать случайные значения и в NumPy для этого
имеется специальный модуль random с богатым функционалом. Конечно,
совершенно случайные величины получить невозможно, поэтому придумываются
различные «хитрости» для их генерации и правильнее их называть –
псевдослучанйыми числами.

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

np.random.rand() # вещественное случайное число от 0 до 1

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

np.random.rand(5) # array()

Для получения
двумерных массивов – два аргумента:

np.random.rand(2, 3) # массив 2x3

И так далее.
Можно создавать любые многомерные массивы из случайных величин.

Если требуется
генерировать целые случайные значения, то используется функция randint():

np.random.randint(10) # генерация целых чисел в диапазоне [0; 10)
np.random.randint(5, 10)# генерация в диапазоне [5; 10)

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

np.random.randint(5, size=4) # array()
np.random.randint(1, 10, size=(2, 5)) # матрица 2x5

Функции rand() и randint() генерируют
числа с равномерным законом распределения. Если нужно получать значения с
другими широко известными распределениями, то используются функции:

np.random.randn() # нормальная СВ с нулевым средним и единичной дисперсией
np.random.randn(5) # массив из пяти нормальных СВ
np.random.randn(2, 3) # матрица 2x3 из нормальных СВ
np.random.pareto(2.0, size=3) # распределение Паретто с параметром 2,0
np.random.beta(0.1, 0.3, size=(3, 3)) # бета-распределение с параметрами 0,1 и 0,3

Существуют и
другие функции для генерации самых разных распределений. Документацию по ним
можно посмотреть на официальном сайте пакета NumPy:

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

np.random.seed(13) # начальное значение генератора случайных чисел

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

np.random.randint(10, size=10) # array()

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

np.random.randint(10, size=10) # array()

Но, установив
зерно снова в значение, например, 13:

np.random.seed(13)

числа начнут
повторяться:

np.random.randint(10, size=10) # array()
np.random.randint(10, size=10) # array()

Загрузка модуля в код Python

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

1. Оператор импорта
2. Оператор from-import

Оператор импорта

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

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

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

import module1,module2,........ module n

Следовательно, если нам нужно вызвать функцию displayMsg(), определенную в файле file.py, мы должны импортировать этот файл как модуль в наш модуль, как показано в примере ниже.

Пример:

import file;
name = input("Enter the name?")
file.displayMsg(name)

Выход:

Enter the name?John
Hi John

Оператор from-import

Вместо того, чтобы импортировать весь модуль, в python имеется возможность импортировать только определенные атрибутов модуля. Это можно сделать с помощью from-import оператора. Синтаксис для использования оператора from-import приведен ниже.

from <module-name> import <name 1>, <name 2>..,<name n>   

Рассмотрим следующий модуль, называемый calculation, который содержит три функции: суммирование, умножение и деление.

calculation.py:

#place the code in the calculation.py 
def summation(a,b):
 return a+b
def multiplication(a,b):
 return a*b;
def divide(a,b):
 return a/b;

Main.py:

from calculation import summation  
#it will import only the summation() from calculation.py
a = int(input("Enter the first number"))
b = int(input("Enter the second number"))
print("Sum = ",summation(a,b)) #we do not need to specify the module name while accessing summation()

Выход:

Enter the first number10
Enter the second number20
Sum =  30

Оператор from … import всегда лучше использовать, если мы заранее знаем атрибуты, которые нужно импортировать из модуля. Это не позволяет нашему коду быть тяжелее. Мы также можем импортировать все атрибуты из модуля, используя *.

Рассмотрим следующий синтаксис.

from <module> import *  

Модули

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

Вы можете использовать любой питоновский файл как модуль в другом файле, выполнив в нем команду . Команда в Python обладает
следующим синтаксисом:

import math
# Используем функцию sqrt из модуля math
print (math.sqrt(9))
# Печатаем значение переменной pi, определенной в math
print (math.pi)

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

Команда позволяет вам импортировать не весь модуль целиком, а только определенное его содержимое. Например:

# Импортируем из модуля math функцию sqrt
from math import sqrt
# Выводим результат выполнения функции sqrt.
# Обратите внимание, что нам больше незачем указывать имя модуля
print (sqrt(144))
# Но мы уже не можем получить из модуля то, что не импортировали
print (pi) # Выдаст ошибку

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

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

from math import *
 
# Теперь у нас есть доступ ко всем функция и переменным, определенным в модуле math
 
print (sqrt(121))
print (pi)
print (e)

Однако это конструкцию следует использовать с осторожностью, поскольку при импортировании нескольких модулей можно запутаться в своем собственном коде

3 Логарифмические функции

Модуль предоставляет нам следующие функции для вычисления логарифмических значений чисел с десятичной запятой:

• decimal.ln();
• decimal.log10().

Функция возвращает значение натурального десятичного числа, как показано ниже.

decimal.Decimal(decimal-number).ln()

Функция decimal.log10() используется для вычисления значения журнала по основанию 10 переданного ей десятичного числа.

decimal.Decimal(decimal-number).log10()

Пример:

import decimal as d

d.getcontext().prec = 2

val = d.Decimal(122.20)

log = val.ln()
print("Natural log value of the decimal number: ",log)

log_10 = val.log10()
print("Log value with base 10 of the decimal number: ",log_10)

Выход:

Natural log value of the decimal number:  4.8
Log value with base 10 of the decimal number:  2.1

Функции математической статистики

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

Рассмотрим
работу этих функций. Предположим, имеются следующие векторы:

x = np.array(1, 4, 3, 7, 10, 8, 14, 21, 20, 23)
y = np.array(4, 1, 6, 9, 13, 11, 16, 19, 15, 22)

Эти числа будем
воспринимать как реализации случайных величин X и Y. Тогда, для
вычисления медианы СВX, можно воспользоваться функцией:

np.median(x) # 9.0

Для расчета
дисперсии и СКО, функциями:

np.var(x) # дисперсия СВX на основе реализации x
np.std(y) # СКО СВY на основе реализации y

Далее, чтобы
рассчитать коэффициент корреляции Пирсона, объединим массивыx и y построчно:

XY = np.vstack(x, y) # матрица 2x10

и выполним
функцию:

np.corrcoef(XY)

Результатом
будет матрица 2×2:

array(,

      
])

Как ее следует
интерпретировать? В действительности, это автоковариационная матрица вектора СВ:

(В этой формуле
полагается, что СВX и Y центрированы, то есть имеют нулевое
математическое ожидание).

Если нужно
вычислить не нормированное МО, то есть, автоковариационную матрицу, то следует
воспользоваться функцией:

np.cov(XY) # ковариационная матрица размерностью 2x2

Наконец, для
вычисления взаимной корреляции между двумя векторамиx и y, используется
функция:

np.correlate(x, y) # array()

Более детальную
информацию по этим статистическим функциям можно найти в официальной
документации пакета NumPy:

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

Видео по теме

#1. Пакет numpy — установка и первое знакомство | NumPy уроки

#2. Основные типы данных. Создание массивов функцией array() | NumPy уроки

#3. Функции автозаполнения, создания матриц и числовых диапазонов | NumPy уроки

#4. Свойства и представления массивов, создание их копий | NumPy уроки

#5. Изменение формы массивов, добавление и удаление осей | NumPy уроки

#6. Объединение и разделение массивов | NumPy уроки

#7. Индексация, срезы, итерирование массивов | NumPy уроки

#8. Базовые математические операции над массивами | NumPy уроки

#9. Булевы операции и функции, значения inf и nan | NumPy уроки

#10. Базовые математические функции | NumPy уроки

#11. Произведение матриц и векторов, элементы линейной алгебры | NumPy уроки

#12. Множества (unique) и операции над ними | NumPy уроки

#13. Транслирование массивов | NumPy уроки

Показатели и логарифмы

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

Функция exp()

Математическая библиотека в Python поставляется с функцией exp(), которую мы можем использовать для вычисления степени e. Например, e x , что означает экспоненту от x. Значение e составляет 2,718281828459045.

Метод можно использовать со следующим синтаксисом:

math.exp(x)

Параметр x может быть положительным или отрицательным числом. Если x не является числом, метод вернет ошибку. Продемонстрируем использование этого метода на примере:

import math

# Initializing values
an_int = 6
a_neg_int = -8
a_float = 2.00

# Pass the values to exp() method and print
print(math.exp(an_int))
print(math.exp(a_neg_int))
print(math.exp(a_float))

Вывод:

403.4287934927351
0.00033546262790251185
7.38905609893065

Мы объявили три переменные и присвоили им значения с разными числовыми типами данных. Затем мы передали их методу exp() для вычисления их показателей.

Мы также можем применить этот метод к встроенным константам, как показано ниже:

import math

print(math.exp(math.e))
print(math.exp(math.pi))

Вывод:

15.154262241479262
23.140692632779267

Если вы передадите методу нечисловое значение, он выдаст ошибку, как показано здесь:

import math

print(math.exp("20"))

Вывод:

Traceback (most recent call last):
  File "C:/Users/admin/mathe.py", line 3, in <module>
    print (math.exp("20"))
TypeError: a float is required

Ошибка TypeError была сгенерирована, как показано в приведенных выше выходных данных.

Функция log()

Эта функция возвращает логарифм указанного числа. Натуральный логарифм вычисляется по основанию e. Следующий пример демонстрирует использование этой функции:

import math

print("math.log(10.43):", math.log(10.43))
print("math.log(20):", math.log(20))
print("math.log(math.pi):", math.log(math.pi))

В приведенном выше скрипте мы передали методу числовые значения с разными типами данных. Мы также вычислили натуральный логарифм константы пи. Результат выглядит так:

Вывод:

math.log(10.43): 2.344686269012681
math.log(20): 2.995732273553991
math.log(math.pi): 1.1447298858494002

Функция log10()

Этот метод возвращает десятичный логарифм указанного числа. Например:

import math

# Returns the log10 of 50
print("The log10 of 50 is:", math.log10(50))

Вывод:

The log10 of 50 is: 1.6989700043360187

Функция log2()

Эта функция вычисляет логарифм числа по основанию 2. Например:

import math

# Returns the log2 of 16
print("The log2 of 16 is:", math.log2(16))

Вывод:

The log2 of 16 is: 4.0

Функция log (x, y)

Эта функция возвращает логарифм x, где y является основанием. Например:

import math

# Returns the log of 3,4
print("The log 3 with base 4 is:", math.log(3, 4))

Вывод:

The log 3 with base 4 is: 0.6309297535714574

Функция log1p (x)

Эта функция вычисляет логарифм (1 + x), как показано здесь:

import math

print("Logarithm(1+x) value of 10 is:", math.log1p(10))

Вывод:

Logarithm(1+x) value of 10 is: 2.3978952727983707

Арифметические функции в Python

Арифметические функции используются для представления чисел в различных формах и осуществления над ними математических операций. Далее представлен перечень самых популярных арифметических функций:

• : округление определенного числа вверх;
• : возвращает модуль (абсолютное значение) указанного числа;
• : округление определенного числа вниз;
• : получение наибольшего общего делителя чисел и ;
• : возвращает сумму всех элементов итерируемого объекта;
• : возвращает (e^x)-1;
• : когда значение слишком мало, вычисление может привести к значительной потери в точности. может вернуть вывод с полной точностью.

В следующем примере показано использование перечисленных выше функций:

Python

import math

num = -4.28
a = 14
b = 8

num_list =
x = 1e-4 # Малое значение x

print(‘Число:’, num)
print(‘Округление числа вниз:’, math.floor(num))
print(‘Округление числа вверх:’, math.ceil(num))
print(‘Модуль числа:’, math.fabs(num))
print(‘Наибольший общий делитель a и b: ‘ + str(math.gcd(a, b)))
print(‘Сумма элементов списка: ‘ + str(math.fsum(num_list)))
print(‘e^x (при использовании функции exp()) равно:’, math.exp(x)-1)
print(‘e^x (при использовании функции expml()) равно:’, math.expm1(x))

Вывод

Python

Число: -4.28
Округление числа вниз: -5
Округление числа вверх: -4
Модуль числа: 4.28
Наибольший общий делитель a и b: 2
Сумма элементов списка: 16.029999999999998
e^x (при использовании функции exp()) равно: 0.0001000050001667141
e^x (при использовании функции expml()) равно: 0.00010000500016667084

К числу других математических функций относятся:

• : принимает два вещественных аргумента, возводит первый аргумент в степень, значением которой является второй аргумент, после чего возвращает результат. К примеру, эквивалентно выражению ;
• : возвращает квадратный корень определенного числа.

Примеры данных методов представлены ниже:

Возведение в степень

Python

math.pow(3, 4)

Вывод

Shell

81.0

Квадратный корень

Python

math.sqrt(81)

Вывод

Shell

9.0

Функции sum, mean, min и max

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

a = np.array( 1,  2,  3, 10, 20, 30)

Вычислим сумму,
среднее значение и найдем максимальное и минимальное значения:

a.sum()    # 66
a.mean()  # 11.0
a.max()    # 30
a.min()    # 1

Как видите, все
достаточно просто. Тот же самый результат будет получен и при использовании
многомерных массивов. Например:

a.resize(3, 2)
a.sum()  # 66

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

a.sum(axis=)  # array()
a.sum(axis=1) # array()

Точно также
работают и остальные три функции, например:

a.max(axis=)  # array()
a.min(axis=1)  # array()

Функция sqrt() — квадратный корень

Функция sqrt() вычисляет и возвращает значение квадратного корня из переданного десятичного числа.

Синтаксис:

decimal.Decimal(decimal-number).sqrt()

Пример:

import decimal as d

d.getcontext().prec = 3

val = d.Decimal(122.20)
sqrt = val.sqrt()
print("Decimal Number: ",val)
print("Square root of the decimal number: ",sqrt)

Выход:

Decimal Number:  122.2000000000000028421709430404007434844970703125
Square root of the decimal number:  11.1

Снова обратите внимание, как объявленное значение содержит полное десятичное число, в то время как вычисленное значение соответствует нашему набору точности из 3 цифр

Максимальные и минимальные

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

• Функция min(): возвращает минимум двух десятичных значений.
• Функция max(): возвращает максимальное из двух десятичных значений.

#Syntax for min() function-
decimal1.min(decimal2)

#Syntax for max() function-
decimal1.max(decimal2)

Пример:

import decimal as d

valx = d.Decimal(122.20)
valy = d.Decimal(123.01)

print("Value 1: ",valx)
print("Value 2: ",valy)

min_val = valx.min(valy)
print("The minimum of the two values: ",min_val)

max_val = valx.max(valy)
print("The maximum of the two values: ",max_val)

Выход:

Value 1:  122.2000000000000028421709430404007434844970703125
Value 2:  123.0100000000000051159076974727213382720947265625
The minimum of the two values:  122.2000000000000028421709430
The maximum of the two values:  123.0100000000000051159076975

Целые числа (int)

В Python любое число, состоящее из десятичных цифр без префикса, интерпретируется как десятичное число типа

Целые числа в Python представлены только одним типом – PyLongObject, реализация которого лежит в longobject.c, а сама структура выглядит так:

Любое целое число состоит из массива цифр переменной длины, поэтому в Python 3 в переменную типа может быть записано число неограниченной длины. Единственное ограничение длины – это размер оперативной памяти.

Целые числа могут записываться не только как десятичные, но и как двоичные, восьмеричные или шестнадцатеричные. Для этого перед числом нужно написать символы:

• 0b (0B) – для двоичного представления;
• 0o (0O) – для восьмеричного представления;
• 0x (0X) – для шестнадцатеричного представления.

Комплексные числа в Python (complex)

Также в Python встроены комплексные числа:

>>>
>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x  y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError unorderable types complex() > complex()
>>> print(x == y)  # Однако можно проверить их на равенство
False
>>> abs(3 + 4j)  # Модуль 
5.0
>>> pow(3 + 4j, 2)  # Возведение в степень, получение значения степени
(-7+24j)

Кроме того, для работы с complex может применяться модуль cmath.

На этом пока что всё. Следите за новостями и не забывайте оставлять свои комментарии!

Использование методов Writelines и Readlines

Как упоминалось в начале этой статьи, Python также содержит два метода Writelines() и readlines() для записи и чтения нескольких строк за один шаг соответственно. Чтобы записать весь список в файл на диске, код Python выглядит следующим образом:

# define list of places
places_list = 

with open('listfile.txt', 'w') as filehandle:
    filehandle.writelines("%s\n" % place for place in places_list)

Чтобы прочитать весь список из файла на диске, код Python выглядит следующим образом:

# define empty list
places = []

# open file and read the content in a list
with open('listfile.txt', 'r') as filehandle:
    filecontents = filehandle.readlines()

    for line in filecontents:
        # remove linebreak which is the last character of the string
        current_place = line

        # add item to the list
        places.append(current_place)

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

# define empty list
places = []

# open file and read the content in a list
with open('listfile.txt', 'r') as filehandle:
    places = 

После открытия файла listfile.txt в строке 5, восстановление списка происходит полностью в строке 6. Во-первых, содержимое файла считывается с помощью readlines(). Во-вторых, в цикле for из каждой строки удаляется символ переноса строки с помощью метода rstrip(). В-третьих, строка добавляется в список мест, как новый элемент списка. По сравнению с приведенным выше листингом код намного компактнее, но может быть более трудным для чтения для начинающих программистов Python.

Математические операции

Над множествами можно выполнять различные математические операции, такие как, пересечение, объединение, разность, симметричная разность.

Рассмотрим ниже операции над двумя множествами.

A = {1,2,3,4,5}

B = {4,5,6,7,8}

Объединение множеств

Объединение можно выполнить с помощью оператора | , и ту же самую операцию можно выполнить с помощью метода union().

A = {1,2,3,4,5}

B = {4,5,6,7,8}

print(A | B)

A.union(B)

print(A)

Результат:

{1,2,3,4,5,6,7,8}

{1,2,3,4,5,6,7,8}

Найти пересечение множеств

Пересечение двух множеств  — это поиск общих элементов. Найти пересечение можно с помощью оператора &, или с помощью метода intersection().

A = {1,2,3,4,5}

B = {4,5,6,7,8}

print(A & B)

A.intersection(B)

Результат:

{4,5}

{4,5}

Нахождение разницы между множествами

Разность множеств — это элементы А не содержащиеся в элементах множества В. Для этого можно воспользоваться оператором —, или методом difference().

A.difference(B)

B -A

Результат:

{1,2,3}

{8,6,7}

От: admin

Эта тема закрыта для публикации ответов.