Конспект по типам данных в Python

В Python есть несколько основных типов данных: int, float, complex, str, bool, list, tuple, dict, set, None. 

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

1. Числовые типы данных:

   • int (целое число): представляет целочисленные значения, например, 5, -10, 1000.
   • float (число с плавающей точкой): представляет числа с плавающей точкой, например, 3.14, -2.5, 1e-3.
   • complex (комплексное число): представляет комплексные числа в форме a + bj, где a и b – это вещественные числа, а j – мнимая единица, например, 2 + 3j, -1j.

2. Строковые типы данных:

   • str (строка): представляет последовательность символов, заключенных в одинарные '' или двойные "" кавычки, например, 'Hello', "World", '123'.

3. Булев тип данных:

   • bool (логическое значение): представляет истину (True) или ложь (False).

4. Списки и кортежи:

   • list (список): представляет упорядоченную изменяемую коллекцию элементов, заключенных в квадратные [] скобки.
   • tuple (кортеж): представляет упорядоченную неизменяемую коллекцию элементов, заключенных в круглые () скобки.

5. Словари и множества:

   • dict (словарь): представляет неупорядоченную коллекцию пар ключ-значение, заключенных в фигурные {} скобки.
   • set (множество): представляет неупорядоченную коллекцию уникальных элементов, заключенных в фигурные {} скобки.

6. Другие типы данных:

   • None (ничто): представляет отсутствие значения или нулевое значение.

Рассмотрим подробнее каждый из этих типов.

Целые числа int

<class 'int'> означает, что объект относится к классу int, то есть это целое число.

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

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

Вы можете создать объект типа int, присвоив значение целого числа переменной. Вот пример:

x = 10
y = -5

Вы также можете использовать различные операции и методы с объектами типа int. Некоторые из них включают математические операции (сложение, вычитание, умножение, деление, возведение в степень), операции сравнения (равенство, неравенство, больше, меньше), а также методы для работы с числами (например, abs() для получения абсолютного значения).

a = 5 + 3 # сложение
b = 10 - 2 # вычитание
c = 2 * 4 # умножение
d = 10 / 2 # деление
e = 2 ** 3 # возведение в степень

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

num_str = "10"
num_int = int(num_str)

Класс int также предоставляет различные методы для работы с целыми числами, такие как bit_length() для определения количества бит, занимаемых числом.

num = 100
bits = num.bit_length()

Числа с плавающей запятой float

Класс <class 'float'> в Python представляет числа с плавающей запятой, которые могут иметь десятичную часть. Он используется для представления чисел с плавающей точкой, таких как 3.14 или -2.5.

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

x = 3.14
y = -2.5

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

a = 2.5 + 1.5 # сложение
b = 5.0 - 2.0 # вычитание
c = 2.0 * 3.5 # умножение
d = 10.0 / 2.0 # деление
e = 2.0 ** 3.0 # возведение в степень

Класс float также предоставляет различные методы для работы с числами с плавающей запятой, такие как is_integer() для проверки, является ли число целым, и as_integer_ratio() для представления числа в виде дроби.

num = 3.14
is_integer = num.is_integer()
integer_ratio = num.as_integer_ratio() # (7070651414971679, 2251799813685248), т.е. 7070651414971679/2251799813685248=3,14 

Комплексные числа complex

<class 'complex'> – это встроенный класс в Python, который представляет комплексные числа. Комплексные числа состоят из действительной и мнимой частей, где мнимая часть умножается на мнимую единицу j или J. Формат комплексного числа выглядит как a + bj, где a – действительная часть, b – мнимая часть.

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

z = 3 + 2j

Вы также можете использовать различные операции и методы с объектами типа complex. Некоторые из них включают арифметические операции (сложение, вычитание, умножение, деление), операции сравнения, а также методы для работы с комплексными числами (например, real – получение действительной части, imag – получение мнимой части, conjugate – получение сопряженного комплексного числа).

a = (2 + 3j) + (1 + 2j) # сложение
b = (5 + 4j) - (2 + 1j) # вычитание
c = (2 + 3j) * (1 + 2j) # умножение
d = (4 + 6j) / (2 + 3j) # деление

Класс complex также предоставляет некоторые встроенные функции для работы с комплексными числами, такие как abs() для вычисления модуля (абсолютного значения) комплексного числа.

z = 3 + 4j
magnitude = abs(z)

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

