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
f = io.StringIO["some initial text data"]2 vào phương thức
f = io.StringIO["some initial text data"]3 của luồng nhị phân sẽ tạo ra một
f = io.StringIO["some initial text data"]4. Vì vậy, sẽ cung cấp một đối tượng
f = io.StringIO["some initial text data"]5 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
f = io.StringIO["some initial text data"]7 hiện tăng
f = io.StringIO["some initial text data"]8, vì
f = io.StringIO["some initial text data"]7 hiện là bí danh của
f = io.StringIO["some initial text data"]8.
Văn bản I/O¶
Văn bản I/O mong đợi và tạo ra các đối tượng
f = io.StringIO["some initial text data"]2. Đ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
f = io.StringIO["some initial text data"]02, tùy chọn chỉ định mã hóa
f = io.StringIO["some initial text data"]1
Luồ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"]03
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
f = io.StringIO["some initial text data"]04
I/O nhị phân
I/O nhị phân [còn gọi là I/O được đệm] yêu cầu các đối tượng giống như byte và tạo ra các đối tượng
f = io.StringIO["some initial text data"]5. 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 = io.StringIO["some initial text data"]02 với
f = io.StringIO["some initial text data"]07 trong chuỗi chế độ
f = io.StringIO["some initial text data"]0
Luồng nhị phân trong bộ nhớ cũng có sẵn dưới dạng đối tượng
f = io.StringIO["some initial text data"]08
f = io.StringIO["some initial text data"]0
API luồng nhị phân được mô tả chi tiết trong tài liệu của
f = io.StringIO["some initial text data"]09
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ụ về
f = io.StringIO["some initial text data"]00
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 = io.StringIO["some initial text data"]3
API luồng thô được mô tả chi tiết trong tài liệu của
f = io.StringIO["some initial text data"]01
Mã hóa văn bản¶
Mã hóa mặc định của
f = io.StringIO["some initial text data"]02 và
f = io.StringIO["some initial text data"]02 là dành riêng cho ngôn ngữ [
f = io.StringIO["some initial text data"]04]
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ụ
f = io.StringIO["some initial text data"]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.StringIO["some initial text data"]05. Để sử dụng mã hóa ngôn ngữ hiện tại,
f = io.StringIO["some initial text data"]06 được hỗ trợ kể từ Python 3. 10
Xem thêm
Chế độ Python UTF-8Chế độ 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 686Trăn 3. 15 sẽ đặt Chế độ Python UTF-8 thành 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 sử dụng mã hóa ngôn ngữ mặc định, bạn có thể bật tùy chọn dòng lệnh
f = io.StringIO["some initial text data"]07 hoặc đặt biến môi trường
f = io.StringIO["some initial text data"]08, biến này sẽ phát ra một
f = io.StringIO["some initial text data"]09 khi mã hóa mặc định được sử dụng
Nếu bạn đang cung cấp API sử dụng
f = io.StringIO["some initial text data"]02 hoặc
f = io.StringIO["some initial text data"]02 và chuyển
f = io.StringIO["some initial text data"]32 làm tham số, thì bạn có thể sử dụng
f = io.StringIO["some initial text data"]33 để những người gọi API sẽ phát ra một
f = io.StringIO["some initial text data"]09 nếu họ không chuyển một
f = io.StringIO["some initial text data"]35. Tuy nhiên, hãy cân nhắc sử dụng UTF-8 theo mặc định [tôi. e.
f = io.StringIO["some initial text data"]05] 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.
f = io.StringIO["some initial text data"]02 sử dụng blksize của tệp [do
f = io.StringIO["some initial text data"]38 thu được] 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
f = io.StringIO["some initial text data"]02 dựng sẵn
Hàm này tạo ra một sự kiện kiểm tra
f = io.StringIO["some initial text data"]80 với các đối số
f = io.StringIO["some initial text data"]81,
f = io.StringIO["some initial text data"]82 và
f = io.StringIO["some initial text data"]83. Các đối số
f = io.StringIO["some initial text data"]82 và
f = io.StringIO["some initial text data"]83 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ế độ
f = io.StringIO["some initial text data"]86. Hàm này nên được sử dụng khi mục đích là coi nội dung là mã thực thi
f = io.StringIO["some initial text data"]81 phải là một
f = io.StringIO["some initial text data"]2 và 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 đó tới
f = io.StringIO["some initial text data"]89. Tuy nhiên, giả sử rằng
f = io.StringIO["some initial text data"]81 là một
f = io.StringIO["some initial text data"]2 và là một đường dẫn tuyệt đối, thì
f = io.StringIO["some initial text data"]62 phải luôn hoạt động giống như
f = io.StringIO["some initial text data"]63. 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 chức năng trợ giúp cho các cuộc gọi sử dụng
f = io.StringIO["some initial text data"]02 hoặc
f = io.StringIO["some initial text data"]02 và có tham số
f = io.StringIO["some initial text data"]32
Hàm này trả về mã hóa nếu nó không phải là
f = io.StringIO["some initial text data"]67. Mặt khác, nó trả về
f = io.StringIO["some initial text data"]68 hoặc
f = io.StringIO["some initial text data"]69 tùy thuộc vào Chế độ UTF-8 .
Hàm này phát ra một
f = io.StringIO["some initial text data"]09 nếu
f = io.StringIO["some initial text data"]51 là true và mã hóa là
f = io.StringIO["some initial text data"]67. stacklevel chỉ định nơi phát ra cảnh báo. Ví dụ
f = io.StringIO["some initial text data"]6
Trong ví dụ này, một
f = io.StringIO["some initial text data"]09 được phát ra cho người gọi của
f = io.StringIO["some initial text data"]54
Xem Mã hóa văn bản để 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. ______233 trả về “utf-8” khi chế độ UTF-8 được bật và mã hóa là
f = io.StringIO["some initial text data"]67. ngoại lệ io. BlockingIOError ¶
Đây là bí danh tương thích cho ngoại lệ
f = io.StringIO["some initial text data"]57 dựng sẵnngoại lệ io. Hoạt động không được hỗ trợ ¶
Một ngoại lệ kế thừa
f = io.StringIO["some initial text data"]8 và
f = io.StringIO["some initial text data"]59 được đưa ra khi một thao tác không được hỗ trợ được gọi trên luồng
Xem thêm
f = io.StringIO["some initial text data"]50
chứa các luồng IO tiêu chuẩn.
f = io.StringIO["some initial text data"]51,
f = io.StringIO["some initial text data"]52 và
f = io.StringIO["some initial text data"]53
Hệ thống 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 các lớp cơ sở trừu tượng [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ụ:
f = io.StringIO["some initial text data"]09 cung cấp các triển khai chưa được tối ưu hóa củaf = io.StringIO["some initial text data"]55 vàf = io.StringIO["some initial text data"]56
Ở trên cùng của hệ thống phân cấp I/O là lớp cơ sở trừu tượng
f = io.StringIO["some initial text data"]57. 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;
f = io.StringIO["some initial text data"]01 ABC kéo dài
f = io.StringIO["some initial text data"]57. Nó xử lý việc đọc và ghi byte vào luồng. Các phân lớp
f = io.StringIO["some initial text data"]61
f = io.StringIO["some initial text data"]01 để cung cấp giao diện cho các tệp trong hệ thống tệp của máy
f = io.StringIO["some initial text data"]09 ABC kéo dài
f = io.StringIO["some initial text data"]57. Nó liên quan đến việc lưu vào bộ đệm trên luồng nhị phân thô [
f = io.StringIO["some initial text data"]01]. Các lớp con của nó,
f = io.StringIO["some initial text data"]66,
f = io.StringIO["some initial text data"]67 và
f = io.StringIO["some initial text data"]68 đệ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.
f = io.StringIO["some initial text data"]69 cung cấp giao diện đệm cho các luồng có thể tìm kiếm. Một phân lớp khác của
f = io.StringIO["some initial text data"]09,
f = io.StringIO["some initial text data"]08, là một luồng các byte trong bộ nhớ
f = io.StringIO["some initial text data"]04 ABC kéo dài
f = io.StringIO["some initial text data"]57. 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.
f = io.StringIO["some initial text data"]02, mở rộng
f = io.StringIO["some initial text data"]04, là giao diện văn bản được đệm cho luồng thô được đệm [
f = io.StringIO["some initial text data"]09]. Cuối cùng,
f = io.StringIO["some initial text data"]03 là luồng trong bộ nhớ dà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
f = io.StringIO["some initial text data"]02 được dùng làm đối số từ khóa
Bảng sau đây tóm tắt các ABC do mô-đun
f = io.StringIO["some initial text data"]0 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"]57
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
f = io.StringIO["some initial text data"]14,
f = io.StringIO["some initial text data"]15,
f = io.StringIO["some initial text data"]16,
f = io.StringIO["some initial text data"]17,
f = io.StringIO["some initial text data"]18,
f = io.StringIO["some initial text data"]19,
f = io.StringIO["some initial text data"]20,
f = io.StringIO["some initial text data"]21,
f = io.StringIO["some initial text data"]22,
f = io.StringIO["some initial text data"]23,
f = io.StringIO["some initial text data"]24,
f = io.StringIO["some initial text data"]25,
f = io.StringIO["some initial text data"]26,
f = io.StringIO["some initial text data"]27, và
f = io.StringIO["some initial text data"]28
f = io.StringIO["some initial text data"]01
f = io.StringIO["some initial text data"]57
f = io.StringIO["some initial text data"]31 và
f = io.StringIO["some initial text data"]32
Kế thừa các phương thức
f = io.StringIO["some initial text data"]57,
f = io.StringIO["some initial text data"]34 và
f = io.StringIO["some initial text data"]35
f = io.StringIO["some initial text data"]09
f = io.StringIO["some initial text data"]57
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
Kế thừa các phương thức
f = io.StringIO["some initial text data"]57,
f = io.StringIO["some initial text data"]31 và
f = io.StringIO["some initial text data"]44
f = io.StringIO["some initial text data"]04
f = io.StringIO["some initial text data"]57
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
Kế thừa các phương pháp
f = io.StringIO["some initial text data"]57,
f = io.StringIO["some initial text data"]35,
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ù
f = io.StringIO["some initial text data"]57 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
f = io.StringIO["some initial text data"]59 [hoặc
f = io.StringIO["some initial text data"]58] 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à
f = io.StringIO["some initial text data"]5. đối tượng dạng byte khác cũng được chấp nhận làm đối số phương thức. Các lớp I/O văn bản hoạt động với dữ liệu
f = io.StringIO["some initial text data"]2.
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
f = io.StringIO["some initial text data"]59 trong trường hợp này
f = io.StringIO["some initial text data"]57 [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
f = io.StringIO["some initial text data"]57 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
f = io.StringIO["some initial text data"]56 bên dưới
f = io.StringIO["some initial text data"]57 cũng là một trình quản lý bối cảnh và do đó hỗ trợ câu lệnh
f = io.StringIO["some initial text data"]67. Trong ví dụ này, tệp bị đóng sau khi bộ câu lệnh
f = io.StringIO["some initial text data"]67 kết thúc—ngay cả khi có ngoại lệ xảy ra
f = io.StringIO["some initial text data"]5
f = io.StringIO["some initial text data"]57 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ẽ tăng
f = io.StringIO["some initial text data"]59
Để thuận tiện, nó được phép gọi phương thức này nhiều lần;
đã đóng ¶f = io.StringIO["some initial text data"]71 nếu luồng bị đóngfileno[] ¶
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. Một
f = io.StringIO["some initial text data"]8 được nâng lên nếu đối tượng IO không sử dụng bộ mô tả tệptuôn ra[] ¶
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
f = io.StringIO["some initial text data"]8đườ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ư
f = io.StringIO["some initial text data"]67, đượ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"]83tìm kiếm[bù , 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ặcf = io.StringIO["some initial text data"]
80 – bắt đầu luồng [mặc định];f = io.StringIO["some initial text data"]
87 hoặcf = io.StringIO["some initial text data"]
88 – vị trí luồng hiện tại;f = io.StringIO["some initial text data"]
89 hoặcf = 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,
f = io.StringIO["some initial text data"]96,
f = io.StringIO["some initial text data"]97 và
f = io.StringIO["some initial text data"]98 sẽ tăng
f = io.StringIO["some initial text data"]8kể[] ¶
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à
f = io.StringIO["some initial text data"]98 sẽ tăng
f = io.StringIO["some initial text data"]8writelines[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.
f = io.StringIO["some initial text data"]57 cung cấp triển khai mặc định của phương thức này gọi phương thức
f = io.StringIO["some initial text data"]006 của cá thểlớp io. rawIOBase ¶
Lớp cơ sở cho luồng nhị phân thô. Nó kế thừa
f = io.StringIO["some initial text data"]57
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
f = io.StringIO["some initial text data"]01 cung cấp các phương thức này ngoài các phương thức từ
f = io.StringIO["some initial text data"]57đọ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ế độ không chặn và không có byte nào, thì trả về
f = io.StringIO["some initial text data"]67
Việc triển khai mặc định trì hoãn cho
f = io.StringIO["some initial text data"]011 và
f = io.StringIO["some initial text data"]55readall[] ¶
Đọ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 một đối tượng giống như byte b được phân bổ trước, có thể ghi và trả về số byte đã đọc. Ví dụ, b có thể là một
f = io.StringIO["some initial text data"]013. Nếu đối tượng ở chế độ không chặn và không có byte nào, thì trả về
f = io.StringIO["some initial text data"]67. viết[b , /]¶
Ghi đối tượng giống như byte đã cho , b, 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.
f = io.StringIO["some initial text data"]67 đượ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
f = io.StringIO["some initial text data"]57
Sự khác biệt chính với
f = io.StringIO["some initial text data"]01 là các phương thức
f = io.StringIO["some initial text data"]56,
f = io.StringIO["some initial text data"]55 và
f = io.StringIO["some initial text data"]3 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ó lẽ là thực hiện nhiều hơn một lệnh gọi hệ thống
Ngoài ra, các phương pháp đó có thể tăng
f = io.StringIO["some initial text data"]57 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 thức
f = io.StringIO["some initial text data"]56 không có triển khai mặc định trì hoãn thành
f = io.StringIO["some initial text data"]55
Việc triển khai
f = io.StringIO["some initial text data"]09 điển hình không nên kế thừa từ triển khai
f = io.StringIO["some initial text data"]01, mà nên bao bọc một triển khai, như
f = io.StringIO["some initial text data"]66 và
f = io.StringIO["some initial text data"]67 làm
f = io.StringIO["some initial text data"]09 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ừ
f = io.StringIO["some initial text data"]57thô ¶
Luồng thô cơ bản [một phiên bản
f = io.StringIO["some initial text data"]01] mà
f = io.StringIO["some initial text data"]09 xử lý. Đây không phải là một phần của API
f = io.StringIO["some initial text data"]09 và có thể không tồn tại trên một số triển khaitá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ư
f = io.StringIO["some initial text data"]08, 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
f = io.StringIO["some initial text data"]58
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,
f = io.StringIO["some initial text data"]67 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
f = io.StringIO["some initial text data"]5 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
Một
f = io.StringIO["some initial text data"]57 đượ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àyread1[size=- 1, /]¶
Đọc và trả về các byte có kích thước tối đa, với tối đa một lần gọi phương thức
f = io.StringIO["some initial text data"]56 [hoặc
f = io.StringIO["some initial text data"]55] 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 đối tượng
f = io.StringIO["some initial text data"]09
Nếu kích thước là
f = io.StringIO["some initial text data"]043 [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 một đối tượng giống như byte b được phân bổ trước, có thể ghi và trả về số byte đã đọc. Ví dụ, b có thể là một
f = io.StringIO["some initial text data"]013.
Giống như
f = io.StringIO["some initial text data"]56, 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
Một
f = io.StringIO["some initial text data"]57 đượ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àyreadinto1[b , /]¶
Đọc byte vào một đối tượng giống như byte bytes-like object được phân bổ trước, có thể ghi b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc. b, sử dụng tối đa một lần gọi tới
f = io.StringIO["some initial text data"]56 của luồng thô bên dưới [ . Trả về số byte đã đọc.
Một
f = io.StringIO["some initial text data"]57 đượ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 , /]¶Ghi đối tượng giống như byte bytes-like object đã cho , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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ễ. , b và trả về số byte đã ghi [luôn bằng độ dài của b tính bằng byte . 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, một
f = io.StringIO["some initial text data"]57 đượ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
Tệp thô I/O¶
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
f = io.StringIO["some initial text data"]01
Tên có thể là một trong hai điều
một chuỗi ký tự hoặc đối tượng
f = io.StringIO["some initial text data"]
5 đạ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ỗimột số nguyên đại diện cho số lượng của một bộ mô tả tệp cấp hệ điều hành hiện có mà đối tượng
f = io.StringIO["some initial text data"]
61 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ànhf = io.StringIO["some initial text data"]
75
Chế độ có thể là
f = io.StringIO["some initial text data"]057,
f = io.StringIO["some initial text data"]058,
f = io.StringIO["some initial text data"]059 hoặc
f = io.StringIO["some initial text data"]060 để đọ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; .
f = io.StringIO["some initial text data"]061 sẽ được nâng lên nếu nó đã tồn tại khi được mở để tạo. Mở 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 = io.StringIO["some initial text data"]058. Thêm một
f = io.StringIO["some initial text data"]063 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],
f = io.StringIO["some initial text data"]55 và
f = io.StringIO["some initial text data"]3 trong lớp này sẽ chỉ thực hiện một cuộc 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ờ]. trình mở phải trả về một bộ mô tả tệp đang mở [chuyển
f = io.StringIO["some initial text data"]067 vì trình mở dẫn đến chức năng tương tự như chuyển
f = io.StringIO["some initial text data"]67]
Tệp mới tạo không thể kế thừa .
Xem chức năng tích hợp sẵn của
f = io.StringIO["some initial text data"]02 để 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 = io.StringIO["some initial text data"]059 đã được thêm vào.
Đã thay đổi trong phiên bản 3. 4. Tệp hiện không thể kế thừa.
f = io.StringIO["some initial text data"]61 cung cấp các thuộc tính dữ liệu này ngoài các thuộc tính từ
f = io.StringIO["some initial text data"]01 và
f = io.StringIO["some initial text data"]57chế độ ¶
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
f = io.StringIO["some initial text data"]09. Bộ đệm bị loại bỏ khi phương thức
f = io.StringIO["some initial text data"]006 được gọi
Đối số tùy chọn init_bytes là một đối tượng giống byte chứa dữ liệu ban đầu.
f = io.StringIO["some initial text data"]08 cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ
f = io.StringIO["some initial text data"]09 và
f = io.StringIO["some initial text data"]57getbuffer[] ¶
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
f = io.StringIO["some initial text data"]5
Ghi chú
Miễn là chế độ xem tồn tại, đối tượng
f = io.StringIO["some initial text data"]08 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ị[] ¶Trả về
f = io.StringIO["some initial text data"]5 chứa toàn bộ nội dung của bộ đệmread1[size=- 1, /]¶
Trong
f = io.StringIO["some initial text data"]08, điều này giống với
f = io.StringIO["some initial text data"]56
Đã 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
f = io.StringIO["some initial text data"]08, điều này giống với
f = io.StringIO["some initial text data"]55
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ô
f = io.StringIO["some initial text data"]01 có thể đọc được, không thể tìm kiếm được. Nó kế thừa
f = io.StringIO["some initial text data"]09
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
f = io.StringIO["some initial text data"]67 cho luồng thô có thể đọc được và buffer_size. Nếu buffer_size bị bỏ qua, thì
f = io.StringIO["some initial text data"]088 được sử dụng
f = io.StringIO["some initial text data"]67 cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ
f = io.StringIO["some initial text data"]09 và
f = io.StringIO["some initial text data"]57nhì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ô
f = io.StringIO["some initial text data"]01 có thể ghi, không thể tìm kiếm. Nó kế thừa
f = io.StringIO["some initial text data"]09
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
f = io.StringIO["some initial text data"]01 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
f = io.StringIO["some initial text data"]
095 được gọi;khi một
f = io.StringIO["some initial text data"]
96 được yêu cầu [đối với các đối tượngf = io.StringIO["some initial text data"]
69];khi đối tượng
f = io.StringIO["some initial text data"]
66 bị đóng hoặc bị hủy
Hàm tạo tạo một
f = io.StringIO["some initial text data"]66 cho luồng thô có thể ghi đã cho. Nếu buffer_size không được cung cấp, nó sẽ mặc định là
f = io.StringIO["some initial text data"]088
f = io.StringIO["some initial text data"]66 cung cấp hoặc ghi đè các phương thức này ngoài các phương thức từ
f = io.StringIO["some initial text data"]09 và
f = io.StringIO["some initial text data"]57tuôn ra[] ¶
Buộc các byte được giữ trong bộ đệm vào luồng thô. Một
f = io.StringIO["some initial text data"]57 nên được nâng lên nếu luồng thô chặnviết[b , /]¶
Viết đối tượng dạng byte , b và trả về số byte đã ghi. Khi ở chế độ không chặn, một
f = io.StringIO["some initial text data"]57 được nâng lên nếu bộ đệm cần được ghi ra nhưng luồng thô lại 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ô
f = io.StringIO["some initial text data"]01 có thể tìm kiếm. Nó kế thừa
f = io.StringIO["some initial text data"]67 và
f = io.StringIO["some initial text data"]66
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à
f = io.StringIO["some initial text data"]088
f = io.StringIO["some initial text data"]69 có khả năng làm bất cứ điều gì mà
f = io.StringIO["some initial text data"]67 hoặc
f = io.StringIO["some initial text data"]66 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ệnlớ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ô
f = io.StringIO["some initial text data"]01 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
f = io.StringIO["some initial text data"]09
người đọc và người viết là ________ 201 đối tượng có thể đọc và ghi tương ứng. Nếu buffer_size bị bỏ qua, nó sẽ mặc định là
f = io.StringIO["some initial text data"]088
f = io.StringIO["some initial text data"]68 thực hiện tất cả các phương pháp của
f = io.StringIO["some initial text data"]09 ngoại trừ
f = io.StringIO["some initial text data"]021, điều này làm tăng
f = io.StringIO["some initial text data"]58
Cảnh báo
f = io.StringIO["some initial text data"]68 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;
Văn bản I/O¶
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
f = io.StringIO["some initial text data"]57
f = io.StringIO["some initial text data"]04 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ừ
f = io.StringIO["some initial text data"]57mã 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
f = io.StringIO["some initial text data"]67, 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ụngbộ đệm ¶
Bộ đệm nhị phân cơ bản [một phiên bản
f = io.StringIO["some initial text data"]09] mà
f = io.StringIO["some initial text data"]04 xử lý. Đây không phải là một phần của API
f = io.StringIO["some initial text data"]04 và có thể không tồn tại trong một số triển khaitách[] ¶
Tách bộ đệm nhị phân cơ bản khỏi
f = io.StringIO["some initial text data"]04 và trả lại
Sau khi bộ đệm bên dưới đã được tách ra,
f = io.StringIO["some initial text data"]04 ở trạng thái không sử dụng được
Một số triển khai
f = io.StringIO["some initial text data"]04, như
f = io.StringIO["some initial text data"]03, có thể không có khái niệm về bộ đệm cơ bản và việc gọi phương thức này sẽ tăng
f = io.StringIO["some initial text data"]58
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
f = io.StringIO["some initial text data"]2. Nếu kích thước là âm hoặc
f = io.StringIO["some initial text data"]67, đọc cho đến khi 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[bù , 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ặcf = 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 địnhf = io.StringIO["some initial text data"]
87 hoặcf = 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ặcf = 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 tới luồng nhị phân được đệm
f = io.StringIO["some initial text data"]09. Nó kế thừa
f = io.StringIO["some initial text data"]04
encoding 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.StringIO["some initial text data"]04.
f = io.StringIO["some initial text data"]06 có thể được sử dụng để chỉ định rõ ràng mã hóa của ngôn ngữ hiện tại. Xem Mã hóa văn bản để 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.StringIO["some initial text data"]053 để tăng ngoại lệ
f = io.StringIO["some initial text data"]59 nếu có lỗi mã hóa [mặc định là
f = io.StringIO["some initial text data"]67 có tác dụng tương tự] hoặc vượt qua
f = io.StringIO["some initial text data"]056 để 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.StringIO["some initial text data"]057 khiến một điểm đánh dấu thay thế [chẳng hạn như
f = io.StringIO["some initial text data"]058] được chèn vào nơi có dữ liệu không đúng định dạng.
f = io.StringIO["some initial text data"]059 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.StringIO["some initial text data"]060 [thay thế bằng tham chiếu ký tự XML thích hợp] hoặc
f = io.StringIO["some initial text data"]061 [thay thế bằng chuỗi thoát
f = io.StringIO["some initial text data"]062]. Bất kỳ tên xử lý lỗi nào khác đã được đăng ký với
f = io.StringIO["some initial text data"]063 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à ________ 567, ________ 2065, ________ 2066,
f = io.StringIO["some initial text data"]067 và ________ 2068. Nó hoạt động như sau
Khi đọc đầu vào từ luồng, nếu dòng mới là
f = io.StringIO["some initial text data"]
67, thì chế độ dòng mới chung được bật. Các dòng trong đầu vào có thể kết thúc bằngf = io.StringIO["some initial text data"]
066,f = io.StringIO["some initial text data"]
067 hoặcf = io.StringIO["some initial text data"]
068 và những dòng này được dịch thànhf = io.StringIO["some initial text data"]
066 trước khi được trả lại cho người gọi. Nếu dòng mới làf = io.StringIO["some initial text data"]
065, 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à
f = io.StringIO["some initial text data"]
67, mọi ký tựf = io.StringIO["some initial text data"]
066 được ghi sẽ được dịch sang dấu phân cách dòng mặc định của hệ thống,f = io.StringIO["some initial text data"]
077. Nếu dòng mới làf = io.StringIO["some initial text data"]
065 hoặcf = io.StringIO["some initial text data"]
066, 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, thì bất kỳ ký tựf = io.StringIO["some initial text data"]
066 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 = io.StringIO["some initial text data"]095 đượ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, các cuộc gọi đến
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
f = io.StringIO["some initial text data"]02 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.StringIO["some initial text data"]086 thay vì
f = io.StringIO["some initial text data"]087. Không thay đổi tạm thời mã hóa ngôn ngữ bằng cách sử dụng
f = io.StringIO["some initial text data"]088, hãy 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ả
f = io.StringIO["some initial text data"]68.
f = io.StringIO["some initial text data"]02 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ừ
f = io.StringIO["some initial text data"]04 và
f = io.StringIO["some initial text data"]57line_buffering ¶
Bộ đệm dòng có được bật hay không
write_through ¶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][, errors][, newline][, line_buffering][, write_through]]¶Đị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.StringIO["some initial text data"]093 đượ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.StringIO["some initial text data"]06. 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
f = io.StringIO["some initial text data"]04
Bộ đệm văn bản bị loại bỏ khi phương thức
f = io.StringIO["some initial text data"]006 đượ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ằng
f = io.StringIO["some initial text data"]3. Luồng được định vị ở đầu bộ đệm mô phỏng việc mở một tệp hiện có ở chế độ
f = io.StringIO["some initial text data"]098, làm cho nó sẵn sàng để ghi ngay từ đầu hoặc ghi đè lên giá trị ban đầu. Để mô phỏng việc mở tệp ở chế độ
f = io.StringIO["some initial text data"]099 đã sẵn sàng để nối thêm, hãy sử dụng
f = io.StringIO["some initial text data"]300 để đị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
f = io.StringIO["some initial text data"]02, ngoại trừ khi ghi đầu ra vào luồng, nếu dòng mới là
f = io.StringIO["some initial text data"]67, thì dòng mới được viết là
f = io.StringIO["some initial text data"]303 trên tất cả các nền tảng
f = io.StringIO["some initial text data"]03 cung cấp phương pháp này ngoài những phương pháp từ
f = io.StringIO["some initial text data"]04 và
f = io.StringIO["some initial text data"]57nhậ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
f = io.StringIO["some initial text data"]56, mặc dù vị trí dòng không thay đổi
Ví dụ sử dụng
f = io.StringIO["some initial text data"]6lớp io. IncrementalNewlineDecoder ¶
Một codec trợ giúp giải mã dòng mới cho chế độ dòng mới chung . Nó kế thừa
f = io.StringIO["some initial text data"]309.
Màn biểu diễn¶
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 những 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
Văn bản I/O¶
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 = io.StringIO["some initial text data"]310 và
f = io.StringIO["some initial text data"]311 đều khá chậm do thuật toán tái tạo được sử dụng
Tuy nhiên,
f = io.StringIO["some initial text data"]03 là một bộ chứa unicode trong bộ nhớ riêng và sẽ thể hiện tốc độ tương tự như
f = io.StringIO["some initial text data"]08
Đa luồng¶
Các đối tượng
f = io.StringIO["some initial text data"]61 an toàn theo luồng trong phạm vi mà hệ điều hành gọi [chẳng hạn như
f = io.StringIO["some initial text data"]315 trong Unix] chúng cũng an toàn theo luồng
Các đối tượng được đệm nhị phân [ví dụ
f = io.StringIO["some initial text data"]67,
f = io.StringIO["some initial text data"]66,
f = io.StringIO["some initial text data"]69 và
f = io.StringIO["some initial text data"]68] 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
f = io.StringIO["some initial text data"]02 không an toàn cho luồng
Reentrancy¶
Các đối tượng được đệm nhị phân [các trường hợp của
f = io.StringIO["some initial text data"]67,
f = io.StringIO["some initial text data"]66,
f = io.StringIO["some initial text data"]69 và
f = io.StringIO["some initial text data"]68] không được truy cập lại. Mặc dù các cuộc gọi reentrant 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 trình xử lý
f = io.StringIO["some initial text data"]325. 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, thì một
f = io.StringIO["some initial text data"]326 sẽ xuất hiệ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
f = io.StringIO["some initial text data"]02 sẽ bọc một đối tượng được đệm bên trong một
f = io.StringIO["some initial text data"]02. Điều này bao gồm các luồng tiêu chuẩn và do đó cũng ảnh hưởng đến hàm
f = io.StringIO["some initial text data"]329 tích hợp