Mendeleev

https://mendeleev.readthedocs.io/en/stable/
Admin
Mendeleev is a Python package that provides an API for accessing various properties of elements from...
Tokens:39,036
Snippets:513
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies with Poetry

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Use poetry to install project dependencies and set up the development environment.

```bash
poetry install
```

--------------------------------

### Install Mendeleev from GitHub using pip

Source: https://mendeleev.readthedocs.io/en/stable/install.html

Install the most recent version directly from the GitHub repository.

```bash
pip install git+https://github.com/lmmentel/mendeleev.git

```

--------------------------------

### Install Mendeleev using pip

Source: https://mendeleev.readthedocs.io/en/stable/install.html

Use this command to install the latest stable version of mendeleev from PyPI.

```bash
pip install mendeleev

```

--------------------------------

### Install Mendeleev using conda

Source: https://mendeleev.readthedocs.io/en/stable/install.html

Install a specific version of mendeleev from the lmmentel anaconda channel.

```bash
conda install -c lmmentel mendeleev=1.1.0

```

--------------------------------

### Import Ion Class

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/ions.html

Import the `Ion` class from the `mendeleev.ion` module to start working with ions.

```python
from mendeleev.ion import Ion
```

--------------------------------

### Get Mendeleev Version Information

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Print the installed version of the Mendeleev library using the `__version__` attribute.

```python
import mendeleev

print(f"{mendeleev.__version__=}")
```

--------------------------------

### Create an Ion Instance

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/ions.html

Instantiate an `Ion` object by providing the element symbol and its charge. For example, creating an Iron(II) ion.

```python
fe_2 = Ion("Fe", 2)
```

--------------------------------

### Import pandas library

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Import the pandas library to enable DataFrame operations. This is a prerequisite for all subsequent code examples.

```python
import pandas as pd
```

--------------------------------

### Import Periodic Table Visualization Function

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/visualizations.html

Import the `periodic_table` function from the `mendeleev.vis` module. Ensure you have installed the optional `vis` dependencies using `pip install mendeleev[vis]`.

```python
from mendeleev.vis import periodic_table
```

--------------------------------

### Clone and Export Data using CLI

Source: https://mendeleev.readthedocs.io/en/stable/data_access.html

Clone the mendeleev repository, install dependencies, and run the export command. Ensure you are in the mendeleev directory before executing the export command.

```bash
gh clone lmmentel/mendeleev
cd mendeleev
poetry install
poetry run inv export

```

--------------------------------

### Get Spin Occupations

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

View the distribution of electron spins (pairs, alpha, beta, unpaired) within each subshell.

```python
Si.ec.spin_occupations()
```

--------------------------------

### Inspect DataFrame Info

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

After fetching the table into a pandas DataFrame, use the `.info()` method to get a concise summary of the DataFrame, including column data types and non-null counts.

```python
ptable.info()
```

--------------------------------

### Get Electronegativity (Pauling Scale)

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Retrieve the electronegativity value for an element on the Pauling scale using the `electronegativity()` method with `scale='pauling'`.

```python
si.electronegativity(scale="pauling")
```

--------------------------------

### Get Element Oxidation States

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Access the `oxistates` attribute to retrieve a list of common oxidation states for an element. Requires importing the `element` function.

```python
from mendeleev import element

fe = element("Fe")
print(fe.oxistates)
```

--------------------------------

### Fetch the elements table

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Retrieve the 'elements' table, which contains basis data for each element, into a pandas DataFrame. This is a common starting point for many analyses.

```python
elements = fetch_table('elements')
```

--------------------------------

### Visualize Atomic Density

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/visualizations.html

Display and color-code the 'density' attribute of elements to visualize atomic volume. This example shows how to use a different property for visualization.

```python
periodic_table(attribute="density", colorby="attribute", title="Atomic Volume")
```

--------------------------------

### Get Spin Strings as NumPy Arrays

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Generates spin strings (alpha and beta) as NumPy arrays from a spin occupation dictionary. Can compute average occupations per subshell.

```python
def get_spin_strings(sodict, average: bool = True):
    """
    spin strings as numpy arrays

    This should be called for valence only
    """

    alphas = []
    betas = []

    for (n, orb), occ in sodict.items():
        nss = subshell_degeneracy(orb)
        if average:
            alphas.extend([occ["alpha"] / nss] * nss)
            betas.extend([occ["beta"] / nss] * nss)
        else:
            alphas.extend([1.0] * occ["alpha"] + [0.0] * (nss - occ["alpha"]))
            betas.extend([1.0] * occ["beta"] + [0.0] * (nss - occ["beta"]))
    return alphas, betas
```

