~聊音小生。

快速上手Python三剑客--Pandas篇

Pandas学习

什么是Pandas？

Pandas是一个开源的数据分析和数据处理库，它是基于 Python 编程语言的
Pandas提供了易于使用的数据结构和数据分析工具，特别适用于处理结构化数据，如表格型数据（类似于Excel表格）
Pandas是数据科学和分析领域中常用的工具之一，它使得用户能够轻松地从各种数据源中导入数据，并对数据进行高效的操作和分析

Pandas的数据结构有哪些？

Pandas主要引入了两种新的数据结构： Series 和 DataFrame。

Series：类似于一维数组或列表，是由一组数据以及与之相关的数据标签（索引）构成。Series可以看作是 DataFrame中的一列，也可以是单独存在的一维数据结构。
DataFrame：类似于一个二维表格，它是Pandas中最重要的数据结构。DataFrame可以看作是由多个Series按列排列构成的表格，它既有行索引也有列索引，因此可以方便地进行行列选择、过滤、合并等操作。

DataFrame可视为由多个 Series 组成的数据结构：

Pandas的应用

Pandas在数据科学和数据分析领域中具有广泛的应用，其主要优势在于能够处理和分析结构化数据。
以下是Pandas的一些主要应用领域：

数据清洗和预处理：Pandas被广泛用于清理和预处理数据，包括处理缺失值、异常值、重复值等。它提供了各种方法来使数据更适合进行进一步的分析
数据分析和统计：Pandas可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据，通过DataFrame和Series的灵活操作，使数据分析变得更加简单，用户可以轻松地进行统计分析、汇总、聚合等操作。从均值、中位数到标准差和相关性分析，Pandas都提供了丰富的功能
数据可视化：将Pandas与Matplotlib等数据可视化库结合使用，可以创建各种图表和图形，从而更直观地理解数据分布和趋势
时间序列分析：Pandas在处理时间序列数据方面表现出色，支持对日期和时间进行高效操作。这对于金融领域、生产领域以及其他需要处理时间序列的行业尤为重要
机器学习和数据建模：在机器学习中，数据预处理是非常关键的一步，而Pandas提供了强大的功能来处理和准备数据。它可以帮助用户将数据整理成适用于机器学习算法的格式
数据库操作：Pandas可以轻松地与数据库进行交互，从数据库中导入数据到DataFrame中，进行分析和处理，然后将结果导回数据库。这在数据库管理和分析中非常有用
实时数据分析：对于需要实时监控和分析数据的应用，Pandas的高效性能使其成为一个强大的工具。结合其他实时数据处理工具，可以构建实时分析系统

基础知识

# 导入Pandas和NumPy
import numpy as np
import pandas as pd

生成对象

# 用列表生成Series
s = pd.Series([1, 3, 5, np.nan, 6, 8])
s

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

# 用Series、字典{"A": "1, "B": "xx"}、对象生成DataFrame
# A-浮点数，B-TimeStamp，C-Series，D-ndarray，E-组合，F-字符串
df = pd.DataFrame({
    'A': 1.,
    'B': pd.Timestamp('20010809'),
    'C': pd.Series(1, index=[0, 1, 2, 3], dtype='float32'),
    'D': np.array([3, 3, 3, 3], dtype='int32'),
    'E': pd.Categorical(["test", "train", "test", "train"]),
    'F': 'foo'
})
df

	A	B	C	D	E	F
0	1.0	2001-08-09	1.0	3	test	foo
1	1.0	2001-08-09	1.0	3	train	foo
2	1.0	2001-08-09	1.0	3	test	foo
3	1.0	2001-08-09	1.0	3	train	foo

# 用含日期时间索引、标签、NumPy数组生成DataFrame
# 随机生成6行4列的二维数组，行标签为之前生成的d，列标签为A、B、C、D
d = pd.date_range('20010807', periods=6)
print(d)
df1 = pd.DataFrame(np.random.randn(6, 4), index=d, columns=list('ABCD'))
df1

DatetimeIndex(['2001-08-07', '2001-08-08', '2001-08-09', '2001-08-10',
               '2001-08-11', '2001-08-12'],
              dtype='datetime64[ns]', freq='D')

	A	B	C	D
2001-08-07	-0.297676	0.049568	-1.299745	0.636079
2001-08-08	0.339365	0.500148	0.243576	-0.160504
2001-08-09	0.704013	1.720233	-0.186915	-1.322280
2001-08-10	-0.951185	1.420427	-0.194470	-0.305272
2001-08-11	-0.182651	0.939551	-0.432457	-1.060890
2001-08-12	1.178420	1.950314	-0.622115	1.248751

查看数据和数据类型

# 查看DataFrame列的数据类型
print(type(df))
print(df.dtypes)


A          float64
B    datetime64[s]
C          float32
D            int32
E         category
F           object
dtype: object

# 查看DataFrame头部和尾部数据
# head()参数为空则默认查看5条
df1.head()

	A	B	C	D
2001-08-07	-0.297676	0.049568	-1.299745	0.636079
2001-08-08	0.339365	0.500148	0.243576	-0.160504
2001-08-09	0.704013	1.720233	-0.186915	-1.322280
2001-08-10	-0.951185	1.420427	-0.194470	-0.305272
2001-08-11	-0.182651	0.939551	-0.432457	-1.060890

# 查看DataFrame尾部数据
df1.tail(3)

	A	B	C	D
2001-08-10	-0.951185	1.420427	-0.194470	-0.305272
2001-08-11	-0.182651	0.939551	-0.432457	-1.060890
2001-08-12	1.178420	1.950314	-0.622115	1.248751

# 查看索引
print(df1.index)
print('------')
# 查看列名
print(df1.columns)

DatetimeIndex(['2001-08-07', '2001-08-08', '2001-08-09', '2001-08-10',
               '2001-08-11', '2001-08-12'],
              dtype='datetime64[ns]', freq='D')
------
Index(['A', 'B', 'C', 'D'], dtype='object')

