Làm thế nào để bạn khớp gaussian với biểu đồ trong python?

Biểu đồ trong Python thuần túy

Khi bạn đang chuẩn bị vẽ một biểu đồ tần suất, đơn giản nhất là đừng nghĩ về các thùng mà hãy báo cáo số lần mỗi giá trị xuất hiện (một bảng tần số). 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})

>>> recounted.items() == counted.items()
True

>>> recounted.items() == counted.items()
True

>>> recounted.items() == counted.items()
True

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

>>> 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})

Bạn có thể xác nhận rằng chức năng thủ công của bạn thực hiện hầu như giống như

>>> recounted.items() == counted.items()
True

>>>

>>> recounted.items() == counted.items()
True

Chi tiết kỹ thuật. Ánh xạ từ

>>> 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})

>>> recounted.items() == counted.items()
True

Có thể hữu ích khi xây dựng các hàm đơn giản hóa từ đầu như là bước đầu tiên để hiểu những hàm 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 lợi thế của Python

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]))

Hàm này tạo một biểu đồ tần suất được sắp xếp trong đó số lượng được biểu diễn dưới dạng các ký hiệu cộng (

>>> recounted.items() == counted.items()
True

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]))

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]))

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]))

>>>

>>> # 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 ++++++++++++

Ở đây, bạn đang mô phỏng việc gảy 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]))

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]))

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]))

Ghi chú. được sử dụng để tạo hoặc khởi tạo, trình tạo số giả ngẫu nhiên cơ bản (PRNG) được sử dụng bởi

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]))

Xây dựng từ cơ sở. Tính toán biểu đồ trong NumPy

Cho đến nay, bạn đã làm việc với thứ tốt nhất có thể gọi là “bảng tần số. ” Nhưng về mặt toán học, biểu đồ là ánh xạ của các thùng (khoảng) thành tần số. Về mặt kỹ thuật hơn, nó có thể được sử dụng để tính gần đúng hàm mật độ xác suất (PDF) của biến cơ bản

Tiếp tục từ “bảng tần suất” ở trên, trước tiên, một biểu đồ thực sẽ “phân tách” phạm vi giá trị và sau đó đếm số lượng giá trị rơi vào mỗi ngăn. Đây là chức năng của hàm

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]))

Hãy xem xét một mẫu số float được rút ra từ phân phối Laplace. Phân phối này có đuôi béo hơn phân phối bình thường và có hai tham số mô tả (vị trí và tỷ lệ)

>>>

>>> 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])

Trong trường hợp này, bạn đang làm việc với phân phối liên tục và sẽ không hữu ích lắm nếu kiểm đếm từng số float một cách độc lập, xuống đến chữ số thập phân thứ mười một. Thay vào đó, bạn có thể tạo thùng hoặc “nhóm” dữ liệu và đếm các quan sát rơi vào mỗi thùng. Biểu đồ là tổng số giá trị trong mỗi thùng

>>>

>>> 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])

Kết quả này có thể không trực quan ngay lập tứ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 ++++++++++++

>>>

>>> hist.size, bin_edges.size
(10, 11)

Chi tiết kỹ thuật. Tất cả trừ thùng cuối cùng (ngoài cùng bên phải) đang mở một nửa. Nghĩa là, tất cả các ngăn trừ ngăn cuối cùng là [bao gồm, loại trừ) và ngăn cuối cùng là [bao gồm, bao gồm]

Một phân tích rất cô đọng về cách các thùng được xây dựng trông như thế này

>>>

>>> # 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. ])

Trường hợp trên có rất nhiều ý nghĩa. 10 ngăn cách đều nhau trên phạm vi từ đỉnh đến đỉnh là 23 có nghĩa là các khoảng có chiều rộng 2. 3

Từ đó, hàm ủy quyền cho

>>> # 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 ++++++++++++

>>> # 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 ++++++++++++

>>> # 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 ++++++++++++

>>>

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

Ghi chú.

>>> recounted.items() == counted.items()
True

>>> # 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 ++++++++++++

Trực quan hóa Biểu đồ với Matplotlib và Pandas

Bây giờ bạn đã biết cách xây dựng 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 các biểu đồ Python ngay lập tức với một trình bao bọc linh hoạt xung quanh

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]))

>>> from collections import Counter

>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})

Như đã đị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à các tần số tương ứng trên trục y. Trong biểu đồ trên, thông qua

>>> # 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 ++++++++++++

Ở 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 ++++++++++++

>>> from collections import Counter

>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})

>>> 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])

