Hướng dẫn read tbl file in python - đọc tệp tbl bằng python

PETL sử dụng các hàm Python đơn giản để cung cấp một hàng và cột trừu tượng để đọc và ghi dữ liệu từ các tệp, cơ sở dữ liệu và các nguồn khác.

Các tính năng chính mà PETL được thiết kế là:

• Việc triển khai Python thuần túy dựa trên các luồng, trình lặp và các loại Python khác.
• Cách tiếp cận mở rộng, chỉ yêu cầu phụ thuộc gói khi sử dụng chức năng của chúng.
• Sử dụng DataFrame/Bảng như mô hình tương tự của Pandas, R và những người khác
• Thay thế nhẹ để phát triển và duy trì so với các khung nặng hơn, đầy đủ tính năng, như pyspark, pyarrow và các công cụ ETL khác.

Tổng quan ngắn gọn

Tải [Viết] ¶

Các chức năng tải dữ liệu của các chức năng từ một bảng thành một nguồn hoặc cơ sở dữ liệu giống như tệp. Đối với các chức năng chấp nhận đối số

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

• >>> import petl as etl
  >>> import pickle
  >>> # set up a file to demonstrate with
  ... with open['example.p', 'wb'] as f:
  ...     pickle.dump[['foo', 'bar'], f]
  ...     pickle.dump[['a', 1], f]
  ...     pickle.dump[['b', 2], f]
  ...     pickle.dump[['c', 2.5], f]
  ...
  >>> # now demonstrate the use of frompickle[]
  ... table1 = etl.frompickle['example.p']
  >>> table1
  +-----+-----+
  | foo | bar |
  +=====+=====+
  | 'a' |   1 |
  +-----+-----+
  | 'b' |   2 |
  +-----+-----+
  | 'c' | 2.5 |
  +-----+-----+
  

  5 - Viết cho Stdout
• Chuỗi kết thúc bằng .gz hoặc .bgz - ghi vào tệp qua giải nén GZIP
• Chuỗi kết thúc bằng .bz2 - Viết để tệp qua giải nén BZ2
• Bất kỳ chuỗi nào khác - ghi trực tiếp vào tệp

Một số lớp trợ giúp cũng có sẵn để ghi vào các loại nguồn giống như tệp khác, ví dụ: ghi vào tệp zip hoặc bộ đệm chuỗi, xem phần trên các luồng I/O Python bên dưới để biết thêm thông tin.Python I/O streams below for more information.

Định dạng tệp tích hợp

Đối tượng Python

Xem một chuỗi các cột dưới dạng bảng, ví dụ:

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Nếu các cột không có cùng độ dài, các giá trị sẽ được đệm theo chiều dài của cột dài nhất bị thiếu, không có gì theo mặc định, ví dụ:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

Xem thêm

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

Mới trong phiên bản 1.1.0.

Các tệp được phân định

Trích xuất một bảng từ một tệp được phân định. Ví dụ.:

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Đối số nguồn là đường dẫn của tệp được phân định, tất cả các đối số từ khóa khác được chuyển đến

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Lưu ý rằng tất cả các giá trị dữ liệu là chuỗi và bất kỳ giá trị số dự định nào sẽ cần được chuyển đổi, xem thêm

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Viết bảng vào tệp CSV. Ví dụ.:

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Đối số nguồn là đường dẫn của tệp được phân định và đối số write_header tùy chọn chỉ định có bao gồm các tên trường trong tệp được phân định hay không. Tất cả các đối số từ khóa khác được chuyển đến

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Lưu ý rằng nếu một tệp đã tồn tại tại vị trí đã cho, nó sẽ bị ghi đè.

Phụ lục các hàng dữ liệu vào một tệp CSV hiện có. Vì

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Lưu ý rằng không có nỗ lực nào được thực hiện để kiểm tra xem các trường hoặc độ dài hàng phù hợp với dữ liệu hiện có, các hàng dữ liệu từ bảng chỉ được thêm vào tệp.

Trả về một bảng ghi các hàng vào tệp CSV khi chúng được lặp lại.

Hàm tiện lợi, như

>>> import petl as etl
>>> # setup example file
... text = 'a,1\nb,2\nc,2\n'
>>> with open['example.txt', 'w'] as f:
...     f.write[text]
...
12
>>> table1 = etl.fromtext['example.txt']
>>> table1
+-------+
| lines |
+=======+
| 'a,1' |
+-------+
| 'b,2' |
+-------+
| 'c,2' |
+-------+

>>> # post-process, e.g., with capture[]
... table2 = table1.capture['lines', '[.*],[.*]$', ['foo', 'bar']]
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Hàm tiện lợi, như

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Hàm tiện lợi, như

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> prologue = '''{| class="wikitable"
... |-
... ! foo
... ! bar
... '''
>>> template = '''|-
... | {foo}
... | {bar}
... '''
>>> epilogue = '|}'
>>> etl.totext[table1, 'example.txt', template=template,
... prologue=prologue, epilogue=epilogue]
>>> # see what we did
... print[open['example.txt'].read[]]
{| class="wikitable"
|-
! foo
! bar
|-
| a
| 1
|-
| b
| 2
|-
| c
| 2
|}

