program常用标识

1：注释代码段

1
2
3
4
#program mark -[注释内容]
说明：用于注释内容
#program mark 是每个ios程序员都必须会用的技巧，通过#program mark 把代码分为个个部分，良好的注释是好代码的开始
# linking哥注：在xcode的代码页最上的目录最后，鼠标停住一会，就可以清晰的看到层次关系。亲测

2：取消xcode编译器内对于弃用方法的警告

1
2
3
4
5
6
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
  // 这段中出现使用所有的弃用方法都不会产生告警   
  // 这里放置弃用代码    
#pragma clang diagnostic pop
#linking哥注：项目中用到了

3：取消对未使用变量的警告，使用方式和2相同，必须成对出现#pragma clang

1
2
3
4
5
6
7
8
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"   
    // unused 代码段
#pragma clang diagnostic pop
# linking哥注：亲测
====================
#warning :手动产生一条告警
#error : 手动产生一条错误

还有种方式也能达到同样效果

1
#pragma unused (foo)

4: 忽略内存泄露告警

1
2
3
4
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
   [someController performSelector: NSSelectorFromString(@"someMethod")]
#pragma clang diagnostic pop

展开全文 >>

《利用Python进行数据分析》读书笔记-8-第八章-绘图和可视化

matplotlib API入门

Figure 和 Subplot

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import matplotlib.pyplot as plt

## Figure 和 Subplot
# matplotlib的图像都位于Figure对象中，构建新对象
fig = plt.figure()
# 不能通过Figure绘图，必须用add_subplot创建一个或多个subplot才行
ax1 = fig.add_subplot(2,2,1)
ax2 = fig.add_subplot(2,2,2)
ax3 = fig.add_subplot(2,2,3)
plt.show()
# 这三个是表示图像是2*2的，当前占编号1，2，3位

plt.plot([1.5,3.5,-2,1.6])

from numpy.random import randn
plt.plot(randn(50).cumsum(), 'k--')
plt.show()
# "k--"线型选项，黑色虚线图

# 随机柱状图，20柱，每柱间隔0.3
_ = ax1.hist(randn(100), bins=20, color='k', alpha=0.3)
# 随机散点图，30个点
ax2.scatter(np.arange(30), np.arange(30) + 3 * randn(30))
# plt.show()

颜色、标记和线型

1
2
3
4
plt.plot(randn(30).cumsum(), 'ko--')
# 等价于以下明确形式：R
# plot(randn(30).cumsum(), color='k', linestyle='dashed', marker='0')
plt.show()

图8-6带有标记的线型图

刻度、标签和图例

xlim xticks xticklabels
范围 刻度位置 刻度标签

标题、轴标签、刻度以及刻度标签

1
2
3
4
5
fig = plt.figure(); ax = fig.add_subplot(1,1,1)
ax.plot(randn(1000).cumsum())
ax.set_title('My first matplotlib plot')
ax.set_xlabel('Stages')
plt.show()

图8-8 用于演示xticks的简单线形图

添加图例

1
2
3
4
5
6
7
# 方式一：传入参数label
fig = plt.figure(); ax = fig.add_subplot(1,1,1)
ax.plot(randn(1000).cumsum(), 'k', label='one')
ax.plot(randn(1000).cumsum(), 'k--', label='two')
ax.plot(randn(1000).cumsum(), 'k.', label='three')
ax.legend(loc='best') # 添加图例
plt.show()

图8-8 用于演示xticks的简单线形图

图注解以及在Subplot上绘图

1
2
3
4
5
6
7
8
9
10
11
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
# 创建块对象
rect = plt.Rectangle((0.2,0.75),0.4,0.15,color='k',alpha=0.3)
circ = plt.Circle((0.7,0.2),0.15,color='b',alpha=0.3)
pgon = plt.Polygon([[0.15,0.15],[0.35,0.4],[0.2,0.6]],color='g',alpha=0.5)
# ax.add_patch(shp) 添加到subplot中
ax.add_patch(rect)
ax.add_patch(circ)
ax.add_patch(pgon)
plt.show()

图8-12 由三个块图形组成的图

将图标保存到文件

1
2
3
4
5
6
7
8
9
10
plt.savefig('figpath.svg')
plt.savefig('figpath.pdf')
# # dpi-分辨率，bbox_inches-剪除图标周围空白部分
plt.savefig('figpath.png', dpi=400, bbox_inches= 'tight')
# 以上都是存到磁盘，也可以存入文件型对象
from io import StringIO
buffer = StringIO()
plt.savefig(buffer)
plot_data = buffer.getvalue()
# 对在Web上提供生成的图片很实用

matplotlib配置

1
2
3
4
5
6
7
# 如设置图像大小
plt.rc('figure', figsize=10*10)
# 关键字参数，写成字典
font_options = {'family': 'monospace',
                'weight': 'bold',
                'size': 'small'}
plt.rc('font', **font_options)

pandas中的绘图函数

线形图

简单Series图表

1
2
3
4
5
from pandas import Series
from pandas import DataFrame
s = Series(np.random.randn(10).cumsum(), index=np.arange(0,100,10))
s.plot()
plt.show()

图8-13 简单Series图表

简单的DataFrame图表

1
2
3
df = DataFrame(np.random.randn(10,4).cumsum(0), columns=['A','B','C','D'],index=np.arange(0,100,10))
df.plot()
plt.show()

图8-14 简单的DataFrame图表

柱状图

1
2
3
4
5
6
# kind="bar"(垂直柱状图)，kind="barh"(水平柱状图)
fig, axes = plt.subplots(2, 1)
data = Series(np.random.rand(16), index=list('abcdefghijklmnop'))
data.plot(kind='bar', ax=axes[0],color='k', alpha=0.7)
data.plot(kind='barh', ax=axes[1],color='k', alpha=0.7)
plt.show()

图8-15 水平和垂直柱状图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
df = DataFrame(np.random.rand(6,4), index=['one', 'two', 'three', 'four', 'five', 'six'],
               columns=pd.Index(['A','B','C','D'],name='Genus'))

# print df
# Genus         A         B         C         D
# one    0.465771  0.579470  0.053485  0.863450
# two    0.550022  0.855826  0.967881  0.792683
# three  0.666868  0.536417  0.245592  0.839482
# four   0.439348  0.676450  0.637932  0.106940
# five   0.606376  0.609878  0.498459  0.010276
# six    0.923550  0.243204  0.422216  0.979446

df.plot(kind='bar')
plt.savefig('图8-16 DataFrame柱状图')
# plt.show()
# 设置stacked=True生成DataFrame的堆积柱状图，每行都堆积在一起
df.plot(kind='barh', stacked=True, alpha=0.5)
plt.savefig('图8-17 DataFrame堆积柱状图')
# plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
tips = pd.read_csv('../pydata-book-master/ch08/tips.csv')
party_counts = pd.crosstab(tips.day, tips.size)
# print party_counts
# col_0  1708
# day
# Fri      19
# Sat      87
# Sun      76
# Thur     62

party_counts = party_counts.ix[:, 2:5]
print party_counts

实战：绘制地图-图形化显示海地地震危机数据

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
data = pd.read_csv('../pydata-book-master/ch08/Haiti.csv')
# print data
# 拿出时间戳和位置信息
# print data[['INCIDENT DATE', 'LATITUDE', 'LONGITUDE']][:10]
#       INCIDENT DATE   LATITUDE   LONGITUDE
# 0  05/07/2010 17:26  18.233333  -72.533333
# 1  28/06/2010 23:06  50.226029    5.729886
# 2  24/06/2010 16:21  22.278381  114.174287
# 3  20/06/2010 21:59  44.407062    8.933989
# 4  18/05/2010 16:26  18.571084  -72.334671
# 5  26/04/2010 13:14  18.593707  -72.310079
# 6  26/04/2010 14:19  18.482800  -73.638800
# 7  26/04/2010 14:27  18.415000  -73.195000
# 8  15/03/2010 10:58  18.517443  -72.236841
# 9  15/03/2010 11:00  18.547790  -72.410010

# 消息类型
# print data['CATEGORY'][:6]
# 0          1. Urgences | Emergency, 3. Public Health,
# 1    1. Urgences | Emergency, 2. Urgences logistiqu...
# 2    2. Urgences logistiques | Vital Lines, 8. Autr...
# 3                            1. Urgences | Emergency,
# 4                            1. Urgences | Emergency,
# 5                       5e. Communication lines down,
# Name: CATEGORY, dtype: object

# 异常的地理位置
# print data.describe()
#             Serial     LATITUDE    LONGITUDE
# count  3593.000000  3593.000000  3593.000000
# mean   2080.277484    18.611495   -72.322680
# std    1171.100360     0.738572     3.650776
# min       4.000000    18.041313   -74.452757
# 25%    1074.000000    18.524070   -72.417500
# 50%    2163.000000    18.539269   -72.335000
# 75%    3088.000000    18.561820   -72.293570
# max    4052.000000    50.226029   114.174287

# 清除错误位置信息并移除缺失分类信息：
data = data[(data.LATITUDE > 18) & (data.LATITUDE < 20) &
            (data.LONGITUDE > -75) & (data.LONGITUDE < -70)
            & data.CATEGORY.notnull()]

# 编写函数获取所有分类的列表，将各个分类信息拆分为编码和英语名称
def to_cat_list(catstr):
    stripped = (x.strip() for x in catstr.split(','))
    return [x for x in stripped if x]

def get_all_categories(cat_series):
    cat_sets = (set(to_cat_list(x)) for x in cat_series)
    return sorted(set.union(*cat_sets))

def get_english(cat):
    code, names = cat.split('.')
    if '|' in names:
        names = names.split(' | ')[1]
    return code, names.strip()

# 测试get_english是否正常
# print get_english('2. Urgences logistiques | Vital Lines')
# ('2', 'Vital Lines')

all_cats = get_all_categories(data.CATEGORY)
# 生成器表达式
english_mapping = dict(get_english(x) for x in all_cats)

# print english_mapping['2a']
# Food Shortage

# print english_mapping['6c']
# Earthquake and aftershocks
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
# 抽取分类编码，构造全0DataFrame
def get_code(seq):
    return [x.split('.')[0] for x in seq if x]

