Hướng dẫn phân tích dữ liệu với DuckDB

Bài báo này đã được xuất bản như một phần của Blogathon Khoa học Dữ liệu.

Đạt đến cấp độ tiếp theo trong sự nghiệp phân tích dữ liệu của bạn bằng cách thêm DuckDB vào ngăn xếp dữ liệu của bạn. Hướng dẫn này sẽ giúp bạn hiểu API Python và các cách khác nhau để đọc tệp CSV bằng tập lệnh SQL.

Cuộc sống của một nhà phân tích dữ liệu xoay quanh việc tải dữ liệu thông qua SQL serve, phân tích nó bằng các gói Python khác nhau và cuối cùng là tạo báo cáo kỹ thuật. Đôi khi những truy vấn SQL này có thể mất nhiều thời gian hơn để xử lý vì chúng tôi đang xử lý hàng terabyte dữ liệu. Trong thế giới có nhịp độ nhanh này, chiến lược này thất bại thảm hại và hầu hết các nhà phân tích đang rời xa các cách truyền thống để thực hiện phân tích dữ liệu. VịtDB giải quyết tất cả các vấn đề, nó được tích hợp với Python & R. Nó hoạt động tương tự như SQLite và tập trung vào việc cung cấp các truy vấn phân tích nhanh hơn.

Trong hướng dẫn này, chúng ta sẽ tìm hiểu các cách khác nhau để chạy các truy vấn DuckDB SQL và cũng tìm hiểu về tích hợp Deepnote.

VịtDB

DuckDB là một hệ quản trị cơ sở dữ liệu hướng bảng quan hệ và hỗ trợ các truy vấn SQL để tạo ra các kết quả phân tích. Nó cũng đi kèm với các tính năng khác nhau hữu ích cho việc phân tích dữ liệu.

Truy vấn phân tích nhanh

DuckDB được thiết kế để chạy khối lượng công việc truy vấn phân tích nhanh hơn. Nó chạy trên một công cụ thực thi truy vấn được vector hóa theo cột, chạy một loạt quy trình lớn trong một lần. Điều này làm cho nó chạy nhanh hơn Xử lý phân tích trực tuyến (OLAP) so với các hệ thống truyền thống như PostgreSQL xử lý tuần tự từng hàng.

Hoạt động đơn giản

DuckDB sử dụng tính đơn giản và hoạt động nhúng.

Không nhập hoặc sao chép dữ liệu trong khi xử lý truy vấn
Được nhúng trong một quy trình lưu trữ
truyền dữ liệu tốc độ cao

Tính năng phong phú

DuckDB cho phép người dùng chạy các truy vấn SQL phức tạp một cách trơn tru. Nó cũng hỗ trợ lập chỉ mục thứ cấp để cung cấp thời gian truy vấn nhanh trong cơ sở dữ liệu một tệp. DuckDB cung cấp tích hợp đầy đủ cho Python và R để các truy vấn có thể được thực thi trong cùng một tệp.

Nguồn mở & miễn phí

DuckDB được sử dụng miễn phí và toàn bộ mã có sẵn trên GitHub. Nó đi kèm với một Giấy phép MIT có nghĩa là bạn có thể sử dụng nó cho mục đích thương mại.

Tạo cơ sở dữ liệu

DuckDB cung cấp trải nghiệm độc lập để bạn kết nối với cơ sở dữ liệu hoặc tạo cơ sở dữ liệu mới bằng một lệnh tương tự duckdb.connect(,read_only=False) .

Như bạn có thể thấy trong hình ảnh bên dưới MẫuDB các tệp đã được tạo trong thư mục của bạn.

nhập duckdb conn = duckdb.connect (“SampleDB”, read_only = False)

