Trong hướng dẫn này, bạn sẽ được trang bị để tạo ra các biểu đồ Python chất lượng sản xuất, trình bày sẵn sàng trình bày với một loạt các lựa chọn và tính năng. Nếu bạn đã giới thiệu kiến thức trung gian về Python và thống kê, thì bạn có thể sử dụng bài viết này như một cửa hàng để xây dựng và âm mưu biểu đồ trong Python sử dụng các thư viện từ ngăn xếp khoa học của nó, bao gồm Numpy, Matplotlib, Pandas và Seaborn. Biểu đồ là một công cụ tuyệt vời để nhanh chóng đánh giá phân phối xác suất được hầu hết các đối tượng hiểu trực giác. Python cung cấp một số ít các tùy chọn khác nhau để xây dựng và vẽ biểu đồ. Hầu hết mọi người đều biết biểu đồ theo biểu diễn đồ họa của nó, tương tự như biểu đồ thanh: Bài viết này sẽ hướng dẫn bạn thông qua việc tạo các lô như phần trên cũng như những bài viết phức tạp hơn. Đây là những gì bạn bao gồm: - Xây dựng biểu đồ trong Python thuần túy, không sử dụng thư viện của bên thứ ba
- Xây dựng biểu đồ với Numpy để tóm tắt dữ liệu cơ bản
- Âm mưu biểu đồ kết quả với matplotlib, gấu trúc và seeborn
Biểu đồ trong Python thuần túyKhi bạn đang chuẩn bị vẽ một biểu đồ, việc không nghĩ về các thùng là đơn giản nhất mà là báo cáo bao nhiêu lần mỗi giá trị xuất hiện (một bảng tần số). Một từ điển Python rất phù hợp cho nhiệm vụ này: >>> >>> # Need not be sorted, necessarily
>>> a = (0, 1, 1, 1, 2, 3, 7, 7, 23)
>>> def count_elements(seq) -> dict:
... """Tally elements from `seq`."""
... hist = {}
... for i in seq:
... hist[i] = hist.get(i, 0) + 1
... return hist
>>> counted = count_elements(a)
>>> counted
{0: 1, 1: 3, 2: 1, 3: 1, 7: 2, 23: 1}
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.Trên thực tế, đây chính xác là những gì được thực hiện bởi lớp >>> recounted.items() == counted.items()
True
3 từ thư viện tiêu chuẩn Python, trong đó phân lớp từ điển Python và ghi đè phương thức >>> recounted.items() == counted.items()
True
4 của nó:>>> >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.>>> >>> recounted.items() == counted.items()
True
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
Trên thực tế, đây chính xác là những gì được thực hiện bởi lớp >>> recounted.items() == counted.items()
True
3 từ thư viện tiêu chuẩn Python, trong đó phân lớp từ điển Python và ghi đè phương thức >>> recounted.items() == counted.items()
True
4 của nó:>>> >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.Trên thực tế, đây chính xác là những gì được thực hiện bởi lớp >>> recounted.items() == counted.items()
True
3 từ thư viện tiêu chuẩn Python, trong đó phân lớp từ điển Python và ghi đè phương thức >>> recounted.items() == counted.items()
True
4 của nó:Bạn có thể xác nhận rằng chức năng thủ công của bạn làm hầu như giống như >>> recounted.items() == counted.items()
True
3 bằng cách kiểm tra sự bình đẳng giữa hai:Nó có thể hữu ích để xây dựng các chức năng đơn giản hóa từ đầu như là bước đầu tiên để hiểu các chức năng phức tạp hơn. Hãy để tiếp tục phát minh lại bánh xe một chút với biểu đồ ASCII tận dụng định dạng đầu ra của Python,: Hàm này tạo ra một biểu đồ tần số được sắp xếp trong đó số lượng được biểu diễn dưới dạng các biểu tượng của Plus ( >>> recounted.items() == counted.items()
True
6). Gọi >>> recounted.items() == counted.items()
True
7 trên một từ điển trả về một danh sách được sắp xếp các khóa của nó và sau đó bạn truy cập giá trị tương ứng cho mỗi khóa với >>> recounted.items() == counted.items()
True
8. Để xem điều này trong hành động, bạn có thể tạo một bộ dữ liệu lớn hơn một chút với mô -đun Python, ____29:>>> >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.>>> >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.>>> >>> hist.size, bin_edges.size
(10, 11)
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.>>> >>> # The leftmost and rightmost bin edges
>>> first_edge, last_edge = a.min(), a.max()
>>> n_equal_bins = 10 # NumPy's default
>>> bin_edges = np.linspace(start=first_edge, stop=last_edge,
... num=n_equal_bins + 1, endpoint=True)
...
>>> bin_edges
array([ 0. , 2.3, 4.6, 6.9, 9.2, 11.5, 13.8, 16.1, 18.4, 20.7, 23. ])
>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
9 trả về một từ điển với các phần tử duy nhất từ chuỗi dưới dạng các khóa và tần số (tính) của chúng là giá trị. Trong vòng lặp trên >>> recounted.items() == counted.items()
True
0, >>> recounted.items() == counted.items()
True
1 nói, Đối với mỗi phần tử của chuỗi, tăng giá trị tương ứng của nó trong >>> recounted.items() == counted.items()
True
2 bởi 1.Trên thực tế, đây chính xác là những gì được thực hiện bởi lớp >>> recounted.items() == counted.items()
True
3 từ thư viện tiêu chuẩn Python, trong đó phân lớp từ điển Python và ghi đè phương thức >>> recounted.items() == counted.items()
True
4 của nó:>>> >>> bcounts = np.bincount(a)
>>> hist, _ = np.histogram(a, range=(0, a.max()), bins=a.max() + 1)
>>> np.array_equal(hist, bcounts)
True
>>> # Reproducing `collections.Counter`
>>> dict(zip(np.unique(a), bcounts[bcounts.nonzero()]))
{0: 1, 1: 3, 2: 1, 3: 1, 7: 2, 23: 1}
Hình dung biểu đồ với matplotlib và gấu trúcBây giờ, bạn đã thấy cách xây dựng một biểu đồ trong Python từ đầu, hãy để xem các gói Python khác có thể thực hiện công việc cho bạn như thế nào. Matplotlib cung cấp chức năng để trực quan hóa biểu đồ python ra khỏi hộp với một trình bao bọc đa năng xung quanh Numpy tựa def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
3:>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
0Như đã định nghĩa trước đó, một biểu đồ của biểu đồ sử dụng các cạnh bin của nó trên trục x và tần số tương ứng trên trục y. Trong biểu đồ trên, việc vượt qua def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
9 đã chọn giữa hai thuật toán để ước tính số lượng thùng lý tưởng của người Viking. Ở cấp độ cao, mục tiêu của thuật toán là chọn một chiều rộng bin tạo ra biểu diễn trung thực nhất của dữ liệu. Để biết thêm về chủ đề này, có thể nhận được khá kỹ thuật, hãy kiểm tra chọn các thùng biểu đồ từ các tài liệu Astropy.Ở trong ngăn xếp khoa học của Python, Pandas, >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
0 sử dụng >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
1 để vẽ biểu đồ matplotlib của chuỗi đầu vào:>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
1>>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
2 là tương tự nhưng tạo ra một biểu đồ cho mỗi cột dữ liệu trong DataFrame.
Sơ đồ ước tính mật độ hạt nhân (KDE)Trong hướng dẫn này, bạn đã làm việc với các mẫu, nói về mặt thống kê. Cho dù dữ liệu là rời rạc hay liên tục, nó được cho là có nguồn gốc từ một dân số có phân phối chính xác, chính xác được mô tả chỉ bằng một vài tham số. Ước tính mật độ kernel (KDE) là một cách để ước tính hàm mật độ xác suất (PDF) của biến ngẫu nhiên mà cách làm nền tảng cho mẫu của chúng tôi. KDE là một phương tiện làm mịn dữ liệu. Gắn bó với thư viện PANDAS, bạn có thể tạo và phủ các sơ đồ mật độ bằng cách sử dụng >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
3, có sẵn cho cả các đối tượng >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
4 và >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
5. Nhưng trước tiên, hãy để tạo ra hai mẫu dữ liệu riêng biệt để so sánh:>>> >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
2Bây giờ, để vẽ từng biểu đồ trên cùng một trục matplotlib: >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
3Các phương pháp này tận dụng SCIPY từ >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
6, dẫn đến một bản PDF trông mượt mà hơn.Nếu bạn xem xét kỹ hơn chức năng này, bạn có thể thấy nó gần đúng mức độ của PDF True True PDF đối với một mẫu tương đối nhỏ gồm 1000 điểm dữ liệu. Dưới đây, trước tiên bạn có thể xây dựng phân phối phân tích trực tuyến với >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
7. Đây là một thể hiện lớp gói đóng gói phân phối bình thường tiêu chuẩn thống kê, khoảnh khắc và các hàm mô tả. PDF của nó là chính xác của nó theo nghĩa là nó được xác định chính xác là >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
8.Xây dựng từ đó, bạn có thể lấy một mẫu ngẫu nhiên là 1000 datapoints từ phân phối này, sau đó cố gắng quay lại ước tính PDF với >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
9:>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
4Đây là một đoạn mã lớn hơn, vì vậy, hãy để một giây để chạm vào một vài dòng chính: - Subpackage SCIPY từ
>>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
0 cho phép bạn tạo các đối tượng Python đại diện cho các phân phối phân tích mà bạn có thể lấy mẫu để tạo dữ liệu thực tế. Vì vậy, >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
1 đại diện cho một biến ngẫu nhiên liên tục thông thường và bạn tạo ra các số ngẫu nhiên từ nó với >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
2. - Để đánh giá cả PDF phân tích và KDE Gaussian, bạn cần một mảng
>>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
3 lượng tử (độ lệch chuẩn ở trên/dưới giá trị trung bình, cho phân phối bình thường). >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
4 thể hiện PDF ước tính mà bạn cần đánh giá trên một mảng để tạo ra một cái gì đó có ý nghĩa trực quan trong trường hợp này. - Dòng cuối cùng chứa một số latex, tích hợp độc đáo với matplotlib.
Một sự thay thế lạ mắt với SeabornHãy để Lừa mang thêm một gói Python vào hỗn hợp. Seaborn có chức năng >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
5 biểu đồ biểu đồ và KDE để phân phối đơn biến trong một bước. Sử dụng mảng numpy >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
6 từ Ealier:>>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
5Cuộc gọi ở trên tạo ra một KDE. Ngoài ra còn có tính tùy chọn để phù hợp với một phân phối cụ thể cho dữ liệu. Điều này khác với KDE và bao gồm ước tính tham số cho dữ liệu chung và tên phân phối được chỉ định: >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
6Một lần nữa, lưu ý sự khác biệt nhỏ. Trong trường hợp đầu tiên, bạn đã ước tính một số PDF không xác định; Trong lần thứ hai, bạn đã lấy một phân phối đã biết và tìm ra những tham số mô tả tốt nhất nó được cung cấp dữ liệu thực nghiệm. Các công cụ khác trong gấu trúcNgoài các công cụ âm mưu của nó, Pandas cũng cung cấp một phương thức >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
7 thuận tiện để tính toán biểu đồ của các giá trị không null cho gấu trúc >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
4:>>> >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
7Ở những nơi khác, >>> import numpy as np
>>> # `numpy.random` uses its own PRNG.
>>> np.random.seed(444)
>>> np.set_printoptions(precision=3)
>>> d = np.random.laplace(loc=15, scale=3, size=500)
>>> d[:5]
array([18.406, 18.087, 16.004, 16.221, 7.358])
9 là một cách thuận tiện để các giá trị thùng thành các khoảng thời gian tùy ý. Hãy nói rằng bạn có một số dữ liệu về độ tuổi của các cá nhân và muốn xô chúng một cách hợp lý:>>> >>> from collections import Counter
>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})
8Điều mà tốt đẹp là cả hai hoạt động này cuối cùng sử dụng mã Cython giúp chúng cạnh tranh về tốc độ trong khi duy trì tính linh hoạt của chúng.
Được rồi, vậy tôi nên sử dụng cái nào?Tại thời điểm này, bạn đã thấy nhiều hơn một số hàm và phương pháp để lựa chọn để vẽ biểu đồ Python. Làm thế nào để họ so sánh? Nói tóm lại, không có một kích cỡ phù hợp với một kích cỡ nào. Ở đây, một bản tóm tắt về các chức năng và phương thức mà bạn đã đề cập cho đến nay, tất cả đều liên quan đến việc phá vỡ và đại diện cho các phân phối trong Python:
| Bạn có/muốn | Xem xét sử dụng | Note(s) |
|---|
| Dữ liệu số nguyên cắt sạch được đặt trong một cấu trúc dữ liệu như danh sách, tuple hoặc bộ và bạn muốn tạo biểu đồ Python mà không cần nhập bất kỳ thư viện bên thứ ba nào. | >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
0 từ Thư viện tiêu chuẩn Python cung cấp một cách nhanh chóng và đơn giản để có được số lượng tần số từ một thùng chứa dữ liệu. | Đây là một bảng tần số, vì vậy nó không sử dụng khái niệm về Binning như một biểu đồ thực sự của người Viking. | | Mảng dữ liệu lớn và bạn muốn tính toán biểu đồ toán học của người Viking đại diện cho các thùng và tần số tương ứng. | Numpy từ def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
4 và def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
5 rất hữu ích cho việc tính toán các giá trị biểu đồ bằng số và các cạnh bin tương ứng. | Để biết thêm, hãy kiểm tra >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
3. | Dữ liệu dạng bảng trong đối tượng Pandas, >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
4 hoặc >>> # No NumPy ... yet
>>> import random
>>> random.seed(1)
>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)
>>> data = []
>>> for f, v in zip(freq, vals):
... data.extend([v] * f)
>>> ascii_histogram(data)
1 +++++++
3 ++++++++++++++
4 ++++++
6 +++++++++
8 ++++++
9 ++++++++++++
10 ++++++++++++
5. | Các phương pháp gấu trúc như >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
6, >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
7, >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
8 và >>> hist, bin_edges = np.histogram(d)
>>> hist
array([ 1, 0, 3, 4, 4, 10, 13, 9, 2, 4])
>>> bin_edges
array([ 3.217, 5.199, 7.181, 9.163, 11.145, 13.127, 15.109, 17.091,
19.073, 21.055, 23.037])
9, cũng như >>> hist.size, bin_edges.size
(10, 11)
0 và >>> hist.size, bin_edges.size
(10, 11)
1. | Kiểm tra các tài liệu trực quan về gấu trúc để lấy cảm hứng. | | Tạo một cốt truyện được tùy biến cao, tinh chỉnh từ bất kỳ cấu trúc dữ liệu nào. | >>> hist.size, bin_edges.size
(10, 11)
2 là một hàm âm mưu biểu đồ được sử dụng rộng rãi sử dụng def ascii_histogram(seq) -> None:
"""A horizontal frequency-table/histogram plot."""
counted = count_elements(seq)
for k in sorted(counted):
print('{0:5d} {1}'.format(k, '+' * counted[k]))
4 và là cơ sở cho các chức năng âm mưu của Pandas. | Matplotlib, và đặc biệt là khung hướng đối tượng của nó, là tuyệt vời để tinh chỉnh các chi tiết của một biểu đồ. Giao diện này có thể mất một chút thời gian để làm chủ, nhưng cuối cùng cho phép bạn rất chính xác trong cách thức trực quan hóa được đặt ra. | | Thiết kế và tích hợp trước. | Seaborn từ >>> hist.size, bin_edges.size
(10, 11)
4, để kết hợp biểu đồ và biểu đồ KDE hoặc vẽ đồ thị phù hợp với phân phối. | Về cơ bản, một trình bao bọc của người Viking xung quanh một trình bao bọc, tận dụng một biểu đồ matplotlib bên trong, từ đó sử dụng Numpy. |
Bạn cũng có thể tìm thấy các đoạn mã từ bài viết này cùng nhau trong một tập lệnh tại trang Vật liệu Python thực. Với điều đó, chúc may mắn tạo ra biểu đồ trong tự nhiên. Hy vọng một trong những công cụ trên sẽ phù hợp với nhu cầu của bạn. Dù bạn làm gì, chỉ cần don sử dụng biểu đồ hình tròn.
Phương pháp nào được sử dụng để tạo biểu đồ với matplotlib?
Trong matplotlib, chúng tôi sử dụng hàm hist () để tạo biểu đồ. Hàm Hist () sẽ sử dụng một mảng các số để tạo biểu đồ, mảng được gửi vào hàm làm đối số.hist() function to create histograms. The hist() function will use an array of numbers to create a histogram, the array is sent into the function as an argument.
Làm thế nào để chúng ta sử dụng hàm hist () trong python?
Hàm Hist () trong mô -đun pyplot của thư viện matplotlib được sử dụng để vẽ biểu đồ biểu đồ ... N: Điều này trả về các giá trị của các thùng biểu đồ .. Bins: Điều này trả về các cạnh của các thùng .. Các bản vá: Điều này trả về danh sách các bản vá riêng lẻ được sử dụng để tạo biểu đồ .. Lệnh nào được sử dụng để tạo biểu đồ?
Hist (x) tạo biểu đồ thanh biểu đồ của các phần tử trong vector x.Các phần tử trong X được sắp xếp thành 10 thùng cách đều nhau dọc theo trục x giữa các giá trị tối thiểu và tối đa của x.Lịch sử hiển thị các thùng như hình chữ nhật, sao cho chiều cao của mỗi hình chữ nhật biểu thị số lượng phần tử trong thùng. creates a histogram bar chart of the elements in vector x . The elements in x are sorted into 10 equally spaced bins along the x-axis between the minimum and maximum values of x . hist displays bins as rectangles, such that the height of each rectangle indicates the number of elements in the bin.
Phương pháp biểu đồ là gì?
Biểu đồ là biểu diễn dữ liệu giống như biểu đồ thanh của thanh mà xô một loạt các lớp thành các cột dọc theo trục x ngang.Trục Y dọc đại diện cho số lượng hoặc tỷ lệ phần trăm xuất hiện trong dữ liệu cho mỗi cột.Các cột có thể được sử dụng để trực quan hóa các mẫu phân phối dữ liệu.a bar graph-like representation of data that buckets a range of classes into columns along the horizontal x-axis. The vertical y-axis represents the number count or percentage of occurrences in the data for each column. Columns can be used to visualize patterns of data distributions. |
