Lägg till, ta bort och byt namn på kolumner i R med hjälp av Dplyr

dplyr är ett populärt R-paket för datamanipulering, vilket gör det lättare för användare att arbeta med dataramar. En vanlig uppgift när man arbetar med data är att byta namn på kolumner, som dplyr hanterar effektivt med funktionen rename().

Funktionen rename() i dplyr är särskilt användbar när man hanterar datauppsättningar som har kolumner med oklara eller tvetydiga namn. Genom att tillhandahålla en enkel och intuitiv syntax för att byta namn på kolumner, gör dplyr det lättare för användare att förstå och underhålla sin kod.

Dessutom kan den här funktionen enkelt kombineras med andra dplyr-operationer, såsom filtrering och sammanfattning, för att skapa ett sömlöst arbetsflöde för datamanipulation i R.

Dessa funktioner är också tillgängliga i , så de är inte unika för R-programmet. R är dock bättre på att hantera dem.

I följande artikel kommer vi att utforska detaljerna om dplyrs rename()-funktion och dess olika applikationer, vilket exemplifierar hur effektiv den kan vara för att hantera dataramar.

Vi kommer också att lära oss hur man lägger till och tar bort kolumner i R med hjälp av dyplr.

Genom att lära sig dessa tekniker kan användare förbättra det praktiska i sina datamanipuleringsinsatser, producera mer robusta och felfria analyser och ha kul på v��gen!

Låt oss gå in på lite datavetenskap, det är dags att tulla, eller ska vi säga, ta med basen R!

Innehållsförteckning

• Förstå Dplyr Rename
• Installera och ladda Dplyr
• Använda Dplyr Rename-funktionen
  • Grundläggande syntax
  • Byta namn på flera kolumner
  • Kedja med andra Dplyr-funktioner
• Vanliga Dplyr Rename Use Cases
• Hantering av fel och kantfall
• Ytterligare exempel från den verkliga världen - Lägga till, ta bort och byta namn på kolumner
• Grundläggande funktioner för kolumnoperationer
  • 1. Lägg till nya kolumner i R
  • 2. Välj kolumner i R
  • 3. Byt namn på kolumner i R
• Det sista ordet
• Vanliga frågor
  • Vad är skillnaden mellan R och Python?
  • Vad är str?
  • Vad är Petal.Length i R?
  • Vad är en DataFrame i R?
  • Vad står dbl för?

Förstå Dplyr Rename

dplyr-paketet i R är ett populärt tidyverse -paket för datamanipulering som erbjuder en uppsättning användbara funktioner för att transformera och organisera datamängder. Bland dessa funktioner är rename()-funktionen särskilt praktisk när det gäller att ändra kolumnnamn i en dataram.

För att använda funktionen rename() anger du helt enkelt det nya kolumnnamnet följt av det gamla, så här: new_name = old_name. Låt oss till exempel överväga en exempeldataram där vi vill ändra kolumnnamnet "gammal1" till "ny1". Syntaxen skulle se ut så här:

library(dplyr)
df %>% rename(new1 = old1)

Dessutom låter funktionen rename_with() dig byta namn på kolumner med en specificerad transformationsfunktion. Till exempel kan du använda den övre funktionen för att konvertera alla kolumnnamn till versaler:

df %>% rename_with(toupper)

Om du behöver byta namn på flera kolumner samtidigt, erbjuder dplyr två metoder. Den första innebär att du använder funktionen rename() och tillhandahåller flera nya och gamla kolumnnamn som argument:

df %>% rename(new1 = old1, new2 = old2)

Den andra metoden innebär att du använder funktionen rename_with() där du definierar matriser med gamla och nya kolumnnamn:

new <- c('new1',="" 'new2')="" old=""><- c('old1',="" 'old2')="" df="" %="">% rename_with(~ new, all_of(old))

Båda metoderna, som visas i exemplen ovan, ger samma resultat.

