python分析英雄联盟

合集下载

基于ECharts的英雄联盟(LPL)数据可视化分析

基于ECharts的英雄联盟(LPL)数据可视化分析

创建Flask 连接前端 模板页面
爬取需要 用到的特 定数据
接收服务 器返回的 JSON数据
ECharts 构建数据 可视化
将数据存 入MySQL 数据库
JSON数据 存入定义 好的路由
将图标放 入前端盒
子中
图 1 系统框架图 Fig.1 System framework diagram
收稿日期 :2022-05-26 作者简介 :郑涛(2001—),男,福建福州人,本科,研究方向 :数据挖掘。 通讯作者 :陈婷婷(1995—),女,福建厦门人,硕士研究生,助教,研究方向 :数据挖掘、大数据分析。
3.1 系统总体框架 本项目运用 Request 网络爬虫框架,从英雄联盟(LPL) 官网爬取各战队比赛数据,利用 Flask 框架及 Python、 ECharts、HTML5、CSSJavaScript 等多种语言,构建针 对赛事观众设计的一套智能分析系统,并进行可视化展 示,其系统结构框架图如图 1 所示。 由图 1 可以看出,该系统由三个模块组成 :数据采 集模块,数据传输模块,数据可视化模块。其中数据可 视化包括个人战绩堆叠图、英雄数据轮播图、战队胜负 数据、个人比赛数据、战队排行榜、个人排行榜及 MVP 种子选手,还有英雄比赛数据查询模块。 3.2 软件体系架构设计 在软件体系架构设计中,采用分层模块化设计。在用 户层上,安装常见的浏览器软件,用户本机可连接英特网 前提下,用户即可操作功能模块 ;在应用层上,设计英雄 比赛数据查询模块、英雄数据轮播图等子模块 ;在交互层 上,使用 Flask 连接前端页面,通过 Ajax 向服务器发送 请求,接收服务器返回的 JSON 数据然后使用 JavaScript 修改网页,进而实现页面局部数据更新。 3.3 系统设计技术路线 在设计本系统时,前端模块可使用 VScode 来进行代 码的编辑、开发和优化,使用 Django 基础架构,利用原 生前端开发工具和 Bootstrap 前端框架来进行前端页面的 搭建,并使用 ECharts 可视化开发工具构建可视化图表, 构建可视化系统,针对部分系统的数据,可使用数据库 作为存储和交换的中间载体,系统设计技术路线直观表 述如图 2 所示。

lol脚本的原理

lol脚本的原理

lol脚本的原理
LOL脚本的原理指的是在LOL游戏中使用脚本编写的程序来
实现自动化操作的功能。

脚本是一种通过代码来控制游戏角色或者自动执行游戏操作的技术。

LOL脚本通常使用脚本编程语言来编写,比如Python、Lua等。

这些编程语言提供了丰富的函数和类库,可以用来模拟玩家的操作。

通过编写脚本,玩家可以实现自动释放技能、自动走位、自动购买装备等一系列操作,从而提高游戏战斗的效率和便捷性。

脚本的原理是将游戏的相关信息和操作以代码的形式进行封装,并通过调用游戏的API(Application Programming Interface,
应用程序编程接口)来实现与游戏的交互。

脚本可以获取游戏内的各种状态信息,比如英雄血量、敌人位置等,然后根据这些信息来做出相应的操作。

这些操作可能是自动释放技能、自动选择目标、自动使用物品等。

脚本的原理还包括了一些游戏机制的研究和分析。

通过分析游戏的内存数据和网络数据包,可以获取到更多的游戏信息,比如敌人的位置、技能的冷却时间等。

这些信息可以用于制定更加精确和高效的操作策略。

需要注意的是,LOL脚本的使用往往违反了游戏的规则和服
务条款,可能会导致账号被封禁。

此外,脚本的使用也会削减游戏的挑战性和娱乐性,对其他玩家造成不公平的竞争。

因此,
玩家在使用脚本前应该权衡利弊,并自觉遵守游戏规则和道德准则。

python数据分析方法论述(配备代码和数据)

python数据分析方法论述(配备代码和数据)

python数据分析方法论述(配备代码和数据)Python数据分析方法论述引言Python是一种功能强大且灵活的编程语言,被广泛应用于数据分析领域。

本文将论述一些常用的Python数据分析方法,并配备相应的代码和数据。

1. 数据获取在数据分析过程中,首先需要获取数据。

Python提供了多种方法来获取数据,包括从文件读取数据、通过API获取数据、从数据库中提取数据等。

以下是一个从CSV文件中读取数据的示例代码:import pandas as pddata = pd.read_csv('data.csv')2. 数据清洗在进行数据分析之前,通常需要对数据进行清洗,以去除缺失值、异常值或重复值等。

Python提供了丰富的工具和库来进行数据清洗。

以下是一个简单的数据清洗示例,用于去除缺失值:data.dropna(inplace=True)3. 数据探索数据探索是数据分析的重要环节,可以通过统计分析、可视化等方式来了解数据的特征和分布情况。

Python提供了许多库和工具来进行数据探索。

以下是一个使用Matplotlib库进行数据可视化的示例代码:import matplotlib.pyplot as pltplt.hist(data['column_name'])plt.show()4. 数据分析在数据分析阶段,可以应用各种统计方法和机器学习算法来挖掘数据中的信息和模式。

Python提供了众多用于数据分析的库和算法。

以下是一个使用Scikit-learn库进行回归分析的示例代码:from sklearn.linear_model import LinearRegressionX = data[['feature1', 'feature2']]y = data['target']model = LinearRegression()model.fit(X, y)5. 结果展示数据分析的最后一步是将结果进行展示和分享。

python爬取电竞《绝地求生》比赛数据集分析

python爬取电竞《绝地求生》比赛数据集分析

python爬取电竞《绝地求⽣》⽐赛数据集分析 python爬取电竞《绝地求⽣》⽐赛数据集分析⼀,选题背景 电⼦竞技(Electronic Sports)是电⼦游戏⽐赛达到“竞技”层⾯的体育项⽬。

电⼦竞技就是利⽤电⼦设备作为运动器械进⾏的、⼈与⼈之间的智⼒和体⼒结合的⽐拼。

通过电⼦竞技,可以锻炼和提⾼参与者的思维能⼒、反应能⼒、四肢协调能⼒和意志⼒,培养团队精神,并且职业电竞对体⼒也有较⾼要求。

电⼦竞技也是⼀种职业,和棋艺等⾮电⼦游戏⽐赛类似,2003年11⽉18⽇,国家体育局正式批准,将电⼦竞技列为第99个正式体育竞赛项⽬。

2008年,国家体育总局将电⼦竞技改批为第78号正式体育竞赛项⽬。

2018年雅加达亚运会将电⼦竞技纳为表演项⽬。

数据来源:20G绝地求⽣⽐赛数据集。