# 查看数据的统计摘要(最大最小值，均值等)
df1.describe()

	A	B	C	D
count	6.000000	6.000000	6.000000	6.000000
mean	0.131714	1.096707	-0.415354	-0.160686
std	0.764475	0.734752	0.521604	0.979992
min	-0.951185	0.049568	-1.299745	-1.322280
25%	-0.268920	0.609999	-0.574701	-0.871986
50%	0.078357	1.179989	-0.313463	-0.232888
75%	0.612851	1.645281	-0.188804	0.436933
max	1.178420	1.950314	0.243576	1.248751

排序

# 按轴排序
df1.sort_index(axis=1, ascending=False)

	D	C	B	A
2001-08-07	0.884528	-1.969893	3.054879	1.128499
2001-08-08	1.532802	0.214965	-0.847056	0.640980
2001-08-09	0.039443	0.228000	-0.209567	0.932230
2001-08-10	-1.657565	-0.738947	0.626624	-1.114161
2001-08-11	0.972585	0.767757	-0.272565	-0.436437
2001-08-12	0.023965	-0.084927	-2.336696	1.306975

# 按值排序
df1.sort_values(by='B')

	A	B	C	D
2001-08-12	1.306975	-2.336696	-0.084927	0.023965
2001-08-08	0.640980	-0.847056	0.214965	1.532802
2001-08-11	-0.436437	-0.272565	0.767757	0.972585
2001-08-09	0.932230	-0.209567	0.228000	0.039443
2001-08-10	-1.114161	0.626624	-0.738947	-1.657565
2001-08-07	1.128499	3.054879	-1.969893	0.884528

选择数据

# 选择单列
df1['A']

2001-08-07   -0.297676
2001-08-08    0.339365
2001-08-09    0.704013
2001-08-10   -0.951185
2001-08-11   -0.182651
2001-08-12    1.178420
Freq: D, Name: A, dtype: float64

# 用[]切片行
df1[1:3]

	A	B	C	D
2001-08-08	0.339365	0.500148	0.243576	-0.160504
2001-08-09	0.704013	1.720233	-0.186915	-1.322280

df1['2001-08-07':'2001-08-11']

	A	B	C	D
2001-08-07	-0.297676	0.049568	-1.299745	0.636079
2001-08-08	0.339365	0.500148	0.243576	-0.160504
2001-08-09	0.704013	1.720233	-0.186915	-1.322280
2001-08-10	-0.951185	1.420427	-0.194470	-0.305272
2001-08-11	-0.182651	0.939551	-0.432457	-1.060890

按标签选择

df1.loc['2001-08-08']

A    0.339365
B    0.500148
C    0.243576
D   -0.160504
Name: 2001-08-08 00:00:00, dtype: float64

# 用标签提取一行数据
df1.loc[d[0]]

A   -0.297676
B    0.049568
C   -1.299745
D    0.636079
Name: 2001-08-07 00:00:00, dtype: float64

# 用标签选择多列数据
df1.loc[:, ['A', 'B']]

	A	B
2001-08-07	-0.297676	0.049568
2001-08-08	0.339365	0.500148
2001-08-09	0.704013	1.720233
2001-08-10	-0.951185	1.420427
2001-08-11	-0.182651	0.939551
2001-08-12	1.178420	1.950314

# 用标签切片
df1.loc['2001-08-07':'2001-08-10', ['C', 'D']]

	C	D
2001-08-07	-1.299745	0.636079
2001-08-08	0.243576	-0.160504
2001-08-09	-0.186915	-1.322280
2001-08-10	-0.194470	-0.305272

# 取某个标签的值
df1.loc['2001-08-10', 'A']

-0.9511849480978183

# 快速取某个标签的值
df1.at['2001-08-09', 'C']

-0.1869148162186709

按位置选择

loc函数：通过行索引 “Index” 中的具体值来取行数据（如取"Index"为"A"的行）,一般用于按标签赋值
iloc函数：通过行号来取行数据（如取第二行的数据），一般用于按位置赋值

# 按位置选择
print(df1.iloc[3])

# 用整数切片
print(df1.iloc[3:5, 0:2])

# 用整数列表按位置切片
print(df1.iloc[[1, 2, 4], [0, 2]])

# 整行切片
print(df1.iloc[1:3, :])

# 整列切片
print(df1.iloc[:, 1:3])

# 显示提取值
print(df1.iloc[1, 1])

# 快速访问标量
print(df1.iat[1, 1])

A   -0.951185
B    1.420427
C   -0.194470
D   -0.305272
Name: 2001-08-10 00:00:00, dtype: float64
                   A         B
2001-08-10 -0.951185  1.420427
2001-08-11 -0.182651  0.939551
                   A         C
2001-08-08  0.339365  0.243576
2001-08-09  0.704013 -0.186915
2001-08-11 -0.182651 -0.432457
                   A         B         C         D
2001-08-08  0.339365  0.500148  0.243576 -0.160504
2001-08-09  0.704013  1.720233 -0.186915 -1.322280
                   B         C
2001-08-07  0.049568 -1.299745
2001-08-08  0.500148  0.243576
2001-08-09  1.720233 -0.186915
2001-08-10  1.420427 -0.194470
2001-08-11  0.939551 -0.432457
2001-08-12  1.950314 -0.622115
0.5001484694436036
0.5001484694436036

筛选

print(df1[df1['C'] > 0])
print(df1[df1 > 0])

# 用isin()筛选
newdf = df1.copy()
newdf['E'] = ['one', 'one', 'two', 'three', 'four', 'three']
print(newdf)
newdf[newdf['E'].isin(['two', 'four'])]

                   A         B         C         D
2001-08-08  0.339365  0.500148  0.243576 -0.160504
                   A         B         C         D
2001-08-07       NaN  0.049568       NaN  0.636079
2001-08-08  0.339365  0.500148  0.243576       NaN
2001-08-09  0.704013  1.720233       NaN       NaN
2001-08-10       NaN  1.420427       NaN       NaN
2001-08-11       NaN  0.939551       NaN       NaN
2001-08-12  1.178420  1.950314       NaN  1.248751
                   A         B         C         D      E
2001-08-07 -0.297676  0.049568 -1.299745  0.636079    one
2001-08-08  0.339365  0.500148  0.243576 -0.160504    one
2001-08-09  0.704013  1.720233 -0.186915 -1.322280    two
2001-08-10 -0.951185  1.420427 -0.194470 -0.305272  three
2001-08-11 -0.182651  0.939551 -0.432457 -1.060890   four
2001-08-12  1.178420  1.950314 -0.622115  1.248751  three

	A	B	C	D	E
2001-08-09	0.704013	1.720233	-0.186915	-1.32228	two
2001-08-11	-0.182651	0.939551	-0.432457	-1.06089	four

赋值

# 用索引自动对齐新增列的数据
s1 = pd.Series([1, 2, 3, 4, 5, 6], index=d)
print(s1)
print()

df1['F'] = s1
print(df1)
print()

# 按标签赋值
df1.at['2001-08-07', 'A'] = 0
print(df1)
print()

# 按位置赋值
df1.iat[1, 0] = 0
print(df1)
print()

# 按数组赋值
df1['G'] = [1, 2, 3, 4, 5, 6]
print(df1)
print()

# 按NumPy数组赋值
df1.loc[:, 'D'] = np.array([5] * len(df1))
print(df1)
print()

# 条件赋值
newdf = df1.copy()
newdf[newdf < 0] = 0
print(newdf)

2001-08-07    1
2001-08-08    2
2001-08-09    3
2001-08-10    4
2001-08-11    5
2001-08-12    6
Freq: D, dtype: int64

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568 -1.299745  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233 -0.186915  5.0  3  3
2001-08-10 -0.951185  1.420427 -0.194470  5.0  4  4
2001-08-11 -0.182651  0.939551 -0.432457  5.0  5  5
2001-08-12  1.178420  1.950314 -0.622115  5.0  6  6

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568 -1.299745  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233 -0.186915  5.0  3  3
2001-08-10 -0.951185  1.420427 -0.194470  5.0  4  4
2001-08-11 -0.182651  0.939551 -0.432457  5.0  5  5
2001-08-12  1.178420  1.950314 -0.622115  5.0  6  6

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568 -1.299745  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233 -0.186915  5.0  3  3
2001-08-10 -0.951185  1.420427 -0.194470  5.0  4  4
2001-08-11 -0.182651  0.939551 -0.432457  5.0  5  5
2001-08-12  1.178420  1.950314 -0.622115  5.0  6  6

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568 -1.299745  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233 -0.186915  5.0  3  3
2001-08-10 -0.951185  1.420427 -0.194470  5.0  4  4
2001-08-11 -0.182651  0.939551 -0.432457  5.0  5  5
2001-08-12  1.178420  1.950314 -0.622115  5.0  6  6

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568 -1.299745  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233 -0.186915  5.0  3  3
2001-08-10 -0.951185  1.420427 -0.194470  5.0  4  4
2001-08-11 -0.182651  0.939551 -0.432457  5.0  5  5
2001-08-12  1.178420  1.950314 -0.622115  5.0  6  6

                   A         B         C    D  F  G
2001-08-07  0.000000  0.049568  0.000000  5.0  1  1
2001-08-08  0.000000  0.500148  0.243576  5.0  2  2
2001-08-09  0.704013  1.720233  0.000000  5.0  3  3
2001-08-10  0.000000  1.420427  0.000000  5.0  4  4
2001-08-11  0.000000  0.939551  0.000000  5.0  5  5
2001-08-12  1.178420  1.950314  0.000000  5.0  6  6

空值

# reindex重写索引(这个方法用的比较多)
newdf = df1.reindex(index=d[0:4], columns=list(df1.columns) + ['E'])
newdf.loc[d[0]:d[1], 'E'] = 1
newdf

	A	B	C	D	F	G	E
2001-08-07	0.000000	0.049568	-1.299745	5.0	1	1	1.0
2001-08-08	0.000000	0.500148	0.243576	5.0	2	2	1.0
2001-08-09	0.704013	1.720233	-0.186915	5.0	3	3	NaN
2001-08-10	-0.951185	1.420427	-0.194470	5.0	4	4	NaN

# 使用dropna函数来删除空值
# how='any'
# 可选参数，默认为any
#    any: 如果存在NaN，则删除该行或列
#    all: 如果所有值都是NaN，则删除该行或列

newdf.dropna(how='any')
# 另注意此处只是操作后的结果，但是并没有赋值给newdf，故newdf展示的结果为两行，其实还是4行
# newdf = newdf.dropna(how='any')结果就为两行

	A	B	C	D	F	G	E
2001-08-07	0.0	0.049568	-1.299745	5.0	1	1	1.0
2001-08-08	0.0	0.500148	0.243576	5.0	2	2	1.0

# 值为NaN的地方赋值为5
newdf.fillna(value=5)

	A	B	C	D	F	G	E
2001-08-07	0.000000	0.049568	-1.299745	5.0	1	1	1.0
2001-08-08	0.000000	0.500148	0.243576	5.0	2	2	1.0
2001-08-09	0.704013	1.720233	-0.186915	5.0	3	3	5.0
2001-08-10	-0.951185	1.420427	-0.194470	5.0	4	4	5.0

# 判断此处值是否为NaN
pd.isna(newdf)

	A	B	C	D	F	G	E
2001-08-07	False	False	False	False	False	False	False
2001-08-08	False	False	False	False	False	False	False
2001-08-09	False	False	False	False	False	False	True
2001-08-10	False	False	False	False	False	False	True

运算

算术运算