DuckDB cũng cho phép bạn tạo cơ sở dữ liệu tạm thời trong bộ nhớ bằng cách sử dụng duckdb.connect(). Các conn.execute() chạy tất cả các yêu cầu truy vấn trong cơ sở dữ liệu. Trong ví dụ này, chúng ta sẽ tạo một bảng tạm thời được gọi là bảng_kiểm tra trong đó có chứa i dưới dạng số nguyên và j như một chuỗi. Nếu bạn quen thuộc với SQL bạn sẽ không gặp khó khăn khi hiểu các yêu cầu truy vấn, nhưng nếu bạn chưa quen với SQL, tôi sẽ đề xuất bạn xem cheat sheet.

conn = duckdb.connect ()

# chạy các lệnh SQL tùy ý conn.execute (“TẠO BẢNG test_table (tôi INTEGER, j STRING)”)

Chèn giá trị

Bạn có thể chèn một hoặc nhiều giá trị bằng cách sử dụng các lệnh SQL. Trong phần này, chúng tôi đang thêm hai giá trị vào bảng_kiểm tra sử dụng thực thi.

conn.execute (“CHÈN BỎ QUA VÀO GIÁ TRỊ test_table (1, 'một'), (9, 'chín')”)

Để kiểm tra xem chúng tôi đã thêm giá trị thành công hay chưa, chúng tôi sẽ chạy SQL để đọc tất cả các giá trị của i. Để hiển thị kết quả của các truy vấn trong Gấu trúc khung dữ liệu chúng tôi sẽ thêm .fetchdf() như hình dưới đây. Làm tốt lắm, Chúng tôi đã thêm thành công hai giá trị thăn của mình.

conn.execute (“CHỌN tôi từ test_table“) .fetchdf ()

Chúng tôi cũng có thể sử dụng trình giữ chỗ cho các tham số và sau đó thêm một mảng vào bảng_kiểm tra. Nếu bạn đã quen với khuôn khổ Python, bạn sẽ thấy phương pháp này dễ thực thi. Chúng tôi cũng có thể thực thi nhiều giá trị cùng một lúc bằng cách sử dụng .executemany(). Như bạn có thể thấy bên dưới cách chúng tôi đã thêm thành công các giá trị vào bảng_kiểm tra.

conn.execute (“CHÈN BỎ QUA VÀO GIÁ TRỊ test_table (?,?)”, [2, 'hai'])

conn.executemany (“CHÈN BỎ QUA GIÁ TRỊ test_table (?,?)”, [[3, 'ba'], [4, 'bốn']])

conn.execute (“SELECT * từ test_table“) .fetchdf ()

Sử dụng .fetchnumpy() để hiển thị kết quả của bạn dưới dạng numpy mảng. Từ điểm này, điều này sẽ trở nên khá thú vị vì chúng ta sẽ học các cách khác nhau để thực thi các truy vấn SQL phức tạp để phân tích dữ liệu

conn.execute (“SELECT * FROM test_table”). fetchnumpy ()

{'i': array([1, 9, 2, 3, 4, 1, 9, 2, 3, 4, 1, 9, 2, 3, 4, 1, 9, 2, 3, 4, 1, 9, 2, 3, 4, 1, 9, 2, 3, 4], dtype=int32), 'j': array(['one', 'nine', 'two', 'three', 'four', 'one', 'nine', 'two', 'three', 'four', 'one', 'nine', 'two', 'three', 'four', 'one', 'nine', 'two', 'three', 'four', 'one', 'nine', 'two', 'three', 'four', 'one', 'nine', 'two', 'three', 'four'], dtype=object)}

Khung dữ liệu Pandas và SQL

Trong phần này, chúng ta sẽ tìm hiểu về khung dữ liệu của Panda và tìm hiểu nhiều cách khác nhau để đọc .csv các tập tin. Đầu tiên, chúng ta sẽ tạo một khung dữ liệu Pandas đơn giản bằng từ điển và sau đó chúng ta sẽ thêm nó vào một bảng mới có tên test_df.

