1. 全栈程序员必看首页

groupby函数详解

全栈程序员-用户IM • • 未分类

groupby函数详解pandas中groupby函数用法详解1groupby()核心用法2groupby()语法格式3groupby()参数说明4groupby()典型范例1groupby()核心用法（1）根据DataFrame本身的某一列或多列内容进行分组聚合，（a）若按某一列聚合，则新DataFrame将根据某一列的内容分为不同的维度进行拆解，同时将同一维度的再进行聚合，（b）若按某多列聚合，则新D…

大家好，又见面了，我是你们的朋友全栈君。

pandas中groupby函数用法详解

计算各列数据总和并作为新列添加到末尾

df['Col_sum'] = df.apply(lambda x: x.sum(), axis=1)

计算指定列下每行数据的总和并作为新列添加到末尾

 df_sf['item_sum'] = df_sf.loc[:,['item_1','item_2','item_3']].apply(lambda x:x.sum(),axis=1)   #'item_sum'列计算'item_1','item_2','item_3'三列的总和

计算各行数据总和并作为新行添加到末尾

df.loc['Row_sum'] = df.apply(lambda x: x.sum())

计算指定列下各行数据总和并作为新行添加到末尾

MT_fs.loc['总计']=MT_fs.loc[:,['发货量','签收量','激活量','首充']].apply(lambda x: x.sum())  #“总计”表示新增行的“index”


Table1 groupby（）的常见用法

函数 适用场景 备注
df.groupby(‘key1’) 一列聚合 分组键为列名（可以是字符串、数字或其他Python对象）
df.groupby([‘key1’,‘key2’]) 多列聚合 分组键为列名，引入列表list[]
df[‘data1’].groupby(df[‘key1’]).mean() 按某一列进行一重聚合求均值 分组键为Series
A=df[‘订单编号’].groupby([ df[‘运营商’], df[‘分类’], df[‘百度圣卡’] ]).count() 按某一列进行多重聚合计数 分组键为Series，引入列表list[]
df[‘data1’].groupby([states,years]).mean() 分组键与原df无关，而是另外指定的任何长度适当的数组 分组键是数组，state和year均为数组

备注：

grouped=df['data1'].groupby(df['key1'])    #聚合后不适用配合函数的输出为：<pandas.core.groupby.generic.SeriesGroupBy object at 0x000001FE3D1FE5C0>

这是由于变量grouped是一个GroupBy对象，它实际上还没有进行任何计算，只是含有一些有关分组键df[‘key1’]的中间数据而已，然后我们可以调用配合函数（如：.mean()方法）来计算分组平均值等。
　　因此，一般为方便起见可直接在聚合之后+“配合函数”，默认情况下，所有数值列都将会被聚合，虽然有时可能会被过滤为一个子集。
　　一般，如果对df直接聚合时，
df.groupby([df['key1'],df['key2']]).mean()（分组键为：Series）与df.groupby(['key1','key2']).mean()（分组键为：列名）是等价的，输出结果相同。
　　但是，如果对df的指定列进行聚合时，
df['data1'].groupby(df['key1']).mean()（分组键为：Series），唯一方式。
此时，直接使用“列名”作分组键，提示“Error Key”。
　　 注意：分组键中的任何缺失值都会被排除在结果之外。

1 groupby()核心用法

（1）根据DataFrame本身的某一列或多列内容进行分组聚合，（a）若按某一列聚合，则新DataFrame将根据某一列的内容分为不同的维度进行拆解，同时将同一维度的再进行聚合，（b）若按某多列聚合，则新DataFrame将是多列之间维度的笛卡尔积，即：新DataFrame具有一个层次化索引（由唯一的键对组成），例如：“key1”列，有a和b两个维度，而“key2”有one和two两个维度，则按“key1”列和“key2”聚合之后，新DataFrame将有四个group；
注意：groupby默认是在axis=0上进行分组的，通过设置axis=1，也可以在其他任何轴上进行分组。