df1 = pd.DataFrame(np.random.randn(2, 5))
print(df1)
print("----------")
df2 = pd.DataFrame(np.random.randn(3, 4))
print(df2)
print("----------")
print("df1+df2\n", df1 + df2)
print("----------")
print("df1-df2\n", df1 - df2)
print("----------")
print("df1*df2\n", df1 * df2)
print("----------")
print("df1/df2\n", df1 / df2)

          0         1         2         3         4
0  0.841797  0.269025  2.514216 -1.896455  0.479344
1  1.352019 -0.467855 -0.754422  0.242742  1.465160

          0         1         2         3
0  1.403584  0.082813  0.469722 -0.534022
1  0.320259  0.331209  0.291575  0.477501
2  1.226319 -1.297662 -0.540806 -0.050445

df1+df2
           0         1         2         3   4
0  2.245381  0.351839  2.983938 -2.430477 NaN
1  1.672278 -0.136645 -0.462847  0.720243 NaN
2       NaN       NaN       NaN       NaN NaN

df1-df2
           0         1         2         3   4
0 -0.561788  0.186212  2.044494 -1.362433 NaN
1  1.031759 -0.799064 -1.045997 -0.234759 NaN
2       NaN       NaN       NaN       NaN NaN

df1*df2
           0         1         2         3   4
0  1.181533  0.022279  1.180982  1.012749 NaN
1  0.432996 -0.154958 -0.219971  0.115910 NaN
2       NaN       NaN       NaN       NaN NaN

df1/df2
           0         1         2         3   4
0  0.599748  3.248576  5.352562  3.551266 NaN
1  4.221638 -1.412564 -2.587399  0.508359 NaN
2       NaN       NaN       NaN       NaN NaN

比较操作

print("df1 等于 df2\n", df1.eq(df2))
print("----------")
print("df1 不等于 df2\n", df1.ne(df2))
print("----------")
print("df1 大于 df2\n", df1.gt(df2))  # greater than
print("----------")
print("df1 小于 df2\n", df1.lt(df2))  # less than
print("----------")
print("df1 大于等于 df2\n", df1.ge(df2))
print("----------")
print("df1 小于等于 df2\n", df1.le(df2))

df1 等于 df2
        0      1      2      3      4
0  False  False  False  False  False
1  False  False  False  False  False
2  False  False  False  False  False
----------
df1 不等于 df2
       0     1     2     3     4
0  True  True  True  True  True
1  True  True  True  True  True
2  True  True  True  True  True
----------
df1 大于 df2
        0      1      2      3      4
0  False   True   True  False  False
1   True  False  False  False  False
2  False  False  False  False  False
----------
df1 小于 df2
        0      1      2      3      4
0   True  False  False   True  False
1  False   True   True   True  False
2  False  False  False  False  False
----------
df1 大于等于 df2
        0      1      2      3      4
0  False   True   True  False  False
1   True  False  False  False  False
2  False  False  False  False  False
----------
df1 小于等于 df2
        0      1      2      3      4
0   True  False  False   True  False
1  False   True   True   True  False
2  False  False  False  False  False

统计

函数	描述	函数	描述	函数	描述	函数	描述
count	统计非空值数量	sum	汇总值	mean	平均值	mad	平均绝对偏差
median	算数中位数	min	最小值	max	最大值	mode	重数
abs	绝对值	prod	乘积	std	标准偏差	var	无偏方差
sem	平均值的标准误差	skew	样本偏度（第三阶）	kurt	样本峰度（第四阶）	quantile	样本分位数（不同%的值）
cumsum	累计和	cumprod	累乘	cummax	累积最大值	cunmin	累积最小值

print(df1)
# 求每一列的均值
print(df1.mean())
# 求每一列的累加和并将每一列的累计和赋给每一列的最下面一行
print(df1.cumsum())

          0         1         2         3         4
0  0.841797  0.269025  2.514216 -1.896455  0.479344
1  1.352019 -0.467855 -0.754422  0.242742  1.465160
0    1.096908
1   -0.099415
2    0.879897
3   -0.826857
4    0.972252
dtype: float64
          0         1         2         3         4
0  0.841797  0.269025  2.514216 -1.896455  0.479344
1  2.193815 -0.198829  1.759794 -1.653713  1.944505

合并concat

pd.concat([df1, df2])

	0	1	2	3	4
0	0.841797	0.269025	2.514216	-1.896455	0.479344
1	1.352019	-0.467855	-0.754422	0.242742	1.465160
0	1.403584	0.082813	0.469722	-0.534022	NaN
1	0.320259	0.331209	0.291575	0.477501	NaN
2	1.226319	-1.297662	-0.540806	-0.050445	NaN

连接join

left = pd.DataFrame({'key': ['foo', 'foo', 'bar'], 'lval': [1, 2, 2]})
print(left)
right = pd.DataFrame({'key': ['foo', 'foo', 'bar'], 'rval': [3, 4, 5]})
print(right)
pd.merge(left, right, on='key')

   key  lval
0  foo     1
1  foo     2
2  bar     2
   key  rval
0  foo     3
1  foo     4
2  bar     5

	key	lval	rval
0	foo	1	3
1	foo	1	4
2	foo	2	3
3	foo	2	4
4	bar	2	5

追加Append（已失效），追加可改为concat来实现

df = pd.DataFrame(np.random.randn(8, 4), columns=['A', 'B', 'C', 'D'])
print(df)
s = df.iloc[3]
print(s)
df.append(s, ignore_index=True)  # 已失效

          A         B         C         D
0  0.277439 -0.363739  1.026139  1.614032
1 -1.595705  1.259329 -1.062648  0.186739
2 -0.639943  0.402358  0.110181  0.180963
3 -0.621929  0.401519 -0.975065 -1.001928
4 -3.077506  1.075743 -0.544791  2.573899
5  2.038906  0.301643 -0.920341  1.700568
6  1.679596  0.642480 -0.688277  0.447207
7 -1.582690 -0.033994 -1.513041  1.009212
A   -0.621929
B    0.401519
C   -0.975065
D   -1.001928
Name: 3, dtype: float64



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

