Scikit Learn's train_test_split is a good one. It will split both numpy arrays and dataframes.

from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.2)

Use np.array_split

shuffled = df.sample(frac=1)
result = np.array_split(shuffled, 5)  

df.sample(frac=1) shuffle the rows of df. Then use np.array_split split it into parts that have equal size.

It gives you:

for part in result:
    print(part,'\n')

    movie_id  1  2  4  5  6  7  8  9  10  11  12  borda
5          6  5  0  0  0  0  0  0  5   0   0   0     10
4          5  3  0  0  0  0  0  0  0   0   0   0      3
7          8  1  0  0  0  4  5  0  0   0   4   0     14
16        17  3  0  0  4  0  0  0  0   0   0   0      7
22        23  4  0  0  0  4  3  0  0   5   0   0     16 

    movie_id  1  2  4  5  6  7  8  9  10  11  12  borda
13        14  5  4  0  0  5  0  0  0   0   0   0     14
14        15  5  0  0  0  3  0  0  0   0   5   5     18
21        22  4  0  0  0  3  5  5  0   5   4   0     26
1          2  3  0  0  3  0  0  0  0   0   0   0      6
20        21  1  0  0  3  3  0  0  0   0   0   0      7 

    movie_id  1  2  4  5  6  7  8  9  10  11  12  borda
10        11  2  0  4  0  0  3  3  0   4   2   0     18
9         10  3  2  0  0  0  4  0  0   0   0   0      9
11        12  5  0  0  0  4  5  0  0   5   2   0     21
8          9  5  0  0  0  4  5  0  0   4   5   0     23
12        13  5  4  0  0  2  0  0  0   3   0   0     14 

    movie_id  1  2  4  5  6  7  8  9  10  11  12  borda
18        19  5  3  0  0  4  0  0  0   0   0   0     12
3          4  3  0  0  0  0  5  0  0   4   0   5     17
0          1  5  4  0  4  4  0  0  0   4   0   0     21
23        24  3  0  0  4  0  0  0  0   0   3   0     10
6          7  4  0  0  0  2  5  3  4   4   0   0     22 

    movie_id  1  2  4  5  6  7  8  9  10  11  12  borda
17        18  4  0  0  0  0  0  0  0   0   0   0      4
2          3  4  0  0  0  0  0  0  0   0   0   0      4
15        16  5  0  0  0  0  0  0  0   4   0   0      9
19        20  4  0  0  0  0  0  0  0   0   0   0      4 

Here's code for this specific case. I don't think it can be generalized much.

The idea is from the areas that are allowed in group C, sample 0.1 * 800 = 80 of them and mark them as belonging to group C. Then from the unmarked rows that have areas allowed in group B, select 240 of them and mark them as belonging to group B. All the rest must be in group A.

import pandas as pd
import random

allowed = {
    'A':"Allston Boston Brighton Fenway Brookline Cambridge Newton".split(),
    'B':"Allston Boston Brighton Fenway".split(),
    'C':"Boston Brighton Fenway".split()
}

weight = {
    'A':0.6,
    'B':0.3,
    'C':0.1
}

# create random areas that meet the requirements 10% group C, 30% group B and 60% group A
rows = []
for area in random.choices(list(weight.keys()), weights=weight.values(), k=800):
    rows.append(random.choice(allowed[area]))

# create a dummy data frame
df = pd.DataFrame({'areas':rows,
                   'price':[random.randrange(1000, 5000) for _ in range(len(rows))]})

# add a column for the group, set to '' to indicate unassigned
df['group'] = ['']*len(rows)

for group in 'CBA':
    # Select rows that are not assigned to a group and that have areas that are
    # allowed for the current group. Then randomly sample the selected rows.
    xs = df[(df.group=='') & df['areas'].isin(allowed[group])].sample(n=int(len(rows)*weight[group]))

    # Mark the sampled rows with the group
    df.loc[xs.index,'group'] = group

    # this just to see what's happening
    print(group, len(xs))
    print(df.head())
    print()

The end result is the DataFrame has a column 'group' with a randomly assigned value according to the given constrains.

If you do not care about the new dataframes potentially containing some of the same information, you could use sample where frac specifies the fraction of the dataframe that you desire

df1 = df.sample(frac=0.5) # df1 is now a random sample of half the dataframe

EDIT:

If you want to avoid duplicates, you can use shuffle from sklearn

from sklearn.utils import shuffle

df = shuffle(df)
df1 = df[0:3]
df2 = df[3:6]

There are a number of ways to create a new column for experiments. Here is one method that builds upon the sample() function you were using:

import pandas as pd
import numpy as np

# some sample data
devices = pd.DataFrame({'DeviceId': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})

# initialize experiment column to 'A'
devices['Experiment'] = 'A'

# use the index of a sampling to change ~50% of the labels to 'B'
devices.loc[devices.sample(frac=0.5, replace=False).index,'Experiment'] = 'B'

In my example, I got the following counts:

>>> devices.groupby('Experiment').count()

Experiment  DeviceId
A           5
B           6

Or, if you wanted to use your coin() function - you could try apply() (though this is probably slower):

devices['Experiment'] = devices.apply(lambda x: coin(), axis=1)

As an aside, having 1,111 more entries in B than A is not a bug- it's a consequence of generating (psuedo) random numbers. Looking at those numbers as a percentage of your populations:

A=0.49994068312326473
B=0.5000593168767353

Which is very close to the 50/50 split you wanted. The more samples you draw, the closer you'll approach 50/50 (theoretically).

As Quang Hoang suggested in the comments. You can split your ids and then select the data based on those ids.

test_ids = df.player_id.drop_duplicates().sample(frac=0.2).values
#-> array([2])

train_data = df[~df["player_id"].isin(test_ids)]
"""
    player_id  year  overall
0           1     1       20
1           1     2       16
4           3     1        8
5           3     2       80
6           4     1       20
7           4     2       12
8           5     1        9
9           5     2        3
10          6     1        2
11          6     2        1
"""

test_data = df[df["player_id"].isin(test_ids)]
"""
   player_id  year  overall
2          2     1        7
3          2     2        3
"""