Ferro, Fiona: A Comprehensive Guide for Sports Bettors
Overview / Introduction
Fiona Ferro, a prominent French tennis player, was born on May 18, 1998. Known for her aggressive baseline play and powerful forehand, Ferro has carved out a niche in the competitive world of women’s tennis. Currently ranked within the top 50 players globally, she has demonstrated consistent performances across various tournaments.
Career Achievements and Statistics
Throughout her career, Fiona Ferro has achieved significant milestones including reaching the quarterfinals at Roland Garros and securing multiple ITF titles. Her recent matches show a balanced record with notable victories against top-seeded players. As of now, she holds a commendable ranking in the WTA circuit.
Playing Style and Key Strengths
Ferro’s playing style is characterized by her powerful groundstrokes and tactical acumen. Her key strengths lie in her ability to dictate points from the baseline and her strategic use of the court to outmaneuver opponents. Her technical prowess is complemented by an impressive mental game.
Interesting Facts and Unique Traits
Known affectionately as “The French Phenom,” Ferro enjoys a growing fan base both in France and internationally. Her charismatic personality and resilience on the court have endeared her to fans worldwide. Notably, she often engages with fans through social media, sharing insights into her training regimen and personal life.
Lists & Rankings of Performance Metrics or Top Stats
- Average First Serve Percentage: ✅ 65%
- Aces per Match: 🎰 5-7
- Winning Percentage on Hard Courts: 💡 70%
Comparisons with Other Players in the Same Team or League
Ferro is often compared to other rising stars in women’s tennis such as Clara Tauson and Leylah Fernandez. While each player brings unique strengths to their game, Ferro stands out for her exceptional baseline play and mental toughness under pressure.
Player-focused Case Studies or Career Stories
Ferro’s breakthrough came during the 2021 Roland Garros where she reached the quarterfinals, defeating higher-ranked opponents along the way. This performance marked a significant milestone in her career, showcasing her potential to compete at the highest levels.
| Statistic | Last Year | This Year |
|---|---|---|
| Total Wins | 15 | 20 |
| Total Losses | 10 | 8 |
| Average Match Duration (minutes) | 110 | 105 |
Tips & Recommendations for Analyzing the Player or Betting Insights
To effectively analyze Fiona Ferro for betting purposes, consider her recent form on clay courts where she excels. Monitor her head-to-head records against upcoming opponents to gauge potential outcomes. Additionally, keep an eye on injury reports that might affect her performance.
“Fiona Ferro’s tenacity and skill make her a formidable opponent on any surface,” says renowned tennis analyst John Doe.
Ferrovian Pros & Cons of Current Form or Performance
- Potential Pros:
- ✅ Strong baseline game.
- ✅ High adaptability across surfaces.
- Potential Cons:
- ❌ Occasional lapses in concentration during long matches.
- ❌ Injuries can impact performance unpredictably.
Tips for Understanding Fiona’s Strengths & Betting Potential: A Step-by-Step Guide 📈💡🎯
- Analyze recent match footage focusing on baseline rallies and serve efficiency.
- Evaluate head-to-head statistics against upcoming opponents using WTA databases.
- Maintain awareness of current rankings to identify shifts in form or momentum.
- Cross-reference expert predictions with your own analysis for balanced insight.
- Leverage betting platforms like Betwhale! for real-time odds updates before placing bets.
In this chapter we will discuss about some of these techniques that you can apply when you are working with data frames.
Let us start by loading our dataset.
{r}
#Loading dataset
data <- read.csv("C:/Users/RAJU/Desktop/ANALYTICS VILLAGE/Python Data Science/Week 6/HR_comma_sep.csv")
head(data)
Now we will explore some basic operations that can be performed over data frames.
### Operations Over Columns
#### Summation
We can find summation over all values present in a particular column using **sum()** function.
{r}
#Summation
sum(data$left)
We can also find summation over all values present in all columns using **colSums()** function.
{r}
#Summation
colSums(data)
#### Mean
We can find mean value over all values present in a particular column using **mean()** function.
{r}
#Mean
mean(data$satisfaction_level)
We can also find mean value over all values present in all columns using **colMeans()** function.
{r}
#Mean
colMeans(data)
#### Max / Min Value
We can find maximum value present over all values present in a particular column using **max()** function.
{r}
#Max Value
max(data$satisfaction_level)
We can also find maximum value over all values present in all columns using **apply()** function along with max(). Note that we are passing axis = 2 here because we want operation to be performed across columns not rows (axis = 1).
{r}
#Max Value
apply(data[,], MARGIN = 2,FUN = max)
Similarly we can find minimum value present over all values present in a particular column using **min()** function.
{r}
#Min Value
min(data$satisfaction_level)
We can also find minimum value over all values present in all columns using **apply()** function along with min(). Note that we are passing axis = 2 here because we want operation to be performed across columns not rows (axis = 1).
{r}
#Min Value
apply(data[,], MARGIN = 2,FUN = min)
#### Variance / Standard Deviation / Median / Quantile
We can calculate variance / standard deviation / median / quantile etc., by applying respective functions on individual columns.
Below are some examples:
Variance:
This gives us variance over all values present inside satisfaction_level column.
Note: We have set na.rm = TRUE so that NA's are ignored while calculating variance.
{r}
#Variance
var(x=data$satisfaction_level , na.rm=TRUE )
Standard Deviation:
This gives us standard deviation over all values present inside satisfaction_level column.
Note: We have set na.rm = TRUE so that NA's are ignored while calculating standard deviation.
{r}
#Standard Deviation
sd(x=data$satisfaction_level , na.rm=TRUE )
Median:
This gives us median value over all values present inside satisfaction_level column.
Note: We have set na.rm = TRUE so that NA's are ignored while calculating median.
{r}
#Median
median(x=data$satisfaction_level , na.rm=TRUE )
Quantile:
This gives us quartiles (25%,50%,75%) value over all values present inside satisfaction_level column.
Note: We have set na.rm = TRUE so that NA's are ignored while calculating quantiles.
{r}
#Quantiles
quantile(x=data$satisfaction_level , probs=c(0.25 ,0.50 ,0.75) , na.rm=TRUE )
### Operations Over Rows
#### Summation
We can calculate summation by applying sum() function on each row.
Below is an example:
Here we are passing axis = 1 because we want operation to be performed across rows not columns (axis = 2).
{r}
#Summation Across Rows
apply(X=data[,], MARGIN=1,FUN=sum)
#### Mean
We can calculate mean by applying mean() function on each row.
Below is an example:
Here we are passing axis = 1 because we want operation to be performed across rows not columns (axis = 2).
{r}
#Mean Across Rows
apply(X=data[,], MARGIN=1,FUN=mean)
### Sorting Data Frames
Sorting is one of most important operations which helps us sort data based upon some specific criteria such as sorting based upon ascending/descending order of salary etc., . We will see how this operation works below :
Let us start by creating our own sample data frame containing employee details such as name,salary etc., . We will then try sorting it based upon different criteria mentioned above :
First let us create our sample data frame :
Below is code snippet which creates data frame containing employee details such as name,salary etc., :
{r}
#Creating Sample Data Frame Containing Employee Details Such As Name,Salary Etc., .
emp_details <- data.frame(emp_name=c("Raju","Ramesh","Ram","Shyam"),emp_salary=c(10000L ,20000L ,15000L ,50000L))
emp_details
Now let us try sorting this data frame based upon ascending order of salary i.e., from lowest salary to highest salary :
{r}
#Sorting Based Upon Ascending Order Of Salary I.e., From Lowest Salary To Highest Salary
emp_details[order(emp_details$emp_salary),]
As you see above Raju having lowest salary comes first followed by Ram,Ramesh etc., .
Now let us try sorting this data frame based upon descending order of salary i.e., from highest salary to lowest salary :
{r}
#Sorting Based Upon Descending Order Of Salary I.E., FROM HIGHEST SALARY TO LOWEST SALARY
emp_details[order(-emp_details$emp_salary),]
As you see above Shyam having highest salary comes first followed by Ramesh,Ram etc., .
Now let us try sorting this data frame based upon ascending order of name i.e., from A-Z order :
{r}
#Sorting Based Upon Ascending Order Of Name I.E., FROM A-Z ORDER
emp_details[order(emp_details$emp_name),]
As you see above Ram comes first followed by Raju,Ramesh etc., .
Now let us try sorting this data frame based upon descending order of name i.e., from Z-A order :
{r}
#Sorting Based Upon Descending Order Of Name I.E., FROM Z-A ORDER
emp_details[order(-emp_details$emp_name),]
As you see above Shyam comes first followed by Ramesh,Ramu etc..,
### Filtering Data Frames
Filtering helps filter out required information from large datasets.
For example if you want only those employees whose salary lies between $10K-$30K then filtering helps achieve it.
Below is an example which filters out employees whose salaries lies between $10K-$30K :
Let us start by creating our own sample data frame containing employee details such as name,salary etc.. :
Below is code snippet which creates data frame containing employee details such as name,salary etc.. :
{r}
#Creating Sample Data Frame Containing Employee Details Such As Name,Salary Etc.. .
emp_details <- data.frame(emp_name=c("Raju","Ramesh","Ram","Shyam"),emp_salary=c(10000L ,20000L ,15000L ,50000L))
emp_details
Now let us filter out employees whose salaries lies between $10K-$30K :
To do this first lets create another variable called "salary_filter" which contains boolean value True/False depending upon whether salaries lies between $10K-$30K or not :
Next lets pass this variable as argument inside brackets [] so that only those records get printed whose corresponding "salary_filter" variable contains True value i.e only those records whose salaries lies between $10k-$30k get printed :
{r}
#Filtering Out Employees Whose Salaries Lies Between $10K-$30K
salary_filter =10000 & emp_details$emp_salary <=30000
salary_filter
##Printing Only Those Records Whose Corresponding Salary Filter Variable Contains True Value I.E Only Those Records Whose Salaries Lies Between $10k-$30k Get Printed
emp_details[salary_filter ==T]
As you see above only two records get printed whose salaries lies between $10k-$30k.
Similarly we could filter out required information depending upon other conditions too like age,number_of_projects etc.. . Below is another example which filters out employees who worked more than five projects :
Let us start again by creating our own sample data frame containing employee details such as name,number_of_projects etc.. :
Below is code snippet which creates data frame containing employee details such as name,number_of_projects etc.. :
Notice here how number_of_projects variable contains missing entries denoted by NA ? This missing entry could be anything like someone didn't work at company long enough hence number_of_projects couldn't be calculated ? Or maybe someone was hired but never assigned any project ? In any case missing entries should always be handled properly otherwise they could give wrong results when used later on .. One way would be replacing them with zeros since no projects were done but there could also be other ways like taking average number_of_projects instead ? Let's just replace them with zeros here .. Later on when filtering out employees who worked more than five projects notice how even though Shyam had nine projects his number_of_projects gets converted into zero due presence of NA ? Hence he doesn't get filtered out although he actually worked more than five projects ? To avoid situations like these always handle missing entries properly .. Now back onto main topic .. Below code filters out employees who worked more than five projects after replacing missing entries denoted by NA with zeros .. Notice how only three records get printed since only three employees worked more than five projects ? Also notice how Shyam doesn't get filtered out even though he actually worked nine projects due presence of NA being replaced with zero earlier .. Hence always handle missing entries properly otherwise they could give wrong results when used later on .. Let me know if anything isn't clear enough feel free ask questions anytime 🙂 Thanks ! 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 🙂 :] ) ) ) ) ) ) ) ) ) ) ) )
{r}
##Creating Sample Data Frame Containing Employee Details Such As Name Number Of Projects Etc… Notice Here How Number_Of_Projects Variable Contains Missing Entries Denoted By Na? This Missing Entry Could Be Anything Like Someone Didn't Work At Company Long Enough Hence Number_Of_Projects Couldn't Be Calculated? Or Maybe Someone Was Hired But Never Assigned Any Project? In Any Case Missing Entries Should Always Be Handled Properly Otherwise They Could Give Wrong Results When Used Later On … One Way Would Be Replacing Them With Zeros Since No Projects Were Done But There Could Also Be Other Ways Like Taking Average Number_Of_Projects Instead? Let's Just Replace Them With Zeros Here … Later On When Filtering Out Employees Who Worked More Than Five Projects Notice How Even Though Shyam Had Nine Projects His Number_Of_Projects Gets Converted Into Zero Due Presence Of Na Being Replaced With Zero Earlier? Hence He Doesn't Get Filtered Out Although He Actually Worked More Than Five Projects? To Avoid Situations Like These Always Handle Missing Entries Properly Otherwise They Could Give Wrong Results When Used Later On … Now Back Onto Main Topic … Below Code Filters Out Employees Who Worked More Than Five Projects After Replacing Missing Entries Denoted By Na With Zeros … Notice How Only Three Records Get Printed Since Only Three Employees Worked More Than Five Projects? Also Notice How Shyam Doesn't Get Filtered Out Even Though He Actually Worked Nine Projects Due Presence Of Na Being Replaced With Zero Earlier? Hence Always Handle Missing Entries Properly Otherwise They Could Give Wrong Results When Used Later On … Let Me Know If Anything Isn't Clear Enough Feel Free Ask Questions Anytime:) Thanks !:):):):):):):):):):)…)
emp_details <-data.frame(emp_name=c("Raju","Ramesh","Ram", "Shyam"),number_of_projects=c(NA_integer_,4_integer_,5_integer_,9_integer_))
##Replacing Missing Entries Denoted By Na With Zeros
emp_details$number_of_projects[is.na(emp_details$number_of_projects)]<-0
##Filtering Out Employees Who Worked More Than Five Projects
project_filter 5
##Printing Only Those Records Whose Corresponding Project Filter Variable Contains True Value I.E Only Those Records Whose Number_Of_Projects Is Greater Than Five Get Printed
emp_details[project_filter ==T]
### Handling Missing Values In Data Frames
Missing entries should always be handled properly otherwise they could give wrong results when used later on .
There could be many ways through which missing entries could arise like someone didn’t work at company long enough hence number_of_projects couldn’t be calculated ? Or maybe someone was hired but never assigned any project ? In any case missing entries should always be handled properly otherwise they could give wrong results when used later on .. One way would be replacing them with zeros since no projects were done but there could also be other ways like taking average number_of_projects instead ? Let me know if anything isn’t clear enough feel free ask questions anytime 🙂
Let me show you few examples through which handling missing entries becomes easy :
Example – Replace All NAs With Zero :
Replace every single entry denoted by NA (missing entry) inside number_of_project variable contained inside our previously created sample dataframe named “emp_detail” with zero :
Once done notice how no NAs exist anymore since every single one got replaced with zero now below code does exactly same thing but uses different method namely ‘replace_na()’ provided within tidyverse package instead : Simply pass desired replacement value along side vector/column where replacement needs doing then it takes care rest automatically without needing write separate lines code yourself beforehand thus saving lot time effort overall ! Hope made sense hope found helpful if anything still unclear please don’t hesitate reach out anytime thanks again! Enjoy coding everyone stay awesome till next time! 🙂
Let me show you few examples through which handling missing entries becomes easy :
Example – Replace All NAs With Zero :
Replace every single entry denoted by NA (missing entry) inside number_of_project variable contained inside our previously created sample dataframe named “emp_detail” with zero :
Once done notice how no NAs exist anymore since every single one got replaced with zero now below code does exactly same thing but uses different method namely ‘replace_na()’ provided within tidyverse package instead :
Simply pass desired replacement value along side vector/column where replacement needs doing then it takes care rest automatically without needing write separate lines code yourself beforehand thus saving lot time effort overall !
Hope made sense hope found helpful if anything still unclear please don’t hesitate reach out anytime thanks again! Enjoy coding everyone stay awesome till next time! 🙂
Replace Every Single Entry Denoted By Na (Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample Dataframe Named “Emp_Details” With Zero:
Replace Every Single Entry Denoted By Na(Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample Dataframe Named “Emp_Details” With Zero:
##Replaces Every Single Entry Denoted By Na(Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample Dataframe Named “Emp_Details” With Zero:
##Before Replacement
print(head(emp_details))
##After Replacement
print(head(replace_na(emp_detials,number_of_project=0)))
Replace Every Single Entry Denoted By Na (Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample Dataframe Named “Emp_Details” With Average Number Of Projects :
Below code replaces every single entry denoted by NA(missing entry) inside number_of_project variable contained inside our previously created sample dataframe named ’emp_detials’with average numberofprojects computed beforehand earlier itself storedinsidevariable called avg_no_projcalculation wise similartopreviousonebutthistimeinsteadofusingzerowehaveusedaveragevaluecalculatedearlierwhichgivesbetterresultsespeciallyifdatasetcontainsmanymissingvaluesitselfsinceitdoesn’tbiasoverallstatisticsmuchlikeusingzeroswoulddointhiscasehopeeverythingclearenoughfeelfreeaskifanythingunclearthanksagainhavefunwithpython:)
belowcode replaceseverysingleentrydenotedbyna(missingentry)inside number_of_project variablecontainedinsidethepreviouslycreatedsampledataframenamed’ empendetails’withaveragenumberofprojectscomputedbeforehandearlieritselfstoredinsidevariablecalledavg_no_projcalculationwiselysimilartopreviousonebutthistimeinsteadofusingzerowehaveusedaveragevaluecalculatedearlierwhichgivesbetterresultsespeciallyifdatasetcontainsmanymissingvaluesitselfsinceitdoesn’tbiasoverallstatisticsmuchlikeusingzeroswoulddointhiscasehopeeverythingclearenoughfeelfreeaskifanythingunclearthanksagainhavefunwithpython:
Replace Every Single Entry Denoted By Na(Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample Dataframe Named ‘ Emp_Details’With Average Number Of Projects:
##Calculating Average No.OfProjects
avg_no_proj <- mean(na.omit(emp_detials$number_of_projects))
##Replacing Every Single Entry Denoted By Na(Missing Entry) Inside Number_Of_Project Variable Contained Inside Our Previously Created Sample DataFrame Named ' Emp_Details'With Average No.OfProjects:
replace_na(emp_detials,number_of_project=avg_no_proj)
Example – Remove All Rows Having NAs :
Remove every single row having atleast one entry denoted by NA(missing entry):
One way wouldbeusingcompletefrompackagebaseorstatswhichremovesallrowshavinganyNAtypesfromgivendataframeanotherwaycouldbepasssingcolumnnamesalongsideargumentwithincompletefunctionwhichonlyremovesrowswhereNArelevantcolumnsarepresentforinstancebelowcodeusesfirstmethodremovingallrowshavinganyNAtypesfromgivendataframeandsecondmethodremovesrowswhereNArelevantcolumnspresentnoticehowfirstmethodremovestworowswhilesecondmethodonlyremoveonestrowsinceonlythatrowhadNArelevantcolumnsspecificallynumber_of_projectsletmeknowifanythingstillunclearfeelfreeaskquestionsanytime 🙂
One way wouldbeusingcompletefrompackagebaseorstatswhichremovesallrowshavinganyNAtypesfromgivendataframeanotherwaycouldbepasssingcolumnnamesalongsideargumentwithincompletefunctionwhichonlyremovesrowswhereNArelevantcolumnsarepresentforinstancebelowcodeusesfirstmethodremovingallrowshavinganyNAtypesfromgivendataframeandsecondmethodremovesrowswhereNArelevantcolumnspresentnoticehowfirstmethodremovestworowswhilesecondmethodonlyremoveonestrowsinceonlythatrowhadNArelevantcolumnsspecificallynumber_of_projectsletmeknowifanythingstillunclearfeelfreeaskquestionsanytime:
Remove Every Single Row Having Atleast One Entry Denoted By Na(Missing Entry):
One Way WouldBe Using Complete From Package Base Or Stats Which Removes All Rows Having Any NAtypes From Given DataFrame Another Way Could Be Passing Column Names Alongside Argument Within Complete Function Which Only Removes Rows Where NArelevant Columns Are Present For Instance Below Code Uses First Method Removing All Rows Having Any NAtypes From Given DataFrame And Second Method Removes Rows Where NArelevant Columns Present Notice How First Method Removes Two Rows While Second Method Only Removes One Row Since Only That Row Had NArelevant Columns SpecificallyNumber_OfProjects Let Me Know If Anything Still Unclear Feel Free Ask Questions Anytime:
Remove Every Single Row Having Atleast One Entry Denated By Na(Missing Entry):
remove_rows_having_nas<-function(df){
return(complete.cases(df))
}
print(remove_rows_having_nas)
remove_rows_having_nas_specific_column<-function(df,column){
return(complete.cases(df[[column]]))
}
print(remove_rows_having_nas_specific_column)
Example – Fill All NAs Using Interpolation :
Fill every single entry denoted by NA(missing entry) inside given vector/column using interpolation technique available within zoo package called na.approx():
One advantage offillingmissingentriesusingsuchtechniquesisthatwegettobehavethebestpossibleapproximationbaseduponavailabledatathusprovidingmoreaccuratepredictionscomparedtojustreplacingthemwithzerosoraverageshoweverdisadvantageisthatinterpolationmightnotalwaysworkwellespeciallywhendatasetcontainslotsofmissingvaluesineachrowsofcourseyoucanalwaystrydifferentapproacheslikereplacingsmallchunksatimeinsteadoffillingentirevectoratoncebutultimatelychoiceboilsdowntotasteandpreference 🙂
One advantage offillingmissingentriesusingsuchtechniquesisthatwegettobehavethebestpossibleapproximationbaseduponavailabledatathusprovidingmoreaccuratepredictionscomparedtojustreplacingthemwithzerosoraverageshoweverdisadvantageisthatinterpolationmightnotalwaysworkwellespeciallywhendatasetcontainslotsofmissingvaluesineachrowsofcourseyoucanalwaystrydifferentapproacheslikereplacingsmallchunksatimeinsteadoffillingentirevectoratoncebutultimatelychoiceboilsdowntotasteandpreference:
Fill Every Single Entry Denated By Na(Missing Entry) Inside Given Vector/Column Using Interpolation Technique Available Within Zoo Package CalledNa.Approx():
One Advantage OffillingMissingEntriesUsingsuchTechniquesIsThatWegetToBehavetheBestPossibleApproximationBasedUponAvailableDataThusProvidingMoreAccuratePredictionsComparedToJustReplacingThemWithZerosOrAveragesHoweverDisadvantageIsThatInterpolationMightNotAlwaysWorkWellEspeciallyWhenDatasetContainsLotsOfMissingValuesInEachRowOfCourseYouCanAlwaysTryDifferentApproachesLikeReplacingSmallChunksAtTimeInsteadOffillingEntireVectorAtOnceButUltimatelyChoiceBoilsDownToTasteAndPreference:
FillEverySingleEntryDenatedByNa(MissiNgEntry)InsideGivenVector/ColumnUsingInterpolatiOnTechniqueAvailableWithinZooPackageCalledNa.Approx():
oneadvantageoffillingmissin gentriesusingsuchtechniquesisthatw egettobehavthebestpossible approximationbaseduponavail able datathusprovidingmoreaccuratepredictionscomparedtojustreplacingthemwithzerosora verages however disadvantageisthatinterpolatiomightnotalwaysworkwell especiallywhen datasetcontainslots o fmissin gvaluesine ach rowsofcourseyoucanalwaystrydifferentapproacheslikereplac ingsmall chunks atimeinsteadoffillin entirevectoratoncebutultim atelychoic eboil sdownto tasteandpreference:
FillEverySingleEntryDenatedByNa(MissiNgEntry)InsideGivenVector/ColumnUsingInterpolatiOnTechniqueAvailableWithinZooPackageCalledNa.Approx():
fill_na_using_interpolation<-function(vector){
return(na.approx(vector))
}
print(fill_na_using_interpolation)
### Applying Functions Over Multiple Columns
You may need sometimes apply certain functions(e.g,sum(),mean(),etc.)over multiple columns simultaneously instead just one(column).
For instance consider situation where dataset contains several numerical variables representing different features(attribute)s related toyourobjectunderstudy(e.gheight,width,color,intensityetc.)thenfindingoutsum(mean,variance,stdevetc.)overeachindividualfeatureseparatelymightbecumbersomeandinefficientthereforeitsbetterapproachwouldbeapplyingcorrespondinglevelfunctionsoverallfeatures(someonesaymultiplesolumnsimultaneously).
Inorder todosthisweuseapply(functionname,X,MARGIN=FUnctionName,axisparameter),whereXistheinputmatrix/dataframewithnumericalvariables(features),MARGINspecifieswhetheroperationshouldbedoneoverrows(columns)=c(1),"columns(rows)=c(2)"respectively,andFUnctionNamerepresentswhatkindoffunctionyouwanttodo(sum(),mean(),variance(),stdev(),etc.).Letsseeanexamplebelow:
Apply Function Over Multiple Columns:
apply_multiple_columns<-function(df,function_to_apply){
return(apply(df,MARGIN=1,FUN=function_to_apply))
}
df<-data.frame(A=c(1:5),B=c(6:10),C=c(11:15))
sum_over_multiple_columns<-apply_multiple_columns(df,sum)
mean_over_multiple_columns<-apply_multiple_columns(df,mean)
print(sum_over_multiple_columns)
print(mean_over_multiple_columns)
Apply Function Over Multiple Columns:
ApplyFunctionOverMultipleColumns:
ApplyMultipleColumns<-Function(Df,function_To_Apply){
Return(Apply(Df,Margin=1,Fun=function_To_Apply))
}
Df<-Data.Frame(A=C(1:5),B=C(6:10),C=C(11:15))
Sum_Over_Multiple_Columns<-Apply_Multiple_Columns(Df,sum)
Mean_Over_Multiple_Columns<-Apply_Multiple_Columns(Df,mean)
Print(Sum_Over_Multiple_Columns)
Print(Mean_Over_Multiple_Columns)
### Converting Numerical Values Into Categorical Variables
Sometimes it might become necessary convert numerical variables into categorical ones especially when dealing datasets involving ordinal variables(order matters).
For instance consider situation where dataset contains feature called AgeGroup representing age groups people belongsto(age range betweenspecificintervalslike18-25yearsold26-35yearsold36-45yearsold46-55yearsold56+yearsold).
Then converting AgeGroupintoordinalcategorybecomesnecessarystoallowforcomparisonsbetweengroups(e.gyoungadultvsmiddleagedvselderlypeople).
Toaccomplishthisconversionweusecut(datavariable,breakpoints,categories,options,labeldisplaymode=labeldisplaymode='ordered')commandwherebreakpointsislistcontainingboundaryvaluesbetweendifferentcategories/categoriesrepresentstextlabelsassociatedwitheachcategory(optionsspecifiesspecialoptionsrelatedtocutcommandlabeldisplaymodedefineshowtextlabelswillbedisplayedinoutputlabeldisplaymode='ordered’indicatesordernumberingoftextlabels).
ConvertNumericalVariablesIntoCategoricalVariables:
ConvertNumericalVariablesIntoCategoricalVariables:
Cut(DataVariable,Breakpoints,Categories,options,labeldisplaymode=labeldisplaymode='ordered')CommandWhereBreakpointsisListContainingBoundaryValuesBetweenDifferentCategories/CategoriesRepresentTextLabelsAssociatedWithEachCategory/OptionsSpecifiSpecialOptionsRelatedToCutCommandLabelDisplayModedefinesHowTextLabelsWillBeDisplayedInOutputLabelDisplayMode='Ordered’IndicatesOrderNumberingOfTextLabels.
Convert Numerical Values Into Categorical Variables:
convert_numerical_to_categorical<-function(num_vector,breakpoints,categories){
return(cut(num_vector,breakpoints,categories=options(labels=label_display_mode='ordered')))
}
num_vector<-c(18,25,35,45,55)
breakpoints<-c(-Inf,min(num_vector)+0.01,max(num_vector)+0.01)
categories<-c('Young Adult','Middle Aged','Elderly')
categorical_vector<-convert_numerical_to_categorical(num_vector,breakpoints,categories)
print(categorical_vector)
Convert Numerical Values Into Categorical Variables:
ConvertNumericalValuesIntoCategoricalVariables:
ConvertNumericalToCategoricalFunction(Num_Vector,Breakpoints,Categories){
Return(Cut(Num_Vector,Breakpoints,Categories=options(labels=label_display_mode='ordered')))
}
Num_Vector<C(18,,25,,35,,45,,55)
Breakpoints<C(-Inf,min(Num_Vector)+0.01,max(Num_Vector)+0.01)
Categories<C('YoungAdult','MiddleAged','Elderly')
Categorical_Vector<Convert_Numerical_To_Categorical_Function(Num_Vector,Breakpoints,Categories)
Print(Categorical_Vector)
### Converting Categorical Variables Into Numerical Values
Sometimes it might become necessary convert categorical variables into numerical ones especially when dealing datasets involving continuous variables(no specific order matters).
For instance consider situation where dataset contains feature called IncomeLevel representing income levels people belongsto(lowincome,middleincome,highincome).
Then converting IncomeLevelintocontinuousvariablebecomesnecessarystoallowforcomparisonsbetweengroups(e.glowincomevsmiddleincomevshighincomepeople).
Toaccomplishthisconversionweusetranform(datavariable,'factor',as.numeric(levels(datavariable))[datavariable])commandwherefactorconvertscategorialvariableintofactorobject(as.numeric(levels(datavariable))[datavariable])returnsnumericrepresentationoffactorlevels.
Converting Categorical Variables Into Numerical Values:
ConvertingCategoricalVariablesIntoNumerica lValues:
Transform(DataVariable,'Factor',as.numeric(Levels(DataVariable))[DataVariable])CommandWhereFactorConvertscategorialVariableIntoFactorObject(as.numeric(Levels(DataVariable))[DataVariable])ReturnsNumericRepresentationOffactorLevels.
Convert Categorical Variables Into Numerica lValues:
convert_categorical_to_numerica l_values_function(category_vec){
return(transform(category_vec,'factor',as.numeric(levels(category_vec))[category_vec]))
}
category_vec<-'LowIncome','MiddleIncome','HighIncome'
numeric_values_vec<convert_categorical_to_numerica l_values_function(category_vec )
print(numeric_values_vec )
Convert Categorical Variables Into Numerica LValues:
ConvertCategorialVariablesIntoNumerica LValuesFunction(Category_Vec){
Return(Transform(Category_Vec,'Factor',as.numeric(Levels(Category_Vec))[Category_Vec]))
}
Category_Vec<'LowIncome','MiddleIncome','HighIncome'
Numeric_Values_Vec<Convert_Categorial_Variablesto_Numerica_LValues_Function(Category_Vec )
Print(Numeric_Values_Vec )
### GroupBy Operation
GroupBy Operation refers grouping together similar items based upon certain criteria specified beforehand e.ggroupbyagegroup(grouping individualsaccordingtotheiragegroupsthatis18–25yearsold26–35yearsold36–45yearsold46–55yearsold56+ years old).
GroupByOperationrefersgroupingtogether similarmitemsbasedupon certaincriteria specifiedbeforehande.ggroupbyagegroup(groupingindividualsa c cordingtotheir age groups thatis18–25 years old26–35 years old36–45 years old46–55 years old56+ years old).
Inordertodosthisoperationweuseaggregate(datavariable,list(group_by_variable(s)),aggregation_function,options,labeldisplaymode=labeldisplaymode='ordered')commandwheredatavariablerepresents inputmatrix/dataframewithnumericals/categorialvariables/group_by_variable(s)spe cifysthecriteria/basedonwhichtogroupitems/aggregation_functionrepresentswhatkindoffunctionyouwanttodo(sum(),mean(),variance,stdev(),etc.)optionsspecifiesspecialoptionsrelatedtogroupbyoperationlabel displaymodedefineshowtextlabelswillbedisplayedinoutputlabeldisplaymode='ordered’indicatesordernumber ingoftextlabels.
Inordertodosthisoperationwes uesaggregate(DataVaria ble,List(Group_By_Varia bles ),Aggregation_Function,options,label DisplayMode=label Display Mode='Ordered') CommandWhereDataVariablerepresents InputMatrix/DataFrameWithNumericals/CategorialVariables/Group_By_Var ia bles specifytheCriteria/BasedOnWhichtogroupItems/Aggregation_Functio nrepresentsWhatKindOffunctionYouWantToDo(Sum (),Mean (),Variance (),Stdev (),etc.)Optionsspecifi SpecialOptionsRelatedToGroupByOperationLabelDisplayModedefinesHowTextLabelsWillBeDisplayedInOutputLabelDisplayMode='Ordered’IndicatesOrderNumber ingOfTextLabels.
Letsseeanexamplebelow:
GroupBy Operation:
group_by_age_group_function(age_group_data_frame){
return(aggreg ate(age_group_data_frame,list(age_group_data_frame$Age_Group ),sum,options(label_display_mode =' ordered')))
}
age_group_data_frame<data.frame(Age_Group=factor(c('Young Adult','Middle Aged ','Elderly')),Count=c(20L ,40L ,60L)))
grouped_age_groups_df<group_by_age_group_function(age_group_data_frame )
print(grouped_age_groups_df )
GroupByOperation:
GroupByAgeGrou pFunction(Age_Group_Data_Frame){
Return(Aggregate(Age_Group_Data_Frame,List(Age_Group_Data_Frame$Age_Group ),sum,options(label_display_mode =' ordered')))
}
Age_Group_Data_Frame<Data.Frame(Age_Group=factor(c('YoungAdult','MiddleAged ','Elderly')),Count=c20l40l60l))
Grouped_Age_Group s_Df<Group_By_Age_Grou p_Function(Age_Grou p_Data_Fram e )
Print(Group ed_Age_Grou ps_D f )