--------------------------------

### Get Li and Xue Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity values for Silicon using the Li and Xue scale, specifying the charge. This scale considers different valence states and coordination environments.

```python
>>> Si.en_li_xue(charge=4)
{u'IV': 13.16033405547733, u'VI': 9.748395596649873}
```

```python
>>> Si.electronegativity('li-xue', charge=4)
{u'IV': 13.16033405547733, u'VI': 9.748395596649873}
```

--------------------------------

### Build Documentation Locally

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Navigate to the docs directory and run 'make html' to build the documentation. Results are placed in 'build/_html'.

```bash
cd docs
make html

```

--------------------------------

### Get Isotope by Mass Number - Python

Source: https://mendeleev.readthedocs.io/en/stable/api/models.html

Retrieve a specific isotope of an element using its mass number. This example shows how to access isotopes for Hydrogen (H) and select the isotope with mass number 2.

```python
>>> from mendeleev import H
>>> H.isotopes
[<Isotope(Z=1, A=1, mass=1.00782503190(1), abundance=99.986(8))>,
    <Isotope(Z=1, A=2, mass=2.01410177784(2), abundance=0.015(8))>,
    <Isotope(Z=1, A=3, mass=3.01604928132(8), abundance=None)>,
    <Isotope(Z=1, A=4, mass=4.0264(1), abundance=None)>,
    <Isotope(Z=1, A=5, mass=5.03531(10), abundance=None)>,
    <Isotope(Z=1, A=6, mass=6.0450(3), abundance=None)>,
    <Isotope(Z=1, A=7, mass=7.053(1), abundance=None)>]
>>> H.isotope(2)
<Isotope(Z=1, A=2, mass=2.01410177784(2), abundance=0.015(8))>
```

--------------------------------

### Navigate to Project Directory

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

After cloning, navigate into the project directory to access its files.

```bash
cd mendeleev
```

--------------------------------

### Initialize ElectronicConfiguration with String

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Initializes the ElectronicConfiguration object by parsing a string representation of the electronic configuration.

```python
def __init__(
        self,
        conf: Union[str, Dict] = None,
        atomre: str = None,
        shellre: str = None,
    ):
        self.atomre = atomre
        self.shellre = shellre
        self.conf = conf
```

--------------------------------

### Render Data Documentation

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Run 'inv render-data-docs' to generate an updated 'data.rst' file from the PropertyMetadata model. Inspect the file before committing.

```bash
inv render-data-docs

```

--------------------------------

### Initialize ElectronicConfiguration Standalone

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Instantiate the ElectronicConfiguration class directly with a string representation of the configuration.

```python
from mendeleev.econf import ElectronicConfiguration
```

```python
ec = ElectronicConfiguration("1s2 2s2 2p6 3s1")
```

--------------------------------

### Get Mulliken Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the Mulliken electronegativity, which is the average of an element's ionization potential and electron affinity. Use this method to get the Mulliken scale value.

```python
>>> Si.en_mulliken()
4.0758415
```

```python
>>> Si.electronegativity('mulliken')
4.0758415
```

--------------------------------

### Import Bokeh Visualization Functions

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/advanced_visualizations.html

Import necessary functions for using the Bokeh backend, including 'show' and 'output_notebook' from bokeh.plotting.

```python
from bokeh.plotting import show, output_notebook
from mendeleev.vis import periodic_table_bokeh
```

--------------------------------

### Get Valence Electrons

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Extract only the valence electron configuration from a given electronic configuration.

```python
ec.get_valence()
```

--------------------------------

### Initialize Element Object

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Import the element class and create an element object for Silicon. This is a prerequisite for accessing its properties.

```python
>>> from mendeleev import element
>>> Si = element('Si')
```

--------------------------------

### Get Unpaired Electrons

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Count the number of unpaired electrons in the atom's electronic configuration.

```python
Si.ec.unpaired_electrons()
```

--------------------------------

### Get Last Subshell

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Retrieve the last occupied subshell and its electron count in the electronic configuration.

```python
Si.ec.last_subshell()
```

--------------------------------

