Pandas学习——Pandas基础

文件的读取和写入

文件读取

df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv') # 可以写相对路径也可以写绝对路径
df_csv

	col1	col2	col3	col4	col5
0	2	a	1.4	apple	2020/1/1
1	3	b	3.4	banana	2020/1/2
2	6	c	2.5	orange	2020/1/5
3	5	d	3.2	lemon	2020/1/7

df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table.txt')
df_txt

	col1	col2	col3	col4
0	2	a	1.4	apple 2020/1/1
1	3	b	3.4	banana 2020/1/2
2	6	c	2.5	orange 2020/1/5
3	5	d	3.2	lemon 2020/1/7

df_excel = pd.read_excel('G:\代码\joyful-pandas-master\data\my_excel.xlsx')
df_excel

	col1	col2	col3	col4	col5
0	2	a	1.4	apple	2020/1/1
1	3	b	3.4	banana	2020/1/2
2	6	c	2.5	orange	2020/1/5
3	5	d	3.2	lemon	2020/1/7

header=None 表示第一行不作为列名
index_col 表示把某一列或几列作为索引
usecols 表示读取列的集合，默认读取所有的列
parse_dates 表示需要转化为时间的列
nrows 表示读取的数据行数

df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', header=None) 
df_csv

	0	1	2	3	4
0	col1	col2	col3	col4	col5
1	2	a	1.4	apple	2020/1/1
2	3	b	3.4	banana	2020/1/2
3	6	c	2.5	orange	2020/1/5
4	5	d	3.2	lemon	2020/1/7

df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', index_col=['col1', 'col2'])
df_csv

		col3	col4	col5
col1	col2
2	a	1.4	apple	2020/1/1
3	b	3.4	banana	2020/1/2
6	c	2.5	orange	2020/1/5
5	d	3.2	lemon	2020/1/7

df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table.txt', usecols=['col1', 'col2'])
df_txt

	col1	col2
0	2	a
1	3	b
2	6	c
3	5	d

df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', parse_dates=['col5'])
type(df_csv['col5'])

pandas.core.series.Series

df_excel = pd.read_excel('G:\代码\joyful-pandas-master\data\my_excel.xlsx', nrows=2) # 只读两行
df_excel

	col1	col2	col3	col4	col5
0	2	a	1.4	apple	2020/1/1
1	3	b	3.4	banana	2020/1/2

在读取 txt 文件时，经常遇到分隔符非空格的情况，read_table 有一个分割参数 sep ，它使得用户可以自定义分割符号，进行 txt 数据的读取。例如，下面的读取的表以 |||| 为分割：

df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table_special_sep.txt')
df_txt

	col1 \|\|\|\| col2
0	TS \|\|\|\| This is an apple.
1	GQ \|\|\|\| My name is Bob.
2	WT \|\|\|\| Well done!
3	PT \|\|\|\| May I help you?

这时可以使用 sep ，同时需要指定引擎为 python
注：参数 sep 中使用的是正则表达式，因此需要对 | 进行转义变成 | ，否则无法读取到正确的结果

df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table_special_sep.txt',
              sep=' \|\|\|\| ', engine='python')
df_txt

	col1	col2
0	TS	This is an apple.
1	GQ	My name is Bob.
2	WT	Well done!
3	PT	May I help you?

数据写入

一般在数据写入的时候，最常用的操作是把 index 设置为 False ，特别当索引没有特殊意义的时候，这样可以在保存文件的时候不保存索引

df_csv.to_csv('G:\代码\joyful-pandas-master\data\my_csv_saved.csv', index=False)

pandas 中没有定义 to_table 函数，但是 to_csv 可以保存为 txt 文件，并且允许自定义分隔符，常用制表符 \t 分割：

df_txt.to_csv('G:\代码\joyful-pandas-master\data\my_txt_saved.txt', sep='\t', index=False)

如果想要把表格快速转换为 markdown 和 latex 语言，可以使用 to_markdown 和 to_latex 函数，需要安装 tabulate 包

print(df_csv.to_markdown())

|    |   col1 | col2   |   col3 | col4   | col5                |
|---:|-------:|:-------|-------:|:-------|:--------------------|
|  0 |      2 | a      |    1.4 | apple  | 2020-01-01 00:00:00 |
|  1 |      3 | b      |    3.4 | banana | 2020-01-02 00:00:00 |
|  2 |      6 | c      |    2.5 | orange | 2020-01-05 00:00:00 |
|  3 |      5 | d      |    3.2 | lemon  | 2020-01-07 00:00:00 |

print(df_csv.to_latex())

\begin{tabular}{lrlrll}
\toprule
{} &  col1 & col2 &  col3 &    col4 &       col5 \\
\midrule
0 &     2 &    a &   1.4 &   apple & 2020-01-01 \\
1 &     3 &    b &   3.4 &  banana & 2020-01-02 \\
2 &     6 &    c &   2.5 &  orange & 2020-01-05 \\
3 &     5 &    d &   3.2 &   lemon & 2020-01-07 \\
\bottomrule
\end{tabular}

基本数据结构

pandas 中具有两种基本的数据存储结构，存储一维 values 的 Series 和存储二维 values 的 DataFrame ，在这两种结构上定义了很多的属性和方法。

Series

Series 一般由四个部分组成，分别是序列的值 data 、索引 index 、存储类型 dtype 、序列的名字 name。其中，索引也可以指定它的名字，默认为空。

s = pd.Series(data = [100, 'a', {'dic1':5}],
              index = pd.Index(['id1', 20, 'third'], name='my_idx'),
              dtype = 'object',
              name = 'my_name')
s

my_idx
id1              100
20                 a
third    {'dic1': 5}
Name: my_name, dtype: object

对于这些属性，可以通过 . 的方式来获取：

print('s.values:',s.values)
print('s.index：',s.index)
print('s.dtype：',s.dtype)
print('s.name：',s.name)

s.values: [100 'a' {'dic1': 5}]
s.index： Index(['id1', 20, 'third'], dtype='object', name='my_idx')
s.dtype： object
s.name： my_name

利用 .shape 可以获取序列的长度：

s.shape

(3,)

如果想要取出单个索引对应的值，可以通过 [index_item] 可以取出：

s['third']

{'dic1': 5}

DataFrame

DataFrame 在 Series 的基础上增加了列索引，一个数据框可以由二维的 data 与行列索引来构造：

