Типы данных в Python подробно. Тип данных в python.

Содержание

# пример присваивания ссылочного объекта link = ‘Ipona’, ‘Master Sword’ alin = link link0 = ‘Zelda’ print(link)>’Zelda’, ‘Master Sword’ print(alin)>Зельда», «Мастер меча».

Основы Python: полный список типов данных

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

В Python существует несколько типов данных. К наиболее важным типам относятся:

Числовые данные: int, float, complex (целые числа, числа с плавающей точкой, комплексные числа)
Строковые: str (строки)
Последовательные: list, tuple, range (список, кортеж, диапазон)
Бинарные типы: bytes, bytearray, memoryview (байты, массивы байтов, представление памяти)
Ассоциативные данные: dict (словари)
Логический тип: bool (булевый тип)
Множественные: set, frozenset (множество, замороженное множество)

1: Числовой тип данных Python

Тип Numeric в Python используется для хранения числовых значений, таких как,

int – целые числа неограниченной длины.
long —длинные целые числа (существует в Python 2.x, устарел в Python 3.x).
float — содержит числа с плавающей точкой (точность до 15 знаков после запятой).
complex – содержит комплексные числа.

Когда вы объявляете переменную в Python, вам не нужно объявлять тип данных, как в C или C++. Вы можете просто присваивать значения переменной. Чтобы узнать, какое числовое значение содержит переменная, мы можем использовать функцию type():

#Создайте переменную с целым значением. a=100 print("Тип переменной, имеющей значение", a, " is ", type(a)) #Создайте переменную с плавающим значением. b=10.2345 print("Тип переменной, имеющей значение", b, " is ", type(b)) #Создайте переменную со сложным значением. c=100+3j print("Тип переменной, которая имеет значение", c, " is ", type(c))

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

2: Строковый тип данных Python

Строка — это последовательность символов. Python поддерживает символы Юникода. Обычно строки указываются в одинарных или двойных кавычках.

a = "строка в кавычках" b = "строка в одних кавычках" print(a) print(b) #использует ',' для объединения двух или более строк print(a, "concatenated with",b) #использует '+' для объединения двух или более строк print(a+" concatenated with "+b)

Этот код дает следующий результат:

3: Списки в Python

Список — это универсальный тип данных, уникальный для Python. В некотором смысле это то же самое, что и таблицы в C/C++. Однако в Python списки обладают интересным свойством: список может одновременно содержать различные типы данных. Обычно список — это упорядоченная последовательность данных, которая записывается с круглыми скобками () и запятыми (,).

#Список, содержащий только целые числа a= 1,2,3,4,5,6 print(a) #Список, содержащий только строки b="hello", "john", "reese" print(b) #Список, содержащий и целые числа, и строки c="hey", "you",1,2,3, "go" print(c) #Индекс равен 0 с базой. Это выведет один символ print(c1) #Это выведет "вы" в списке c.

Этот код дает следующий результат:

Числовой тип данных

int – содержит целые числа со знаком неограниченной длины.
long – содержит длинные целые числа (существует в Python 2.x, не рекомендуется в Python 3.x).
float – содержит числа с плавающей точкой с точностью до 15 десятичных знаков.
комплексный – содержит комплексные числа.

В Python нам не нужно указывать тип данных при объявлении переменной, как это делается в C или C+. Мы можем просто присвоить значения переменным. Но если мы хотим узнать, какое числовое значение он содержит в данный момент, мы можем использовать, например, type():

# создать переменную с целым значением. a = 100 print ("Тип переменной, имеющей значение", a, "is", type (a)) # создать переменную со значением с плавающей точкой. b = 10.2345 print ("Тип переменной со значением", b, "is", type (b)) # Создайте переменную со сложным значением. c = 100 + 3j print ("Тип переменной, имеющей значение", c, "is", type (c)).

Если вы выполните приведенный выше код, вы получите результат, показанный на следующем рисунке.

Тип данных String