Sử dụng tập lệnh SQL để tìm tất cả các giá trị của j Ở đâu i lớn hơn một. Kết quả truy vấn cho thấy ba mẫu phù hợp với điều kiện của chúng tôi.

gấu trúc nhập khẩu như pd

test_df = pd.DataFrame.from_dict ({“i”: [1, 2, 3, 4], “j”: [“một”, “hai”, “ba”, “bốn”]})

conn.register (“test_df”, test_df)

conn.execute (“CHỌN j TỪ test_df WHERE i> 1”). fetchdf ()

Trong bước tiếp theo, chúng tôi sẽ nhập .csv vào khung dữ liệu gấu trúc và sau đó thêm nó vào bảng mới ngân hàng_df. Tập dữ liệu được sử dụng trong ví dụ này là từ Kaggle theo GPL2 giấy phép. Kết quả cho thấy số lượng khôi phục thực tế khi tuổi lớn hơn 27. Như chúng ta có thể thấy rằng các truy vấn phức tạp đang trở nên đơn giản để thực thi.

df = pd.read_csv (“bank_data.csv”)

conn.register (“bank_df”, df)

conn.execute (“SELECT real_recovery_amount FROM bank_df WHERE tuổi> 27”). fetchdf ()

mối quan hệ

API quan hệ sử dụng các truy vấn có lập trình để đánh giá các lệnh quan hệ chuỗi f. Nói tóm lại, bạn có thể chạy các hàm python trên quan hệ và hiển thị kết quả. Các kết quả chứa một Cây có kinh nghiệm, kết quả trong các cột và kết quả trong một bản xem trước. Nếu bạn đang cảm thấy bối rối ngay bây giờ thì không sao cả vì chúng ta sẽ đi sâu vào các mối quan hệ và cách sử dụng chúng để có được kết quả phân tích.

Đang tải quan hệ

Tạo mối quan hệ từ khung dữ liệu Pandas hiện có test_df sử dụng conn.from_df(test_df) . Bằng cách in, rel chúng ta có thể hình dung toàn bộ khung dữ liệu.

rel = conn.from_df (test_df)

rel

---------------------
-- Expression Tree --
---------------------
pandas_scan(140194817412592)

--------------------- - Các Cột Kết quả ---------------------------- - i (BIGINT) - j (VARCHAR)

--------------------- -- Result Preview -- --------------------- i j BIGINT VARCHAR [ Rows: 4] 1 one 2 two 3 three 4 four

Vous sử dụng pouvez aussi duckdb.df() nó cho kết quả tương tự.

rel = duckdb.df (test_df)

Sử dụng conn.table để tạo một mối quan hệ từ bảng hiện có. Trong trường hợp của chúng tôi, chúng tôi đang sử dụng bảng_kiểm tra.

rel = conn.table (“test_table”)

rel

---------------------
-- Expression Tree --
---------------------
Scan Table [test_table]

--------------------- -- Result Preview -- --------------------- i j INTEGER VARCHAR [ Rows: 5] 1 one 9 nine 2 two 3 three 4 four

Để tạo mối quan hệ trực tiếp từ .csv tập tin, sử dụng .from_csv_auto .

rel = duckdb.from_csv_auto (“bank_data.csv”)

rel

---------------------
-- Expression Tree --
---------------------
read_csv_auto(bank_data.csv)