data = [[1, 'a', 1.2], [2, 'b', 2.2], [3, 'c', 3.2]]
df = pd.DataFrame(data = data,
                  index = ['row_%d'%i for i in range(3)],
                  columns=['col_0', 'col_1', 'col_2'])
df

	col_0	col_1	col_2
row_0	1	a	1.2
row_1	2	b	2.2
row_2	3	c	3.2

但一般而言，更多的时候会采用从列索引名到数据的映射来构造数据框，同时再加上行索引：

df = pd.DataFrame(data = {'col_0': [1,2,3], 'col_1':list('abc'),
                          'col_2': [1.2, 2.2, 3.2]},
                  index = ['row_%d'%i for i in range(3)])
df

	col_0	col_1	col_2
row_0	1	a	1.2
row_1	2	b	2.2
row_2	3	c	3.2

由于这种映射关系，在 DataFrame 中可以用 [col_name] 与 [col_list] 来取出相应的列与由多个列组成的表，结果分别为 Series 和 DataFrame ：

print(df['col_0'])
print(type(df['col_0']))
print('\n')
print(df[['col_0', 'col_1']])
print(type(df[['col_0', 'col_1']]))

row_0    1
row_1    2
row_2    3
Name: col_0, dtype: int64



       col_0 col_1
row_0      1     a
row_1      2     b
row_2      3     c

与 Series 类似，在数据框中同样可以取出相应的属性：

print('df.values:')
print(df.values)
print('\n')
print('df.index:')
print(df.index)
print('\n')
print('df.columns:')
print(df.columns)
print('\n')
print('df.dtypes:')
print(df.dtypes)
print('\n')
print('df.shape:')
print(df.shape)

df.values:
[[1 'a' 1.2]
 [2 'b' 2.2]
 [3 'c' 3.2]]


df.index:
Index(['row_0', 'row_1', 'row_2'], dtype='object')


df.columns:
Index(['col_0', 'col_1', 'col_2'], dtype='object')


df.dtypes:
col_0      int64
col_1     object
col_2    float64
dtype: object


df.shape:
(3, 3)

通过 .T 可以把 DataFrame 进行转置：

df.T

	row_0	row_1	row_2
col_0	1	2	3
col_1	a	b	c
col_2	1.2	2.2	3.2

常用基本函数

以如下四所学校学生的体测信息为例进行分析：

df = pd.read_csv('G:\代码\joyful-pandas-master\data\learn_pandas.csv')
df

	School	Grade	Name	Gender	Height	Weight	Transfer	Test_Number	Test_Date	Time_Record
0	Shanghai Jiao Tong University	Freshman	Gaopeng Yang	Female	158.9	46.0	N	1	2019/10/5	0:04:34
1	Peking University	Freshman	Changqiang You	Male	166.5	70.0	N	1	2019/9/4	0:04:20
2	Shanghai Jiao Tong University	Senior	Mei Sun	Male	188.9	89.0	N	2	2019/9/12	0:05:22
3	Fudan University	Sophomore	Xiaojuan Sun	Female	NaN	41.0	N	2	2020/1/3	0:04:08
4	Fudan University	Sophomore	Gaojuan You	Male	174.0	74.0	N	2	2019/11/6	0:05:22
...	...	...	...	...	...	...	...	...	...	...
195	Fudan University	Junior	Xiaojuan Sun	Female	153.9	46.0	N	2	2019/10/17	0:04:31
196	Tsinghua University	Senior	Li Zhao	Female	160.9	50.0	N	3	2019/9/22	0:04:03
197	Shanghai Jiao Tong University	Senior	Chengqiang Chu	Female	153.9	45.0	N	1	2020/1/5	0:04:48
198	Shanghai Jiao Tong University	Senior	Chengmei Shen	Male	175.3	71.0	N	2	2020/1/7	0:04:58
199	Tsinghua University	Sophomore	Chunpeng Lv	Male	155.7	51.0	N	1	2019/11/6	0:05:05

200 rows × 10 columns

df.columns

Index(['School', 'Grade', 'Name', 'Gender', 'Height', 'Weight', 'Transfer',
       'Test_Number', 'Test_Date', 'Time_Record'],
      dtype='object')

df = df[df.columns[:7]]

汇总函数

head, tail 函数分别表示返回表或者序列的前 n 行和后 n 行，其中 n 默认为5：

df.head(2)

	School	Grade	Name	Gender	Height	Weight	Transfer	Test_Number	Test_Date	Time_Record
0	Shanghai Jiao Tong University	Freshman	Gaopeng Yang	Female	158.9	46.0	N	1	2019/10/5	0:04:34
1	Peking University	Freshman	Changqiang You	Male	166.5	70.0	N	1	2019/9/4	0:04:20

df.tail(3)

	School	Grade	Name	Gender	Height	Weight	Transfer	Test_Number	Test_Date	Time_Record
197	Shanghai Jiao Tong University	Senior	Chengqiang Chu	Female	153.9	45.0	N	1	2020/1/5	0:04:48
198	Shanghai Jiao Tong University	Senior	Chengmei Shen	Male	175.3	71.0	N	2	2020/1/7	0:04:58
199	Tsinghua University	Sophomore	Chunpeng Lv	Male	155.7	51.0	N	1	2019/11/6	0:05:05

info, describe 分别返回表的信息概况和表中数值列对应的主要统计量：

df.info()