Строка — это последовательность символов. Python поддерживает символы Юникода. Обычно строки представляются одинарными или двойными кавычками.

a = 'строка в кавычках' b = 'строка в одних кавычках' print (a) print (b) # используйте ',' для объединения двух или более строк print (a, 'concatenated with', b) # используйте '+' для объединения двух или более строк print (a + 'concatenated with' + b)

Приведенный выше код выдает результат, показанный на следующем рисунке:

Списка

Список — это универсальный тип данных, который существует только в Python. В некотором смысле это то же самое, что и таблица в C/C++. Однако список в Python интересен тем, что он может одновременно содержать различные типы данных. Список обычно представляет собой упорядоченную последовательность данных, записанных с использованием круглых скобок () и запятых (,).

# список только целых чисел a = 1,2,3,4,5,6 print (a) # список только строк b = "hello", "John", "reese" print (b) # список, содержащий и целые числа, и строки c = "hey", "you", 1,2,3, "go" print (c) # индекс основан на 0. это выведет один символ print (c 1) # это выведет "you" в списке c

Приведенный выше код выдает такой результат:

Модель данных

Давайте рассмотрим, как создаются объекты в памяти, их структуру, процесс объявления новых переменных и как работает операция присваивания.

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

обозначает переменную b и присваивает ей значение 5.

Целое значение 5 по сути является объектом в Python. Объект в данном случае — это абстракция для представления данных; данные — это числа, списки, строки и т.д. Однако под данными следует понимать как сами объекты, так и отношения между ними (подробнее об этом позже). Каждый объект имеет три атрибута — идентификатор, значение и тип. Идентификатор — это уникальный атрибут объекта, позволяющий отличать объекты друг от друга, а значение — это информация, хранящаяся непосредственно в памяти, которой управляет интерпретатор.

Когда переменная инициализируется на уровне интерпретатора, происходит следующее:

создается целочисленный объект 5 (можно представить, что в этот момент создается ячейка и 5 кладется в эту ячейку);
данный объект имеет некоторый идентификатор, значение: 5, и тип: целое число;
посредством оператора “=” создается ссылка между переменной b и целочисленным объектом 5 (переменная b ссылается на объект 5).

Имя переменной не должно совпадать с ключевыми словами интерпретатора Python. Список ключевых слов можно найти здесь. Вы также можете получить их непосредственно в программе, включив модуль ключевых слов и используя команду keyword.kwlist.

>>>импортироватьключевое слово>>>вывести("Ключевые слова Python:", keyword.kwlist)

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

>>>keyword.iskeyword("попробовать")Правда>>>keyword.iskeyword("b")Ложь

Функция id() может быть использована для просмотра объекта, на который ссылается переменная.

>>>a=4>>>b=5>>>id(a)1829984576>>>id(b)1829984592>>>a=b>>>id(a)1829984592

Как видно из примера, идентификатор — это целочисленное значение, по которому объект имеет уникальный адрес. В начале переменная a ссылается на объект 4 с ID 1829984576, переменная b ссылается на объект с ID = 1829984592. После выполнения операции присваивания a = b переменная a ссылается на тот же объект, что и b .

Изменяемые и неизменяемые типы данных

В Python существуют плавающие и неизменяемые типы.

К неизменяемым типам относятся ints, float, complexes, bools, tuples, str и замороженные множества.

К изменяемым типам относятся: Списки ( list ), множества ( set ), словари ( dict ).

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

Неизменяемость типа данных означает, что созданный объект больше не изменяется. Например, если мы объявляем переменную k = 15, то создается объект со значением 15, типом int и идентификатором, который можно определить с помощью функции id().

>>>k=15>>>id(k)1672501744>>>Тип(k)Класс'int'>

Объект с id = 1672501744 имеет значение 15 и не может быть изменен.

Если тип данных может быть изменен, то значение объекта может быть изменено. Например, создадим список 1, 2 и заменим второй элемент на 3.