• Математика и наука: Комплексные числа широко используются в математике и науке для моделирования и решения задач, которые требуют работу с вещественными и мнимыми числами. Например, комплексные числа могут использоваться для решения уравнений, моделирования колебаний и волн, анализа электрических цепей и многое другое.
• Сигнальная обработка: В области сигнальной обработки комплексные числа используются для представления и обработки сигналов, таких как аудио- и видеосигналы. Комплексные числа позволяют представить фазу и амплитуду сигнала, а также выполнять операции, такие как фильтрация и преобразование Фурье.
• Графика и компьютерная графика: Комплексные числа могут использоваться для представления и моделирования геометрических объектов в двумерном пространстве. Например, они могут быть использованы для поворота и масштабирования объектов, а также для выполнения других геометрических операций.
• Криптография: Комплексные числа могут использоваться в криптографии для реализации различных алгоритмов шифрования и дешифрования. Некоторые алгоритмы криптографии, такие как алгоритм RSA, используют комплексные числа для выполнения операций с большими числами.
• Моделирование и симуляция: Комплексные числа могут быть использованы для моделирования и симуляции физических систем, таких как электрические цепи, колебательные системы, оптические системы и другие. Они позволяют представить и анализировать поведение системы в комплексной плоскости.

Строки str

<class 'str'> – это встроенный класс в Python, который представляет строки символов. Строки в Python являются неизменяемыми последовательностями символов, которые могут быть представлены в одинарных, двойных или тройных кавычках.

Вы можете создать объект типа str, присвоив строковое значение переменной. Вот пример:

name = "Привет, мир!"

Строки в Python имеют много полезных методов, которые позволяют выполнять различные операции с ними. Некоторые из них включают:

• len() – возвращает длину строки.
• lower() – преобразует все символы строки в нижний регистр.
• upper() – преобразует все символы строки в верхний регистр.
• strip() – удаляет пробельные символы в начале и конце строки.
• split() – разделяет строку на список подстрок по указанному разделителю.
• join() – объединяет список строк в одну строку, используя указанный разделитель.

message = " Привет, Мир! "
length = len(message)
lowercase = message.lower()
uppercase = message.upper()
stripped = message.strip()
split_words = message.split(',')
joined = '-'.join(['Привет', 'Мир!'])

Строки в Python также поддерживают индексацию и нарезку (slicing), что позволяет получить доступ к отдельным символам или подстрокам строки.

text = "Привет, Мир!"
first_char = text[0]  # получение первого символа
substring = text[8:11]  # получение подстроки "МИР"

name = "Алиса"
new_name = name.replace("Ал", "Лар")  # создание новой строки "Лариса"

Логический тип данных bool

Тип данных bool в Python представляет логические значения True (истина) и False (ложь). Он используется для выполнения логических операций и принятия решений в программе. Например, вы можете использовать bool для проверки условий в операторах if и while.

В Python значения True и False являются ключевыми словами и обозначаются с большой буквы. Они также могут быть представлены числами, где 0 соответствует False, а любое ненулевое значение соответствует True.

Примеры использования bool:

x = True
y = False

if x:
print("x равно True")

if not y:
print("y равно False")

В этом примере, первое условие будет выполнено, поскольку x равно True. Второе условие также будет выполнено, потому что not y приводит y к значению True, а затем отрицает его.

Вы также можете выполнять логические операции с использованием операторов and, or и not. Например:

a = True
b = False

if a and b:
print("Оба a и b равны True")

if a or b:
print("Хотя бы одно из a или b является True")

if not b:
print("b равно False")

В этом примере, первое условие не будет выполнено, потому что a and b дает False. Второе условие будет выполнено, потому что a or b дает True. Третье условие также будет выполнено, потому что not b дает True.

Тип данных bool является фундаментальным для логических операций и принятия решений в Python.

Списки list

<class 'list'> (список) – это один из встроенных типов данных в Python, который представляет упорядоченную и изменяемую коллекцию элементов. Список может содержать объекты любого типа, такие как числа, строки, другие списки и т. д. Основные особенности списка в Python:

1. Упорядоченность: Элементы списка упорядочены и доступ к ним осуществляется по индексу. Индексы начинаются с 0 для первого элемента списка, -1 для последнего элемента, -2 для предпоследнего элемента и так далее.

2. Изменяемость: Список может быть изменен после создания. Вы можете добавлять, удалять или изменять элементы списка.

3. Гетерогенность: Список может содержать элементы разных типов. Например, список может содержать и числа, и строки, и другие списки.

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

# Создание пустого списка
empty_list = []

# Создание списка с элементами
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']

# Доступ к элементам списка по индексу
print(numbers[0]) # Выводит 1
print(fruits[2]) # Выводит 'orange'

# Изменение элементов списка
numbers[1] = 10
print(numbers) # Выводит [1, 10, 3, 4, 5]

# Добавление элемента в конец списка
fruits.append('grape')
print(fruits) # Выводит ['apple', 'banana', 'orange', 'grape']