### Convert Configuration to String

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Returns a string representation of the electronic configuration. Useful for display and logging.

```python
def to_str(self) -> str:
        """Return a string with the configuration"""
        return " ".join(
            "{n:d}{s:s}{e:d}".format(n=k[0], s=k[1], e=v) for k, v in self.conf.items()
        )
```

--------------------------------

### Get Total Number of Electrons

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Calculate the total number of electrons in the atom based on its electronic configuration.

```python
Si.ec.ne()
```

--------------------------------

### Render Periodic Table with Bokeh

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/advanced_visualizations.html

Generate and display the periodic table visualization using the Bokeh backend. Requires enabling notebook output first.

```python
fig = periodic_table_bokeh(elements)
show(fig)
```

--------------------------------

### ElectronicConfiguration.to_str()

Source: https://mendeleev.readthedocs.io/en/stable/genindex.html

Converts ElectronicConfiguration to a string representation.

```APIDOC
## Method to_str()

### Description
Converts to a string representation.

### Class
ElectronicConfiguration
```

--------------------------------

### Get Unicode Ion Symbol

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/ions.html

Obtain the unicode representation of the ion symbol, useful for display purposes.

```python
fe_2.unicode_ion_symbol()
```

--------------------------------

### Get Electronegativity (Allen Scale)

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Obtain the electronegativity value for an element on the Allen scale by calling `electronegativity()` with `scale='allen'`.

```python
si.electronegativity(scale="allen")
```

--------------------------------

### Create a New Alembic Migration

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Generate a new database migration script using alembic. Replace '[your summary of changes here]' with a concise description of the changes.

```bash
alembic revision -m "[your summary of changes here]"
```

--------------------------------

### Fetch and Display Property Metadata

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Fetches the 'propertymetadata' table and displays the first 10 rows. This table contains metadata for properties, including units compatible with the pint package.

```python
metadata = fetch_table("propertymetadata")
metadata.head(10)
```

--------------------------------

### Accessing Isotope Decay Modes

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Shows how to access the `decay_modes` attribute of an Isotope object to get a list of its decay modes.

```APIDOC
## isotope(element_symbol, mass_number).decay_modes

### Description
Retrieves a list of decay modes for a given isotope.

### Method
Attribute access on an `isotope` object.

### Parameters
- **element_symbol** (str) - The symbol of the element (e.g., "Li").
- **mass_number** (int) - The mass number of the isotope.

### Response Example
```json
[
  {
    "id": 40,
    "intensity": 100.0,
    "is_allowed_not_observed": null,
    "is_observed_intensity_unknown": null,
    "isotope_id": 39,
    "mode": "B-",
    "relation": "="
  },
  {
    "id": 41,
    "intensity": 86.3,
    "is_allowed_not_observed": null,
    "is_observed_intensity_unknown": null,
    "isotope_id": 39,
    "mode": "B-n",
    "relation": "="
  }
]
```
```

--------------------------------

### Fetch Oxidation States Table

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Retrieve the 'oxidationstates' dataset using `fetch_table`. This table lists the oxidation states for various elements.

```python
ox = fetch_table("oxidationstates")
ox
```

--------------------------------

### Apply Database Migrations

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Apply all pending database migrations to the mendeleev/elements.db database.

```bash
alembic migrate head
```

--------------------------------

### Get Largest Noble Gas Core

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Identify the largest noble gas electronic configuration that is a subset of the current configuration.

```python
Si.ec.get_largest_core()
```

--------------------------------

### Get Maximum Principal Quantum Number

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Find the highest principal quantum number (n) present in the electronic configuration.

```python
Si.ec.max_n()
```

--------------------------------

### Calculating Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Demonstrates how to calculate electronegativity using different scales via the `electronegativity()` function.

```APIDOC
## element.electronegativity(scale)

### Description
Calculates the electronegativity of an element using a specified scale.

### Method
`electronegativity` function call on an `element` object.

### Parameters
- **scale** (str) - The electronegativity scale to use (e.g., "pauling", "allen").

### Response Example
```json
1.9
```
```

--------------------------------

### Get Element Ionization Energies

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Retrieve a dictionary of ionization energies in eV using the `ionenergies` attribute. Keys are degrees of ionization.

```python
from mendeleev import element

o = element("O")
o.ionenergies
```

--------------------------------

### to_str

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Returns a string representation of the electronic configuration.