>>>a=1,2>>>id(a)47997336>>>a1=3>>>a1,3>>>id(a)47997336

Как видите, объект, на который ссылается переменная α, был изменен. Это можно проиллюстрировать следующим рисунком.

P.S.

Если вы интересуетесь темой анализа данных, вам следует ознакомиться с библиотекой Pandas. Вы можете найти вводные уроки по этой теме на нашем сайте. Все уроки по библиотеке Pandas кратко изложены в книге «Pandas — работа с данными».

Артем 25.04.2018 У Вас в коде>>>print “Python keywords: “, keyword.kwlist не хватает круглых скобок:>>>print(“Python keywords: “, keyword.kwlist)

Complex Numbers

>>>2+3j(2+3j)>>>Тип(2+3j)

Строки — это строки символьных данных. Строковый тип в Python называется str .

Буквенно-цифровые строки могут быть разделены одинарными или двойными кавычками. Все символы между заключенным в кавычки разделителем и соответствующим вложенным разделителем являются частью строки:

>>>вывести("Я - струна".)Я - струна.>>>Тип("Я - струна".)>>>вывести(Я тоже.)Я тоже.>>>Тип(Я тоже.)

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

Что если вы хотите включить инвертированную запятую как часть самой строки? Вашим первым побуждением может быть попытка сделать что-то подобное:

>>>вывести(Эта строка содержит одинарную кавычку (')персонаж.')SyntaxError: Неверный синтаксис

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

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

>>>вывести("Эта строка содержит одну инвертированную запятую (')".)Эта строка содержит одну перевернутую запятую (').>>>вывести("Эта строка содержит двойную кавычку ("").)Эта строка содержит двойную кавычку ("").

Escape Sequences in Strings

Иногда вы хотите, чтобы Python интерпретировал символ или последовательность символов в строке по-другому. Это может произойти двумя способами:

You may want to suppress the special interpretation that certain characters are usually given within a string.
You may want to apply special interpretation to characters in a string which would normally be taken literally.

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

Давайте посмотрим, как это работает.

Suppressing Special Character Meaning

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

Boolean Type, Boolean Context, and “Truthiness”

Python 3 предоставляет тип данных Boolean. Объекты типа Boolean могут принимать одно из двух значений, True или False:

>>>Тип(Правда)>>>Тип(Ложь)

Как вы увидите в следующих уроках, выражения в Python часто оцениваются в булевом контексте, т.е. интерпретируются как true или false. Значение, которое является истинным в булевом контексте, иногда называют «true», а значение, которое является ложным в булевом контексте, называют «false». (Вы также можете написать «falsy» как «фальшивый»).

Истинность» булева объекта самоочевидна: булевы объекты, равные True, являются истинными, а равные False — ложными. Но небулевы объекты также могут быть оценены в булевом контексте и определены как истинные или ложные.

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

Built-In Functions

Интерпретатор Python поддерживает множество встроенных функций: шестьдесят восемь (по состоянию на Python 3.6). Со многими из них вы познакомитесь в последующих обсуждениях, когда они будут появляться в контексте.

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

Math

Функция	Описание
abs()	Возвращает абсолютное значение числа
divmod()	Возвращает коэффициент и остаток от деления целого числа
max()	Возвращает наибольший из указанных аргументов или элементов в итерационном массиве.
min()	Возвращает наименьший из указанных аргументов или элементов в итерационном массиве.
pow()	Возводит число в степень.
round()	Округляет число с плавающей запятой
sum()	Суммирует элементы итерационной таблицы

Type Conversion

Функция	Описание
ascii()	Возвращает строку, содержащую печатное представление объекта.
bin()	Преобразование целого числа в двоичную строку
bool()	Преобразует аргумент в булево значение
chr()	Возвращает строковое представление символа, указанного целочисленным аргументом.
комплекс()	Возвращает комплексное число, составленное из аргументов
float()	Возвращает объект с плавающей точкой, построенный из числа или строки.
hex()	Преобразует целое число в шестнадцатеричное буквенно-цифровое число.
int()	Возвращает целочисленный объект, построенный из числа или строки.
oct()	Преобразует целое число в восьмеричную строку.
ord()	Возвращает целочисленное представление символа.
repr()	Возвращает строку, содержащую печатное представление объекта.
str()	Возвращает строку объекта
type()	Возвращает тип объекта или создает новый объект типа

Iterables and Iterators

Функция	Описание
all()	Возвращает true, если все элементы итерации истинны.
any()	Возвращает true, если любой элемент итеративного ряда является true.
перечислить()	Возвращает список кортежей с указателями и значениями из итерационного ряда.
filter()	Фильтрует элементы из итеративного массива.
iter()	Возвращает объект итератора
len()	Возвращает длину объекта
map()	Применяет функцию к каждому объекту таблицы итераторов
next()	Получает следующий элемент из итератора
диапазон()	Создает диапазон целочисленных значений
reversed()	Возвращает обратный итератор
slice()	Возвращает объект среза
sorted()	Возвращает отсортированный список из таблицы итератора
zip()	Создает итератор, который суммирует элементы из итерируемых таблиц.

Последовательности

Еще одно математическое понятие. Там последовательность — это пронумерованный набор элементов, в котором возможны повторения, причем важен порядок. Определение в Python похоже на определение в математике: последовательность здесь — это упорядоченная коллекция объектов.

str (строка)

Строки — это, пожалуй, единственный объект, который по удобству использования можно сравнить с числовым типом данных. Тавтологичное, но полное определение, применимое к Python, звучит следующим образом:

Строка — это последовательность строк отдельных символов.

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

list (список)

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

# пример списка list_of_lists = ‘code alpha’, ‘code beta’, 553, 434 list_of_lists01 = ‘code omega’ print(list_of_lists)>»Код Альфа», «Код Омега», 553, 434

Само название списков указывает на то, что они являются объектами для хранения записей. Список покупок, подарков, результатов сопоставления, IP-адресов клиентов или объектов типа «студент». Списки в Python, как и таблицы в других языках, «на максимумах».

tuple (кортеж)

Кортежи в Python можно рассматривать как неизменяемые списки, в которых все включено:

# пример кортежа tup = (‘i’, ‘j’) # мы можем получить первый элемент print(tup0)>i # но изменить его не получится tup0 = ‘k’>Traceback (most recent call last): tup0 = ‘k’ Ошибка типа: объект ‘tuple’ не поддерживает присвоение данных.

Использование кортежей оправдано, когда для программиста важна скорость или неизменяемость элементов последовательности.

dict (словарь)

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

# Пример простого словаря = словарь

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

set (множество)

Еще один «набор, но без порядка».

# Пример набора integer_num_set =.

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

# свойство уникальности unique_set = print(unique_set)>

Введение в тему

Данные не являются однородными. Информация, написанная на естественном языке, например, это предложение, сильно отличается от данных, состоящих из цифр. Слова можно спрягать, а числа умножать. Чтобы облегчить работу с такими разными данными, разработчики языков программирования разделили их на различные типы. Типы данных в Python не являются исключением. Мы обсудим это на данном уроке.

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

Типирование является таким механизмом.

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

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

example_variable = ‘Eggs’ print(type(example_variable)) example_variable = 500 print(type(example_variable)) example_variable = print(type(example_variable)) #Выход:

Но не переусердствуйте — для улучшения читабельности кода в большинстве случаев лучше ввести дополнительные переменные для данных с другими типами. Это полезно еще и потому, что переменные с хорошо подобранными именами являются альтернативой комментариям и объясняют, какого рода данные они хранят.

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

В последнее время набирает популярность подход «смешанной типизации». Наиболее ярким примером такого подхода является язык Rust: статическая типизация при входе и выходе из блока кода, но динамическая типизация внутри этого блока. Последние версии Python также делают шаг в этом направлении: появился такой инструмент, как Type Annotation или Type Hinting, но это тема отдельной статьи.

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

Создание гетерогенных коллекций. Благодаря тому, что в Python 3 типы данных определяются во время run time (выполнения программы), можно создавать наборы данных, состоящие их элементов различных типов. Делается это не сложно:

example_variable = ('eggs', 500, )

Абстрагирование в алгоритмах. Благодаря тому, что тип данных определяется «на лету», можно создавать универсальные алгоритмы, которые будут работать с любыми данными.
Длина кода. Если не описывать тип каждой переменной, код, конечно же получается короче и становится более высокоуровневым, читаемым.
Простота изучения. Поскольку преобразование типов – отдельная сложная тема, а в этих языках вся работа с типами происходит без участия программиста, то, естественно, на динамических языках проще писать и их легче учить.

Разница между атомарными и структурными типы данных

Все типы данных в Python можно разделить на атомарные и ссылочные.

списки;
множества;
кортежи;
словари;
функции;
классы;

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

example_variable1 = 'Eggs' example_variable2 = example_variable1 example_variable1 = 500 print(example_variable1) print(example_variable2) #Выход: 500 яиц
Вывод показывает, что переменная example_variable2 получила значение, содержащееся в example_variable1, а не ссылку на участок памяти.
Для ссылочных типов такой режим не предусмотрен:
example_variable1 = 'Eggs' example_variable2 = example_variable1 example_variable10 = 500 print(example_variable1) print(example_variable2) #Выход: 500 500 500 500
Поскольку списки являются структурированными (ссылочными) объектами, после присвоения переменной example_variable1 переменной example_variable2 передается ссылка на объект list, и при печати выводятся два одинаковых заголовка.
Вот в чем разница.
Числовые типы
Данные, представленные в виде чисел, - одна из самых важных вещей в программировании. В Python для работы с такими данными было создано несколько типов данных:
Int целое число
Понять целые числа очень просто. Самое простое определение: целые числа - это числа без дробей. Он может быть нулевым, положительным или отрицательным.
Пример_переменной1 = 500 Пример_переменной2 = Пример_переменной1 - 43 Пример_переменной3 = 2+2 print(Пример_переменной1, Пример_переменной2, Пример_переменной3) #Выход: 500 457 4
Когда есть числа, к ним можно применять математические операции. Целые числа используются для вычисления различных математических выражений. Также int используется для описания количественных характеристик объектов.
Float число с плавающей точкой
Вещественные или действительные числа (числа с плавающей точкой) созданы для измерения непрерывных величин. Поскольку языки программирования не способны реализовать иррациональные или бесконечные числа, всегда остается место для аппроксимации с некоторой точностью и, следовательно, некоторой неточностью, что может привести к следующим ситуациям:
print(0.11 + 0.11 + 0.11 + 0.11 + 0.11) print(0.1 + 0.1 + 0.1) print(0.2 * 6) print(0.3 * 3 == 0.9) #Вывод: 0.33 0.3000000000004 1.20000000000002 False
Оператор float ничем не отличается от оператора int:
Преобразование типов данных
Python позволяет менять типы данных "на лету". Это может быть очень полезно при обучении и решении практических задач.
Округление действительных чисел:
>>>a = float(input()) 5.123>>>print(int(a)) 5
Преобразование целого числа в действительное:
>>>a = 5>>>print(float(a)) 5.0
Преобразование строки в число и печать числа без ведущих нулей:
>>>a = '00032567'>>>print(int(a)) 32567
Добавьте строку и число:
>>>a = 'Apollo '>>>b = 13>>>print(a + str(b)) Аполлон 13
Преобразует список в строку:
>>>a = 'п', 'р', 'и', 'в', 'е', 'т'>>>print('*'.join(a)) p*r*i*v*e*t
Преобразует строку в массив:
>>>a = 'привет'>>>print(set(a))
Преобразует строку в список:
>>>a = 'я изучаю Python'>>>print(list(a)) 'I', ' ', 'y', 'h', 'y', 'h', 'h', 'a', 'y', 'P', 'y', 't', 'h', 'o', 'n'
Преобразует кортеж в список:
>>>a = ('red', 'blue', 'green')>>>print(list(a)) 'красный', 'синий', 'зеленый'
Преобразование типов данных, конечно, осуществляется в определенных пределах - буквенно-цифровое число, содержащее буквы и специальные символы, не может быть преобразовано в число, а преобразование списка, буквенно-цифрового числа, массива или кортежа в словарь требует дополнительных манипуляций, которые мы рассмотрим позже.
Практика – задачи с решениями
Задача 1. Напишите программу, которая запрашивает имя и возраст пользователя и выводит его приветствие и возраст в следующем году. Пример того, как работает программа:
Как вас зовут? Катя Здравствуйте Катя, сколько вам лет? 14 лет, отлично! В следующем году тебе исполнится 15 лет!
имя = input('Как тебя зовут? ') print(f 'Привет, !') возраст = int(input('Сколько тебе лет? ')) print(f 'Привет! В следующем году тебе будет !')
Задание 2. Напишите программу, которая запрашивает имя, фамилию и возраст пользователя и выводит эти данные в столбец, используя строку f. Результат программы:
Имя: Евгения Фамилия: Фролова Возраст: 19 лет
имя = input() фамилия = input() возраст = input() print(f'Name:
Family:
Age: ')
Напишите программу, которая печатает прямоугольник 5 x 15 из звездочек. Пример вывода:
print('*' * 15) print('*' + '*' * 13 + '*') print('*' + '*' * 13 + '*') print('*' + '*' * 13 + '*') print('*' * 15)
Задание 4 Напишите программу, которая принимает на вход целое число n в диапазоне от 1 до 9 включительно и выводит результат вычисления выражения nnn - nn - n. Например, если входное число равно 3, программа должна вывести 297 (333 - 33 - 3).
num1 = input() num2 = int(num1 * 2) num3 = int(num1 * 3) print(num3 - num2 - int(num1))
Задание 5. Напишите программу, которая принимает на вход целые положительные числа a и b, а затем выводит результаты математических операций в следующем формате:
Число a в степени b = 25 Произведение a * b = 10 Сумма a + b = 7 Разность a - b = 3
a, b = int(input()), int(input()) print('Число a в степени b =', a ** b) print('Произведение a * b =', a * b) print('Сумма a + b =', a + b) print('Разность a - b =', a - b) print('Разность a - b =', a - b)
Задача 6. Напишите программу, которая получает от пользователя вещественные числа a и b - длину и ширину прямоугольника - и выводит периметр и площадь прямоугольника в следующем формате:
Площадь S = 88,0 Периметр P = 38,0
Площадь вычисляется по формуле S = a * b, периметр P = 2 * (a + b) .
a, b = float(input()), float(input()) print('Площадь S =', a * b) print('Периметр P =', 2 * (a + b))
Задание 7. Напишите программу, которая принимает на вход число от 420 до 540 (оптимальное время сна в минутах) и помогает пользователю указать время (в формате "часы:минуты"), на которое должен быть установлен будильник. Обратный отсчет начинается в полночь.
Пример записи:
Установите будильник на 7:50 утра.
a, b = float(input()), float(input()) print('Площадь S =', a * b) print('Периметр P =', 2 * (a + b))
Задание 8: Напишите программу, которая получает на вход целое число n - количество дней - и преобразует n в годы, месяцы и дни.
Пример ввода:
Годы: 1 Месяцы: 1 Дни: 3
Подведем итоги
n = int(input("Введите количество дней: ")) years = n // 365 months = (n - years * 365) // 30 days = (n - years * 365 - months * 30) print(f'Years: Months: Days: ')

Особенности, сферы применения, установка, онлайн IDE
Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
Типы данных: преобразование и базовые операции
Методы работы со строками
Методы работы со списками и списковыми включениями