Installera och ladda Dplyr

För att börja använda dplyr-paketet för att byta namn på kolumner måste du först installera och ladda paketet i din R-miljö. Att installera dplyr är en enkel process som kan utföras med följande kommando:

install.packages("dplyr")

När installationen är klar kan du ladda dplyr-paketet i ditt R-skript med hjälp av biblioteksfunktionen:

library("dplyr")

Med dplyr-paketet installerat och laddat kan du nu använda dess kraftfulla datamanipuleringsfunktioner, inklusive funktionen rename() för att byta namn på kolumner i din dataram.

Här är ett exempel på att använda rename()-funktionen med den välkända irisdatauppsättningen. Anta att du vill byta namn på kolumnen "Sepal.Length" till "sepal_length". Du kan uppnå detta med följande kod:

iris_renamed <- iris="" %="">%
  rename(sepal_length = Sepal.Length)

I det här kodavsnittet används operatorn %>% för att överföra irisdatauppsättningen till rename()-funktionen. Det nya kolumnnamnet "sepal_length" tilldelas det gamla kolumnnamnet "Sepal.Length". Den resulterande dataramen med den omdöpta kolumnen tilldelas sedan variabelnamnen, iris_renamed.

Funktionen rename() kan också hantera flera kolumner som byter namn på en gång. Om du till exempel vill byta namn på kolumnerna "Sepal.Length" och "Sepal.Width" till "sepal_length" respektive "sepal_width", kan du använda följande kod:

iris_renamed <- iris="" %="">%
  rename(
    sepal_length = Sepal.Length,
    sepal_width = Sepal.Width
  )

Det här kodavsnittet visar hur enkelt det är att byta namn på flera kolumner i en dataram med hjälp av dplyrs rename()-funktion.

Använda Dplyr Rename-funktionen

Paketet dplyr i R är ett kraftfullt verktyg för datamanipulation när man arbetar med dataramar. En av de många användbara funktioner den tillhandahåller är funktionen för att ändra namn, som gör att du enkelt kan byta namn på kolumner i din dataram.

Grundläggande syntax

Den grundläggande syntaxen för att använda rename-funktionen i dplyr är följande:

library(dplyr)
your_dataframe %>% rename(new_column_name = old_column_name)

Detta kommando kommer att byta namn på den angivna gamla kolumnen till det önskade nya kolumnnamnet, utan att ändra några andra kolumner i dataramen.

Byta namn på flera kolumner

Du kan också byta namn på flera kolumner samtidigt med samma namnbytefunktion. För att göra detta, separera bara varje kolumn genom att byta namn på paret med ett kommatecken:

your_dataframe %>%
   rename(new_column1 = old_column1,
          new_column2 = old_column2,
          new_column3 = old_column3)

Med detta tillvägagångssätt kan du byta namn på så många kolumner som behövs i en enda sats.

Alternativt kan du använda rename_with()funktionen för att tillämpa en transformation på kolumnnamn. Denna funktion tar en dataram och en funktion som kommer att tillämpas på kolumnnamnen för att generera de nya namnen. Till exempel:

your_dataframe %>%
  rename_with(.cols = c("old_column1", "old_column2"), .fn = toupper)

Detta kommer att konvertera de angivna kolumnnamnen till versaler.

Kedja med andra Dplyr-funktioner

En av styrkorna med dplyr är dess förmåga att koppla ihop flera åtgärder med hjälp av %>%operatören. Detta gör att du kan utföra en rad datamanipulationer på ett kortfattat och lättläst sätt. När du använder funktionen för att byta namn kan du koppla den ihop med andra dplyr-funktioner som , filter(), mutate()och summarize():

your_dataframe %>%
  filter(some_condition) %>%
  rename(new_column_name = old_column_name) %>%
  mutate(new_column = some_expression) %>%
  summarize(some_aggregation)