⼆,设计⽅案1,爬⾍名称:python爬取电竞《绝地求⽣》⽐赛数据集分析2,爬⾍爬取的内容与数据特征分析 主要分成两部分,⼀部分是玩家⽐赛的统计数据,以agg_match_stats开头,⼀部分是玩家被击杀的数据,以kill_match_stats开头本次分析选取其中的两个数据集进⾏分析3,设计⽅案:1. 飞机嗡嗡地,我到底跳哪⾥⽐较安全?2. 我是该苟着不动,还是应该出去猛⼲?3. 是该单打独⽃还是跟队友⼀起配合?4. 毒来了我跑不过毒怎么办啊?5. 什么武器最有⽤?6. 近战适合使⽤什么武器,狙击适合使⽤什么武器呢?7. 最后的毒圈⼀般会在哪⾥呢?三,结果特征分析1,页⾯的结构与特征分析四,程序设计1,# 使⽤pandas读取数据1import pandas as pd2import numpy as np3import matplotlib.pyplot as plt4import seaborn as sns5 %matplotlib inline6 plt.rcParams['font.sans-serif'] = ['SimHei'] # 指定默认字体7 plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显⽰为⽅块的问题89# 使⽤pandas读取数据10 agg1 = pd.read_csv('/Users/apple/Desktop/pubg/aggregate/agg_match_stats_1.csv')2,# 探索数据结构并数据清洗1 agg1.head()# 总共有13844275⾏玩家数据,15列1 agg1.shape1 agg1.columns1 ()3,数据分析与可视化# 丢弃重复数据1 agg1.drop_duplicates(inplace=True)23 agg1.loc[1]# 添加是否成功吃鸡列1 agg1['won'] = agg1['team_placement'] == 1# 添加是否搭乘过车辆列1 agg1['drove'] = agg1['player_dist_ride'] != 0我是该苟着不动,还是应该出去猛⼲1 agg1.loc[agg1['player_kills'] < 40, ['player_kills', 'won']].groupby('player_kills').won.mean().plot.bar(figsize=(15,6), rot=0)2 plt.xlabel('击杀⼈数', fontsize=14)3 plt.ylabel("吃鸡概率", fontsize=14)4 plt.title('击杀⼈数与吃鸡概率的关系', fontsize=14)不同模式下的平均击杀⼈数:1 agg1.groupby('party_size').player_kills.mean()1 g = sns.FacetGrid(agg1.loc[agg1['player_kills']<=10, ['party_size', 'player_kills']], row="party_size", size=4, aspect=2)2 g = g.map(sns.countplot, "player_kills")3456 party_size=11 party_size=21 party_size=4是该单打独⽃还是跟队友⼀起配合?1 agg1.loc[agg1['party_size']!=1, ['player_assists', 'won']].groupby('player_assists').won.mean().plot.bar(figsize=(15,6), rot=0)2 plt.xlabel('助攻次数', fontsize=14)3 plt.ylabel("吃鸡概率", fontsize=14)4 plt.title('助攻次数与吃鸡概率的关系', fontsize=14)“毒来了我跑不过毒怎么办啊”之车辆到底有多重要?1 agg1.groupby('drove').won.mean().plot.barh(figsize=(6,3))2 plt.xlabel("吃鸡概率", fontsize=14)3 plt.ylabel("是否搭乘过车辆", fontsize=14)4 plt.title('搭乘车辆与吃鸡概率的关系', fontsize=14)5 plt.yticks([1,0],['是','否'])1 dist_ride = agg1.loc[agg1['player_dist_ride']<12000, ['player_dist_ride', 'won']]23 labels=["0-1k", "1-2k", "2-3k", "3-4k","4-5k", "5-6k", "6-7k", "7-8k", "8-9k", "9-10k", "10-11k", "11-12k"]4 dist_ride['drove_cut'] = pd.cut(dist_ride['player_dist_ride'], 12, labels=labels)56 dist_ride.groupby('drove_cut').won.mean().plot.bar(rot=60, figsize=(8,4))7 plt.xlabel("搭乘车辆⾥程", fontsize=14)8 plt.ylabel("吃鸡概率", fontsize=14)9 plt.title('搭乘车辆⾥程与吃鸡概率的关系', fontsize=14)match_unique = agg1.loc[agg1['party_size'] == 1, 'match_id'].unique()match_unique = agg1.loc[agg1['party_size'] == 1, 'match_id'].unique()把玩家被击杀的数据导⼊进来1# 先把玩家被击杀的数据导⼊进来并探索数据2 death1 = pd.read_csv('/Users/apple/Desktop/pubg/deaths/kill_match_stats_final_1.csv')34 death1.head()1 ()23 death1.shape45 death1_solo = death1[death1['match_id'].isin(match_unique)]67 death1_()飞机嗡嗡地,我到底跳哪⾥⽐较安全1# 只统计单⼈模式,筛选存活不超过180秒的玩家数据2 death_180_seconds_erg = death1_solo.loc[(death1_solo['map'] == 'ERANGEL')&(death1_solo['time'] < 180)&(death1_solo['victim_position_x']>0), :].dropna()3 death_180_seconds_mrm = death1_solo.loc[(death1_solo['map'] == 'MIRAMAR')&(death1_solo['time'] < 180)&(death1_solo['victim_position_x']>0), :].dropna() 45 death_180_seconds_erg.shape67 death_180_seconds_mrm.shape1# 选择存活不过180秒的玩家死亡位置2 data_erg = death_180_seconds_erg[['victim_position_x', 'victim_position_y']].values3 data_mrm = death_180_seconds_mrm[['victim_position_x', 'victim_position_y']].values45# 重新scale玩家位置6 data_erg = data_erg*4096/8000007 data_mrm = data_mrm*1000/80000089from scipy.ndimage.filters import gaussian_filter10import matplotlib.cm as cm11from matplotlib.colors import Normalize12from scipy.misc.pilutil import imread1314from scipy.ndimage.filters import gaussian_filter15import matplotlib.cm as cm16from matplotlib.colors import Normalize1718def heatmap(x, y, s, bins=100):19 heatmap, xedges, yedges = np.histogram2d(x, y, bins=bins)20 heatmap = gaussian_filter(heatmap, sigma=s)2122 extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]23return heatmap.T, extent2425 bg = imread('/Users/apple/Desktop/pubg/erangel.jpg')26 hmap, extent = heatmap(data_erg[:,0], data_erg[:,1], 4.5)27 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*4.5, 0.0, 1.)28 colors = Normalize(0, hmap.max(), clip=True)(hmap)29 colors = cm.Reds(colors)30 colors[..., -1] = alphas3132 fig, ax = plt.subplots(figsize=(24,24))33 ax.set_xlim(0, 4096); ax.set_ylim(0, 4096)34 ax.imshow(bg)35 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)36 plt.gca().invert_yaxis()1 bg = imread('/Users/apple/Desktop/pubg/miramar.jpg')2 hmap, extent = heatmap(data_mrm[:,0], data_mrm[:,1], 4)3 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*4, 0.0, 1.)4 colors = Normalize(0, hmap.max(), clip=True)(hmap)5 colors = cm.Reds(colors)6 colors[..., -1] = alphas78 fig, ax = plt.subplots(figsize=(24,24))9 ax.set_xlim(0, 1000); ax.set_ylim(0, 1000)10 ax.imshow(bg)11 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)12#plt.scatter(plot_data_mr[:,0], plot_data_mr[:,1])13 plt.gca().invert_yaxis()最后的毒圈⼀般会在哪⾥呢?这⾥选取每场⽐赛第⼀名和第⼆名的位置数据,因为第⼀名和第⼆名所在的位置基本上就是最后的毒圈所在的位置1 death_final_circle_erg = death1_solo.loc[(death1_solo['map'] == 'ERANGEL')&(death1_solo['victim_placement'] == 2)&(death1_solo['victim_position_x']>0)&(death1_solo['killer_position_x']>0), :].dropna()2 death_final_circle_mrm = death1_solo.loc[(death1_solo['map'] == 'MIRAMAR')&(death1_solo['victim_placement'] == 2)&(death1_solo['victim_position_x']>0)&(death1_solo['killer_position_x']>0), :].dropna() 34print(death_final_circle_erg.shape)5print(death_final_circle_mrm.shape)67 final_circle_erg = np.vstack([death_final_circle_erg[['victim_position_x', 'victim_position_y']].values,8 death_final_circle_erg[['killer_position_x', 'killer_position_y']].values])*4096/8000009 final_circle_mrm = np.vstack([death_final_circle_mrm[['victim_position_x', 'victim_position_y']].values,10 death_final_circle_mrm[['killer_position_x', 'killer_position_y']].values])*1000/8000001 bg = imread('/Users/apple/Desktop/pubg/erangel.jpg')2 hmap, extent = heatmap(final_circle_erg[:,0], final_circle_erg[:,1], 1.5)3 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*1.5, 0.0, 1.)4 colors = Normalize(0, hmap.max(), clip=True)(hmap)5 colors = cm.Reds(colors)6 colors[..., -1] = alphas78 fig, ax = plt.subplots(figsize=(24,24))9 ax.set_xlim(0, 4096); ax.set_ylim(0, 4096)10 ax.imshow(bg)11 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)12#plt.scatter(plot_data_er[:,0], plot_data_er[:,1])1314 plt.gca().invert_yaxis()1 bg = imread('/Users/apple/Desktop/pubg/miramar.jpg')2 hmap, extent = heatmap(final_circle_mrm[:,0], final_circle_mrm[:,1], 1.5)3 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*1.5, 0.0, 1.)4 colors = Normalize(0, hmap.max(), clip=True)(hmap)5 colors = cm.Reds(colors)6 colors[..., -1] = alphas78 fig, ax = plt.subplots(figsize=(24,24))9 ax.set_xlim(0, 1000); ax.set_ylim(0, 1000)10 ax.imshow(bg)11 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)12#plt.scatter(plot_data_mr[:,0], plot_data_mr[:,1])13 plt.gca().invert_yaxis()什么武器最有⽤?1 erg_died_of = death1.loc[(death1['map']=='ERANGEL')&(death1['killer_position_x']>0)&(death1['victim_position_x']>0)&(death1['killed_by']!='Down and Out'),:]2 mrm_died_of = death1.loc[(death1['map']=='MIRAMAR')&(death1['killer_position_x']>0)&(death1['victim_position_x']>0)&(death1['killed_by']!='Down and Out'),:]34print(erg_died_of.shape)5print(mrm_died_of.shape)1 erg_died_of['killed_by'].value_counts()[:10].plot.barh(figsize=(10,5))2 plt.xlabel("被击杀⼈数", fontsize=14)3 plt.ylabel("击杀的武器", fontsize=14)4 plt.title('武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)5 plt.yticks(fontsize=12)狙击适合使⽤什么武器?1# 把位置信息转换成距离,以“⽶”为单位2 erg_distance = np.sqrt(((erg_died_of['killer_position_x']-erg_died_of['victim_position_x'])/100)**2 + ((erg_died_of['killer_position_y']-erg_died_of['victim_position_y'])/100)**2)3456 mrm_distance = np.sqrt(((mrm_died_of['killer_position_x']-mrm_died_of['victim_position_x'])/100)**2 + ((mrm_died_of['killer_position_y']-mrm_died_of['victim_position_y'])/100)**2) 78910 sns.distplot(erg_distance.loc[erg_distance<400])1 erg_died_of.loc[(erg_distance > 800)&(erg_distance < 1500), 'killed_by'].value_counts()[:10].plot.bar(rot=30)2 plt.xlabel("狙击的武器", fontsize=14)3 plt.ylabel("被狙击的⼈数", fontsize=14)4 plt.title('狙击武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)5 plt.yticks(fontsize=12)1 mrm_died_of.loc[(mrm_distance > 800)&(mrm_distance < 1000), 'killed_by'].value_counts()[:10].plot.bar(rot=30)2 plt.xlabel("狙击的武器", fontsize=14)3 plt.ylabel("被狙击的⼈数", fontsize=14)4 plt.title('狙击武器跟击杀⼈数的统计(热情沙漠⽶拉玛)', fontsize=14)5 plt.yticks(fontsize=12)近战适合使⽤什么武器?1 erg_died_of.loc[erg_distance<10, 'killed_by'].value_counts()[:10].plot.bar(rot=30)2 plt.xlabel("近战武器", fontsize=14)3 plt.ylabel("被击杀的⼈数", fontsize=14)4 plt.title('近战武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)5 plt.yticks(fontsize=12)1 mrm_died_of.loc[mrm_distance<10, 'killed_by'].value_counts()[:10].plot.bar(rot=30)2 plt.xlabel("近战武器", fontsize=14)3 plt.ylabel("被击杀的⼈数", fontsize=14)4 plt.title('近战武器武器跟击杀⼈数的统计(热情沙漠⽶拉玛)', fontsize=14)5 plt.yticks(fontsize=12)Top10武器在各距离下的击杀百分⽐1 erg_died_of['erg_dist'] = erg_distance2 erg_died_of = erg_died_of.loc[erg_died_of['erg_dist']<800, :]3 top_weapons_erg = list(erg_died_of['killed_by'].value_counts()[:10].index)4 top_weapon_kills = erg_died_of[np.in1d(erg_died_of['killed_by'], top_weapons_erg)].copy()5 top_weapon_kills['bin'] = pd.cut(top_weapon_kills['erg_dist'], np.arange(0, 800, 10), include_lowest=True, labels=False)6 top_weapon_kills_wide = top_weapon_kills.groupby(['killed_by', 'bin']).size().unstack(fill_value=0).transpose()7810 top_weapon_kills_wide = top_weapon_kills_wide.div(top_weapon_kills_wide.sum(axis=1), axis=0)11121314from bokeh.models.tools import HoverTool15from bokeh.palettes import brewer16from bokeh.plotting import figure, show, output_notebook17from bokeh.models.sources import ColumnDataSource1819def stacked(df):20 df_top = df.cumsum(axis=1)21 df_bottom = df_top.shift(axis=1).fillna(0)[::-1]22 df_stack = pd.concat([df_bottom, df_top], ignore_index=True)23return df_stack2425 hover = HoverTool(26 tooltips=[27 ("index", "$index"),28 ("weapon", "@weapon"),29 ("(x,y)", "($x, $y)")30 ],31 point_policy='follow_mouse'32 )3334 areas = stacked(top_weapon_kills_wide)3536 colors = brewer['Spectral'][areas.shape[1]]37 x2 = np.hstack((top_weapon_kills_wide.index[::-1],38 top_weapon_kills_wide.index)) /0.0953940 TOOLS="pan,wheel_zoom,box_zoom,reset,previewsave"41 output_notebook()42 p = figure(x_range=(1, 800), y_range=(0, 1), tools=[TOOLS, hover], plot_width=800)43 p.grid.minor_grid_line_color = '#eeeeee'4445 source = ColumnDataSource(data={46'x': [x2] * areas.shape[1],47'y': [areas[c].values for c in areas],48'weapon': list(top_weapon_kills_wide.columns),49'color': colors50 })5152 p.patches('x', 'y', source=source, legend="weapon",53 color='color', alpha=0.8, line_color=None)54 p.title.text = "Top10武器在各距离下的击杀百分⽐(绝地海岛艾伦格)"55 p.xaxis.axis_label = "击杀距离(0-800⽶)"56 p.yaxis.axis_label = "百分⽐"5758 show(p)59606162 mrm_died_of['erg_dist'] = mrm_distance63 mrm_died_of = mrm_died_of.loc[mrm_died_of['erg_dist']<800, :]64 top_weapons_erg = list(mrm_died_of['killed_by'].value_counts()[:10].index)65 top_weapon_kills = mrm_died_of[np.in1d(mrm_died_of['killed_by'], top_weapons_erg)].copy()66 top_weapon_kills['bin'] = pd.cut(top_weapon_kills['erg_dist'], np.arange(0, 800, 10), include_lowest=True, labels=False)67 top_weapon_kills_wide = top_weapon_kills.groupby(['killed_by', 'bin']).size().unstack(fill_value=0).transpose()6869 top_weapon_kills_wide = top_weapon_kills_wide.div(top_weapon_kills_wide.sum(axis=1), axis=0)70717273def stacked(df):74 df_top = df.cumsum(axis=1)75 df_bottom = df_top.shift(axis=1).fillna(0)[::-1]76 df_stack = pd.concat([df_bottom, df_top], ignore_index=True)77return df_stack7879 hover = HoverTool(80 tooltips=[81 ("index", "$index"),82 ("weapon", "@weapon"),83 ("(x,y)", "($x, $y)")84 ],85 point_policy='follow_mouse'86 )8788 areas = stacked(top_weapon_kills_wide)8990 colors = brewer['Spectral'][areas.shape[1]]91 x2 = np.hstack((top_weapon_kills_wide.index[::-1],92 top_weapon_kills_wide.index)) /0.0959394 TOOLS="pan,wheel_zoom,box_zoom,reset,previewsave"95 output_notebook()96 p = figure(x_range=(1, 800), y_range=(0, 1), tools=[TOOLS, hover], plot_width=800)97 p.grid.minor_grid_line_color = '#eeeeee'9899 source = ColumnDataSource(data={100'x': [x2] * areas.shape[1],101'y': [areas[c].values for c in areas],102'weapon': list(top_weapon_kills_wide.columns),103'color': colors104 })105106 p.patches('x', 'y', source=source, legend="weapon",107 color='color', alpha=0.8, line_color=None)108 p.title.text = "Top10武器在各距离下的击杀百分⽐(热情沙漠⽶拉玛)"109 p.xaxis.axis_label = "击杀距离(0-800⽶)"110 p.yaxis.axis_label = "击杀百分⽐"112 show(p)⾃⼰把⾃⼰⼲倒的⽅式与⼈数1 death1.head()1 kill_by_self = death1.loc[death1['killer_name']==death1['victim_name'], "killed_by"]23 kill_by_self.value_counts()[:10].plot.barh()4 plt.xlabel("⾃毙的⼈数", fontsize=14)5 plt.ylabel("⾃毙的⽅式", fontsize=14)6 plt.title('⾃⼰把⾃⼰⼲倒的⽅式与⼈数', fontsize=14)7 plt.yticks(fontsize=12)1# ⾃⼰把⾃⼰⼲倒的⼈数场均百分⽐2 kill_by_self.shape[0]/death1.shape[0]*100完整代码:1import pandas as pd2import numpy as np3import matplotlib.pyplot as plt4import seaborn as sns5 %matplotlib inline6 plt.rcParams['font.sans-serif'] = ['SimHei'] # 指定默认字体7 plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显⽰为⽅块的问题89# 使⽤pandas读取数据10 agg1 = pd.read_csv('/Users/apple/Desktop/pubg/aggregate/agg_match_stats_1.csv')1112# 探索数据结构13 agg1.head()1415# 总共有13844275⾏玩家数据,15列16 agg1.shape1718 agg1.columns1920 ()2122# 丢弃重复数据23 agg1.drop_duplicates(inplace=True)2425 agg1.loc[1]2627# 添加是否成功吃鸡列28 agg1['won'] = agg1['team_placement'] == 12930# 添加是否搭乘过车辆列31 agg1['drove'] = agg1['player_dist_ride'] != 03233 agg1.loc[agg1['player_kills'] < 40, ['player_kills', 'won']].groupby('player_kills').won.mean().plot.bar(figsize=(15,6), rot=0)34 plt.xlabel('击杀⼈数', fontsize=14)35 plt.ylabel("吃鸡概率", fontsize=14)36 plt.title('击杀⼈数与吃鸡概率的关系', fontsize=14)3738 agg1.groupby('party_size').player_kills.mean()3940 g = sns.FacetGrid(agg1.loc[agg1['player_kills']<=10, ['party_size', 'player_kills']], row="party_size", size=4, aspect=2)41 g = g.map(sns.countplot, "player_kills")4243 agg1.loc[agg1['party_size']!=1, ['player_assists', 'won']].groupby('player_assists').won.mean().plot.bar(figsize=(15,6), rot=0)44 plt.xlabel('助攻次数', fontsize=14)45 plt.ylabel("吃鸡概率", fontsize=14)46 plt.title('助攻次数与吃鸡概率的关系', fontsize=14)4748 agg1.groupby('drove').won.mean().plot.barh(figsize=(6,3))49 plt.xlabel("吃鸡概率", fontsize=14)50 plt.ylabel("是否搭乘过车辆", fontsize=14)51 plt.title('搭乘车辆与吃鸡概率的关系', fontsize=14)52 plt.yticks([1,0],['是','否'])5354 dist_ride = agg1.loc[agg1['player_dist_ride']<12000, ['player_dist_ride', 'won']]5556 labels=["0-1k", "1-2k", "2-3k", "3-4k","4-5k", "5-6k", "6-7k", "7-8k", "8-9k", "9-10k", "10-11k", "11-12k"]57 dist_ride['drove_cut'] = pd.cut(dist_ride['player_dist_ride'], 12, labels=labels)5859 dist_ride.groupby('drove_cut').won.mean().plot.bar(rot=60, figsize=(8,4))60 plt.xlabel("搭乘车辆⾥程", fontsize=14)61 plt.ylabel("吃鸡概率", fontsize=14)62 plt.title('搭乘车辆⾥程与吃鸡概率的关系', fontsize=14)6364 match_unique = agg1.loc[agg1['party_size'] == 1, 'match_id'].unique()6566# 先把玩家被击杀的数据导⼊进来并探索数据67 death1 = pd.read_csv('/Users/apple/Desktop/pubg/deaths/kill_match_stats_final_1.csv')6869 death1.head()7071 ()7273 death1.shape7475 death1_solo = death1[death1['match_id'].isin(match_unique)]7677 death1_()7879# 只统计单⼈模式,筛选存活不超过180秒的玩家数据80 death_180_seconds_erg = death1_solo.loc[(death1_solo['map'] == 'ERANGEL')&(death1_solo['time'] < 180)&(death1_solo['victim_position_x']>0), :].dropna()81 death_180_seconds_mrm = death1_solo.loc[(death1_solo['map'] == 'MIRAMAR')&(death1_solo['time'] < 180)&(death1_solo['victim_position_x']>0), :].dropna()8283 death_180_seconds_erg.shape8485 death_180_seconds_mrm.shape8687# 选择存活不过180秒的玩家死亡位置88 data_erg = death_180_seconds_erg[['victim_position_x', 'victim_position_y']].values89 data_mrm = death_180_seconds_mrm[['victim_position_x', 'victim_position_y']].values9091# 重新scale玩家位置92 data_erg = data_erg*4096/80000093 data_mrm = data_mrm*1000/8000009495from scipy.ndimage.filters import gaussian_filter96import matplotlib.cm as cm97from matplotlib.colors import Normalize98from scipy.misc.pilutil import imread99100from scipy.ndimage.filters import gaussian_filter101import matplotlib.cm as cm102from matplotlib.colors import Normalize103104def heatmap(x, y, s, bins=100):105 heatmap, xedges, yedges = np.histogram2d(x, y, bins=bins)106 heatmap = gaussian_filter(heatmap, sigma=s)107108 extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]109return heatmap.T, extent110111 bg = imread('/Users/apple/Desktop/pubg/erangel.jpg')112 hmap, extent = heatmap(data_erg[:,0], data_erg[:,1], 4.5)113 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*4.5, 0.0, 1.)114 colors = Normalize(0, hmap.max(), clip=True)(hmap)115 colors = cm.Reds(colors)116 colors[..., -1] = alphas117118 fig, ax = plt.subplots(figsize=(24,24))119 ax.set_xlim(0, 4096); ax.set_ylim(0, 4096)120 ax.imshow(bg)121 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)122 plt.gca().invert_yaxis()123124 bg = imread('/Users/apple/Desktop/pubg/miramar.jpg')125 hmap, extent = heatmap(data_mrm[:,0], data_mrm[:,1], 4)126 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*4, 0.0, 1.)127 colors = Normalize(0, hmap.max(), clip=True)(hmap)128 colors = cm.Reds(colors)129 colors[..., -1] = alphas130131 fig, ax = plt.subplots(figsize=(24,24))132 ax.set_xlim(0, 1000); ax.set_ylim(0, 1000)133 ax.imshow(bg)134 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)135#plt.scatter(plot_data_mr[:,0], plot_data_mr[:,1])136 plt.gca().invert_yaxis()137138 death_final_circle_erg = death1_solo.loc[(death1_solo['map'] == 'ERANGEL')&(death1_solo['victim_placement'] == 2)&(death1_solo['victim_position_x']>0)&(death1_solo['killer_position_x']>0), :].dropna() 139 death_final_circle_mrm = death1_solo.loc[(death1_solo['map'] == 'MIRAMAR')&(death1_solo['victim_placement'] == 2)&(death1_solo['victim_position_x']>0)&(death1_solo['killer_position_x']>0), :].dropna() 140141print(death_final_circle_erg.shape)142print(death_final_circle_mrm.shape)143144 final_circle_erg = np.vstack([death_final_circle_erg[['victim_position_x', 'victim_position_y']].values,145 death_final_circle_erg[['killer_position_x', 'killer_position_y']].values])*4096/800000146 final_circle_mrm = np.vstack([death_final_circle_mrm[['victim_position_x', 'victim_position_y']].values,147 death_final_circle_mrm[['killer_position_x', 'killer_position_y']].values])*1000/800000148149 bg = imread('/Users/apple/Desktop/pubg/erangel.jpg')150 hmap, extent = heatmap(final_circle_erg[:,0], final_circle_erg[:,1], 1.5)151 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*1.5, 0.0, 1.)152 colors = Normalize(0, hmap.max(), clip=True)(hmap)153 colors = cm.Reds(colors)154 colors[..., -1] = alphas155156 fig, ax = plt.subplots(figsize=(24,24))157 ax.set_xlim(0, 4096); ax.set_ylim(0, 4096)158 ax.imshow(bg)159 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)160#plt.scatter(plot_data_er[:,0], plot_data_er[:,1])161 plt.gca().invert_yaxis()162163 bg = imread('/Users/apple/Desktop/pubg/miramar.jpg')164 hmap, extent = heatmap(final_circle_mrm[:,0], final_circle_mrm[:,1], 1.5)165 alphas = np.clip(Normalize(0, hmap.max(), clip=True)(hmap)*1.5, 0.0, 1.)166 colors = Normalize(0, hmap.max(), clip=True)(hmap)167 colors = cm.Reds(colors)168 colors[..., -1] = alphas169170 fig, ax = plt.subplots(figsize=(24,24))171 ax.set_xlim(0, 1000); ax.set_ylim(0, 1000)172 ax.imshow(bg)173 ax.imshow(colors, extent=extent, origin='lower', cmap=cm.Reds, alpha=0.9)174#plt.scatter(plot_data_mr[:,0], plot_data_mr[:,1])175 plt.gca().invert_yaxis()176177 erg_died_of = death1.loc[(death1['map']=='ERANGEL')&(death1['killer_position_x']>0)&(death1['victim_position_x']>0)&(death1['killed_by']!='Down and Out'),:]178 mrm_died_of = death1.loc[(death1['map']=='MIRAMAR')&(death1['killer_position_x']>0)&(death1['victim_position_x']>0)&(death1['killed_by']!='Down and Out'),:]179180print(erg_died_of.shape)181print(mrm_died_of.shape)182183 erg_died_of['killed_by'].value_counts()[:10].plot.barh(figsize=(10,5))184 plt.xlabel("被击杀⼈数", fontsize=14)185 plt.ylabel("击杀的武器", fontsize=14)186 plt.title('武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)187 plt.yticks(fontsize=12)188189 mrm_died_of['killed_by'].value_counts()[:10].plot.barh(figsize=(10,5))190 plt.xlabel("被击杀⼈数", fontsize=14)191 plt.ylabel("击杀的武器", fontsize=14)192 plt.title('武器跟击杀⼈数的统计(热情沙漠⽶拉玛)', fontsize=14)193 plt.yticks(fontsize=12)194195# 把位置信息转换成距离,以“⽶”为单位196 erg_distance = np.sqrt(((erg_died_of['killer_position_x']-erg_died_of['victim_position_x'])/100)**2 + ((erg_died_of['killer_position_y']-erg_died_of['victim_position_y'])/100)**2)197198 mrm_distance = np.sqrt(((mrm_died_of['killer_position_x']-mrm_died_of['victim_position_x'])/100)**2 + ((mrm_died_of['killer_position_y']-mrm_died_of['victim_position_y'])/100)**2) 199200 sns.distplot(erg_distance.loc[erg_distance<400])201202 erg_died_of.loc[(erg_distance > 800)&(erg_distance < 1500), 'killed_by'].value_counts()[:10].plot.bar(rot=30)203 plt.xlabel("狙击的武器", fontsize=14)204 plt.ylabel("被狙击的⼈数", fontsize=14)205 plt.title('狙击武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)206 plt.yticks(fontsize=12)207208 mrm_died_of.loc[(mrm_distance > 800)&(mrm_distance < 1000), 'killed_by'].value_counts()[:10].plot.bar(rot=30)209 plt.xlabel("狙击的武器", fontsize=14)210 plt.ylabel("被狙击的⼈数", fontsize=14)211 plt.title('狙击武器跟击杀⼈数的统计(热情沙漠⽶拉玛)', fontsize=14)212 plt.yticks(fontsize=12)213214 erg_died_of.loc[erg_distance<10, 'killed_by'].value_counts()[:10].plot.bar(rot=30)215 plt.xlabel("近战武器", fontsize=14)216 plt.ylabel("被击杀的⼈数", fontsize=14)217 plt.title('近战武器跟击杀⼈数的统计(绝地海岛艾伦格)', fontsize=14)218 plt.yticks(fontsize=12)219220 mrm_died_of.loc[mrm_distance<10, 'killed_by'].value_counts()[:10].plot.bar(rot=30)221 plt.xlabel("近战武器", fontsize=14)222 plt.ylabel("被击杀的⼈数", fontsize=14)223 plt.title('近战武器武器跟击杀⼈数的统计(热情沙漠⽶拉玛)', fontsize=14)224 plt.yticks(fontsize=12)225226 erg_died_of['erg_dist'] = erg_distance227 erg_died_of = erg_died_of.loc[erg_died_of['erg_dist']<800, :]228 top_weapons_erg = list(erg_died_of['killed_by'].value_counts()[:10].index)229 top_weapon_kills = erg_died_of[np.in1d(erg_died_of['killed_by'], top_weapons_erg)].copy()230 top_weapon_kills['bin'] = pd.cut(top_weapon_kills['erg_dist'], np.arange(0, 800, 10), include_lowest=True, labels=False)231 top_weapon_kills_wide = top_weapon_kills.groupby(['killed_by', 'bin']).size().unstack(fill_value=0).transpose()232233 top_weapon_kills_wide = top_weapon_kills_wide.div(top_weapon_kills_wide.sum(axis=1), axis=0)234235from bokeh.models.tools import HoverTool236from bokeh.palettes import brewer237from bokeh.plotting import figure, show, output_notebook238from bokeh.models.sources import ColumnDataSource239240def stacked(df):241 df_top = df.cumsum(axis=1)242 df_bottom = df_top.shift(axis=1).fillna(0)[::-1]243 df_stack = pd.concat([df_bottom, df_top], ignore_index=True)244return df_stack245246 hover = HoverTool(247 tooltips=[248 ("index", "$index"),249 ("weapon", "@weapon"),250 ("(x,y)", "($x, $y)")251 ],252 point_policy='follow_mouse'253 )254255 areas = stacked(top_weapon_kills_wide)。