all_codes = get_code(all_cats)
code_index = pd.Index(pd.unique(all_codes))
dummy_frame = DataFrame(np.zeros((len(data), len(code_index))), index=data.index, columns=code_index)
# print dummy_frame.ix[:, :6]
#         1   1a   1b   1c   1d    2
# 0     0.0  0.0  0.0  0.0  0.0  0.0
# 4     0.0  0.0  0.0  0.0  0.0  0.0
# 5     0.0  0.0  0.0  0.0  0.0  0.0
# 6     0.0  0.0  0.0  0.0  0.0  0.0
# 7     0.0  0.0  0.0  0.0  0.0  0.0
# 8     0.0  0.0  0.0  0.0  0.0  0.0
# 9     0.0  0.0  0.0  0.0  0.0  0.0
# 10    0.0  0.0  0.0  0.0  0.0  0.0

for row, cat in zip(data.index, data.CATEGORY):
    codes = get_code(to_cat_list(cat))
    dummy_frame.ix[row, codes] = 1

data = data.join(dummy_frame.add_prefix('category_'))
# print data.ix[:,10:15]
#       category_1  category_1a  category_1b  category_1c  category_1d
# 0            1.0          0.0          0.0          0.0          0.0
# 4            1.0          0.0          0.0          0.0          0.0
# 5            0.0          0.0          0.0          0.0          0.0
# 6            0.0          0.0          0.0          0.0          0.0
# 7            0.0          0.0          0.0          0.0          0.0
# 8            0.0          0.0          0.0          0.0          0.0
# 9            0.0          0.0          0.0          0.0          0.0
# 10           0.0          1.0          0.0          0.0          0.0

# Python绘制地图依赖于basemap工具集(http://matplotlib.github.com/basemap）插件
# 绘制黑白海地地图
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt

def basic_haiti_map(ax=None, lllat=17.25, urlat=20.25, lllon=-75, urlon=-71):
    # 创建极球面投影的Basemap实例
    m = Basemap(ax=ax, projection='stere',
                lon_0=(urlon + lllon) / 2,
                lat_0=(urlat + lllat) / 2,
                llcrnrlat=lllat, urcrnrlat=urlat,
                llcrnrlon=lllon, urcrnrlon=urlon,
                resolution='f')

    # 绘制海岸线、州届、国界以及地图边界
    m.drawcoastlines()
    m.drawstates()
    m.drawcountries()
    return m

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 10))
fig.subplots_adjust(hspace=0.05, wspace=0.05)

to_plot = ['2a', '1', '3c', '7a']
lllat = 17.25;urlat = 20.25;lllon = -75;urlon = -71

for code, ax in zip(to_plot, axes.flat):
    m = basic_haiti_map(ax, lllat=lllat, urlat=urlat, lllon=lllon, urlon=urlon)
    cat_data = data[data['category_%s' % code] == 1]
    # 计算地图的投影坐标
    x, y = m(cat_data.LONGITUDE, cat_data.LATITUDE)

    m.plot(x, y, 'k.', alpha=0.5)
    ax.set_title('%s: %s' % (code, english_mapping[code]))

展开全文 >>

《利用Python进行数据分析》读书笔记-7-第七章-数据规整化：清理、转换、合并与重塑

合并数据集

pandas对象中的数据可通过内置方式合并：

  • pandas.merge根据键将不同DataFrame种的行连接起来，实现的是数据库的连接操作；
  • panda.concat沿一条轴将多个对象堆叠在一起；
  • 实例方法combine_first将重复数据编结在一起，用一个对象中的值填写另一个中的缺失值。

数据库风格的DataFrame合并

数据集的合并（merge）和连接（join）是通过键将行连接起来的。

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
df1 = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                 'data1': range(7)})
df2 = DataFrame({'key': ['、a', 'b', 'c'],
                 'data2': range(3)})
# print df1
#    data1 key
# 0      0   b
# 1      1   b
# 2      2   a
# 3      3   c
# 4      4   a
# 5      5   a
# 6      6   b

# print df2
#    data2 key
# 0      0   a
# 1      1   b
# 2      2   c

# print pd.merge(df1, df2)
#    data1 key  data2
# 0      0   b      1
# 1      1   b      1
# 2      6   b      1
# 3      2   a      0
# 4      4   a      0
# 5      5   a      0
# 6      3   c      2

# 这里默认将重叠列列名当做键；显式指定哪列连接用on参数
pd.merge(df1, df2, on='key')
# 还可以分别指定左右连接的键值，left_on,right_on
# 默认merge"inner"连接，结果中的键是交集
# how参数，'inner'是交集，outer是并集

# 重复列名的处理
# merge的suffixes参数，指定附加到左右两个DataFrame对象的重叠列名上的字符串

两边都有的列就都有数据，一边有列一边的数据，没有就用缺省值NaN填充。

索引上的合并

DataFrame的连接键位于索引上；传入left_index=True或right_index=True（或两者）指定。

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
left1 = DataFrame({'key': ['a', 'b', 'c', 'a', 'b', 'a'],
                   'value': range(6)})
right1 = DataFrame({'group_value': [3.5, 7]}, index=['a', 'b'])
# print pd.merge(left1, right1, left_on='key', right_index=True)
#     key  value  group_value
# 0   a      0          3.5
# 3   a      3          3.5
# 5   a      5          3.5
# 1   b      1          7.0
# 4   b      4          7.0

# 若要取并集，用how='outer';一边没有的会用缺省值NaN填充
# print pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
#    key  value  group_value
# 0   a      0          3.5
# 3   a      3          3.5
# 5   a      5          3.5
# 1   b      1          7.0
# 4   b      4          7.0
# 2   c      2          NaN

# 层次化索引，暂时不看了，用到再研究；
# 层次化索引，只是指明合并键是多个列的列表形式，left_on=['a','b']

# DataFrame的join方法，可以实现同样的功能，而不管是否有重叠列
# left.join([right, another])

对于像这样的东西，了解一下，知道有这么个东西，以后用到能想到，查一下；
现在第一次看没必要看得这么深，也很难懂，看不懂还影响了心情。

轴向连接

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
arr = np.arange(12).reshape((3, 4))
# print arr
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# print np.concatenate([arr,arr],axis=1)
# [[ 0  1  2  3  0  1  2  3]
#  [ 4  5  6  7  4  5  6  7]
#  [ 8  9 10 11  8  9 10 11]]

s1 = Series([0, 1], index=['a', 'b'])
s2 = Series([2, 3, 4], index=['c', 'd', 'e'])
s3 = Series([5, 6], index=['f', 'g'])
# print pd.concat([s1,s2,s3])
# a    0
# b    1
# c    2
# d    3
# e    4
# f    5
# g    6
# dtype: int64

# 默认concat在axis=0上工作，产生一个新的Series，如axis=1(axis=1是列)则会产生一个DataFrame
# print pd.concat([s1, s2, s3], axis=1)
#      0    1    2
# a  0.0  NaN  NaN
# b  1.0  NaN  NaN
# c  NaN  2.0  NaN
# d  NaN  3.0  NaN
# e  NaN  4.0  NaN
# f  NaN  NaN  5.0
# g  NaN  NaN  6.0

合并重叠数据

NumPy的where函数，实现合并两个有重叠部分数据集；Series的combine_first方法实现同样的功能，且数据对齐。

重塑和轴向旋转

重新排列表格型数据的基础运算，谓之重塑(reshape)或轴向旋转运算(pivot)。

重塑层次化索引

  • stack：将列转为行；
  • unstack：将行转为列。

数据转换

移除重复数据

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
data = DataFrame({'k1':['one']*3 + ['two']*4,
                  'k2':[1,1,2,3,4,4,5]})
# print data
#     k1  k2
# 0  one   1
# 1  one   1
# 2  one   2
# 3  two   3
# 4  two   4
# 5  two   4
# 6  two   5

## 判断重复
# print data.duplicated()
# 0    False
# 1     True
# 2    False
# 3    False
# 4    False
# 5     True
# 6    False
# dtype: bool

## 移除重复
# print data.drop_duplicates()
#     k1  k2
# 0  one   1
# 2  one   2
# 3  two   3
# 4  two   4
# 6  two   5

## 指定判断重复项的列；如还有一列值，只通过k1过滤重复项
data['v1'] = range(7)
# print data.drop_duplicates(['k1'])
#     k1  k2  v1
# 0  one   1   0
# 3  two   3   3

了解到有这么个知识点可以完成那些功能，将来遇到要实现的时候能回忆起来就可以了。

利用函数或映射进行数据转换