RangeIndex: 200 entries, 0 to 199
Data columns (total 10 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   School       200 non-null    object 
 1   Grade        200 non-null    object 
 2   Name         200 non-null    object 
 3   Gender       200 non-null    object 
 4   Height       183 non-null    float64
 5   Weight       189 non-null    float64
 6   Transfer     188 non-null    object 
 7   Test_Number  200 non-null    int64  
 8   Test_Date    200 non-null    object 
 9   Time_Record  200 non-null    object 
dtypes: float64(2), int64(1), object(7)
memory usage: 15.8+ KB

df.describe()

	Height	Weight	Test_Number
count	183.000000	189.000000	200.000000
mean	163.218033	55.015873	1.645000
std	8.608879	12.824294	0.722207
min	145.400000	34.000000	1.000000
25%	157.150000	46.000000	1.000000
50%	161.900000	51.000000	1.500000
75%	167.500000	65.000000	2.000000
max	193.900000	89.000000	3.000000

特征统计函数

在 Series 和 DataFrame 上定义了许多统计函数，最常见的是 sum, mean, median, var, std, max, min。

df_demo = df[['Height', 'Weight']]
df_demo.mean()

Height    163.218033
Weight     55.015873
dtype: float64

quantile, count, idxmax 三个函数，它们分别返回的是分位数、非缺失值个数、最大值对应的索引：

df_demo.quantile(0.75)

Height    167.5
Weight     65.0
Name: 0.75, dtype: float64

df_demo.count()

Height    183
Weight    189
dtype: int64

df_demo.idxmax()

Height    193
Weight      2
dtype: int64

上面这些所有的函数，由于操作后返回的是标量，所以又称为聚合函数，它们有一个公共参数 axis ，默认为0代表逐列聚合，如果设置为1则表示逐行聚合：

df_demo.mean(axis=1).head() # 表示按行求身高和体重的均值

0    102.45
1    118.25
2    138.95
3     41.00
4    124.00
dtype: float64

唯一值函数

对序列使用 unique 和 nunique 可以分别得到其唯一值组成的列表和唯一值的个数：

print(df['School'].unique())
print(df['School'].nunique())

['Shanghai Jiao Tong University' 'Peking University' 'Fudan University'
 'Tsinghua University']
4

value_counts 可以得到唯一值和其对应出现的频数：

df['School'].value_counts()

Tsinghua University              69
Shanghai Jiao Tong University    57
Fudan University                 40
Peking University                34
Name: School, dtype: int64

如果想要观察多个列组合的唯一值，可以使用 drop_duplicates。其中的关键参数是 keep，默认值 first 表示每个组合保留第一次出现的所在行， last 表示保留最后一次出现的所在行， False 表示把所有重复组合所在的行剔除。

df_demo = df[['Gender','Transfer','Name']]
df_demo.drop_duplicates(['Gender', 'Transfer'])

	Gender	Transfer	Name
0	Female	N	Gaopeng Yang
1	Male	N	Changqiang You
12	Female	NaN	Peng You
21	Male	NaN	Xiaopeng Shen
36	Male	Y	Xiaojuan Qin
43	Female	Y	Gaoli Feng

df_demo.drop_duplicates(['Gender', 'Transfer'], keep='last')

	Gender	Transfer	Name
147	Male	NaN	Juan You
150	Male	Y	Chengpeng You
169	Female	Y	Chengquan Qin
194	Female	NaN	Yanmei Qian
197	Female	N	Chengqiang Chu
199	Male	N	Chunpeng Lv

df_demo.drop_duplicates(['Name', 'Gender'],keep=False).head() # 保留只出现过一次的性别和姓名组合

	Gender	Transfer	Name
0	Female	N	Gaopeng Yang
1	Male	N	Changqiang You
2	Male	N	Mei Sun
4	Male	N	Gaojuan You
5	Female	N	Xiaoli Qian

df['School'].drop_duplicates()

0    Shanghai Jiao Tong University
1                Peking University
3                 Fudan University
5              Tsinghua University
Name: School, dtype: object

此外， duplicated 和 drop_duplicates 的功能类似，但前者返回了是否为唯一值的布尔列表，其 keep 参数与后者一致。其返回的序列，把重复元素设为 True ，否则为 False 。 drop_duplicates 等价于把 duplicated 为 True 的对应行剔除。

print(df_demo.head())
print('\n')
print(df_demo.duplicated(['Gender', 'Transfer']).head())

   Gender Transfer            Name
0  Female        N    Gaopeng Yang
1    Male        N  Changqiang You
2    Male        N         Mei Sun
3  Female        N    Xiaojuan Sun
4    Male        N     Gaojuan You


0    False
1    False
2     True
3     True
4     True
dtype: bool

print(df['School'].head())
print('\n')
print(df['School'].duplicated().head())

0    Shanghai Jiao Tong University
1                Peking University
2    Shanghai Jiao Tong University
3                 Fudan University
4                 Fudan University
Name: School, dtype: object


0    False
1    False
2     True
3    False
4     True
Name: School, dtype: bool

替换函数

一般而言，替换操作是针对某一个列进行的，因此下面的例子都以 Series 举例。pandas 中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换。

在 replace 中，可以通过字典构造，或者传入两个列表来进行替换：

 df['Gender'].replace({'Female':0, 'Male':1}).head()

0    0
1    1
2    1
3    0
4    1
Name: Gender, dtype: int64

df['Gender'].replace(['Female', 'Male'], [0, 1]).head()

0    0
1    1
2    1
3    0
4    1
Name: Gender, dtype: int64

另外， replace 还有一种特殊的方向替换，指定 method 参数为 ffill 则为用前面一个最近的未被替换的值进行替换， bfill 则使用后面最近的未被替换的值进行替换。从下面的例子可以看到，它们的结果是不同的：

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s

0    a
1    1
2    b
3    2
4    1
5    1
6    a
dtype: object

s.replace([1, 2], method='bfill')

0    a
1    b
2    b
3    a
4    a
5    a
6    a
dtype: object

s.replace([1, 2], method='ffill')

0    a
1    a
2    b
3    b
4    b
5    b
6    a
dtype: object

逻辑替换包括了 where 和 mask ，这两个函数是完全对称的： where 函数在传入条件为 False 的对应行进行替换，而 mask 在传入条件为 True 的对应行进行替换，当不指定替换值时，替换为缺失值。

s = pd.Series([-1, 1.2345, 100, -50])
s

0     -1.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64

s.where(s<0)

0    -1.0
1     NaN
2     NaN
3   -50.0
dtype: float64

s.mask(s<0)

0         NaN
1      1.2345
2    100.0000
3         NaN
dtype: float64

s.mask(s<0, -50) # 指定替换值为 -50

0    -50.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64

需要注意的是，传入的条件只需是与被调用的 Series 索引一致的布尔序列即可：

s_condition= pd.Series([True,False,False,True],index=s.index)
s_condition

0     True
1    False
2    False
3     True
dtype: bool

s.mask(s_condition, -50)

0    -50.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64

数值替换包含了 round, abs, clip 方法，它们分别表示取整、取绝对值和截断：

s = pd.Series([-1, 1.2345, 100, -50])
print(s)
print('\n')
print(s.round(2))
print('\n')
print(s.abs())
print('\n')
print(s.clip(0, 2)) # 前两个数分别表示上下截断边界，如果超过边界就替换为该值

0     -1.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64


0     -1.00
1      1.23
2    100.00
3    -50.00
dtype: float64


0      1.0000
1      1.2345
2    100.0000
3     50.0000
dtype: float64


0    0.0000
1    1.2345
2    2.0000
3    0.0000
dtype: float64

Question：cilp 超过边界的只能截断为边界值，如果要把超出边界的替换为自定义的值，应当如何做？

s.mask((s<0)|(s>2),-50)

0   -50.0000
1     1.2345
2   -50.0000
3   -50.0000
dtype: float64

排序函数

排序共有两种方式，其一为值排序，其二为索引排序，对应的函数是 sort_values 和 sort_index。

df_demo = df[['Grade', 'Name', 'Height','Weight']].set_index(['Grade','Name']) # 把年级和姓名两列作为索引
df_demo.head()

		Height	Weight
Grade	Name
Freshman	Gaopeng Yang	158.9	46.0
Freshman	Changqiang You	166.5	70.0
Senior	Mei Sun	188.9	89.0
Sophomore	Xiaojuan Sun	NaN	41.0
Sophomore	Gaojuan You	174.0	74.0

对身高进行排序，默认参数 ascending=True 为升序：

df_demo.sort_values('Height').head()

		Height	Weight
Grade	Name
Junior	Xiaoli Chu	145.4	34.0
Senior	Gaomei Lv	147.3	34.0
Sophomore	Peng Han	147.8	34.0
Senior	Changli Lv	148.7	41.0
Sophomore	Changjuan You	150.5	40.0

df_demo.sort_values('Height', ascending=False).head()

		Height	Weight
Grade	Name
Senior	Xiaoqiang Qin	193.9	79.0
	Mei Sun	188.9	89.0
	Gaoli Zhao	186.5	83.0
Freshman	Qiang Han	185.3	87.0
Senior	Qiang Zheng	183.9	87.0

在排序中，经常遇到多列排序的问题，比如在体重相同的情况下，对身高进行排序，并且保持身高降序排列，体重升序排列：

df_demo.sort_values(['Weight','Height'],ascending=[True,False]).head()

		Height	Weight
Grade	Name
Sophomore	Peng Han	147.8	34.0
Senior	Gaomei Lv	147.3	34.0
Junior	Xiaoli Chu	145.4	34.0
Sophomore	Qiang Zhou	150.5	36.0
Freshman	Yanqiang Xu	152.4	38.0

索引排序的用法和值排序完全一致，只不过元素的值在索引中，此时需要指定索引层的名字或者层号，用参数 level 表示。另外，需要注意的是字符串的排列顺序由字母顺序决定。

df_demo.sort_index(level=['Grade','Name'],ascending=[True,False]).head()

		Height	Weight
Grade	Name
Freshman	Yanquan Wang	163.5	55.0
	Yanqiang Xu	152.4	38.0
	Yanqiang Feng	162.3	51.0
	Yanpeng Lv	NaN	65.0
	Yanli Zhang	165.1	52.0

apply方法

apply 方法常用于 DataFrame 的行迭代或者列迭代，它的 axis 含义与统计聚合函数一致， apply 的参数往往是一个以序列为输入的函数。例如对于 .mean() ，使用 apply 可以如下地写出：

df_demo = df[['Height', 'Weight']]

def my_mean(x):
    res = x.mean()
    return res

df_demo.apply(my_mean)

Height    163.218033
Weight     55.015873
dtype: float64

同样的，可以利用 lambda 表达式使得书写简洁，这里的 x 就指代被调用的 df_demo 表中逐个输入的序列：

df_demo.apply(lambda x:x.mean())

Height    163.218033
Weight     55.015873
dtype: float64

若指定 axis=1 ，那么每次传入函数的就是行元素组成的 Series ，其结果与之前的逐行均值结果一致。

df_demo.apply(lambda x:x.mean(), axis=1).head()

0    102.45
1    118.25
2    138.95
3     41.00
4    124.00
dtype: float64

另一个例子：mad 函数返回的是一个序列中偏离该序列均值的绝对值大小的均值，例如序列1,3,7,10中，均值为5.25，每一个元素偏离的绝对值为4.25,2.25,1.75,4.75，这个偏离序列的均值为3.25。现在利用 apply 计算升高和体重的 mad 指标：

df_demo.apply(lambda x:(x-x.mean()).abs().mean())

Height     6.707229
Weight    10.391870
dtype: float64

这与使用内置的 mad 函数计算结果一致：

df_demo.mad()

Height     6.707229
Weight    10.391870
dtype: float64

窗口对象

pandas 中有3类窗口，分别是滑动窗口 rolling 、扩张窗口 expanding 以及指数加权窗口 ewm

滑窗对象

要使用滑窗函数，就必须先要对一个序列使用 .rolling 得到滑窗对象，其最重要的参数为窗口大小 window。

s = pd.Series([1,2,3,4,5])
roller = s.rolling(window = 3)
roller

Rolling [window=3,center=False,axis=0]

在得到了滑窗对象后，能够使用相应的聚合函数进行计算，需要注意的是窗口包含当前行所在的元素，例如在第四个位置进行均值运算时，应当计算(2+3+4)/3，而不是(1+2+3)/3：

roller.mean()

0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64

roller.sum()

0     NaN
1     NaN
2     6.0
3     9.0
4    12.0
dtype: float64

对于滑动相关系数或滑动协方差的计算，可以如下写出：

s2 = pd.Series([1,2,6,16,30])
roller.cov(s2)

0     NaN
1     NaN
2     2.5
3     7.0
4    12.0
dtype: float64

roller.corr(s2)

0         NaN
1         NaN
2    0.944911
3    0.970725
4    0.995402
dtype: float64

此外，还支持使用 apply 传入自定义函数，其传入值是对应窗口的 Series ，例如上述的均值函数可以等效表示：

roller.apply(lambda x:x.mean())

0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64

shift, diff, pct_change 是一组类滑窗函数，它们的公共参数为 periods=n ，默认为1，分别表示取向前第 n 个元素的值、与向前第 n 个元素做差（与 Numpy 中不同，后者表示 n 阶差分）、与向前第 n 个元素相比计算增长率。这里的 n 可以为负，表示反方向的类似操作。

s = pd.Series([1,3,6,10,15])

s.shift(2)

0    NaN
1    NaN
2    1.0
3    3.0
4    6.0
dtype: float64

s.diff(3)

0     NaN
1     NaN
2     NaN
3     9.0
4    12.0
dtype: float64

s.pct_change()

0         NaN
1    2.000000
2    1.000000
3    0.666667
4    0.500000
dtype: float64

s.shift(-1)

0     3.0
1     6.0
2    10.0
3    15.0
4     NaN
dtype: float64

s.diff(-2)

0   -5.0
1   -7.0
2   -9.0
3    NaN
4    NaN
dtype: float64

将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为 n+1 的 rolling 方法等价代替：

s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)