Det här exemplet visar en serie datamanipulationer där datafiltrering görs först, följt av att byta namn på en kolumn, skapa en ny kolumn med mutate och slutligen sammanfatta data med en aggregeringsfunktion.

Genom att utnyttja kraften i dplyrs namnbytefunktion och kedjefunktioner kan R-användare utföra effektiva och läsbara datamanipulationer på sina dataramar.

Vanliga Dplyr Rename Use Cases

Dplyr är ett kraftfullt paket i R som tillhandahåller en uppsättning funktioner för att utföra datamanipuleringsuppgifter. En vanlig uppgift är att byta namn på kolumner i en dataram. I det här avsnittet kommer vi att diskutera några vanliga användningsfall för byta namn på funktionen i dplyr.

1. Enkel kolumnbyte:

Att byta namn på en enskild kolumn är enkelt med rename()funktionen. Syntaxen är rename(dataframe, new_name = old_name). Här är ett exempel:

library(dplyr)
dataframe <- dataframe="" %="">% rename(new_column_name = old_column_name)

2. Byt namn på flera kolumner:

Du kan också byta namn på flera kolumner i ett funktionsanrop genom att tillhandahålla ytterligare kolumnmappning inuti rename()funktionen. Här är ett exempel:

dataframe <- dataframe="" %="">%
  rename(new_col_name1 = old_col_name1,
         new_col_name2 = old_col_name2)

3. Byt namn på kolumner med strängfunktioner:

Du kan byta namn på kolumner med strängfunktioner, till exempel tolower()eller toupper(), genom att använda rename_with()funktionen. Enligt Stack Overflow ersätter denna funktion de nu ersatta , rename_ifoch rename_at- rename_allfunktionerna. Här är ett exempel:

dataframe <- dataframe="" %="">%
  rename_with(tolower)  # Converts column names to lowercase

4. Byt namn på kolumner baserat på ett villkor:

Med rename_with()kan du använda anpassade döpningsfunktioner och till och med användningsvillkor. Följande exempel visar byte av kolumner baserat på om de innehåller en viss sträng:

rename_function <- function(x)="" {="" if="" (grepl("length",="" x))="" {="" return(paste0(x,="" "_length"))="" }="" else="" {="" return(paste0(x,="" "_default"))="" }="" }="" dataframe=""><- dataframe="" %="">% rename_with(rename_function)

Hantering av fel och kantfall

När du använder funktionen dplyr rename för att ändra kolumnnamn i en dataram kan du stöta på vissa fel eller kantfall på grund av dubbletter av kolumnnamn, mellanslag i kolumnnamn eller felaktig syntax. Det här avsnittet ger vägledning om hur man löser dessa problem.

När det gäller dubbletter av kolumnnamn kan dplyr inte byta namn på kolumnerna med samma utdatanamn. Men en lösning för att unduplicate kolumnnamn är att använda funktionen rename_allfrån dplyr-paketet tillsammans med paste0:

d %>% rename_all(~paste0(., 1:2))

Denna kod kommer att lägga till ett nummer från 1 till 2 till varje kolumnnamn, vilket säkerställer att det inte finns några dubbletter. Mer information kan hittas i denna Stack Overflow-diskussion .

Om det finns mellanslag i kolumnnamn kan du använda backticks för att omsluta kolumnnamnen så här:

df %>% rename(foo = `test col`)

Slutligen, om du stöter på problem relaterade till att dplyr inte accepterar funktionen paste0()som old_name i rename(), är en möjlig lösning att konstruera de nya kolumnnamnen utanför funktionen rename()och sedan använda dem som indata. En relevant diskussion om en liknande fråga finns i denna Stack Overflow- fråga .

Genom att ta itu med dessa fel och edge-fall blir du bättre rustad att hantera komplexa scenarier för byte av namn i dplyr.