```APIDOC
## to_str()

### Description
Return a string with the configuration.

### Method
```python
def to_str(self) -> str:
    """Return a string with the configuration"""
    return " ".join(
        "{n:d}{s:s}{e:d}".format(n=k[0], s=k[1], e=v) for k, v in self.conf.items()
    )
```
```

--------------------------------

### Visualization Functions

Source: https://mendeleev.readthedocs.io/en/stable/api/api.html

Entry points for visualizing periodic tables with different properties using various libraries.

```APIDOC
## mendeleev.vis.periodictable.periodic_table()

### Description
Main entry point for visualizing periodic tables.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.bokeh.periodic_table_bokeh()

### Description
Generates a periodic table visualization using Bokeh.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.plotly.periodic_table_plotly()

### Description
Generates a periodic table visualization using Plotly.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.plotly.create_annotation()

### Description
Creates an annotation for Plotly visualizations.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.plotly.create_tile()

### Description
Creates a tile for Plotly visualizations.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.seaborn.heatmap()

### Description
Generates a heatmap visualization using Seaborn.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.utils.add_tile_coordinates()

### Description
Adds tile coordinates for visualizations.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.utils.colormap_column()

### Description
Creates a colormap for a column in visualizations.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

```APIDOC
## mendeleev.vis.utils.create_vis_dataframe()

### Description
Creates a DataFrame for visualization purposes.

### Method
(Not specified, likely a function call)

### Endpoint
(Not applicable, this is a Python function)

### Parameters
(Not specified)

### Request Example
(Not applicable)

### Response
(Not specified)
```

--------------------------------

### Get Database Session

Source: https://mendeleev.readthedocs.io/en/stable/data_access.html

Obtain the database session connection for interacting with the mendeleev database using SQLAlchemy. By default, the session is read-only.

```python
>>> from mendeleev.session import get_session
>>> session = get_session()

```

--------------------------------

### Get Nagle Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Fetch the Nagle electronegativity value, derived from atomic dipole polarizability. This provides a specific scale for electronegativity.

```python
>>> Si.electronegativity('nagle')
0.47505611644667534
```

--------------------------------

### Fetch and Sort Phase Transitions Table

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Fetch the 'phasetransitions' dataset and sort it by 'atomic_number' to view phase transition properties. This is useful for elements with multiple allotropes.

```python
pt = fetch_table("phasetransitions")
pt.sort_values(by="atomic_number").head(15)
```

--------------------------------

### Get Maximum Azimuthal Quantum Number

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Determine the largest azimuthal quantum number (l) for a given principal quantum number (n).

```python
Si.ec.max_l(n=3)
```

--------------------------------

### Fetch and Display Screening Constants

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Fetches the 'screeningconstants' table and displays the first 10 rows. This table holds screening constants for different atomic numbers and quantum numbers.

```python
screening = fetch_table("screeningconstants")
screening.head(10)
```

--------------------------------

### Get Allen Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Allen scale. This can be accessed directly as an attribute or via a method call.

```python
>>> Si.en_allen
11.33
```

```python
>>> Si.electronegativity('allen')
11.33
```

--------------------------------

### Get Valence Electronic Configuration

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Calculates the valence electronic configuration by removing the largest noble gas core. Returns a new ElectronicConfiguration object.

```python
def get_valence(self):
        """
        Find the valence configuration i.e. remove the largest noble gas
        core from the current configuration and return the result.
        """
        _, core_conf = self.get_largest_core()
        valence = OrderedDict(set(self.conf.items()) - set(core_conf.conf.items()))
        return ElectronicConfiguration(valence)
```

--------------------------------

### Enable Bokeh Notebook Output

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/advanced_visualizations.html

Configure the environment to display Bokeh plots directly within a Jupyter Notebook.

```python
output_notebook()
```

--------------------------------

### Import ElectronicConfiguration

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/electronic_configuration.html

Import the ElectronicConfiguration class from the mendeleev library. This is the first step to using its functionalities.

```python
from mendeleev import Si
```

--------------------------------

### Display the first few rows of a DataFrame

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Use the `.head()` method to display the first five rows of a DataFrame. This provides a quick look at the data after merging and helps in verifying the structure and content.

```python
merged.head()
```

--------------------------------

### Get Orbital Angular Momentum Quantum Number

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Returns the 'l' quantum number for a given subshell. Raises ValueError for invalid subshell labels.

```python
def get_l(subshell: str) -> int:
    """Return the orbital angular momentum quantum number for a given subshell"""

    if subshell.lower() in ORBITALS:
        return ORBITALS.index(subshell.lower())
    else:
        raise ValueError(
            (
                f'wrong subshell label: "{subshell}",'
                + f' should be one of: {", ".join(ORBITALS)}'
            )
        )
