Zusammenfassung des zugehörigen Inhalts von Dateioperationen in Python (mit Beispielen)

Dieser Artikel bietet Ihnen eine Zusammenfassung relevanter Inhalte zu Dateioperationen in Python (mit Beispielen). Ich hoffe, dass er Ihnen als Referenz dienen wird.

1. Einführung in Dateioperationen

Wenn es um die Bedienung von Dateien geht, werden wir auf jeden Fall an Streams denken. Die Bedienung von Dateien in Python ist sehr einfach. Im Gegensatz zu anderen Sprachen wie Java, die über verschiedene Stream-Operationen verfügen, können wir eine Datei direkt mit der Open-Funktion öffnen und dann je nach Öffnungsart verschiedene Operationen ausführen , Die ausführbaren Vorgänge sind ebenfalls unterschiedlich: r, w, a, r+, w+, a+, rb, wb, ab, r+b, w+b, a+b usw.

Sehen wir uns zunächst einen Dateilesevorgang an:

In [2]: f = open(file='a.txt', mode='r', encoding='utf-8')

In [3]: f.read()
Out[3]: '每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'
In [4]:

Verwenden Sie die Funktion „Öffnen“, um die Datei zu öffnen und ein Dateiobjekt zurückzugeben Datei, die bearbeitet werden soll). Werfen wir einen Blick auf verschiedene Vorgänge an Dateien.

2. Mehrere Möglichkeiten, Dateien zu bedienen

(1) Schreibgeschützter Betrieb

Für den schreibgeschützten Betrieb geben Sie einfach den Modus als r an:

In [5]: f = open(file='a.txt', mode='r', encoding='utf-8')
 
In [6]: f.read()
Out[6]: '每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'
 
In [7]: f.readable()                # 判断文件是否可读
Out[7]: True
 
In [8]: f.writable()                # 判断文件是否可写
Out[8]: False                       # 此处是以只读模式打开的文件，所以返回False不可写
 
In [9]: f1 = open(file='单分支结构.eddx', mode='rb')        # 使用‘rb’可以打开存储为二进制的数据，图片、视频等
 
In [10]: f1.read(20)
Out[10]: b'PK\x03\x04\x14\x00\x08\x00\x08\x00mN\xe3H\xa9\x95\xb3\x9eW\x01'

(2) Nur-Schreibvorgang

mode='w'

                                                                             
In [13]: f = open(file='a.txt', mode='w', encoding='utf-8')                  
                                                                             
In [14]: f.read()                       # 此时尝试读取文件会报错                                            
---------------------------------------------------------------------------  
UnsupportedOperation                      Traceback (most recent call last)  
<ipython-input-14-571e9fb02258> in <module>                                  
----> 1 f.read()                                                             
                                                                             
UnsupportedOperation: not readable                                           
                                                                             