（2）groupby()，根据分组键的不同，有以下4种聚合方法：

  • 分组键为Series
    （a）使用原df的子列作为Series
    df.groupby([ df[‘key1’], df[‘key2’] ]).mean()
    （b）使用自定义的Series
    mapping={‘a’:‘red’,‘b’:‘red’,‘c’:‘blue’,‘d’:‘blue’,‘e’:‘red’,‘f’:‘orange’}
    map_series=pd.Series(mapping)
    people.groupby(map_series,axis=1).count()
  • 分组键为列名
    df.groupby([ ‘key1’,‘key2’ ]).mean()
  • 分组键为数组
    states=np.array([‘Ohio’, ‘California’, ‘California’, ‘Ohio’, ‘Ohio’])
    years=np.array([2004,2005,2006,2005,2006]) #自定义数组
    df[‘data1’].groupby( [ states,years ] ).mean()
  • 分组键为字典
    mapping={‘a’:‘red’,‘b’:‘red’,‘c’:‘blue’,‘d’:‘blue’,‘e’:‘red’,‘f’:‘orange’} #自定义字典
    by_column=people.groupby(mapping,axis=1).sum() #指定axis=1，表示对列数据进行聚合分组
  • 分组键为函数
    例如：传入len函数(可以求取一个字符串长度数组)，实现根据字符串的长度进行分组
    people.groupby(len).sum() #将字符串长度相同的行进行求和
  • 分组键为函数和数组、列表、字典、Series的组合
    引入列表list[ ] 将函数跟数组、列表、字典、Series混合使用作为分组键进行聚合，因为任何东西最终都会被转换为数组
    key_list=[‘one’,‘one’,‘one’,‘two’,‘two’] #自定义列表，默认列表顺序和df的列顺序一致
    people.groupby([ len,key_list ]).min()
  • 分组键为具有多重列索引df 的列索引层次
    hier_df.groupby(level=‘cty’,axis=1).count() #利用参数level，指明聚合的层级
    （3）常用配合函数/方法
  1. 打印出按某一指定列进行聚合的DataFrame：
for i in df.groupby('key1'):
    print(i)
  1. 按某一指定列进行聚合的DataFrame：


Table1 groupby（）的配合函数

函数 适用场景 备注
.mean() 均值
.count() 计数
.min() 最小值
.mean().unstack() 求均值，聚合表的层次索引不堆叠
.size() 计算分组大小 GroupBy的size方法，将返回一个含有分组大小的Series
.apply()
.agg()

（4）对聚合后的数据片段，进行字典、列表等格式转化

  • 将数据片段转为字典
pieces=pieces=dict(list(df.groupby('key1')))
  • 将数据片段转为列表
pieces=list(df.groupby('key1'))

（5）利用groupby，根据dtypes对列进行分组，此时需指定axis=1，否则，groupby默认根据axis=0进行分组，而行数据由于类型不统一，故无法根据dtypes对列进行分组，结果为空。
（6）可使用一个/组列名，或者一个/组字符串数组对由DataFrame产生的GroupBy对象，进行索引，从而实现选取部分列进行聚合的目的即：

（1）根据key1键对data1列数据聚合
df.groupby('key1')['data1'].mean()
#或者
df['data1'].groupby(df['key1']).mean()    #或者df['data1'].groupby([df['key1']]).mean() ，当按多个层次聚合时引入列表，故单层次用列表也无妨
>>>
key1
a    -0.048502
b     0.053162
Name: data1, dtype: float64
（2）根据key1键对data2列数据聚合
df.groupby('key1')['data2'].mean()
#或者
df['data2'].groupby(df['key1']).mean()
>>>
key1
a     -0.533444
b     -0.948798
Name: data2, dtype: float64
（3）根据key1键对data2列数据聚合，当对多列数据如data1和data2根据某个键入key1聚合分组时，组引入列表['data1','data2'],此处对data2外加中括号是一个意思，只是影响输出格式。
df.groupby('key1')[['data2']].mean()
#或者df[['data2']].groupby(df['key1']).mean()
>>>
	 data2