Cell In[112], line 5
      3 s=df.iloc[3]
      4 print(s)
----> 5 df.append(s,ignore_index=True)#已失效


File D:\Python\Miniconda3\miniconda3\envs\p2s\lib\site-packages\pandas\core\generic.py:6204, in NDFrame.__getattr__(self, name)
   6197 if (
   6198     name not in self._internal_names_set
   6199     and name not in self._metadata
   6200     and name not in self._accessors
   6201     and self._info_axis._can_hold_identifiers_and_holds_name(name)
   6202 ):
   6203     return self[name]
-> 6204 return object.__getattribute__(self, name)


AttributeError: 'DataFrame' object has no attribute 'append'

分组group

df = pd.DataFrame({
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar'],
    'B': ['one', 'two', 'three', 'four', 'one', 'two', 'three', 'four'],
    'C':
    np.random.randn(8),
    'D':
    np.random.randn(8)
})
print(df)
df.groupby('A').sum()

     A      B         C         D
0  foo    one  0.189163 -0.806318
1  bar    two  2.407904 -0.095191
2  foo  three  0.074226  0.293678
3  bar   four  0.546407  0.809018
4  foo    one -0.450351 -0.499252
5  bar    two -1.720710  0.931944
6  foo  three  0.695358  0.185726
7  bar   four  2.094319  1.072681

	B	C	D
A
bar	twofourtwofour	3.327920	2.718452
foo	onethreeonethree	0.508397	-0.826166

df.groupby(['A', 'B']).sum()

		C	D
A	B
bar	four	-1.064164	0.872241
bar	two	-0.608013	0.091348
foo	one	3.065079	1.367708
foo	three	1.380634	-1.439255

数据透视表

df = pd.DataFrame({
    'A': ['one', 'two', 'three', 'four'] * 3,
    'B': ['A', 'B', 'C'] * 4,
    'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
    'D': np.random.randn(12),
    'E': np.random.randn(12)
})
print(df)
pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])

        A  B    C         D         E
0     one  A  foo -1.546985  0.590130
1     two  B  foo  1.732416 -2.586836
2   three  C  foo -1.105102 -0.858783
3    four  A  bar -0.732389 -0.475518
4     one  B  bar  0.533465  0.736240
5     two  C  bar  0.197097 -1.329285
6   three  A  foo  0.495105  0.426743
7    four  B  foo -0.611343 -0.204255
8     one  C  foo -0.678577 -2.013504
9     two  A  bar -0.538301 -1.216611
10  three  B  bar -1.503484 -0.199938
11   four  C  bar  1.323900  0.883130

	C	bar	foo
A	B
four	A	-0.732389	NaN
	B	NaN	-0.611343
	C	1.323900	NaN
one	A	NaN	-1.546985
	B	0.533465	NaN
	C	NaN	-0.678577
three	A	NaN	0.495105
	B	-1.503484	NaN
	C	NaN	-1.105102
two	A	-0.538301	NaN
	B	NaN	1.732416
	C	0.197097	NaN

时间序列

# 将秒级的数据转换为5分钟为频率的数据
rng = pd.date_range('1/1/2001', periods=100, freq='S')
ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
print(ts)
# 每5分钟合并为一个，上面数据不足5分钟，故最后合成为1个
ts.resample('5Min').sum()

2001-01-01 00:00:00    492
2001-01-01 00:00:01     12
2001-01-01 00:00:02    154
2001-01-01 00:00:03    100
2001-01-01 00:00:04    184
                      ... 
2001-01-01 00:01:35    164
2001-01-01 00:01:36    118
2001-01-01 00:01:37    245
2001-01-01 00:01:38    288
2001-01-01 00:01:39     20
Freq: S, Length: 100, dtype: int32





2001-01-01    26724
Freq: 5T, dtype: int32

# 时区表示
rng = pd.date_range('3/6/2001 00:00', periods=5, freq='D')
ts = pd.Series(np.random.randn(len(rng)), rng)
print(ts)
ts_utc = ts.tz_localize('UTC')
print(ts_utc)
ts_utc.tz_convert('US/Eastern')

2001-03-06    0.029706
2001-03-07    1.486630
2001-03-08    1.418271
2001-03-09    0.120030
2001-03-10    0.579539
Freq: D, dtype: float64
2001-03-06 00:00:00+00:00    0.029706
2001-03-07 00:00:00+00:00    1.486630
2001-03-08 00:00:00+00:00    1.418271
2001-03-09 00:00:00+00:00    0.120030
2001-03-10 00:00:00+00:00    0.579539
Freq: D, dtype: float64





2001-03-05 19:00:00-05:00    0.029706
2001-03-06 19:00:00-05:00    1.486630
2001-03-07 19:00:00-05:00    1.418271
2001-03-08 19:00:00-05:00    0.120030
2001-03-09 19:00:00-05:00    0.579539
Freq: D, dtype: float64

# 转换时间段
rng = pd.date_range('1/1/2012', periods=5, freq='M')
ts = pd.Series(np.random.randn(len(rng)), rng)
print(ts)
# to_period 函数允许将日期转换为特定的时间间隔。
ps = ts.to_period()
print(ps)
ps.to_timestamp()
# 结果中的freq = "M",是以月为频率产生时间序列,以月末为时间点,而freq = "MS"则是以月初为时间点。

2012-01-31   -0.892879
2012-02-29   -0.340107
2012-03-31    0.813457
2012-04-30    2.199679
2012-05-31    2.256466
Freq: M, dtype: float64
2012-01   -0.892879
2012-02   -0.340107
2012-03    0.813457
2012-04    2.199679
2012-05    2.256466
Freq: M, dtype: float64





2012-01-01   -0.892879
2012-02-01   -0.340107
2012-03-01    0.813457
2012-04-01    2.199679
2012-05-01    2.256466
Freq: MS, dtype: float64

可视化

ts = pd.Series(np.random.randn(1000),
               index=pd.date_range('1/1/2001', periods=1000))
