Как решить пример в питоне
Перейти к содержимому

Как решить пример в питоне

  • автор:

Примеры решения простых задач на языке Python

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

  • вычисление значения среднего в данном списке чисел;
  • замена значения двух чисел без использования временной переменной;
  • вычисление числа n + nn + nnn при заданном числе n;
  • написание заданного числа в обратном порядке;
  • проверка знака числа;
  • определение успеваемости студента по его оценкам;
  • вывод всех чисел в заданном диапазоне, кратных определенному числу;
  • вывод результата целочисленного деления и остатка;
  • считывание трех чисел и вывод всех возможных перестановок этих чисел;
  • вывод всех нечетных чисел в заданном диапазоне;
  • нахождение суммы всех цифр заданного числа;
  • нахождение наименьшего делителя целого числа;
  • нахождение количества цифр в числе;
  • проверка, является ли введенное число палиндромом;
  • вывод всех целых чисел, которые не делятся на 2 и 3, в диапазоне от 1 до 50;
  • программа, считывающая число n и выводящая сумму 1 + 2 + 3 +… + n;
  • программа, считывающая число n и выводящая все промежуточные суммы от 1 до n;
  • вывод единичной матрицы;
  • вывод n рядов, заполненных значком ‘*’, количество которых убывает от начала к концу;
  • поиск и вывод всех простых числе в заданном диапазоне с использованием решета Эратосфена.

Как решить простое уравнение Python

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

from sympy import symbols, solve, parse_expr, simplify from sympy.parsing.sympy_parser import standard_transformations, implicit_multiplication_application transformations = (standard_transformations + (implicit_multiplication_application,)) formula = "x(4x+22)-(3x+44)^2=0" def map_operations(formula_str): return formula_str.replace("^", "**").replace("=", "-") f = parse_expr(map_operations(formula), transformations=transformations) roots = solve(f) #  
[-121/5 - 11*sqrt(41)/5, -121/5 + 11*sqrt(41)/5] 

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

In [7]: simplify(f) Out[7]: -5*x**2 - 242*x - 1936 In [8]: simplify(parse_expr("(x-1) * (x+1)")) Out[8]: x**2 - 1 

Как решить пример в питоне

Python поддерживает все распространенные арифметические операции:

    + Сложение двух чисел:

print(6 + 2) # 8
print(6 - 2) # 4
print(6 * 2) # 12
print(6 / 2) # 3.0
print(7 / 2) # 3.5 print(7 // 2) # 3
print(6 ** 2) # Возводим число 6 в степень 2. Результат - 36
print(7 % 2) # Получение остатка от деления числа 7 на 2. Результат - 1

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

Пусть у нас выполняется следующее выражение:

number = 3 + 4 * 5 ** 2 + 7 print(number) # 110

Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).

Чтобы переопределить порядок операций, можно использовать скобки:

number = (3 + 4) * (5 ** 2 + 7) print(number) # 224

Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.

Арифметические операции с присвоением

Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:

  • += Присвоение результата сложения
  • -= Присвоение результата вычитания
  • *= Присвоение результата умножения
  • /= Присвоение результата от деления
  • //= Присвоение результата целочисленного деления
  • **= Присвоение степени числа
  • %= Присвоение остатка от деления
number = 10 number += 5 print(number) # 15 number -= 3 print(number) # 12 number *= 4 print(number) # 48

Округление и функция round

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

first_number = 2.0001 second_number = 5 third_number = first_number / second_number print(third_number) # 0.40002000000000004

В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:

print(2.0001 + 0.1) # 2.1001000000000003

В случае выше для округления результата мы можем использовать встроенную функцию round() :

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number)) # 2

В функцию round() передается число, которое надо округлить. Если в функцию передается одно число, как в примере выше, то оно округляется до целого.

Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number, 4)) # 2.1001

В данном случае число third_number округляется до 4 знаков после запятой.

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

# округление до целого числа print(round(2.49)) # 2 - округление до ближайшего целого 2 print(round(2.51)) # 3

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

print(round(2.5)) # 2 - ближайшее четное print(round(3.5)) # 4 - ближайшее четное

Округление производится до ближайшего кратного 10 в степени минус округляемая часть:

# округление до двух знаков после запятой print(round(2.554, 2)) # 2.55 print(round(2.5551, 2)) # 2.56 print(round(2.554999, 2)) # 2.55 print(round(2.499, 2)) # 2.5

Однако следует учитывать, что функция round() не идеальный инструмент. Например, выше при округление до целых чисел применяется правило, согласно которому, если округляемая часть одинаково удалена от двух значений, то округление производится до ближайшего четного значения. В Python в связи с тем, что десятичная часть числа не может быть точно представлена в виде числа float, то это может приводить к некоторым не совсем ожидаемым результатам. Например:

# округление до двух знаков после запятой print(round(2.545, 2)) # 2.54 print(round(2.555, 2)) # 2.56 - округление до четного print(round(2.565, 2)) # 2.56 print(round(2.575, 2)) # 2.58 print(round(2.655, 2)) # 2.65 - округление не до четного print(round(2.665, 2)) # 2.67 print(round(2.675, 2)) # 2.67

Подобно о проблеме можно почитать к документации.

  • Вопросы для самопроверки
  • Упражнения для самопроверки

Математические (арифметические) операторы. Примеры

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

  • ** – возведение в степень;
  • –x – унарный минус;
  • / , // – обычное деление, деление с округлением вниз (одинаковый приоритет);
  • % – остаток от деления;
  • * – умножение;
  • – вычитание;
  • + – сложение.
2. Для каких категорий числовых типов можно применять математические операторы?

Математические операторы можно применять для любых числовых типов, а именно:

  • целочисленных (типов);
  • вещественных;
  • комплексных.
3. Каким образом вычисляется тип результата операции в случае если операция есть бинарной и содержит операнды различных типов?

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

Здесь возможны два случая:

  • операнды имеют одинаковый тип. В этом случае тип результата операции есть этот же тип. Исключение составляет операция деления / целочисленных операндов. Если оба операнда целого типа, то результат операции деления будет иметь вещественый тип (число с плавающей запятой);
  • операнды имеют разные типы. В этом случае тип результата операции будет определяется в следующей последовательности: сначала тип обоих операндов приводится к типу более сложного операнда; затем для операндов применяется математика, специфическая для этого типа.

Интерпретатор Python определяет сложность типов в такой последовательности (от простого к более сложному):

  • целый тип;
  • вещественный тип;
  • комплексный тип.

В Python 2.6 (при необходимости) обычные целые числа могут быть преобразованы в длинные целые числа. В Python 3.0 и выше этого ранжирования уже нет и все целые числа представлены как длинные целые числа.

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

4. Операция возведения в степень ** . Пример

Операция возведения в степень обозначается ** и используется для операндов любых числовых типов (целочисленных, вещественных, комплексных).

# Операция ** - возведение в степень # 1. Для целых чисел a = 3 b = 2 c = a**b # c = 9 print("c color: #ff0000;"># 2. Для вещественных чисел a = 2.5 b = 3 c = a**b # c = 15.625 print('c = ', c) # 3. Для комплексных чисел x = 1 - 2j y = -4j z = x**y # z = (-0.011895629765035814+0.0009211666704635043j) print('z = ', z) # 4. В 16-й системе исчисления a = 0xA1 b = 0x03 c = a**b # c = 4173281 - результат в 10-й системе исчисления d = hex(c) # d = 0x3fade1 - результат в 16-й системе исчисления print('c = ', c) print('d = ', d) # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a**b # c = 56644 - результат в 10-й системе исчисления d = oct(c) # d = 0o156504 - результат в 8-й системе исчисления print('c = ', c) print('d = ', d) # 6. В 2-й системе исчисления a = 0b101 b = 0b110 c = a**b # c = 15625 - результат в 10-й системе исчисления d = bin(c) # d = 0b11110100001001 - результат в 2-й с/и print('c = ', c) print('d = ', d)
5. Операции сложения ( + ), вычитания ( – ). Примеры

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

# Операция сложения +, вычитания - # 1. Сложение, вычитание целых чисел a=3 b=5 c = a+b #c = 8 d = a-b # d = -2 # 2. Сложение, вычитание целого и вещественного чисел a = 2.5 b = 7 c = a + b # c = 9.5 - результат - вещественное число d = a - b # d = -4.5 - результат - вещественное число # 3. Сложение, вычитание вещественных чисел x = 8.99902 y = 9.112356 z = x+y # z = 18.111376 v = x-y # v = -0.11333600000000033 # 4. Сложение, вычитание комплексных чисел, результат - комплексное число a = 7+8j b = 3-2j c = a + b # c = (10+6j) d = a - b # d = (4+10j) # 5. Сложение, вычитание чисел в шестнадцатеричной системе исчисления a = 0xFF5 b = 0xC9 c = a + b # c = 4286 - в десятичной системе исчисления d = a - b # d = 3884 # 6. Сложение, вычитание чисел в восьмеричной системе исчисления a = 0o730 b = 0o50 c = a + b # c = 512 d = a - b # d = 432 # 7. Сложение, вычитание чисел в двоичной системе исчисления a = 0b0110110 b = 0b0001010 c = a + b # c = 64 - результат в десятичной системе исчисления d = a - b # d = 44
6. Операции умножения ( * ) и обычного деления ( / ). Пример

