Работа с текстовыми файлами python 3

Openpyxl Charts

The library supports creation of various charts, including
bar charts, line charts, area charts, bubble charts, scatter charts, and pie charts.

According to the documentation, supports chart creation within
a worksheet only. Charts in existing workbooks will be lost.

create_bar_chart.py

#!/usr/bin/env python

from openpyxl import Workbook
from openpyxl.chart import (
    Reference,
    Series,
    BarChart
)

book = Workbook()
sheet = book.active

rows = 

for row in rows:
    sheet.append(row)
    
data = Reference(sheet, min_col=2, min_row=1, max_col=2, max_row=6)
categs = Reference(sheet, min_col=1, min_row=1, max_row=6)

chart = BarChart()
chart.add_data(data=data)
chart.set_categories(categs)

chart.legend = None
chart.y_axis.majorGridlines = None
chart.varyColors = True
chart.title = "Olympic Gold medals in London"

sheet.add_chart(chart, "A8")    

book.save("bar_chart.xlsx")

In the example, we create a bar chart to show the number of Olympic
gold medals per country in London 2012.

from openpyxl.chart import (
    Reference,
    Series,
    BarChart
)

The module has tools to work with charts.

book = Workbook()
sheet = book.active

A new workbook is created.

rows = 

for row in rows:
    sheet.append(row)

We create some data and add it to the cells of the active sheet.

data = Reference(sheet, min_col=2, min_row=1, max_col=2, max_row=6)

With the class, we refer to the rows in the sheet that
represent data. In our case, these are the numbers of olympic gold medals.

categs = Reference(sheet, min_col=1, min_row=1, max_row=6)

We create a category axis. A category axis is an axis with the data
treated as a sequence of non-numerical text labels. In our case, we have
text labels representing names of countries.

chart = BarChart()
chart.add_data(data=data)
chart.set_categories(categs)

We create a bar chart and set it data and categories.

chart.legend = None
chart.y_axis.majorGridlines = None

Using and attributes, we
turn off the legends and major grid lines.

chart.varyColors = True

Setting to , each bar has a different
colour.

chart.title = "Olympic Gold medals in London"

A title is set for the chart.

sheet.add_chart(chart, "A8")   

The created chart is added to the sheet with the method.

Figure: Bar chart

In this tutorial, we have worked with the openpyxl library. We have read data
from an Excel file, written data to an Excel file.

Visit Python tutorial or
list .

Стилевое оформление

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

from openpyxl.styles import Font

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

import openpyxl
from openpyxl.styles import Font

# создаем новый excel-файл
wb = openpyxl.Workbook()
# добавляем новый лист
wb.create_sheet(title = 'Первый лист', index = )
# получаем лист, с которым будем работать
sheet = wb'Первый лист'

font = Font(name='Arial', size=24, italic=True, color='FF0000')
sheet'A1'.font = font
sheet'A1' = 'Здравствуй мир!'

# записываем файл
wb.save('example.xlsx')

Именованные стили применяются, когда надо применить стилевое оформление к большому количеству ячеек.

import openpyxl
from openpyxl.styles import NamedStyle, Font, Border, Side

# создаем новый excel-файл
wb = openpyxl.Workbook()
# добавляем новый лист
wb.create_sheet(title = 'Первый лист', index = )
# получаем лист, с которым будем работать
sheet = wb'Первый лист'

# создаем именованный стиль
ns = NamedStyle(name='highlight')
ns.font = Font(bold=True, size=20)
border = Side(style='thick', color='000000')
ns.border = Border(left=border, top=border, right=border, bottom=border)

# вновь созданный именованный стиль надо зарегистрировать
# для дальнейшего использования
wb.add_named_style(ns)

# теперь можно использовать именованный стиль
sheet'A1'.style = 'highlight'

# записываем файл
wb.save('example.xlsx')

Создание наших собственных менеджеров контекста для нашего класса

Рассмотрим приведенный ниже класс, для которого у нас будет собственный диспетчер контекста для обработки файлов.

