Replace the Column Contains the Values 'yes' and 'no' with True and False in Pandas| Python

Values of the Data Frame are supplanted with different qualities progressively. This varies from updating with. loc or. iloc, which expect you to determine an area to refresh with some worth.

to_replace: str, regex, list, dict, Series, int, float, or None

The most effective method to find the qualities that will be supplanted.

numeric, str or regex:

• numeric: numeric qualities equivalent to to_replace will be supplanted with esteem
• str: string precisely coordinating to_replace will be supplanted with esteem
• regex: regexs coordinating to_replace will be supplanted with esteem

List of str, regex, or numeric:

• To start with, if to_replace and esteem are the two records, they should be a similar length.
• Second, in the event that regex=True, the strings in the two records will be all deciphered as regexs if not they will match straightforwardly. This doesn't make any difference much for esteem since there are a couple of conceivable replacement regexes you can utilize.
• str, regex and numeric principles apply as above.

dict:

• Dicts can be utilized to indicate different swap values for various existing qualities. For instance, {'a': 'b', 'y': 'z'} replaces the worth 'a' with 'b' and 'y' with 'z'. To utilize a dict in this manner the worth boundary ought to be None.
• For a Data Frame a dict can determine that various qualities ought to be supplanted in various sections. For instance, {'a': 1, 'b': 'z'} searches for the worth 1 in section 'a' and the worth 'z' in segment 'b' and replaces these qualities with whatever is determined in esteem. The worth boundary ought not be None for this situation. You can regard this as a unique instance of passing two records with the exception of that you are determining the section to look in.
• For a Data Frame settled word references, e.g., {'a': {'b': np.nan}}, are perused as follows: search in segment 'a' for the worth 'b' and supplant it with NaN. The worth boundary ought to be None to utilize a settled dict along these lines. You can settle ordinary articulations also. Note that segment names (the high level word reference keys in a settled word reference) can't be ordinary articulations.

None:

• This implies that the regex contention should be a string, incorporated standard articulation, or rundown, dict, ndarray or Series of such components. In the event that worth is likewise None, this should be a settled word reference or Series.

Value:

• scalar, dict, list, str, regex, default None. Worth to supplant any qualities coordinating to_replace with. For a Data Frame a dict of values can be utilized to determine which worth to use for every section (segments not in the dict won't be filled). Normal articulations, strings and records or dicts of such articles are additionally permitted.

inplace: Boolean, default Bogus

• If Valid, set up. Note: this will adjust some other perspectives on this article (for example a segment from a Data Frame). Returns the guest in the event that this is Valid.

limit: int, default None

• Most extreme size hole to advance or in reverse fill.

regex: bool or same sorts as to_replace, default Bogus

• Whether to decipher to_replace as well as worth as customary articulations. On the off chance that this is Valid, to_replace should a string. On the other hand, this could be a normal articulation or a rundown, dict, or exhibit of standard articulations in which case to_replace should be None.

technique: {'pad', 'ffill', 'bfill', None}

• The technique to involve when for substitution, when to_replace is a scalar, list or tuple and esteem is None. Changed in variant 0.23.0: Added to Data Frame.

Returns:

• Data Frame: Object after substitution

Raises:

• Assertion Error: In the event that regex isn't a bool and to_replace isn't None.

Value Error:

• In the event that to_replace is a dict and esteem is not a rundown, dict, ndarray, or Series. On the off chance that to_replace is None and regex is not compilable into a customary articulation or is a rundown, dict, ndarray, or Series.

Sample Data Frame:

Std data = {'name of the student': ['Ajay', 'Sai', 'Chikky', 'Pavani', 'Pojitha', 'Michael', 'Sri', 'Devi', 'David', 'Gopal'],

'Scores of the Student': [11.5, 7, 20.5, np.nan, 6, 21, 22.5, np.nan, 10, 30],

'Number of attempts': [10, 9, 5, 6, 7, 2, 8, 3, 2, 1],

'Pass': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}

labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

Values for each column will be:

name: 'Anil', score: 18.5, Number of attempts: 1, Pass: 'yes', label: 'k'

Example:

Output:

The Original rows of the student data is:
     Number of attempts	name of the student		Pass		Scores
a         	10 			Ajay	    		yes   		11.5                                  
b         9       			Sai	      		no		    7.0                                  
c         5 			Chikky     		yes   		20.5                                  
d         6      			Pavani      		no    		NaN                                  
e         7      			Pojitha      		no    		6.0                                  
f          2   			Michael     		yes   		21.0                                  
g         8    			Sri	     		yes   		22.5                                  
h         3      			Devi      		no    		NaN                                  
i          2      			David      		no    		10.0                                  
j          1      			Gopal     		yes   		30.0                                  
                                                                       
Here, we are replacing the 'Pass' column contains the values 'yes' and 'no' with True and False:                                                        
   Number of attempts	name of the student		Pass		Scores
a         	10 			Ajay	    		True   		11.5                                  
b          9       			Sai	      		False		    7.0                                  
c          5 			Chikky     		True   		20.5                                  
d          6     			Pavani      		False    	NaN                                  
e         7      			Pojitha      		False    	6.0                                  
f         2    			Michael     		True   		21.0                                  
g         8    			Sri	     		True   		22.5                                  
h         3      			Devi      		False    	NaN                                  
i          2      			David      		False    	10.0                                  
j          1      			Gopal     		True   		30.0               

Using DataFrame.replace() Method

This strategy is utilized to supplant a string, regex, list, word reference, series, number, and so forth from an information outline.

Syntax:

Example:

Output:

The Original rows of the student data is:
     Number of attempts	name of the student		Pass		Scores
a         	10 			Ajay	    		yes   		11.5                                  
b         9       			Sai	      		no		    7.0                                  
c         5 			Chikky     		yes   		20.5                                  
d         6      			Pavani      		no    		NaN                                  
e         7      			Pojitha      		no    		6.0                                  
f          2   			Michael     		yes   		21.0                                  
g         8    			Sri	     		yes   		22.5                                  
h         3      			Devi      		no    		NaN                                  
i          2      			David      		no    		10.0                                  
j          1      			Gopal     		yes   		30.0                                  
                                                                       
Here, we are replacing the 'Pass' column contains the values 'yes' and 'no' with True and False:                                                        
   Number of attempts	name of the student		Pass		Scores
a         	10 			Ajay	    		True   		11.5                                  
b          9       			Sai	      		False		    7.0                                  
c          5 			Chikky     		True   		20.5                                  
d          6     			Pavani      		False    	NaN                                  
e         7      			Pojitha      		False    	6.0                                  
f         2    			Michael     		True   		21.0                                  
g         8    			Sri	     		True   		22.5                                  
h         3      			Devi      		False    	NaN                                  
i          2      			David      		False    	10.0                                  
j          1      			Gopal     		True   		30.0