Python爬取OPGG上英雄联盟英雄胜率及选取率信息的操作

Python爬取OPGG上英雄联盟英雄胜率及选取率信息的操作

Python爬取OPGG上英雄联盟英雄胜率及选取率信息的操作由⽹站界⾯可以看出,右侧有英雄的详细信息,以Garen为例,胜率为53.84%,选取率为16.99%,常⽤位置为上单现对⽹页源代码进⾏分析(右键⿏标在菜单中即可找到查看⽹页源代码)。

通过查找“53.84%”快速定位Garen所在位置由代码可看出,英雄名、胜率及选取率都在td标签中,⽽每⼀个英雄信息在⼀个tr标签中,td⽗标签为tr标签,tr⽗标签为tbody标签。

对tbody标签进⾏查找代码中共有5个tbody标签(tbody标签开头结尾均有”tbody”,故共有10个”tbody”),对字段内容分析,分别为上单、打野、中单、ADC、辅助信息以上单这部分英雄为例,我们需要⾸先找到tbody标签,然后从中找到tr标签(每⼀条tr标签就是⼀个英雄的信息),再从⼦标签td标签中获取英雄的详细信息⼆、爬取步骤爬取⽹站内容->提取所需信息->输出英雄数据getHTMLText(url)->fillHeroInformation(hlist,html)->printHeroInformation(hlist)getHTMLText(url)函数是返回url链接中的html内容fillHeroInformation(hlist,html)函数是将html中所需信息提取出存⼊hlist列表中printHeroInformation(hlist)函数是输出hlist列表中的英雄信息三、代码实现1、getHTMLText(url)函数def getHTMLText(url): #返回html⽂档信息try:r = requests.get(url,timeout = 30)r.raise_for_status()r.encoding = r.apparent_encodingreturn r.text #返回html内容except:return ""2、fillHeroInformation(hlist,html)函数以⼀个tr标签为例,tr标签内有7个td标签,第4个td标签内属性值为"champion-index-table__name"的div标签内容为英雄名,第5个td标签内容为胜率,第6个td标签内容为选取率,将这些信息存⼊hlist列表中def fillHeroInformation(hlist,html): #将英雄信息存⼊hlist列表soup = BeautifulSoup(html,"html.parser")for tr in soup.find(name = "tbody",attrs = "tabItem champion-trend-tier-TOP").children: #遍历上单tbody标签的⼉⼦标签if isinstance(tr,bs4.element.Tag): #判断tr是否为标签类型,去除空⾏tds = tr('td') #查找tr标签下的td标签heroName = tds[3].find(attrs = "champion-index-table__name").string #英雄名winRate = tds[4].string #胜率pickRate = tds[5].string #选取率hlist.append([heroName,winRate,pickRate]) #将英雄信息添加到hlist列表中3、printHeroInformation(hlist)函数def printHeroInformation(hlist): #输出hlist列表信息print("{:^20}\t{:^20}\t{:^20}\t{:^20}".format("英雄名","胜率","选取率","位置"))for i in range(len(hlist)):i = hlist[i]print("{:^20}\t{:^20}\t{:^20}\t{:^20}".format(i[0],i[1],i[2],"上单"))4、main()函数⽹站地址赋值给url,新建⼀个hlist列表,调⽤getHTMLText(url)函数获得html⽂档信息,使⽤fillHeroInformation(hlist,html)函数将英雄信息存⼊hlist列表,再使⽤printHeroInformation(hlist)函数输出信息def main():url = "http://www.op.gg/champion/statistics"hlist = []html = getHTMLText(url) #获得html⽂档信息fillHeroInformation(hlist,html) #将英雄信息写⼊hlist列表printHeroInformation(hlist) #输出信息四、结果演⽰1、⽹站界⾯信息2、爬取结果五、完整代码import requests #导⼊requests库import bs4 #导⼊bs4库from bs4 import BeautifulSoup #导⼊BeautifulSoup库def getHTMLText(url): #返回html⽂档信息try:r = requests.get(url,timeout = 30)r.raise_for_status()r.encoding = r.apparent_encodingreturn r.text #返回html内容except:return ""def fillHeroInformation(hlist,html): #将英雄信息存⼊hlist列表soup = BeautifulSoup(html,"html.parser")for tr in soup.find(name = "tbody",attrs = "tabItem champion-trend-tier-TOP").children: #遍历上单tbody标签的⼉⼦标签 if isinstance(tr,bs4.element.Tag): #判断tr是否为标签类型,去除空⾏tds = tr('td') #查找tr标签下的td标签heroName = tds[3].find(attrs = "champion-index-table__name").string #英雄名winRate = tds[4].string #胜率pickRate = tds[5].string #选取率hlist.append([heroName,winRate,pickRate]) #将英雄信息添加到hlist列表中def printHeroInformation(hlist): #输出hlist列表信息print("{:^20}\t{:^20}\t{:^20}\t{:^20}".format("英雄名","胜率","选取率","位置"))for i in range(len(hlist)):i = hlist[i]print("{:^20}\t{:^20}\t{:^20}\t{:^20}".format(i[0],i[1],i[2],"上单"))def main():url = "http://www.op.gg/champion/statistics"hlist = []html = getHTMLText(url) #获得html⽂档信息fillHeroInformation(hlist,html) #将英雄信息写⼊hlist列表printHeroInformation(hlist) #输出信息main()如果需要爬取打野、中单、ADC或者辅助信息,只需要修改fillHeroInformation(hlist,html)函数中的for tr in soup.find(name = "tbody",attrs = "tabItem champion-trend-tier-TOP").children语句将attrs属性值修改为"tabItem champion-trend-tier-JUNGLE""tabItem champion-trend-tier-MID""tabItem champion-trend-tier-ADC""tabItem champion-trend-tier-SUPPORT"等即可!以上为个⼈经验,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。