Hàm tiện lợi, như

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> prologue = '''{| class="wikitable"
... |-
... ! foo
... ! bar
... '''
>>> template = '''|-
... | {foo}
... | {bar}
... '''
>>> epilogue = '|}'
>>> etl.totext[table1, 'example.txt', template=template,
... prologue=prologue, epilogue=epilogue]
>>> # see what we did
... print[open['example.txt'].read[]]
{| class="wikitable"
|-
! foo
! bar
|-
| a
| 1
|-
| b
| 2
|-
| c
| 2
|}

Tệp Pickle

Trích xuất một bảng từ dữ liệu ngâm trong tệp đã cho. Các hàng trong bảng đáng lẽ phải được đưa vào tệp một. Ví dụ.:

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

Viết bảng vào một tệp dưa chua. Ví dụ.:

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Lưu ý rằng nếu một tệp đã tồn tại tại vị trí đã cho, nó sẽ bị ghi đè.

________ 70 ________ 78 [bảng, nguồn = không, mã hóa = không, lỗi = 'nghiêm ngặt', write_header = false

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Lưu ý rằng không có nỗ lực nào được thực hiện để kiểm tra xem các trường hoặc độ dài hàng phù hợp với dữ liệu hiện có, các hàng dữ liệu từ bảng chỉ được thêm vào tệp.

Lưu ý rằng không có nỗ lực nào được thực hiện để kiểm tra xem các trường hoặc độ dài hàng phù hợp với dữ liệu hiện có, các hàng dữ liệu từ bảng chỉ được thêm vào tệp.

Trả về một bảng ghi các hàng vào tệp CSV khi chúng được lặp lại.

________ 70 ________ 83 [nguồn = không, mã hóa = không, lỗi = 'nghiêm ngặt', tiêu đề = không

>>> import petl as etl
>>> # setup example file
... text = 'a,1\nb,2\nc,2\n'
>>> with open['example.txt', 'w'] as f:
...     f.write[text]
...
12
>>> table1 = etl.fromtext['example.txt']
>>> table1
+-------+
| lines |
+=======+
| 'a,1' |
+-------+
| 'b,2' |
+-------+
| 'c,2' |
+-------+

>>> # post-process, e.g., with capture[]
... table2 = table1.capture['lines', '[.*],[.*]$', ['foo', 'bar']]
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

________ 70 ________ 86 [Bảng, Nguồn = Không, Mã hóa = Không

>>> import petl as etl
>>> # setup example file
... text = 'a,1\nb,2\nc,2\n'
>>> with open['example.txt', 'w'] as f:
...     f.write[text]
...
12
>>> table1 = etl.fromtext['example.txt']
>>> table1
+-------+
| lines |
+=======+
| 'a,1' |
+-------+
| 'b,2' |
+-------+
| 'c,2' |
+-------+

>>> # post-process, e.g., with capture[]
... table2 = table1.capture['lines', '[.*],[.*]$', ['foo', 'bar']]
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Hàm tiện lợi, như

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

Hàm tiện lợi, như

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> prologue = '''{| class="wikitable"
... |-
... ! foo
... ! bar
... '''
>>> template = '''|-
... | {foo}
... | {bar}
... '''
>>> epilogue = '|}'
>>> etl.totext[table1, 'example.txt', template=template,
... prologue=prologue, epilogue=epilogue]
>>> # see what we did
... print[open['example.txt'].read[]]
{| class="wikitable"
|-
! foo
! bar
|-
| a
| 1
|-
| b
| 2
|-
| c
| 2
|}

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> prologue = '''{| class="wikitable"
... |-
... ! foo
... ! bar
... '''
>>> template = '''|-
... | {foo}
... | {bar}
... '''
>>> epilogue = '|}'
>>> etl.totext[table1, 'example.txt', template=template,
... prologue=prologue, epilogue=epilogue]
>>> # see what we did
... print[open['example.txt'].read[]]
{| class="wikitable"
|-
! foo
! bar
|-
| a
| 1
|-
| b
| 2
|-
| c
| 2
|}

Mẫu sẽ được sử dụng để định dạng từng hàng thông qua str.format.

Nối bảng vào một tệp văn bản.

Trả lại một bảng ghi các hàng vào một tệp văn bản khi chúng được lặp lại.

Tệp XML

Trích xuất dữ liệu từ một tệp XML. Ví dụ.:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Nếu các giá trị dữ liệu được lưu trữ trong một thuộc tính, hãy cung cấp tên thuộc tính như một đối số vị trí bổ sung:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Giá trị dữ liệu cũng có thể được trích xuất bằng cách cung cấp ánh xạ tên trường đến các đường dẫn phần tử:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Nếu LXML được cài đặt, các biểu thức XPath đầy đủ có thể được sử dụng.

Lưu ý rằng việc triển khai hiện không phát trực tuyến, tức là toàn bộ tài liệu được tải vào bộ nhớ.not streaming, i.e., the whole document is loaded into memory.

Nếu nhiều phần tử khớp với một trường đã cho, tất cả các giá trị được báo cáo là một tuple.

Nếu có nhiều hơn một tên phần tử được sử dụng cho các giá trị hàng, một bộ hoặc danh sách các đường dẫn có thể được cung cấp, ví dụ:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Tùy chọn một trình phân tích cú pháp tùy chỉnh có thể được cung cấp, ví dụ:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Viết bảng vào tệp XML mới theo các phần tử được xác định trong các đối số chức năng.

Các đối số gốc, đầu và hàng [chuỗi, tùy chọn] xác định các thẻ và việc làm tổ của tệp XML. Mỗi cái xác định các phần tử XML với các thẻ được phân tách bằng các dấu gạch chéo [/] như trong root/level/tag. Họ có thể có một số lượng thẻ tùy ý sẽ phản ánh ở các mức làm tổ nhiều hơn cho tiêu đề hoặc bản ghi/hàng được viết trong tệp XML.

Để biết chi tiết về cách đặt tên thẻ và quy tắc làm tổ, kiểm tra thông số kỹ thuật XML hoặc tham chiếu XML.

Đối số hàng xác định các phần tử cho mỗi hàng dữ liệu được ghi trong tệp XML. Khi được chỉ định, nó phải có ít nhất 2 thẻ để xác định các thẻ cho hàng/cột. Các thẻ bổ sung sẽ thêm lồng nhau kèm theo tất cả các bản ghi/hàng/đường.

Đối số đầu tương tự như các hàng, nhưng chỉ có một dòng/hàng tiêu đề với các tên trường. Khi được chỉ định, nó phải có ít nhất 2 thẻ cho các trường/tên và phần còn lại sẽ tăng làm tổ.

Đối số gốc xác định các phần tử bao gồm đầu và hàng và được yêu cầu khi sử dụng đầu để chỉ định các tài liệu XML hợp lệ.

Khi không có đối số nào được chỉ định, chúng sẽ mặc định cho các thẻ tạo ra đầu ra tương tự như bảng HTML: root = Bảng bảng, đầu = Hồi đó

Đối số mở đầu [chuỗi, tùy chọn] có thể là một đoạn của XML hợp lệ sẽ được chèn trước các yếu tố khác trong XML. Nó có thể tùy chọn chỉ định prolog XML của tệp.

Đối số của phần kết [chuỗi, tùy chọn] có thể là một đoạn của XML hợp lệ sẽ được chèn sau tất cả các phần tử XML khác ngoại trừ thẻ đóng gốc. Nó phải chỉ định thẻ đóng nếu đối số gốc không được chỉ định.

Đối số kiểu chọn định dạng của các phần tử trong tệp XML. Nó có thể là thẻ [mặc định], tên, thuộc tính hoặc chuỗi tùy chỉnh để định dạng mỗi hàng thông qua str.format.

Ví dụ sử dụng cho các tệp viết:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Hàm ToxMl [] chỉ là một trình bao bọc trên

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Mới trong phiên bản 1.7.0.

HTML Files¶

Viết bảng dưới dạng HTML vào một tệp. Ví dụ.:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Đối số từ khóa chú thích được sử dụng để cung cấp chú thích bảng trong HTML đầu ra.

Trả về một bảng ghi các hàng vào tệp HTML Unicode khi chúng được lặp lại.

Các tệp JSON

Trích xuất dữ liệu từ tệp JSON. Tệp phải chứa một mảng JSON làm đối tượng cấp cao nhất và mỗi thành viên của mảng sẽ được coi là một hàng dữ liệu. Ví dụ.:

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Đặt các dòng đối số thành true sẽ cho phép suy ra tài liệu dưới dạng tài liệu dòng JSON. Để biết thêm chi tiết về các dòng JSON, vui lòng truy cập //jsonlines.org/.

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Nếu tệp JSON của bạn không phù hợp với cấu trúc này, bạn sẽ cần phải phân tích nó qua

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

Đã thay đổi trong phiên bản 1.1.0.

Nếu không có tiêu đề nào được chỉ định, các trường sẽ được phát hiện bằng các khóa lấy mẫu từ các đối tượng mẫu đầu tiên trong nguồn. Tiêu đề sẽ được xây dựng từ các khóa theo thứ tự được phát hiện. Lưu ý rằng thứ tự này có thể không ổn định, và do đó có thể nên chỉ định một tiêu đề rõ ràng hoặc sử dụng một chức năng khác như

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Xem một chuỗi Python

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Các chế độ đối số cũng có thể là một trình tạo, đầu ra của trình tạo được lặp lại và được lưu trong bộ nhớ cach

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Nếu tiêu đề không được chỉ định, các mục mẫu từ dicts sẽ được kiểm tra đến các khóa từ điển Discovery. Lưu ý rằng thứ tự phát hiện ra các khóa từ điển có thể không ổn định,

Xem thêm

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Đã thay đổi trong phiên bản 1.1.0.

Nếu không có tiêu đề nào được chỉ định, các trường sẽ được phát hiện bằng các khóa lấy mẫu từ các từ điển mẫu đầu tiên trong Dicts. Tiêu đề sẽ được xây dựng từ các khóa theo thứ tự được phát hiện. Lưu ý rằng thứ tự này có thể không ổn định, và do đó có thể nên chỉ định một tiêu đề rõ ràng hoặc sử dụng một chức năng khác như

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Thay đổi trong phiên bản 1.7.5.

Hỗ trợ đầy đủ của các máy phát điện được thông qua khi dicts đã được thêm vào, tận dụng itertools.tee.

Thay đổi trong phiên bản 1.7.11.

Hỗ trợ máy phát đã được sửa đổi để sử dụng bộ đệm tệp tạm thời thay vì itertools.tee do sử dụng bộ nhớ cao.

Viết một bảng ở định dạng JSON, với đầu ra hàng dưới dạng đối tượng JSON. Ví dụ.:

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Lưu ý rằng điều này hiện không phát trực tuyến, tất cả dữ liệu được tải vào bộ nhớ trước khi được ghi vào tệp.

Viết một bảng ở định dạng JSON, với đầu ra hàng dưới dạng mảng JSON. Ví dụ.:

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Lưu ý rằng điều này hiện không phát trực tuyến, tất cả dữ liệu được tải vào bộ nhớ trước khi được ghi vào tệp.

________ 121 ________ 134 [bảng, nguồn = không, tiền tố = không, hậu tố = none, output_header = false

Viết một bảng ở định dạng JSON, với đầu ra hàng dưới dạng mảng JSON. Ví dụ.:

Python I/O Streams¶

Các lớp sau là Trợ giúp cho các hàm trích xuất [

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Một thể hiện của bất kỳ lớp nào sau đây có thể được sử dụng làm đối số

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

>>> import petl as etl
>>> # setup example file
... text = 'a,1\nb,2\nc,2\n'
>>> with open['example.txt', 'w'] as f:
...     f.write[text]
...
12
>>> table1 = etl.fromtext['example.txt']
>>> table1
+-------+
| lines |
+=======+
| 'a,1' |
+-------+
| 'b,2' |
+-------+
| 'c,2' |
+-------+

>>> # post-process, e.g., with capture[]
... table2 = table1.capture['lines', '[.*],[.*]$', ['foo', 'bar']]
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> import pickle
>>> # set up a file to demonstrate with
... with open['example.p', 'wb'] as f:
...     pickle.dump[['foo', 'bar'], f]
...     pickle.dump[['a', 1], f]
...     pickle.dump[['b', 2], f]
...     pickle.dump[['c', 2.5], f]
...
>>> # now demonstrate the use of frompickle[]
... table1 = etl.frompickle['example.p']
>>> table1
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' | 2.5 |
+-----+-----+

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.topickle[table1, 'example.p']
>>> # look what it did
... table2 = etl.frompickle['example.p']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' |   1 |
+-----+-----+
| 'b' |   2 |
+-----+-----+
| 'c' |   2 |
+-----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Hành vi của mỗi nguồn thường có thể được cấu hình bằng cách chuyển các đối số cho hàm tạo, xem mã nguồn của mô -đun

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Lớp ________ 146 ________ 147 [Nguồn] ¶ Lớp ________ 146 ________ 149 [Nguồn] Lớp ________ 146 ________ 151 [S = Không] [Nguồn] ¶

Cũng hỗ trợ nối thêm.

Lớp ________ 146 ________ 153 [*args, ** kwargs] [Nguồn] ¶remote I/O or compression use the following functions:

Để tạo Trợ lý tùy chỉnh cho I/O từ xa hoặc nén, hãy sử dụng các chức năng sau:

________ 146 ________ 155 [Giao thức, Handler_Class] [Nguồn] ¶

Đăng ký xử lý để đọc tự động bằng giao thức từ xa.

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Mới trong phiên bản 1.5.0.

________ 146 ________ 158 [Giao thức, Handler_Class] [Nguồn] ¶

Đăng ký xử lý để đọc tự động bằng giao thức từ xa.

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Mới trong phiên bản 1.5.0.

________ 146 ________ 158 [Giao thức, Handler_Class] [Nguồn] ¶

Việc sử dụng trình xử lý được xác định phù hợp với giao thức với phần sơ đồ của URL trong hàm

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

________ 146 ________ 158 [Giao thức, Handler_Class] [Nguồn] ¶

Đăng ký xử lý để viết tự động bằng giao thức từ xa.

Việc sử dụng trình xử lý được xác định phù hợp với giao thức với phần sơ đồ của URL trong hàm

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

36 [ví dụ: SMB: //].

________ 146 ________ 161 [Giao thức] [Nguồn] ¶

Lấy người xử lý chịu trách nhiệm đọc từ một giao thức từ xa.

Mới trong phiên bản 1.6.0.

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Lấy người xử lý chịu trách nhiệm viết từ một giao thức từ xa.

Xem mã nguồn của các lớp trong mô -đun

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Các định dạng tệp được hỗ trợ

Viết một bảng vào tệp .xls Excel mới.

Các tệp excel .xlsx [openpyxl] ¶

Ghi chú

Các chức năng sau yêu cầu OpenPyXL phải được cài đặt, ví dụ:

Trích xuất một bảng từ một tờ trong tệp .xlsx Excel.

N.B., tên trang tính nhạy cảm.

Đối số trang tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

Đối số Range_String có thể được sử dụng để cung cấp một chuỗi phạm vi chỉ định một loạt các ô để trích xuất.

Các đối số MIN_ROW, MIN_COL, MAX_ROW và MAX_COL có thể được sử dụng để giới hạn phạm vi của các ô để trích xuất. Họ sẽ bị bỏ qua nếu Range_String được cung cấp.

Đối số read_only xác định cách OpenPyXL trả về sổ làm việc được tải. Mặc định là sai vì nó ngăn chặn một số tệp libreoffice bị cắt ở 65536 hàng. Đúng phải nhanh hơn nếu việc sử dụng tệp chỉ đọc và các tệp được tạo bằng Microsoft Excel.

Bất kỳ đối số từ khóa nào khác được truyền qua

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Viết một bảng vào tệp .xlsx Excel mới.

N.B., tên trang tính nhạy cảm.

Đối số trang tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

• Đối số Range_String có thể được sử dụng để cung cấp một chuỗi phạm vi chỉ định một loạt các ô để trích xuất.
• Các đối số MIN_ROW, MIN_COL, MAX_ROW và MAX_COL có thể được sử dụng để giới hạn phạm vi của các ô để trích xuất. Họ sẽ bị bỏ qua nếu Range_String được cung cấp.
• Đối số read_only xác định cách OpenPyXL trả về sổ làm việc được tải. Mặc định là sai vì nó ngăn chặn một số tệp libreoffice bị cắt ở 65536 hàng. Đúng phải nhanh hơn nếu việc sử dụng tệp chỉ đọc và các tệp được tạo bằng Microsoft Excel.

Bất kỳ đối số từ khóa nào khác được truyền qua

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Viết một bảng vào tệp .xlsx Excel mới.

Đối số chế độ kiểm soát cách xử lý tệp và trang tính:

Ghi chú

Thay thế: Đây là mặc định. Nó hoặc thay thế hoặc thêm một tờ được đặt tên hoặc nếu không có tên trang tính nào được cung cấp, tất cả các tờ [ghi đè toàn bộ tệp].

Thêm: Thêm một tờ mới. Tăng valueError nếu một tờ được đặt tên đã tồn tại.

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

________ 169 ________ 175 [tbl, fileName, sheet = none, write_header = false] [Nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Nối các hàng vào tệp .xlsx Excel hiện có.

Các chức năng sau yêu cầu cài đặt Numpy, ví dụ:

Trích xuất một bảng từ một mảng có cấu trúc numpy, ví dụ:

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

________ 176 ________ 179 [Bảng, dtype = none, Count = -1, sample = 1000] [Nguồn] ¶

Ghi chú

Tải dữ liệu từ bảng đã cho vào một mảng có cấu trúc numpy. Ví dụ.:

________ 176 ________ 181 [*args, ** kwargs] [Nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

________ 176 ________ 184 [vals, dtype = none, Count = -1, sample = 1000] [Nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Tải các giá trị từ cột bảng vào một mảng numpy, ví dụ:

Ghi chú

DataFrames [gấu trúc] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

________ 185 ________ 186 [DF, bao gồm_index = false] [Nguồn] ¶

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

________ 185 ________ 188 [bảng, index = none, exclude = none

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

Tệp HDF5 [PyTables] ¶

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

A

Cung cấp quyền truy cập vào bảng HDF5. Ví dụ.:

Ghi chú

A

________ 189 ________ 194 [Bảng, Nguồn, trong đó = none, name = none, created = false , mẫu = 1000] [Nguồn] ¶

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

Viết vào bảng HDF5. Nếu tạo là sai, giả sử bảng đã tồn tại và cố gắng cắt ngắn nó trước khi tải. Nếu tạo là đúng, một bảng mới sẽ được tạo và nếu thả là đúng, bất kỳ bảng hiện tại nào sẽ bị bỏ trước. Nếu mô tả là không, mô tả sẽ được đoán. Ví dụ.:

________ 189 ________ 196 [Bảng, Nguồn, trong đó = Không, Tên = Không] [Nguồn] ¶

Như

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Tải dữ liệu vào Bcolz CTable, ví dụ:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

Các đối số từ khóa khác được chuyển qua hàm tạo CTable.

Mới trong phiên bản 1.1.0.

Chụp dữ liệu vào một ctable bcolz. Đối số OBJ có thể là CTable hiện có hoặc tên của thư mục là CTable trên đĩa được lưu trữ.

Mới trong phiên bản 1.1.0.

________ 198 ________ 203 [Bảng, OBJ, Check_names = true] [Nguồn] ¶

Chụp dữ liệu vào một ctable bcolz. Đối số OBJ có thể là CTable hiện có hoặc tên của thư mục là CTable trên đĩa được lưu trữ.

Chỉ số văn bản [whoosh] ¶

Các chức năng sau yêu cầu whoosh phải được cài đặt, ví dụ:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

________ 204 ________ 205 [index_or_dirname, indexName = none, docnum_field = none] [nguồn] ¶

Từ khóa đối số:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

________ 204 ________ 205 [index_or_dirname, indexName = none, docnum_field = none] [nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Từ khóa đối số:

________ 204 ________ 205 [index_or_dirname, indexName = none, docnum_field = none] [nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Từ khóa đối số:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

________ 204 ________ 205 [index_or_dirname, indexName = none, docnum_field = none] [nguồn] ¶

Từ khóa đối số:

________ 204 ________ 205 [index_or_dirname, indexName = none, docnum_field = none] [nguồn] ¶

Tệp Avro [Fastavro] ¶

Ghi chú

Các chức năng sau yêu cầu Fastavro phải được cài đặt, ví dụ:

Trích xuất một bảng từ các bản ghi của tệp AVRO.

Đối số nguồn [chuỗi hoặc tệp giống như tệp hoặc fastavro.reader] có thể là đường dẫn của tệp, luồng đầu vào giống như tệp hoặc một phiên bản từ fastavro.reader.

Các đối số giới hạn và bỏ qua có thể được sử dụng để giới hạn phạm vi của các hàng để trích xuất.

Đối số mẫu [int, tùy chọn] xác định số lượng hàng được kiểm tra để khám phá các loại trường và xây dựng một lược đồ cho tệp AVRO khi đối số lược đồ không được truyền.

Các trường hàng được đọc từ tệp có thể có các giá trị vô hướng như int, chuỗi, float, dateTime, ngày và thập phân nhưng cũng có thể có các loại hỗn hợp như enum, mảng, bản đồ, liên minh và ghi. Các loại trường cũng có thể có các cấu trúc đệ quy được xác định trong các lược đồ phức tạp.array, map, union and record. The fields types can also have recursive structures defined in complex schemas.

Ngoài ra các loại với các loại logic được đọc và dịch thành các loại python: thời gian dài thời gian dài và thời gian dài-micros: datetime.datetime, int date: datetime.date, byte thập phân và số thập phân cố định: thập phân, int thời gian và dài Thời gian-micros: DateTime.time.logical types types are read and translated to coresponding python types: long timestamp-millis and long timestamp-micros: datetime.datetime, int date: datetime.date, bytes decimal and fixed decimal: Decimal, int time-millis and long time-micros: datetime.time.

Ví dụ sử dụng để đọc tệp:

>>> cols = [[0, 1, 2], ['a', 'b']]
>>> tbl = etl.fromcolumns[cols, missing='NA']
>>> tbl
+----+------+
| f0 | f1   |
+====+======+
|  0 | 'a'  |
+----+------+
|  1 | 'b'  |
+----+------+
|  2 | 'NA' |
+----+------+

Mới trong phiên bản 1.4.0.

Viết bảng vào một tệp AVRO mới theo lược đồ được thông qua.

Phương thức này giả định rằng mỗi cột có các giá trị có cùng loại cho tất cả các hàng của bảng nguồn.

Apache Avro là một khung tuần tự hóa dữ liệu. Nó được sử dụng trong tuần tự hóa dữ liệu [đặc biệt là trong hệ sinh thái Hadoop], cho các giao thức DataExchange cho cơ sở dữ liệu [RedShift] và các giao thức RPC [như trong Kafka]. Nó có các thư viện để hỗ trợ nhiều ngôn ngữ và thường nhanh hơn và an toàn hơn các định dạng văn bản như JSON, XML hoặc CSV.

Đối số đích là đường dẫn tệp để tạo tệp AVRO. Lưu ý rằng nếu một tệp đã tồn tại tại vị trí đã cho, nó sẽ bị ghi đè.

Đối số lược đồ [DICT] xác định cấu trúc trường hàng của tệp. Kiểm tra tài liệu Fastavro và tham chiếu lược đồ AVRO để biết chi tiết.

Đối số mẫu [int, tùy chọn] xác định số lượng hàng được kiểm tra để khám phá các loại trường và xây dựng một lược đồ cho tệp AVRO khi đối số lược đồ không được truyền.

Các trường hàng được đọc từ tệp có thể có các giá trị vô hướng như int, chuỗi, float, dateTime, ngày và thập phân nhưng cũng có thể có các loại hỗn hợp như enum, mảng, bản đồ, liên minh và ghi. Các loại trường cũng có thể có các cấu trúc đệ quy được xác định trong các lược đồ phức tạp.

Ngoài ra các loại với các loại logic được đọc và dịch thành các loại python: thời gian dài thời gian dài và thời gian dài-micros: datetime.datetime, int date: datetime.date, byte thập phân và số thập phân cố định: thập phân, int thời gian và dài Thời gian-micros: DateTime.time.

Ví dụ sử dụng để đọc tệp:

Mới trong phiên bản 1.4.0.

Aarray, map, union, record, and recursive types defined in complex schemas.

Viết bảng vào một tệp AVRO mới theo lược đồ được thông qua.logical types are supported and translated to coresponding python types: long timestamp-millis, long timestamp-micros, int date, bytes decimal, fixed decimal, string uuid, int time-millis, long time-micros.

Phương thức này giả định rằng mỗi cột có các giá trị có cùng loại cho tất cả các hàng của bảng nguồn.

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Mới trong phiên bản 1.4.0.

Viết bảng vào một tệp AVRO mới theo lược đồ được thông qua.

Phương thức này giả định rằng mỗi cột có các giá trị có cùng loại cho tất cả các hàng của bảng nguồn.

Apache Avro là một khung tuần tự hóa dữ liệu. Nó được sử dụng trong tuần tự hóa dữ liệu [đặc biệt là trong hệ sinh thái Hadoop], cho các giao thức DataExchange cho cơ sở dữ liệu [RedShift] và các giao thức RPC [như trong Kafka]. Nó có các thư viện để hỗ trợ nhiều ngôn ngữ và thường nhanh hơn và an toàn hơn các định dạng văn bản như JSON, XML hoặc CSV.

Đối số mẫu [int, tùy chọn] xác định số lượng hàng được kiểm tra để khám phá các loại trường và xây dựng một lược đồ cho tệp AVRO khi đối số lược đồ không được truyền.

Ví dụ sử dụng để đọc tệp:

Mới trong phiên bản 1.4.0.

Mới trong phiên bản 1.4.0.

A¶

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Viết bảng vào một tệp AVRO mới theo lược đồ được thông qua.¶

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Phương thức này giả định rằng mỗi cột có các giá trị có cùng loại cho tất cả các hàng của bảng nguồn.¶

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Ví dụ về lược đồ avro phức tạp đệ quy¶

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Google Sheets [GSpread] ¶

Cảnh báo

Đây là một tính năng thử nghiệm. API và hành vi có thể thay đổi giữa các bản phát hành với một số thay đổi có thể phá vỡ.

Ghi chú

Các chức năng sau yêu cầu cài đặt GSPREAD, ví dụ:

Trích xuất một bảng từ bảng tính Google.

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

Bảng tính có thể là khóa của bảng tính hoặc tên của nó.

Đối số bảng tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

Đối số cell_range có thể được sử dụng để cung cấp một chuỗi phạm vi chỉ định các góc bên trái và dưới cùng bên phải của một tập hợp các ô để trích xuất. [tức là ‘A1: C7,].

Đặt open_by_key thành true để coi bảng tính là khóa bảng tính.

Ghi chú

• Các chức năng sau yêu cầu cài đặt GSPREAD, ví dụ:
• ________ 221 ________ 222 [thông tin xác thực_or_client, bảng tính, bảng tính = none, cell_range = none

Trích xuất một bảng từ bảng tính Google.

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

Đối số bảng tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

Bảng tính có thể là khóa của bảng tính hoặc tên của nó.

Đối số bảng tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

Đối số cell_range có thể được sử dụng để cung cấp một chuỗi phạm vi chỉ định các góc bên trái và dưới cùng bên phải của một tập hợp các ô để trích xuất. [tức là ‘A1: C7,].

Đặt open_by_key thành true để coi bảng tính là khóa bảng tính.

Ghi chú

Các chức năng sau yêu cầu cài đặt GSPREAD, ví dụ:

________ 221 ________ 222 [thông tin xác thực_or_client, bảng tính, bảng tính = none, cell_range = none

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

Bảng tính có thể là khóa của bảng tính hoặc tên của nó.

Đối số bảng tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

Đặt open_by_key thành true để coi bảng tính là khóa bảng tính.

Chỉ có cấp cao nhất của Google Drive sẽ được tìm kiếm tên tệp bảng tính do các giới hạn API.

Ghi chú

Các chức năng sau yêu cầu cài đặt GSPREAD, ví dụ:

________ 221 ________ 222 [thông tin xác thực_or_client, bảng tính, bảng tính = none, cell_range = none

Ghi chú

Các chức năng sau yêu cầu cài đặt GSPREAD, ví dụ:

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Trích xuất một bảng từ bảng tính Google.

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Thông tin đăng nhập_or_client được sử dụng để xác thực với API Google. Để biết thêm thông tin, kiểm tra xác thực.

>>> import petl as etl
>>> import csv
>>> # set up a CSV file to demonstrate with
... table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> with open['example.csv', 'w'] as f:
...     writer = csv.writer[f]
...     writer.writerows[table1]
...
>>> # now demonstrate the use of fromcsv[]
... table2 = etl.fromcsv['example.csv']
>>> table2
+-----+-----+
| foo | bar |
+=====+=====+
| 'a' | '1' |
+-----+-----+
| 'b' | '2' |
+-----+-----+
| 'c' | '2' |
+-----+-----+

Bảng tính có thể là khóa của bảng tính hoặc tên của nó.

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Đối số bảng tính có thể được bỏ qua, trong trường hợp đó bảng đầu tiên trong sổ làm việc được sử dụng theo mặc định.

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Đối số cell_range có thể được sử dụng để cung cấp một chuỗi phạm vi chỉ định các góc bên trái và dưới cùng bên phải của một tập hợp các ô để trích xuất. [tức là ‘A1: C7,].

Đặt open_by_key thành true để coi bảng tính là khóa bảng tính.

Chỉ có cấp cao nhất của Google Drive sẽ được tìm kiếm tên tệp bảng tính do các giới hạn API.

Tên bảng tính là trường hợp nhạy cảm.

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Ví dụ sử dụng theo sau:

• //initd.org/psycopg/docs/usage.html#server-side-cursors
• //mysql-python.sourceforge.net/MySQLdb.html#using-and-extending

A

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

N.B., Đối với MySQL, câu lệnh

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Một con trỏ cũng có thể được cung cấp thay vì kết nối, ví dụ:

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Tham số DBO cũng có thể là một động cơ SQLalchemy, phiên hoặc đối tượng kết nối.

Tham số DBO cũng có thể là một chuỗi, trong trường hợp nó được hiểu là tên của một tệp chứa cơ sở dữ liệu

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Nếu

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Từ khóa đối số:

Ghi chú

Hàm này về nguyên tắc tương thích với bất kỳ trình điều khiển cơ sở dữ liệu tuân thủ DB-API 2.0 nào. Tuy nhiên, tại thời điểm viết một số triển khai DB-API 2.0, bao gồm CX_ORACLE và đầu nối/Python của MySQL, không tương thích với chức năng này, bởi vì họ chỉ chấp nhận một đối số danh sách đối với hàm con trỏ.executemany [] được gọi là nội bộ bởi

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Tuy nhiên, lưu ý rằng điều này ngụ ý tải toàn bộ bảng vào bộ nhớ dưới dạng danh sách trước khi chèn vào cơ sở dữ liệu.

Tải dữ liệu vào bảng cơ sở dữ liệu hiện có thông qua kết nối DB-API 2.0 hoặc con trỏ. Vì

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Hệ thống tập tin từ xa và đám mây

Các lớp sau là Trợ giúp để đọc [

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Không cần phải khởi tạo chúng. Chúng được sử dụng trong Mecanism được mô tả trong chiết xuất và tải.Extract and Load.

Nó có thể đọc và viết chỉ bằng cách đặt tiền tố giao thức [ví dụ: s3: //] trong đường dẫn nguồn của tệp.

Ghi chú

Hàm này về nguyên tắc tương thích với bất kỳ trình điều khiển cơ sở dữ liệu tuân thủ DB-API 2.0 nào. Tuy nhiên, tại thời điểm viết một số triển khai DB-API 2.0, bao gồm CX_ORACLE và đầu nối/Python của MySQL, không tương thích với chức năng này, bởi vì họ chỉ chấp nhận một đối số danh sách đối với hàm con trỏ.executemany [] được gọi là nội bộ bởi

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Tuy nhiên, lưu ý rằng điều này ngụ ý tải toàn bộ bảng vào bộ nhớ dưới dạng danh sách trước khi chèn vào cơ sở dữ liệu.

• ________ 227 ________ 240 [Bảng, DBO, TableName, Schema = none, cam kết = true] [Nguồn] ¶
• Tải dữ liệu vào bảng cơ sở dữ liệu hiện có thông qua kết nối DB-API 2.0 hoặc con trỏ. Vì

  >>> import petl as etl
  >>> cols = [[0, 1, 2], ['a', 'b', 'c']]
  >>> tbl = etl.fromcolumns[cols]
  >>> tbl
  +----+-----+
  | f0 | f1  |
  +====+=====+
  |  0 | 'a' |
  +----+-----+
  |  1 | 'b' |
  +----+-----+
  |  2 | 'c' |
  +----+-----+
  

  41 ngoại trừ bảng cơ sở dữ liệu sẽ được nối thêm, tức là, dữ liệu mới sẽ được chèn vào bảng và bất kỳ hàng hiện tại nào cũng sẽ vẫn còn.

Hệ thống tập tin từ xa và đám mây

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Không cần phải khởi tạo chúng. Chúng được sử dụng trong Mecanism được mô tả trong chiết xuất và tải.

Nó có thể đọc và viết chỉ bằng cách đặt tiền tố giao thức [ví dụ: s3: //] trong đường dẫn nguồn của tệp.

Để đọc và ghi vào các hệ thống tập tin từ xa, các chức năng sau đây yêu cầu FSSPEC được cài đặt dọc theo gói PETL, ví dụ::

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Các hệ thống tập tin được hỗ trợ với các định dạng URI của chúng có thể được tìm thấy trong tài liệu FSSPEC:

Triển khai tích hợp

Ghi chú

Hàm này về nguyên tắc tương thích với bất kỳ trình điều khiển cơ sở dữ liệu tuân thủ DB-API 2.0 nào. Tuy nhiên, tại thời điểm viết một số triển khai DB-API 2.0, bao gồm CX_ORACLE và đầu nối/Python của MySQL, không tương thích với chức năng này, bởi vì họ chỉ chấp nhận một đối số danh sách đối với hàm con trỏ.executemany [] được gọi là nội bộ bởi

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Tuy nhiên, lưu ý rằng điều này ngụ ý tải toàn bộ bảng vào bộ nhớ dưới dạng danh sách trước khi chèn vào cơ sở dữ liệu.

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

________ 227 ________ 240 [Bảng, DBO, TableName, Schema = none, cam kết = true] [Nguồn] ¶

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

Hệ thống tập tin từ xa và đám mây

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Các lớp sau là Trợ giúp để đọc [

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

Không cần phải khởi tạo chúng. Chúng được sử dụng trong Mecanism được mô tả trong chiết xuất và tải.

Nó có thể đọc và viết chỉ bằng cách đặt tiền tố giao thức [ví dụ: s3: //] trong đường dẫn nguồn của tệp.

Ghi chú

Hàm này về nguyên tắc tương thích với bất kỳ trình điều khiển cơ sở dữ liệu tuân thủ DB-API 2.0 nào. Tuy nhiên, tại thời điểm viết một số triển khai DB-API 2.0, bao gồm CX_ORACLE và đầu nối/Python của MySQL, không tương thích với chức năng này, bởi vì họ chỉ chấp nhận một đối số danh sách đối với hàm con trỏ.executemany [] được gọi là nội bộ bởi

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

>>> import petl as etl
>>> table1 = [['foo', 'bar'],
...           ['a', 1],
...           ['b', 2],
...           ['c', 2]]
>>> etl.tocsv[table1, 'example.csv']
>>> # look what it did
... print[open['example.csv'].read[]]
foo,bar
a,1
b,2
c,2

Tuy nhiên, lưu ý rằng điều này ngụ ý tải toàn bộ bảng vào bộ nhớ dưới dạng danh sách trước khi chèn vào cơ sở dữ liệu.

________ 227 ________ 240 [Bảng, DBO, TableName, Schema = none, cam kết = true] [Nguồn] ¶

Những người trợ giúp sau đây không được dùng và sẽ bị xóa trong phiên bản trong tương lai.

Chức năng của nó đã được thay thế bởi người trợ giúp trong người trợ giúp từ xa.Remote helpers.

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+

import pandas
pandas.read_table['myfile.tbl', comment='#', delim_whitespace=True]

>>> import petl as etl
>>> cols = [[0, 1, 2], ['a', 'b', 'c']]
>>> tbl = etl.fromcolumns[cols]
>>> tbl
+----+-----+
| f0 | f1  |
+====+=====+
|  0 | 'a' |
+----+-----+
|  1 | 'b' |
+----+-----+
|  2 | 'c' |
+----+-----+