Xjyuk

MCVE

Here is a simple suggestion:

import pandas as pd

# MCVE dataframe:
df = pd.DataFrame([123456, 456789, 135797, 123, 123456789], columns=['number'])

def digit(x, n):
 """Return the n-th digit of integer in base 10"""
 return (x // 10**n) % 10

def digitize(df, key, n):
 """Extract n less significant digits from an integer in base 10"""
 for i in range(n):
 df['x%d' % i] = digit(df[key], n-i-1)

# Apply function on dataframe (inplace):
digitize(df, 'number', 6)

For the trial dataframe, it returns:

 number x0 x1 x2 x3 x4 x5
0 123456 1 2 3 4 5 6
1 456789 4 5 6 7 8 9
2 135797 1 3 5 7 9 7
3 123 0 0 0 1 2 3
4 123456789 4 5 6 7 8 9

Observations

This method avoids the need to cast into string and then cast again to int.

It relies on modular integer arithmetic, bellow details of operations:

10**3 # int: 1000 (integer power)
54321 // 10**3 # int: 54 (quotient of integer division)
(54321 // 10**3) % 10 # int: 4 (remainder of integer division, modulo)

Last but not least, it is fail safe and exact for number shorter than n digits or greater than (notice it returns the n less significant digits in latter case).

Some fun with views, assuming that each number has 6 digits:

u = df[['Number']].to_numpy().astype('U6').view('U1').astype(int)

df.join(pd.DataFrame(u).rename(columns=lambda c: f'xc+1'))

 Number x1 x2 x3 x4 x5 x6
0 654321 6 5 4 3 2 1
1 223344 2 2 3 3 4 4

Turn it into a string first!

Also, included a zfill just in case not all numbers are 6 digits

dat = [list(map(int, str(x).zfill(6))) for x in df.Number]
d = pd.DataFrame(dat, df.index).rename(columns=lambda x: f'xx + 1')
df.join(d)

 Number x1 x2 x3 x4 x5 x6
0 654321 6 5 4 3 2 1
1 223344 2 2 3 3 4 4

Details

This gets the digits

dat = [list(map(int, str(x).zfill(6))) for x in df.Number]
dat

[[6, 5, 4, 3, 2, 1], [2, 2, 3, 3, 4, 4]]

This creates a new dataframe with the same index as df AND renames the columns to have an 'x' in front and begin with 'x1' and not 'x0'

d = pd.DataFrame(dat, df.index).rename(columns=lambda x: f'xx + 1')
d

 x1 x2 x3 x4 x5 x6
0 6 5 4 3 2 1
1 2 2 3 3 4 4

While string-based solutions are simpler and probably good enough in most cases, you can do this with math which, if you have a big data set, can make a significant difference in speed.

import numpy as np
import pandas as pd

df = pd.DataFrame('Number': [654321, 223344])
num_cols = int(np.log10(df['Number'].max() - 1)) + 1
vals = (df['Number'].values[:, np.newaxis] // (10 ** np.arange(num_cols - 1, -1, -1))) % 10
df_digits = pd.DataFrame(vals, columns=[f'xi + 1' for i in range(num_cols)
df2 = pd.concat([df, df_digits])], axis=1)
print(df2)
# Number x1 x2 x3 x4 x5 x6
# 0 654321 6 5 4 3 2 1
# 1 223344 2 2 3 3 4 4

You could use np.unravel_index

df = pd.DataFrame('Number': [654321,223344])

def split_digits(df):
 # get data as numpy array
 numbers = df['Number'].to_numpy()
 # extract digits
 digits = np.unravel_index(numbers, 6*(10,))
 # create column headers
 columns = ['Number', *(f'xi' for i in "123456")]
 # build and return new data frame
 return pd.DataFrame(np.stack([numbers, *digits], axis=1), columns=columns, index=df.index)


split_digits(df)
# Number x1 x2 x3 x4 x5 x6
# 0 654321 6 5 4 3 2 1
# 1 223344 2 2 3 3 4 4

timeit(lambda:split_digits(df),number=1000)
# 0.3550272472202778

Thanks @GZ0 for some pandas tips.

Assuming that all numbers are of same length (have equal number of digits), I would do it following way using numpy:

import numpy as np
a = np.array([[654321],[223344]])
str_a = a.astype(str)
out = np.apply_along_axis(lambda x:list(x[0]),1,str_a)
print(out)

Output:

[['6' '5' '4' '3' '2' '1']
 ['2' '2' '3' '3' '4' '4']]

Note that out is currently np.array of strs, you might convert it to int if such need arise.

I really liked @user3483203's answer. I think .str.findall could work with any number of digits:

df = pd.DataFrame(
 'Number' : [65432178888, 22334474343]
)

u = df['Number'].astype(str).str.findall(r'(w)')
df.join(pd.DataFrame(list(u)).rename(columns=lambda c: f'xc+1')).apply(pd.to_numeric)

 Number x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11
0 65432178888 6 5 4 3 2 1 7 8 8 8 8
1 22334474343 2 2 3 3 4 4 7 4 3 4 3

Simple way around:

>>> df
 number
0 123456
1 456789
2 135797

First convert the column into string

>>> df['number'] = df['number'].astype(str)

Create the new columns using string indexing

>>> df['x1'] = df['number'].str[0]
>>> df['x2'] = df['number'].str[1]
>>> df['x3'] = df['number'].str[2]
>>> df['x4'] = df['number'].str[3]
>>> df['x5'] = df['number'].str[4]
>>> df['x6'] = df['number'].str[5]

>>> df
 number x1 x2 x3 x4 x5 x6
0 123456 1 2 3 4 5 6
1 456789 4 5 6 7 8 9
2 135797 1 3 5 7 9 7

>>> df.drop('number', axis=1, inplace=True)
>>> df
 x1 x2 x3 x4 x5 x6
0 1 2 3 4 5 6
1 4 5 6 7 8 9
2 1 3 5 7 9 7

@another trick with str.split()

>>> df = df['number'].str.split('(d1)', expand=True).add_prefix('x').drop(columns=['x0', 'x2', 'x4', 'x6', 'x8', 'x10', 'x12'])
>>> df
 x1 x3 x5 x7 x9 x11
0 1 2 3 4 5 6
1 4 5 6 7 8 9
2 1 3 5 7 9 7

>>> df.rename(columns='x3':'x2', 'x5':'x3', 'x7':'x4', 'x9':'x5', 'x11':'x6')
 x1 x2 x3 x4 x5 x6
0 1 2 3 4 5 6
1 4 5 6 7 8 9
2 1 3 5 7 9 7

OR

>>> df = df['number'].str.split(r'(d1)', expand=True).T.replace('', np.nan).dropna().T

>>> df
 1 3 5 7 9 11
0 1 2 3 4 5 6
1 4 5 6 7 8 9
2 1 3 5 7 9 7

>>> df.rename(columns=1:'x1', 3:'x2', 5:'x3', 7:'x4', 9:'x5', 11:'x6')
 x1 x2 x3 x4 x5 x6
0 1 2 3 4 5 6
1 4 5 6 7 8 9
2 1 3 5 7 9 7