Усъвършенствайте уменията си за кодиране с Python: файлове

Открийте какво представляват файловете в Python

Тази статия има за цел да ни запознае с различните начини, по които можем да работим с файлове и файлови обекти в Python, по-конкретно, ще видим как да отваряме, затваряме и извършваме операции върху такива файлови обекти, за да извлечем от тях това, от което се нуждаем. За простота и праволинейност ще започна с предположението, че всички знаем какво представляват файловете и каква е целта им. Те са просто данни (съдържанието на файла), съхранени под наименувани местоположения (името на файла), в енергонезависима памет (SSD, HDD, USB/външни флаш устройства и т.н.). Типичният цикъл от операции, извършвани върху файл, се състои от три важни стъпки:

отваряне на файла;
четене от / запис във файла;
затворете файла.

Отварянето на файла се постига с помощта на функцията open():

my_file_object = open(filename, mode)

Това, което прави тази функция, е, че връща обект _io.TextIOWrapper, който след това се присвоява на променливата my_file_object.

# say we have a file in our current directory
# called "sample_text_file":
my_file_object = open("sample_text_file", "r")
print(type(my_file_object))
Output:
<class '_io.TextIOWrapper'>

Това е най-широко използваната форма за извикване на open(). Има и други аргументи за ключови думи, можете да прочетете много повече за тях тук. Засега, фокусирайки се върху двата аргумента, които предоставихме, веднага става очевидно, че filename е низ, представляващ името на файла. За да бъдем по-точни, това е пътят на файла, независимо дали е относителен или абсолютен път. Ако предоставим на функцията само име на файл, като example.txt, тогава предполагаемият път е идентичен с текущата работна директория и, като пряко следствие, Python ще се опита да отвори файла example.txt в текущата работна директория.

Другият аргумент, mode е друг низ, който се отнася до режима, в който отваряме файла. Има няколко режима, за които можем да отворим файл:

четене (това е по подразбиране): r;
писане (записване във файл — презаписване, ако съществува, създаване, ако не съществува): w;
изключително писане (създайте файла, това ще се провали, ако вече съществува): x;
добавяне (добавяне към файл, създаване, ако не съществува): a.

Има и още няколко режима, които могат да се използват заедно с горните 4:

отворете файла в текстов режим (това е по подразбиране): t;
отворете файла за актуализиране: +;
отворете файла в двоичен режим: b.

Нека да разгледаме няколко примера:

# open file in text mode, for reading
my_file = open("file.txt")
# same file, same mode (text mode, open for reading)
my_file = open("file.txt", "rt")
# open file for reading and writing - overwrites previous contents
my_file = open("file.txt", "r+")
# open for writing and reading - completely wipes previous contents
my_file = open("file.txt", "w+")
# open for appending and reading - does not overwrite data
my_file = open("file.txt", "a+")
# open for reading, binary mode
my_file = open("file.txt", "rb")

Отварянето на файлове в двоичен режим ще третира данните като bytes обекти, докато в текстовия режим данните ще бъдат прочетени от файла като str. Да кажем, че имаме файл, наречен file.txt, който се намира в текущата ни работна директория и съдържа низа abc. Нека отворим файла както в двоичен, така и в текстов режим и да прочетем един ред от него:

# binary mode
my_file_obj = open("file.txt", "rb")
line = my_file_obj.readline()
print(f"{type(line)}: {line}")
my_file_obj.close()
# text mode
my_other_file_obj = open("file.txt", "rt")
line = my_other_file_obj.readline()
print(f"{type(line)}: {line}")
my_other_file_obj.close()
Output:
<class 'bytes'>: b'abc'
<class 'str'>: abc

Нещо, което трябва да имате предвид. Режимът за отваряне на файла (текст/двоичен) е, както току-що видяхме, отразен в типа данни, които получаваме от него. Обратно, ако отворим файла за запис, трябва да предприемем необходимите стъпки, за да подадем данни от правилния тип за файловия обект. Ето какво се случва, ако не адаптираме нашия тип данни към режима, в който сме отворили файла:

# open a file for writing in binary mode
my_file_obj = open("file.txt", "wb")
# create a string and attempt to write it to the file
line = "abc"
my_file_obj.write(line)
my_file_obj.close()
Output:
Traceback (most recent call last):
  ...
    my_file_obj.write(line)