# Удаление элемента из списка
del numbers[2]
print(numbers) # Выводит [1, 10, 4, 5]

# Длина списка
print(len(fruits)) # Выводит 4

Списки в Python предоставляют множество методов для работы с ними, таких как append(), insert(), remove(), pop(), sort(), reverse() и др. Вы можете использовать эти методы для выполнения различных операций над списками, таких как добавление элементов, удаление элементов, сортировка и т. д.

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

numbers = [1, 2, 3, 4, 5]
sublist = numbers[1:4] # Получить подсписок с индексами 1, 2, 3
print(sublist) # Выводит [2, 3, 4]

# Создание списка
numbers = [1, 2, 3, 4, 5]

# Добавление элемента в список
numbers.append(6)
print(numbers) # Выводит [1, 2, 3, 4, 5, 6]

# Удаление элемента из списка
numbers.remove(3)
print(numbers) # Выводит [1, 2, 4, 5, 6]

# Доступ к элементам списка по индексу
print(numbers[0]) # Выводит 1
print(numbers[-1]) # Выводит 6

# Сортировка списка
numbers.sort()
print(numbers) # Выводит [1, 2, 4, 5, 6]

# Объединение списков
fruits = ['apple', 'banana', 'orange']
combined_list = numbers + fruits
print(combined_list) # Выводит [1, 2, 4, 5, 6, 'apple', 'banana', 'orange']

numbers = [1, 2, 3, 4, 3, 2, 1]
print(numbers.count(2)) # Выводит 2

numbers = [1, 2, 3, 4, 3, 2, 1]
print(numbers.index(4)) # Выводит 3

# Создание кортежа
empty_tuple = ()
numbers = (1, 2, 3, 4, 5)
person = ('John', 25, 'USA')

# Доступ к элементам кортежа по индексу
print(numbers[0]) # Выводит 1
print(person[1]) # Выводит 25

# Перебор элементов кортежа
for number in numbers:
print(number)

# Длина кортежа
print(len(person)) # Выводит 3

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

combined_tuple = tuple1 + tuple2
print(combined_tuple) # Выводит (1, 2, 3, 4, 5, 6)

repeated_tuple = tuple1 * 3
print(repeated_tuple) # Выводит (1, 2, 3, 1, 2, 3, 1, 2, 3)

Словари dict

<class 'dict'> – это класс в Python, который представляет собой структуру данных “словарь”. Словарь представляет собой неупорядоченную коллекцию пар ключ-значение, где каждый ключ является уникальным. Вы можете рассматривать словарь как отображение между ключами и значениями. Словари в Python предоставляют эффективный способ хранения и доступа к данным, основанным на уникальных ключах. Основные особенности словарей:

1. Неупорядоченность: Элементы словаря не имеют определенного порядка. Порядок элементов в словаре не гарантирован и может меняться при каждой операции.

2. Изменяемость: Словари могут быть изменены после создания. Вы можете добавлять, удалять и изменять пары ключ-значение в словаре.

3. Уникальность ключей: Ключи в словаре должны быть уникальными. Это означает, что каждый ключ может быть связан только с одним значением. Если вы попытаетесь добавить элемент с уже существующим ключом, старое значение будет заменено новым.

4. Гетерогенность: Словари могут содержать элементы разных типов. Ключи и значения могут быть любого типа данных, таких как числа, строки, списки и даже другие словари.

Для создания словаря вы можете использовать фигурные скобки {} или конструктор dict().

# Создание пустого словаря
empty_dict = {}

# Создание словаря с элементами
person = {'name': 'Slava', 'age': 25, 'country': 'Russian'}

# Доступ к значениям по ключу
print(person['name']) # Выводит 'Slava'
print(person['age']) # Выводит 25

# Изменение значения по ключу
person['age'] = 30
print(person['age']) # Выводит 30

# Добавление новой пары ключ-значение
person['occupation'] = 'Engineer'
print(person) # Выводит {'name': 'Slava', 'age': 30, 'country': 'Russian', 'occupation': 'Engineer'}

# Удаление элемента по ключу
del person['country']
print(person) # Выводит {'name': 'Slava', 'age': 30, 'occupation': 'Engineer'}

# Проверка наличия ключа
print('name' in person) # Выводит True
print('country' in person) # Выводит False

# Длина словаря
print(len(person)) # Выводит 3

Словари в Python предоставляют множество методов для работы с ними, таких как keys(), values(), items(), get(), pop() и другие. Например, метод keys() возвращает список всех ключей в словаре:

person = {'name': 'John', 'age': 30, 'occupation': 'Engineer'}
keys = person.keys()
print(keys) # Выводит dict_keys(['name', 'age', 'occupation'])

Метод values() возвращает список всех значений в словаре:

person ={'name': 'Slava', 'age': 30, 'occupation': 'Engineer'}
values = person.values()
print(values) # Выводит dict_values(['Slava', 30, 'Engineer'])

Метод `items()` возвращает список кортежей, содержащих все пары ключ-значение в словаре:

person = {'name': 'John', 'age': 30, 'occupation': 'Engineer'}
items = person.items()
print(items) # Выводит dict_items([('name', 'John'), ('age', 30), ('occupation', 'Engineer')])

Метод get() позволяет получить значение по ключу, если ключ существует, и возвращает значение по умолчанию, если ключ отсутствует:

person = {'name': 'Slava', 'age': 30}
print(person.get('name')) # Выводит 'Slava'
print(person.get('country', 'RUS')) # Выводит 'RUS'

Словари в Python являются мощным и удобным инструментом для хранения и доступа к данным на основе уникальных ключей.

Множества set

<class 'set'> (множество) – это один из встроенных типов данных в Python, который представляет неупорядоченную коллекцию уникальных элементов. В отличие от списков или кортежей, которые могут содержать дублирующиеся элементы, множества содержат только уникальные элементы. Основные особенности множеств в Python:

1. Неупорядоченность: Элементы в множестве не имеют определенного порядка. Порядок элементов в множестве не гарантирован и может меняться при каждой операции.

2. Уникальность элементов: Множества содержат только уникальные элементы. Если вы попытаетесь добавить элемент, который уже присутствует в множестве, он будет проигнорирован.

3. Изменяемость: Множества могут быть изменены после создания. Вы можете добавлять и удалять элементы из множества.

# Создание пустого множества
empty_set = set()

# Создание множества с элементами
fruits = {'apple', 'banana', 'orange'}

# Добавление элемента в множество
fruits.add('mango')
print(fruits) # Выводит {'apple', 'banana', 'orange', 'mango'}

# Удаление элемента из множества
fruits.remove('banana')
print(fruits) # Выводит {'apple', 'orange', 'mango'}

# Проверка наличия элемента в множестве
print('apple' in fruits) # Выводит True
print('pear' in fruits) # Выводит False

# Длина множества
print(len(fruits)) # Выводит 3

Множества в Python предоставляют множество методов для работы с ними, таких как union(), intersection(), difference(), symmetric_difference() и другие. Например, метод union() объединяет два множества, возвращая новое множество, содержащее все уникальные элементы из обоих множеств:

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)
print(union_set) # Выводит {1, 2, 3, 4, 5}

Метод intersection() возвращает новое множество, содержащее только уникальные элементы, присутствующие в обоих множествах:

set1 = {1, 2, 3}
set2 = {3, 4, 5}

intersection_set = set1.intersection(set2)
print(intersection_set) # Выводит {3}

Метод difference() возвращает новое множество, содержащее только уникальные элементы из первого множества, не присутствующие во втором множестве:

set1 ={1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set) # Выводит {1, 2}

Метод `symmetric_difference()` возвращает новое множество, содержащее только уникальные элементы, которые присутствуют только в одном из множеств:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set) # Выводит {1, 2, 4, 5}

Множества в Python также поддерживают операции над множествами, такие как объединение (|), пересечение (&), разность (-), симметричная разность (^) и другие. Например:

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1 | set2
print(union_set) # Выводит {1, 2, 3, 4, 5}

intersection_set = set1 & set2
print(intersection_set) # Выводит {3}

difference_set = set1 - set2
print(difference_set) # Выводит {1, 2}

symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set) # Выводит {1, 2, 4, 5}

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

Тип данных None

None – это специальный тип данных в Python, который представляет отсутствие значения или нулевое значение. None используется для указания, что переменная не имеет значения или что функция не возвращает какое-либо значение.

Вот некоторые особенности типа данных None:

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

2. Сравнение: None можно сравнивать с другими объектами с помощью операторов сравнения (==, !=, <, >, и т.д.). Он равен только самому себе и не равен любому другому значению.

3. Проверка наличия значения: None можно использовать для проверки наличия значения в переменной. Например, если переменная x имеет значение None, это может указывать на то, что переменная еще не была инициализирована или что она не имеет значения.

4. Возвращаемое значение функции: Если функция не возвращает явного значения, она возвращает None по умолчанию. Например, если в функции отсутствует оператор return, она все равно вернет None.

x = None # Присвоение переменной значения None
print(x) # Выводит None

if x is None:
print("Переменная x не имеет значения")

def do_something():
# Функция, которая не возвращает значение
pass

result = do_something()
print(result) # Выводит None

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

Важно отметить, что None не эквивалентен нулю или пустой строке. Он представляет уникальное отсутствие значения в Python.