Типы в Python

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

  • Числа
  • Строки
  • Списки
  • Словари
  • Кортежи
  • Файлы
  • Множества

Для начала, определимся чем в Python являются переменные, если тут их можно так назвать. Итак, разберём код ниже, и познакомимся с числами.

x = 25
b = 25
print(b is x)      #вывод на экран выражения
b = 32
print(x)
print(b)

#-------------Вывод будет таков:
#True
#25
#32

Итак, что тут происходит. Дело в том, что в Python всё является объектами, и первая строка сначала создаёт объект числа со значением 25, после чего присваивает его ссылке с именем x. В итоге получаем конструкцию X ----> 25.
Вторая строка присваивает этот же объект ссылке с именем b. Почему не создаёт новый? Да потому что он аналогичен предыдущему, а так как числа - это неизменяемый объект (об этом чуть позже), то можно для экономии памяти ссылаться на тот же объект.
Потом выводим на экран результат выражения is, которая проверяет один и тот же ли это объект - вывод труе))))
Затем создаём объект числа со значением 32, и так как число это объект неизменяемый, то при присваивании ссылке b мы не изменяем объект со значением 25, а просто переопределяем ссылку на новый наш объект, последние два вывода на экран иллюстрируют это. Вот так мы познакомились с самыми простыми числами, целые числа не имеют ограничений в размере - разве только объём вашей оперативной памяти может их ограничить)))) Также имеются иные числа, код ниже демонстрирует вам это.

x = 3 + 4j  #создание комплексного числа
b = 2 + 6j  
z = x+b
print(x,b,z) #вывод комплексных чисел и их суммы
x = 3.234  # рациональные числа
b = 4
z = x - b
print(x,b,z)
print(b**x)  #возведение в b в степень x
x = 5 
b = 2
print(x/b)  #деление  - получаем вещественное число
print(x//b) #деление с округлением вниз

#далее вывод при запуске кода:
"""
(3+4j) (2+6j) (5+10j)
3.234 4 -0.766
88.52420025670175
2.5
2
"""

Пойдём дальше - Строки. Тут всё просто, любые кавычки, одинарные или двойные создадут строку, строка также неизменяемый объект, но она также является последовательностью, и с ней можно работать как с последовательностью. Пример:

s = "hello people i love you" # создаём строку
b = 'hi man'                      # также создаём строку но используем другие кавычки
z = """                               # создаём строку юзая фитчу многострочного ввода, вывод тоже будет многострочный
buuuuu
buuuuu
buuuuu
xsxsxs
"""
print(s,b)                         # печатаем строки на одной строчке))))
print(z)                            # печатаем z
print(s[2])                       # а эта фитча доступа по индексу
#s[1] = 't'                      #так как строки неизменяемый объект - присваивать нельзя, выведет ошибку поэтому в коменте
print(s[:])                        #а это фитча для последовательностей - извлечения среза, такой вид вернёт полностью строку
print(s[1:4])                   #извлекаем срез со второго элемента включительно (нумерация с нуля) по 4-й не включительно
print(s[:-1])                    #фитча срезов, отрицательные значения дают элементы с конца - выведет первый элемент с конца
print(s[1:-3])                  # вернёт все элементы начиная со второго до третего с  конца не включительно
print(s[0:-3:2])               # можно задать шаг в третьем параметре
print(s[-1:0:-1])              # можно инвертировать, начать с конца и задав обратный шаг дойти до начала не включительно

#---- вывод на экран при запуске
"""
hello people i love you hi man

buuuuu
buuuuu
buuuuu
xsxsxs

l
hello people i love you
ell
hello people i love yo
ello people i love 
hlopol  oe
uoy evol i elpoep olle
"""


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

y = 23               # создадим обычный объек "Число"
x = [1,2,y,'trim',['spam1','spam2'],65]   # создание списка - просто))) он вложенный, и содержит объекты различных типов
print(x)            #выведем его
y = 21             #переобозначим y, заметьте что список x остался прежним, так как Числа - неизменяемые объекты, y #ссылается     уже на новый объект а третий элемент списка x на старый объект Числа.
c = x               #сошлёмся из с на объект списка на который ссылается x
print(x,c)         #выведем их - они одинаковы, как видно внизу
x[1] = 't'          #изменим x, так как списки - это изменяемый объект, то изменится сам объект, а не создастся новый как с 
                        #числами, поэтому изменения распространятся дальше чем привыкли Сишники)))
print(x,c)             # Выводим x и c после изменений, как видно c тоже изменился
b = [x,y,'t',35]    #новый список, включающий наш старый список
print(b)                      #печатаем его
x[0:2] = (5,7)            #изменяем старый список, тут присваиваем срезу, тут справа используем Кортеж, пока не забивайте себе 
                                  #голову, о нём дальше
print(b)                      #изменения также коснутся и новый список
nums = [1,2,3,4,5,6,7,8]        # тут новый список из чисел
nums = [x**2 for x in nums]           #это генератор списков, применяет выражение x**2 (возведение в квадрат) для каждого
 #элемента из nums и создаёт список - генераторы работают много быстрее циклов, они оптимизированны и занимают меньше 
#строк кода, супер штуки, но они отдельная большая тема - потом может быть, а пока просто занйте что они есть))
print(nums)                                       #посмотрим что получилось!!!

#-------вывод на экран при запуске:
[1, 2, 23, 'trim', ['spam1', 'spam2'], 65]
[1, 2, 23, 'trim', ['spam1', 'spam2'], 65] [1, 2, 23, 'trim', ['spam1', 'spam2'], 65]
[1, 't', 23, 'trim', ['spam1', 'spam2'], 65] [1, 't', 23, 'trim', ['spam1', 'spam2'], 65]
[[1, 't', 23, 'trim', ['spam1', 'spam2'], 65], 21, 't', 35]
[[5, 7, 23, 'trim', ['spam1', 'spam2'], 65], 21, 't', 35]
[1, 4, 9, 16, 25, 36, 49, 64]

Словари - тоже что и списки, только неупорядоченные именнованные объекты, доступ идёт по ключу.

mydict = {'livenumber':1, 'food':'spam'}       #создание
mydict['food']                                                   #обращение

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

mycort = (1,'spam',24)                             #создание
mycort[1]                                                   #обращение


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

myset = {1,'spam',24}                            #создание

Файлы - отдельная тема для разговора)))) Просто знайте что они есть, и что это встроенный тип.

Ну вот и всё, краткий обзор встроенных типов в Python)))