ఉదాహరణ 1: R లో ఖాళీ డేటా ఫ్రేమ్‌ని సృష్టించడం
R లో ఖాళీ డేటాఫ్రేమ్‌ని సృష్టించడానికి అత్యంత ప్రాథమిక విధానం data.frame() పద్ధతిని ఉపయోగించడం.
ఖాళీ_df < - data.frame ( )ముద్రణ ( ఖాళీ_df )
మసకగా ( ఖాళీ_df )
R యొక్క ఇవ్వబడిన కోడ్‌లో, ఖాళీ_dfలో మేము data.frame() ఫంక్షన్‌ని సృష్టిస్తాము. data.frame() ఫంక్షన్ ఎటువంటి వాదనలు తీసుకోదు, ఇది అడ్డు వరుసలు మరియు నిలువు వరుసలు లేకుండా డేటాఫ్రేమ్‌ను సృష్టిస్తుంది. మేము print() ఫంక్షన్‌ని ఉపయోగించి ఖాళీ_dfని ప్రింట్ చేసినప్పుడు, మనకు ఖాళీ డేటాఫ్రేమ్ అవుట్‌పుట్ వస్తుంది. అప్పుడు, మేము రెండు విలువలతో డేటాఫ్రేమ్ యొక్క కొలతలు వెక్టర్‌గా పొందడానికి dim() ఫంక్షన్‌లో ఖాళీ_dfని పాస్ చేస్తాము: వరుసగా వరుసల సంఖ్య మరియు నిలువు వరుసల సంఖ్య.
అందువల్ల, డేటాఫ్రేమ్‌లో “0” నిలువు వరుసలు మరియు “0” అడ్డు వరుసలు ఉన్నాయనే సందేశాన్ని ఫలితం మొదట ప్రదర్శిస్తుంది. అదనంగా, డేటాఫ్రేమ్‌లో సున్నా అడ్డు వరుసలు మరియు సున్నా నిలువు వరుసలు ఉన్నందున మేము రెండు సున్నాల వెక్టార్‌ని పొందుతాము.
ఉదాహరణ 2: R లో '0' నిలువు వరుస మరియు అడ్డు వరుసతో ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడం
ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడానికి మరొక మార్గం మ్యాట్రిక్స్() ఫంక్షన్‌ని ఉపయోగించడం మరియు దానిని డేటాఫ్రేమ్‌గా మార్చడం. అలాగే, మ్యాట్రిక్స్ మరియు డేటాఫ్రేమ్ ఫంక్షన్‌లు రెండూ ఇంటర్‌కన్వర్టబుల్.
m1 = మాతృక ( ncol = 0 , nrow = 0 )
m1 = మాతృక ( ncol = 0 , nrow = 0 )
df =డేటా.ఫ్రేమ్ ( m1 )
ముద్రణ ( 'ఖాళీ డేటా ఫ్రేమ్' )
ముద్రణ ( df )
ముద్రణ ( 'డేటా ఫ్రేమ్ కొలతలు' )
మసకగా ( df )
R యొక్క ఇచ్చిన కోడ్‌లో, మేము మొదట 'm1'లో మాతృక() ఫంక్షన్‌ని అమలు చేస్తాము మరియు ఆపై 'ncol' మరియు 'nrow' పారామితులను పాస్ చేయడం ద్వారా మాతృక()ని నిర్వచించాము. ఈ పారామితులకు కేటాయించిన విలువ “0”. ఆ తర్వాత, “m1”ని డేటాఫ్రేమ్‌గా మార్చడానికి మేము data.frame() ఫంక్షన్‌ని ఉపయోగిస్తాము. మార్చబడిన డేటాఫ్రేమ్ యొక్క ఫలితం ప్రింట్ ఫంక్షన్‌ని ఉపయోగించి ముద్రించబడుతుంది. dim() ఫంక్షన్‌ని ఉపయోగించి DataFrame కోసం కొలతలు కూడా ప్రదర్శించబడతాయి.
అందువల్ల, అవుట్‌పుట్ ఖాళీ డేటాఫ్రేమ్ యొక్క సందేశాన్ని మరియు ఖాళీ మాతృక కారణంగా డేటాఫ్రేమ్ కోసం సున్నా వెక్టార్ కొలతలను సూచిస్తుంది.
ఉదాహరణ 3: R లో N నిలువు వరుసలతో ఒక ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడం
అంతేకాకుండా, c() ఫంక్షన్‌ని ఉపయోగించి కాలమ్ పేరును పేర్కొనడం ద్వారా మనం ఖాళీ డేటాఫ్రేమ్‌ని సృష్టించవచ్చు. R యొక్క క్రింది కోడ్‌ను పరిగణించండి:
cols = సి ( 'పేరు' , 'వయస్సు' , 'మార్కులు' )df = డేటా.ఫ్రేమ్ ( మాతృక ( nrow = 0 , ncol = పొడవు ( cols ) ) )
పేర్లు ( df ) = కలలు
ముద్రణ ( df )
మేము 'cols' అక్షర వెక్టర్‌లోని c() ఫంక్షన్‌ని పిలుస్తాము. ఇక్కడ, c() ఫంక్షన్ మూడు నిలువు వరుస పేర్లతో పేర్కొనబడింది. ఆ తర్వాత, మేము డేటా.ఫ్రేమ్() ఫంక్షన్‌లోని మ్యాట్రిక్స్() ఫంక్షన్‌లోని 0 అడ్డు వరుసలు మరియు అదే సంఖ్యలో నిలువు వరుసల పొడవుతో ఖాళీ మాత్రికను సృష్టిస్తాము.
ఖాళీ మాత్రికను సృష్టించడానికి మేము 0 విలువతో 'nrow'ని పాస్ చేస్తాము. 'cols' వెక్టర్ యొక్క పొడవుతో సమానమైన నిలువు వరుసలతో మాతృకను సృష్టించడానికి 'ncol' పొడవు(cols)తో పేర్కొనబడింది. అప్పుడు, మేము 'colnames()' ఫంక్షన్ మరియు 'cols' వెక్టర్ ఉపయోగించి డేటాఫ్రేమ్‌కు కాలమ్ పేర్లను కేటాయిస్తాము.
మనం చూడగలిగినట్లుగా, మూడు నిలువు వరుస పేర్లతో ఖాళీ డేటాఫ్రేమ్ క్రింది విధంగా ఉంది:
ఉదాహరణ 4: R లోని నిలువు వరుసలకు కేటాయించబడిన ఖాళీ వెక్టర్‌తో ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడం
ముందస్తు విధానాలతో పాటు, నిలువు వరుసలకు ఖాళీ వెక్టర్‌లను పేర్కొనడం ద్వారా మరియు అడ్డు వరుసలను మినహాయించడం ద్వారా మేము ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించవచ్చు. దీన్ని సాధించడానికి క్రింది R కోడ్‌పై దృష్టి పెడతాము:
df < - data.frame ( c1 = రెట్టింపు ( ) ,c2 = పూర్ణాంకం ( ) ,
c3 = కారకం ( ) ,
c4 = తార్కిక ( ) ,
c5 = అక్షరం ( ) ,
stringsAsFactors = తప్పు )
str ( df )
మేము ముందుగా data.frame() ఫంక్షన్‌ని ప్రకటిస్తాము. అప్పుడు, మేము దానిలోని వివిధ నిలువు వరుసల కోసం వివిధ డేటా రకాలను నిర్వచించాము. విలువలు లేని ఖాళీ నిలువు వరుసలను సృష్టించడానికి మేము ఈ డేటా రకం ఫంక్షన్‌లకు ఎటువంటి ఆర్గ్యుమెంట్‌లను పంపలేదని గమనించండి.
ఇంకా, అక్షర నిలువు వరుసలను కారకాలుగా స్వయంచాలకంగా మార్చకుండా R ని నిరోధించడానికి “stringsAsFactors” FALSEకి సెట్ చేయబడింది. అప్పుడు, str() ఫంక్షన్‌తో, డేటాఫ్రేమ్ “df” యొక్క నిర్మాణం ముద్రించబడుతుంది, ఇందులో ప్రతి నిలువు వరుస యొక్క డేటా రకాలు మరియు డేటాఫ్రేమ్‌లోని అడ్డు వరుసల సంఖ్య ఉంటాయి.
ఫలిత అవుట్‌పుట్ వివిధ డేటా రకాల ఐదు నిలువు వరుసలతో ఖాళీ డేటాఫ్రేమ్ క్రింద ప్రదర్శించబడుతుంది మరియు అడ్డు వరుసలు లేవు.
ఉదాహరణ 5: R లో ఉన్న దాని నుండి ఖాళీ డేటా ఫ్రేమ్‌ని సృష్టించడం
దీనికి విరుద్ధంగా, మనకు ఇప్పటికే ఉన్న డేటాఫ్రేమ్ ఉంటే, ఖాళీ డేటాఫ్రేమ్‌ని సృష్టించడానికి దాన్ని ఖాళీ చేయవచ్చు. దీని కోసం మేము క్రింది కోడ్‌ను R లో అందిస్తాము:
df < - data.frame (స్నో = సి ( 1 , 2 , 3 , 4 ) ,
పేర్లు = సి ( 'అలెక్స్' , 'కాండీస్' , 'జిమ్మీ' , 'చీకటి' ) ,
వయస్సు = సి ( ఇరవై ఒకటి , 24 , 25 , 26 )
)
emp_df = df [ తప్పు, ]
emp_df
వివిధ రకాల విలువలతో విభిన్న కాలమ్ పేర్లను తీసుకునే డేటాఫ్రేమ్‌ని మేము నిర్వచించాము. ముఖ్యంగా, డేటాఫ్రేమ్ “df” ఇక్కడ నాలుగు వరుసల డేటాను కలిగి ఉంది. ఆ తర్వాత, మేము లాజికల్ ఇండెక్స్, FALSEని ఉపయోగించి “emp_df” కొత్త డేటా ఫ్రేమ్‌ని ప్రకటిస్తాము. ఈ సూచిక “df” నుండి అడ్డు వరుసలను ఎంచుకోదు. అందువల్ల, “emp_df” డేటాఫ్రేమ్ “df” వలె అదే కాలమ్ పేర్లు మరియు డేటా రకాలను కలిగి ఉంటుంది.
కింది అవుట్‌పుట్ డేటాఫ్రేమ్ యొక్క నిలువు వరుసలు, డేటాటైప్‌లు, అలాగే అడ్డు వరుసల సంఖ్యను ప్రదర్శిస్తుంది. డేటాఫ్రేమ్ సున్నా అడ్డు వరుసలను కలిగి ఉన్నందున, ఇది సున్నా విలువలతో అడ్డు వరుసలను చూపుతుంది:
ఉదాహరణ 6: R లో స్ట్రక్చర్() పద్ధతిని ఉపయోగించి ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడం
ఖాళీ డేటాఫ్రేమ్‌ను రూపొందించడానికి మేము స్ట్రక్చర్() పద్ధతిని సమర్థవంతంగా ఉపయోగించుకోవచ్చు. ఈ ఫంక్షన్ నిర్దిష్ట లక్షణాలతో నిర్దిష్ట వస్తువుపై వివరాలను అందిస్తుంది. స్ట్రక్చర్() ఫంక్షన్‌ని ఉపయోగించి ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించే క్రింది R కోడ్‌ని చూడండి:
df < - నిర్మాణం ( జాబితా ( పేరు = పాత్ర ( ) ,లొకేషన్ = పాత్ర ( ) ,
తేదీ = తేదీ ( పాత్ర ( ) ) ) ,
తరగతి = 'data.frame' )
str ( df )
మేము వరుసగా ఖాళీ అక్షరం మరియు తేదీ వెక్టర్‌లను సృష్టించడానికి అక్షరం() మరియు as.Date(అక్షరం())ని కలిగి ఉన్న నిలువు వరుసల పేర్లను పేర్కొంటాము. నిలువు వరుసల ప్రారంభ విలువలను పేర్కొనే జాబితా() ఫంక్షన్‌లో ఈ నిలువు వరుసలు పంపబడతాయి. ఇక్కడ స్ట్రక్చర్() ఫంక్షన్ డేటాఫ్రేమ్‌ని సృష్టించడానికి మరియు దానిని 'data.frame' క్లాస్‌తో కేటాయించడానికి ఉపయోగించబడుతుంది.
కింది అవుట్‌పుట్ 0 పరిశీలనలు మరియు 3 వేరియబుల్‌లను కలిగి ఉన్న డేటాఫ్రేమ్‌ను సూచిస్తుంది మరియు ప్రతి వేరియబుల్ యొక్క పేర్లు మరియు డేటాటైప్‌లను అందిస్తుంది:
ముగింపు
డేటా.ఫ్రేమ్() ఫంక్షన్ ఇవ్వబడిన అన్ని ఉదాహరణలలో ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించడానికి ఉపయోగించబడుతుంది. మేము ముందుగా డేటా.ఫ్రేమ్() ఫంక్షన్‌ను పారామితులు లేకుండా ఖాళీ డేటాఫ్రేమ్ కోసం ఉపయోగించాము. అప్పుడు, మేము సున్నా విలువలతో అడ్డు వరుసలు మరియు నిలువు వరుసలను పేర్కొనడం ద్వారా ఖాళీ డేటాఫ్రేమ్‌ను సృష్టించాము. మేము విలువతో నిలువు వరుసలను మరియు సున్నాతో అడ్డు వరుసలను కూడా పేర్కొన్నాము, విలువలు మరియు 0 వరుసలతో నిలువు వరుసలను మాత్రమే పేర్కొన్నాము మరియు ఖాళీ వెక్టార్‌ని ఉపయోగించాము. చివరగా, మేము స్ట్రక్చర్() ఫంక్షన్‌ని ఉపయోగించి ఖాళీ డేటాఫ్రేమ్‌ని సృష్టించాము.