একাধিক নতুন কলাম তৈরি করতে কলামে পান্ডাস ফাংশন প্রয়োগ করবেন?

Question

পান্ডায় এটি কীভাবে করবেন:

আমার extract_text_featuresএকক পাঠ্য কলামে একটি ফাংশন রয়েছে, একাধিক আউটপুট কলামগুলি ফেরত। বিশেষত, ফাংশনটি 6 মান দেয়।

ফাংশনটি কাজ করে, তবে কোনও সঠিক রিটার্ন টাইপ (পান্ডাস ডেটা ফ্রেম / নম্পি অ্যারে / পাইথন তালিকা) বলে মনে হচ্ছে না যাতে আউটপুট সঠিকভাবে নির্ধারিত হতে পারে df.ix[: ,10:16] = df.textcol.map(extract_text_features)

সুতরাং আমি মনে করি আমাকে এইdf.iterrows() হিসাবে পুনরাবৃত্তি ফিরে যেতে হবে ?

আপডেট: এর সাথে আইট্রেটিং df.iterrows()কমপক্ষে 20x ধীর, তাই আমি আত্মসমর্পণ করে ছয়টি স্বতন্ত্র .map(lambda ...)কলগুলিতে ফাংশনটি বিভক্ত করলাম ।

আপডেট 2: v0.11.0 এর দিকে এই প্রশ্নটি জিজ্ঞাসা করা হয়েছিল । সুতরাং প্রশ্ন এবং উত্তর অনেক বেশি প্রাসঙ্গিক নয়।

Comments

আমি মনে করি না যদি আপনার একাধিক নিয়োগ আপনি লেখা আছে করতে পারেন: df.ix[: ,10:16]। আমি মনে করি আপনার mergeডেটাসেটে আপনার বৈশিষ্ট্য থাকবে ।

— জেলাজনি 7

যারা আরও বেশি পারফরম্যান্ট সমাধান চান তাদের নীচে এটি ব্যবহার করুন যা ব্যবহার করে নাapply

— টেড পেট্রো

পান্ডাসহ বেশিরভাগ সংখ্যাসূচক অপারেশনগুলি ভেক্টরাইজ করা যায় - এর অর্থ তারা প্রচলিত পুনরাবৃত্তির চেয়ে অনেক দ্রুত faster OTOH, কিছু ক্রিয়াকলাপ (যেমন স্ট্রিং এবং রেজেক্স) ভেক্টরাইজ করা সহজাতভাবে শক্ত। এই ক্ষেত্রে, আপনার ডেটা কীভাবে লুপ করবেন তা বোঝা গুরুত্বপূর্ণ । কখন এবং কীভাবে আপনার ডেটা থেকে লুপিং করা হবে সে সম্পর্কে আরও তথ্য, দয়া করে পান্ডাদের সাথে লুপগুলি পড়ুন - কখন আমার যত্ন নেওয়া উচিত? ।

— সিএস 95

@ কোল্ডস্পিড: মূল বিষয়টি বেছে নিচ্ছে না যে কয়েকটি বিকল্পের মধ্যে উচ্চ-পারফরম্যান্স ছিল, এটি একেবারে কাজ করার জন্য পান্ডাস সিনট্যাক্সের সাথে লড়াই করে যাচ্ছিল, প্রায় v0.11.0 এর দিকে ।

— স্মি

প্রকৃতপক্ষে, মন্তব্যটি ভবিষ্যতের পাঠকদের জন্য যারা যারা পুনরাবৃত্ত সমাধানগুলি সন্ধান করছেন তাদের উদ্দেশ্যে করা হয়েছে, যারা হয় আরও ভাল জানেন না বা যারা জানেন তারা কী করছেন।

— সিএস 95

Answer 1

ব্যবহারকারীর জবাবটি বন্ধ করে 1827356, আপনি এক পাসে অ্যাসাইনমেন্টটি ব্যবহার করে করতে পারেন df.merge:

df.merge(df.textcol.apply(lambda s: pd.Series({'feature1':s+1, 'feature2':s-1})), 
    left_index=True, right_index=True)

    textcol  feature1  feature2
0  0.772692  1.772692 -0.227308
1  0.857210  1.857210 -0.142790
2  0.065639  1.065639 -0.934361
3  0.819160  1.819160 -0.180840
4  0.088212  1.088212 -0.911788