```

--------------------------------

### Get Miedema Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Miedema scale. This scale is part of a semi-empirical theory for predicting alloy properties.

```python
>>> Si.en_miedema
4.7
```

--------------------------------

### Import Plotly Visualization Functions

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/advanced_visualizations.html

Import necessary functions for creating visualization dataframes and rendering with Plotly.

```python
from mendeleev.vis import create_vis_dataframe, periodic_table_plotly
```

--------------------------------

### Convert Configuration to List of Tuples

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Converts the electronic configuration into a list of tuples, where each tuple represents a subshell as (principal quantum number, azimuthal quantum number as int, number of electrons). Assumes `get_l` is defined.

```python
def shell2int(self) -> List[Tuple[int]]:
        """configuration as list of tuples (n, l, e)"""
        return [(x[0], get_l(x[1]), x[2]) for x in self.conf]
```

--------------------------------

### Get Ghosh Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Ghosh scale. This scale is based on absolute atomic radii and empirical parameters.

```python
>>> Si.en_ghosh
0.178503
```

--------------------------------

### Get Allred-Rochow Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Allred-Rochow scale. This scale is based on the electrostatic force exerted by the nuclear charge.

```python
>>> Si.electronegativity('allred-rochow')
0.00028240190249702736
```

--------------------------------

### Calculating Hardness

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Demonstrates how to calculate the hardness of an ion using the `hardness()` function, specifying the charge.

```APIDOC
## element.hardness(charge)

### Description
Calculates the hardness of an ion based on its charge.

### Method
`hardness` function call on an `element` object.

### Parameters
- **charge** (int) - The charge of the ion.

### Response Example
```json
60.812605
```
```

--------------------------------

### ElectronicConfiguration.parse

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Parses a string representation of an electronic configuration into an OrderedDict.

```APIDOC
## parse(self, string: str) -> None

### Description
Parse a ``string`` with electronic configuration into an ``OrderedDict`` representation.

### Parameters
#### Path Parameters
- **string** (str) - Required - The electronic configuration string to parse (e.g., '1s2 2s2 2p6').

### Returns
- **None**
```

--------------------------------

### ElectronicConfiguration Configuration Property Setter

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Setter for the 'conf' property, handling initialization from string or dictionary. Raises ValueError for unsupported types.

```python
@property
def conf(self) -> OrderedDict:
    """Return the configuration"""
    return self._conf

@conf.setter
def conf(self, value: Union[str, Dict]) -> OrderedDict:
    """Setter method for initializing the configuration"""
    if isinstance(value, str):
        self.confstr = value
        self.parse(value)
    elif isinstance(value, dict):
        self._conf = OrderedDict(
            sorted(value.items(), key=lambda x: (x[0][0] + get_l(x[0][1]), x[0][0]))
        )
    else:
        raise ValueError(f"<conf> should be str or dict, got {type(value)}")
```

--------------------------------

### Visualize Pauling's Electronegativity with Viridis Colormap

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/visualizations.html

Visualize 'en_pauling' (Pauling's Electronegativity) and color-code by attribute value using the 'viridis' colormap. This is useful for comparing electronegativity across elements.

```python
periodic_table(
    attribute="en_pauling",
    colorby="attribute",
    title="Pauling's Electronegativity",
    cmap="viridis",
)
```

--------------------------------

### Get Electrons Per Shell

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Returns a dictionary mapping shell number (n) to the total number of electrons in that shell. Assumes `SHELLS` is defined globally.

```python
def electrons_per_shell(self) -> Dict[str, int]:
        """Return number of electrons per shell as dict"""
        return {
            s: sum(v for k, v in self.conf.items() if k[0] == n)
            for n, s in zip(range(1, self.max_n() + 1), SHELLS)
        }
```

--------------------------------

### Get Database Engine

Source: https://mendeleev.readthedocs.io/en/stable/data_access.html

Retrieve the SQLAlchemy database engine for the mendeleev database. This allows for more advanced database interactions. By default, the engine is configured for read-only access.

```python
>>> from mendeleev.session import get_engine
>>> engine = get_engine()

```

--------------------------------

### Calculating Softness

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Shows how to calculate the softness of an ion using the `softness()` function, specifying the charge.

```APIDOC
## element.softness(charge)

### Description
Calculates the softness of an ion based on its charge.

### Method
`softness` function call on an `element` object.

### Parameters
- **charge** (int) - The charge of the ion.

### Response Example
```json
0.05831872935152488
```
```

--------------------------------

### Get Pauling Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Access Pauling's thermochemical electronegativity scale, which is a relative scale based on electronegativity differences derived from bond dissociation energies.

```python
>>> Si.en_pauling
1.9
```

```python
>>> Si.electronegativity('pauling')
1.9
```

--------------------------------

### ElectronicConfiguration.sort()

Source: https://mendeleev.readthedocs.io/en/stable/genindex.html

Sorts the electronic configuration.

```APIDOC
## Method sort()

### Description
Sorts the electronic configuration.

### Class
ElectronicConfiguration
```

--------------------------------

### Get Gordy Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Gordy scale. This scale is based on the potential measuring the work necessary for charge separation.

```python
>>> Si.electronegativity('gordy')
0.03275862068965517
```

--------------------------------

### Fetch and Display Scattering Factors

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Fetches the 'scattering_factors' table and displays the first 10 rows. This table contains data related to atomic scattering factors.

```python
scattering_factors = fetch_table("scattering_factors")
scattering_factors.head(10)
```

--------------------------------

### ElectronicConfiguration.slater_screening()

Source: https://mendeleev.readthedocs.io/en/stable/genindex.html

Calculates Slater screening for ElectronicConfiguration.

```APIDOC
## Method slater_screening()

### Description
Calculates Slater screening.

### Class
ElectronicConfiguration
```

--------------------------------

### Get Isotope Information

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Retrieve detailed information about a specific isotope using its atomic number and mass number. This includes properties like half-life, mass, and spin.

```python
isotope(1, 3)
```

--------------------------------

### Get Sanderson Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the Sanderson electronegativity, calculated based on the stability ratio derived from average electron density. This method provides a unique scale for electronegativity.

```python
>>> Si.en_sanderson()
0.3468157872145231
```

```python
>>> Si.electronegativity()
0.3468157872145231
```

--------------------------------

### oxidation_states(_category : str = 'main'_)

Source: https://mendeleev.readthedocs.io/en/stable/api/models.html

Retrieves oxidation states for the element based on the specified category.

```APIDOC
## oxidation_states(_category : str = 'main'_)

### Description
Utility method for accessing oxidation states.

### Parameters
#### Query Parameters
- **_category** (str) - Optional - Category of oxidation state. Options are 'main' (default), 'extended', or 'all'.

### Response
#### Success Response (200)
- **oxidation_states** (List[int]) - A list of oxidation states.
```

--------------------------------

### nist_webbook_url

Source: https://mendeleev.readthedocs.io/en/stable/api/models.html

URL for the NIST Chemistry WebBook.

```APIDOC
## nist_webbook_url

### Description
URL for the NIST Chemistry WebBook.

### Response
#### Success Response (200)
- **nist_webbook_url** (str) - The URL for the NIST Chemistry WebBook.
```

--------------------------------

### Fetch All Electronegativities

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Use `fetch_electronegativities` to retrieve all data from electronegativity scales. This operation can take a few seconds as most values require computation. The result is a pandas DataFrame.

```python
from mendeleev.fetch import fetch_electronegativities
```

```python
ens = fetch_electronegativities()
ens.head(10)
```

--------------------------------

### Get Martynov and Batsanov Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Martynov and Batsanov scale. This scale uses the square root of the averaged valence ionization energy.

```python
>>> Si.en_martynov_batsanov()
5.0777041564076963
```

```python
>>> Si.electronegativity(scale='martynov-batsanov')
5.0777041564076963
```

--------------------------------

### Display First 10 Records

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Use the `.head(10)` method to view the first 10 rows of the DataFrame, providing a glimpse of the data content.

```python
isotopes.head(10)
```

--------------------------------

### Get Cottrell-Sutton Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Retrieve the electronegativity value for Silicon using the Cottrell-Sutton scale. This scale is derived from a specific equation involving effective nuclear charge and covalent radius.

```python
>>> Si.electronegativity('cottrell-sutton')
0.18099342720014772
```

--------------------------------

### Clone Mendeleev Repository

Source: https://mendeleev.readthedocs.io/en/stable/CONTRIBUTING.html

Clone your forked repository to your local machine to begin making changes.

```bash
git clone https://github.com/lmmentel/mendeleev.git
```

--------------------------------

### Get Last Subshell

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Returns the last subshell in the electronic configuration, either based on the order of insertion ('order') or Aufbau principle ('aufbau'). Raises ValueError for invalid 'wrt' arguments.

```python
def last_subshell(self, wrt: str = "order"):
        """Return the valence shell"""
        if wrt.lower() == "order":
            return list(self.conf.items())[-1]
        elif wrt.lower() == "aufbau":
            return sorted(
                self.conf.items(), key=lambda x: (x[0][0] + get_l(x[0][1]), x[0][0])
            )[-1]
        else:
            raise ValueError(f"wrong <wrt>: {wrt}")