Vẽ 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 một cách thống kê. Cho dù dữ liệu là rời rạc hay liên tục, nó được giả định là bắt nguồn từ một tổng thể có phân phối chính xác, thực tế được mô tả chỉ bằng một vài tham số

Ước tính mật độ hạt nhân (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 “làm cơ sở” 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 ô mật độ bằng cách sử dụ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])

>>> 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])

>>> 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})

Bâ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})

Các phương pháp này tận dụ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])

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 với PDF “đúng” như thế nào đối với một mẫu tương đối nhỏ gồm 1000 điểm dữ liệu. Bên dưới, trước tiên bạn có thể xây dựng bản phân phối “phân tích” 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])

>>> 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])

Xây dựng từ đó, bạn có thể lấy một mẫu ngẫu nhiên gồm 1000 điểm dữ liệu từ bản phân phối này, sau đó cố gắng quay lại ước tính của tệp PDF 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])

>>> from collections import Counter

>>> recounted = Counter(a)
>>> recounted
Counter({0: 1, 1: 3, 3: 1, 2: 1, 7: 2, 23: 1})

Đây là một đoạn mã lớn hơn, vì vậy hãy dành một giây để chạm vào một vài dòng chính

• Gói con

  >>> 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])
  

  8 của SciPy cho phép bạn tạo các đối tượng Python đại diện cho các bản phân phối phân tích mà bạn có thể lấy mẫu từ đó để 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])
  

  9 đại diện cho một biến ngẫu nhiên liên tục bình thường và bạn tạo các số ngẫu nhiên từ biến đó với

  >>> 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
• Để đánh giá cả PDF phân tích và Gaussian KDE, bạn cần một mảng

  >>> 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])
  

  1 lượng phân vị (độ lệch chuẩn trên/dưới giá trị trung bình, đối với phân phối chuẩn).

  >>> 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])
  

  2 đại diện cho một tệp PDF ước tính mà bạn cần đánh giá trên một mảng để tạo ra thứ 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ế ưa thích với Seaborn

Hãy mang thêm một gói Python vào hỗn hợp. Seaborn có hàm

>>> 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])

>>> 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})

Cuộc gọi ở trên tạo ra một KDE. Ngoài ra còn có 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})

Một lần nữa, lưu ý sự khác biệt nhỏ. Trong trường hợp đầu tiên, bạn đang ước tính một số tệp PDF không xác định;

Các công cụ khác trong Pandas

Ngoài các công cụ vẽ biểu đồ, Pandas còn cung cấp một phương pháp

>>> 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])

>>> 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})

Ở những nơi khác,

>>> 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})

Điều thú vị là cả hai hoạt động này cuối cùng đều sử dụng mã Cython giúp chúng cạnh tranh về tốc độ trong khi vẫn duy trì tính linh hoạt

Đượ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àm và phương thức để lựa chọn để vẽ biểu đồ Python. Làm thế nào để họ so sánh? . ” Đây là bản tóm tắt 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 chia nhỏ và biểu diễn các bản phân phối trong Python

Bạn Có/Muốn Cân nhắc Sử dụng (Các) Ghi chú Dữ liệu số nguyên cắt gọn được đặt trong một cấu trúc dữ liệu như danh sách, bộ hoặc tập hợp 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. từ thư viện chuẩn Python cung cấp một cách nhanh chóng và đơn giản để lấy số lượng tần suất từ ​​một vùng chứa dữ liệu. Đây là một bảng tần suất, vì vậy nó không sử dụng khái niệm tạo thùng như một biểu đồ "đúng". Mảng dữ liệu lớn và bạn muốn tính toán biểu đồ "toán học" đại diện cho các thùng và tần số tương ứng. NumPy's

>>> # 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 ++++++++++++

>>> # 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 ++++++++++++

>>> hist.size, bin_edges.size
(10, 11)

>>> 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])

>>> 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])

>>> hist.size, bin_edges.size
(10, 11)

>>> hist.size, bin_edges.size
(10, 11)

>>> hist.size, bin_edges.size
(10, 11)

>>> hist.size, bin_edges.size
(10, 11)

>>> hist.size, bin_edges.size
(10, 11)

>>> hist.size, bin_edges.size
(10, 11)

>>> # 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. ])

>>> # 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 ++++++++++++

>>> # 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. ])

Tiền thưởng miễn phí. Thời gian ngắn?

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 Tài liệu Python thực

Với điều đó, chúc may mắn khi tạo biểu đồ trong tự nhiên. Hy vọng rằ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 không sử dụng biểu đồ hình tròn