You can handle the positive case using the following:

In [150]:
import re
df['fundleverage'] = '+' + df['name'].str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('X') + '00'
df

Out[150]:
                 name fundleverage
0  BULL AXP UN X3 VON         +300
1    BULL ESTOX X12 S        +1200

You can use np.where to handle both cases in a one liner:

In [151]:
df['fundleverage'] = np.where(df['name'].str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('X').str.isdigit(),  '+' + df['name'].str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('X') + '00', '+100')
df

Out[151]:
                 name fundleverage
0  BULL AXP UN X3 VON         +300
1    BULL ESTOX X12 S        +1200

So the above uses the vectorised str methods strip, extract and isdigit to achieve what you want.

Update

After you changed your requirements (which you should not do for future reference) you can mask the df for the bull and bear cases:

In [189]:
import re
df = pd.DataFrame(["BULL AXP UN X3 VON", "BEAR ESTOX 12x S"], columns=["name"])
bull_mask_name = df.loc[df['name'].str.contains('bull', case=False), 'name']
bear_mask_name = df.loc[df['name'].str.contains('bear', case=False), 'name']
df.loc[df['name'].str.contains('bull', case=False), 'fundleverage'] = np.where(bull_mask_name.str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('X').str.isdigit(),  '+' + bull_mask_name.str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('X') + '00', '+100')
df.loc[df['name'].str.contains('bear', case=False), 'fundleverage'] = np.where(bear_mask_name.str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('x').str.isdigit(),  '-' + bear_mask_name.str.extract(r"(X\d+|\d+X)\s", flags=re.IGNORECASE).str.strip('x') + '00', '-100')
df

Out[189]:
                 name fundleverage
0  BULL AXP UN X3 VON         +300
1    BEAR ESTOX 12x S        -1200

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

Copyletsago = "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:

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

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

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

or the globals function:

Copyclass 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.

You are defining a string here: myZip = "textinhere.txt"

exctractall is a method of the ZipFile class. So you need to construct an instance of ZipFile first, assuming this name is the file you wish to use as a path for the ZipFile instance:

myZip = ZipFile("textinhere.txt")