I det här sista avsnittet av vår artikel om dplyr-byte har vi diskuterat dess betydelse i datamanipuleringsuppgifter. Rename()-funktionen tillåter användare att ändra kolumnnamn effektivt, vilket leder till tydligare och mer koncisa dataramar. Detta blir särskilt användbart när man hanterar stora datamängder eller under dataförbehandlingssteg.

Genom att använda dplyr-paketet är det enkelt att byta namn på kolumner i R, det är inte svårt datavetenskap, kolla in nedan:

  rename(new_column_name = old_column_name)

Denna enkla syntax låter dig ersätta gamla kolumnnamn med nya, vilket förbättrar läsbarheten och säkerställer konsistens i dina data. Dessutom kan funktionen rename_with() användas för att ändra kolumnnamn med en specifik funktion. Detta ger större kontroll och anpassning av dina datamanipulationer.

Genom att utnyttja kraften i dplyr och byta namn-funktionen kan du med säkerhet manipulera dina data och förbättra den övergripande databehandlingskapaciteten. Kom ihåg att alltid använda tillförlitliga källor när du lär dig nya R-programmeringstekniker, som t.ex

Med dplyr rename i din verktygslåda är du väl rustad att ta itu med en mängd olika datamanipuleringsutmaningar och fortsätta att utveckla din R-programmeringsexpertis.

Ytterligare exempel från den verkliga världen - Lägga till, ta bort och byta namn på kolumner

Kolumnoperationer låter dig beräkna, lägga till, ta bort och byta namn på kolumner i R med dplyr . Öppna ett nytt R-skript i RStudio. Om du inte vet hur, klicka på länkarna för att ta reda på hur och .

För den här demonstrationen används Lahman datasetpaketet . Det här innehåller baseballrekord som går tillbaka över hundra år. Det är en bra datauppsättning att använda för övning. Du kan ladda ner den genom att göra en snabb google-sökning.

Dessutom har Lahman-paketet en datauppsättning märkt Teams , med stort T. En bästa praxis för att namnge konventioner i R är att använda gemener. Så detta måste först konverteras till lag , som visas i bilden nedan.

Grundläggande funktioner för kolumnoperationer

1. Lägg till nya kolumner i R

Den första funktionen är mutera ( ) . Detta skapar en ny kolumn baserad på befintliga kolumner.

Om du vill beräkna en ny kolumn kan du använda funktionen mutera efter argumentet:

df är ett stand-in-namn för alla typer av dataramar. Så när den faktiskt används, ersätt df med namnet på den dataram du vill mutera. Sedan placerar du de nya variablerna som måste namnges tillsammans med formeln för att härleda den nya kolumnen.

Som ett exempel kommer mutationsfunktionen att användas för att hitta vinstprocenten för varje kolumn. I Lahman-datauppsättningen finns en vinst och förlust-kolumn. För att få procentsatsen, dividera vinst med summan av vinst och förlust. Men innan du kan göra det måste du ta in dplyr-paketet.

Så här händer om du kör mutera -funktionen utan dplyr:

Du kommer att få ett felmeddelande som säger "kunde inte hitta funktion mutate".

Så här är hur du tar in dplyr till R. Du behöver bara köra library (tidyverse) .

Du kommer att se att dplyr är bland de många funktionerna i tidyverse -paketet. Ett annat alternativ är att köra library (dplyr) .

Om du nu placerar markören på koden med mutate -funktionen och kör den, kommer du att se kolumnen Wpct som innehåller de vinnande procenten.

I detta fall kördes endast resultatet av den muterade funktionen; den tilldelades inte data.

Om du vill tilldela resultatet av muteringsfunktionen till datateamen måste du använda tilldelningsoperatorn ( <-> ) . När du är klar, kör den. Sedan i en annan rad, kör huvud (lag) . Detta kommer att tilldela resultatet till teamets datauppsättning.

Om du vill kontrollera vilka kolumner som är tillgängliga i en datamängd, använd funktionen namn ( ) . Detta kommer att lista alla kolumnnamn i data.

