Hướng dẫn create table from array python - tạo bảng từ mảng python

Question

Vì vậy, tôi đã chuyển đổi một CSV có tên trong một cột và giá trị trong cột thứ hai thành hai mảng, một mảng cho tên và một mảng cho các giá trị. Tôi muốn chuyển đổi nó thành một bảng đánh đồng hai, vì vậy mục đầu tiên trong mảng tên được liên kết với mục đầu tiên trong giá trị. Làm thế nào để tôi làm điều này?

Nội dung chính Show

Thành lập¶
Tạo từ đầu
Danh sách các cột
Diễn ngôn của cột

Một >>> Table([t['c'], t['a']]) c a str1 int32 ---- ----- x 1 y 4 3 của dữ liệu cột có thể được sử dụng để khởi tạo >>> t = QTable() >>> t['a'] = [1, 4] >>> t['b'] = [2.0, 5.0] * u.cm / u.s >>> t['c'] = ['x', 'y'] >>> type(t['b']) 4:

Mảng có cấu trúc numpy

Mảng đồng nhất không có

Từ một bảng hiện có

Mảng trống có kích thước đã biết

Sao chép Versus Reference¶

Các lớp học và bảng tính bảng tính

TableColonns¶

Bảng phân lớp

Thêm các thuộc tính bảng tùy chỉnh

Thay đổi hành vi của các đối tượng lớp nội bộ

Cột và số lượng

Đối tượng giống như bảng

import csv

data = csv.reader(open('C:\\Users\\Grant\\Documents\\finalproject\\centers.csv', 'r'), delimiter=",", quotechar='|')
names, values = [], []

for row in data:
    names.append(row[0])
    values.append(row[1])

Joe Iddon

Huy hiệu vàng 19,6K77 gold badges32 silver badges51 bronze badges

Đã hỏi ngày 2 tháng 12 năm 2017 lúc 20:01Dec 2, 2017 at 20:01

5

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

Đã trả lời ngày 2 tháng 12 năm 2017 lúc 20:10Dec 2, 2017 at 20:10

Pahopahopaho

1.1229 huy hiệu bạc13 huy hiệu đồng9 silver badges13 bronze badges

2

Vì bạn nói

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

0, tôi sẽ đề nghị bạn đi với DataFrames bởi Pandas.

Giả sử danh sách tên của bạn là

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

1 và danh sách giá trị là

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

2,

Bạn có thể có một cái gì đó như:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

Tất nhiên bạn phải

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

3 trước.

Điều này sẽ cung cấp cho bạn một "bảng" (hoặc dataFrame?) Giống như:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

Đọc thêm ở đây.

Đã trả lời ngày 2 tháng 12 năm 2017 lúc 20:11Dec 2, 2017 at 20:11

Hướng dẫn create table from array python - tạo bảng từ mảng python

Sayan Silsayan SilSayan Sil

5.3803 Huy hiệu vàng15 Huy hiệu bạc31 Huy hiệu đồng3 gold badges15 silver badges31 bronze badges

Có rất nhiều sự linh hoạt trong cách mà một bảng có thể được xây dựng ban đầu. Chi tiết về các đầu vào cho các hàm tạo

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 và

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 nằm trong phần chi tiết khởi tạo. Tuy nhiên, cách tốt nhất để hiểu làm thế nào để làm một bảng là ví dụ.

Ví dụ;

Thành lập¶

Đối với các ví dụ sau, bạn cần nhập các lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5,

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 và

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 cùng với gói đơn vị và số lượng (astropy.units) và gói

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9:Units and Quantities (astropy.units) package and the

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 package:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

Tạo từ đầu

Một

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 có thể được tạo mà không cần bất kỳ dữ liệu đầu vào ban đầu nào hoặc thậm chí không có bất kỳ cột ban đầu nào. Điều này rất hữu ích cho việc xây dựng các bảng một cách linh hoạt nếu kích thước, cột hoặc dữ liệu ban đầu không được biết đến.

Ghi chú

Thêm các hàng yêu cầu tạo một bản sao mới của toàn bộ bảng mỗi lần, vì vậy trong trường hợp các bảng lớn, điều này có thể chậm. Mặt khác, thêm các cột là nhanh.

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

Nếu các cột dữ liệu của bạn có các đơn vị vật lý được liên kết với chúng thì chúng tôi khuyên bạn nên sử dụng lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5. Điều này sẽ cho phép cột được lưu trữ trong bảng dưới dạng

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 bản địa và mang toàn bộ sức mạnh của các đơn vị và số lượng (astropy.units) vào bảng. Xem số lượng và QTABLE để biết chi tiết.Units and Quantities (astropy.units) to the table. See Quantity and QTable for details.

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

Danh sách các cột

