Home-theater-designers
Bilang isang data analyst, madalas mong haharapin ang pangangailangang pagsamahin ang maraming dataset. Kakailanganin mong gawin ito para makumpleto ang iyong pagsusuri at magkaroon ng konklusyon para sa iyong negosyo/mga stakeholder.
kung paano i-install ang mac os mula sa usb
Madalas na mahirap na katawanin ang data kapag naka-store ito sa iba't ibang talahanayan. Sa ganitong mga sitwasyon, ang mga pagsali ay nagpapatunay ng kanilang halaga, anuman ang programming language na iyong ginagawa.
MAKEUSEOF VIDEO OF THE DAY
Ang mga pagsali sa Python ay parang mga pagsali sa SQL: pinagsasama nila ang mga set ng data sa pamamagitan ng pagtutugma ng kanilang mga hilera sa isang karaniwang index.
Lumikha ng Dalawang DataFrame para sa Sanggunian
Upang sundin ang mga halimbawa sa gabay na ito, maaari kang lumikha ng dalawang sample na DataFrame. Gamitin ang sumusunod na code upang gawin ang unang DataFrame, na naglalaman ng ID, pangalan, at apelyido.
import pandas as pd
a = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"],
"Fname": ["Ron", "John", "Helen", "Jenny", "Kenny"],
"Lname": ["Keith", "Harley", "Smith", "Kerr-Hislop", "Barber"]})
print(a)Para sa unang hakbang, i-import ang mga panda aklatan. Maaari kang gumamit ng variable, a , upang iimbak ang resulta mula sa tagabuo ng DataFrame. Ipasa sa constructor ang isang diksyunaryo na naglalaman ng iyong mga kinakailangang halaga.
Panghuli, ipakita ang mga nilalaman ng halaga ng DataFrame na may function ng pag-print, upang suriin ang hitsura ng lahat tulad ng iyong inaasahan.
Katulad nito, maaari kang lumikha ng isa pang DataFrame, b , na naglalaman ng ID at mga halaga ng suweldo.
b = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"],
"Salary": [100000, 700000, 80000, 904750, 604772]})
print(b)Maaari mong suriin ang output sa isang console o isang IDE. Dapat nitong kumpirmahin ang mga nilalaman ng iyong DataFrames:
Paano Naiiba ang Joins Mula sa Merge Function sa Python?
Ang pandas library ay isa sa mga pangunahing aklatan na magagamit mo upang manipulahin ang DataFrames. Dahil ang DataFrames ay naglalaman ng maraming set ng data, ang iba't ibang mga function ay magagamit sa Python upang sumali sa kanila.
Nag-aalok ang Python ng mga function ng pagsali at pagsamahin, bukod sa marami pang iba, na magagamit mo upang pagsamahin ang DataFrames. May malaking pagkakaiba sa pagitan ng dalawang function na ito, na dapat mong tandaan bago gamitin ang alinman.
Ang join function ay sumasali sa dalawang DataFrame batay sa kanilang mga index value. Ang Pinagsasama ng merge function ang DataFrames batay sa mga halaga ng index at mga column.
Ano ang Kailangan Mong Malaman Tungkol sa Pagsali sa Python?
Bago talakayin ang mga uri ng available na pagsali, narito ang ilang mahahalagang bagay na dapat tandaan:
- Ang mga pagsali sa SQL ay isa sa mga pinakapangunahing function at medyo katulad sa mga pagsali ni Python.
- Upang sumali sa DataFrames, maaari mong gamitin ang pandas.DataFrame.join() paraan.
- Ang default na pagsali ay gumaganap ng isang kaliwang pagsali, samantalang ang pagsasama ng function ay gumaganap ng isang panloob na pagsasama.
Ang default na syntax para sa isang pagsali sa Python ay ang mga sumusunod:
DataFrame.join(other, on=None, how='left/right/inner/outer', lsuffix='', rsuffix='',
sort=False)I-invoke ang join method sa unang DataFrame at ipasa ang pangalawang DataFrame bilang unang parameter nito, iba pa . Ang natitirang mga argumento ay:
- sa , na nagpapangalan sa isang index na sasalihan, kung mayroong higit sa isa.
- paano , alin tumutukoy sa uri ng pagsali, kabilang ang panloob, panlabas, kaliwa, at kanan.
- lsuffix , alin tumutukoy sa kaliwang suffix string ng pangalan ng iyong column.
- rsuffix , alin tumutukoy sa tamang suffix string ng pangalan ng iyong column.
- uri , alin ay isang boolean na nagpapahiwatig kung pag-uri-uriin ang magreresultang DataFrame.
Matutong Gamitin ang Iba't Ibang Uri ng Pagsali sa Python
Ang Python ay may ilang mga opsyon sa pagsali, na maaari mong i-ehersisyo, depende sa pangangailangan ng oras. Narito ang mga uri ng pagsali:
1. Kaliwang Sumali
Pinapanatili ng kaliwang pagsali ang mga halaga ng unang DataFrame habang dinadala ang mga katumbas na halaga mula sa pangalawa. Halimbawa, kung gusto mong dalhin ang mga katumbas na halaga mula sa b , maaari mong tukuyin ito bilang mga sumusunod:
c = a.join(b, how="left", lsuffix = "_left", rsuffix = "_right", sort = True)
print(c)Kapag naisakatuparan ang query, naglalaman ang output ng mga sumusunod na sanggunian ng column:
- ID_left
- Fname
- Lname
- ID_right
- suweldo
Ang pagsali na ito ay kumukuha ng unang tatlong column mula sa unang DataFrame, at ang huling dalawang column mula sa pangalawang DataFrame. Ginamit nito ang lsuffix at rsuffix mga value upang palitan ang pangalan ng mga column ng ID mula sa parehong mga dataset, na tinitiyak na ang mga resultang pangalan ng field ay natatangi.
Ang output ay ang mga sumusunod:
2. Tamang Sumali
Ang tamang pagsali ay nagpapanatili sa mga halaga ng pangalawang DataFrame na buo, habang dinadala ang mga tumutugmang halaga mula sa unang talahanayan. Halimbawa, kung gusto mong dalhin ang mga katumbas na halaga mula sa a , maaari mong tukuyin ito bilang mga sumusunod:
c = b.join(a, how="right", lsuffix = "_right", rsuffix = "_left", sort = True)
print(c)Ang output ay ang mga sumusunod:
Kung susuriin mo ang code, may ilang malinaw na pagbabago. Halimbawa, kasama sa resulta ang mga column ng pangalawang DataFrame bago ang mga mula sa unang DataFrame.
Dapat kang gumamit ng halaga ng tama para sa paano argumento upang tukuyin ang tamang pagsali. Gayundin, tandaan kung paano mo maililipat ang lsuffix at rsuffix mga halaga upang ipakita ang likas na katangian ng tamang pagsali.
Sa iyong mga regular na pagsali, maaari mong makita ang iyong sarili na gumagamit ng kaliwa, panloob at panlabas na pagsali nang mas madalas, kumpara sa kanang pagsali. Gayunpaman, ang paggamit ay ganap na nakasalalay sa iyong mga kinakailangan sa data.
3. Inner Join
Ang panloob na pagsali ay naghahatid ng magkatugmang mga entry mula sa parehong DataFrames. Dahil ginagamit ng mga pagsali ang mga index na numero upang tumugma sa mga row, ang panloob na pagsasama ay nagbabalik lamang ng mga row na tumutugma. Para sa paglalarawang ito, gamitin natin ang sumusunod na dalawang DataFrame:
bakit hindi kinikilala ng aking computer ang aking telepono
a = pd.DataFrame({"ID": ["001", "002", "003", "004", "005", "006", "007"],
"Fname": ["Ron", "John", "Helen", "Jenny", "Kenny", "Daryl", "Cathy"],
"Lname": ["Keith", "Harley", "Smith", "Kerr-Hislop", "Barber", "Hooper", "Hope"]})
b = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"],
"Salary": [100000, 700000, 80000, 904750, 604772]})
print(a)
print(b)Ang output ay ang mga sumusunod:
Maaari kang gumamit ng panloob na pagsali, tulad ng sumusunod:
c = a.join(b, lsuffix="_left", rsuffix="_right", how='inner')
print(c)Ang resultang output ay naglalaman lamang ng mga row na umiiral sa parehong input DataFrames:
4. Outer Joint
Ang isang panlabas na pagsali ay nagbabalik ng lahat ng mga halaga mula sa parehong DataFrames. Para sa mga row na walang tugmang value, gumagawa ito ng null value sa mga indibidwal na cell.
Gamit ang parehong DataFrame tulad ng nasa itaas, narito ang code para sa panlabas na pagsali:
c = a.join(b, lsuffix="_left", rsuffix="_right", how='outer')
print(c)
Paggamit ng Joins sa Python
Ang mga pagsali, tulad ng kanilang mga katapat na function, merge at concat, ay nag-aalok ng higit pa sa isang simpleng pag-andar ng pagsali. Dahil sa serye ng mga opsyon at function nito, maaari mong piliin ang mga opsyon na nakakatugon sa iyong mga kinakailangan.
Madali mong mapag-uri-uriin ang mga nagreresultang dataset, mayroon man o wala ang join function, gamit ang mga flexible na opsyon na inaalok ng Python.