try this :-

carprice['fueltype']=carprice['fueltype'].map({'gas':1,'diesel':0})

or you can do

carprice['fueltype']=carprice['fueltype'].apply(lambda x: 1 if x =='gas' else 0))

Map basically operates on the series while apply works on each cell.

I'm not sure why you're using map here. Iterating over a dictionary gives you the keys only, which are strings. Just use the dict directly; you don't need lambda either:

my_dict.get('a').get('b')

(As noted in the comments, you shouldn't use dict as the name of your variable.)

The problem is in your playerMovement method. You are creating the string name of your room variables (ID1, ID2, ID3):

letsago = "ID" + str(self.dirDesc.values())

However, what you create is just a str. It is not the variable. Plus, I do not think it is doing what you think its doing:

>>>str({'a':1}.values())
'dict_values([1])'

If you REALLY needed to find the variable this way, you could use the eval function:

>>>foo = 'Hello World!'
>>>eval('foo')
'Hello World!'

or the globals function:

class Foo(object):
    def __init__(self):
        super(Foo, self).__init__()
    def test(self, name):
        print(globals()[name])

foo = Foo()
bar = 'Hello World!'
foo.text('bar')

However, instead I would strongly recommend you rethink you class(es). Your userInterface class is essentially a Room. It shouldn't handle player movement. This should be within another class, maybe GameManager or something like that.

In [23]: df1
Out[23]: 
  Name    income
0    a        $1
1    b    $2,000
2    c   $10,000
3    d  $140,000

In [24]: cols_to_change = ['income']

In [25]: for col in cols_to_change:
    ...:     df1[col] = df1[col].str.replace('[$,]', '')
    ...: 

In [26]: df1
Out[26]: 
  Name  income
0    a       1
1    b    2000
2    c   10000
3    d  140000

Here is another possible solution:

In order to print an object of any class that you created, you must implement the __str__() method or the __repr__() method as an official string representation of your objects. So, here is the modified Animal class:

class Animal:
    def __init__(self, name, year_of_birth):
        self.name = name
        self.year_of_birth = year_of_birth # Added this field because your created Animal objects had it in the example.

    def __str__(self):
        return self.name + " " + str(self.year_of_birth)

    def __repr__(self):
        return self.name + " " + str(self.year_of_birth)

Next thing, I simplified your add_member() method because there was no reason for self.member = member:

def add_member(self, member):
        self.members.append(member)

Next, I modified your print_team() function like this:

def print_team(team):
    list_members= []
    for member in team.members:
        list_members.append(member)

    print("Unsorted: ")
    print (list_members)

    list_members.sort(key = lambda animal: animal.name)

    print("Sorted by name: ")
    print (list_members)

You can simply append any object of type Animal in the list_members list. After that, you can sort your list using sort() and then print it. The code below:

team = Team('Wolves',2015)
team.add_member(Animal('Josh',2015))
team.add_member(Animal('Quinn',2145))
team.add_member(Animal('Peter',3000))
print_team(team)  

Produces the following result:

Unsorted: 
[Josh 2015, Quinn 2145, Peter 3000]
Sorted by name: 
[Josh 2015, Peter 3000, Quinn 2145]

The error means exactly what it says:

AttributeError: 'str' object has no attribute 'DataFrame' 
      ^           ^                                ^
the kind of error |                                |
       the thing you tried to use      what was missing from it

The line it's complaining about:

df = pd.DataFrame(date, columns = ['Date'])
     ^      ^
     |   the attribute the error said was missing
the thing the error said was a string

has been working no problem until I added a few lines of code above

Evidently, somewhere in the "few lines of code above", you caused pd to be a string. And sure enough, when we look at those few lines of code, we find:

pd = PDays[j]
^       ^
|    the string that you're making it into
the thing that you're making a string

Look at these two lines:

vertex = my_queue.pop()
# ...
my_queue = str(test)

So, after the first time through the loop, my_queue is obviously a str, because you explicitly convert it to one.

You can see a list of String Methods and Common Sequence Operations. Notice that pop doesn't appear anywhere there. That's because pop is only a method of Mutable Sequence Types like list. Which is exactly what this error is telling you:

AttributeError: 'str' object has no attribute 'pop'

And even if there were such a method, what would you expect it to return? The first character of the string? How would that work with for n_vertex in vertex['neighbors'], which clearly expects vertex to be a dict (or other Mapping type), not a single-character string?

I'm not sure what exactly you're trying to do at the end, but I suspect that removing the str() call won't be enough on its own to solve all of your problems. You're appending to a list named test that isn't defined anywhere in the function, so presumably it's a global variable. You then throw away whatever was in my_queue and instead assign it to that global variable. That can't possibly be what you want. My guess—but this is only a guess—is that you want to replace those last two lines with this:

my_queue.insert(0, my_data[int_vertex])

There are a few problems with your script. Firstly, to define a layer to load on completion, you must an additional parameter of type QgsProcessingParameterFeatureSink in the initAlgorithm() method.

Then, when you call the native fix geometries algorithm inside the processAlgorithm() method, the output parameter should be: parameters['OUTPUT'].

That will give you the checkbox in the dialog: 'Open output file after running algorithm'

Renaming the output file is a little more involved. To do this you need to add a Layer Post Processor class and rename the layer inside this class. Then create an instance of this class at the end of the processAlgorithm() method and pass it to the setPostProcessor() method chained to the layerToLoadOnCompletionDetails() method of the QgsProcessingContext object.

Working modified script below (maybe not perfect but it's working!):

# -*- coding: utf-8 -*-

from qgis.PyQt.QtCore import QCoreApplication
from qgis.core import (QgsProcessing,
                       QgsFeatureSink,
                       QgsProcessingException,
                       QgsProcessingAlgorithm,
                       QgsProcessingParameterFeatureSource,
                       QgsProcessingParameterFeatureSink,
                       QgsVectorLayer,
                       QgsProcessingLayerPostProcessorInterface)
from qgis import processing


class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
    INPUT1 = 'INPUT1'
    OUTPUT = 'OUTPUT'
    def tr(self, string):
        return QCoreApplication.translate('Processing', string)
    def createInstance(self):
        return ExampleProcessingAlgorithm()
    def name(self):
        return 'testpersistence'
    def displayName(self):
        return self.tr('Testpersistence')
    def group(self):
        return self.tr('Example scripts')
    def groupId(self):
        return 'examplescripts'
    def shortHelpString(self):
        return self.tr("Testing the script")

    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT1,
                self.tr('Input layer 1'),
                [QgsProcessing.TypeVectorAnyGeometry]
            )
        )
        self.addParameter(QgsProcessingParameterFeatureSink(
            self.OUTPUT,
            self.tr("Output layer"),
            QgsProcessing.TypeVectorAnyGeometry))
        
    def processAlgorithm(self, parameters, context, feedback):
        source1 = self.parameterAsSource(parameters,self.INPUT1,context)
        fixgeometries1_result = processing.run(
            'native:fixgeometries',
            {
                'INPUT': parameters['INPUT1'],
                'OUTPUT': parameters['OUTPUT']
            },
            is_child_algorithm=True,
            context=context,
            feedback=feedback)

        dest_id = fixgeometries1_result['OUTPUT']
        
        if context.willLoadLayerOnCompletion(dest_id):
            context.layerToLoadOnCompletionDetails(dest_id).setPostProcessor(MyLayerPostProcessor.create())

        return {}
        
        
