Как объявить тип переменной в python

5. Python – Типы переменных

Типы переменных в Python – это не что иное, как зарезервированные ячейки памяти для хранения значений. Это означает, что при создании переменной вы резервируете некоторое место в памяти.

В зависимости от типа данных переменной интерпретатор выделяет память и решает, что можно сохранить в зарезервированной памяти. Следовательно, назначая переменным разные типы данных, вы можете хранить в этих переменных целые числа, десятичные дроби или символы.

Как указать значение переменной в Python

Типа переменных в Питон не нуждаются в явном объявлении для резервирования места в памяти. Объявление происходит автоматически, когда вы присваиваете значение переменной. Знак равенства (=) используется для присвоения типа переменным.

Операнд слева от оператора = – это имя переменной, а операнд справа от оператора = – это значение, хранящееся в переменной. Например, как объявить тип переменной:

#!/usr/bin/python counter = 100 # Присвоение целого числа miles = 1000.0 # С плавающей точкой name = "Джон" # Строка print counter print miles print name 

Здесь 100, 1000.0 и «Джон» – это значения, присвоенные переменным counter, miles и name соответственно. Это дает следующий результат:

100 1000.0 Джон 

Множественное присвоение

Python позволяет назначать одно значение нескольким переменным одновременно. Это множественное присвоение. Например:

а = b = с = 1

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

a, b, c = 1,2, «john»

Здесь два целочисленных объекта со значениями 1 и 2 присвоены переменным a и b соответственно, а один строковый объект со значением «john» назначен переменной c.

Стандартные типы данных

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

Python имеет пять стандартных типов данных:

Числа Python

Числовые типы данных хранят числовые значения. Числовые объекты создаются, когда вы присваиваете им значение. Например:

var1 = 1 var2 = 10 

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

del var1[, var2[, var3[. varN]]]]

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

del var del var_a, var_b 

Типы числовых переменных Python:

• int (целые числа со знаком)
• long (длинные целые числа, они также могут быть представлены в восьмеричном и шестнадцатеричном формате)
• float (реальные значения с плавающей точкой)
• complex (комплексные числа)

Примеры

Вот несколько примеров числовых данных:

int

long

float

complex

• Python позволяет использовать строчную букву l для long, но рекомендуется использовать только верхний регистр L, чтобы избежать путаницы с числом 1. Python отображает длинные целые числа с прописной L.
• Комплексное число состоит из упорядоченной пары реальных чисел с плавающей запятой, обозначенных как x + yj, где x и y — реальные числа, а j — мнимая единица.

Типы строк в Python

Строки в Python идентифицируются как непрерывный набор символов, представленных в кавычках. Python позволяет использовать пары одинарных или двойных кавычек. Подмножества строк могут быть взяты с помощью оператора вырезки ([] и [:]) с индексами, начинающимися с 0 в начале строки и -1 в конце.

Знак плюс (+) – это оператор конкатенации строк, а звездочка (*) – оператор повторения. Например:

#!/usr/bin/python str = Привет, мир!' print str # Выводит полную строку print str[0] # Выводит первый символ строки print str[2:5] # Выводит символы с 3-го по 5-й print str[2:] # Выводит строку, начиная с 3-го символа print str * 2 # Выводит строку два раза print str + "ТЕСТ" # Выводит составную строку 

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

Привет, мир! П иве ивет, мир! Привет, мир! Привет, мир! Привет, мир!ТЕСТ 

Списки

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

К значениям, хранящимся в списке, можно получить доступ с помощью оператора вырезки ([] и [:]) с индексами, начинающимися с 0 в начале списка и продвигающимися до конца -1. Знак плюс (+) ч это оператор конкатенации списков, а звездочка (*) – оператор повторения. Например:

#!/usr/bin/python list = [ 'abcd', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # Выводит полный список print list[0] # Выводит первый элемент списка print list[1:3] # Выводит элементы со 2-го по 3-й print list[2:] # Выводит элементы, начиная с 3-го элемента print tinylist * 2 # Выводит список два раза print list + tinylist # Выводит составные списки 

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

[abcd, 786, 2.23, john, 70.2] abcd [786, 2.23] [2.23, 'john', 70.2] [123, 'john', 123, 'john'] [abcd, 786, 2.23, john, 70.2, 123, john] 

Кортежи Python

