функции библиотеки и примеры на Python 3
Как и многие другие языки программирования, Python позволяет работать с генераторами случайных значений. С их помощью можно оперативно создавать последовательности из различных чисел или символов, предугадать которые невозможно. Для этой цели в Python применяется встроенная библиотека с множеством методов для управляемой генерации.
Что такое случайные числа?
Случайные числа представляют собой произвольные данные, которые были получены в результате автоматической генерации компьютерной программой. Подобная информация используется во многих видах программного обеспечения, где необходимо иметь дело с непредсказуемыми величинами. Ярким примером тому являются игровые автоматы либо казино, в которых каждый раз генерируется новая выигрышная комбинация чисел. Также данный подход применяется в криптографических целях для создания надежных паролей.
Стоит заметить, что стандартные средства Python не способны предоставлять в программе истинно случайные значения.
Но есть механизмы, позволяющие получать каждый раз совершенно новые и независимые последовательности чисел. Они имеют существенный недостаток. Существенно снижается быстродействие. Это происходит из-за того, что время получения каждого числа увеличивается в несколько раз.
Так что обычно используется метод генерации псевдослучайных величин с иницилизацией от системных часов.
Реализации случайных чисел в Python
Язык программирования Python содержит в себе несколько разных модулей, применяемых для генерации псевдослучайных величин. Все они, как правило, используют в своих целях текущее системное время, которое установлено на компьютере. Это гарантирует получение разных последовательностей значений при каждом новом обращении к генератору.
Особенности их применения:
- Стандартный модуль random в Python 3 включает множество методов для генерации как целых, так и вещественных чисел, а также последовательностей с определенными параметрами.
- Функция numpy.random используется для заполнения массивов случайными величинами.
- Функция os.urandom предоставляет набор из случайных байтов, что применимо в криптографии.
В модуле random есть класс SystemRandom, внутри реализации которого идет обращение как раз к os.urandom. В этом альтернативном генераторе реализованы те же функции, но их уже можно применять в криптографии.
Наиболее широкое применение получила в Python библиотека random. Поэтому далее мы ее и рассмотрим подробно.
Модуль random
Ниже приведена таблица, где описаны самые главные методы из подключаемого модуля, входящего в состав стандартных библиотек Python.
В таблице приведены названия функций, а также доступный перечень параметров с небольшой характеристикой.
| Метод | Характеристика |
| random() | возвращает число в диапазоне от 0 до 1 |
| seed(a) | настаивает генератор на новую последовательность a |
| randint(a, b) | возвращает целое число в диапазоне от a и b |
| randrange(a, b, c) | возвращает целое число в диапазоне от a до b с шагом c |
| uniform(a, b) | возвращает вещественное число в диапазоне от a и b |
| shuffle(a) | перемешивает значения в списке a |
| choice(a) | возвращает случайный элемент из списка a |
| sample(a, b) | возвращает последовательность длиной b из набора a |
| getstate() | возвращает внутреннее состояние генератора |
| setstate(a) | восстанавливает внутреннее состояние генератора a |
| getrandbits(a) | возвращает a случайно сгенерированных бит |
| triangular(a, b, c) | возвращает вещественное число от a до b с распределением c |
Здесь хотелось бы описать функцию seed.
Она как раз и применяется для задания инициализирующего числа псевдо случайной последовательности. При вызове seed без параметра, берется значение системного таймера. Эта функция вызывается в конструкторе класса Random.
В примерах мы рассмотрим, как применяются основные функции. А так же в конце рассмотрим как используется SystemRandom.
Примеры
Чтобы воспользоваться возможностями генерации случайных чисел в Python 3, следует произвести импорт библиотеки random, вынеся ее в начало исполняемого файла при помощи ключевого слова import.
Вещественные числа
В модуле есть одноименная функция random. В Python она используется чаще, чем другие функции этого модуля. Функция возвращает вещественное число в промежутке от 0 до 1. В следующем примере демонстрируется создание трех разных переменных a, b и c.
import random a = random.random() b = random.random() print(a) print(b) 0.547933286519 0.456436031781
Целые числа
Для получения случайных целых чисел в определенном диапазоне используется функция randint, принимающая два аргумента: минимальное и максимальное значение.
Программа, показанная ниже отображает генерацию трех разных значений в промежутке от 0 до 9.
import random a = random.randint(0, 9) b = random.randint(0, 9) print(a) print(b) 4 7
Диапазоны целых
Метод randrange позволяет генерировать целочисленные значения, благодаря работе с тремя параметрами: минимальная и максимальная величина, а также длина шага. Вызвав функцию с одним аргументом, начальная граница получит значение 0, а интервал станет равен 1. Для двух аргументов автоматически инициализируется только длина шага. Работа данного метода с трема разными наборами параметров показана в следующем примере.
import random a = random.randrange(10) b = random.randrange(2, 10) c = random.randrange(2, 10, 2) print(a) print(b) print(c) 9 5 2
Диапазоны вещественных
Сгенерировать вещественное число поможет метод под названием uniform. Он принимает всего два аргумента, обозначающих минимальное и максимальное значения.
import random a = random.uniform(0, 10) b = random.uniform(0, 10) print(a) print(b) 4.85687375091 3.66695202551
Использование в генераторах
Возможности генерации псевдослучайных чисел можно использовать и для создания последовательностей. В следующем фрагменте кода создается набор чисел при помощи генератора списка со случайным наполнением и длиной. Как можно заметить, в данном примере функция randint вызывается дважды: для каждого элемента и размера списка.
import random a = [random.randint(0, 9) for i in range(random.randint(0, 9))] print(a) [4, 1, 8, 6, 6, 9, 7]
Перемешивание
Метод shuffle дает возможность перемешать содержимое уже созданного списка. Таким образом, все его элементы будут находиться в абсолютно случайном порядке. Пример, где отображается работа этой функции со списком a из 10 значений, располагается дальше.
import random a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] random.shuffle(a) print(a) [3, 9, 0, 7, 6, 2, 5, 1, 8, 4]
Случайный элемент списка
При помощи функции choice можно извлечь случайный элемент из существующего набора данных. В следующем примере переменная b получает некое целое число из списка a.
import random a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] b = random.choice(a) print(b) 7
Несколько элементов списка
Извлечь из последовательности данных можно не только один элемент, но и целый набор значений. Функция sample позволит получить абсолютно новый список чисел из случайных компонентов уже существующего списка. В качестве первого аргумента необходимо ввести исходную последовательность, а на месте второго указать желаемую длину нового массива.
import random a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a = random.sample(a, 5) print(a) [8, 0, 9, 4, 6]
Генерация букв
Возможности стандартной библиотеки позволяют генерировать не только числа, но и буквы.
В следующем примере показывается инициализация трех разных переменных случайными символами латиницы. Для этого необходимо произвести импортирование модуля string, а затем воспользоваться списком letters, который включает все буквы английского алфавита.
import random import string a = random.choice(string.letters) b = random.choice(string.letters) c = random.choice(string.letters) print(a) print(b) print(c) J i L
Как можно заметить, отображаются буквы в разном регистре. Для того чтобы преобразовать их к общему виду, рекомендуется вызвать стандартные строковые методы upper или lower.
SystemRandom
Как уже говорилось ранее, SystemRandom основана на os.urandom. Она выдает так же псевдослучайные данные, но они зависят дополнительно и от операционной системы. Результаты используются в криптографии. Есть недостаток – то что функции SystemRandom отрабатывают в несколько раз дольше. Рассмотрим пример использования:
import random sr = random.SystemRandom() a = sr.random() b = sr.randint(0, 9) c = sr.randrange(2, 10, 2) print(a) print(b) print(c) 0.36012464614815465 2 8
SystemRandom()
a = sr.random()
b = sr.randint(0, 9)
c = sr.randrange(2, 10, 2)
print(a)
print(b)
print(c)
0.36012464614815465
2
8Заключение
Таким образом, язык программирования Python содержит массу встроенных методов для генерации и обработки случайных значений. Пользоваться ими можно при помощи разных библиотек, входящих в стандартный набор инструментов платформы. Благодаря данным функциям можно задавать различные условия, а также ограничения для своих генераторов.
Функции и методы модуля math в python ~ PythonRu
Эта статья посвящена математическим функциям в Python. Для выполнения математических операций необходим модуль math.
Что такое модуль?
В C и C++ есть заголовочные файлы, в которых хранятся функции, переменные классов и так далее. При включении заголовочных файлов в код появляется возможность не писать лишние строки и не использовать одинаковые функции по несколько раз.
Аналогично в Python для этого есть модули, которые включают функции, классы, переменные и скомпилированный код. Модуль содержит группу связанных функций, классов и переменных.
Есть три типа модулей в Python:
- Модули, написанные на Python (
.py). - Модули, написанные на
Cи загружаемые динамически (.dll,.pyd,.so,.slи так далее). - Модули, написанные на
C, но связанные с интерпретатором.import sys print(sys.builtin_module_names)('_ast', '_bisect', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_csv', '_datetime', '_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', '_sha256', '_sha512', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'math', 'mmap', 'msvcrt', 'nt', 'parser', 'signal', 'sys', 'time', 'winreg', 'xxsubtype', 'zipimport', 'zlib').
Для получения списка модулей, написанных на C, но связанных с Python, можно использовать следующий код.
Как видно из списка выше, модуль math написан на C, но связан с интерпретатором. Он содержит математические функции и переменные, о которых дальше и пойдет речь.
Функции представления чисел
ceil() и floor() — целая часть числа
Сeil() и floor() — функции общего назначения. Функция ceil округляет число до ближайшего целого в большую сторону. Функция floor убирает цифры десятичных знаков. Обе принимают десятичное число в качестве аргумента и возвращают целое число.
Пример:
import math
number=8.10
print("Верхний предел 8.10 это:",math.ceil(number))
print("Нижний предел 8.10 это:",math.floor(number))
Вывод:
Верхний предел 8. 10 это: 9
Нижний предел 8.10 это: 8
10 это: 9
Нижний предел 8.10 это: 8
Функция fabs() — абсолютное значение
Функция fabs используется для вычисления абсолютного значения числа. Если число содержит любой отрицательный знак (-), то функция убирает его и возвращает положительное дробное число.
Пример:
import math
number = -8.10
print(math.fabs(number))
Вывод:
8.1
factorial() — функция факториала
Эта функция принимает положительное целое число и выводит его факториал.
Пример:
import math
number = 5
print("факториала числа", math.factorial(number))
Вывод:
факториала числа 120
Примечание: при попытке использовать отрицательное число, возвращается ошибка значения (Value Error).
Пример:
import math
number = -5
print("факториала числа", math.factorial(number))
Вывод:
ValueError: factorial() not defined for negative values
Функция fmod() — остаток от деления
Функция fmod(x,y) возвращает x % y. Разница в том, что выражение x % y работает только с целыми числами, а эту функцию можно использовать и для чисел с плавающей точкой.
Пример:
import math
print(math.fmod(5,2))
print(math.fmod(-5,2))
print(math.fmod(-5.2,2))
print(math.fmod(5.2,2))
Вывод:
1.0
-1.0
-1.2000000000000002
1.2000000000000002
Функция frexp()
Эта функция возвращает мантиссу и показатель степени в виде пары (m,n) любого числа x, решая следующее уравнение.
x.
Пример:
import math
print("e в степени 5 ", math.exp(5))
print("e в степени 2.5", math.exp(2.5))
Вывод:
e в степени 5 148.4131591025766
e в степени 2.5 12.182493960703473
Функция expm1()
Эта функция работает так же, как и exp, но возвращает exp(x)-1. Здесь, expm1 значит exm-m-1, то есть, exp-minus-1.
Пример:
import math
print(math.exp(5)-1)
print(math.expm1(5))
Вывод:
147.4131591025766
147.4131591025766
Функция log() — логарифм числа
Функция log(x[,base]) находит логарифм числа x по основанию e (по умолчанию). base— параметр опциональный. Если нужно вычислить логарифм с определенным основанием, его нужно указать.
Пример:
import math
print(math.log(2))
print(math.log(64,2))
Вывод:
0.6931471805599453
6.0
Функция log1p()
Эта функция похожа на функцию логарифма, но добавляет 1 к x. log1p значит log-1-p, то есть, log-1-plus.
Пример:
import math
print(math.log1p(2))
Вывод:
1.0986122886681098
Функция log10()
Вычисляет логарифм по основанию 10.
Пример:
import math
print(math.log10(1000))
Вывод:
3.0
Функция pow() — степень числа
Используется для нахождение степени числа. Синтаксис функции pow(Base, Power). Она принимает два аргумента: основание и степень.
Пример:
import math
print(math.pow(5,4))
Вывод:
625.0
Функция sqrt() — квадратный корень числа
Эта функция используется для нахождения квадратного корня числа. Она принимает число в качестве аргумента и находит его квадратный корень.
Пример:
import math
print(math.sqrt(256))
Вывод:
16.0
Тригонометрические функции
В Python есть следующие тригонометрические функции.
| Функция | Значение |
|---|---|
sin | принимает радиан и возвращает его синус |
cos | принимает радиан и возвращает его косинус |
tan | принимает радиан и возвращает его тангенс |
asin | принимает один параметр и возвращает арксинус (обратный синус) |
acos | принимает один параметр и возвращает арккосинус (обратный косинус) |
atan | принимает один параметр и возвращает арктангенс (обратный тангенс) |
sinh | принимает один параметр и возвращает гиперболический синус |
cosh | принимает один параметр и возвращает гиперболический косинус |
tanh | принимает один параметр и возвращает гиперболический тангенс |
asinh | принимает один параметр и возвращает обратный гиперболический синус |
acosh | принимает один параметр и возвращает обратный гиперболический косинус |
atanh | принимает один параметр и возвращает обратный гиперболический тангенс |
Пример:
import math
print("синус PI/2 :", math. sin(math.pi/2))
print("косинус 0 :", math.cos(0))
print("тангенс PI/4 :", math.tan(math.pi/4))
print()
print("арксинус 0 :", math.acos(0))
print("арккосинус 1 :", math.acos(1))
print("арктангенс 0.5 :", math.atan(0.5))
print()
print("гиперболический синус 1 :", math.sinh(1))
print("гиперболический косинус 0 :", math.cos(0))
print("гиперболический тангенс 1 :", math.tan(1))
print()
print("обратный гиперболический синус 1 :", math.acosh(1))
print("обратный гиперболический косинус 1 :", math.acosh(1))
print("обратный гиперболический тангенс 0.5 :", math.atanh(0.5))
sin(math.pi/2))
print("косинус 0 :", math.cos(0))
print("тангенс PI/4 :", math.tan(math.pi/4))
print()
print("арксинус 0 :", math.acos(0))
print("арккосинус 1 :", math.acos(1))
print("арктангенс 0.5 :", math.atan(0.5))
print()
print("гиперболический синус 1 :", math.sinh(1))
print("гиперболический косинус 0 :", math.cos(0))
print("гиперболический тангенс 1 :", math.tan(1))
print()
print("обратный гиперболический синус 1 :", math.acosh(1))
print("обратный гиперболический косинус 1 :", math.acosh(1))
print("обратный гиперболический тангенс 0.5 :", math.atanh(0.5))
Вывод:
синус PI/2 : 1.0
косинус 0 : 1.0
тангенс PI/4 : 0.9999999999999999
арксинус 0 : 1.5707963267948966
арккосинус 1 : 0.0
арктангенс 0.5 : 0.4636476090008061
гиперболический синус 1 : 1. 1752011936438014
гиперболический косинус 0 : 1.0
гиперболический тангенс 1 : 1.5574077246549023
обратный гиперболический синус 1 : 0.0
обратный гиперболический косинус 1 : 0.0
обратный гиперболический тангенс 0.5 : 0.5493061443340549
1752011936438014
гиперболический косинус 0 : 1.0
гиперболический тангенс 1 : 1.5574077246549023
обратный гиперболический синус 1 : 0.0
обратный гиперболический косинус 1 : 0.0
обратный гиперболический тангенс 0.5 : 0.5493061443340549
Функция преобразования углов
Эти функции преобразуют угол. В математике углы можно записывать двумя способами: угол и радиан. Есть две функции в Python, которые конвертируют градусы в радиан и обратно.
degrees(): конвертирует радиан в градусы;radians(): конвертирует градус в радианы;
Пример:
import math
print(math.degrees(1.57))
print(math.radians(90))
Вывод:
89.95437383553924
1.5707963267948966
Математические константы
В Python есть две математические константы: pi и e.
pi: это математическая константа со значением3. 1416..e: это математическая константа со значением2.7183..
1416..Пример:
import math
print("значение PI", math.pi)
print("значение e", math.e)
Вывод:
значение PI 3.141592653589793
значение e 2.718281828459045
Числа в Python — int, float и операции с числами ~ PythonRu
В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.
В Python достаточно просто работать с числами, ведь сам язык является простым и одновременно мощным. Он поддерживает всего три числовых типа:
int(целые числа)float(числа с плавающей точкой)complex(комплексные числа)
Хотя int и float присутствуют в большинстве других языков программирования, наличие типа комплексных чисел — уникальная особенность Python.
Теперь рассмотрим в деталях каждый из типов.
Целые и числа с плавающей точкой в Python
В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.
Создание int и float чисел
Для создания целого числа нужно присвоить соответствующее значение переменной. Возьмем в качестве примера следующий код:
var1 = 25Здесь мы присваиваем значение 25 переменной var1. Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.
var1 = "25"
# или
var1 = '25'
В этих случаях данные представлены как строки, поэтому не могут быть обработаны так, как требуется. Для создания числа с плавающей точкой, типа float, нужно аналогичным образом присвоить значение переменной.
var1 = 0.001Здесь также не стоит использовать кавычки.
Проверить тип данных переменной можно с помощью встроенной функции type(). Можете проверить результат выполнения, скопировав этот код в свою IDE.
var1 = 1 # создание int
var2 = 1.10 # создание float
var3 = "1.10" # создание строки
print(type(var1))
print(type(var2))
print(type(var3))
Вывод:
<class 'int'>
<class 'float'>
<class 'str'>В Python также можно создавать крупные числа, но в таком случае нельзя использовать запятые.
# создание 1,000,000
var1 = 1,000,000 # неправильно
Если попытаться запустить этот код, то интерпретатор Python вернет ошибку. Для разделения значений целого числа используется нижнее подчеркивание. Вот пример корректного объявления.
# создание 1,000,000
var1 = 1_000_000 # правильно
print(var1)
Значение выведем с помощью функции print:
1000000Арифметические операции над целыми и числами с плавающей точкой
Используем такие арифметические операции, как сложение и вычитание, на числах. Для запуска этого кода откройте оболочку Python, введите python или python3. Терминал должен выглядеть следующим образом:
Сложение
В Python сложение выполняется с помощью оператора +. В терминале Python выполните следующее.
>>> 1+3Результатом будет сумма двух чисел, которая выведется в терминале.
Теперь запустим такой код.
>>> 1.0 + 2
3.0В нем было выполнено сложение целого и числа с плавающей точкой. Можно обратить внимание на то, что результатом также является число с плавающей точкой.
Таким образом сложение двух целых чисел дает целое число, но если хотя бы один из операндов является числом с плавающей точкой, то и результат станет такого же типа.
Вычитание
В Python для операции вычитания используется оператор -. Рассмотрим примеры.
>>> 3 - 1
2
>>> 1 - 5
-4
>>> 3.0 - 4.0
-1.0
>>> 3 - 1.0
2.0Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа.
Умножение
Для умножения в Python применяется оператор *.
>>> 8 * 2
16
>>> 8.0 * 2
16.0
>>> 8.0 * 2.0
16.0Если перемножить два целых числа, то результатом будет целое число.
Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
Деление
В Python деление выполняется с помощью оператора /.
>>> 3 / 1
3.0
>>> 4 / 2
2.0
>>> 3 / 2
1.5В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError. Вот пример такого поведения.
>>> 1 / 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zeroДеление без остатка
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.
>>> 2 // 1
2
>>> 4 // 3
1
>>> 5 // 2
2Результатом такой операции становится частное.
Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
Остаток от деления
Для получения остатка деления двух чисел используется оператор деления по модулю %.
>>> 5 % 2
1
>>> 4 % 2
0
>>> 3 % 2
1
>>> 5 % 3
2На этих примерах видно, как это работает.
Возведение в степень
Число можно возвести в степень с помощью оператора **.
>>> 3**2
9
>>> 2**4
16
>>> 3**3
27Комплексные числа
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:
# создание двух комплексных чисел
var1 = 2 + 2j
var2 = 3 + 4j
# сложение двух комплексных чисел
sum = var1 + var2
print("Сумма двух комплексных чисел равна: ", sum)
В этом примере были созданы два комплексных числа a+bj.
После этого было выполнено их сложение с помощью оператора +. Результат вывели на экран с помощью функции print().
Сумма двух комплексных чисел равна: (5+6j)Конвертация типов чисел
Конвертация типа — это метод конвертации числа из одного типа в другой. Для этого можно использовать функции float(), int() и complex().
x = 1 # создание целого числа
y = 2.0 # создание числа с плавающей точкой
z = 2+3j # создание комплексного числаa = float(x) # преобразование целого числа в число с плавающей точкой
b = int(x) # преобразование числа с плавающей точкой в целое число
c = complex(x) # преобразование целого числа в комплексное
d = complex(y) # преобразование числа с плавающей точкой в комплексное
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))
Можно увидеть, как числа изменились за счет использования простых встроенных функций Python.
1.0 <class 'float'>
1 <class 'int'>
(1+0j) <class 'complex'>
(2+0j) <class 'complex'>Случайные числа
Случайные числа используются в играх, криптографии и так далее. В Python нативной поддержки случайных чисел нет, но есть встроенный модуль random, который используется для работы с целыми числами. Рассмотрим пример генерации случайных чисел с помощью такого модуля.
import random
print(random.randrange(1, 1000))
Результатом будет новое число от 1 до 1000, у каждого свое.
Встроенные математические функции
В Python есть множество встроенных функций для работы с числами. Вот самые важные из них.
round()
Функция round() используется для округления чисел с плавающей точкой до ближайшего целого. Пр этом тип данных не меняется. Целое число — это также число с плавающей точкой. Пример:
# создание чисел
a = 0. 01
b = 1.45
c = 2.25
d = 3.7
e = 4.5# округление чисел
print(round(a))
print(round(b))
print(round(c))
print(round(d))
print(round(e))
01В выводе можно увидеть, что все числа с плавающей точкой были округлены до ближайшего целого.
0
1
2
4
4abs()
Эта функция используется для генерации абсолютного значения числа. Оно всегда положительное, хотя число можно быть как положительным, так и отрицательным. Пример:
# создание чисел
a = 1.1
b = -1.5
c = 2
d = -3
e = 0# отображение абсолютного значения
print(round(a))
print(round(b))
print(round(c))
print(round(d))
print(round(e))
Вывод:
1.1
1.5
2
3
0pow()
Функция pow() используется для возведения числа в степень. Она повторяет то, что можно сделать и с помощью оператора **.
Функции pow() нужно передать два параметра. Первый — число, которое нужно возвести в степень, а второе — сама степень. Пример:
base = 8
power = 2print(pow(base, power))
Возведем 8 в степень 2. Вывод:
64Библиотека math
В Python есть полноценная библиотека, с помощью которой можно выполнять почти любую математическую операцию — math. Все это есть в стандартной библиотеке, поэтому дополнительные действия выполнять не нужно. В модуле есть кое-какие константы, среди которых PI, e и так далее. Есть и кое-какие математические методы: log(), exp(), sqrt(), тригонометрические функции и так далее.
Выводы
В этом материале вы узнали об основах работы с числами в Python. Это поможет выполнять математические операции при работе с кодом.
чисел — Числовые абстрактные базовые классы — документация Python 3. 9.1
9.1 Исходный код: Lib / numbers.py
Модуль номеров ( PEP 3141 ) определяет иерархию числовых
абстрактные базовые классы, которые постепенно определяют
больше операций. Ни один из типов, определенных в этом модуле, не может быть создан.
- класс
номеров.Номер Корень числовой иерархии.Если вы просто хотите проверить, является ли аргумент x — это число, неважно какого вида, используйте
isinstance (x, Number).
Числовая башня
- класс
номеров.Комплекс Подклассы этого типа описывают комплексные числа и включают операции которые работают на встраиваемом комплексе
типа. Это: преобразования вкомплексныеиbool,реальные,imag,+,-,*,/,абс (),конъюгат (),==и! =. Все
кроме -и! =являются абстрактными.-
реал Аннотация. Извлекает реальную составляющую этого числа.
-
имидж Аннотация. Извлекает мнимую составляющую этого числа.
- абстрактный метод
конъюгат() Аннотация. Возвращает комплексное сопряжение. Например,
(1 + 3j) .conjugate () == (1-3j).
-
Все
кроме - класс
номеров.Реальный К
Комплекс,Реальныйдобавляет операции, которые работают на реальном числа.Короче говоря, это преобразование в
с плавающей запятой,math.trunc (),раунд (),math.floor (),math.ceil (),divmod (),//,%,<,<=,>и> =.Real также предоставляет значения по умолчанию для
complex (),real,imagиконъюгат ().
- класс
номеров.Рациональный Подтипы
Реальныйи добавляетчислительи знаменательс плавающей запятой ().-
числитель Аннотация.
- Знаменатель
Аннотация.
-
- класс
номеров.Интегральный Подтип
Rationalи добавляет преобразование вint. Обеспечивает значения по умолчанию дляfloat (),числительи Знаменатель**и битовые операции:<<,>>,и,^,|,~.
Примечания для разработчиков типов
Разработчики должны быть осторожны, чтобы равные числа были равны и хеш
их к одинаковым значениям. Это может быть незаметно, если есть два разных
расширения действительных чисел. Например, дроби .
реализует hash () следующим образом:
def __hash __ (сам):
если self.denominator == 1:
# Получите правильные числа.
вернуть хеш (self.numerator)
# Дорогой чек, но однозначно правильный.если self == float (self):
вернуть хеш (float (self))
еще:
# Используйте хеш кортежа, чтобы избежать высокой частоты конфликтов на
# простые дроби.
вернуть хеш ((self.numerator, self.denominator))
Добавление дополнительных цифровых ABC
Конечно, есть и другие варианты ABC для чисел, и это
быть плохой иерархией, если она исключает возможность добавления
те. Вы можете добавить MyFoo между Complex и Real с:
Введение в модуль Sys
Следующая глава: Python и оболочкаСистемный модуль
Информация об интерпретаторе Python
Как и все другие модули, модуль sys должен быть импортирован с помощью оператора импорта, т.
е.е.
import sys
Если есть вопросы по оператору импорта, мы рекомендуем вводную главу наш базовый курс по этой теме Модульное программирование и модули
Модуль sys предоставляет информацию о константах, функциях и методах языка Python. переводчик. dir (system) дает сводку доступных констант, функций и методов. Другая возможность - это функция help (). Использование help (sys) предоставляет ценную подробную информацию.
Модуль sys сообщает, например, о максимальной глубине рекурсии
( sys.getrecursionlimit () ) и предоставляет возможность изменить
(sys.setrecursionlimit ())
Также доступен текущий номер версии Python:
>>> import sys >>> sys.version '2.6.5 (r265: 79063, 16 апреля 2010 г., 13:57:41) \ n [GCC 4.4.3]' >>> sys.version_info (2, 6, 5, 'финал', 0) >>>
Аргументы командной строки
Многим скриптам нужен доступ к аргументам, переданным скрипту, когда скрипт был запущен. argv argv (точнее sys. argv ) - список, который
содержит аргументы командной строки, переданные сценарию.
Первый элемент этого списка содержит название самого скрипта. Аргументы
следуйте имени сценария. 
argv Следующий сценарий выполняет итерацию по списку
sys.argv :
#! / usr / bin / python
import sys
# Конечно, этот список легко распечатать:
напечатать sys.argv
# или его можно повторить с помощью цикла for:
для i в диапазоне (len (sys.argv)):
если я == 0:
print "Имя функции:% s"% sys.argv [0]
еще:
напечатайте "% d. аргумент:% s"% (i, sys.argv [i])
Мы сохраняем этот скрипт как arguments.py . Если мы это назовем, то получим следующее
вывод::$ python arguments.py arg1 arg2 ['arguments.py', 'arg1', 'arg2'] Имя функции: arguments.py 1. аргумент: arg1 2. аргумент: arg2 $
Изменение поведения вывода интерактивной оболочки Python
Интерактивный режим Python - одна из вещей, которые делают Python особенным среди прочего.
языки программирования, такие как Perl или Java.Как мы видели в главе
Интерактивный режим нашего вводного урока, этого достаточно
чтобы написать выражение в командной строке и получить значимый результат.
Однако некоторые пользователи могут предпочесть другое поведение вывода. Чтобы изменить способ
интерпретатор печатает интерактивно введенные выражения, вам придется перепривязать sys.displayhook к вызываемому объекту. Мы продемонстрируем это в следующем интерактивном примере сеанса:
>>> import sys >>> х = 42 >>> х 42 >>> import sys >>> def my_display (x): ... распечатка: ", ... напечатать x ... >>> sys.displayhook = my_display >>> х из: 42 >>> >>> напечатайте x 42
Из этого примера видно, что стандартное поведение функции print () не будет изменен.
Стандартные потоки данных
Каждый серьезный пользователь операционной системы UNIX или Linux знает стандартные потоки, т.е. ввод, стандартный вывод и стандартная ошибка.
Они известны как трубы. Они обычно
сокращенно stdin, stdout, stderr.Стандартный ввод (stdin) обычно подключается к клавиатуре, а стандартный ввод ошибка и стандартный вывод поступают в терминал (или окно), в котором вы работаете.
К этим потокам данных можно получить доступ из Python через объекты модуля sys с
те же имена, то есть sys.stdin, sys.stdout и sys.stderr.
>>> import sys >>> для i in (sys.stdin, sys.stdout, sys.stderr): ... печать (я) ... ', режим' w 'в 0x7f3397a2c150> ', режим' w 'в 0x7f3397a2c1e0> >>>В следующем примере показано использование стандартных потоков данных:
>>> import sys
>>> print "Going via stdout"
Переход через стандартный вывод
>>> sys.stdout.write ("Другой способ сделать это! \ n")
Другой способ сделать это!
>>> x = raw_input ("прочитать значение через stdin:")
прочитать значение через stdin: 42
>>> напечатайте x
42
>>> print "введите значение:",; sys.stdin.readline () [: - 1]
введите значение: 42
'42'
>>>
В следующем примере объединены ввод и вывод:import sys в то время как True: # вывод на стандартный вывод: print "Еще одна итерация .Если мы сохраним предыдущий пример в «streams.py» и воспользуемся файлом с именем "number.txt" с числами (по одному в строке) для ввода, мы можем вызвать скрипт из оболочки Bash следующим образом:
.."
пытаться:
# чтение из sys.stdin (остановить Ctrl-D):
number = raw_input ("Введите число:")
кроме EOFError:
печать "\ nciao"
сломать
еще:
число = int (число)
если число == 0:
печать >> sys.stderr, "0 не имеет обратного"
еще:
print "инверсия% d -% f"% (число, 1.0 / число)
$ python streams.py Также возможно перенаправить вывод в файл:$ python streams.py output.txtТеперь в оболочке останется только следующий вывод:0 не имеет обратногопотому что это происходит через поток sterr.Перенаправление
Вряд ли найдется пользователь Linux или Unix Shell, например. Bourne или Bash Shell, которые не использовали перенаправление ввода или вывода. Не будет преувеличением сказать, что полезная работа не возможно без перенаправлений.Стандартный вывод (stdout) может быть перенаправлен, например в файл, чтобы мы могли позже обработайте этот файл другой программой. То же самое возможно и со стандартным потоком ошибок, мы также можем перенаправить его в файл. Мы можем перенаправить как stderr, так и stdout в один файл или в отдельные файлы.
Следующий сценарий не требует пояснений. Но все же вот некоторые пояснения: Первый оператор использует обычный стандартный вывод (stdout), т.е. текст "Coming through stdout" будет напечатан в терминале, из которого сценарий был вызван. В следующей строке мы сохраняем стандартный выходной канал в переменная save_stdout, так что мы сможем восстановить исходное состояние позже в сценарии. После этого открываем для записи файл «test.txt».После заявления
sys.stdout = fhвсе операторы печати будут напрямую печататься в этом файле. Оригинал состояние восстанавливается с помощьюsys.stdout = save_stdout.import sys print ("Проходит через стандартный вывод") # стандартный вывод сохранен save_stdout = sys.В следующем примере показано, как перенаправить стандартный поток ошибок в файл:import sys save_stderr = sys.stderr fh = open ("errors.txt", "w") sys.stderr = fh х = 10/0 # вернуться в нормальное состояние: sys.stderr = save_stderr fh.close ()
Можно записывать в поток ошибок напрямую, т.е. без изменения общего вывода поведение. Этого можно добиться, добавив>> sys.stderrк оператору печати.import sys save_stderr = sys.stderr fh = open ("errors.txt", "w") sys.stderr = fh print >> sys.stderr, "печать в error.txt" # вернуться в нормальное состояние: sys.stderr = save_stderr фх.Закрыть()Другие интересные переменные и константы в модуле sys
stdout
fh = open ("test.txt", "w")
sys.stdout = fh
print ("Эта строка идет в test.txt")
# вернуться в нормальное состояние:
sys.stdout = save_stdout
fh.close ()
| Имя | Описание | |
|---|---|---|
| byteorder | Индикатор собственного порядка байтов. Следующий вывод был создан на машине Linux и Python 2.6.5: >>> sys.byteorder 'маленький' >>>Значение будет 'большим' на платформах с прямым порядком байтов (сначала старший байт), и 'little' на платформах с прямым порядком байтов (сначала наименее значимый байт). | |
| исполняемый файл | Строка, содержащая имя исполняемого двоичного файла (путь и
имя исполняемого файла) для интерпретатора Python. Например. "c: \\ Python31 \\ python.exe в Windows 7 или" / usr / bin / python "в
Linux.>>> sys.executable '/ usr / bin / python' | |
| макс. | Этот атрибут содержит наибольшее положительное целое число, поддерживаемое Python
обычный целочисленный тип.
Минимальное значение максимального целочисленного значения - не менее2 31-1.Наибольшее отрицательное целое число соответствует значению - maxint - 1.  Эта асимметрия является результатом использования двоичной арифметики с дополнением до 2. Значение maxint зависит от операционной системы. Замечание относительно Python 3.X: Константа sys.maxint была удалена в Python 3.0, так как ограничения больше нет. к значениям целых чисел. Однако sys.maxsize можно использовать как целое число, большее, чем любой практический список или строковый индекс. Он соответствует «естественному» целочисленному размеру реализации и обычно совпадает с sys.Максинта в предыдущих выпусках на той же платформе (при тех же параметрах сборки). | |
| макс. Размер | Наибольшее положительное целое число, поддерживаемое типом Py_ssize_t платформы, и, следовательно, максимальное списки размеров, строки, словари и многие другие контейнеры.||
| maxunicode | Целое число, дающее наибольшую поддерживаемую кодовую точку для
Символ Юникода. Значение этого параметра зависит от параметра конфигурации, который указывает
сохраняются ли символы Unicode как UCS-2 или UCS-4. | |
| модуля | Значение sys.modules - это словарь, отображающий имена модулей. модулям, которые уже были загружены. Этим можно манипулировать, например, чтобы заставить перезагрузить модули. Обратите внимание, что удаление модуля из этого словаря не то же самое, что вызов reload () на соответствующем модульном объекте. | |
| путь | Содержит поисковый запрос, в котором Python ищет модули.>>> sys.path ['', '/ usr / lib / python2.6 ',' /usr/lib/python2.6/plat-linux2 ',' /usr/lib/python2.6/lib-tk ', '/usr/lib/python2.6/lib-old', '/usr/lib/python2.6/lib-dynload', '/usr/lib/python2.6/dist-packages', '/usr/lib/python2.6/dist-packages/PIL', '/usr/lib/python2.6/dist-packages/gst-0.10', '/usr/lib/pymodules/python2. | |
| платформа | Имя платформы, на которой работает Python, e.г. "linux2" для
Linux и win32 для Windows>>> sys.platform linux2 >>> | |
| версия | Номер версии интерпретатора Python>>> sys.version '2.6.5 (r265: 79063, 16 апреля 2010 г., 13:57:41) \ n [GCC 4.4.3]' >>> | |
| версия_инфо | Информация аналогична sys.version, но на выходе получается кортеж
содержащий пять компонентов номера версии: основной, дополнительный, микро, уровень выпуска и серийный.Значения этого кортежа являются целыми числами, кроме значения для уровня выпуска, которое является одним из
следующие: «альфа», «бета», «кандидат» или «финал». >>> sys.version_info (2, 6, 5, 'финал', 0) >>> | |
| __stdin__ __stdout__ __stderr__ | Эти атрибуты содержат исходные значения stdin, stderr и stdout в начале программы. Их можно использовать для печати в фактический стандартный поток независимо от того, sys.Объект std * был перенаправлен. Их также можно использовать для восстановления самих файлов. к известным рабочим файловым объектам на случай, если они были перезаписаны поврежденным объектом. Но вместо использования этих значений исходный поток всегда следует явно сохранять в переменная (как показано в наших предыдущих примерах) перед ее заменой, а исходное состояние должно можно восстановить с помощью сохраненного объекта. | |
| getrecursionlimit () setrecursionlimit (limit) | getrecursionlimit () возвращает текущее значение лимита рекурсии,
максимальная глубина стека интерпретатора Python. Этот предел предотвращает
бесконечная рекурсия из-за переполнения стека C и
сбой Python.>>> sys.getrecursionlimit () >>> 1000 setrecursionlimit (limit) устанавливает максимальную глубину стека интерпретатора Python равной значению «предел». |
6', '/usr/lib/python2.6/dist-packages/gtk-2.0',
'/usr/lib/pymodules/python2.6/gtk-2.0', '/usr/lib/python2.6/dist-packages/wx-2.8-gtk2-unicode',
'/usr/local/lib/python2.6/dist-packages']
>>>
Следующая глава: Python и оболочка
Python 元 组 |菜鸟 教程
Python 的 元 组 与 列表 类似 ， 不同 之 处 在于 元 组 的 元素 不能 修改。
元 组 使用 小 括号 ， 列表 使用 方 括号。
元 组 创建 很 简单 ， 只 需要 在 括号 中 添加 元素 ， 并 使用 逗号 隔开 即可。
如下 实例 ：
实例 (Python 2.0+)
tup1 = ('физика', 'химия', 1997, 2000) tup2 = (1, 2, 3, 4, 5) tup3 = "a", "b", "c", "d"
创建 空 元 组
tup1 = ()
元 组 中 只 包含 一个 元素 时 ， 需要 元素 后面 添加 逗号
tup1 = (50,)
元 组 与 字符串 类似 ， 下 标 索引 从 0 开始 ， 可以 进行 截取 ， 组合 等。
元 组
组 可以 使用 下 标 索引 来 访问 元 组 中 的 值 ， 如下 实例:
实例 (Python 2.0+)
tup1 = ('физика', 'химия', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7) напечатайте «tup1 [0]:», tup1 [0] напечатайте «tup2 [1: 5]:», tup2 [1: 5]
以上 实例 输出 结果 ：
tup1 [0]: физика tup2 [1: 5]: (2, 3, 4, 5)
元 组
组 中 的 元素 值 是 不允许 修改 的 ， 但 我们 可以 对 元 组 进行 ， 如下 实例:
实例 (Python 2. 0+)
0+) tup1 = (12; 34,56) tup2 = ('abc', 'xyz') tup3 = tup1 + tup2 печать tup3
以上 实例 输出 结果 ：
(12, 34.56, 'abc', 'xyz')
元 组
组 中 的 元素 值 是 不允许 删除 的 ， 但 我们 可以 使用 del 语句 来 组 ， 如下 实例:
实例 (Python 2.0+)
tup = ('физика', 'химия', 1997, 2000) распечатать дель туп print "После удаления tup:" печать туп
以上 实例 元 组 被 删除 后 ， 输出 变量 会有 异常 信息 ， 输出 如下 所示 ：
(«физика», «химия», 1997, 2000) После удаления tup: Отслеживание (последний вызов последний): Файл "test.py ", строка 9, враспечатать NameError: имя tup не определено
元 组 运算 符
字符串 一样 ， 元 组 之间 可以 使用 + 号 和 * 号 进行 运算。 这就 意味着 可以 组合 和 ， 运算 后 会 生成 一个 的 元 组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len ((1, 2, 3)) | 3 | 计算 元素 个数 |
| (1, 2, 3) + (4 , 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| ('Привет!',) * 4 | ('Привет!', 'Привет!', ' Привет! ',' Привет! ') | 复制 |
| 3 дюйма (1, 2, 3) | True | 元素 是否 存在 |
| для x дюймов (1, 2, 3): печать x , | 1 2 3 | 迭代 |
元 组 索引 ， 截取
元 组 也是 一个 ， 所以 我们 元 组 中 的 指定 位置 的 元素 ， 也 可以 截取 中 的 一段 元素 ， 如下 所示 ：
元 组 ：
L = ('спам', 'Спам', 'СПАМ!')
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L [2] | 'СПАМ!' | 读取 第三 个 元素 |
| L [-2] | 'Спам' | 反向 读取 ， 读取 倒数 个 元素 |
| L [1:] | ('Спам ',' СПАМ! ') | 截取 元素 |
无 关闭 分隔 符
任意 无 符号 的 对象 ， 以 逗号 隔开 ， 默认 为 元 组 ， 如下 实例 ：
实例 (Python 2. 0+)
0+) напечатайте 'abc', -4.24e93, 18 + 6.6j, 'xyz' х, у = 1, 2 print "Значение x, y:", x, y
以上 实例 运行 结果 ：
abc -4,24e + 93 (18 + 6,6j) xyz Значение x, y: 1 2
元 组 内置 函数
Python 元 组 包含 了 以下 内置 函数
Перенос на Python 3 | Документация Django
Django 1.5 - первая версия Django, поддерживающая Python 3. Тот же код работает как на Python 2 (≥ 2.6.5), так и на Python 3 (≥ 3.2), благодаря шести слой совместимости.
Этот документ в первую очередь предназначен для авторов подключаемых приложений. кто хочет поддерживать Python 2 и 3. В нем также описаны рекомендации, применить к коду Django.
Философия¶
Этот документ предполагает, что вы знакомы с изменениями между Python 2
и Python 3. Если вы этого не сделаете, сначала прочтите официальное руководство по портированию Python. Обновление ваших знаний об обработке Unicode на
Python 2 и 3 помогут; презентация Pragmatic Unicode - хорошая
ресурс.
Django использует стратегию Python 2/3 Compatible Source . Конечно ты вы можете выбрать другую стратегию для вашего собственного кода, особенно если вам не нужно чтобы оставаться совместимым с Python 2. Но авторы подключаемых приложений рекомендуется использовать ту же стратегию переноса, что и сам Django.
Написать совместимый код будет намного проще, если вы ориентируетесь на Python ≥ 2.6. Django 1.5
вводит инструменты совместимости, такие как django.utils.six , который является
модифицированная версия шести модулей .Для удобства,
Вперед-совместимые псевдонимы были представлены в Django 1.4.2. Если ваш
приложение использует эти инструменты, для этого потребуется Django ≥ 1.4.2.
Очевидно, что написание совместимого исходного кода добавляет некоторые накладные расходы, и это может
вызвать разочарование. Разработчики Django обнаружили, что при попытке написать
Код Python 3, совместимый с Python 2, приносит гораздо больше пользы, чем
напротив.
Это не только делает ваш код более перспективным, но и Python 3
преимущества (например, более разумное обращение со струнами) начинают проявляться быстро.Дилинг
с Python 2 становится требованием обратной совместимости, и мы, как
разработчики привыкли иметь дело с такими ограничениями.
Инструменты переноса, предоставляемые Django, вдохновлены этой философией, и это отражено в этом руководстве.
Наконечники для переноски¶
литералов Unicode¶
Этот шаг состоит из:
- Добавление
из __future__ import unicode_literalsв верхней части вашего Python модулей - лучше всего помещать их в каждый модуль, иначе вы продолжайте проверять верхнюю часть ваших файлов, чтобы увидеть, какой режим действует; - Удаление префикса
uперед строками Unicode; - Добавление префикса
bперед строками байтов.
Систематическое внесение этих изменений гарантирует обратную совместимость.
Однако приложениям Django обычно не нужны байтовые строки, поскольку Django
предоставляет программисту только интерфейсы Unicode. Python 3 не рекомендует использовать
байтовые строки, за исключением двоичных данных или байтовых интерфейсов. Python 2
делает строки байтов и строки юникода взаимозаменяемыми, если
они содержат только данные ASCII. Воспользуйтесь этим, чтобы использовать строки Unicode
по возможности и избегайте префиксов b .
Примечание
Префикс Python 2 u является синтаксической ошибкой в Python 3.2, но будет
снова разрешен в Python 3.3 благодаря PEP 414 . Таким образом, это
преобразование не является обязательным, если вы ориентируетесь на Python ≥ 3.3. Это все еще
рекомендуется в соответствии с философией «писать код Python 3».
Обработка строк¶
Тип Unicode Python 2 был переименован в str в Python 3, str () был переименован в байтов , а базовая строка исчезла.
шесть предоставляет инструменты для решения этих
изменения.
Django также содержит несколько связанных со строками классов и функций в django.utils.encoding и django.utils.safestring модулей. Их
в именах используются слова str , что не означает то же самое в Python 2
и Python 3, и unicode , которого нет в Python 3. Чтобы
во избежание двусмысленности и путаницы эти концепции были переименованы в байтов, в и текст .
Вот изменения имени в django.utils.encoding :
| Старое название | Новое название |
|---|---|
smart_str | smart_bytes |
smart_unicode | smart_text |
force_unicode | force_text |
Для обратной совместимости старые имена все еще работают на Python 2.