Create all pairs combinations of columns names, loop and divide to new columns:

from  itertools import combinations

for a, b in combinations(df.columns, 2):
    df[f'{a}/{b}'] = df[a].div(df[b])

Or use list comprehension, join together by concat and add original columns by join:

df = df.join(pd.concat([df[a].div(df[b]).rename(f'{a}/{b}') 
                         for a, b in combinations(df.columns, 2)], 1))

print (df)
   x1  x2  x3  x4     x1/x2     x1/x3     x1/x4     x2/x3     x2/x4     x3/x4
0   4   7   1   5  0.571429  4.000000  0.800000  7.000000  1.400000  0.200000
1   5   8   3   3  0.625000  1.666667  1.666667  2.666667  2.666667  1.000000
2   4   9   5   6  0.444444  0.800000  0.666667  1.800000  1.500000  0.833333
3   5   4   7   9  1.250000  0.714286  0.555556  0.571429  0.444444  0.777778
4   5   2   1   2  2.500000  5.000000  2.500000  2.000000  1.000000  0.500000
5   4   3   0   4  1.333333       inf  1.000000       inf  0.750000  0.000000

We can take advantage of the way that Boolean values are handled mathematically (True being 1 and False being 0) and use 3 aggregation functions sum, count and mean per group (groupby aggregate). We can also take advantage of Named Aggregation to both create and rename the columns in one step:

df = (
    df.groupby('playerId', as_index=False)
        .agg(wins=('winner', 'sum'),
             totalCount=('winner', 'count'),
             winPct=('winner', 'mean'))
)
# Scale up winPct
df['winPct'] *= 100

df:

   playerId  wins  totalCount  winPct
0      1848     1           2    50.0
1      1988     0           2     0.0
2      3543     1           1   100.0

DataFrame and imports:

import pandas as pd

df = pd.DataFrame({
    'playerId': [1848, 1988, 3543, 1848, 1988],
    'winner': [True, False, True, False, False]
})

Try (with the original df):

df.groupby("Department")["Status"].value_counts(normalize=True).mul(100)

Outputs:

Department  Status
Finance     Contractor    100.000000
Marketing   Contractor     50.000000
            Employee       50.000000
Sales       Employee       66.666667
            Contractor     33.333333
Name: Status, dtype: float64

If your columns are all named consistently using the exact pattern in your question, you can do something like this:

for i in range(1, 101):
    df['ratio_b{}'.format(i)] = df['b{}_amt'.format(i)] / df['total_balance']

This should do:

df['price_per_sqft'] = df['SalePrice']/df['LotArea']

or you can use pd.assign

df.assign(price_per_sqft = df.SalePrice/df.LotArea)

Try to use this:

(df.groupby(["gender", "yes/no"]).size()/df.groupby(["yes/no"]).size()).rename('ratio').reset_index()

If I understand you correctly, you are describing the following:

Setup

d = {'id1': ['x', 'x'], 'id2': ['z','w'], 'metric': [100,10] }
df = pd.DataFrame(data=d)
df

Solution

# Manually choose the value by which to scale the column 'metric'
scaler = df.loc[(df['id1'] == 'x') & (df['id2'] == 'z'), 'metric'].values

# Divide all 'metric' values by the above scaler value
df['result'] = df['metric'] / scaler

df
  id1 id2  metric  result
0   x   z     100     1.0
1   x   w      10     0.1

I think you need convert string columns to float or int, because their type is string (but looks like numbers):

Apple_farm['Good_apples'] = Apple_farm['Good_apples'].astype(float)
Apple_farm['Total_apples'] = Apple_farm['Total_apples'].astype(float)

Apple_farm['Good_apples'] = Apple_farm['Good_apples'].astype(int)
Apple_farm['Total_apples'] = Apple_farm['Total_apples'].astype(int)

Sample:

import pandas as pd

Good_apples = ["10", "20", "3", "7", "9"]
Total_apples = ["20", "80", "30", "70", "90"]
d = {"Good_apples": Good_apples, "Total_apples": Total_apples}
Apple_farm = pd.DataFrame(d)
print Apple_farm 
  Good_apples Total_apples
0          10           20
1          20           80
2           3           30
3           7           70
4           9           90

print Apple_farm.dtypes
Good_apples     object
Total_apples    object
dtype: object

print Apple_farm.at[0,'Good_apples']
10

print type(Apple_farm.at[0,'Good_apples'])
<type 'str'>

Apple_farm['Good_apples'] = Apple_farm['Good_apples'].astype(int)
Apple_farm['Total_apples'] = Apple_farm['Total_apples'].astype(int)