Một trường hợp điển hình là nơi bạn có một số cột dữ liệu có cùng độ dài được xác định trong các biến khác nhau. Đây có thể là danh sách Python hoặc mảng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 hoặc kết hợp cả hai. Chúng có thể được sử dụng để tạo

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 bằng cách đặt các biến dữ liệu cột vào danh sách Python. Trong trường hợp này, các tên cột không được xác định bởi dữ liệu đầu vào, do đó chúng phải được đặt bằng từ khóa

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 hoặc chúng sẽ được tạo tự động là

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y6.

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y

Tạo một bảng mới sử dụng các cột từ bảng đầu tiên

Khi bạn có

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4, thì bạn có thể tạo một bảng mới bằng cách chọn các cột và đặt chúng vào danh sách Python (ví dụ:

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y8):

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 4

Tạo một bảng mới bằng cách sử dụng các biểu thức liên quan đến các cột

Đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 có nguồn gốc từ tiêu chuẩn

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 và có thể được sử dụng trực tiếp trong các biểu thức số học. Điều này cho phép một cách nhỏ gọn để tạo một bảng mới với các giá trị cột được sửa đổi:

>>> Table([t['a']**2, t['b'] + 10])

a bint32 float64----- ------- 1 12.0 16 15.0

Các loại dữ liệu cột khác nhau

Phương thức đầu vào danh sách cho

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 rất linh hoạt vì bạn có thể sử dụng hỗn hợp các loại dữ liệu khác nhau để khởi tạo bảng:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

0

Lưu ý rằng trong cột thứ ba, tên cột hiện có

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 42 được sử dụng.

Diễn ngôn của cột

Một

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 của dữ liệu cột có thể được sử dụng để khởi tạo

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

1

Chỉ định thứ tự cột và tùy chọn các kiểu dữ liệu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

2

Các loại dữ liệu cột khác nhau

Phương thức đầu vào danh sách cho

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 rất linh hoạt vì bạn có thể sử dụng hỗn hợp các loại dữ liệu khác nhau để khởi tạo bảng:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

3

Lưu ý rằng trong cột thứ ba, tên cột hiện có

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 42 được sử dụng.

Diễn ngôn của cột

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

4

Một >>> Table([t['c'], t['a']])

c a str1 int32 ---- ----- x 1 y 4 3 của dữ liệu cột có thể được sử dụng để khởi tạo >>> t = QTable() >>> t['a'] = [1, 4] >>> t['b'] = [2.0, 5.0] * u.cm / u.s >>> t['c'] = ['x', 'y'] >>> type(t['b']) 4:

Chỉ định thứ tự cột và tùy chọn các kiểu dữ liệu

Dữ liệu cột đầu vào có thể là bất kỳ loại dữ liệu nào có thể khởi tạo đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8:

Lưu ý rằng khóa

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 46 được ưu tiên hơn tên cột hiện có

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 42 trong cột thứ ba. Cũng thấy rằng cột

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 48 là một cột vector trong đó mỗi phần tử hàng là một mảng hai phần tử.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

5

Đổi tên các cột là không thể

Dữ liệu hàng

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

6

Dữ liệu định hướng hàng có thể được sử dụng để tạo bảng bằng đối số từ khóa

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 49.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

7

Liệt kê hoặc tuple của hồ sơ dữ liệu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

8

Nếu bạn có dữ liệu đầu vào định hướng hàng như danh sách các bản ghi, bạn cần sử dụng từ khóa

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 49 để tạo bảng:

Danh sách các đối tượng Dict

Bạn cũng có thể khởi tạo một bảng với các giá trị hàng. Điều này được xây dựng như một danh sách các đối tượng

>>> Table([t['c'], t['a']])

c a str1 int32 ---- ----- x 1 y 4 3. Các phím xác định tên cột:

Nếu có các phím bị thiếu trong một hoặc nhiều hàng thì các giá trị tương ứng sẽ được đánh dấu là thiếu (mặt nạ):

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

0

Bạn có thể chỉ định thứ tự cột với đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5:

Ghi chú

Thêm các hàng yêu cầu tạo một bản sao mới của toàn bộ bảng mỗi lần, vì vậy trong trường hợp các bảng lớn, điều này có thể chậm. Mặt khác, thêm các cột là nhanh.

Mảng có cấu trúc numpy

Mảng có cấu trúc là cơ chế tiêu chuẩn trong

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 để lưu trữ dữ liệu bảng không đồng nhất. Hầu hết các gói I/O khoa học đọc các tệp bảng (ví dụ:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

04,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

05 và Asciable) sẽ trả lại bảng trong một đối tượng dựa trên mảng có cấu trúc. Một mảng có cấu trúc có thể được tạo bằng cách sử dụng:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

1

Từ

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

06 có thể tạo đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 tương ứng:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

2

