目录:¶

# 导入基本包
import numpy as np
import pandas as pd

# 导入杂项包
import gc  # 垃圾回收，用于管理内存
import time  # 时间模块，用于计时
import warnings  # 警告处理模块，用于过滤警告信息

# 导入数据可视化包
import matplotlib.pyplot as plt  # Matplotlib绘图库，用于绘制静态图形
import seaborn as sns  # Seaborn绘图库，用于绘制统计图形
import matplotlib.gridspec as gridspec  # Matplotlib网格布局库，用于创建复杂的图形布局
import plotly.offline as pyo  # Plotly离线绘图库，用于绘制交互式图形
from plotly.graph_objs import *  # Plotly绘图库，用于绘制交互式图形
import plotly.graph_objs as go  # Plotly绘图库，用于绘制交互式图形

# 导入地图相关包
import imageio  # 图像处理库，用于处理地图图像
import folium  # Folium地图库，用于创建交互式地图
import folium.plugins as plugins  # Folium插件库，用于添加地图插件
from mpl_toolkits.basemap import Basemap  # Basemap地图库，用于绘制地图

# 导入图网络相关包
import networkx as nx  # NetworkX图网络库，用于构建和分析图网络
import heapq  # 堆队列模块，用于获取列表、字典中的前n个元素

# 设置
start_time = time.time()  # 获取开始时间，用于计时
color = sns.color_palette()  # 设置颜色调色板
sns.set_style("darkgrid")  # 设置Seaborn的绘图风格
warnings.filterwarnings("ignore")  # 忽略警告信息
pyo.init_notebook_mode()  # 初始化Plotly的notebook模式，用于在Jupyter Notebook中显示交互式图形

# 导入必要的包
import pandas as pd  # 导入pandas用于数据处理

# 导入yelp_business.csv数据集
business = pd.read_csv("./data/yelp_business.csv")  # 使用pd.read_csv()函数从CSV文件中读取数据
#business_attributes=pd.read_csv("../data/yelp_business_attributes.csv")  # 可以添加其他的数据集导入语句，例如yelp_business_attributes.csv

# 导入yelp_business_hours.csv数据集
business_hours = pd.read_csv("./data/yelp_business_hours.csv")  

# 导入yelp_checkin.csv数据集
check_in = pd.read_csv("./data/yelp_checkin.csv")  

# 导入yelp_review.csv数据集
reviews = pd.read_csv("./data/yelp_review.csv")  

# 导入yelp_tip.csv数据集
tip = pd.read_csv("./data/yelp_tip.csv")  

# 导入yelp_user.csv数据集
user = pd.read_csv("./data/yelp_user.csv")  

# 计算导入数据集所花费的时间
end_time = time.time()  # 获取当前时间
print("Took", end_time - start_time, "s")  # 输出导入数据集所花费的时间

business.head()

# 获取星级评分的分布
x = business['stars'].value_counts()  # 使用value_counts()函数获取星级评分的计数
x = x.sort_index()  # 对计数结果按照索引（星级评分）排序

# 绘制条形图
plt.figure(figsize=(16,8))  # 设置图像大小
ax = sns.barplot(x=x.index, y=x.values, alpha=0.8)  # 使用seaborn库的barplot函数绘制条形图
plt.title("Star Rating Distribution")  # 设置图标题
plt.ylabel('# of businesses', fontsize=12)  # 设置y轴标签
plt.xlabel('Star Ratings ', fontsize=12)  # 设置x轴标签

# 添加标签文本
rects = ax.patches  # 获取条形图的矩形对象
labels = x.values  # 获取计数值
for rect, label in zip(rects, labels):  # 遍历矩形对象和计数值
    height = rect.get_height()  # 获取矩形的高度
    ax.text(rect.get_x() + rect.get_width()/2, height + 5, label, ha='center', va='bottom')  # 在矩形上方添加文本标签

plt.show()  # 显示图像

# 获取所有商家的业务类别
business_cats = ' '.join(business['categories'])  # 将所有商家的业务类别连接成一个字符串

# 将业务类别拆分为单独的类别，并存储在DataFrame中
cats = pd.DataFrame(business_cats.split(';'), columns=['category'])  # 使用分号将业务类别拆分为单独的类别，并创建DataFrame
x = cats.category.value_counts()  # 使用value_counts()函数获取每个类别的计数
print("Yelp上共有", len(x), "种不同的业务类型/类别!")  # 输出不同业务类别的数量

# 准备绘制条形图的数据
x = x.sort_values(ascending=False)  # 按照计数值降序排序
x = x.iloc[0:20]  # 只取前20个类别用于绘制图表

# 绘制条形图
plt.figure(figsize=(16,4))  # 设置图像大小
ax = sns.barplot(x = x.index, y = x.values, alpha=0.8)  # 使用seaborn库的barplot函数绘制条形图
plt.title("What are the top categories?", fontsize=25)  # 设置图标题
locs, labels = plt.xticks()  # 获取x轴刻度位置和标签
plt.setp(labels, rotation=80)  # 设置x轴标签旋转角度
plt.ylabel('# businesses', fontsize=12)  # 设置y轴标签
plt.xlabel('Category', fontsize=12)  # 设置x轴标签

# 添加标签文本
rects = ax.patches  # 获取条形图的矩形对象
labels = x.values  # 获取计数值
for rect, label in zip(rects, labels):  # 遍历矩形对象和计数值
    height = rect.get_height()  # 获取矩形的高度
    ax.text(rect.get_x() + rect.get_width()/2, height + 5, label, ha='center', va='bottom')  # 在矩形上方添加文本标签

plt.show()  # 显示图像

# 导入必要的库
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap

# 创建一个指定大小的图像窗口
plt.figure(1, figsize=(15,6))

# 使用正投影（ortho projection）生成地球型版本的地图
m1 = Basemap(projection='ortho', lat_0=20, lon_0=-50)

# 使用指定的颜色代码填充大陆和海洋的颜色
m1.fillcontinents(color='#bbdaa4', lake_color='#4a80f5') 

# 添加指定颜色的海洋边界
m1.drawmapboundary(fill_color='#4a80f5')                

# 绘制国家边界线，并设置线宽和颜色
m1.drawcountries(linewidth=0.1, color="black")

# 使用散点图在地图上标示商家的经纬度位置
mxy = m1(business["longitude"].tolist(), business["latitude"].tolist())
m1.scatter(mxy[0], mxy[1], s=3, c="orange", lw=3, alpha=1, zorder=5)

# 为地图添加标题
plt.title("Yelp Reviews Worldwide")

# 显示地图
plt.show()

# 将数据筛选为北美地区
lon_min, lon_max = -132.714844, -59.589844
lat_min, lat_max = 13.976715, 56.395664

# 创建选择器
idx_NA = (business["longitude"] > lon_min) & \
         (business["longitude"] < lon_max) & \
         (business["latitude"] > lat_min) & \
         (business["latitude"] < lat_max)
# 应用选择器进行子集筛选
NA_business = business[idx_NA]

# 初始化绘图
plt.figure(figsize=(12, 6))
m2 = Basemap(projection='merc',
             llcrnrlat=lat_min,
             urcrnrlat=lat_max,
             llcrnrlon=lon_min,
             urcrnrlon=lon_max,
             lat_ts=35,
             resolution='i')

m2.fillcontinents(color='#252a2f', lake_color='#3370ff')  # 深灰色陆地，蓝色湖泊
m2.drawmapboundary(fill_color='#000000')  # 黑色背景
m2.drawcountries(linewidth=0.3, color="w")  # 白色线条标示国界

# 绘制数据
mxy = m2(NA_business["longitude"].tolist(), NA_business["latitude"].tolist())
m2.scatter(mxy[0], mxy[1], s=5, c="#ffcc00", lw=0, alpha=0.05, zorder=5)

plt.title("North America")

# 将数据筛选为欧洲地区
lon_min, lon_max = -8.613281, 16.699219
lat_min, lat_max = 40.488737, 59.204064

# 创建选择器
idx_euro = (business["longitude"] > lon_min) & \
           (business["longitude"] < lon_max) & \
           (business["latitude"] > lat_min) & \
           (business["latitude"] < lat_max)