print Apple_farm.dtypes
Good_apples     int32
Total_apples    int32
dtype: object

print Apple_farm.at[0,'Good_apples']
10

print type(Apple_farm.at[0,'Good_apples'])
<type 'numpy.int32'>

Apple_farm['Perc_Good'] = (Apple_farm['Good_apples'] / Apple_farm['Total_apples']) *100

print Apple_farm
   Good_apples  Total_apples  Perc_Good
0           10            20       50.0
1           20            80       25.0
2            3            30       10.0
3            7            70       10.0
4            9            90       10.0

You could use apply. The general idea is to iterate over the "target" columns and count the number of matches with "value" columns (with eq on axis + sum); then find the ratio by dividing the totals found with the number of non-NaN rows for each "value" column:

val_cols = ['value1','value2','value3']
totals = df[val_cols].notna().sum()
out = df[['target1','target2']].apply(lambda col: df[val_cols].eq(col, axis=0).sum() / totals)

# out.rename_axis('value_cols').reset_index()

Output:

         target1   target2
value1  0.666667  0.333333
value2  0.333333  0.500000
value3  0.333333  0.666667

I think you need groupby with transform sum and then divide by div:

rat = names.groupby(['year','sex'])['births'].transform('sum')
print (rat)
0     13611
1     13611
2     13611
3     13611
4        20
5        20
6        20
7        20
8     13503
9     13503
10    13503
11    13503
12       20
13       20
14       20
15       20
Name: births, dtype: int64

names['ratio'] = names.births.div(rat)
print (names)
         name sex  births  year     ratio
0        Mary   F    7065  1880  0.519065
1        Anna   F    2604  1880  0.191316
2        Emma   F    2003  1880  0.147160
3   Elizabeth   F    1939  1880  0.142458
4      Worthy   M       5  1880  0.250000
5      Wright   M       5  1880  0.250000
6        York   M       5  1880  0.250000
7   Zachariah   M       5  1880  0.250000
8        Mary   F    6919  1881  0.512405
9        Anna   F    2698  1881  0.199807
10       Emma   F    2034  1881  0.150633
11  Elizabeth   F    1852  1881  0.137155
12     Wilton   M       5  1881  0.250000
13       Wing   M       5  1881  0.250000
14       Wood   M       5  1881  0.250000
15     Wright   M       5  1881  0.250000

Solution with assign:

names = names.assign(ratio=lambda x: x.births.div(rat))
print (names)
         name sex  births  year     ratio
0        Mary   F    7065  1880  0.519065
1        Anna   F    2604  1880  0.191316
2        Emma   F    2003  1880  0.147160
3   Elizabeth   F    1939  1880  0.142458
4      Worthy   M       5  1880  0.250000
5      Wright   M       5  1880  0.250000
6        York   M       5  1880  0.250000
7   Zachariah   M       5  1880  0.250000
8        Mary   F    6919  1881  0.512405
9        Anna   F    2698  1881  0.199807
10       Emma   F    2034  1881  0.150633
11  Elizabeth   F    1852  1881  0.137155
12     Wilton   M       5  1881  0.250000
13       Wing   M       5  1881  0.250000
14       Wood   M       5  1881  0.250000
15     Wright   M       5  1881  0.250000

Looks like you want the ratio of y1 to the total instead. Use groupby + value_counts:

v = df.groupby('AAA').BBB.value_counts().unstack()
df['RATIO'] = df.AAA.map(v.y2 / (v.y2 + v.y1))

  AAA BBB CCC  DDD     RATIO
0  x1  y1  t1   10  0.333333
1  x1  y1  t2   11  0.333333
2  x1  y2  t3   18  0.333333
3  x2  y2  t1   17  0.666667
4  x2  y2  t1   21  0.666667
5  x2  y1  t1   30  0.666667

To generalise for many groups, you may use

df['RATIO'] = df.AAA.map(v.y2 / v.sum(axis=1))

This can be merge:

df2['sum'] = (df2.merge(df, on=['ID','ID2'],
                        how='left')
                 .assign(sum=lambda x: x.sum_x/x.sum_y)
                 ['sum']
             )

Output:

       ID ID2 TYPE        sum
0  100001   G    A        NaN
1  100002   H    A        NaN
2  100002   Q    B        NaN
3  100003   J    A        NaN
4  100003   H    B        NaN
5  100001   A    C  14.285714
6  100002   B    E   1.250000

Just subset your data frame using that ratio:

df[df$Male / df$Female > 0.5, ]

     Cars Male Female
2 vw golf   76     12
3 ford ka   34     55

Demo