可以叫我才哥

只需8招，搞定Pandas数据筛选与查询

大家好，我是才哥。

今天聊聊Pandas数据筛选与查询的一些操作，在数据分析的过程中通常要对数据进行清洗与处理，而其中比较重要和常见的操作就有对数据进行筛选与查询。

目录：

文章目录

- 1. 案例数据预览
- 2. 基础操作
- - 2.1. 切片[]
  - 2.2. 索引选择.iloc与.loc
  - 2.3. 元素选择.iat与.at
  - 2.4. get与truncate
- 3. 进阶操作
- - 3.1. 逻辑筛选
  - 3.2. 函数筛选
  - 3.3. query
  - 3.4. filter

1. 案例数据预览

本次案例，我们继续采用之前用到过的各地区GDP数据，数据信息大致如下，后台回复GDP可以获取哈。

In [1]: import pandas as pd

In [2]: df = pd.read_excel(r'各地区生产总值.xlsx')

In [3]: df.head()
Out[3]: 
       地区    2020年    2019年    2018年    2017年    2016年
0     北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1     天津市  14083.7  14055.5  13362.9  12450.6  11477.2
2     河北省  36206.9  34978.6  32494.6  30640.8  28474.1
3     山西省  17651.9  16961.6  15958.1  14484.3  11946.4
4  内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3