Series的map方法可接受一个函数或含有映射关系的自典型对象。

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
## 肉类
data = DataFrame({'food': ['bacon', 'pulled pork', 'bacon', 'Pastrami', 'coned', 'Bacon', 'Pastrami', 'honey', 'nova'],
                  'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
# print data
#           food  ounces
# 0        bacon     4.0
# 1  pulled pork     3.0
# 2        bacon    12.0
# 3     Pastrami     6.0
# 4        coned     7.5
# 5        Bacon     8.0
# 6     pastrami     3.0
# 7        honey     5.0
# 8         nova     6.0

## 添加该肉类食物的动物本体
meat_to_animal = {
    'bacon': 'pig',
    'pulled pork': 'pig',
    'Pastrami': 'cow',
    'coned': 'cow',
    'honey': 'pig',
    'nova': 'salmon'
}
data['animal'] = data['food'].map(str.lower).map(meat_to_animal)
## 转换了大小写
# print data
#         food  ounces  animal
# 0        bacon     4.0     pig
# 1  pulled pork     3.0     pig
# 2        bacon    12.0     pig
# 3     Pastrami     6.0     NaN
# 4        coned     7.5     cow
# 5        Bacon     8.0     pig
# 6     Pastrami     3.0     NaN
# 7        honey     5.0     pig
# 8         nova     6.0  salmon

## map是一种实现元素级转换以及其他数据清理工作的便捷方式。

替换值

replace提供了简单灵活的替换方式。

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
data = Series([1.,-999.,2.,-999.,-1000.,3.])
# print data
# 0       1.0
# 1    -999.0
# 2       2.0
# 3    -999.0
# 4   -1000.0
# 5       3.0
# dtype: float64

## -999可能是缺失数据标记值，替换成pandas的NA
# print data.replace(-999, np.nan)
# 0       1.0
# 1       NaN
# 2       2.0
# 3       NaN
# 4   -1000.0
# 5       3.0
# dtype: float64

## 一次替换多个值为一个值
# print data.replace([-999,-1000], np.nan)
# 0    1.0
# 1    NaN
# 2    2.0
# 3    NaN
# 4    NaN
# 5    3.0
# dtype: float64

## 分别替换为不同值
# print data.replace([-999,-1000], [np.nan,0])
# 0    1.0
# 1    NaN
# 2    2.0
# 3    NaN
# 4    0.0
# 5    3.0
# dtype: float64

字符串操作

字符串对象方法

1.连接符
join连接列表或元祖

1
2
3
4
# print piece 
# ['a','b','c']
# print '::'.join(pieces)
# 'a::b::c'

2.子串定位in关键字

1
2
3
4
5
# print 'guido' in val
# True
## 可以用index和find查找子串
val.index(',')
val.find(':')

3.count计算子串出现的次数

1
val.conut(',')

正则表达式

re模块函数可分三大类：模式匹配
替换以及拆分。

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
import re

# 空白符（制表符、空格、换行符等）
# text = "foo bar\t baz \tqux"
# print re.split('\s+', text)
# ['foo', 'bar', 'baz', 'qux']

# re.compile编译regex以得到一个可重用的regex对象
regex = re.compile('\s+')
# print regex.split(text)
# ['foo', 'bar', 'baz', 'qux']
# print regex.findall(text)
# [' ', '\t ', ' \t']
# 建议使用re.compile创建regex对象，节省CPU

# re.IGNORECASE对大小写不敏感

text1 = """Dave lin@qq.com
lin king@163.com
king wu@sina.com
ryle ryal@gmail.com
"""

pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2，4}'
regex = re.compile(pattern, flags=re.IGNORECASE)
# print regex.findall(text1)
# []

m = regex.search(text1)
# print m
# none

# regex.sub方法匹配成指定字符串
# print regex.sub('REDACTED', text1)

# 将邮件地址分成用户名、域名及域后缀三部分，用()包起来即可
pattern1 = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
regex1 = re.compile(pattern1, flags=re.IGNORECASE)

pandas中矢量化的字符串函数

清理散乱数据，字符串规整化工作。
data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但如果存在NA就会报错。通过Series的str属性即可访问这些方法。如str.contains检查是否含”gmail”.

1
data.str.contains('gmail')

示例：USDA食品数据库

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import json

db = json.load(open('../pydata-book-master/ch07/foods-2011-10-03.json'))

# print len(db)
# 6636

# print db[0].keys()
# [u'portions', u'description', u'tags', u'nutrients', u'group', u'id', u'manufacturer']

# print db[0]['nutrients'][0]
# {u'units': u'g', u'group': u'Composition', u'description': u'Protein', u'value': 25.18}

# nutrients = DataFrame(db[0]['nutrients'])
# print nutrients[:7]
#                    description        group units    value
# 0                      Protein  Composition     g    25.18
# 1            Total lipid (fat)  Composition     g    29.20
# 2  Carbohydrate, by difference  Composition     g     3.06
# 3                          Ash        Other     g     3.28
# 4                       Energy       Energy  kcal   376.00
# 5                        Water  Composition     g    39.28
# 6                       Energy       Energy    kJ  1573.00

# DataFrame可以只抽取一部分字段，如食物的名称、分类、编号以及制造商
info_key = ['description', 'group', 'id', 'manufacturer']
info = DataFrame(db, columns=info_key)
# print info[:5]
#                           description                   group    id  manufacturer
# 0                     Cheese, caraway  Dairy and Egg Products  1008
# 1                     Cheese, cheddar  Dairy and Egg Products  1009
# 2                        Cheese, edam  Dairy and Egg Products  1018
# 3                        Cheese, feta  Dairy and Egg Products  1019
# 4  Cheese, mozzarella, part skim milk  Dairy and Egg Products  1028

# 查看食物类别分布情况
# print pd.value_counts(info.group)[:10]
# Vegetables and Vegetable Products    812
# Beef Products                        618
# Baked Products                       496
# Breakfast Cereals                    403
# Legumes and Legume Products          365
# Fast Foods                           365
# Lamb, Veal, and Game Products        345
# Sweets                               341
# Fruits and Fruit Juices              328
# Pork Products                        328
# Name: group, dtype: int64

nutrients = []
for rec in db:
    fnuts = DataFrame(rec['nutrients'])
    fnuts['id'] = rec['id']
    nutrients.append(fnuts)

nutrients = pd.concat(nutrients, ignore_index=True)
# print  nutrients
# 丢弃重复项
# print nutrients.duplicated().sum()
# 14179
# nutrients = nutrients.drop_duplicates()
# print nutrients

# 明确重命名
col_mapping = {'description': 'food',
               'group': 'fgroup'}

# info = info.rename(columns=col_mapping, copy=False)
# print info

展开全文 >>

ListView嵌套GridView显示多张图片出现图片重复、错乱、闪烁等问题

场景

为了实现一个订单下多个商品同时评价功能，列表分五种状态（非常满意，满意，一般，较差，不满意）展示，用一个listview，item中有一个GridView，GridView中放置最多五张图片；在listview上下滑动时会出现item中的图片重复、错乱、闪烁等问题。

我的错误

先讲我的错误。遇到问题后Google，参考了一些资料，都是提示要在外层listview的adapter上设置setTag(), 然后在内层GridView的adapter上整体和需要标记复用的imageView上setTag()。照此执行了，还是出错；后来在同事指点下，原来外层adapter中设置gridAdapter时只是在没有塞值时gridView.setVisibility(View.GONE)，忘了要在有值的时候gridView.setVisibility(View.VISIBLE)， 所以导致在复用的时候，没有了GridView可复用。

more >>

展开全文 >>

《利用Python进行数据分析》读书笔记-6-第六章-数据加载、存储和数据格式

输入输出分类：

  • 读取文本文件
  • 其他更高效的磁盘存储格式
  • 加载数据库中数据
  • 利用Web API操作网络资源

读取文本格式的数据

pandas提供了将表格数据读取为DataFrame对象的函数；其中read_csv和read_table是应用最多的两个：

函数 说明
read_csv 从文件、URL、文件型对象中加载带分隔符的数据；默认逗号
read_table 从文件、URL、文件型对象中加载带分隔符的数据；默认制表符”\t”

类型推断是这些函数中最重要的功能之一。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$ cat ex1.csv
<!--out: -->
<!--a,b,c,d,message-->
<!--0,1,2,3,4,hello-->
<!--1,5,6,7,8,world-->
<!--2,9,10,11,12,foo-->
#以上数据用逗号隔开

import pandas as pd
import numpy as np
from pandas import Series, DataFrame

df = pd.read_csv('../pydata-book-master/ch06/ex1.csv')
# print df
#  a   b   c   d message
# 0  1   2   3   4   hello
# 1  5   6   7   8   world
# 2  9  10  11  12     foo
pt = pd.read_table('../pydata-book-master/ch06/ex1.csv', sep=',')
# print pt
# out: 同上

对于没有标题行的文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$ cat ex2.csv
<!--out: --> 
<!--0,1,2,3,4,hello-->
<!--1,5,6,7,8,world-->
<!--2,9,10,11,12,foo-->

# 自动分配默认列名

# pc = pd.read_csv('../pydata-book-master/ch06/ex2.csv', header=None)
# print pc
#    0   1   2   3      4
# 0  1   2   3   4  hello
# 1  5   6   7   8  world
# 2  9  10  11  12    foo
# 手动定义列名
# pc2 = pd.read_csv('../pydata-book-master/ch06/ex2.csv', names=['a','b','c','d','msg'])
# print pc2
#    a   b   c   d    msg
# 0  1   2   3   4  hello
# 1  5   6   7   8  world
# 2  9  10  11  12    foo

指定索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 指定索引
names = ['a','b','c','d','msg']
pc3 = pd.read_csv('../pydata-book-master/ch06/ex2.csv', names=names, index_col='msg')
# print pc3
#        a   b   c   d
# msg
# hello  1   2   3   4
# world  5   6   7   8
# foo    9  10  11  12
# 层次化索引
parsed = pd.read_csv('../pydata-book-master/ch06/csv_mindex.csv', index_col=['key1', 'key2'])
# print parsed
#            value1  value2
# key1 key2
# one  a          1       2
#      b          3       4
#      c          5       6
#      d          7       8
# two  a          9      10
#      b         11      12
#      c         13      14
#      d         15      16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 非固定分隔符，需要正则表达式
# print list(open('../pydata-book-master/ch06/ex3.csv'))
# ['            A         B         C\n',
#  'aaa -0.264438 -1.026059 -0.619500\n',
#  'bbb  0.927272  0.302904 -0.032399\n',
#  'ccc -0.264273 -0.386314 -0.217601\n',
#  'ddd -0.871858 -0.348382  1.100491']
# 观察到该文件各个字段由不定数量的空白符分割，用`\s+`这个正则来表示：
result = pd.read_table('../pydata-book-master/ch06/ex3.csv', sep='\s+')
# print result
#             A         B         C
# aaa -0.264438 -1.026059 -0.619500
# bbb  0.927272  0.302904 -0.032399
# ccc -0.264273 -0.386314 -0.217601
# ddd -0.871858 -0.348382  1.100491

跳过异常行(使用参数skiprows)

1
2
3
4
5
6
7
8
$ cat ch06/ex4.csv 
# hey!
a,b,c,d,message
# just wanted to make things more difficult for you
# who reads CSV files with computers, anyway?
1,2,3,4,hello
5,6,7,8,world
9,10,11,12,foo%

可以认为1，3，4行为异常数据

1
2
3
4
5
print pd.read_csv('../pydata-book-master/ch06/ex4.csv', skiprows=[0,2,3])
#    a   b   c   d message
# 0  1   2   3   4   hello
# 1  5   6   7   8   world
# 2  9  10  11  12     foo

逐块读取文本文件

大文件只想读取一小部分或者逐块对文件进行迭代

1
2
3
4
5
6
7
8
result = pd.read_csv('../pydata-book-master/ch06/ex6.csv', nrows=5)
# print result
#         one       two     three      four key
# 0  0.467976 -0.038649 -0.295344 -1.824726   L
# 1 -0.358893  1.404453  0.704965 -0.200638   B
# 2 -0.501840  0.659254 -0.421691 -0.057688   G
# 3  0.204886  1.074134  1.388361 -0.982404   R
# 4  0.354628 -0.133116  0.283763 -0.837063   Q

逐块读取;用到chunksize(行数)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# chunker = pd.read_csv('../pydata-book-master/ch06/ex6.csv', chunksize=100)
# print chunker
# <pandas.io.parsers.TextFileReader object at 0x10f6175d0>
# TextFileReader对象可实现盾剑逐块迭代
chunker = pd.read_csv('../pydata-book-master/ch06/ex6.csv', chunksize=1000)
tot = Series([])
for piece in chunker:
    tot = tot.add(piece['key'].value_counts(), fill_value=0)
tot = tot.sort_values(ascending=False)
print tot[:10]
# E    368.0
# X    364.0
# L    346.0
# O    343.0
# Q    340.0
# M    338.0
# J    337.0
# F    335.0
# K    334.0
# H    330.0
# dtype: float64

将数据写到文本格式

1
2
3
4
5
6
data = pd.read_csv('../pydata-book-master/ch06/ex5.csv')
# print data
#   something  a   b     c   d message
# 0       one  1   2   3.0   4     NaN
# 1       two  5   6   NaN   8   world
# 2     three  9  10  11.0  12     foo

pandas.read_csv生成的是DataFrame对象；

DataFrame的to_csv方法，可以将数据写到一个用逗号分隔的文件中

1
2
3
4
5
6
7
8
9
10
11
12
13
data.to_csv('./ch06_out.csv')
# $ cat ./ch06_out.csv
# ,something,a,b,c,d,message
# 0,one,1,2,3.0,4,
# 1,two,5,6,,8,world
# 2,three,9,10,11.0,12,foo

# 可以指定分隔符,如|；这里只为了展示，所以用sys.stdout直接打印出来了。
data.to_csv(sys.stdout, sep='|')
# |something|a|b|c|d|message
# 0|one|1|2|3.0|4|
# 1|two|5|6||8|world
# 2|three|9|10|11.0|12|foo

将缺失值替换为其他标记值

1
2
3
4
5
data.to_csv(sys.stdout, na_rep='NULL')
# ,something,a,b,c,d,message
# 0,one,1,2,3.0,4,NULL
# 1,two,5,6,NULL,8,world
# 2,three,9,10,11.0,12,foo

只输出特定列，指定顺序

1
2
3
4
5
data.to_csv(sys.stdout, index=False, columns=['a', 'b', 'c'])
# a,b,c
# 1,2,3.0
# 5,6,
# 9,10,11.0

Series也有to_csv()方法

1
2
3
4
5
6
7
8
9
10
datas = pd.date_range('1/1/2000', periods=7)
ts = Series(np.arange(7), index=datas)
ts.to_csv('./ch06tsseries.csv')
# 2000-01-01,0
# 2000-01-02,1
# 2000-01-03,2
# 2000-01-04,3
# 2000-01-05,4
# 2000-01-06,5
# 2000-01-07,6

更简单的读取方法from_csv

1
2
3
4
5
6
7
8
9
# print Series.from_csv('./ch06tsseries.csv', parse_dates=True)
# 2000-01-01    0
# 2000-01-02    1
# 2000-01-03    2
# 2000-01-04    3
# 2000-01-05    4
# 2000-01-06    5
# 2000-01-07    6
# dtype: int64

手工处理分隔符格式

场景：pandas.read_table加载表格数据时，由于畸形行导致错误

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
# $ cat ch06/ex7.csv
# "a","b","c"
# "1","2","3"
# "1","2","3","4"

import csv

lines = list(csv.reader(open('../pydata-book-master/ch06/ex7.csv')))
headers, values = lines[0], lines[1:]
data_dict = {h: v for h, v in zip(headers, zip(*values))}
# print data_dict
# {'a': ('1', '1'), 'c': ('3', '3'), 'b': ('2', '2')}

class my_dialect(csv.Dialect):
    lineterminator = '\n'
    delimiter = ';'
    quotechar = '"'
    quoting = csv.QUOTE_ALL

# delimiter分隔符指定

f = open('../pydata-book-master/ch06/ex7.csv')
reader = csv.reader(f, dialect=my_dialect)
# print reader
# <_csv.reader object at 0x10a5bb440>
# 以上类的参数也可以单个的传入csv.reader方法

手动写入分隔符文件csv.writer

1
2
3
4
5
6
7
8
9
10
11
with open('mydata.csv', 'w') as fw:
    writer = csv.writer(fw, my_dialect)
    writer.writerow(("one", "two", "three"))
    writer.writerow(('1', '2', '3'))
    writer.writerow(('4', '5', '6'))
    writer.writerow(('7', '8', '9'))
# out: mydata.csv
# "one";"two";"three"
# "1";"2";"3"
# "4";"5";"6"
# "7";"8";"9"

tip:一些东西还是要看源码才最直接

JSON数据

JSON已成为HTTP请求在Web浏览器和其他程序之间发送数据的标准格式之一、

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
obj1 = """
{"name": "Wes",
"places_lived": ["United States", "Spain", "Germany"],
"pet":null,
"siblings":[{"name":"Scott", "age":25, "pet":"Zuko"}, {"name":"Katie", "age":22, "pet":"Cisco"}]
}
"""
import json
# json.loads将JSON字符串转换成Python形式
result = json.loads(obj1)
# print result
# {u'pet': None,
# u'siblings': [{u'pet': u'Zuko', u'age': 25, u'name': u'Scott'},
#               {u'pet': u'Cisco', u'age': 22, u'name': u'Katie'}],
# u'name': u'Wes',
# u'places_lived': [u'United States', u'Spain', u'Germany']}
# 对应的，json.dumps将Python转换成JSON形式
asjson = json.dumps(result)
# print asjson
# {"pet": null, "siblings": [{"pet": "Zuko", "age": 25, "name": "Scott"},
#                            {"pet": "Cisco", "age": 22, "name": "Katie"}],
#  "name": "Wes", "places_lived": ["United States", "Spain", "Germany"]}

XML和HTML：Web信息收集

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# http://finance.yahoo.com/quote/AAPL/options?ltr=1
from lxml.html import parse
from urllib2 import urlopen
# 原网址404，在雅虎随便找了一个阿里巴巴的
# parsed = parse(urlopen('http://finance.yahoo.com/quote/BABA/options?p=BABA'))
# doc = parsed.getroot()
# 通过上面的对象，可获取特定的tag
# 如获取所有的链接；<a href="#">word</a>
# links = doc.findall('.//a')
# print links[:5]
# [<Element a at 0x1109ace10>,
# <Element a at 0x1109ace68>,
# <Element a at 0x1109acec0>,
# <Element a at 0x1109acf18>,
# <Element a at 0x1109acf70>]
# lnk = links[7]
# print lnk
# <Element a at 0x1040d3628>
# 从以上对象中提取出href
# print len(links)
# 50个
# print lnk.get('href')
# https://www.yahoo.com/celebrity/
# print lnk.text_content()
# Celebrity

# 构建列表推导式，获取全部URL
# urls = [lnk1.get('href') for lnk1 in doc.findall('.//a')]
# print urls[-10:]
# ['//finance.yahoo.com/broker-comparison?bypass=true',
# 'https://help.yahoo.com/kb/index?page=content&y=PROD_MAIL_ML&locale=en_US&id=SLN2310&actp=productlink',
# 'http://help.yahoo.com/l/us/yahoo/finance/',
# 'https://yahoo.uservoice.com/forums/382977',
# 'http://info.yahoo.com/privacy/us/yahoo/',
# 'http://info.yahoo.com/relevantads/',
# 'http://info.yahoo.com/legal/us/yahoo/utos/utos-173.html',
# 'http://twitter.com/YahooFinance',
# 'http://facebook.com/yahoofinance',
# 'http://yahoofinance.tumblr.com']

# 从文档中找出正确的表格就是反复试验
# parsed1 = parse(urlopen('http://finance.yahoo.com/quote/BABA/options?p=BABA'))
# doc1 = parsed1.getroot()
# tables = doc1.findall('.//table')
# calls = tables[0]
# puts = tables[0]
# rows = calls.findall('.//tr')
# print rows[0].text_content()
# Search
# def unpack(row, kind='td'):
#     elts = row.findall('.//%s' % kind)
#     return [val.text_content() for val in elts]

# print unpack(rows[0], kind='th')
# 由于对Safari怎么获取XPath不熟悉，后期还要专门了解
# 原网址变动，书本代码无法运行，需要深入理解改写一下
# 完全照着书本敲收效甚微

# 利用lxml.objectify解析XML
from lxml import objectify
path = '../pydata-book-master/ch06/mta_perf/Performance_MNR.xml'
parsed2 = objectify.parse(open(path))
root = parsed2.getroot()
print root

利用lxml.objectify解析XML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from lxml import objectify
# path = '../pydata-book-master/ch06/mta_perf/Performance_MNR.xml'
# parsed2 = objectify.parse(open(path))
# root = parsed2.getroot()
# print root

# 解析HTML标签
from StringIO import StringIO
tag = '<a href="http://www.google.com">Google</a>'
root = objectify.parse(StringIO(tag)).getroot()
# print root.get('href')
# http://www.google.com
# print root.text
# Google

二进制数据格式

1
2
3
4
5
6
7
8
9
# 保存到磁盘上
frame = pd.read_csv('../pydata-book-master/ch06/ex1.csv')
# print  frame
#    a   b   c   d message
# 0  1   2   3   4   hello
# 1  5   6   7   8   world
# 2  9  10  11  12     foo
# 从磁盘读取到Python对象中
print pd.load('../pydata-book-master/ch06/frame_pickle')

读取Microsoft Excel文件(pandas的ExcelFile类）

1
2
3
4
5
6
7
8
xls_file = pd.ExcelFile('../pydata-book-master/ch06/ex1.xlsx')
# 将某个工作表中的数据通过parse读取到DataFrame中
table = xls_file.parse('Sheet1')
# print table
#    a   b   c   d message
# 0  1   2   3   4   hello
# 1  5   6   7   8   world
# 2  9  10  11  12     foo

使用HTML和Web API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import requests
url = 'https://www.google.com.hk/search?safe=strict&site=&source=hp&q=test&btnK=Google+搜索'
resp = requests.get(url)
# print resp
# <Response [200]>
# Web API一般返回JSON字符串
import json
data = json.loads(resp.text)
# print data.keys()
# ValueError: No JSON object could be decoded
# 书上的Twitter链接打不开

# 取出感兴趣的tweet字段，然后将results列表传给DataFrame
tweet_field = ['created_at', 'from_user', 'id', 'text']
tweets = DataFrame(data['result'], columns=tweet_field)
# print tweets
# DataFrame中每一行有了来自一条tweet的数据
tweets._ix[7]

使用数据库

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
41
42
43
44
45
# 数据库选择标准：性能、数据完整性、应用程序的伸缩性需求
# 引入Python内置的sqlite3驱动器
import sqlite3
query = """
CREATE TABLE test (a VARCHAR(20), b VARCHAR(20),
c REAL, d INTEGER
);"""
con = sqlite3.connect(':memory:')
con.execute(query)
con.commit()
# 插入几条数据
data = [('Atlanta', 'Georgia', 1.25, 6),
        ('Wangjiang', 'Maoan', 2.5, 5),
        ('Hefei', 'Gaoxing', 5.5, 9)]
stmt = "INSERT INTO test VALUES(?,?,?,?)"
con.executemany(stmt, data)
con.commit()
# 从表中选取数据
cursor = con.execute('select * from test')
rows = cursor.fetchall()
# print rows
# [(u'Atlanta', u'Georgia', 1.25, 6),
(u'Wangjiang', u'Maoan', 2.5, 5), 
(u'Hefei', u'Gaoxing', 5.5, 9)]
# 列名位于游标的description属性中
# print cursor.description
# (('a', None, None, None, None, None, None),
# ('b', None, None, None, None, None, None),
# ('c', None, None, None, None, None, None),
# ('d', None, None, None, None, None, None))
# 传入DataFrame
# print DataFrame(rows, columns=zip(*cursor.description)[0])
#            a        b     c  d
# 0    Atlanta  Georgia  1.25  6
# 1  Wangjiang    Maoan  2.50  5
# 2      Hefei  Gaoxing  5.50  9

# pandas有一个简化过程的read_frame函数
import pandas.io.sql as sql
# 书本上read_frame已失效
# print sql.read_sql('select * from test', con)
#            a        b     c  d
# 0    Atlanta  Georgia  1.25  6
# 1  Wangjiang    Maoan  2.50  5
# 2      Hefei  Gaoxing  5.50  9

存取MongoDB数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 电脑上需要装MongoDB数据库；
# 使用pymongo驱动通过默认端口连接
# 存储在MongoDB中的文档被组织在数据库的集合（想象成表）
# 没有装，姑且记录一下该怎么写,留作参考
import pymongo
con = pymongo.Connection('localhost', port=27017)
# MongoDB服务运行的每个实例可以有多个数据库，每个数据库又可以有多个集合。
# 访问之前获取的tweets集合
tweets = con.db.tweets
# 加载数据并存入集合
import requests, json

url = 'https://www.google.com.hk/search?safe=strict&site=&source=hp&q=test&btnK=Google+搜索'
data = json.loads(requests.get(url).text)
for tweet in data['results']:
    tweets.save(tweet)

# 从集合中取出
cursor = tweets.find({'from_user': 'linking'})
# 转换成DataFrame
tweet_fileds = ['create_at', 'from_user', 'id', 'text']
result = DataFrame(list(cursor), columns=tweet_fileds)

走过了一遍第六章，给我的感觉是，工具很强大，可以做很多数据分析工作，数据结构知识还是匮乏，一些比较复杂的东西还是不能很好的理解，需要加强，多看几遍也是一个方法。

时间上，下班时间有点晚，可以看书的时间都在9点左右，有点晚，太累了，以后下班是不是可以早一点，做饭时间吃饭时间太晚；另外严重缺乏锻炼了，涨了一些肉的，膝盖还是没有恢复，需要针对性锻炼。

记一下，博客的评论插件，多说社会化评论系统已经关闭；选择移除多说或者换成其他的。

………………………………………………2017-03-25 22:57 Sat&合肥-皖水公寓

展开全文 >>

《利用Python进行数据分析》读书笔记-第五章-pandas入门

pandas数据结构介绍

Series

  • Series最重要的一个功能：在算术运算中会自动对齐不同索引的数据（键相同）。
  • Series对象本身及其索引都有一个name属性。
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# 一组 key: value
# obj = Series([4,5,7,-3])
# print obj
# out:
# 0    4
# 1    5
# 2    7
# 3   -3
# dtype: int64
# print obj.values
# out：[ 4  5  7 -3]
# print obj.index
# out:RangeIndex(start=0, stop=4, step=1)

obj2 = Series([3, 5, -7, 9], index=['a', 'd', 'b', 'c'])
# print obj2
# out:
# a    3
# d    5
# b    7
# c    9
# dtype: int64
# print obj2['d']
# out: 5
# print obj2[['d','c','b']]
# out:
# d    5
# c    9
# b    7
# dtype: int64
# print obj2[obj2>0]
# out:
# a    3
# d    5
# c    9
# dtype: int64
# print 'b' in obj2
# out: True

# 通过字典创建Series
sdata = {'aaa': 41, 'bbb': 51, 'ccc': 61, 'ddd': 71}
obj3 = Series(sdata)
# print obj3
# out：
# aaa    41
# bbb    51
# ccc    61
# ddd    71
# dtype: int64
# 传入一个值，作为键
states = ['aaa', 'bbb', 'ddd', 'eee']
obj4 = Series(sdata, index=states)
# print obj4
# out:
# aaa    41
# bbb    51
# ddd    71
# eee    NaN
# dtype: int64
# 第四个值eee找不到键

# isnull,notnull检测缺失数据
# print pd.isnull(obj4)
# out:
# aaa    False
# bbb    False
# ddd    False
# eee     True
# dtype: bool

# 算术运算，自动对齐键
# print obj3+obj4
# our:
# aaa     82.0
# bbb    102.0
# ccc      NaN
# ddd    142.0
# eee      NaN
# dtype: float64

obj4.name = 'population'
obj4.index.name = 'state'
# print obj4
# out:
# state
# aaa    41.0
# bbb    51.0
# ddd    71.0
# eee     NaN
# Name: population, dtype: float64

# 索引改变：
obj4.index = ['bob', 'fds', 'a33', '8uk']
# print obj4

DataFrame

DataFrame是一个表格型的数据结构，含有一组有序的列，每列可以是不同的值类型。既有行索引也有列索引。可看做由Series组成的字典。
以二维结构保存数据，可视为多维数据（层次化索引的表格型结构是pandas中许多高级数据处理功能的关键要素）。

  1. 构建DataFrame方式一

    方式一：直接传入一个由等长列表或NumPy数组组成的字典：

1
2
3
4
5
6
7
8
9
10
11
12
13
## 构建
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2003, 2004],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame1 = DataFrame(data)
# print frame1
# out:
#    pop   state  year
# 0  1.5    Ohio  2000
# 1  1.7    Ohio  2001
# 2  3.6    Ohio  2002
# 3  2.4  Nevada  2003
# 4  2.9  Nevada  2004

