Работа с файлами в с примеры: C++. Примеры использования средств C++ для работы с файлами

Содержание

Ввод данных из файла и вывод в файл. Урок 18 курса «Основы языка C»

Открытие и закрытие файлов

До этого при вводе-выводе данных мы работали со стандартными потоками — клавиатурой и монитором. Теперь рассмотрим, как в языке C реализовано получение данных из файлов и запись их туда. Перед тем как выполнять эти операции, надо открыть файл и получить доступ к нему.

В языке программирования C указатель на файл имеет тип FILE и его объявление выглядит так:

FILE *myfile;

С другой стороны, функция fopen() открывает файл по указанному в качестве первого аргумента адресу в режиме чтения («r»), записи («w») или добавления («a») и возвращает в программу указатель на него. Поэтому процесс открытия файла и подключения его к программе выглядит примерно так:

myfile = fopen("hello.txt", "r");

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

При чтении или записи данных в файл обращение к нему осуществляется посредством файлового указателя (в данном случае, myfile).

Если в силу тех или иных причин (нет файла по указанному адресу, запрещен доступ к нему) функция fopen() не может открыть файл, то она возвращает NULL. В реальных программах почти всегда обрабатывают ошибку открытия файла в ветке if, мы же далее опустим это.

Объявление функции fopen() содержится в заголовочном файле stdio.h, поэтому требуется его подключение. Также в stdio.h объявлен тип-структура FILE.

После того, как работа с файлом закончена, принято его закрывать, чтобы освободить буфер от данных и по другим причинам. Это особенно важно, если после работы с файлом программа продолжает выполняться. Разрыв связи между внешним файлом и указателем на него из программы выполняется с помощью функции fclose(). В качестве параметра ей передается указатель на файл:

fclose(myfile);

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

Чтение из текстового файла и запись в него

fscanf()

Функция fscanf() аналогична по смыслу функции scanf(), но в отличии от нее осуществляет форматированный ввод из файла, а не стандартного потока ввода. Функция fscanf() принимает параметры: файловый указатель, строку формата, адреса областей памяти для записи данных:

fscanf(myfile, "%s%d", str, &a);

Возвращает количество удачно считанных данных или EOF. Пробелы, символы перехода на новую строку учитываются как разделители данных.

Допустим, у нас есть файл содержащий такое описание объектов:

apples 10 23.4
bananas 5 25.0
bread 1 10.3

Тогда, чтобы считать эти данные, мы можем написать такую программу:

#include <stdio.h>
 
int main () { 
    FILE *file;
    struct food {
        char name[20]; 
        unsigned qty; 
        float price; 
    };
    struct food shop[10];
    char i=0;
 
    file = fopen("fscanf.txt", "r");
 
    while (fscanf(file, "%s%u%f", 
        shop[i].name, &(shop[i].qty), 
        &(shop[i].price)) != EOF) {
 
        printf("%s %u %.2f\n", shop[i].name, 
               shop[i].qty, shop[i].price); 
        i++;
    }
}

В данном случае объявляется структура и массив структур. Каждая строка из файла соответствует одному элементу массива; элемент массива представляет собой структуру, содержащую строковое и два числовых поля. За одну итерацию цикл считывает одну строку. Когда встречается конец файла fscanf() возвращает значение EOF и цикл завершается.

fgets()

Функция fgets() аналогична функции gets() и осуществляет построчный ввод из файла. Один вызов fgets() позволят прочитать одну строку. При этом можно прочитать не всю строку, а лишь ее часть от начала. Параметры fgets() выглядят таким образом:

fgets(массив_символов, 
      количество_считываемых_символов, 
      указатель_на_файл)

Например:

fgets(str, 50, myfile)

Такой вызов функции прочитает из файла, связанного с указателем myfile, одну строку текста полностью, если ее длина меньше 50 символов с учетом символа ‘\n’, который функция также сохранит в массиве. Последним (50-ым) элементом массива str будет символ ‘\0’, добавленный fgets(). Если строка окажется длиннее, то функция прочитает 49 символов и в конце запишет ‘\0’. В таком случае ‘\n’ в считанной строке содержаться не будет.

#include <stdio.h>
 
#define N 80
 
main () { 
    FILE *file;
    char arr[N];
 
    file = fopen("fscanf.txt", "r");
 
    while (fgets(arr, N, file) != NULL)
        printf("%s", arr);
 
    printf("\n");
    fclose(file);
}

В этой программе в отличие от предыдущей данные считываются строка за строкой в массив arr. Когда считывается следующая строка, предыдущая теряется. Функция fgets() возвращает NULL в случае, если не может прочитать следующую строку.

getc() или fgetc()

Функция getc() или fgetc() (работает и то и другое) позволяет получить из файла очередной один символ.

#include <stdio.h>
 
#define N 80
 
int main () { 
    FILE *file;
    char arr[N];
    int i;
 
    file = fopen("fscanf.txt", "r");
 
    while ((arr[i] = fgetc(file)) != EOF) {
        if (arr[i] == '\n') {
            arr[i] = '\0';
            printf("%s\n",arr);
            i = 0;
        }
        else i++;
    }
    arr[i] = '\0';
    printf("%s\n",arr);
 
    fclose(file);
}

Приведенный в качестве примера код выводит данные из файла на экран.

Запись в текстовый файл

Также как и ввод, вывод в файл может быть различным.

  • Форматированный вывод. Функция fprintf (файловый_указатель, строка_формата, переменные).
  • Посточный вывод. Функция fputs (строка, файловый_указатель).
  • Посимвольный вывод. Функция fputc() или putc(символ, файловый_указатель).

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

Запись в каждую строку файла полей одной структуры:

#include <stdio.h>
 
int main () { 
    FILE *file;
    struct food {
        char name[20]; 
        unsigned qty; 
        float price; 
    };
    struct food shop[10];
    char i=0;
 
    file = fopen("fprintf.txt", "w");
 
    while (scanf("%s%u%f", shop[i].name, 
           &(shop[i].qty), 
           &(shop[i].price)) != EOF) {
 
        fprintf(file, "%s %u %.2f\n", 
                shop[i].name, shop[i].qty, 
                shop[i].price); 
        i++;
    }
    fclose(file);
}

Построчный вывод в файл (fputs(), в отличие от puts() сама не помещает в конце строки ‘\n’):

while (gets(arr) != NULL) {
    fputs(arr, file);
    fputs("\n", file);
}

Пример посимвольного вывода:

while ((i = getchar()) != EOF)
    putc(i, file);

Чтение из двоичного файла и запись в него

С файлом можно работать не как с последовательностью символов, а как с последовательностью байтов. В принципе, с нетекстовыми файлами работать по-другому не возможно. Однако так можно читать и писать и в текстовые файлы. Преимущество такого способа доступа к файлу заключается в скорости чтения-записи: за одно обращение можно считать/записать существенный блок информации.

При открытии файла для двоичного доступа, вторым параметром функции fopen() является строка «rb» или «wb».

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

Функции fread() и fwrite() принимают в качестве параметров:

  1. адрес области памяти, куда данные записываются или откуда считываются,
  2. размер одного данного какого-либо типа,
  3. количество считываемых данных указанного размера,
  4. файловый указатель.

Эти функции возвращают количество успешно прочитанных или записанных данных. Т.е. можно «заказать» считывание 50 элементов данных, а получить только 10. Ошибки при этом не возникнет.

Пример использования функций fread() и fwrite():

#include <stdio.h>
#include <string.h>
 
int main () {
    FILE *file;
    char shelf1[50], shelf2[100];
    int n, m;
 
    file = fopen("shelf1.txt", "rb");
    n=fread(shelf1, sizeof(char), 50, file);
    fclose(file);
 
    file = fopen("shelf2.txt", "rb");
    m=fread(shelf2, sizeof(char), 50, file);
    fclose(file);   
 
    shelf1[n] = '\0';
    shelf2[m] = '\n';
    shelf2[m+1] = '\0';
 
    file = fopen("shop.txt", "wb");
    fwrite(strcat(shelf2,shelf1), 
           sizeof(char), n+m, file);
    fclose(file);   
}

Здесь осуществляется попытка чтения из первого файла 50-ти символов. В n сохраняется количество реально считанных символов. Значение n может быть равно 50 или меньше. Данные помещаются в строку. То же самое происходит со вторым файлом. Далее первая строка присоединяется ко второй, и данные сбрасываются в третий файл.

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

Курс с решением части задач:
android-приложение, pdf-версия

API для работы с файлами

Начиная с версии 7.17.2 ядро Creatio предоставляет набор классов и интерфейсов по работе с файлами:

  • пространство имен Terrasoft.File.Abstractions — интерфейсы и абстрактные классы, описывающие логику работы с файлами в Creatio.
  • пространство имен Terrasoft.File — конкретные реализации абстракций, использующиеся в системе.

Местоположение файла и файловые локаторы 

Местоположение файла в файловом хранилище задается с помощью файлового локатора — объекта, который реализует интерфейс Terrasoft.File.Abstractions.IFileLocator.

Файловый локатор обязательно содержит уникальный идентификатор файла RecordId.

Можно создавать разные реализации файловых локаторов для различных файловых хранилищ. В зависимости от специфики хранилища файловый локатор может содержать дополнительные свойства, позволяющие определить место хранения файла. Например, класс Terrasoft.File.EntityFileLocator — это реализация файлового локатора для текущего файлового хранилища Creatio Файлы и ссылки (Attachments). Объект класса EntityFileLocator, кроме свойства RecordId, имеет свойство EntitySchemaName — имя схемы объекта, в котором хранится файл, например: «ActivityFile» или «CaseFile».

Все методы по работе с файлами оперируют с файловыми локаторами.

Файлы и файловые хранилища 

Структура файла в Creatio:

  • метаданные файла;
  • контент файла.

Метаданные описывают свойства файла:

  • имя;
  • размер в байтах;
  • дата создания и т. п.

Основой для метаданных файла является абстрактный класс Terrasoft.File.Abstractions.Metadata.FileMetadata. Примером его конкретной реализации является класс Terrasoft.File.Metadata.EntityFileMetadata для описания метаданных файлов в объекте Файлы и ссылки (Attachments).

Контент — это непосредственно содержимое файла. 

Метаданные файла и его контент хранятся в Creatio в разных хранилищах:

  • Хранилище метаданных файлов должно реализовывать интерфейс Terrasoft.File.Abstractions.Metadata.IFileMetadataStorage.
  • Хранилище контента файла должно реализовывать интерфейс Terrasoft.File.Abstractions.Metadata.IFileContentStorage.

Конкретные реализации этих интерфейсов скрывают в себе нюансы взаимодействия с различными системами хранения файлов: Файлы и ссылки (Attachments) Creatio, файловая система сервера, Amazon S3, Google Drive и т. п.

Интерфейс Terrasoft.File.Abstractions.IFile предоставляет необходимые методы для работы с файлами, хранящимися в любых типах файловых хранилищ. Реализация этого интерфейса означает «файл» в терминах Creatio. Методы в этом интерфейсе обеспечивают асинхронную работу с файлами. Синхронные версии этих методов находятся в расширяющем классе Terrasoft.File.Abstractions.FileUtils.

Получить файл (IFileFactory) 

Интерфейс Terrasoft.File.Abstractions.IFileFactory предоставляет методы для создания и получения объектов некоторого класса, реализующего интерфейс Terrasoft.File.Abstractions.IFile. Этот интерфейс реализует фабрика, доступ к которой обеспечивается через методы класса Terrasoft.File.FileFactoryUtils, расширяющего класс UserConnection. Соответственно, для успешной работы с файлами необходимо иметь экземпляр UserConnection или SystemUserConnection.

Место хранения нового или существующего файла однозначно определяется его файловым локатором. Для получения доступа к существующему файлу необходимо знать его уникальный идентификатор RecordId. Для нового файла этот идентификатор формируется самостоятельно и передается в метод по созданию локатора.

Реализовать и зарегистрировать новый тип файлового хранилища 

Для реализации нового типа файлового хранилища необходимо:

  1. Создать свою реализацию интерфейса Terrasoft.File.Abstractions.Content.IFileContentStorage, который описывает необходимое API для работы с хранилищем файлового контента.
  2. Если текущее хранилище метаданных файлов (Terrasoft.File.Metadata.EntityFileMetadataStorage) по каким-то причинам не подходит, необходимо реализовать собственное хранилище метаданных, свой тип метаданных и свой тип файлового локатора:
    • Хранилище данных должно реализовывать интерфейс Terrasoft.File.Abstractions.Metadata.IFileMetadataStorage.
    • Файловый локатор должен реализовывать интерфейс Terrasoft.File.Abstractions.IFileLocator.
    • Класс метаданных должен быть наследником абстрактного класса Terrasoft.File.Abstractions.Metadata.FileMetadata.
  3. Новые хранилища контента и метаданных файлов необходимо зарегистрировать в соответствующих справочниках «SysFileContentStorage» и «SysFileMetadataStorage».

Исключения при работе с файлами 

Тип исключения

Сообщение

Условия возникновения

Terrasoft.File.Abstractions.
FileNotFoundByLocatorException

File not found by locator ‘{тип_локатора}{локатор.ToString}’

При доступе к любому из свойств или методов интерфейса IFile, если метаданные файла не найдены.

System.InvalidOperationExceptionCan’t delete new file: ‘{тип_локатора}, {локатор.ToString}’При попытке удаления только что созданного файла: FileMetadata.StoringState == FileStoringState.New
Terrasoft.Common.NullOrEmptyExceptionFile name cannot be null or emptyПри попытке сохранения файла с пустым полем Name
System.InvalidOperationExceptionCan’t find a metadata storage for the ‘{тип_локатора}’ locator type

Если подходящее по типу локатора хранилище метаданных файла не найдено

System.InvalidOperationExceptionCan’t find a content storage for the ‘{тип_метаданных}’ metadata typeЕсли подходящее по типу метаданных хранилище контента файла не найдено.

Настройка активного хранилища 

Настройка активного хранилища происходит путем установки значения системной настройки Активное хранилище содержимого файлов (код «ActiveFileContentStorage»).

Основные команды для работы с файлами

Команды для работы с файловой системой

Просмотр файловой системы — ls

Команда ls (list files) предназначена для просмотра содержимого каталогов и получения информации о файлах.

Примеры:

$ ls
$ ls -a
$ ls /bin
$ ls -l /
$ ls -l /dev
$ ls -l ..
$ ls -a .

Определение текущего каталога — pwd

pwd (print working directory) показывает текущий рабочий каталог.

Смена текущего каталога — cd

cd (change directory) меняет текущий рабочий каталог. Если команда cd вызвана без параметров, происходит переход в домашний каталог пользователя. Команда cd позволяет вернуться в предыдущий каталог (каталог, откуда был осуществлен переход в текущий).

Примеры:

$ cd /usr
$ cd bin
$ cd ..
$ cd
$ cd ~
$ cd ~u1

Создание файла с помощью команды touch

Команда touch меняет временные метки файла и имеет побочное действие, которое используется гораздо чаще, чем основное – если файла с указанным именем нет, создается пустой файл.

Создание каталога — mkdir

Команда mkdir (make directory) создает каталоги, в том числе и промежуточные (если указана опция -p).

Примеры:

$ mkdir /tmp/test
$ mkdir ~p /tmp/a/b/c

Удаление файла — rm

Команда rm удаляет файлы и каталоги, в т.ч. каталоги с содержимым (опция r или R). Опция f подавляет вывод запросов (например, при удалении файлов, доступных только для чтения) и ошибок при удалении, а опция i выводит запрос при удалении каждого файла.

Примеры:

$ touch /tmp/test
$ rm -r /tmp/test
# rm -fr /*

Удаление каталога — rmdir

Команда rmdir удаляет только пустые каталоги. При использовании опции p удаляются и родительские каталоги целевого каталога, если они пусты.

Примеры:

$ rmdir /tmp/test
$ rmdir -p /tmp/a/b/c

Копирование файлов и каталогов — cp