Кортеж – это другой тип данных последовательности, похожий на список. Кортеж состоит из ряда значений, разделенных запятыми. Однако, в отличие от списков, кортежи заключаются в круглые скобки. Основные различия между списками и кортежами заключаются в следующем: списки заключаются в квадратные скобки ([]), их элементы и размер могут быть изменены, а кортежи заключаются в круглые скобки (()) и данные внутри не могут быть обновлены. Кортежи можно рассматривать как списки только для чтения. Например:

#!/usr/bin/python tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print tuple # Выводит полный кортеж print tuple[0] # Выводит первый элемент кортежа print tuple[1:3] # Выводит элементы кортежа со 2-го по 3-й print tuple[2:] # Выводит элементы кортежа, начиная с 3-го элемента print tinytuple * 2 # Выводит содержимое кортежа дважды print tuple + tinytuple # Выводит составные кортежи 

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

('abcd', 786, 2.23, 'john', 70.2) abcd (786, 2.23) (2.23, 'john', 70.2) (123, 'john', 123, 'john') ('abcd', 786, 2.23, 'john', 70.2, 123, 'john') 

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

#!/usr/bin/python tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 ) list = [ 'abcd', 786 , 2.23, 'john', 70.2 ] tuple[2] = 1000 # Неверный синтаксис с кортежем list[2] = 1000 # Действительный синтаксис со списком 

Словарь

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

Словари заключаются в фигурные скобки (<>), а значения могут быть присвоены и доступны с помощью квадратных скобок ([]). Например:

#!/usr/bin/python dict = <> dict['один'] = "Это один" dict[2] = "Это два" tinydict = print dict['one'] # Выводит значение для ключа 'один' print dict[2] # Выводит значение для ключа 2 print tinydict # Выводит весь словарь print tinydict.keys() # Выводит все ключи print tinydict.values() # Выводит все значения 

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

Это один Это два ["отдел", "код", "имя"] ['продажи', 6734, 'john'] 

В словарях отсутствует понятие порядка элементов. Неверно говорить, что элементы расположены «не по порядку»; они просто не упорядочены.

Преобразование типов данных Python

Иногда вам может потребоваться выполнить преобразование между встроенными типами данных питон. Для преобразования между типами вы просто используете имя типа как функцию.

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

п/п

Функция и описание

int(x [,base])
Преобразует x в целое число. base указывает основание, если x — строка.

long(x [,base] )
Преобразует x в длинное целое число. base указывает основание, если x — строка.

float(x)
Преобразует x в число с плавающей запятой.

complex(real [,imag])
Создает комплексное число.

str(x)
Преобразует объект x в строковое представление.

repr(x)
Преобразует объект x в строку выражения.

eval(str)
Оценивает строку и возвращает объект.

tuple(s)
Преобразует s в кортеж.

list(s)
Преобразует s в список.

set(s)
Преобразует s в набор.

dict(d)
Создает словарь. d должен быть последовательностью (ключ, значение) кортежей.

frozenset(s)
Преобразует s в замороженный набор.

chr(x)
Преобразует целое число в символ.

unichr(x)
Преобразует целое число в символ Юникода.

ord(x)
Преобразует одиночный символ в его целочисленное значение.

hex(x)
Преобразует целое число в шестнадцатеричную строку.

oct(x)
Преобразует целое число в восьмеричную строку.

Оглавление

