Распечатать числа от 1 до 10: Карточки — Цифры и числа от 1 до 20 — распечатать — Kid-mama – Всё о детях – беременность, воспитание, уроки для детей

Содержание

Таблица кубов

Определение Калькулятор – куб числа Таблица кубов

Скачать таблицу кубов

Определение.Куб числа – есть данное число, возведенное в третью степень.

a³ = a · a · a

“Кубом” оно называется, потому что такая операция аналогична вычислению объема куба.

Калькулятор для вычисления куба числа

³ = 827 ≈ 0.2962962962962963

Ниже приведены две удобные таблицы кубов натуральных чисел от 1 до 100.

Таблица кубов чисел от 1 до 100

1³ = 1

2³ = 8

3³ = 27

4³ = 64

5³ = 125

6³ = 216

7³ = 343

8³ = 512

9³ = 729

10³ = 1000

11³ = 1331

12³ = 1728

13³ = 2197

14³ = 2744

15³ = 3375

16³ = 4096

17³ = 4913

18³ = 5832

19³ = 6859

20³ = 8000

21³ = 9261

22³ = 10648

23³ = 12167

24³ = 13824

25³ = 15625

26³ = 17576

27³ = 19683

28³ = 21952

29³ = 24389

30³ = 27000

31³ = 29791

32³ = 32768

33³ = 35937

34³ = 39304

35³ = 42875

36³ = 46656

37³ = 50653

38³ = 54872

39³ = 59319

40³ = 64000

41³ = 68921

42³ = 74088

43³ = 79507

44³ = 85184

45³ = 91125

46³ = 97336

47³ = 103823

48³ = 110592

49³

= 117649

50³ = 125000

51³ = 132651

52³ = 140608

53³ = 148877

54³ = 157464

55³ = 166375

56³ = 175616

57³ = 185193

58³ = 195112

59³ = 205379

60³ = 216000

61³ = 226981

62³ = 238328

63³ = 250047

64³ = 262144

65³ = 274625

66³ = 287496

67³ = 300763

68³ = 314432

69³ = 328509

70³ = 343000

71³ = 357911

72³ = 373248

73³ = 389017

74³ = 405224

75³ = 421875

76³ = 438976

77³ = 456533

78³ = 474552

79³ = 493039

80³ = 512000

3 = 531441

82³ = 551368

83³ = 571787

84³ = 592704

85³ = 614125

86³ = 636056

87³ = 658503

88³ = 681472

89³ = 704969

90³ = 729000

91³ = 753571

92³ = 778688

93³ = 804357

94³ = 830584

95³ = 857375

96³ = 884736

97³ = 912673

98³ = 941192

99³ = 970299

100³ = 1000000

 Распечатать таблицу кубов

Таблица кубов

	0	1	2	3	4	5	6	7	8	9
0	0	1	8	27	64	125	216	343	512	729
1	1000	1331	1728	2197	2744	3375	4096	4913	5832	6859
2	8000	9261	10648	12167	13824	15625	17576	19683	21952	24389
3	27000	29791	32768	35937	39304	42875	46656	50653	54872	59319
4	64000	68921	74088	79507	85184	91125	97336	103823	110592	117649
5	125000	132651	140608	148877	157464	166375	175616	185193	195112	205379
6	216000	226981	238328	250047	262144	274625	287496	300763	314432	328509
7	343000	357911	373248	389017	405224	421875	438976	456533	474552	493039
8	512000	531441	551368	571787	592704	614125	636056	658503	681472	704969
9	729000	753571	778688	804357	830584	857375	884736	912673	941192	970299

 Распечатать таблицу кубов

Добро пожаловать на OnlineMSchool.
Меня зовут Довжик Михаил Викторович. Я владелец и автор этого сайта, мною написан весь теоретический материал, а также разработаны онлайн упражнения и калькуляторы, которыми Вы можете воспользоваться для изучения математики.

Если Вы хотите связаться со мной, имеете вопросы, предложения или хотите помочь развивать сайт

OnlineMSchool пишите мне [email protected]

натуральные числа, двузначные числа, распечатать фото в хорошем качестве с крупными цифрами

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

Анна Стрельцова

Автор КП

Александр Мельников

Преподаватель информатики и математики онлайн-школы «Коалиция», эксперт ЕГЭ и ОГЭ

Квадратом числа называют произведение на самого себя один раз или возведение во вторую степень. В школе это действие проходят в 5 классе. Например, чтобы вычислить квадрат числа 5, нужно умножить его на 5: в итоге получится 25. С натуральными числами до 10 вычисления довольно просты, а посчитать квадрат двузначного числа в уме уже сложнее. Поэтому для удобства можно пользоваться таблицами: это облегчает вычисления.

Таблица квадратов натуральных чисел

Натуральные числа — те числа, которые мы используем при счете или при перечислении вещей, объектов. К натуральным относятся только полные и неотрицательные числа. В математике их много: поэтому мы сделали таблицу квадратов натуральных чисел от 1 до 10.

Таблица квадратов двузначных чисел

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

Скачать таблицу двузначных чисел

Таблица квадратов до 100

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

Скачать таблицу квадратов до 100

Популярные вопросы и ответы

Отвечает Александр Мельников, преподаватель информатики и математики онлайн-школы «Коалиция», эксперт ЕГЭ и ОГЭ, сертифицированный преподаватель проекта «Математическая вертикаль».

Как пользоваться таблицей квадратов?

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

В таблице пересечение цифр слева в столбце и сверху в строке дает квадрат искомого числа. Например, нужно найти квадрат числа 15. В столбце слева берем первую цифру данного числа «1». В самой верхней строке берем вторую цифру данного числа «5». На пересечении данных цифр получаем квадрат числа 15, то есть 225.

Таблицу квадратов также можно использовать для извлечения квадратного корня — обратной операции возведения в квадрат. Например, √225=15.

В ТЕМУ

Как быстро выучить таблицу квадратов?

— Если мы говорим о сдаче ОГЭ и ЕГЭ базового уровня по математике, то учить таблицу квадратов необязательно, так как она будет в справочном материале. А вот для ЕГЭ по профильной математике это делать нужно: справочные материалы не предоставляются. Пригодится таблица квадратов и позже, при обучении в вузе. Вот несколько советов, как это сделать.

1. Если число заканчивается на 0, его легко возвести в квадрат — необходимо только дописать пару нулей: 60 х 60 = 3600.