সম্পাদনা: বিপুল মেমরির খরচ এবং স্বল্প গতি সম্পর্কে দয়া করে সচেতন হন: https://ys-l.github.io/posts/2015/08/28/how-not-to-use-pandas-apply/ !

Comments

শুধু কৌতূহলের বাইরে, এটি কি এর দ্বারা প্রচুর স্মৃতি ব্যবহার করা আশা করা যায়? আমি এটি একটি ডেটাফ্রেমে করছি যা 2.5 মিলিল সারি ধারণ করে, এবং আমি প্রায় স্মৃতি সমস্যার মধ্যে পড়েছি (এছাড়াও এটি কেবল 1 কলামটি ফেরার চেয়ে ধীরে ধীরে)।

— জেফরি04

'df.join (df.textcol.apply (lambda s: pd.Series ({' বৈশিষ্ট্য 1 ': s + 1,' বৈশিষ্ট্য 2 ': s-1}))))' আমার মনে হয় আরও ভাল বিকল্প হবে।

— শিবম কে। ঠাক্কর

@ শিভামকেঠাকর আপনি কেন মনে করেন যে আপনার পরামর্শটি আরও ভাল বিকল্প হবে? আপনি কী ভাবেন এটি আরও দক্ষ হবে বা মেমরির দাম কম হবে?

— tsando

প্রয়োজনীয় গতি এবং মেমরিটি দয়া করে বিবেচনা করুন: ys-l.github.io/posts/2015/08/28/how-not-to-use-pandas-apply

— Make42

Answer 2

আমি সাধারণত এটি ব্যবহার করে করি zip:

>>> df = pd.DataFrame([[i] for i in range(10)], columns=['num'])
>>> df
    num
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9

>>> def powers(x):
>>>     return x, x**2, x**3, x**4, x**5, x**6

>>> df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
>>>     zip(*df['num'].map(powers))

>>> df
        num     p1      p2      p3      p4      p5      p6
0       0       0       0       0       0       0       0
1       1       1       1       1       1       1       1
2       2       2       4       8       16      32      64
3       3       3       9       27      81      243     729
4       4       4       16      64      256     1024    4096
5       5       5       25      125     625     3125    15625
6       6       6       36      216     1296    7776    46656
7       7       7       49      343     2401    16807   117649
8       8       8       64      512     4096    32768   262144
9       9       9       81      729     6561    59049   531441

Comments

তবে আপনার যদি 6 টির পরিবর্তে 50 টি কলাম যুক্ত হয় তবে আপনি কী করবেন?

— সর্বোচ্চ 21

@ ম্যাক্সtemp = list(zip(*df['num'].map(powers))); for i, c in enumerate(columns): df[c] = temp[c]

— ostrokach

@ostrokach আমি মনে করি আপনি বোঝানো for i, c in enumerate(columns): df[c] = temp[i]। এর জন্য ধন্যবাদ, আমি সত্যিই এর উদ্দেশ্য পেয়েছি enumerate: ডি

— রোকভারজ

এটি এখন পর্যন্ত সর্বাধিক মার্জিত এবং পঠনযোগ্য সমাধান এটির জন্য আমি এসেছি। আপনি যদি পারফরম্যান্সের সমস্যা না পান, তবে zip(*df['col'].map(function))সম্ভবত রীতিমতো পথ চলার উপায়।

— ফ্রানসোয়া লেব্ল্যাঙ্ক

@XiaoyuLu দেখুন stackoverflow.com/questions/3394835/args-and-kwargs

— ostrokach

Answer 3

অতীতে আমি এটি করেছি

df = pd.DataFrame({'textcol' : np.random.rand(5)})

df
    textcol
0  0.626524
1  0.119967
2  0.803650
3  0.100880
4  0.017859

df.textcol.apply(lambda s: pd.Series({'feature1':s+1, 'feature2':s-1}))
   feature1  feature2
0  1.626524 -0.373476
1  1.119967 -0.880033
2  1.803650 -0.196350
3  1.100880 -0.899120
4  1.017859 -0.982141

সম্পূর্ণতার জন্য সম্পাদনা