1.1. 指定列序列

1
2
3
4
5
6
7
8
9
10
frame2 = DataFrame(data, columns=['year', 'state', 'pop'])
# print frame2
# out:
#    year   state  pop
# 0  2000    Ohio  1.5
# 1  2001    Ohio  1.7
# 2  2002    Ohio  3.6
# 3  2003  Nevada  2.4
# 4  2004  Nevada  2.9
# 若找不到列，就会显示NaN

1.2. 通过字典标记方式或属性方式，获取一个Series

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# print frame2['state']
# out:
# 0      Ohio
# 1      Ohio
# 2      Ohio
# 3    Nevada
# 4    Nevada
# Name: state, dtype: object
# print frame2.year
# out:
# 0    2000
# 1    2001
# 2    2002
# 3    2003
# 4    2004
# Name: year, dtype: int64

1.3. 行，通过名称或位置获取，如用索引字段ix

1
2
3
4
5
6
# print frame2.ix[1]
# out：
# year     2001
# state    Ohio
# pop       1.7
# Name: 1, dtype: object

1.4. 直接给列赋值，新建test列，赋值2.3

1
2
3
4
5
6
7
8
9
frame2['test'] = 2.3
# print frame2
# out:
#    year   state  pop  test
# 0  2000    Ohio  1.5   2.3
# 1  2001    Ohio  1.7   2.3
# 2  2002    Ohio  3.6   2.3
# 3  2003  Nevada  2.4   2.3
# 4  2004  Nevada  2.9   2.3