key1	
a	-0.533444
b	-0.948798
（4）根据key1键对data1和data2列数据聚合
df.groupby('key1')[['data1','data2']].mean()
#或者
df[['data1','data2']].groupby(df['key1']).mean()
>>>
	   data1	data2
key1		
a	 -0.048502	-0.533444
b	  0.053162	-0.948798
（5）根据多个键key1、key2对data2列数据聚合
df.groupby(['key1','key2'])['data2'].mean()
#或者
df['data2'].groupby([df['key1'],df['key2']]).mean()
>>>
key1  key2
a     one    -1.391653
      two     1.182974
b     one    -1.707349
      two    -0.190247
Name: data2, dtype: float64

2 groupby()语法格式

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

3 groupby()参数说明

by : mapping, function, label, or list of labels
Used to determine the groups for the groupby. If by is a function, it’s called on each value of the object’s index. If a dict or Series is passed, the Series or dict VALUES will be used to determine the groups (the Series’ values are first aligned; see .align() method). If an ndarray is passed, the values are used as-is determine the groups. A label or list of labels may be passed to group by the columns in self. Notice that a tuple is interpreted a (single) key.

axis : {0 or ‘index’, 1 or ‘columns’}, default 0
Split along rows (0) or columns (1).

level : int, level name, or sequence of such, default None
If the axis is a MultiIndex (hierarchical), group by a particular level or levels.

as_index : bool, default True
For aggregated output, return object with group labels as the index. Only relevant for DataFrame input. as_index=False is effectively “SQL-style” grouped output.

sort : bool, default True
Sort group keys. Get better performance by turning this off. Note this does not influence the order of observations within each group. Groupby preserves the order of rows within each group.

group_keys : bool, default True
When calling apply, add group keys to index to identify pieces.

squeeze : bool, default False
Reduce the dimensionality of the return type if possible, otherwise return a consistent type.

observed : bool, default False
This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers.

New in version 0.23.0.

**kwargs
Optional, only accepts keyword argument ‘mutated’ and is passed to groupby.

4 groupby()典型范例

范例一：根据DataFrame本身的某一列或多列内容进行分组聚合

#创建原始数据集
import pandas as pd
import numpy as np

df=pd.DataFrame({ 
   'key1':['a','a','b','b','a'],
                 'key2':['one','two','one','two','one'],
                  'data1':np.random.randn(5),
                  'data2':np.random.randn(5)})
#'key1':['a','a','b','b','a']亦可写作'key1':list('aabba'),完成列表的创建
>>> df
   key1	 key2	    data1	  data2
0	a	 one	  -0.484689	  -3.105627
1	a	 two	  0.033929	  1.182974
2	b	 one	  1.067201	  -1.707349
3	b	 two	  -0.960876	  -0.190247
4	a	 one	  0.305254	  0.322322
#（1）按指定的某一列进行聚合
for i in df.groupby('key1'):
    print(i)
>>>
('a',   key1   key2     data1      data2
0        a     one     -0.484689   -3.105627
1        a     two     0.033929    1.182974
4        a     one     0.305254    0.322322)
('b',   key1   key2     data1      data2
2        b     one     1.067201    -1.707349
3        b     two     -0.960876   -0.190247)
#（2）按多列进行聚合，新的DataFrame是多列之间维度的笛卡尔积
for i in df.groupby(['key1','key2']):
    print(i)
>>>
(('a', 'one'),   key1    key2     data1      data2
      0          a       one      -0.484689  -3.105627
      4          a       one      0.305254   0.322322)
(('a', 'two'),   key1    key2     data1     data2
      1          a       two      0.033929   1.182974)
(('b', 'one'),   key1    key2     data1     data2
      2          b       one      1.067201 -1.707349)
(('b', 'two'),   key1   key2     data1     data2
      3          b       two      -0.960876 -0.190247)