2. Если число заканчивается на 5, то следует умножить первую цифру (x) на (x+1) и дописать к полученному числу «25». 65 х 65 = 6 х 7 = 42 приписываем 25 и получаем 4225.

3. Можно воспользоваться формулой (a + b)² = a² + 2ab + b² . Как мы уже выяснили, возводить в квадрат числа, оканчивающиеся на 0, очень просто. Следовательно, а — это число, которое делится на 10, а b — остаток от деления на 10. Приведем пример. Возведем в квадрат 32. 32 можно представить как 30 (число делится на 10) и 2 (остаток от деления на 10): (30+2)² = 30² + 2 х 30 х 2 + 2² = 900 + 120 + 4 =1024.

Для начала нужно выучить таблицу квадратов первого десятка, так как она используется чаще всего: 121, 144, 169, 196, 225, 256, 289, 324, 361. И важно запомнить, что не бывает квадратов, последняя цифра в которых 2, 3, 7, 8. Также часто используются квадраты таких чисел как 21, 24, 25, 26: они встречаются чаще других.

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

Как извлечь корень числа без таблицы квадратов?

— Число необходимо разложить на простые множители, например 1225 = 5 х 5 х 7 х 7 = 5²7². Значит, √1225 = √(5²7²) = 5 х 7 = 35. Благодаря разложению на множители можно извлечь корень из многозначного числа, выходящего за рамки таблицы квадратов.

Фото на обложке: shutterstock.com

Алгоритмы поиска простых чисел / Хабр

«Самое большое простое число 2^32582657-1. И я с гордостью утверждаю, что запомнил все его цифры… в двоичной форме».
Карл Померанс

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

Решето Эратосфена

Решето Эратосфена — алгоритм, предложенный древнегреческим математиком Эратосфеном. Этот метод позволяет найти все простые числа меньше заданного числа n. Суть метода заключается в следующем. Возьмем набор чисел от 2 до n. Вычеркнем из набора (отсеим) все числа делящиеся на 2, кроме 2. Перейдем к следующему «не отсеянному» числу — 3, снова вычеркиваем все что делится на 3. Переходим к следующему оставшемуся числу — 5 и так далее до тех пор пока мы не дойдем до n. После выполнения вышеописанных действий, в изначальном списке останутся только простые числа.

Алгоритм можно несколько оптимизировать. Так как один из делителей составного числа n обязательно , алгоритм можно останавливать, после вычеркивания чисел делящихся на .

Иллюстрация работы алгоритма из Википедии:

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

Существует ряд оптимизаций, позволяющих снизить эти показатели. Прием под названием wheel factorization состоит в том, чтобы включать в изначальный список только числа взаимно простые с несколькими первыми простыми числами (например меньше 30). В теории предлагается брать первые простые примерно до . Это позволяет снизить сложность алгоритма в раз. Помимо этого для уменьшения потребляемой памяти используется так называемое сегментирование. Изначальный набор чисел делится на сегменты размером и для каждого сегмента решето Эратосфена применяется по отдельности. Потребление памяти снижается до .

Решето Аткина

Более совершенный алгоритм отсеивания составных чисел был предложен Аткином и Берштайном и получил название Решето Аткина. Этот способ основан на следующих трех свойствах простых чисел.

Свойство 1
Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.
Свойство 2
Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.
Свойство 3
Если n — положительное число, не кратное квадрату простого числа и такое, что . То n — простое, тогда и только тогда, когда число корней уравнения нечетно.
Доказательства этих свойств приводятся в этой статье.
На начальном этапе алгоритма решето Аткина представляет собой массив
A размером n, заполненный нулями. Для определения простых чисел перебираются все . Для каждой такой пары вычисляется , , и значение элементов массива , , увеличивается на единицу. В конце работы алгоритма индексы всех элементов массива, которые имеют нечетные значения либо простые числа, либо квадраты простого числа. На последнем шаге алгоритма производится вычеркивание квадратов оставшихся в наборе чисел.
Из описания алгоритма следует, что вычислительная сложность решета Аткина и потребление памяти составляют . При использовании wheel factorization и сегментирования оценка сложности алгоритма снижается до , а потребление памяти до .
Числа Мерсенна и тест Люка-Лемера
Конечно при таких показателях сложности, даже оптимизированное решето Аткина невозможно использовать для поиска по-настоящему больших простых чисел.
К счастью, существуют быстрые тесты, позволяющие проверить является ли заданное число простым. В отличие от алгоритмов решета, такие тесты не предназначены для поиска всех простых чисел, они лишь способны сказать с некоторой вероятностью, является ли определенное число простым.
Один из таких методов проверки — тест Люка-Лемера. Это детерминированный и безусловный тест простоты. Это означает, что прохождение теста гарантирует простоту числа. К сожалению, тест предназначен только для чисел особого вида , где p — натуральное число. Такие числа называются числами Мерсенна.
Тест Люка-Лемера утверждает, что число Мерсенна простое тогда и только тогда, когда p — простое и делит нацело -й член последовательности задаваемой рекуррентно: для .
Для числа длиной p бит вычислительная сложность алгоритма составляет .
Благодаря простоте и детерминированности теста, самые большие известные простые числа — числа Мерсенна. Самое большое известное простое число на сегодня — , его десятичная запись состоит из 24,862,048 цифр.
Полюбоваться на эту красоту можно здесь.
Теорема Ферма и тест Миллера-Рабина
Простых чисел Мерсенна известно не очень много, поэтому для криптографии с открытым ключом необходим другой способ поиска простых чисел. Одним из таким способов является тест простоты Ферма. Он основан на малой теореме Ферма, которая гласит, что если n — простое число, то для любого a, которое не делится на n, выполняется равенство . Доказательство теоремы можно найти на Википедии.
Тест простоты Ферма — вероятностный тест, который заключается в переборе нескольких значений a, если хотя бы для одного из них выполняется неравенство , то число n — составное. В противном случае, n — вероятно простое. Чем больше значений a использовано в тесте, тем выше вероятность того, что n — простое.
К сожалению, существуют такие составные числа n, для которых сравнение выполняется для всех a взаимно простых с n. Такие числа называются числам Кармайкла. Составные числа, которые успешно проходят тест Ферма, называются псевдопростыми Ферма. Количество псевдопростых Ферма бесконечно, поэтому тест Ферма — не самый надежный способ определения простых чисел.
Тест Миллера-Рабина
Более надежных результатов можно добиться комбинируя малую теорему Ферма и тот факт, что для простого числа p не существует других корней уравнения , кроме 1 и -1. Тест Миллера-Рабина перебирает несколько значений a и проверяет выполнение следующих условий.
Пусть p — простое число и , тогда для любого a справедливо хотя бы одно из условий:

Существует целое число r < s такое, что

По теореме Ферма , а так как из свойства о корнях уравнения следует что если мы найдем такое a, для которого одно из условий не выполняется, значит p — составное число. Если одно из условий выполняется, число a называют свидетелем простоты числа n по Миллеру, а само число n — вероятно простым.
Чем больше свидетелей простоты найдено, тем выше вероятность того, что n — простое. Согласно теореме Рабина вероятность того, что случайно выбранное число a окажется свидетелем простоты составного числа составляет приблизительно .
Следовательно, если проверить k случайных чисел a, то вероятность принять составное число за простое .
Сложность работы алгоритма , где k — количество проверок.
Благодаря быстроте и высокой точности тест Миллера-Рабина широко используется при поиске простых чисел. Многие современные криптографические библиотеки при проверке больших чисел на простоту используют только этот тест и, как показал Мартин Альбрехт в своей работе , этого не всегда оказывается достаточно.
Он смог сгенерировать такие составные числа, которые успершно прошли тест на простоту в библиотеках OpenSSL, CryptLib, JavaScript Big Number и многих других.
Тест Люка и Тест Baillie–PSW
Чтобы избежать уязвимости, связанные с ситуациями, когда сгенерированное злоумышленником составное число, выдается за простое, Мартин Альбрехт предлагает использовать тест Baillie–PSW. Несмотря на то, что тест Baillie–PSW является вероятностным, на сегодняшний день не найдено ни одно составное число, которое успешно проходит этот тест. За нахождение подобного числа в 1980 году авторы алгоритма пообещали вознаграждение в размере $30. Приз пока так и не был востребован.
Ряд исследователей проверили все числа до и не обнаружили ни одного составного числа, прошедшего тест Baillie–PSW. Поэтому, для чисел меньше тест считается детерминированным.
Суть теста сводится к последовательной проверке числа на простоу двумя различными методами. Один из этих методов уже описанный выше тест Миллера-Рабина. Второй — тест Люка на сильную псевдопростоту.
Тест Люка на сильную псевдопростоту
Последовательности Люка — пары рекуррентных последовательностей , описываемые выражениями:
Пусть и — последовательности Люка, где целые числа P и Q удовлетворяют условию
Вычислим символ Якоби: .
Найдем такие r, s для которых выполняется равенство
Для простого числа n выполняется одно из следующих условий:
n делит

n делит для некоторого j < r

В противном случае n — составное.
Вероятность того, что составное число n успешно пройдет тест Люка для заданной пары параметров P, Q не превышает 4/15. Следовательно, после применения теста k раз, эта вероятность составляет .
Тесты Миллера-Рабина и Люка производят не пересекающиеся множества псевдопростых чисел, соответственно если число p прошло оба теста, оно простое. Именно на этом свойстве основывается тест Baillie–PSW.
Заключение
В зависимости от поставленной задачи, могут использоваться различные методы поиска простых чисел. К примеру, при поиске больших простых чисел Мерсенна, сперва, при помощи решета Эратосфена или Аткина определяется список простых чисел до некоторой границы, предположим, до . Затем для каждого числа p из списка, с помощью теста Люка-Лемера, на простоту проверяется .
Чтобы сгенерировать большое простое число в криптографических целях, выбирается случайное число a и проверяется тестом Миллера-Рабина или более надежным Baillie–PSW. Согласно теореме о распределении простых чисел, у случайно выбранного числа от 1 до n шанс оказаться простым примерно равен . Следовательно, чтобы найти простое число размером 1024 бита, достаточно перебрать около тысячи вариантов.
P.S. Исходники
Реализацию всех описанных алгоритмов на Go можно посмотреть на GitHub.
чисел в Python — настоящий Python
Чтобы хорошо программировать, не нужно быть математическим гением. Правда в том, что немногим программистам нужно знать больше, чем базовую алгебру. Конечно, то, сколько математики вам нужно знать, зависит от приложения, над которым вы работаете. В общем, уровень математики, необходимый для того, чтобы быть программистом, ниже, чем можно было бы ожидать. Хотя математика и компьютерное программирование не так уж взаимосвязаны, как некоторые думают, числа являются неотъемлемой частью любого языка программирования, и Python не исключение.
В этом руководстве вы узнаете, как:
Создавать целых числа и числа с плавающей запятой
Округление чисел до заданного числа знаков после запятой
Форматирование и отображение чисел в строках
Начнем!
Примечание: Это руководство адаптировано из главы «Числа и математика» в Основы Python: практическое введение в Python 3 .
В книге используется встроенный в Python редактор IDLE для создания и редактирования файлов Python и взаимодействия с оболочкой Python, поэтому в этом руководстве вы увидите ссылки на встроенные инструменты отладки IDLE. Однако у вас не должно возникнуть проблем с запуском кода примера из редактора и среды по вашему выбору.
Бесплатный бонус: 5 Thoughts On Python Mastery, бесплатный курс для Python-разработчиков, который показывает вам дорожную карту и образ мышления, которые вам понадобятся, чтобы вывести свои навыки Python на новый уровень.
Целые числа и числа с плавающей запятой
Python имеет три встроенных числовых типа данных: целые числа, числа с плавающей запятой и комплексные числа. В этом разделе вы узнаете о целых числах и числах с плавающей запятой, которые являются двумя наиболее часто используемыми типами чисел. Вы узнаете о комплексных числах в следующем разделе.