0    NaN
1    NaN
2    1.0
3    3.0
4    6.0
dtype: float64

s.rolling(4).apply(lambda x:list(x)[-1]-list(x)[0]) # s.diff(3)

0     NaN
1     NaN
2     NaN
3     9.0
4    12.0
dtype: float64

def my_pct(x):
    L = list(x)
    return L[-1]/L[0]-1

s.rolling(2).apply(my_pct) # s.pct_change()

0         NaN
1    2.000000
2    1.000000
3    0.666667
4    0.500000
dtype: float64

Question：rolling 对象的默认窗口方向都是向前的，某些情况下用户需要向后的窗口，例如对1,2,3设定向后窗口为2的 sum 操作，结果为3,5,NaN，此时应该如何实现向后的滑窗操作？（提示：使用 shift ）

s = pd.Series([1,2,3])
s+s.shift(-1)

0    3.0
1    5.0
2    NaN
dtype: float64

扩张窗口

扩张窗口又称累计窗口，可以理解为一个动态长度的窗口，其窗口的大小就是从序列开始处到具体操作的对应位置，其使用的聚合函数会作用于这些逐步扩张的窗口上。具体地说，设序列为a1, a2, a3, a4，则其每个位置对应的窗口即[a1]、[a1, a2]、[a1, a2, a3]、[a1, a2, a3, a4]。

