In [1]: import numpy as np

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

In [2]: excel_file = 'phil_salt_data.xlsx'

df = pd.read_excel(excel_file)
​
csv_file = 'phil_salt_data.csv'
df.to_csv(csv_file, index=False)

In [3]: df.head()

Out[3]:
inns bat bowl ball outcome score out dismissal over cur_bat_runs ... batruns ballfaced bowlruns wagonX wagonY wagonZone

Phil Fawad
0 1 3 six 6 False NaN 7 35 ... 6 1 6 320 306 4
Salt Ahmed

Phil Fawad
1 1 4 no run 0 False NaN 7 35 ... 0 1 0 139 196 6
Salt Ahmed

Phil Fawad
2 1 5 run 1 False NaN 7 36 ... 1 1 1 143 118 8
Salt Ahmed

Phil Fawad
3 1 1 four 4 False NaN 9 48 ... 4 1 4 322 298 3
Salt Ahmed

Phil Fawad
4 1 2 run 1 False NaN 9 49 ... 1 1 1 136 132 7
Salt Ahmed

5 rows × 28 columns
 In This Data We Have One Column Called Wagon Zone Which Tells about the area where the shot was
played , but here the data is mentioned in int form , to make it more clear we will make a 'Shot Area'
Attribute which will clearly tell about the part of the ground where the shot was played

In [4]: shot_area_mapping = {
0: 'Null',
1: 'Towards Third Man',
2: 'Towards Fine Leg',
3: 'Towards Square Leg',
4: 'Towards Mid Wicket',
5: 'Towards Long On',
6: 'Towards Long Off',
7: 'Towards Covers',
8: 'Towards Point'
}
​
df['Shot Area'] = df['wagonZone'].map(shot_area_mapping)

In [5]: df.columns

Out[5]: Index(['inns', 'bat', 'bowl', 'ball', 'outcome', 'score', 'out', 'dismissal',

'over', 'cur_bat_runs', 'cur_bat_bf', 'year', 'ground', 'country',
'competition', 'bat_hand', 'bowl_style', 'bowl_kind', 'batruns',
'ballfaced', 'bowlruns', 'wagonX', 'wagonY', 'wagonZone', 'line',
'length', 'shot', 'control', 'Shot Area'],
dtype='object')

Process To Find How Many Runs Phil Salt Scored

In [6]: df['batruns'].sum()

Out[6]: 3659
 Process To Find How Many Balls Phil Salt Faced

In [7]: df['outcome'].count()

Out[7]: 2471

In [8]: df['outcome'].unique()

Out[8]: array(['six', 'no run', 'run', 'four', 'out', 'bye', 'wide', 'leg bye',
'no ball'], dtype=object)
In [9]: desired_outcomes = [ 'six', 'no run', 'run', 'four', 'out', 'bye', 'leg bye']
df[df['outcome'].isin(desired_outcomes)].count()

Out[9]: inns 2376

bat 2376
bowl 2376
ball 2376
outcome 2376
score 2376
out 2376
dismissal 140
over 2376
cur_bat_runs 2376
cur_bat_bf 2376
year 2376
ground 2376
country 2376
competition 2376
bat_hand 2376
bowl_style 2376
bowl_kind 2376
batruns 2376
ballfaced 2376
bowlruns 2376
wagonX 2376
wagonY 2376
wagonZone 2376
line 1562
length 1562
shot 2341
control 2375
Shot Area 2376
dtype: int64
 Runs Scored By Phil Salt in T20 Cricket from 2020 to Present = 3659

Balls Faced By Phil Salt in T20 Cricket from 2020 to Present = 2376

Process To Find Phil Salt T20 Sr :

In [10]: Strike_Rate = (3659/2376)*100

print(f'Strike Rate of Phil Salt in T20 Cricket From 2020 To Present is {round((Strike_Rate),2)}')

Strike Rate of Phil Salt in T20 Cricket From 2020 To Present is 154.0

In [11]: df['over'].unique()

Out[11]: array([ 7, 9, 5, 6, 8, 10, 3, 1, 4, 2, 14, 11, 13, 12, 15, 16, 17,
18, 19, 20], dtype=int64)

We will break the dataset into three parts - Powerplay ( 1 To 6 Overs), Middle Overs (7 to 15 overs) and
Death Overs (16 To 20 Overs), To Get a better understanding of phil salt strong and weak areas during
the particular phase of innings, so opposition can plan more well accordingly to it

In [12]: pp=[1,2,3,4,5,6]
pp_df = df[df['over'].isin(pp)]

In [13]: mo=[7,8,9,10,11,12,13,14,15]
mo_df = df[df['over'].isin(mo)]

In [14]: death=[16,17,18,19,20]
death_df = df[df['over'].isin(death)]
In [15]: df['wagonZone'].unique()

Out[15]: array([4, 6, 8, 3, 7, 5, 2, 0, 1], dtype=int64)

Bowling Plans For Phil Salt In PowerPlay :

In [16]: pp_df.head()

Out[16]:
inns bat bowl ball outcome score out dismissal over cur_bat_runs ... ballfaced bowlruns wagonX wagonY wagonZone