将列表或数组赋值给某个列时，长度必须和DataFrame相匹配；空位都将填上缺失值NaN。

  1. 构建DataFrame方式二

    方式二：嵌套字典，即字典的字典。

1
2
3
4
5
6
7
8
9
10
11
pop = {'Nevada': {2001:2.3, 2004:3.4},
       'Ohio': {2003:3.34, 2005:5.2}}
# 转化为DataFrame，解释原则：外层字典的键作为列，内层键作为行索引。
frame3 = DataFrame(pop)
# print frame3
# out:
#       Nevada  Ohio
# 2001     2.3   NaN
# 2003     NaN  3.34
# 2004     3.4   NaN
# 2005     NaN  5.20

2.1 设置index和columns的name属性

1
2
3
4
5
6
7
8
9
frame3.index.name = 'year';frame3.columns.name = 'state'
# print frame3
# out:
# state  Nevada  Ohio
# year
# 2001      2.3   NaN
# 2003      NaN  3.34
# 2004      3.4   NaN
# 2005      NaN  5.20

2.2 value属性会以二维ndarray形式返回DataFrame中的数据

1
2
3
4
5
6
# print frame3.values
# out:
# [[ 2.3    nan]
#  [  nan  3.34]
#  [ 3.4    nan]
#  [  nan  5.2 ]]

索引对象

pandas索引对象负责管理轴标签和其他元数据（比如轴名称等）。

Index对象不可修改。此特性非常重要，使得Index对象在多个数据结构之间安全共享。

基本功能

重新索引reindex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

obj = Series([4.5, 2.3, -2.4, 3.5], index=['d', 'c', 'a', 'b'])
# obj.reindex(['a','b', 'c', 'd', 'e', 'f'])
# print obj
# out:
# d    4.5
# c    2.3
# a   -2.4
# b    3.5
# dtype: float64
# 这里没有像书上说的一样，没有索引值用缺失值NaN；待查
# obj.reindex(['a','b', 'c', 'd', 'e', 'f'], fill_value=0)
# 这一句会用0来填充缺失值
# print obj
# out:
# d    4.5
# c    2.3
# a   -2.4
# b    3.5
# dtype: float64
# 同样无效