pd.concat([df, df.textcol.apply(lambda s: pd.Series({'feature1':s+1, 'feature2':s-1}))], axis=1)
    textcol feature1  feature2
0  0.626524 1.626524 -0.373476
1  0.119967 1.119967 -0.880033
2  0.803650 1.803650 -0.196350
3  0.100880 1.100880 -0.899120
4  0.017859 1.017859 -0.982141

Comments

নতুন কোলগুলিকে আসল ডেটাফ্রেমে সংযুক্ত করার জন্য কনক্যাট () মার্জ () এর চেয়ে সহজ দেখাচ্ছে।

— জিরা

সুন্দর উত্তর, আপনি আবেদনের বাইরে কলামগুলি নির্দিষ্ট করে রাখলে আপনার ডিক বা মার্জ ব্যবহার করার দরকার নেইdf[['col1', 'col2']] = df['col3'].apply(lambda x: pd.Series('val1', 'val2'))

— ম্যাট

Answer 4

95% ব্যবহারের ক্ষেত্রে এটি সম্পাদন করার এটি সঠিক এবং সহজ উপায়:

>>> df = pd.DataFrame(zip(*[range(10)]), columns=['num'])
>>> df
    num
0    0
1    1
2    2
3    3
4    4
5    5

>>> def example(x):
...     x['p1'] = x['num']**2
...     x['p2'] = x['num']**3
...     x['p3'] = x['num']**4
...     return x

>>> df = df.apply(example, axis=1)
>>> df
    num  p1  p2  p3
0    0   0   0    0
1    1   1   1    1
2    2   4   8   16
3    3   9  27   81
4    4  16  64  256

Comments

আপনি কি লিখবেন না: df = df.apply (উদাহরণ (df), অক্ষ = 1) আমি ভুল হলে আমাকে সংশোধন করুন, আমি কেবল নবাগত

— ব্যবহারকারী 299791

@ ব্যবহারকারী 299791, না এই ক্ষেত্রে আপনি উদাহরণটিকে প্রথম শ্রেণীর বস্তু হিসাবে বিবেচনা করছেন যাতে আপনি নিজেই ফাংশনটিতে যাচ্ছেন। এই ক্রিয়াটি প্রতিটি সারিতে প্রয়োগ করা হবে।

— মাইকেল ডেভিড ওয়াটসন

হাই মাইকেল, আপনার উত্তর আমাকে আমার সমস্যায় সাহায্য করেছে। অবশ্যই আপনার সমাধানটি মূল প্যান্ডাসের df.assign () পদ্ধতির চেয়ে ভাল, এটি প্রতি কলামে এক বার। অ্যাসাইন () ব্যবহার করে, আপনি যদি 2 টি নতুন কলাম তৈরি করতে চান তবে নতুন কলাম 1 পাওয়ার জন্য আপনাকে df1 ব্যবহার করতে হবে, তারপরে দ্বিতীয় নতুন কলাম তৈরি করতে df1 এ কাজ করতে df2 ব্যবহার করুন ... এটি বেশ মনোহর mon কিন্তু আপনার পদ্ধতি আমার জীবন বাঁচিয়ে !!! ধন্যবাদ !!!

— কমেন্টালিজ-ভাস

এটি কি প্রতি সারিতে একবার কলাম অ্যাসাইনমেন্ট কোড চালাবে না? pd.Series({k:v})ইওয়ানের উত্তরের মতো কলাম ক্যাসেন্টমেন্টটি ফেরত দেওয়া এবং সিরিয়ালাইজ করা ভাল না ?

— ডেনিস ডি বার্নার্ডি

Answer 5

2018 সালে, আমি apply()যুক্তি সহ ব্যবহার করিresult_type='expand'

>>> appiled_df = df.apply(lambda row: fn(row.text), axis='columns', result_type='expand')
>>> df = pd.concat([df, appiled_df], axis='columns')

Comments

আজকাল তুমি এভাবেই কর!

— Make42

এটি ২০২০ সালে বাক্স থেকে বেরিয়ে এসেছিল এবং অন্যান্য অনেক প্রশ্নই এর উত্তর দেয় নি। এছাড়াও এটিকে ব্যবহার করে না pd.Series যার ফলে কর্মক্ষমতা সমস্যার বিষয়ে সবসময় সুন্দর

— Théo Rubenach

