Part 1.生成指定维度的随即多维数组

1.Numpy 库

import numpy as np #引入numpy

data = np.random.rand(2, 3）#生成两行三列随机数

print(data) #输出数据

print(type(data)) #输出数据类型

2.一维数组

arr1 = np.arange(10)

print(arr1)

3.多维数组

arr2 = np.arange(12).reshape(3,4)

print(arr2) #3行4列

4.转置

arr = np.random.rand(2,3)

print(arr) #2行3列

print(arr.transpose()) #转成3行2列

5.常用的统计方法

arr = np.arange(10).reshape(5,2) #生成5行2列序列

print(arr)

print(np.sum(arr)) #统计总和

print(np.sum(arr, axis=0)) #按列求和

print(np.sum(arr, axis=1)) #按行求和

print(np.any(arr > 0)) #至少有一个值大于0

print(np.all(arr > 0)) #所有值大于0

print(np.unique(arr)) #去重

6.格式转换

#str转换成bytes，用encode

b_str = ch_str.encode('utf-8')

print(b_str)

type(b_str)

# bytes转换成str，用decode

ch_str2 = b_str.decode('utf-8')

print(ch_str2)

type(ch_str2)

7.映射

'{0}, {1}'.format('Python', 2019) #通过位置映射

#输出结果：“python，2019”

'{name}, {year}'.format(year=2019, name='Python') #通过关键字映射

#输出结果：“Python，2019”

Part 2.数据采集与操作

1.常用格式的本地数据读写

1.读取txt文件

File_obj=open(‘路径’，’编码’) #打开文件，编码通常为’r’：读,’w’：写

File_obj.read() #读取整个文件

File_obj.readline() #逐行读取

File_obj.readlines() #返回列表，列表中的每个元素是行内容

#写操作

txt_filename = 'D:./123.txt' #定义文件路径

File_obj = open(txt_filename, 'w', encoding='utf-8') #打开文件

File_obj.write(“内容”) #将内容写入文件

#关闭文件

File_obj.close()

2 读取csv格式文件

#pandas读取csv

mport pandas as pd #引入pandas

filename = 'E:./123.csv' #文件地址

df = pd.read_csv(filename, encoding='utf-16') #读取文件

3.读取json数据

import json #引入json

filename = './123.json'

with open(filename, 'r') as f_obj:

json_data = json.load(f_obj)

2.爬虫简介

1.访问

import urllib.request #引入requests库

test_url =' http://www.google.com ' #网址url

response = urllib.request.urlopen(test_url) #通过url下载

print(response.getcode()) # 200 表示访问成功

print(response.read())

#通过requests访问

request = urllib.request.Request(test_url)

request.add_header("user-agent", "Mozilla/5.0")

response = urlopen(request)

print(response.getcode()) # 200 表示访问成功

print(response.read())

#通过cookie访问

import http.cookiejar

cookie_jar = http.cookiejar.CookieJar()

opener =urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cookie_jar))

urllib.request.install_opener(opener)

response = urllib.request.urlopen(test_url)

print(response.getcode()) # 200 表示访问成功

print(response.read())

print(cookie_jar)

2.beautifulsoup库解析

from bs4 import BeautifulSoup

Import urllib.request #引入

html = urllib.request.urlopen("http://www.baidu.com")

bs_obj = BeautifulSoup(html, 'html.parser', from_encoding='utf-8');

print("title tag: ", bs_obj.title)

Part3.数据分析工具Pandas

1.通过list创建series

Ser_obj=pd.Series(range(10)) #索引在左，数据在右

2.通过dict构建Series

year_data = {2001: 17.8, 2002: 20.1, 2003: 16.5}

ser_obj2 = pd.Series(year_data) #年份是索引

3.通过ndarray构建DataFrame

Import numpy as np #引入numpy