TypeError: a bytes-like object is required, not 'str'

Също така е много важно да се отбележи, че режимите r+ и w+ се държат малко по-различно, така че си струва да ги проучите отблизо.

Да кажем, че имаме файл, наречен file.txt, съдържащ само един ред данни: Python. Нека да видим какво ще се случи, ако го отворим съответно в режимите r+ и w+. Също така бихме записали низа abc във файла, преди да го затворим. След това ще проверим съдържанието на файла:

my_file = open("file.txt", "r+")
my_file.write("abc")
my_file.close()
File contents:
abchon

Както можехме да видим сами, в случая с режима r+ това, което се случи, беше, че позиционира курсора в самото начало на файла и просто започна да пише низа, който сме му инструктирали. Някои, но не всички данни бяха презаписани, тъй като нашият низ, abc, не беше достатъчно дълъг, за да презапише цялото съдържание на файла.

Да видим дали режимът w+ се държи по същия начин:

my_file = open("file.txt", "w+")
my_file.write("abc")
my_file.close()
File contents:
abc

Този път при отваряне на файла в режим w+ всички съдържащи се данни бяха загубени. След това низът abc беше записан във файла и в резултат това е всичко, което ни остава. Целият низ Python, който първоначално беше там, просто го нямаше.

Като заключение, трябва да сме много внимателни, когато избираме правилния режим за отваряне на нашия файл.

Както всеки обект в Python, файловите обекти също могат и всъщност имат няколко собствени свойства:

encoding — кодиране на текстовия поток. Един много известен стандарт за кодиране е UTF-8;
errors — настройката за грешка на енкодера/декодера. Може да бъде или strict (повишаване на UnicodeDecodeError изключение), replace (използване на U+FFFD, replacement_character), ignore (оставете знака извън резултата) или backslashreplace (вмъква \xNN екранираща последователност);
newlines — връща броя на срещаните знаци за нов ред при извършване на операции за четене на файла. Операциите за запис не влияят на този брой;
raw — това има връзки с класа RawIOBase, който наследява класа IOBase. Засега спецификата на този клас е извън нашия обхват;

Нашият файлов обект, след като бъде създаден, има няколко собствени атрибута:

buffer — използва се за буфериране на необработени двоични потоци. Режимът, в който се отваря файлът, определя типа на този буфер. Например, ако файлът се отваря за четене, нашият буфер ще бъде от тип _io.BufferedReader;
closed — дали файлът е затворен или не;
line_buffering — дали да се активира буферирането на линията;
write_through — дали записите се предават незабавно към базовия двоичен буфер;
closefd — дали да се затвори файловият дескриптор в същото време, когато I/O обектът се затваря. Използва се само ако вместо str представяне на име на файл е предоставен файлов дескриптор;
name — доста просто, това е свойството име на файла на файловия обект;
mode — отново, много ясно, това е режимът, в който е отворен нашият файл.

Сега, след като набързо разгледахме някои от атрибутите на файловия обект, нека да видим кои са основните методи, които можем да използваме върху такива обекти.

Затваряне на файл

Много ясна тази:

# open a file for appending
my_file_obj = open("file.txt", "a")
# close the file
my_file_obj.close()
# check if the file's been closed
print(my_file_obj.closed)
Output:
True

Отделете буфера от текстовия поток

Може да срещнете ситуации, в които може да се наложи да направите това. Методът detach() ефективно изключва буфера от необработения поток и след това го връща (буфера). Предупреждение: отделеният буфер вече е в неизползваемо състояние. Опит за затваряне на файла или извършване на операции за четене/запис на файловия обект ще доведе до хвърляне на изключения:

# open a file for appending
my_file_obj = open("file.txt", "a")
# detach the buffer
buffer = my_file_obj.detach()
print(buffer)
# attempt to close the file
my_file_obj.close()
Output:
<_io.BufferedWriter name='file.txt'>
Traceback (most recent call last):
  ...
    my_file_obj.close()
ValueError: underlying buffer has been detached

Получихме буфера, както се вижда по-горе, но всички по-нататъшни операции върху файловия обект сега водят до грешка.

Вземете файлов дескриптор на файловия обект

Методът fileno() връща основния файлов дескриптор на отворен файл (ако съществува). Обикновено е цяло число:

# open a file for appending
my_file_obj = open("file.txt", "a")
# get its file descriptor
file_descriptor = my_file_obj.fileno()
print(file_descriptor)
# close the file
my_file_obj.close()
Output:
3

Причината, поради която получаваме 3 е, че нямаме други отворени файлове преди този и също така, че файловите дескриптори 0, 1 и 2 са запазени, както следва:

0 е файловият дескриптор за стандартен вход или stdin;
1 съответства на стандартния изход, известен също като stdout;
2 е файловият дескриптор, отговорен за стандартната грешка (stderr).

Промиване на вътрешния буфер

Добър пример, подходящ за представяне на метода flush(), е записването на данни във файл. Обикновено ще забележите, че данните си проправят път към файла, след като той е бил затворен:

# open a file for writing
my_file_obj = open("file.txt", "w")
# write 2 lines to the file
my_file_obj.write("First line\n")
my_file_obj.write("Second line\n")
# wait for Enter key. 
# check file.txt. Right now it should be empty.
input()
my_file_obj.close()
# check file.txt again. Now it should contain the data

Ако сте следвали, ще забележите, че данните не се записват във файла, докато файлът не бъде затворен. Сега да видим какво се случва, ако използваме flush() във файла, преди да го затворим:

# open a file for writing
my_file_obj = open("file.txt", "w")
# write a first line to the file
my_file_obj.write("First line\n")
# flush the buffer
my_file_obj.flush()
# write a second line to the file
my_file_obj.write("Second line\n")
# wait for Enter key. 
# check file.txt. It should contain the first line.
input()
my_file_obj.close()
# check file.txt again. Now it should contain all data

Както видяхме, flush() принуди записването на данните от вътрешния буфер във файла, преди файлът да бъде затворен. Има редица ситуации, в които може да намерите това за много полезно и като такъв трябва да знаете за този полезен метод за вашия колан с инструменти за I/O файлове на Python.

Определете дали файловият поток е интерактивен

Или, с други думи, ако файлът е свързан към tty (или подобно на tty) устройство (например терминал), методът isatty() ще върне True. В противен случай очевидно ще върне False:

# open a file for writing
my_file_obj = open("file.txt", "w")
# is it associated with a terminal?
result = my_file_obj.isatty()
print(result)
# close the file
my_file_obj.close()
Output:
False

Очевидно току-що отворихме обикновен файл за писане, така че резултатът False не трябва да ни изненадва. Но ако продължим и изградим някакъв канален файл, като в „този“ страхотен пример, тогава ще имаме файл, свързан към терминал.

Надникнете в буфера

Метод, който ни помага да постигнем това, който работи за файлове, отворени за четене в двоичен режим, peek() ни дава съдържанието на буфера, без да се налага да извършваме операции за четене:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open the file for reading, in binary mode
my_file_obj = open("file.txt", "rb")
# return the current buffer contents
result = my_file_obj.peek()
print(result)
# perform a reading operation
result = my_file_obj.readline()
print(result)
# check the buffer once again
result = my_file_obj.peek()
print(result)
# finally close the file
my_file_obj.close()
Output:
b'ABCD\nEFGH\nIJKL'
b'ABCD\n'
b'EFGH\nIJKL'

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

Четене от файл — read()

Методът read() може да се използва за четене на символи от файл. Незадължителният целочислен аргумент (size) указва броя знаци за четене от файла. Пропускането му или задаването му на отрицателна стойност ще го накара да прочете всички налични данни, или чрез извикване на readall(), или чрез множество операции за четене на основния необработен поток:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open the file for reading
my_file_obj = open("file.txt", "r")
# read 1 char
result = my_file_obj.read(1)
print(result)
# argumentless read operation
result = my_file_obj.read()
print(result)
# close the file
my_file_obj.close()
Output:
A
BCD
EFGH
IJKL

Първо, прочетохме 1 знак. След това извършихме операция за четене без аргументи, давайки ни останалото съдържание на файла.

Четене от файл — read1()

