1. Типы данных

Примечание

Статья в разработке…

1.1. Переменные в Python:

Переменная в языке программирования это название для зарезервированного места в памяти компьютера, предназначенное для хранения значений. Это означает, что когда вы создаете переменную, вы на самом деле резервируете определенное место в памяти компьютера. Основываясь на типе данных переменной, интерпретатор выделяет необходимое количество памяти и решает, что может находится в зарезервированной области памяти. Для понимания, можете думать о переменной как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Это не совсем верное определение, но оно дает общее представление о картине в целом.

Присвоение значения переменной:

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

Таблица - Обзор встроенных типов объектов

Имя

Тип

Описание и пример

Целые Числа

int
Целые положительные или отрицательные числа

-35, 0, 24, 123467890033373747428

Числа с плавающей точкой

float

Дробные числа 3.14, 2.5, -2.33333, 0.12334

Строки

str

Строки «asdf», «Hello world», «123456»

Списки

list
последовательность элементов

[«hello», -123, 0.34, «345»]

Словарь

dict

Последовательность пар элементов содержаших ключ-значение (key-value)

{«Language»: «Python», «Version»: «3.8»}

Кортеж (Tuple)

tup

Неизменяемая упорядоченная последовательность элементов («hostname», 1234, -0.45, -32)

Множество

set
Изменяемая неупоряоченная последовательность

элементов {10, «Name», -30, 4.02, 100}

Булевые значения

bool
Тип данных принимающий одно из двух значений

true - истина false - ложь

1.2. Числа

Числа - Это не изменяемый тип данных. Числа в Python бывают трёх типов: целые, с плавающей точкой и комплексные. * Примером целого числа может служить 2. * Примерами чисел с плавающей точкой (или «плавающих» для краткости) могут быть 3.23 и 52.3E-4. Обозначение E показывает степени числа 10. В данном случае 52.3E-4 означает 52.3 · 10−4. * Примерыкомплексныхчисел:(-5+4j)и(2.3-4.6j)

Примечание

Нет отдельного типа ‘long int’ (длинное целое). Целые числа по умолчанию могут быть произвольной длины.

1.3. Строки

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

Строки можно суммировать. Тогда они объединяются в одну строку, такая операция называется «Конкатенацией строк»:

firts_string = "asdfgh"
second_string = "oiuytr"
print(firts_string + second_string)

Примечание

В Python 3 нет ASCII-строк, потому что Unicode является надмножеством (включает в себя) ASCII. Если необходимо получить строку строго в кодировке ASCII, используйте str.encode(«ascii»). По умолчанию все строки в Unicode.

Предупреждение

Нельзя производить арифметтические операции над строкам и числами Например: «qwerty» + 3 Это вызовет ошибку, Но строки можно перемножать «#» * 10 выведет на экран строку ##########

1.3.1. Логические и физические строки

Физическая строка – это то, что вы видите, когда набираете программу. Логическая стро- ка – это то, что Python видит как единое предложение. Python неявно предполагает, что каждой физической строке соответствует логическая строка. Примером логической строки может служить предложение print(„Привет, Мир!“) – ес- ли оно на одной строке (как вы видите это в редакторе), то эта строка также соответствует физической строке. Python неявно стимулирует использование по одному предложению на строку, что об- легчает чтение кода. Чтобы записать более одной логической строки на одной физической строке, вам придёт- ся явно указать это при помощи точки с запятой (;), которая отмечает конец логической строки/предложения. Например:

i=5
print(i)
#то же самое, что
i = 5; print(i);
#и то же самое может быть записано в виде
i = 5; print(i);

Однако я настоятельно рекомендую вам придерживаться написания одной логической строки в каждой физической строке. Таким образом вы можете обойтись совсем без точки с запятой. Кстати, я никогда не использовал и даже не встречал точки с запятой в программах на Python. Можно использовать более одной физической строки для логической строки, но к этому следует прибегать лишь в случае очень длинных строк. Пример написания одной логиче- ской строки, занимающей несколько физических строк, приведён ниже. Это называется явным объединением строк.

s = 'Это строка. \
Это строка продолжается.'
print(s) #Это строка. Это строка продолжается.

1.3.2. Операции над последовательностями

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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

simple_string = 'Spam'
len(simple_string)
# 4
simple_string[0]
# 'S'
simple_string[1]
# 'p'