class MyFileHandler():
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        # Originally, context object is None
        self.context_object = None


    # The context manager executes this first
    # Save the object state
    def __enter__(self):
        print("Entered the context!")
        self.context_object = open(self.filename, self.mode)
        return self.context_object


    # The context manager finally executes this before exiting
    # Information about any Exceptions encountered will go to
    # the arguments (type, value, traceback)
    def __exit__(self, type, value, traceback):
        print("Exiting the context....")
        print(f"Type: {type}, Value: {value}, Traceback: {traceback}")
        # Close the file
        self.context_manager.close()
        # Finally, restore the context object to it's old state (None)
        self.context_object = None

# We're simply reading the file using our context manager
with MyFileHandler('input.txt', 'r') as file_handle:
    for line in file_handle:
        print(line)

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

Теперь метод dunder сохраняет состояние объекта и открывает файл. Теперь мы внутри блока.

После выполнения блока диспетчер контекста наконец выполняет , при этом восстанавливается исходное состояние объекта контекста и файл закрывается.

Выход

Entered the context!
Hello from AskPython

This is the second line

This is the last line!
Exiting the context....
Type: None, Value: None, Traceback: None

Хорошо, похоже, у нас нет ошибок. Мы только что реализовали собственные контекстные менеджеры для нашего Custom Class. Теперь есть другой подход к созданию диспетчера контекста, который использует генераторы.

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

Есть два разных метода для менеджера контекста. Эти методы —

Шаг 2 — Открытие файла

Прежде чем написать программу, нужно создать файл для кода Python. С помощью текстового редактора создадим файл files.py. Чтобы упростить задачу, сохраните его в том же каталоге, что и файл days.txt:

/users/sammy/.

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

Чтобы Python мог открыть файл, ему требуется путь к нему: days.txt -/users/sammy/days.txt. Затем создаем строковую переменную для хранения этой информации. В нашем скрипте files.py мы создадим переменную path и установим для нее значение days.txt.

files.py

path = '/users/sammy/days.txt'

Затем используем функцию Python open(), чтобы открыть файл days.txt. В качестве первого аргумента она принимает путь к файлу.

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

Вот некоторые из существующих режимов:

• ‘r’: использовать для чтения;
• ‘w’: использовать для записи;
• ‘x’: использование для создания и записи в новый файл;
• ‘a’: использование для добавления к файлу;
• ‘r +’: использовать для чтения и записи в тот же файл.

В текущем примере нужно только считать данные из файла, поэтому будем использовать режим «r». Применим функцию open(), чтобы открыть файл days.txt и назначить его переменной days_file.

files.py

days_file = open(path,'r')

После открытия файла мы сможем прочитать его, что сделаем на следующем шаге.

Запись в файл

Функциональность внесения данных в файл не зависит от режима — добавление данных или перезаписывание файла. В выполнении этой операции также существует несколько подходов.

Самый простой и логичный — использование функции

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

Конференция IT ENTRANCE 2021

24 апреля в 10:00, Онлайн, Беcплатно

tproger.ru

События и курсы на tproger.ru

Есть возможность записать в файл большой объем данных, если он может быть представлен в виде списка строк.

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

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

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

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

Получение информации о пути в Pathlib

Во время работы с путями зачастую требуется найти родительскую директорию файла/папки или получить символические ссылки. У класса Path есть несколько удобных для этого методов, различные части пути доступны как свойства, что включают следующее:

• : строка, что представляет название жесткого диска. К примеру, вернет ;
• : возвращает , что дает доступ к компонентам пути;
• : компонент пути без директории;
• : последовательность обеспечивает доступ к логическим предкам пути;
• : финальный компонент пути без суффикса;
• : разрешение файла финального компонента;
• : часть пути перед директорией. используется для создания дочерних путей и имитации поведения ;
• : совмещает путь с предоставленными аргументами;
• : возвращает , основываясь на совпадении пути с предоставленным шаблоном поиска.

Например, у нас есть данный путь :