...Only then can you call myZip.extractall(...

Try this:

df['landing_screen_name'] = df['landing_screen_name'].str.extract(r'(.{0,13}\.html)')

CopyIn [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

Try this:

import scrapy
class CybexbotSpider(scrapy.Spider): 
   name = 'cybexbot'
   allowed_domains = ['http://links.com']
   start_urls = ['http://links.com']
   def parse(self, response):
       data=response.xpath('//tr[contains(@class,"GridView")]')
       for d in data[1:]:
         print(type(d))
         temp=dict()
         temp['Code']=d.xpath('tr//td[1]/a/text()').extract()
         temp['Desc']=d.xpath('tr//td[2]/a/text()').extract()
         yield temp

Once you extract it, it becomes a string so the library can no longer process it

If use Series.apply then in function gr is scalar, function loop by element of Series. So cannot use Series functions for it like str.extract, but solution for processing by scalars:

def clear_teams(gr):
    try:
        return re.search(r'(\w+)+', text).group(1)
    except:
        return np.nan   

df['team'] = df['team'].apply(clear_teams)

If use Series.pipe then gr is Series, co all working correct:

def clear_teams(gr):
    return gr.str.extract(r'(\w+)+')

df['team'] = df['team'].pipe(clear_teams)

Or:

df['team'] = clear_teams(df['team'])

Since

self.board = [['.']*8 for _ in range(8)]

for some values of i and j, self.board[i][j] is a string. Therefore,

self.board[i][j].sl=='R'

is raising AttributeError: 'str' object has no attribute 'sl' because strings have no sl attribute.

Perhaps the easiest way to fix your code with minimal changes would be to add an Empty class similar to other chess piece classes to represent unoccupied squares on the chess board. Make sure instances of the Empty class have an sl attribute.

Note however that it is not clear (to me) that you really need separate classes for each kind of chess piece. They are all basically the same kind of object, they merely differ in terms of how they move. So you may be better off with one chess piece class and give each instance a kind attribute which could equal 'rook', 'knight', etc.

Also note that in your code there is redundant information: The self.board records the location of the pieces, and the chess piece also records the location:

    self.board[7][0] = Rook(x=7,y=0,sl='R',team='white')

Recording the information in two places poses a problem:

• The information may become corrupted -- if the logic in your code is not correct, the board may record the location of a piece in a different place than where the piece itself thinks it is on the board. Thus you have a coordination problem.

• Having the information in two places makes your code more complicated because you have to update the location in both the board and the chess piece to maintain consistency every time a piece is moved.

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]

Your code has multiple problems - not just the one that has been answered by @Tanishq

You entire approach is not ideal. It's much better to limit your Student class to storing data and handling its representation. Acquisition of the data should be dealt with separately.

Something like this:

Copyfrom typing import Any

class Student:
    def __init__(self, name: str):
        self._name: str = name
        self._data: dict[str, float] = {}
        
    def __add__(self, __value: Any) -> 'Student':
        subject, score = __value
        self._data[subject] = score
        return self

    def __str__(self):
        r = [self._name]
        for subject, score in self._data.items():
            r.append(f'{subject} -> {score}')
        return '\n'.join(r)

name = input('Student name: ')
student = Student(name)
n = int(input('Number of subjects: '))
for _ in range(n):
    subject = input('Subject name: ')
    score = float(input('Score: '))
    student += (subject, score)
print(student)

Console example:

CopyStudent name: John
Number of subjects: 2
Subject name: English
Score: 65
Subject name: Geography
Score: 58
John
English -> 65.0
Geography -> 58.0

Note:

Numeric input validation omitted for brevity

• Correcting the code as shown below after following the links given in the comments by @SolomonUcko, the requirement was achieved without any error and status as succeeded.

from azure.identity import DefaultAzureCredential, ClientSecretCredential
from azure.synapse.artifacts import ArtifactsClient
from azure.synapse.artifacts.models import SqlScript,SqlScriptContent,SqlScriptResource,SqlConnection
import json


workspace_name = 'synapse2403'
subscription_id = '<subscription_id>'
resource_group = '<resource_grp'
workspace_endpoint = f"https://<workspace_name>.dev.azuresynapse.net"

#my credentials
tenant_id='<tenant_id>'
client_id='<client_id>'
client_secret='<client_secret>'
credential = ClientSecretCredential(tenant_id,client_id,client_secret)

client = ArtifactsClient(
credential = credential,
subscription_id = subscription_id,
endpoint = workspace_endpoint
)

#sql script as string
sql_script_content='create table demo(id int, gname varchar(40))'


sql_conn = SqlConnection(name='pool1',type='SqlPool')   #SqlConnection object for SqlScriptContent
sql_cnt = SqlScriptContent(query = sql_script_content, current_connection=sql_conn)    #SqlScriptContent object for SqlScript
sql_scrpt = SqlScript(type = 'SqlQuery', content = sql_cnt)    #SqlScript object for SqlScriptResource 
sql_resource = SqlScriptResource(name = 'myresource', properties = sql_scrpt)    #SqlScriptResource for begin_create_or_update_sql_script
sql_scripts_operations = client.sql_script

create_or_update_script_response = sql_scripts_operations.begin_create_or_update_sql_script(
sql_script_name = 'sql_query.sql',
sql_script = sql_resource
)

• The following is the output image for reference.

You convert the geometry dict to string using json.dumps and pass the string to wkb.dumps() method. But it requires a shapely geometry. Therefore, you get 'str' object has no attribute '_geom' error. Leave it as is.

And to get the geom_wkb for different type of geometry, you need to check geometry type, make a geometry from coordinates, then pass the geometry to wkb.dumps() method.

Use the following if statement instead of yours:

if decoded_content['type'] == "FeatureCollection":
    
    for (idx, obj) in enumerate(decoded_content['features']):
        
        geom_type = obj['geometry']['type']
        coords = obj['geometry']['coordinates']
        
        if geom_type == 'Point':
            geom = Point(coords)
        elif geom_type == 'LineString':
            geom = LineString(coords)
        elif geom_type == 'Polygon':
            geom = Polygon(coords)
        elif geom_type == 'MultiPoint':
            geom = MultiPoint(coords)
        elif geom_type == 'MultiLineString':
            geom = MultiLineString(coords)
        elif geom_type == 'MultiPolygon':
            geom = MultiPolygon(coords)
        else:
            raise Exception("unidentified flying geometry detected")
             
        geom_wkb = wkb.dumps(geom, hex=True, srid=3857)
        print(geom_wkb)

# OUT
# 01020000A0110F00000300000063FA8C6D360716C19E66053BD2FE5C410000000000000000D038FD60350E16C1947EE3FCAAFE5C410000000000000000D2698E53341516C1C3771FBC83FE5C410000000000000000

Add from shapely.geometry import * to imports.