Нумерация всех символов в строке идет с нуля. Но, если нужно обратиться к какому-то по счету символу, начиная с конца, то можно указывать отрицательные значения (на этот раз с единицы).

simple_string = "StringBody"
simple_string[1]
# t

simple_string[-1]
# y

Кроме обращения к конкретному символу, можно делать срезы строк, указав диапазон номеров (срез выполняется по второе число, не включая его):

example_string = "Lorem Ipsum is simply dummy text of the printing and typesetting"
example_string[0:9]
# 'Lorem Ips'

example_string[10:22]
# 'm is simply '

# Если не указывается второе число, то срез будет до конца строки:
example_string[-3:]
# 'ing'

Также в срезе можно указывать шаг:

# Так можно получить нечетные числа
a = '0123456789'
a[1::2]
# '13579'

# А таким образом можно получить все четные числа строки a:
a[::2]
# '02468'

# Срезы также можно использовать для получения строки в обратном порядке:
a[::-1]
# '9876543210'

1.3.3. Методы для работы со строками

Методы upper, lower, swapcase, capitalize

Методы upper(), lower(), swapcase(), capitalize() выполняют преобразование регистра строки:

string1 = 'FastEthernet'

string1.upper()
#'FASTETHERNET'

string1.lower()
#'fastethernet'

string1.swapcase()
#'fASTeTHERNET'

string2 = 'tunnel 0'

string2.capitalize()
#'Tunnel 0'

#Очень важно обращать внимание на то, что часто методы возвращают преобразованную строку. И, значит, надо не забыть присвоить ее какой-то переменной (можно той же).
string1 = string1.upper()
print(string1)
#FASTETHERNET

Метод count

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

string1 = 'Hello, hello, hello, hello'
string1.count('hello') # 3
string1.count('ello') # 4
string1.count('l') # 8

Метод find

Методу find() можно передать подстроку или символ, и он покажет, на какой позиции находится первый символ подстроки (для первого совпадения):

string1 = 'interface FastEthernet0/1'
string1.find('Fast') # 10
string1[string1.find('Fast')::] # 'FastEthernet0/1'

Методы startswith, endswith

Проверка на то, начинается или заканчивается ли строка на определенные символы (методы startswith(), endswith()):

string1 = 'FastEthernet0/1'
string1.startswith('Fast') # True
string1.startswith('fast') # False
string1.endswith('0/1') # True
string1.endswith('0/2') # False

Метод replace

Замена последовательности символов в строке на другую последовательность (метод replace()):

string1 = 'FastEthernet0/1'
string1.replace('Fast', 'Gigabit') # 'GigabitEthernet0/1'

Метод strip

Часто при обработке файла файл открывается построчно. Но в конце каждой строки, как правило, есть какие-то спецсимволы (а могут быть и в начале). Например, перевод строки.

Для того, чтобы избавиться от них, очень удобно использовать метод strip():

string1 = '\n\tinterface FastEthernet0/1\n'
print(string1)
#
#interface FastEthernet0/1
#

string1.strip()
#'interface FastEthernet0/1'

Примечание

По умолчанию метод strip() убирает пробельные символы. В этот набор символов входят: tnrfv

Методу strip можно передать как аргумент любые символы. Тогда в начале и в конце строки будут удалены все символы, которые были указаны в строке:

Метод strip() убирает спецсимволы и в начале, и в конце строки. Если необходимо убрать символы только слева или только справа, можно использовать, соответственно, методы lstrip() и rstrip().

Метод split

Метод split() разбивает строку на части, используя как разделитель какой-то символ (или символы) и возвращает список строк:

string1 = 'switchport trunk allowed vlan 10,20,30,100-200'
commands = string1.split()
print(commands) # ['switchport', 'trunk', 'allowed', 'vlan', '10,20,30,100-200']

#По умолчанию в качестве разделителя используются пробельные символы (пробелы, табы, перевод строки), но в скобках можно указать любой разделитель:
vlans = commands[-1].split(',')
print(vlans) #['10', '20', '30', '100-200']

Метод join

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

myTuple = ("John", "Peter", "Vicky")
x = "-".join(myTuple)
print(x) #John-Peter-Vicky

Метод format

Метод format() позволяет подставлять в отмеченные в строке области символами «{}» значени из списка аргументов

например:

price = 49
txt = "The price is {} dollars"
print(txt.format(price))

Так же можно указать тип подставлемых значений:

#Строковые занчения
'{} {}'.format('one', 'two') #one two