#（3） 按key1进行分组，并计算data1列的平均值
df1=df['data1'].groupby(df['key1']).mean()
>>>
key1
a       -0.048502
b       0.053162
#（4） 按key1、key2进行分组，并计算data1列的平均值,聚合表不堆叠
#将数据从“花括号”格式转为“表格”格式，unstack即“不要堆叠”
df2=df['data1'].groupby([df['key1'],df['key2']]).mean().unstack()
>>>df2
key2	one	        two
key1		
a	    -0.089718	 0.033929
b	    1.067201	 -0.960876
#(5)分组键可以是与原df无关的，另外指定的任何长度适当的数组，新数组按列表顺序分别与df[col_1]的数据一一对应。
states=np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])
years=np.array([2004,2005,2006,2005,2006])
df['data1'].groupby([states,years]).mean()
>>>
California  2005    0.033929
            2006    1.067201
Ohio        2004   -0.484689
            2005   -0.960876
            2006    0.305254
#用到GroupBy的size方法，它可以返回一个含有分组大小的Series
df.groupby(['key1','key2']).size()
>>>
      key1  key2
a     one     2
      two     1
b     one     1
      two     1

范例二：利用for循环，对分组进行迭代

#原始数据集与范例一相同
#对一列聚合，使用for循环进行分组迭代
for name,group in df.groupby('key1'):
    print(name)
    print(group)
>>>
a
  key1 key2     data1     data2
0    a  one -0.484689 -3.105627
1    a  two  0.033929  1.182974
4    a  one  0.305254  0.322322
b
  key1 key2     data1     data2
2    b  one  1.067201 -1.707349
3    b  two -0.960876 -0.190247
#若仅使用一个变量name,会影响输出结果的索引层次表达方式，且结果为元组
for name in df.groupby('key1'):
    print(name)
>>>
('a',   key1 key2     data1     data2
0    a  one -0.484689 -3.105627
1    a  two  0.033929  1.182974
4    a  one  0.305254  0.322322)
('b',   key1 key2     data1     data2
2    b  one  1.067201 -1.707349
3    b  two -0.960876 -0.190247)
#对于多重键的情况，元组的第一个元素将会是由键值组成的元组,所以for循环的第一个变量用元组（k1,k2）：
for (k1,k2),group in df.groupby(['key1','key2']):
    print(k1,k2)
    print(group)
>>>
a one
  key1 key2     data1     data2
0    a  one -0.484689 -3.105627
4    a  one  0.305254  0.322322
a two
  key1 key2     data1     data2
1    a  two  0.033929  1.182974
b one
  key1 key2     data1     data2
2    b  one  1.067201 -1.707349
b two
  key1 key2     data1     data2
3    b  two -0.960876 -0.190247
#对于多重键的情况，若for循环的第一个变量不用元组（k1,k2），而是普通变量name,则输出结果的层次索引将为元组格式
for name,group in df.groupby(['key1','key2']):
    print(name)
    print(group)
>>>
('a', 'one')
  key1 key2     data1     data2
0    a  one -0.484689 -3.105627
4    a  one  0.305254  0.322322
('a', 'two')
  key1 key2     data1     data2
1    a  two  0.033929  1.182974
('b', 'one')
  key1 key2     data1     data2
2    b  one  1.067201 -1.707349
('b', 'two')
  key1 key2     data1     data2
3    b  two -0.960876 -0.190247

范例三：对聚合后的数据片段，进行格式类型转化

#将数据片段转为字典
pieces=dict(list(df.groupby('key1')))
>>>
pieces
{ 
   'a':   key1  key2     data1     data2
 0       a   one     -0.484689 -3.105627
 1       a   two      0.033929  1.182974
 4       a   one      0.305254  0.322322, 'b':   key1 key2     data1     data2
 2       b   one      1.067201 -1.707349
 3       b   two     -0.960876 -0.190247}
 >>>
 pieces['b']    #选取片段
    key1	key2	data1	    data2