Команда cp позволяет копировать файли и каталоги (опция r или R). При её использовании часто применяются шаблоны шелла. В общем случае, команда cp требует не менее двух параметров: что копировать и куда копировать. Команда cp имеет большое количество опций, подробно о которых можно узнать на странице man.

Примеры:

$ touch file1
$ mkdir dir1
$ cp file1 file2
$ cp file1 incorrectdirname
$ cp file1 dir1/
$ cp -r dir1/ dir2/

Перемещение и переименование файлов и каталогов — mv

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

Примеры:

$ mv file2 file3
$ mv dir2 dir3
$ mv file3 incorrectdirname
$ mv file3 dir1/
$ mv dir3 dir1/

Создание линков/ссылок на файлы и каталоги — ln

Команда ln позволяет создавать символьные (с опцией s) и жесткие (без опции s) ссылки.

Примеры:

$ ln -s /etc/rc.conf file4

$ mkdir -p ~/var/db/mysql
$ touch ~/var/db/mysql/file.db

$ mkdir ~/disk2
$ mv ~/var/db/mysql ~/disk2/

$ ln -s ~/disk2/mysql/ ~/var/db/mysql
$ ls ~/var/db/mysql/

Команды для работы с содержимым файлов

Определение типа файла — file

Команда file представляет собой интерфейс к системе magic, который доступен пользователю в виде обычной команды.

Примеры:

$ file /usr/sbin/adduser
$ file /bin/sh
$ file /usr/share/man/man1/cat.1.gz

Просмотр файлов — more/less

Пейджеры (pager) more или less используются для просмотра больших объемов текстовой информации страницами. Они позволяют осуществлять навигавицию, поиск по тексту и некоторые другие действия с помощью команд. Получить помощь по этим командам всегда можно, нажав клавишу h. Выход из пейджера осуществляется с помощью команды q. Поиск информации осуществляется с помощью команд / (вперед) и ? (назад), после которых указывается шаблон для поиска. Для получения подробной справки обратитесь к соответствующей странице справочного руководства.

Примеры запуска:

$ more /etc/defaults/rc.conf
$ less /etc/defaults/rc.conf

Работа с архивами

UNIX обладает богатым арсеналом средств резервного копирования и восстановления данных: программы dump/restore, cpio, tar и пр. Для работы архивами наиболее широко используется программа tar. Несмотря на то, что в разных системах UNIX используются различные реализации этой программы, получающиеся в результате архивы являются кроссплатформенными, т. е. могут быть обработаны в разных ОС (в т.ч. и Windows). Ниже приведены примеры работы с программой tar:

Создать архив:

$ tar -c -v -f имяфайлаархива.tar каталогилифайл …

Посмотреть содержимое архива:

$ tar -t -f имяфайлаархива.tar

Раскрыть архив целиком:

$ tar -x -v -f имяфайлаархива.tar

Раскрыть отдельные файлы:

$ tar -xf имяфайлаархива.tar ‘etc/fstab’ $ tar -xOf имяфайлаархива.tar ‘etc/fstab’ — вывести на экран(STDOUT) $ tar -xf имяфайлаархива.tar ‘etc/’ $ tar -xf имяфайлаархива.tar ‘*fstab*’

Дополнительные ключи:

-z использовать gzip сжатие
-j использовать bzip2 сжатие

Команды оценки использования дискового пространства

Статистика использования разделов — df

Для получения статистики использования разделов дисков (смонтированных файловых систем) используется команда df. Наиболее полезные опции здесь – h (human-readable, выводит числовые данные в виде, удобном для восприятия пользователем) и t (выводит информацию только о файловых системах указанного типа, не принимая во внимание остальные – например, виртуальные файловые системы).

Пример запуска программы:

$ df -h -t ufs
Filesystem Size Used Avail Capacity Mounted on
/dev/ad0s1a 434M 143M 256M 36% /
/dev/ad0s1e 403M 12K 371M 0% /tmp
/dev/ad0s1f 6.4G 427M 5.5G 7% /usr
/dev/ad0s1d 771M 304K 709M 0% /var

Размер каталога — du

Программа du (disk usage) позволяет получить статистику использования дискового пространства не по разделам целиком, а для конкретных указанных каталогов. Опция h здесь аналогична этой опции программы df, а опции s (summary) и d число (depth) позволяют указать необходимую степень подробности (глубину) выводимой информации. Опция s эквивалента опции d 0 (нулевая глубина погружения), причем эти опции нельзя указывать вместе.

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

$ du -s -h /usr/share/
$ du -d 1 /usr/share/

Команды поиска файлов

Метоположение программ — which и whereis

Для поиска программ (исполняемых файлов) в UNIX используется команда which, которая ищет указанные файлы в каталогах, перечисленных в переменной окружения PATH. Команда whereis аналогична по действию, но ищет также среди man страниц и в каталогах с исходными текстами программ.

Примеры:

$ which ls
/bin/ls

$ whereis ls
ls: /bin/ls /usr/share/man/man1/ls.1.gz

Поиск файлов по индексированной базе — locate

Поиск файлов по имени с помощью заранее созданной индексной базы данных используется программа locate. Для создания индексной базы используется программа /usr/libexec/locate.updatedb

Полный поиск файлов — find

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

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

Поиск по имени и по шаблону имени

$ find /usr/share -name index.html
$ find /usr/share -name ‘*.html’

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

$ find /var/log -ctime -2 -type f -ls

Поиск файлов более новых чем некоторый

$ touch -t 200901051230 /tmp/xtime
$ find /etc/ -newer /tmp/xtime -type f

Пример выполнения команд над найденными файлами

# find /usr/ports/ -name ‘*.tbz’ -exec mv {} /usr/ports/packages/All/ \;

Работа с файловой системой в языке 1С 8.3, 8.2 (в примерах)

&НаСервере
Процедура ЧтениеИЗаписьФайловНаСервере()
 
    /// Как записать произвольное значение в файл в 1с 8.3, 8.2
 
    // любое сериализуемое (то есть превращаемое 
    // в строку и обратно) значение можно сохранять
    // в файл, например, массивы, списки значений, строки
    // структуры и т.д.
    Числа = Новый Массив;
    Числа.Добавить(35);
    Числа.Добавить(67);
    ЗначениеВФайл("c:\числа.txt", Числа);
    // эта функция работает только на сервере
 
    /// Как восстановить произвольное значение из файла в 1с 8.3, 8.2    
 
    ЧислаИзФайла = ЗначениеИзФайла("c:\числа.txt");
    Сообщить(ЧислаИзФайла[0]); // 35
    Сообщить(ЧислаИзФайла[1]); // 67
 
    /// Как записать текстовый файл в 1с 8.3, 8.2
 
    // работает как на сервере, так и на клиенте
    Текст = Новый ЗаписьТекста(
        "c:\привет.txt", // имя
        КодировкаТекста.ANSI, // кодировка
        Символы.ПС, // разделитель строк (необ.)
        Ложь // перезаписывать файл, а не дописывать в конец (необ.)
    );    
    Текст.ЗаписатьСтроку("Добро пожаловать!");
    Текст.ЗаписатьСтроку("Посторонним вход воспрещен.");
    Текст.Закрыть();
 
    /// Как прочитать текстовый файл в 1с 8.3, 8.2
 
    // работает как на сервере, так и на клиенте
    Текст = Новый ЧтениеТекста(
        "c:\привет.txt", // имя
        КодировкаТекста.ANSI, // кодировка
        Символы.ПС, // разделитель строк (необ.)
        ,
        Истина // монопольный режим (необ.)
    );
 
    // читаем пока есть что читать
    Пока Истина Цикл
        Строка = Текст.ПрочитатьСтроку();
        Если Строка = Неопределено Тогда
            Прервать;
        Иначе
            Сообщить(Строка);
        КонецЕсли;
    КонецЦикла;
 
КонецПроцедуры
 
&НаКлиенте
Процедура ОперацииНадФайлами(Команда)
 
    // для тестов создадим пустой файл
 
    Текст = Новый ЗаписьТекста("c:\file_src.txt");
    Текст.Закрыть();
 
    /// Как проверить существование файла в 1С 8.3, 8.2    
 
    ФайлНаДиске = Новый Файл("c:\file_src.txt");
    Если ФайлНаДиске.Существует() Тогда
        Сообщить("c:\file_src.txt существует");
    КонецЕсли;
 
    /// Как скопировать файл в 1с 8.3, 8.2 
 
    КопироватьФайл(
        "c:\file_src.txt", // что копируем
        "c:\file_dest.txt" // куда копируем
    ); // перезапишет, если уже есть такой файл
 
    /// Как переместить файл в 1с 8.3, 8.2 
 
    ПереместитьФайл(
        "c:\file_dest.txt",
        "c:\file_new.txt"
    ); // перезапишет, если уже есть такой файл
 
    /// Как найти файлы в каталоге в 1с 8.3, 8.2 
 
    // возвращает массив значений типа Файл
    МассивНайденныхФайлов = НайтиФайлы(
        "c:\", // где искать
        "*.txt", // маска поиска
        Ложь // если Истина, то будет искать и в подкаталогах
    );
 
    Для Каждого Файл Из МассивНайденныхФайлов Цикл
        Сообщить("Найден " + Файл.ПолноеИмя);
    КонецЦикла;
 
    /// Как удалить файл в 1с 8.3, 8.2
 
    // если файл readonly - будет ошибка
    УдалитьФайлы(
        "c:\file_new.txt"
    );
 
    /// Как удалить файлы в каталоге по маске в 1с 8.3, 8.2
 
    // поиск в каталоге нерекурсивный
    УдалитьФайлы(
        "c:\helpme1c", // заведомо не существующий каталог
        "*.txt" // маска для поиска удаляемых файлов
    ); // если опустить маску, то удалятся все файлы и каталог
 
    /// Как получить имя временного файла в 1с 8.3, 8.2
 
    Сообщить(
        ПолучитьИмяВременногоФайла()
    ); // например, c:\Temp\v8_11AE_4.tmp
 
    Сообщить(
        ПолучитьИмяВременногоФайла(".txt")
    ); // например, c:\Temp\v8_11AE_5.txt
 
    /// Как прочитать атрибуты файла в 1с 8.3, 8.2
 
    Ф = Новый Файл("c:\file_src.txt");
 
    // время последнего изменения файла
    Сообщить(Ф.ПолучитьВремяИзменения());
 
    // проверяем атрибут только чтение
    Сообщить(Ф.ПолучитьТолькоЧтение());
 
    // проверяем атрибут hidden (скрытность, невидимость)
    Сообщить(Ф.ПолучитьНевидимость());
 
    /// Как установить атрибуты файла в 1с 8.3, 8.2
 
    // меняем время последнего изменения файла
    Ф.УстановитьВремяИзменения(ТекущаяДата());
 
    // меняем атрибут только чтение
    Ф.УстановитьТолькоЧтение(Ложь);
 
    // меняем атрибут невидимости
    Ф.УстановитьНевидимость(Ложь);
 
    /// Как узнать размер файла в 1с 8.3, 8.2
 
    Сообщить(Ф.Размер()); // в байтах
 
    // Как узнать по пути файл это или каталог в 1с 8.3, 8.2
    Если Ф.ЭтоКаталог() Тогда
        Сообщить("Это каталог");
    ИначеЕсли Ф.ЭтоФайл() Тогда
        Сообщить("Это файл");
    КонецЕсли;
 
    /// Как вытащить расширение файла из его пути в 1с 8.3, 8.2
 
    Сообщить(Ф.Расширение); // .txt
 
    /// Как вытащить имя файла без расширения в 1с 8.3, 8.2
 
    Сообщить(Ф.ИмяБезРасширения); // file_src
 
КонецПроцедуры
 
&НаКлиенте
Процедура ОперацииНадКаталогами(Команда)
 
    /// Как создать каталог в 1с 8.3, 8.2
 
    // каталог может уже существовать
    СоздатьКаталог("c:\new_dir");
 
    // создадутся все подкаталоги
    СоздатьКаталог("c:\new_dir\2\3");
 
    /// Как проверить существование каталога в 1с 8.3, 8.2
 
    КаталогНаДиске = Новый Файл("c:\new_dir");
    Если КаталогНаДиске.Существует() Тогда
        Сообщить("Папка c:\new_dir существует");
    КонецЕсли;    
 
    /// Как удалить каталог вместе с содержимым в 1с 8.3, 8.2
 
    УдалитьФайлы("c:\new_dir");
    // мы опустили маску, поэтому удалятся все файлы
    // внутри каталога, а также сам каталог
 
    /// Как получить каталог временных файлов в 1с 8.3, 8.2
 
    Сообщить(
        КаталогВременныхФайлов()
    ); // например, c:\temp
 
КонецПроцедуры
 
&НаКлиенте
Процедура РаботаСВременнымХранилищем(Команда)
 
    // временное хранилище - объект, в который мы можем помещать
    // и считывать данные произвольного типа,
    // доступ к которому есть и на сервере и на клиенте
    // это позволяет передавать между сервером и клиентом
    // данные, которые иначе не передать
 
    /// Как сохранить произвольное значение во временное
    /// хранилище в 1с 8.3, 8.2
 
    Список = Новый СписокЗначений;
    Список.Добавить("Владивосток");
    Список.Добавить("Хабаровск");
    Список.Добавить("Петропавловск-Камчатский");
 
    АдресВХранилище = ПоместитьВоВременноеХранилище(
        Список // произвольные данные        
    );
 
    /// Как прочитать произвольное значение из временного
    /// хранилища в 1с 8.3, 8.2
 
    СписокИзХранилища = ПолучитьИзВременногоХранилища(АдресВХранилище);
    Если СписокИзХранилища = Неопределено Тогда
        Сообщить("Значение по этому адресу уже удалено из хранилища.");
    Иначе
        Сообщить(СписокИзХранилища[0]); // Владивосток
    КонецЕсли;
 
    /// Как перезаписать уже сохраненное значение во временном
    /// хранилище в 1с 8.3, 8.2
 
    Массив = Новый Массив;
    Массив.Добавить(10);
    Массив.Добавить(20);
 
    ПоместитьВоВременноеХранилище(
        Массив,
        АдресВХранилище
    );
 
    /// Сколько времени хранится значение, сохраненное во
    /// временном хранилище в 1с 8.3, 8.2
 
    // всё зависит от второго параметра функции ПоместитьВоВременноеХранилище
 
    // #1 если туда в качестве адреса был передан уникальный идентификатор формы
    // или уже существующий адрес в хранилище, то значение будет автоматически
    // удалено после закрытия формы
 
    // #2 если туда в качестве адреса передан уникальный идентификатор, не
    // являющийся уникальным идентификатором формы, то значение будет
    // автоматически удалено только после завершения сеанса пользвоателя    
 
    // #3 если адрес не указан, помещенное значение будет удалено после
    // очередного запроса сервера    
 
    // см. примеры ниже
 
    /// Как сохранить значение во временное хранилище на всё
    /// время жизни формы в 1с 8.3, 8.2
 
    ПоместитьВоВременноеХранилище(
        Массив,
        ЭтаФорма.УникальныйИдентификатор
    );
 
    /// Как сохранить значение во временное хранилище на всё
    /// время сеанса пользователя в 1с 8.3, 8.2
 
    АдресВХранилище = ПоместитьВоВременноеХранилище(
        Массив,
        Новый УникальныйИдентификатор
    );
 
    /// Как удалить значение из временного хранилища в 1с 8.3, 8.2
 
    УдалитьИзВременногоХранилища(АдресВХранилище);
 
    /// Как узнать является ли строка адресом во временном хранилище
    /// в 1с 8.3, 8.2
 
    Если ЭтоАдресВременногоХранилища(АдресВХранилище) Тогда
        Сообщить("Да, это адрес во временном хранилище.");
    КонецЕсли;
 
КонецПроцедуры
 
/// Как передать файл с клиента на сервер в 1с 8.3, 8.2
 
&НаКлиенте
Процедура ПередачаФайлаСКлиентаНаСервер(Команда)
 
    // создадим тестовый файл для передачи
    Текст = Новый ЗаписьТекста("c:\test.txt");
    Текст.ЗаписатьСтроку("Привет,");
    Текст.ЗаписатьСтроку("Мир!");
    Текст.Закрыть();
 
    ОповещениеОЗавершении = Новый ОписаниеОповещения(
        "ВыполнитьПослеПомещенияФайла", ЭтотОбъект
    );    
 
    НачатьПомещениеФайла(
        ОповещениеОЗавершении,
        , // адрес в хранилище
        "c:\test.txt", // имя файла
        Ложь, // интерактивно
        ЭтаФорма.УникальныйИдентификатор
    );
    // если опустить последний параметр, то помещенный файл
    // будет удален после очередного запроса сервера
    // а если указать - то только после удаления объекта формы
 
    // если нужно предоставить пользователю возможность
    // выбрать файл самому четвёртый параметр (интерактивно)
    // нужно установить в Истина
 
КонецПроцедуры
 
&НаКлиенте
Процедура ВыполнитьПослеПомещенияФайла(Результат, Адрес,
    ВыбранноеИмяФайла, ДополнительныеПараметры) Экспорт
 
    Если Результат Тогда
 
        // сохраним полученный адрес в реквизит формы
        АдресФайлаВХранилище = Адрес;
 
        Сообщить(
            "Наконец-то! Файл " +
            ВыбранноеИмяФайла + " передан на сервер и сохранён во " +
            "временном хранилище по адресу " + Адрес);
 
    Иначе
 
        Сообщить("Не удалось передать файл на сервер.");
 
    КонецЕсли;
 
КонецПроцедуры
 
/// Как прочитать файл на сервере из временного хранилища
/// в 1с 8.3, 8.2
 
&НаСервере
Процедура ПрочитатьФайлНаСервереИзХранилищаНаСервере()
 
    Если АдресФайлаВХранилище = "" Тогда
        Сообщить("Сначала нужно передать файл с клиента на сервер.");
        Возврат;
    КонецЕсли;
 
    ДвоичныеДанные = 
        ПолучитьИзВременногоХранилища(АдресФайлаВХранилище);
 
    Если ДвоичныеДанные = Неопределено Тогда
        Сообщить("Похоже файл уже был удалён из хранилища.");
        Возврат;
    КонецЕсли;
 
    ДвоичныеДанные.Записать("c:\server.txt");
 
    Текст = Новый ЧтениеТекста("c:\server.txt");
    Пока Истина Цикл
        Строка = Текст.ПрочитатьСтроку();
        Если Строка = Неопределено Тогда
            Прервать;
        Иначе
            Сообщить(Строка);
        КонецЕсли;
    КонецЦикла;
 
КонецПроцедуры
 
/// Как передать файл с сервера на клиент в 1с 8.3, 8.2
 
&НаКлиенте
Процедура ПередатьФайлССервераНаКлиент(Команда)
 
    Если АдресФайлаВХранилище = "" Тогда
        Сообщить("Сначала нужно сохранить файл на сервере.");
        Сообщить("Воспользуйтесь кнопкой 'Передача файла с клиента...'");
        Возврат;
    КонецЕсли;
 
    ОповещениеОЗавершении = Новый ОписаниеОповещения(
        "ВыполнитьПослеПолученияФайлов", ЭтотОбъект
    );
 
    ПолучаемыеФайлы = Новый Массив;
    ПолучаемыеФайлы.Добавить(
        Новый ОписаниеПередаваемогоФайла(
            "c:\from_server.txt", // куда сохранять на клиента
            АдресФайлаВХранилище // адрес в хранилище на сервере
        )
    );
 
    НачатьПолучениеФайлов(
        ОповещениеОЗавершении,
        ПолучаемыеФайлы,
        ,
        Ложь // интерактивно
    );
 
КонецПроцедуры
 
&НаКлиенте
Процедура ВыполнитьПослеПолученияФайлов(ПолученныеФайлы,
    ДополнительныеПараметры) Экспорт
 
    Для Каждого Файл Из ПолученныеФайлы Цикл
        Сообщить("Получен " + Файл.Имя + " из " + Файл.Хранение);
    КонецЦикла;
 
КонецПроцедуры
 
/// Скачать и выполнить эти примеры на компьютере

Работа с файлами в Python. Чтение и запись в файл (ввод-вывод)

Автор Амина С. На чтение 9 мин Опубликовано
Обновлено

Работа с файлами – неизменная составляющая программирования на любом языке. Если хочется идти дальше калькуляторов и программ типа «Hello, World», то работа с файлами – обязательная составляющая. Причем не только для редактирования изображений, текстов, видео или другой видимой работы. Файлы используются для хранения необходимой для исполнения информации, настроек и так далее.

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

Типы файлов в Python

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

Файлы разделяются на две разновидности:

  1. Текстовые.
  2. Бинарные.

Рассмотрим более подробно первый тип.

Текстовые

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

Есть еще один формат текстовых файлов, который более сложный – .rtf. Он может содержать форматирование, и этим выгодно отличается от стандартного текстового.

Бинарные

Такие файлы содержат последовательность нулей и единиц. Как правило, представляют собойы последовательность битов. Стандартный формат –  .bin.

Независимо от типа файла, с ним возможно выполнение одного из следующего действия:

  1. Открытие. 
  2. Выполнение (сюда входит запись какой-то информации или ее получение).
  3. Закрытие файла.

Рассмотрим основные методы, позволяющие осуществить чтение из файла. 

Открытие файла

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

Используется функция таким образом.

f = open(a, b)

Расшифруем параметры функции:

  1. a – это имя файла. Включает не только непосредственно имя, но и расширение.
  2. b – это тип открытия. В Python есть 12 типов открытия файлов.

Приведем таблицу с ними.

Допустим, у нас есть текстовый файл с таким содержимым.

Видим, что он называется «example.txt». Чтобы программа получила к нему доступ, используйте одну из следующих строк кода.

f = open(‘example.txt’,’r’)

fp = open(‘C:/xyz.txt’,’r’)

Оба позволяют выполнить открытие файла в формате чтения. Но отличается место, из которого осуществляется открытие. Так, первая строчка в переменную f записывает объект из файла, находящегося в той же папке, где расположена программа. А вторая строка демонстрирует пример открытия файла в конкретной папке. В нашем случае – на диске c.

Ну и во втором аргументе мы видим, что файл открывается в режиме «только чтение».

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

>>> print(*f)

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

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

Что касается кодировки, то Windows и Linux используют разные: cp1252 и utf-08 соответственно.

Закрытие

Если для открытия текстового документа применяется метод open() то, логично, для закрытия – close(). Это надо делать всегда, если программа не будет с ним больше работать. Если этого не сделать, его след останется в оперативной памяти, и компьютер может начать работать медленнее. В случае с маленькими файлами это не критично, а что если придется открывать большой?

Если присвоить новый файл той же переменной, то закрытие старого произойдет автоматически.

Есть несколько способов осуществления закрытия.

Способ 1

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

f = open(‘example.txt’,’r’)

# процессы, выполняемые над файлом

f.close()

Пока его снова не открыть средствами программы, она уже ничего не сможет с ним сделать, если выполнить последнюю инструкцию.

Способ 2

Приведенный выше способ прост, но имеет недостаток. Если возникает какая-то ошибка, это может привести к сбою в работе программы. Чтобы обработать ошибки при открытии файла, используется комбинация try/finally. В таком случае, если что-то пойдет не так, то программа просто закроет файл, а не аварийно завершит свою работу. 

Вот код, как это делается.

f = open(‘example.txt’,’r’)

try:

   # работа с файлом

finally:

   f.close()

Открытие файла должно осуществиться до того, как создается конструкция try/finally. Потом пишется try, и это начинается обработчик ошибок. Далее пишутся инструкции по работе с этим файлом, после чего finally записывается, и тогда файл закрывается. То есть, синтаксис обработчика стандартный, и ничем принципиально не отличается.

Способ 3

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

with open(‘example.txt’) as f:

    # работа с файлом

Операции чтения и записи

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

read()

После того, как приложение открыло файл в режиме чтения, к нему можно применить функцию read().

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

>>> f = open(‘example.txt’,’r’)

>>> f.read(7)  # чтение 7 символов из example.txt

‘This is ‘

Это код открыл файл, который выше на картинке и прочитал из него только первые два слова, что равняется 7 символам с пробелами.

Хорошо, предположим, нам надо прочитать 7 символов, начиная с восьмого. Что делать в этом случае? Для этого надо повторно использовать эту функцию. То есть, последняя позиция запоминается.

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

readline()

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

Допустим, у нас есть файл, содержащий следующие строки.

Example of line1.

Example of line2.

Example of line3.

Теперь давайте увидим, как метод readline() используется для нашего файла.

>>> x = open(‘example.txt’,’r’)

>>> x.readline()  # строка осуществляет чтение строки №1

Example of line1.

>>> x.readline(2)  # строка осуществляет чтение строки №2

Example of line2.

>>> x.readlines()  # строка осуществляет чтение строки №3

Что получится в итоге? Вывод интерпретатора будет следующим:

[‘Example of line1.’,’Example of line2.’,’Example of line3.’]

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

write()

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

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

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

>>> f = open(‘xyz.txt’,’w’)  # открытие в режиме записи

>>> f.write(‘Hello \n World’)  # запись Hello World в файл

Hello

World

>>> f.close()  # закрытие файла

Изменение имени файла

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

  1. Путь к файлу. Если указать только название (с расширением), то будет переименовываться тот, который находится в той же папке, что и программа. Если же указать полный путь, то можно задать файл, располагающийся в другой директории. 
  2. Новое имя файла. 

Работает функция так.

>>> import os

>>> # присвоение файлу нового имени test2.txt

>>> os.rename(«test1″,»test2.txt»)

Управление позицией в текстовых файлах

Управление позицией в файлах возможно такими действиями:

  1. Определение позиции. Используется метод tell().
  2. Редактирование. Осуществляется с помощью функции seek().

Для наглядности, как это работает, приведем пример.

>> f = open(‘example.txt’)  # файл, созданный нами в самом начале статьи

>>> f.read(4)  # выполнение перехода к четвертой позиции

This

>>> f.tell()  # получение позиции файла

4

>>> f.seek(0,0)  # возврат позиции к изначальной.

Оцените качество статьи. Нам важно ваше мнение:

Файловые функции VBA

Файловые функции VBA

Главная » Функции VBA »

