Python数据分析实战1

#数据链接：https://pan.baidu.com/s/1o8eLDEi 密码：i1zx

# 本实战教程是python2.7版本

# 涉及的API
# http://pandas.pydata.org/pandas-docs/stable/genindex.html

# https://docs.python.org/2/library/index.html
#############
# "第一课：操作TSV文件"
############

'''
第1部分：用csv.reader（）读入文件，并将其存储在名为“file_nested_list”的对象中。
提示：这是一个TSV文件，需要告诉csv.resader（）如何处理它。
   

'''

import csv

# 指定分隔符是制表符，TSV为用制表符tab分隔的文本文件。 CSV为用逗号,分隔的文本文件。
with open('chipotle.tsv', mode='rU') as f:
    file_nested_list = [row for row in csv.reader(f, delimiter='t')]


'''
第2部分：将'file_nested_list'分隔为'header'和'data'。
'''

header = file_nested_list[0]
data = file_nested_list[1:]   #从第二个元素开始截取列表，




'''
第3部分：计算订单的平均价格。
提示：检查数据以查看“数量”列是否与此计算相关。
提示：仔细想想最简单的方法来做到这一点！
'''

#统计唯一的order_id的数量
#注意：你可以认为这是1834年，因为这是最大的order_id，但最好检查一下
num_orders = len(set([row[0] for row in data]))     # 1834
data

# 对data列表遍历，因为里面还有列表，
# 因为要剥离美元符号和尾随空间，所以读data里面的列表取索引4的值，然后在对里面从索引1处到结尾的那个数字，进行取值，
#创建一个价格清单
prices = [float(row[4][1:-1]) for row in data]

prices



# calculate the average price of an order and round to 2 digits
round(sum(prices) / num_orders, 2)      # $18.81    round对浮点数进行近似取值，保留几位小数


'''
第4部分：创建一个销售的所有独特的苏打水和软饮料的清单（或集合）。
注意：只要看“'Canned Soda' 和'Canned Soft Drink'”，不要忽略其他饮料，如“Izze”。
'''

#如果“item_name”包含“Canned”，则将“choice_description”附加到“sodas”列表中
sodas = []
for row in data:
    if 'Canned' in row[2]:   #因为item_name在data列表中索引是2
        sodas.append(row[3][1:-1])      # 去掉括号，choice_description在data列表中是索引3，去长度索引为1，到结尾的字符。

# 等价上面，一个效果！
sodas = [row[3][1:-1] for row in data if 'Canned' in row[2]]

# 创建一个无重复的列表。
unique_sodas = set(sodas)
unique_sodas

'''
第5部分：计算每个卷饼的平均配料数量。
注意：我们忽略“数量”列来简化此任务。
'''

# 总的卷饼和配料
burrito_count = 0    #卷饼数量
topping_count = 0    #配料数量

# 通过计算逗号并加1来计算配料的数量
# note: x += 1 is equivalent to x = x + 1
for row in data:
    if 'Burrito' in row[2]:
        burrito_count += 1
        topping_count += (row[3].count(',') + 1)

# calculate the average topping count and round to 2 digits
round(topping_count / float(burrito_count), 2)      # 5.40


'''
第6部分：创建一个字典，其中的键代表芯片订单和该值表示订单总数。
预计产量：{'芯片和烤辣椒玉米莎莎'：18，...}
注意：请考虑“数量”栏！
可选：了解如何使用“defaultdict”来简化代码。
'''

#创建一个空字典
chips = {}

# 如果芯片顺序不在字典中，则添加一个新的键/值对
# 如果芯片顺序已经在字典中，则更新该键的值
for row in data:
    if 'Chips' in row[2]:
        if row[2] not in chips:
            chips[row[2]] = int(row[1])     # 这是一个新键，所以创建键/值对，row[1]代表订单（quantity）数量，
        else:
            chips[row[2]] += int(row[1])    # 这是一个现有的键值，所以当遍历到新的chips没有在chips字典里时候，所以增加值。

# defaultdict 函数可以帮你检查key时候已经存在的麻烦~，跟上面的for 代码一样！简化了一层if！
from collections import defaultdict
dchips = defaultdict(int)
for row in data:
    if 'Chips' in row[2]:
        dchips[row[2]] += int(row[1])

chips