# 应用选择器进行子集筛选
euro_business = business[idx_euro]

# 初始化绘图
plt.figure(figsize=(12, 6))
m3 = Basemap(projection='merc',
             llcrnrlat=lat_min,
             urcrnrlat=lat_max,
             llcrnrlon=lon_min,
             urcrnrlon=lon_max,
             lat_ts=35,
             resolution='i')

m3.fillcontinents(color='#252a2f', lake_color='#3370ff')  # 深灰色陆地，蓝色湖泊
m3.drawmapboundary(fill_color='#000000')  # 黑色背景
m3.drawcountries(linewidth=0.3, color="w")  # 白色线条标示国界

# 绘制数据
mxy = m3(euro_business["longitude"].tolist(), euro_business["latitude"].tolist())
m3.scatter(mxy[0], mxy[1], s=5, c="#ffcc00", lw=0, alpha=0.05, zorder=5)

plt.title("Europe")
plt.show()

# 获取城市的评级数量
x = business['city'].value_counts()
x = x.sort_values(ascending=False)
x = x.iloc[0:20]

# 绘制柱状图
plt.figure(figsize=(16,4))
ax = sns.barplot(x = x.index, y = x.values, alpha=0.8, color=color[3]) # 设置颜色为color[3]
plt.title("City with the Most Reviews", fontsize=16) # 设置标题和字体大小
plt.xticks(rotation=45, fontsize=12) # 设置X轴标签的旋转角度和字体大小
plt.ylabel('Number of Businesses', fontsize=12) # 设置Y轴标签和字体大小
plt.xlabel('City', fontsize=12) # 设置X轴标签和字体大小

rects = ax.patches # 获取柱状图的每个矩形对象
labels = x.values # 获取柱状图上方的数字标签

# 在每个柱状图上方添加数字标签
for rect, label in zip(rects, labels):
    height = rect.get_height() # 获取柱状图的高度
    ax.text(rect.get_x() + rect.get_width()/2, height + 5, label, ha='center', va='bottom', fontsize=12) # 添加数字标签，设置位置、对齐方式和字体大小

plt.show() # 显示柱状图

# 获取所有的评分数据
rating_data = business[['latitude', 'longitude', 'stars', 'review_count']]
# 创建一个自定义列 'popularity'，计算方法为评分乘以评论数量
rating_data['popularity'] = rating_data['stars'] * rating_data['review_count']

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 7))  # 创建一个包含两个子图的画布，设置画布大小为15x7

# 拉斯维加斯的随机点坐标
lat = 36.207430
lon = -115.268460
# 进行坐标调整，获取合适的图像
lon_min, lon_max = lon - 0.3, lon + 0.5
lat_min, lat_max = lat - 0.4, lat + 0.5
# 根据经纬度范围筛选出拉斯维加斯的数据
ratings_data_vegas = rating_data[(rating_data["longitude"] > lon_min) &
                                (rating_data["longitude"] < lon_max) &
                                (rating_data["latitude"] > lat_min) &
                                (rating_data["latitude"] < lat_max)]

# 绘制拉斯维加斯的散点图
ratings_data_vegas.plot(kind='scatter', x='longitude', y='latitude',
                       color='#74a89b',
                       s=.02, alpha=.6, subplots=True, ax=ax1)
ax1.set_title("Las Vegas")  # 设置子图1的标题
ax1.set_facecolor('black')  # 设置子图1的背景颜色为黑色

# 凤凰城的随机点坐标
lat = 33.435463
lon = -112.006989
# 进行坐标调整，获取合适的图像
lon_min, lon_max = lon - 0.3, lon + 0.5
lat_min, lat_max = lat - 0.4, lat + 0.5
# 根据经纬度范围筛选出凤凰城的数据
ratings_data_phoenix = rating_data[(rating_data["longitude"] > lon_min) &
                                  (rating_data["longitude"] < lon_max) &
                                  (rating_data["latitude"] > lat_min) &
                                  (rating_data["latitude"] < lat_max)]