class MyLayerPostProcessor(QgsProcessingLayerPostProcessorInterface):
    # Courtesy of Nyall Dawson: https://gist.github.com/nyalldawson/26c091dd48b4f8bf56f172efe22cf75f
    instance = None

    def postProcessLayer(self, layer, context, feedback):  # pylint: disable=unused-argument
        if not isinstance(layer, QgsVectorLayer):
            return

        layer.setName('Renamed layer')
        

    # Hack to work around sip bug!
    @staticmethod
    def create() -> 'MyLayerPostProcessor':
        """
        Returns a new instance of the post processor, keeping a reference to the sip
        wrapper so that sip doesn't get confused with the Python subclass and call
        the base wrapper implementation instead... ahhh sip, you wonderful piece of sip
        """
        MyLayerPostProcessor.instance = MyLayerPostProcessor()
        return MyLayerPostProcessor.instance

The code for the MyLayerPostProcessor() class I adapted from a github gist of Nyall Dawson's here.

See a gif below showing this script working and loading a renamed layer:

your issue is caused by class_weight="balanced" parameter that you pass to model.fit()

according to the model.fit() reference, this parameter should be a dict: Optional dictionary mapping class indices (integers) to a weight (float) value, used for weighting the loss function (during training only). This can be useful to tell the model to "pay more attention" to samples from an under-represented class.

try class_weight=None for testing, it should get rid of the original error. Later provide proper dict as class_weight to address imbalanced dataset issue.