--------------------- - Cột Kết quả --------------------- - id (INTEGER) - dự kiến_recovery_amount (INTEGER) - thực_triển_kết_hợp (DOUBLE) - recovery_strategy (VARCHAR) - tuổi (INTEGER) - giới tính (VARCHAR)
---------------------
-- Result Preview --
---------------------
id	expected_recovery_amount	actual_recovery_amount	recovery_strategy	age	sex INTEGER	INTEGER	DOUBLE	VARCHAR	INTEGER	VARCHAR [ Rows: 10]
2030	194	263.540000	Level 0 Recovery	19	Male 1150	486	416.090000	Level 0 Recovery	25	Female 380	527	429.350000	Level 0 Recovery	27	Male 1838	536	296.990000	Level 0 Recovery	25	Male 1995	541	346.385000	Level 0 Recovery	34	Male 731	548	520.710000	Level 0 Recovery	35	Male 221	549	221.585000	Level 0 Recovery	33	Male 1932	560	373.720000	Level 0 Recovery	19	Female 1828	562	201.865000	Level 0 Recovery	22	Female 2001	565	504.885000	Level 0 Recovery	27	Male

Thông tin quan hệ

Sử dụng rel.alias để kiểm tra tên được đặt cho mối quan hệ. Trong trường hợp của chúng tôi, đó là ngân hàng_data.csv.

rel.alias

'bank_data.csv'

Chúng tôi có thể thay đổi bí danh hiện tại bằng cách sử dụng .set_alias . Điều này có thể hữu ích cho việc tham gia các mối quan hệ tương tự.

rel2 = rel.set_alias ('bank_data')

rel2.alias

'bank_data'

Loại quan hệ của chúng tôi trong Truy vấn con_Relation.

rel.type

'SUBQUERY_RELATION'

Để kiểm tra tên cột của mối quan hệ, chỉ cần sử dụng .columns .

rel.column

['id', 'expected_recovery_amount', 'actual_recovery_amount', 'recovery_strategy', 'age', 'sex']

Sử dụng .types để kiểm tra các loại cột.

rel.types

['INTEGER', 'INTEGER', 'DOUBLE', 'VARCHAR', 'INTEGER', 'VARCHAR']

Áp dụng các hàm giống như Python (Hàm đơn)

Bây giờ đến phần thú vị. Bạn có thể thêm bất kỳ chức năng nào với mối quan hệ và nó sẽ hiển thị kết quả tăng cường. Trong trường hợp của chúng tôi, chúng tôi đã sử dụng rel.filter và nó hiển thị các kết quả có độ tuổi lớn hơn 18. Nó cũng hiển thị thông tin bổ sung về cây biểu thức, có thể khá hữu ích nếu bạn có một truy vấn phức tạp dài để chạy.

rel.filter ('tuổi> 18')

---------------------
-- Expression Tree --
---------------------
Filter [age>18] read_csv_auto(bank_data.csv)

--------------------- - Cột Kết quả --------------------- - id (INTEGER) - dự kiến_recovery_amount (INTEGER) - thực_triển_kết_hợp (DOUBLE) - recovery_strategy (VARCHAR) - tuổi (INTEGER) - giới tính (VARCHAR)
---------------------
-- Result Preview --
---------------------
id	expected_recovery_amount	actual_recovery_amount	recovery_strategy	age	sex INTEGER	INTEGER	DOUBLE	VARCHAR	INTEGER	VARCHAR [ Rows: 10]
2030	194	263.540000	Level 0 Recovery	19	Male 1150	486	416.090000	Level 0 Recovery	25	Female 380	527	429.350000	Level 0 Recovery	27	Male 1838	536	296.990000	Level 0 Recovery	25	Male 1995	541	346.385000	Level 0 Recovery	34	Male 731	548	520.710000	Level 0 Recovery	35	Male 221	549	221.585000	Level 0 Recovery	33	Male 1932	560	373.720000	Level 0 Recovery	19	Female 1828	562	201.865000	Level 0 Recovery	22	Female 2001	565	504.885000	Level 0 Recovery	27	Male

Sử dụng .project sẽ hiển thị các cột được đề cập và trong trường hợp của chúng tôi là hiển thị id và tuổi tác.

rel.project ('id, age')

---------------------
-- Expression Tree --
---------------------
Projection [id, age] read_csv_auto(bank_data.csv)

--------------------- - Cột Kết quả --------------------- - id (INTEGER) - tuổi (INTEGER)