# 绘制凤凰城的散点图
ratings_data_phoenix.plot(kind='scatter', x='longitude', y='latitude',
                         color='#fb4e29',
                         s=.02, alpha=.6, subplots=True, ax=ax2)
ax2.set_title("Phoenix")  # 设置子图2的标题
ax2.set_facecolor('black')  # 设置子图2的背景颜色为黑色

f.show()  # 显示画布

# 导入必要的绘图库
import matplotlib.pyplot as plt

# 创建包含两个子图的图形窗口，大小为15x7
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,7))

# 在斯图加特市内随机选择一个点
lat = 48.7757200
lon = 9.187950
# 对经纬度进行微调，以获取合适的图片
lon_min, lon_max = lon-0.05,lon+0.05
lat_min, lat_max = lat-0.05,lat+0.05
# 在斯图加特市内筛选数据
ratings_data_stuttgart=rating_data[(rating_data["longitude"]>lon_min) &\
                    (rating_data["longitude"]<lon_max) &\
                    (rating_data["latitude"]>lat_min) &\
                    (rating_data["latitude"]<lat_max)]

# 绘制斯图加特市的散点图
ratings_data_stuttgart.plot(kind='scatter', x='longitude', y='latitude',
                color='#3973fe', 
                s=1, alpha=.6, subplots=True, ax=ax1)
ax1.set_title("Stuttgart") # 设置子图标题
ax1.set_facecolor('black') # 设置子图背景色为黑色

# 在爱丁堡市内随机选择一个点
lat = 55.947871
lon = -3.194255
# 对经纬度进行微调，以获取合适的图片
lon_min, lon_max = lon-0.03,lon+0.03
lat_min, lat_max = lat-0.01,lat+0.01
# 在爱丁堡市内筛选数据
ratings_data_edinburgh=rating_data[(rating_data["longitude"]>lon_min) &\
                    (rating_data["longitude"]<lon_max) &\
                    (rating_data["latitude"]>lat_min) &\
                    (rating_data["latitude"]<lat_max)]
                    
# 绘制爱丁堡市的散点图
ratings_data_edinburgh.plot(kind='scatter', x='longitude', y='latitude',
                color='#ffd949', 
                s=1, alpha=.6, subplots=True, ax=ax2)
ax2.set_title("Edinburgh") # 设置子图标题
ax2.set_facecolor('black') # 设置子图背景色为黑色

# 显示图形窗口
f.show()

data=[]
# 重新排列数据以适应folium所需的格式
stars_list=list(rating_data['stars'].unique()) # 获取唯一的评分值列表
for star in stars_list: # 遍历评分值列表
    subset=ratings_data_vegas[ratings_data_vegas['stars']==star] # 根据评分值筛选数据子集
    data.append(subset[['latitude','longitude']].values.tolist()) # 将经纬度数据转换为列表并添加到data列表中
# 初始化地图的中心坐标和缩放级别
lat = 36.127430
lon = -115.138460
zoom_start=11
print("Vegas Review heatmap Animation ") # 打印标题

# 创建一个基本的folium地图
m = folium.Map(location=[lat, lon], tiles="OpenStreetMap", zoom_start=zoom_start)
# 使用HeatMapWithTime插件来创建带有时间动态变化的热力图
hm = plugins.HeatMapWithTime(data,max_opacity=0.3,auto_play=True,display_index=True,radius=7)
hm.add_to(m) # 将热力图添加到地图中
m # 显示地图

end_time=time.time()
print("Took",end_time-start_time,"s")

# 数据量太大，有100多万个用户，所以抽样100000条数据，你可以用全量数据
user_agg=reviews.sample(100000).groupby('user_id').agg(
            {'review_id':['count'],
             'date':['min','max'],
             'useful':['sum'],
             'funny':['sum'],
             'cool':['sum'],
             'stars':['mean']})

user_agg=user_agg.sort_values([('review_id','count')],ascending=False)
print("          Top 10 Users in Yelp")
user_agg.head(10)