s = pd.Series([1, 3, 6, 10])
s.expanding().mean()

0    1.000000
1    2.000000
2    3.333333
3    5.000000
dtype: float64

Question：cummax, cumsum, cumprod 函数是典型的类扩张窗口函数，请使用 expanding 对象依次实现它们。

s = pd.Series([1, 3, 6, 10])
s.expanding().max() # s.cummax()

0     1.0
1     3.0
2     6.0
3    10.0
dtype: float64

s.expanding().sum() # s.cumsum()

0     1.0
1     4.0
2    10.0
3    20.0
dtype: float64

s.expanding().apply(lambda x:x.prod()) # s.cumprod()

0      1.0
1      3.0
2     18.0
3    180.0
dtype: float64

练习

口袋妖怪数据集

现有一份口袋妖怪的数据集，下面进行一些背景说明：

# 代表全国图鉴编号，不同行存在相同数字则表示为该妖怪的不同状态
妖怪具有单属性和双属性两种，对于单属性的妖怪， Type 2 为缺失值
Total, HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 分别代表种族值、体力、物攻、防御、特攻、特防、速度，其中种族值为后6项之和

df = pd.read_csv('G:\代码\joyful-pandas-master\data\pokemon.csv')
df.head()

	#	Name	Type 1	Type 2	Total	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed
0	1	Bulbasaur	Grass	Poison	318	45	49	49	65	65	45
1	2	Ivysaur	Grass	Poison	405	60	62	63	80	80	60
2	3	Venusaur	Grass	Poison	525	80	82	83	100	100	80
3	3	VenusaurMega Venusaur	Grass	Poison	625	80	100	123	122	120	80
4	4	Charmander	Fire	NaN	309	39	52	43	60	50	65

对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值
对于 # 重复的妖怪只保留第一条记录，解决以下问题：

a. 求第一属性的种类数量和前三多数量对应的种类

b. 求第一属性和第二属性的组合种类

c. 求尚未出现过的属性组合
按照下述要求，构造 Series ：

a. 取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid

b. 取出第一属性，分别用 replace 和 apply 替换所有字母为大写

c. 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序

# 1. 对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值
df[['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed']].sum(axis=1).head()-df['Total'].head()

0    0
1    0
2    0
3    0
4    0
dtype: int64

# 2. 对于 # 重复的妖怪只保留第一条记录
df_uni = df.drop_duplicates(['#'])
print(df['#'].count())
print(df_uni['#'].count())

800
721

# 2.a 求第一属性的种类数量和前三多数量对应的种类
print('第一属性的种类数量：')
print(df_uni['Type 1'].nunique())
print('前三多数量对应的种类：')
print(df_uni['Type 1'].value_counts()[0:3])

第一属性的种类数量：
18
前三多数量对应的种类：
Water     105
Normal     93
Grass      66
Name: Type 1, dtype: int64

# 2.b 求第一属性和第二属性的组合种类
print(df_uni[['Type 1', 'Type 2']].drop_duplicates(['Type 1', 'Type 2']).head())
print('\n')
print(df_uni[['Type 1', 'Type 2']].drop_duplicates(['Type 1', 'Type 2']).shape[0])

   Type 1  Type 2
0   Grass  Poison
4    Fire     NaN
6    Fire  Flying
9   Water     NaN
13    Bug     NaN


143

# 2.c 求尚未出现过的属性组合
L_full = [i+' '+j for i in df['Type 1'].unique() for j in (df['Type 1'].unique().tolist() + [''])] # 所有组合
L_part = [i+' '+j for i, j in zip(df['Type 1'], df['Type 2'].replace(np.nan, ''))] # 出现过的属性组合
res = set(L_full).difference(set(L_part))
len(res)

# 3.a 取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
df['Attack'].mask(df['Attack']>120, 'high').mask(df['Attack']<50, 'low').mask((50<=df['Attack'])&(df['Attack']<=120), 'mid').head()

0    low
1    mid
2    mid
3    mid
4    mid
Name: Attack, dtype: object

# 3.b 取出第一属性，分别用 replace 和 apply 替换所有字母为大写
print(df['Type 1'].replace({i:str.upper(i) for i in df['Type 1'].unique()}).head()) # replace
# {i:str.upper(i) for i in df['Type 1'].unique()} 相当于用来替换的字典
print('\n')
print(df['Type 1'].apply(lambda x:str.upper(x)).head()) # apply

0    GRASS
1    GRASS
2    GRASS
3    GRASS
4     FIRE
Name: Type 1, dtype: object


0    GRASS
1    GRASS
2    GRASS
3    GRASS
4     FIRE
Name: Type 1, dtype: object

# 3.c 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
df['Deviation'] = df[['HP', 'Attack', 'Defense', 'Sp. Atk','Sp. Def', 'Speed']].apply(lambda x:np.max((x-x.median()).abs()), 1)
df.sort_values('Deviation', ascending=False).head()

	#	Name	Type 1	Type 2	Total	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed	Deviation