Python实现的10个有趣的项目

Python实现的10个有趣的项目
务等。
Web应用开发
Python在Web开发中的应用广泛,如Django、Flask等框架
Python的Web开发框架具有易用性、灵活性和扩展性
Python的Web开发框架支持多种数据库,如MySQL、PostgreSQL 等
Python的Web开发框架支持多种模板引擎,如Jinja2、Django Te m p l a te 等
Part Six
Python在科学计 算中的应用
生物信息学分析
基因序列分析:通过Python进行 基因序列的比对、注释和预测
基因组数据分析:对基因组数据进 行统计分析、可视化和挖掘
添加标题
添加标题
添加标题
添加标题
蛋白质结构预测:利用Python进 行蛋白质结构预测和建模
药物设计:通过Python进行药物 设计和筛选,提高药物研发效率
数据处理:使用Python进行数据清 洗、转换和整合
数据可视化:使用Python绘制天气 数据图表,如温度、湿度、风速等
数据分析:对天气数据进行统计分析, 如温度变化趋势、湿度分布等
应用:将分析结果应用于天气预报、 旅游规划等领域
股票市场数据分析
利用Python进行股票市场数据分析 利用Python库如pandas、numpy等进行数据处理 利用Python进行股票价格预测 利用Python进行股票市场风险评估
Python的Web开发框架支持多种前端技术,如HTML、CSS、 JavaScript等
Python的Web开发框架支持多种部署方式,如Apache、Nginx等
Part Five
Python在游戏开 发中的应用
游戏AI设计
游戏AI的基本概 念:让游戏中的 角色具有智能行 为

faker库的用法

faker库的用法

Faker是一个用于生成伪随机数据的Python 库,可以用于生成各种类型的虚拟数据,如姓名、地址、电子邮件、文本、图像等。

它通常用于测试、填充数据库、制作样本数据等场景。

下面是关于Faker库的基本用法示例:
1.安装:你可以使用pip命令来安装Faker库。

在终端中运行以下命令即可安
装:
2.生成随机数据:在使用之前,你需要导入Faker库并创建一个Faker实例。


后,你可以使用该实例来生成不同类型的虚拟数据。

以下是一个示例:
3.本地化设置:Faker支持多种语言和地区的数据生成。

你可以通过设置本地
化参数来生成特定语言和地区的虚拟数据。

例如:
这将生成英文语言环境下的虚拟数据。

Faker是一个方便易用的 Python 库,可以帮助你快速生成各种类型的虚拟数据。


论是在进行软件测试、数据库填充、数据分析还是制作样本数据时,Faker都可以
提供有效的解决方案。

如果你需要不同类型的虚拟数据来填充应用程序或测试数据集,Faker库将会是一个很有用的工具。

python中faker用法

python中faker用法

python中faker用法摘要:1.介绍Python中的Faker库2.Faker库的作用和用途3.Faker库的主要功能4.Faker库在实际项目中的应用5.Faker库与其他库的比较和优势6.总结Faker库在Python中的重要性正文:Python是一种广泛使用的编程语言,其功能强大且易于学习。

在数据生成和模拟方面,Python中的Faker库是一个非常有用的库。

Faker库是一个用于生成各种数据的Python库,它可以模拟各种数据类型,如姓名、地址、电话号码、电子邮件地址等。

在许多实际项目中,Faker库可以帮助开发者快速生成大量测试数据,从而简化开发过程并提高效率。

Faker库的主要功能包括:- 生成各种类型的随机数据,如文本、数字、日期等- 支持多种语言和地区设置- 可自定义生成数据的样式和格式- 与其他Python库集成,如Factory Boy和Pytest等在实际项目应用中,Faker库可以帮助开发者生成大量测试数据,从而简化测试过程。

例如,在进行数据验证或数据处理任务时,可以使用Faker库生成模拟数据,以验证代码的正确性。

此外,Faker库还可以用于生成虚拟用户信息,从而在Web应用程序中模拟用户行为。

与其他库相比,Faker库具有以下优势:- 易于使用:Faker库提供了简单易用的API,开发者可以快速上手并开始使用- 高度灵活:Faker库支持多种语言和地区设置,可以根据需要自定义生成数据的样式和格式- 社区支持:Faker库拥有活跃的社区,可以获得丰富的文档和示例代码综上所述,Faker库在Python中具有重要的地位。

无论是在实际项目中还是日常开发中,Faker库都可以为开发者提供便利,帮助快速生成数据并提高开发效率。

Python技术在游戏测试中的实际应用技巧

Python技术在游戏测试中的实际应用技巧

Python技术在游戏测试中的实际应用技巧游戏测试是确保游戏软件质量的重要环节,而Python作为一种广泛应用于软件开发领域的编程语言,也可以在游戏测试中发挥重要作用。

Python技术在游戏测试中的实际应用技巧包括自动化测试、性能测试、错误检测和日志分析等方面。

首先,Python的自动化测试技术在游戏测试中得到广泛应用。

通过编写Python 脚本,可以模拟玩家操作,从而实现游戏功能的自动化测试。

例如,可以使用Python控制鼠标和键盘,自动执行游戏中的操作,如点击、移动、战斗等,检验游戏的稳定性和功能是否正常。

