Làm cách nào để đọc dữ liệu byte trong Python?

Mô-đun này cung cấp các phương tiện chính của Python để xử lý các loại I/O khác nhau. Có ba loại I/O chính. I/O văn bản, I/O nhị phân và I/O thô. Đây là những danh mục chung và có thể sử dụng nhiều kho lưu trữ dự phòng khác nhau cho mỗi danh mục đó. Một đối tượng cụ thể thuộc bất kỳ loại nào trong số này được gọi là. Các thuật ngữ phổ biến khác là luồng và đối tượng giống như tệp

Không phụ thuộc vào danh mục của nó, mỗi đối tượng luồng cụ thể cũng sẽ có các khả năng khác nhau. nó có thể là chỉ đọc, chỉ ghi hoặc đọc-ghi. Nó cũng có thể cho phép truy cập ngẫu nhiên tùy ý (tìm kiếm tiến hoặc lùi tới bất kỳ vị trí nào) hoặc chỉ truy cập tuần tự (ví dụ: trong trường hợp ổ cắm hoặc đường ống)

Tất cả các luồng đều cẩn thận về loại dữ liệu bạn cung cấp cho họ. Ví dụ: đưa một đối tượng vào phương thức

f = io.StringIO("some initial text data")
3 của luồng nhị phân sẽ tăng. Vì vậy, sẽ cung cấp một đối tượng cho phương thức
f = io.StringIO("some initial text data")
3 của luồng văn bản

Đã thay đổi trong phiên bản 3. 3. Các hoạt động từng tăng giờ tăng , vì hiện là bí danh của.

Nhập/xuất văn bản

Văn bản I/O mong đợi và tạo ra các đối tượng. Điều này có nghĩa là bất cứ khi nào kho lưu trữ sao lưu được tạo bằng byte nguyên bản (chẳng hạn như trong trường hợp tệp), việc mã hóa và giải mã dữ liệu được thực hiện một cách minh bạch cũng như dịch tùy chọn các ký tự xuống dòng dành riêng cho nền tảng

Cách dễ nhất để tạo luồng văn bản là với , tùy chọn chỉ định mã hóa

f = open("myfile.txt", "r", encoding="utf-8")

Dòng văn bản trong bộ nhớ cũng có sẵn dưới dạng đối tượng

f = io.StringIO("some initial text data")

API luồng văn bản được mô tả chi tiết trong tài liệu của

I/O nhị phân

I/O nhị phân (còn gọi là I/O được đệm) mong đợi và tạo ra các đối tượng. Không mã hóa, giải mã hoặc dịch dòng mới nào được thực hiện. Loại luồng này có thể được sử dụng cho tất cả các loại dữ liệu phi văn bản và cả khi muốn kiểm soát thủ công việc xử lý dữ liệu văn bản

Cách dễ nhất để tạo luồng nhị phân là với

f = open("myfile.jpg", "rb")
7 trong chuỗi chế độ

f = open("myfile.jpg", "rb")

Luồng nhị phân trong bộ nhớ cũng có sẵn dưới dạng đối tượng

f = io.BytesIO(b"some initial binary data: \x00\x01")

API luồng nhị phân được mô tả chi tiết trong tài liệu của

Các mô-đun thư viện khác có thể cung cấp các cách bổ sung để tạo văn bản hoặc luồng nhị phân. Xem ví dụ

I/O thô

I/O thô (còn được gọi là I/O không có bộ đệm) thường được sử dụng làm khối xây dựng cấp thấp cho các luồng văn bản và nhị phân; . Tuy nhiên, bạn có thể tạo luồng thô bằng cách mở tệp ở chế độ nhị phân đã tắt bộ đệm

f = open("myfile.jpg", "rb", buffering=0)

API luồng thô được mô tả chi tiết trong tài liệu của

Mã hóa văn bản

Mã hóa mặc định của và là ngôn ngữ cụ thể ()

Tuy nhiên, nhiều nhà phát triển quên chỉ định mã hóa khi mở tệp văn bản được mã hóa bằng UTF-8 (e. g. JSON, TOML, Markdown, v.v…) vì hầu hết các nền tảng Unix đều sử dụng ngôn ngữ UTF-8 theo mặc định. Điều này gây ra lỗi vì mã hóa ngôn ngữ không phải là UTF-8 đối với hầu hết người dùng Windows. Ví dụ

________số 8_______

Theo đó, bạn nên chỉ định mã hóa rõ ràng khi mở tệp văn bản. Nếu bạn muốn sử dụng UTF-8, hãy vượt qua

f = io.BytesIO(b"some initial binary data: \x00\x01")
5. Để sử dụng mã hóa ngôn ngữ hiện tại,
f = io.BytesIO(b"some initial binary data: \x00\x01")
6 được hỗ trợ kể từ Python 3. 10

Xem thêm

Chế độ Python UTF-8 có thể được sử dụng để thay đổi mã hóa mặc định thành UTF-8 từ mã hóa dành riêng cho ngôn ngữ

PEP 686

Trăn 3. 15 sẽ làm mặc định

Mã hóa chọn tham giaCảnh báo

Mới trong phiên bản 3. 10. Xem PEP 597 để biết thêm chi tiết.

Để tìm nơi mã hóa ngôn ngữ mặc định được sử dụng, bạn có thể bật tùy chọn dòng lệnh

f = io.BytesIO(b"some initial binary data: \x00\x01")
7 hoặc đặt biến môi trường, biến này sẽ phát ra khi mã hóa mặc định được sử dụng

Nếu bạn đang cung cấp một API sử dụng hoặc và chuyển

f = open("myfile.jpg", "rb", buffering=0)
2 làm tham số, thì bạn có thể sử dụng để những người gọi API sẽ phát ra một nếu họ không chuyển một
f = open("myfile.jpg", "rb", buffering=0)
5. Tuy nhiên, hãy cân nhắc sử dụng UTF-8 theo mặc định (tôi. e.
f = io.BytesIO(b"some initial binary data: \x00\x01")
5) cho các API mới

Giao diện mô-đun cấp cao

io. DEFAULT_BUFFER_SIZE

Một int chứa kích thước bộ đệm mặc định được sử dụng bởi các lớp I/O được đệm của mô-đun. sử dụng blksize của tệp (như thu được bởi ) nếu có thể