丢弃指定轴上的项

1
2
3
4
5
6
7
8
9
10
obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
# print new_obj
# out:
# a    0.0
# b    1.0
# d    3.0
# e    4.0
# dtype: float64
# drop放回一个在指定轴上删除了指定值的新对象

索引、选取和过滤

利用标签的切片与普通Python切片运算不同，末端是包含的，即封闭区间。如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
obj = Series(np.arange(4.), index=['a','b','c','d'])
# print obj
# out:
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# dtype: float64
# print obj['b':'c']
# out:
# b    1.0
# c    2.0
# dtype: float64
# 如果是普通切片方式，b-c就只有1.0
# 赋值方式如下：
obj['b','c'] = 5
# print obj
# out: 
# a    0.0
# b    5.0
# c    5.0
# d    3.0
# dtype: float64

算术运算和数据对齐

对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。

1
2
3
4
5
6
7
8
9
10
11
12
13
s1 = Series([7.3, 4.5, 67.1, 2.3], index=['a', 'b', 'd', 'f'])
s2 = Series([3, 5, 6, 7, 3], ['a', 'd', 'f', 'g', 'h'])
# print s1 + s2
# out:
# a    10.3
# b     NaN
# d    72.1
# f     8.3
# g     NaN
# h     NaN
# dtype: float64
# 相加就是并集，若索引不重叠，则NaN；自动数据对齐操作。
# 而DataFrame对齐操作会同时发生在行和列上

排序和排名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# obj = Series(range(4), index=['d','c','b','a'])
# print obj
# d    0
# c    1
# b    2
# a    3
# dtype: int64
# print obj.sort_index()
# a    3
# b    2
# c    1
# d    0
# dtype: int64

frame = DataFrame(np.arange(8).reshape((2,4)), index=['three', 'one'], columns=['d','a','b','c'])
# print frame.sort_index()
#        d  a  b  c
# one    4  5  6  7
# three  0  1  2  3
# print frame.sort_index(axis=1)
#        a  b  c  d
# three  1  2  3  0
# one    5  6  7  4

按值对Series排序，用其order方法；
排序时缺失值会被放到Series末尾。

sort_index()方法已过时，用sort_value()方法代替。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# DataFrame根据列值排序，传列名给by选项
frame = DataFrame({'b': [4, 8, 5, 3], 'a': [-2, 1, 9, 6]})
# print frame
#    a  b
# 0 -2  4
# 1  1  8
# 2  9  5
# 3  6  3
# print frame.sort_values(by='b')
#    a  b
# 3  6  3
# 0 -2  4
# 2  9  5
# 1  1  8

排序

1
2
3
4
5
6
7
8
9
10
11
obj = Series([7, 3, 5, 7, 9, 3, 1])
# print obj.rank()
# 0    5.5
# 1    2.5
# 2    4.0
# 3    5.5
# 4    7.0
# 5    2.5
# 6    1.0
# dtype: float64
# 暂时没看懂什么意思啊

汇总和计算描述统计

  • axis（约简的 轴）选项标明是按行还是按列；如axis=0按列，axis=1按行。
  • skipna 排除缺失值，默认值True
  • level 轴是层次化索引的，则根据level分组约简

第五章于20170319结束，时间节点设计有问题，现在需要手动敲的越来越多，所以速度跟不上，尤其是精力跟不上了。看书要分主次，重要的知识点要细看，必须手动敲出来；一些同类化的知识可以跳着看，以节省时间。

但是有一个原则不能改，一些重要的知识点不能跳过，需要真真的✋敲出来。不然那就是真正的浪费时间。

展开全文 >>

《利用Python进行数据分析》读书笔记-4-第四章-Numpy基础：数组和矢量计算

Tip：全称Numerical Pythn，是高性能科学计算和数据分析的基础包。本书所有高级工具的构建基础。

NumPy功能

  • ndarry，矢量算术运算和复杂广播能力的快速切节省空间的多维数组
  • 对数组数据进行快速运算的标准数据函数（无需编写循环）
  • 读写磁盘的工具，，操作内存映射文件的工具
  • 线性代数、随机数生成以及傅立叶变换
  • 集成C、C++、Fortran等语言编写的代码（从生态系统角度，最重要的功能）

对于大部分数据分析应用，作者关注功能：

  • 数据整理和清理、子集构造和过滤、转换等快速矢量化数组运算
  • 数组算法，如排序、唯一化、集合运算
  • 高效描述统计和数据聚合／摘要运算
  • 异构数据集的合并／连接运算
  • 条件逻辑表述为数组表达式（除去if-else-if循环）
  • 数据分组运算

Tip:标准NumPy约定，总是使用import NumPy as np,而不是from NumPy import *.

ndarray: 一种多维数组对象

Tip：NumPy最重要特点是其N维数组对象（即ndarray，该对象是一个快速而灵活的大数据集容器）。

大多数数据分析工作不需要深入理解NumPy，但精通面向数组的编程和思维方式是成为Python科学计算牛人的一大关键步骤。

Focus:本书提到的数组、NUmPy数组、ndarray都是指ndarray对象

  • ndarray是同构数据多维容器，其中所有元素相同的类型。
  • 每个数组都有shape和dtype属性

创建ndarray

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
#!/usr/bin/python
# -*- coding:utf-8 -*-

import numpy as np
# data = np.ndarraz([[0.580052,0.186730,1.040717],[-0.636917,-0.938659,0.124094]])
# print data.shape

data1 = [5,7,8,3,9]
arr1 = np.array(data1)
# print arr1
# print arr1.ndim  # 1 维
# print arr1.shape  # (5,)
# print arr1.dtype   # int64

# print np.zeros(10)
# [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
# print np.zeros((3,6))
# [[ 0.  0.  0.  0.  0.  0.]
#  [ 0.  0.  0.  0.  0.  0.]
#  [ 0.  0.  0.  0.  0.  0.]]
# print np.empty((2,3,2))
# [[[ -2.00000000e+000  -2.00000000e+000]
#   [  6.95320070e-310   6.95320070e-310]
#   [  6.95320070e-310   6.95320070e-310]]
#
#  [[  6.95320070e-310   6.95320070e-310]
#   [  6.95320070e-310   6.95320070e-310]
#   [  6.95320070e-310   6.95320070e-310]]]
# np.empty经常返回一些为初始化的垃圾值
# print np.arange(10)
# [0 1 2 3 4 5 6 7 8 9]

Focus:如无特别指定，数据类型基本都是float64

ndarray的数据类型

ndarray的astype方法可转换其dtype：

1
2
3
4
5
6
arr = np.array([1,2,3,4,5])
print arr.dtype
# int64
float_arr = arr.astype(np.float64)
print float_arr.dtype
# float64

数组与标量之间运算

无需循环就可执行批量运算；这就叫做矢量化（vectorization）。不同大小数组之间的运算叫做广播。

1
2
3
arr = np.array([[1.,2.,3.], [4.,5.,6.]])
# print arr
# print arr * arr 加减乘除都是相对位置相乘

基本索引和切片

与列表最重要区别在于，数组切片是原始数组的视图。说明数据不会被复制，视图伤的任何修改都会直接反映到数组上。若非要复制，就要显式复制：arr[5:8].copy()

1
2
3
4
5
6
7
8
9
arr = np.arange(10)
# print arr[5:8]  # [5,6,7]
arr[5:8] = 12
# print arr   # [0 1 2 3 4 12 12 12 8 9]
arr_slice = arr[5:8]
arr_slice[1] =12345
print arr  # [0 1 2 3 4 12 12345 12 8 9]
arr_slice[:] = 64
# print arr  # [0 1 2 3 4 64 64 64 8 9]

切片索引

ndarray切片语法与一维对象相似。多维切片只是一维的基础山进行扩展。

沿着第0轴切片；切片是沿着一个轴向选取元素的。一次传入多个切片：

1
2
3
4
5
6
7
arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
# print arr2d[:2]
# out: [[1 2 3], [4 5 6]]
# print arr2d[:2,:1]
# out: [[1], [4]]
# print arr2d[:2,1:]
# out: [[2,3],[5,6]]

上面只能得到相同维数的数组视图。

通过将整数索引和切片混合，可以得到低维度的切片：

1
2
3
4
5
6
print arr2d[1,:2]
# out: [4, 5]
print arr2d[2:,1]
# out: [8]
print arr2d[:, :1]
# out: [[1],  [4],  [7]]

Focus：:,冒号表示选取整个轴。

对切片表达式进行赋值，该操作会扩散到整个选区。

1
2
3
arr2d[:2, 1:] = 0
print arr2d
# out: [[1 0 0],  [4 0 0],  [7 8 9]]

布尔型索引

二维数组切片，第一个数字开始在行这个维度上切片，第二个数字在列上切片。

布尔型索引选取数组中多数据，总是创建数的副本，即使是返回一摸一样多数组。

⚠️：Python关键字and和or在布尔型数组中无效。

通过布尔型数组设置值，如下，将data中的所有负值都设为0:

1
data[data < 0] = 0

一维数组设置正行或列的值：

1
data[name != 'Joe'] = 7

花式索引

指利用整数数组进行索引；花式索引跟切片不一样，总是将数据复制到新数组中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
arr = np.empty((8,3))
for i in range(8):
    arr[i] = i
# print arr
# out：[[ 0.  0.  0.]
#  [ 1.  1.  1.]
#  [ 2.  2.  2.]
#  [ 3.  3.  3.]
#  [ 4.  4.  4.]
#  [ 5.  5.  5.]
#  [ 6.  6.  6.]
#  [ 7.  7.  7.]]

# print arr[[4,3,0,6]]
# out:[[ 4.  4.  4.]
#  [ 3.  3.  3.]
#  [ 0.  0.  0.]
#  [ 6.  6.  6.]]

数组转置与轴对换

1
2
3
4
5
6
7
8
9
10
11
12
13
arrzzdh = np.arange(15).reshape(3,5)
# print arrzzdh
# out: 0-15个数字 转换成3行5列的数组
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]
print arrzzdh.T
# out: 转置，行列倒置
# [[ 0  5 10]
#  [ 1  6 11]
#  [ 2  7 12]
#  [ 3  8 13]
#  [ 4  9 14]]

利用数组进行数据处理