230	213	Shuckle	Bug	Rock	505	20	10	230	10	230	5	215.0
121	113	Chansey	Normal	NaN	450	250	5	5	35	105	50	207.5
261	242	Blissey	Normal	NaN	540	255	10	10	75	135	55	190.0
333	306	AggronMega Aggron	Steel	NaN	630	70	140	230	60	80	50	155.0
224	208	SteelixMega Steelix	Steel	Ground	610	75	125	230	55	95	30	145.0

{i:str.upper(i) for i in df['Type 1'].unique()}

{'Grass': 'GRASS',
 'Fire': 'FIRE',
 'Water': 'WATER',
 'Bug': 'BUG',
 'Normal': 'NORMAL',
 'Poison': 'POISON',
 'Electric': 'ELECTRIC',
 'Ground': 'GROUND',
 'Fairy': 'FAIRY',
 'Fighting': 'FIGHTING',
 'Psychic': 'PSYCHIC',
 'Rock': 'ROCK',
 'Ghost': 'GHOST',
 'Ice': 'ICE',
 'Dragon': 'DRAGON',
 'Dark': 'DARK',
 'Steel': 'STEEL',
 'Flying': 'FLYING'}

指数加权窗口

作为扩张窗口的 ewm 窗口

在扩张窗口中，用户可以使用各类函数进行历史的累计指标统计，但这些内置的统计函数往往把窗口中的所有元素赋予了同样的权重。事实上，可以给出不同的权重来赋给窗口中的元素，指数加权窗口就是这样一种特殊的扩张窗口。其中，最重要的参数是 alpha ，它决定了默认情况下的窗口权重为 $w_i = (1-\alpha)^i,i \in \{0,1,...,t\}$ ，其中 $i = t$ 表示当前元素， $i = 0$ 表示序列的第一个元素。

从权重公式可以看出，离开当前值越远则权重越小，若记原序列为 x ，更新后的当前元素为 yt ，此时通过加权公式归一化后可知：

$y_t =\frac{\sum_{i=0}^{t} w_i x_{t-i}}{\sum_{i=0}^{t} w_i}$
$=\frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 - \alpha)^{t} x_{0}}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^{t-1}}$
对于 Series 而言，可以用 ewm 对象如下计算指数平滑后的序列：

np.random.seed(0)
s = pd.Series(np.random.randint(-1,2,30).cumsum())
s.head()

0   -1
1   -1
2   -2
3   -2
4   -2
dtype: int32

s.ewm(alpha=0.2).mean().head()

0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64

请用 expanding 窗口实现:

# 方法一
alpha = 0.2
s1 = pd.Series([(1-alpha)**i for i in range(29,-1,-1)]) 
s2 = s1*s.sort_index(ascending=False)
res = s2.expanding().sum()/s1.expanding().sum()
res.head()

0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64

# 方法二
def ewm_func(x, alpha=0.2):
    win = (1-alpha)**np.arange(x.shape[0])[::-1]
    res = (win*x).sum()/win.sum()
    return res

s.expanding().apply(ewm_func).head()

0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64

作为滑动窗口的 ewm 窗口

从第1问中可以看到， ewm 作为一种扩张窗口的特例，只能从序列的第一个元素开始加权。现在希望给定一个限制窗口 n ，只对包含自身最近的 n 个窗口进行滑动加权平滑。请根据滑窗函数，给出新的 $w_i$ 与 $y_t$ 的更新公式，并通过 rolling 窗口实现这一功能。

新的权重为 $w_i = (1 - \alpha)^i, i\in \{0,1,...,n-1\} ，y_t$ 更新如下：

$y_t =\frac{\sum_{i=0}^{n-1} w_i x_{t-i}}{\sum_{i=0}^{n-1} w_i}$
$=\frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 - \alpha)^{n-1} x_{t-(n-1)}}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^{n-1}}$

s.rolling(window=4).apply(ewm_func).head()

0         NaN
1         NaN
2         NaN
3   -1.609756
4   -1.826558
dtype: float64

你可能感兴趣的:(数据分析与挖掘,python,数据分析,pandas)