io. mở(tệp , chế độ='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Đây là bí danh cho hàm dựng sẵn

Hàm này tạo ra một

# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
0 với các đối số
# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
1,
# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
2 và
# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
3. Các đối số
# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
2 và
# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
3 có thể đã được sửa đổi hoặc suy ra từ cuộc gọi ban đầu

io. open_code(đường dẫn)

Mở tệp được cung cấp với chế độ

# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
6. Hàm này nên được sử dụng khi mục đích là coi nội dung là mã thực thi

# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
1 phải là một và là một đường dẫn tuyệt đối

Hành vi của chức năng này có thể bị ghi đè bởi một cuộc gọi trước đó đến. Tuy nhiên, giả sử rằng

# May not work on Windows when non-ASCII characters in the file.
with open("README.md") as f:
    long_description = f.read()
1 là một và là một đường dẫn tuyệt đối, thì
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
2 phải luôn hành xử giống như
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
3. Ghi đè hành vi nhằm mục đích xác thực bổ sung hoặc tiền xử lý tệp

Mới trong phiên bản 3. 8

io. mã hóa văn bản(mã hóa , cấp độ ngăn xếp=2, /)

Đây là một hàm trợ giúp cho các hàm có thể gọi được sử dụng hoặc và có tham số

f = open("myfile.jpg", "rb", buffering=0)
2

Hàm này trả về mã hóa nếu nó không phải là

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7. Mặt khác, nó trả về
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
8 hoặc
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
9 tùy thuộc vào

Hàm này phát ra if là true và mã hóa là

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7. stacklevel chỉ định nơi phát ra cảnh báo. Ví dụ

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()

Trong ví dụ này, an được phát ra cho người gọi của

with open('spam.txt', 'w') as file:
    file.write('Spam and eggs!')
4

Xem để biết thêm thông tin

Mới trong phiên bản 3. 10

Đã thay đổi trong phiên bản 3. 11. trả về “utf-8” khi chế độ UTF-8 được bật và mã hóa là

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7.

ngoại lệ io. BlockingIOError

Đây là bí danh tương thích cho ngoại lệ dựng sẵn

ngoại lệ io. Hoạt động không được hỗ trợ

Một ngoại lệ kế thừa và được đưa ra khi một thao tác không được hỗ trợ được gọi trên luồng

Xem thêm

chứa các luồng IO tiêu chuẩn. , , và

Phân cấp lớp

Việc triển khai các luồng I/O được tổ chức dưới dạng phân cấp các lớp. Đầu tiên (ABC), được sử dụng để chỉ định các loại luồng khác nhau, sau đó là các lớp cụ thể cung cấp triển khai luồng tiêu chuẩn

Ghi chú

Các lớp cơ sở trừu tượng cũng cung cấp các triển khai mặc định của một số phương thức để giúp triển khai các lớp luồng cụ thể. Ví dụ: cung cấp các triển khai chưa được tối ưu hóa của

>>> b = io.BytesIO(b"abcdef")
>>> view = b.getbuffer()
>>> view[2:4] = b"56"
>>> b.getvalue()
b'ab56ef'
5 và

Ở trên cùng của hệ thống phân cấp I/O là lớp cơ sở trừu tượng. Nó định nghĩa giao diện cơ bản cho một luồng. Tuy nhiên, lưu ý rằng không có sự tách biệt giữa đọc và ghi vào luồng;

ABC mở rộng. Nó xử lý việc đọc và ghi byte vào luồng. các lớp con để cung cấp giao diện cho các tệp trong hệ thống tệp của máy

ABC mở rộng. Nó xử lý bộ đệm trên luồng nhị phân thô (). Các lớp con của nó, , và đệm các luồng nhị phân thô có thể ghi, có thể đọc và cả có thể đọc và ghi tương ứng. cung cấp giao diện đệm cho các luồng có thể tìm kiếm. Một lớp con khác, , là một luồng byte trong bộ nhớ

ABC mở rộng. Nó xử lý các luồng có byte đại diện cho văn bản và xử lý mã hóa và giải mã đến và từ các chuỗi. , mở rộng , là giao diện văn bản được đệm cho luồng thô được đệm (). Cuối cùng, là một luồng trong bộ nhớ cho văn bản

Tên đối số không phải là một phần của thông số kỹ thuật và chỉ các đối số của được dự định sử dụng làm đối số từ khóa

Bảng sau đây tóm tắt các ABC do mô-đun cung cấp

ABC

kế thừa

Phương pháp sơ khai

Các phương thức và thuộc tính của Mixin

f = io.StringIO("some initial text data")
11,
f = io.StringIO("some initial text data")
12 và
f = io.StringIO("some initial text data")
13

_________14, _________15, _______0_______16, _______0_______17, _______ 18, _______ 19, _______ 20, _______ 21, _______22, _______23, _______24, _______25, _______26, _______ 27 và _______ 28

f = io.StringIO("some initial text data")
31 và
f = io.StringIO("some initial text data")
32

Các phương thức kế thừa,

f = io.StringIO("some initial text data")
34 và
f = io.StringIO("some initial text data")
35

f = io.StringIO("some initial text data")
38,
f = io.StringIO("some initial text data")
34,
f = io.StringIO("some initial text data")
40 và
f = io.StringIO("some initial text data")
32

Các phương thức kế thừa,

f = io.StringIO("some initial text data")
31 và
f = io.StringIO("some initial text data")
44

f = io.StringIO("some initial text data")
38,
f = io.StringIO("some initial text data")
34,
f = io.StringIO("some initial text data")
23 và
f = io.StringIO("some initial text data")
32

Các phương thức kế thừa,

f = open("myfile.jpg", "rb", buffering=0)
5,
f = io.StringIO("some initial text data")
53 và
f = io.StringIO("some initial text data")
54

Các lớp cơ sở I/O

lớp io. IOBase

Lớp cơ sở trừu tượng cho tất cả các lớp I/O

Lớp này cung cấp các triển khai trừu tượng trống cho nhiều phương thức mà các lớp dẫn xuất có thể ghi đè một cách có chọn lọc;

Mặc dù không khai báo

f = io.StringIO("some initial text data")
56 hoặc
f = io.StringIO("some initial text data")
3 vì chữ ký của chúng sẽ khác nhau, việc triển khai và ứng dụng khách nên coi các phương thức đó là một phần của giao diện. Ngoài ra, việc triển khai có thể tăng (hoặc ) khi các hoạt động mà chúng không hỗ trợ được gọi

Loại cơ bản được sử dụng cho dữ liệu nhị phân được đọc từ hoặc ghi vào tệp là. Khác cũng được chấp nhận làm đối số phương thức. Các lớp văn bản I/O hoạt động với dữ liệu

Lưu ý rằng việc gọi bất kỳ phương thức nào (thậm chí là yêu cầu) trên luồng đã đóng là không xác định. Việc triển khai có thể tăng lên trong trường hợp này

(và các lớp con của nó) hỗ trợ giao thức trình lặp, nghĩa là một đối tượng có thể được lặp lại để tạo ra các dòng trong luồng. Các dòng được xác định hơi khác nhau tùy thuộc vào việc luồng là luồng nhị phân (tạo byte) hay luồng văn bản (tạo chuỗi ký tự). Xem bên dưới

cũng là một trình quản lý bối cảnh và do đó hỗ trợ tuyên bố. Trong ví dụ này, tệp bị đóng sau khi hoàn thành bộ câu lệnh của câu lệnh

f = io.StringIO("some initial text data")
67—ngay cả khi có ngoại lệ xảy ra

with open('spam.txt', 'w') as file:
    file.write('Spam and eggs!')

cung cấp các thuộc tính và phương thức dữ liệu này

đóng()

Xóa và đóng luồng này. Phương pháp này không có tác dụng nếu tệp đã được đóng. Sau khi đóng tệp, bất kỳ thao tác nào trên tệp (e. g. đọc hoặc viết) sẽ nâng cao

Để thuận tiện, nó được phép gọi phương thức này nhiều lần;

đóng cửa

f = io.StringIO("some initial text data")
71 nếu luồng bị đóng

fileno()

Trả về bộ mô tả tệp cơ bản (một số nguyên) của luồng nếu nó tồn tại. An được nâng lên nếu đối tượng IO không sử dụng bộ mô tả tệp

xả()

Xóa bộ đệm ghi của luồng nếu có. Điều này không làm gì đối với các luồng chỉ đọc và không chặn

isatty()

Trả lại

f = io.StringIO("some initial text data")
71 nếu luồng tương tác (i. e. , được kết nối với thiết bị đầu cuối/thiết bị tty)

có thể đọc được()

Trả lại

f = io.StringIO("some initial text data")
71 nếu luồng có thể được đọc từ. Nếu
f = io.StringIO("some initial text data")
75,
f = io.StringIO("some initial text data")
56 sẽ tăng

đường đọc(kích thước=- 1, /)

Đọc và trả lại một dòng từ luồng. Nếu kích thước được chỉ định, hầu hết các byte kích thước sẽ được đọc

Dấu kết thúc dòng luôn là

f = io.StringIO("some initial text data")
78 đối với các tệp nhị phân;

đường dẫn(gợi ý=- 1, /)

Đọc và trả về danh sách các dòng từ luồng. gợi ý có thể được chỉ định để kiểm soát số lượng dòng đọc. sẽ không còn dòng nào được đọc nếu tổng kích thước (tính bằng byte/ký tự) của tất cả các dòng cho đến nay vượt quá gợi ý

các giá trị gợi ý từ

f = io.StringIO("some initial text data")
80 trở xuống, cũng như
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7, được coi là không có gợi ý

Lưu ý rằng đã có thể lặp lại trên các đối tượng tệp bằng cách sử dụng

f = io.StringIO("some initial text data")
82 mà không cần gọi
f = io.StringIO("some initial text data")
83

tìm kiếm( , từ đâu=SEEK_SET, /)

Thay đổi vị trí luồng thành phần bù byte đã cho. offset được diễn giải tương ứng với vị trí được chỉ định bởi từ đâu. Giá trị mặc định cho từ đâu là

f = io.StringIO("some initial text data")
84. Các giá trị cho từ đâu là

  • f = io.StringIO("some initial text data")
    
    84 hoặc
    f = io.StringIO("some initial text data")
    
    80 – bắt đầu luồng (mặc định);

  • f = io.StringIO("some initial text data")
    
    87 hoặc
    f = io.StringIO("some initial text data")
    
    88 – vị trí luồng hiện tại;

  • f = io.StringIO("some initial text data")
    
    89 hoặc
    f = io.StringIO("some initial text data")
    
    90 – kết thúc luồng;

Trả lại vị trí tuyệt đối mới

Mới trong phiên bản 3. 1. Hằng số

f = io.StringIO("some initial text data")
91.

Mới trong phiên bản 3. 3. Một số hệ điều hành có thể hỗ trợ các giá trị bổ sung, như

f = io.StringIO("some initial text data")
92 hoặc
f = io.StringIO("some initial text data")
93. Các giá trị hợp lệ cho một tệp có thể phụ thuộc vào việc nó được mở ở chế độ văn bản hoặc nhị phân.

có thể tìm kiếm()

Trả lại

f = io.StringIO("some initial text data")
71 nếu luồng hỗ trợ truy cập ngẫu nhiên. Nếu
f = io.StringIO("some initial text data")
75, , và sẽ tăng

kể()

Trả lại vị trí luồng hiện tại

cắt ngắn(kích thước=Không có, /)

Thay đổi kích thước luồng thành kích thước đã cho theo byte (hoặc vị trí hiện tại nếu kích thước không được chỉ định). Vị trí luồng hiện tại không thay đổi. Việc thay đổi kích thước này có thể mở rộng hoặc giảm kích thước tệp hiện tại. Trong trường hợp mở rộng, nội dung của vùng tệp mới phụ thuộc vào nền tảng (trên hầu hết các hệ thống, các byte bổ sung không được điền). Kích thước tệp mới được trả về

Đã thay đổi trong phiên bản 3. 5. Windows hiện sẽ không lấp đầy các tệp khi mở rộng.

có thể ghi()

Trả lại

f = io.StringIO("some initial text data")
71 nếu luồng hỗ trợ viết. Nếu
f = io.StringIO("some initial text data")
75,
f = io.StringIO("some initial text data")
3 và sẽ tăng

writelines(lines , /)

Viết danh sách các dòng vào luồng. Dấu phân cách dòng không được thêm vào, do đó, thông thường mỗi dòng được cung cấp sẽ có dấu phân cách dòng ở cuối

__del__()

Chuẩn bị cho việc phá hủy đối tượng. cung cấp một triển khai mặc định của phương thức này để gọi phương thức của cá thể

lớp io. rawIOBase

Lớp cơ sở cho luồng nhị phân thô. Nó kế thừa

Luồng nhị phân thô thường cung cấp quyền truy cập cấp thấp vào API hoặc thiết bị HĐH cơ bản và không cố gắng đóng gói nó trong nguyên hàm cấp cao (chức năng này được thực hiện ở cấp cao hơn trong luồng nhị phân và luồng văn bản được đệm, được mô tả sau trong

cung cấp các phương thức này ngoài các phương thức từ

đọc(kích thước=- 1, /)

Đọc đến kích thước byte từ đối tượng và trả lại chúng. Để thuận tiện, nếu kích thước không được chỉ định hoặc -1, tất cả các byte cho đến khi EOF được trả về. Mặt khác, chỉ có một cuộc gọi hệ thống được thực hiện. Có thể trả về ít byte kích thước hơn nếu lệnh gọi hệ điều hành trả về ít byte kích thước hơn

Nếu 0 byte được trả về và kích thước không phải là 0, điều này cho biết kết thúc tệp. Nếu đối tượng ở chế độ non-blocking và không có byte nào, thì trả về

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7

Việc triển khai mặc định trì hoãn và

đọc hết()

Đọc và trả về tất cả các byte từ luồng cho đến EOF, sử dụng nhiều lệnh gọi tới luồng nếu cần

đọc(b , /)

Đọc byte vào b được phân bổ trước, có thể ghi và trả về số byte đã đọc. Ví dụ, b có thể là một. Nếu đối tượng ở chế độ non-blocking và không có byte nào, thì trả về

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7

viết(b , /)

Viết b đã cho vào luồng thô bên dưới và trả về số byte đã ghi. Giá trị này có thể nhỏ hơn độ dài của b tính bằng byte, tùy thuộc vào chi tiết cụ thể của luồng thô bên dưới và đặc biệt nếu luồng đó ở chế độ không chặn.

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7 được trả về nếu luồng thô được đặt không bị chặn và không có byte nào có thể dễ dàng ghi vào luồng đó. Người gọi có thể giải phóng hoặc thay đổi b sau khi phương thức này trả về, vì vậy việc triển khai chỉ nên truy cập b trong khi gọi phương thức

lớp io. BufferedIOBase

Lớp cơ sở cho các luồng nhị phân hỗ trợ một số loại bộ đệm. Nó kế thừa

Sự khác biệt chính với các phương thức đó và sẽ cố gắng (tương ứng) để đọc càng nhiều đầu vào theo yêu cầu hoặc tiêu thụ tất cả đầu ra đã cho, với chi phí có thể là thực hiện nhiều hơn một cuộc gọi hệ thống

Ngoài ra, các phương pháp đó có thể tăng nếu luồng thô cơ bản ở chế độ không chặn và không thể lấy hoặc cung cấp đủ dữ liệu;

Bên cạnh đó, phương pháp này không có triển khai mặc định trì hoãn

Một triển khai điển hình không nên kế thừa từ một triển khai, mà nên bao bọc một, thích và làm

cung cấp hoặc ghi đè các thuộc tính và phương thức dữ liệu này ngoài các thuộc tính và phương thức từ

thô

Luồng thô cơ bản (một ví dụ) xử lý. Đây không phải là một phần của API và có thể không tồn tại trên một số triển khai

tách()

Tách luồng thô bên dưới khỏi bộ đệm và trả lại

Sau khi luồng thô đã được tách ra, bộ đệm ở trạng thái không sử dụng được

Một số bộ đệm, như , không có khái niệm về một luồng thô duy nhất để trả về từ phương thức này. Họ nuôi

Mới trong phiên bản 3. 1

đọc(kích thước=- 1, /)

Đọc và trả về kích thước byte. Nếu đối số bị bỏ qua,

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7 hoặc phủ định, thì dữ liệu sẽ được đọc và trả về cho đến khi đạt đến EOF. Một đối tượng trống được trả về nếu luồng đã ở EOF

Nếu đối số là dương và luồng thô bên dưới không tương tác, thì nhiều lần đọc thô có thể được thực hiện để đáp ứng số lượng byte (trừ khi đạt đến EOF trước). Nhưng đối với các luồng thô tương tác, nhiều nhất một lần đọc thô sẽ được đưa ra và một kết quả ngắn không có nghĩa là EOF sắp xảy ra

A được nâng lên nếu luồng thô cơ bản ở chế độ không chặn và không có sẵn dữ liệu vào lúc này

read1(size=- 1, /)

Đọc và trả về tối đa byte kích thước, với tối đa một lệnh gọi đến phương thức (hoặc ) của luồng thô bên dưới. Điều này có thể hữu ích nếu bạn đang triển khai bộ đệm của riêng mình trên một đối tượng

Nếu kích thước là

f = open("myfile.jpg", "rb")
43 (mặc định), một số byte tùy ý được trả về (nhiều hơn 0 trừ khi đạt đến EOF)

đọc(b , /)

Đọc byte vào b được phân bổ trước, có thể ghi và trả về số byte đã đọc. Ví dụ, b có thể là một

Giống như , nhiều lần đọc có thể được cấp cho luồng thô bên dưới, trừ khi luồng sau là tương tác

A được nâng lên nếu luồng thô cơ bản ở chế độ không chặn và không có sẵn dữ liệu vào lúc này

readinto1(b , /)

Đọc các byte thành một b được phân bổ trước, có thể ghi, sử dụng tối đa một lệnh gọi đến phương thức (hoặc ) của luồng thô bên dưới. Trả về số byte đã đọc

A được nâng lên nếu luồng thô cơ bản ở chế độ không chặn và không có sẵn dữ liệu vào lúc này

Mới trong phiên bản 3. 5

viết(b , /)

Viết , b đã cho và trả về số byte đã ghi (luôn bằng độ dài của b tính theo byte, vì nếu ghi không thành công, sẽ tăng lên). Tùy thuộc vào việc triển khai thực tế, các byte này có thể dễ dàng được ghi vào luồng bên dưới hoặc được giữ trong bộ đệm vì lý do hiệu suất và độ trễ

Khi ở chế độ không chặn, a được nâng lên nếu dữ liệu cần được ghi vào luồng thô nhưng nó không thể chấp nhận tất cả dữ liệu mà không chặn

Người gọi có thể giải phóng hoặc thay đổi b sau khi phương thức này trả về, vì vậy việc triển khai chỉ nên truy cập b trong khi gọi phương thức

I/O tệp thô

lớp io. TệpIO(tên , chế độ='r', closefd=True, opener=None)

Luồng nhị phân thô đại diện cho tệp cấp hệ điều hành chứa dữ liệu byte. Nó kế thừa

Tên có thể là một trong hai điều

  • một chuỗi ký tự hoặc đối tượng đại diện cho đường dẫn đến tệp sẽ được mở. Trong trường hợp này, closefd phải là

    f = io.StringIO("some initial text data")
    
    71 (mặc định) nếu không sẽ xảy ra lỗi

  • một số nguyên biểu thị số lượng bộ mô tả tệp cấp hệ điều hành hiện có mà đối tượng kết quả sẽ cấp quyền truy cập. Khi đối tượng FileIO bị đóng, fd này cũng sẽ bị đóng, trừ khi closefd được đặt thành

    f = io.StringIO("some initial text data")
    
    75

Chế độ có thể là

f = open("myfile.jpg", "rb")
57,
f = open("myfile.jpg", "rb")
58,
f = open("myfile.jpg", "rb")
59 hoặc
f = open("myfile.jpg", "rb")
60 để đọc (mặc định), viết, tạo độc quyền hoặc thêm vào. Tệp sẽ được tạo nếu nó không tồn tại khi được mở để ghi hoặc nối thêm; . sẽ được nâng lên nếu nó đã tồn tại khi được mở để tạo. Mở một tệp để tạo có nghĩa là viết, vì vậy chế độ này hoạt động theo cách tương tự như
f = open("myfile.jpg", "rb")
58. Thêm một
f = open("myfile.jpg", "rb")
63 vào chế độ để cho phép đọc và ghi đồng thời

Các phương thức

f = io.StringIO("some initial text data")
56 (khi được gọi với đối số khẳng định),
>>> b = io.BytesIO(b"abcdef")
>>> view = b.getbuffer()
>>> view[2:4] = b"56"
>>> b.getvalue()
b'ab56ef'
5 và
f = io.StringIO("some initial text data")
3 trong lớp này sẽ chỉ thực hiện một lệnh gọi hệ thống

Có thể sử dụng công cụ mở tùy chỉnh bằng cách chuyển một công cụ mở có thể gọi được. Bộ mô tả tệp cơ bản cho đối tượng tệp sau đó được lấy bằng cách gọi opener với (tên, cờ). công cụ mở phải trả về một bộ mô tả tệp đang mở (việc chuyển dưới dạng công cụ mở dẫn đến chức năng tương tự như chuyển

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7)

Tệp mới được tạo là

Xem chức năng tích hợp để biết các ví dụ về cách sử dụng tham số mở

Đã thay đổi trong phiên bản 3. 3. Tham số mở đã được thêm vào. Chế độ

f = open("myfile.jpg", "rb")
59 đã được thêm vào.

Đã thay đổi trong phiên bản 3. 4. Tệp hiện không thể kế thừa.

cung cấp các thuộc tính dữ liệu này ngoài các thuộc tính từ và

chế độ

Chế độ như được đưa ra trong hàm tạo

tên

tên tập tin. Đây là bộ mô tả tệp của tệp khi không có tên được đặt trong hàm tạo

Luồng đệm

Luồng I/O đệm cung cấp giao diện cấp cao hơn cho thiết bị I/O so với I/O thô

lớp io. BytesIO(initial_byte=b)

Luồng nhị phân sử dụng bộ đệm byte trong bộ nhớ. Nó kế thừa. Bộ đệm bị loại bỏ khi phương thức được gọi

Đối số tùy chọn initial_bytes là đối số chứa dữ liệu ban đầu

cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ và

getbuffer()

Trả về chế độ xem có thể đọc và ghi đối với nội dung của bộ đệm mà không cần sao chép chúng. Ngoài ra, việc thay đổi chế độ xem sẽ cập nhật rõ ràng nội dung của bộ đệm

>>> b = io.BytesIO(b"abcdef")
>>> view = b.getbuffer()
>>> view[2:4] = b"56"
>>> b.getvalue()
b'ab56ef'

Ghi chú

Miễn là chế độ xem tồn tại, đối tượng không thể thay đổi kích thước hoặc đóng

Mới trong phiên bản 3. 2

nhận giá trị()

Return chứa toàn bộ nội dung của bộ đệm

read1(size=- 1, /)

Trong , điều này giống như

Đã thay đổi trong phiên bản 3. 7. Đối số kích thước hiện là tùy chọn.

readinto1(b , /)

Trong , điều này giống như

Mới trong phiên bản 3. 5

lớp io. BufferedReader(raw , buffer_size=DEFAULT_BUFFER_SIZE)

Luồng nhị phân được đệm cung cấp quyền truy cập cấp cao hơn vào luồng nhị phân thô có thể đọc được, không thể tìm kiếm được. Nó kế thừa

Khi đọc dữ liệu từ đối tượng này, một lượng dữ liệu lớn hơn có thể được yêu cầu từ luồng thô bên dưới và được lưu trong bộ đệm bên trong. Dữ liệu được đệm sau đó có thể được trả về trực tiếp trong các lần đọc tiếp theo

Hàm tạo tạo một cho luồng thô có thể đọc được và buffer_size. Nếu buffer_size bị bỏ qua, được sử dụng

cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ và

nhìn trộm(kích thước=0, /)

Trả về byte từ luồng mà không tăng vị trí. Tối đa một lần đọc trên luồng thô được thực hiện để đáp ứng cuộc gọi. Số byte được trả về có thể ít hơn hoặc nhiều hơn yêu cầu

đọc(kích thước=- 1, /)

Đọc và trả về các byte kích thước hoặc nếu kích thước không được cung cấp hoặc âm, cho đến khi EOF hoặc nếu lệnh gọi đọc sẽ chặn ở chế độ không chặn

read1(size=- 1, /)

Đọc và trả về kích thước byte chỉ với một lệnh gọi trên luồng thô. Nếu ít nhất một byte được lưu vào bộ đệm, thì chỉ các byte được lưu vào bộ đệm được trả về. Mặt khác, một cuộc gọi đọc luồng thô được thực hiện

Đã thay đổi trong phiên bản 3. 7. Đối số kích thước hiện là tùy chọn.

lớp io. BufferedWriter(raw , buffer_size=DEFAULT_BUFFER_SIZE)

Luồng nhị phân được đệm cung cấp quyền truy cập cấp cao hơn vào luồng nhị phân thô có thể ghi, không thể tìm kiếm. Nó kế thừa

Khi ghi vào đối tượng này, dữ liệu thường được đặt vào bộ đệm bên trong. Bộ đệm sẽ được ghi ra đối tượng bên dưới trong các điều kiện khác nhau, bao gồm

  • khi bộ đệm trở nên quá nhỏ đối với tất cả dữ liệu đang chờ xử lý;

  • khi nào được gọi;

  • khi một

    f = io.StringIO("some initial text data")
    
    96 được yêu cầu (đối với đồ vật);

  • khi đối tượng bị đóng hoặc bị hủy

Hàm tạo tạo một luồng thô có thể ghi cho trước. Nếu buffer_size không được cung cấp, nó sẽ mặc định là

cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ và

xả()

Buộc các byte được giữ trong bộ đệm vào luồng thô. A nên được nâng lên nếu luồng thô chặn

viết(b , /)

Viết , b và trả về số byte đã ghi. Khi ở chế độ không chặn, a được nâng lên nếu bộ đệm cần được ghi nhưng luồng thô chặn

lớp io. BufferedRandom(raw , buffer_size=DEFAULT_BUFFER_SIZE)

Luồng nhị phân được đệm cung cấp quyền truy cập cấp cao hơn vào luồng nhị phân thô có thể tìm kiếm. Nó kế thừa và

Hàm tạo tạo trình đọc và ghi cho luồng thô có thể tìm kiếm, được đưa ra trong đối số đầu tiên. Nếu buffer_size bị bỏ qua, nó sẽ mặc định là

có khả năng của bất cứ điều gì hoặc có thể làm. Ngoài ra,

f = io.StringIO("some initial text data")
96 và
f = io.StringIO("some initial text data")
97 được đảm bảo thực hiện

lớp io. BufferedRWPair(người đọc , người viết, buffer_size=DEFAULT_BUFFER_SIZE, /)

Luồng nhị phân được đệm cung cấp quyền truy cập cấp cao hơn vào hai luồng nhị phân thô không thể tìm kiếm—một luồng có thể đọc được, luồng còn lại có thể ghi. Nó kế thừa

người đọc và người viết là các đối tượng có thể đọc và ghi tương ứng. Nếu buffer_size bị bỏ qua, nó sẽ mặc định là

thực hiện tất cả các phương thức của ngoại trừ , điều này làm tăng

Cảnh báo

không cố gắng đồng bộ hóa quyền truy cập vào các luồng thô cơ bản của nó. Bạn không nên chuyển nó cùng một đối tượng là người đọc và người viết;

Nhập/xuất văn bản

lớp io. TextIOBase

Lớp cơ sở cho luồng văn bản. Lớp này cung cấp giao diện dựa trên ký tự và dòng để truyền I/O. Nó kế thừa

cung cấp hoặc ghi đè các thuộc tính và phương thức dữ liệu này ngoài các thuộc tính và phương thức từ

mã hóa

Tên của mã hóa được sử dụng để giải mã byte của luồng thành chuỗi và để mã hóa chuỗi thành byte

lỗi

Cài đặt lỗi của bộ giải mã hoặc bộ mã hóa

dòng mới

Một chuỗi, một bộ chuỗi hoặc

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7, cho biết các dòng mới được dịch cho đến nay. Tùy thuộc vào việc triển khai và các cờ khởi tạo ban đầu, điều này có thể không khả dụng

đệm

Bộ đệm nhị phân bên dưới (một ví dụ) xử lý. Đây không phải là một phần của API và có thể không tồn tại trong một số triển khai

tách()

Tách bộ đệm nhị phân cơ bản khỏi và trả lại

Sau khi bộ đệm bên dưới đã được tách ra, bộ đệm ở trạng thái không sử dụng được

Một số triển khai, như , có thể không có khái niệm về bộ đệm bên dưới và việc gọi phương thức này sẽ tăng

Mới trong phiên bản 3. 1

đọc(kích thước=- 1, /)

Đọc và trả về các ký tự có kích thước tối đa từ luồng dưới dạng một ký tự. Nếu kích thước là âm hoặc

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7, thì đọc cho đến EOF

đường đọc(kích thước=- 1, /)

Đọc cho đến dòng mới hoặc EOF và trả lại một

f = io.StringIO("some initial text data")
2. Nếu luồng đã ở EOF, một chuỗi trống sẽ được trả về

Nếu kích thước được chỉ định, hầu hết các ký tự kích thước sẽ được đọc

tìm kiếm( , từ đâu=SEEK_SET, /)

Thay đổi vị trí luồng thành phần bù đã cho. Hành vi phụ thuộc vào tham số wherece. Giá trị mặc định cho từ đâu là

f = io.StringIO("some initial text data")
84

  • f = io.StringIO("some initial text data")
    
    84 hoặc
    f = io.StringIO("some initial text data")
    
    80. tìm kiếm từ đầu luồng (mặc định); . Bất kỳ giá trị bù nào khác đều tạo ra hành vi không xác định

  • f = io.StringIO("some initial text data")
    
    87 hoặc
    f = io.StringIO("some initial text data")
    
    88. “tìm kiếm” vị trí hiện tại;

  • f = io.StringIO("some initial text data")
    
    89 hoặc
    f = io.StringIO("some initial text data")
    
    90. tìm đến cuối dòng;

Trả lại vị trí tuyệt đối mới dưới dạng số mờ

Mới trong phiên bản 3. 1. Hằng số

f = io.StringIO("some initial text data")
91.

kể()

Trả lại vị trí luồng hiện tại dưới dạng số mờ. Số này thường không đại diện cho một số byte trong bộ lưu trữ nhị phân cơ bản

viết(s , /)

Viết chuỗi s vào luồng và trả về số ký tự đã viết

lớp io. TextIOWrapper(bộ đệm , mã hóa=None, errors=None, newline=None, line_buffering=False, write_through=False)

Luồng văn bản được đệm cung cấp quyền truy cập cấp cao hơn cho luồng nhị phân được đệm. Nó kế thừa

mã hóa cung cấp tên của mã hóa mà luồng sẽ được giải mã hoặc mã hóa bằng. Nó mặc định là.

f = io.BytesIO(b"some initial binary data: \x00\x01")
6 có thể được sử dụng để chỉ định rõ ràng mã hóa của ngôn ngữ hiện tại. Xem để biết thêm thông tin

lỗi là một chuỗi tùy chọn chỉ định cách xử lý lỗi mã hóa và giải mã. Vượt qua

f = io.BytesIO(b"some initial binary data: \x00\x01")
53 để đưa ra một ngoại lệ nếu có lỗi mã hóa (mặc định của
def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7 có tác dụng tương tự) hoặc vượt qua
f = io.BytesIO(b"some initial binary data: \x00\x01")
56 để bỏ qua lỗi. (Lưu ý rằng việc bỏ qua lỗi mã hóa có thể dẫn đến mất dữ liệu. )
f = io.BytesIO(b"some initial binary data: \x00\x01")
57 khiến một điểm đánh dấu thay thế (chẳng hạn như
f = io.BytesIO(b"some initial binary data: \x00\x01")
58) được chèn vào nơi có dữ liệu không đúng định dạng.
f = io.BytesIO(b"some initial binary data: \x00\x01")
59 khiến dữ liệu không đúng định dạng được thay thế bằng chuỗi thoát có dấu gạch chéo ngược. Khi viết, có thể sử dụng
f = io.BytesIO(b"some initial binary data: \x00\x01")
60 (thay thế bằng tham chiếu ký tự XML thích hợp) hoặc
f = io.BytesIO(b"some initial binary data: \x00\x01")
61 (thay thế bằng chuỗi ký tự thoát
f = io.BytesIO(b"some initial binary data: \x00\x01")
62). Bất kỳ tên xử lý lỗi nào khác đã được đăng ký cũng hợp lệ

dòng mới kiểm soát cách xử lý kết thúc dòng. Nó có thể là

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7,
f = io.BytesIO(b"some initial binary data: \x00\x01")
65,
f = io.BytesIO(b"some initial binary data: \x00\x01")
66,
f = io.BytesIO(b"some initial binary data: \x00\x01")
67 và
f = io.BytesIO(b"some initial binary data: \x00\x01")
68. Nó hoạt động như sau

  • Khi đọc đầu vào từ luồng, nếu dòng mới là

    def read_text(path, encoding=None):
        encoding = io.text_encoding(encoding)  # stacklevel=2
        with open(path, encoding) as f:
            return f.read()
    
    7, chế độ được bật. Các dòng trong đầu vào có thể kết thúc bằng
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    66,
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    67 hoặc
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    68 và những dòng này được dịch thành
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    66 trước khi được trả lại cho người gọi. Nếu dòng mới là
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    65, chế độ dòng mới chung được bật, nhưng kết thúc dòng được trả lại cho người gọi chưa được dịch. Nếu dòng mới có bất kỳ giá trị pháp lý nào khác, các dòng đầu vào chỉ được kết thúc bởi chuỗi đã cho và kết thúc dòng được trả lại cho người gọi chưa được dịch

  • Khi ghi đầu ra vào luồng, nếu dòng mới là

    def read_text(path, encoding=None):
        encoding = io.text_encoding(encoding)  # stacklevel=2
        with open(path, encoding) as f:
            return f.read()
    
    7, thì bất kỳ ký tự
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    66 nào được ghi sẽ được dịch sang dấu phân cách dòng mặc định của hệ thống,. Nếu dòng mới là
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    65 hoặc
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    66, không có bản dịch nào diễn ra. Nếu dòng mới là bất kỳ giá trị pháp lý nào khác, bất kỳ ký tự
    f = io.BytesIO(b"some initial binary data: \x00\x01")
    
    66 nào được viết sẽ được dịch sang chuỗi đã cho

Nếu line_buffering là

f = io.StringIO("some initial text data")
71, thì
f = open("myfile.jpg", "rb")
95 được ngụ ý khi lệnh gọi write chứa ký tự xuống dòng hoặc xuống dòng

Nếu write_through là

f = io.StringIO("some initial text data")
71, lệnh gọi tới
f = io.StringIO("some initial text data")
3 được đảm bảo không bị lưu vào bộ đệm. bất kỳ dữ liệu nào được ghi trên đối tượng ngay lập tức được xử lý vào bộ đệm nhị phân bên dưới của nó

Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số write_through.

Đã thay đổi trong phiên bản 3. 3. Mã hóa mặc định hiện là

f = io.BytesIO(b"some initial binary data: \x00\x01")
86 thay vì
f = io.BytesIO(b"some initial binary data: \x00\x01")
87. Không thay đổi tạm thời mã hóa ngôn ngữ bằng cách sử dụng , sử dụng mã hóa ngôn ngữ hiện tại thay vì mã hóa ưa thích của người dùng.

Đã thay đổi trong phiên bản 3. 10. Đối số mã hóa hiện hỗ trợ tên mã hóa giả

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
8.

cung cấp các thuộc tính và phương thức dữ liệu này ngoài các thuộc tính và phương thức từ và

line_buffering

Bộ đệm dòng có được bật hay không

viết_thông qua

Việc ghi có được chuyển ngay đến bộ đệm nhị phân bên dưới hay không

Mới trong phiên bản 3. 7

cấu hình lại(* , mã hóa=None, errors=None, newline=None, line_buffering=None, write_through=None)

Định cấu hình lại luồng văn bản này bằng cài đặt mới cho mã hóa, lỗi, dòng mới, line_buffering và write_through

Các tham số không được chỉ định giữ cài đặt hiện tại, ngoại trừ

f = io.BytesIO(b"some initial binary data: \x00\x01")
93 được sử dụng khi mã hóa được chỉ định nhưng lỗi không được chỉ định

Không thể thay đổi mã hóa hoặc dòng mới nếu một số dữ liệu đã được đọc từ luồng. Mặt khác, có thể thay đổi mã hóa sau khi ghi

Phương pháp này thực hiện một luồng ẩn trước khi đặt các tham số mới

Mới trong phiên bản 3. 7

Đã thay đổi trong phiên bản 3. 11. Phương thức hỗ trợ tùy chọn

f = io.BytesIO(b"some initial binary data: \x00\x01")
6.

lớp io. StringIO(initial_value=', newline='\n')

Luồng văn bản sử dụng bộ đệm văn bản trong bộ nhớ. Nó kế thừa

Bộ đệm văn bản bị loại bỏ khi phương thức được gọi

Giá trị ban đầu của bộ đệm có thể được đặt bằng cách cung cấp giá trị ban đầu. Nếu dịch dòng mới được bật, dòng mới sẽ được mã hóa như thể bởi. Luồng được định vị ở đầu bộ đệm mô phỏng việc mở một tệp hiện có ở chế độ

f = io.BytesIO(b"some initial binary data: \x00\x01")
98, làm cho nó sẵn sàng để ghi ngay từ đầu hoặc ghi đè lên giá trị ban đầu. Để mô phỏng mở tệp ở chế độ
f = io.BytesIO(b"some initial binary data: \x00\x01")
99 đã sẵn sàng để nối thêm, hãy sử dụng
f = open("myfile.jpg", "rb", buffering=0)
00 để định vị lại luồng ở cuối bộ đệm

Đối số dòng mới hoạt động giống như đối số của , ngoại trừ khi ghi đầu ra vào luồng, nếu dòng mới là

def read_text(path, encoding=None):
    encoding = io.text_encoding(encoding)  # stacklevel=2
    with open(path, encoding) as f:
        return f.read()
7, thì dòng mới được viết là
f = open("myfile.jpg", "rb", buffering=0)
03 trên tất cả các nền tảng

cung cấp phương pháp này ngoài những phương pháp từ và

nhận giá trị()

Trả về một

f = io.StringIO("some initial text data")
2 chứa toàn bộ nội dung của bộ đệm. Các dòng mới được giải mã như thể bởi , mặc dù vị trí dòng không thay đổi

Ví dụ sử dụng

import io

output = io.StringIO()
output.write('First line.\n')
print('Second line.', file=output)

# Retrieve file contents -- this will be
# 'First line.\nSecond line.\n'
contents = output.getvalue()

# Close object and discard memory buffer --
# .getvalue() will now raise an exception.
output.close()

lớp io. IncrementalNewlineDecoder

Một codec trợ giúp giải mã các dòng mới cho chế độ. Nó kế thừa

Hiệu suất

Phần này thảo luận về hiệu suất của việc triển khai I/O cụ thể được cung cấp

I/O nhị phân

Bằng cách chỉ đọc và ghi các khối dữ liệu lớn ngay cả khi người dùng yêu cầu một byte đơn lẻ, I/O được đệm sẽ che giấu mọi sự kém hiệu quả trong việc gọi và thực thi các quy trình I/O không có bộ đệm của hệ điều hành. Mức tăng phụ thuộc vào HĐH và loại I/O được thực hiện. Ví dụ: trên một số hệ điều hành hiện đại như Linux, I/O đĩa không có bộ đệm có thể nhanh như I/O được đệm. Tuy nhiên, điểm mấu chốt là I/O được đệm cung cấp hiệu suất có thể dự đoán được bất kể nền tảng và thiết bị hỗ trợ. Do đó, hầu như luôn luôn thích sử dụng I/O có bộ đệm hơn là I/O không có bộ đệm cho dữ liệu nhị phân

Nhập/xuất văn bản

Nhập/xuất văn bản qua bộ lưu trữ nhị phân (chẳng hạn như tệp) chậm hơn đáng kể so với nhập/xuất nhị phân trên cùng bộ lưu trữ, vì nó yêu cầu chuyển đổi giữa dữ liệu unicode và dữ liệu nhị phân bằng bộ giải mã ký tự. Điều này có thể trở nên đáng chú ý khi xử lý lượng dữ liệu văn bản khổng lồ như tệp nhật ký lớn. Ngoài ra,

f = open("myfile.jpg", "rb", buffering=0)
10 và
f = open("myfile.jpg", "rb", buffering=0)
11 đều khá chậm do thuật toán tái tạo được sử dụng

tuy nhiên, là một bộ chứa unicode trong bộ nhớ riêng và sẽ thể hiện tốc độ tương tự như

đa luồng

các đối tượng an toàn theo luồng trong phạm vi mà hệ điều hành gọi (chẳng hạn như

f = open("myfile.jpg", "rb", buffering=0)
15 trong Unix) chúng cũng an toàn theo luồng

Các đối tượng đệm nhị phân (ví dụ của , , và ) bảo vệ cấu trúc bên trong của chúng bằng cách sử dụng khóa;

các đối tượng không an toàn cho luồng

tái nhập cư

Các đối tượng được đệm nhị phân (các trường hợp của , và ) không được đăng nhập lại. Mặc dù các lệnh gọi lại sẽ không xảy ra trong các tình huống bình thường, nhưng chúng có thể phát sinh từ việc thực hiện I/O trong một trình xử lý. Nếu một luồng cố gắng nhập lại một đối tượng được lưu vào bộ đệm mà nó đang truy cập, a sẽ được nâng lên. Lưu ý rằng điều này không cấm một luồng khác vào đối tượng được đệm

Ở trên hoàn toàn mở rộng cho các tệp văn bản, vì hàm sẽ bọc một đối tượng được đệm bên trong một. Điều này bao gồm các luồng tiêu chuẩn và do đó cũng ảnh hưởng đến chức năng tích hợp

Các byte được biểu diễn bằng Python như thế nào?

Trong Python, một chuỗi byte được biểu thị bằng a b , theo sau là biểu diễn ASCII của chuỗi byte . Một chuỗi byte có thể được giải mã trở lại thành một chuỗi ký tự, nếu bạn biết mã hóa đã được sử dụng để mã hóa nó.

Làm thế nào để đọc một tập tin nhị phân?

Để đọc từ tệp nhị phân .
Sử dụng phương thức ReadAllBytes, trả về nội dung của tệp dưới dạng mảng byte. Ví dụ này đọc từ tệp C. /Documents and Settings/selfportrait. .
Đối với các tệp nhị phân lớn, bạn có thể sử dụng phương thức Đọc của đối tượng FileStream để chỉ đọc từ tệp một lượng được chỉ định tại một thời điểm