#Числовые значения
'{} {}'.format(1, 2) #1 2

#порядок значений можно указывать
'{1} {0}'.format('one', 'two') #two one

#Можно так же подставлять значения классов
class Data(object):

    def __str__(self):
        return 'str'

    def __repr__(self):
        return 'repr'

'{0!s} {0!r}'.format(Data()) #str repr

#Отступы и выравнивания
#по правому краю
'{:>10}'.format('test') #      test

#по левому краю
'{:_<10}'.format('test') #test______

#по центру
'{:^10}'.format('test') #   test

#срезы
'{:.5}'.format('xylophone') #xylop

#срезы и отступы
'{:10.5}'.format('xylophone') #xylop

#числа
'{:d}'.format(42) #42
'{:f}'.format(3.141592653589793) #3.141593

#числа и отступы
'{:4d}'.format(42) #  42
'{:06.2f}'.format(3.141592653589793) #003.14
'{:04d}'.format(42) # 0042

#знаковые числа
'{:+d}'.format(42) #+42
'{: d}'.format((- 23)) #-23
'{: d}'.format(42) # 42
'{:=5d}'.format((- 23)) #-  23
'{:=+5d}'.format(23) #+  23

#можно вставлять значения по именам
data = {'first': 'Hodor', 'last': 'Hodor!'}
'{first} {last}'.format(**data) #Hodor Hodor!
'{first} {last}'.format(first='Hodor', last='Hodor!') #Hodor Hodor!

#Формат даты и времени
from datetime import datetime
'{:%Y-%m-%d %H:%M}'.format(datetime(2001, 2, 3, 4, 5)) #2001-02-03 04:05

другие примеры форматированого вывода можно ныйти по следующим ссылкам pyformat.info w3schools.com

1.3.4. Пример программы

Подсчет слов

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#Программа подсчета слов в файле
import os #подуль для взаимодействия с операционной системой, например просмотр файлов


def get_words(filename):
    '''функци принимает в качестве аргумента путь до файла'''
    with open(filename, encoding="utf8") as file: #эта строка открывает файл
        text = file.read()  #читаем содержимое файла и записываем все в переменную text
        text = text.replace("\n", " ") #преобразуем наш текст в одну длинную строку заменив символ перевода строки на пробел
        text = text.replace(",", "").replace(".", "").replace("?", "").replace("!", "") #а так же уберем все запетые, пробелы, и прочие знаки пунктуации
        text = text.lower()  #перведем все слова в строчные, тоесть если было "Начало изучения Языка Программирования", то будет "начало изучения языка программирования"
        words = text.split() #создадим список слов ("списки","выгледят","вот","так")
        words.sort() #метод sort отсортирует все слова по алфовиту
    return words  #эта строка вернет нам массив строк


def get_words_dict(words):
    ''''эта функция содасть словарь где ключь, это слово, а значение, то сколько раз оно встречается в тексте'''
    words_dict = dict() #создаем простой словарь

    for word in words:  #цикл который перебирает наш список и записывает каждое слово в отдельную переменную word
        if word in words_dict:  #проверим условие, если слово уже есть в словаре,
            words_dict[word] = words_dict[word] + 1 # увеличим его значение на 1
        else:
            words_dict[word] = 1 # если не встречается, то просто присвоим значение 1
    return words_dict #вернем наш словарь


def main():
    '''наша главная функция в которой выполняется основная логика нашей программы
    Вызываются все созданные ранее функции, передаются значения, выводятся на экран результаты'''
    filename = input("Введите путь к файлу: ") #функция input() выводит на экран сообщение и ожидает ввода, все что будет введенобудет записано в переменную filename
    if not os.path.exists(filename): #проверяем соществует ли наш файл на диске
        print("Указанный файл не существует")
    else:
        words = get_words(filename)  #получаем список слов
        words_dict = get_words_dict(words) #получаем словарь из слов и их количества в тексте
        print("Кол-во слов: %d" % len(words)) #печатаем количество слов в тексте
        print("Кол-во уникальных слов: %d" % len(words_dict)) #печатаем количество уникальных слов
        print("Все использованные слова:") # и все слова
        for word in words_dict:
            print(word.ljust(20), words_dict[word])


if __name__ == "__main__":
    main()

1.4. Списки

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

names = [ “Dave”, “Mark”, “Ann”, “Phil” ]

