Can't change class variable with outside function in Python

The problem is that you made equipped_weapon a class attribute, not an instance attribute. del instance.attribute only deletes instance attributes, it doesn't even look for class attributes.

If the goal is just to change the instance, you can just remove the del entirely; the next line will add (if no instance attribute exists, shadowing the class attribute) or replace (if an instance attribute already exists) the instance's specific weapon.

If the goal is to change the class, you need to change the assignment to operate on the class:

type(player).equipped_weapon = new_weapon_code

or explicitly naming the class:

Player.equipped_weapon = new_weapon_code

Either way, the del isn't necessary; assigning the new value replaces the old one, implicitly dropping the reference to the old value in the same way that del does explicitly. It would be perfectly legal to do del type(player).equipped_weapon or del Player.equipped_weapon to delete the class attribute specifically, but it's pointless; whatever the desired behavior, simple assignment to either the class or the instance attribute will discard the old reference anyway.

UPDATE: As you noted, removing the del prevents the exception, but your output (from see_inventory) never changes. That's because see_inventory is looking at Player.inv, which in turn contains a reference to the original value of Player.ui_equipped_weapon. Problem is, while ui_equipped_weapon and equipped_weapon are initialized based on the same default weapon, they're not synced to one another; changing one has no effect on the other (and therefore changing equipped_weapon, on the class or instance, doesn't affect inv, so see_inventory never changes).

Really, the solution here is to make a sane class. None of your class attributes make sense; they're all logically instance attributes and should be defined as such. In a few cases, they're just convenience-oriented transformations of another attribute; in those cases, they shouldn't be attributes at all, but rather propertys, which dynamically recompute their value based on another attribute, preventing them from getting out of sync.

Here's a really quick (not tested, might have small typos) rewrite that moves all your justified attributes to the instance, and converts the rest to read-only properties that derive their value from another instance attribute:

import copy

# Factored out to avoid repetition
def clean_armor(armor):
    return {k.rstrip(':'): v
            for k, v in armor.items() if k in {'Name:', 'Defense:'}}

class Person:
    DEFAULT_WEAPON = weapon_rusty_sword
    DEFAULT_ARMOR = {
        "Head Protection:": clean_armor(armor_head_rusty_cap),
        "Chest Protection:": clean_armor(armor_chest_rusty_mail),
        "Legs Protection:": clean_armor(armor_legs_rash_leggings),
    }

    def __init__(self, name="Cavalex",
                 equipped_weapon=DEFAULT_WEAPON, equipped_armor=DEFAULT_ARMOR,
                 base_attack=1, base_defense=1,
                 hp=20, gold=10,
                 potions=(potion_hp["Name:"],)):
        self.name = name
        # deepcopy is defensive (so changing defaults doesn't retroactively
        # alter existing instance); can be removed if you guarantee defaults
        # won't be changed, or you want changes to defaults to affect
        # Players still wielding default items
        self.equipped_weapon = copy.deepcopy(equipped_weapon)
        self.equipped_armor = copy.deepcopy(equipped_armor)
        self.base_attack = int(base_attack)
        self.base_defense = int(base_defense)
        self.HP = int(hp)
        self.gold = int(gold)
        # potions only used as dictionary, but it's silly to store it as one
        # Just store list of potion names in protected attribute,
        # property can construct the expected dict on demand
        self._potions = list(potions)

    @property
    def ATTACK(self):
        return self.base_attack + self.equipped_weapon[add_attack]

    @property
    def DEFENSE(self):
        return self.base_defense + sum(armor['Defense'] for armor in self.equipped_armor.values())

    @property
    def potions(self):
        return {"Potions: ": self._potions}

    @property
    def ui_gold(self):
        return {"Gold: ": self.gold}

    @property
    def ui_equipped_weapon(self):
        return {"Equipped Weapon: {}".format(self.equipped_weapon): ""}

    @property:
    def inv(self):
        return [
            self.equipped_armor,
            self.ui_equipped_weapon,
            self.potions,
            self.ui_gold,
        ]

    def see_inventory(self):
        for element in self.inv:
            for k, v in element.items():
                if isinstance(v, list):
                    print(k, ' '.join(v))
                else:
                    print(k, v)

This still has a lot of questionable choices (inconsistent attribute/property naming; weird key names in the dicts that seem to have been chosen to make display easier, but make all non-display uses more annoying; using top-level functions for things that only make sense as instance methods, etc.), but I preserved those quirks to keep it a drop-in replacement for your existing class (but with all per-player attributes set on the instance, not the class, and all derived attributes computed via propertys rather than set statically, since independent static attributes increase the odds of the base and derived attributes getting out of sync).

I preserved the behavior of allowing you to create a player without providing any arguments, though the name should really be a non-optional argument (unless "Cavalex" is such a common name that you can safely assume most if not all players have that name).

I realize it seems kind of tedious to spell out __init__ and define propertys when you can just copy over the data from attribute to derived attribute, but in terms of code that you can actually use in a meaningful way without extreme repetition (and the accompanying risk of typos and logic errors), understand the behavior of, etc., this is the only way that makes sense; a class that is 99% class attributes (and all the methods effectively ignore per-instance state) may as well have just been a bunch of globals and top-level functions, not a class at all.

The reason you make classes is to allow you to create many instances of the class with different attributes, but shared behaviors; making the class a quasi-singleton by using purely class-level state makes the class pointless, at least in Python where the multiparadigm language design means the singleton pattern is rarely necessary, if ever (and using class level state defined at definition time removes the sole advantage of the pattern, deferring initialization of the singleton until it's needed).