print(ts)
ts1 = ts.cumsum()
print(ts1)
ts1.plot()

2001-01-01    0.309942
2001-01-02    0.850757
2001-01-03   -0.798396
2001-01-04    0.297484
2001-01-05   -0.592258
                ...   
2003-09-23   -0.679936
2003-09-24    1.986236
2003-09-25    0.665965
2003-09-26   -0.479215
2003-09-27    0.731958
Freq: D, Length: 1000, dtype: float64
2001-01-01     0.309942
2001-01-02     1.160698
2001-01-03     0.362303
2001-01-04     0.659787
2001-01-05     0.067529
                ...    
2003-09-23    87.444694
2003-09-24    89.430929
2003-09-25    90.096894
2003-09-26    89.617680
2003-09-27    90.349637
Freq: D, Length: 1000, dtype: float64

import matplotlib.pyplot as plt

df = pd.DataFrame(np.random.randn(1000, 4),
                  index=ts.index,
                  columns=['A', 'B', 'C', 'D'])
df = df.cumsum()
plt.figure()
df.plot()
plt.legend(loc='best')

数据输入/输出

CSV

df.to_csv('foo.csv')
pd.read_csv('foo.csv')

	Unnamed: 0	A	B	C	D
0	2001-01-01	-1.992527	-1.719912	-0.231028	-0.493246
1	2001-01-02	-1.568642	-2.505710	0.815862	-2.581479
2	2001-01-03	-2.122416	-2.599320	-0.761854	-3.090637
3	2001-01-04	-4.027765	-2.955616	-0.219192	-2.320385
4	2001-01-05	-6.431664	-2.809861	-3.017848	-2.569958
...	...	...	...	...	...
995	2003-09-23	3.825476	10.674352	37.139296	9.314710
996	2003-09-24	3.565270	9.656261	37.906229	9.560828
997	2003-09-25	2.923609	10.739928	38.297159	8.431035
998	2003-09-26	4.654014	10.587138	39.214216	8.264657
999	2003-09-27	4.539063	10.066622	40.246983	10.362177

1000 rows × 5 columns

HDF5

!pip install tables

df.to_hdf('foo.h5', 'df')
pd.read_hdf('foo.h5', 'df')

	A	B	C	D
2001-01-01	-1.992527	-1.719912	-0.231028	-0.493246
2001-01-02	-1.568642	-2.505710	0.815862	-2.581479
2001-01-03	-2.122416	-2.599320	-0.761854	-3.090637
2001-01-04	-4.027765	-2.955616	-0.219192	-2.320385
2001-01-05	-6.431664	-2.809861	-3.017848	-2.569958
...	...	...	...	...
2003-09-23	3.825476	10.674352	37.139296	9.314710
2003-09-24	3.565270	9.656261	37.906229	9.560828
2003-09-25	2.923609	10.739928	38.297159	8.431035
2003-09-26	4.654014	10.587138	39.214216	8.264657
2003-09-27	4.539063	10.066622	40.246983	10.362177

1000 rows × 4 columns

Excel

!pip install openpyxl

df.to_excel('foo.xlsx', sheet_name='Sheet1')
pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])

	Unnamed: 0	A	B	C	D
0	2001-01-01	-1.992527	-1.719912	-0.231028	-0.493246
1	2001-01-02	-1.568642	-2.505710	0.815862	-2.581479
2	2001-01-03	-2.122416	-2.599320	-0.761854	-3.090637
3	2001-01-04	-4.027765	-2.955616	-0.219192	-2.320385
4	2001-01-05	-6.431664	-2.809861	-3.017848	-2.569958
...	...	...	...	...	...
995	2003-09-23	3.825476	10.674352	37.139296	9.314710
996	2003-09-24	3.565270	9.656261	37.906229	9.560828
997	2003-09-25	2.923609	10.739928	38.297159	8.431035
998	2003-09-26	4.654014	10.587138	39.214216	8.264657
999	2003-09-27	4.539063	10.066622	40.246983	10.362177

1000 rows × 5 columns

更详细教程可关注
https://www.runoob.com/pandas/pandas-tutorial.html

Congratulations!

记录者：ZL-Qin

你可能感兴趣的:(快速上手Python三剑客,Python,python,pandas)