# 追踪顶级用户:
top_user_reviews = reviews[reviews['user_id'] == 'CxDOIDnH8gp9KXzpBHJYXw']
# 获取顶级用户评论的地点信息
top_user_locs = pd.merge(top_user_reviews, business, on='business_id')
# 获取顶级用户评论的唯一日期列表
date_list = list(top_user_locs['date'].unique())
# 重新组织数据以符合 Folium 库所需的格式
data = []
for date in date_list:
    subset = top_user_locs[top_user_locs['date'] == date]
    df = subset[['latitude', 'longitude', 'date']]
    data.append(subset[['latitude', 'longitude']].values.tolist())

# 初始化地图，设置初始位置为加拿大安大略省，经纬度分别为43.860397和-79.303184，初始缩放级别为9
lat = 43.860397
lon = -79.303184
zoom_start = 9
print("                     Stalking the top User    ")
# 创建基础地图对象，使用 Cartodb Positron 瓦片样式，设置初始位置和缩放级别
m = folium.Map(location=[lat, lon], tiles="Cartodb Positron", zoom_start=zoom_start)

# 创建带有时间轴的热力图对象，传入数据和其他参数
hm = plugins.HeatMapWithTime(data, max_opacity=0.3, auto_play=True, display_index=True)
hm.add_to(m) # 将热力图对象添加到地图中
m # 显示地图

reviews = reviews.query('useful>0 and funny>0 and cool>0')

thresholds = [x for x in range(100,1000,20)]
max_star = [round(reviews.query('useful>@thres').stars.max(),1) for thres in thresholds]
avg_star = [round(reviews.query('useful>@thres').stars.mean(),1) for thres in thresholds]
avg_review_len = [reviews.query('useful>@thres')['text'].agg(lambda x: len(x)).agg('mean') for thres in thresholds]
n_review = [reviews.query('useful>@thres').stars.count() for thres in thresholds]

fig, axes = plt.subplots(1, 4, figsize = [20,5])
sns.regplot(x=thresholds, y=max_star,ax = axes[0])
axes[0].title.set_text('Highest Rating with increasing Useful')

sns.regplot(x=thresholds, y=avg_star,ax = axes[1])
axes[1].title.set_text('Average Rating with increasing Useful')

sns.regplot(x=thresholds, y=avg_review_len,ax = axes[2])
axes[2].title.set_text('Average Review Length with increasing Useful')

sns.regplot(x=thresholds, y=n_review,ax = axes[3])
axes[3].title.set_text('Number of Reviews with increasing Useful')

thresholds = [x for x in range(100,1000,20)]
max_star = [round(reviews.query('funny>@thres').stars.max(),1) for thres in thresholds]
avg_star = [round(reviews.query('funny>@thres').stars.mean(),1) for thres in thresholds]
avg_review_len = [reviews.query('funny>@thres')['text'].agg(lambda x: len(x)).agg('mean') for thres in thresholds]
n_review = [reviews.query('funny>@thres').stars.count() for thres in thresholds]

fig, axes = plt.subplots(1, 4, figsize = [20,5])
sns.regplot(x=thresholds, y=max_star,ax = axes[0])
axes[0].title.set_text('Maximum Rating with increasing Funny')

sns.regplot(x=thresholds, y=avg_star,ax = axes[1])
axes[1].title.set_text('Average Rating with increasing Funny')

sns.regplot(x=thresholds, y=avg_review_len,ax = axes[2])
axes[2].title.set_text('Average Review Length with increasing Funny')

sns.regplot(x=thresholds, y=n_review,ax = axes[3])
axes[3].title.set_text('Number of Reviews with increasing Funny')

from textblob import TextBlob

%%time
elite_review_sentiment_score_2012 = reviews.merge(user[user['elite'] != 'None']['user_id'])\
.query("date.str.startswith('2012')", engine='python')['text'].apply(lambda x: TextBlob(x).sentiment.polarity)

regular_review_sentiment_score_2012 = reviews.merge(user[user['elite'] == 'None']['user_id'])\
.query("date.str.startswith('2012')", engine='python')['text'].apply(lambda x: TextBlob(x).sentiment.polarity)

import seaborn as sns

ax1 = sns.histplot(elite_review_sentiment_score_2012, alpha = .4)
ax2 = sns.histplot(regular_review_sentiment_score_2012, alpha = .4)

def senti_word_cloud(s,max_words = 200):
    import matplotlib
    from wordcloud import WordCloud
    matplotlib.rcParams['figure.figsize'] = (20,10)
    # color_mask =imageio.imread("1.png")
    wc1 = WordCloud(background_color="black",  # 背景颜色
            max_words=max_words,  # 显示最大词数
            font_path="msyh.ttf",
            width=1920, height=1080
            ) # 图幅宽度
    
    wc2 = WordCloud(background_color="white",  # 背景颜色
            max_words=max_words,  # 显示最大词数
            font_path="msyh.ttf",
            width=1920, height=1080
            ) # 图幅宽度
    
    positivelist = []
    negativelist = []

    from textblob import TextBlob
    for each in s:
        each_word = TextBlob(each)
        feeling = each_word.sentiment.polarity
        if feeling > 0.25:
            positivelist.append(each)
        elif feeling < -0.25:
            negativelist.append(each)
        else:
            pass
    # 将积极和消极的两个列表各自合并成积极字符串和消极字符串，字符串中的词用空格分隔
    
    positive_string = " ".join(positivelist)
    negative_string = " ".join(negativelist)

    
    fig, axes = plt.subplots(1, 2, figsize=(20, 10))
    wc1.generate(negative_string) 
    axes[0].imshow(wc1, interpolation='bilinear')
    axes[0].set_title('Negative')
    axes[0].axis('off')

    wc2.generate(positive_string) 
    axes[1].imshow(wc2, interpolation='bilinear')
    axes[1].set_title('Positive')
    axes[1].axis('off')

    plt.show()

senti_word_cloud(reviews['text'].sample(20000),max_words = 300)

# Cap max reviews to 30 for better visuals
user_agg[('review_id','count')].loc[user_agg[('review_id','count')]>30] = 30
plt.figure(figsize=(12,5))
plt.suptitle("User Deep dive",fontsize=20)
gridspec.GridSpec(1,2)
plt.subplot2grid((1,2),(0,0))
#Cumulative Distribution
ax=sns.kdeplot(user_agg[('review_id','count')],shade=True,color='r')
plt.title("How many reviews does an average user give?",fontsize=15)
plt.xlabel('# of reviews given', fontsize=12)
plt.ylabel('# of users', fontsize=12)

#Cumulative Distribution
plt.subplot2grid((1,2),(0,1))
sns.distplot(user_agg[('review_id','count')],
             kde_kws=dict(cumulative=True))
plt.title("Cumulative dist. of user reviews",fontsize=15)
plt.ylabel('Cumulative perc. of users', fontsize=12)
plt.xlabel('# of reviews given', fontsize=12)

plt.show()
end_time=time.time()
print("Took",end_time-start_time,"s")

gc.collect()
end_time=time.time()
print("Took",end_time-start_time,"s")

def highlight_max(data, color='yellow'):
    '''
    highlight the maximum in a Series or DataFrame
    '''
    attr = 'background-color: {}'.format(color)
    if data.ndim == 1:  # Series from .apply(axis=0) or axis=1
        is_max = data == data.max()
        return [attr if v else '' for v in is_max]
    else:  # from .apply(axis=None)
        is_max = data == data.max().max()
        return pd.DataFrame(np.where(is_max, attr, ''),
                            index=data.index, columns=data.columns)

#checkins exploration

# 对check_in数据按照'weekday'和'hour'进行分组，计算每组中的'checkins'之和
df = check_in.groupby(['weekday', 'hour'])['checkins'].sum()

# 重置索引，将分组后的结果转换为DataFrame
df = df.reset_index()

# 使用'hour'作为行索引，'weekday'作为列索引，将'checkins'作为值的DataFrame
df = df.pivot(index='hour', columns='weekday')[['checkins']]

# 删除多余的列级别
df.columns = df.columns.droplevel()

# 重置行索引
df = df.reset_index()

# 对'hour'列进行处理，将其转换为整数类型
# 这里使用了lambda函数和split方法将时间字符串中的分钟部分去掉
df.hour = df.hour.apply(lambda x: str(x).split(':')[0])
df.hour = df.hour.astype(int)