In [4]: df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 32 entries, 0 to 31
Data columns (total 6 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   地区      32 non-null     object 
 1   2020年   31 non-null     float64
 2   2019年   31 non-null     float64
 3   2018年   31 non-null     float64
 4   2017年   31 non-null     float64
 5   2016年   31 non-null     float64
dtypes: float64(5), object(1)
memory usage: 1.6+ KB

我们看看描述统计情况，然后在后续做筛选查询的时候好演示

In [5]: df.describe()
Out[5]: 
               2020年          2019年         2018年         2017年         2016年
count      31.000000      31.000000     31.000000     31.000000     31.000000
mean    32658.551613   31687.758065  29487.661290  26841.819355  24224.148387
std     26661.811640   25848.652250  24136.181387  22161.575235  20008.278500
min      1902.700000    1697.800000   1548.400000   1349.000000   1173.000000
25%     13940.650000   13826.300000  13104.700000  12381.800000  11634.800000
50%     25115.000000   24667.300000  22716.500000  20210.800000  18388.600000
75%     42612.500000   41110.350000  37508.750000  33835.250000  30370.250000
max    110760.900000  107986.900000  99945.200000  91648.700000  82163.200000

可以看到，有效数据有30多条，为了让数据显示好一点，我们可以设置最多显示6行

In [6]: pd.set_option('display.max_rows', 6) #最多显示6行

In [7]: df
Out[7]: 
          地区    2020年    2019年    2018年    2017年    2016年
0        北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
..       ...      ...      ...      ...      ...      ...
29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
31       台湾省      NaN      NaN      NaN      NaN      NaN

[32 rows x 6 columns]

接下来，我们开始演示数据的筛选与查询吧

2. 基础操作

一般来说，数据筛选有选择行、列或者指定位置的值等

2.1. 切片[]

切片这玩意就和python的列表数据的切片操作很相似

选择某一列

注意：如果列名为 2020年或者2020 年，则无法采用属性形式，因为这种操作的变量名不能以数字开头或存在空格

df['地区']  # 切片形式
Out[8]: 
0          北京市
1          天津市
2          河北省
  
29     宁夏回族自治区
30    新疆维吾尔自治区
31         台湾省
Name: 地区, Length: 32, dtype: object

In [9]: df.地区  # 属性形式
Out[9]: 
0          北京市
1          天津市
2          河北省
        ...   
29     宁夏回族自治区
30    新疆维吾尔自治区
31         台湾省
Name: 地区, Length: 32, dtype: object

In [10]: # 如果列名为 2020年或者2020 年，则无法采用属性形式，因为这种操作的变量名不能以数字开头或存在空格
    ...: df.2020年
  File "C:\Users\Gdc\AppData\Local\Temp/ipykernel_6832/3948025585.py", line 2
    df.2020年
      ^
SyntaxError: invalid syntax

切片操作

切片里是索引位置，筛选的是对应的行
同样如果我们在切片里是列名组成的列表，则可以筛选出这些列
对于只有一列的情况，切片[]是列名构成的列表返回结果类型分别是DataFrame，反之则是Series

In [11]: df[:2] # 前两行数据
Out[11]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1  天津市  14083.7  14055.5  13362.9  12450.6  11477.2

In [12]: df[6:8] # 索引6-7 行数据（注意这里索引是从0开始的）
Out[12]: 
     地区    2020年    2019年    2018年    2017年    2016年
6   吉林省  12311.3  11726.8  11253.8  10922.0  10427.0
7  黑龙江省  13698.5  13544.4  12846.5  12313.0  11895.0

In [13]: df[:16:2] # 前15行 隔2行取
Out[13]: 
        地区    2020年    2019年    2018年    2017年    2016年
0      北京市  36102.6  35445.1  33106.0  29883.0  27041.2
2      河北省  36206.9  34978.6  32494.6  30640.8  28474.1
4   内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
..     ...      ...      ...      ...      ...      ...
10     浙江省  64613.3  62462.0  58002.8  52403.1  47254.0
12     福建省  43903.9  42326.6  38687.8  33842.4  29609.4
14     山东省  73129.0  70540.5  66648.9  63012.1  58762.5

[8 rows x 6 columns]

In [14]: df[::-1] # 倒序
Out[14]: 
          地区    2020年    2019年    2018年    2017年    2016年
31       台湾省      NaN      NaN      NaN      NaN      NaN
30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
..       ...      ...      ...      ...      ...      ...
2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
0        北京市  36102.6  35445.1  33106.0  29883.0  27041.2

[32 rows x 6 columns]

In [15]: # 我们看到刚才在上述切片里是索引位置，筛选的是对应的行；同样如果我们在切片里是列名组成的列表，则可以筛选出这些列
    ...: df[['地区','2016年']]
Out[15]: 
          地区    2016年
0        北京市  27041.2
1        天津市  11477.2
2        河北省  28474.1
..       ...      ...
29   宁夏回族自治区   2781.4
30  新疆维吾尔自治区   9630.8
31       台湾省      NaN

[32 rows x 2 columns]

In [16]: # 对于只有一列的情况，以下两种形式下返回结果类型分别是DataFrame和Series
    ...: df[['地区']]
Out[16]: 
          地区
0        北京市
1        天津市
2        河北省
..       ...
29   宁夏回族自治区
30  新疆维吾尔自治区
31       台湾省

[32 rows x 1 columns]

In [17]: df['地区']
Out[17]: 
0          北京市
1          天津市
2          河北省
        ...   
29     宁夏回族自治区
30    新疆维吾尔自治区
31         台湾省
Name: 地区, Length: 32, dtype: object

2.2. 索引选择.iloc与.loc

按照索引有两种筛选方式，iloc和loc

df.iloc[行表达式, 列表达式]，两个表达式只支持数字切片形式：行表达式筛选行、列表达式筛选列
df.loc[行表达式, 列表达式]，两个表达式其实是对行列索引名称的选择：行表达式筛选行、列表达式筛选列

当然，这两种筛选方式的表达式也支持条件

iloc[]

大家可以根据方法名称来区分是针对自然索引位置还是索引名称，比如iloc多个i嘛，i就是数字码，所以它针对的是自然索引位置

In [18]: df.iloc[0] # 返回是Series，0是自然索引位置
Out[18]: 
地区           北京市
2020年    36102.6
2019年    35445.1
2018年    33106.0
2017年    29883.0
2016年    27041.2
Name: 0, dtype: object

In [19]: df.iloc[[0]] # 返回是一行，0是自然索引位置
Out[19]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2

In [20]: df.iloc[:2] # 前两行数据
Out[20]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1  天津市  14083.7  14055.5  13362.9  12450.6  11477.2

In [21]: df.iloc[:2,[0,1,3]] # 前两行，第0-1-3列数据
Out[21]: 
    地区    2020年    2018年
0  北京市  36102.6  33106.0
1  天津市  14083.7  13362.9

In [22]: df.iloc[1,1] # 自然索引为1，第1列的数据（也就是天津2020年的gdp），一般用 .iat
Out[22]: 14083.7

loc[]

区别于iloc，它根据索引的名称来进行筛选，如果没有设置索引一般就是自然索引

In [23]: df1 = df.set_index('地区') # 我们设置 地区字段 列 为索引

In [24]: df1
Out[24]: 
            2020年    2019年    2018年    2017年    2016年
地区                                                   
北京市       36102.6  35445.1  33106.0  29883.0  27041.2
天津市       14083.7  14055.5  13362.9  12450.6  11477.2
河北省       36206.9  34978.6  32494.6  30640.8  28474.1
...           ...      ...      ...      ...      ...
宁夏回族自治区    3920.5   3748.5   3510.2   3200.3   2781.4
新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
台湾省           NaN      NaN      NaN      NaN      NaN

[32 rows x 5 columns]

In [25]: df1.loc['北京市'] # 选择 索引名为北京市的数据
Out[25]: 
2020年    36102.6
2019年    35445.1
2018年    33106.0
2017年    29883.0
2016年    27041.2
Name: 北京市, dtype: float64

In [26]: df1.loc['北京市':'河北省','2020年'] # 选择 索引名称 在北京市到河北省，列名为 2020年的数据
Out[26]: 
地区
北京市    36102.6
天津市    14083.7
河北省    36206.9
Name: 2020年, dtype: float64

In [27]: df1.loc['北京市':'河北省','2019年':] # 选择 索引名称 在北京市到河北省，列名在 2019年及之后的数据
Out[27]: 
       2019年    2018年    2017年    2016年
地区                                     
北京市  35445.1  33106.0  29883.0  27041.2
天津市  14055.5  13362.9  12450.6  11477.2
河北省  34978.6  32494.6  30640.8  28474.1

In [28]: df1.loc[['北京市','上海市','重庆市','天津市'],['2020年','2019年']] # 选择索引名为 北京、上海、重庆、天津 2020年及2019年数据
Out[28]: 
       2020年    2019年
地区                   
北京市  36102.6  35445.1
上海市  38700.6  37987.6
重庆市  25002.8  23605.8
天津市  14083.7  14055.5

In [29]: df1.loc['北京市','2020年'] # 选择 索引名为 北京市，列名为2020年 额数据（就是坐标元素值）
Out[29]: 36102.6

2.3. 元素选择.iat与.at

按坐标其实可以通过上述的按索引进行，这里还可以用.iat和.at来实现，和按索引类型一个是自然索引值一个是索引名称

In [30]: df.iat[0,2]
Out[30]: 35445.1

In [31]: df1.at['北京市','2019年']
Out[31]: 35445.1

In [32]: df.地区.at[3]
Out[32]: '山西省'

In [33]: # 其实还有以下方式
    ...: df1['2019年']['北京市']
Out[33]: 35445.1

In [34]: df['2019年'][0]
Out[34]: 35445.1

2.4. get与truncate

df.get(key, default=None)类似python字典里的get方法

df.truncate(before=None, after=None, axis=None, copy: 'bool_t' = True)，返回区间数据

get()

对于DataFrame数据来说返回key列的值，如果key不存在就返回默认值。

Signature: df.get(key, default=None)
Docstring:
Get item from object for given key (ex: DataFrame column).

Returns default value if not found.

对于Series数据来说，返回key索引的值，不存在就返回默认值。

In [35]: df.get('地区','无数据')
Out[35]: 
0          北京市
1          天津市
2          河北省
        ...   
29     宁夏回族自治区
30    新疆维吾尔自治区
31         台湾省
Name: 地区, Length: 32, dtype: object

In [36]: df.get('2015年','无数据')
Out[36]: '无数据'

In [37]: df.地区.get(0,'无数据')
Out[37]: '北京市'

In [38]: df.地区.get(100,'无数据')
Out[38]: '无数据'

truncate()

将索引代入before和after，截取这区间的数据，支持对行和列操作

In [39]: df.truncate(before=0,after=4)
Out[39]: 
       地区    2020年    2019年    2018年    2017年    2016年
0     北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1     天津市  14083.7  14055.5  13362.9  12450.6  11477.2
2     河北省  36206.9  34978.6  32494.6  30640.8  28474.1
3     山西省  17651.9  16961.6  15958.1  14484.3  11946.4
4  内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3

In [40]: df.truncate(before='2018年',after='2020年',axis=1)
Out[40]: 
      2020年    2019年    2018年
0   36102.6  35445.1  33106.0
1   14083.7  14055.5  13362.9
2   36206.9  34978.6  32494.6
..      ...      ...      ...
29   3920.5   3748.5   3510.2
30  13797.6  13597.1  12809.4
31      NaN      NaN      NaN

[32 rows x 3 columns]

以上属于数据筛选与查询的基础操作，接下来我们介绍进阶操作

3. 进阶操作

基础操作部分我们介绍的是比较简单的数据筛选操作，实际的数据清洗与处理时我们更多的是需要根据更加复杂的组合条件来查询数据进行筛选。这一节，我们就来一一介绍一下。

3.1. 逻辑筛选

逻辑刷选这里是指按照一定的逻辑条件来进行数据的筛选，比如满足某条件的行、列数据等等

In [41]: df[df['地区'] == '北京市'] # 地区是北京市的数据
Out[41]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2

In [42]: df[df['地区'].str.contains('市')] # 地区名称 含关键字 市 的数据 
Out[42]: 
     地区    2020年    2019年    2018年    2017年    2016年
0   北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1   天津市  14083.7  14055.5  13362.9  12450.6  11477.2
8   上海市  38700.6  37987.6  36011.8  32925.0  29887.0
21  重庆市  25002.8  23605.8  21588.8  20066.3  18023.0

In [43]: df[df['地区'].str.contains('市|自治区')] # 地区名称含关键字 市或自治区 的数据
Out[43]: 
          地区    2020年    2019年    2018年    2017年    2016年
0        北京市  36102.6  35445.1  33106.0  29883.0  27041.2
1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
4     内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
..       ...      ...      ...      ...      ...      ...
25     西藏自治区   1902.7   1697.8   1548.4   1349.0   1173.0
29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8

[9 rows x 6 columns]

In [44]: df[df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 在北京市、湖北省、江苏省的数据
Out[44]: 
     地区     2020年    2019年    2018年    2017年    2016年
0   北京市   36102.6  35445.1  33106.0  29883.0  27041.2
9   江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
16  湖北省   43443.5  45429.0  42022.0  37235.0  33353.0

In [45]: df[~df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 不在北京市、湖北省、江苏省的数据
Out[45]: 
          地区    2020年    2019年    2018年    2017年    2016年
1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
3        山西省  17651.9  16961.6  15958.1  14484.3  11946.4
..       ...      ...      ...      ...      ...      ...
29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
31       台湾省      NaN      NaN      NaN      NaN      NaN

[29 rows x 6 columns]

除了上面用切片[]的形式，同样可以用loc[]的形式

In [46]: df.loc[df['地区'].isin(['北京市','湖北省','江苏省'])]
Out[46]: 
     地区     2020年    2019年    2018年    2017年    2016年
0   北京市   36102.6  35445.1  33106.0  29883.0  27041.2
9   江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
16  湖北省   43443.5  45429.0  42022.0  37235.0  33353.0

对于iloc[]来说，则需要是对自然索引值的判断

In [47]: df.iloc[df.index==9]
Out[47]: 
    地区     2020年    2019年    2018年    2017年    2016年
9  江苏省  102719.0  98656.8  93207.6  85869.8  77350.9

我们还可以进行更复杂的逻辑判断去筛选想要的数据，在进行或（|）且（&）非（~）逻辑判断的时候，每个独立的逻辑判断需要用括号括起来

In [48]: df[df['2020年']<df['2019年']] # 2020年GDP小于2019年GDP的省份
Out[48]: 
     地区    2020年    2019年    2018年    2017年    2016年
16  湖北省  43443.5  45429.0  42022.0  37235.0  33353.0

In [49]: df[(df['2020年']>30000) &
    ...:    (df['2019年']>30000)
    ...:   ] # 最近连续2年GDP超过3万亿的地区
Out[49]: 
     地区     2020年     2019年    2018年    2017年    2016年
0   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
..  ...       ...       ...      ...      ...      ...
17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5

[13 rows x 6 columns]

我们还可以通过any和all对逻辑判断后结果进行再次判断，对于all来说需要都满足才行，对于any来说只需要满足一个即可，需要注意的是默认是0列方向，1是行方向

In [50]: df[(df[['2020年','2019年']]>30000).all(1)] # 最近连续2年GDP超过3万亿的地区
Out[50]: 
     地区     2020年     2019年    2018年    2017年    2016年
0   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
..  ...       ...       ...      ...      ...      ...
17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5

[13 rows x 6 columns]

In [51]: df[(df[['2020年','2019年']]>100000).all(1)] # 最近2年有1年GDP超过10万亿
Out[51]: 
     地区     2020年     2019年    2018年    2017年    2016年
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2

3.2. 函数筛选

函数筛选是指我们在不管是切片还是索引选择方式中，表达式还可以是lambda函数；此外，pandas也提供了一些比较函数可以用来进行数据筛选。

自定义lambda函数

df.loc[lambda x : x['2020年']>50000, ['地区','2020年','2019年']] # 筛选2020年GDP超过5万亿且只选 地区、2020年和2019年数据
Out[53]: 
     地区     2020年     2019年
9   江苏省  102719.0   98656.8
10  浙江省   64613.3   62462.0
14  山东省   73129.0   70540.5
15  河南省   54997.1   53717.8
18  广东省  110760.9  107986.9

In [54]: import re
    
In [55]: df.loc[:, lambda x : [i for i in df.columns[1:] if int(re.findall('\d+',i)[0])<2020]] # 筛选列名满足条件的列
Out[55]: 
      2019年    2018年    2017年    2016年
0   35445.1  33106.0  29883.0  27041.2
1   14055.5  13362.9  12450.6  11477.2
2   34978.6  32494.6  30640.8  28474.1
..      ...      ...      ...      ...
29   3748.5   3510.2   3200.3   2781.4
30  13597.1  12809.4  11159.9   9630.8
31      NaN      NaN      NaN      NaN

[32 rows x 4 columns]

比较函数

panda有一些比较函数，我们可以将逻辑表达式替换为比较函数形式

In [56]: df[df['地区'].eq('北京市')] # 等于
Out[56]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2

In [57]: df[df['地区'].ne('北京市')] # 不等于
Out[57]: 
          地区    2020年    2019年    2018年    2017年    2016年
1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
3        山西省  17651.9  16961.6  15958.1  14484.3  11946.4
..       ...      ...      ...      ...      ...      ...
29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
31       台湾省      NaN      NaN      NaN      NaN      NaN

[31 rows x 6 columns]

In [58]: df[df['2020年'].lt(10000)] # 小于
Out[58]: 
         地区   2020年   2019年   2018年   2017年   2016年
20      海南省  5532.4  5330.8  4910.7  4497.5  4090.2
25    西藏自治区  1902.7  1697.8  1548.4  1349.0  1173.0
27      甘肃省  9016.7  8718.3  8104.1  7336.7  6907.9
28      青海省  3005.9  2941.1  2748.0  2465.1  2258.2
29  宁夏回族自治区  3920.5  3748.5  3510.2  3200.3  2781.4

In [59]: df[df['2020年'].le(5532.4)] # 小于等于
Out[59]: 
         地区   2020年   2019年   2018年   2017年   2016年
20      海南省  5532.4  5330.8  4910.7  4497.5  4090.2
25    西藏自治区  1902.7  1697.8  1548.4  1349.0  1173.0
28      青海省  3005.9  2941.1  2748.0  2465.1  2258.2
29  宁夏回族自治区  3920.5  3748.5  3510.2  3200.3  2781.4

In [60]: df[df['2020年'].gt(50000)] # 大于
Out[60]: 
     地区     2020年     2019年    2018年    2017年    2016年
9   江苏省  102719.0   98656.8  93207.6  85869.8  77350.9
10  浙江省   64613.3   62462.0  58002.8  52403.1  47254.0
14  山东省   73129.0   70540.5  66648.9  63012.1  58762.5
15  河南省   54997.1   53717.8  49935.9  44824.9  40249.3
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2

In [61]: df[df['2020年'].ge(62462.0)] # 大于等于
Out[61]: 
     地区     2020年     2019年    2018年    2017年    2016年
9   江苏省  102719.0   98656.8  93207.6  85869.8  77350.9
10  浙江省   64613.3   62462.0  58002.8  52403.1  47254.0
14  山东省   73129.0   70540.5  66648.9  63012.1  58762.5
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2

对于isin()，还可以传入字典，key为列名，value为待匹配的值（这个大家可以构建数据试试）

3.3. query

Signature: df.query(expr: 'str', inplace: 'bool' = False, **kwargs)
Docstring:
Query the columns of a DataFrame with a boolean expression.

query()的很高校的查询方法，其表达式是一个字符串，我们在《》介绍过，大家可前往了解，这里稍微介绍下

在引号中，如果列名是数字开头或者含有空格，则需要用`反引号标识
其他情况下的列名直接写即可，用于筛选对比的对象如果是字符串则需要用引号
我们还可以通过@来引入变量

In [62]: df.query('地区=="北京市"') # 地区为北京市的数据
Out[62]: 
    地区    2020年    2019年    2018年    2017年    2016年
0  北京市  36102.6  35445.1  33106.0  29883.0  27041.2

In [63]: df.query('`2020年`<`2019年`') # 2020年GDP小于2019年GDP的数据
Out[63]: 
     地区    2020年    2019年    2018年    2017年    2016年
16  湖北省  43443.5  45429.0  42022.0  37235.0  33353.0

In [64]: mean_gdp = df['2020年'].mean()
        
In [64]: mean_gdp
Out[65]: 32658.55161290323

In [66]: df.query('`2020年` > @mean_gdp') # @ 引入变量
Out[66]: 
     地区     2020年     2019年    2018年    2017年    2016年
0   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
..  ...       ...       ...      ...      ...      ...
17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5

[13 rows x 6 columns]

3.4. filter

Signature:
df.filter(
    items=None,
    like: 'str | None' = None,
    regex: 'str | None' = None,
    axis=None,
) -> 'FrameOrSeries'
Docstring:
Subset the dataframe rows or columns according to the specified index labels.

Note that this routine does not filter a dataframe on its
contents. The filter is applied to the labels of the index.

df.filter()可以对行和列名进行筛选，支持模糊匹配和正则表达式

In [67]: df.filter(items=['2020年','2016年']) # 选择两列
Out[67]: 
      2020年    2016年
0   36102.6  27041.2
1   14083.7  11477.2
2   36206.9  28474.1
..      ...      ...
29   3920.5   2781.4
30  13797.6   9630.8
31      NaN      NaN

[32 rows x 2 columns]

In [68]: df.filter(regex='年') # 列名称含 年 的列
Out[68]: 
      2020年    2019年    2018年    2017年    2016年
0   36102.6  35445.1  33106.0  29883.0  27041.2
1   14083.7  14055.5  13362.9  12450.6  11477.2
2   36206.9  34978.6  32494.6  30640.8  28474.1
..      ...      ...      ...      ...      ...
29   3920.5   3748.5   3510.2   3200.3   2781.4
30  13797.6  13597.1  12809.4  11159.9   9630.8
31      NaN      NaN      NaN      NaN      NaN

[32 rows x 5 columns]

In [69]: df1.filter(regex='市', axis=0) # 索引名含 市 的数据
Out[69]: 
       2020年    2019年    2018年    2017年    2016年
地区                                              
北京市  36102.6  35445.1  33106.0  29883.0  27041.2
天津市  14083.7  14055.5  13362.9  12450.6  11477.2
上海市  38700.6  37987.6  36011.8  32925.0  29887.0
重庆市  25002.8  23605.8  21588.8  20066.3  18023.0

In [70]: df1.filter(regex='^江', axis=0) # 索引名中以江开头的
Out[70]: 
        2020年    2019年    2018年    2017年    2016年
地区                                               
江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
江西省   25691.5  24667.3  22716.5  20210.8  18388.6

In [71]: df1.filter(regex='自治区$', axis=0) # 索引名中以自治区结尾的
Out[71]: 
            2020年    2019年    2018年    2017年    2016年
地区                                                   
内蒙古自治区    17359.8  17212.5  16140.8  14898.1  13789.3
广西壮族自治区   22156.7  21237.1  19627.8  17790.7  16116.6
西藏自治区      1902.7   1697.8   1548.4   1349.0   1173.0
宁夏回族自治区    3920.5   3748.5   3510.2   3200.3   2781.4
新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8

In [72]: df1.filter(like='北',axis=0) # 索引名中有 北 的
Out[72]: 
       2020年    2019年    2018年    2017年    2016年
地区                                              
北京市  36102.6  35445.1  33106.0  29883.0  27041.2
河北省  36206.9  34978.6  32494.6  30640.8  28474.1
湖北省  43443.5  45429.0  42022.0  37235.0  33353.0

以上就是本次全部内容，希望对你有所帮助，如果你喜欢的话还希望能给个在看、点个赞呀！

加油~

你可能感兴趣的:(pandas,python,数据库)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【PG】常见数据库、表属性设置江无羡数据库
PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
PHP如何实现二维数组排序？ IT独行者二维数组 PHP 排序　
二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数：代码： functionarray_sort($arr,$keys,$type='asc'){ $keysvalue= $new_arr
【Hadoop十七】HDFS HA配置 bit1129 hadoop
基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。测试环境有三台 hadoop.master hadoop.slave1 hadoop.slave2 hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
由wsdl生成的java vo类不适合做普通java vo darrenzhu VO wsdl webservice rpc
开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下： 1)使用了集合如Li
JAVA海量数据处理之二（BitMap）周凡杨 java 算法 bitmap bitset 数据
路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？啊哈！算法。这里采用了 BitMap 思想。首先来看一个实验：指定 VM 参数大小： -Xms256m -Xmx540m
java类型与数据库类型 g21121 java
很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。 &nb
Linux命令 510888780 linux命令
系统信息 arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI) hdparm -i /dev/hda 罗列一个磁盘的架构特性 hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示C
java常用JVM参数墙头上一根草 java jvm参数
-Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制 -Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制 -Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点 aijuans Spring 3
方法一： <bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory" factory-method="createMusicBoxStatic"></bean> 方法二：
mysql查询性能优化之二 annan211 UNION mysql 查询优化索引优化
1 union的限制有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层查询的优化上。如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在合并结果集的话，就需要在union的各个子句中分别使用这些子句。例如想将两个子查询结果联合起来，然后再取前20条记录，那么mys
数据的备份与恢复百合不是茶 oracle sql 数据恢复数据备份
数据的备份与恢复的方式有: 表,方案 ,数据库; 数据的备份: 导出到的常见命令; 参数说明 USERID 确定执行导出实用程序的用户名和口令 BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示 FILE 指定导出的二进制文
线程组 bijian1013 java 多线程 thread java多线程线程组
有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。线程组可以用来同时对一组线程进行操作。创建线程组：ThreadGroup g = new ThreadGroup(groupName); &nbs
top命令找到占用CPU最高的java线程 bijian1013 java linux top
上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程 top -Hp 28174 -d 1 -n 1 32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java
【持久化框架MyBatis3四】MyBatis3一对一关联查询 bit1129 Mybatis3
当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询 One-To-One示例数据以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的学生表 CREATE TABLE STUDENTS (
C/C++图片或文件的读写 bitcarter 写图片
先看代码： /*strTmpResult是文件或图片字符串 * filePath文件需要写入的地址或路径 */ int writeFile(std::string &strTmpResult,std::string &filePath) { int i,len = strTmpResult.length(); unsigned cha
nginx自定义指定加载配置 ronin47
进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码： upstream nodejs { server 127.0.0.1:3000; #server 127.0.0.1:3001; keepalive 64; } server { liste
java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方 bylijinnan double
public class Power { /** *Q71-数值的整数次方 *实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。 */ private static boolean InvalidInput=false; public static void main(
Android四大组件的理解 Cb123456 android 四大组件的理解
分享一下，今天在Android开发文档-开发者指南中看到的: App components are the essential building blocks of an Android
[宇宙与计算]涡旋场计算与拓扑分析 comsci 计算
怎么阐述我这个理论呢？。。。。。。。。。首先：宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
同一个Tomcat不同Web应用之间共享会话Session cwqcwqmax9 session
实现两个WEB之间通过session 共享数据查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下： If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
springmvc Spring3 MVC，ajax，乱码 dashuaifu spring jquery mvc Ajax
springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决 Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
搭建WAMP环境 dcj3sjt126com wamp
这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
yii2 使用raw http request dcj3sjt126com http
Parses a raw HTTP request using yii\helpers\Json::decode() To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class: 'request' =&g
Quartz-1.8.6 理论部分 eksliang quartz
转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建；什么是quartz? 答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
什么是POJO？ gupeng_ie java POJO 框架 Hibernate
POJO--Plain Old Java Objects(简单的java对象) POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。 POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
jQuery网站顶部定时折叠广告 ini JavaScript html jquery Web css
效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>网页顶部定时收起广告jQuery特效 - HoverTree<
Spring boot内嵌的tomcat启动失败 kane_xie spring boot
根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误： SEVERE: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catalina.Lif
leetcode: sort list michelle_0916 Algorithm linked list sort
Sort a linked list in O(n log n) time using constant space complexity. ====analysis======= mergeSort for singly-linked list ====code======= /** * Definition for sin
nginx的安装与配置,中途遇到问题的解决 qifeifei nginx
我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装 wget http://nginx.org/download/nginx-1.0.11.tar.gz tar zxvf nginx-1.0.11.tar.gz ./configure make make install 安装的时候出现
用枚举来处理java自定义异常 tcrct java enum exception
在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。 1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage public
erlang supervisor分析 wudixiaotie erlang
当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那