【Python】一文详细介绍 py格式文件高斯小哥 Python基础【高质量合集】python 新手入门学习
【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
python 推导式(派生、衍生) sanduo112 人工智能 python windows 开发语言
python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
数据挖掘|数据预处理|基于Python的数据标准化方法皖山文武数据挖掘数据建模与分析 python 数据挖掘开发语言
基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
CSV指南：Python程序获取大型CSV文件行数孤独打铁匠Julian 笔记经验分享 python
本指南提供了几种使用Python来获取大型CSV文件行数的方法，并解释了每种方法的适用场景。方法1:使用csv.reader处理复杂CSV文件当你的CSV文件中包含多行字段（即某些字段的值中包含换行符）时，使用csv.reader是一个可靠的选择，因为它能够正确处理这些复杂情况。这个方法适用于大多数大小的CSV文件，但是对于非常大的文件，读取整个文件可能会占用较多的时间和内存。对于极大的文件，考虑
谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Python python chrome drivers
ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
大创项目推荐深度学习 opencv python 公式识别(图像识别机器视觉) laafeer python
文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
python转码 Desamond python 开发语言
转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现）宇宙之一粟不归路之Python #IT面试题收集与总结数据结构与算法算法数据结构排序算法 python java
文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
27.Python从入门到精通—Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为以山河作礼。 #Python基础入门—详解版 python java 服务器
27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
Python | Redis工具类 -拟墨画扇- Python redis 数据库缓存 python
一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
Python dict字符串转json对象，小数精度丢失问题朝如青丝暮成雪 json python
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
Numpy、Pandas库的使用貮叁量化投资分析 python python 数据分析
目录Numpy1、概述2、基础操作2.1生成一个numpy的array数组：2.2自定义一个新的数据类型：np.dtype()3、并行化思想4、量化分析应用4.1索引选取和切片选择4.2数据转换与规整4.3逻辑条件进行数据筛选4.4通用序列函数4.5文件保存与读取Pandas1、简介2、Series和DataFrame的使用2.1Series2.2DataFrame3、量化分析应用3.1形成一个p
Python+Requests模拟发送GET请求爱学习的执念自动化测试软件测试技术分享 python 开发语言
模拟发送GET请求前置条件：导入requests库一、发送不带参数的get请求代码如下：以百度首页为例importrequests#发送get请求response=requests.get(url="http://www.baidu.com")print(response.content.decode("utf-8"))#以utf-8的编码输出内容二、发送带参数的get请求发送带参数的get请求有
Python极速入门：五分钟开启实战之旅！知白守黑V Python 编程语言系统运维 python 编程语言 python开发 python学习 python入门 python数据分析
1.Python基础语法和结构：了解Python的基本语法，包括变量、数据类型、运算符、注释等。控制流：掌握条件语句（if-elif-else）、循环（for和while）及其控制（break和continue）。函数：学习如何定义和使用函数，包括参数传递、返回值、作用域和闭包。模块和包：理解如何导入和使用模块，以及如何创建和使用自己的包。2.数据处理列表、元组和集合：学习这些序列类型的操作和方法
Python Flask 使用数据库安果移不动 python flask 开发语言
pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
PaperWeekly sapienst Papers PaperwithCode General ML
1.Python软件包解决DL在未见过的数据分布下性能差的问题：（1）神经网络和损失分离的模块化设计（2）强大便捷的基准测试能力（3）易于使用但难以修改（4）github:https://github.com/marrlab/domainlabTrainer和Models之间是什么关系Trainer和Models是DomainLab中的两个核心概念。Trainer是一个用于指导数据流向模型并计算S
使用Python读取Excel文件并计算平均分嘻嘻爱编码 Python从入门到放弃 python excel 开发语言
在这篇博客中，我们将探讨如何使用Python的pandas库来读取Excel文件，并计算其中数据的平均分。pandas是一个强大的数据分析工具，它允许我们以简单直观的方式处理表格数据。安装必要的库在开始之前，确保你的环境中安装了pandas和openpyxl库。可以使用以下命令进行安装：pipinstallpandasopenpyxl读取Excel文件首先，我们需要读取Excel文件。假设我们有一
python项目练习——7.网站访问日志分析器 F—— python项目练习 python 信息可视化数据分析数据挖掘开发语言学习
项目功能分析：这个项目可以读取网站的访问日志文件，统计访问量、独立访客数、访问来源等信息，并以图表或表格的形式展示出来。这个项目涉及到文件操作、数据处理、数据可视化等方面的技术。示例代码：importrefromcollectionsimportCounterimportmatplotlib.pyplotaspltdefparse_log_file(log_file):#读取日志文件内容witho
python的while双重循环九九乘法表 Jinm_R python 开发语言
a=1whilea<=9:b=1#乘数每次需要从1开始whileb<=a:print(f"{a}*{b}={a*b}\t",end='')#\t为制表符使乘法表整齐end=''代表用空格代替换行b+=1a+=1print()#乘数每加一换行
【Python】成功解决ModuleNotFoundError: No module named ‘torchinfo‘ 高斯小哥 BUG解决方案合集 python pytorch 新手入门学习 debug
【Python】成功解决ModuleNotFoundError:Nomodulenamed‘torchinfo’个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文
Python自动化测试web常见框架汇总自动化测试薰儿软件测试技术分享 python 前端开发语言
1、前言目前，有非常多的Python框架，用来帮助你更轻松的创建web应用。这些框架把相应的模块组织起来，使得构建应用的时候可以更快捷，也不用去关注一些细节（例如socket和协议），所以需要的都在框架里了。接下来我们会介绍不同的选项。经过初期的不起眼，Python已经成为互联网最流行的服务端编程语言之一。根据W3Techs的统计，它被用于很多的大流量的站点很多的大流量的站点很多的大流量的站点，超
python安装jupter在线ide 晚风拂柳颜生活小经验 python3 ide jupter
我在虚拟3.6.8的环境里面安装的，具体用了以下命令；pipinstallipython-ihttps://mirrors.aliyun.com/pypi/simple/pipinstalljupyter-ihttps://mirrors.aliyun.com/pypi/simple/jupyternotebook当然，jupter可以直接通过python环境里script目录下的jupyter-
opencv 十八 python下实现0缓存掉线重连的rtsp直播流播放器摸鱼的机器猫 opencv实战 opencv python 缓存
使用opencv打开rtsp视频流时，会因为网络问题导致VideoCapture掉线；也会因为图像的后处理阶段耗时过长导致opencv缓冲区数据堆积，从而使程序无法及时处理最新的数据。为此对cv2.VideoCapture进行封装，实现0缓存掉线重连的rtsp直播流播放器，让程序能一直处理最新的数据。代码实现fromcollectionsimportdequeimportthreadingimpo
Windows如何安装poppler库，python的PDF转PPTX项目跨不过 pdf
资源库在这里下载https://github.com/oschwartz10612/poppler-windows/releases/tag/v21.03.0其他的参考这篇博客，里面提到的资源链接失效了https://blog.csdn.net/wy01415/article/details/110257130
用Python批量更改图片大小马达马达达 AI python
#提取目录下所有图片,更改尺寸后保存到另一目录fromPILimportImageimportos.pathimportglobdefconvertjpg(jpgfile,outdir,width=128,height=128):img=Image.open(jpgfile)try:new_img=img.resize((width,height),Image.BILINEAR)new_img.s
3.Python数据分析—数据分析入门知识图谱&索引(知识体系中篇) 以山河作礼。 Python数据分析项目数据分析知识图谱数据挖掘 python 开发语言
3.Python数据分析—数据分析入门知识图谱&索引-知识体系中篇一·个人简介二·数据获取和处理2.1数据来源：2.2数据清洗：2.2.1缺失值处理：2.2.2异常值处理：2.3数据转换：2.3.1数据类型转换：2.3.2数据编码：2.4数据合并与重塑：2.4.1数据合并：2.4.2数据拼接：2.4.3数据重塑：三·数据探索与分析3.1描述性统计分析3.2数据可视化原则和技巧3.3探索性数据分析（
SWIFT环境配置及大模型微调实践 weixin_43870390 swift 开发语言 ios
SWIFT环境配置及大模型微调实践SWIFT环境配置基础配置增量配置SWIFTQwen_audio_chat大模型微调实践问题1:问题2:问题定位解决方法手动安装pytorchSWIFT介绍参考：这里SWIFT环境配置基础配置condacreate-nswiftpython=3.8pipinstallms-swift[all]-U#下载项目gitclonehttps://github.com/mo
scala的option和some 矮蛋蛋编程 scala
原文地址： http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在本系列前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
NullPointerException Cb123456 android BaseAdapter
java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference 出现以上异常.然后就在baidu上
PHP使用文件和目录天子之骄 php文件和目录读取和写入 php验证文件 php锁定文件
PHP使用文件和目录 1.使用include()包含文件 (1)：使用include()从一个被包含文档返回一个值 (2)：在控制结构中使用include() include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。在php.ini文件中设置
SQL SELECT DISTINCT 语句何必如此 sql
SELECT DISTINCT 语句用于返回唯一不同的值。 SQL SELECT DISTINCT 语句在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 DISTINCT 关键词用于返回唯一不同的值。 SQL SELECT DISTINCT 语法 SELECT DISTINCT column_name,column_name F
java冒泡排序 3213213333332132 java 冒泡排序
package com.algorithm; /** * @Description 冒泡 * @author FuJianyong * 2015-1-22上午09:58:39 */ public class MaoPao { public static void main(String[] args) { int[] mao = {17,50,26,18,9,10
struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！ 7454103 DAO spring Ajax json qq
struts2.18 出来有段时间了！（貌似是稳定版）闲时研究下下！貌似 sruts2 搭配 json 做 ajax 很吃香！实践了下下！不当之处请绕过！呵呵网上一大堆 struts2+json 不过大多的json 插件都是 jsonplugin.34.jar strut
struts2 数据标签说明 darkranger jsp bean struts servlet Scheme
数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能数据标签主要包括： action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
链表.简单的链表节点构建 aijuans 编程技巧
/*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" #define NODE(name, key_word, help) \ Node name[1]={{NULL, NULL, NULL, key_word, help}} typedef struct node { &nbs
tomcat下jndi的三种配置方式 avords tomcat
jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。 tomcat配置
关于敏捷的一些想法 houxinyou 敏捷
从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 感觉表达的不太清楚。感觉容易被人误解的地方主要在“用户多变的需求”上。第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
富养还是穷养，决定孩子的一生 bijian1013 教育人生
是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
oracle 日期时间格式转化征客丶 oracle
oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； SYSDATE：不支持毫秒，取的是系统时间； SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。日期转字符窜：一、不取毫秒： TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 简要说明， YYYY 年 MM 月
【Scala六】分析Spark源代码总结的Scala语法四 bit1129 scala
1. apply语法 FileShuffleBlockManager中定义的类ShuffleFileGroup，定义： private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) { ... def apply(bucketId
Erlang中有意思的bug bookjovi erlang
代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b Author: Jovi Zhang <[email protected]> Date: Fri Dec 2 16:19:22 2011 +0100 erts:
移位打印10进制数转16进制-2008-08-18 ljy325 java 基础
/** * Description 移位打印10进制的16进制形式 * Creation Date 15-08-2008 9:00 * @author 卢俊宇 * @version 1.0 * */ public class PrintHex { // 备选字符 static final char di
读《研磨设计模式》-代码笔记-组合模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
利用cmd命令将.class文件打包成jar chenyu19891124 cmd jar
cmd命令打jar是如下实现：在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： cd D: 回车 cd workspace/prpal
[原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 comsci eclipse 设计模式算法工作 swing
JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 &nb
SecureCRT右键粘贴的设置 daizj secureCRT 右键粘贴
一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。菜单： Options->Global Options ...->Terminal 右边有个Mouse的选项块。 Copy on Select Paste on Right/Middle
Linux 软链接和硬链接 dongwei_6688 linux
1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
DIV底部自适应 dcj3sjt126com JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
Centos6.5使用yum安装mysql——快速上手必备 dcj3sjt126com mysql
第1步、yum安装mysql [root@stonex ~]# yum -y install mysql-server 安装结果： Installed: mysql-server.x86_64 0:5.1.73-3.el6_5 &nb
如何调试JDK源码 frank1234 jdk
相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。下面是编译jdk的具体步骤： 1.把C:\java\jdk1.6.0_26\sr
Maximal Rectangle hcx2013 max
Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area. public class Solution { public int maximalRectangle(char[][] matrix)
Spring MVC测试框架详解——服务端测试 jinnianshilongnian spring mvc test
随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。 Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 &nbs
Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0 liyong0802 hadoop
一、准备编译软件 1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。环境变量设置如下：（1）执行vim /etc/profile （2）在文件尾部加入: export JAVA_HOME=/home/spark/jdk1.7 export MAVEN_HOME=/ho
StatusBar 字体白色 pangyulei status
[[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent]; /*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
如何分析Java虚拟机死锁 sesame java thread oracle 虚拟机 jdbc
英文资料： Thread Dump and Concurrency Locks Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
位运算简介及实用技巧（一）：基础篇 tw_wangzhengquan 位运算
http://www.matrix67.com/blog/archives/263 去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
jsearch的索引文件结构 yangshangchuan 搜索引擎 jsearch 全文检索信息检索 word分词
jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。 jsearch的索引文件结构定义如下： 1、一个词的索引由=分割的三部分组成：第一部分是词第二部分是这个词在多少