.
>>>
>>> число = 25
Когда вы создаете подобное целое число, значение 25 называется целочисленным литералом , потому что целое число буквально вводится в код.
Возможно, вы уже знакомы с тем, как преобразовать строку, содержащую целое число, в число с помощью int() . Например, следующий код преобразует строку "25" в целое число 25 :
.
>>>
>>> целое ("25") 25
int("25") не является целочисленным литералом, поскольку целочисленное значение создается из строки.
Когда вы пишете большие числа вручную, вы обычно группируете цифры в группы по три, разделенные запятой или десятичной точкой. Число 1 000 000 намного легче читать, чем 1 000 000.
В Python нельзя использовать запятые для группировки цифр в целочисленных литералах, но можно использовать символы подчеркивания ( _ ). Оба следующих способа являются допустимыми способами представления числа один миллион в виде целочисленного литерала:
.
>>>
>>> 1000000 1000000 >>> 1_000_000 1000000
Нет предела тому, насколько большим может быть целое число, что может показаться удивительным, учитывая, что компьютеры имеют ограниченный объем памяти. Попробуйте ввести самое большое число, которое вы можете придумать, в интерактивное окно IDLE. Python справится с этим без проблем!
Числа с плавающей запятой
Число с плавающей запятой или с плавающей запятой для краткости — это число с десятичным знаком. 1.0 — число с плавающей запятой, как и -2.75 . Имя типа данных с плавающей запятой — 9.0054 с плавающей запятой :
>>>
>>> тип(1.0) <класс 'плавающий'>
Как и целые числа, числа с плавающей запятой могут быть созданы из литералов с плавающей запятой или путем преобразования строки в число с плавающей запятой с помощью float() :
>>>
>>> с плавающей запятой ("1,25") 1,25
Существует три способа представления литерала с плавающей запятой. Каждое из следующих действий создает литерал с плавающей запятой со значением один миллион:
>>>
>>> 1000000. 0 1000000,0 >>> 1_000_000.0 1000000,0 >>> 1e6 1000000,0
Первые два способа аналогичны двум методам создания целочисленных литералов. Третий подход использует нотацию E для создания литерала с плавающей запятой.
Примечание: E-нотация является сокращением от экспоненциальной записи . Возможно, вы видели это обозначение, используемое калькуляторами для представления чисел, которые слишком велики, чтобы поместиться на экране.
Чтобы написать литерал с плавающей запятой в нотации E, введите число, за которым следует буква e , а затем еще одно число. Python берет число слева от e и умножает его на 10 , возведенное в степень числа после e . Таким образом, 1e6 эквивалентно 1×10⁶.
Python также использует нотацию E для отображения больших чисел с плавающей запятой:
>>>
>>> 200000000000000000. 0 2е+17
Число с плавающей запятой 200000000000000000.0 отображается как 2e+17 . Знак + указывает на то, что показатель степени 17 является положительным числом. Вы также можете использовать отрицательные числа в качестве показателя степени:
.
>>>
>>> 1e-4 0,0001
Буквенное число 1e-4 интерпретируется как 10 , возведенное в степень -4 , что составляет 1/10000, или 0,0001 .
В отличие от целых чисел, у чисел с плавающей запятой есть максимальный размер. Максимальное число с плавающей запятой зависит от вашей системы, но что-то вроде 2e400 должно быть далеко за пределами возможностей большинства машин. 2e400 равно 2×10⁴⁰⁰, что намного больше, чем общее количество атомов во Вселенной!
Когда вы достигаете максимального числа с плавающей запятой, Python возвращает специальное значение с плавающей запятой, inf :
>>>
>>> 2e400 инф
inf означает бесконечность, и это просто означает, что число, которое вы пытались создать, превышает максимальное значение с плавающей запятой, разрешенное на вашем компьютере. Тип inf по-прежнему с плавающей запятой :
>>>
>>> n = 2e400 >>> н инф >>> тип(н) <класс 'плавающий'>
Python также использует -inf , что означает отрицательную бесконечность и представляет отрицательное число с плавающей запятой, выходящее за пределы минимального числа с плавающей запятой, разрешенного на вашем компьютере:
>>>
>>> -2e400 -инф
Вы вряд ли встретите инф и -inf очень часто как программист, если вы регулярно не работаете с чрезвычайно большими числами.
Проверьте свое понимание
Разверните блок ниже, чтобы проверить, что вы поняли:
Напишите программу, которая создает две переменные: num1 и num2 . И num1 , и num2 должны быть назначены целочисленному литералу 25000000 , один из которых написан с подчеркиванием, а другой без. Распечатать число1 и num2 на двух отдельных строках.
Вы можете развернуть блок ниже, чтобы увидеть решение:
Сначала присвойте значение 25000000 num1 без подчеркивания:
num1 = 25000000
Далее в новой строке присвойте значение 25_000_000 переменной num2 :
num2 = 25_000_000
Печатать обе переменные в отдельных строках, передавая каждую переменную отдельным вызовам print() :
печать (номер1) печать (число2)
В выводе видно, что оба числа одинаковы:
25000000 25000000
Хотя обеим переменным присвоено значение 25000000 , запись значения с использованием подчеркивания для группировки цифр значительно облегчает человеку быстрое определение числа. Больше не нужно щуриться на экран и пытаться считать нули!
Когда вы будете готовы, вы можете перейти к следующему разделу.

В этом разделе вы узнаете, как выполнять базовые арифметические действия, такие как сложение, вычитание, умножение и деление, с числами в Python. Попутно вы изучите некоторые правила написания математических выражений в коде.
Обратите внимание, что результатом 1.0 + 2 является 3.0 , то есть число с плавающей запятой . Каждый раз, когда к числу добавляется с плавающей запятой , в результате получается еще 9.0054 поплавок . Сложение двух целых чисел всегда дает int .
.
>>>
>>> 1 - (-3) 4
Использование круглых скобок — хорошая идея, потому что это делает ваш код более явным. Компьютеры выполняют код, но люди читают код. Все, что вы можете сделать, чтобы ваш код было легче читать и понимать, — это хорошо.

