Appropriate function definition and call

This method gets vowels (‘a’, ‘e’, ‘i’, ‘o’, ‘u’) found in a string.
   
#make a function:
def get_vowels(string):

#return is the keyword which means function have to return value: 
 return [each for each in string if each in 'aeiou']


#assign the words and function will return vowels words.
get_vowels('foobar') # ['o', 'o', 'a']


get_vowels('gym') # []

def when(predicate, when_true):
  return lambda x: when_true(x) if predicate(x) else x
  
EXAMPLES
double_even_numbers = when(lambda x: x % 2 == 0, lambda x : x * 2)
double_even_numbers(2) # 4
double_even_numbers(1) # 1

def unfold(fn, seed):
  def fn_generator(val):
    while True: 
      val = fn(val[1])
      if val == False: break
      yield val[0]
  return [i for i in fn_generator([None, seed])]
  
  
EXAMPLES
f = lambda n: False if n > 50 else [-n, n + 10]
unfold(f, 10) # [-10, -20, -30, -40, -50]

def prepare_master_datasets(df: pd.DataFrame, start_date: str = '2021-01-01', end_date:str = None, time_series_split: bool = True, test_start_date: str = '2021-01-01', test_end_date:str = None, test_size: float = 0.2, random_state: int = 42) -> pd.DataFrame:

	# function definition
    
# Funtion call

master_data, X_train_raw, X_test_raw = prepare_master_datasets(claims_data, 
                                                               start_date='2021-01-01', 
                                                               end_date='2022-12-31', 
                                                               time_series_split = True,
                                                               test_start_date = '2022-06-30', 
                                                               test_end_date = '2022-12-31',
                                                               test_size=0.2, random_state=SEED)

prec = precision_score(y_test, (y_prob> threshold))
f1_sc = f1_score(y_test, (y_prob> threshold))

# Permutation feature importance
feature_importance_scores = []
for feature in X_train_required.columns:
    X_permuted = X_test_required.copy()
    X_permuted[feature] = np.random.permutation(X_permuted[feature])
    permuted_preds = cb_model.predict(X_permuted)
    permuted_prec = precision_score(y_test, permuted_preds)
    feature_importance = prec - permuted_prec
    feature_importance_scores.append((feature, feature_importance))
# feature_importance_scores.sort(key=lambda x: x[1], reverse=True)
feat=[]
imp=[]
for feature, importance in feature_importance_scores:
    feat.append(feature)
    imp.append(importance)   
    # print(f"Feature: {feature}, Importance: {importance}")
feature_imp = pd.DataFrame(columns=['Feature', 'Importance'])
feature_imp['Feature']=feat
feature_imp['Importance']=imp
feature_imp.sort_values(by='Importance', ascending=False, inplace=True)
feature_imp.to_csv('OMI-trans-perm.csv')

from functools import reduce

def compose(*fns):
  return reduce(lambda f, g: lambda *args: f(g(*args)), fns)


EXAMPLES
add5 = lambda x: x + 5
multiply = lambda x, y: x * y
multiply_and_add_5 = compose(add5, multiply)

multiply_and_add_5(5, 2) # 15

#define a function 
 1.Def cube(num)
      #write the formula of cube
      2.return num*num*num
     #give the number to calculate the cube 
     3.cube(3)
   # print the cube of that number simply by using print command
    4.print(cube(3))
     5.“return” keyword means that function have to return value         

#define function
defall_unique(lst):

   return len(lst) == len(set(lst))
   
x = [1,1,2,2,3,2,3,4,5,6]


y = [1,2,3,4,5]


all_unique(x) # False
all_unique(y) # True

 # give a name of function after def
 1.def sayhi():
      #put the statement in the function  
     2.print(“hello world”)
#call function by name:
3.sayhi()


Output: 
Hello world

#define a function 
 Def cube(num)
      #write the formula of cube
      return num*num*num
     #give the number to calculate the cube 
     cube(3)
   # print the cube of that number simply by using print command
    print(cube(3))
     “return” keyword means that function have to return          value

Use functools.reduce() to perform right-to-left function composition. The last (rightmost) function can accept one or more arguments; the remaining functions must be unary.
from functools import reduce

1.def compose(*fns):
  2.return reduce(lambda f, g: lambda *args: f(g(*args)), fns)
EXAMPLES
add5 = lambda x: x + 5
multiply = lambda x, y: x * y
multiply_and_add_5 = compose(add5, multiply)

multiply_and_add_5(5, 2) # 15

def byte_size(string):

  return(len(string.encode('utf-8')))

byte_size('😀’) # 4
byte_size('Hello World') # 11

add_action( 'wp_body_open', 'wpdoc_add_custom_body_open_code' );
 
function wpdoc_add_custom_body_open_code() {
    echo '<!-- Google Tag Manager (noscript) --> ... <!-- End Google Tag Manager (noscript) -->';
}

for c in df_drop.columns:
    df_drop[c] = df_drop[c].str.replace('[^\w\s]+', '')
df_drop = df_drop.astype(str)
df_drop.head()

rmsval = df.loc[:, 'c1':'c4']
def getrms(row):  
  a = np.sqrt(sum(row**2/4))
  return a
df['rms'] = df.apply(getrms,axis=1)
df.head()