此外,Python还提供了丰富的测试框架和库,如unittest和pytest,可以帮助开发人员编写和执行自动化测试用例,简化测试流程,并提高测试效率。

其次,Python的性能测试技术对于游戏测试也具有重要意义。

游戏在运行时需要处理大量的数据和复杂的逻辑,因此需要进行性能测试以保证游戏运行的流畅性和稳定性。

Python提供了性能测试工具和库,如locust和pytest-benchmark,可以帮助开发人员对游戏进行性能测试,并得到相应的测试结果和指标。

通过性能测试,可以发现游戏在不同负载下的性能瓶颈,并针对性地进行优化,提升游戏的性能和用户体验。

另外,Python在游戏测试中的另一个应用技巧是错误检测。

游戏在开发和测试过程中,难免会出现各种错误和异常情况。

Python提供了强大的异常处理机制,可以捕获和处理游戏中出现的异常,以及生成相应的错误日志。

通过分析错误日志,开发人员可以及时发现和解决游戏中的问题,确保游戏的质量和稳定性。

此外,Python在游戏测试中还可以应用于日志分析。

游戏中的日志文件记录了游戏运行过程中的各种信息,如玩家操作、游戏状态、错误信息等。

Python提供了强大的文本处理和分析库,如re、pandas和numpy,可以将日志文件导入Python中进行分析。

通过对游戏日志的分析,可以发现潜在的问题和异常情况,为开发人员提供宝贵的调试和优化线索。

对LOL游戏数据集进行可视化分析

对LOL游戏数据集进行可视化分析

对LOL游戏数据集进⾏可视化分析⼀、理解数据1、采集数据本数据集描述了LOL游戏相关信息,共包含51000条数据,共61个字段。