Phil Fawad
7 1 1 run 1 False NaN 5 18 ... 1 1 101 291 5 WIDE_
Salt Ahmed

Phil Fawad
8 1 3 six 6 False NaN 5 24 ... 1 6 360 194 3
Salt Ahmed

Phil Fawad
9 1 4 four 4 False NaN 5 28 ... 1 4 17 230 6 WIDE_
Salt Ahmed

Phil Fawad
10 1 5 four 4 False NaN 5 32 ... 1 4 249 350 4 WIDE_
Salt Ahmed

Phil Fawad
11 1 6 run 1 False NaN 5 33 ... 1 1 85 278 5 WIDE_
Salt Ahmed

5 rows × 29 columns

Areas in the ground where phil Salt Mostly Scores in Power Play:

In [17]: pp_df['batruns'].unique()

Out[17]: array([1, 6, 4, 0, 2, 3], dtype=int64)

In [18]: runs_by_shot_area_pp = pp_df.groupby('Shot Area')['batruns'].sum().reset_index()
​
runs_by_shot_area_pp.columns = ['Shot Area', 'Total Runs Scored']
​
total_runs = runs_by_shot_area_pp['Total Runs Scored'].sum()
​
runs_by_shot_area_pp['Percentage of Total Runs'] = round((runs_by_shot_area_pp['Total Runs Scored'] / total_runs) * 10
​
print(runs_by_shot_area_pp)

Shot Area Total Runs Scored Percentage of Total Runs

0 Null 8 0.34
1 Towards Covers 197 8.45
2 Towards Fine Leg 257 11.03
3 Towards Long Off 393 16.87
4 Towards Long On 341 14.64
5 Towards Mid Wicket 318 13.65
6 Towards Point 117 5.02
7 Towards Square Leg 562 24.12
8 Towards Third Man 137 5.88

Different Combinations Of Line-Length In Power Play and Runs Scored along with SR Of Phil Salt On
That Combinations Of Line Length :

In [19]: pp_df['line'].unique()

Out[19]: array(['WIDE_OUTSIDE_OFFSTUMP', 'ON_THE_STUMPS', 'OUTSIDE_OFFSTUMP',

'DOWN_LEG', nan, 'WIDE_DOWN_LEG'], dtype=object)

In [20]: pp_df['length'].unique()

Out[20]: array(['FULL', 'SHORT', 'SHORT_OF_A_GOOD_LENGTH', 'GOOD_LENGTH', nan,

'YORKER', 'FULL_TOSS'], dtype=object)

In [21]: pp_df['ballfaced'].unique()

Out[21]: array([1, 0], dtype=int64)

In [22]: line_length_stats = pp_df.groupby(['line', 'length']).agg(
total_runs_scored=('batruns', 'sum'),
total_balls_faced=('ballfaced', 'sum')
).reset_index()
​
line_length_stats['strike_rate'] = round(
(line_length_stats['total_runs_scored'] / line_length_stats['total_balls_faced']) * 100, 2
)
​
line_length_stats['strike_rate'] = line_length_stats['strike_rate'].fillna(0)
​
line_length_stats
​
Out[22]:
line length total_runs_scored total_balls_faced strike_rate

0 DOWN_LEG FULL 23 15 153.33

1 DOWN_LEG FULL_TOSS 4 3 133.33

2 DOWN_LEG GOOD_LENGTH 18 14 128.57

3 DOWN_LEG SHORT 26 11 236.36

4 DOWN_LEG SHORT_OF_A_GOOD_LENGTH 21 24 87.50

5 DOWN_LEG YORKER 0 0 0.00

6 ON_THE_STUMPS FULL 118 65 181.54

7 ON_THE_STUMPS FULL_TOSS 11 5 220.00

8 ON_THE_STUMPS GOOD_LENGTH 181 175 103.43

9 ON_THE_STUMPS SHORT 31 12 258.33

10 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH 150 92 163.04

11 ON_THE_STUMPS YORKER 8 8 100.00

12 OUTSIDE_OFFSTUMP FULL 164 82 200.00

13 OUTSIDE_OFFSTUMP FULL_TOSS 12 6 200.00

14 OUTSIDE_OFFSTUMP GOOD_LENGTH 297 228 130.26

15 OUTSIDE_OFFSTUMP SHORT 90 38 236.84

16 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH 267 153 174.51

17 OUTSIDE_OFFSTUMP YORKER 1 3 33.33

18 WIDE_DOWN_LEG FULL 0 1 0.00

19 WIDE_DOWN_LEG FULL_TOSS 0 0 0.00

20 WIDE_DOWN_LEG GOOD_LENGTH 0 1 0.00

21 WIDE_DOWN_LEG SHORT 6 1 600.00

22 WIDE_DOWN_LEG YORKER 0 0 0.00

23 WIDE_OUTSIDE_OFFSTUMP FULL 22 11 200.00

24 WIDE_OUTSIDE_OFFSTUMP FULL_TOSS 4 2 200.00

 line length total_runs_scored total_balls_faced strike_rate

25 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH 21 12 175.00

26 WIDE_OUTSIDE_OFFSTUMP SHORT 21 6 350.00

27 WIDE_OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH 12 12 100.00

28 WIDE_OUTSIDE_OFFSTUMP YORKER 1 2 50.00

Combinations Of Line Length In Which Phil Salt Gets Dismissed The Most In Power Play:

In [23]: pp_df['dismissal'].unique()

Out[23]: array([nan, 'caught', 'bowled', 'leg before wicket', 'run out', 'stumped'],
dtype=object)
In [24]: dismissals_df = pp_df[pp_df['dismissal'].notna()]
​
line_length_dismissals = (
dismissals_df.groupby(['line', 'length'])
.size()
.reset_index(name='total_dismissals')
)
​
line_length_dismissals

Out[24]:
line length total_dismissals

0 DOWN_LEG FULL 1

1 DOWN_LEG SHORT_OF_A_GOOD_LENGTH 2

2 ON_THE_STUMPS FULL 1

3 ON_THE_STUMPS GOOD_LENGTH 11

4 ON_THE_STUMPS SHORT 1

5 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH 5

6 OUTSIDE_OFFSTUMP FULL 5

7 OUTSIDE_OFFSTUMP GOOD_LENGTH 17

8 OUTSIDE_OFFSTUMP SHORT 3

9 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH 6

10 WIDE_OUTSIDE_OFFSTUMP FULL 1

11 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH 3
In [25]: dismissals_df = pp_df[pp_df['dismissal'].notna()]
​
line_length_dismissals = (
dismissals_df.groupby(['line', 'length', 'bowl_kind'])
.size()
.reset_index(name='total_dismissals')
)
​
line_length_dismissals

Out[25]:
line length bowl_kind total_dismissals

0 DOWN_LEG FULL pace bowler 1

1 DOWN_LEG SHORT_OF_A_GOOD_LENGTH pace bowler 2

2 ON_THE_STUMPS FULL pace bowler 1

3 ON_THE_STUMPS GOOD_LENGTH pace bowler 8

4 ON_THE_STUMPS GOOD_LENGTH spin bowler 3

5 ON_THE_STUMPS SHORT pace bowler 1

6 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH pace bowler 5

7 OUTSIDE_OFFSTUMP FULL pace bowler 5

8 OUTSIDE_OFFSTUMP GOOD_LENGTH pace bowler 12

9 OUTSIDE_OFFSTUMP GOOD_LENGTH spin bowler 5

10 OUTSIDE_OFFSTUMP SHORT pace bowler 2

11 OUTSIDE_OFFSTUMP SHORT spin bowler 1

12 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH pace bowler 6

13 WIDE_OUTSIDE_OFFSTUMP FULL pace bowler 1

14 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH pace bowler 3

 So I Got 2 Bowling Plans Which Opposition Should Plan To Bowl in Power Play For Phil Salt Are :

Plan A. Outside Off Stump - Good Length

Reason : * Highest Number Of Dismissals In PP In That Line Length (17)
* In That Line Length His SR Is Only 130 In PP,
* As We Have Seen Only His Around 8 % Runs Come Toward Covers In PP, Around 5% Runs Towards Point
And
Around 6 % Towards Third Man, Means he Struggles To Score Runs Between Covers to Third Man Regi
on And
These Are The Go To Region Against The Outside Off Stump Good Length Delivery

Let's Check What Type Of Shots Phil Salt Plays Against The Outside Off Stump - Good Length
Delivery

In [26]: pp_df['shot'].unique()

Out[26]: array(['ON_DRIVE', 'SLOG_SWEEP', 'CUT_SHOT', 'PULL', 'SLOG_SHOT', 'FLICK',

'COVER_DRIVE', 'DEFENDED', 'SQUARE_DRIVE', 'LEFT_ALONE', 'PUSH',
'HOOK', nan, 'VERTICAL_FORWARD_ATTACK', 'LEG_GLANCE',
'PULL_HOOK_ON_BACK_FOOT', 'DROP_AND_RUN', 'STRAIGHT_DRIVE',
'PUSH_SHOT', 'SWEEP_SHOT', 'STEERED', 'BACK_DEFENCE', 'SWEEP',
'CUT_SHOT_ON_BACK_FOOT', 'FORWARD_DEFENCE', 'DAB', 'REVERSE_SWEEP',
'UPPER_CUT', 'PADDLE_SWEEP', 'LATE_CUT'], dtype=object)
In [27]: filtered_df = pp_df[(pp_df['line'] == 'OUTSIDE_OFFSTUMP') & (pp_df['length'] == 'GOOD_LENGTH')]
​
shots_and_dismissals = filtered_df.groupby('shot').agg(
total_shots=('shot', 'size'),
dismissals=('dismissal', lambda x: x.notna().sum())
).reset_index()
​
shots_and_dismissals

Out[27]:
shot total_shots dismissals

0 COVER_DRIVE 70 3

1 CUT_SHOT 23 2

2 DAB 1 0

3 DEFENDED 14 0

4 FLICK 11 2

5 LEFT_ALONE 4 0

6 ON_DRIVE 43 1

7 PULL 4 2

8 PUSH 16 2

9 SLOG_SHOT 16 2

10 SLOG_SWEEP 2 1

11 SQUARE_DRIVE 19 1

12 STEERED 3 1

13 STRAIGHT_DRIVE 6 0

14 SWEEP_SHOT 1 0

We Can See Phil Salt Attempts The Most For Cover Drive, On Drive And Cut Shot Against The Outside Off Stump Good Length Delivery In
PowerPlay And Gets Dismissed Too While Playing Those Shots, So The Best Field Position Strategy For This Delivery Would Be Keeping 1 Slip,
1 Gully, 1 Point, 1 Extra Cover, 1 Cover, 1 Mid Off, 1 Mid Wicket, 1 Long On, 1 Deep Square Leg
Plan B. On The Stumps - Good Length
Reason : * Second Highest Numbar Of Dismissals In Power Play In That Line Length (11)
* In That Line Length His SR Is Only 103.43 In PP,
* As We Have Seen He Scores Around 55% Of His Runs In Power Play Between Square Leg to Long Off R
egion,
So He Will Definetly Try To Play The Middle Stump Ball On The Leg Side Hence It Will Create
Chances For Top Edges And LBW As Those Will Be Cross Batted Shots
 Let's See What Shots Phil Salt Attempts The Most In On The Stumps Good Length Ball In Powerplay :

In [28]: filtered_df = pp_df[(pp_df['line'] == 'ON_THE_STUMPS') & (pp_df['length'] == 'GOOD_LENGTH')]

​
shots_and_dismissals = filtered_df.groupby('shot').agg(
total_shots=('shot', 'size'),
dismissals=('dismissal', lambda x: x.notna().sum())
).reset_index()
​
shots_and_dismissals

Out[28]:
shot total_shots dismissals

0 COVER_DRIVE 8 0

1 CUT_SHOT 6 1

2 DEFENDED 21 0

3 FLICK 64 5

4 LEFT_ALONE 1 0

5 LEG_GLANCE 2 0

6 ON_DRIVE 36 1

7 PULL 5 1

8 PUSH 11 0

9 REVERSE_SWEEP 1 0

10 SLOG_SHOT 10 2

11 SLOG_SWEEP 1 1

12 SQUARE_DRIVE 2 0

13 STRAIGHT_DRIVE 3 0

14 SWEEP_SHOT 6 0
 As We Can See Phil Salt Attempts Flick Shot The Most In PowerPlay In On The Stumps Good Length Ball And Gets Dismissed The Most Also
While Playing It

Lets See In Which Area Of The Ground Does His Flick Shot Goes Against The On The Stumps Good
Length Ball In PowerPlay :

In [29]: filtered_df = pp_df[(pp_df['line'] == 'ON_THE_STUMPS') &

(pp_df['length'] == 'GOOD_LENGTH') &
(pp_df['shot'] == 'FLICK')]
​
shot_areas = filtered_df['Shot Area'].value_counts().reset_index()
shot_areas.columns = ['Shot Area', 'Count']
​
shot_areas

Out[29]:
Shot Area Count

0 Towards Square Leg 30

1 Null 12

2 Towards Fine Leg 9

3 Towards Third Man 6

4 Towards Mid Wicket 5

5 Towards Long Off 1

6 Towards Long On 1
 He Got Out 5 Times While Playing Flick Shot In Powerplay Against The On The Stumps Good Length
Ball, Lets Try To See The Pattern In Those Dismissals

In [30]: filtered_df = pp_df[(pp_df['line'] == 'ON_THE_STUMPS') &

(pp_df['length'] == 'GOOD_LENGTH') &
(pp_df['shot'] == 'FLICK')]
​
shot_areas_dismissals = filtered_df.groupby(['Shot Area', 'dismissal']).size().reset_index(name='Count')
​
shot_areas_dismissals

Out[30]:
Shot Area dismissal Count

0 Null bowled 1

1 Towards Long Off caught 1

2 Towards Square Leg caught 2

3 Towards Third Man caught 1

As I said Earlier Phil Salt Will Try To Play Cross Batted Shots Against The On The Stumps Good Length Ball In Powerplay, Hence It Will Create
Chances For Top Edges, So You Can See His Flicks Got Caught In Long Off And Third Man, This Proves My Point Right

Field Setup For This On The Stumps Good Length Ball Against Phil Salt In Powerplay Considering He Will Try To Play This Ball On Leg Side The
Most And Will Attempt Flick And On Drive The Most Would Be: 1 Mid On, 1 Mid Wicket, 1 Deep Sqaure Leg, 1 Long On, 1 Short Fine Leg, 1
Gully, 1 Point, 1 Cover, 1 Mid Off
 Bowling Plans For Phil Salt In Middle Overs :

In [31]: mo_df.head()

Out[31]:
inns bat bowl ball outcome score out dismissal over cur_bat_runs ... ballfaced bowlruns wagonX wagonY wagonZone

Phil Fawad
0 1 3 six 6 False NaN 7 35 ... 1 6 320 306 4 ON_
Salt Ahmed

Phil Fawad
1 1 4 no run 0 False NaN 7 35 ... 1 0 139 196 6 ON_
Salt Ahmed

Phil Fawad
2 1 5 run 1 False NaN 7 36 ... 1 1 143 118 8 OUTSID
Salt Ahmed

Phil Fawad
3 1 1 four 4 False NaN 9 48 ... 1 4 322 298 3 OUTSID
Salt Ahmed

Phil Fawad
4 1 2 run 1 False NaN 9 49 ... 1 1 136 132 7 OUTSID
Salt Ahmed

5 rows × 29 columns
 Areas in the ground where phil Salt Mostly Scores in Middle Overs:

In [32]: runs_by_shot_area_mo = mo_df.groupby('Shot Area')['batruns'].sum().reset_index()

​
runs_by_shot_area_mo.columns = ['Shot Area', 'Total Runs Scored']
​
total_runs = runs_by_shot_area_mo['Total Runs Scored'].sum()
​
runs_by_shot_area_mo['Percentage of Total Runs'] = round((runs_by_shot_area_mo['Total Runs Scored'] / total_runs) * 10
​
runs_by_shot_area_mo

Out[32]:
Shot Area Total Runs Scored Percentage of Total Runs

0 Null 0 0.00

1 Towards Covers 45 4.07

2 Towards Fine Leg 97 8.78

3 Towards Long Off 169 15.29

4 Towards Long On 168 15.20

5 Towards Mid Wicket 164 14.84

6 Towards Point 69 6.24

7 Towards Square Leg 347 31.40

8 Towards Third Man 46 4.16

 Different Combinations Of Line-Length In Middle Overs and Runs Scored along with SR Of Phil Salt On
That Combinations Of Line Length :

In [33]: line_length_stats_mo = mo_df.groupby(['line', 'length', 'bowl_kind']).agg(

total_runs_scored=('batruns', 'sum'),
total_balls_faced=('ballfaced', 'sum')
).reset_index()
​
line_length_stats_mo['strike_rate'] = round(
(line_length_stats_mo['total_runs_scored'] / line_length_stats_mo['total_balls_faced']) * 100, 2
)
​
line_length_stats_mo['strike_rate'] = line_length_stats_mo['strike_rate'].fillna(0)
​
line_length_stats_mo
Out[33]:
line length bowl_kind total_runs_scored total_balls_faced strike_rate

0 DOWN_LEG FULL pace bowler 2 1 200.00

1 DOWN_LEG FULL spin bowler 0 0 0.00

2 DOWN_LEG FULL_TOSS pace bowler 5 2 250.00

3 DOWN_LEG GOOD_LENGTH pace bowler 0 0 0.00

4 DOWN_LEG GOOD_LENGTH spin bowler 1 2 50.00

5 DOWN_LEG SHORT pace bowler 10 2 500.00

6 DOWN_LEG SHORT spin bowler 1 1 100.00

7 DOWN_LEG SHORT_OF_A_GOOD_LENGTH pace bowler 5 3 166.67

8 DOWN_LEG SHORT_OF_A_GOOD_LENGTH spin bowler 1 2 50.00

9 DOWN_LEG YORKER pace bowler 0 1 0.00

10 ON_THE_STUMPS FULL pace bowler 25 15 166.67

11 ON_THE_STUMPS FULL spin bowler 32 23 139.13

12 ON_THE_STUMPS FULL_TOSS pace bowler 10 5 200.00

13 ON_THE_STUMPS FULL_TOSS spin bowler 1 1 100.00

14 ON_THE_STUMPS GOOD_LENGTH pace bowler 25 24 104.17

15 ON_THE_STUMPS GOOD_LENGTH spin bowler 84 64 131.25

16 ON_THE_STUMPS SHORT pace bowler 20 6 333.33

17 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH pace bowler 34 21 161.90

18 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH spin bowler 32 28 114.29

19 ON_THE_STUMPS YORKER pace bowler 2 5 40.00

20 OUTSIDE_OFFSTUMP FULL mixture/unknown 4 1 400.00

21 OUTSIDE_OFFSTUMP FULL pace bowler 35 21 166.67

22 OUTSIDE_OFFSTUMP FULL spin bowler 30 19 157.89

23 OUTSIDE_OFFSTUMP FULL_TOSS pace bowler 10 5 200.00

24 OUTSIDE_OFFSTUMP GOOD_LENGTH mixture/unknown 1 1 100.00

 line length bowl_kind total_runs_scored total_balls_faced strike_rate

25 OUTSIDE_OFFSTUMP GOOD_LENGTH pace bowler 47 27 174.07

26 OUTSIDE_OFFSTUMP GOOD_LENGTH spin bowler 97 77 125.97

27 OUTSIDE_OFFSTUMP SHORT pace bowler 37 17 217.65

28 OUTSIDE_OFFSTUMP SHORT spin bowler 1 1 100.00

29 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH pace bowler 53 36 147.22

30 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH spin bowler 72 40 180.00

31 OUTSIDE_OFFSTUMP YORKER pace bowler 2 3 66.67

32 WIDE_DOWN_LEG FULL_TOSS pace bowler 0 0 0.00

33 WIDE_OUTSIDE_OFFSTUMP FULL pace bowler 23 9 255.56

34 WIDE_OUTSIDE_OFFSTUMP FULL spin bowler 4 2 200.00

35 WIDE_OUTSIDE_OFFSTUMP FULL_TOSS pace bowler 0 2 0.00

36 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH pace bowler 5 3 166.67

37 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH spin bowler 6 3 200.00

38 WIDE_OUTSIDE_OFFSTUMP SHORT pace bowler 6 1 600.00

39 WIDE_OUTSIDE_OFFSTUMP SHORT spin bowler 8 2 400.00

40 WIDE_OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH pace bowler 10 5 200.00

41 WIDE_OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH spin bowler 4 5 80.00

42 WIDE_OUTSIDE_OFFSTUMP YORKER pace bowler 0 0 0.00

 Combinations Of Line Length In Which Phil Salt Gets Dismissed The Most In Middle Overs ( We Will
Consider Line Length For Spinners And Pacers Seprately After PowerPlay As After PowerPlay Spinners
Play A Cruical Role) :

In [34]: dismissals_df_mo = mo_df[mo_df['dismissal'].notna()]

​
line_length_dismissals_mo = (
dismissals_df_mo.groupby(['line', 'length', 'bowl_kind'])
.size()
.reset_index(name='total_dismissals')
)
​
line_length_dismissals_mo

Out[34]:
line length bowl_kind total_dismissals

0 DOWN_LEG SHORT_OF_A_GOOD_LENGTH spin bowler 1

1 ON_THE_STUMPS FULL spin bowler 1

2 ON_THE_STUMPS GOOD_LENGTH pace bowler 3

3 ON_THE_STUMPS GOOD_LENGTH spin bowler 6

4 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH spin bowler 2

5 ON_THE_STUMPS YORKER pace bowler 2

6 OUTSIDE_OFFSTUMP FULL pace bowler 1

7 OUTSIDE_OFFSTUMP FULL spin bowler 1

8 OUTSIDE_OFFSTUMP GOOD_LENGTH pace bowler 1

9 OUTSIDE_OFFSTUMP GOOD_LENGTH spin bowler 2

10 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH pace bowler 5

11 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH spin bowler 4

12 WIDE_OUTSIDE_OFFSTUMP FULL pace bowler 1

So I Got 2 Bowling Plans Which Opposition Should Plan To Bowl in Middle Overs For Phil Salt Are :

Plan A. On The Stump - Good Length By A Spinner :

Reason : * Highest Number Of Dismissals In Middle Overs In This Line Length By A Spinner (6)
* In This Line Length By A Spinner His SR Is Only Around 131 In Middle Overs
 Let's See What Shots Phil Salt Attempts & And His Dismissals In On The Stumps Good Length Ball By a
Spinner In Middle Overs :

In [35]: filtered_df_mo = mo_df[(mo_df['line'] == 'ON_THE_STUMPS') & (mo_df['length'] == 'GOOD_LENGTH') & (mo_df['bowl_kind'] =

​
shots_and_dismissals_mo = filtered_df_mo.groupby('shot').agg(
total_shots=('shot', 'size'),

dismissals=('dismissal', lambda x: x.notna().sum())

).reset_index()
​
shots_and_dismissals_mo

Out[35]:
shot total_shots dismissals

0 COVER_DRIVE 3 0

1 CUT_SHOT 6 3

2 DEFENDED 6 1

3 FLICK 16 1

4 LEG_GLANCE 1 0

5 ON_DRIVE 10 0

6 PULL 6 0

7 PUSH 1 0

8 REVERSE_SWEEP 1 0

9 SLOG_SHOT 3 0

10 SLOG_SWEEP 8 0

11 STRAIGHT_DRIVE 3 1
In [36]: filtered_df_mo = mo_df[(mo_df['line'] == 'ON_THE_STUMPS') &
(mo_df['length'] == 'GOOD_LENGTH') &
(mo_df['bowl_kind'] == 'spin bowler')]
​
shots_and_dismissals_mo = filtered_df_mo.groupby(['shot', 'dismissal']).agg(
total_shots=('shot', 'size')
).reset_index()
​
shots_and_dismissals_mo

Out[36]:
shot dismissal total_shots

0 CUT_SHOT bowled 2

1 CUT_SHOT caught 1

2 DEFENDED bowled 1

3 FLICK leg before wicket 1

4 STRAIGHT_DRIVE run out 1

As We Can Infer From The Data That In Middle Overs If A Spinner Keeps The Ball On The Stumps and Pitch It in Good Length Phil Salt Will Play
That Ball On Leg Side By Flick ,Sweep Or He Will Play It At Long On By On Drive , The Shot Area Data In Middle Overs Clearly Shows He
Scores Around 70% Of His Runs Between Long On To Fine Leg, And By Analyzing His Dismissals Data On That "On The Stump Good Length
Bowl" We Inferred That He Got Dismissed 3 Out Of 6 Times While Playing Cut Shot Out Of Which 2 Were Bowled, So If We Compeletely Pack
The Field On Leg Side And Leave The Point Open For Him To Invite Him To Play Cut Shot Than We Can Get Him Bowled On This "On The
Stump Good Length Bowl"

Apt Field Placement For This 'On The Stumps Good Length Ball' By A Spinner In Middle Overs Is - 1 Third Man, 1 Deep Extra Cover, 1 Long Off,
1 Deep Mid Wicket, 1 Forward Square Leg, 1 Square Leg, 1 Short Fine Leg, 1 Cover And 1 Gully
Plan B. Outside Off Stump - Short Of A Good Length Bowl
Reason : * Got Dismissed 9 Times In Middle Overs In This Type Of Bowl Out Of Which 5 Times By Fast Bo
wler And
4 Times By Spinner
* As Inferred By The Shot Area Data His Off Side Game Is Weak, And In This Delivery Mostly
You Can Score On Off Side Only
 Lets See What Shots Does Phil Salt Mosty Play On The Outside Off Stump - Short Of A Good Length
Bowl:

In [37]: filtered_df_mo_b = mo_df[(mo_df['line'] == 'OUTSIDE_OFFSTUMP') & (mo_df['length'] == 'SHORT_OF_A_GOOD_LENGTH') ]

​
shots_and_dismissals_mo_b = filtered_df_mo_b.groupby('shot').agg(
total_shots=('shot', 'size'),

dismissals=('dismissal', lambda x: x.notna().sum())

).reset_index()
​
shots_and_dismissals_mo_b

Out[37]:
shot total_shots dismissals

0 COVER_DRIVE 7 0

1 CUT_SHOT 21 1

2 DEFENDED 2 0

3 FLICK 3 0

4 LEFT_ALONE 1 0

5 ON_DRIVE 5 0

6 PULL 29 8

7 PUSH 2 0

8 SLOG_SHOT 2 0

9 STEERED 2 0

10 STRAIGHT_DRIVE 2 0

So According To The Data In Middle Overs Phil Salt Mostly Attempts The Pull Shot Against The Outside Off Stump Short Of A Good Length Bowl,
And Also He Gets Dismissed Mostly Playing That Pull Shot
 Lets Try To See The Pattern In Phil Salt Dismisssals While Playing The Pull Shot Against The Outside Off
Stump Short Of A Good Length Bowl

In [38]: filtered_df_mo_bb = mo_df[(mo_df['line'] == 'OUTSIDE_OFFSTUMP') &

(mo_df['length'] == 'SHORT_OF_A_GOOD_LENGTH') &
(mo_df['shot'] == 'PULL')]
​
shots_and_dismissals_mo_bb = filtered_df_mo_bb.groupby(['shot', 'dismissal', 'Shot Area']).agg(
total_shots=('shot', 'size')
).reset_index()
​
shots_and_dismissals_mo_bb

Out[38]:
shot dismissal Shot Area total_shots

0 PULL caught Towards Mid Wicket 2

1 PULL caught Towards Point 2

2 PULL caught Towards Square Leg 4

So According To This Data In Middle Overs We Can Trap Phil Salt In This Bowl By This Field : 1 Third Man, 1 Deep Point, 1 Cover, 1 Mid Off, 1
Mid On, 1 Deep Mid Wicket, 1 Backward Square Leg, 1 Deep Square Leg, 1 Fine Leg,
 Bowling Plans For Phil Salt In Death Overs :

In [39]: death_df.head()

Out[39]:
inns bat bowl ball outcome score out dismissal over cur_bat_runs ... ballfaced bowlruns wagonX wagonY wagonZone

Phil D'Arcy
453 2 1 run 1 False NaN 16 63 ... 1 1 265 204 3
Salt Short

Phil D'Arcy
454 2 3 run 1 False NaN 16 64 ... 1 1 145 245 5
Salt Short

Phil D'Arcy
455 2 5 six 6 False NaN 16 70 ... 1 6 362 261 3
Salt Short

Phil D'Arcy
456 2 6 run 2 False NaN 16 72 ... 1 2 258 249 3
Salt Short

Phil Ben
457 1 1 run 1 False NaN 17 23 ... 1 1 301 253 3 OUT
Salt Laughlin

5 rows × 29 columns
 Areas in the ground where phil Salt Mostly Scores in Death Overs:

In [40]: runs_by_shot_area_death = death_df.groupby('Shot Area')['batruns'].sum().reset_index()

​
runs_by_shot_area_death.columns = ['Shot Area', 'Total Runs Scored']
​
total_runs = runs_by_shot_area_death['Total Runs Scored'].sum()
​
runs_by_shot_area_death['Percentage of Total Runs'] = round((runs_by_shot_area_death['Total Runs Scored'] / total_runs
​
runs_by_shot_area_death

Out[40]:
Shot Area Total Runs Scored Percentage of Total Runs

0 Null 0 0.00

1 Towards Covers 10 4.46

2 Towards Fine Leg 23 10.27

3 Towards Long Off 32 14.29

4 Towards Long On 25 11.16

5 Towards Mid Wicket 56 25.00

6 Towards Point 26 11.61

7 Towards Square Leg 49 21.88

8 Towards Third Man 3 1.34

 Different Combinations Of Line-Length In Death Overs and Runs Scored along with SR Of Phil Salt On
That Combinations Of Line Length :

In [41]: line_length_stats_death = death_df.groupby(['line', 'length']).agg(

total_runs_scored=('batruns', 'sum'),
total_balls_faced=('ballfaced', 'sum')
).reset_index()
​
line_length_stats_death['strike_rate'] = round(
(line_length_stats_death['total_runs_scored'] / line_length_stats_death['total_balls_faced']) * 100, 2
)
​
line_length_stats_death['strike_rate'] = line_length_stats_death['strike_rate'].fillna(0)
​
line_length_stats_death
Out[41]:
line length total_runs_scored total_balls_faced strike_rate

0 DOWN_LEG GOOD_LENGTH 1 2 50.00

1 DOWN_LEG SHORT_OF_A_GOOD_LENGTH 4 1 400.00

2 ON_THE_STUMPS FULL 22 9 244.44

3 ON_THE_STUMPS FULL_TOSS 0 1 0.00

4 ON_THE_STUMPS GOOD_LENGTH 18 8 225.00

5 ON_THE_STUMPS SHORT 10 4 250.00

6 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH 8 3 266.67

7 ON_THE_STUMPS YORKER 0 1 0.00

8 OUTSIDE_OFFSTUMP FULL 20 10 200.00

9 OUTSIDE_OFFSTUMP FULL_TOSS 23 7 328.57

10 OUTSIDE_OFFSTUMP GOOD_LENGTH 23 16 143.75

11 OUTSIDE_OFFSTUMP SHORT 15 7 214.29

12 OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH 8 6 133.33

13 OUTSIDE_OFFSTUMP YORKER 1 2 50.00

14 WIDE_OUTSIDE_OFFSTUMP FULL 19 10 190.00

15 WIDE_OUTSIDE_OFFSTUMP FULL_TOSS 6 2 300.00

16 WIDE_OUTSIDE_OFFSTUMP GOOD_LENGTH 12 3 400.00

17 WIDE_OUTSIDE_OFFSTUMP SHORT 7 2 350.00

18 WIDE_OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH 1 2 50.00

19 WIDE_OUTSIDE_OFFSTUMP YORKER 0 3 0.00

 Combinations Of Line Length In Which Phil Salt Gets Dismissed The Most In Death Overs :

In [42]: dismissals_df_death = death_df[death_df['dismissal'].notna()]

​
line_length_dismissals_death = (
dismissals_df_death.groupby(['line', 'length', 'bowl_kind'])
.size()
.reset_index(name='total_dismissals')
)
​
line_length_dismissals_death

Out[42]:
line length bowl_kind total_dismissals

0 DOWN_LEG GOOD_LENGTH spin bowler 1

1 ON_THE_STUMPS FULL pace bowler 1

2 ON_THE_STUMPS FULL_TOSS pace bowler 1

3 ON_THE_STUMPS SHORT pace bowler 2

4 ON_THE_STUMPS SHORT_OF_A_GOOD_LENGTH spin bowler 1

5 ON_THE_STUMPS YORKER pace bowler 1

6 OUTSIDE_OFFSTUMP GOOD_LENGTH spin bowler 2

7 WIDE_OUTSIDE_OFFSTUMP SHORT_OF_A_GOOD_LENGTH pace bowler 1

 What Shots Does Phis Salt Play Mostly In Death Overs :

In [43]: shots_and_dismissals_death_b = death_df.groupby('shot').agg(

total_shots=('shot', 'size'),

dismissals=('dismissal', lambda x: x.notna().sum())

).reset_index()
​
shots_and_dismissals_death_b
Out[43]:
shot total_shots dismissals

0 COVER_DRIVE 8 0

1 CUT_SHOT 9 0

2 CUT_SHOT_ON_BACK_FOOT 1 0

3 DAB 2 0

4 DEFENDED 2 1

5 FLICK 5 2

6 HOOK 1 0

7 LEFT_ALONE 2 0

8 LEG_GLANCE 1 0

9 ON_DRIVE 22 2

10 PADDLE_SWEEP 1 0

11 PULL 18 3

12 PULL_HOOK_ON_BACK_FOOT 5 0

13 PUSH 3 0

14 PUSH_SHOT 2 0

15 RAMP 1 0

16 REVERSE_SWEEP 1 0

17 SLOG_SHOT 10 2

18 SLOG_SWEEP 2 0

19 SQUARE_DRIVE 4 0

20 STEERED 1 0

21 STRAIGHT_DRIVE 4 0

22 SWEEP_SHOT 2 0

23 VERTICAL_FORWARD_ATTACK 6 0
 Since Phil Salt Is An Opener So There Is No Such Specific Pattern In Data To See Where He Struggles In Death Overs, Becuase The Data Is
Too Small To Get Into A Conclusion, But Still There Is One Pattern Which Can Be Inferred With The Available Death Over Dataset

Plan A. On The Stumps - Short Ball :

Reason : * Anything Short In Death Overs Phil Salt Will Try Ti Pull It, As We Can See From Data That
He
Attempts Pull Shot Very Much In Death Overs
* Out Of 18 Attempts To Play Pull Shot In Death Overs He Got Dismissed 3 Times
* 46 % Of His Runs In Death Overs Comes In Mid Wicket And Square Leg Region, Means We Can Tr
ap Him
In That Region

Apt Field Placement For This 'On The Stumps - Short Ball' In Death Overs Will Be - 1 Deep Fine Leg, 1 Deep Square Leg, 1 Deep Mid Wicket, 1
Mid On, 1 Long Off, 1 Deep Extra Cover, 1 Point, 1 Short Third Man, 1 Backward Square Leg

In [ ]: ​