这篇文章主要围绕带有异常的Python随机样本和python异常例子展开，旨在为您提供一份详细的参考资料。我们将全面介绍带有异常的Python随机样本的优缺点，解答python异常例子的相关问题，同时

这篇文章主要围绕带有异常的Python随机样本和python异常例子展开，旨在为您提供一份详细的参考资料。我们将全面介绍带有异常的Python随机样本的优缺点，解答python异常例子的相关问题，同时也会为您带来Python Pandas从Groupby中选择组的随机样本、Python中异常的传递性和手动抛出异常的方法、python中的加权随机样本、python代码为给定参数的截断正态分布生成随机样本的实用方法。

• 带有异常的Python随机样本（python异常例子）
• Python Pandas从Groupby中选择组的随机样本
• Python中异常的传递性和手动抛出异常的方法
• python中的加权随机样本
• python代码为给定参数的截断正态分布生成随机样本

带有异常的Python随机样本（python异常例子）

i_ = 'd'

myList = ['a','b','c','d','e']

myList = random.sample(myList,3)

['a','e']

Python Pandas从Groupby中选择组的随机样本

随机获取a的元素的最佳方法是groupby什么？据我了解，agroupby只是在各个组之间迭代。

如果要选择N = 200元素，我将进行迭代的标准方法是：

rand = random.sample(data, N)

如果您尝试将数据进行“分组”的上述方法，则出于某种原因，结果列表的元素为元组。

我发现下面的示例用于随机选择单个键的元素groupby，但是不适用于多键groupby。从，如何按键访问熊猫分组数据

创建分组对象

grouped = df.groupby(''some_key'')

选择N个数据框并获取其索引

sampled_df_i = random.sample(grouped.indices, N)

使用groupby对象的“ get_group”方法获取组

df_list = map(lambda df_i: grouped.get_group(df_i),sampled_df_i)

可选-将其全部转换回单个数据框对象

sampled_df = pd.concat(df_list, axis=0, join=''outer'')

答案1

您可以对的唯一值进行随机抽样，将其df.some_key.unique()用于对进行切片df，最后groupby对结果进行切片：

In [337]:df = pd.DataFrame({''some_key'': [0,1,2,3,0,1,2,3,0,1,2,3],                   ''val'':      [1,2,3,4,1,5,1,5,1,6,7,8]})In [338]:print df[df.some_key.isin(random.sample(df.some_key.unique(),2))].groupby(''some_key'').mean()               valsome_key          0         1.0000002         3.666667

如果有多个groupby键：

In [358]:df = pd.DataFrame({''some_key1'':[0,1,2,3,0,1,2,3,0,1,2,3],                   ''some_key2'':[0,0,0,0,1,1,1,1,2,2,2,2],                   ''val'':      [1,2,3,4,1,5,1,5,1,6,7,8]})In [359]:gby = df.groupby([''some_key1'', ''some_key2''])In [360]:print gby.mean().ix[random.sample(gby.indices.keys(),2)]                     valsome_key1 some_key2     1         1            53         2            8

但是，如果您只是要获取每个组的值，则甚至不需要groubpy，它MultiIndex会做：

In [372]:idx = random.sample(set(pd.MultiIndex.from_product((df.some_key1, df.some_key2)).tolist()),                    2)print df.set_index([''some_key1'', ''some_key2'']).ix[idx]                     valsome_key1 some_key2     2         0            33         1            5

Python中异常的传递性和手动抛出异常的方法

异常的传递性

在 python 中，异常的传递性指的是，当一个异常没有被处理时，它会沿着调用栈向上抛出，直到被处理或者导致程序崩溃。

具体来说，当一个函数内部发生了异常但是没有进行处理时，该异常会向上抛出给调用该函数的代码块。如果这个代码块也没有处理该异常，那么异常会继续向上抛出，直到找到能够处理该异常的代码块或程序中止运行。

下面是一个简单的例子来演示异常的传递性：

def func1():
    print("func1 开始")
    func2()
    print("func1 结束")
def func2():
    print("func2 开始")
    func3()
    print("func2 结束")
def func3():
    print("func3 开始")
    a = 1 / 0   # 引发 ZeroDivisionError 异常
    print("func3 结束")
try:
    func1()
except Exception as e:
    print("错误信息：", e)

在上述代码中，函数 func3() 发生了除零错误（ ZeroDivisionError ），但是没有处理该异常。因此，该异常会向上抛出给调用 func3() 的代码块 func2() ，而 func2() 也没有处理该异常，所以异常会继续向上抛出给调用 func2() 的代码块 func1() 。最终，在 func1() 中的 try...except... 语句块捕获到了异常，并输出了错误信息。

总之，在编写完整的程序时，我们应该注意处理可能出现的异常，从而避免异常的传递和程序的崩溃。

立即学习“Python免费学习笔记（深入）”；

主动抛出异常

在 Python 中，我们可以使用内置的 Exception 类来抛出异常。Exception 是所有标准异常的基类，当我们自定义异常时也可以继承该类。通过继承 Exception 类，我们可以很方便地创建自己的异常类型，并定义相应的处理方式。

下面是一个使用 Exception 抛出自定义异常的代码示例：

def func(value):
    if value < 0:
        # 如果参数小于0，则抛出自定义异常
        raise Exception("参数不能小于0")
    else:
        print(f"参数值为：{value}")
try:
    # 调用带参数的函数
    func(-1)
except Exception as e:
    # 捕获自定义异常并输出错误信息
    print(e)

在上述代码中，当传入的参数小于 0 时，我们使用 raise 语句抛出 Exception 异常，并将错误信息一同抛出。最后，在主程序中，我们调用带参数的 func() 函数，并在捕获到自定义异常时输出错误信息。

需要注意的是，使用 Exception 抛出异常可能会导致代码结构不太清晰，因为它可以抛出任何种类的异常，包括系统内置的异常和自定义的异常。因此，如果想要更好地控制异常的类型和处理方式，建议还是使用专门的异常类或者自定义的异常类。

以上就是Python中异常的传递性和手动抛出异常的方法的详细内容，更多请关注php中文网其它相关文章！

python中的加权随机样本

def weighted_choice(weights,random=random):
    """ Given a list of weights [w_0,w_1,...,w_n-1],return an index i in range(n) with probability proportional to w_i. """
    rnd = random.random() * sum(weights)
    for i,w in enumerate(weights):
        if w<0:
            raise ValueError("Negative weight encountered.")
        rnd -= w
        if rnd < 0:
            return i
    raise ValueError("Sum of weights is not positive")

lambda weights: random.choice([val for val,cnt in enumerate(weights)
    for i in range(cnt)])

lambda weights,k: random.sample([val for val,cnt in enumerate(weights)
    for i in range(cnt)],k)

weight_sample_indexes = lambda weights,k: random.sample([val 
        for val,cnt in enumerate(weights) for i in range(cnt)],k)

import bisect
import random
from collections import Counter,Sequence

def weighted_sample(population,weights,k):
    return random.sample(WeightedPopulation(population,weights),k)

class WeightedPopulation(Sequence):
    def __init__(self,population,weights):
        assert len(population) == len(weights) > 0
        self.population = population
        self.cumweights = []
        cumsum = 0 # compute cumulative weight
        for w in weights:
            cumsum += w   
            self.cumweights.append(cumsum)  
    def __len__(self):
        return self.cumweights[-1]
    def __getitem__(self,i):
        if not 0 <= i < len(self):
            raise IndexError(i)
        return self.population[bisect.bisect(self.cumweights,i)]

total = Counter()
for _ in range(1000):
    sample = weighted_sample("abc",[1,10,2],5)
    total.update(sample)
print(sample)
print("Frequences %s" % (dict(Counter(sample)),))

# Check that values are sane
print("Total " + ','.join("%s: %.0f" % (val,count * 1.0 / min(total.values()))
                           for val,count in total.most_common()))

['b','b','c','c']
Frequences {'c': 2,'b': 3}
Total b: 10,c: 2,a: 1

python代码为给定参数的截断正态分布生成随机样本

# Creating Function to pass given mu,sigma,lower & upper bound values
def truncated_mean_std(mu,lower,upper):
    alpha = (lower - mu)/sigma
    beta = (upper - mu)/sigma
    d_pdf = (stats.norm.pdf(alpha) - stats.norm.pdf(beta))
    wd_pdf = (alpha * stats.norm.pdf(alpha) - beta * stats.norm.pdf(beta))
    d_cdf = stats.norm.cdf(beta) - stats.norm.cdf(alpha)
    mu_trunc = mu + sigma * (d_pdf / d_cdf)
    var_trunc = sigma**2 * (1 + wd_pdf / d_cdf - (d_pdf/d_cdf)**2)
    std_trunc = var_trunc**0.5
    return mu_trunc,std_trunc
# Creating function to return sample,mu,lower & upper bound values
def trunc_samples(mu,upper,num_samples=1000):
    random.seed(123)
    n = stats.truncnorm((lower - mu) / sigma,(upper - mu) / sigma,loc=mu,scale=sigma)
    samples = n.rvs(num_samples)
    return samples
# Creating function to correct the sample mu & sigma values to match the predefined values
def corrector(mu,upper):
    target = np.array([mu,sigma])
    result = scipy.optimize.minimize(
        lambda x: ((target - truncated_mean_std(x[0],x[1],upper))**2).sum(),x0=[mu,sigma])
    return result.x