Bạn có thể biến đổi các giá trị cột của mình bằng cách thêm một số hoặc sử dụng bất kỳ hàm số học nào. Trong trường hợp của chúng tôi, nó hiển thị tuổi với +1.

rel.project ('age + 1')

---------------------
-- Expression Tree --
---------------------
Projection [age + 1] read_csv_auto(bank_data.csv)

--------------------- - Cột Kết quả ---------------------------- tuổi + 1 (INTEGER)
---------------------
-- Result Preview --
---------------------
age + 1 INTEGER [ Rows: 10]
20 26 28 26 35 36 34 20 23 28

Thứ tự tương tự như tập lệnh SQL ORDER .

rel.order ('sex')

Sản phẩm .limit hiển thị các mẫu hàng đầu trong một bảng. Trong trường hợp của chúng tôi, nó sẽ chỉ hiển thị 2 giá trị hàng đầu.

rel.limit (2)

Xếp tất cả các chức năng trong một chuỗi

Cũng giống như trong R, bạn có thể xếp chồng tất cả các hàm của mình để lấy đầu ra SQL. Trong trường hợp của chúng tôi, nó hiển thị hai real_recovery_amount, đặt bởi quan hệ tình dục của những người với tuổi lớn hơn 27. Bây giờ chúng tôi đang nhận ra tiềm năng đầy đủ của cây biểu thức.

rel.filter ('age> 27'). project ('reality_recovery_amount'). order ('sex'). limit (2)
---------------------
-- Expression Tree --
---------------------
Limit 2 Order [sex DESC] Projection [actual_recovery_amount] Filter [age>27] read_csv_auto(bank_data.csv)

--------------------- - Các Cột Kết quả --------------------- - số tiền thực_nghiệp (KÉP)
---------------------
-- Result Preview --
---------------------
actual_recovery_amount DOUBLE [ Rows: 2]
278.720000 245.000000

Chức năng tổng hợp

Hàm tổng hợp có thể thực hiện nhiều nhiệm vụ nhóm. Trong trường hợp này, nó là tổng tất cả số tiền thu hồi thực tế.

rel.aggregate (“sum (real_recovery_amount)”)

---------------------
-- Result Preview --
---------------------
sum(actual_recovery_amount) DOUBLE [ Rows: 1]
7529821.469511

Hàm bên dưới sẽ hiển thị tổng của real_recovery_amount mỗi nhóm tuổi. Điều này thật tuyệt vì chúng tôi đã giảm hai chức năng thành một.

rel.aggregate (“age, sum (real_recovery_amount)”)

---------------------
-- Result Preview --
---------------------
age	sum(actual_recovery_amount) INTEGER	DOUBLE [ Rows: 10]
19	52787.712089 25	72769.342330 27	67569.292950 34	109902.427032 35	115424.466724 33	138755.807230 22	46662.153746 31	92225.534688 18	39969.573274 32	110627.466806

Nếu bạn chỉ muốn hiển thị tổng số tiền _recovery thực tế thì hãy thêm nhóm theo cột làm đầu vào phụ. Trong trường hợp của chúng tôi, nó chỉ hiển thị tổng số tiền phục hồi thực tế theo độ tuổi.

rel.aggregate (“sum (real_recovery_amount)”, “tuổi”)

---------------------
-- Result Preview --
---------------------
sum(actual_recovery_amount) DOUBLE [ Rows: 10]
52787.712089 72769.342330 67569.292950 109902.427032 115424.466724 138755.807230 46662.153746 92225.534688 39969.573274 110627.466806

Để hiển thị các giá trị duy nhất, hãy sử dụng distinct()

rel.distinction ()

