~聊音小生。

快速上手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)

理解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代
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
使用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填
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&#
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作为一门
【华为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、波特五力这类分析法，为啥
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开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
自然语言处理_tf-idf _feivirus_ 算法机器学习和数学自然语言处理 tf-idf 逆文档频率词频
importpandasaspdimportmath1.数据预处理docA="Thecatsatonmyface"docB="Thedogsatonmybed"wordsA=docA.split("")wordsB=docB.split("")wordsSet=set(wordsA).union(set(wordsB))print(wordsSet){'on','my','face','sat',
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
python中的深拷贝与浅拷贝 anshejd70787 python
深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
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、一个词的索引由=分割的三部分组成：第一部分是词第二部分是这个词在多少