Элементы списка индексируются целыми числами, первый элемент списка имеет индекс, равный нулю. Для доступа к отдельным элементам списка используется оператор индексирования

a = names[2] # Вернет третий элемент списка, “Ann”
names[0] = “Jeff” # Запишет имя “Jeff” в первый элемент списка

С помощью оператора среза можно извлекать и изменять целые фрагменты списков:

b = names[0:2]     # Вернет [“Jeff”, “Mark”]
c = names[2:]      # Вернет [“Thomas”, “Ann”, “Phil”, “Paula”]
names[1] = ‘Jeff’  # Во второй элемент запишет имя ‘Jeff’
names[0:2] = [‘Dave’,’Mark’,’Jeff’]  # Заменит первые два элемента списком справа.

Списки могут содержать объекты любого типа, числа, строки, другие списки

a = [1,”Dave”,3.14, [“Mark”, 7, 9, [100,101]], 10]

Списки так же как и строки можно конкатинировать между собоой

[1,2,3] + [4,5] # Создаст список [1,2,3,4,5]

1.4.1. Меторы для работы со списками

List()

создаст пустой список, либо преобразует аргументы в список

l = list('1234567890')
print(l) # [1,2,3,4,5,6,7,8,9,0]

join()

собирает список строк в одну строку с разделителем, который указан перед join:

a = ['10', '20', '30']
print(','.join(a)) # 10,20,30

Примечание

Метод join на самом деле относится к строкам, но так как значение ему надо передавать как список, он рассматривается тут.

append()

добавляет в конец списка указанный элемент:

a = ['10', '20', '30', '100-200']
a.append('300')
print(a) # ['10', '20', '30', '100-200', '300']

extend()

Если нужно объединить два списка, то можно использовать два способа: метод extend() и операцию сложения.

У этих способов есть важное отличие - extend меняет список, к которому применен метод, а суммирование возвращает новый список, который состоит из двух.

a = ['10', '20', '30', '100-200']
b = ['300', '400', '500']
a.extend(b)
print(a) # ['10', '20', '30', '100-200', '300', '400', '500']

pop()

удаляет элемент, который соответствует указанному номеру. Но, что важно, при этом метод возвращает этот элемент:

a = ['10', '20', '30', '100-200']
a.pop(-1) # '100-200'
print(a) #['10', '20', '30']

Примечание

Без указания номера удаляется последний элемент списка.

remove()

удаляет указанный элемент и не возвращает удаленный элемент:

a = ['10', '20', '30', '100-200']
a.remove('20')
print(a) # ['10', '30', '100-200']

Примечание

В методе remove надо указывать сам элемент, который надо удалить, а не его номер в списке. Если указать номер элемента, возникнет ошибка:

insert()

позволяет вставить элемент на определенное место в списке:

a = ['10', '20', '30', '100-200']
a.insert(1, '15')
print(a) # ['10', '15', '20', '30', '100-200']

sort()

сортирует список на месте:

a = [1, 50, 10, 15]
a.sort()
print(a) # [1, 10, 15, 50]

1.5. Словари

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

Словари - это изменяемый упорядоченный тип данных:

  • данные в словаре - это пары ключ: значение

  • доступ к значениям осуществляется по ключу, а не по номеру, как в списках

  • данные в словаре упорядочены по порядку добавления элементов

  • так как словари изменяемы, то элементы словаря можно менять, добавлять, удалять

  • ключ должен быть объектом неизменяемого типа: число, строка, кортеж

  • значение может быть данными любого типа

для удобства словарь можно записать так:

london = {
'id': 1,
'name':'London',
'it_vlan':320,
'user_vlan':1010,
'mngmt_vlan':99,
'to_name': None,
'to_id': None,
'port':'G1/0/11'
}

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

london = {'name': 'London1', 'location': 'London Str'}
print(london['name'], london['location'])
#'London1' 'London Str'

При написании в виде литералов словари указываются в фигурных скобках и состо­ ят из ряда пар “ключ: значение”. Словари удобны всегда, когда нам необходимо ассо­ циировать набор значений с ключами — например, для описания свойств чего-нибудь. Рассмотрим следующий словарь их трех элементов (с ключами ’ food ’, ’ quantity ’ и ’ color ’, возможно представляющих детали позиции гипотетического меню):

D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'}

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

D['food'] # Извлечь значение, связанное с ключом 'food' 'Spam'
D['quantity'] += 1 # Добавить 1 к значению, связанному с ключом 'quantity'
print(D)
#{'color': 'pink', 'food': 'Spam', 'quantity': 5}

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