#############
# "第二课：pandas统计操作csv文件"
############

'''
基本水平
'''

import pandas as pd
import matplotlib.pyplot as plt

# 读入“imdb_1000.csv”并将其存储在名为movies的DataFrame中
movies = pd.read_csv('imdb_1000.csv')

# 检查行数和列数
movies.shape

# 检查每列的数据类型
movies.dtypes

# 计算平均电影持续时间，mean是均值统计函数！  计算出这1千部电影，电影平均持续时间大约为120分钟！
movies.duration.mean()
# 按持续时间排序DataFrame以查找最短和最长的电影
movies.sort_values('duration').head(1)   #时间最短的电影
movies.sort_values('duration').tail(1) #时间最长的电影：Kenneth Branagh'


# 创建一个持续时间的直方图，选择一个“适当”的箱子数量
movies.duration.plot(kind='hist', bins=20)

# 使用箱形图来显示相同的数据
movies.duration.plot(kind='box')

'''
中级水平
'''

# 统计每个内容分级的电影数量,分级字(content_rating)
movies.content_rating.value_counts()  #返回包含唯一值计数的对象,默认以降序排列

# 使用可视化显示相同的数据，包括标题和x和y标签
plt.xlabel('Content Rating')
plt.ylabel('Number of Movies')
movies.content_rating.value_counts().plot(kind='bar', title='Top 1000 Movies by Content Rating')

# 将 NOT RATED, APPROVED, PASSED, GP 评级 都转换为"UNRATED"，初始状态为38个！
movies.content_rating.replace(['NOT RATED', 'APPROVED', 'PASSED', 'GP'], 'UNRATED', inplace=True)


movies.content_rating.value_counts() # 验证


# 将 'X', 'TV-MA评级 都转换为"NC-17"!
movies.content_rating.replace(['X', 'TV-MA'], 'NC-17', inplace=True)

#计算每列中缺失值的数量
movies.isnull().sum()

# 如果缺少值：检查它们，然后用“合理的”值填充它们
movies[movies.content_rating.isnull()]
movies.content_rating.fillna('UNRATED', inplace=True)

# 计算电影2小时以上的平均星级评分，
# 并与短于2小时的电影的平均星级进行比较
movies[movies.duration >= 120].star_rating.mean()
movies[movies.duration < 120].star_rating.mean()

# 使用可视化来检测持续时间和星级之间是否存在关系
movies.plot(kind='scatter', x='duration', y='star_rating', alpha=0.2)

# 计算每个类型的平均持续时间
movies.groupby('genre').duration.mean()

'''
先进水平
'''

# 可视化内容评级和持续时间之间的关系
movies.boxplot(column='duration', by='content_rating')
movies.hist(column='duration', by='content_rating', sharex=True)

# 确定最高评级的电影（按星级评分）为每个流派
movies.sort_values('star_rating', ascending=False).groupby('genre').title.first()
movies.groupby('genre').title.first()   # 因为DataFrame已经按照星级评分

# 检查是否有多个具有相同标题的电影，如果是，确定它们是否实际上是重复的
dupe_titles = movies[movies.title.duplicated()].title
movies[movies.title.isin(dupe_titles)]  # 将重复的标题显示出来



# 计算每个流派的平均星级，但只包括至少有10部电影的流派

# 选项1：手动创建相关流派的列表，然后使用该列表进行过滤
movies.genre.value_counts()
top_genres = ['Drama', 'Comedy', 'Action', 'Crime', 'Biography', 'Adventure', 'Animation', 'Horror', 'Mystery']
movies[movies.genre.isin(top_genres)].groupby('genre').star_rating.mean()




# 选项2：通过保存value_counts然后过滤，自动创建相关流派的列表
genre_counts = movies.genre.value_counts()
top_genres = genre_counts[genre_counts >= 10].index

movies[movies.genre.isin(top_genres)].groupby('genre').star_rating.mean()

# 选项3：计算所有流派的平均星级评分，然后使用布尔序列进行筛选
movies.groupby('genre').star_rating.mean()[movies.genre.value_counts() >= 10]

# 选项4：通过计数和平均值聚合，然后使用计数进行过滤
genre_ratings = movies.groupby('genre').star_rating.agg(['count', 'mean'])
genre_ratings[genre_ratings['count'] >= 10]