---------------------
-- Result Preview --
---------------------
id	expected_recovery_amount	actual_recovery_amount	recovery_strategy	age	sex INTEGER	INTEGER	DOUBLE	VARCHAR	INTEGER	VARCHAR [ Rows: 10]
2030	194	263.540000	Level 0 Recovery	19	Male 1150	486	416.090000	Level 0 Recovery	25	Female 380	527	429.350000	Level 0 Recovery	27	Male 1838	536	296.990000	Level 0 Recovery	25	Male 1995	541	346.385000	Level 0 Recovery	34	Male 731	548	520.710000	Level 0 Recovery	35	Male 221	549	221.585000	Level 0 Recovery	33	Male 1932	560	373.720000	Level 0 Recovery	19	Female 1828	562	201.865000	Level 0 Recovery	22	Female 2001	565	504.885000	Level 0 Recovery	27	Male

Toán tử đa quan hệ

Chúng tôi có thể tạo UNION giữa hai quan hệ bằng cách sử dụng .union Điều này kết hợp các kết quả của cả hai mối quan hệ.

rel.union (rel)
---------------------
-- Expression Tree --
---------------------
Union read_csv_auto(bank_data.csv) read_csv_auto(bank_data.csv)

Tham gia hai mối quan hệ trên id cột. Chúng tôi đã tạo rel2 và tham gia nó để rel dựa trên ID.

rel2 = duckdb.df (df)

rel.join (rel2, 'id')

---------------------
-- Expression Tree --
---------------------
Join read_csv_auto(bank_data.csv) pandas_scan(139890483423984)

Để tham gia mối quan hệ tương tự, chúng tôi sẽ sử dụng alias() để thay đổi bí danh và sau đó nối chúng như hình dưới đây.

rel.set_alias ('a'). tham gia (rel.set_alias ('b'), 'a.id = b.id')

 - - - - - - - - - - - - Cây biểu thức - - - - - - - - - - - - Tham gia read_csv_auto (bank_data.csv) read_csv_auto (bank_data.csv)

Chức năng DuckDB với DataFrame.

Chúng ta có thể bỏ qua việc tạo quan hệ và đi sâu vào lọc và sắp xếp bằng cách sử dụng duckdb.(,). Các ví dụ cho thấy cách bạn có thể tạo kết quả bằng cách sử dụng khung dữ liệu Pandas trực tiếp.

print (duckdb.filter (df, 'age> 1'))

print (duckdb.project (df, 'age +1'))

print (duckdb.order (df, 'sex'))

print (duckdb.limit (df, 2))

Tương tự, chúng ta có thể tạo một chuỗi các hàm và hiển thị kết quả như hình bên dưới.

duckdb.filter (df, 'age> 1'). project ('age + 1'). order ('sex'). limit (2)

---------------------
-- Expression Tree --
---------------------
Limit 2 Order [sex DESC] Projection [age + 1] Filter [age>1] pandas_scan(139890483423984)

--------------------- - Cột Kết quả ---------------------------- tuổi + 1 (LỚN)
---------------------
-- Result Preview --
---------------------
age + 1 BIGINT [ Rows: 2]
26 20

Kết quả truy vấn quan hệ trong DuckDB

Để hiển thị kết quả của việc sử dụng quan hệ:

fetchall (): để hiển thị tất cả các giá trị từ kết quả.
fetchdf (): để hiển thị kết quả dưới dạng Khung dữ liệu Pandas.
fethnumpy (): để hiển thị kết quả dưới dạng mảng Numpy.

res = rel.execute ()

print (res.fetchone ())
(2030, 194, 263.54, 'Phục hồi cấp độ 0', 19, 'Nam')

print (res.fetchall ())