用数组表达式代替循环的做法，称为矢量化。

1
2
3
4
5
6
7
8
9
points = np.arange(-5,5,0.1) # 1000个间隔相等的点
xs, ys = np.meshgrid(points, points)
# print ys
import matplotlib.pyplot as plt
z = np.sqrt(xs**2 + ys**2)
# print z
plt.imshow(z, cmap=plt.cm.gray);plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
plt.show()

将条件逻辑表述为数组运算

如numpy.where函数是三元表达式x if condition erse y的矢量化版本。

1
result = np.where(condition="",x="",y="")

满足条件则x，否则y

数学和统计方法

1
2
3
4
5
6
7
arr = np.random.randn(5, 4)
print arr.mean()
# out: -0.360180571527

arr = np.random.randn(100)
print (arr > 0).sum()
# out: 随机的一百个数字，每次大于0的数的个数。
1
2
3
4
5
6
7
8
9
10
11
12
## 排序
arr1 =np.random.randn(8)
print arr1
arr1.sort()
# 先sort排序，才能输出，如果直接同时输出排序，会None
print arr1

# 多维数组排序，在任何一个轴上，传入该轴编号即可
arr2 = np.random.randn(5,3)
print arr2
arr2.sort(1)
print arr2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
## 唯一化
names = np.array(['jin', 'king', 'lin', 'wen', 'jin', 'wen', 'lin'])
# print np.unique(names) # 这里又必须直接输出
# print names  # 无效
ints = np.array([2,3,4,5,6,7,8,5,4,2,4,6,1])
# print np.unique(ints) # 直接输出有效
# print ints # 无效
# # 没效果？那么纯Python方法有效果吗
# print sorted(set(names))
# print names
# print sorted(set(ints))
# print ints
# 还是没有效果啊
# 这里说明排序唯一都要直接输出，**原值没有改变**。
1
2
3
4
5
6
7
8
9
10
11
12
13
## 用于数组的文件输入输出
### 将数组以二进制格式保存到硬盘
# np.save()和np.load()方法是用于读写的主要方法。
arr3 = np.arange(10)
np.save('test_arr_save', arr3)
# 保存为了.npy文件；然后用load方法读取数组
# print np.load('test_arr_save.npy')
# out: [0 1 2 3 4 5 6 7 8 9]
# np.savez保存多个数组到压缩文件
np.savez('arr_archive.npz', a= arr3, b=arr3)
arch = np.load('arr_archive.npz')
# print arch['b']
# out: [0 1 2 3 4 5 6 7 8 9]
1
2
3
# 存取文本文件
# 指定分隔符为逗号，读取csv文件
# np.loadtxt('filename', delimiter=',')

最后涉及到了线性代数,随机漫步等数学概念，深切体会到学好数学是任何一门科学想要往高了走的必然阶梯，计算机科学当然也不例外。

今天组内培训，讲了一些代码规范、版本更新和项目管理的知识，无规矩不成方圆，团队大了，尤其需要一套行之有效的规矩来约束每个人的行为，代码能体现一个人的行为方式，是否有代码洁癖。Talk is cheap, show me the code.希望组内能坚持下去，互相code Review。

展开全文 >>

《利用Python进行数据分析》读书笔记-3-第三章-IPython:一种交互式计算和开发环境

IPython:一种交互式计算和开发环境

Tip:动手敲一敲，跟所有由键盘驱动的控制台环境一样，锻炼对常用命令的肌肉记忆是学习曲线中不可或缺的一部分。

  • 输入变量，会显示出该对象的一个字符串表示
  • IPython支持Tab自动完成，类shell
  • IPython支持内省，在变量前或后加?，就能查看对象的一些信息

代码设计提示

  • 保留有意义的对象和数据
  • 扁平化结构要比嵌套结构好（洋葱；低耦合，模块化）
  • 无惧大文件（一次性干大文件，比加载若干小文件来得实惠）

这一章介绍了IPython的强大功能，作为数据分析利器的存在。目前我还是用PyCharm这个IDE顺手。这一章暂且搁置，若后续需要了解再来查看。–20170307

Python之禅

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import this
# 查看Python之禅
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

今日感悟：在项目开发过程中，一些坑现在不填平，以后还会跳出来坑你，还是往死里坑。这也正是Errors should never pass silently.的意指。so，不要逃避困难，遇到问题，想办法解决。

展开全文 >>

《利用Python进行数据分析》读书笔记_2_第一二章_准备工作及引言

第一章 准备工作

这一章节主要是环境构建工作。

遇到问题，无法安装pandas包，pip也无法安装；
命令sudo easy_install xxx，怀疑是网速原因，超时了。
所以直接下载了zip包。。补充：之后在公司网速可以的情况下由下载下来了，安装了pip工具。

本书用到的数据地址

第二章 引言

来自bit.ly的1.usa.gov数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
#-*- coding:utf-8 -*-

# 读取文件中一行
path = '../pydata-book-master/ch02/usagov_bitly_data2012-03-16-1331923249.txt'
print open(path).readline()
# out: { "a": "Mozilla\/5.0 (Windows NT 6.1; WOW64) AppleWebKit\/535.11 (KHTML, like Gecko) Chrome\/17.0.963.78 Safari\/535.11", "c": "US", "nk": 1, "tz": "America\/New_York", "gr": "MA", "g": "A6qOVH", "h": "wfLQtf", "l": "orofrog", "al": "en-US,en;q=0.8", "hh": "1.usa.gov", "r": "http:\/\/www.facebook.com\/l\/7AQEFzjSi\/1.usa.gov\/wfLQtf", "u": "http:\/\/www.ncbi.nlm.nih.gov\/pubmed\/22415991", "t": 1331923247, "hc": 1331822918, "cy": "Danvers", "ll": [ 42.576698, -70.954903 ] }

import json
# 列表推导式，生成的是一组Python字典
record = [json.loads(line) for line in open(path)]
print record[0]
# out：{u'a': u'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 Safari/535.11', u'c': u'US', u'nk': 1, u'tz': u'America/New_York', u'gr': u'MA', u'g': u'A6qOVH', u'h': u'wfLQtf', u'cy': u'Danvers', u'l': u'orofrog', u'al': u'en-US,en;q=0.8', u'hh': u'1.usa.gov', u'r': u'http://www.facebook.com/l/7AQEFzjSi/1.usa.gov/wfLQtf', u'u': u'http://www.ncbi.nlm.nih.gov/pubmed/22415991', u't': 1331923247, u'hc': 1331822918, u'll': [42.576698, -70.954903]}
# 既然已经生成了字典项，就可以通过键访问值
print record[0]['ll']
# out: [42.576698, -70.954903]
# 单引号前面的u标识unicode；
print record[0]['tz']
# out: America/New_York  # 时区是字符串对象形式，而非打印形式

纯Python时区计数

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
time_zones = [rec['tz'] for rec in record if 'tz' in rec]
print time_zones[:10]

# 对时区进行计数
def get_counts(sequence):
    counts = {}
    for x in sequence:
        if x in counts:
            counts[x] += 1
        else:
            counts[x] = 1
    return counts
# 使用标准库简化方法
from collections import defaultdict
def get_counts2(sequence):
    counts = defaultdict(int)
    for x in sequence:
        counts[x]+=1
    return counts
counts = get_counts(time_zones)
print counts['America/New_York']
# out: 1251
print len(time_zones)
# 3340
# 前10位的时区及计数
def top_counts(count_dict, n = 10):
    value_key_pairs = [(count, tz) for tz, count in count_dict.items()]
    value_key_pairs.sort()
    return value_key_pairs[-n:]
print top_counts(counts)
# out: [(33, u'America/Sao_Paulo'), (35, u'Europe/Madrid'), (36, u'Pacific/Honolulu'), (37, u'Asia/Tokyo'), (74, u'Europe/London'), (191, u'America/Denver'), (382, u'America/Los_Angeles'), (400, u'America/Chicago'), (521, u''), (1251, u'America/New_York')]
# 更简单的方式是collections.Counter类
from collections import Counter
counts1 = Counter(time_zones)
print counts1.most_common(10)
# out: [(u'America/New_York', 1251), (u'', 521), (u'America/Chicago', 400), (u'America/Los_Angeles', 382), (u'America/Denver', 191), (u'Europe/London', 74), (u'Asia/Tokyo', 37), (u'Pacific/Honolulu', 36), (u'Europe/Madrid', 35), (u'America/Sao_Paulo', 33)]

pandas对时区计数

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
# pandas时区计数
# DataFrame是pandas中最重要的数据结构，将数据处理成表格
from pandas import DataFrame, Series
import pandas as pd ;import numpy as np;import matplotlib.pyplot as plt
frame = DataFrame(record)
# print frame
# print frame['tz'][:10]
tz_counts = frame['tz'].value_counts()
# print tz_counts[:10]
# tz_counts[:10].plot(kind='barh', rot=0)
# 这里如不添加下句，图形闪退
# plt.show()
# print frame['a'][1]
result = Series([x.split()[0] for x in frame.a.dropna()])
# print result[:5]
# print result.value_counts()[:8]
cframe = frame[frame.a.notnull()]
operating_sys = np.where(cframe['a'].str.contains('Windows'),("Windows"),'Not Windows')
# print operating_sys[:5]
by_tz_os = cframe.groupby(['tz',operating_sys])
agg_counts = by_tz_os.size().unstack().fillna(0)
# print agg_counts[:5]
indexer = agg_counts.sum(1).argsort()
# print indexer[:5]
count_subset = agg_counts.take(indexer)[-10:]
# print count_subset
# count_subset.plot(kind='barh', stacked=True)
# plt.show()
normed_subset = count_subset.div(count_subset.sum(1),axis=0)
# normed_subset.plot(kind='barh', stached=True)
# plt.hold()
# plt.interactive(False)
# plt.show()

MovieLens 1M数据集

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
41
42
43
44
45
46
unames = ['user_id', 'gender', 'age', 'occupation', 'zip']
users = pd.read_table('../pydata-book-master/ch02/movielens/users.dat', sep='::', header=None, names=unames, engine='python')

rnames = ['user_id', 'movie_id', 'rating', 'timestamp']
ratings = pd.read_table('../pydata-book-master/ch02/movielens/ratings.dat', sep='::', header=None, names=rnames, engine='python')

mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('../pydata-book-master/ch02/movielens/movies.dat', sep='::', header=None, names=mnames, engine='python')