Lưu ý rằng trong ví dụ trên và hầu hết các ví dụ sau đây, chúng tôi đang tạo một bảng và ngay lập tức yêu cầu trình thông dịch Python tương tác in bảng để xem những gì chúng tôi đã làm. Trong mã thực, bạn có thể làm một cái gì đó như:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

3

Mảng có cấu trúc như một cột

Trong một số trường hợp, thuận tiện để bao gồm một mảng có cấu trúc như một cột duy nhất trong bảng. Lớp

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

08 là một trường hợp trong Astropy trong đó điều này được thực hiện, trong đó cột có cấu trúc có ba yếu tố

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

09,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

10 và

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

11. Một ví dụ khác sẽ là một tham số mô hình có giá trị, giá trị được phép tối thiểu và giá trị được phép tối đa. Ở đây chúng tôi chứng minh bao gồm cả mảng có cấu trúc đơn giản được xác định trước đây là cột:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

4

Bạn có thể truy cập hoặc in một trường duy nhất trong cột có cấu trúc như sau:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

5

Tên cột mới

Các tên cột có thể được thay đổi từ các giá trị ban đầu bằng cách cung cấp đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

6

Các loại dữ liệu mới

Kiểu dữ liệu cho mỗi cột cũng có thể được thay đổi với

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

7

Mảng đồng nhất không có

Một mảng 1D

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 được coi là một bảng hàng duy nhất trong đó mỗi phần tử của mảng tương ứng với một cột:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

8

Một mảng 2D

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 (trong đó tất cả các phần tử có cùng loại) cũng có thể được chuyển đổi thành

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4. Trong trường hợp này, các tên cột không được người dùng chỉ định và phải được cung cấp bởi người dùng hoặc sẽ được tạo tự động dưới dạng

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y6 trong đó

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

18 là số cột.

Ví dụ cơ bản với tên cột tự động

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

9

Tên và loại cột được chỉ định

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

0

Tham khảo dữ liệu gốc

Có thể tham chiếu dữ liệu gốc miễn là các loại dữ liệu không được thay đổi:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

1

Xem phần Bản sao so với tham chiếu để biết thêm thông tin.

Mảng python so với mảng numpy làm đầu vào

Có một vấn đề hơi tinh tế, rất quan trọng để hiểu về cách tạo ra các đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4. Bất kỳ đầu vào dữ liệu nào trông giống như Python

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20 (bao gồm cả

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

21) được coi là một danh sách các cột. Ngược lại, đầu vào

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 đồng nhất được hiểu là danh sách các hàng:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

2

Sự phân đôi này là cần thiết để hỗ trợ đầu vào danh sách linh hoạt trong khi vẫn giữ được sự giải thích tự nhiên của các mảng 2D

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 trong đó chỉ mục đầu tiên tương ứng với dữ liệu của các hàng và chỉ số thứ hai tương ứng với các cột dữ liệu.

Từ một bảng hiện có

Một bảng mới có thể được tạo bằng cách chọn một tập hợp con của các cột trong một bảng hiện có:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

3

Một cách khác là sử dụng thuộc tính

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

24 (được giải thích trong phần bảng tính) để khởi tạo một bảng mới. Điều này cho phép bạn chọn các cột theo chỉ mục số hoặc tên của họ và hỗ trợ cú pháp cắt:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

4

Để tạo một bản sao của một bảng hiện có trống (không có hàng):

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

5

Mảng trống có kích thước đã biết

Nếu bạn biết kích thước mà bảng của bạn sẽ là, nhưng không biết trước các giá trị, bạn có thể tạo

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 không và xây dựng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 từ nó:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

6

Ví dụ: sau đó bạn có thể điền vào hàng bảng này theo từng hàng với các giá trị được trích xuất từ một bảng khác hoặc được tạo khi đang bay:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

7

Chi tiết khởi tạo Jo

Một đối tượng bảng được tạo bằng cách khởi tạo đối tượng lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 với các đối số sau, tất cả đều là tùy chọn:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 hoặc đối tượng giống như bảng, tùy chọn

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4, or table-like object, optional

Dữ liệu để khởi tạo bảng.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

33

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, optional

Chỉ định xem bảng có bị che dấu không.

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20, optional

Chỉ định tên cột.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20, optional

Chỉ định các loại dữ liệu cột.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

39

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, tùy chọn

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, optional

Siêu dữ liệu liên quan đến bảng.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, optional

Sao chép dữ liệu đầu vào. Nếu đầu vào là

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

39 luôn được sao chép bất kể tham số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41. Mặc định là

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

46.

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 49

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20 của Danh sách, Tùy chọn

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20 of lists, optional

Dữ liệu định hướng hàng cho bảng thay vì đối số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

51

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34, optional

Sao chép bất kỳ chỉ số nào trong dữ liệu đầu vào. Mặc định là

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

46.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

54

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, optional

Liệt kê hoặc độc lực của các đơn vị để áp dụng cho các cột.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

57

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, optional

Liệt kê hoặc bắt buộc các mô tả để áp dụng cho các cột.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, tùy chọn

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, optional

Từ khóa bổ sung Args khi chuyển đổi đối tượng giống như bảng.

Các tiểu mục sau đây cung cấp thêm chi tiết về các giá trị và tùy chọn cho từng đối số từ khóa có thể được sử dụng để tạo một đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 mới.

dữ liệu¶

Đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 có thể được khởi tạo với một số hình thức khác nhau cho đối số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00.

Numpy Ndarray (mảng có cấu trúc)

Tên cột cơ sở là tên trường của mảng có cấu trúc

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00. Danh sách

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 (tùy chọn) có thể được sử dụng để chọn các trường cụ thể và/hoặc sắp xếp lại các tên cơ sở. Danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 (tùy chọn) phải khớp với độ dài của

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 và được sử dụng để ghi đè các loại

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 hiện có.

Numpy Ndarray (đồng nhất)

Nếu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 là

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 một chiều thì nó được coi là một bảng hàng duy nhất trong đó mỗi phần tử của mảng tương ứng với một cột.

Nếu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 là

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 ít nhất hai chiều, thì chỉ số thứ nhất (nhất bên trái) tương ứng với số hàng (chiều dài bảng) và chỉ số thứ hai tương ứng với số cột (chiều rộng bảng). Kích thước cao hơn được hấp thụ trong hình dạng của mỗi ô bảng.

Nếu được cung cấp, danh sách

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 phải phù hợp với chiều rộng của nhóm của đối số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00. Mặc định cho

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 là tự động tạo tên cột trong mẫu

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y6. Nếu được cung cấp, danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 ghi đè các loại cột cơ sở và phải khớp với độ dài của

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5.

dict-like

Các khóa của đối tượng

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 xác định tên cột cơ sở. Các giá trị tương ứng có thể là các đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8, mảng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 hoặc các đối tượng giống như danh sách. Danh sách

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 (tùy chọn) có thể được sử dụng để chọn các trường cụ thể và/hoặc sắp xếp lại các tên cơ sở. Danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 (tùy chọn) phải khớp với độ dài của

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 và được sử dụng để ghi đè các loại dữ liệu hiện có hoặc mặc định.

list-like

Mỗi mục trong danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 cung cấp một cột các giá trị dữ liệu và có thể là đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 hoặc đối tượng giống như danh sách. Danh sách

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 xác định tên của mỗi cột. Các tên sẽ được tạo tự động nếu không được cung cấp (với đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 hoặc bởi các đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8). Nếu được cung cấp, đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 phải khớp với số lượng mục trong danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00. Danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 tùy chọn sẽ ghi đè các loại dữ liệu hiện có hoặc mặc định và phải khớp với độ dài

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5.

list-of-dicts

Tương tự như Python, tích hợp

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

96, mỗi mục trong danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 cung cấp một hàng giá trị dữ liệu và phải là

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43. Các giá trị khóa trong mỗi

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 xác định tên cột. Đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 có thể được cung cấp để chỉ định đặt hàng cột. Nếu

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 không được cung cấp thì đặt hàng cột sẽ được xác định bởi

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 đầu tiên nếu nó chứa các giá trị cho tất cả các cột hoặc bằng cách sắp xếp các tên cột theo thứ tự bảng chữ cái nếu không. Danh sách

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 có thể được chỉ định và phải tương ứng với thứ tự của các cột đầu ra.

Đối tượng giống như bảng

Nếu một đối tượng giống như bảng khác có phương thức

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04 thì đối tượng đó có thể được sử dụng để trực tiếp tạo

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4. Xem phần đối tượng giống như bảng để biết chi tiết.

Không có

Khởi tạo một bảng có độ dài bằng không. Nếu

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 và tùy chọn

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 được cung cấp, thì các cột tương ứng được tạo.

tên

Đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 cung cấp một cách để chỉ định tên cột bảng hoặc ghi đè lên các tên hiện có. Theo mặc định, các tên cột được lấy từ các tên hiện có (cho đầu vào

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 hoặc

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4) hoặc tự động tạo là

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y6. Nếu

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 được cung cấp, thì nó phải là một danh sách có cùng độ dài với số lượng cột. Bất kỳ yếu tố danh sách nào có giá trị

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13 rơi trở lại tên mặc định.

Trong trường hợp

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 được cung cấp dưới dạng

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 của các cột, đối số

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 có thể được cung cấp để chỉ định thứ tự của các cột. Danh sách

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y5 sau đó phải chứa từng khóa trong

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43.

DTYPE¶

Đối số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 cung cấp một cách để chỉ định các loại dữ liệu cột bảng hoặc ghi đè các loại hiện có. Theo mặc định, các loại được lấy từ các loại hiện có (cho đầu vào

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 hoặc

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4) hoặc tự động tạo bởi thói quen

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

23. Nếu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 được cung cấp thì nó phải là một danh sách có cùng độ dài với số lượng cột. Các giá trị phải hợp lệ

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

25 khởi tạo hoặc

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13. Bất kỳ yếu tố danh sách nào có giá trị

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13 rơi trở lại loại mặc định.

bản sao;

Trong trường hợp

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 là đối tượng

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 hoặc

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 hiện có, có thể sử dụng tham chiếu đến dữ liệu hiện có bằng cách đặt

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

32. Điều này có lợi thế là giảm sử dụng bộ nhớ và nhanh hơn. Tuy nhiên, bạn nên cẩn thận vì mọi sửa đổi đối với dữ liệu

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 mới cũng sẽ được nhìn thấy trong dữ liệu đầu vào ban đầu. Xem phần Bản sao so với tham chiếu để biết thêm thông tin.

hàng

Đối số này cho phép cung cấp dữ liệu như một chuỗi các hàng, trái ngược với từ khóa

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00, thường giả định dữ liệu là một chuỗi các cột. Phần dữ liệu hàng cung cấp chi tiết.

Copy_Indices¶

Nếu bạn đang khởi tạo

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 từ một

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 khác sử dụng lập chỉ mục bảng, thì tùy chọn này cho phép sao chép bảng đó mà không sao chép các chỉ số bằng cách đặt

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

37. Theo mặc định, các chỉ số được sao chép.Table Indexing, then this option allows copying that table without copying the indices by setting

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

37. By default, the indices are copied.

các đơn vị¶

Điều này cho phép đặt thiết bị cho một hoặc nhiều cột tại thời điểm tạo bảng. Đầu vào có thể là danh sách các giá trị đơn vị tương ứng với từng cột trong bảng (sử dụng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13 hoặc

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

39 không có đơn vị) hoặc

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 cung cấp đơn vị cho tên cột được chỉ định. Ví dụ:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

8

Xem số lượng và QTable cho lý do tại sao chúng tôi sử dụng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 ở đây thay vì

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4.Quantity and QTable for why we used a

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 here instead of a

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4.

mô tả và

Điều này cho phép thiết lập mô tả cho một hoặc nhiều cột tại thời điểm tạo bảng. Đầu vào có thể là danh sách các giá trị mô tả tương ứng với từng cột trong bảng (sử dụng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13 không có mô tả) hoặc

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43 cung cấp mô tả cho tên cột được chỉ định. Điều này hoạt động theo cách tương tự như ví dụ

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

54 ở trên.

Sao chép Versus Reference¶

Thông thường khi một đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 mới được tạo, dữ liệu đầu vào được sao chép. Điều này đảm bảo rằng nếu các yếu tố bảng mới được sửa đổi thì dữ liệu gốc sẽ không bị ảnh hưởng. Tuy nhiên, khi tạo bảng từ

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 hiện có, đối tượng

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 (có cấu trúc hoặc đồng nhất) hoặc

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43, có thể vô hiệu hóa sao chép để sử dụng tham chiếu bộ nhớ đến dữ liệu gốc. Điều này có lợi thế là nhanh hơn và sử dụng ít bộ nhớ hơn. Tuy nhiên, phải thận trọng vì dữ liệu bảng mới và dữ liệu gốc sẽ được liên kết, như được hiển thị bên dưới:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

9

Lưu ý rằng khi tham chiếu dữ liệu, không thể thay đổi các loại dữ liệu vì thao tác đó yêu cầu tạo một bản sao của dữ liệu. Trong trường hợp này xảy ra lỗi:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

0

Một cảnh báo khác để sử dụng dữ liệu được tham chiếu là nếu bạn thêm một hàng mới vào bảng, tham chiếu đến mảng dữ liệu gốc sẽ bị mất và thay vào đó, bảng sẽ giữ một bản sao của các giá trị gốc (ngoài hàng mới).

Các lớp học và bảng tính bảng tính

Có hai lớp,

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 và

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51, rất hữu ích khi xây dựng các bảng mới.

Cột¶

Đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 có thể được tạo như sau, trong đó trong mọi trường hợp, cột

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

53 nên được cung cấp dưới dạng đối số từ khóa và bạn có thể tùy chọn cung cấp các giá trị sau:

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 hoặc

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

20,

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 40 or

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

13

Giá trị dữ liệu cột.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

25 Giá trị tương thích

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

25 compatible value

Kiểu dữ liệu cho cột.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

60

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61

Mô tả đầy đủ của cột.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

62

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61

Đơn vị vật lý.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

64

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61 hoặc chức năng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

61 or function

Định dạng xác định cho các giá trị cột xuất ra.

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

39

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43

>>> Table([t['c'], t['a']])

c astr1 int32---- ----- x 1 y 43

Siêu dữ liệu liên quan đến cột.

Tùy chọn khởi tạo

Các giá trị dữ liệu cột, hình dạng và kiểu dữ liệu được chỉ định theo một trong hai cách:

Cung cấp dữ liệu nhưng không có độ dài hoặc hình dạng

Examples:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

1

Đối số

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 có thể là bất kỳ giá trị nào là trình khởi tạo loại dữ liệu có kích thước cố định được chấp nhận cho

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

25. Xem tham chiếu cho các đối tượng kiểu dữ liệu. Những ví dụ bao gồm:

Loại không chuỗi Python (

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

70,

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

71,

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

34).

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9 loại không chuỗi (ví dụ:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

74,

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

75).

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

25 chuỗi loại giao thức mảng (ví dụ:

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

77,

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

78,

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

79).

Nếu không có giá trị

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 được cung cấp, thì loại được suy ra bằng cách sử dụng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

23. Khi

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 được cung cấp thì các đối số

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

83 và

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

84 bị bỏ qua.

Cung cấp độ dài và hình dạng tùy chọn, nhưng không phải dữ liệu

Examples:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

2

Mặc định

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

13 là

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

86. Đối số

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

83 là hình dạng mảng của một ô trong cột. Mặc định

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

83 là

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

89 có nghĩa là một giá trị duy nhất trong mỗi phần tử.

Ghi chú

Sau khi đặt loại cho một cột, loại đó không thể thay đổi. Nếu các giá trị dữ liệu của một loại khác nhau được gán cho cột thì chúng sẽ được chuyển vào loại cột hiện có.

Định dạng xác định

Trình xác định định dạng điều khiển đầu ra của các giá trị cột khi bảng hoặc cột được in hoặc ghi vào bảng ASCII. Trong trường hợp đơn giản nhất, nó là một chuỗi có thể được chuyển đến chức năng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

90 tích hợp của Python. Đối với định dạng phức tạp hơn, người ta cũng có thể cung cấp cho các chuỗi định dạng kiểu cũ hoặc phong cách mới, hoặc thậm chí là một chức năng:

Đặc điểm kỹ thuật định dạng đơn giản

Loại chuỗi này chỉ định trực tiếp cách giá trị nên được định dạng bằng cách sử dụng ngôn ngữ nhỏ đặc tả định dạng khá giống với C.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
91 sẽ cho bốn chữ số sau thập phân ở định dạng float, hoặc
data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
92 sẽ cung cấp số nguyên trong các lĩnh vực sáu ký tự.

Chuỗi định dạng kiểu cũ

Điều này tương ứng với cú pháp như

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

93 như được ghi lại trong định dạng chuỗi kiểu printf.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
94 để in bốn chữ số sau thập phân ở định dạng float, hoặc
data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
95 để in một số nguyên trong trường rộng sáu ký tự.

Chuỗi định dạng kiểu mới

Điều này tương ứng với cú pháp như

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

96 như được ghi lại trong cú pháp chuỗi định dạng.

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
97 để in bốn chữ số sau thập phân ở định dạng float, hoặc
data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
98 để in một số nguyên trong trường rộng sáu ký tự.

Lưu ý rằng trong một trong hai trường hợp chuỗi định dạng, bất kỳ chuỗi python nào định dạng chính xác một giá trị là hợp lệ, do đó

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

99 hoặc

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

00 sẽ hoạt động.

Hàm số

Tính linh hoạt lớn nhất có thể đạt được bằng cách đặt hàm định dạng. Hàm này phải chấp nhận một đối số duy nhất (giá trị) và trả về một chuỗi. Một cảnh báo là một hàm định dạng như vậy không thể được lưu vào tệp và bạn sẽ có một ngoại lệ nếu bạn cố gắng làm như vậy. Trong ví dụ sau đây, điều này được sử dụng để tạo ra đầu ra sẵn sàng latex:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

3

Chuỗi định dạng cho cột mảng có cấu trúc

Đối với các cột là các mảng có cấu trúc, chuỗi định dạng phải là một chuỗi sử dụng các chuỗi định dạng kiểu mới với các thay thế tham số tương ứng với tên trường trong mảng có cấu trúc. Xem các cột mảng có cấu trúc cho một ví dụ.Structured array columns for an example.

TableColonns¶

Mỗi đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 có một thuộc tính

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

24 là một từ điển được đặt hàng lưu trữ tất cả các đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 trong bảng (xem thêm phần Cột). Về mặt kỹ thuật, thuộc tính

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

24 là một đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51, đây là một từ điển được đặt hàng nâng cao cung cấp các cách dễ dàng hơn để chọn nhiều cột. Có một vài điểm chính cần nhớ:

A

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 có thể được khởi tạo từ đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51 (

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41 luôn là

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

46).

Chọn nhiều cột từ đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51 trả về một đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51 khác.

Chọn một cột từ đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51 trả về

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8.

Có một vài cách khác nhau để chọn các cột từ đối tượng

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51:

Chọn các cột theo tên

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

4

Chọn các cột bằng cách cắt chỉ mục

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

5

Chọn các cột đơn theo chỉ mục hoặc tên

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

6

Bảng phân lớp

Đối với một số ứng dụng, có thể hữu ích khi phân lớp lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 để giới thiệu hành vi chuyên môn. Ở đây chúng tôi giải quyết hai trường hợp sử dụng cụ thể để phân lớp: Thêm thuộc tính bảng tùy chỉnh và thay đổi hành vi của các đối tượng lớp bên trong.

Thêm các thuộc tính bảng tùy chỉnh

Một tùy chỉnh đơn giản có thể hữu ích là thêm các thuộc tính mới vào đối tượng bảng. Không có gì ngăn chặn việc thiết lập một thuộc tính trên một đối tượng bảng hiện có, ví dụ

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

16. Tuy nhiên, thuộc tính này sẽ là phù du vì nó sẽ bị mất nếu bảng được cắt, sao chép hoặc ngâm. Thay vào đó, bạn có thể thêm các thuộc tính liên tục như trong ví dụ này:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

7

Một số điểm chính:

Một thuộc tính tùy chỉnh có thể được đặt khi bảng được tạo hoặc sử dụng cú pháp thông thường để đặt thuộc tính đối tượng.
Một thuộc tính tùy chỉnh luôn có giá trị mặc định, được đặt rõ ràng trong định nghĩa lớp hoặc
```
data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)
```
13.
Các giá trị thuộc tính được lưu trữ trong bảng
```
names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))
```
39 Từ điển. Đây là cơ chế mà chúng kiên trì thông qua bản sao, lát cắt và tuần tự hóa như ngâm hoặc ghi vào tệp định dạng ECSV.ECSV Format file.

Thay đổi hành vi của các đối tượng lớp nội bộ

Cũng có thể thay đổi hành vi của các đối tượng lớp bên trong được chứa hoặc tạo bởi

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4. Điều này bao gồm các hàng, cột, định dạng và thùng chứa cột. Để làm điều này, lớp con cần phải khai báo loại nào (nếu nó khác với phiên bản tích hợp). Điều này được thực hiện bằng cách chỉ định một hoặc nhiều thuộc tính lớp

>>> Table([t['a']**2, t['b'] + 10])

a bint32 float64----- ------- 1 12.0 16 15.05,

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8,

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

22,

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

51 hoặc

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

24.

Ví dụ tầm thường sau đây ghi đè tất cả những điều này với các lớp con không có gì, nhưng trong thực tế, bạn sẽ chỉ ghi đè lên các thành phần cần thiết:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

8

Thí dụ¶

Như một ví dụ thực tế hơn, giả sử bạn có một bảng dữ liệu với một tập hợp các cột cố định nhất định, nhưng bạn cũng muốn mang theo một từ điển tùy ý cho mỗi hàng và sau đó truy cập các giá trị đó bằng cách sử dụng cùng một cú pháp truy cập mục như thể chúng là cột. Ở đây, ở đây rằng các tham số bổ sung được chứa trong cột

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

9-DType có tên

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

26:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

9

Bây giờ chúng tôi đưa điều này vào hành động với một lớp con

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 tầm thường:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

0

Đầu tiên hãy tạo một bảng và thêm một vài hàng:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

1

Bây giờ hãy xem những gì chúng tôi có từ đối tượng

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

28 chuyên dụng của chúng tôi:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

2

Để làm cho ví dụ này thực sự hữu ích, bạn có thể muốn ghi đè

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

29 để cho phép truy cập cấp bảng vào các trường tham số. Điều này có thể trông giống như:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

3

Cột và số lượng

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

30

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 Các đối tượng có thể được xử lý trong các bảng theo hai cách bổ sung. Phương pháp đầu tiên lưu trữ đối tượng

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 trong bảng thông qua giao thức cột Mix Mixin. Xem các phần trên các cột mixin và số lượng và qtable để biết chi tiết, nhưng tóm lại, sự khác biệt chính là sử dụng lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 để chỉ ra rằng

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 nên được lưu trữ tự nhiên trong bảng:Mixin Columns and Quantity and QTable for details, but in brief, the key difference is using the

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 class to indicate that a

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 should be stored natively within the table:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