D = {}
D['name'] = 'Bob'
D['job'] = 'dev'
D['age'] =40
print (D)
#{'*:age 40, 'job': 'dev', 'name': 'Bob'}
print(D['name'])
#Bob

В словаре в качестве значения можно использовать словарь:

london_co = {
'r1': {
    'hostname': 'london_r1',
    'location': '21 New Globe Walk',
    'vendor': 'Cisco',
    'model': '4451',
    'ios': '15.4',
    'ip': '10.255.0.1'
},
'r2': {
    'hostname': 'london_r2',
    'location': '21 New Globe Walk',
    'vendor': 'Cisco',
    'model': '4451',
    'ios': '15.4',
    'ip': '10.255.0.2'
},
'sw1': {
    'hostname': 'london_sw1',
    'location': '21 New Globe Walk',
    'vendor': 'Cisco',
    'model': '3850',
    'ios': '3.6.XE',
    'ip': '10.255.0.101'
}

}

Получить значения из вложенного словаря можно так:

london_co['r1']['ios'] #'15.4'
london_co['r1']['model'] #'4451'
london_co['sw1']['ip'] #'10.255.0.101'

1.6. Методы для работы со словарями

clear()

  • позволяет очистить словарь:

copy()

  • создает полную копию словаря

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
london2 = london.copy()
id(london) #25524512
id(london2) #25563296
london['vendor'] = 'Juniper'
london2['vendor'] #'Cisco'

Примечание

Если указать, что один словарь равен другому, то london2 будет ссылкой на словарь. И при изменениях словаря london меняется и словарь london2, так как это ссылки на один и тот же объект.

get()

  • запрашивает ключ, и если его нет, вместо ошибки возвращает None.

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
print(london.get('ios')) #None

#Метод get() позволяет также указывать другое значение вместо None
print(london.get('ios', 'Ooops')) #Ooops

setdefault()

  • ищет ключ, и если его нет, вместо ошибки создает ключ со значением None, если ключ есть, setdefault возвращает значение, которое ему соответствует:

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
ios = london.setdefault('ios')
print(ios) #None
london #{'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': None}
london.setdefault('name') #'London1'

#Второй аргумент позволяет указать, какое значение должно соответствовать ключу
model = london.setdefault('model', 'Cisco3580')
print(model) #Cisco3580
london
{'name': 'London1',
 'location': 'London Str',
 'vendor': 'Cisco',
 'ios': None,
 'model': 'Cisco3580'}

# Метод setdefault заменяет такую конструкцию:
if key in london:
     value = london[key]
else:
     london[key] = 'somevalue'
     value = london[key]

keys(), values(), items()

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

Очень важная особенность view заключается в том, что они меняются вместе с изменением словаря. И фактически они лишь дают способ посмотреть на соответствующие объекты, но не создают их копию.

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
keys = london.keys()
print(keys)
#dict_keys(['name', 'location', 'vendor'])

#Сейчас переменной keys соответствует view dict_keys, в котором три ключа: name, location и vendor.
#Но, если мы добавим в словарь еще одну пару ключ-значение, объект keys тоже поменяется:
london['ip'] = '10.1.1.1'
keys
#dict_keys(['name', 'location', 'vendor', 'ip'])

#Если нужно получить обычный список ключей, который не будет меняться с изменениями словаря, достаточно конвертировать view в список:
list_keys = list(london.keys())
list_keys
#['name', 'location', 'vendor', 'ip']

del()

Удаляет ключ и значение

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}
del london['name']
london
#{'location': 'London Str', 'vendor': 'Cisco'}

update()

Позволяет добавлять в словарь содержимое другого словаря:

r1 = {'name': 'London1', 'location': 'London Str'}
r1.update({'vendor': 'Cisco', 'ios':'15.2'})
r1
# {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': '15.2'}

#Аналогичным образом можно обновить значения:
r1.update({'name': 'london-r1', 'ios':'15.4'})
r1
'''
{'name': 'london-r1',
 'location': 'London Str',
 'vendor': 'Cisco',
 'ios': '15.4'}
'''

1.7. Кортежи

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

T = (1, 2, 3, 4) # Кортеж из 4 элементов
len(Т)           # Длина 4
Т + (5, б)       # Конкатенация (1, 2, 3, 4, 5, 6)
Т[О]             # Индексация, нарезание и т.д.