# 按照'hour'列的值进行排序
df = df.sort_values('hour')

# 重新排列列的顺序，将'hour'列放在第一列
df = df[['hour', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']]

# 创建颜色映射
cm = sns.light_palette("orange", as_cmap=True)

# 使用自定义函数highlight_max，将每列中的最大值突出显示，颜色为蓝色
df.style.apply(highlight_max, color='#679bff', axis=0)

plt.style.use('ggplot')

# 使用'seaborn-darkgrid'样式设置绘图风格

# 创建颜色调色板
palette = plt.get_cmap('Set1')

# 创建一个大小为(20,10)的图像
plt.figure(figsize=(20,10))

# 添加总标题
plt.suptitle("Checkins variation across time", fontsize=25)

# 创建3x3的网格布局
gridspec.GridSpec(3,3)

# 调整子图之间的垂直间距
plt.subplots_adjust(hspace=0.4)

# 循环绘制多个线图
num = 0
for column in df.drop('hour', axis=1):
    num += 1
    # 找到子图的位置
    
    if num == 7:  # 调整以适应星期日的位置
        plt.subplot2grid((3,3), (2,0), colspan=3)
    else:
        plt.subplot(3,3, num)
    
    # 绘制离散的灰色线图，表示所有组的趋势
    for v in df.drop('hour', axis=1):
        plt.plot(df['hour'], df[v], marker='', color='grey', linewidth=0.6, alpha=0.3)
    
    # 绘制带有标签的线图，表示特定组的趋势
    plt.plot(df['hour'], df[column], marker='', color=palette(num), linewidth=2.4, alpha=0.9, label=column)
    
    # 设置x轴的范围
    plt.xlim(0,24)
    
    # 设置y轴的范围
    plt.ylim(-2,260000)
    
    # 关闭部分子图的x轴刻度
    if num in range(4) :
        plt.tick_params(labelbottom='off')
    
    # 关闭部分子图的y轴刻度
    if num not in [1,4,7] :
        plt.tick_params(labelleft='off')
    
    # 添加子图标题
    plt.title(column, loc='center', fontsize=18, fontweight=0, color=palette(num))

# 筛选至少有一个朋友的用户子集
subset_users = user[user['friends'] != 'None']

# 筛选至少给出 10 条评论的用户子集
subset_users = subset_users[subset_users['review_count'] >= 10]

# 拆分 "friends" 列的值，并创建新的 "list_friends" 列
subset_users['list_friends'] = subset_users["friends"].apply(lambda x: str(x).split(','))

# 仅选择 "user_id" 和 "list_friends" 两列
subset_users = subset_users[['user_id','list_friends']]

# 由于空间限制，限制 DataFrame 在前 6000 行
subset_users = subset_users.iloc[0:6000]

# 将 "user_id" 列设置为索引，并将 "list_friends" 列的值堆叠成多行
res = subset_users.set_index(['user_id'])['list_friends'].apply(pd.Series).stack()

network_data=res.reset_index()
network_data.tail()

#changing the column name to suit nx import
network_data.columns=['source','level_1','target']

# Considering each (user_id,friend) pair as an edge of a graph, constructing the graph
graph=nx.from_pandas_edgelist(network_data.sample(1000))
# logging time
end_time=time.time()
print("Took",end_time-start_time,"s")

#credits https://www.kaggle.com/crailtap/basic-network-analysis-tutorial
#basic info
print(nx.info(graph))
#check density
print("The density of the graph is ",nx.density(graph))
# we get a very sparse(not dense) graph. Maybe if we used all the nodes then we might get a more dense graph
#too big to draw!
nx.draw(graph, pos=nx.spring_layout(graph))

# 从位于 Stuttgart 城市的商家中提取用户数据并创建用户网络图

# 选择位于 Stuttgart 城市的商家
subset = business[business.city == 'Stuttgart']

# 将商家数据与评论数据进行内连接
subset = pd.merge(subset, reviews, how='inner', on='business_id')

# 提取唯一的用户ID
subset_users = subset.user_id.unique()

# 创建用户ID的数据框
subset_users = pd.DataFrame(subset_users, columns=['user_id'])

# 将用户ID与用户数据集进行内连接
subset_users = pd.merge(subset_users, user, how='inner', on='user_id')

# 创建好友列表
subset_users['list_friends'] = subset_users["friends"].apply(lambda x: str(x).split(','))
subset_users['count_friends'] = subset_users["list_friends"].apply(lambda x: len(x))

# 检查结果
subset_users.shape

# 提取用户ID和好友列表
subset_users_list = subset_users[['user_id', 'list_friends']]

# 将好友列表展开成多行
network_data = subset_users_list.set_index(['user_id'])['list_friends'].apply(pd.Series).stack()
network_data = network_data.reset_index()

# 修改列名以适应网络图导入
network_data.columns = ['source', 'level_1', 'target']

graph=nx.from_pandas_edgelist(network_data)
# logging time
end_time=time.time()
print("Took",end_time-start_time,"s")

#basic info
print(nx.info(graph))
#check density
print("The density of the graph is ",nx.density(graph))

#use degree-centrality to find out influencers in the selected region
x=nx.degree_centrality(graph)
#Creating a subset again as we cant handle 70k nodes, unfortunately.

#Using heapq to find the 500 most connected nodes (ie) peeple with the most connections
influencers=heapq.nlargest(500, x, key=x.get)

#creating a sub-graph as I'm not able to create the layout positions without killing the kernal
influencers_sub_graph=graph.subgraph(influencers)

# Check for isolates ( nodes with no edges (ie) users without friends in the sub-graph)
# graph=graph.remove_nodes_from(nx.isolates(graph))
list_of_nodes_to_be_removed=[x for x in nx.isolates(influencers_sub_graph)]

# remove the selected isolates from the main graph
graph.remove_nodes_from(list_of_nodes_to_be_removed)

#recreate the subgraph from the updated graph
influencers_sub_graph=graph.subgraph(influencers)

#basic info
print(nx.info(influencers_sub_graph))
#check density
print("The density of the graph is ",nx.density(influencers_sub_graph))

nx.draw(influencers_sub_graph, pos=nx.spring_layout(influencers_sub_graph))

# create the layout
pos = nx.spring_layout(influencers_sub_graph)

plt.figure(figsize=(8,8))
plt.title("Stuttgart's friend graph: Spring layout")
nx.draw(influencers_sub_graph, pos=pos, node_size=0.05, width=1)

plt.figure(figsize=(8,8))
plt.title("Cicos style plot of Stuttgart's community")
#https://stackoverflow.com/questions/21978487/improving-python-networkx-graph-layout
nx.draw_circular(influencers_sub_graph,node_size=0.001, width=0.001)

plt.figure(figsize=(8,8))
plt.title("Plot of Stuttgart's community with nodes at random positions")
#https://stackoverflow.com/questions/21978487/improving-python-networkx-graph-layout
nx.draw_random(influencers_sub_graph,node_size=0.001, width=0.001)

plt.figure(figsize=(8,8))
plt.title("Plot of Stuttgart's community : Kamada Kawai layout")
pos2=nx.kamada_kawai_layout(influencers_sub_graph)
nx.draw(influencers_sub_graph, pos=pos, node_size=0.2, width=0.1)

# pip install python-louvain

#community detection -- Done in 3 lines :p
import community
parts = community.best_partition(influencers_sub_graph)
values = [parts.get(node) for node in influencers_sub_graph.nodes()]

print(len(set(values))," Communities have been identified")

plt.figure(figsize=(8,8))
plt.axes=False
plt.title("Stuttgart's Communities",fontsize=20)
nx.draw_networkx(influencers_sub_graph, 
                 pos = pos,cmap = plt.get_cmap("rainbow"), 
                 node_color = values, 
                 node_size = 10,
                 with_labels = False)

plt.figure(figsize=(8,8))
plt.axes=False
plt.title("Stuttgart's Communities : alternate view",fontsize=20)
nx.draw_networkx(influencers_sub_graph, pos = pos2,cmap = plt.get_cmap("rainbow"), node_color = values, node_size = 10, with_labels = False)