Операции умножения * и деления / есть бинарными. Эти операции используются с операндами любого числового типа (целого, вещественного, комплексного).

# Операции умножения * и обычного деления / # 1. Для целых чисел a = 7 b = 4 c = a*b # c = 28 - целый результат d = a/b # d = 1.75 - вещественный результат # 2. Для вещественных чисел a = 7.5 b = 3.2 c = a*b # c = 24.0 - вещественный результат d = a/b # d = 2.34375 # 3. Для комплексных чисел x = 2 + 2j y = 3 - 1j z = x*y # z = (8+4j) v = x/y # v = (0.4+0.7999999999999999j) # 4. В 16-й системе исчисления a = 0xaff b = 0x5b c = a*b # c = 256165 - результат в 10-й системи исчисления d = a/b # d = 30.934065934065934 - вещественное число # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a*b # c = 476 d = a/b # d = 119.0 # 6. В 2-й системе исчисления a = 0b111 # a = 35 b = 0b101 # b = 5 c = a*b # c = 35 - результат в 10-й системе исчисления d = a/b # d = 1.4 - результат в 2-й системе исчисления
7. Особенности операции деления / для различных типов чисел. Пример

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

При использовании операции деления для целочисленных операндов в таких языках как C/C ++, C#, Java результат операции будет целочисленным. В версиях Python 2.6 и ниже операция деления целочисленных операндов также дает целочисленный результат, то есть после деления

a = 9/6 # a = 1 - версии Python 2.6 и ниже

переменная a = 1.

В версии Python 3.0 и выше результат операции деления / всегда будет вещественное число (независимо от типов операндов), то есть после деления

a = 9/6 # a = 1.5 - версии Python 3.0 и выше

переменная a имеет вещественный тип (a = 1.5). Если в версии Python 3.0 и выше при делении целочисленных операндов нужно вернуть целое число, то для этого используется операция деления с округлением вниз // (см. п. 8).

Пример.

# Для целых чисел (целочисленных операндов) a = 7 b = 4 c = a/b # c = 1.75 - результат вещественный a = 9 b = 3 c = a/3 # c = 3.0 - результат также вещественный
8. Операция деления с округлением вниз // . Пример

В версиях Python 2.2 и выше введена операция // деления с округлением вниз, которая в случае целочисленных операндов возвращает результат целого типа. В версиях Python 3.0 и выше эта операция заменяет целочисленное деление с возвращением целочисленного результата.

Пример.

# Операция деления // с округлением вниз, Python 3.7.0 # 1. Для целых чисел a = 8 b = 5 c = a // b # c = 1 a = 17 b = 3 c = a//b # c = 5 - целый результат с округлением вниз # 2. Для вещественного и целого числа x = 6.0 y = 2 z = x//y # z = 3.0 - вещественный результат # 3. Для вещественных чисел x = 5.5 y = 2.5 z = x//y # z = 2.0 - вещественный результат с округлением вниз x = 13.7 y = 2.3333 z = x//y # z = 5.0 - вещественный результат с округлением вниз
9. Операция «унарный» минус ( –x ). Пример

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

# Унарный минус -x a = 15 b = -a # b = -15 - унарный минус a = -12.35 b = -a # b = 12.35 a = 0xFF b = -a # b = -255 - десятичная система исчисления c = hex(b) # c = -0xff a = 0o775 # восьмеричная система исчисления b = -a c = oct(b) # c = -0o775 a = 0b1111001 b = -a # b = -121 - десятичная система исчисления c = bin(b) # c = -0b1111001 - двоичная система исчисления # Комплексное число z = 2 - 8j z = -z # z = (-2+8j)
10. Операция взятия остатка от деления ( % ). Пример
# Операция взятия остатка от деления # 1. Для целых чисел a = 7 b = 4 c = a%b # c = 3 a = 5 b = 9 c = a % b # c = 5 # 2. Для вещественных чисел a = 5.5 b = 2.1 c = a%b # c = 1.2999999999999998 a = -8.1 b = -1.01 c = a%b # c = -0.019999999999999574 # 3. Для шестнадцатеричных чисел a = 0xA8 b = 0x0F c = a%b # c = 3 - результат в десятичной системе d = hex(c) # d = 0x3 - результат в 16-й системе # 4. Для восьмеричных чисел a = 0o15 b = 0o25 c = a % b # c = 13 d = oct(c) # d = 0o15 # 5. Для двоичных чисел a = 0b10011 b = 0b101 c = a%b # c = 4 d = bin(c) # d = 0b100

Связанные темы

  • Операторы (операции) для работы с числовыми объектами. Таблица приоритетности операторов
  • Смешивание типов. Преобразование типов в операторах
  • Операторы сравнения

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *