Repository: PlasmaPy/PlasmaPy
Pull request #984 (2021-01-25 18:23:40)

Deprecate `Particle.particle` in favor of `Particle.symbol`
One naming decision I've regretted is for `Particle.particle`.  I would have preferred the name to be `Particle.symbol`, since `particle` does not really represent what the particle is.  I've deprecated `Particle.particle` in favor of `Particle.symbol` for when we release 0.6.0.  We should remove `Particle.particle` in a subsequent release of PlasmaPy, probably 0.8.0 in order to give a bit of time.  Once this is merged, we'll need to create an issue to remove this and add it to the appropriate milestone.


namurphy: I also added `symbol` as a property of `AbstractParticle` that then gets inherited by `CustomParticle` and `DimensionlessParticle`.  It defaults to what comes from `repr`.
StanczakDominik: Just to clear this up - this is about the renaming of the `particle` *field* of the `Particle` *object* to be called `symbol`, which sounds very sane and I wholeheartedly agree!

Patch:
diff --git a/changelog/984.feature.rst b/changelog/984.feature.rst
new file mode 100644
index 00000000..04d22a72
--- /dev/null
+++ b/changelog/984.feature.rst
@@ -0,0 +1,6 @@
+The `~plasmapy.particles.particle_class.Particle` class now contains an
+attribute named ``symbol`` that is intended to replace ``particle``. The
+``symbol`` attribute has been added as a property to
+`~plasmapy.particles.particle_class.AbstractParticle`,
+`~plasmapy.particles.particle_class.CustomParticle`, and
+`~plasmapy.particles.particle_class.DimensionlessParticle`.
diff --git a/changelog/984.removal.rst b/changelog/984.removal.rst
new file mode 100644
index 00000000..bd7e510a
--- /dev/null
+++ b/changelog/984.removal.rst
@@ -0,0 +1,4 @@
+The ``particle`` attribute of `~plasmapy.particles.particle_class.Particle`
+has been deprecated in favor of the new ``symbol`` attribute.  The ``particle``
+attribute now issues a `FutureWarning` to indicate that it will be removed in
+a future release.
diff --git a/docs/particles/decorators.rst b/docs/particles/decorators.rst
index 8f4e806f..5ae98ab3 100644
--- a/docs/particles/decorators.rst
+++ b/docs/particles/decorators.rst
@@ -62,7 +62,7 @@ classes as well:
   class ExampleClass:
       @particle_input
       def particle_symbol(self, particle: Particle) -> str:
-          return particle.particle
+          return particle.symbol
 
 On occasion it is necessary for a function to accept only certain
 categories of particles.  The `~plasmapy.particles.particle_input`
diff --git a/docs/particles/particle_class.rst b/docs/particles/particle_class.rst
index fd437343..2ff5a46e 100644
--- a/docs/particles/particle_class.rst
+++ b/docs/particles/particle_class.rst
@@ -75,12 +75,12 @@ SI units.
 <Quantity 0.49225958 GeV>
 
 Strings representing particles may be accessed using the
-`~plasmapy.particles.Particle.particle`,
+`~plasmapy.particles.Particle.symbol`,
 `~plasmapy.particles.Particle.element`,
 `~plasmapy.particles.Particle.isotope`, and
 `~plasmapy.particles.Particle.ionic_symbol` attributes.
 
->>> antimuon.particle
+>>> antimuon.symbol
 'mu+'
 >>> triton.element
 'H'
diff --git a/plasmapy/formulary/parameters.py b/plasmapy/formulary/parameters.py
index a408026e..d3e128ea 100644
--- a/plasmapy/formulary/parameters.py
+++ b/plasmapy/formulary/parameters.py
@@ -952,7 +952,7 @@ def Hall_parameter(
 
     gyro_frequency = gyrofrequency(B, particle)
     gyro_frequency = gyro_frequency / u.radian
-    if particles.Particle(particle).particle == "e-":
+    if particles.Particle(particle).symbol == "e-":
         coll_rate = fundamental_electron_collision_freq(
             T, n, ion, coulomb_log, V, coulomb_log_method=coulomb_log_method
         )
diff --git a/plasmapy/particles/ionization_state.py b/plasmapy/particles/ionization_state.py
index bfd385cf..61976b50 100644
--- a/plasmapy/particles/ionization_state.py
+++ b/plasmapy/particles/ionization_state.py
@@ -286,7 +286,7 @@ def __init__(
 
         except Exception as exc:
             raise ParticleError(
-                f"Unable to create IonizationState object for {particle.particle}."
+                f"Unable to create IonizationState object for {particle.symbol}."
             ) from exc
 
     def __str__(self) -> str:
@@ -649,8 +649,7 @@ def _particle_instances(self) -> List[Particle]:
         instances corresponding to each ion.
         """
         return [
-            Particle(self._particle.particle, Z=i)
-            for i in range(self.atomic_number + 1)
+            Particle(self._particle.symbol, Z=i) for i in range(self.atomic_number + 1)
         ]
 
     @property
diff --git a/plasmapy/particles/ionization_state_collection.py b/plasmapy/particles/ionization_state_collection.py
index c7c03b99..4b582864 100644
--- a/plasmapy/particles/ionization_state_collection.py
+++ b/plasmapy/particles/ionization_state_collection.py
@@ -542,7 +542,7 @@ def ionic_fractions(self, inputs: Union[Dict, List, Tuple]):
                 n_elems = {}
 
             for key in sorted_keys:
-                new_key = particles[key].particle
+                new_key = particles[key].symbol
                 _particle_instances.append(particles[key])
                 if new_key in _elements_and_isotopes:
                     raise ParticleError(
@@ -572,10 +572,10 @@ def ionic_fractions(self, inputs: Union[Dict, List, Tuple]):
                     isinstance(inputs[key], np.ndarray)
                     and inputs[key].dtype.kind == "f"
                 ):
-                    new_ionic_fractions[particles[key].particle] = inputs[key]
+                    new_ionic_fractions[particles[key].symbol] = inputs[key]
                 else:
                     try:
-                        new_ionic_fractions[particles[key].particle] = np.array(
+                        new_ionic_fractions[particles[key].symbol] = np.array(
                             inputs[key], dtype=np.float
                         )
                     except ValueError as exc:
@@ -632,10 +632,10 @@ def ionic_fractions(self, inputs: Union[Dict, List, Tuple]):
                 key=lambda p: (p.atomic_number, p.mass_number if p.isotope else 0)
             )
             _elements_and_isotopes = [
-                particle.particle for particle in _particle_instances
+                particle.symbol for particle in _particle_instances
             ]
             new_ionic_fractions = {
-                particle.particle: np.full(
+                particle.symbol: np.full(
                     particle.atomic_number + 1, fill_value=np.nan, dtype=np.float64
                 )
                 for particle in _particle_instances
diff --git a/plasmapy/particles/parsing.py b/plasmapy/particles/parsing.py
index 3b813099..191b149f 100644
--- a/plasmapy/particles/parsing.py
+++ b/plasmapy/particles/parsing.py
@@ -452,7 +452,7 @@ def _reconstruct_ion_symbol(
         symbol = element
 
     nomenclature_dict = {
-        "particle": symbol,
+        "symbol": symbol,
         "element": element,
         "isotope": isotope,
         "ion": ion,
diff --git a/plasmapy/particles/particle_class.py b/plasmapy/particles/particle_class.py
index 74c2ad81..0db349e9 100644
--- a/plasmapy/particles/particle_class.py
+++ b/plasmapy/particles/particle_class.py
@@ -138,7 +138,7 @@ def json_dict(self) -> dict:
                 # string representation of the module contains the particle class
                 "module": "plasmapy.particles.particle_class",
 
-                # date stamp of when the object was creaed
+                # date stamp of when the object was created
                 "date_created": "2020-07-20 17:46:13 UTC",
 
                 # parameters used to initialized the particle class
@@ -163,6 +163,11 @@ def json_dict(self) -> dict:
         }
         return json_dictionary
 
+    @property
+    def symbol(self):
+        """Return a string representation of the particle."""
+        return self.__repr__()
+
     def __bool__(self):
         """
         Raise an `~plasmapy.particles.exceptions.ParticleError` because particles
@@ -261,10 +266,10 @@ class Particle(AbstractParticle):
     >>> positron = Particle('positron')
     >>> hydrogen = Particle(1)  # atomic number
 
-    The `~plasmapy.particles.Particle.particle` attribute returns the
+    The `~plasmapy.particles.Particle.symbol` attribute returns the
     particle's symbol in the standard form.
 
-    >>> positron.particle
+    >>> positron.symbol
     'e+'
 
     The ``element``, ``isotope``, and ``ionic_symbol`` attributes return
@@ -392,7 +397,7 @@ def __init__(
         # copy).
 
         if isinstance(argument, Particle):
-            argument = argument.particle
+            argument = argument.symbol
 
         if mass_numb is not None and not isinstance(mass_numb, Integral):
             raise TypeError("mass_numb is not an integer")
@@ -413,30 +418,30 @@ def __init__(
         # case-insensitive aliases for particles, return the standard
         # symbol. Otherwise, return the original argument.
 
-        particle = _dealias_particle_aliases(argument)
+        particle_symbol = _dealias_particle_aliases(argument)
 
-        if particle in _Particles.keys():  # special particles
+        if particle_symbol in _Particles.keys():  # special particles
 
-            attributes["particle"] = particle
+            attributes["symbol"] = particle_symbol
 
-            for attribute in _Particles[particle].keys():
-                attributes[attribute] = _Particles[particle][attribute]
+            for attribute in _Particles[particle_symbol].keys():
+                attributes[attribute] = _Particles[particle_symbol][attribute]
 
             particle_taxonomy = ParticleZoo._taxonomy_dict
             all_categories = particle_taxonomy.keys()
 
             for category in all_categories:
-                if particle in particle_taxonomy[category]:
+                if particle_symbol in particle_taxonomy[category]:
                     categories.add(category)
 
             if attributes["name"] in _specific_particle_categories:
                 categories.add(attributes["name"])
 
-            if particle == "p+":
+            if particle_symbol == "p+":
                 categories.update({"element", "isotope", "ion"})
 
             if mass_numb is not None or Z is not None:
-                if particle == "p+" and (mass_numb == 1 or Z == 1):
+                if particle_symbol == "p+" and (mass_numb == 1 or Z == 1):
                     warnings.warn(
                         "Redundant mass number or charge information.", ParticleWarning
                     )
@@ -542,11 +547,11 @@ def __repr__(self) -> str:
         >>> repr(lead)
         'Particle("Pb")'
         """
-        return f'Particle("{self.particle}")'
+        return f'Particle("{self.symbol}")'
 
     def __str__(self) -> str:
         """Return the particle's symbol."""
-        return self.particle
+        return self.symbol
 
     def __eq__(self, other) -> bool:
         """
@@ -560,7 +565,7 @@ def __eq__(self, other) -> bool:
 
         If ``other`` is not a `str` or `~plasmapy.particles.Particle`
         instance, then this method will raise a `TypeError`.  If
-        ``other.particle`` equals ``self.particle`` but the attributes
+        ``other.symbol`` equals ``self.symbol`` but the attributes
         differ, then this method will raise a
         `~plasmapy.particles.exceptions.ParticleError`.
 
@@ -576,7 +581,7 @@ def __eq__(self, other) -> bool:
         if isinstance(other, str):
             try:
                 other_particle = Particle(other)
-                return self.particle == other_particle.particle
+                return self.symbol == other_particle.symbol
             except InvalidParticleError as exc:
                 raise InvalidParticleError(
                     f"{other} is not a particle and cannot be compared to {self}."
@@ -587,15 +592,15 @@ def __eq__(self, other) -> bool:
                 f"The equality of a Particle object with a {type(other)} is undefined."
             )
 
-        no_particle_attr = "particle" not in dir(self) or "particle" not in dir(other)
+        no_symbol_attr = "symbol" not in dir(self) or "symbol" not in dir(other)
         no_attributes_attr = "_attributes" not in dir(self) or "_attributes" not in dir(
             other
         )
 
-        if no_particle_attr or no_attributes_attr:  # coverage: ignore
+        if no_symbol_attr or no_attributes_attr:  # coverage: ignore
             raise TypeError(f"The equality of {self} with {other} is undefined.")
 
-        same_particle = self.particle == other.particle
+        same_particle = self.symbol == other.symbol
 
         # The following two loops are a hack to enable comparisons
         # between defaultdicts.  By accessing all of the defined keys in
@@ -635,7 +640,7 @@ def __ne__(self, other) -> bool:
 
         If ``other`` is not a `str` or `~plasmapy.particles.Particle`
         instance, then this method will raise a `TypeError`.  If
-        ``other.particle`` equals ``self.particle`` but the attributes
+        ``other.symbol`` equals ``self.symbol`` but the attributes
         differ, then this method will raise a
         `~plasmapy.particles.exceptions.ParticleError`.
         """
@@ -678,21 +683,47 @@ def json_dict(self) -> dict:
             '__init__': {'args': ('e-',), 'kwargs': {}}}}
         """
         particle_dictionary = super().json_dict
-        particle_dictionary["plasmapy_particle"]["__init__"]["args"] = (self.particle,)
+        particle_dictionary["plasmapy_particle"]["__init__"]["args"] = (self.symbol,)
         return particle_dictionary
 
     @property
-    def particle(self) -> Optional[str]:
+    def particle(self) -> str:
+        """
+        Return the symbol of the particle, atom, isotope, or ion.
+
+        .. deprecated:: 0.6.0
+            `Particle.particle` has been deprecated and will be removed in
+            a subsequent release of PlasmaPy.  Use `Particle.symbol`
+            instead.
         """
-        Return the particle's symbol.
+        warnings.warn(
+            "Particle.particle has been deprecated and will be removed in "
+            "a subsequent release. Use Particle.symbol instead.",
+            FutureWarning,
+        )
+        return self.symbol
+
+    @property
+    def symbol(self) -> str:
+        """
+        Return the symbol of the particle, atom, isotope, or ion.
+
+        This attribute will return the canonical symbol for special
+        particles (e.g., ``"p+"``, ``"e-"``, or ``"n"``), the atomic
+        symbol for elements (e.g., ``"Fe"``), the isotopic symbol for
+        isotopes (e.g., ``"D"`` or ``"Fe-56"``), and the ionic symbol
+        for ions (e.g., ``"N 1+"`` or ``"He-4 1+"``).
 
         Examples
         --------
-        >>> electron = Particle('electron')
-        >>> electron.particle
-        'e-'
+        >>> electron = Particle('positron')
+        >>> electron.symbol
+        'e+'
+        >>> deuteron = Particle('D 1+')
+        >>> deuteron.symbol
+        'D 1+'
         """
-        return self._attributes["particle"]
+        return self._attributes["symbol"]
 
     @property
     def antiparticle(self):
@@ -714,8 +745,8 @@ def antiparticle(self):
         >>> ~antineutron
         Particle("n")
         """
-        if self.particle in _antiparticles.keys():
-            return Particle(_antiparticles[self.particle])
+        if self.symbol in _antiparticles.keys():
+            return Particle(_antiparticles[self.symbol])
         else:
             raise ParticleError(
                 "The unary operator can only be used for elementary "
@@ -837,7 +868,7 @@ def isotope_name(self) -> str:
         'iron-56'
         """
         if not self.element:
-            raise InvalidElementError(_category_errmsg(self.particle, "element"))
+            raise InvalidElementError(_category_errmsg(self.symbol, "element"))
         elif not self.isotope:
             raise InvalidIsotopeError(_category_errmsg(self, "isotope"))
 
@@ -1006,7 +1037,7 @@ def nuclide_mass(self) -> u.Quantity:
             return _special_ion_masses["D 1+"]
         elif self.isotope == "T":
             return _special_ion_masses["T 1+"]
-        elif self.particle == "n":
+        elif self.symbol == "n":
             return const.m_n
 
         if not self.isotope:
@@ -1056,7 +1087,7 @@ def mass_energy(self) -> u.Quantity:
             return energy.to(u.J)
         except MissingParticleDataError:
             raise MissingParticleDataError(
-                f"The mass energy of {self.particle} is not available "
+                f"The mass energy of {self.symbol} is not available "
                 f"because the mass is unknown."
             ) from None
 
@@ -1169,7 +1200,7 @@ def neutron_number(self) -> Integral:
         >>> Particle('n').neutron_number
         1
         """
-        if self.particle == "n":
+        if self.symbol == "n":
             return 1
         elif self.isotope:
             return self.mass_number - self.atomic_number
@@ -1194,7 +1225,7 @@ def electron_number(self) -> Integral:
         >>> Particle('e-').electron_number
         1
         """
-        if self.particle == "e-":
+        if self.symbol == "e-":
             return 1
         elif self.ionic_symbol:
             return self.atomic_number - self.integer_charge
@@ -1220,7 +1251,7 @@ def isotopic_abundance(self) -> u.Quantity:
         from .atomic import common_isotopes
 
         if not self.isotope or self.is_ion:  # coverage: ignore
-            raise InvalidIsotopeError(_category_errmsg(self.particle, "isotope"))
+            raise InvalidIsotopeError(_category_errmsg(self.symbol, "isotope"))
 
         abundance = self._attributes.get("isotopic abundance", 0.0)
 
@@ -1253,7 +1284,7 @@ def baryon_number(self) -> Integral:
         """
         if self._attributes["baryon number"] is None:  # coverage: ignore
             raise MissingParticleDataError(
-                f"The baryon number for '{self.particle}' is not available."
+                f"The baryon number for '{self.symbol}' is not available."
             )
         return self._attributes["baryon number"]
 
@@ -1280,7 +1311,7 @@ def lepton_number(self) -> Integral:
         """
         if self._attributes["lepton number"] is None:  # coverage: ignore
             raise MissingParticleDataError(
-                f"The lepton number for {self.particle} is not available."
+                f"The lepton number for {self.symbol} is not available."
             )
         return self._attributes["lepton number"]
 
@@ -1302,18 +1333,18 @@ def half_life(self) -> Union[u.Quantity, str]:
         <Quantity 881.5 s>
         """
         if self.element and not self.isotope:
-            raise InvalidIsotopeError(_category_errmsg(self.particle, "isotope"))
+            raise InvalidIsotopeError(_category_errmsg(self.symbol, "isotope"))
 
         if isinstance(self._attributes["half-life"], str):
             warnings.warn(
-                f"The half-life for {self.particle} is not known precisely; "
+                f"The half-life for {self.symbol} is not known precisely; "
                 "returning string with estimated value.",
                 MissingParticleDataWarning,
             )
 
         if self._attributes["half-life"] is None:
             raise MissingParticleDataError(
-                f"The half-life of '{self.particle}' is not available."
+                f"The half-life of '{self.symbol}' is not available."
             )
         return self._attributes["half-life"]
 
@@ -1333,7 +1364,7 @@ def spin(self) -> Real:
         """
         if self._attributes["spin"] is None:
             raise MissingParticleDataError(
-                f"The spin of particle '{self.particle}' is unavailable."
+                f"The spin of particle '{self.symbol}' is unavailable."
             )
 
         return self._attributes["spin"]
@@ -1362,7 +1393,7 @@ def periodic_table(self) -> namedtuple:
         if self.element:
             return self._attributes["periodic table"]
         else:  # coverage: ignore
-            raise InvalidElementError(_category_errmsg(self.particle, "element"))
+            raise InvalidElementError(_category_errmsg(self.symbol, "element"))
 
     @property
     def categories(self) -> Set[str]:
@@ -1563,17 +1594,16 @@ def ionize(self, n: Integral = 1, inplace: bool = False):
         """
         if not self.element:
             raise InvalidElementError(
-                f"Cannot ionize {self.particle} because it is not a "
+                f"Cannot ionize {self.symbol} because it is not a "
                 f"neutral atom or ion."
             )
         if not self.is_category(any_of={"charged", "uncharged"}):
             raise ChargeError(
-                f"Cannot ionize {self.particle} because its charge "
-                f"is not specified."
+                f"Cannot ionize {self.symbol} because its charge " f"is not specified."
             )
         if self.integer_charge == self.atomic_number:
             raise InvalidIonError(
-                f"The particle {self.particle} is already fully "
+                f"The particle {self.symbol} is already fully "
                 f"ionized and cannot be ionized further."
             )
         if not isinstance(n, Integral):
@@ -1647,12 +1677,12 @@ def recombine(self, n: Integral = 1, inplace=False):
 
         if not self.element:
             raise InvalidElementError(
-                f"{self.particle} cannot undergo recombination because "
+                f"{self.symbol} cannot undergo recombination because "
                 f"it is not a neutral atom or ion."
             )
         if not self.is_category(any_of={"charged", "uncharged"}):
             raise ChargeError(
-                f"{self.particle} cannot undergo recombination because "
+                f"{self.symbol} cannot undergo recombination because "
                 f"its charge is not specified."
             )
         if not isinstance(n, Integral):
@@ -1912,47 +1942,11 @@ def json_dict(self) -> dict:
         }
         return particle_dictionary
 
-    @property
-    def mass(self) -> u.kg:
-        """Return the custom particle's mass."""
-        return self._mass
-
     @property
     def charge(self) -> u.C:
         """Return the custom particle's electric charge in coulombs."""
         return self._charge
 
-    @mass.setter
-    def mass(self, m: u.kg):
-        if m is None:
-            m = np.nan * u.kg
-            warnings.warn(
-                "CustomParticle mass set to NaN kg", MissingParticleDataWarning
-            )
-        elif isinstance(m, str):
-            m = u.Quantity(m)
-        elif not isinstance(m, u.Quantity):
-            raise TypeError(
-                "The mass of a custom particle must be a nonnegative Quantity "
-                "with units of mass."
-            )
-        if np.isnan(m):
-            self._mass = m
-        else:
-            if not isinstance(m.value, Real):
-                raise TypeError(
-                    "The mass of a custom particle must be a real number "
-                    "with units of mass."
-                )
-            try:
-                self._mass = m.to(u.kg)
-                if self.mass < 0 * u.kg:
-                    raise ValueError("The mass of a particle must be nonnegative.")
-            except u.UnitsError as exc:
-                raise u.UnitsError(
-                    "The mass of a custom particle must have units of mass."
-                ) from exc
-
     @charge.setter
     def charge(self, q: Optional[Union[u.Quantity, Real]]):
         if q is None:
@@ -1992,6 +1986,42 @@ def charge(self, q: Optional[Union[u.Quantity, Real]]):
                 "the elementary charge."
             )
 
+    @property
+    def mass(self) -> u.kg:
+        """Return the custom particle's mass."""
+        return self._mass
+
+    @mass.setter
+    def mass(self, m: u.kg):
+        if m is None:
+            m = np.nan * u.kg
+            warnings.warn(
+                "CustomParticle mass set to NaN kg", MissingParticleDataWarning
+            )
+        elif isinstance(m, str):
+            m = u.Quantity(m)
+        elif not isinstance(m, u.Quantity):
+            raise TypeError(
+                "The mass of a custom particle must be a nonnegative Quantity "
+                "with units of mass."
+            )
+        if np.isnan(m):
+            self._mass = m
+        else:
+            if not isinstance(m.value, Real):
+                raise TypeError(
+                    "The mass of a custom particle must be a real number "
+                    "with units of mass."
+                )
+            try:
+                self._mass = m.to(u.kg)
+                if self.mass < 0 * u.kg:
+                    raise ValueError("The mass of a particle must be nonnegative.")
+            except u.UnitsError as exc:
+                raise u.UnitsError(
+                    "The mass of a custom particle must have units of mass."
+                ) from exc
+
 
 # TODO: Describe valid particle representations in docstring of particle_like
 
diff --git a/plasmapy/particles/symbols.py b/plasmapy/particles/symbols.py
index d9763c30..eaff6fbc 100644
--- a/plasmapy/particles/symbols.py
+++ b/plasmapy/particles/symbols.py
@@ -284,7 +284,7 @@ def particle_symbol(
     >>> particle_symbol('H-1', Z=-1)
     'H-1 1-'
     """
-    return particle.particle
+    return particle.symbol
 
 
 @particle_input


Test patch:
diff --git a/plasmapy/particles/tests/test_ionization_collection.py b/plasmapy/particles/tests/test_ionization_collection.py
index d1711adc..d517c1f4 100644
--- a/plasmapy/particles/tests/test_ionization_collection.py
+++ b/plasmapy/particles/tests/test_ionization_collection.py
@@ -157,7 +157,7 @@ def test_simple_equality(self, test_name):
     def test_that_particles_were_set_correctly(self, test_name):
         input_particles = tests[test_name]["inputs"].keys()
         particles = [Particle(input_particle) for input_particle in input_particles]
-        expected_particles = {p.particle for p in particles}
+        expected_particles = {p.symbol for p in particles}
         actual_particles = {
             particle for particle in self.instances[test_name].ionic_fractions.keys()
         }
diff --git a/plasmapy/particles/tests/test_parsing.py b/plasmapy/particles/tests/test_parsing.py
index 627f7a83..2bde74c1 100644
--- a/plasmapy/particles/tests/test_parsing.py
+++ b/plasmapy/particles/tests/test_parsing.py
@@ -95,7 +95,7 @@ def test_alias_dict_properties(alias_dict):
         "He",
         {"Z": 1, "mass_numb": 4},
         {
-            "particle": "He-4 1+",
+            "symbol": "He-4 1+",
             "element": "He",
             "isotope": "He-4",
             "ion": "He-4 1+",
@@ -107,7 +107,7 @@ def test_alias_dict_properties(alias_dict):
         "alpha",
         {},
         {
-            "particle": "He-4 2+",
+            "symbol": "He-4 2+",
             "element": "He",
             "isotope": "He-4",
             "ion": "He-4 2+",
@@ -119,7 +119,7 @@ def test_alias_dict_properties(alias_dict):
         1,
         {},
         {
-            "particle": "H",
+            "symbol": "H",
             "element": "H",
             "isotope": None,
             "ion": None,
@@ -131,7 +131,7 @@ def test_alias_dict_properties(alias_dict):
         "p",
         {},
         {
-            "particle": "p+",
+            "symbol": "p+",
             "element": "H",
             "isotope": "H-1",
             "ion": "p+",
@@ -143,7 +143,7 @@ def test_alias_dict_properties(alias_dict):
         "H",
         {"mass_numb": 2},
         {
-            "particle": "D",
+            "symbol": "D",
             "element": "H",
             "isotope": "D",
             "ion": None,
@@ -155,7 +155,7 @@ def test_alias_dict_properties(alias_dict):
         2,
         {},
         {
-            "particle": "He",
+            "symbol": "He",
             "element": "He",
             "isotope": None,
             "ion": None,
@@ -167,7 +167,7 @@ def test_alias_dict_properties(alias_dict):
         "T",
         {"Z": 0},
         {
-            "particle": "T 0+",
+            "symbol": "T 0+",
             "element": "H",
             "isotope": "T",
             "ion": "T 0+",
@@ -179,7 +179,7 @@ def test_alias_dict_properties(alias_dict):
         "Fe-56+++++++",
         {},
         {
-            "particle": "Fe-56 7+",
+            "symbol": "Fe-56 7+",
             "element": "Fe",
             "isotope": "Fe-56",
             "ion": "Fe-56 7+",
@@ -191,7 +191,7 @@ def test_alias_dict_properties(alias_dict):
         "H-",
         {},
         {
-            "particle": "H 1-",
+            "symbol": "H 1-",
             "element": "H",
             "isotope": None,
             "ion": "H 1-",
@@ -203,7 +203,7 @@ def test_alias_dict_properties(alias_dict):
         "D+",
         {},
         {
-            "particle": "D 1+",
+            "symbol": "D 1+",
             "element": "H",
             "isotope": "D",
             "ion": "D 1+",
@@ -215,7 +215,7 @@ def test_alias_dict_properties(alias_dict):
         "Au",
         {},
         {
-            "particle": "Au",
+            "symbol": "Au",
             "element": "Au",
             "isotope": None,
             "ion": None,
@@ -227,7 +227,7 @@ def test_alias_dict_properties(alias_dict):
         "Ar 2-",
         {},
         {
-            "particle": "Ar 2-",
+            "symbol": "Ar 2-",
             "element": "Ar",
             "isotope": None,
             "ion": "Ar 2-",
@@ -239,7 +239,7 @@ def test_alias_dict_properties(alias_dict):
         "Fe +24",
         {"mass_numb": 56},
         {
-            "particle": "Fe-56 24+",
+            "symbol": "Fe-56 24+",
             "element": "Fe",
             "isotope": "Fe-56",
             "ion": "Fe-56 24+",
@@ -251,7 +251,7 @@ def test_alias_dict_properties(alias_dict):
         "Be-8 +3",
         {},
         {
-            "particle": "Be-8 3+",
+            "symbol": "Be-8 3+",
             "element": "Be",
             "isotope": "Be-8",
             "ion": "Be-8 3+",
@@ -263,7 +263,7 @@ def test_alias_dict_properties(alias_dict):
         "p+",
         {},
         {
-            "particle": "p+",
+            "symbol": "p+",
             "element": "H",
             "isotope": "H-1",
             "ion": "p+",
diff --git a/plasmapy/particles/tests/test_particle_class.py b/plasmapy/particles/tests/test_particle_class.py
index a6049c46..3ab76225 100644
--- a/plasmapy/particles/tests/test_particle_class.py
+++ b/plasmapy/particles/tests/test_particle_class.py
@@ -38,7 +38,7 @@
         "neutron",
         {},
         {
-            "particle": "n",
+            "symbol": "n",
             "element": None,
             "isotope": None,
             "isotope_name": InvalidElementError,
@@ -61,7 +61,7 @@
         "p+",
         {},
         {
-            "particle": "p+",
+            "symbol": "p+",
             "element": "H",
             "element_name": "hydrogen",
             "isotope": "H-1",
@@ -100,7 +100,7 @@
         "p-",
         {},
         {
-            "particle": "p-",
+            "symbol": "p-",
             "element": None,
             "element_name": InvalidElementError,
             "isotope": None,
@@ -125,7 +125,7 @@
         "e-",
         {},
         {
-            "particle": "e-",
+            "symbol": "e-",
             "element": None,
             "element_name": InvalidElementError,
             "isotope": None,
@@ -153,7 +153,7 @@
         "e+",
         {},
         {
-            "particle": "e+",
+            "symbol": "e+",
             "element": None,
             "isotope": None,
             "isotope_name": InvalidElementError,
@@ -185,7 +185,7 @@
         "H",
         {},
         {
-            "particle": "H",
+            "symbol": "H",
             "element": "H",
             "isotope": None,
             "isotope_name": InvalidIsotopeError,
@@ -210,7 +210,7 @@
         "H 1-",
         {},
         {
-            "particle": "H 1-",
+            "symbol": "H 1-",
             "element": "H",
             "isotope": None,
             "isotope_name": InvalidIsotopeError,
@@ -233,7 +233,7 @@
         "H-1 0+",
         {},
         {
-            "particle": "H-1 0+",
+            "symbol": "H-1 0+",
             "element": "H",
             "isotope": "H-1",
             "isotope_name": "hydrogen-1",
@@ -258,7 +258,7 @@
         "D+",
         {},
         {
-            "particle": "D 1+",
+            "symbol": "D 1+",
             "element": "H",
             "element_name": "hydrogen",
             "isotope": "D",
@@ -283,7 +283,7 @@
         "tritium",
         {"Z": 1},
         {
-            "particle": "T 1+",
+            "symbol": "T 1+",
             "element": "H",
             "isotope": "T",
             "isotope_name": "tritium",
@@ -305,7 +305,7 @@
         "Fe",
         {"Z": 17, "mass_numb": 56},
         {
-            "particle": "Fe-56 17+",
+            "symbol": "Fe-56 17+",
             "element": "Fe",
             "element_name": "iron",
             "isotope": "Fe-56",
@@ -329,7 +329,7 @@
         "alpha",
         {},
         {
-            "particle": "He-4 2+",
+            "symbol": "He-4 2+",
             "element": "He",
             "element_name": "helium",
             "isotope": "He-4",
@@ -351,7 +351,7 @@
         "He-4 0+",
         {},
         {
-            "particle": "He-4 0+",
+            "symbol": "He-4 0+",
             "element": "He",
             "isotope": "He-4",
             "mass_energy": 5.971919969131517e-10 * u.J,
@@ -361,7 +361,7 @@
         "Li",
         {"mass_numb": 7},
         {
-            "particle": "Li-7",
+            "symbol": "Li-7",
             "element": "Li",
             "element_name": "lithium",
             "isotope": "Li-7",
@@ -382,7 +382,7 @@
         "Cn-276",
         {"Z": 22},
         {
-            "particle": "Cn-276 22+",
+            "symbol": "Cn-276 22+",
             "element": "Cn",
             "isotope": "Cn-276",
             "isotope_name": "copernicium-276",
@@ -402,7 +402,7 @@
         "muon",
         {},
         {
-            "particle": "mu-",
+            "symbol": "mu-",
             "element": None,
             "isotope": None,
             "isotope_name": InvalidElementError,
@@ -420,7 +420,7 @@
         "nu_tau",
         {},
         {
-            "particle": "nu_tau",
+            "symbol": "nu_tau",
             "element": None,
             "isotope": None,
             "isotope_name": InvalidElementError,
@@ -449,12 +449,12 @@
             'is_category(any_of="boson", exclude="boson")': ParticleError,
         },
     ),
-    (Particle("C"), {}, {"particle": "C", "atomic_number": 6, "element": "C"}),
+    (Particle("C"), {}, {"symbol": "C", "atomic_number": 6, "element": "C"}),
     (
         Particle("C"),
         {"Z": 3, "mass_numb": 14},
         {
-            "particle": "C-14 3+",
+            "symbol": "C-14 3+",
             "element": "C",
             "isotope": "C-14",
             "ionic_symbol": "C-14 3+",
@@ -668,7 +668,7 @@ def test_particle_class_mass_nuclide_mass(isotope: str, ion: str):
         "baryon",
     }:
 
-        particle = Isotope.particle
+        particle = Isotope.symbol
 
         assert Isotope.nuclide_mass == Ion.mass, (
             f"Particle({repr(particle)}).nuclide_mass does not equal "
@@ -1198,8 +1198,8 @@ def test_particles_from_json_string(cls, kwargs, json_string, expected_exception
     if expected_exception is None:
         instance = cls(**kwargs)
         instance_from_json = json_loads_particle(json_string)
-        expected_particle = instance.particle
-        actual_particle = instance_from_json.particle
+        expected_particle = instance.symbol
+        actual_particle = instance_from_json.symbol
         assert expected_particle == actual_particle, pytest.fail(
             f"Expected {expected_particle}\nGot {actual_particle}"
         )
@@ -1222,8 +1222,8 @@ def test_particles_from_json_file(cls, kwargs, json_string, expected_exception):
         test_file_object = io.StringIO(json_string)
         test_file_object.seek(0, io.SEEK_SET)
         instance_from_json = json_load_particle(test_file_object)
-        expected_particle = instance.particle
-        actual_particle = instance_from_json.particle
+        expected_particle = instance.symbol
+        actual_particle = instance_from_json.symbol
         assert expected_particle == actual_particle, pytest.fail(
             f"Expected {expected_particle}\nGot {actual_particle}"
         )