#############
# "第三课：鸢尾花数据用来预测种类
############


# 增加默认图形和字体大小以便于查看
plt.rcParams['figure.figsize'] = (8, 6)
plt.rcParams['font.size'] = 14


# ## Task 1
#
#将鸢尾花数据读入熊猫数据框，包括列名。

#定义列名称列表（作为字符串）(sepal)萼片,(petal)花瓣,(species)种类
col_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']

# 定义从中检索数据的URL（以字符串形式）
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data';;

# 检索CSV文件并添加列名称
iris = pd.read_csv(url, header=None, names=col_names)

# ## Task 2
#
# 收集有关数据的一些基本信息。

iris.shape

iris.head()

iris.dtypes

iris.describe()

iris.species.value_counts()

iris.isnull().sum()

# ## Task 3
#
# 使用排序，拆分应用组合和/或可视化来查找物种之间的差异。.

# ### sorting

# 通过petal_width对DataFrame进行排序并显示NumPy数组

iris.sort_values('petal_width').values

# ### 拆分申请，结合
# 是按物种分组，萼片的长度的统计均值。
iris.groupby('species').sepal_length.mean()

# 所有数字列的均值按物种分组
iris.groupby('species').mean()

#描述按物种分组的所有数字列
iris.groupby('species').describe()  #生成描述性统计数据，汇总数据集分布的中心趋势。

# ### 可视化

# 花瓣宽度的直方图按物种分组
iris.hist(column='petal_width', by='species', sharex=True)

# 根据物种分组的花瓣宽度箱形图
iris.boxplot(column='petal_width', by='species')

# 按种类分组的所有数字列的框图
iris.boxplot(by='species')

# 将物种映射到数值，以便可以按物种染色
iris['species_num'] = iris.species.map({'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2})

# 替代方法
iris['species_num'] = iris.species.factorize()[0]

# petal_length（花瓣长度） vs petal_width（花瓣宽度）的散点图
iris.plot(kind='scatter', x='petal_length', y='petal_width', c='species_num', colormap='brg')

# 所有特征的物种的散布矩阵
pd.scatter_matrix(iris.drop('species_num', axis=1), c=iris.species_num, figsize=(12, 10))

# ## Task 4
#
# 写下一套可用于根据鸢尾花数据测量结果预测物种的规则。.

# 定义一个代表花瓣区域的新特征（“特征工程”）
iris['petal_area'] = iris.petal_length * iris.petal_width

# 描述花瓣区域按物种分组
iris.groupby('species').petal_area.describe().unstack()#旋转（必须是分层的）索引标签的级别，返回具有新标签级别的DataFrame

# 根据物种分组的花瓣区域箱形图
iris.boxplot(column='petal_area', by='species')

# 只显示7至9的花瓣区域的鸢尾花
iris[(iris.petal_area > 7) & (iris.petal_area < 9)].sort_values('petal_area')


# 我的一套预测物种的规则：
#
# - 如果petal_area小于2，则预测** setosa **
# - - 如果petal_area小于7.4，则预测**versicolor*.
# -否则，预测** virginica ***.

# ## Bonus
#
# 定义一个接受一行数据并返回预测物种的函数。 然后，使用该函数对所有现有数据行进行预测，并检查预测的准确性。
#给出一行数据，返回预测的species_num（0/1/2）
def classify_iris(row):
    # c计算petal_area
    petal_area = row[2] * row[3]

    # 根据上述规则预测物种
    if petal_area < 2:
        prediction = 'setosa'
    elif petal_area < 7.4:
        prediction = 'versicolor'
    else:
        prediction = 'virginica'

    # 将物种名称映射到数值
    species_to_num = {'setosa': 0, 'versicolor': 1, 'virginica': 2}

    # 返回该值
    return species_to_num[prediction]


# 打印第一行
iris.iloc[0, :]

# 打印最后一行
iris.iloc[149, :]

# 测试第一行和最后一行的功能
print classify_iris(iris.iloc[0, :])
print classify_iris(iris.iloc[149, :])

# 对所有行进行预测并将其存储在DataFrame中
iris['prediction'] = [classify_iris(row) for index, row in iris.iterrows()]

# 计算正确预测的百分比
sum(iris.species_num == iris.prediction) / 150.




##教程来源：https://github.com/justmarkham/DAT8   作者：Kevin Markham