Du kan också använda befintliga funktioner som en del av muteringsfunktionen . Du kan till exempel ta loggen för en specifik datauppsättning med funktionen logg ( ) .

2. Välj kolumner i R

En annan funktion i dplyr är select ( ) . Den antingen släpper eller väljer givna kolumner. Dess grundläggande algoritm är:

Du måste ange dataramens namn och sedan kolumnerna du vill välja.

Om du till exempel vill behålla år-ID, vinster och förlustkolumner i datamängden behöver du bara köra:

Du får då det resultat du vill ha:

Men om du inte använder funktionen head ( ) , kommer resultatet att visa de nedre raderna i kolumnerna. Så om du har att göra med flera rader med data, måste du kontinuerligt rulla uppåt för att komma till toppen av kolumnen.

En bästa praxis är att använda huvudfunktionen tillsammans med select. Så att när du kör koden kommer resultatet att visa de översta raderna i kolumnen först.

Om du nu vill ta bort kolumner från datamängden behöver du bara placera ett minustecken ( – ) före kolumnnamnet.

För att kontrollera om en kolumn verkligen har tagits bort kan du jämföra den nya datamängden från den gamla. Så här gör du:

Tilldela först R-koden med select -funktionen till ett objekt. I det här exemplet har den tilldelats teams_short . Använd funktionen ncol ( ) för att räkna antalet kolumner . Kör ncol -funktionen för både teams_short och teams .

Du kommer då att se att en kolumn togs bort från datamängden.

3. Byt namn på kolumner i R

Den sista kolumnfunktionen i dplyr är rename ( ) . Och som namnet antyder kan den byta namn på valda kolumner i R.

Detta är dess grundläggande algoritm:

Och du kommer att märka att det är lite kontraintuitivt; det nya namnet kommer först medan det gamla namnet kommer efter det. Så se till att inte blanda ihop dessa.

Som ett exempel kommer de aktuella år-ID och divID- kolumnerna att döpas om till year_id respektive division_id . Innan du kör koden, se till att tilldela detta till ett nytt objekt för att inte störa den ursprungliga datamängden.

För att kontrollera om de valda kolumnernas namn har ändrats, använd funktionen namn ( ) .

Du kommer att se att kolumnerna verkligen har bytt namn.

Har du någonsin undrat hur kraftfull R är när den används med LuckyTemplates, kolla in denna fantastiska teknik, den kommer att spara massor av tid.

Det sista ordet

Denna handledning har diskuterat tre grundläggande dplyr -funktioner som du kan använda för att utföra kolumnoperationer. Specifikt lärde du dig hur du lägger till, tar bort och byter namn på kolumner i R.

Det finns fortfarande andra funktioner som du ännu inte har utforskat. Men det är viktigt att känna till och vara bekant med mutera ( ) , välj ( ) och byt namn på ( ) eftersom de är de vanligaste.

Dessa kolumnredigeringstekniker kan också göras i Power Query. Men det är bra att ha kunskap om hur man gör detta i dplyr också. Detta kommer säkert att hjälpa dig när du går över till att analysera statistiska datamängder.

Vanliga frågor

Vad är skillnaden mellan R och Python?

Till att börja med är både R och Python programmeringsspråk, men python är mer ett allmänt bruksspråk och R är ett statistiskt programmeringsspråk. Python är ett mer vanligt använt, förståeligt och mångsidigt språk.

Vad är str?

str visar helt enkelt strukturerna för r objekt

Vad är Petal.Length i R?

Petal.length är ett format som används i hela R för att återge relationer som vi testar.

Vad är en DataFrame i R?

En R-dataram är en tabellformad datastruktur som vanligtvis används för att lagra värden för alla typer av data.

Vad står dbl för?

Dbl står för "dubbelklass" det är en datatyp som används för att hålla numeriska värden som innehåller decimaler.