Примечание

Главное отличие кортежей заключается в том, что после создания их нельзя из­ менять, т.е. они являются неизменяемыми последовательностями (одноэлементные кортежи вроде приведенного ниже требуют хвостовой запятой): tuple2 = („password“,)

Итак, зачем нам тип, который похож на список, но поддерживает меньше операций? Откровенно говоря, на практике кортежи применяются в целом не так часто, как списки, но весь смысл в их неизменяемости. Если вы передаете коллекцию объектов внутри своей программы в виде списка, тогда он может быть модифицирован где угодно; если вы используете кортеж, то изменить его не удастся. То есть кортежи обеспечивают своего рода ограничение целостности, что удобно в программах, крупнее тех, которые мы будем писать здесь. Позже в книге мы еще обсудим кортежи, включая расширение, которое построено поверх них и называется именованными кортежами.

1.8. Множество

Множество - это изменяемый неупорядоченный тип данных. В множестве всегда содержатся только уникальные элементы.

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

С помощью множества можно легко убрать повторяющиеся элементы:

cities = ['Санкт-Петербург', 'Хабаровск', 'Казань', 'Санкт-Петербург', 'Казань']
un_cities = set(cities)
for city in un_cities:
    print("Один мой друг живёт в городе " + city)

'''
Один мой друг живёт в городе Хабаровск
Один мой друг живёт в городе Санкт-Петербург
Один мой друг живёт в городе Казань
'''

Множества полезны тем, что с ними можно делать различные операции и находить объединение множеств, пересечение и так далее.

Объединение множеств можно получить с помощью метода union() или оператора |:

vlans1 = {10,20,30,50,100}
vlans2 = {100,101,102,102,200}
vlans1.union(vlans2) #{10, 20, 30, 50, 100, 101, 102, 200}
vlans1 | vlans2 #{10, 20, 30, 50, 100, 101, 102, 200}

#Пересечение множеств можно получить с помощью метода intersection() или оператора &
vlans1 = {10,20,30,50,100}
vlans2 = {100,101,102,102,200}
vlans1.intersection(vlans2) #{100}
vlans1 & vlans2 #{100}

Предупреждение

Нельзя создать пустое множество с помощью литерала (так как в таком случае это будет не множество, а словарь): set1 = {} type(set1) #dict

Но пустое множество можно создать таким образом set2 = set() type(set2) #set

1.9. Методы для работы с множествами

add()

добавляет элемент во множество:

set1 = {10,20,30,40}
set1.add(50)
set1 #{10, 20, 30, 40, 50}

discard()

позволяет удалять элементы, не выдавая ошибку, если элемента в множестве нет

set1 #{10, 20, 30, 40, 50}
set1.discard(55)
set1 #{10, 20, 30, 40, 50}
set1.discard(50)
set1 #{10, 20, 30, 40}

clear()

очищает множество

set1 = {10,20,30,40}
set1.clear()
set1 #set()

1.10. Булевы значения

Булевы значения в Python это две константы True и False.

В Python истинными и ложными значениями считаются не только True и False.

  • истинное значение:

  • любое ненулевое число

  • любая непустая строка

  • любой непустой объект

  • ложное значение:

  • 0

  • None

  • пустая строка

  • пустой объект

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

Для проверки булевого значения объекта, можно воспользоваться bool:

items = [1, 2, 3]
empty_list = []
bool(empty_list) #False
bool(items) #True
bool(0) #False
bool(1) #True

1.11. Преобразование типов

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

int()

преобразует строку в int:

int("10") #10
int("11111111", 2) #255  С помощью функции int можно преобразовать и число в двоичной записи в десятичную (двоичная запись должна быть в виде строки)

bin()

Преобразовать десятичное число в двоичный формат можно с помощью bin():

bin(10) #'0b1010'
bin(255) #'0b11111111'

hex()

Аналогичная функция есть и для преобразования в шестнадцатеричный формат:

hex(10) #'0xa'
hex(255) #'0xff'

list()

Функция list() преобразует аргумент в список:

list("string") #['s', 't', 'r', 'i', 'n', 'g']
list({1,2,3})  #[1, 2, 3]
list((1,2,3,4)) #[1, 2, 3, 4

set()

Функция set() преобразует аргумент в множество:

set([1,2,3,3,4,4,4,4]) #{1, 2, 3, 4}
set((1,2,3,3,4,4,4,4)) #{1, 2, 3, 4}
set("string string") #{' ', 'g', 'i', 'n', 'r', 's', 't'}

tuple()

Функция tuple() преобразует аргумент в кортеж:

tuple([1,2,3,4]) #(1, 2, 3, 4)
tuple({1,2,3,4}) #(1, 2, 3, 4)
tuple("string")  #('s', 't', 'r', 'i', 'n', 'g')

str()

Функция str() преобразует аргумент в строку:

str(10) #'10'

1.12. Проверка типов

isdigit()

Проверяет, сосоит ли строка из одних только цифр

"a".isdigit() #False
"a10".isdigit() #False
"10".isdigit() #True

isalpha()

Проверяет, состоит ли строка из одних букв:

"a".isalpha() #True
"a100".isalpha() #False
"a--  ".isalpha() #False
"a ".isalpha() #False

isalnum()

позволяет проверить, состоит ли строка из букв или цифр:

"a".isalnum() #True
"a10".isalnum() #True

type()

Иногда, в зависимости от результата, библиотека или функция может выводить разные типы объектов. Например, если объект один, возвращается строка, если несколько, то возвращается кортеж.

Нам же надо построить ход программы по-разному, в зависимости от того, была ли возвращена строка или кортеж.

В этом может помочь функция type():

type("string") #str
type("string") is str #True

#Аналогично с кортежем (и другими типами данных):
type((1,2,3)) #tuple
type((1,2,3)) is tuple #True
type((1,2,3)) is list #False

1.13. Файлы

Объекты файлов являются главным интерфейсом к внешним файлам на компью­ тере. Они могут применяться для чтения и записи текстовых заметок, аудиоклипов, документов Excel, сохраненных сообщений электронной почты и всего того, что вы в итоге сохранили на своем компьютере. Файлы относятся к основным типам, но они кое в чем своеобразны — специфический литеральный синтаксис для их создания от­ сутствует, Взамен, чтобы создать объект файла, необходимо вызвать встроенную фун­ кцию open, передав ей в виде строк имя внешнего файла и необязательный режим обработки.

Например, для создания выходного текстового файла понадобится передать его имя и строку режима обработки ’ w ’, чтобы записывать данные:

f = open('data.txt' , 'w') # Создать новый файл в режиме записи ('w')
f.write('Hello\n') # Записать в него строки символов
f.write ('world\n') # Возвратить количество записанных элементов
f.close()   # Закрыть для сбрасывания буферов вывода на диск

Код создает файл в текущем каталоге и записывает в него текст (имя файла мо­ жет содержать полный путь к каталогу, если нужно получить доступ к файлу где-то в другом месте на компьютере). Чтобы прочитать то, что было записано, необходимо повторно открыть файл в режиме обработки ’ г ’ для чтения текстового ввода (он вы­ бирается по умолчанию, если в вызове строка режима не указана). Затем следует про­ читать содержимое файла в строку и отобразить ее. В сценарии содержимое файла всегда будет строкой независимо от типа находящихся в нем данных:

f = open('data.txt')    # 'г' (чтение) - стандартный режим обработки
text = f.read()         # Прочитать все содержимое файла в строку
text                    #'Hello\nworld\n'
print(text)             # print интерпретирует управляющие символы
#Hello
#world
text.split()            # Содержимое файла - всегда строка
#['Hello', 'world']

Примечание

Обратите внимание, что для того что бы прочесь все строки из файла, нам нужно обернуть функцию чтения в цикл for line in open(’data.txt’): print(line)

так же не забывайте закрывать файл после операции чтения или записи f.close

Примечание

Ранее в примере с подсчетом слов мы использовали друую констукцию

with open(filename, encoding=»utf8») as file: #эта строка открывает файл

text = file.read() #читаем содержимое файла и записываем все в переменную text

text = text.replace(«n», » «) #преобразуем наш текст в одну длинную строку заменив символ перевода строки на пробел

text = text.replace(«,», «»).replace(«.», «»).replace(«?», «»).replace(«!», «») #а так же уберем все запетые, пробелы, и прочие знаки пунктуации

text = text.lower() #перведем все слова в строчные, тоесть если было «Начало изучения Языка Программирования», то будет «начало изучения языка программирования»

words = text.split() #создадим список слов («списки»,»выгледят»,»вот»,»так»)

words.sort()

Такой подход позволяет не закрывать файл в ручную.