```

--------------------------------

### Access Isotope Decay Modes

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

For radioactive isotopes, access the `decay_modes` attribute to get a list of possible decay modes and their intensities. This requires specifying the element symbol or atomic number.

```python
isotope("Li", 11).decay_modes
```

--------------------------------

### Visualize Atomic Radius with Bokeh

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/advanced_visualizations.html

Render the periodic table using Bokeh, highlighting the 'atomic_radius' attribute and coloring by this attribute. This demonstrates customization options with Bokeh.

```python
fig = periodic_table_bokeh(elements, attribute="atomic_radius", colorby="attribute")
show(fig)
```

--------------------------------

### Render Periodic Table in Wide Layout

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/visualizations.html

Use the `periodic_table` function with `wide_layout=True` to display the periodic table in a 32-column format. Adjust `height` and `width` for desired dimensions.

```python
periodic_table(height=600, width=1500, wide_layout=True)
```

--------------------------------

### Get Maximum Azimuthal Quantum Number for a Principal Quantum Number

Source: https://mendeleev.readthedocs.io/en/stable/_modules/mendeleev/econf.html

Finds the largest azimuthal quantum number (l) for a given principal quantum number (n). Assumes `ORBITALS` and `get_l` are defined.

```python
def max_l(self, n: int) -> int:
        """
        Return the largest value of azimutal quantum number for a given
        value of principal quantum number

        Args:
            n : int
                Principal quantum number

        Returns:
            l: int
                Azimutal quantum number
        """
        return ORBITALS[max(get_l(x[1]) for x in self.conf.keys() if x[0] == n)]
```

--------------------------------

### Get Mullay Electronegativity

Source: https://mendeleev.readthedocs.io/en/stable/electronegativity.html

Access Mullay's orbital electronegativity for an element. This scale is calculated using a formula involving orbital character, screened nuclear charge, and effective principal quantum number.

```python
>>> Si.en_mullay
1.91
```

```python
>>> Si.electronegativity("mullay")
1.91
```

--------------------------------

### Calculating Number of Valence Electrons

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/quick_start.html

Demonstrates the use of the `nvalence()` function to calculate the number of valence electrons for an element.

```APIDOC
## element.nvalence()

### Description
Calculates the number of valence electrons for an element.

### Method
`nvalence` function call on an `element` object.

### Response Example
```json
4
```
```

--------------------------------

### Fetch and Display Series Metadata

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/bulk_data_access.html

Fetches the 'series' table, which contains metadata about periodic table series including their names and associated colors. The entire table is displayed.

```python
series = fetch_table("series")
series
```

--------------------------------

### Fetch Table Data as DataFrame

Source: https://mendeleev.readthedocs.io/en/stable/data_access.html

Retrieve a specified table from the mendeleev database as a pandas DataFrame. This function is useful for accessing bulk data such as element properties, group information, or ionization energies. Ensure pandas is installed.

```python
>>> from mendeleev.fetch import fetch_table
>>> df = fetch_table('elements')
>>> type(df)
pandas.core.frame.DataFrame

```

--------------------------------

### Display Default Periodic Table

Source: https://mendeleev.readthedocs.io/en/stable/notebooks/visualizations.html

Call the imported `periodic_table` function without any arguments to display the default visualization of the periodic table.

```python
periodic_table()
```
Tokens:
Raw