# print users[:5]
# print ratings[:5]
# print movies[:4]

# pandas的merge函数根据列名的重叠情况推断出哪些列是合并（或连接）键
data = pd.merge(pd.merge(ratings, users), movies)
# print data
# data.ix[0]

# 按性别计算每部电影平均分，使用pivot_table方法
mean_ratings = data.pivot_table('rating', index='title', columns='gender', aggfunc='mean')
# print mean_ratings[:5]
rating_by_title = data.groupby('title').size()
# print rating_by_title[:10]
# 过滤掉评分小于250
active_title = rating_by_title.index[rating_by_title>=250]
# print active_title
mean_ratings =mean_ratings.ix[active_title]
# print mean_ratings
# 按女性分数排序
top_female_rating = mean_ratings.sort_values(by='F', ascending=False)
# print top_female_rating[:4]

# 计算评分分歧；男女观众的分歧；方法是加上一列diff，做差;按diff排序，得出的结果是分歧 最大且女性更喜欢的电影。
mean_ratings['diff'] = mean_ratings['M'] - mean_ratings['F']
sorted_by_diff = mean_ratings.sort_values(by='diff')
# print sorted_by_diff[:10]
# 对行反序，并去除前十，则是男性更喜欢的电影
# print sorted_by_diff[::-1][:10]

# 根据电影名称分组的得分数据的标准差
rating_std_by_title = data.groupby('title')['rating'].std()
# 根据active_titles进行过滤
rating_std_by_title = rating_std_by_title.ix[active_title]
# 根据值对Series进行降序排列
rating_std_by_title.sort_value(ascending=False)[:5]
# AttributeError: 'Series' object has no attribute 'sort_value';按树上对order也不行，deprecated

1880–2010年间全美婴儿姓名

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
41
42
43
44
45
46
47
48
49
50
51
52
# 1880-2010年间全美婴儿姓名
# 用linux命令查看某个文件对前十行
# head -n 10 names/yob1880.txt
# 第一行：Mary,F,7065
# 数据由标准逗号隔开，可以用pandas.read_csv加载到DataFrame中
import pandas as pd;import matplotlib.pyplot as plt;import numpy as  np
# names1880 = pd.read_csv('../pydata-book-master/ch02/names/yob1880.txt', names=['name', 'sex', 'birthsNum'])
# print names1880
# print names1880.groupby('sex').birthsNum.sum()
# out: sex
#      F     90993
#      M    110493
#      Name: birthsNum, dtype: int64

# 将所有文件中到数据组装到一个DataFrame中，并加上一个year字段。使用pandas.concat
# 2010年是目前最后一个有效统计年度
years = range(1880, 2011)
pieces = []
columns = ['name', 'sex', 'birthsNum']
for year in years:
    path = '../pydata-book-master/ch02/names/yob%d.txt' % year
    frame = pd.read_csv(path, names=columns)

    frame['year'] = year
    pieces.append(frame)
# 将所有数据整合到单个DataFrame中;ignore_index必须置为False，不保留原始行号；concat默认按行整合
names = pd.concat(pieces, ignore_index=False)
# print names
# 聚合;DataFrame.pivot_table(y轴，x轴，多种类型-线条，每一年每种性别对出生总数)
total_birthsNum = names.pivot_table('birthsNum', index='year', columns='sex', aggfunc=sum)
# print total_birthsNum.tail()
# total_birthsNum.plot(title='Total birthsNum by sex and year')
# plt.show()

# 插入prop列，表示相对比例；由于birthsNum是整数，需要将分子分母转换成浮点数（Python3.x除外）
def add_prop(group):
    # 整数除法会向下圆整
    birthsNum = group.birthsNum.astype(float)
    group['prop'] = birthsNum/birthsNum.sum()
    return group
names = names.groupby(['year', 'sex']).apply(add_prop)
# print names
# 分组前应该进行有效性检查，用numpy.allclose=1判定所有prop之和是否为1
# print np.allclose(names.groupby(['year', 'sex']).prop.sum(), 1)
# out: True
# 为便于分析，取出前1000条按sex/year组合对数据
def get_top1000(group):
    return group.sort_index(by='birthsNum', ascending=False)[:1000]
grouped = names.groupby(['year', 'sex'])
top_1000 = grouped.apply(get_top1000)
# print top_1000
# 接下来针对这1000条数据进行分析

感到这一章就是先展示一下能干什么，用到的东西不熟悉，也只能照着敲敲；因此决定暂不跟着敲了；P41-P47跳过。

展开全文 >>

《利用Python进行数据分析》读书笔记_1_附录

题记：这本书是2016年6月10日购于Aamazon，至今还是新的，有愧初衷。决定于2017年2月25日开始看，本书共12章，400页（不含附录）。计划两个月看完。那么，到3月25日要看200页，大概到第七章结束；四周200页，一周就是50页。

那么就从附录的基础开始看吧。

时间计划表：

周序号 时间 章节 页码 执行情况
1 20170227-20170305 第一、二章 p1-p47 完成
2 20170306-20170312 第三、四章 p48-p112 完成
3 20170313-20170319 第五章 p115-p161 完成
4 20170320-20170325 第六章 p162-p185 完成
5 20170326-201704 第七章 p186-p230 -
6 20170305-20170305 - - -
7 20170305-20170305 - - -
8 20170305-20170305 - - -
9 20170305-20170305 - - -

附录A：Python语言精要

-重拾Python基础

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#!/usr/bin/python
# -*- coding: utf-8 -*-
# 在python中输入中文，包括中文注释，都需要加入上面对声明：https://www.python.org/dev/peps/pep-0263/#defining-the-encoding

# python对变量进行赋值是在创建等号右侧对象对一个引用；即左侧是引用，右侧是对象；
a = [1, 2, 3, 4, 5, 6]
b = a
a.append(7)
print a
print b
# a，b两个引用指向一个对象，输出都是[1,2,3,4,5,6,7]
# 赋值也叫绑定，将一个名称（引用）和一个对象绑定自在一起；

# python按引用传递，以参数形式传入函数时，只是传入一个引用，不会复制；
# 其他语言既支持按引用传递，又支持按值传递；
# python可以修改参数的内容；而其他语言貌似不可以
def append_ele(data_list, ele):
    data_list.append(ele)
data_list = [1,2,3]
append_ele(data_list, 5)
print data_list

# 强类型语言？
# 由于没有显式的将类型写出，常被误认为是弱类型语言，和js差不多；
# 如计算以下：
'5' + 5
# 报错信息如下：
Traceback (most recent call last):
   File "/Users/linking/PycharmProjects/testProject/test1", line 25, in <module>
    '5' + 5
TypeError: cannot concatenate 'str' and 'int' objects
# 再例：
a = 5.3
b = 2
print 'a is %s, b is %s' % (type(a), type(b))
out: a is <type 'float'>, b is <type 'int'>
# 占位符 %s
print a/b
2.65
# isinstance()函数检查类型
print isinstance(a, int)
out: False
print isinstance(b, int)
out: True
print isinstance(a, (int, float))
out: True

# 属性和方法
a = 'foo'
# 通过.调用a.

# python是一种非常严格的语言（急性子）；几乎在任何时候，计算过程和表达式都是立即求值。

# 可变对象：列表，字典，NumPy数组及大部分用户自定义类
# 不可变类：字符串和元组等；
# 不可变指不能修改原内存块的数据。即使修改成功了也只是创建了一个新对象，并将其赋值给原变量而已。

# 数据类型
from __future__ import division
print 3 / 2
# 加__future__则结果是1.5,不加就是1
# 也可以显式转换  3／float(2)
# 整数除法如下：
print 3//2
# 结果 1

# 字符串
# 很多人因灵活的字符串处理能力而选择了python
# ''  ""  效果相同
# 多行字符串用三重引号（'''或"""）如下
c = """
    this is a longer string that
    spans multiple lines
    """
# 字符串不可变；要修改也只能创建一个新的。
# str(5.6)这种形式即可完成类型转换
# 反斜杠（\）是转义字符；
pring s = '12\\34'
out : 12\34
# 若要按照原样输出，则在左侧加r前缀
s = r'this\has\no\special\characters\'
out: 'this\has\no\special\characters\'
# 字符串格式化
# 机制：以一个%开头后面跟着一个或多个格式字符的字符串是需要插入的目标（类似c中的printf函数）
temple = '%2.f %s are worth $%d'
print temple % (3.413444, 'we', 222)
# 这里的%是二元运算符，后面是元组(,,,)
print bool([]),bool([1,2,3])
out: False True
print bool('hollo'),bool('')
out: True False
print bool(0), bool(1)
out: False,True

# None是Python的空值类型。一个函数没有显式地返回值，则隐式返回None
# None不是保留关键字，只是NoneType的一个实例。

# 异常处理
def attempt_float(x):
    try:
        return float(x)
    except (TypeError,ValueError):
        return x
print attempt_float('123.44xx')
# 如上用元组包括多个，同时捕捉多个异常。

# 三元表达式
x = 5
print 'Non-negative' if x > 0 else 'Negative'
# 优点是缩减代码，缺点是复杂情况下可读性差

# 元组
# 任何序列或迭代器都可以通过tuple转换为元组
print tuple([3,2,1])
out: (3,2,1)
tup = tuple('string')
print tup
out: ('s', 't', 'r', 'i', 'n', 'g')
print tup[0]
out: s

# 列表切片
# 正 从0开始，负 从-1开始；都是在索引的插缝数数。

# 有序 sorted ，唯一 set

# 字典，是Python中最重要的内置数据结构。是一种大小可变的键值对集。
empty_dict={}
dict_a = {"a key": "a value", 'b key': 'b value'}

# 匿名函数
def apply_to_list(some_list, f):
    return [f(x) for x in some_list]
ints = [4, 0, 1, 5, 6]
print apply_to_list(ints, lambda x: x * 2)
out: [8, 0, 2, 10, 12]
# 得以轻松的传入一个自定义运算给apply_to_list函数；

# 生成器
def squares(n=10):
    print 'Generating squares from 1 to %d' % (n**2)
    for i in xrange(1, n+1):
        yield i**2
gen = squares()
print gen
out: <generator object squares at 0x106936d20>
for x in gen:
    print x,
out:  Generating squares from 1 to 100
      1 4 9 16 25 36 49 64 81 100

20170226 23:06 周日 于皖水公寓1#1317

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true