下⾯是该数据集中包含的字段以及对各字段的解释:gameId(游戏编号)creationTime(创建时间)gameDuration(游戏持续时间)seasonId(赛季编号)winner(获胜者)(1 =团队1,2 =团队2)First blood, tower, inhibitor, Baron, dragon and Rift Herald:⼀⾎,⼀塔,⽔晶,第⼀条纳什男爵,⼤龙,峡⾕先锋 (1 = 团队1, 2 = 团队2, 0 = ⽆)Champions and summoner spells for each team (Stored as Riot's champion and summoner spell IDs):每只队伍选择的英雄和召唤术(⽤英雄和召唤师技能编号表⽰)The number of tower, inhibitor, Baron, dragon and Rift Herald kills each team has:塔,⽔晶,男爵,⼤龙和峡⾕先锋击杀数The 5 bans of each team (Again, champion IDs are used):每个队伍的禁⽤英雄(英雄编号表⽰)2、导⼊数据import pandas as pddf=pd.read_csv("games.csv")3、查看数据集信息print(df)df.shape //查看数据集⼤⼩⼆、数据清洗1、查找缺失值数据集中的信息太多,所以先计算所有缺失值总和,如果缺失值过多再进⼀步决定如何处理每⼀列的缺失值none_number = sum(df.isnull().sum()) //查看缺失值总和print(none_number)幸运的是从结果来看数据集很完整,没有任何缺失值。

python实现粒子群算法(PSO)优化神经网络超参数——以预测英雄联盟比赛结果为例

python实现粒子群算法(PSO)优化神经网络超参数——以预测英雄联盟比赛结果为例

python实现粒⼦群算法(PSO)优化神经⽹络超参数——以预测英雄联盟⽐赛结果为例⽬录程序简介本实验根据英雄联盟的对局数据,搭建全连接⽹络分类模型,以粒⼦群算法对神经⽹络的节点数和dropout概率进⾏调优,最后对⽐默认模型和优化后的模型对英雄联盟⽐赛结果的预测准确率粒⼦群优化算法(PSO)是⼀种进化计算技术源于对鸟群捕⾷的⾏为研究。

粒⼦群优化算法的基本思想:是通过群体中个体之间的协作和信息共享来寻找最优解。

它的优点是收敛快、实现简单,缺点则是容易陷⼊局部最优程序/数据集下载代码分析导⼊模块from yers import Input,Dense,Dropout,Activationimport matplotlib.pyplot as pltfrom tensorflow.keras.models import load_modelfrom tensorflow.keras.models import Modelfrom tensorflow.keras.optimizers import Adamfrom sklearn.metrics import accuracy_scoreimport pandas as pdimport numpy as npimport jsonfrom copy import deepcopy数据是英雄联盟各对局10分钟的战况,英雄联盟对战⽅分为红蓝双⽅,blueWins就是指是否为蓝⽅获胜,其他列基本就是⼩龙、野怪、经济啥的,原谅我解释不清。

读研的时候升到⽩银,因为出装问题每⼀局都要被骂,顺便说⼀下,我⽼是在⾥⾯装妹⼦,玩辅助,因为这样骂我的⼈就少了很多,好友已经满了┭┮﹏┭┮错的不是我,是这个世界data = pd.read_csv("Static/high_diamond_ranked_10min.csv").iloc[:,1:]print("数据尺⼨:",data.shape)print("展⽰下数据前5⾏和前5列")data.iloc[:,:5].head()数据尺⼨: (9879, 39)展⽰下数据前5⾏和前5列blueWins blueWardsPlaced blueWardsDestroyed blueFirstBlood blueKills00282191012105201500730431044075406切割数据集,分成训练、验证和测试,这⾥只⽤验证集给PSO调优⽤,并没有给神经⽹络训练保存最佳checkpointdata = data.sample(frac=1.0)#打乱数据trainData = data.iloc[:6000]#训练集xTrain = trainData.values[:,1:]yTrain = trainData.values[:,:1]valData = data.iloc[6000:8000]#验证集xVal = valData.values[:,1:]yVal = valData.values[:,:1]testData = data.iloc[8000:]#测试集xTest = testData.values[:,1:]yTest = testData.values[:,:1]1个粒⼦即1个⽅案,在本实验中,1个粒⼦就是1个(节点数、dropout概率)的数组,PSO就是计算每个粒⼦对应⽅案的适应度,找到最合适的⽅案的过程,下⽂的PSO类会根据粒⼦需要优化的特征对粒⼦迭代,⽀持⼩数或整数的特征,若为⾃定的离散区间,可在适应度函数中,将⾮法粒⼦的适应度给予惩罚值,实例化该类后,需要指定适应度函数给iterate函数对粒⼦⽅案进⾏迭代,本实验的粒⼦群算法为最简单的形式,更新公式如下:class PSO():def __init__(self,featureNum,featureArea,featureLimit,featureType,particleNum=5,epochMax=10,c1=2,c2=2): '''粒⼦群算法:param featureNum: 粒⼦特征数:param featureArea: 特征上下限矩阵:param featureLimit: 特征上下阙界,也是区间的开闭 0为不包含 1为包含:param featureType: 特征类型 int float:param particleNum: 粒⼦个数:param epochMax: 最⼤迭代次数:param c1: ⾃⾝认知学习因⼦:param c2: 群体认知学习因⼦'''#如上所⽰self.featureNum = featureNumself.featureArea = np.array(featureArea).reshape(featureNum,2)self.featureLimit = np.array(featureLimit).reshape(featureNum,2)self.featureType = featureTypeself.particleNum = particleNumself.epochMax = epochMaxself.c1 = c1self.c2 = c2self.epoch = 0#已迭代次数#⾃⾝最优适应度记录self.pBest = [-1e+10 for i in range(particleNum)]self.pBestArgs = [None for i in range(particleNum)]#全局最优适应度记录self.gBest = -1e+10self.gBestArgs = None#初始化所有粒⼦self.particles = [self.initParticle() for i in range(particleNum)]#初始化所有粒⼦的学习速度self.vs = [np.random.uniform(0,1,size=featureNum) for i in range(particleNum)]#迭代历史self.gHistory = {"特征%d"%i:[] for i in range(featureNum)}self.gHistory["群内平均"] = []self.gHistory["全局最优"] = []def standardValue(self,value,lowArea,upArea,lowLimit,upLimit,valueType):'''规范⼀个特征值,使其落在区间内:param value: 特征值:param lowArea: 下限:param upArea: 上限:param lowLimit: 下限开闭区间:param upLimit: 上限开闭区间:param valueType: 特征类型:return: 修正后的值'''if value < lowArea:value = lowAreaif value > upArea:value = upAreaif valueType is int:value = np.round(value,0)#下限为闭区间if value <= lowArea and lowLimit==0:value = lowArea + 1#上限为闭区间if value >= upArea and upLimit==0:value = upArea - 1elif valueType is float:#下限为闭区间if value <= lowArea and lowLimit == 0:value = lowArea + 1e-10#上限为闭=间if value >= upArea and upLimit==0:value = upArea - 1e-10return valuedef initParticle(self):'''随机初始化1个粒⼦'''values = []#初始化这么多特征数for i in range(self.featureNum):#该特征的上下限lowArea = self.featureArea[i][0]upArea = self.featureArea[i][1]#该特征的上下阙界lowLimit = self.featureLimit[i][0]upLimit = self.featureLimit[i][1]#随机值value = np.random.uniform(0,1) * (upArea-lowArea) + lowAreavalue = self.standardValue(value,lowArea,upArea,lowLimit,upLimit,self.featureType[i])values.append(value)return valuesdef iterate(self,calFitness):'''开始迭代:param calFitness:适应度函数输⼊为1个粒⼦的所有特征和全局最佳适应度,输出为适应度'''while self.epoch<self.epochMax:self.epoch += 1for i,particle in enumerate(self.particles):#该粒⼦的适应度fitness = calFitness(particle,self.gBest)#更新该粒⼦的⾃⾝认知最佳⽅案if self.pBest[i] < fitness:self.pBest[i] = fitnessself.pBestArgs[i] = deepcopy(particle)#更新全局最佳⽅案if self.gBest < fitness:self.gBest = fitnessself.gBestArgs = deepcopy(particle)#更新粒⼦for i, particle in enumerate(self.particles):#更新速度self.vs[i] = np.array(self.vs[i]) + self.c1*np.random.uniform(0,1,size=self.featureNum)*(np.array(self.pBestArgs[i])-np.array(self.particles[i])) + self.c2*np.random.uniform(0,1,size=self.featureNum)*(np.array(self.gBestArgs)-np.array(self #更新特征值self.particles[i] = np.array(particle) + self.vs[i]#规范特征值values = []for j in range(self.featureNum):#该特征的上下限lowArea = self.featureArea[j][0]upArea = self.featureArea[j][1]#该特征的上下阙界lowLimit = self.featureLimit[j][0]upLimit = self.featureLimit[j][1]#随机值value =self.particles[i][j]value = self.standardValue(value,lowArea,upArea,lowLimit,upLimit,self.featureType[j])values.append(value)self.particles[i] = values#保存历史数据for i in range(self.featureNum):self.gHistory["特征%d"%i].append(self.gBestArgs[i])self.gHistory["群内平均"].append(np.mean(self.pBest))self.gHistory["全局最优"].append(self.gBest)print("PSO epoch:%d/%d 群内平均:%.4f 全局最优:%.4f"%(self.epoch,self.epochMax,np.mean(self.pBest),self.gBest))buildNet函数根据⽹络节点数和dropout概率来构建⼀个简单的全连接分类⽹络,其输⼊特征数为38,输出特征数为1(当然,也可以选择⽹络层数、学习率等超参数来优化,为⽅便学习,这⾥只选择这俩超参数进⾏实验)并对该⽹络进⾏训练def buildNet(nodeNum,p):'''搭建全连接⽹络进⾏训练,返回模型和训练历史、验证集准确率和测试集准确率:param nodeNum: ⽹络节点数:param p: dropout概率'''#输⼊层 38个对局特征inputLayer = Input(shape=(38,))#中间层middle = Dense(nodeNum)(inputLayer)middle = Dropout(p)(middle)#输出层⼆分类outputLayer = Dense(1,activation="sigmoid")(middle)#建模⼆分类损失model = Model(inputs=inputLayer,outputs=outputLayer)optimizer = Adam(lr=1e-3)pile(optimizer=optimizer,loss="binary_crossentropy",metrics=['acc'])#训练history = model.fit(xTrain,yTrain,verbose=0,batch_size=1000,epochs=100,validation_data=(xVal,yVal)).history#验证集准确率valAcc = accuracy_score(yVal,model.predict(xVal).round(0))#测试集准确率testAcc = accuracy_score(yTest,model.predict(xTest).round(0))return model,history,valAcc,testAcc为了跟优化好的模型有所对⽐,这⾥我们训练⼀个默认参数的神经⽹络,它的超参数取值即各超参数区间的平均值,训练并打印⽹络结构和训练指标nodeArea = [10,200]#节点数区间pArea = [0,0.5]#dropout概率区间#按区间平均值训练⼀个神经⽹络nodeNum = int(np.mean(nodeArea))p = np.mean(pArea)defaultNet,defaultHistory,defaultValAcc,defaultTestAcc = buildNet(nodeNum,p)defaultNet.summary()print("\n默认⽹络的节点数:%d dropout概率:%.2f 验证集准确率:%.4f 测试集准确率:%.4f"%(nodeNum,p,defaultValAcc,defaultTestAcc))Model: "model_346"_________________________________________________________________Layer (type) Output Shape Param #=================================================================input_347 (InputLayer) [(None, 38)] 0_________________________________________________________________dense_691 (Dense) (None, 105) 4095_________________________________________________________________dropout_346 (Dropout) (None, 105) 0_________________________________________________________________dense_692 (Dense) (None, 1) 106=================================================================Total params: 4,201Trainable params: 4,201Non-trainable params: 0_________________________________________________________________默认⽹络的节点数:105 dropout概率:0.25 验证集准确率:0.6535 测试集准确率:0.6578实例化PSO模型,将区间信息输⼊,开始迭代,适应度函数就是输⼊1各粒⼦和全局最优适应度,返回该粒⼦对应⽅案的验证集准确率featureNum = 2#2个需要优化的特征featureArea = [nodeArea,pArea]#2个特征取值范围featureLimit = [[1,1],[0,1]]#取值范围的开闭 0为闭区间 1为开区间featureType = [int,float]#2个特征的类型#粒⼦群算法类pso = PSO(featureNum,featureArea,featureLimit,featureType)def calFitness(particle,gBest):'''适应度函数,输⼊1个粒⼦的数组和全局最优适应度,返回该粒⼦对应的适应度'''nodeNum,p = particle#取出粒⼦的特征值net,history,valAcc,testAcc = buildNet(nodeNum,p)#该粒⼦⽅案超过全局最优if valAcc>gBest:#保存模型和对应信息net.save("Static/best.h5")history = pd.DataFrame(history)history.to_excel("Static/best.xlsx",index=None)with open("Static/info.json","w") as f:f.write(json.dumps({"valAcc":valAcc,"testAcc":testAcc}))return valAcc#开始⽤粒⼦群算法迅游pso.iterate(calFitness)#载⼊最佳模型和对应的训练历史bestNet = load_model("Static/best.h5")with open("Static/info.json","r") as f:info = json.loads(f.read())bestValAcc = float(info["valAcc"])bestTestAcc = float(info["testAcc"])bestHistory = pd.read_excel("Static/best.xlsx")print("最优模型的验证集准确率:%.4f 测试集准确率:%.4f"%(bestValAcc,bestTestAcc)) PSO epoch:1/10 群内平均:0.7210 全局最优:0.7280PSO epoch:2/10 群内平均:0.7210 全局最优:0.7280PSO epoch:3/10 群内平均:0.7251 全局最优:0.7280PSO epoch:4/10 群内平均:0.7275 全局最优:0.7350PSO epoch:5/10 群内平均:0.7275 全局最优:0.7350PSO epoch:6/10 群内平均:0.7299 全局最优:0.7350PSO epoch:7/10 群内平均:0.7313 全局最优:0.7350PSO epoch:8/10 群内平均:0.7313 全局最优:0.7350PSO epoch:9/10 群内平均:0.7313 全局最优:0.7350PSO epoch:10/10 群内平均:0.7313 全局最优:0.7350最优模型的验证集准确率:0.7350 测试集准确率:0.7350查看PSO最优解随迭代次数的变换history = pd.DataFrame(pso.gHistory)history["epoch"] = range(1,history.shape[0]+1)history特征0特征1群内平均全局最优epoch050.00.2677060.72100.7281150.00.2677060.72100.7282250.00.2677060.72510.7283357.00.2013360.72750.7354457.00.2013360.72750.7355557.00.2013360.72990.7356657.00.2013360.73130.7357757.00.2013360.73130.7358857.00.2013360.73130.7359957.00.2013360.73130.73510对⽐下默认参数模型和PSO调优模型的准确率,是有点效果,仅供学习... fig, ax = plt.subplots()x = np.arange(2)a = [defaultValAcc,bestValAcc]b = [defaultTestAcc,bestTestAcc]total_width, n = 0.8, 2width = total_width / nx = x - (total_width - width) / 2ax.bar(x, a, width=width, label='val',color="#00BFFF")for x1,y1 in zip(x,a):plt.text(x1,y1+0.01,'%.3f' %y1, ha='center',va='bottom')ax.bar(x + width, b, width=width, label='test',color="#FFA500")for x1,y1 in zip(x,b):plt.text(x1+width,y1+0.01,'%.3f' %y1, ha='center',va='bottom')ax.legend()ax.set_xticks([0, 1])ax.set_ylim([0,1.2])ax.set_ylabel("acc")ax.set_xticklabels(["default net","PSO-net"])fig.savefig("Static/对⽐.png",dpi=250)。

python中faker用法

python中faker用法

python中faker用法(实用版)目录1.Faker 库简介2.Faker 的安装与使用3.Faker 的主要功能4.Faker 生成器的使用示例5.Faker 的应用场景正文【Faker 库简介】Faker 是一个 Python 库,用于生成伪数据。

它可以帮助开发者在开发过程中快速生成大量模拟数据,以便进行测试和演示。

Faker 支持多种数据类型,如字符串、数字、日期、地址等,可以满足各种场景的需求。

【Faker 的安装与使用】要使用 Faker 库,首先需要安装它。

可以使用 pip 命令进行安装:```pip install Faker```安装完成后,就可以在 Python 代码中导入 Faker 库并使用了。

以下是一个简单的示例:```pythonfrom faker import Fakerfake = Faker()ame = ()print(name)```【Faker 的主要功能】Faker 库的主要功能如下:1.生成随机字符串:Faker 可以生成指定长度的随机字符串,如姓名、邮箱、密码等。

2.生成随机数字:Faker 可以生成指定范围内的随机整数或浮点数。

3.生成随机日期:Faker 可以生成指定范围内的随机日期,包括年、月、日等。

4.生成随机地址:Faker 可以生成随机的国家、城市、街道、邮编等地址信息。

5.生成随机文件名:Faker 可以生成指定扩展名的随机文件名。

【Faker 生成器的使用示例】Faker 库提供了多种生成器,可以方便地生成不同类型的数据。

以下是一些生成器的使用示例:```pythonfrom faker import Fakerfake = Faker()# 生成随机字符串ame = ()print(name)# 生成随机数字umber = fake.random_number()print(number)# 生成随机日期date = fake.random_date()print(date)# 生成随机地址address = fake.address()print(address)```【Faker 的应用场景】Faker 库在许多场景下都可以发挥作用,例如:1.在开发过程中,使用 Faker 生成模拟数据,可以方便地进行测试和调试。

Python数据分析入门(二十二):数据可视化之绘制雷达图

Python数据分析入门(二十二):数据可视化之绘制雷达图

Python数据分析⼊门(⼆⼗⼆):数据可视化之绘制雷达图雷达图雷达图(Radar Chart)⼜被叫做蜘蛛⽹图,适⽤于显⽰三个或更多的维度的变量的强弱情况。

⽐如英雄联盟中某个影响的属性(法术伤害,物理防御等),或者是某个企业在哪些业务⽅⾯的投⼊等,都可以⽤雷达图⽅便的表⽰。

使⽤plt.polar绘制雷达图:在matplotlib.pyplot中,可以通过plt.polar来绘制雷达图,这个⽅法的参数跟plt.plot⾮常的类似,只不过是x轴的坐标点应该为弧度(2*PI=360°)。

⽰例代码如下:properties = ['输出','KDA','发育','团战','⽣存']values = [40,91,44,90,95,40]theta = np.linspace(0,np.pi*2,6)plt.polar(theta,values)plt.xticks(theta,properties,fontproperties=font)plt.fill(theta,values)效果图如下:其中有⼏点需要注意:1. 因为polar并不会完成线条的闭合绘制,所以我们在绘制的时候需要在theta中和values中在最后多重复添加第0个位置的值,然后在绘制的时候就可以和第1个点进⾏闭合了。

2. polar只是绘制线条,所以如果想要把⾥⾯进⾏颜⾊填充,那么需要调⽤fill函数来实现。

3. polar默认的圆圈的坐标是⾓度,如果我们想要改成⽂字显⽰,那么可以通过xticks来设置。

使⽤⼦图绘制雷达图:在多⼦图中,绘图对象不再是pyplot⽽是Axes,⽽Axes及其⼦类绘制雷达图则是通过将直⾓坐标转换成极坐标,然后再绘制折线图。

⽰例代码如下:1. 使⽤plt.subplot绘制的⼦图:properties = ['输出','KDA','发育','团战','⽣存']values = [40,91,44,90,95,40]theta = np.linspace(0,np.pi*2,6)# ⽣成⼀个⼦图,并且指定⼦图的类型为polaraxes = plt.subplot(111,projection="polar")axes.plot(theta,values)axes.fill(theta,values)2. 使⽤plt.subplots绘制的⼦图:properties = ['输出','KDA','发育','团战','⽣存']values = [40,91,44,90,95,40]theta = np.linspace(0,np.pi*2,6)figure,axes = plt.subplots(1,1,subplot_kw={"projection":"polar"}) axes.plot(theta,values)3. 使⽤fig.add_subplot绘制的⼦图:properties = ['输出','KDA','发育','团战','⽣存']values = [40,91,44,90,95,40]theta = np.linspace(0,np.pi*2,6)fig = plt.figure(figsize=(10,10))axes = fig.add_subplot(111,polar=True)axes.plot(theta,values)。

用Python实现爬取百度热搜信息

用Python实现爬取百度热搜信息

⽤Python实现爬取百度热搜信息⽬录前⾔库函数准备数据爬取⽹页爬取数据解析数据保存总结前⾔何为爬⾍,其实就是利⽤计算机模拟⼈对⽹页的操作例如模拟⼈类浏览购物⽹站使⽤爬⾍前⼀定要看⽬标⽹站可刑不可刑:-)可以在⽬标⽹站添加/robots.txt 查看⽹页具体信息User-agent 代表发送请求的对象星号*代表任何搜索引擎Disallow 代表不允许访问的部分/代表从根⽬录开始Allow代表允许访问的部分在本例中我爬取的百度热搜前30的新闻(本⼈原本打算爬取英雄联盟主页数据中⼼⼤乱⽃胜率前五⼗的英雄信息奈何不会实现延时爬取⽹页的操作⽆奈只能爬百度热搜)并且其⼤致信息放到Excel表格以及Flask⽹页中实现数据可视化感兴趣的同学也可以对其它内容进⾏爬取由于本⼈⽔平有限本⽂章中的爬⾍都是⽐较基础的东西库函数准备Python库的安装⽅法:打开cmd命令提⽰符输⼊pip install XXX(这个是你要装的库名称)关于这些库的具体使⽤可以接下来看我的操作只需要简单掌握⼏个常⽤的函数即可bs4即BeautifulSoup⽤来解析HTML⽹页,提取指定数据的。

其中详细的⽤法待会看我的演⽰。

re正则表达式⽤来匹配字符串中响应的字串。

关于正则表达式可以去看菜鸟教程⾥边讲的很详细urllib是⼀个Python⾃带的HTTP请求库,可以操作⼀系列URL。

xlwt/xlrt⽤于写⼊(write) / 读取(read),Excel表中的数据。

flask这个库是⽤来只做⼀个简单的Web框架即⽹站,⽤于数据的可视化。

其实本⼈对于数据可视化的掌握也很浅薄,只是简单的将数据导⼊Web⽹页中。

jinja2这个库的作⽤是为了实现在HTML⽹页中的字符中插⼊⾃变量的功能。

