programming python Python table function DataFrame array Python

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

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?

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

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     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:
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




  



	
Bài Viết Liên Quan

	

	 	

		

		   
		   
		   
		

		

			
Hướng dẫn css wiki - wiki css


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn dict in dict python - dict trong dict python


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn php get navegador - php nhận trình duyệt


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn what is a function definition in javascript? - định nghĩa hàm trong javascript là gì?


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn for variable in python - cho biến trong python


		

	

		

		

		   
		   
		   
		

		

			
2024 Muharram date


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn edit html iphone - chỉnh sửa html iphone


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn online html css jobs work from home - công việc html css trực tuyến làm việc tại nhà


		

	

		

		

		   
		   
		   
		

		

			
Sử dụng các cú pháp cơ bản của javascript để hộp ngày tháng năm sinh trên một hộp lựa chọn


		

	

		

		

		   
		   
		   
		

		

			
NASCAR schedule 2022 2023


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn where can i learn html5? - tôi có thể học html5 ở đâu?


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn global style css - phong cách toàn cầu css


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn can we use where clause in joins in mysql? - chúng ta có thể sử dụng mệnh đề where trong phép nối trong mysql không?


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn what should i learn after python to get a job? - tôi nên học gì sau python để có việc làm?


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn what is php explain its variables and operators? - php giải thích các biến và toán tử của nó là gì?


		

	

		

		

		   
		   
		   
		

		

			
Học phí vinschool 2023 2023


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn how do i get permission from a file in python? - làm cách nào để tôi có quyền từ một tệp trong python?


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn python developer notes - ghi chú nhà phát triển python


		

	

		

		

		   
		   
		   
		

		

			
2023 Part A deductible


		

	

		

		

		   
		   
		   
		

		

			
Hướng dẫn check string is integer javascript - kiểm tra chuỗi là số nguyên javascript


		

	

	
	




Toplist mới



 

	
	 

		
#1

		

			
Top 4 uống nước chanh sả mật ong có tác dụng gì 2023

			5 tháng trước
		

	





	
	 

		
#2

		

			
Top 10 bài tập làm văn số 5 lớp 7 de 4 2023

			5 tháng trước
		

	





	
	 

		
#3

		

			
Top 3 vừa chơi đã có tài khoản vương giả chap 1 2023

			5 tháng trước
		

	





	
	 

		
#4

		

			
Top 6 anh sẽ on thôi cover phạm nguyên ngọc lyrics 2023

			5 tháng trước
		

	





	
	 

		
#5

		

			
Top 7 tài liệu quản lý nhà nước và quản lý ngành giáo dục đào tạo 2023

			5 tháng trước
		

	





	
	 

		
#6

		

			
Top 7 hãy ra khỏi người đó đi hợp âm 2023

			5 tháng trước
		

	





	
	 

		
#7

		

			
Top 6 giáo án thơ về thăm nhà bác 2023

			5 tháng trước
		

	





	
	 

		
#8

		

			
Top 8 giáo án ngữ văn 6 cánh diều 2023

			5 tháng trước
		

	





	
	 

		
#9

		

			
Top 9 tinh bột tham gia phản ứng nào 2023

			5 tháng trước
		

	








	
Bài mới nhất

	

	 	

		

		   
		   
		   
		

		

			
Trung tâm dịch vụ nông nghiệp 2023 báo bình định năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Top những người được yêu thích nhất thế giới năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Cong văn 3722 ngay 4 thang 10 nam 2023 năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Đầu số 0766 là mạng gì năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Xe bus 22 đi qua những điểm nào năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Theo dõi thai có nguy cơ cao là gì năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Công văn thu hồi hóa đơn xuất dư năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Mổ mắt cận thị ở bệnh viện nào tốt nhất năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Bài tập chứng minh suy dẫn trong csdl năm 2024


		

	

		

		

		   
		   
		   
		

		

			
Đặc điểm của tuyến sinh dục là gì sinh 8 năm 2024


		

	

	
	



	
Chủ Đề

	
	

	
		  programming
		  Hỏi Đáp
		  Mẹo Hay
		  Toplist
		  Là gì
		  Địa Điểm Hay
		  Học Tốt
		  Công Nghệ
		  mẹo hay
		  Nghĩa của từ
		  Bao nhiêu
		  Khỏe Đẹp
		  đánh giá
		  Top List
		  bao nhieu
		  bao nhiêu
		  hướng dẫn
		  So Sánh
		  So sánh
		  Tiếng anh
		  Bài tập
		  Xây Đựng
		  Sản phẩm tốt
		  Ngôn ngữ
		  Bài Tập
		  Máy tính
		  javascript
		  Ở đâu
		  Hướng dẫn
		  Dịch 
		  Thế nào
		  Tại sao
		  Đại học
		  Món Ngon
		  Facebook
		  Khoa Học