Не, не е правописна грешка, това е метод, който е достъпен за файлове, отворени за четене - очевидно - в двоичен режим. Той се отличава от предишния метод read() по това, че в случай на липса на достатъчно данни в буфера, за да се удовлетвори незадължителният аргумент size, ще бъде извършена най-много една операция за четене към базовия необработен поток. Ако size е отрицателно или пропуснато, няма операция за четене на основния необработен поток и целият наличен буфер се връща:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open the file for reading, in binary mode
my_file_obj = open("file.txt", "rb")
# read 1 byte
result = my_file_obj.read1(1)
print(result)
# argumentless read operation
result = my_file_obj.read1()
print(result)
# close the file
my_file_obj.close()
Output:
b'A'
b'BCD\nEFGH\nIJKL'

Резултатите са много подобни на операцията read(). Освен че този път резултатът се връща в bytes, за разлика от str.

Определете дали файлът може да се чете

Методът readable() ще ни каже дали даден файл е четим или не:

# open a file in append mode
my_file_obj = open("file.txt", "a")
# this file isn't readable
result = my_file_obj.readable()
print(result)
# close the file
my_file_obj.close()
# open the same file, this time in read mode
my_file_obj = open("file.txt", "r")
# this time the file's readable
result = my_file_obj.readable()
print(result)
# close the file once more
my_file_obj.close()
Output:
False
True

Четене на байтове в буфер — readinto()

За да постигнем това, се нуждаем от обект, подобен на байтове, който да представлява буфера и файл, от който да четем, отворен в двоичен режим. След това методът readinto() върши своето. Струва си да се отбележи, че под капака може да има множество операции за четене, извършени върху базовия поток:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open a file in binary mode, for reading
my_file_obj = open("file.txt", "rb")
# construct our buffer
buffer = bytearray(16)
# read from the file into the buffer
my_file_obj.readinto(buffer)
print(buffer)
# close the file
my_file_obj.close()
Output:
bytearray(b'ABCD\nEFGH\nIJKL\x00\x00')

Както успяхме да видим, буферът първоначално беше запълнен с \x00 bytes и след това попълнен с данните, които прочетохме от файла.

Четене на байтове в буфер — readinto1()

Подобно на readinto(), с изключение на това, че ще има най-много една единствена операция за четене на основния поток, за разлика от readinto(), където има възможност за извършване на множество операции за четене на базовия поток:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open a file in binary mode, for reading
my_file_obj = open("file.txt", "rb")
# construct our buffer
buffer = bytearray(16)
# read from the file into the buffer
my_file_obj.readinto1(buffer)
print(buffer)
# close the file
my_file_obj.close()
Output:
bytearray(b'ABCD\nEFGH\nIJKL\x00\x00')

Прочетете един ред от файла

В случай, че трябва да прочетем един ред (или да извършим четене ред по ред) от файл, методът readline() е тук, за да помогне точно с това:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL:
# open a file for reading
my_file_obj = open("file.txt", "r")
# read one line from the file
result = my_file_obj.readline()
print(result)
# read a second line from the file
result = my_file_obj.readline()
print(result)
# close the file
my_file_obj.close()
Output:
ABCD
EFGH

Едно нещо, което трябва да се отбележи, readline() не премахва прочетения ред от знака за нов ред (\n), както може да се види по-горе.

Прочетете редове от файла

Ако това, от което се нуждаем, е да прочетем всички редове от файл и да ги съхраним в списък, readlines() е методът за нас. Той разполага с незадължителен целочислен аргумент, който спира добавянето на редове към изходния списък, ако общият брой върнати байтове надвишава този аргумент. Нека да видим метода в действие:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL\nMNOP:
# open a file for reading
my_file_obj = open("file.txt", "r")
# read lines from the file, until 5+ bytes are returned
result = my_file_obj.readlines(5)
print(result)
# read all remaining lines
result = my_file_obj.readlines()
print(result)
# close the file
my_file_obj.close()
Output:
['ABCD\n', 'EFGH\n']
['IJKL\n', 'MNOP\n']

Директно итериране през файла

Трябва да се каже, че ако всичко, което искаме, е да четем от файла ред по ред, но не се интересуваме от съхраняването на всички тези редове в списък, можем просто да четем директно от файловия обект. Файловият обект е от тип _io.TextIOWrapper и в случай, че сме отворили файла за целите на четене, той може да бъде повторен, позволявайки достъп до съдържанието на самия файл. Да видим как:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCD\nEFGH\nIJKL\nMNOP:
# open a file for reading
my_file_obj = open("file.txt", "r")
# read directly from the file, line by line
for line in my_file_obj:
    print(line)