এটি একটি ভাল সমাধান। কেবলমাত্র সমস্যাটি হল, আপনি নতুনভাবে যুক্ত হওয়া 2 টি কলামের নাম চয়ন করতে পারবেন না। আপনাকে পরে df.rename (কলামগুলি = {0: 'কল 1', 1: 'কল 2'}) করতে হবে

— পেড্রাম বাশিরি

@pedrambashiri যদি ফাংশন আপনি পাস df.applyআয় একটি dict, কলাম বাইরে আসতে হবে কী অনুযায়ী নামে।

— Seb

Answer 6

শুধু ব্যবহার result_type="expand"

df = pd.DataFrame(np.random.randint(0,10,(10,2)), columns=["random", "a"])
df[["sq_a","cube_a"]] = df.apply(lambda x: [x.a**2, x.a**3], axis=1, result_type="expand")

Comments

এটি 0.23 এ বিকল্পটি নতুনভাবে চিহ্নিত করতে সহায়তা করে । প্রশ্নটি 0.11

— smci

দুর্দান্ত, এটি সহজ এবং এখনও ঝরঝরে কাজ করে। এটিই আমি খুঁজছিলাম। ধন্যবাদ

— আইজাক সিম

পূর্বের উত্তরটির সদৃশ: stackoverflow.com/a/52363890/823470

— আলকাতরা

Answer 7

সংক্ষিপ্তসার: আপনি যদি কেবল কয়েকটি কলাম তৈরি করতে চান তবে ব্যবহার করুনdf[['new_col1','new_col2']] = df[['data1','data2']].apply( function_of_your_choosing(x), axis=1)

এই সমাধানের জন্য, আপনি যে নতুন কলামগুলি তৈরি করছেন তার সংখ্যা অবশ্যই অ্যাপ্লিকেশন () ফাংশনে ইনপুট হিসাবে আপনি ব্যবহার করেছেন এমন কলামগুলির সমান হতে হবে। আপনি যদি অন্য কিছু করতে চান তবে অন্যান্য উত্তরগুলি দেখুন।

বিস্তারিত আসুন বলে দুই-কলাম dataframe আছে। প্রথম কলামটি কোনও ব্যক্তির উচ্চতা যখন 10 হয়; দ্বিতীয়টি ব্যক্তির উচ্চতা যখন 20 হয় তখন বলা হয়।

মনে করুন আপনার প্রতিটি ব্যক্তির উচ্চতার গড় এবং প্রতিটি ব্যক্তির উচ্চতার সমষ্টি উভয়ই গণনা করতে হবে। এটি প্রতিটি সারিতে দুটি মান।

আপনি নিম্নলিখিত, শীঘ্রই প্রয়োগযোগ্য ফাংশনটির মাধ্যমে এটি করতে পারেন:

def mean_and_sum(x):
    """
    Calculates the mean and sum of two heights.
    Parameters:
    :x -- the values in the row this function is applied to. Could also work on a list or a tuple.
    """

    sum=x[0]+x[1]
    mean=sum/2
    return [mean,sum]

আপনি এই ফাংশনটি এর মতো ব্যবহার করতে পারেন:

 df[['height_at_age_10','height_at_age_20']].apply(mean_and_sum(x),axis=1)

(পরিষ্কার করার জন্য: এই প্রয়োগ ফাংশনটি সাবসেটেড ডেটাফ্রেমের প্রতিটি সারি থেকে মান গ্রহণ করে এবং একটি তালিকা ফেরত দেয়))

তবে আপনি যদি এটি করেন:

df['Mean_&_Sum'] = df[['height_at_age_10','height_at_age_20']].apply(mean_and_sum(x),axis=1)

আপনি 1 টি নতুন কলাম তৈরি করবেন যার মধ্যে [গড়, যোগফল] তালিকাগুলি রয়েছে, যা আপনি সম্ভবত এড়াতে চান, কারণ এর জন্য অন্য ল্যাম্বডা / প্রয়োগের প্রয়োজন হবে।

পরিবর্তে, আপনি প্রতিটি মানকে তার নিজস্ব কলামে বিভক্ত করতে চান। এটি করতে, আপনি একবারে দুটি কলাম তৈরি করতে পারেন:

df[['Mean','Sum']] = df[['height_at_age_10','height_at_age_20']]
.apply(mean_and_sum(x),axis=1)

Comments

পান্ডাস 0.23 এর জন্য আপনাকে সিনট্যাক্সটি ব্যবহার করতে হবে:df["mean"], df["sum"] = df[['height_at_age_10','height_at_age_20']] .apply(mean_and_sum(x),axis=1)

— সামারেলা

এই ফাংশন ত্রুটি বাড়াতে পারে। রিটার্ন ফাংশনটি অবশ্যই হবে return pd.Series([mean,sum])

— কনিষ্ক মাইর

Answer 8

আমার জন্য এটি কাজ করেছে:

ইনপুট df

df = pd.DataFrame({'col x': [1,2,3]})
   col x
0      1
1      2
2      3

ক্রিয়া

def f(x):
    return pd.Series([x*x, x*x*x])

2 টি নতুন কলাম তৈরি করুন:

df[['square x', 'cube x']] = df['col x'].apply(f)

আউটপুট:

   col x  square x  cube x
0      1         1       1
1      2         4       8
2      3         9      27

Answer 9

আমি এটি করার বিভিন্ন উপায় এবং এখানে দেখানো পদ্ধতিটি (একটি পান্ডাস সিরিজ ফিরিয়ে দেওয়া) সর্বাধিক দক্ষ বলে মনে হচ্ছে না।

যদি আমরা এলোমেলো ডেটার একটি বৃহত্তর ডেটাফ্রেম দিয়ে শুরু করি:

# Setup a dataframe of random numbers and create a 
df = pd.DataFrame(np.random.randn(10000,3),columns=list('ABC'))
df['D'] = df.apply(lambda r: ':'.join(map(str, (r.A, r.B, r.C))), axis=1)
columns = 'new_a', 'new_b', 'new_c'

উদাহরণ এখানে দেখানো হয়েছে:

# Create the dataframe by returning a series
def method_b(v):
    return pd.Series({k: v for k, v in zip(columns, v.split(':'))})
%timeit -n10 -r3 df.D.apply(method_b)

10 লুপ, প্রতি লুপ 3: 2.77 এর মধ্যে সেরা

একটি বিকল্প পদ্ধতি:

# Create a dataframe from a series of tuples
def method_a(v):
    return v.split(':')
%timeit -n10 -r3 pd.DataFrame(df.D.apply(method_a).tolist(), columns=columns)

10 লুপ, 3 লুপ প্রতি: 8.85 এমএস সেরা

আমার গণনা অনুসারে টিউপলগুলির একটি সিরিজ নেওয়া এবং তারপরে এটিকে ডেটা ফ্রেমে রূপান্তর করা আরও বেশি দক্ষ। আমার কাজকর্মের ক্ষেত্রে কোনও ত্রুটি থাকলেও আমি মানুষের চিন্তাভাবনা শুনতে আগ্রহী।

Comments

এটি সত্যিই দরকারী! ফাংশন রিটার্ন সিরিজ পদ্ধতির তুলনায় আমি 30x স্পিড-আপ পেয়েছি।

— পুষ্কর নিমকার

Answer 10

গৃহীত সমাধানটি প্রচুর ডেটার জন্য অত্যন্ত ধীর হতে চলেছে। সর্বাধিক সংখ্যক উর্ধ্বতন সহ সমাধানটি পড়া খুব কঠিন এবং সংখ্যার ডেটা সহ ধীর। যদি প্রতিটি নতুন কলাম অন্যের থেকে স্বতন্ত্রভাবে গণনা করা যায় তবে আমি কেবল তাদের ব্যবহার না করে প্রত্যেকে সরাসরি নিয়োগ করবapply ।

নকল চরিত্রের ডেটা সহ উদাহরণ

ডেটা ফ্রেমে 100,000 স্ট্রিং তৈরি করুন

df = pd.DataFrame(np.random.choice(['he jumped', 'she ran', 'they hiked'],
                                   size=100000, replace=True),
                  columns=['words'])
df.head()
        words
0     she ran
1     she ran
2  they hiked
3  they hiked
4  they hiked