4

Đối với mã mới nhận biết số lượng, chúng tôi khuyên bạn nên sử dụng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5, nhưng điều này có thể không thể thực hiện được trong mọi tình huống (đặc biệt là khi giao tiếp với mã di sản không xử lý số lượng) và có chi tiết và cảnh báo. Trong trường hợp này, hãy sử dụng lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4, sẽ chuyển đổi

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 thành đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 bằng thuộc tính

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

62:Details and Caveats that apply. In this case, use the

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 class, which will convert a

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t

a b cint32 float64 str1----- ------- ---- 1 2.0 x 4 5.0 y2 to a

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 object with a

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

62 attribute:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

5

Để tìm hiểu thêm về việc sử dụng các đối tượng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

8 tiêu chuẩn với các đơn vị được xác định, hãy xem các cột với phần Đơn vị.Columns with Units section.

Đối tượng giống như bảng

Để cải thiện khả năng tương tác giữa các lớp bảng khác nhau, đối tượng

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

30

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 có thể được tạo trực tiếp từ bất kỳ đối tượng giống như bảng nào khác cung cấp phương thức

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04. Trong trường hợp này, phương pháp

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04 sẽ được gọi như sau:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

6

Bên trong cuộc gọi sau đây sẽ được thực hiện để yêu cầu đối tượng

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 trả về một đại diện của chính nó dưới dạng

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

30

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4, tôn trọng ưu tiên của

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41 của cuộc gọi ban đầu đến

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

49:

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

7

Ở đây

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

50 là lớp

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 hoặc lớp con đang được khởi tạo (

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

5 trong ví dụ này),

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41 cho biết liệu một bản sao của các giá trị trong

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

00 có nên được cung cấp hay không và

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60 là bất kỳ đối số từ khóa nào không hợp lệ. Trong ví dụ trên,

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

58 sẽ kết thúc vào

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60 và được chuyển sang

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04.

Nếu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41 là

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

46 thì phương thức

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04 phải đảm bảo rằng một bản sao của dữ liệu gốc được trả về. Nếu

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

41 là

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

65 thì nên trả về dữ liệu bảng nếu có thể. Nếu không thể (ví dụ: dữ liệu gốc nằm trong danh sách Python hoặc phải được chuyển đổi trong bộ nhớ) thì phương thức

data = {'names': names, 'values': values}
df = pandas.DataFrame(data=data)

04 được tự do trả lại một bản sao hoặc nếu không sẽ tăng ngoại lệ. Sự lựa chọn này phụ thuộc vào sở thích của việc thực hiện. Việc triển khai có thể chọn cho phép một đối số từ khóa bổ sung (ví dụ:

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

67 được truyền qua

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60) để kiểm soát hành vi trong trường hợp này.

Như một ví dụ ngắn gọn, hãy tưởng tượng một lớp bảng dựa trên dict. (Lưu ý rằng

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])

4 đã có thể được khởi tạo từ một đối tượng giống như dict

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

8

Việc thực hiện lớp của bạn về điều này phải sử dụng kỹ thuật

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60 để bắt các đối số từ khóa ở cuối. Điều này là để đảm bảo khả năng tương thích trong tương lai trong trường hợp các từ khóa bổ sung được thêm vào cuộc gọi

         names          values
0      Byakuya           500
1     Kenpachi           600
2          Kon           50

71 nội bộ. Bao gồm

names = ["a", "b", "c"]
values = [1, 2, 3]
for n, v in zip(names, values):
    print("{} = {}".format(n, v))

60 sẽ ngăn ngừa vỡ trong trường hợp này.

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

9

programming python Python table function DataFrame array Python

Bài Viết Liên Quan

Danh sách ngân hàng tại tỉnh thanh hóa năm 2024

Hướng dẫn create table from array python - tạo bảng từ mảng python

Ví dụ;

Thành lập¶

Tạo từ đầu

Danh sách các cột

Diễn ngôn của cột

Một >>> Table([t['c'], t['a']])

Mảng có cấu trúc numpy

Mảng có cấu trúc như một cột

Mảng đồng nhất không có

Từ một bảng hiện có

Mảng trống có kích thước đã biết

Chi tiết khởi tạo Jo

dữ liệu¶

tên

DTYPE¶

bản sao;

hàng

Copy_Indices¶

các đơn vị¶

mô tả và

Sao chép Versus Reference¶

Các lớp học và bảng tính bảng tính

Cột¶

Tùy chọn khởi tạo

Định dạng xác định

TableColonns¶

Bảng phân lớp

Thêm các thuộc tính bảng tùy chỉnh

Thay đổi hành vi của các đối tượng lớp nội bộ

Thí dụ¶

Cột và số lượng

Đối tượng giống như bảng

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội