Как связать два файла python

Обновлено: 25.04.2024

У меня есть список из 20 имен файлов, например, ['file1.txt', 'file2.txt', . ] . Я хочу написать скрипт Python для объединения этих файлов в новый файл. Я мог бы открыть каждый файл с помощью f = open(. ) , прочитать строку за строкой, вызвав f.readline() , и записать каждую строку в этот новый файл. Это не кажется мне очень «элегантным», особенно та часть, где я должен читать // писать построчно.

Есть ли более «элегантный» способ сделать это в Python?

Это должно сделать это

Для больших файлов:

Для небольших файлов:

… и еще один интересный вопрос, о котором я подумал :

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

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

Я не знаю об элегантности, но это работает:

Что не так с командами UNIX? (учитывая, что вы не работаете в Windows):

ls | xargs cat | tee output.txt выполняет работу (вы можете вызвать его из python с подпроцессом, если хотите)

Проверьте метод .read () объекта File:

Вы можете сделать что-то вроде:

Или более «элегантный» путь Python:

Простой тест показывает, что шутил работает лучше.

Если файлы не гигантские:

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

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

Альтернативный ответ @ inspectorG4dget (лучший ответ на сегодняшний день 29-03-2016). Я тестировал с 3 файлами 436MB.

Решение @ inspectorG4dget: 162 секунды

Следующее решение: 125 секунд

Идея состоит в том, чтобы создать пакетный файл и выполнить его, используя «старые добрые технологии». Его полупитон, но работает быстрее. Работает для окон.

Именно для этого fileinput:

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

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

Как отмечено в комментариях и обсуждено в другом посте, > для Python 2.7 не будет работать, как указано. Здесь небольшая модификация, чтобы сделать код Python 2.7 совместимым

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

Связь Python + C(C++)
Добрый день. Есть задание написать небольшую игрушку. Вся фишка в том, чтобы оболочка была написана.

Связь python и sql
Есть ли связь? Добавлено через 3 минуты CREATE TABLE NEW ( inn numeric(20), naimen.

Связь Python c Django
Заранее прошу сильно не пинать, если такая тему уже есть на форуме пожалуйста дайте ссылку -сам не.

Что мешает в файл А импортировать функцию из файла Б.
При нажатии на ОК (gui файл А), вызвать эту функцию.
p.s.: функции могут что-то принимать и возвращать

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

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

Добавлено через 7 минут

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

И не надо никаких глобальных переменных.
Ни первый, ни второй файл главными не являются. Они должны быть оформлены как библиотеки с классами. По крайней мере интерфейсный модуль.
Главный модуль main.py(или .pyw) будет импортировать нужную функциональность и из первого и второго и пользоваться ей в меру необходимости.

Главный модуль main.py(или .pyw) будет импортировать нужную функциональность и из первого и второго и пользоваться ей в меру необходимости.

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

Это не имеет отношение к проблематике хранения состояния в глобальных переменных.
Данные сохраняются в БД не по причине их глобальности, а по необходимости персистентного хранения какого-то состояния.

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

Именно это и должен сделать ТС: оформить этот модуль как контейнер с магией. Когда ему понадобится какая-то магия оттуда, он вызывает черный ящик (модуль) и говорит "хочу шляпу с кроликом" и модуль дает ему это.
А главный модуль должен заботиться исключительно о создании экземпляра программы, логике его запуска и завершения. Вся магия должна быть за кулисами.

Решение

Garry Galler, И все таки Вы не ответили ТСу на его вопрос, как передать данные введенные в форму в главный модуль, пусть он будет как Вы предлагаете main.py (или main.pyw). Я предложил запустив в интерфейсном модуле функцию сохранить данные в глобальных переменных этого интерфейсного модуля. Затем главным модулем можно будет их забрать используя квалифицированные имена. Можно конечно при импорте использовать from но в этом случае возникает риск конфликта имен. Но даже пусть используется from , все равно, как забрать данные из формы. Как только закроем форму, так данные пропадут. То есть сохранить данные мы можем только запуская функцию из под формы. Но эта функция будет принадлежать интерфейсному модулю и сохранять внутри функции мы не можем, так как при ее отработки ее содержимое пропадет. Если мы будем запускать эту функцию из главного модуля то форма уже будет закрыта и потому функция ничего не вернет.
Хотя сейчас придумал вариант.
Из главного модуля запускать функцию в интерфейсном модуле которая в свою очередь запускает форму , затем сохраняет в локальных переменных данные . После закрывает форму и возвращает данные в главный модуль, который ее вызвал. Пожалуй так сработает.

Добавлено через 1 минуту
Пожалуй запомню такую технологию и буду ее применять.

Как я ему отвечу, если я не вижу ни строчки кода? Все что мы сейчас ему советуем это "разговоры в пользу бедных".
Но ТС сам виноват: что спросил, то и ответили.

Да ничего никуда не пропадает. GUI класс ничем не отличается от любого другого класса.
Как из одного класса можно передать состояние любому другому, так и здесь.

Всем спасибо за ответы, понял, в каком направлении копать. Garry Galler, Viktorrus, вариант с записью значений переменных в текстовый файл, а затем, при запуске основного кода, брать их оттуда, стоит рассмотрения? Мне все равно нужно сохранять где-то значения переменных для будущих сессий - если пользователь ставит галочку - при следующем запуске программы, поля автоматически заполняются.

Обычно для небольшого числа переменных, чьи значения нужно сохранять для последующего запуска программы вполне приемлемо использовать ini файл.
В Python работа с ini файлами встроена в стандартную библиотеку. Однако, сам модуль оставляет желать лучшего (есть баги, типа стирания комментариев после перезаписи файла). Да и формат ini уже несколько устарел.
Можно попробовать рассмотреть более мощный формат toml (сам сейчас им пользуюсь в Go), для Python парсеры toml тоже можно найти на pypi.

Aleksandrw, Советую еще посмотреть встроенный в питон модуль shelve. Я использую его для сохранения данных. Основное его достоинство, с ним очень удобно работать. Сохраненные данные имеют структуру словаря питона, и кроме того, что они сохраняются на диске и поэтому перед началом работы нужно выполнить загрузку, а по окончании закрыть, в остальном Вы работаете с ним как с обычным словарем питона. Все методы и операции, которые доступны словарям питона, доступны и этому словарю.
То есть Вы получаете словарь питона, который можете сохранять на диске, и при необходимости загружать его для работы.
Да и чуть не забыл, в отличие от текстовых файлов и некоторых других средств, в этом словаре , как и в любом другом словаре питона, можно сохранять любые объекты питона и вложенные структуры питона, в том числе экземпляры класса. Это благодаря тому, что модуль shelve использует в своей работе модуль pickle , с помощью которого можно сохранять на диске любой объект питона. Но модуль shelve предоставляет более удобный сервис для работы с ним, как я описал выше.

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

Добавлено через 9 минут
Aleksandrw, Пример аналогичный Вашей задаче подробно рассматривается в книге
Лутц М. Программирование на Python. Том 1 (4-е издание, 2011) Глава 1. Там где рассказывается как использовать графический интерфейс и сохранять данные с помощью модуля shelve в базе данных.

Добавлено через 3 минуты
Для Вашей задачи shelve может оказаться излишне мощным инструментом, но стоит научиться с ним работать.

Как можно это сделать без библиотеки pandas? у меня выходит только:

Подскажите пожалуйста. Спасибо

with open('1.txt', 'r') as f1, open('2.txt', 'r') as f2, open('3.txt', 'w') as f3: for i, j in zip(f1.readlines(), f2.readlines()): f3.write(f",'\n'") Размеры ведь одинаковые?

@EzikBro не нужно обрамлять '\n' кавычками. и можно без второго .strip(), просто f3.write(f',') добавьте как ответ?

2 ответа 2

Открываем файлы, читаем построчно, строки чистим, печатаем через запятую в третий файл:

Всё ещё ищете ответ? Посмотрите другие вопросы с метками python массивы объединение txt или задайте свой вопрос.

1 ответ 1

Позволю дать вам некоторые советы:

хотя ваш вопрос звучит как: 'Соединение двух проектов с расширением .py', я понял что вам надо вставить виджет App из втогого файла как страницу (например четвертую) в основное приложение main.py .

ваше основное приложение main.py - содержало много ошибок. Я исправил их, смотрите по тексту кода.

НЕТ проблемы в том, что второй файл делался с помощью Qt Designer и имеет отсылки к .ui файлам.

я не могу проверить правильно ли работает ваш второй файл, поэтому я заменил его каким-то своим q1297974_second.py.

I have a list of 20 file names, like ['file1.txt', 'file2.txt', . ] . I want to write a Python script to concatenate these files into a new file. I could open each file by f = open(. ) , read line by line by calling f.readline() , and write each line into that new file. It doesn't seem very "elegant" to me, especially the part where I have to read/write line by line.

Is there a more "elegant" way to do this in Python?

Its not python, but in shell scripting you could do something like cat file1.txt file2.txt file3.txt . > output.txt . In python, if you don't like readline() , there is always readlines() or simply read() .

@jedwards simply run the cat file1.txt file2.txt file3.txt command using subprocess module and you're done. But I am not sure if cat works in windows.

As a note, the way you describe is a terrible way to read a file. Use the with statement to ensure your files are closed properly, and iterate over the file to get lines, rather than using f.readline() .

12 Answers 12

This should do it

For large files:

For small files:

… and another interesting one that I thought of:

Sadly, this last method leaves a few open file descriptors, which the GC should take care of anyway. I just thought it was interesting

why would you decode and re-encode the whole thing? and search for newlines and all the unnecessary stuff when all that’s required is concatenating the files. the shutil.copyfileobj answer below will be much faster.

It automatically reads the input files chunk by chunk for you, which is more more efficient and reading the input files in and will work even if some of the input files are too large to fit into memory:

for i in glob.glob(r'c:/Users/Desktop/folder/putty/*.txt'): well i replaced the for statement to include all the files in directory but my output_file started growing really huge like in 100's of gb in very quick time.

Note, that is will merge last strings of each file with first strings of next file if there are no EOL characters. In my case I got totally corrupted result after using this code. I added wfd.write(b"\n") after copyfileobj to get normal result

@Thelambofgoat I would say that is not a pure concatenation in that case, but hey, whatever suits your needs.

This is super fast and as I required. yes it does not add new line between "two files end and start" and exactly this I needed. so dont update it :D

That's exactly what fileinput is for:

For this use case, it's really not much simpler than just iterating over the files manually, but in other cases, having a single iterator that iterates over all of the files as if they were a single file is very handy. (Also, the fact that fileinput closes each file as soon as it's done means there's no need to with or close each one, but that's just a one-line savings, not that big of a deal.)

There are some other nifty features in fileinput , like the ability to do in-place modifications of files just by filtering each line.

As noted in the comments, and discussed in another post, fileinput for Python 2.7 will not work as indicated. Here slight modification to make the code Python 2.7 compliant

@abament I think for line in fileinput.input() isn't the best way to choose in this particular case: the OP wants to concatenate files, not read them line by line which is a theoretically longer process to execute

@eyquem: It's not a longer process to execute. As you yourself pointed out, line-based solutions don't read one character at a time; they read in chunks and pull lines out of a buffer. The I/O time will completely swamp the line-parsing time, so as long as the implementor didn't do something horribly stupid in the buffering, it will be just as fast (and possibly even faster than trying to guess at a good buffer size yourself, if you think 10000 is a good choice).

@abarnert NO, 10000 isn't a good choice. It is indeed a very bad choice because it isn't a power of 2 and it is ridiculously a little size. Better sizes would be 2097152 (221), 16777216 (224) or even 134217728 (2**27) , why not ?, 128 MB is nothing in a RAM of 4 GB.