# close the file
my_file_obj.close()
Output:
ABCD
EFGH
IJKL
MNOP

Повече за това тук, където официалните документи подкрепят това и дори ни съветват да го направим, тъй като води до по-прост, по-четлив код, в допълнение към това, че е по-ефективен и по-бърз. Моля, обърнете внимание, че итерирането върху файловия обект работи, докато все още има редове за четене. След като стигнем до края, трябва да направим нещо като my_file_obj.seek(0), за да преместим курсора в началото на файла, за да можем отново да преминем през файловия обект.

Преконфигуриране на текстовия поток

Да предположим, че искаме малко по-различна конфигурация на текстовия поток, след като файлът бъде отворен, и затварянето на файла само за повторното му отваряне под различна конфигурация не е опция. Методът reconfigure() ни позволява да задаваме стойности за няколко параметъра, като:

encoding
errors
newline
line_buffering
write_through

# say we have a file in our current directory
# called "file.txt"
# open a file for reading, UTF-16 encoding
my_file_obj = open("file.txt", "r", encoding="UTF-16")
print(my_file_obj.encoding)
# reconfigure the text stream for UTF-8 encoding
my_file_obj.reconfigure(encoding="UTF-8")
print(my_file_obj.encoding)
# close the file
my_file_obj.close()
Output:
UTF-16
UTF-8

Търсене във файлове

Методът seek() се оказва много полезен в ситуации, в които трябва да прочетете само някои специфични фрагменти от файла. Той идва с 2 аргумента:

offset — цяло число, определящо отместването в байтове;
whence — това е незадължителен аргумент, който по подразбиране е 0, ако е пропуснат, и има 3 възможни стойности: 0 означава абсолютно позициониране на файла, така че отместването е спрямо началото на файла, 1 означава търсене спрямо текущата позиция във файла, а 2 означава търсене спрямо края на файла;

Този метод се използва най-добре, когато работите с файлове, отворени в двоичен режим. За файлове, отворени в текстов режим, ще открием, че неговите функционалности са ограничени само до търсене от началото на файла (seek(i, 0)) и прескачане направо до края на файла чрез seek(0, 2).

Нека да видим как се държи този метод:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCDEFGHIJKLMNOPQRSTUVWXYZ:
# open a file for reading
my_file_obj = open("file.txt", "rb")
# move the cursor 3 bytes from the start
location = my_file_obj.seek(3, 0)
print(location)
# from that location, read 2 bytes
result = my_file_obj.read(2)
print(result)
# advance cursor 1 byte from current location
location = my_file_obj.seek(1, 1)
print(location)
# from that new location, read 3 bytes
result = my_file_obj.read(3)
print(result)
# move cursor 5 bytes before end of file
location = my_file_obj.seek(-5, 2)
print(location)
# from that new location, read 4 bytes
result = my_file_obj.read(4)
print(result)
# close the file
my_file_obj.close()
Output:
3
b'DE'
6
b'GHI'
21
b'VWXY'

Определете дали даден файл може да се търси

Сега, след като току-що видяхме как се държи seek(), можем също така да проверим дали даден файл може да се търси, преди дори да опитаме операция за търсене на файла. Простият метод seekable() връща булево (True / False), което показва дали файлът позволява достъп до файловия поток или не.

# open a file for reading
my_file_obj = open("file.txt", "rb")
# is the file seekable?
result = my_file_obj.seekable()
print(result)
# close the file
my_file_obj.close()
Output:
True

Получаване на текущото местоположение на курсора

Има моменти, когато трябва да получим текущото местоположение на курсора във файла. Това местоположение е позицията, от която данните ще се записват или четат, и това е важна информация, която трябва да знаете. Веднага след отваряне на файл курсорът седи в началото на файла, така че първоначално това местоположение е 0. Докато записваме/четем данни към/от файла, това местоположение автоматично напредва. Възможно е също да преместите този курсор чрез метода seek(). За да получим местоположението на курсора, използваме метода tell() с голям успех:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCDEFGHIJKLMNOPQRSTUVWXYZ:
# open a file for reading
my_file_obj = open("file.txt", "r")
# read 5 bytes
my_file_obj.read(5)
# get the current position within the file
result = my_file_obj.tell()
print(result)
# close the file
my_file_obj.close()
Output:
5

