精华内容
下载资源
问答
  • Panda总结

    2017-11-23 14:38:06
    Numpy 随机选择list元素 ACTIONS = ['left', 'right'] action_name = np.random.choice(ACTIONS) ...np.random.uniform()Panda panda初始化 table = pd.DataFrame( np.zeros((n_states, len(actions)))

    Numpy

    • 随机选择list元素
    ACTIONS = ['left', 'right'] 
    action_name = np.random.choice(ACTIONS)
    • 产生【0,1】均匀分布的随机数
    np.random.uniform()

    Panda

    • panda初始化
     table = pd.DataFrame(
            np.zeros((n_states, len(actions))),     # q_table initial values
            columns=actions,    # actions's name
        )
    
    pd.DataFrame(columns=self.actions, dtype=np.float64) # 建一个空的table
    
    • 元素值读取
    state_actions = q_table.loc[state, action] # 获取1个位置的元素值
    state_actions = q_table.loc[state, :] # 获取第i行元素
    q_table.loc[S_, :].max() # 获取第i行元素的最大值
    • 判断是否元素值全为0
    state_actions.all() == 0
    展开全文
  • Numpy&Panda

    2018-12-19 22:16:25
    4.产生一个3X4的矩阵,索引最小值得角标和最大值得角标 import numpy as np a = np.arange(2,14).reshape(3,4) print(a) print(np.argmax(a)) print(np.argmin(a)) 5.求矩阵中的所有元素的平均 import ...

    主要用作数据的处理和变化
    一、基础命令
    1.
    import numpy as np //引入numpy模块
    array=np.array([[1,2,3],[2,3,4]]) //将list转换为array
    print(array)
    print(‘shape:’,array.shape) //输出数组的形状
    print(‘size:’,array.size) //尺寸
    print(‘number of dim:’,array.ndim) //维度

    import numpy as np
    a = np.array([1,2,3,4],dtype=np.int64)
    print(a.dtype)

    import numpy as np
    a = np.array([[1,2,3],
    [2,3,4]])
    print(a)

    4.全部为0
    import numpy as np
    a = np.zeros((3,4))
    print(a)

    5.全部为1
    import numpy as np
    a=np.arange(10,20,2)
    print(a)

    6.输出3-4的矩阵
    import numpy as np
    a = np.arange(12).reshape((3,4))
    print(a)

    7.线段数字的生成
    import numpy as np
    a = np.linspace(1,10,20)
    print(a)

    二、运算
    1.矩阵的减法
    import numpy as np
    a = np.array([10,20,30,40])
    b=np.arange(4)
    c = a -b
    print©

    2.numpy三角函数的使用
    np.sin()
    e=10*np.sin(a)
    print(e)
    print(c>b) //bool的使用

    1. 生成两行四列的随机值
      import numpy as np
      a = np.random.random((2,4))
      print(a)

    np.max //np.min //np.sum

    4.产生一个3X4的矩阵,索引最小值得角标和最大值得角标
    import numpy as np
    a = np.arange(2,14).reshape(3,4)
    print(a)
    print(np.argmax(a))
    print(np.argmin(a))

    5.求矩阵中的所有元素的平均值
    import numpy as np
    a = np.arange(2,14).reshape(3,4)
    print(a)
    print(np.argmax(a))
    print(np.argmin(a))
    print(a.mean())#求平均值
    print(np.mean(a))#求平均值

    6.数学中的一些常用的计算
    print(a.mean())#求平均值
    print(np.mean(a))#求平均值
    print(np.median(a))#中位数
    print(np.cumsum(a))#累加
    print(np.diff(a))#累差
    print(np.nonzero(a))
    print(np.sort(a))

    7.矩阵的转置的输出
    import numpy as np
    A=np.arange(12).reshape(3,4)
    print(A)
    print(np.transpose(A))
    print(A.T) #A的转置的两种形式

    8.矩阵的索引
    import numpy as np
    A = np.arange(3,15).reshape(3,4)
    print(A)

    print(A[3][2])

    print(A[1][1])

    9.矩阵的行列迭代
    import numpy as np
    A = np.arange(3,15).reshape(3,4)
    print(A)
    for row in A:
    print(row) #迭代行

    for column in A.T:
    print(column) #通过转置进行列迭代

    10.利用for item in A.flat进行展开输出
    import numpy as np
    A = np.arange(3,15).reshape(3,4)
    print(A)
    for item in A.flat:#展开输出
    print(item)
    11.合并两个矩阵(分左右、上下)
    import numpy as np

    A = np.array([1,1,1])
    B = np.array([2,2,2])

    print(np.vstack((A,B))) #vertical合并
    print(np.hstack((A,B)))#herizon合并

    12.矩阵的分割用split进行分割
    import numpy as np
    A=np.arange(12).reshape(3,4)
    print(A)
    print(np.split(A,2,axis=1))
    print(np.array_split(A,12,axis=1))#k可以实现不等分割

    展开全文
  • panda数据处理

    千次阅读 2019-05-07 23:50:03
    argmin , argmax 最小值和最大值的索引位置(整数) idxmin , idxmax 最小值和最大值的索引值 quantile 样本分位数(0 到 1) sum 求和 mean 均值 median 中位数 mad 根据均值计算...

    转自:https://blog.csdn.net/Dorisi_H_n_q/article/details/82313244,进行了整理结合
    其他常用的统计方法有:

    常用统计方法

    count 非 NA 值的数量
    describe 针对 Series 或 DF 的列计算汇总统计
    min , max 最小值和最大值
    argmin , argmax 最小值和最大值的索引位置(整数)
    idxmin , idxmax 最小值和最大值的索引值
    quantile 样本分位数(0 到 1)
    sum 求和
    mean 均值
    median 中位数
    mad 根据均值计算平均绝对离差
    var 方差
    std 标准差
    skew 样本值的偏度(三阶矩)
    kurt 样本值的峰度(四阶矩)
    cumsum 样本值的累计和
    cummin , cummax 样本值的累计最大值和累计最小值
    cumprod 样本值的累计积
    diff 计算一阶差分(对时间序列很有用)
    pct_change 计算百分数变化

    1、删除重复元素

    使用duplicated()函数检测重复的行,返回元素为布尔类型的Series对象,每个元素对应一行,如果该行不是第一次出现,则元素为True

    
     
    1. import numpy as np
    2. import pandas as pd
    3. from pandas import Series,DataFrame
    4. import matplotlib.pyplot as plt
    5. %matplotlib inline
    • 创建数据集:

    
     
    1. # color 0 :red;1:green;2:blue
    2. df = DataFrame({ 'color':np.random.randint( 0, 3,size = 300), 'num':np.random.randint( 0, 5,size = 300)})
    3. df
    4. #或者:
    5. b=np.random.choice([ 'B', 'M'],size=( 100, 2))
    6. b1=DataFrame(b,columns=[ 'True', 'Predict'])
    7. b1

    
     
    1. # 计算True的总个数,即计算重复的总行数
    2. df.duplicated().sum()
    3. Out: 285
    • 使用drop_duplicates()函数删除重复的行【inplace=True则会修改原数组】

    df.drop_duplicates()
     

    • 查看图片中的重复元素
    
     
    1. img = plt.imread( './芝麻.jpg')
    2. img.shape
    3. Out: ( 662, 1000, 3)
    4. # 这张图片总共有多少个像素呢?
    5. # (红,绿,蓝)
    6. 662* 1000
    7. Out: 662000
    8. # numpy没有去重的方法
    9. img2 = img.reshape( -1, 3)
    10. img2
    11. # img2 必须是转化成n行n列,比如reshape(-1,3)
    12. df = DataFrame(img2,columns=[ 'red', 'green', 'blue'])
    13. df
    14. # 总数据662000
    15. # 非重复的像素,71526个 ,inplace=True则能修改原数组
    16. df.drop_duplicates().shape
    17. Out: ( 71526, 3)

    【注意】如果使用pd.concat([df1,df2],axis = 1)生成新的DataFrame,新的df中columns相同,使用duplicate()和drop_duplicates()都会出问题

     

    2. 映射

    映射的含义:创建一个映射关系列表,把values元素和一个特定的标签或者字符串绑定

    需要使用字典:

    map = { 'label1':'value1', 'label2':'value2', ... }

    包含三种操作:

    • replace()函数:替换元素
    • 最重要:map()函数:新建一列
    • rename()函数:替换索引

     

    1) replace()函数:替换元素

    使用replace()函数,对values进行替换操作

    • 定义数据集
    
     
    1. df = DataFrame({ 'color':np.random.randint( 0, 3,size = 300), 'num':np.random.randint( 10, 30,size = 300)})
    2. df

    • 首先定义一个字典
    m = {0:'red',1:'green',2:'blue'}
     
    • 调用.replace()
    
     
    1. # replace方法,可将DataFrame中所有满足条件的数据,进行替换
    2. df.replace(m)

    • replace还经常用来替换NaN元素
    
     
    1. # 字典的key类型要一致
    2. m = { 0: 'red', 1: 'green', 2: 'blue', 1024: 'purple', 2048: 'cyan'}
    3. # 字典中映射关系,键值对,去DataFrame找数据,找到了就替换,没有找到,也不会报错
    4. df.replace(m)
    • 使用正则匹配替换:

    数据集 data1 ——> 杂质:-数字\t

    法①:遍历—> re.sub

    
     
    1. import re
    2. data1[ 0].map( lambda x: re.sub( '.*\d+\\t', '',x))

    法②【一定要加上.str才能替换】:data1[0].str.replace

    pd.DataFrame(data1[0].str.replace('.*?\d+?\\t ', '')) #用正则表达式修改数据
     

     

    2) map()函数:新建一列

    使用map()函数,由已有的列生成一个新列

    适合处理某一单独的列。

    仍然是新建一个字典

    map()函数中可以使用lambda函数

    transform()和map()类似

    使用map()函数新建一个新列

     

    • 新建数据集
    
     
    1. df = DataFrame(np.random.randint( 0, 150,size = ( 10, 3)),
    2. columns=[ 'Python', 'Math', 'En'],index=list( 'ABCDEFGHJK'))
    3. df

    • map映射简单lambda函数
    
     
    1. # df['Python'] 10 个数据 迭代器
    2. df[ 'Java'] = df[ 'Python'].map( lambda x : 2*x - 100)
    3. df

    
     
    1. f = lambda x : x* 2 - 100
    2. type(f)
    3. Out: function
    4. def fun(x):
    5. x* 2 - 100
    6. type(fun)
    7. Out: function
    • 定义一个函数level,带入map函数:
    
     
    1. def convert(x):
    2. if x >= 130:
    3. return '优秀'
    4. elif x < 130 and x >= 100:
    5. return '良好'
    6. elif x < 100 and x >= 80:
    7. return '中等'
    8. elif x < 80 and x >= 60:
    9. return '及格'
    10. else:
    11. return '不及格'
    12. df[ 'Level'] = df[ 'Python'].map(convert)
    13. df

     

    • 给某一列都加上某个数:法① df['Python'] += 10
    
     
    1. # Python 这一列,老师出考题的时候,有一道题出错了,每个人Python加10分
    2. df[ 'Python'] += 10
    3. df

     

    • 给某一列都加上某个数:法② map(lambda x : x+10)
    
     
    1. # map 这个方法,可以修改当前的列
    2. df[ 'Python'] = df[ 'Python'].map( lambda x :x + 10)
    3. df
    • 分箱操作:

    分箱、分块、分类——》

    # 分箱,分类
    # 葡萄品质0~10 
    # 0~4 low
    # 5~7 median
    # 8~10 high

    
     
    1. # 分箱,分类
    2. # 葡萄品质0~10
    3. # 0~4 low
    4. # 5~7 median
    5. # 8~10 high
    6. # 0 ~ 10 信用
    7. # 0~3 low
    8. # 4~ 6 median
    9. # 7~10 high
    10. # 根据这个人手机产生数据
    11. def convert(x):
    12. if x >= 140:
    13. return 150
    14. elif x < 140 and x >= 100:
    15. return 125
    16. elif x < 100 and x>= 60:
    17. return 80
    18. else:
    19. return 0
    20. df[ 'Python'] = df[ 'Python'].map(convert)
    21. df

     

    3) rename()函数:替换索引

    • 新建数据集:
    
     
    1. df = DataFrame(np.random.randint( 0, 150,size = ( 4, 3)))
    2. df

    • 仍然是新建一个字典,使用rename()函数替换行索引
    
     
    1. # 更改列标题 【axis = 0 行】
    2. m = { 0: '张三', 1: '李四', 2: '王五', 3: '小刘'}
    3. df.rename(m,axis = 0,inplace= True)
    4. # 更改行标题
    5. m = { 0: 'Python', 1: 'Math', 2: 'En'}
    6. df.rename(m,axis = 1,inplace= True)
    7. df

     

    3. 异常值检测和过滤

    使用describe()函数查看每一列的描述性统计量

    • 新建数据集
    
     
    1. df = DataFrame(np.random.randn( 10000, 3),columns=list( 'ABC'))
    2. df

    • 检测异常值:① 求出每一列均值;② 异常值判断条件:大于5倍均值
    
     
    1. # 过滤条件,大于5倍平均,异常
    2. # 均值0.79,则大于3.95为异常值
    3. df.abs().mean()
    4. Out:
    5. A 0.798357
    6. B 0.793909
    7. C 0.789348
    8. dtype: float64
    9. # 找出各个属性的异常值
    10. cond = df.abs() > 3.95
    11. cond.sum()
    12. Out:
    13. A 2
    14. B 2
    15. C 0
    16. dtype: int64
    17. # 异常值总和
    18. (cond.sum()).sum()
    19. # 异常值总行数
    20. cond.any(axis = 1).sum()
    21. Out: 4
    22. # 以DataFrame形式展示存在异常值的行数
    23. df[cond.any(axis = 1)]

    展示满足要求的数据:

    
     
    1. # 满足要求的数据
    2. cond = df.abs() <= 3.95
    3. cond = cond.all(axis = 1)
    4. df[cond]

     

    • 使用std()函数可以求得DataFrame对象每一列的标准差;
    • 根据每一列的标准差,对DataFrame元素进行过滤;
    • 借助any()函数, 测试是否有True,有一个或以上返回True,反之返回False;
    • 对每一列应用筛选条件,去除标准差太大的数据

     

    3原则:如果数据服从正态分布,在3原则下,异常值被定义为一组测定值中与平均值的偏差超过3倍标准差的值。在正态分布的假设下,距离平均值3之外的值出现的概率为P(|x-|>3)≤0.003,属于极个别的小概率事件。

    
     
    1. #平均值上下三倍标准差之间属于正常点
    2. std=df.abs().std()
    3. std
    4. Out:
    5. A 0.607076
    6. B 0.598781
    7. C 0.594652
    8. dtype: float64
    9. mean=df.abs().mean()
    10. mean
    11. Out:
    12. A 0.798357
    13. B 0.793909
    14. C 0.789348
    15. dtype: float64
    16. low=mean -3*std
    17. high=mean+ 3*std
    18. display(low.mean(),high.mean())
    19. Out:
    20. -1.0066372280404017
    21. 2.5943795581659246
    22. # 异常值 位于小于mean-3*std or 大于mean+3*std
    23. low1=df.abs()<low.mean()
    24. high1=df.abs() > high.mean()
    25. low_high1=np.logical_or(low1,high1)
    26. low_high1
    27. # 显示异常值个数
    28. df[low_high1.any(axis= 1)].shape
    29. Out: ( 259, 3)
    30. # 过滤掉正常值,显示异常值
    31. df[low_high1.any(axis= 1)]
    32. #平均值上下三倍标准差之间属于正常点
    33. lowcond=df.abs()>low.mean()
    34. highcond=df.abs() < high.mean()
    35. low_high=np.logical_and(lowcond,highcond)
    36. low_high
    37. # 过滤异常值,满足条件 df.mean()-3*df.std() ~ df.mean()+3*df.std()
    38. df[low_high.all(axis= 1)].shape
    39. Out: ( 9741, 3)
    40. df.shape
    41. Out:( 10000, 3)
    42. 259+ 9741= 10000
    • 新建数据集:身高、体重
    • 手动创建异常值
    • 判定异常值范围
    • 过滤异常值
    
     
    1. df =DataFrame(
    2. { 'height':np.random.randint( 150, 200, 1000),
    3. 'weight':np.random.randint( 50, 90,size = 1000)})
    4. df
    5. # 创造异常值
    6. # 每隔10个数据加一个300,比如第10个原本63,处理后变363,第20,30..一样
    7. df[ 'weight'][:: 10] + 300
    8. df
    9. # 判定异常值范围:
    10. # 体重的异常值:>300公斤
    11. cond = df[ 'weight'] < 300
    12. # 异常值筛选:给定条件(数据不同,条件不一样,根据数据属性来做选择)
    13. df[cond]

     

    4. 排序及打乱下标随机排序

    使用.take()函数排序,可以借助np.random.permutation()函数随机排序

    df.take([100,300,210])
     

    
     
    1. # 产生5个0-4的随机数
    2. np.random.permutation( 5)
    3. Out: array([ 2, 0, 4, 3, 1])
    4. # 产生1000个0-999的随机数
    5. index = np.random.permutation( 1000)
    6. index
    7. type(index)
    8. Out: numpy.ndarray
    9. # 使用产生的随机数作为下标排序显示数据
    10. df.take(index)
    • 另一种产生n个 0 ~ n-1 的随机数
    
     
    1. # 产生1000个从0~999的升序数列
    2. index = np.arange( 1000)
    3. index
    4. # 打乱0~999的顺序数列
    5. np.random.shuffle(index)
    6. index
    7. display(type(index),index)
    8. Out: numpy.ndarray
    9. # 使用随机打乱的数列作为下标显示数据
    10. df.take(index)

    随机抽样

    当DataFrame规模足够大时,直接使用np.random.randint()函数,就配合take()函数实现随机抽样

    
     
    1. df = DataFrame(np.random.randn( 10000, 3),columns=list( 'ABC'))
    2. df
    3. df.size
    4. Out: 30000

    
     
    1. ss=np.random.randint( 0, 10000,size = 100)
    2. ss
    3. Out:
    4. array([ 4065, 9998, 4088, 2039, 4184, 1807, 1325, 1569, 6657, 2974, 3211,
    5. 2982, 8154, 7668, 6738, 7486, 4362, 105, 6373, 3119, 1261, 1648,
    6. 2962, 7112, 2243, 6014, 2211, 6357, 2032, 1761, 7664, 6734, 1882,
    7. 6126, 8942, 4872, 8935, 9207, 4533, 4558, 9922, 5127, 9340, 5148,
    8. 640, 8374, 5681, 1160, 325, 2469, 9823, 7114, 8228, 5019, 4217,
    9. 2901, 8420, 4888, 4274, 6595, 2289, 1446, 8035, 958, 736, 7005,
    10. 5490, 2752, 3260, 9686, 5241, 3165, 8381, 7885, 4582, 8015, 7215,
    11. 8430, 8921, 4957, 2419, 7912, 9510, 1614, 1102, 3070, 2390, 228,
    12. 3588, 829, 6808, 4883, 349, 1869, 2073, 1992, 9280, 1085, 5495,
    13. 5396])
    14. DataFrame(ss)[ 0].unique().size
    15. Out: 100
    16. # 可以直接使用random.randint 产生的数据来做下标随机抽取数据
    17. df.take(np.random.randint( 0, 10000,size = 100))

    5. 数据聚合【重点】

    数据聚合是数据处理的最后一步,通常是要使每一个数组生成一个单一的数值。

    数据分类处理:

    • 分组:先把数据分为几组
    • 用函数处理:为不同组的数据应用不同的函数以转换数据
    • 合并:把不同组得到的结果合并起来

    数据分类处理的核心: groupby()函数

    • 创建数据集
    
     
    1. df = DataFrame({ 'item':np.random.randint( 0, 4, 50),
    2. 'level':np.random.randint( 0, 3,size = 50),
    3. 'price':np.random.randint( 1, 10,size = 50),
    4. 'sailer':np.random.randint( 0, 3,size = 50),
    5. 'weight':np.random.randint( 50, 100,size = 50)})
    6. df

     

    • 赋值转换
    
     
    1. # = 赋值 :使用map({字典集})
    2. df[ 'item'] = df[ 'item'].map({ 0: '萝卜', 1: '白菜', 2: '西红柿', 3: '黄瓜'})
    3. df[ 'level'] = df[ 'level'].map({ 0: '差', 1: '中', 2: '优'})
    4. df[ 'sailer'] = df[ 'sailer'].map({ 0: '张大妈', 1: '李大妈', 2: '赵大叔'})
    5. df

     

    • 聚合操作
    
     
    1. # 按 sailer,item分组,显示价格的最大值
    2. aa=df.groupby([ 'sailer', 'item'])[ 'price'].max()
    3. aa
    4. Out:[Series]
    5. sailer item
    6. 张大妈 白菜 8
    7. 萝卜 8
    8. 西红柿 9
    9. 黄瓜 2
    10. 李大妈 白菜 4
    11. 萝卜 6
    12. 西红柿 7
    13. 黄瓜 9
    14. 赵大叔 白菜 8
    15. 萝卜 9
    16. 西红柿 8
    17. 黄瓜 8
    18. Name: price, dtype: int32
    19. # 按等级,类别分组,显示价格和体重的最小值
    20. df.groupby([ 'level', 'item'])[ 'price', 'weight'].min()

    • 求总和
    
     
    1. weight_sum = df.groupby([ 'level'])[ 'weight'].sum()
    2. weight_sum
    3. Out:
    4. level
    5. 1570
    6. 790
    7. 1250
    8. Name: weight, dtype: int64
    
     
    1. weight_sum = DataFrame(weight_sum)
    2. weight_sum

    
     
    1. # 给表头修改名字
    2. weight_sum = weight_sum.rename({ 'weight': 'weight_sum'},axis = 1)
    3. weight_sum

     

    • 合并聚合表格【左连接:left_on='level',right_index=True】注意:没有right_index=True会报错
    
     
    1. df2 = df.merge(weight_sum,left_on= 'level',right_index= True)
    2. df2

    • 求平均价格
    
     
    1. price_mean = df.groupby([ 'item'])[ 'price'].mean()
    2. price_mean = DataFrame(price_mean)
    3. price_mean
    4. # 修改标题名称
    5. price_mean.columns = [ 'price_mean']
    6. price_mean

    • 合并聚合数据表格
    df2.merge(price_mean,left_on='item',right_index=True)
     

    ============================================

    练习23:

    • 假设菜市场张大妈在卖菜,有以下属性:
    • 菜品(item):萝卜,白菜,辣椒,冬瓜
    • 颜色(color):白,青,红
    • 重量(weight)
    • 价格(price)
    1. 要求以属性作为列索引,新建一个ddd
    2. 对ddd进行聚合操作,求出颜色为白色的价格总和
    3. 对ddd进行聚合操作,求出萝卜的所有重量(包括白萝卜,胡萝卜,青萝卜)以及平均价格
    4. 使用merge合并总重量及平均价格

    ============================================

    
     
    1. # 测试choice
    2. np.random.choice([ 0, 1, 2],size= 10)
    3. Out:
    4. array([ 1, 0, 1, 1, 0, 2, 2, 1, 2, 2])
    • 创建数据集
    
     
    1. ddd=DataFrame({ 'item':np.random.choice([ '萝卜', '白菜', '辣椒', '冬瓜'],size= 50),
    2. 'color':np.random.choice([ '白', '青', '红'],size= 50),
    3. 'weight':np.random.randint( 10, 100, 50),
    4. 'price':np.random.randint( 1, 10, 50)
    5. })
    6. ddd

    • 求出颜色为白色的价格总和
    
     
    1. ddd.color.map( lambda x:x== '白').sum()
    2. Out: 19
    • 对ddd进行聚合操作,求出萝卜的所有重量(包括白萝卜,胡萝卜,青萝卜)以及平均价格
    
     
    1. p=ddd.groupby( 'item')[ 'price'].mean()
    2. p=DataFrame(p)
    3. p
    4. p.index
    5. Out: Index([ '冬瓜', '白菜', '萝卜', '辣椒'], dtype= 'object', name= 'item')
    6. p.columns
    7. Out: Index([ 'price'], dtype= 'object')
    8. w=ddd.groupby( 'item')[ 'weight'].sum()
    9. w=DataFrame(w)
    10. w

    • 使用merge合并总重量及平均价格
    p.merge(w,left_index=True,right_index=True)
     

    p.join(w)
     

    ============================================

    6.0 高级数据聚合

    可以使用pd.merge()函数将聚合操作的计算结果添加到df的每一行
    使用groupby分组后调用加和等函数进行运算,让后最后可以调用add_prefix(),来修改列名

    可以使用transform和apply实现相同功能

    在transform或者apply中传入函数即可

    • 采用上面的数据集

    • 使用apply
    df.groupby(['sailer','item'])['price'].apply(np.mean)
     

    • 使用transform
    
     
    1. # apply和transform都可以进行分组计算,计算结果一样
    2. # 表现形式不同,apply多层索引,图形直观,简洁
    3. # transform 一层索引,所有的数据,级联方便
    4. mean_price = df.groupby([ 'sailer', 'item'])[[ 'price']].transform(np.mean).add_prefix( 'mean_')
    5. mean_price

    • 使用pd.concat()拼接mean_price
    pd.concat([df,mean_price],axis = 1)
     

     

    transform()与apply()函数还能传入一个函数或者lambda

    
     
    1. df = DataFrame({ 'color':[ 'white', 'black', 'white', 'white', 'black', 'black'],
    2. 'status':[ 'up', 'up', 'down', 'down', 'down', 'up'],
    3. 'value1':[ 12.33, 14.55, 22.34, 27.84, 23.40, 18.33],
    4. 'value2':[ 11.23, 31.80, 29.99, 31.18, 18.25, 22.44]})

     

    举栗子

    
     
    1. dic = {
    2. 'item':[ '萝卜', '白菜', '萝卜', '辣椒', '冬瓜', '冬瓜', '萝卜', '白菜'],
    3. 'color':[ 'red', 'white', 'green', 'red', 'green', 'white', 'white', 'green'],
    4. 'weight':[ 12, 30, 16, 5, 10, 5, 25, 18],
    5. 'price':[ 2.5, 0.8, 3.5, 4, 1.2, 1.5, 0.9, 3]
    6. }
    7. df = DataFrame(data=dic)
    8. df

    定义函数

    
     
    1. # 定义求和
    2. def m_sum(items):
    3. sum= 0
    4. for item in items:
    5. sum+=item
    6. return sum
    7. # 定义求平均
    8. def my_mean(items): #参数为复数(List形式)
    9. sum= 0
    10. for item in items:
    11. sum+=item
    12. return sum/items.size
    
     
    1. df.groupby(by= 'item')[ 'weight'].apply(m_sum)[ '萝卜']
    2. Out:
    3. 53
    4. df.groupby(by= 'item')[ 'price'].apply(my_mean)
    5. Out:
    6. item
    7. Apple 3.00
    8. Banana 2.75
    9. Orange 3.50
    10. Name: price, dtype: float64

     

    展开全文
  • Panda渲染过程Panda的渲染过程由4个类相互作用构成,它们分别是:GraphicsPipe、GraphicsEngine、GraphicsStateGaurdian和GraphicsOutput。本章将详细讲解这些类的作用。注意,这些接口只针对高级用户。如果只是一个...
    Panda 渲染过程
    Panda的渲染过程由4个类相互作用构成,它们分别是:GraphicsPipe、GraphicsEngine、GraphicsStateGaurdian和GraphicsOutput。本章将详细讲解这些类的作用。
    注意,这些接口只针对高级用户。如果只是一个打开窗口进行基本的3D渲染的简单程序,就用不着这些接口,因为当你在程序开头import direct.directbase.DirectStart时,系统将自动调用正确的函数来打开一个默认窗口。
     
    图形管线(The Graphics Pipe
    GraphicsPipe类是诸如OpenGL、DirectX等3D API的Panda3D接口。为了使用某种API来渲染一个窗口,你必须提供一个针对该API的GraphicsPipe。
    一般来讲,当你import DirectStart时系统自动为你创建了一个默认的图形管线,可以由base.pipe访问。对于大多数应用,你没必要再创建新的图形管线。
    Config.prc文件中用2个变量决定程序可使用哪个或哪些图形管线:
    load-display:该变量指定图形管线的第一选择,给出最先尝试使用的GraphicsPipe类型名,如pandagl或pandadx8。如果因为某些原因不能创建该类型的GraphicsPipe,比如由于缺乏驱动,Panda3D将转到下一个变量:
    aux-display:该变量可以多次出现,列出所有可能的GraphicsPipe实现。如果Panda3D不能打开由load-display指定的管线类型,它将转入aux-display提供的管线列表,按顺序一个一个地尝试直到成功打开某个图形管线为止。
    注 意,以上2个变量指定的名字,如pandagl,实际上是指定了一个Windows DLL或Unix Shared-library文件。Panda3D将先在这个名字的前面加上“lib”,并在其后面加上“.dll”或“.so”(取决于操作系统),然 后导入(import)这个库。即“load-display pandagl”真正的含义是导入“libpandagl.dll”文件。panda提供了各种不同的用于显示的DLL,当成功导入时,它们将在 panda里注册,对运行它们的GraphicsPipe进行支持。
    你可以增加图形管线,例如提供在OpenGL和DirectX之间转换的游戏内部接口。最简单的办法是调用base.makeAllPipes(),然后让base.pipeList列出某环境下所有有效的GraphicsPipe。
    对base.pipeList列出的每一种GraphicsPipes都可以调用以下的接口:
    pipe.isValid()
    如果该管线可以用来渲染,返回True,否则返回False。
    pipe.getDisplayWidth()
    返回桌面的宽度,或者一个offscreen-only GraphicsPipe最大的缓冲(buffer)宽度。
    pipe.getDisplayHeight()
    返回桌面的高度,或者一个offscreen-only GraphicsPipe最大的缓冲(buffer)高度。
    pipe.getInterfaceName()
    返回该GraphicsPipe运行的API,如“OpenGL”或“DirectX8 ”。
    pipe.getType()
    为每一种管线返回一个不同的TypeHandle对象。
     
    图形引擎(The Graphics Engine
    图形引擎是渲染过程的心脏。最终负责每一帧图像绘制(drawing)和剔除(culling)的就是GraphicsEngine类。
    一般来讲,我们不需要创建GraphicsEngine,Panda3D在程序一启动就为我们创建好了。这个默认的GraphicsEngine存储在base.graphicsEngine里。
    注意,下面的接口只能由高级用户来使用。如果你想创建一个新窗口或一个offscreen的渲染缓冲(buffer),只需使用base.openWindow()或window.makeTextureBuffer()接口就行,它们将自动为你处理所有的细节问题。
    但是,如果你想详细了解Panda怎样管理窗口和缓冲,或者上面的方法不能满足你的某些特殊需求,那么就请继续阅读吧。
    渲染一帧(Rendering a frame
    每一帧图像的渲染都少不了一个关键的接口:
    base.graphicsEngine.renderFrame()
    这个方法使全体打开的GraphicsWindows和GraphicsBuffers渲染当前帧的内容。
    为了让Panda3D渲染任何场景,该方法必须每一帧调用一次。一般来讲,这个由“igloop”task自动完成,该task在启动Panda时创建。
    使用GraphicsEngine 创建窗口和缓冲
    为了在Panda3D里渲染,你需要一个 GraphicsStateGuardian,以及一个 GraphicsWindow (渲染到窗口)或者一个 GraphicsBuffer(渲染offscreen)。我们不能直接创建或销毁这些对象,必须使用GraphicsEngine的接口来创建它们。
    在创建它们之前,还必须提供一个GraphicsPipe,指出你要使用的图形API(OpenGL或DirectX)。你的Config.prc文件里默认的GraphicsPipe已经在启动时被创建好了,可以通过base.pipe来访问。
    有 了GraphicsPipe和GraphicsEngine,你就可以创建一个GraphicsStateGuardian对象。在图形API上,该对象 相当于一个单一的图形context,例如一个单一的OpenGL context。(context拥有全部OpenGL对象或全部DirectX对象,如显示列表、顶点缓冲和纹理对象)在创建 GraphicsWindow之前至少需要有一个GraphicsStateGuardian:
    myGsg=base.graphicsEngine.makeGsg(base.pipe)
    一旦有了GraphicsStateGuardian,你就可以用它来创建onscreen的GraphicsWindow或offscreen的GraphicsBuffer。
    base.graphicsEngine.makeWindow(gsg, name, sort)
    base.graphicsEngine.makeBuffer(gsg, name, sort, xSize, ySize, wantTexture)
    gsg指的就是那个GraphicsStateGuardian,name是你分配给窗口/缓冲的名字,sort是一个整数,决定窗口/缓冲的渲染顺序。
    缓冲参数xSize和ySize确定缓冲的宽高尺寸,如果以后想从这个缓冲取回一个纹理,wantTexture参数应该设为True。
    你 也可以使用graphicsEngine.makeParasite(host,name,sort,xSize,ySize), host是一个GraphicsOutput对象。它创建一个缓冲但并不为其分配空间,而是渲染到host的帧缓冲上(framebuffer)。实际上 它把wantTexture设为True,因此你以后可以从它那取回一个纹理。
    更多详情请参考“GraphicsOutput类”和“ 图形缓冲与窗口”部分。
    myWindow=base.graphicsEngine.makeWindow(myGsg, "Hello World", 0)
    myBuffer=base.graphicsEngine.makeBuffer(myGsg, "Hi World", 0, 800,600, True)
    myParasite=base.graphicsEngine.makeBuffer(myBuffer,"Im a leech", 0, 800, 600)
    注意,如果你想让缓冲可见,在你的 配置文件里加上“ show-buffers true ”,使缓冲像窗口一样显示,在 debug 时特别有用。
    共享图形上下文(Sharing graphics contexts
    可 以在多个不同的GraphicsWindow和/或 GraphicsBuffer之间共享同一个GraphicsStateGuardian。这样一来,图形context将被渲染到每个窗口,一次一个窗 口。当不同窗口渲染很多相同的物体时特别有用,因为各窗口可以共享相同的纹理对象和顶点缓冲。
    两个窗口也可以各自使用不同的 GraphicsStateGuardian。如果在各窗口都渲染某个纹理,该纹理将被载入显存2次,一个context一次,势必造成了浪费。但在某些 情况下必须这么做,例如你有2块显卡,想让它们同时渲染。(注意,Panda对双显卡并行渲染的支持目前还未完成,只是设计了API预备日后实现)
    关闭窗口(Closing windows
    removeWindow(window)关闭某个窗口或缓冲,removeAllWindows()关闭所有窗口:
    base.graphicsEngine.removeWindow(myWindow)
    base.graphicsEngine.removeAllWindows()
    补充内容(More about GraphicsEngine
    下面列出 GraphicsEngine 类其他一些有用的功能:
    getNumWindows()
    返回该GraphicsEngine对象管理的窗口和缓冲数。
    isEmpty()
    如果该GraphicsEngine不管理任何窗口或缓冲,返回True。
    更多功能请查阅GraphicsEngine和GraphicsStateGuardian类的API文档。
     
    GraphicsOutput
    封 装在GraphicsBuffer和GraphicsWindow类中的缓冲和窗口在Panda中几乎是等价的。事实上,GraphicsEngine类 的大部分操作都是针对GraphicsOutput对象,并且返回GraphicsOutput对象,而GraphicsBuffer和 GraphicsWindow都是从GraphicsOutput类继承得来。因此,我们将首先讨论GraphicsOutput对象的属性。
    首先要注意的重要一点是这些对象都不能直接构造,如:
    myOutput=GraphicsOutput()
    myWindow=GraphicsWindow()
    myBuffer=GraphicsBuffer()
    都是无效的。如何创建请参考GraphicsEngine部分。此外,由于GraphicsOutput是一个抽象类,我们将在示例代码里使用GraphicsWindow对象。
    全 部GraphicsOutput对象都有getGsg()、getPipe()和getName()方法,分别返回它们的 GraphicsStateGuardian、GraphicsPipe和name,你也可以由getXSize()和getYSize()得到窗口或缓 冲的宽、高:
    from pandac.PandaModules import GraphicsWindow

    #假设我们已经创建了一个 myWindow窗口
    myWindowGsg=myWindow.getGsg()
    myWindowPipe=myWindow.getPipe()
    myWindowName=myWindow.getName()

    myWindowWidth=myWindow.getXSize()
    myWindowLength=myWindow.getYSize()
    使 用saveScreenShot(fileName) 可以从任何GraphicsOutput那里保存一个截屏,fileName为图片的名字(图片格式由fileName的扩展名指定)。截屏成功返回 True,失败返回False。图片保存在当前运行的脚本同一路径下:
    from pandac.PandaModules import Filename
    myWindow.saveScreenShot(Filename('hello.bmp'))
    该 功能自然而然将用于渲染到纹理。我们将从场景拷贝开始介绍。如果你想把GraphicsOutput对象的内容拷贝成一个纹理,必须首先调用 setupCopyTexture(),接着用getTexture()得到纹理。然后你就可以将这个从内存载入的纹理应用到一个NodePath。由于 指针的贡献,当GraphicsOutput的内容改变时纹理将自动更新。如果不想让纹理自动更新你应该使用detachTexture()。但因为渲染 的第一帧通常为空白,最佳方式是在一个do-later task或event里使用detachTexture():
    myWindow.setupCopyTexture()
    myTexture=myWindow.getTexture()

    #假设已经设置了一个myModel模型
    myModel.setTexture(myTexture)

    #如果不想让纹理自动更新
    def stopUpdating():
       global myWindow
       myWindow.detachTexture()
    taskMgr.doMethodLater(1,stopUpdating,'stops updating')
    虽 然这样挺有用,但你可能要渲染一个全新的场景到GraphicsOutput然后在屏幕上显示(例如,你的场景里有个电视机要现场直播)。首先要创建一个 GraphicsOutput保留场景。通过调用makeTextureBuffer实现,我们专门为渲染场景准备了一个GraphicsOutput, 然后通过getTexture()取回:
    makeTextureBuffer(name, xSize, ySize)
    参数name、xSize和ySize与 makeWindow makeBuffer 方法中的意义一样。
    接下来为新场景创建一个新的摄影机,使用:
    base.makeCamera(win, sort=0, scene=None, displayRegion=(0,1,0,1), aspectRatio=None, camName='cam')
    下面列出各个参数的含义:
    win
    建立摄影机的那个GraphicsOutput对象
    sort
    摄影机的类别值,决定了在同一窗口里DisplayRegion的绘制顺序。详情请参考API。
    scene
    由于其他函数的反对,这个参数不起作用。
    displayRegion
    新的GraphicsOutput 覆盖的区域,格式为(左边起点,右终点,下起点,上终点)。(0,0) 代表屏幕的左下角,(1,1)代表屏幕右上角。因此, (0,1,0,1) 代表整个屏幕区域。参数值必须在0到1之间。
    aspectRatio
    GraphicsOutput的纵横比。如果留空,makeCamera将使用默认窗口纵横比。
    camName
    在scene graph中该摄影机的节点的名字。
    摄 影机渲染scene graph里任何连接到它的祖先上的对象。因此如果你想得到一个真正独立的场景,必须重新建立一个新的scene graph。创建一个空(dummy)Nodepath,把新摄影机作为它的子节点,然后可以把你的场景渲染到GraphicsOuptut上。
    但 是,你对原摄影机NodePath做的状态改变不会再影响新摄影机,新摄影机也不会有原摄影机 NodePath上标准的鼠标控制。另一种办法是,使用Camera类方法setScene(scenePath),这里的scenePath是你想绘制 的scene graph的最顶端。这样做保留了标准的摄影机控制状态:
    #我只使用一个GraphicsBuffer ,因为你想让用户看见这个过程
    myBuffer=myWindow.makeTextureBuffer("Another Scene", 800,600)

    #必须给NodePath构造器传递一个字符串,否则把它当成父节点时将会删掉子节点
    myNewScene=NodePath("myRender")
    myNewCamera=base.makeCamera(myBuffer)
    myNewCamera.reparentTo(myNewScene)
    #或者myNewCamera.node().setScene(myNewScene)

    #现在你可以得到新场景的任何纹理(仍然是自动更新的)
    myTexture=myBuffer.getTexture()
     
    图形缓冲与窗口(Graphics Buffers and Windows
    本节将详细讲述具体的缓冲和窗口函数。
    GraphicsBuffer ParasiteBuffer
    off-screen渲染时使用这2种缓冲。如果想从它们那获取纹理必须在创建时传递True参数。否则,它们在功能上与一个GraphicsOutput毫无差别。
    GraphicsBuffer ParasiteBuffer 唯一区别在后者没有自己的帧缓冲空间。创建 ParasiteBuffer 时从图形引擎调用 makeParasite()
    makeParasite(host, name,sort, xSize, ySize)
    name、sort、xSize和ySize参数与 makeWindow makeBuffer 中含义相同。新的参数 host 为将被使用内存空间作为缓冲的 GraphicsOutput 对象。寄主渲染到宿主 host 的内存空间。为了节省空间,makeTextureBuffer函数有时返回一个 ParasiteBuffer ,对不支持 offscreen 渲染的 API 同样有用。
    调用getTexture()自动建立 ParasiteBuffer 对象,因为当 host 绘制自己时,缓冲的内容很明确。
    GraphicsWindows
    跟GraphicsBuffer不同,GraphicsWindow对象拥有比GraphicsOutput更多的功能。
    最基本的就是hasKeyboard()和hasPointer()函数,分别判断窗口是否拥有键盘或光标的焦点。在没有获得控制权的情况下调用键盘或光标函数将产生错误。
    使 用getNumInputDevices()获得该窗口的输入设备数。在没有joystick等其他设备的情况下,一般只有一种输入设备。如果你使用的 API支持“键/鼠”,你可以使用movePointer(device, x,y)把鼠标移动到窗口的某个位置,device为控制鼠标的设备名(绝大多数为“键/鼠”),x和y表示你要移动到的屏幕坐标。函数成功返回 True,否则返回False。
    还可以用isFullscreen()或isClosed()查询窗口是否全屏或是否关闭。值得注意的是,调用makeWindow后窗口不会自动打开,调用closeWindow后也不会自动关闭。
    为了获得窗口的全部属性,我们可以使用getProperties()函数,它返回一个WindowProperties对象,其中包含指定窗口的全部信息。详情请参考WindowProperties类API文档。
    如果你想改变窗口属性,使用getRequestedProperties()并应用适当的WindowProperties函数。
    例如要想全屏运行Panda3D:
    wp = WindowProperties()
    wp.setFullscreen(True)
    base.win.requestProperties(wp)
    另一种办法,在导入direct.directbase.DirectStart之前修改全屏配置变量:
    from pandac.PandaModules import loadPrcFileData
    loadPrcFileData("", """fullscreen 1
    win-size 1024 768""")

    from direct.showbase.DirectObject import DirectObject # for event handling
    import direct.directbase.DirectStart
    import sys

    class World(DirectObject):
       def __init__(self):
          self.accept("escape",sys.exit)

    w= World()
    run()
    某些修改属性的请求是行不通的或无效的,你可以调用getRejectedProperties(),它返回一个WindowProperties对象,包含所有不能修改的属性。
    当 用户改变窗口属性时,窗口也发送事件。调用getWindowEvent()可获得这个事件的名字。初始状态下,所有窗口改变时都发送相同的事件。如果你 想对某个窗口设置事件,请使用setWindowEvent(name),参数name为窗口改变时你想发送的事件的名字。
    更多内容请参考GraphicsWindow的API文档。
     
    多重渲染(Multi-Pass Rendering
    有时需要在一帧画面里对同一个场景进行多次绘制,每一次绘制的结果都不同。这就是所谓的多重渲染。
    实现多重渲染最简单的办法是使用“GraphicsOutput类”那一节最后提到的办法,我们可以这样做:
    1)建立一个GraphicsBuffer对象
    2)为它创建一个摄影机
    3)将摄影机放进场景中
    然 而,这种办法的前提是你得有2个独立的scene graph。如果用该办法来渲染同一个scene graph,得到只是从不同摄影机观察到的场景而已。为了真正让场景拥有不同的RenderStates(例如一个有光照,另一个没有),必须修改每个摄 影机的渲染方式。
    每个摄影机节点都有一个名为setInitialState(state)的函数,它使场景里的物体都以同样的RenderState渲染,也就是说摄影机放进场景后,属性仍然可以被修改/覆盖。
    #用默认摄影机渲染的所有物体都使用myNodePath这个节点的RenderState
    base.cam.setInitialState(myNodePath.getState())
    你 可能想进一步场景里每个节点的RenderState进行控制。使用Camera类的setTagStateKey(key) 和setTagState(value, state)方法可以达到这一目的。对你想特殊对待的NodePath调用setTag(key, value)(参考“普通状态改变”一节)。这样,当摄影机发现有贴有key标签的NodePath时,它就会给节点分配与value关联的 RenderState:
    #假设我们有2个CgShaderAttrib 类的实例toonShadingAttrib和blurShadingAttrib
    #以及一个NodePath为myCamera 的摄影机

    base.cam.node().setTagStateKey("Toon Shading")
    base.cam.node().setTagState("True", RenderState.make(toonShadingAttrib))

    myCamera.node().setTagStateKey("Blur Shading")
    myCamera.node().setTagState("True", RenderState.make(blurShadingAttrib))

    #这使得默认摄影机以卡通形式渲染myNodePath 和它的子节点
    myNodePath.setTag("Toon Shading", "True")
    ....
    #如果你想让myNodePath被myCamera渲染成模糊形式
    #只需添加一个标签就行
    myNodePath.setTag("Blur Shading", "True")
     
    渲染到纹理(Render to Texture
    基础
    在Panda3D中,渲染到纹理由3个基本步骤构成:
    l         创建一个隐藏窗口(GraphicsBuffer类)
    l         渲染到这个隐藏窗口
    l         将隐藏窗口的内容转化成一个纹理
    我 说把窗口内容“转化”成一个纹理,并不是指“拷贝”。有许多转化方法比拷贝更快。举个例子,如果OpenGL的实现支持ARB_pbuffers扩展,那 么我们就可以用wglBindTexImageARB来完成转化。Panda用户不必操心转化如何进行,唯一要记住的就是Panda会使用最快的工具来把 窗口内容转化为纹理。
    更概括地说,虽然渲染到纹理一般由隐藏窗口(GraphicsBuffer类)来完成,但其实也可以用可见窗 口(GraphicsWindow类)。任何窗口,无论隐藏或可见,都可以转化成纹理。这一点非常有用——例如,你把主窗口(main window)的内容转化成一个纹理,在渲染下一帧时使用,在不用累积缓冲(accumulation buffer)的条件下达到类似累积缓冲(accumulation-buffer-like)的效果。
    简单API :makeTextureBuffer
    下面这一小段程序创建一个隐藏的窗口,和一个渲染到该窗口的摄影机以及摄影机的scene graph:
    mybuffer = base.win.makeTextureBuffer("My Buffer", 512, 512)
    mytexture = mybuffer.getTexture()
    mybuffer.setSort(-100)
    mycamera = base.makeCamera(mybuffer)
    myscene = NodePath("My Scene")
    mycamera.node().setScene(myscene)
    makeTextureBuffer 是实现渲染到纹理最简单的接口。它创建一个新的隐藏窗口(通常为一个GraphicsBuffer)和一个用于渲染的纹理,并将纹理和隐藏窗口联系在一 起。调用时使用(512, 512)指定隐藏窗口和纹理的大小。当然,必须是2的乘方。getTexture方法取回纹理,每一帧都渲染到该纹理。
    setSort方法设置窗口的排序,它决定Panda渲染各个窗口的顺序。主窗口的排序为0。把mybuffer的排序设定为一个负数可以确保mybuffer首先被渲染。这样,就保证了当渲染主窗口时,mytexture已经准备好可以使用了。
    那个新的隐藏窗口不会自动连接到scene graph。在上例中,我们创建了一个根节点为myscene的单独的scene graph,以及一个观察该scene graph的摄影机,并把摄影机关联到mybuffer。
    makeTextureBuffer 函数通常创建一个GraphicsBuffer(隐藏窗口),但如果显卡的功能有限,无法创建offscreen窗口时, makeTextureBuffer将创建一个parasiteBuffer来替代。寄生缓冲(parasite buffer)是在低端显卡上模拟GraphicsBuffer的一种技巧。它的诀窍在于:既然不能先渲染到一个offscreen窗口再把数据转化成纹 理,panda就干脆渲染到主窗口然后把数据拷贝到纹理上。该技巧的局限性是不证自明的,第一,它对主窗口的内容断章取义,这个缺点还不是很严重,因为主 窗口的每一帧总是清除后从零开始渲染的。第二,如果主窗口比要得到的纹理小的话就该技巧会失败。既然这2个问题在实际中都不常见, makeTextureBuffer在不能创建GraphicsBuffer是还是会用寄生缓冲来代替。
    在debugging模式 下,makeTextureBuffer将创建一个可见窗口(GraphicsWindow类)而不是一个隐藏窗口(GraphicsBuffer类)。 在你的panda配置文件里设置布尔变量“show-buffers #t”就可以进入debugging模式。
    高级API :addRenderTexture
    使用简单API很方便,但有些事情它无能为力。例如,它不能:
    l         拷贝主窗口到一个纹理。
    l         拷贝Z缓冲(Z-buffer)到一个深度纹理(depth texture)。
    l         拷贝窗口到一个纹理,但不是每一帧。
    l         限制或强制使用寄生缓冲。
    如果要进行此类操作,你需要使用底层的API。
    (本节作者Josh还未写完)
     
    如何控制渲染顺序(How to Control Render Order
    How to Control Render Order
    在大多数简单场景中,你只要把几何体放入scene graph里,然后由Panda来决定这些物体的渲染顺序。一般来讲,Panda安排得挺好了,但某些情况下我们有必要对渲染顺序进行干预和控制。
    为此,你需要了解渲染顺序的含义。在典型的OpenGL或DirectX型Z缓冲系统下,图元传送到显卡的顺序理论上是无关紧要的,但在实践中谁在谁之前渲染有很重要的理由。
    首 先,状态(state)排序是重要的优化手段之一。它把所有拥有简单状态(纹理、颜色等等)的物体挑选出来同时渲染,以此减少在一帧内显卡渲染状态改变的 次数。这种优化对高端显卡尤其关键,它们只有在没有状态改变的前提下才能达到广告中宣称的多边形吞吐率。对于许多高级显卡,每一次状态改变都将造成全部寄 存器的刷新和强制管线重新启动。
    其次,一些显卡有其他的优化需求,先绘制近处的物体也许对它们更有利,因为对于一些距离遥远模糊不清的像素,Z缓冲算法可以有效地绕过某些高级的着色特性从而缩短渲染时间。从最近物体到最远物体,或以“从前往后”顺序绘制时,这种显卡绘图效率最高。
    最 后一点,除了上面所说的2中优化手段,渲染透明物体时也需要某种排序(只有少数显卡提供对透明支持,所以我们忽略它们的存在)。透明和半透明物体一般这样 绘制:将它们半透明的部分和已经渲染到帧缓冲的内容进行混合(blending),即在绘制遮挡物的半透明部分之前,必须先渲染位于它后面的所有物体。这 也暗示着所有半透明物体必须从最远到最近进行绘制,或称为 “从后往前”顺序,而且不透明物体应在任何透明物体之前被渲染。
    Panda使用bins机制来实现这些有时会产生冲突的排序。
    Cull Bins
    CullBinManager是一个全局对象,它维护场景中全部的cull bin及其属性。初始时有5种默认的bin,它们的渲染顺序如下:
    Bin名字
    序号
    类型
    background
    10
    BT_fixed
    opaque
    20
    BT_state_sorted
    transparent
    30
    BT_back_to_front
    fixed
    40
    BT_fixed
    unsorted
    50
    BT_unsorted
    渲 染每一帧时,Panda都要遍历scene graph,把每个几何体分配到CullBinManager定义的某个bin里。(上面的表只列出默认的bin,可以根据需要增加bin,使用 CullBinManager::add_bin()方法,或者Config.prc文件中的“cull-bin”变量)
    你也可以使用NodePath::set_bin()接口把某个节点或某些节点分配到一个bin。set_bin()要求2个参数,bin的名字和一个整数序号。序号参数只有bin类型为BT_fixed时才有意义,其他情况下通常被忽略。
    如果一个节点没有明确地分配到某个bin,Panda将根据它是否允许透明把它分配到“opaque”或“transparent”bin。(注意,反方向不成立:我们把一个对象分配到“transparent”bin并不会自动打开该对象的透明属性)
    当遍历了整个场景,所有对象都分配了bin后,接下来Panda将根据序号来渲染各个bin,同一个bin内部将更根据类型来排序。
    如果你想把排在后面的物体提到前面来渲染,请对那个模型使用下面的代码:
    model.setBin("fixed", 40)
    model.setDepthTest(False)
    model.setDepthWrite(False)
    下面列出bin类型的解释:
    BT_fixed
    以用户指定的固定顺序来渲染bin中全部对象,序号来自NodePath::set_bin()方法的第二个参数,从小到大渲染。
    BT_state_sorted
    将状态相近的对象集中到一起渲染,力求减少场景的状态转换。
    BT_back_to_front
    根据每个几何体包围盒的中心到摄影机平面的直线距离排序,由远及近绘制。即在Panda默认的Z轴向上右手坐标系中,正Y值比较大的物体先被绘制。
    BT_front_to_back
    与back_to_front恰恰相反,近处的物体首先被绘制。
    BT_unsorted
    对象以它们在scene graph里出现的顺序绘制,深度优先的遍历是自顶向下然后从左到右进行。
      
    展开全文
  • 每列的最大值: df.max() 每列的最小值: df.min()
  • numpy与panda基本操作

    2019-10-31 19:37:14
    numpy and pandaNumpy 属性Numpy 的创建 array关键字创建数组指定数据 dtype创建特定数据numpy 的几种基本运算numpy 的几种基本运算Numpy 索引一维索引二维索引Numpy array 合并np.vstack()np.hstack()np.newaxis()...
  • panda强化练习2

    2019-04-15 11:07:00
    # ()中没有任何参数时,会默认只统计数值类型的字段内容,包括:计数,平均数,方差,最小值,最大值,四分位数,若其中有字符串数据会报错 ​ print( data. describe( include =[ np. object])) # 这里代表只...
  • Python panda库和seaborn学习笔记)@[TOC](Python panda库和seaborn学习笔记)前言seabornpanda库 前言 最近可能要打数学建模,就把python看了一遍,做些笔记防止自己忘了emmm seaborn seaborn import pandas as pd ...
  • 第3章 panda 分组

    2020-04-26 21:21:28
    第3章 分组 import numpy as np import pandas as pd df = pd.read_csv('data/table.csv',index_col='ID') df.head() School Class Gender Address Height Weig...
  • 第2章 panda 索引

    2020-04-23 21:58:39
    不能使用布尔索引 (c) []操作符 如果不想陷入困境,请不要在行索引为浮点时使用[]操作符,因为在Series中的浮点[]并不是进行位置比较,而是比较,非常特殊 (c.1)Series的[]操作 ① 单元素索引: s = pd.Series...
  • Panda 用法( 基础 )

    千次阅读 2019-04-22 16:53:38
    18. Series 求最大值 s4.max() 19. Series 求最小值 s4.min() 创建 DataFrame 数据类型 与 Sereis 不同,DataFrame 可以存在多列数据。一般情况下,DataFrame 也更加常用。 20. 通过 NumPy ...
  • 话不多说,先看怎么修改某一列的最大值。 那首先就要先找到该列的最大值: import numpy as np import pylab as plt plt.style.use("ggplot") import pandas as pd df = pd.DataFrame({"A":[1,2...
  • 如何熟练使用python 中的panda 和 download CSV 技巧总结 如何下载CSV对于数据的基本分析数据的功能介绍引用 ) 如何下载CSV %matplotlib inline import matplotlib.pyplot as plt from IPython.display import...
  • Qingdao Panda进阶之路

    千次阅读 2018-08-30 04:30:01
    黑客的基本技能 1、黑客的精神态度是很重要的,但技术则更是重要。黑客的态度虽然是无可取代,随著新科技的发明和旧技术的取代,这些工具随时间在慢慢的改变。...不过,在1996年末,当然,这是基础的hacking技能。...
  • pandas可以说是python当中的表格处理神器,利用pandas可以实现很多使用的功能,下面脚本就是利用pandas找出每一行数据的最大值。 脚本一 import pandas as pd df = pd.read_csv('all_rc.tsv', index_col=0, header=0...
  • 文本和图片渲染(Text and Image Rendering)Panda能够在屏幕或3维世界动态地绘制文字,它支持全部Unicode字符集,可以方便地渲染各国语言(包括亚洲语言,但要选择恰当的字体)。Panda3D提供3种文本接口,你可以按...
  • panda01】预备知识

    2020-12-16 20:36:34
    【矩阵范数】 对于矩阵 1-范数 列和范数,即所有矩阵列向量绝对值之和的最大值 2-范数 ∞\infty∞ -范数 行和范数,即所有矩阵行向量绝对值之和的最大值 F -范数 Frobenius范数,即矩阵元素绝对值的平方和再开平方 ...
  • Panda3D 有限状态机,或简称FSM,由一个Python类实现。要定义一个新的FSM,应该从FSM类派生出一个Python类,并通过类的方法来定义状态,这些 方法定义了进入或离开某种状态时的FSM行为。然后你可以根据需
  • pandas入门 panda速查速记

    千次阅读 2018-07-17 19:36:25
    #数据读取与导出 import pandas as pd import numpy as np pd.read_csv(filename,sep='')#从csv文件导入数据 ...对数据应用函数 a.apply(lambda x :x.max()-x.mnin())表示 返回所有列中最大值-最小值的差
  • 51nod 1402 最大值

    2017-01-17 00:32:10
    1402 最大值 题目来源: TopCoder 基准时间限制:1 秒 空间限制:131072 KB 分值: 20 难度:3级算法题  收藏  关注 一个N长的数组s[](注意这里的数组初始下标设为1,而不是0,即N个元素为s[1],s...
  • Mr.... 求这两个子序列的长度的和的最大值。 思路:首先对于尺取的L与R,再次尺取0到L与R到N,从中选择一段最长的连续序列,每次更新即可 #include&lt;bits/stdc++.h&gt; using n...
  • 基于图块的模型,例如Iafoss的内核( panda_models/PatchPoolModel2 ) 平铺设置为224 x 224 x 64 我们通过序数回归(珊瑚损失)解决问题 se-resnext50始终是最好的骨干 公众LB:〜0.87 最大的挑战是如何处理嘈杂...
  • pandas求每列的最大值和最小值

    千次阅读 2020-10-03 13:20:55
    df.min() 用来求每列的最小值 df.max() 用来求每列的最大值
  • 蓝桥杯 算法提高 求最大值

    千次阅读 2016-11-19 12:16:51
    算法提高 求最大值 时间限制:1.0s 内存限制:256.0MB   问题描述  给n个有序整数对ai bi,你需要选择一些整数对 使得所有你选定的数的ai+bi的和最大。并且要求你选定的数对的ai之和非负,bi之和非负。 ...
  • In recent months, a computer virus spread across ... The virus came with an icon of a lovely panda, hence the name Panda Virus. What makes this virus difficult to handle is that it has many variations.
  • 1496 : 寻找最大值时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 给定N个数A1, A2, A3, … AN,小Ho想从中找到两个数Ai和Aj(i ≠ j)使得乘积Ai × Aj × (Ai AND Aj)最大。其中AND是按位与操作。 小Ho...
  • 粒子效果(Particle Effects ) 粒子效果由一些小的图像在相同的外力...ZSpin粒子工厂生产绕Z轴旋转的粒子,Z轴在Panda3D中为垂直轴。它们有一些额外的参数: 变量 定义 ...
  • Panda and Fantastic Beasts2016acm-icpc 中国赛区总决赛 F题 后缀自动机题意给n个字符串,找第一个字符串的一个最短子串,使得它不是2到n任何一个字符串的子串。输出字典序最小的。思路SAM。算半个裸题? %%%把2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,242
精华内容 1,296
关键字:

panda最大值