array = np.random.randn(5,4）

df_obj = pd.DataFrame(array) #可添加列名colimns=['a', 'b', 'c', 'd'])

4.通过dict构建DataFrame

dict_data = {'A': 1.,

'B': pd.Timestamp('20161217'),

'C': pd.Series(1, index=list(range(4)),dtype='float32'),

'D': np.array([3] * 4,dtype='int32'),

'E' : pd.Categorical(["Python","Java","C++","C#"]),

'F' : 'ChinaHadoop' } #建立描述数据

df_obj2['G'] = df_obj2['D'] + 4 #增加列

del(df_obj2['G'] ) # 删除列

print(df_obj['a']) #列索引

5.整型位置索引iloc

print(df_obj.iloc[0:2, 0])

6.计算

s1.add(s2, fill_value = -1) #未对齐的数据-1处理

s3 = s1 + s2

s3_filled = s3.fillna(-1) #未对齐的数据变成-1

df3.fillna(100, inplace = True) #未对齐的数据变成100

np.abs(df) #求绝对值

import numpy as np

import pandas as pd

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd']) #创建dataframe

df_obj.sum() #列求和

df_obj.max() #列最大值

df_obj.min(axis=1) #行最小值

df_obj.describe() #统计描述

7.处理缺失数据

df_data.isnull() #判断是否为缺失值

df_data.dropna() #删除缺失值所在的行列

df_data.fillna(-100.) #缺失值按-100处理

8.多层数据选取

#外层选取

print(ser_obj['c'])

#内层选取

print(ser_obj[:, 2])

#交换分层顺序

print(ser_obj.swaplevel())

#交换并排序分层

print(ser_obj.swaplevel().sortlevel())

Part 4.时间序列数据分析

1.python的日期和时间处理

1.建立时间格式

from datetime import datetime #引入datetime模块

now = datetime.now() #当前时间

print('年: {}, 月: {}, 日: {}'.format(now.year, now.month, now.day)) #当前年月日

diff = datetime(2018, 6, 20, 11) - datetime(2014, 9, 7, 16) #时间段相差

2.时间格式转换

dt_obj = datetime(2017, 3, 4)

str_obj2 = dt_obj.strftime('%d-%m-%Y')

print(str_obj2)

s_obj2 = pd.to_datetime(s_obj) #格式统一

2.创建日期序列

dates = pd.date_range('2017-02-18', # 起始日期

periods=5, # 周期

freq='W-SAT') # 频率

1.索引

print(time_s[0]) # 索引位置

print(time_s[datetime(2017, 2, 18)]) # 索引值

# 按“年份”、“月份”索引

print(time_s['2017-2'])

2.切片操作

print(time_s['2017-2-26':])

3.过滤

time_s.truncate(before='2017-2-25') #日期后的数据

time_s.truncate(after='2017-2-25') #日期前的数据

4.生成日期范围

# 传入开始、结束日期，默认生成的该时间段的时间点是按天计算的

date_index = pd.date_range('2017/02/18', '2017/03/18')

# 只传入开始或结束日期，还需要传入时间段

print(pd.date_range(start='2017/02/18', periods=10))

print(pd.date_range(end='2017/03/18', periods=10))

5频率与偏移量

print(pd.date_range('2017/02/18', '2017/03/18', freq='2D'))#2天为间隔

# 偏移量通过加法连接

sum_offset = pd.tseries.offsets.Week(2) + pd.tseries.offsets.Hour(12)

#向下或向上偏移

print(ts.shift(1))

print(ts.shift(-1))

3.时间数据重采样

# 统计每个月的数据总和

resample_month_sum = ser_obj.resample('M').sum()

# 统计每个月的数据平均

resample_month_mean = ser_obj.resample('M').mean() #数据以日期为索引

#将数据聚合到5天的频率

five_day_sum_sample = ser_obj.resample('5D').sum()

# 使用groupby降采样

print(ser_obj.groupby(lambda x: x.month).sum())

4.滑动窗口

r_obj = ser_obj.rolling(window=5) # 确定滑动值

print(r_obj.mean()) #位置在最后一个

print(ser_obj.rolling(window=5, center=True).mean()) #求和位置在中间

5.ARIMA模型

1.差分处理

# 一阶差分处理

df_obj['diff_1'] = df_obj['data'].diff(1)

# 二阶差分处理

df_obj['diff_2'] = df_obj['diff_1'].diff(1)

# 查看图像

df_obj.plot(subplots=True, figsize=(18, 12))

2.ACF和[ACF

from scipy import stats

import statsmodels.api as sm

sm.graphics.tsa.plot_acf(df_obj['data'], lags=20) #ACF值

sm.graphics.tsa.plot_pacf(df_obj['data'], lags=20) #PACF值

Part 5.文本数据分析

#安装语料库

Import nlltk

nltk.load() #安装分词、停用词等语料库

1.分词

# 安装汉语分词语料库

pip install jieba

import jieba

seg_list = jieba.cut("同志们好，同志们辛苦了", cut_all=True)

print("全模式: " + "/ ".join(seg_list)) # 全模式

seg_list = jieba.cut("同志们好，同志们辛苦了", cut_all=False)

print("精确模式: " + "/ ".join(seg_list)) # 精确模式

#安装英语分词语料库

sentence = "Python is a widely used high-level programming language for general-purpose programming."

tokens = nltk.word_tokenize(sentence) #分词

2.词干提取

from nltk.stem.porter import PorterStemmer #引入包

porter_stemmer = PorterStemmer() #建立库

print(porter_stemmer.stem('looked')) #提取原型

print(porter_stemmer.stem('looking')) #提取原型

3.词形归并

from nltk.stem import WordNetLemmatizer #引入worknet语料库

wordnet_lematizer = WordNetLemmatizer() #使用该库

print(wordnet_lematizer.lemmatize('cats')) #lemmatize 默认为名词

print(wordnet_lematizer.lemmatize('boxes')) #统一为原型

# 指明词性可以更准确地进行lemma

print(wordnet_lematizer.lemmatize('are', pos='v'))

print(wordnet_lematizer.lemmatize('went', pos='v')) #得到原型

4.词性标注

import nltk #引入nltk

words = nltk.word_tokenize('Python is a widely used programming language.')

print(nltk.pos_tag(words)) #分词后每个单词都词性标注

5.去除停用词（删除没意义的词，如“的地得”）

from nltk.corpus import stopwords # 需要下载stopwords

filtered_words = [word for word in words if word not in stopwords.words('english')] #分词后的单词如果不在stopwords语料库，则输出

6.文本相似度检验

1.统计频次最多词

import nltk

from nltk import FreqDist #引入库

text1 = 'I like the movie so much '

text2 = 'That is a good movie '

text3 = 'This is a great one '

text4 = 'That is a really bad movie '

text5 = 'This is a terrible movie'

text = text1 + text2 + text3 + text4 + text5

words = nltk.word_tokenize(text) #分词

freq_dist = FreqDist(words) #查看某个单词的频次

most_common_words = freq_dist.most_common(n) #查看用词最多的前n个词

2.查找常用单词的位置

def lookup_pos(most_common_words):

result = {}

pos = 0

for word in most_common_words:

result[word[0]] = pos

pos += 1

return result

3.记录位置

std_pos_dict = lookup_pos(most_common_words)

print(std_pos_dict)

new_text = 'That one is a a a a good movie. This is so good!' #新文本

freq_vec = [0] * n # 初始化向量

new_words = nltk.word_tokenize(new_text) # 分词

4.在“常用单词列表”上计算词频

for new_word in new_words:

if new_word in list(std_pos_dict.keys()):

freq_vec[std_pos_dict[new_word]] += 1

print(freq_vec) #查看词频

7.求单词的TF-IDF

from nltk.text import TextCollection #引入库

text1 = 'I like the movie so much '

text2 = 'That is a good movie '

text3 = 'This is a great one '

text4 = 'That is a really bad movie '

text5 = 'This is a terrible movie'

# 构建TextCollection对象

tc = TextCollection([text1, text2, text3, text4, text5])

new_text = 'That one is a good movie. This is so good!'

word = 'That'

tf_idf_val = tc.tf_idf(word, new_text)

print('{}的TF-IDF值为：{}'.format(word, tf_idf_val)) #得到结果

Part 6.Scikit-learn与机器学习

1.机器学习方法与步骤

1.建立模型

from sklearn import datasets #引入scikit库

from sklearn import svm #引入SVM模型

svm_model = svm.SVC(gamma=0.001, C=100.) #建模，参数可以不写

from sklearn.linear_model import LogisticRegression #引入LR模型

lr_model = LogisticRegression() #建模

2.训练模型

svm_model.fit(train_X, train_y) #训练SVM模型

lr_model.fit(train_X, train_y) #训练LR模型

3.预测结果

y_pred_svm = svm_model.predict(test_X) #预测

y_pred_lr = lr_model.predict(test_X) #预测

4.计算accurary_score分数

from sklearn.metrics import accuracy_score #引入库

print('SVM结果：', accuracy_score(y_true, y_pred_svm))

print('LR结果：', accuracy_score(y_true, y_pred_lr)) #accurary_score的参数是两个向量

5.保存模型

import pickle #引入pickle

with open('svm_model.pkl', 'wb') as f:

pickle.dump(svm_model, f) #把模型扔进'svm_model.pkl’

6.重新加载模型进行预测

with open('svm_model.pkl', 'rb') as f:

svm_model = pickle.load(f)

2.特征归一化

from sklearn import preprocessing #引入库

print(preprocessing.scale(X)) #归一成大小相差很小的值