[(1150, 486, 416.09, 'Phục hồi cấp 0', 25, 'Nữ'), (380, 527, 429.35, 'Phục hồi cấp 0', 27, 'Nam') .....

Chúng tôi cũng có thể chuyển đổi kết quả thành khung dữ liệu Pandas bằng cách sử dụng rel.df() or rel.to_df() như hình dưới đây.

rel.to_df ()

Bàn và VịtDB

Chúng ta cũng có thể tạo các bảng trong mối quan hệ bằng cách sử dụng .create

rel.create (“test_table2”)

Trong phần tiếp theo, chúng ta sẽ tìm hiểu các cách khác nhau để chèn các giá trị vào mối quan hệ.

Chèn các giá trị bằng cách sử dụng values() và insert_into()
tạo một quan hệ bằng cách sử dụng test_table3.
Chèn các giá trị vào quan hệ bằng cách sử dụng hàm .insert đơn giản.

Như chúng ta thấy, chúng ta đã thêm thành công một giá trị duy nhất vào mối quan hệ.

conn.execute (“TẠO BẢNG test_table3 (tôi INTEGER, j STRING)”)

conn.values ([5, 'five']). insert_into (“test_table3”)

rel_3 = conn.table (“test_table3”)

rel_3.insert ([6, 'six'])

rel_3

---------------------
-- Expression Tree --
---------------------
Scan Table [test_table3]

--------------------- - Các Cột Kết quả ---------------------------- - i (INTEGER) - j (VARCHAR)
---------------------
-- Result Preview --
---------------------
i	j INTEGER	VARCHAR [ Rows: 2]
5	five 6	six

Chức năng truy vấn DuckDB

Để chạy các truy vấn SQL trực tiếp, bạn có thể sử dụng .query chúng với mối quan hệ. Sau đó, thêm đầu vào đầu tiên làm tên dạng xem của truy vấn và đầu vào thứ hai dưới dạng tập lệnh SQL bằng cách sử dụng tên dạng xem như được hiển thị bên dưới.

res = rel.query ('my_name_for_rel', 'SELECT * FROM my_name_for_rel LIMIT 5')

Để xem kết quả, chúng ta hãy sử dụng fetchall() để hiển thị tất cả 5 giá trị.

res.fetchall ()

[(2030, 194, 263.54, 'Level 0 Recovery', 19, 'Male'), (1150, 486, 416.09, 'Level 0 Recovery', 25, 'Female'), (380, 527, 429.35, 'Level 0 Recovery', 27, 'Male'), (1838, 536, 296.99, 'Level 0 Recovery', 25, 'Male'), (1995, 541, 346.385, 'Level 0 Recovery', 34, 'Male')]

Chúng tôi có thể trực tiếp sử dụng .query() và chạy một truy vấn trên test_df bàn. Kết quả hiển thị tất cả bốn giá trị từ bảng. Hàm truy vấn có thể thực hiện tất cả các chức năng trên bảng, khung dữ liệu và thậm chí trên .csv các tập tin.

res = duckdb.query ('CHỌN * TỪ test_df')

res.df ()

Để chạy một truy vấn trên .csv tập tin, chúng tôi sẽ sử dụng read_csv_auto() trong tập lệnh SQL. Trong trường hợp của chúng tôi, chúng tôi đang đọc toàn bộ dữ liệu trực tiếp từ tệp CSV và hiển thị nó trong khung dữ liệu Pandas.

res = duckdb.query (“CHỌN * TỪ read_csv_auto ('bank_data.csv')”)

res.df ()

Hãy chạy một script phức tạp để chúng ta có thể nhận ra toàn bộ tiềm năng của DuckDB. Kết quả dưới đây cho thấy rằng một phụ nữ đã thu hồi được nhiều tiền hơn mong đợi bằng cách sử dụng chiến lược cấp 4. Theo tôi, sử dụng truy vấn SQL để phân tích dữ liệu rất nhanh và thú vị, thay vì tải dữ liệu của bạn vào gấu trúc và viết một loạt mã để nhận được kết quả tương tự.

res = duckdb.query (“CHỌN giới tính, SUM (dự kiến_recovery_amount) như Dự kiến, SUM (thực_triển_amount) là Thực tế TỪ 'bank_data.csv' WHERE recovery_strategy LIKE" Khôi phục cấp 4 "NHÓM BY sex HAVING sex = 'Nữ'") res. df ()

Ô SQL ghi chú sâu

Ghi chú sâu'S Ô SQL Dataframe đang sử dụng DuckDB trên phần phụ trợ của nó, vì vậy nếu bạn muốn sử dụng tất cả các chức năng của DuckDB một cách dễ dàng, tôi khuyên bạn nên sử dụng ô Deepnote SQL. Để chạy truy vấn SQL của bạn, trước hết hãy thêm các ô SQL từ tùy chọn khối.

Hãy thử viết một tập lệnh SQL đơn giản. Như chúng ta có thể thấy, chúng ta đang đọc dữ liệu trực tiếp từ ngân hàng_data.csv và kết quả được lưu trữ trong df_1 dưới dạng Pandas DataFrame. Tôi chỉ thích tính năng này, nó thậm chí còn tốt hơn việc tải dữ liệu của bạn thông qua Pandas.

Hãy thử một truy vấn SQL phức tạp hơn trên tệp CSV. Chúng tôi sẽ hiển thị ba cột tình dục, mong đợivà thực tế. Sau đó, chúng tôi sẽ chọn các giá trị trong đó chiến lược phục hồi là 'Phục hồi cấp độ 4' và nhóm theo quan hệ tình dục. Cuối cùng, chúng tôi sẽ chỉ hiển thị giá trị nữ.

Suy nghĩ cuối cùng về DuckDB

DuckDB có thể giải quyết hầu hết các vấn đề trong cơ sở dữ liệu SQL truyền thống. Đây là một hệ thống quản lý cơ sở dữ liệu không máy chủ với các truy vấn phân tích nhanh hơn và nó được tích hợp hoàn toàn với Python và R. Nếu bạn định triển khai ứng dụng khoa học dữ liệu hoặc máy học, tôi khuyên bạn nên thêm DuckDB vào ngăn xếp của mình.

Trong hướng dẫn này, chúng ta đã học các cách khác nhau để tạo cơ sở dữ liệu, thêm bảng và chạy các truy vấn. Chúng ta cũng đã học về các quan hệ và chúng ta có thể sử dụng chúng để tạo các hàm phức tạp. Cuối cùng, chúng tôi đã sử dụng nhiều cách khác nhau để tương tác trực tiếp với tệp CSV và chạy nhiều tập lệnh phức tạp. Hướng dẫn này bao gồm tất cả các loại ví dụ, vì vậy nếu bạn gặp khó khăn trong dự án của mình, bạn có thể quay lại và học một số thủ thuật. Cuối cùng, tôi sẽ luôn đề nghị bạn le

Tài nguyên học tập

về tác giả

Abid Ali Awan (@ 1abidaliawan) là một nhà khoa học dữ liệu chuyên nghiệp được chứng nhận, người yêu thích việc xây dựng các mô hình học máy và nghiên cứu về các công nghệ AI mới nhất. Hiện tại, đang thử nghiệm các Sản phẩm AI tại PEC-PITC, công việc của họ sau đó được phê duyệt để thử nghiệm trên người, chẳng hạn như Máy phân loại ung thư vú. Tầm nhìn của ông là xây dựng một sản phẩm trí tuệ nhân tạo có thể xác định các sinh viên đang vật lộn với bệnh tâm thần.

Dự án danh mục khoa học dữ liệu

Phương tiện hiển thị trong bài viết này không thuộc sở hữu của Analytics Vidhya và được sử dụng theo quyết định của Tác giả

Sản phẩm liên quan

PlatoAi. Web3 được mô phỏng lại. Khuếch đại dữ liệu thông minh.
Nhấn vào đây để truy cập.

Nguồn: https://www.analyticsvidhya.com/blog/2021/12/the-guide-to-data-analysis-with-duckdb/

Trí thông minh dữ liệu tạo