2	b	    one	    1.067201	-1.707349
3	b	    two	    -0.960876	-0.190247
#将数据片段转为列表
pieces=list(df.groupby('key1'))
>>>
pieces
[('a',   key1 key2     data1     data2
  0       a   one     -0.484689 -3.105627
  1       a   two      0.033929  1.182974
  4       a   one      0.305254  0.322322), ('b',   key1 key2     data1     data2
  2       b   one      1.067201 -1.707349
  3       b   two     -0.960876 -0.190247)]

范例四：利用groupby，根据dtypes对列进行分组,此时，需指定axis=1，否则，groupby默认根据axis=0进行分组，而行数据由于类型不统一，故无法根据dtypes对列进行分组

#df.dtypes用于确定df的数据类型
df.dtypes
>>>
key1      object
key2      object
data1    float64
data2    float64
dtype: object
#将聚合后df转化为字典格式，后根据df的数据类型对列进行分组
grouped=df.groupby(df.dtypes,axis=1)
dict(list(grouped))
>>>
{ 
   dtype('float64'):       data1     data2
                      0 -0.484689 -3.105627
                      1  0.033929  1.182974
                      2  1.067201 -1.707349
                      3 -0.960876 -0.190247
                      4  0.305254  0.322322, dtype('O'):   key1  key2
                                                       0    a   one
                                                       1    a   two
                                                       2    b   one
                                                       3    b   two
                                                       4    a   one}
#若不指定axis=1，则默认groupby根据行数据按dtypes进行分组
grouped1=df.groupby(df.dtypes)
dict(list(grouped1))
>>>
{ 
   }    #由于行数据不统一，故按dtypes分组时，为空
#将聚合数据片段转化为list类型
list(grouped)
>>>
[(dtype('float64'),       data1     data2
                       0  -0.484689 -3.105627
                       1   0.033929  1.182974
                       2   1.067201 -1.707349
                       3  -0.960876 -0.190247
                       4   0.305254  0.322322), (dtype('O'),    key1  key2
                                                             0    a  one
                                                             1    a  two
                                                             2    b  one
                                                             3    b  two
                                                             4    a  one)]

范例五：根据自定义字典、自定义列表、自定义Series、函数或者函数与自定义数组、列表、字典、Series的组合，作为分组键进行聚合

#创建原始数据集
people=pd.DataFrame(np.random.randn(5,5),columns=list('abcde'),index=['Joe','Steve','Wes','Jim','Travis'])
people
>>>
            a	        b	        c	       d	       e
Joe 	-0.350379	-2.216265	-1.922898	0.655574	0.512573
Steve	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
Wes	    -1.624845	-0.432863	-0.211577	0.310541	2.138030
Jim	     2.038365	-0.237121	-0.392664	-0.480918	1.566855
Travis	-0.345361	-0.653787	-0.299217	1.019871	0.511216
#利用people.ix[2:3,['b','c']]=np.nan，将第2,3行，第b,c列的数据置为空
people.ix[2:3,['b','c']]=np.nan
>>>
people
            a	        b	        c	       d	      e
Joe	    -0.350379	-2.216265	-1.922898	 0.655574	0.512573
Steve	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
Wes	    -1.624845	   NaN	       NaN	     0.310541	2.138030
Jim	     2.038365	-0.237121	-0.392664	-0.480918	1.566855
Travis	-0.345361	-0.653787	-0.299217	 1.019871	0.511216
# 假设已知列的分组关系，并希望根据分组计算列的总计：
#创建分组的映射字典
mapping={ 
   'a':'red','b':'red','c':'blue','d':'blue','e':'red','f':'orange'}