Както се очакваше, прочетохме 5 байта от началото на файла и това автоматично придвижи курсора напред с 5 байта. Така че, естествено, резултатът е, че курсорът сега е на 0+5=5.

Съкращаване на файл

Методът truncate() ефективно съкращава размера на файла. Има незадължителен аргумент, size, който инструктира метода да съкрати файла до най-много size байта. Ако не присъства, тогава просто ще съкрати всичко от текущата позиция до края.

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCDEFGHIJKLMNOPQRSTUVWXYZ:
# open a file for reading and updating, binary mode
my_file_obj = open("file.txt", "r+b")
# read 4 bytes
my_file_obj.read(4)
# truncate all remaining data
result = my_file_obj.truncate()
# wait for Enter key. 
# check file.txt. Right now it should contain 'ABCD'
input()
# truncate the file size to 3 bytes
result = my_file_obj.truncate(3)
# close the file
my_file_obj.close()
# now check file.txt again. Should contain 'ABC'

Това, което е важно да се отбележи тук е, че ако аргументът size е по-голям от действителния размер на файла, поведението на Python в този случай ще зависи от платформата. Според това възможностите включват файлът да остане непроменен, да се увеличи до определения размер, сякаш е запълнен с нула, или да се увеличи до определения размер с недефинирано ново съдържание.

Проверете дали файлът може да се записва

Методът writable() връща булево True или False, в зависимост от това дали файлът може да се записва или не:

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCDEFGHIJKLMNOPQRSTUVWXYZ:
# open a file for appending
my_file_obj = open("file.txt", "a")
# this file should be writable
result = my_file_obj.writable()
print(result)
# close the file
my_file_obj.close()
# now open the same file, for reading
my_file_obj = open("file.txt", "r")
# this time the file should not be writable
result = my_file_obj.writable()
print(result)
# close the file again
my_file_obj.close()
Output:
True
False

Пишете във файл

Методът write() записва определен низ във файл и също така връща цяло число, представляващо броя байтове, успешно записани във файла.

# say we have a file in our current directory
# called "file.txt", having the following contents:
# ABCDEFGHIJKLMNOPQRSTUVWXYZ:
# open a file for appending
my_file_obj = open("file.txt", "a")
# write 'Hello, World!' (append it) to the file
result = my_file_obj.write("Hello, World!")
print(result)
# close the file
my_file_obj.close()
# the file should now contain:
# "ABCDEFGHIJKLMNOPQRSTUVWXYZHello, World!"
Output:
13

Напишете поредица от низове във файл

Можем също да напишем поредица от низове във файл, използвайки метода writelines(). Забележка: не добавя разделителните знаци.

# open a file for writing
my_file_obj = open("file.txt", "w")
# list of lines to write to the file
lines = ["ABCD", "EFGH", "IJKL", "MNOP"]
# write the list of lines
my_file_obj.writelines(lines)
# close the file
my_file_obj.close()
# the file should now be created in your current directory
# and contain: "ABCDEFGHIJKLMNOP"

Надяваме се, че този малко дълъг преглед на файловете в Python е бил полезен. Ако е така, тогава целта му е постигната. Интернет е пълен с информация по тази тема, така че не забравяйте да го използвате, за да обогатите знанията си за файлове и най-добри практики, които да използвате, докато работите с тях в Python. Ще си благодарите по-късно. Едно малко усилие всеки ден води до много дълъг път.

Като се има предвид това, аз ви благодаря и очаквам с нетърпение „следващия“. Приятно кодиране! наздраве!

Дек е софтуерен инженер, ментор, писател и понякога дори учител. С повече от 12 години опит в софтуерното инженерство, сега той е истински защитник на езика за програмиране Python, докато страстта му е да помага на хората да изострят своите Python — и програмирането като цяло — умения. Можете да стигнете до Deck в Linkedin, Facebook, Twitter и Discord: Deck451#6188, както и да проследите писането му тук в Medium.

Повече съдържание в PlainEnglish.io. Регистрирайте се за нашия безплатен седмичен бюлетин. Следвайте ни в Twitter и LinkedIn. Вижте нашия Community Discord и се присъединете към нашия Talent Collective.