科研绘图系列：R语言基础图形合集生信学习者2 R语言可视化其他 r语言
基础图形可视化数据分析的图形可视化是了解数据分布、波动和相关性等属性必不可少的手段。不同的图形类型对数据属性的表征各不相同，通常具体问题使用具体的可视化图形。R语言在可视化方面具有极大的优势，因其本身就是统计学家为了研究统计问题开发的编程语言，因此极力推荐使用R语言可视化数据。散点图散点图是由x值和y值确定的点散乱分布在坐标轴上，一是可以用来展示数据的分布和聚合情况，二是可通过分布情况得到x和y之
智能听诊器：宠物心脏健康监测的创新工具萌宠心语宠物
智能听诊器作为宠物医疗领域的新兴技术，提供了一种创新的监测手段。与传统听诊器相比，它能更准确地捕捉宠物心脏的声音，并通过算法分析识别潜在的心脏问题。便携性是智能听诊器的一大优势。宠物主人可以在家中轻松监测宠物的心跳和呼吸频率，并将数据上传至互联网平台，为兽医提供实时监控宠物心脏健康状态的途径。上传至互联网平台的数据可以被兽医远程访问和分析，提供个性化的健康管理方案。智能听诊器的数据分析功能，帮助兽
宠物健康新守护：智能听诊器引领科技突破萌宠心语宠物科技
在宠物护理领域，一项令人瞩目的科技创新正逐渐兴起，那便是智能听诊器。这款革命性的设备以前所未有的准确性和便利性，为宠物主人提供了一种全新的健康监测体验。只需将智能听诊器轻轻放置在爱宠的身上，它便立即开始工作，捕捉到宠物胸腔的微小振动。借助高精度传感器和先进的数据分析技术，这些振动被转化为宠物的关键健康指标，如心率和呼吸频率。智能算法的力量使得这个过程变得简单直观。智能听诊器的实时监控功能，赋予了宠
Python简单的学生管理系统（字典实现） Lill_bin Python 字典学生管理数据操作用户交互
代码：dict1={'小黑':'2020212978','小白':'2020212977','小绿':'2020212966'}print("请输入想要进行的操作:1.插入学生2.查询学生3.删除学生4.查询所有信息5.退出")definsertstudent():#插入学生信息name=input("请输入想要插入的学生姓名")if(nameindict1):print("该学生信息已存在")e
基于Spark的云南旅游大数据分析平台 Sweican 毕业设计 spark 大数据分布式
一、项目概述Hi，大家好，今天分享的项目是《基于Spark的云南旅游大数据分析平台》。随着旅游业的发展和数字化进程的加速，智慧旅游已成为旅游业的重要发展方向。智慧旅游大数据平台的建设，能够为旅游业提供更加高效、智能的数据处理和分析能力，帮助旅游企业更好地了解市场需求、优化资源配置。平台将互联网采集的有关云南旅游信息的数据，结合Spark对数据进行过滤分析和可视化，最终实现了一个对云南旅游数据进行分
《Python数据分析实战》 johnny233 Python 读书笔记 python
环境搭建定义变量名时要遵循的规则：变量名必须以字母或下画线开始，名字中间只能由字母、数字和下画线组成长度不能超过255个字符变量名在有效范围内必须具有唯一性不能使用保留字（关键字）区分大小写不能对元组中的元素做修改，只能做切片查询。如果元组中只有1个元素，则需要在这个元素的后面加上逗号。数字100正确的表示方法为(100,)列表：a=[1,2,3]，常用列表函数函数用途append()向列表末尾添
Pyecharts 可视化数据大屏设计与实践 jun778895 pyecharts
Pyecharts可视化数据大屏设计与实践在当今数字化转型的大潮中，数据可视化大屏成为了企业展示业务数据、监控运营状态、辅助决策制定的重要工具。Pyecharts，作为一款基于Python的开源数据可视化库，因其丰富的图表类型、灵活的配置选项以及易于集成的特性，成为构建数据大屏的理想选择。本文将详细探讨如何利用Pyecharts设计并实现一个功能全面、视觉效果突出的数据可视化大屏。一、项目概述假设
Django模板语法和ModelForm Q_M_Y_Y django django python
ModelForm或者Form组件的作用:生成HTML标签对POST过来的表单数据进行验证直接将数据保存到数据库获取表单错误信息Django的管道操作模板时间格式化显示{{item.event_start|date:“Y-m-dH:i:s”}}{{bio|truncatewords:“30”}}{{my_list|first|upper}}{{name|lower}}Mysql时间转Python时
【Python】面向对象丕羽 python
面向对象1.概述:编程思想,对象为基础,基于面向过程.三大思想特点:把复杂的事情简单化把人们(程序员)从执行者变成指挥者.更符合人们的思考习惯.总结1.万物皆对象2.概述,特点,举例,总结四个方向描述什么是面向对象2.三大特征:封装,继承,多态封装:隐藏对象的属性和实现细节(方法),仅对外提供公共的访问方式.通过私有化方式隐藏,公共的访问方式操作,因为函数也是封装,所以封装不单指的是私有封装保证了
python csv文件创建时间_更高效的Python CSV文件导出 weixin_39622084 python csv文件创建时间
在上一篇文章，我介绍了CSV是什么？CSV有哪些优点？如何使用等等？并且最后我们用一个例子简单讲解了如何使用Python模块CSV进行导出后缀为.csv的文本文件。其实例子用于异步导出数据文件是够了，但工作中我们可能还需要结合我们Web框架进行更复杂的CSV导出。所以今天我们的目的就是结合PythonDjango框架进行分享CSV导出的另外一种方式。安装依赖这里面我们需要安装一个第三方包djang
python Django +Vue实现多文件异步上传离光头还差半个光头 python vue.js upload post
pythonDjango+Vue实现多文件异步上传刚接触python不久，接到个需求需要多文件上传，在网上找了很多，有讲理论的，有讲实现的，但我花了很长时间，才从这些文章中搞懂这个问题，我们来个直接粗暴的，上代码，部分解释加在代码上html首页letapp=newVue({el:'#app',data:{fileList:[],},methods:{fileChange:function(e){t
火山引擎字节跳动豆包AI对话接口 lytcreate. Python 火山引擎 AI 火山引擎
#pipinstall'volcengine-python-sdk[ark]'fromvolcenginesdkarkruntimeimportArkdefchat_dance(desc):client=Ark(api_key='你的api_key')completion=client.chat.completions.create(model="ep-20240619083846-c4xff",
python 打包docker 风行傲天 python docker 开发语言
python版本3.10使用flask项目打包1、创建requirements.txt列出项目所安装依赖，如：flaskstatsmodels==0.14.2neuralprophet==0.9.0keras==3.4.1scikit-learn==1.5.1tensorflow2、编写Dockerfile#拉取基础镜像FROMpython:3.10#镜像维护者的姓名和邮箱地址MAINTAINER
python sql语句生成_python自动生成sql语句的脚本 weixin_39531183 python sql语句生成
描述：工作中在数据库中创建表时，当字段很多时，比较麻烦，开发一个工具，可在excel中写好字段英文名和中文名，然后通过py生成脚本或直接在库中生成表脚本：importtkinterfromtkinterimport*importtkinter.messageboxfromtkinterimportscrolledtextimportxlrdimportpymysqlimportos#从excel中
python数据库操作批量sql执行_利用Python脚本批量生成SQL语句 weixin_39725154
通过Python脚本批量生成插入数据的SQL语句原始SQL语句：INSERTINTOsystem_user(id,login_name,name,password,salt,code,createtime,email,main_org,positions,status,used,url,invalid,millis,id_card,phone_no,past,end_date,start_date
BeautifulSoup：Python网页解析库详解零度° python beautifulsoup python
BeautifulSoup是一个Python库，用于从HTML或XML文件中提取数据。它能够通过简单的方法处理复杂的HTML文档，并且很容易就能找到你需要的标签和数据。BeautifulSoup的主要特点易于使用：BeautifulSoup提供了简洁的API来提取HTML标签。灵活：可以与lxml、html5lib或html.parser等解析器一起使用。强大：支持导航、搜索、修改解析树等功能。常
Python比C语言到底有什么优势？为什么越来越多人都学python？马大哈（Python） python pycharm 开发语言 AI编程爬虫
Python作为一种高级编程语言，在众多编程语言中脱颖而出，主要得益于其多方面的优势。以下是Python相比于其他语言的一些显著优势：简单易学：Python的语法清晰、简洁，易于阅读和编写，这使得它成为初学者的首选语言。其语法结构接近于自然语言，减少了学习曲线的陡峭度。丰富的库和框架：Python拥有庞大的标准库和第三方库，涵盖了从Web开发、数据科学、机器学习、人工智能、自动化测试到网络编程等各
python批量生成sql用于创建500个用户 weixin_43946945 python sql 数据库
创建500个用户，分别为jmeter001-jmeter500，密码都是123，手动添加不现实，用客户端复制粘贴表数据也要添加很久，因此想批量生成500条插入的sql，如下：start_num=1end_num=500insert_sql="INSERTINTO`sys_user`(`user_id`,`username`,`password`,`email`,`mobile`,`create_t
汇编、C/C++编译过程迷的人 c++
前言最近安装汇编环境的时候了解到代码的执行与编译过程，对自己曾经学习过语言的编译过程无法准确的回答，借此进行一些简单的梳理。一、汇编的编译过程汇编作为我们能够接触到最底层的语言、低级语言，汇编语言的编译方法多是基于对于寄存器的控制，可以直接翻译成机器代码，它同样是其他高级语言的基础，高级语言如Python、C++和Java与汇编语言的关系是一对多。比如，C++的一条语句就会扩展为多条汇编指令。故汇
Python任务调度的几种方式唯余木叶下弦声 python python 开发语言
目录1、通过time.sleep(n)2、通过LinuxCrontab3、通过APScheduler4、通过AirFlow框架1、通过time.sleep(n)例如，写个while(True)循环，每次执行完程序休眠1小时：time.sleep(3600)，以间接达到定时调度的效果。这是最简单也是最笨的方式，会阻塞当前线程，而且无法控制任务准确的执行时间，不推荐用于生产环境中的任务调度。2、通过L
python编写API接口实现数据筛选、查询与分页唯余木叶下弦声 python 开发语言
目录一、背景二、代码一、背景由于系统上需要分页展示数据，并提供按字段筛选数据的功能，于是需要我写个接口，以供前端使用。接口可以通过pythonflask框架实现。Flask是一个轻量级的Web框架，它提供了足够的灵活性来构建定制的RESTfulAPI。开发者可以根据需求轻松地设计和实现接口。数据的查询可以通过pymysql连接MySQL数据库实现。数据的筛选和分页可以通过堆叠where条件、row
BUG解决：postman可以请求成功，但Python requests请求报403 唯余木叶下弦声 bug
目录问题背景问题定位问题解决问题背景使用Python的requests库对接物联数据的接口之前一直正常运行，昨天突然请求不通了，通过进一步验证发现凡是使用代码调用接口就不通，而使用postman就能调通，请求参数啥的都没变。接口返回的结果如下：\n\n\n\n\n403\n\nbody{\nbackground-color:#f3f3f4;\ncolor:#676a6c;\nheight:100%
Python使用pyhive库远程操作hive的配置和使用玩家_名狱 Python学习大数据 python 数据库 hive
请先安装好hive，林子雨老师的配置方法，该配置方法是可以配置成功的，请注意配置hive-site.xml文件的时候，里面添加的信息都是在标签里的尾部添加配置hive环境到hive安装的conf目录下，把hive-env.sh.template复制一份并改名为hive-env.shcd/usr/local/hive/conf/cphive-env.sh.templatehive-env.sh然后配
python模块使用流光影下 python入门教程 python 开发语言
自定义模块以内建的sys模块为例，编写一个hello的模块：#!/usr/bin/envpython3#-*-coding:utf-8-*-'atestmodule'__author__='MichaelLiao'importsysdeftest():args=sys.argviflen(args)==1:print('Hello,world!')eliflen(args)==2:print('H
1.5 编程基础之循环控制 45 金币方法二（python3实现） dllglvzhenfeng CSP-J CSP-S NOIP历年真题计算机考研机试程序猿的数学算法人工智能 python 蓝桥杯 CSP-J
OpenJudge-45:金币信息学奥赛一本通（C++版）在线评测系统[NOIP2015普及组]金币-洛谷1.5编程基础之循环控制_45金币https://blog.csdn.net/dllglvzhenfeng/article/details/1219932361.5编程基础之循环控制45金币（python3实现一）https://blog.csdn.net/dllglvzhenfeng/art
python利用pyhive 连接hive Leonban 《Python基础知识》python hive 大数据
1.下载需求包pipinstallsaslpipinstallthriftpipinstallthrift-saslpipinstallPyHive2.连接hive注意端口默认为10000frompyhiveimporthiveconn=hive.Connection(host='192.168.100.100',port=10000,username='root',database='defau
python连接hive--Pyhive Elvis_hui hive hive python sql
Pyhive安装包pipinstallsaslpipinstallthriftpipinstallthrift-saslpipinstallPyHive#安装对应的包sasl可能会报错#下载sasl文件sasl下载执行语句第一种frompyhiveimporthivedefselect_pyhive(sql):#创建hive连接conn=hive.Connection(host='##',port
pyhton - PyHive 凌不了云 python python hive
简介PyHive是一组PythonDB-API和SQLAlchemy接口，可用于Presto和Hive。它为Python提供了一个与Presto和Hive进行交互的平台，使得数据分析师和工程师可以更方便地进行数据处理和分析。安装在安装PyHive之前，你需要确保已经安装以下软件：PipPythonJDK（JavaDevelopmentKit）Hive或Presto在安装完成上述软件之后，你可以使用
python中格式化输出 2301_76175793 python 开发语言
1、使用%占位符%s将内容转化为字符串，放入占位位置。内容可以是列表，字典等类型，最后会转化成字符串类型。%d将内容转化为整数，放入占位位置%f将内容转化为浮点数，放入占位位置使用占位符按位置传参，如果只传一个参数的话，不用在参数的位置加括号，而要传多个参数的话，要加括号，并且传入的参数与占位符的位置一一对应。输入：print("我的名字是%s。"%"明天")print("我的名字是%s，我的年龄
Python中使用SQLite ch_s_t Python sqlite python 数据库 sql
一、SQLite3增删改查在Python中使用SQLite3进行数据库操作是一种常见的实践，特别是对于小型应用程序或原型开发。以下是使用Python标准库中的`sqlite3`模块进行增删改查（CRUD）操作的基本示例。1.连接数据库首先，需要连接到SQLite数据库。如果数据库文件不存在，`sqlite3.connect()`将会创建一个新的数据库文件。importsqlite3#连接到SQLi
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，

	col1 \|\|\|\| col2
0	TS \|\|\|\| This is an apple.
1	GQ \|\|\|\| My name is Bob.
2	WT \|\|\|\| Well done!
3	PT \|\|\|\| May I help you?