В отличие от сложения, вычитания и умножения, деление с помощью оператора / всегда возвращает число с плавающей запятой . Если вы хотите убедиться, что вы получите целое число после деления двух чисел, вы можете использовать int() для преобразования результата:
Приведенный выше пример также показывает, что // возвращает число с плавающей запятой, когда один из операндов является числом с плавающей запятой . Вот почему 9 // 3 возвращает целое число 3 , а 5.0 // 2 возвращает число с плавающей запятой 2.0 .
Возведение числа в отрицательную степень равносильно делению 1 на число, возведенное в положительную степень. Итак, 2 ** -1 совпадает с 1 / (2 ** 1) , что совпадает с 1 / 2 , или 0,5 . Точно так же 2 ** -2 совпадает с 1 / (2 ** 2) , что совпадает с 1 / 4 или 0,25 .
3 делит 5 один раз с остатком 2 , поэтому 5 % 3 равно 2 . Точно так же 7 делит 20 дважды с остатком 6 . В последнем примере 16 делится на 8 , поэтому 16 % 8 равно 0 . Каждый раз, когда число слева от % делится на число справа, результат равен 9.0054 0 .
Одним из наиболее распространенных применений % является определение, делится ли одно число на другое. Например, число n четно тогда и только тогда, когда n % 2 равно 0 . Как вы думаете, что возвращает 1 % 0 ? Давайте попробуем:
Однако, когда Python обнаруживает ошибку при выполнении скрипта, выполнение останавливается. Другими словами, программа вылетает . В главе 8 из Основы Python вы узнаете, как обрабатывать ошибки, чтобы ваши программы не вылетали неожиданно.
Например, чтобы найти 5 % -3 , Python сначала находит (5 // -3) . Поскольку 5/-3 равно примерно -1,67 , это означает, что 5//-3 равно -2 . Теперь Python умножает это на -3 , чтобы получить 6 . Наконец, Python вычитает 6 из 5 , чтобы получить -1 9. 0055 .
Все операторы * , / , // и % имеют равный приоритет , или приоритет, в выражении, и каждый из них имеет более высокий приоритет, чем + и - операторов. Вот почему 2*3 - 1 возвращает 5 , а не 4 . 2*3 оценивается первым, потому что * имеет более высокий приоритет, чем оператор - .
Если используются операторы с разными приоритетами, рассмотрите возможность добавления пробелов вокруг операторов с наименьшим(и) приоритетом(ами). Используйте свое собственное суждение; однако никогда не используйте более одного пробела и всегда используйте одинаковое количество пробелов с обеих сторон бинарного оператора. (Источник)
. Заставь Python лгать тебе Как вы думаете, что такое 0,1 + 0,2 ? Ответ 0. 3 , верно? Давайте посмотрим, что Python может сказать об этом. Попробуйте это в интерактивном окне: >>> >>> 0,1 + 0,2 0,30000000000000004 Ну, это . . . почти верно. Что, черт возьми, здесь происходит? Это ошибка в Python? Нет, это не ошибка! Это ошибка представления с плавающей запятой , и она не имеет ничего общего с Python. Это связано с тем, как числа с плавающей запятой хранятся в памяти компьютера. Число 0,1 можно представить в виде дроби 1/10 . Оба числа 0,1 и его дробь 1/10 представляют собой десятичных представления или десятичных представления . Однако компьютеры хранят числа с плавающей запятой в представлении с основанием 2, которое чаще называют двоичным представлением . При представлении в двоичном виде с десятичным числом 0,1 происходит что-то знакомое, но, возможно, неожиданное. Дробь 1/3 не имеет конечного десятичного представления. То есть 1/3 = 0,3333... с бесконечным количеством троек после запятой. То же самое происходит с дробью 1/10 в двоичном формате. Двоичное представление числа 1/10 представляет собой следующую бесконечно повторяющуюся дробь: 0.00011001100110011001100110011... Компьютеры имеют ограниченную память, поэтому число 0,1 должно храниться как приблизительное, а не как его истинное значение. Сохраняемое приближение немного выше фактического значения и выглядит так: . 0.1000000000000000055511151231257827021181583404541015625 Однако вы, возможно, заметили, что при запросе на печать 0,1 Python печатает 0,1 , а не приблизительное значение выше: . >>> >>> 0,1 0,1 Python не просто отсекает цифры в двоичном представлении для 0. 1 . То, что происходит на самом деле, немного более тонко. Поскольку аппроксимация 0,1 в двоичной системе является всего лишь аппроксимацией, вполне возможно, что несколько десятичных чисел имеют одну и ту же двоичную аппроксимацию. Например, и 0,1 , и 0,10000000000000001 имеют одинаковое двоичное приближение. Python выводит кратчайшее десятичное число, соответствующее приближению. Это объясняет, почему в первом примере этого раздела 0,1 + 0,2 не равно 0,3 . Python складывает вместе двоичные приближения для 0,1 и 0,2 , что дает число, которое равно , а не , двоичное приближение для 0,3 . Если у вас от всего этого начинает кружиться голова, не волнуйтесь! Если вы не пишете программы для финансов или научных вычислений, вам не нужно беспокоиться о неточности арифметики с плавающей запятой. Удаление рекламы Математические функции и числовые методы Python имеет несколько встроенных функций, которые можно использовать для работы с числами. В этом разделе вы узнаете о трех наиболее распространенных: раунд() , для округления чисел до некоторого количества знаков после запятой abs() , для получения абсолютного значения числа pow() , для возведения числа в некоторую степень Вы также узнаете о методе, который можно использовать с числами с плавающей запятой, чтобы проверить, имеют ли они целочисленное значение. Круглые числа с round() Вы можете использовать round() для округления числа до ближайшего целого числа: >>> >>> круглый(2.3) 2 >>> раунд(2.7) 3 round() ведет себя неожиданно, когда число заканчивается на .5 : >>> >>> круглый(2,5) 2 >>> раунд(3.5) 4 2,5 округляется до 2 , а 3,5 округляется до 4 . Большинство людей ожидают, что число, оканчивающееся на .5 , будет округлено в большую сторону, поэтому давайте подробнее рассмотрим, что здесь происходит. Python 3 округляет числа в соответствии со стратегией, называемой округлением до четного. tie — это любое число, последняя цифра которого равна пяти. 2,5 и 3,1415 равны, а 1,37 нет. При округлении ничьи до четного вы сначала смотрите на цифру на один десятичный знак слева от последней цифры ничьи. Если эта цифра четная, то вы округляете в меньшую сторону. Если цифра нечетная, то округляем в большую сторону. Вот почему 2,5 округляется до 2 и 3,5 округляется до 4 . Примечание: Округление до четного — это стратегия округления, рекомендованная IEEE (Институт инженеров по электротехнике и электронике) для чисел с плавающей запятой, поскольку она помогает ограничить влияние округления на операции с большим количеством чисел. IEEE поддерживает стандарт IEEE 754 для работы с числами с плавающей запятой на компьютере. Он был опубликован в 1985 году и до сих пор широко используется производителями оборудования. Вы можете округлить число до заданного количества знаков после запятой, передав второй аргумент функции round() : >>> >>> круглый(3.14159, 3) 3.142 >>> раунд(2.71828, 2) 2,72 Число 3,14159 округляется до трех знаков после запятой, чтобы получить 3,142 , а число 2,71828 округляется до двух знаков после запятой, чтобы получить 2,72 . Второй аргумент round() должно быть целым числом. Если это не так, Python выдает TypeError : . >>> >>> круглый(2,65, 1,4) Traceback (последний последний вызов): Файл "", строка 1, в раунд(2,65, 1,4) TypeError: объект 'float' не может быть интерпретирован как целое число Иногда round() дает не совсем правильный ответ: >>> >>> # Ожидаемое значение: 2,68 >>> раунд(2. 675, 2) 2,67 2,675 является ничьей, потому что находится ровно посередине между числами 2,67 и 2,68 . Поскольку Python округляет связи до ближайшего четного числа, вы ожидаете, что round(2.675, 2) вернет 2.68 , но вместо этого он вернет 2.67 . Эта ошибка является результатом ошибки представления с плавающей запятой, а не ошибкой в round() . Работа с числами с плавающей запятой может вызывать разочарование, но это не относится к Python. Все языки, реализующие стандарт IEEE с плавающей запятой, имеют одинаковые проблемы, включая C/C++, Java и JavaScript. Однако в большинстве случаев небольшие ошибки, возникающие при работе с числами с плавающей запятой, незначительны, и результаты round() весьма полезны. Удалить рекламу Найти абсолютное значение с помощью abs() Абсолютное значение числа n равно n , если n положительно, и - n , если n отрицательно. Например, абсолютное значение 3 равно 3 , а абсолютное значение -5 это 5 . Чтобы получить абсолютное значение числа в Python, вы используете abs() : >>> >>> абс(3) 3 >>> абс (-5.0) 5,0 abs() всегда возвращает положительное число того же типа, что и его аргумент. То есть абсолютное значение целого числа всегда является положительным целым числом, а абсолютное значение числа с плавающей запятой всегда является положительным числом с плавающей запятой. Возведение в степень с помощью pow() Ранее вы узнали, как возводить число в степень с помощью оператора ** . Вы также можете использовать pow() для достижения того же результата. pow() принимает два аргумента. Первый аргумент — это основание , или число, которое нужно возвести в степень, а второй аргумент — это показатель степени , или степень, в которую нужно возвести число. Например, следующее использует pow() для повышения 2 в степени 3 : >>> >>> пау(2, 3) 8 Как и в случае с ** , показатель степени в pow() может быть отрицательным: >>> >>> pow(2, -2) 0,25 Итак, в чем разница между ** и pow() ? Функция pow() принимает необязательный третий аргумент, который вычисляет первое число, возведенное в степень второго числа, а затем берет модуль по модулю относительно третьего числа. Другими словами, pow(x, y, z) эквивалентно (x ** y) % z . Вот пример, в котором x = 2 , y = 3 и z = 2 : >>> >>> пау(2, 3, 2) 0 Во-первых, 2 возводится в степень 3 , чтобы получить 8 . Затем вычисляется 8 % 2 , что равно 0 , потому что 2 делит 8 без остатка. Проверка целостности числа с плавающей запятой Возможно, вы знакомы со строковыми методами, такими как .lower() , .upper() и .find() . Целые числа и числа с плавающей запятой также имеют методы. Численные методы используются не очень часто, но есть один, который может быть полезен. Числа с плавающей запятой имеют метод .is_integer() , который возвращает True , если число целочисленное — это означает, что оно не имеет дробной части — и в противном случае возвращает False : >>> >>> число = 2,5 >>> число.is_integer() ЛОЖЬ >>> число = 2,0 >>> число.is_integer() Истинный Одно из применений .is_integer() — проверка пользовательского ввода. Например, если вы пишете приложение онлайн-заказа для пиццерии, вам нужно проверить, что количество пиццы, которое вводит клиент, является целым числом. Функции round() , abs() и pow() являются встроенными функциями, то есть вам не нужно ничего импортировать, чтобы использовать их. Но эти три функции едва касаются поверхности всех функций, доступных для работы с числами в Python. Чтобы получить еще больше удовольствия от математики, ознакомьтесь с математическим модулем Python: все, что вам нужно знать! Проверьте свое понимание Разверните блок ниже, чтобы проверить, что вы поняли: Напишите программу, которая просит пользователя ввести число, а затем отображает это число, округленное до двух знаков после запятой. При запуске ваша программа должна выглядеть так: Введите число: 5.432 5,432, округленное до 2 знаков после запятой, равно 5,43. Вы можете развернуть блок ниже, чтобы увидеть решение: Чтобы получить ввод от пользователя, передайте приглашение input() : user_input = input("Введите число: ") Обратите внимание на пробел в конце строки подсказки. Это гарантирует наличие пробела между текстом, введенным пользователем, когда он начинает печатать, и двоеточием в подсказке. Значение, возвращаемое input() , является строкой, поэтому вам нужно преобразовать ее в число с плавающей запятой, прежде чем вы сможете округлить число: num = float(user_input) Имейте в виду, что приведенный выше код предполагает, что строка user_input действительно содержит числовое значение, а не какой-либо другой текст. Примечание: Если user_input действительно содержит нечисловой текст, то будет выдано сообщение ValueError . Ознакомьтесь с исключениями Python: введение для получения информации о том, как обрабатывать такие ошибки. Теперь вы можете использовать round() для округления значения до двух знаков после запятой: rounded_num = round(num, 2) Помните, что первым аргументом round() должно быть число, которое нужно округлить. Второй аргумент — это количество знаков после запятой, до которого следует округлить. Наконец, вы можете напечатать вывод, вставив rounded_num в f-строку: print(f"{num}, округленное до 2 знаков после запятой, равно {rounded_num}") round() — отличный способ округления значений, но если вы округляете значения только для их отображения, вы можете рассмотреть возможность использования методов, описанных в следующем разделе. Когда вы будете готовы, вы можете перейти к следующему разделу. Удалить рекламу Печать номеров в стиле Для отображения чисел пользователю требуется вставка чисел в строку. Вы можете сделать это с помощью f-строк, заключив переменную, присвоенную числу, в фигурные скобки: . >>> >>> n = 7,125 >>> f"Значение n равно {n}" «Значение n равно 7,125» Эти фигурные скобки поддерживают простой язык форматирования, который можно использовать для изменения внешнего вида значения в окончательной отформатированной строке. Например, чтобы отформатировать значение n в приведенном выше примере до двух знаков после запятой, замените содержимое фигурных скобок в f-строке на {n:.2f} : >>> >>> n = 7,125 >>> f"Значение n равно {n:.2f}" «Значение n равно 7,12» Двоеточие ( : ) после переменной n указывает, что все после него является частью спецификации форматирования. В этом примере спецификация форматирования равна 9.0054 .2f .
.2 в .2f округляет число до двух знаков после запятой, а f указывает Python отображать n как число с фиксированной точкой . Это означает, что число отображается ровно с двумя знаками после запятой, даже если исходное число имеет меньше знаков после запятой.
Когда n = 7,125 , результатом {n:.2f} будет 7,12 . Как и в случае с round() , Python округляет связи до даже при форматировании чисел внутри строк. Итак, если вы замените n = 7,125 с n = 7,126 , тогда результатом {n:.2f} будет 7,13 :
>>>
>>> n = 7,126 >>> f"Значение n равно {n:.2f}" «Значение n равно 7,13»
Чтобы округлить до одного десятичного знака, замените .2 на .1 :
>>>
>>> n = 7,126 >>> f"Значение n равно {n:.1f}" «Значение n равно 7,1»
Когда вы форматируете число как фиксированную точку, оно всегда отображается с точным числом десятичных разрядов, которое вы укажете:
>>>
>>> n = 1 >>> f"Значение n равно {n:.2f}" «Значение n равно 1,00» >>> f"Значение n равно {n:.3f}" «Значение n равно 1.000»
Вы можете вставлять запятые для группировки целой части больших чисел тысячами с помощью опции , :
>>>
>>> n = 1234567890 >>> f"Значение n равно {n:,}" «Значение n равно 1 234 567 890»
Чтобы округлить до некоторого количества знаков после запятой, а также сгруппировать по тысячам, поставьте , до . в вашей спецификации форматирования:
>>>
>>> n = 1234,56 >>> f"Значение n равно {n:,.2f}" «Значение n равно 1 234,56»
Спецификатор ,.2f полезен для отображения значений валюты:
>>>
>>> остаток = 2000.0 >>> потрачено = 256,35 >>> остаток = баланс - потрачено >>> f"Потратив ${spent:.2f}, у меня осталось ${осталось:,.2f}" «Потратив 256,35 долларов, у меня осталось 1743,65 долларов».
Еще одна полезная опция — % , которая используется для отображения процентов. Опция % умножает число на 100 и отображает его в формате с фиксированной точкой, за которым следует знак процента.
Опция % всегда должна идти в конце спецификации форматирования, и ее нельзя смешивать с опцией f . Например, .1% отображает число в процентах ровно с одним десятичным знаком:
>>>
>>> соотношение = 0,9 >>> f"Более {соотношение:. 1%} питонистов говорят: "Настоящий питон рулит!"" «Более 90,0% питонистов говорят: «Настоящий питон рулит!»» >>> # Отображение процентов с 2 знаками после запятой >>> f"Более {соотношение:.2%} питонистов говорят: "Настоящий питон рулит!"" «Более 90,00% питонистов говорят: «Настоящий питон крут!»
Мини-язык форматирования мощный и обширный. Здесь вы видели только основы. Для получения дополнительной информации ознакомьтесь с официальной документацией.
Проверьте свое понимание
Разверните блок ниже, чтобы проверить, что вы поняли:
Напечатайте число 150000 в качестве валюты с тысячами, сгруппированными запятыми. Валюта должна отображаться с двумя десятичными знаками и начинаться с символа доллара США.
Вы можете развернуть блок ниже, чтобы увидеть решение:
Давайте наращивать нашу струну шаг за шагом.
Во-первых, f-строка, отображающая значение 150000 без форматирования выглядит так:
>>>
>>> f"{150000}" 150000
Это может выглядеть немного странно, но это настраивает вас на добавление спецификаторов форматирования.
Чтобы значение отображалось как число с плавающей запятой, поставьте двоеточие ( : ) после числа 150000 , а затем букву f :
>>>
>>> f "{150000:ф}" '150000.000000'
По умолчанию Python отображает число с точностью до шести знаков после запятой. Валюта должна иметь только два десятичных знака точности, поэтому вы можете добавить .2 между : и f :
>>>
>>> f"{150000:.2f}" '150000,00'
Чтобы отобразить число с цифрами, сгруппированными запятыми, вставьте запятую (, ) между двоеточием (: ) и точкой (. ):
>>>
>>> f"{ 150000:,.2f}" «150 000,00»
Наконец, добавьте знак доллара ( $ ) в начале строки, чтобы указать, что значение указано в долларах США:
>>>
>>> f"${150000:,. 2f}" «150 000 долларов США»
F-строки — это всего лишь один из способов форматирования чисел для отображения. Ознакомьтесь с руководством по новым методам форматирования строк в Python, чтобы узнать о других способах форматирования чисел и другого текста в Python.
Когда вы будете готовы, вы можете перейти к следующему разделу.

Python — один из немногих языков программирования со встроенной поддержкой комплексных чисел. Хотя комплексные числа не часто встречаются за пределами областей научных вычислений и компьютерной графики, поддержка Python для них является одной из его сильных сторон.
Если вы когда-либо посещали уроки предварительного исчисления или алгебры более высокого уровня, то вы, возможно, помните, что комплексное число — это число, состоящее из двух отдельных компонентов: реальной части и мнимой части.
Для любого комплексного числа его сопряженное является комплексным числом с той же действительной частью и мнимой частью, которая является той же по модулю, но с противоположным знаком. Таким образом, в этом случае комплексно-сопряженное число 1 + 2j равно 1 - 2j .
За исключением оператора деления пола ( // ), все арифметические операторы, работающие с числами с плавающей запятой и целыми числами, также будут работать с комплексными числами. Поскольку это не учебник по математике для продвинутых пользователей, мы не будем обсуждать механику сложной арифметики. Вместо этого вот несколько примеров использования комплексных чисел с арифметическими операторами:
Для вещественных и целых чисел .real и .conjugate() всегда возвращают само число, а .imag всегда возвращает 0 . Однако следует отметить, что n.real и n.imag возвращают целое число, если n является целым числом и числом с плавающей запятой, если n является числом с плавающей запятой.
Теперь, когда вы ознакомились с основами работы с комплексными числами, вам может быть интересно, когда вам понадобится их использовать. Если вы изучаете Python для веб-разработки, науки о данных или программирования общего назначения, правда в том, что вам может никогда не понадобиться использовать комплексные числа.
С другой стороны, комплексные числа важны в таких областях, как научные вычисления и компьютерная графика. Если вы когда-либо работали в этих областях, вам может пригодиться встроенная в Python поддержка комплексных чисел.
Независимо от вашего уровня владения числами и математикой, теперь вы готовы выполнять все виды вычислений в своем коде Python. Вы можете использовать эти знания для решения широкого круга проблем, с которыми вы столкнетесь в своей карьере программиста.
Одна из важных вещей, которую следует помнить в python, это то, что в нем нет символа “{” для обозначения блоков кода, как в любых других языках программирования. В python это обрабатывается совершенно по-другому, набор операторов устанавливается в один блок, когда они следуют одинаковым отступам. т. е. если 4 оператора имеют пространство табуляции (4 пробела для одной табуляции) в начале каждого оператора, они образуют один блок кода. Это важно знать при работе с условными и циклическими структурами.
#инициализируйте переменную “numbers” количеством чисел, которые вы хотите напечатать. #В Python вам не нужно объявлять переменные для определенного типа данных. числа = 10; #для цикла в соответствии с синтаксисом python для числа в диапазоне (1, числа): напечатать число; #следующий оператор python в этой программе находится вне цикла for, #поскольку перед оператором нет 4 пробелов. #Каждый оператор внутри цикла for идентифицируется по количеству пробелов перед каждым оператором. print “Это выражение вне цикла for”;
1
2
3
4
5
6
7
8
10
110007
12
13
14
15
#инициализируйте переменную “numbers” с количеством чисел, которые вы хотите напечатать.
#В Python вам не нужно объявлять переменные для определенного типа данных.

числа = 10;

#для цикла в соответствии с синтаксисом Python

#следующий оператор python в этой программе находится вне цикла for,
#поскольку перед оператором нет 4 пробелов.
#Каждый оператор внутри цикла for идентифицируется по количеству пробелов перед каждым оператором.

print “Это выражение вне цикла for”;
#инициализируйте переменную “num”, “numbers” начальным номером и количеством чисел, которые вы хотите напечатать соответственно. #В Python вам не нужно объявлять переменные для определенного типа данных. число = 1; числа = 10; #в то время как цикл согласно синтаксису python в то время как (число<=10): напечатать число; число = число + 1; #следующий оператор python в этой программе находится вне цикла while, #поскольку перед оператором нет 4 пробелов. #Каждый оператор внутри цикла while идентифицируется по количеству пробелов перед каждым оператором. print “Этот оператор находится вне цикла while”;
1
2
3
4
5
6
7
8
10
110007
12
13
14
160007
160007
160007
#инициализируйте переменную “num”, “numbers” начальным номером и количеством чисел, которые вы хотите распечатать соответственно.
#В Python вам не нужно объявлять переменные для определенного типа данных.

число = 1;
числа = 10;

#цикл while в соответствии с синтаксисом Python

while (num<=10):
print num;
число = число + 1;

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

print “Это выражение находится вне цикла while”;
Основатель TestingTools.co, постоянно делится знаниями о различных инструментах автоматизации тестирования. Имеет опыт разработки концепций, решений, фреймворков, платформ и реализации проектов автоматизации тестирования.
В отличие от других программ Microsoft Office, в Excel нет кнопки для автоматической нумерации данных. Но вы можете легко добавлять последовательные числа к строкам данных, перетаскивая маркер заполнения, чтобы заполнить столбец серией чисел, или с помощью функции ROW.
Совет: Если вы ищете более совершенную систему автоматической нумерации для своих данных и на вашем компьютере установлен Access, вы можете импортировать данные Excel в базу данных Access. В базе данных Access можно создать поле, которое автоматически генерирует уникальный номер при вводе новой записи в таблицу.
Примечание. Когда вы перетаскиваете маркер заполнения по каждой ячейке, Excel отображает предварительный просмотр значения. Если вам нужен другой узор, перетащите маркер заполнения, удерживая нажатой правую кнопку, а затем выберите узор.
Примечание. Эти номера не обновляются автоматически при добавлении, перемещении или удалении строк. Вы можете вручную обновить последовательную нумерацию, выбрав два числа в правильной последовательности, а затем перетащив маркер заполнения в конец пронумерованного диапазона.
org/ItemList”>
В первой ячейке диапазона, который вы хотите пронумеровать, введите =СТРОКА(A1) .
Функция ROW возвращает номер строки, на которую вы ссылаетесь. Например, =СТРОКА(A1) возвращает число 1 .
Перетащите маркер заполнения через диапазон, который вы хотите заполнить.
Совет: Если вы не видите дескриптор заполнения, возможно, вам придется сначала отобразить его. Дополнительные сведения см. в разделе Отображение или скрытие маркера заполнения.
Эти числа обновляются, когда вы сортируете их с вашими данными. Последовательность может быть прервана, если вы добавляете, перемещаете или удаляете строки. Вы можете вручную обновить нумерацию, выбрав два числа в правильной последовательности, а затем перетащив маркер заполнения в конец пронумерованного диапазона.
Если вы используете функцию ROW и хотите, чтобы числа вставлялись автоматически при добавлении новых строк данных, превратите этот диапазон данных в таблицу Excel. Все строки, добавляемые в конец таблицы, нумеруются последовательно. Дополнительные сведения см. в статье Создание или удаление таблицы Excel на листе.
Чтобы ввести определенные последовательные числовые коды, такие как номера заказов на поставку, вы можете использовать ROW вместе с функцией TEXT . Например, чтобы начать нумерованный список с помощью 000-001 , введите формулу =ТЕКСТ(СТРОКА(A1);”000-000″) в первую ячейку диапазона, который вы хотите пронумеровать, и затем перетащите маркер заполнения в конец диапазона.

В Excel 2010 и более поздних версиях щелкните вкладку Файл и щелкните Параметры .
В Excel 2007 нажмите кнопку Microsoft Office и выберите Параметры Excel .
В категории Дополнительно в разделе Параметры редактирования установите или снимите флажок Включить маркер заполнения и перетаскивание ячеек , чтобы отобразить или скрыть маркер заполнения.