• : — возвращает PosixPath(‘/home/projects/pyscripts/python/sample.md’);
• : — возвращает (‘/’, ‘home’, ‘projects’, ‘pyscripts’, ‘python’);
• : — возвращает ‘sample.md’;
• : — возвращает ‘sample’;
• : — возвращает ‘.md’;
• : — возвращает PosixPath(‘/home/projects/pyscripts/python’);
• : — возвращает PosixPath(‘/home/projects/pyscripts’);
• : возвращает True;
• : возвращает (‘home/projects/pyscripts/python/edited_version.

Benefits of calling open() using “with statement”

Fewer chances of bug due to coding error

No need to explicitly close the opened file, “with statement” takes care of that. When with the block ends, it will automatically close the file. So, it reduces the number of lines of code and reduces the chances of bug.

Excellent handling in case of exception

Check out this example,

# File will be closed before handling the exception
try:
    # using "with statement" with open() function
    with open('sample.txt', "r") as file_object:
        # read file content
        data = file_object.read()
        # it raises an error
        x = 1 / 0
        print(data)
except:
    # handling exception
    print('An Error')
    if file_object.closed == False:
        print('File is not closed')
    else:
        print('File is closed')

An Error
File is closed

We don’t need to call the close() function even in case of exceptions, execution block of “with statement” handles that too and closes the file before exception handling.

We confirmed this using file_object.closed in the except block.

Примеры построчного чтения файла.

• ;
• ;
• .

Общий случай использования метода файла .

# подготовим файл 'foo.txt'
>>> text = 'This is 1st line\nThis is 2nd line\nThis is 3rd line\n'
>>> fp = open('foo.txt', 'w+')
# запишем текст в файл 'foo.txt'
>>> fp.write(text)
# 51

# указатель в начало файла
>>> fp.seek()
# 0

# начинаем читать построчно
>>> fp.readline()
# 'This is 1st line\n'
>>> fp.readline()
# 'This is 2nd line\n'
>>> fp.readline()
# 'This is 3rd line\n'
>>> fp.readline()
# ''
>>> fp.close()

Чтение файла при помощи цикла .

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

>>> fp = open('foo.txt', 'r')
>>> next(fp)
# 'This is 1st line\n'
>>> next(fp)
# 'This is 2nd line\n'
>>> next(fp)
# 'This is 3rd line\n'
>>> next(fp)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# StopIteration
>>> fp.close()

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

Внимание! Функцию предпочтительнее использовать с оператором контекстного менеджера. При использовании оператора файл закрывать не нужно:

>>> with open('foo.txt', 'r') as fp
...     for n, line in enumerate(fp, 1):
...         # Обработка строки 'line'
...         line = line.rstrip('\n')
...         print(f"Вывод строки: {n}) - {line}")
... 
# Вывод строки: 1) - This is 1st line
# Вывод строки: 2) - This is 2nd line
# Вывод строки: 3) - This is 3rd line

Чтение строк файла кусками при помощи цикла .

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

>>> fp = open('foo.txt', 'r')
# будем читать строку по 10 байт
>>> line = fp.readline(10)
>>> while line
...     line = line.rstrip('\n')
...     print(line)
...     line = fp.readline(10)
... 
# This is 1s
# t line
# This is 2n
# d line
# This is 3r
# d line

>>> fp.close()

Параметры

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

Pretty-Printing

Сделать JSON более удобочитаемым (pretty-printing) — очень просто. Нужно лишь передать целое число в параметр : 

import json
data = {'people':}
json.dumps(data, indent=4)
{
    "people": 
}

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

$ echo '{"people":}' | python -m json.tool
{
    "people": 
}

Сортировка

В JSON объект определяется следующим образом:

То есть, порядок не гарантируется. Но навести его реально. Сделать это можно с помощью передачи в параметр в методах или .

import json
data = {'people':}
json.dumps(data, sort_keys=True, indent=4)
{
    "people": 
}

ASCII-текст

По умолчанию проверяет, имеет ли ваш текст в словаре кодировку ASCII. Если присутствуют символы, отличные от ASCII, они автоматически экранируются. Это показано в следующем примере:

import json
data = {'item': 'Beer', 'cost':'£4.00'}
jstr = json.dumps(data, indent=4)
print(jstr)
{
    "item": "Beer",
    "cost": "\u00a34.00"
}

Но это не всегда приемлемо. Во многих случаях вы бы хотели сохранить символы Unicode нетронутыми. Для этого нужно передать в параметр значение .

jstr = json.dumps(data, ensure_ascii=False, indent=4)
print(jstr)
{
    "item": "Beer",
    "cost": "£4.00"
}

Извлечение текста с помощью PyMuPDF

Перейдём к PyMuPDF.

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

import fitz

pdf_document = "./source/Computer-Vision-Resources.pdf"
doc = fitz.open(pdf_document)
print("Исходный документ: ", doc)
print("\nКоличество страниц: %i\n\n------------------\n\n" % doc.pageCount)
print(doc.metadata)

for current_page in range(len(doc)):
    page = doc.loadPage(current_page)
    page_text = page.getText("text")
    print("Стр. ", current_page+1, "\n\nСодержание;\n")
    print(page_text)

Извлечение текста с помощью PyMuPDF

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

Способ 1

import os
import shutil
import glob

# перейти в папку RandomFiles
os.chdir('./RandomFiles')

# получить список файлов в папке RandomFiles
files_to_group = []
for random_file in os.listdir('.'):
    files_to_group.append(random_file)

# получить все расширения имен всех файлов
file_extensions = []
for our_file in files_to_group:
    file_extensions.append(os.path.splitext(our_file))

print(set(file_extensions))

file_types = set(file_extensions)

for type in file_types:
    new_directory = type.replace(".", " ")
    os.mkdir(new_directory)  # создать папку с именем данного расширения

    for fname in glob.glob(f'*.{type}'):
        shutil.move(fname, new_directory)

Для этого импортируем еще две библиотеки: shutil и glob. Первая поможет перемещать файлы, а вторая – находить и систематизировать. Но обо всем по порядку.

Для начала получим список всех файлов в директории.

Здесь мы предполагаем, что у нас нет ни малейшего понятия о том, какие именно файлы лежат в этой папке. Вместо того, чтобы вписывать все расширения вручную и использовать лестницу инструкций if или switch, мы желаем, чтобы программа сама просмотрела каталог и определила, на какие типы можно разделить его содержание. Что, если бы там были файлы с десятками расширений или логи? Вы бы стали описывать их вручную?

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

Обратите внимание на разделение строки:

os.path.splitext(our_file)

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

`('5', '.docx')`

Мы возьмем отсюда второй элемент по индексу , то есть . Ведь по индексу у нас располагается 5.

Таким образом, у нас имеется список всех файловых расширений в папке, в том числе повторяющихся. Чтобы оставить только уникальные элементы, преобразуем его во множество. К примеру, если бы этот список состоял исключительно из , повторяющегося снова и снова, то в set остался бы всего один элемент.

# создать множество и присвоить его переменной
file_types = set(file_extensions)

Заметим, что в списке типов файлов каждое расширение содержит в начале. Если мы назовем так папки на UNIX-системе, то они будут скрытыми, что не входит в наши намерения.

Поэтому, итерируя
по нашему множеству, мы заменяем точку на пустую строку. И создаем папку с полученным
названием.

new_directory = type.replace(".", " ")
# наша директория теперь будет называться "docx"

Но чтобы переместить файлы, нам все еще нужно расширение .

for fname in glob.glob(f'*.{type}')

Этим попросту отбираем все файлы, оканчивающиеся расширением . Заметьте, что в нет пробелов.

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

Что дальше?
Перемещаем любые файлы с данным расширением в директорию с тем же названием.

shutil.move(fname, new_directory)

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

Шаг 3 — Чтение файла

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

Первая операция <file>.read() возвращает все содержимое файла как одну строку.

days_file.read()
Вывод

'MondaynTuesdaynWednesdaynThursdaynFridaynSaturdaynSundayn'

Вторая операция <file>.readline() возвращает следующую строку файла (текст до следующего символа новой строки, включая сам символ). Проще говоря, эта операция считывает файл по частям.

days_file.readline()
Вывод
'Mondayn'

Поэтому, когда вы прочтете строку с помощью readline, она перейдет к следующей строке. Если вы снова вызовете эту операцию, она вернет следующую строку, прочитанную в файле.

days_file.readline()
Вывод
'Tuesdayn'

Последняя операция, <file>.readlines(), возвращает список строк в файле. При этом каждый элемент списка представляет собой одну строку.

days_file.readlines()
Вывод

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

Openpyxl dimensions

To get those cells that actually contain data, we can use dimensions.

dimensions.py

#!/usr/bin/env python

from openpyxl import Workbook

book = Workbook()
sheet = book.active

sheet = 39
sheet = 19

rows = 

for row in rows:
    sheet.append(row)

print(sheet.dimensions)
print("Minimum row: {0}".format(sheet.min_row))
print("Maximum row: {0}".format(sheet.max_row))
print("Minimum column: {0}".format(sheet.min_column))
print("Maximum column: {0}".format(sheet.max_column))

for c1, c2 in sheet:
    print(c1.value, c2.value)

book.save('dimensions.xlsx')

The example calculates the dimensions of two columns of data.

sheet = 39
sheet = 19

rows = 

for row in rows:
    sheet.append(row)

We add data to the worksheet. Note that we start adding from
the third row.

print(sheet.dimensions)

The property returns the top-left and bottom-right
cell of the area of non-empty cells.

print("Minimum row: {0}".format(sheet.min_row))
print("Maximum row: {0}".format(sheet.max_row))

Witht the and properties, we get the minimum
and maximum row containing data.

print("Minimum column: {0}".format(sheet.min_column))
print("Maximum column: {0}".format(sheet.max_column))

With the and properties, we get the minimum
and maximum column containing data.

for c1, c2 in sheet:
    print(c1.value, c2.value)

We iterate through the data and print it to the console.

$ ./dimensions.py 
A3:B9
Minimum row: 3
Maximum row: 9
Minimum column: 1
Maximum column: 2
39 19
88 46
89 38
23 59
56 21
24 18
34 15

This is the output of the example.

Концепт пути и директории в Python

Перед началом подробного рассмотрения модуля Pathlib важно разобраться в разнице между главными концептами темы — путем (path) и директорией (directory)

• Путь используется для идентификации файла. Путь предоставляет необязательную последовательность названий директорий, в конце которой значится конечное имя файла, а также его расширение;
• Расширение названия файла предоставляет некоторую информацию о формате/содержимом файла. Модуль Pathlib может работать как с абсолютными, так и с относительными путями;
• Абсолютный путь начинается с корневой директории и определяет полное дерево каталогов;
• Относительный путь, как следует из названия, является путем к файлу относительно другого файла или директории, обычно текущей;
• Директория представляет собой запись пути в файловой системе и включает название файла, время создания, размер, владельца и так далее.

Модуль Pathlib в Python занимается задачами, связанными с путями, такими как создание новых путей из названий файлов и других путей, проверка различных свойств путей, создание файлов и папок по определенным путям.

Statistics

For the next example, we need to create a xlsx file containing
numbers. For instance, we have created 25 rows of numbers in
10 columns with the function.

mystats.py

#!/usr/bin/env python

import openpyxl
import statistics as stats

book = openpyxl.load_workbook('numbers.xlsx', data_only=True)

sheet = book.active

rows = sheet.rows

values = []

for row in rows:
    for cell in row:
        values.append(cell.value)

print("Number of values: {0}".format(len(values)))
print("Sum of values: {0}".format(sum(values)))
print("Minimum value: {0}".format(min(values)))
print("Maximum value: {0}".format(max(values)))
print("Mean: {0}".format(stats.mean(values)))
print("Median: {0}".format(stats.median(values)))
print("Standard deviation: {0}".format(stats.stdev(values)))
print("Variance: {0}".format(stats.variance(values)))

In the example, we read all values from the sheet and compute some basic statistics.

import statistics as stats

The module is imported to provide some statistical functions,
such as median and variance.

book = openpyxl.load_workbook('numbers.xlsx', data_only=True)

Using the option, we get the values from the cells, not the formula.

rows = sheet.rows

We get all the rows of cells that are not empty.

for row in rows:
    for cell in row:
        values.append(cell.value)

In two for loops, we form a list of integer values from the cells.

print("Number of values: {0}".format(len(values)))
print("Sum of values: {0}".format(sum(values)))
print("Minimum value: {0}".format(min(values)))
print("Maximum value: {0}".format(max(values)))
print("Mean: {0}".format(stats.mean(values)))
print("Median: {0}".format(stats.median(values)))
print("Standard deviation: {0}".format(stats.stdev(values)))
print("Variance: {0}".format(stats.variance(values)))

We compute and print mathematical statistics about the values. Some of
the functions are built-in, others are imported with the
module.

$ ./mystats.py 
Number of values: 312
Sum of values: 15877
Minimum value: 0
Maximum value: 100
Mean: 50.88782051282051
Median: 54.0
Standard deviation: 28.459203819700967
Variance: 809.9262820512821

This is a sample output.

Чтение файла

С помощью файлового метода можно прочитать файл целиком или только определенное количество байт. Пусть у нас имеется файл data.txt с таким содержимым:

one - 1 - I
two - 2 - II
three - 3 - III
four - 4 - IV
five - 5 - V

Откроем его и почитаем:

>>> f1 = open('data.txt')
>>> f1.read(10)
'one - 1 - '
>>> f1.read()
'I\ntwo - 2 - II\nthree - 3 - III\n
four - 4 - IV\nfive - 5 - V\n'
>>> f1.read()
''
>>> type(f1.read())
<class 'str'>

Сначала считываются первые десять байтов, которые равны десяти символам. Это не бинарный файл, но мы все равно можем читать по байтам. Последующий вызов считывает весь оставшийся текст. После этого объект файлового типа f1 становится пустым.

Заметим, что метод возвращает строку, и что конец строки считывается как .

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

>>> f1 = open('data.txt')
>>> f1.readline()
'one - 1 - I\n'
>>> f1.readline()
'two - 2 - II\n'
>>> f1.readline()
'three - 3 — III\n'

Метод считывает сразу все строки и создает список:

>>> f1 = open('data.txt')
>>> f1.readlines()

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

>>> for i in open('data.txt'):
...     print(i)
...
one - 1 - I

two - 2 - II

three - 3 - III

four - 4 - IV

five - 5 - V

>>> 

Здесь при выводе наблюдаются лишние пустые строки. Функция преобразует в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без :

>>> nums = []
>>> for i in open('data.txt'):
...     nums.append(i)
...
>>> nums

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

Открытие файла с помощью функции open()

Первый шаг к работе с файлами в Python – научиться открывать файл. Вы можете открывать файлы с помощью метода open().

Функция open() в Python принимает два аргумента. Первый – это имя файла с полным путем, а второй – режим открытия файла.

Ниже перечислены некоторые из распространенных режимов чтения файлов:

• ‘r’ – этот режим указывает, что файл будет открыт только для чтения;
• ‘w’ – этот режим указывает, что файл будет открыт только для записи. Если файл, содержащий это имя, не существует, он создаст новый;
• ‘a’ – этот режим указывает, что вывод этой программы будет добавлен к предыдущему выводу этого файла;
• ‘r +’ – этот режим указывает, что файл будет открыт как для чтения, так и для записи.

Кроме того, для операционной системы Windows вы можете добавить «b» для доступа к файлу в двоичном формате. Это связано с тем, что Windows различает двоичный текстовый файл и обычный текстовый файл.

Предположим, мы помещаем текстовый файл с именем file.txt в тот же каталог, где находится наш код. Теперь мы хотим открыть этот файл.

Однако функция open (filename, mode) возвращает файловый объект. С этим файловым объектом вы можете продолжить свою дальнейшую работу.

#directory:   /home/imtiaz/code.py
text_file = open('file.txt','r')

#Another method using full location
text_file2 = open('/home/imtiaz/file.txt','r')
print('First Method')
print(text_file)

print('Second Method')
print(text_file2)

Результатом следующего кода будет:

================== RESTART: /home/imtiaz/code.py ==================
First Method

Second Method

>>>