In [15]: f.write(&#39;葫芦娃&#39;)                                                      
Out[15]: 3                                                                   
                                                                             
In [16]: f.close()                                                           
                                                                             
In [17]: !cat a.txt                     # 此时查看文件之前那的内容已经被覆盖了                             
葫芦娃                                                                          
In [18]:

Wenn mode='w' zum Bearbeiten einer Datei verwendet wird, wird die Datei zuerst gelöscht Beim Öffnen der Datei wird der Inhalt dann entsprechend dem Vorgang in die Datei geschrieben. Der schreibgeschützte Modus weist die folgenden Eigenschaften auf:

• Wenn die Datei nicht vorhanden ist automatisch erstellt und dann wird die Datei für den Betrieb geöffnet

• Beim Öffnen einer Datei wird der Inhalt der Datei zuerst gelöscht und dann von Anfang an geschrieben

• Die Datei wird im schreibgeschützten Modus geöffnet und kann nicht gelesen werden

(3) Anhängevorgang

mode='a'

In [18]: f = open(file='a.txt', mode='a', encoding='utf-8')
 
In [19]: f.write('每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n')
Out[19]: 42
 
In [20]: f.close()
 
In [21]:
 
In [21]: !cat a.txt
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大
 
In [22]:

Betrieb im Anhängemodus:

• Datei öffnen Wenn die Datei nicht existiert, wird sie zuerst erstellt

• Beim Schreiben Inhalt in die Datei schreibt immer an das Ende der Datei, egal wo sich der Cursor befindet

• Geöffnete Dateien können nur geschrieben, nicht gelesen werden

(4) r+ Modus

r+ Modus ist erweiterter Lesevorgang, das heißt, Sie können lesen und schreiben:

In [22]: f = open(file='a.txt', mode='r+', encoding='utf-8')

In [23]: f.readable()
Out[23]: True

In [24]: f.writable()
Out[24]: True

In [25]: f.read()
Out[25]: '葫芦娃每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'

In [26]: f.write('\n哈哈哈哈哈哈哈')
Out[26]: 8

In [27]: f.close()

In [28]: !cat a.txt         # 查看写入的文件并没有异常
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大

哈哈哈哈哈哈哈
In [29]: f = open(file='a.txt', mode='r+', encoding='utf-8')

In [30]: f.seek(0, 2)       # seek可以调整光标位置
Out[30]: 153

In [31]: f.write('你的进步越来越大')
Out[31]: 8

In [32]: f.read()           # 先写后读会读出空字符
Out[32]: ''

In [33]:

Zusammenfassung: Der erweiterte Lesevorgang kann Dateien lesen und schreiben, aber die Reihenfolge muss sein, zuerst zu lesen und dann darauf zu schreiben. Wenn Sie zuerst lesen, dann schreiben und dann lesen, kann beim Abrufen eine leere Zeichenfolge gelesen werden

r+-Modus Bitte beachten Sie: Wenn der Inhalt gelesen wird, wird der Cursor beim Schreiben oder Bedienen von Dateien am Ende angezeigt >(5) W+- und A+-Modi

W+-Modus und A+-Modus sind in tatsächlichen Nutzungsszenarien schwieriger zu verwenden. Hier ist eine kurze Einführung:

w+: Erweiterter W-Modus, der Schreib- und Lesevorgänge ausführen kann. Wenn Sie jedoch wie bei R + zuerst lesen und dann schreiben, treten Fallstricke auf. Jedes Mal, wenn eine Datei geöffnet wird, wird die Datei zuerst gelöscht, sodass weniger Verwendungsszenarien auftreten

• a+: Ein Modus wurde erweitert, der auch Lese- und Schreibvorgänge ausführen kann, aber beim Schreiben kann nur bis zum Ende der Datei geschrieben werden
Egal wie Sie den Cursor bewegen , Sie können nur bis zum Ende der Datei schreiben
3. Dateioperationen Methoden

(1) Lesen und Schreiben von Dateien

Schreiben von Dateien

: hauptsächlich die Schreibmethode und die Writelines-Methode

Schreibmethode: Schreiben Sie einfach die Zeichenfolge direkt. Das obige Beispiel Verwendet auch die

• writelines-Methode: Die übergebenen Parameter müssen iterierbar sein (z. B. eine Liste und Tupel usw.)
Datei lesen

:

Lesemethode: Die Lesemethode empfängt einen Parameter vom Typ int, der angibt, wie viele Zeichen gleichzeitig gelesen werden sollen (die Sucheinheit ist Bytes). Vorausgesetzt, die Standardeinstellung ist, den gesamten Inhalt der Datei zu lesen

• readline-Methode: Eine Zeile der Datei lesen, die Datei ist sehr groß. Diese Methode ist sehr nützlich. Sie wird nicht gelesen die gesamte Datei auf einmal

• readlines-Methode: liest die gesamte Datei, teilt sie nach jeder Zeile in eine Liste auf und gibt diese Liste zurück

• In [34]: f = open(file='a.txt', mode='r', encoding='utf-8')
  # 葫芦娃每天坚持一点，
  # 每天努力一点，
  # 每天多思考一点，
  # 慢慢你会发现，
  # 你的进步越来越大
   
  # 哈哈哈哈哈哈哈你的进步越来越大
  In [35]: f.read(10)                 # 这里时一次读取10个字符
  Out[35]: '葫芦娃每天坚持一点，'
   
  In [36]: f.readline()
  Out[36]: '\n'
   
  In [37]: f.readline()               # 每次读取一行
  Out[37]: '每天努力一点，\n'
   
  In [38]: f.readlines()              # 返回的是一个列表
  Out[38]: ['每天多思考一点，\n', '慢慢你会发现，\n', '你的进步越来越大\n', '\n', '哈哈哈哈哈哈哈你的进步越来越大']
   
  In [39]:

  Der Unterschied zwischen readline (Dateihandle) und readlines

Das Dateihandle ist ein iterierbares Objekt. Bei jedem Schleifendurchlauf wird eine Zeile verwendet und beim Lesen der Datei nicht gelesen Sie alle auf einmal

Das von readlines zurückgegebene Ergebnis ist eine Liste. Es liest den Inhalt der gesamten Datei auf einmal und gibt eine Liste zurück. Bei der Verarbeitung großer Dateien werden viele Ressourcen verbraucht.

Sie können auch eine Schleife verwenden, um das Dateihandle zu durchlaufen und den Inhalt der Datei auszugeben:

In [39]: f.seek(0)
Out[39]: 0

In [40]: for line in f:
    ...:     print(line.strip())
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大

哈哈哈哈哈哈哈你的进步越来越大

In [41]:

(2) Andere Methoden der Dateioperation

close : Schließen Sie die Datei

• lesbar: Bestimmen Sie, ob die Datei lesbar ist

• suchen: Bewegen Sie den Cursor und empfangen Sie zwei Daten die Offset-Position (Bewegungseinheit) ist Byte. Wenn es sich also um den chinesischen Teil von UTF-8 handelt, muss er ein Vielfaches von 3 sein), und der zweite Parameter gibt den Offset von dieser Position an (0, stellt den Anfang dar). 1 stellt die aktuelle Position dar, 2 stellt das Ende dar)

• seekable：判断当前文件的光标是否可移动

• tell：返回当前光标所在的位置

• truncate：截断数据（谨慎操作），默认截断光标后所有字符

• writable：判断文件是否可写

（3）打开文件的另一种方式

在打开一个文件后，要记得在文件使用结束狗使用close方法关闭文件句柄，但有时在中间进行大量的操作后可能会忘了关闭，下面介绍的这种方法可以不用自己手动关闭文件了，他会在您操作解说后（代码块的语句执行完毕）自动关闭文件句柄，这种方法就是使用context上下文管理，使用with语句实现：

In [43]: with open('a.txt', mode='r', encoding='utf-8') as f:   # 使用with管理上下文，最后退出时会自己执行close动作
    ...:     for line in f:
    ...:         print(line.strip())
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大
哈哈哈哈哈哈哈你的进步越来越大

Das obige ist der detaillierte Inhalt vonZusammenfassung des zugehörigen Inhalts von Dateioperationen in Python (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!