mapping
>>>
{ 
   'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'blue', 'e': 'red', 'f': 'orange'}
type(mapping)
>>>
dict
#将这个字典传给groupby即可,由于是按列进行分组，指定axis=1
by_column=people.groupby(mapping,axis=1).sum()
by_column
>>>
	        blue	red
Joe	       -1.267323	-2.054071
Steve	   -0.937431	-1.638802
Wes	        0.310541	 0.513184
Jim	       -0.873581	 3.368099
Travis	    0.720653	-0.487932
#用自定义Series作为分组键进行聚合，则pandas会检查Series以确保其索引跟分组轴是对齐的
#自定义Series作为分组键
map_series=pd.Series(mapping)
>>>
map_series
a       red
b       red
c      blue
d      blue
e       red
f    orange
dtype: object
#用自定义Series作为分组键聚合
people.groupby(map_series,axis=1).count()
>>>
       blue	red
Joe	    2	3
Steve	2	3
Wes	    1	2
Jim	    2	3
Travis	2	3
#用函数作分组键，进行分组，需传入len函数(可以求取一个字符串长度数组),实现根据人名的长度进行分组
people.groupby(len).sum()   #将名字长度相同的行求和
>>>
        a	        b	         c	        d	       e
3	0.063140	-2.453386	-2.315561	0.485198	4.217458
5	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
6	-0.345361	-0.653787	-0.299217	1.019871	0.511216
#将函数和数组、列表、字典、Series组合作为分组键，进行聚合
key_list=['one','one','one','two','two']   #自定义列表，默认列表的字符串顺序和df的列顺序一致
people.groupby([len,key_list]).min()
>>>
             a	        b	        c	        d	       e
3	one	 -1.624845	-2.216265	-1.922898	0.310541	0.512573
    two	  2.038365	-0.237121	-0.392664	-0.480918	1.566855
5	one	 -1.212107	-1.040184	-0.659978	-0.277454	0.613489
6	two	 -0.345361	-0.653787	-0.299217	1.019871	0.511216

范例六：df含有多重列索引的聚合分组

#根据df的多重列索引的层次级别分组聚合
#自定义列层次索引
columns=pd.MultiIndex.from_arrays([['US','US','US','JP','JP'],[1,3,5,1,3]],names=['cty','tenor'])
>>>
columns
MultiIndex(levels=[['JP', 'US'], [1, 3, 5]],
           codes=[[1, 1, 1, 0, 0], [0, 1, 2, 0, 1]],
           names=['cty', 'tenor'])
#创建包含多重列索引的原始数据集
hier_df=pd.DataFrame(np.random.randn(4,5),columns=columns)
>>>
hier_df
cty	    US	        JP
tenor	  1	          3	         5	         1	        3
0	  0.023254	 -0.271758	-0.129695	-1.003850	0.600698
1	  -0.076856	 0.696218	-1.054670	-0.232982	0.641908
2	  0.211017	 0.481233	-0.289600	0.794614	-0.910464
3	  1.069144	 0.358034	0.169202	-1.910069	0.769219
#按列索引层次进行分组聚合
hier_df.groupby(level='cty',axis=1).count()    #利用参数level，指明聚合的层级
>>>
cty	JP	US
0	2	3
1	2	3
2	2	3
3	2	3

#"盲投"DataFrame按照“号码归属省”对指定4列“'发货量','签收量','激活量','首充'”进行聚合
functions=['count']
MT_fs_grouped=MT_data.groupby(['号码归属省'])
MT_fs=MT_fs_grouped['发货量','签收量','激活量','首充'].agg(functions)
MT_fs=pd.DataFrame(MT_fs)
MT_fs.reset_index(inplace=True)   #将聚合表的index转为普通列
#对聚合表增加“各列统计求和”的行，同时指定参与求和的列，即“号码归属省”列需排除；
MT_fs.loc['总计']=MT_fs.loc[:,['发货量','签收量','激活量','首充']].apply(lambda x: x.sum())
MT_fs.loc['总计',['号码归属省']]='总计'  #补全“省份”最后一行的“总计”名称

参考链接：https://www.cnblogs.com/huiyang865/p/5577772.html

5 groupby常见的调用函数

  • 描述组内数据的基本统计量：A.groupby("性别").describe().unstack()
  • 组内均值计算：A.groupby("性别").mean()
  • 我们还可以一次运用多个函数计算：A.groupby( ["班级","性别"]).agg([np.sum, np.mean, np.std]) # 一次计算了三个
  • 按照【生日】的【年份】进行分组，看看有多少人是同龄？
    A[“生日”] = pd.to_datetime(A[“生日”],format =”%Y/%m/%d”) # 转化为时间格式
    A.groupby(A["生日"].apply(lambda x:x.year)).count() # 按照【生日】的【年份】分组
    在这里插入图片描述

参考链接：python中groupby函数主要的作用是进行数据的分组以及分组后地组内运算！

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/141098.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • tp框架的特性_tp5框架

    tp框架的特性_tp5框架

    tp框架的特性_tp5框架一、结构目录》Thinkphp文件夹,是thinkPHP的核心文件,里面的内容是不允许我们修改的》Public是公有的文件夹,里面可以写自己的东西》Application我们建立项目的文件夹(Public和Application里面原有自带的文件可以删除,相当于两个空的文件夹)》tp文件夹中的index.php是所有程序的入口文件》conf->convention.php配置文件包含了所有的配置》thinkphp->conf文件夹->配置文件,几乎包括关于..

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年11月1日
  • 数字音频编辑的基本流程_数字音频编辑

    数字音频编辑的基本流程_数字音频编辑

    数字音频编辑的基本流程_数字音频编辑为什么会有SampleRate和BitdepthSampleRate就是采样率Bitdepth就是位深度不管在什么应用场合，只要是关于数字音频的这两个参数必然跑不了，网上的问答多为如何设置这两个参数，在何种使用场景使用哪种采样率和位深度最好，但对做数据处理的必须知道这两个值怎么设定，才能在特殊场合提高处理速度牺牲精度或是提高精度牺牲处理速度。SampleRate简单来说，Sample…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月17日
  • hadoop学习；安装jdk，workstation虚拟机v2v迁移；虚拟机之间和跨物理机之间ping网络通信;virtualbox的centos中关闭防火墙和检查服务启动

    hadoop学习；安装jdk，workstation虚拟机v2v迁移；虚拟机之间和跨物理机之间ping网络通信;virtualbox的centos中关闭防火墙和检查服务启动

    hadoop学习；安装jdk，workstation虚拟机v2v迁移；虚拟机之间和跨物理机之间ping网络通信;virtualbox的centos中关闭防火墙和检查服务启动

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年12月5日
  • JS 点击复制Copy插件–Zero Clipboard

    JS 点击复制Copy插件–Zero Clipboard

    JS 点击复制Copy插件–Zero Clipboard

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年12月2日
  • SecureCRT的使用教程（ 过程非常详细！！值得查看）

    SecureCRT的使用教程（ 过程非常详细！！值得查看）

    SecureCRT的使用教程（ 过程非常详细！！值得查看）SecureCRT的使用教程（过程非常详细！！值得查看）下载和安装简单的介绍一、SecureCRT的使用二、SecureFX的使用下载和安装SecureCRT和SecureFX的下载和安装我这里就不多说了，详细的安装下载教程请参考：SecureCRT的下载、安装（过程非常详细！！值得查看）简单的介绍SecureCRT是一款支持SSH（SSH1和SSH2）的终端仿真程序，简单地说是…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月29日
  • c语言中getchar的运用_c语言中gets和getchar

    c语言中getchar的运用_c语言中gets和getchar

    c语言中getchar的运用_c语言中gets和getchar1.从缓冲区读走一个字符，相当于清除缓冲区2.前面的scanf()在读取输入时会在缓冲区中留下一个字符’\n'(输入完s[i]的值后按回车键所致)，所以如果不在此加一个getchar()把这个回车符取走的话，gets()就不会等待从键盘键入字符，而是会直接取走这个“无用的”回车符，从而导致读取有误3.getchar()是在输入缓冲区顺序读入一个字符(包括空格、回车和Tab)getchar()使用不…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月31日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号