选择随机样本

A random selection of rows or columns from a Series, DataFrame, or Panel with the sample() method. The method will sample rows by default, and accepts a specific number of rows/columns to return, or a fraction of rows.

  1. In [111]: s = pd.Series([0,1,2,3,4,5])
  3. # When no arguments are passed, returns 1 row.
  4. In [112]: s.sample()
  5. Out[112]: 
  6. 4    4
  7. dtype: int64
  9. # One may specify either a number of rows:
  10. In [113]: s.sample(n=3)
  11. Out[113]: 
  12. 0    0
  13. 4    4
  14. 1    1
  15. dtype: int64
  17. # Or a fraction of the rows:
  18. In [114]: s.sample(frac=0.5)
  19. Out[114]: 
  20. 5    5
  21. 3    3
  22. 1    1
  23. dtype: int64

By default, sample will return each row at most once, but one can also sample with replacement using the replace option:

  1. In [115]: s = pd.Series([0,1,2,3,4,5])
  3.  # Without replacement (default):
  4. In [116]: s.sample(n=6, replace=False)
  5. Out[116]: 
  6. 0    0
  7. 1    1
  8. 5    5
  9. 3    3
  10. 2    2
  11. 4    4
  12. dtype: int64
  14.  # With replacement:
  15. In [117]: s.sample(n=6, replace=True)
  16. Out[117]: 
  17. 0    0
  18. 4    4
  19. 3    3
  20. 2    2
  21. 4    4
  22. 4    4
  23. dtype: int64

By default, each row has an equal probability of being selected, but if you want rows to have different probabilities, you can pass the sample function sampling weights as weights. These weights can be a list, a NumPy array, or a Series, but they must be of the same length as the object you are sampling. Missing values will be treated as a weight of zero, and inf values are not allowed. If weights do not sum to 1, they will be re-normalized by dividing all weights by the sum of the weights. For example:

  1. In [118]: s = pd.Series([0,1,2,3,4,5])
  3. In [119]: example_weights = [0, 0, 0.2, 0.2, 0.2, 0.4]
  5. In [120]: s.sample(n=3, weights=example_weights)
  6. Out[120]: 
  7. 5    5
  8. 4    4
  9. 3    3
  10. dtype: int64
  12. # Weights will be re-normalized automatically
  13. In [121]: example_weights2 = [0.5, 0, 0, 0, 0, 0]
  15. In [122]: s.sample(n=1, weights=example_weights2)
  16. Out[122]: 
  17. 0    0
  18. dtype: int64

When applied to a DataFrame, you can use a column of the DataFrame as sampling weights (provided you are sampling rows and not columns) by simply passing the name of the column as a string.

  1. In [123]: df2 = pd.DataFrame({'col1':[9,8,7,6], 'weight_column':[0.5, 0.4, 0.1, 0]})
  3. In [124]: df2.sample(n = 3, weights = 'weight_column')
  4. Out[124]: 
  5.    col1  weight_column
  6. 1     8            0.4
  7. 0     9            0.5
  8. 2     7            0.1

sample also allows users to sample columns instead of rows using the axis argument.

  1. In [125]: df3 = pd.DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})
  3. In [126]: df3.sample(n=1, axis=1)
  4. Out[126]: 
  5.    col1
  6. 0     1
  7. 1     2
  8. 2     3

Finally, one can also set a seed for sample’s random number generator using the random_state argument, which will accept either an integer (as a seed) or a NumPy RandomState object.

  1. In [127]: df4 = pd.DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})
  3. # With a given seed, the sample will always draw the same rows.
  4. In [128]: df4.sample(n=2, random_state=2)
  5. Out[128]: 
  6.    col1  col2
  7. 2     3     4
  8. 1     2     3
  10. In [129]: df4.sample(n=2, random_state=2)
  11. Out[129]: 
  12.    col1  col2
  13. 2     3     4
  14. 1     2     3