28 Апрель 2011       Дмитрий       89939 просмотров

  • CurDir() — функция, которая возвращает путь к каталогу(для указанного диска), в котором по умолчанию будут сохраняться файлы:
        Dim sCurDir As String
    sCurDir = CurDir("D")

    Dim sCurDir As String
    sCurDir = CurDir(«D»)

  • Dir() — позволяет искать файл или каталог по указанному пути на диске. Пример использования можно посмотреть в статье: Просмотреть все файлы в папке
  • EOF() — при операции записи в файл на диске эта функция вернет True, если вы находитесь в конце файла. Обычно используется при работе с текстовыми файлами — .txt. При сохранении книг Excel лучше использовать стандартные методы: Save и SaveAs.
  • Error() — позволяет вернуть описание ошибки по ее номеру. Генерировать ошибку нужно при помощи метода RaiseError() специального объекта Er.
  • Print — записывает в открытый файл указанный текст. Далее будет приведен пример использования данной функции
  • FreeFile() — позволяет определить номер следующего свободного файла, который можно использовать как номер файла при его открытии методом Open. Предпочтительно применять именно этот метод определения номера файла(вместо статичного #1), чтобы не было неоднозначности обращения к файлам. Ниже приведены примеры применения данной функции при обращении к файлам
  • FileAttr() — позволяет определить, как именно был открыт файл в файловой системе: на чтение, запись, добавление, в двоичном или текстовом режиме и т.п. Применяется для работы с текстовыми файлами, открытыми при помощи Open "C:\Text1.txt" For [] As #1
    Открыть файл можно несколькими способами, приведу примеры наиболее распространенных вариантов:
    • Input() — открывает текстовый файл на чтение. Т.е. таким методом можно открыть файл и вытянуть из него данные. Например, чтобы считать информацию из файла C:Text1.txt и вывести ее в окно Immediate можно применить такой код:
          Dim MyChar
    Open "C:\Text1.txt" For Input As #1 'Открываем файл функцией Open() на чтение(Input)
    Do While Not EOF(1)  'пока файл не кончился
        ' Получаем по одному символу и добавляем его к предыдущим
        MyChar = MyChar & Input(1, #1)
    Loop
    Close #1 ' Закрываем файл
    'Выводим его содержание в окно Immediate
    '(отобразить Immediate: Ctrl+G в окне редактора VBA)
    Debug.Print MyChar
    'или в MsgBox
    MsgBox MyChar, vbInformation, "www.excel-vba.ru"

      Dim MyChar
      Open «C:\Text1.txt» For Input As #1 ‘Открываем файл функцией Open() на чтение(Input)
      Do While Not EOF(1) ‘пока файл не кончился
      ‘ Получаем по одному символу и добавляем его к предыдущим
      MyChar = MyChar & Input(1, #1)
      Loop
      Close #1 ‘ Закрываем файл
      ‘Выводим его содержание в окно Immediate
      ‘(отобразить Immediate: Ctrl+G в окне редактора VBA)
      Debug.Print MyChar
      ‘или в MsgBox
      MsgBox MyChar, vbInformation, «www.excel-vba.ru»

    • Ouput() — метод открывает файл для записи. Например, чтобы записать в файл строку, содержащую все ячейки в выделенном диапазоне, можно использовать такой код:
      Sub SelectionToTxt()
    Dim s As String, rc As Range
    Dim ff
    'запоминаем все значения из выделенной строки в строку
    For Each rc In Selection
        If s = "" Then 'если пока ничего не записали - присваиваем только значение ячейки
            s = rc.Value
        Else 'если уже записано - добавляем через TAB
            s = s & vbTab & rc.Value
        End If
    Next
    ff = FreeFile
    'Открываем текстовый файл
    'если файла нет - он будет создан
    Open "C:\Text1.txt" For Output As #ff
    'записываем значение строки в файл
    Print #ff, s
    Close #ff ' Закрываем файл
End Sub

      Sub SelectionToTxt()
      Dim s As String, rc As Range
      Dim ff
      ‘запоминаем все значения из выделенной строки в строку
      For Each rc In Selection
      If s = «» Then ‘если пока ничего не записали — присваиваем только значение ячейки
      s = rc.Value
      Else ‘если уже записано — добавляем через TAB
      s = s & vbTab & rc.Value
      End If
      Next
      ff = FreeFile
      ‘Открываем текстовый файл
      ‘если файла нет — он будет создан
      Open «C:\Text1.txt» For Output As #ff
      ‘записываем значение строки в файл
      Print #ff, s
      Close #ff ‘ Закрываем файл
      End Sub

      Важно помнить, что при открытии файла таким методом(Output) все предыдущие данные из файла стираются и в файле будет записано только то, что мы записали в текущем сеансе. Если данные необходимо добавить к имеющимся — используется метод Append

    • Append() — метод открывает файл для записи, но в отличии от Output записывает данные в конец файла, а не перезаписывает текущие данные. Например, код добавления выделенных ячеек как одной строки в имеющийся файл будет выглядеть так:
      Sub SelectionToTxt_Add()
    Dim s As String, rc As Range
    Dim ff
    'запоминаем все значения из выделенной строки в строку
    For Each rc In Selection
        If s = "" Then 'если пока ничего не записали - присваиваем только значение ячейки
            s = rc.Value
        Else 'если уже записано - добавляем через TAB
            s = s & vbTab & rc.Value
        End If
    Next
    ff = FreeFile
    'Открываем текстовый файл
    'если файла нет - он будет создан
    Open "C:\Text1.txt" For Append As #ff
    'записываем значение строки в файл
    Print #ff, s
    Close #ff ' Закрываем файл
End Sub

      Sub SelectionToTxt_Add()
      Dim s As String, rc As Range
      Dim ff
      ‘запоминаем все значения из выделенной строки в строку
      For Each rc In Selection
      If s = «» Then ‘если пока ничего не записали — присваиваем только значение ячейки
      s = rc.Value
      Else ‘если уже записано — добавляем через TAB
      s = s & vbTab & rc.Value
      End If
      Next
      ff = FreeFile
      ‘Открываем текстовый файл
      ‘если файла нет — он будет создан
      Open «C:\Text1.txt» For Append As #ff
      ‘записываем значение строки в файл
      Print #ff, s
      Close #ff ‘ Закрываем файл
      End Sub

  • FileDateTime() — позволяет получить информацию о последнем времени обращения к указанному файлу. Если к файлу после создания ни разу не обращались, то это будет время создания файла. Если попытаться обратиться к уже открытой книге/файлу — то будет получено время открытия книги/файла, а не создания или сохранения.
        sFileDateTime = FileDateTime("C:\Text1.txt")

    sFileDateTime = FileDateTime(«C:\Text1.txt»)

  • FileLen() — позволяет определить длину указанного файла в байтах:
        MsgBox FileLen("C:\Text1.txt") & " bites", vbInformation, "www.excel-vba.ru"

    MsgBox FileLen(«C:\Text1.txt») & » bites», vbInformation, «www.excel-vba.ru»

  • GetAttr() — возможность обратиться к файлу к файловой системе и получить информацию об его атрибутах (скрытый, доступен только для чтения, архивный и т.п.)
  • InputB() — позволяет указывать количество байт, которые надо считать из файла. Альтернатива методу Open в случаях, когда необходимо считывать данные не по конкретным строкам, а именно побайтово.
  • Loc() — от Location, то есть местонахождение — возвращает число, которое определяет текущее место вставки или чтения в открытом файле.
  • Seek() — очень похожа на функцию Loc(), но Seek() возвращает информацию о позиции, с которой будет выполняться следующая операция чтения или вставки.
  • LOF() — length of file — позволяет определить длину открытого файла в байтах.

Статья помогла? Сделай твит, поделись ссылкой с друзьями!

Юридическая информация

Наши партнеры

Спасибо за сообщение

Ваше сообщение было получено и отправлено администратору.

чтение и работа с ними на примерах

Как прочитать текстовый файл средствами платформы 1С 8.3 и как работать с ними в целом? Если не брать во внимание чтение специализированных форматов текстовых файлов то, по сути, во встроенном языке для этих целей реализованы два объекта: ЧтениеТекста и ТекстовыйДокумент. Рассмотрим на примерах, какие возможности предоставляет каждый из них.

ЧтениеТекста()

Объект ЧтениеТекста() предназначен для последовательного чтения текстовых файлов (большой длины)

Пример №1 — Прочитать файл по строкам

//Инициализируем объект ЧтениеТекста

Текст = Новый ЧтениеТекста;

Текст.Открыть("C:\Док.txt");              

Строка = Текст.ПрочитатьСтроку();

Пока Строка <> Неопределено Цикл //строки читаются до символа перевода строки                  

            //манипуляции со строкой

            Позиция = Найти(Строка, "=");

            Если Позиция > 0 Тогда

                        Значение = СокрЛП(Сред(Строка, Позиция + 1));

                        Сообщить(Значение);

            КонецЕсли;

            Строка = Текст.ПрочитатьСтроку();             

КонецЦикла;

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

Пример №2 — Чтение через «Файл»

Если требуется предварительно проанализировать параметры файла или параметры каталога, в котором он расположен необходимо использовать совместно с объектом Файл(). Пример кода, который перед чтением проверяет текстовый файл на существование, может выглядеть так:

//Инициализируем объект Файл

ИмяФайла = "C:\Док.txt";

ВыбФайл = Новый Файл(ИмяФайла);

Если ВыбФайл.Существует() Тогда //проверка на существование файла

Текст = Новый ЧтениеТекста(ИмяФайла);

Строка = Текст.ПрочитатьСтроку();

Пока Строка <> Неопределено Цикл //строки читаются до символа       перевода строки

// манипуляции со строкой

Сообщить(Строка);

Строка = Текст.ПрочитатьСтроку();

КонецЦикла;

Иначе

Сообщить("Файл не найден!");

КонецЕсли; 

Пример №3 — Выбираем файл на диске и читаем его

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

//Инициализируем объект ДиалогВыбораФайла

ДиалогВыбора = Новый ДиалогВыбораФайла(РежимДиалогаВыбораФайла.Открытие);

ДиалогВыбора.Заголовок = "Выберите файл";


Если ДиалогВыбора.Выбрать() Тогда

ИмяФайла = ДиалогВыбора.ПолноеИмяФайла; //Выбор файла из диалогового окна

КонецЕсли;


Текст = Новый ЧтениеТекста(ИмяФайла);

Строка = Текст.ПрочитатьСтроку();

Пока Строка <> Неопределено Цикл //строки читаются до символа перевода строки

// манипуляции со строкой

Сообщить(Строка);

Строка = Текст.ПрочитатьСтроку();

КонецЦикла;

Пример №4 — Чтение текста «порциями»

Если есть необходимость контролировать длину читаемых строк текстового файла, стоит заменить метод ПрочитатьСтроку() на Прочитать(). Однако отметим, что при указании параметра <РазмерСтроки>, заданное число может включать в себя символы переноса строки. То есть символы переноса строки идут в счёт параметра. Пример кода:

Текст = Новый ЧтениеТекста("C:\Док.txt");

Строка = Текст.Прочитать(10);

Пока Строка <> Неопределено Цикл //чтение файла по 10 символов

// манипуляции со строкой

Сообщить(Строка);

Строка = Текст.Прочитать(10);

КонецЦикла;

ТекстовыйДокумент()

Объект ТекстовыйДокумент() предназначен для работы с текстами. Позволяет получать и сохранять текст в файле, работать со строками, открывать текст в текстовом редакторе 1С:Предприятия. Обладает более богатым набором методов и свойств в отличие от объекта ЧтениеТекста().  При необходимости к нему так же применимы объекты Файл() и ДиалогВыбораФайла().

Если вы только начинаете программировать в 1С или просто хотите систематизировать свои знания — попробуйте Школу программирования 1С нашего друга Владимира Милькина. Пошаговые и понятные уроки даже для новичка с поддержкой учителя.
Попробуйте бесплатно по ссылке >>

Пример кода:

Текст = Новый ТекстовыйДокумент;

Текст.Прочитать("C:\Док.txt");

КоличествоСтрок = Текст.КоличествоСтрок();//получаем количество строк

Для Строка = 1 По КоличествоСтрок Цикл

//Получаем строку по номеру

СтрокаДляРазбора = Текст.ПолучитьСтроку(Строка);

//манипуляции со строкой

Сообщить(СтрокаДляРазбора);

КонецЦикла;

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

К сожалению, мы физически не можем проконсультировать бесплатно всех желающих, но наша команда будет рада оказать услуги по внедрению и обслуживанию 1С. Более подробно о наших услугах можно узнать на странице Услуги 1С или просто позвоните по телефону +7 (499) 350 29 00. Мы работаем в Москве и области.

упражнений по программированию на C: Работа с файлами

Работа с файлами C [15 упражнений с решением]

[ Внизу страницы доступен редактор для написания и выполнения сценариев. ]

1. Напишите программу на языке C для создания и хранения информации в текстовом файле. Перейдите в редактор.
Test Data:
Введите предложение для файла: Это содержимое файла test.текст.
Ожидаемый результат :

 Файл test.txt успешно создан ... !!

Щелкните меня, чтобы увидеть решение

2. Напишите программу на языке C для чтения существующего файла. Перейдите в редактор.
Test Data:
Введите имя файла, который нужно открыть: test.txt
Ожидаемый результат :

 Содержимое файла test.txt:
Это содержимое файла test.текст.

Щелкните меня, чтобы увидеть решение

3. Напишите программу на языке C для записи нескольких строк в текстовый файл. Перейдите в редактор
Test Data:
Введите количество строк для записи: 4
:: Строки:
test line 1
test line 2
test line 3
test line 4
Ожидаемый результат :

 Содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Щелкните меня, чтобы увидеть решение

4. Напишите программу на языке C для чтения файла и сохранения строк в массив. Перейдите в редактор.
Test Data:
Введите имя файла, который нужно открыть: test.txt
Ожидаемый результат :

 Содержимое файла test.txt:
 тестовая строка 1
 тестовая строка 2
 тестовая строка 3
 тестовая строка 4

Щелкните меня, чтобы увидеть решение

5. Напишите программу на языке C для определения количества строк в текстовом файле. Перейдите в редактор.
Test Data:
Введите имя файла, который нужно открыть: test.txt
Ожидаемый результат :

 В файле test.txt есть следующие строки: 4

Щелкните меня, чтобы увидеть решение

6. Напишите программу на языке C, чтобы найти содержимое файла и количество строк в текстовом файле. Перейдите в редактор.
Test Data:
Введите файл, который нужно открыть: test.txt
Ожидаемый результат :

 Содержимое файла test.txt:
 тестовая строка 1
 тестовая строка 2
 тестовая строка 3
 тестовая строка 4
 Строки в файле: 4

Щелкните меня, чтобы увидеть решение

7. Напишите программу на языке C для подсчета количества слов и символов в файле. Перейдите в редактор.
Test Data:
Введите имя файла, который нужно открыть: test.txt
Ожидаемый результат :

 Содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4
 Количество слов в файле test.txt: 12
 Количество символов в файле test.txt: 36

Щелкните меня, чтобы увидеть решение

8. Напишите программу на языке C для удаления определенной строки из файла. Заходим в редактор

 Предположим, что содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Тестовые данные:
Введите имя файла, который нужно открыть: test.txt
Введите строку, которую вы хотите удалить: 2
Ожидаемый результат :

 Содержимое файла test.txt:
тестовая строка 1
тестовая строка 3
тестовая строка 4

Щелкните меня, чтобы увидеть решение

9. Напишите программу на языке C для замены определенной строки другим текстом в файле. Заходим в редактор

 Предположим, что содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Тестовые данные:
Введите имя файла, который нужно открыть: test.txt
Введите содержимое новой строки: Да, это новый текст вместо тестовой строки 2
Введите строку нет, которую вы хотите заменить: 2
Ожидаемый результат :

 Замена прошла успешно .. !!

Щелкните меня, чтобы увидеть решение

10. Напишите программу на языке C для добавления нескольких строк в конец текстового файла. Заходим в редактор

 Предположим, что содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Тестовые данные:
Введите имя файла, который нужно открыть: test.txt
Введите количество строк для записи: 3
Строки:
тестовая строка 5
тестовая строка 6
тестовая строка 7
Ожидаемый результат :

 Содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4
                                                                                                              
тестовая строка 5
тестовая строка 6
тестовая строка 7

Щелкните меня, чтобы увидеть решение

11. Напишите программу на языке C для копирования файла с другим именем. Заходим в редактор

 Предположим, что содержимое файла test.txt:
тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Тестовые данные:
Введите имя исходного файла: test.txt
Введите новое имя файла: test1.txt
Ожидаемый результат :

 Файл test.txt успешно скопирован в файл test1.txt.

Если вы прочитаете новый файл, вы увидите его содержимое:

 тестовая строка 1
тестовая строка 2
тестовая строка 3
тестовая строка 4

Щелкните меня, чтобы увидеть решение

12. Напишите программу на языке C, чтобы объединить два файла и записать их в новый файл. Заходим в редактор

 Предположим, что содержимое файлов test.txt и test1.txr:
 Содержимое файла test.txt:
Это файл test.txt.

 Содержимое файла test1.txt:
Это файл test1.txt.

Тестовые данные:
Введите имя 1-го файла: test.txt
Введите имя второго файла: test1.txt
Введите новое имя файла, в котором необходимо объединить два вышеуказанных файла: mergefiles.txt
Ожидаемый результат :

 Два файла успешно объединены в файл mergefiles.txt .. !!

Вот содержимое файла слияния mergefiles.txt:

 Содержимое файла mergefiles.txt:
Это файл test.txt.
Это файл test1.текст.

Щелкните меня, чтобы увидеть решение

13. Напишите программу на языке C для шифрования текстового файла. Заходим в редактор

 Предположим, что содержимое файла test.txt:
Добро пожаловать на w3resource.com.

Тестовые данные:
Введите имя файла для шифрования: test.txt
Ожидаемый результат :

 Файл test.txt успешно зашифрован .. !!

Если вы читаете файл test.txt вы увидите следующее:

 ������Ʉ�ӄ ۗ�������ɒ�� ђn

Щелкните меня, чтобы увидеть решение

14. Напишите программу на языке C для расшифровки ранее зашифрованного файла-файла. Заходим в редактор

 Предположим, что содержимое файла test.txt было:
 ������Ʉ�ӄ ۗ�������ɒ�� ђn

После шифрования содержимое файла выглядит следующим образом:
Добро пожаловать на w3resource.com.

Тестовые данные:
Введите имя файла для дешифрования: test.txt
Ожидаемый результат :

 Файл test.txt успешно расшифрован .. !!

Теперь, если вы прочитаете файл test.txt, вы увидите следующее:

 Добро пожаловать на w3resource.com.

Щелкните меня, чтобы увидеть решение

15. Напишите программу на языке C для удаления файла с диска. Перейдите в редактор
Test Data:
Введите имя файла для удаления: test.txt
Ожидаемый результат :

 Файл test.txt успешно удален .. !!

Щелкните меня, чтобы увидеть решение

Редактор кода программирования C:

Еще больше впереди!

Не отправляйте здесь какие-либо решения вышеуказанных упражнений, если вы хотите внести свой вклад, перейдите на соответствующую страницу упражнения.

Учебник по языку

C => Типы файлов

Пример

Для компиляции программ C требуется работа с пятью типами файлов:

  1. Исходные файлы : Эти файлы содержат определения функций и имеют имена, оканчивающиеся на .c условно. Примечание. .cc и .cpp — файлы C ++; , а не файлов C.
    например, foo.c

  2. Заголовочные файлы : Эти файлы содержат прототипы функций и различные операторы препроцессора (см. Ниже). Они используются, чтобы разрешить файлам исходного кода доступ к функциям, определенным извне. Файлы заголовков по соглашению заканчиваются на .h .
    например, foo.h

  3. Объектные файлы : Эти файлы создаются как выходные данные компилятора.Они состоят из определений функций в двоичной форме, но сами по себе не могут быть выполнены. По соглашению объектные файлы заканчиваются на .o , хотя в некоторых операционных системах (например, Windows, MS-DOS) они часто заканчиваются на .obj .
    например, foo.o foo.obj

  4. Двоичные исполняемые файлы : Они создаются как выходные данные программы, называемой «компоновщиком». Компоновщик связывает вместе несколько объектных файлов для создания двоичного файла, который может быть запущен напрямую.У двоичных исполняемых файлов нет специального суффикса в операционных системах Unix, хотя в Windows они обычно заканчиваются на .exe .
    например, foo foo.exe

  5. Библиотеки : Библиотека представляет собой скомпилированный двоичный файл, но сама по себе не является исполняемым файлом (т.е. в библиотеке нет функции main () ). Библиотека содержит функции, которые могут использоваться более чем одной программой. Библиотека должна поставляться с заголовочными файлами, которые содержат прототипы всех функций библиотеки; на эти файлы заголовков следует ссылаться (например,грамм; #include ) в любом исходном файле, который использует библиотеку. Затем компоновщик необходимо передать в библиотеку, чтобы программа могла успешно скомпилироваться. Есть два типа библиотек: статические и динамические.

    • Статическая библиотека : статическая библиотека (файлы .a для систем POSIX и файлы .lib для Windows — не путать с файлами библиотеки импорта DLL, которые также используют расширение .lib ) статически встроен в программу.Статические библиотеки имеют то преимущество, что программа точно знает, какая версия библиотеки используется. С другой стороны, размеры исполняемых файлов больше, поскольку включены все используемые библиотечные функции.
      например, libfoo.a foo.lib
    • Динамическая библиотека : динамическая библиотека ( .so файлов для большинства систем POSIX, .dylib для OSX и .dll файлов для Windows) динамически подключается программой во время выполнения.Их также иногда называют общими библиотеками, потому что один образ библиотеки может использоваться многими программами. Преимущество динамических библиотек состоит в том, что они занимают меньше места на диске, если библиотеку используют более одного приложения. Кроме того, они позволяют обновлять библиотеки (исправлять ошибки) без необходимости перестраивать исполняемые файлы.
      например, foo.so foo.dylib foo.dll

Примеры программирования C для обработки файлов

В этом разделе рассматриваются примеры программирования на C по обработке файлов.Каждый пример программы включает описание программы, код C, а также вывод программы. Все примеры скомпилированы и протестированы в системе Linux. Эти примеры могут быть простыми программами на C или расширенными программами на C. Таким образом, они подходят для любого пользователя (чайников, новичков или продвинутых пользователей).

Вот список примеров программирования C по обработке файлов.

1. C Примеры создания файлов

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

2. C Примеры удаления содержимого файла

Программы C в этом разделе демонстрируют удаление содержимого файла. Он удаляет целевую строку из текстового файла, заменяет указанную строку в текстовом файле и вычисляет количество строк в текстовом файле.

3. C Примеры добавления и объединения содержимого файлов

Программы на языке C в этом разделе предназначены для добавления и объединения содержимого файлов. Программа объединяет содержимое файла, объединяет строки из разных файлов и печатает их, перечисляет файлы в каталоге, отображает имена функций из исходного файла C и определяет размер файла с помощью функций обработки файлов. Язык C предоставляет такие функции, как fopen, fread, fwrite, fseek для обработки файлов.

4. C Примеры создания, копирования, сравнения и печати содержимого файла

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

5. C Примеры операций преобразования, замены, подсчета и обратного преобразования содержимого файла

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

6. C Примеры операций по созданию и обновлению содержимого файла

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

Файл C (что это такое и как его открыть)

Файл с расширением .C представляет собой текстовый файл исходного кода C / C ++. Он может содержать как исходный код всей программы на языке программирования C или C ++, так и ссылаться на другие файлы из проекта C.

Обратите внимание, что некоторые программы используют расширение файла c в нижнем регистре для обозначения файла исходного кода C и C в верхнем регистре для C ++, но это не обязательно. CPP также используется для файлов исходного кода C ++.

Если файл C не на языке программирования C или C ++, это может быть файл сценария Lite-C, написанный на lite-C, языке программирования, аналогичном C / C ++.

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

CFile также относится к классам файлов Microsoft Foundation Class, но это не имеет ничего общего с форматами файлов исходного кода, описанными здесь.

Как открыть файл C

Любой текстовый редактор, например Notepad ++, Emacs, программа Windows Notepad, EditPlus, TextMate и другие, может открывать и просматривать файл C, если это файл исходного кода C / C ++.

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

Однако файлы C обычно открываются в контексте программы разработки программного обеспечения, такой как Visual Studio, Eclipse, C ++ Builder, Dev-C ++ или Code :: Blocks.

Программа lite-C от Conitec Datasystems является основной программой, используемой для работы с файлами сценария Lite-C, но эти файлы C также могут открываться с помощью текстовых редакторов.

Как конвертировать файлы C

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

Если это то, что вы ищете, мы рекомендуем посетить другие ресурсы, например Stack Overflow.

Однако, если вам действительно нужен конвертер файлов C, вы можете использовать любой текстовый редактор или средства открытия файлов C, указанные выше, для преобразования или сохранения файла в другом текстовом формате, таком как TXT или HTML.Скорее всего, они больше не будут использоваться в качестве файлов исходного кода с Eclipse, Dev-C ++ и т. Д., Если они существуют в другом формате файла.

Существует также ряд конвертеров исходного кода, доступных от Tangible Software Solutions, которые могут конвертировать C ++ в C #, Java или VB. Однако имейте в виду, что бесплатные выпуски ограничены, когда речь идет о количестве строк, которые можно преобразовать за один раз.

По-прежнему не удается открыть файл?

Учитывая, что расширение файла C — это всего лишь одна буква, легко спутать другие форматы файлов с файлом C.Это первое, на что следует обратить внимание, если вы не можете открыть файл, потому что вполне вероятно, что вы на самом деле имеете дело не с файлом C.

Например, если вы пытаетесь просмотреть свой файл с помощью текстового редактора, потому что предполагаете, что это файл с исходным кодом, но ничего не можете прочитать, у вас, вероятно, есть что-то совершенно другое, например файл CAB или CSH.

CS — очень похожее расширение файла, но оно используется для файлов исходного кода Visual C # и файлов цветовой схемы ColorSchemer Studio.Если у вас есть файл CS, он может нормально открываться программами, поддерживающими файлы C, поскольку это аналогичный формат с содержимым, написанным на языке C Sharp. Однако последний формат файла используется специально с ColorSchemer Studio и не будет работать так же, как файлы C Sharp или C.

Как видите, в этих и многих других форматах файлов есть буква «C», но это не означает, что они вообще связаны с форматом файлов C, описанным на этой странице.

Чтобы сделать это еще более запутанным, чем это могло бы быть, расширение файла CSH используется не только как нетекстовый файл с Adobe Photoshop (это файл пользовательских форм), но также как простой текстовый файл сценария оболочки C, что означает, что в зависимости от того, что у вас есть, может очень хорошо открываться в текстовом редакторе (например, с файлами CS) , но это еще не означает, что это файл исходного кода C / C ++ или даже то, что его можно открыть в любом приложении вышеперечисленное.

FAQ

  • Как мне создать файл на C?

    Простой способ создать файл C — использовать Блокнот. Введите свой код C в файл Блокнота, а затем сохраните файл с расширением .c . Введите имя файла в кавычках, например «filename.c», чтобы файл по умолчанию не имел расширение .txt. Затем скомпилируйте свою программу с помощью компилятора, такого как Microsoft Visual Studio C / C ++ Compiler.

  • Как создать файл заголовка на C ++?

    Вы можете либо импортировать уже существующий файл заголовка, либо создать определяемый пользователем файл заголовка.Чтобы создать заголовок, напишите свой код C / C ++ и сохраните его в файле с расширением .h . Чтобы импортировать файл заголовка, вы будете использовать «#include» ; синтаксис: #include или #include «filename.h» .

Спасибо, что сообщили нам!

Расскажите, почему!

Другой

Недостаточно подробностей

Трудно понять

C прочитанный файл | Упрощенное программирование

Как читать файл на C? Вы уже знаете, что такое файл и его типы (текстовый / двоичный (аудио / изображения / видео и т. Д.).)). Когда компьютер выключен, они присутствуют на жестком диске.

Предположим, на прошлой неделе вы создали программу на языке C для сортировки чисел и хотите снова увидеть эту программу. Как ты это делаешь? Вы находите файл в системе и открываете его в IDE / текстовом редакторе. Это круто! Но что интереснее, так это открыть файл через вашу программу.

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

Давайте напишем программу на C, чтобы открывать файл с жесткого диска, имя которого вводится пользователем, и отображать его содержимое на экране.Открытие файла означает, что мы переносим содержимое файла с диска в ОЗУ для выполнения над ним операций (чтения / изменения / добавления файла). Файл должен находиться в каталоге, в котором находится исполняемый файл программы.

Функция fopen используется для открытия файла; он возвращает указатель на структуру FILE, которая является предопределенной структурой в заголовочном файле «stdio.h». Если открытие файла прошло успешно, возвращается указатель на файл, а если открыть его не удается, возвращается NULL.

Функция fgetc возвращает символ, прочитанный из файла, а функция fclose закрывает файл.

Прочтите файл на C с помощью программного кода fopen

C, чтобы открыть файл и распечатать его содержимое на экране.

#include
#include

int main ()
{
char ch, file_name [25];
ФАЙЛ * fp;

printf («Введите имя файла, который вы хотите увидеть \ n»);
получает (имя_файла);

fp = fopen (имя_файла, «r»); // режим чтения

if (fp == NULL)
{
perror («Ошибка при открытии файла.\ n «);
exit (EXIT_FAILURE);
}

printf (» Содержимое файла% s: \ n «, имя_файла);

while ((ch = fgetc (fp))! = EOF)
printf («% c», ch);

fclose (fp);
return 0;
}

Чтение файла вывода программы C:

Загрузить Чтение программы файла.

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

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

Автоматизируйте сверление с помощью Python

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

Файл имеет два ключевых свойства: имя файла (обычно записывается как одно слово) и путь . Путь указывает расположение файла на компьютере. Например, на моем ноутбуке с Windows 7 есть файл с именем project.docx по пути C: \ Users \ asweigart \ Documents . Часть имени файла после последней точки называется расширением файла и сообщает вам тип файла. project.docx — это документ Word, а Users , asweigart и Documents все относятся к папкам (также называемым каталогами ). Папки могут содержать файлы и другие папки. Например, project.docx находится в папке Documents , которая находится внутри папки asweigart , которая находится внутри папки Users . Рисунок 8-1 показывает эту организацию папок.

Рисунок 8-1.Файл в иерархии папок

Часть пути C: \ — это корневая папка , которая содержит все остальные папки. В Windows корневая папка называется C: \ , а также C: диск . В OS X и Linux корневая папка — /. В этой книге я буду использовать корневую папку в стиле Windows, C: \ . Если вы вводите примеры интерактивной оболочки в OS X или Linux, введите вместо этого /.

Дополнительные томов , такие как DVD-привод или флэш-накопитель USB, будут отображаться по-разному в разных операционных системах.В Windows они отображаются как новые корневые диски с буквенными обозначениями, например D: \ или E: \ . В OS X они появляются как новые папки в папке / Volumes . В Linux они появляются как новые папки в папке / mnt («монтировать»). Также обратите внимание, что, хотя имена папок и файлов не чувствительны к регистру в Windows и OS X, они чувствительны к регистру в Linux.

Обратная косая черта в Windows и прямая косая черта в OS X и Linux

В Windows пути записываются с использованием обратной косой черты ( \ ) в качестве разделителя между именами папок.Однако OS X и Linux используют косую черту (/) в качестве разделителя пути. Если вы хотите, чтобы ваши программы работали во всех операционных системах, вам придется написать сценарии Python для обработки обоих случаев.

К счастью, это просто сделать с помощью функции os.path.join () . Если вы передадите ему строковые значения имен отдельных файлов и папок в вашем пути, os.path.join () вернет строку с путем к файлу с использованием правильных разделителей пути. Введите в интерактивную оболочку следующее:

 >>>  импорт ОС 
>>>  os.path.join ('usr', 'bin', 'спам') 
'usr \\ bin \\ spam'

Я запускаю эти интерактивные примеры оболочки в Windows, поэтому os.path.join ('usr', 'bin', 'spam') вернул 'usr \\ bin \\ spam' . (Обратите внимание, что обратная косая черта удваивается, потому что каждая обратная косая черта должна быть экранирована другим символом обратной косой черты.) Если бы я вызвал эту функцию в OS X или Linux, строка была бы 'usr / bin / spam' .

Функция os.path.join () полезна, если вам нужно создать строки для имен файлов.Эти строки будут переданы нескольким функциям, связанным с файлами, представленным в этой главе. Например, в следующем примере имена из списка имен файлов присоединяются к концу имени папки:

 >>>  myFiles = ['accounts.txt', 'details.csv', 'invite.docx'] 
>>>  для имени файла в myFiles: 
        print (os.path.join ('C: \\ Users \\ asweigart', имя файла))
C: \ Users \ asweigart \ accounts.txt
C: \ Users \ asweigart \ details.csv
C: \ Users \ asweigart \ invite.docx

Текущий рабочий каталог

Каждая программа, работающая на вашем компьютере, имеет текущий рабочий каталог или cwd . Предполагается, что любые имена файлов или пути, которые не начинаются с корневой папки, находятся в текущем рабочем каталоге. Вы можете получить текущий рабочий каталог в виде строкового значения с помощью функции os.getcwd () и изменить его с помощью os.chdir () . Введите в интерактивную оболочку следующее:

 >>>  импорт ОС 
>>>  os.getcwd () 
'C: \\ Python34'
>>>  os.chdir ('C: \\ Windows \\ System32') 
>>>  os.getcwd () 
'C: \ Windows \ System32'

Здесь текущий рабочий каталог установлен на C: \ Python34 , поэтому имя файла project.docx относится к C: \ Python34 \ project.docx . Когда мы меняем текущий рабочий каталог на C: \ Windows , project.docx интерпретируется как C: \ Windows \ project.docx .

Python отобразит ошибку, если вы попытаетесь перейти в несуществующий каталог.

 >>>  os.chdir ('C: \\ ThisFolderDoesNotExist') 
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    os.chdir ('C: \\ ThisFolderDoesNotExist')
FileNotFoundError: [WinError 2] Система не может найти указанный файл:
'C: \\ ThisFolderDoesNotExist'

Примечание

Хотя папка — это более современное название каталога, обратите внимание, что текущий рабочий каталог (или просто рабочий каталог ) является стандартным термином, а не текущей рабочей папкой.

Абсолютные и относительные пути

Есть два способа указать путь к файлу.

  • Абсолютный путь , который всегда начинается с корневой папки

  • Относительный путь , который относится к текущему рабочему каталогу программы

Есть также папки точек (. ) и точек ( .. ).Это не настоящие папки, а специальные имена, которые можно использовать в пути. Единственная точка («точка») в имени папки является сокращением для «этого каталога». Две точки («точка-точка») означают «родительскую папку».

Рисунок 8-2 — это пример некоторых папок и файлов. Когда текущий рабочий каталог установлен на C: \ bacon , относительные пути для других папок и файлов устанавливаются, как показано на рисунке.

Рисунок 8-2. Относительные пути к папкам и файлам в рабочем каталоге C: \ bacon

.\ в начале относительного пути не является обязательным. Например, . \ Spam.txt и spam.txt относятся к одному и тому же файлу.

Создание новых папок с помощью os.makedirs ()

Ваши программы могут создавать новые папки (каталоги) с помощью функции os.makedirs () . Введите в интерактивную оболочку следующее:

 >>>  импорт ОС 
>>>  os.makedirs ('C: \\ вкусно \\ грецкий \\ вафли')

Будет создана не только папка C: \ Delicious , но и папка walnut внутри C: \ Delicious и папка waffles внутри C: \ Delicious \ walnut .То есть os.makedirs () создаст все необходимые промежуточные папки, чтобы гарантировать существование полного пути. На рисунке 8-3 показана эта иерархия папок.

Рисунок 8-3. Результат os.makedirs ('C: \\ delicious \\ walnut \\ waffles')

Модуль os.path содержит множество полезных функций, связанных с именами файлов и путями к файлам. Например, вы уже использовали os.path.join () для построения путей таким образом, чтобы они работали в любой операционной системе.Поскольку os.path является модулем внутри модуля os , вы можете импортировать его, просто запустив import os . Всякий раз, когда вашим программам необходимо работать с файлами, папками или путями к файлам, вы можете обратиться к коротким примерам в этом разделе. Полная документация для модуля os.path находится на веб-сайте Python по адресу http://docs.python.org/3/library/os.path.html .

Примечание

Для большинства примеров, которые следуют в этом разделе, потребуется модуль os , поэтому не забудьте импортировать его в начале любого написанного вами сценария и каждый раз при перезапуске IDLE.В противном случае вы получите сообщение об ошибке NameError: имя 'os' не определено .

Обработка абсолютных и относительных путей

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

  • Вызов os.path.abspath ( путь ) вернет строку с абсолютным путем аргумента.Это простой способ преобразовать относительный путь в абсолютный.

  • Вызов os.path.isabs ( путь ) вернет Истина , если аргумент является абсолютным путем, и Ложь , если это относительный путь.

  • Вызов os.path.relpath ( path, start ) вернет строку относительного пути от start path до path .Если start не указан, текущий рабочий каталог используется как начальный путь.

Попробуйте эти функции в интерактивной оболочке:

 >>>  os.path.abspath ('.') 
'C: \\ Python34'
>>>  os.path.abspath ('. \\ Scripts') 
'C: \\ Python34 \\ Scripts'
>>>  os.path.isabs ('.') 
Ложь
>>>  os.path.isabs (os.path.abspath ('.')) 
Правда

Начиная с C: \ Python34 был рабочим каталогом, когда os.path.abspath () , папка с одной точкой представляет собой абсолютный путь 'C: \\ Python34' .

Примечание

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

Введите следующие вызовы os.path.relpath () в интерактивную оболочку:

 >>>  ос.path.relpath ('C: \ Windows', 'C: \\') 
'Окна'
>>>  os.path.relpath ('C: \\ Windows', 'C: \\ спам \\ яйца') 
'.. \\ .. \\ Windows'
>>>  os.getcwd ()  'C: \\ Python34'

Вызов os.path.dirname ( путь ) вернет строку всего, что идет до последней косой черты в аргументе path . Вызов os.path.basename ( путь ) вернет строку всего, что идет после последней косой черты в аргументе path .Имя каталога и базовое имя пути показаны на рисунке 8-4.

Рисунок 8-4. Базовое имя следует за последней косой чертой в пути и совпадает с именем файла. Имя каталога — это все, что находится до последней косой черты.

Например, введите в интерактивную оболочку следующее:

 >>>  путь = 'C: \ Windows \ System32 \ calc.exe' 
>>>  os.path.basename (путь) 
'calc.exe'
>>>  os.path.dirname (путь) 
'C: \ Windows \ System32'

Если вам нужно вместе имя каталога пути и базовое имя, вы можете просто позвонить по номеру os.path.split () , чтобы получить значение кортежа с этими двумя строками, например:

 >>>  calcFilePath = 'C: \ Windows \ System32 \ calc.exe' 
>>>  os.path.split (calcFilePath) 
('C: \ Windows \ System32', 'calc.exe')

Обратите внимание, что вы можете создать такой же кортеж, вызвав os.path.dirname () и os.path.basename () и поместив их возвращаемые значения в кортеж.

 >>>  (os.path.dirname (calcFilePath), os.path.basename (calcFilePath)) 
('C: \ Windows \ System32', 'calc.exe')

Но os.path.split () — хороший ярлык, если вам нужны оба значения.

Также обратите внимание, что os.path.split () не , а принимает путь к файлу и возвращает список строк каждой папки. Для этого используйте строковый метод split () и разделите строку в os.sep . Напомним, что для переменной os.sep задана правильная косая черта, разделяющая папки, для компьютера, на котором запущена программа.

Например, введите в интерактивную оболочку следующее:

 >>>  calcFilePath.split (os.path.sep) 
['C:', 'Windows', 'System32', 'calc.exe']

В системах OS X и Linux в начале возвращаемого списка будет пустая строка:

 >>>  '/usr/bin'.split(os.path.sep) 
['', 'usr', 'bin']

Строковый метод split () будет работать для возврата списка каждой части пути.Он будет работать в любой операционной системе, если вы передадите ему os.path.sep .

Определение размеров файлов и содержимого папок

Когда у вас появятся способы обработки путей к файлам, вы можете начать сбор информации о конкретных файлах и папках. Модуль os.path предоставляет функции для определения размера файла в байтах, а также файлов и папок внутри данной папки.

  • Вызов os.path.getsize ( путь ) вернет размер файла в байтах в аргументе path .

  • Вызов os.listdir ( путь ) вернет список строк имени файла для каждого файла в аргументе путь . (Обратите внимание, что эта функция находится в модуле os , а не в os.path .)

Вот что я получаю, когда пробую эти функции в интерактивной оболочке:

 >>>  os.path.getsize ('C: \\ Windows \\ System32 \\ calc.exe ') 
776192
>>>  os.listdir ('C: \\ Windows \\ System32') 
['0409', '12520437.cpx', '12520850.cpx', '5U877.ax', 'aaclient.dll',
-  ножницы  -
'xwtpdui.dll', 'xwtpw32.dll', 'zh-CN', 'zh-HK', 'zh-TW', 'zipfldr.dll']

Как видите, программа calc.exe на моем компьютере имеет размер 776192 байта, и у меня много файлов в C: \ Windows \ system32 . Если я хочу узнать общий размер всех файлов в этом каталоге, я могу использовать os.path.getsize () и os.listdir () вместе.

 >>>  totalSize = 0 
>>>  для имени файла в os.listdir ('C: \\ Windows \\ System32'): 
        totalSize = totalSize + os.path.getsize (os.path.join ('C: \\ Windows \\ System32', имя файла)) 

>>>  печать (общий размер) 
1117846456

Когда я перебираю каждое имя файла в папке C: \ Windows \ System32 , переменная totalSize увеличивается на размер каждого файла.Обратите внимание, как когда я вызываю os.path.getsize () , я использую os.path.join () для соединения имени папки с текущим именем файла. Целое число, которое возвращает os.path.getsize () , добавляется к значению totalSize . Перебрав все файлы в цикле, я печатаю totalSize , чтобы увидеть общий размер папки C: \ Windows \ System32 .

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

  • Вызов os.path.exists ( путь ) вернет Истина , если файл или папка, указанные в аргументе, существуют, и вернет Ложь , если они не существуют.

  • Вызов os.path.isfile ( путь ) вернет Истина , если аргумент пути существует и является файлом, и вернет Ложь в противном случае.

  • Вызов os.path.isdir ( путь ) вернет Истина , если аргумент пути существует и является папкой, и вернет Ложь в противном случае.

Вот что я получаю, когда пробую эти функции в интерактивной оболочке:

 >>>  os.path.exists ('C: \\ Windows') 
Правда
>>>  os.path.exists ('C: \\ some_made_up_folder') 
Ложь
>>>  os.путь.isdir ('C: \ Windows \ System32') 
Правда
>>>  os.path.isfile ('C: \\ Windows \\ System32') 
Ложь
>>>  os.path.isdir ('C: \\ Windows \\ System32 \\ calc.exe') 
Ложь
>>>  os.path.isfile ('C: \\ Windows \\ System32 \\ calc.exe') 
Правда

Вы можете определить, подключен ли в данный момент к компьютеру DVD-диск или флэш-накопитель, проверив его с помощью функции os.path.exists () . Например, если бы я хотел проверить наличие флэш-накопителя с томом с именем D: \ на моем компьютере с Windows, я мог бы сделать это следующим образом:

 >>>  ос.path.exists ('D: \\') 
Ложь

Ой! Похоже, я забыл подключить флешку.

Когда вы освоитесь с папками и относительными путями, вы сможете указать расположение файлов для чтения и записи. Функции, описанные в следующих нескольких разделах, будут применяться к файлам с открытым текстом. Файлы с открытым текстом содержат только основные текстовые символы и не включают информацию о шрифте, размере или цвете. Текстовые файлы с расширением .txt или файлы сценариев Python с расширением .py — это примеры файлов с открытым текстом. Их можно открыть с помощью Блокнота Windows или приложения TextEdit OS X. Ваши программы могут легко читать содержимое файлов с открытым текстом и обрабатывать их как обычное строковое значение.

Двоичные файлы — это файлы всех других типов, например текстовые документы, PDF-файлы, изображения, электронные таблицы и исполняемые программы. Если вы откроете двоичный файл в Блокноте или TextEdit, он будет выглядеть как зашифрованная ерунда, как на рис. 8-5.

Рисунок 8-5.Программа Windows calc.exe открыта в Блокноте

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

Есть три шага для чтения или записи файлов в Python.

  1. Вызовите функцию open () , чтобы вернуть объект File .

  2. Вызовите метод read () или write () для объекта File .

  3. Закройте файл, вызвав метод close () для объекта File .

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

Чтобы открыть файл с помощью функции open () , вы передаете ей строковый путь, указывающий файл, который вы хотите открыть; это может быть как абсолютный, так и относительный путь.Функция open () возвращает объект File .

Попробуйте, создав текстовый файл с именем hello.txt с помощью Блокнота или TextEdit. Тип Привет, мир! в качестве содержимого этого текстового файла и сохраните его в домашней папке пользователя. Затем, если вы используете Windows, введите в интерактивную оболочку следующее:

 >>>  helloFile = open ('C: \\ Users \\    your_home_folder    \\ hello.txt')

Если вы используете OS X, введите вместо этого в интерактивную оболочку следующее:

 >>>  helloFile = open ('/ Users /    your_home_folder    / hello.txt ')

Не забудьте заменить your_home_folder именем пользователя вашего компьютера. Например, мое имя пользователя — asweigart , поэтому в Windows я ввожу 'C: \\ Users \\ asweigart \\ hello.txt' .

Обе эти команды откроют файл в режиме «чтения открытого текста» или в режиме чтения. для краткости. Когда файл открывается в режиме чтения, Python позволяет вам только читать данные из файла; вы не можете ни написать, ни изменить его. Режим чтения — это режим по умолчанию для файлов, которые вы открываете в Python.Но если вы не хотите полагаться на значения Python по умолчанию, вы можете явно указать режим, передав строковое значение 'r' в качестве второго аргумента функции open () . Итак, open ('/ Users / asweigart / hello.txt', 'r') и open ('/ Users / asweigart / hello.txt') делают то же самое.

Вызов open () возвращает объект File . Объект File представляет файл на вашем компьютере; это просто еще один тип значений в Python, очень похожий на списки и словари, с которыми вы уже знакомы.В предыдущем примере вы сохранили объект File в переменной helloFile . Теперь, когда вы хотите прочитать или записать в файл, вы можете сделать это, вызвав методы объекта File в helloFile .

Чтение содержимого файлов

Теперь, когда у вас есть объект File , вы можете начать чтение из него. Если вы хотите прочитать все содержимое файла как строковое значение, используйте метод read () объекта File .Давайте продолжим с объекта hello.txt File , который вы сохранили в helloFile . Введите в интерактивную оболочку следующее:

 >>>  helloContent = helloFile.read () 
>>>  helloContent 
'Привет, мир!'

Если вы думаете о содержимом файла как об одном большом строковом значении, метод read () возвращает строку, которая хранится в файле.

В качестве альтернативы вы можете использовать метод readlines () для получения списка строковых значений из файла, по одной строке для каждой строки текста.Например, создайте файл с именем sonnet29.txt в том же каталоге, что и hello.txt , и напишите в нем следующий текст:

 Когда, опозорившись удачей и человеческими глазами,
Я один оплакиваю свое отверженное состояние,
И беспокоит глухое небо моими криками без сапог,
И посмотри на себя и прокляни мою судьбу,

Убедитесь, что четыре строки разделены разрывами строк. Затем введите в интерактивную оболочку следующее:

 >>>  sonnetFile = open ('sonnet29.txt ') 
>>>  sonnetFile.readlines () 
[Когда, опозоренный судьбой и человеческими глазами, \ n ',' я один плачу своим
государство изгнанников, \ n ', И горе глухое небо моими беспомощными воплями, \ n', И
взгляни на себя и прокляни мою судьбу »,

Обратите внимание, что каждое из строковых значений заканчивается символом новой строки, \ n , за исключением последней строки файла. Со списком строк часто легче работать, чем с одним большим строковым значением.

Python позволяет записывать содержимое в файл аналогично тому, как функция print () «записывает» строки на экран.Однако вы не можете писать в файл, который вы открыли в режиме чтения. Вместо этого вам нужно открыть его в режиме «запись открытого текста» или в режиме «добавления открытого текста», или в режиме записи и в режиме добавления для краткости.

Режим записи перезапишет существующий файл и начнется с нуля, точно так же, как когда вы перезаписываете значение переменной новым значением. Передайте 'w' в качестве второго аргумента функции open () , чтобы открыть файл в режиме записи. Режим добавления, с другой стороны, добавит текст в конец существующего файла.Вы можете думать об этом как о добавлении к списку в переменной, а не о перезаписи переменной в целом. Передайте 'a' в качестве второго аргумента функции open () , чтобы открыть файл в режиме добавления.

Если имя файла, переданное в open () , не существует, оба режима записи и добавления создадут новый пустой файл. После чтения или записи файла вызовите метод close () перед повторным открытием файла.

Давайте объединим эти концепции. Введите в интерактивную оболочку следующее:

 >>>  baconFile = open ('бекон.txt ',' w ') 
>>>  baconFile.write ('Привет, мир! \ N') 
13
>>>  беконFile.close () 
>>>  baconFile = open ('bacon.txt', 'a') 
>>>  baconFile.write ('Бекон - это не овощ.') 
25
>>>  беконFile.close () 
>>>  baconFile = open ('bacon.txt') 
>>>  content = baconFile.read () 
>>>  беконFile.close () 
>>>  печать (содержание) 
Привет, мир!
Бекон - это не овощ.

Сначала открываем bacon.txt в режиме записи. Поскольку bacon.txt еще не существует, Python создает его. Вызов write () для открытого файла и передача write () строкового аргумента 'Hello world! / n ' записывает строку в файл и возвращает количество записанных символов, включая новую строку. Затем закрываем файл.

Чтобы добавить текст к существующему содержимому файла вместо замены только что написанной строки, мы открываем файл в режиме добавления.Мы пишем «Бекон - это не овощ». в файл и закройте его. Наконец, чтобы вывести содержимое файла на экран, мы открываем файл в режиме чтения по умолчанию, вызываем read () , сохраняем полученный объект File в содержимом , закрываем файл и печатаем содержимое .

Обратите внимание, что метод write () не добавляет автоматически символ новой строки в конец строки, как это делает функция print () . Вам придется добавить этого персонажа самостоятельно.

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

Введите в интерактивную оболочку следующее:

 >>>  импортная полка 
>>>  полкаФайл = полка.открыть ('mydata') 
>>>  кошек = ['Zophie', 'Pooka', 'Simon'] 
>>>  полкаFile ['коты'] = коты 
>>>  полкаFile.close ()

Для чтения и записи данных с помощью модуля полки необходимо сначала импортировать полку . Вызовите shelve.open () и передайте ему имя файла, а затем сохраните возвращенное значение полки в переменной. Вы можете изменить значение полки, как если бы это был словарь. Когда вы закончите, вызовите close () на полке value.Здесь наша полочная стоимость хранится в полке . Мы создаем список cats и пишем shelFile ['cats'] = cats , чтобы сохранить список в полке как значение, связанное с ключом 'cats' (как в словаре). Затем мы вызываем close () на полку .

После выполнения предыдущего кода в Windows вы увидите три новых файла в текущем рабочем каталоге: mydata.bak , mydata.dat и mydata.директория . В OS X будет создан только один файл mydata.db .

Эти двоичные файлы содержат данные, которые вы сохранили на своей полке. Формат этих двоичных файлов не важен; вам нужно только знать, что делает модуль полки , а не как он это делает. Модуль избавляет вас от забот о том, как сохранить данные вашей программы в файле.

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

 >>>  shelveFile = shelve.open ('mydata') 
>>>  тип (полкаФайл) 
<класс 'shelve.DbfilenameShelf'>
>>>  полкаФайл ['коты'] 
[«Зофи», «Пука», «Саймон»]
>>>  полкаFile.close ()

Здесь мы открываем файлы полок, чтобы проверить правильность хранения наших данных.Ввод shelFile ['cats'] возвращает тот же список, который мы сохранили ранее, поэтому мы знаем, что список сохранен правильно, и вызываем close () .

Как и словари, значения на полке имеют методы keys (), и values ​​(), , которые возвращают значения в виде списка ключей и значений на полке. Поскольку эти методы возвращают значения, подобные спискам, а не истинные списки, вы должны передать их функции list () , чтобы получить их в виде списка.Введите в интерактивную оболочку следующее:

 >>>  shelveFile = shelve.open ('mydata') 
>>>  список (shelFile.keys ()) 
['кошки']
>>>  список (shelFile.values ​​()) 
[['Зофи', 'Пука', 'Саймон']]
>>>  полкаFile.close ()

Plaintext полезен для создания файлов, которые вы будете читать в текстовом редакторе, таком как Блокнот или TextEdit, но если вы хотите сохранить данные из ваших программ Python, используйте модуль полки .

Напомним из Pretty Printing, что функция pprint.pprint () будет «красиво выводить» содержимое списка или словаря на экран, а функция pprint.pformat () вместо этого вернет тот же текст в виде строки. распечатать это. Эта строка не только отформатирована для удобства чтения, но и является синтаксически правильным кодом Python. Допустим, у вас есть словарь, хранящийся в переменной, и вы хотите сохранить эту переменную и ее содержимое для использования в будущем. Используя pprint.pformat () предоставит вам строку, которую вы можете записать в файл .py . Этот файл будет вашим собственным модулем, который вы можете импортировать, когда захотите использовать сохраненную в нем переменную.

Например, введите в интерактивную оболочку следующее:

 >>>  импортная печать 
>>>  cats = [{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}] 
>>>  pprint.pformat (кошки) 
"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]»
>>>  fileObj = open ('myCats.ру ',' ш ') 
>>>  fileObj.write ('cats =' + pprint.pformat (cats) + '\ n') 
83
>>>  fileObj.close ()

Здесь мы импортируем pprint , чтобы использовать pprint.pformat () . У нас есть список словарей, хранящихся в переменной cats . Чтобы список в cats был доступен даже после закрытия оболочки, мы используем pprint.pformat () , чтобы вернуть его в виде строки. Когда у нас есть данные в cats в виде строки, ее легко записать в файл, который мы назовем myCats.py .

Модули, которые импортирует оператор import , сами по себе являются скриптами Python. Когда строка из pprint.pformat () сохраняется в файл .py , файл представляет собой модуль, который можно импортировать, как и любой другой.

А поскольку скрипты Python сами по себе представляют собой просто текстовые файлы с расширением .py , ваши программы Python могут даже генерировать другие программы Python. Затем вы можете импортировать эти файлы в сценарии.

 >>>  импорт myCats 
>>>  myCats.кошки 
[{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}]
>>>  myCats.cats [0] 
{'name': 'Zophie', 'desc': 'chubby'}
>>>  myCats.cats [0] ['name'] 
'Зофия'

Преимущество создания файла .py (в отличие от сохранения переменных с помощью модуля shelve ) заключается в том, что, поскольку это текстовый файл, его содержимое может быть прочитано и изменено любым пользователем с помощью простого текстового редактора. .Однако для большинства приложений сохранение данных с использованием модуля полки является предпочтительным способом сохранения переменных в файл. Только основные типы данных, такие как целые числа, числа с плавающей запятой, строки, списки и словари, могут быть записаны в файл как простой текст. Например, Объекты нельзя закодировать как текст.

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

Вот что делает программа:

  • Создает 35 различных викторин.

  • Создает 50 вопросов с несколькими вариантами ответов для каждой викторины в случайном порядке.

  • Предоставляет правильный ответ и три случайных неправильных ответа на каждый вопрос в случайном порядке.

  • Записывает тесты в 35 текстовых файлов.

  • Записывает ключи ответов в 35 текстовых файлов.

Это означает, что код должен будет сделать следующее:

  • Сохраните штаты и их заглавные буквы в словаре.

  • Позвоните по номеру open () , write () и close () , чтобы получить ключевые текстовые файлы викторины и ответов.

  • Используйте random.shuffle () , чтобы рандомизировать порядок вопросов и вариантов с множественным выбором.

Шаг 1. Сохраните данные теста в словаре

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

 #! python3
   # randomQuizGenerator.py - создает викторины с вопросами и ответами на
   # случайный порядок вместе с ключом ответа.❶ импорт случайный

   # Данные викторины. Ключи - это состояния, а значения - их заглавные буквы.
❷ capitals = {'Алабама': 'Монтгомери', 'Аляска': 'Джуно', 'Аризона': 'Феникс',
   «Арканзас»: «Литл-Рок», «Калифорния»: «Сакраменто», «Колорадо»: «Денвер»,
   «Коннектикут»: «Хартфорд», «Делавэр»: «Довер», «Флорида»: «Таллахасси»,
   «Джорджия»: «Атланта», «Гавайи»: «Гонолулу», «Айдахо»: «Бойсе», «Иллинойс»:
   Спрингфилд, Индиана: Индианаполис, Айова: Де-Мойн, Канзас:
   «Топика», «Кентукки»: «Франкфорт», «Луизиана»: «Батон-Руж», «Мэн»:
   «Огаста», «Мэриленд»: «Аннаполис», «Массачусетс»: «Бостон», «Мичиган»:
   «Лансинг», «Миннесота»: «Сент-Пол», «Миссисипи»: «Джексон», «Миссури»:
   «Джефферсон-Сити», «Монтана»: «Хелена», «Небраска»: «Линкольн», «Невада»:
   «Карсон-Сити», «Нью-Гэмпшир»: «Конкорд», «Нью-Джерси»: «Трентон», «Нью-Йорк».
   Мексика »:« Санта-Фе »,« Нью-Йорк »:« Олбани »,« Северная Каролина »:« Роли »,
   «Северная Дакота»: «Бисмарк», «Огайо»: «Колумбус», «Оклахома»: «Оклахома-Сити»,
   «Орегон»: «Салем», «Пенсильвания»: «Харрисбург», «Род-Айленд»: «Провиденс»,
   «Южная Каролина»: «Колумбия», «Южная Дакота»: «Пьер», «Теннесси»:
   «Нэшвилл», «Техас»: «Остин», «Юта»: «Солт-Лейк-Сити», «Вермонт»:
   «Монтпилиер», «Вирджиния»: «Ричмонд», «Вашингтон»: «Олимпия», «Запад»
   Вирджиния »:« Чарльстон »,« Висконсин »:« Мэдисон »,« Вайоминг »:« Шайенн »}

   # Создать 35 файлов викторин.❸ для quizNum in range (35):
       # ЗАДАЧИ: Создайте ключевые файлы викторины и ответов.

       # ЗАДАЧИ: Напишите заголовок для викторины.

       # TODO: Перемешать порядок состояний.

       # TODO: Прокрутите все 50 состояний, задавая вопросы для каждого.

Поскольку эта программа будет упорядочивать вопросы и ответы в случайном порядке, вам необходимо импортировать модуль random ❶, чтобы использовать его функции. Переменная capitals ❷ содержит словарь с штатами США в качестве ключей и их заглавными буквами в качестве значений.И поскольку вы хотите создать 35 тестов, код, который фактически генерирует файлы ответов и ответов (на данный момент отмечен комментариями TODO ), войдет в цикл для , который повторяется 35 раз ❸. (Это число можно изменить для создания любого количества файлов викторины.)

Шаг 2. Создайте файл викторины и перемешайте порядок вопросов

Теперь пора начать заполнять те TODO s.

Код в цикле будет повторяться 35 раз — по одному разу для каждой викторины, поэтому вам придется беспокоиться только об одной викторине за раз в цикле.Сначала вы создадите сам файл викторины. У него должно быть уникальное имя файла, а также должен быть какой-то стандартный заголовок, в котором учащийся может заполнить имя, дату и период занятий. Затем вам нужно будет получить список состояний в случайном порядке, который впоследствии можно будет использовать для создания вопросов и ответов для викторины.

Добавьте следующие строки кода в randomQuizGenerator.py :

 #! python3
   # randomQuizGenerator.py - создает викторины с вопросами и ответами на
   # случайный порядок вместе с ключом ответа.-  ножницы  -

   # Создать 35 файлов викторин.
   для quizNum in range (35):
         # Создайте ключевые файлы викторины и ответов. 
❶  quizFile = open ('capitalsquiz% s.txt'% (quizNum + 1), 'w') 
❷  answerKeyFile = open ('capitalsquiz_answers% s.txt'% (quizNum + 1), 'w') 

         # Выпишите заголовок для викторины. 
❸  quizFile.write ('Имя: \ n \ nДата: \ n \ nПериод: \ n \ n') 
         quizFile.write (('' * 20) + 'Викторина по столицам штатов (форма% s)'% (quizNum + 1)) 
         quizFile.write ('\ n \ n') 

         # Перемешать порядок состояний. 
         состояний = список (capitals.keys ()) 
❹  random.shuffle (состояния) 

       # TODO: Прокрутите все 50 состояний, задавая вопросы для каждого.

Имена файлов для викторин будут: capitalsquiz .txt , где — это уникальный номер для викторины, полученный из quizNum , для счетчика цикла .Ключ ответа для capitalsquiz .txt будет сохранен в текстовом файле с именем capitalsquiz_answers .txt . При каждом прохождении цикла заполнитель % s в 'capitalsquiz% s.txt' и 'capitalsquiz_answers% s.txt' будет заменен на (quizNum + 1) , так что первый тест и ответ Созданный ключ будет иметь вид capitalsquiz1.txt и capitalsquiz_answers1.txt . Эти файлы будут созданы с помощью вызовов функции open () в ❶ и ❷, с 'w' в качестве второго аргумента, чтобы открыть их в режиме записи.

Операторы write () в ❸ создают заголовок викторины, который студент должен заполнить. Наконец, случайный список штатов США создается с помощью функции random.shuffle () ❹, которая случайным образом меняет порядок значений в любом переданном ей списке.

Шаг 3. Создайте варианты ответа

Теперь вам нужно сгенерировать варианты ответа для каждого вопроса, который будет иметь несколько вариантов ответа от A до D. Вам нужно будет создать еще один цикл для — этот, чтобы сгенерировать контент для каждого из 50 вопросов викторины. .Затем будет третий цикл для , вложенный внутрь, чтобы генерировать варианты с множественным выбором для каждого вопроса. Сделайте так, чтобы ваш код выглядел следующим образом:

 #! python3
   # randomQuizGenerator.py - создает викторины с вопросами и ответами на
   # случайный порядок вместе с ключом ответа.

   -  ножницы  -

         # Просмотрите все 50 состояний, задавая вопросы каждому. 
         на вопрос Число в диапазоне (50): 

             # Получите правильные и неправильные ответы.
❶  правильный ответ = заглавные буквы [указано [questionNum]] 
❷  errorAnswers = list (capitals.values ​​()) 
❸  del неправильные ответы [неправильный ответ.index (правильный ответ)] 
❹  неправильные ответы = случайный. Образец (неправильные ответы, 3) 
❺  answerOptions = неправильные ответы + [правильный ответ] 
❻  random.shuffle (варианты ответа) 

             # TODO: Напишите варианты вопросов и ответов в файл викторины.

             # TODO: Записать ключ ответа в файл.

Правильный ответ получить легко — он хранится как значение в словаре заглавные буквы ❶. Этот цикл будет перебирать состояния в перемешанном списке состояний , от состояний [0] до состояний [49] , найдет каждое состояние в столицах и сохранит соответствующую столицу этого штата в rightAnswer .

Список возможных неправильных ответов сложнее.Вы можете получить его, продублировав всех значений в словаре capitals ❷, удалив правильный ответ ❸ и выбрав три случайных значения из этого списка ❹. Функция random.sample () упрощает этот выбор. Его первый аргумент — это список, из которого вы хотите выбрать; второй аргумент — это количество значений, которые вы хотите выбрать. Полный список вариантов ответов представляет собой комбинацию этих трех неправильных ответов с правильными ответами ❺. Наконец, ответы должны быть рандомизированы ❻ так, чтобы правильный ответ не всегда был вариантом D.

Шаг 4. Запишите содержимое ключевых файлов викторины и ответов

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

 #! python3
   # randomQuizGenerator.py - создает викторины с вопросами и ответами на
   # случайный порядок вместе с ключом ответа.

   -  ножницы  -
       # Прокрутите все 50 состояний, задавая вопросы для каждого.
       для questionNum in range (50):
           -  ножницы  -

             # Напишите вопрос и варианты ответа в файл викторины.
             quizFile.write ('% s. Какой капитал у% s? \ N'% (questionNum + 1, 
                 указывает [questionNum])) 
❶  для i в диапазоне (4): 
❷  quizFile.write ('% s.% S \ n'% ('ABCD' [i], answerOptions [i])) 
             quizFile.write ('\ n') 

             # Записать ключ ответа в файл. 
❸  answerKeyFile.write ('% s.% S \ n'% (questionNum + 1, 'ABCD' [
                answerOptions.индекс (правильный ответ)])) 
         quizFile.close () 
         answerKeyFile.close ()

Цикл для , который перебирает целые числа от 0 до 3 , запишет варианты ответа в список answerOptions ❶. Выражение 'ABCD' [i] at ❷ обрабатывает строку 'ABCD' как массив и возвращает 'A' , 'B' , 'C' , а затем 'D ' на каждой соответствующей итерации цикла.

В последней строке ❸ выражение answerOptions.index (rightAnswer) найдет целочисленный индекс правильного ответа в случайно упорядоченных вариантах ответов, а 'ABCD' [answerOptions.index (correAnswer)] будет оценивать как письмо с правильным ответом, которое будет записано в ключевой файл ответов.

После запуска программы так будет выглядеть ваш файл capitalsquiz1.txt , хотя, конечно, ваши вопросы и варианты ответов могут отличаться от показанных здесь, в зависимости от результата вашего случайного выбора.shuffle () звонки:

 Имя:

Дата:

Период:

                    Викторина о столицах штатов (форма 1)

1. Какая столица Западной Вирджинии?
    А. Хартфорд
    Б. Санта-Фе
    К. Харрисберг
    Д. Чарльстон

2. Какая столица Колорадо?
    А. Роли
    Б. Гаррисберг
    К. Денвер
    Д. Линкольн

-  ножницы  -

Соответствующие capitalsquiz_answers1.txt текстовый файл будет выглядеть так:

 1. D
2. С
3. А
4. С
-  ножницы  -

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

Вы можете написать программу Python для отслеживания нескольких фрагментов текста. Эта «многоклипсовая доска» будет называться mcb.pyw (поскольку «mcb» короче для ввода, чем «multiclipboard»). Расширение .pyw означает, что Python не будет отображать окно терминала при запуске этой программы. (Для получения более подробной информации см. Приложение B.)

Программа сохранит каждый фрагмент текста из буфера обмена под ключевым словом. Например, когда вы запускаете py mcb.pyw save spam , текущее содержимое буфера обмена будет сохранено с ключевым словом spam .Позднее этот текст можно снова загрузить в буфер обмена, запустив py mcb.pyw spam . А если пользователь забывает, какие ключевые слова у него есть, он может запустить py mcb.pyw list , чтобы скопировать список всех ключевых слов в буфер обмена.

Вот что делает программа:

  • Проверяется аргумент командной строки для ключевого слова.

  • Если аргумент — сохранить , то содержимое буфера обмена сохраняется в ключевое слово.

  • Если аргумент — список , то все ключевые слова копируются в буфер обмена.

  • В противном случае текст ключевого слова копируется в буфер обмена.

Это означает, что код должен будет сделать следующее:

  • Прочтите аргументы командной строки из sys.argv .

  • Чтение и запись в буфер обмена.

  • Сохранить и загрузить в файл на полке.

Если вы используете Windows, вы можете легко запустить этот сценарий из окна «Выполнить …», создав командный файл с именем mcb.bat со следующим содержимым:

 @ pyw.exe C: \ Python34 \ mcb.pyw% *

Шаг 1. Комментарии и настройка полки

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

 #! python3
   # mcb.pyw - сохраняет и загружает фрагменты текста в буфер обмена.
❶ # Использование: py.exe mcb.pyw save <ключевое слово> - сохраняет буфер обмена в ключевое слово.
   # py.exe mcb.pyw <ключевое слово> - загружает ключевое слово в буфер обмена.
   # py.exe mcb.pyw list - загружает все ключевые слова в буфер обмена.

❷ импорт полки, pyperclip, sys

❸ mcbShelf = shelve.open ('mcb')

   # TODO: сохранить содержимое буфера обмена.

   # TODO: перечислить ключевые слова и загрузить контент.

   mcbShelf.close ()

Обычно общую информацию об использовании помещают в комментарии вверху файла ❶.Если вы когда-нибудь забудете, как запустить свой скрипт, вы всегда можете просмотреть эти комментарии в качестве напоминания. Затем вы импортируете свои модули ❷. Для копирования и вставки потребуется модуль pyperclip , а для чтения аргументов командной строки потребуется модуль sys . Модуль полки также пригодится: всякий раз, когда пользователь хочет сохранить новый фрагмент текста из буфера обмена, вы сохраняете его в файл полки. Затем, когда пользователь захочет вставить текст обратно в буфер обмена, вы откроете файл полки и загрузите его обратно в свою программу.Имя файла полки будет иметь префикс mcb ❸.

Шаг 2. Сохраните содержимое буфера обмена с ключевым словом

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

 #! python3
   # mcb.pyw - сохраняет и загружает фрагменты текста в буфер обмена.
   -  ножницы  -

     # Сохранить содержимое буфера обмена.
❶ , если len (sys.argv) == 3 и sys.argv [1] .lower () == 'save': 
❷  mcbShelf [sys.argv [2]] = pyperclip.paste () 
     elif len (sys.argv) == 2: 
❸ # TODO: составить список ключевых слов и загрузить контент.

   mcbShelf.close ()

Если первый аргумент командной строки (который всегда будет с индексом 1 в списке sys.argv ) равен 'save' ❶, второй аргумент командной строки является ключевым словом для текущего содержимого буфера обмена.Ключевое слово будет использоваться в качестве ключа для mcbShelf , а значением будет текст, находящийся в данный момент в буфере обмена ❷.

Если есть только один аргумент командной строки, вы предположите, что это либо 'list', , либо ключевое слово для загрузки содержимого в буфер обмена. Вы реализуете этот код позже. А пока просто поместите туда комментарий TODO ❸.

Шаг 3. Список ключевых слов и загрузка содержания ключевого слова

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

 #! python3
   # mcb.pyw - сохраняет и загружает фрагменты текста в буфер обмена.
   -  ножницы  -

   # Сохранить содержимое буфера обмена.
   если len (sys.argv) == 3 и sys.argv [1] .lower () == 'save':
           mcbShelf [sys.argv [2]] = pyperclip.paste ()
   elif len (sys.argv) == 2:
         # Список ключевых слов и загрузка содержимого. 
❶ , если sys.argv [1] .lower () == 'list': 
❷  пиперклип.копия (str (список (mcbShelf.keys ()))) 
         elif sys.argv [1] в mcb полка: 
❸  pyperclip.copy (mcbShelf [sys.argv [1]]) 

   mcbShelf.close ()

Если есть только один аргумент командной строки, сначала давайте проверим, 'список' ❶. Если это так, строковое представление списка ключей полки будет скопировано в буфер обмена ❷. Пользователь может вставить этот список в открытый текстовый редактор, чтобы прочитать его.

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

И все! Эта программа запускается по-разному, в зависимости от того, какую операционную систему использует ваш компьютер. См. Приложение B для получения подробной информации о вашей операционной системе.

Вспомните программу блокировки паролей, созданную вами в главе 6, которая хранит пароли в словаре. Для обновления паролей потребовалось изменить исходный код программы. Это не идеально, потому что обычным пользователям неудобно менять исходный код для обновления своего программного обеспечения.Кроме того, каждый раз, когда вы изменяете исходный код программы, вы рискуете случайно внести новые ошибки. Сохраняя данные для программы в другом месте, чем код, вы можете упростить использование ваших программ для других и сделать их более устойчивыми к ошибкам.

Файлы организованы в папки (также называемые каталогами), а путь описывает расположение файла. Каждая программа, запущенная на вашем компьютере, имеет текущий рабочий каталог, который позволяет вам указывать пути к файлам относительно текущего местоположения вместо того, чтобы всегда вводить полный (или абсолютный) путь.Модуль os.path имеет множество функций для управления путями к файлам.

Ваши программы также могут напрямую взаимодействовать с содержимым текстовых файлов. Функция open () может открывать эти файлы для чтения их содержимого в виде одной большой строки (с помощью метода read () ) или в виде списка строк (с помощью метода readlines () ). Функция open () может открывать файлы в режиме записи или добавления для создания новых текстовых файлов или добавления к существующим текстовым файлам соответственно.

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

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

Вопрос:

1.Что такое относительный путь относительно?

Вопрос:

2. С чего начинается абсолютный путь?

Вопрос:

3. Что делают функции os.getcwd () и os.chdir () ?

Вопрос:

4. Что такое . и .. папки?

Вопрос:

5. Какая часть в C: \ bacon \ egg \ spam.txt является именем каталога, а какая — базовым?

Вопрос:

6. Какие три аргумента «режима» можно передать функции open () ?

Вопрос:

7.Что произойдет, если существующий файл будет открыт в режиме записи?

Вопрос:

8. В чем разница между методами read () и readlines () ?

Вопрос:

9. На какую структуру данных похожа полка?

Для практики разработайте и напишите следующие программы.

Расширение Multiclipboard

Расширьте программу мультилипборда в этой главе, добавив в нее аргумент командной строки delete , который удаляет ключевое слово с полки. Затем добавьте аргумент командной строки delete , который удалит всех ключевых слов.

Создайте программу Mad Libs, которая читает текстовые файлы и позволяет пользователю добавлять свой собственный текст в любом месте, где в текстовом файле появляется слово ADJECTIVE , NOUN , ADVERB или VERB .Например, текстовый файл может выглядеть так:

 ПРИЛАГАЮЩАЯ панда подошла к СУЩЕСТВИТЕЛЬНОМУ, а затем к ГЛАГОЛУ. Близлежащее СУЩЕСТВИТЕЛЬНОЕ было
не затронуты этими событиями.

Программа найдет эти вхождения и предложит пользователю заменить их.

 Введите прилагательное:
  глупо 
Введите существительное:
  люстра 
Введите глагол:
  кричал 
Введите существительное:
  пикап

Затем будет создан следующий текстовый файл:

 Глупая панда подошла к люстре и закричала.Ближайший пикап
Грузовик не пострадали от этих событий.

Результаты следует распечатать на экране и сохранить в новый текстовый файл.

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

Что такое Makefile и как он работает?

Если вы хотите запустить или обновить задачу при обновлении определенных файлов, вам может пригодиться утилита make .Утилите make требуется файл Makefile (или makefile ), который определяет набор задач, которые должны быть выполнены. Возможно, вы использовали make для компиляции программы из исходного кода. Большинство проектов с открытым исходным кодом используют make для компиляции окончательного исполняемого двоичного файла, который затем может быть установлен с помощью make install .

В этой статье мы рассмотрим make и Makefile , используя базовые и расширенные примеры. Перед тем как начать, убедитесь, что make установлен в вашей системе.

Основные примеры

Начнем с печати классического «Hello World» на терминале. Создайте пустой каталог myproject , содержащий файл Makefile со следующим содержимым:

 
 say_hello: 
 echo "Hello World"

Теперь запустите файл, набрав make внутри каталога myproject . На выходе будет:

 
 $ сделать 
 echo "Hello World" 
 Hello World

В приведенном выше примере say_hello ведет себя как имя функции, как и в любом языке программирования.Это называется целью . Предварительные требования или зависимости соответствуют цели. Для простоты мы не определили никаких предварительных условий в этом примере. Команда echo "Hello World" называется рецептом . Рецепт использует предварительных условий для создания цели . Цель, предпосылки и рецепты вместе составляют правило .

Подводя итог, ниже приведен синтаксис типичного правила:

 
 цель: предпосылки 
  рецепт

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

 final_target: sub_target final_target.c 

Recipe_to_create_final_target 
 sub_target: sub_target.c 
 Recipe_to_create_sub_target

Целевой объект не обязательно должен быть файлом; это может быть просто название рецепта, как в нашем примере. Мы называем это «фальшивыми целями».

Возвращаясь к приведенному выше примеру, при выполнении make отображалась вся команда echo «Hello World» , за которой следовал фактический вывод команды.Мы часто этого не хотим. Чтобы подавить эхо фактической команды, нам нужно запустить echo с @ :

 
 say_hello: 
 @echo "Hello World"

Теперь попробуйте снова запустить make . Вывод должен отображать только это:


 
 Давайте добавим еще несколько фальшивых целей:  сгенерировать  и  очистить  в Makefile  : 


 
 say_hello: 

@echo "Hello World" 
 generate: 
 @echo "Создание пустых текстовых файлов... "
 touch file- {1..10} .txt 
 
 clean: 
 @echo" Очистка ... "
 rm * .txt 
 
 Если мы попытаемся запустить  make  после изменений, будет выполнена только цель  say_hello . Это потому, что только первая цель в make-файле является целью по умолчанию. Часто цель  по умолчанию называется , поэтому в большинстве проектов вы будете видеть  все  в качестве первой цели.  и  несут ответственность за вызов других целей.Мы можем изменить это поведение, используя специальную фальшивую цель с именем  .DEFAULT_GOAL .
 Давайте включим это в начало нашего make-файла:
  .DEFAULT_GOAL: = создать  
 Это запустит цель  сгенерировать  по умолчанию:
 
 $ make 
 Создание пустых текстовых файлов ... 
 touch file- {1..10} .txt 
 
 Как следует из названия, фальшивая цель  .DEFAULT_GOAL  может запускать только одну цель за раз.Вот почему большинство make-файлов включают  и  в качестве цели, которая может вызывать столько целей, сколько необходимо.
 Давайте включим фальшивую цель  все  и удалим  .DEFAULT_GOAL :
 all: say_hello generate 
 say_hello: 
 @echo "Hello World" 
 
 generate: 
 @echo "Создание пустых текстовых файлов ..." 
 touch file- {1..10} .txt 
 
 clean: 
 @echo "Уборка ..." 
 rm * .txt 
 
 Прежде чем запускать  make , давайте включим еще одну специальную фальшивую цель, .PHONY , где мы определяем все цели, не являющиеся файлами.  make  будет запускать свой рецепт независимо от того, существует ли файл с таким именем или каково время его последнего изменения. Вот полный make-файл:
 .PHONY: все say_hello сгенерировать чистый 
 все: say_hello сгенерировать 
 
 say_hello: 
 @echo "Hello World" 
 
 generate: 
 @echo "Создание пустых текстовых файлов ..." 
 touch file- {1..10} .txt 
 
 clean: 
 @echo "Очистка... "
 rm * .txt 
 
 Модель  make  должна вызвать  say_hello , а  сгенерирует :
 
 $ make 
 Hello World 
 Создание пустых текстовых файлов ... 
 touch file- {1..10} .txt 
 
 Хорошей практикой является не называть  чистым  из  все  и не ставить его в качестве первой цели.  clean  должен вызываться вручную, когда требуется очистка, в качестве первого аргумента для  make :
 
 $ очистить 
 Очистить... 
 RM * .txt 
 
 Теперь, когда у вас есть представление о том, как работает базовый make-файл и как написать простой make-файл, давайте рассмотрим несколько более сложных примеров.
 Дополнительные примеры 
 Переменные 
В приведенном выше примере большинство целевых и обязательных значений жестко запрограммированы, но в реальных проектах они заменяются переменными и шаблонами.
 Самый простой способ определить переменную в make-файле — использовать оператор  = . Например, чтобы присвоить команду  gcc  переменной  CC :
  CC = gcc
  
 Это также называется рекурсивной расширенной переменной   и используется в правиле, как показано ниже:
 
 привет: привет.c 
 $ {CC} hello.c -o привет 
 
 Как вы уже догадались, рецепт расширяется, как показано ниже, когда он передается в терминал:
  gcc hello.c -o привет
  
 И  $ {CC} , и  $ (CC)  являются действительными ссылками для вызова  gcc . Но если кто-то попытается переназначить переменную самой себе, это вызовет бесконечный цикл. Проверим это:
 CC = gcc 

CC = $ {CC} 
 все: 
 @echo $ {CC} 
 
 Выполнение  make  приведет к:
 
 $ make 
 Makefile: 8: *** Рекурсивная переменная CC ссылается на себя (в конце концов).Стоп. 
 
 Чтобы избежать этого сценария, мы можем использовать оператор : =  (он также называется просто расширенной переменной  ). У нас не должно возникнуть проблем с запуском make-файла ниже:
 CC: = gcc 

CC: = $ {CC} 
 все: 
 @echo $ {CC} 
 
 Узоры и функции 
 Следующий make-файл может компилировать все программы C с использованием переменных, шаблонов и функций. Давайте исследуем его построчно:
 # Использование: 

# make # скомпилировать весь двоичный код 

# очистить # удалить ВСЕ двоичные файлы и объекты 
.PHONY = all clean 
 
 CC = gcc # compiler to use 
 
 LINKERFLAG = -lm 
 
 SRCS: = $ (wildcard * .c) 
 BINS: = $ (SRCS:%. C =%) 
 
 all: $ {BINS} 
 
%:% .o 
 @echo "Checking .." 
 $ {CC} $ {LINKERFLAG} $ <-o $ @ 
 
% .o:% .c 
 @echo "Создание объекта .. "
 $ {CC} -c $ <
 
 clean: 
 @echo" Очистка ... "
 rm -rvf * .o $ {BINS} 
 
  •  Строки, начинающиеся с  # , являются комментариями.
  •  Строка  .PHONY = all clean  определяет фальшивые цели  все  и  clean .
  •  Переменная  LINKERFLAG  определяет флаги, которые будут использоваться с  gcc  в рецепте.
  •   SRCS: = $ (подстановочный знак * .c) :  $ (подстановочный знак)  — одна из функций  для имен файлов . В этом случае все файлы с расширением  .c  будут храниться в переменной  SRCS .
  •   BINS: = $ (SRCS:%. C =%) : Это называется ссылкой на подстановку  . В этом случае, если  SRCS  имеет значения  'foo.c bar.c' ,  BINS  будет иметь  'foo bar' .
  •  Строка  все: $ {BINS} : Фальшивая цель  все  вызывает значения в  $ {BINS}  как отдельные цели.
  •  Правило:
     
    %:% .o 
     @echo "Проверка.. "
     $ {CC} $ {LINKERFLAG} $ & lt; -o $ @ 
     
     Давайте рассмотрим пример, чтобы понять это правило. Предположим,  foo  — одно из значений в  $ {BINS} . Тогда %  будет соответствовать  foo  (%  может соответствовать любому целевому имени). Ниже представлено правило в развернутом виде:
     
     foo: foo.o 
     @echo "Проверка .." 
     gcc -lm foo.o -o foo 
     
     Как показано, %  заменяется на  foo .  $ < заменяется на  foo.o . Шаблон  $ < соответствует предварительным условиям, а  $ @  соответствует цели. Это правило будет вызываться для каждого значения в  $ {BINS} 
  •  Правило:
     
    % .o:% .c 
     @echo "Создание объекта .." 
     $ {CC} -c $ & lt; 
     
     Каждое предварительное условие в предыдущем правиле считается целью для этого правила. Ниже представлено правило в развернутом виде:
     
     foo.o: foo.c 
     @echo "Создание объекта.. "
     gcc -c foo.c 
     
  •  Наконец, мы удаляем все двоичные файлы и объектные файлы в цели  clean .
 Ниже приведена перезапись вышеуказанного make-файла, предполагая, что он помещен в каталог с единственным файлом  foo.c: 
 
 # Использование: 
 # make # скомпилировать весь двоичный код 
 # очистить # удалить ВСЕ двоичные файлы и объекты
 .PHONY = все очистить
 CC = gcc # использовать компилятор
 LINKERFLAG = -lm
 SRCS: = foo.c 
 BINS: = foo
 all: foo
 foo: foo.o 
 @echo "Проверка .
Добавить комментарий 
Ваш адрес email не будет опубликован. Обязательные поля помечены *