• 1. Python – Самоучитель для начинающих
• 2. Python – Обзор
• 3. Python – Установка среды
• 4. Python – Базовый синтаксис
• 4.1. Python – Аргументы командной строки
• 5. Python – Типы переменных
• 6. Python – Основные операторы
• 6.1. Python – Арифметические операторы
• 6.2. Python – Операторы сравнения
• 6.3. Python – Операторы присваивания: примеры
• 6.4. Python – Побитовые операторы
• 6.5. Python – Логические операторы
• 6.6. Python – Операторы членства
• 6.7. Python – Операторы идентификации
• 6.8. Python – Приоритет операторов
• 7. Python – Условные операторы
• 7.1. Python – Условие if
• 7.2. Python – Условные операторы if. else и elif
• 7.3. Python – Вложенные операторы if
• 8. Python – Циклы
• 8.1. Python – Цикл while
• 8.2. Python – Цикл for
• 8.3. Python – Вложенные циклы
• 8.4. Python – Оператор break
• 8.5. Python – Оператор continue
• 8.6. Python – Оператор pass
• 9. Python – Числа
• 9.1. Python – Метод abs()
• 9.2. Python – Метод ceil()
• 9.3. Python – Метод cmp()
• 9.4. Python – Метод exp()
• 9.5. Python – Метод fabs()
• 9.6. Python – Метод floor()
• 9.7. Python – Метод log()
• 9.8. Python – Метод log10()
• 9.9. Python – Метод max()
• 9.10. Python – Метод min()
• 9.11. Python – Метод modf()
• 9.12. Python – Метод pow()
• 9.13. Python – Метод round()
• 9.14. Python – Метод sqrt()
• 9.15. Python – Метод choice()
• 9.16. Python – Метод randrange()
• 9.17. Python – Метод random()
• 9.18. Python – Метод seed()
• 9.19. Python – Метод shuffle()
• 9.20. Python – Метод uniform()
• 9.21. Python – Метод acos()
• 9.22. Python – Метод asin()
• 9.23. Python – Метод atan()
• 9.24. Python – Метод atan2()
• 9.25. Python – Метод cos()
• 9.26. Python – Метод hypot()
• 9.27. Python – Метод sin()
• 9.28. Python – Метод tan()
• 9.29. Python – Метод degrees()
• 9.30. Python – Метод radians()

Типизация в Python. Типы данных, переменные

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

Числа

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

 
var1 = 1 var2 = 10
Ссылка на числовой объект без проблем удаляется с помощью оператора del. Синтаксис:
 
del var1[,var2[,var3[. varN]]]]
В Python поддерживаются 3 разных числовых типа: — целые числа со знаком (int); — значения с плавающей запятой (float); — комплексные числа (complex).
В Python 3 все целые числа представлены как long числа, то есть отдельного типа long нет.
Чтобы узнать класс переменной либо значения, мы можем использовать функции type() и isinstance() . Это позволяет проверить принадлежность объекта конкретному классу:
 
>>> a = 5 >>> print(a, "is of type", type(a)) 5 is of type >>> a = 2.0 >>> print(a, "is of type", type(a)) 2.0 is of type >>> a = 1+2j >>> print(a, "is complex number?", isinstance(1+2j, complex)) (1+2j) is complex number? True
У чисел с плавающей запятой ограниченная точность. Визуально разница видна в консоли по наличию точки: 1.0 — число с плавающей запятой, 1 — целое число.
Что касается комплексных чисел, то они записываются в виде x+yj . Х в данном случае — действительная часть числа, Y — мнимая. Примеры:
 
>>> a = 1234567890123456789 >>> a 1234567890123456789 >>> b = 0.1234567890123456789 >>> b 0.12345678901234568 >>> c = 1+2j >>> c (1+2j)
Здесь следует учесть, что значение переменной b усечено.
Списки
Список — упорядоченная последовательность элементов. Этот тип данных используется в Python очень часто. Кстати, все элементы списка не обязательно должны иметь один и тот же тип.
Объявить список несложно. Элементы помещаются внутрь квадратных скобок и разделяются запятой:
 
>>> a = [1, 2.2, 'python']
Для доступа к значениям списка используют оператор среза [] . Индексация в Python начинается с нуля:
 
>>> a = [5,10,15,20,25,30,35,40] >>> print("a[2] =", a[2]) a[2] = 15 >>> print("a[0:3] =", a[0:3]) a[0:3] = [5, 10, 15] >>> print("a[5:] =", a[5:]) a[5:] = [30, 35, 40]
Списки — изменяемый тип, т. е. значения элементов можно менять:
 
>>> a = [1,2,3] >>> a[2] = 4 >>> a [1, 2, 4]
Кортежи
Кортежи, как и списки — это упорядоченные последовательности элементов, только они неизменяемы. Кроме того, кортежи заключены в круглые скобки. Их используют для защиты данных о перезаписи. Эти типы данных можно рассматривать как «списки только для чтения».
 
>>> t = (5,'program', 1+3j)
Для извлечения элементов также используют оператор среза [] . Но поменять значения не получится:
 
>>> t = (5,'program', 1+3j) >>> print("t[1] =", t[1]) t[1] = program >>> print("t[0:3] =", t[0:3]) t[0:3] = (5, 'program', (1+3j)) # Приведёт к ошибке, т. к. # кортежи неизменяемы >>> t[0] = 10
Строки
Строка — непрерывный набор символов, которые размещаются в двойных или одинарных кавычках:
 
>>> s = "Простая строка" >>> s = '''многострочная строка'''
Как и в случае с кортежами и списками, можно применять [] . Строки — тип данных, который относится к категории неизменяемых последовательностей.
Множества
Неупорядоченная уникализированная последовательность, объявляемая посредством элементов, которые разделены запятой внутри фигурных скобок:
 >>> a = # вывод переменной множества >>> print("a =", a) a = # тип данных переменной а >>> print(type(a))
Можно выполнять объединение и пересечение множеств. Так как все элементы должны быть уникальными, дубликаты автоматически удаляются:
 >>> a = >>> a
Раз последовательность не упорядочена, оператор извлечения среза не работает.
Словари
Словари — это хеш-таблицы или неупорядоченные наборы пар типа «ключ-значение». Работают, как ассоциативные массивы. Используются, если нужно сопоставить значение какому-нибудь ключу, чтобы иметь возможность получить доступ к этому значению, имея соответствующий ключ. В других языках программирования словари называют map , hash , object .
Словарь оптимизирован для извлечения данных. Он объявляется парами элементов в виде ключ:значение, которые заключены в фигурные скобки:
 >>> d = >>> type(d)
Ключ используется для получения значения, которое ему соответствует. Не наоборот!
 
>>> d = >>> print("d[1] =", d[1]); d[1] = value >>> print("d['key'] =", d['key']); d['key'] = 2 # Приведёт к ошибке >>> print("d[2] =", d[2]);
Преобразование типов данных
Мы можем преобразовывать значения из одного типа в другой с помощью таких функций, как int() , str() , float() и других:
 
>>> float(5) 5.0
Когда происходит преобразование числа с плавающей запятой в целое, то теряется часть после запятой:
 
>>> int(10.6) 10 >>> int(-10.6) -10
Преобразование в словарь требует, чтобы каждый элемент последовательности был парой:
 >>> dict([[1,2],[3,4]]) >>> dict([(3,26),(4,44)])
Подробнее о преобразовании типов данных в Python смотрите в таблице ниже:


Материал «Типизация в Python. Типы данных, переменные» подготовлен специально для OTUS на основании статьи «Python Data Types».
Как определить тип переменной в Python

Узнайте о различных способах определения типа переменной в Python с помощью функций type(), isinstance() и аннотаций типов, чтобы улучшить ваш код!

Алексей Кодов

Автор статьи

23 июня 2023 в 18:43
Определение типа переменной в Python является важным аспектом при работе с данными, особенно для новичков, которые только начинают изучать этот язык программирования. В этой статье мы рассмотрим основные методы определения типа переменной в Python. ��
Использование функции type()
Один из самых простых и распространенных способов определить тип переменной в Python — использовать встроенную функцию type() . Вот как это работает:
x = 5 print(type(x))
В этом примере переменная x имеет тип int (целое число).
Использование isinstance()
Еще один способ определения типа переменной — использовать функцию isinstance() . Она проверяет, является ли объект экземпляром указанного класса или кортежа классов. Вот пример:
x = "hello" if isinstance(x, str): print("x is a string") else: print("x is not a string")
x is a string 
Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Аннотации типов
Начиная с Python 3.5, вы можете использовать аннотации типов для указания ожидаемого типа переменной. Это не влияет на выполнение кода, но может помочь в проверке кода и автодополнении в редакторах кода. Вот пример:
def greet(name: str) -> str: return "Hello, " + name x = "world" print(greet(x))
В этом примере функция greet ожидает, что аргумент name будет типа str и также возвращает строку.
Обратите внимание, что аннотации типов не являются обязательными и не влияют на выполнение кода. Их главная цель — помочь программистам лучше понимать код и предотвратить ошибки.
Заключение
Теперь вы знаете основные способы определения типа переменной в Python. Используйте функции type() и isinstance() для определения типа переменных, а также аннотации типов для улучшения читаемости кода.
Не забывайте практиковаться и изучать больше о Python, чтобы стать успешным разработчиком! ��
1. Типы данных¶
Переменная в языке программирования это название для зарезервированного места в памяти компьютера, предназначенное для хранения значений. Это означает, что когда вы создаете переменную, вы на самом деле резервируете определенное место в памяти компьютера. Основываясь на типе данных переменной, интерпретатор выделяет необходимое количество памяти и решает, что может находится в зарезервированной области памяти. Для понимания, можете думать о переменной как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Это не совсем верное определение, но оно дает общее представление о картине в целом.
Присвоение значения переменной:
В Python вам не нужно объявлять тип переменной вручную (как, например в С++). Объявление происходит автоматически (это называется динамическая типизация), когда вы присваиваете значение переменной. Знак равенства ( = ) используется для присвоения значения переменной. Операнд по левую сторону от знака равно ( = ) это имя переменной, операнд по правую сторону - значение присвоенное этой переменной.
Таблица - Обзор встроенных типов объектов
Описание и пример
-35, 0, 24, 123467890033373747428
Числа с плавающей точкой
Дробные числа 3.14, 2.5, -2.33333, 0.12334
Строки «asdf», «Hello world», «123456»
[«hello», -123, 0.34, «345»]
Последовательность пар элементов содержаших ключ-значение (key-value)
Неизменяемая упорядоченная последовательность элементов («hostname», 1234, -0.45, -32)
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 #порядок значений можно указывать '  '.format('one', 'two') #two one #Можно так же подставлять значения классов class Data(object): def __str__(self): return 'str' def __repr__(self): return 'repr' '  '.format(Data()) #str repr #Отступы и выравнивания #по правому краю '10>'.format('test') # test #по левому краю ' '.format('test') #test______ #по центру ' '.format('test') # test #срезы ' '.format('xylophone') #xylop #срезы и отступы ' '.format('xylophone') #xylop #числа ' '.format(42) #42 ' '.format(3.141592653589793) #3.141593 #числа и отступы ' '.format(42) # 42 ' '.format(3.141592653589793) #003.14 ' '.format(42) # 0042 #знаковые числа ' '.format(42) #+42 ' '.format((- 23)) #-23 ' '.format(42) # 42 ' '.format((- 23)) #- 23 ' '.format(23) #+ 23 #можно вставлять значения по именам data = 'first': 'Hodor', 'last': 'Hodor!'> '  '.format(**data) #Hodor Hodor! '  '.format(first='Hodor', last='Hodor!') #Hodor Hodor! #Формат даты и времени from datetime import datetime '%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) #
Хотя форма литерала в фигурных скобках встречается, пожалуй, чаще приходится видеть словари, построенные другими способами (все данные программы редко из­ вестны до ее запуска). Скажем, следующий код начинает с пустого словаря и заполняет его по одному ключу за раз. В отличие от присваивания элементу в списке, находящемуся вне установленных границ, которое запрещено, присваивание новому ключу словаря приводит к созданию этого ключа:
D = <> D['name'] = 'Bob' D['job'] = 'dev' D['age'] =40 print (D) # 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 # 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 #
update()
Позволяет добавлять в словарь содержимое другого словаря:
r1 = 'name': 'London1', 'location': 'London Str'> r1.update('vendor': 'Cisco', 'ios':'15.2'>) r1 # #Аналогичным образом можно обновить значения: r1.update('name': 'london-r1', 'ios':'15.4'>) 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) # vlans1 | vlans2 # #Пересечение множеств можно получить с помощью метода intersection() или оператора & vlans1 = 10,20,30,50,100> vlans2 = 100,101,102,102,200> vlans1.intersection(vlans2) # vlans1 & vlans2 #
Нельзя создать пустое множество с помощью литерала (так как в таком случае это будет не множество, а словарь): set1 = <> type(set1) #dict
Но пустое множество можно создать таким образом set2 = set() type(set2) #set
1.9. Методы для работы с множествами¶
add()
добавляет элемент во множество:
set1 = 10,20,30,40> set1.add(50) set1 #
discard()
позволяет удалять элементы, не выдавая ошибку, если элемента в множестве нет
set1 # set1.discard(55) set1 # set1.discard(50) set1 #
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]) # set((1,2,3,3,4,4,4,4)) # set("string string") #
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()
Такой подход позволяет не закрывать файл в ручную.
© Copyright 2020, Oleg Kishinskii Revision 87b11443 .
Built with Sphinx using a theme provided by Read the Docs.

Read the Docs v: latest
Versions latest Downloads pdf html epub On Read the Docs Project Home Builds Free document hosting provided by Read the Docs.
Читать:
Абрис как делать