后端:name="HQ"前端:<p>{{name}}长得真帅!</p>显⽰:HQ长得真帅!markupsafe与Jinja共⽤在渲染页⾯时⽤于避免不可信的输⼊,防⽌注⼊攻击(虽然没⼈会攻击你....)数据爬取数据爬取和数据可视化两个py⽂件是分开的数据爬取需要导⼊re bs4 urllib xlwt 四个库⽂件⽹页爬取使⽤⼀下的⽅法调⽤函数可以使函数调⽤关系更加清晰if __name__=="__main__": #当程序执⾏时调⽤⼀下函数main()def askurl(url):head={"User-Agent":'''Mozilla/5.0 (Windows NT 10.0; Win64; x64)AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36 Edg/97.0.1072.55'''}#⽤户代理告诉服务器我只是⼀个普普通通的浏览器requset=urllib.request.Request(url)#发送请求response=urllib.request.urlopen(requset)#响应的为⼀个request对象#通过read()转化为 bytes类型字符串#再通过decode()转化为 str类型的字符串#接受响应html=response.read().decode('utf-8')将抓取到的⽹页存⼊⽂档中⽅便观察path=r"C:\Users\XXX\Desktop\Python\text.txt"#这⾥在字符串前加⼊r 防⽌字符串中的\发⽣转义f=open(r"path",'w',encoding='utf-8')f.write(html)f.close()#这样在txt⽂件中就可以查看⽹页的源码return htmlheaders的值可以在⽹页中按F12然后点击⽹络变化对于任意⼀个请求标头下拉到最下⽅即为 user-agent 代理信息值得注意的是请求中如果不设置headers 则服务器会返回⼀个418的状态码代表服务器识别出来你是⼀个爬⾍并且表⽰:“ I'm a teapot ”表明服务器拒绝冲煮咖啡,因为它永远是⼀个茶壶(这是⼀个梗)数据解析将抓取的txt⽂件后缀改为html后打开即为⼀个本地的⽹页如果在vscode中因为⾏过长⽽产⽣报错可以参考以下博客打开后的⽹页如图所⽰使⽤这个功能查看需要爬取信息的位置在本项⽬中我们抓取⽬标信息的标题内容热度以及链接我们可以发现我们需要的信息全部在class为以下类型的表中于是我们⽤Beautifulsoup对⽹页进⾏解析def getData(html):datalist=[]soup=BeautifulSoup(html,"html.parser") #定义⼀个解析对象#soup.find_all(a,b) 其中a为标签的类型 class_ 对div的class进⾏匹配#返回的是所有class为category-wrap_iQLoo horizontal_1eKyQ的列表for item in soup.find_all('div',class_="category-wrap_iQLoo horizontal_1eKyQ"): item=str(item)#将列表中每⼀个⼦标签转换为字符串⽤于re匹配接下来对每⼀个item进⾏re匹配⾸先使⽤pile()创建匹配规则然后⽤findall进⾏匹配匹配规则的创建⽅式为在HTML⽂件中查看⽬标信息前后的特殊字符⽽(.*?)即为要匹配的字符串其中*后加?代表⾮贪婪匹配例如标题前后信息即为ellipsis">和</div> <div cla其它同理#匹配规则#链接findlink=pile(r' href="(.*?)" rel="external nofollow" target="_blank')#标题findtitle=pile(r'ellipsis"> (.*?) </div> <div cla')#内容findcontent1=pile(r'ellipsis_DupbZ"> (.*?) <a class=')findcontent2=pile(r'small_Uvkd3"> (.*?) <a class=')#热度findnumber=pile(r'ex_1Bl1a"> (.*?) </div>')⽽内容部分我在后续运⾏的时候发现报错原因是部分内容前缀为'ellipsis_DupbZ"> 部分内容前缀为small_Uvkd3">因此我编写了两种匹配⽅式具体代码如下def getData(html):datalist=[]soup=BeautifulSoup(html,"html.parser") #定义⼀个解析对象#soup.find_all(a,b) 其中a为标签的类型 class_ 对div的class进⾏匹配#返回的是所有class为category-wrap_iQLoo horizontal_1eKyQ的列表for item in soup.find_all('div',class_="category-wrap_iQLoo horizontal_1eKyQ"): item=str(item)#将列表中每⼀个⼦标签转换为字符串⽤于re匹配data=[]#标题title=re.findall(findtitle,item)[0]#简介#判断是否对第⼀种匹配如果不是的话返回为空列表此时应采⽤第⼆种匹配 if (len(re.findall(findcontent1,item))!=0):content=re.findall(findcontent1,item)[0]else:content=re.findall(findcontent2,item)[0]#热度number=re.findall(findnumber,item)[0]#链接link=re.findall(findlink,item)[0]#将数据存⼊数组data.append(title)data.append(number)data.append(content)data.append(link)datalist.append(data)print(datalist)return datalist数据保存def Savedata(datalist):#存⼊数据的⽬标路径path=r'C:\Users\XXX\Desktop\Python\爬⾍\data.xls'workbook=xlwt.Workbook(encoding='utf-8')#创建⼯作表对象worksheet=workbook.add_sheet('sheet1')#创建表单col=("标题","热度","内容","链接")#定义表含有的属性for i in range(4):worksheet.write(0,i,col[i])#write(i,j,value) 向表单的 [i][j] 位置写⼊valuefor i in range(30):for j in range(4):worksheet.write(i+1,j,datalist[i][j])#将excel表保存workbook.save(path)总结到此这篇关于⽤Python实现爬取百度热搜信息的⽂章就介绍到这了,更多相关Python爬取百度热搜内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

python抓取英雄联盟英雄图片

python抓取英雄联盟英雄图片

爬取英雄联盟所有英雄的皮肤图片源代码:import requestsimport jsonimport osimport urllib.requestcur_path = os.path.abspath(os.curdir)champion = "https:///images/lol/act/img/js/heroList/hero_list.js" championobj = json.loads(requests.get(champion).text)heroIds = championobj['hero']# print(championobj)# # print(jsonobj)for c in heroIds:print(c["heroId"])url="https:///images/lol/act/img/js/hero/"+str(c["heroId"])+".js"# 发送请求,获取响应结果response = requests.get(url)text = response.text # 打印本次请求响应内容# print(text) # 将响应内容转换为Json对象jsonobj = json.loads(text) # print(jsonobj) #获取英雄名称作为文件夹名heroname = jsonobj["hero"]["name"]print(heroname)isExists=os.path.exists(cur_path+'/所有皮肤图片/'+heroname)skinpath =cur_path+'/所有皮肤图片/'+heronameif not isExists:os.makedirs(cur_path+'/所有皮肤图片/'+heroname) # print(heroname) #获取所有的皮肤heroskins = jsonobj["skins"] # print(heroskins)for s in heroskins:skinname = str(s["name"]).replace(' ','-').replace('/','') #皮肤名字skinimage = str(s["mainImg"]) #皮肤图片路径if(len(skinimage)!=0):file_suffix = os.path.splitext(skinimage)[1]filename = '{}{}{}{}'.format(skinpath,os.sep,skinname,file_suffix)urllib.request.urlretrieve(skinimage,filename) # print(skinimage)运行结果:。

用Python爬取LOL所有的英雄信息以及英雄皮肤的示例代码

用Python爬取LOL所有的英雄信息以及英雄皮肤的示例代码

⽤Python爬取LOL所有的英雄信息以及英雄⽪肤的⽰例代码实现思路:分为两部分,第⼀部分,获取⽹页上数据并使⽤xlwt⽣成excel(当然你也可以选择保存到数据库),第⼆部分获取⽹页数据使⽤IO流将图⽚保存到本地⼀、爬取所有英雄属性并⽣成excel1.代码import jsonimport requestsimport xlwt# 设置头部信息,防⽌被检测出是爬⾍headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36'}url = "https:///images/lol/act/img/js/heroList/hero_list.js"response = requests.get(url=url, headers=headers).textloads = json.loads(response)dic = loads['hero']# 创建⼀个workbook 设置编码workbook = xlwt.Workbook(encoding='utf-8')# 创建⼀个worksheetworksheet = workbook.add_sheet('LOL')try:for i in range(len(dic)):# 设置单元格宽度⼤⼩worksheet.col(i).width = 4000# 设置单元格⾼度⼤⼩style = xlwt.easyxf('font:height 300')worksheet.row(i).set_style(style)# 第⼀⾏⽤于写⼊表头if i == 0:worksheet.write(i, 0, '编号')worksheet.write(i, 1, '名称')worksheet.write(i, 2, '英⽂名')worksheet.write(i, 3, '中⽂名')worksheet.write(i, 4, '⾓⾊')worksheet.write(i, 5, '物攻')worksheet.write(i, 6, '物防')worksheet.write(i, 7, '魔攻')worksheet.write(i, 8, '魔防')continueworksheet.write(i, 0, dic[i - 1]['heroId'])worksheet.write(i, 1, dic[i - 1]['name'])worksheet.write(i, 2, dic[i - 1]['alias'])worksheet.write(i, 3, dic[i - 1]['title'])roles_ = dic[i - 1]['roles']roles = []for data in roles_:if 'mage' == data:roles.append('法师')if 'tank' == data:roles.append('坦克')if 'fighter' == data:roles.append('战⼠')if 'marksman' == data:roles.append('ADC')if 'assassin' == data:roles.append('刺客')if 'support' == data:roles.append('辅助')worksheet.write(i, 4, str(roles))worksheet.write(i, 5, dic[i - 1]['attack'])worksheet.write(i, 6, dic[i - 1]['defense'])worksheet.write(i, 7, dic[i - 1]['magic'])worksheet.write(i, 8, dic[i - 1]['difficulty'])# 保存workbook.save('C:\\Users\\Jonsson\\Desktop\\lol.xls')except Exception as e:print(e)2.效果⼆、爬取所有英雄⽪肤并保存到本地1.代码import jsonimport osimport requestsimport xlwt# 设置头部信息,防⽌被检测出是爬⾍headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36' }url = "https:///images/lol/act/img/js/heroList/hero_list.js"# 请求英雄列表的url地址response = requests.get(url=url, headers=headers).textloads = json.loads(response)dic = loads['hero']for data in dic:id_ = data['heroId']skinUrl = 'https:///images/lol/act/img/js/hero/%s.js' % id_# 请求每个英雄⽪肤的url地址skinResponse = requests.get(url=skinUrl, headers=headers).textjson_loads = json.loads(skinResponse)hero_ = json_loads['hero']save_path = './skin/%s-%s-%s' % (hero_["heroId"], hero_['name'], hero_['title'])# ⽂件夹不存在,则创建⽂件夹folder = os.path.exists(save_path)if not folder:os.makedirs(save_path)skins_ = json_loads['skins']for data in skins_:if data['chromas'] == '0':content = requests.get(url=data['mainImg'], headers=headers).contenttry:with open('%s/%s.jpg' % (save_path, data['name']), "wb") as f:print("正在下载英雄:%s ⽪肤名称:%s ..." % (hero_['name'], data['name']))f.write(content)except Exception as e:print('下载失败')print(e)2.效果持!。

Python爬取OPGG里英雄联盟位置排名数据,及其可视化

Python爬取OPGG里英雄联盟位置排名数据,及其可视化

Python爬取OPGG⾥英雄联盟位置排名数据,及其可视化⼀、选题背景近年来电⼦竞技在当今社会越来越来受欢迎,同时电⼦竞技也成了亚运会项⽬之⼀。

英雄联盟便是奥运会上的项⽬类型之⼀,我国便曾在亚运会的英雄联盟项⽬上拿下冠军。

所以我便选择了,英雄联盟这个项⽬来作为我的设计⽬标。

⼆、主题式⽹络爬⾍设计⽅案1.主题式⽹络爬⾍名称OPGG⾥英雄联盟位置排名数据,及其可视化2.主题式⽹络爬⾍爬取的内容与数据特征分析爬取opgg中上单及射⼿的排名,名字,胜率,出场率,并对其进⾏分析。

3.主题式⽹络爬⾍设计⽅案概述(1)实现思路先对⽬标页⾯进⾏分析,利⽤urllib.爬⾍库和BeautifulSoup库进⾏爬取解析,后分别⽤BeautifulSoup和正则表达式,分别查找所需要的数据。

然后再保存为.csv⽂件,最后进⾏可视化分析。

(2)技术难点 request库出现问题,被迫学习使⽤urllib.request库,在编写re库的正则表达式中,发现⾃⼰熟练程度低,出错较多,在数据可视化上也出现了忘记代码的问题。