আসুন ধরা যাক আমরা মূল প্রশ্নের মতো কিছু পাঠ্য বৈশিষ্ট্য বের করতে চেয়েছিলাম। উদাহরণস্বরূপ, আসুন প্রথম অক্ষরটি বের করুন, 'ই' বর্ণটির উপস্থিতি গণনা করুন এবং বাক্যাংশটি মূলধন করুন।

df['first'] = df['words'].str[0]
df['count_e'] = df['words'].str.count('e')
df['cap'] = df['words'].str.capitalize()
df.head()
        words first  count_e         cap
0     she ran     s        1     She ran
1     she ran     s        1     She ran
2  they hiked     t        2  They hiked
3  they hiked     t        2  They hiked
4  they hiked     t        2  They hiked

সময়

%%timeit
df['first'] = df['words'].str[0]
df['count_e'] = df['words'].str.count('e')
df['cap'] = df['words'].str.capitalize()
127 ms ± 585 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

def extract_text_features(x):
    return x[0], x.count('e'), x.capitalize()

%timeit df['first'], df['count_e'], df['cap'] = zip(*df['words'].apply(extract_text_features))
101 ms ± 2.96 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

আশ্চর্যজনকভাবে, আপনি প্রতিটি মান দিয়ে লুপ করে আরও ভাল পারফরম্যান্স পেতে পারেন

%%timeit
a,b,c = [], [], []
for s in df['words']:
    a.append(s[0]), b.append(s.count('e')), c.append(s.capitalize())

df['first'] = a
df['count_e'] = b
df['cap'] = c
79.1 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

জাল সংখ্যাযুক্ত ডেটা সহ আরও একটি উদাহরণ

1 মিলিয়ন এলোমেলো সংখ্যা তৈরি করুন এবং powersউপরে থেকে কার্যটি পরীক্ষা করুন ।

df = pd.DataFrame(np.random.rand(1000000), columns=['num'])


def powers(x):
    return x, x**2, x**3, x**4, x**5, x**6

%%timeit
df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
       zip(*df['num'].map(powers))
1.35 s ± 83.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

প্রতিটি কলামটি নির্ধারণ করা 25x দ্রুত এবং খুব পঠনযোগ্য:

%%timeit 
df['p1'] = df['num'] ** 1
df['p2'] = df['num'] ** 2
df['p3'] = df['num'] ** 3
df['p4'] = df['num'] ** 4
df['p5'] = df['num'] ** 5
df['p6'] = df['num'] ** 6
51.6 ms ± 1.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

আমি কেন সাধারণত যাওয়ার পথে হয় না তা এখানে আরও বিশদ সহ একই রকম প্রতিক্রিয়া জানিয়েছিলাম apply।

Answer 11

অনুরূপ দুটি অন্যান্য প্রশ্নে একই উত্তর পোস্ট করেছেন। আমি এটি করতে যেভাবে পছন্দ করি তা হ'ল একটি সিরিজে ফাংশনের রিটার্ন মানগুলি মোড়ানো:

def f(x):
    return pd.Series([x**2, x**3])

এবং তারপরে পৃথক কলাম তৈরি করতে নীচের প্রয়োগ প্রয়োগ করুন:

df[['x**2','x**3']] = df.apply(lambda row: f(row['x']), axis=1)

Answer 12

আপনি মানগুলির পরিবর্তে পুরো সারিটি ফিরিয়ে দিতে পারেন:

df = df.apply(extract_text_features,axis = 1)

যেখানে ফাংশনটি সারিটি দেয়

def extract_text_features(row):
      row['new_col1'] = value1
      row['new_col2'] = value2
      return row

Comments

না আমি extract_text_featuresdf এর প্রতিটি কলামে আবেদন করতে চাই না , কেবল পাঠ্য কলামেdf.textcol

— স্মি

Answer 13

def myfunc(a):
    return a * a

df['New Column'] = df['oldcolumn'].map(myfunc))

এটি আমার পক্ষে কাজ করেছে। প্রক্রিয়াজাত পুরানো কলামের ডেটা দিয়ে নতুন কলাম তৈরি করা হবে।

Comments

এটি 'একাধিক নতুন কলাম' ফেরত দেয় না

— পেড্রাম বাশির

এটি 'একাধিক নতুন কলাম' ফেরত দেয় না, সুতরাং এটি প্রশ্নের উত্তর দেয় না। আপনি কি এটি মুছতে পারেন?

— স্মি