三、主题页⾯的结构特征分析1.主题页⾯的结构与特征分析⾸先是本机的usr-agent查询,做准备由⽹站界⾯可以看出,右侧有英雄的详细信息,以Garen为例,胜率为53.84%,选取率为16.99%,常⽤位置为上单。

2.Htmls 页⾯解析现对⽹页源代码进⾏分析代码中共有5个tbody标签(tbody标签开头结尾均有”tbody”,故共有10个”tbody”),对字段内容分析,分别为上单、打野、中单、ADC、辅助信息。

再对tbody标签进⾏查找由此代码可看出,英雄名、胜率及选取率都在td标签中,⽽每⼀个英雄信息在⼀个tr标签中,td⽗标签为tr标签,tr⽗标签为tbody标签3.节点(标签)查找⽅法与遍历⽅法计划将Beautifulsoup查找,re库.正则表达式搭配查找四、⽹络爬⾍程序设计1.数据爬取与采集1def askurl(urlbase):2import.urllib.request 引⽤urllib.request库3#模拟浏览器头部信息,向⽹站发送信息4 header={5"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62"6 }7#模拟⽤户代理8 request = urllib.request.Request(urlbase,headers=header)9#异常超时处理10try:11# html=""12 response = urllib.request.urlopen(request,timeout=5)13 html = response.read().decode("utf-8")14# print(html)15except Exception as a:16print(a)17return html2.数据解析与整理(1)采⽤BeautifulSoup解析提取数据1import pandas as pd #导⼊pandas库2import bs4 # 导⼊bs4库3from bs4 import BeautifulSoup # 导⼊BeautifulSoup库4 url = "http://www.op.gg/champion/statistics"5# 获得html⽂档信息6 html = askurl(url)7#解析数据8 soup = BeautifulSoup(html,"html.parser")9 top = []10 name = [] #建⽴空列表⽤于储存数据11 winRate = []12 pickRate = []13# 遍历上单tbody标签的⼉⼦标签14for tr in soup.find(name = "tbody",attrs = "tabItem champion-trend-tier-TOP").children:15# 判断tr是否为标签类型,去除空⾏16if isinstance(tr,bs4.element.Tag):17# 查找tr标签下的td标签18 tds = tr('td')19#排名20 top.append(tds[0].string)21# 英雄名22 name.append(tds[3].find(attrs = "champion-index-table__name").string)23# 胜率 %百分号对后续有影响,去除24 winRate.append(tds[4].string.replace('%',''))25# 选取率26 pickRate.append(tds[5].string.replace('%',''))2728#将准确获得的数据保存到列表中29 df1 = pd.DataFrame(data=[top, name, winRate, pickRate], index=['排名', '英雄名', '英雄胜率', '英雄出场率'])30# 对⽂本进⾏,⾏换列,列换⾏31 df2 = pd.DataFrame(df1.values.T, columns=df1.index)32# 保存数据到xlsx⽂件中33 df2.to_excel('上单top.xlsx')(2)利⽤正则提取法提取数据1from bs4 import BeautifulSoup2import re3import pandas as pd4 ADtop = []5 ADname = [] # 设⽴空表格6 ADwinrate = []7 ADpickrate = []8 url = "http://www.op.gg/champion/statistics"9# 获得html⽂档信息10 html = askurl(url)11# 解析数据12 soup = BeautifulSoup(html, "html.parser")13# 取得射⼿标签内容14 ADCdata = soup.find_all("tbody", class_="tabItem champion-trend-tier-ADC")15# 将BeautifulSoup类型转换为字符串类型,以便使⽤re库下的正则搜索16 strADCdata = str(ADCdata)17# 通过⽹页源码得知,需要收集的排名,英雄名信息为23条18for i in range(0, 23):19# 排名设定约束20 findTop = pile(r'<td class="champion-index-table__cell champion-index-table__cell--rank">(\d*?)</td>')21# 运⽤约束查找22 ADtop.append(re.findall(findTop, strADCdata)[i])23# 英雄名字设定约束24 findName = pile(r'<div class="champion-index-table__name">(.*?)</div>')25# 运⽤约束查找26 ADname.append(re.findall(findName, strADCdata)[i])27# 运⽤正则表达式查找时发现胜率与选取率除了标签,内容完全相同,导致在上⾯的循环中会出现交叉获得的问题出现。

基于深度学习方法的dota2游戏数据分析与胜率预测(python3.6+keras框架实现)

基于深度学习方法的dota2游戏数据分析与胜率预测(python3.6+keras框架实现)

基于深度学习⽅法的dota2游戏数据分析与胜率预测(python3.6+keras框架实现)这篇⽂章分为两⼤部分,第⼀部分为数据获取,第⼆部分为建模预测。

Part 1,数据获取1.接⼝分析①请求单场⽐赛https:///api/matches/{match_id}调⽤该URL可以根据⽐赛ID来获得单场⽐赛的详细信息,包括游戏起始时间,游戏持续时间,游戏模式,⼤厅模式,天辉/夜魇剩余兵营数量,玩家信息等,甚⾄包括游戏内聊天信息都有记录。

上⾯就是⼀条聊天记录⽰例,在这局游戏的第7条聊天记录中,玩家“⾼⾼兴兴把家回”发送了消息:”1指1个⼩朋友”。

②随机查找10场⽐赛该URL会随机返回10场近期⽐赛的基本数据,包括游戏起始时间,对阵双⽅英雄ID,天辉是否胜利等数据。

该接⼝URL返回该英雄对应的基本信息,包括有英雄属性,近战/远程,英雄名字,英雄有⼏条腿等等。

这⾥我们只对英雄名字这⼀条信息进⾏使⽤。

这个接⼝URL可以返回opendota数据库的表名称和其所包含的列名,在写sql语句时会有所帮助,⼀般与下⽅的数据浏览器接⼝配合使⽤。

⑤数据浏览器该接⼝⽤来对⽹站的数据库进⾏访问,所输⼊参数为sql语句,可以对所需的数据进⾏筛选。

如下图就是在matches表中寻找ID=5080676255的⽐赛的调⽤⽅式。

但是在实际使⽤中发现,这个数据浏览器接⼝仅能够查询到正式⽐赛数据,像我们平时玩的游戏情况在matches数据表⾥是不存在的。

⑥公开⽐赛查找该接⼝URL可以查询到我们所需要的在线游戏对局数据,其输⼊参数less_than_match_id指的是某局游戏的match_id,该接⼝会返回100条⼩于这个match_id的游戏对局数据,包括游戏时间,持续时间,游戏模式,⼤厅模式,对阵双⽅英雄,天辉是否获胜等信息。

本次建模所需的数据都是通过这个接⼝来进⾏获取的。

2.通过爬⾍获取游戏对局数据这次实验准备建⽴⼀个通过对阵双⽅的英雄选择情况来对胜率进⾏预测的模型,因此需要获得以下数据,[天辉⽅英雄列表]、[夜魇⽅英雄列表]、[哪⽅获胜]。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

还不会选英雄阵容?python来帮你carry全场欢迎来到召唤术峡谷~”英雄联盟作为一款长青游戏,风靡了这么多年,2018全球总决赛的IG冠军一出更是引发了众多撸迷又将游戏重新拾起。

今天我们就来分析一下战队的阵容选择会对胜率带来什么样的影响。

1.载入必要的包import pandas as pdimport matplotlib.pyplot as pltimport seaborn as snsfrom pyecharts import Radar2.读取并观察数据情况dat_hero=pd.read_csv('TeamHero_index.csv')dat_hero.head()3.数据分析(1)红蓝方因素对胜负的影响众所周知,在英雄联盟中,由于蓝方会先手ban英雄及pick英雄,因此通常蓝方的胜率更高一些。

让我们来看看数据是否能够印证这一点。

取出红方获胜的数据:red_win1=dat_hero[dat_hero['是否红方'].isin(['1'])]red_win1=red_win1[red_win1['是否获胜'].isin(['1'])]red_win2=dat_hero[dat_hero['是否红方'].isin(['0'])]red_win2=red_win2[red_win2['是否获胜'].isin(['0'])]red_win=pd.concat([red_win1,red_win2])red_win.shape(208,8)取出蓝方获胜的数据blue_win1=dat_hero[dat_hero['是否红方'].isin(['1'])]blue_win1=blue_win1[blue_win1['是否获胜'].isin(['0'])]blue_win2=dat_hero[dat_hero['是否红方'].isin(['0'])]blue_win2=blue_win2[blue_win2['是否获胜'].isin(['1'])]blue_win=pd.concat([blue_win1,blue_win2])blue_win.shape(316,8)画出红蓝方胜场直方图由上面的数据和图可以看到,蓝方有316胜场,红方仅有208胜场。

可以印证蓝有相对而言更有优势。

下面我们再对红蓝方所选用的英雄属性进行分析。

计算红方获胜时英雄平均属性:value1=[[red_win['攻击'].mean(),red_win['法术'].mean(),red_win['防御'].mean(),red_win['团战'].mean(),red_win['机动'].mean()]]计算蓝方获胜时英雄平均属性:value2=[[blue_win['攻击'].mean(),blue_win['法术'].mean(),blue_win['防御'].mean(),blue_win['团战'].mean(),bluewin['机动'].mean()]]from pyecharts import Radarradar = Radar()#用于调整雷达各维度的范围大小c_schema= [{"name": "攻击", "max": 54.3, "min": 54.1},{"name": "法术", "max": 52, "min": 51},{"name": "防御", "max": 54, "min": 52},{"name": "团战", "max": 73.2, "min": 71},{"name": "机动", "max": 66, "min": 65}]radar.config(c_schema=c_schema)radar.add("红方获胜",value1,item_color="#f9713c",area_color='#ea3a2e',area_opacity=0.3) radar.add("蓝方获胜",value2,item_color='#2525f5',area_color='#2525f5',area_opacity=0.3)radar从图中可以看到,作为红方,想要胜利攻击力、法术强度、防御性能都要比在蓝方时强一些,团战能力更是达到顶峰,而作为蓝色方来说,均衡发展就可以赢得胜利,团战能力也不需要特别强。

(2) 各个战队战绩分析plt.figure(figsize=(15,7))plt.xlabel('战队',fontsize=30,fontproperties=myfont)plt.ylabel('次数',fontsize=30,fontproperties=myfont)sns.countplot(x='战队',hue='是否获胜',data=dat_hero,palette=sns.color_palette('hls',7))从图中可以看出,胜场比负场多的战队分别有EDG, IG, RNG, WE, NB,OMG这六支战队。

胜场最多的依次是IG, RNG, WE这三支战队。

我们对这三支战队所选用英雄属性进行分析。

#计算EDG战队所选用英雄的平均属性EDG=dat_hero[dat_hero['战队'].isin(['EDG'])]edg_value=[[EDG['攻击'].mean(),EDG['法术'].mean(),EDG['防御'].mean(),EDG['团战'].mean(),EDG['机动'].mean()]]#计算RNG战队所选用英雄的平均属性RNG=dat_hero[dat_hero['战队'].isin(['RNG'])]rng_value=[[RNG['攻击'].mean(),RNG['法术'].mean(),RNG['防御'].mean(),RNG['团战'].mean(),RNG['机动'].mean()]]#计算WE战队所选用英雄的平均属性WE=dat_hero[dat_hero['战队'].isin(['WE'])]we_value=[[WE['攻击'].mean(),WE['法术'].mean(),WE['防御'].mean(),WE['团战'].mean(),WE['机动'].mean()]]radar1 = Radar()#用于调整雷达各维度的范围大小c_schema= [{"name": "攻击", "max": 55, "min": 53},{"name": "法术", "max": 52.5, "min": 50},{"name": "防御", "max": 55, "min": 52},{"name": "团战", "max": 76, "min": 72},{"name": "机动", "max": 68, "min": 64}]radar1.config(c_schema=c_schema)radar1.add("EDG", edg_value,item_color="#f9713c",line_width=3)radar1.add("RNG", rng_value,item_color='#2525f5',line_width=3)radar1.add("WE", we_value,item_color='#000',line_width=3)radar1从上图可以看出,每支队伍在选用英雄时都有自己的特点。

EDG更爱攻击性的阵容,RNG法术、防御做的不错,WE则更偏向团战和机动性。

所以说,没有绝对的阵容,只要队友不坑、猥琐别浪,游戏还是能赢得。

看了分析,赶快去召唤师峡谷战斗吧!。

相关文档
最新文档