├── tests ├── __init__.py └── test_interval.py ├── requirements.txt ├── docs ├── sample_plot.png └── example.ipynb ├── plot_likert ├── __init__.py ├── colors.py ├── interval.py ├── scales.py └── plot_likert.py ├── setup.py ├── .github └── workflows │ └── test.yml ├── LICENSE ├── README.md └── .gitignore /tests/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | matplotlib>=3.4.0 2 | numpy 3 | pandas 4 | -------------------------------------------------------------------------------- /docs/sample_plot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nmalkin/plot-likert/HEAD/docs/sample_plot.png -------------------------------------------------------------------------------- /plot_likert/__init__.py: -------------------------------------------------------------------------------- 1 | import plot_likert.plot_likert as __internal__ 2 | from .plot_likert import ( 3 | plot_likert, 4 | plot_counts, 5 | likert_counts, 6 | likert_percentages, 7 | likert_response, 8 | raw_scale, 9 | PlotLikertError, 10 | ) 11 | 12 | name = "plot_likert" 13 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | import setuptools 2 | 3 | with open("README.md", "r") as fh: 4 | long_description = fh.read() 5 | 6 | with open("requirements.txt", "r") as f: 7 | requirements = f.read().splitlines() 8 | 9 | setuptools.setup( 10 | name="plot-likert", 11 | version="0.5.0", 12 | author="nmalkin", 13 | description="Library to visualize results from Likert-style survey questions", 14 | long_description=long_description, 15 | long_description_content_type="text/markdown", 16 | keywords="plot graph visualize likert survey matplotlib", 17 | url="https://github.com/nmalkin/plot-likert", 18 | packages=setuptools.find_packages(), 19 | classifiers=[ 20 | "Programming Language :: Python :: 3", 21 | "License :: OSI Approved :: BSD License", 22 | "Operating System :: OS Independent", 23 | "Development Status :: 3 - Alpha", 24 | "Topic :: Scientific/Engineering :: Visualization", 25 | ], 26 | python_requires=">=3.6", 27 | install_requires=requirements, 28 | ) 29 | -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions 2 | # It's based on the sample workflow here: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions 3 | 4 | name: Basic testing 5 | 6 | on: 7 | push: 8 | branches: [master] 9 | pull_request: 10 | branches: [master] 11 | 12 | jobs: 13 | build: 14 | runs-on: ubuntu-latest 15 | strategy: 16 | fail-fast: false 17 | matrix: 18 | python-version: ["3.7", "3.8", "3.9", "3.10"] 19 | 20 | steps: 21 | - uses: actions/checkout@v2 22 | - name: Set up Python ${{ matrix.python-version }} 23 | uses: actions/setup-python@v2 24 | with: 25 | python-version: ${{ matrix.python-version }} 26 | - name: Install dependencies 27 | run: | 28 | python -m pip install --upgrade pip 29 | python -m pip install flake8 pytest 30 | if [ -f requirements.txt ]; then pip install -r requirements.txt; fi 31 | - name: Lint with flake8 32 | run: | 33 | # stop the build if there are Python syntax errors or undefined names 34 | flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics 35 | - name: Test with unittest 36 | run: | 37 | python -m unittest 38 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2018 N. Malkin 2 | 3 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 4 | 5 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 6 | 7 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 8 | 9 | 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 10 | 11 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 12 | -------------------------------------------------------------------------------- /tests/test_interval.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from plot_likert.interval import * 4 | 5 | 6 | class TestIntervalCalculations(unittest.TestCase): 7 | def test_get_next_interval_divisor(self): 8 | generator = get_next_interval_divisor() 9 | divisor = generator.__next__() 10 | self.assertEqual(5, divisor) 11 | divisor = generator.__next__() 12 | self.assertEqual(10, divisor) 13 | divisor = generator.__next__() 14 | self.assertEqual(25, divisor) 15 | divisor = generator.__next__() 16 | self.assertEqual(50, divisor) 17 | divisor = generator.__next__() 18 | self.assertEqual(100, divisor) 19 | divisor = generator.__next__() 20 | self.assertEqual(1000, divisor) 21 | divisor = generator.__next__() 22 | self.assertEqual(10000, divisor) 23 | 24 | def test_get_biggest_divisor(self): 25 | self.assertEqual(1, get_biggest_divisor(4)) 26 | self.assertEqual(5, get_biggest_divisor(5)) 27 | self.assertEqual(1, get_biggest_divisor(9)) 28 | self.assertEqual(10, get_biggest_divisor(10)) 29 | self.assertEqual(5, get_biggest_divisor(15)) 30 | self.assertEqual(100, get_biggest_divisor(200)) 31 | self.assertEqual(1, get_biggest_divisor(202)) 32 | self.assertEqual(1000, get_biggest_divisor(1000)) 33 | self.assertEqual(10, get_biggest_divisor(1010)) 34 | 35 | def test_get_best_interval_in_list(self): 36 | self.assertEqual(5, get_best_interval_in_list([3, 4, 5])) 37 | self.assertEqual(10, get_best_interval_in_list([9, 10, 11])) 38 | self.assertEqual(100, get_best_interval_in_list(list(range(1, 199)))) 39 | -------------------------------------------------------------------------------- /plot_likert/colors.py: -------------------------------------------------------------------------------- 1 | """ 2 | This file allow for more color maps. 3 | """ 4 | 5 | import typing 6 | 7 | Colors = typing.List[str] 8 | 9 | TRANSPARENT = "#ffffff00" 10 | 11 | default: Colors = [ 12 | TRANSPARENT, 13 | "firebrick", 14 | "lightcoral", 15 | "gainsboro", 16 | "cornflowerblue", 17 | "darkblue", 18 | ] 19 | 20 | default_with_darker_neutral: Colors = [ 21 | TRANSPARENT, 22 | "firebrick", 23 | "lightcoral", 24 | "silver", 25 | "cornflowerblue", 26 | "darkblue", 27 | ] 28 | 29 | default_label_color = "white" 30 | 31 | # default color scheme with neutral removed 32 | likert4: Colors = list(default) 33 | likert4.pop(len(likert4) // 2) 34 | 35 | likert5: Colors = [TRANSPARENT, "#d8a539", "#efe0c1", "lightgray", "#bde1dd", "#5ab4ac"] 36 | 37 | likert6: Colors = [ 38 | TRANSPARENT, 39 | "#d8a539", 40 | "#dfc283", 41 | "#efe0c1", 42 | "#def0ee", 43 | "#7bc3bc", 44 | "#5ab4ac", 45 | ] 46 | likert7: Colors = [ 47 | TRANSPARENT, 48 | "#d8a539", 49 | "#dfc283", 50 | "#efe0c1", 51 | "lightgray", 52 | "#bde1dd", 53 | "#7bc3bc", 54 | "#5ab4ac", 55 | ] 56 | 57 | likert8: Colors = [ 58 | TRANSPARENT, 59 | "#d8b365", 60 | "#dfc283", 61 | "#e7d1a2", 62 | "#efe0c1", 63 | "#bde1dd", 64 | "#9cd2cd", 65 | "#7bc3bc", 66 | "#5ab4ac", 67 | ] 68 | 69 | likert9: Colors = [ 70 | TRANSPARENT, 71 | "#d8b365", 72 | "#dfc283", 73 | "#e7d1a2", 74 | "#efe0c1", 75 | "lightgray", 76 | "#bde1dd", 77 | "#9cd2cd", 78 | "#7bc3bc", 79 | "#5ab4ac", 80 | ] 81 | 82 | likert10: Colors = [ 83 | TRANSPARENT, 84 | "#d8b365", 85 | "#dfc283", 86 | "#e7d1a2", 87 | "#efe0c1", 88 | "#f7efe0", 89 | "#def0ee", 90 | "#bde1dd", 91 | "#9cd2cd", 92 | "#7bc3bc", 93 | "#5ab4ac", 94 | ] 95 | -------------------------------------------------------------------------------- /plot_likert/interval.py: -------------------------------------------------------------------------------- 1 | """ 2 | Module for computing the best interval for the x-ticks on a plot 3 | """ 4 | 5 | import typing 6 | 7 | 8 | import numpy as np 9 | 10 | 11 | def get_next_interval_divisor() -> typing.Generator[int, None, None]: 12 | """ 13 | A generator that yields "useful" interval values. 14 | These are 5, 10, 25, 50, and then successive powers of 10 15 | """ 16 | yield 5 17 | yield 10 18 | yield 25 19 | yield 50 20 | i = 1 21 | while True: 22 | i += 1 23 | yield 10**i 24 | 25 | 26 | def get_biggest_divisor(n: int) -> int: 27 | """ 28 | Returns the largest divisor, from those generated by get_next_interval_divisor(), 29 | that divides the given number without a remainder. 30 | """ 31 | biggest_divisor = 1 32 | for divisor in get_next_interval_divisor(): 33 | if divisor > n: 34 | return biggest_divisor 35 | 36 | if n % divisor == 0: 37 | biggest_divisor = divisor 38 | 39 | raise RuntimeError( 40 | "this should never be reached because get_next_interval_divisor returns increasingly big numbers" 41 | ) # needed for type-checking 42 | 43 | 44 | def get_best_interval_in_list(candidate_intervals: typing.List[int]) -> int: 45 | """ 46 | Given a list of values, returns the one with the largest divisor (as defined above) 47 | """ 48 | candidate_divisors = list(map(get_biggest_divisor, candidate_intervals)) 49 | best_candidate = np.argmax(candidate_divisors) 50 | best_interval = candidate_intervals[best_candidate] 51 | 52 | return best_interval 53 | 54 | 55 | def get_interval_for_scale(tick_space: int, max_width: int) -> int: 56 | """ 57 | Given a width of the plot (max_width) and a suggested number of tick marks (tick_space), 58 | return the "best" interval to use between tick marks. 59 | """ 60 | min_ticks = tick_space - 5 61 | min_ticks = 1 if min_ticks <= 0 else min_ticks 62 | max_ticks = tick_space + 2 63 | 64 | # Ensure zero can't be an interval 65 | min_interval = max(1, int(max_width / max_ticks)) 66 | max_interval = max(1, round(max_width / min_ticks)) 67 | 68 | candidate_intervals = list(range(min_interval, max_interval + 1)) 69 | return get_best_interval_in_list(candidate_intervals) 70 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Plot Likert 2 | =========== 3 | This is a library to visualize results from [Likert-type](https://en.wikipedia.org/wiki/Likert_scale) survey questions in Python, using [matplotlib](https://matplotlib.org/). 4 | 5 | ![A sample plot](docs/sample_plot.png) 6 | 7 | 8 | 9 | Installation 10 | ------------ 11 | Install the latest stable version from PyPI: 12 | 13 | ```shell 14 | pip install plot-likert 15 | ``` 16 | 17 | To get the latest development version: 18 | 19 | ```shell 20 | pip install --pre plot-likert 21 | # OR 22 | pip install git+https://github.com/nmalkin/plot-likert.git 23 | ``` 24 | 25 | 26 | Quick start 27 | ----------- 28 | ```python 29 | # Make sure you have some data 30 | import pandas as pd 31 | 32 | data = pd.DataFrame({'Q1': {0: 'Strongly disagree', 1: 'Agree', ...}, 33 | 'Q2': {0: 'Disagree', 1: 'Strongly agree', ...}}) 34 | 35 | # Now plot it! 36 | import plot_likert 37 | 38 | plot_likert.plot_likert(data, plot_likert.scales.agree, plot_percentage=True); 39 | ``` 40 | 41 | 42 | Usage and sample figures 43 | ------------------------ 44 | 45 | To learn about how to use this library and see more example figures, 46 | [visit the User Guide, which is a Jupyter notebook](https://github.com/nmalkin/plot-likert/blob/release/docs/guide.ipynb). 47 | 48 | Want to see even more examples? [Look here](docs/lots_of_random_figures.ipynb)! 49 | 50 | Background 51 | ---------- 52 | 53 | This library was inspired by Jason Bryer's great [`likert` package for R](https://cran.r-project.org/web/packages/likert/) (but it's nowhere near as good). 54 | I needed to visualize the results of some Likert-style questions and knew about the `likert` R package but was surprised to find nothing like that existed in Python, except for a [Stackoverflow answer by Austin Cory Bart](https://stackoverflow.com/a/41384812). This package builds on that solution and packages it as a library. 55 | 56 | I've since discovered that there may be other solutions out there. 57 | Here are a few to consider: 58 | - https://github.com/dmardanbeigi/Likert_Scale_Plot_in_Python 59 | - https://github.com/Oliph/likertScalePlot 60 | - https://blog.orikami.nl/behind-the-screens-likert-scale-visualization-368557ad72d1 61 | 62 | While this library started as a quick-and-dirty hack, 63 | it has been steadily improving thanks to the contributions of a number of community members and [Fjohürs Lykkewe](https://www.youtube.com/watch?v=ef7cTuVUiWs). 64 | Thank you to everyone who has contributed! 65 | -------------------------------------------------------------------------------- /plot_likert/scales.py: -------------------------------------------------------------------------------- 1 | import typing 2 | 3 | Scale = typing.List[str] 4 | 5 | agree5_0: Scale = [ 6 | "0", 7 | "Strongly disagree", 8 | "Disagree", 9 | "Neither agree nor disagree", 10 | "Agree", 11 | "Strongly agree", 12 | ] 13 | 14 | agree5: Scale = [ 15 | "Strongly disagree", 16 | "Disagree", 17 | "Neither agree nor disagree", 18 | "Agree", 19 | "Strongly agree", 20 | ] 21 | agree: Scale = agree5 22 | 23 | acceptable5_0: Scale = [ 24 | "0", 25 | "Completely unacceptable", 26 | "Somewhat unacceptable", 27 | "Neutral", 28 | "Somewhat acceptable", 29 | "Completely acceptable", 30 | ] 31 | 32 | acceptable5: Scale = [ 33 | "Completely unacceptable", 34 | "Somewhat unacceptable", 35 | "Neutral", 36 | "Somewhat acceptable", 37 | "Completely acceptable", 38 | ] 39 | acceptable: Scale = acceptable5 40 | 41 | likely5: Scale = [ 42 | "Very unlikely", 43 | "Somewhat unlikely", 44 | "Neutral", 45 | "Somewhat likely", 46 | "Very likely", 47 | ] 48 | likely: Scale = likely5 49 | 50 | scores5_0: Scale = [ 51 | "0", 52 | "1 - Strongly Disagree", 53 | "2 - Disagree", 54 | "3 - Neither Agree nor Disagree", 55 | "4 - Agree", 56 | "5 - Strongly Agree", 57 | ] 58 | 59 | scores5: Scale = [ 60 | "1 - Strongly Disagree", 61 | "2 - Disagree", 62 | "3 - Neither Agree nor Disagree", 63 | "4 - Agree", 64 | "5 - Strongly Agree", 65 | ] 66 | 67 | scores6_0: Scale = [ 68 | "0", 69 | "1 - Strongly Disagree", 70 | "2 - Disagree", 71 | "3 - Slightly Disagree", 72 | "4 - Slightly Agree", 73 | "5 - Agree", 74 | "6 - Strongly Agree", 75 | ] 76 | 77 | scores6: Scale = [ 78 | "1 - Strongly Disagree", 79 | "2 - Disagree", 80 | "3 - Slightly Disagree", 81 | "4 - Slightly Agree", 82 | "5 - Agree", 83 | "6 - Strongly Agree", 84 | ] 85 | 86 | scores7_0: Scale = [ 87 | "0", 88 | "1 - Strongly Disagree", 89 | "2 - Disagree", 90 | "3 - Slightly Disagree", 91 | "4 - Neither Agree nor Disagree", 92 | "5 - Slightly Agree", 93 | "6 - Agree", 94 | "7 - Strongly Agree", 95 | ] 96 | 97 | scores7: Scale = [ 98 | "1 - Strongly Disagree", 99 | "2 - Disagree", 100 | "3 - Slightly Disagree", 101 | "4 - Neither Agree nor Disagree", 102 | "5 - Slightly Agree", 103 | "6 - Agree", 104 | "7 - Strongly Agree", 105 | ] 106 | 107 | raw5_0: Scale = ["0", "1", "2", "3", "4", "5"] 108 | raw5: Scale = ["1", "2", "3", "4", "5"] 109 | 110 | raw6_0: Scale = ["0", "1", "2", "3", "4", "5", "6"] 111 | 112 | raw6: Scale = ["1", "2", "3", "4", "5", "6"] 113 | 114 | raw7_0: Scale = ["0", "1", "2", "3", "4", "5", "6", "7"] 115 | 116 | raw7: Scale = ["1", "2", "3", "4", "5", "6", "7"] 117 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # via https://github.com/github/gitignore/blob/master/Python.gitignore 2 | 3 | # Byte-compiled / optimized / DLL files 4 | __pycache__/ 5 | *.py[cod] 6 | *$py.class 7 | 8 | # C extensions 9 | *.so 10 | 11 | # Distribution / packaging 12 | .Python 13 | build/ 14 | develop-eggs/ 15 | dist/ 16 | downloads/ 17 | eggs/ 18 | .eggs/ 19 | lib/ 20 | lib64/ 21 | parts/ 22 | sdist/ 23 | var/ 24 | wheels/ 25 | share/python-wheels/ 26 | *.egg-info/ 27 | .installed.cfg 28 | *.egg 29 | MANIFEST 30 | 31 | # PyInstaller 32 | # Usually these files are written by a python script from a template 33 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 34 | *.manifest 35 | *.spec 36 | 37 | # Installer logs 38 | pip-log.txt 39 | pip-delete-this-directory.txt 40 | 41 | # Unit test / coverage reports 42 | htmlcov/ 43 | .tox/ 44 | .nox/ 45 | .coverage 46 | .coverage.* 47 | .cache 48 | nosetests.xml 49 | coverage.xml 50 | *.cover 51 | *.py,cover 52 | .hypothesis/ 53 | .pytest_cache/ 54 | cover/ 55 | 56 | # Translations 57 | *.mo 58 | *.pot 59 | 60 | # Django stuff: 61 | *.log 62 | local_settings.py 63 | db.sqlite3 64 | db.sqlite3-journal 65 | 66 | # Flask stuff: 67 | instance/ 68 | .webassets-cache 69 | 70 | # Scrapy stuff: 71 | .scrapy 72 | 73 | # Sphinx documentation 74 | docs/_build/ 75 | 76 | # PyBuilder 77 | .pybuilder/ 78 | target/ 79 | 80 | # Jupyter Notebook 81 | .ipynb_checkpoints 82 | 83 | # IPython 84 | profile_default/ 85 | ipython_config.py 86 | 87 | # pyenv 88 | # For a library or package, you might want to ignore these files since the code is 89 | # intended to run in multiple environments; otherwise, check them in: 90 | # .python-version 91 | 92 | # pipenv 93 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 94 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 95 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 96 | # install all needed dependencies. 97 | #Pipfile.lock 98 | 99 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 100 | __pypackages__/ 101 | 102 | # Celery stuff 103 | celerybeat-schedule 104 | celerybeat.pid 105 | 106 | # SageMath parsed files 107 | *.sage.py 108 | 109 | # Environments 110 | .env 111 | .venv 112 | env/ 113 | venv/ 114 | ENV/ 115 | env.bak/ 116 | venv.bak/ 117 | 118 | # Spyder project settings 119 | .spyderproject 120 | .spyproject 121 | 122 | # Rope project settings 123 | .ropeproject 124 | 125 | # mkdocs documentation 126 | /site 127 | 128 | # mypy 129 | .mypy_cache/ 130 | .dmypy.json 131 | dmypy.json 132 | 133 | # Pyre type checker 134 | .pyre/ 135 | 136 | # pytype static type analyzer 137 | .pytype/ 138 | 139 | # Cython debug symbols 140 | cython_debug/ 141 | -------------------------------------------------------------------------------- /plot_likert/plot_likert.py: -------------------------------------------------------------------------------- 1 | """ 2 | Plot Likert-style data from Pandas using Matplotlib 3 | 4 | Initially based on code from Austin Cory Bart 5 | https://stackoverflow.com/a/41384812 6 | 7 | 8 | Note: 9 | the data must be strings 10 | for a float: scores.applymap(int).applymap(str) 11 | """ 12 | 13 | 14 | import logging 15 | import typing 16 | from warnings import warn 17 | from textwrap import wrap 18 | 19 | import numpy as np 20 | import pandas as pd 21 | 22 | 23 | try: 24 | import matplotlib.axes 25 | import matplotlib.pyplot as plt 26 | except RuntimeError as err: 27 | logging.error( 28 | "Couldn't import matplotlib, likely because this package is running in an environment that doesn't support it (i.e., without a graphical output). See error for more information." 29 | ) 30 | raise err 31 | 32 | from plot_likert.scales import Scale 33 | import plot_likert.colors as builtin_colors 34 | import plot_likert.interval as interval_helper 35 | 36 | HIDE_EXCESSIVE_TICK_LABELS = True 37 | PADDING_LEFT = 0.02 # fraction of the total width to use as padding 38 | PADDING_RIGHT = 0.04 # fraction of the total width to use as padding 39 | BAR_LABEL_FORMAT = ( 40 | "%g" # if showing labels, how should the number be formatted? e.g., "%.2g" 41 | ) 42 | BAR_LABEL_SIZE_CUTOFF = 0.05 43 | 44 | 45 | class PlotLikertError(ValueError): 46 | pass 47 | 48 | 49 | def plot_counts( 50 | counts: pd.DataFrame, 51 | scale: Scale, 52 | plot_percentage: typing.Optional[bool] = None, 53 | colors: builtin_colors.Colors = builtin_colors.default, 54 | figsize=None, 55 | xtick_interval: typing.Optional[int] = None, 56 | compute_percentages: bool = False, 57 | bar_labels: bool = False, 58 | bar_labels_color: typing.Union[str, typing.List[str]] = "white", 59 | **kwargs, 60 | ) -> matplotlib.axes.Axes: 61 | """ 62 | Plot the given counts of Likert responses. 63 | 64 | 65 | Parameters 66 | ---------- 67 | counts : pd.DataFrame 68 | The given DataFrame should contain the pre-computed counts of responses to a set of Likert-style questions. 69 | Its columns represent the total counts in each category, while each row is a different question. 70 | scale : list of str 71 | The scale used for the plot: an ordered list of strings for each of the answer options. 72 | plot_percentage : bool, optional 73 | DEPRECATED: use `compute_percentages` instead. 74 | If true, the counts are assumed to be percentages and % marks will be added to the x-axis labels. 75 | colors : list of str 76 | A list of colors in hex string or RGB tuples to use for plotting. 77 | Attention: if your colormap doesn't work right try appending transparent ("#ffffff00") in the first place. 78 | figsize : tuple of (int, int) 79 | A tuple (width, heigth) that controls size of the final figure - similarly to matplotlib 80 | xtick_interval : int, optional 81 | Controls the interval between x-axis ticks. 82 | compute_percentages : bool, default = True, 83 | Convert the given response counts to percentages and display the counts as percentages in the plot. 84 | bar_labels : bool, default = False 85 | Show a label with the value of each bar segment on top of it 86 | bar_labels_color : str or list of str = "white", 87 | If showing bar labels, use this color (or colors) for the text 88 | **kwargs 89 | Options to pass to pandas plotting method. 90 | 91 | Returns 92 | ------- 93 | matplotlib.axes.Axes 94 | The axes of the generated Likert plot 95 | 96 | See Also 97 | -------- 98 | plot_likert : aggregate raw responses then plot them. Most often, you'll want to use that function instead of calling this one directly. 99 | """ 100 | if plot_percentage is not None: 101 | warn( 102 | "parameter `plot_percentage` for `plot_likert.likert_counts` is deprecated, set it to None and use `compute_percentages` instead", 103 | FutureWarning, 104 | ) 105 | counts_are_percentages = plot_percentage 106 | else: 107 | # Re-compute counts as percentages, if requested 108 | if compute_percentages: 109 | counts = _compute_counts_percentage(counts) 110 | counts_are_percentages = True 111 | else: 112 | counts_are_percentages = False 113 | 114 | # Pad each row/question from the left, so that they're centered around the middle (Neutral) response 115 | scale_middle = len(scale) // 2 116 | 117 | if scale_middle == len(scale) / 2: 118 | middles = counts.iloc[:, 0:scale_middle].sum(axis=1) 119 | else: 120 | middles = ( 121 | counts.iloc[:, 0:scale_middle].sum(axis=1) 122 | + counts.iloc[:, scale_middle] / 2 123 | ) 124 | 125 | center = middles.max() 126 | 127 | padding_values = (middles - center).abs() 128 | padded_counts = pd.concat([padding_values, counts], axis=1) 129 | # Hide the padding row from the legend 130 | padded_counts = padded_counts.rename({0: ""}, axis=1) 131 | 132 | # Reverse rows to keep the questions in order 133 | # (Otherwise, the plot function shows the last one at the top.) 134 | reversed_rows = padded_counts.iloc[::-1] 135 | 136 | # Start putting together the plot 137 | axes = reversed_rows.plot.barh( 138 | stacked=True, color=colors, figsize=figsize, **kwargs 139 | ) 140 | 141 | # Draw center line 142 | center_line = axes.axvline(center, linestyle="--", color="black", alpha=0.5) 143 | center_line.set_zorder(-1) 144 | 145 | # Compute and show x labels 146 | max_width = int(round(padded_counts.sum(axis=1).max())) 147 | if xtick_interval is None: 148 | num_ticks = axes.xaxis.get_tick_space() 149 | interval = interval_helper.get_interval_for_scale(num_ticks, max_width) 150 | else: 151 | interval = xtick_interval 152 | 153 | right_edge = max_width - center 154 | right_labels = np.arange(interval, right_edge + interval, interval) 155 | right_values = center + right_labels 156 | left_labels = np.arange(0, center + 1, interval) 157 | left_values = center - left_labels 158 | xlabels = np.concatenate([left_labels, right_labels]) 159 | xvalues = np.concatenate([left_values, right_values]) 160 | 161 | xlabels = [int(l) for l in xlabels if round(l) == l] 162 | 163 | # Ensure tick labels don't exceed number of participants 164 | # (or, in the case of percentages, 100%) since that looks confusing 165 | if HIDE_EXCESSIVE_TICK_LABELS: 166 | # Labels for tick values that are too high are hidden, 167 | # but the tick mark itself remains displayed. 168 | total_max = counts.sum(axis="columns").max() 169 | xlabels = ["" if label > total_max else label for label in xlabels] 170 | 171 | if counts_are_percentages: 172 | xlabels = [str(label) + "%" if label != "" else "" for label in xlabels] 173 | 174 | axes.set_xticks(xvalues) 175 | axes.set_xticklabels(xlabels) 176 | if counts_are_percentages is True: 177 | axes.set_xlabel("Percentage of Responses") 178 | else: 179 | axes.set_xlabel("Number of Responses") 180 | 181 | # Reposition the legend if present 182 | if axes.get_legend(): 183 | axes.legend(bbox_to_anchor=(1.05, 1)) 184 | 185 | # Adjust padding 186 | counts_sum = counts.sum(axis="columns").max() 187 | # Pad the bars on the left (so there's a gap between the axis and the first section) 188 | padding_left = counts_sum * PADDING_LEFT 189 | # Tighten the padding on the right of the figure 190 | padding_right = counts_sum * PADDING_RIGHT 191 | x_min, x_max = axes.get_xlim() 192 | axes.set_xlim(x_min - padding_left, x_max - padding_right) 193 | 194 | # Add labels 195 | if bar_labels: 196 | bar_label_format = BAR_LABEL_FORMAT + ("%%" if compute_percentages else "") 197 | bar_size_cutoff = counts_sum * BAR_LABEL_SIZE_CUTOFF 198 | 199 | if isinstance(bar_labels_color, list): 200 | if len(bar_labels_color) != len(scale): 201 | raise PlotLikertError( 202 | "list of bar label colors must have as many values as the scale" 203 | ) 204 | bar_label_colors = bar_labels_color 205 | else: 206 | bar_label_colors = [bar_labels_color] * len(scale) 207 | 208 | for i, segment in enumerate( 209 | axes.containers[1:] # the first container is the padding 210 | ): 211 | try: 212 | labels = axes.bar_label( 213 | segment, 214 | label_type="center", 215 | fmt=bar_label_format, 216 | padding=0, 217 | color=bar_label_colors[i], 218 | weight="bold", 219 | ) 220 | except AttributeError: 221 | raise PlotLikertError( 222 | "Rendering bar labels requires matplotlib version 3.4.0 or higher" 223 | ) 224 | 225 | # Remove labels that don't fit because the bars are too small 226 | for label in labels: 227 | label_text = label.get_text() 228 | if compute_percentages: 229 | label_text = label_text.rstrip("%") 230 | number = float(label_text) 231 | if number < bar_size_cutoff: 232 | label.set_text("") 233 | 234 | return axes 235 | 236 | 237 | def likert_counts( 238 | df: typing.Union[pd.DataFrame, pd.Series], 239 | scale: Scale, 240 | label_max_width=30, 241 | drop_zeros=False, 242 | ) -> pd.DataFrame: 243 | """ 244 | Given a dataframe of Likert-style responses, returns a count of each response, 245 | validating them against the provided scale. 246 | """ 247 | 248 | if type(df) == pd.core.series.Series: 249 | df = df.to_frame() 250 | 251 | def validate(value): 252 | if (not pd.isna(value)) and (value not in scale): 253 | raise PlotLikertError( 254 | f"A response was found with value `{value}`, which is not one of the values in the provided scale: {scale}. If this is unexpected, you might want to double-check for extra whitespace, capitalization, spelling, or type (int versus str)." 255 | ) 256 | 257 | try: 258 | df.map(validate) 259 | except AttributeError: # for compatibility with Pandas < 2.1.0 260 | df.applymap(validate) 261 | 262 | # fix long questions for printing 263 | old_labels = list(df) 264 | new_labels = ["\n".join(wrap(str(l), label_max_width)) for l in old_labels] 265 | if pd.__version__ >= "1.5.0": 266 | df = df.set_axis(new_labels, axis=1, copy=True) 267 | else: 268 | df = df.set_axis(new_labels, axis=1, inplace=False) 269 | 270 | counts_unordered = df.apply(lambda row: row.value_counts()) 271 | counts = counts_unordered.reindex(scale).T 272 | counts = counts.fillna(0) 273 | 274 | # remove NA scores 275 | if drop_zeros == True: 276 | counts = counts.drop("0", axis=1) 277 | 278 | return counts 279 | 280 | 281 | def likert_percentages( 282 | df: pd.DataFrame, scale: Scale, width=30, zero=False 283 | ) -> pd.DataFrame: 284 | """ 285 | Given a dataframe of Likert-style responses, returns a new one 286 | reporting the percentage of respondents that chose each response. 287 | Percentages are rounded to integers. 288 | """ 289 | 290 | counts = likert_counts(df, scale, width, zero) 291 | 292 | # Warn if the rows have different counts 293 | # If they do, the percentages shouldn't be compared. 294 | responses_per_question = counts.sum(axis=1) 295 | responses_to_first_question = responses_per_question.iloc[0] 296 | responses_same = responses_per_question == responses_to_first_question 297 | if not responses_same.all(): 298 | warn( 299 | "In your data, not all questions have the same number of responses. i.e., different numbers of people answered each question. Therefore, the percentages aren't directly comparable: X% for one question represents a different number of responses than X% for another question, yet they will appear the same in the percentage graph. This may be misleading to your reader." 300 | ) 301 | 302 | try: 303 | return counts.apply(lambda row: row / row.sum(), axis=1).map(lambda v: 100 * v) 304 | except AttributeError: # for compatibility with Pandas < 2.1.0 305 | return counts.apply(lambda row: row / row.sum(), axis=1).applymap( 306 | lambda v: 100 * v 307 | ) 308 | 309 | 310 | def _compute_counts_percentage(counts: pd.DataFrame) -> pd.DataFrame: 311 | """ 312 | Given a dataframe of response counts, return a new one 313 | with the response counts converted to percentages. 314 | """ 315 | # Warn if the rows have different counts 316 | # If they do, the percentages shouldn't be compared. 317 | responses_per_question = counts.sum(axis="columns") 318 | responses_to_first_question = responses_per_question.iloc[0] 319 | responses_same = responses_per_question == responses_to_first_question 320 | if not responses_same.all(): 321 | warn( 322 | "In your data, not all questions have the same number of responses. i.e., different numbers of people answered each question. Therefore, the percentages aren't directly comparable: X% for one question represents a different number of responses than X% for another question, yet they will appear the same in the percentage graph. This may be misleading to your reader." 323 | ) 324 | return counts.divide(counts.sum(axis="columns"), axis="rows") * 100 325 | 326 | 327 | def likert_response(df: pd.DataFrame, scale: Scale) -> pd.DataFrame: 328 | """ 329 | This function replaces values in the original dataset to match one of the plot_likert 330 | scales in scales.py. Note that you should use a '_0' scale if there are NA values in the 331 | orginal data. 332 | """ 333 | for i in range(0, len(scale)): 334 | try: 335 | df = df.map(lambda x: scale[i] if str(i) in x else x) 336 | except AttributeError: # for compatibility with Pandas < 2.1.0 337 | df = df.map(lambda x: scale[i] if str(i) in x else x) 338 | return df 339 | 340 | 341 | def plot_likert( 342 | df: typing.Union[pd.DataFrame, pd.Series], 343 | plot_scale: Scale, 344 | plot_percentage: bool = False, 345 | format_scale: Scale = None, 346 | colors: builtin_colors.Colors = builtin_colors.default, 347 | label_max_width: int = 30, 348 | drop_zeros: bool = False, 349 | figsize=None, 350 | xtick_interval: typing.Optional[int] = None, 351 | bar_labels: bool = False, 352 | bar_labels_color: typing.Union[str, typing.List[str]] = "white", 353 | **kwargs, 354 | ) -> matplotlib.axes.Axes: 355 | """ 356 | Plot the given Likert-type dataset. 357 | 358 | Parameters 359 | ---------- 360 | df : pandas.DataFrame or pandas.Series 361 | A dataframe with questions in column names and answers recorded as cell values. 362 | plot_scale : list 363 | The scale used for the actual plot: a list of strings in order for answer options. 364 | plot_percentage : bool 365 | Normalize the answer counts. 366 | format_scale : list of str 367 | Optional scale used to reformat the responses: \ 368 | if your responses are numeric values, you can pass in this scale to replace them with text. \ 369 | If your dataset has NA values, this list must have a corresponding 0/empty value at the beginning. 370 | colors : list of str 371 | A list of colors in hex string or RGB tuples to use for plotting. Attention: if your \ 372 | colormap doesn't work right try appending transparent ("#ffffff00") in the first place. 373 | label_max_width : int 374 | The character wrap length of the y-axis labels. 375 | drop_zeros : bool 376 | Indicates whether the data have NA values that should be dropped (True) or not (False). 377 | figsize : tuple of (int, int) 378 | A tuple (width, heigth) that controls size of the final figure - \ 379 | similarly to matplotlib 380 | xtick_interval : int 381 | Controls the interval between x-axis ticks. 382 | bar_labels : bool, default = False 383 | Show a label with the value of each bar segment on top of it 384 | bar_labels_color : str or list of str = "white", 385 | If showing bar labels, use this color (or colors) for the text 386 | **kwargs 387 | Options to pass to pandas plotting method. 388 | 389 | Returns 390 | ------- 391 | matplotlib.axes.Axes 392 | Likert plot 393 | """ 394 | if format_scale: 395 | df_fixed = likert_response(df, format_scale) 396 | else: 397 | df_fixed = df 398 | format_scale = plot_scale 399 | 400 | counts = likert_counts(df_fixed, format_scale, label_max_width, drop_zeros) 401 | 402 | if drop_zeros: 403 | plot_scale = plot_scale[1:] 404 | 405 | return plot_counts( 406 | counts=counts, 407 | scale=plot_scale, 408 | colors=colors, 409 | figsize=figsize, 410 | xtick_interval=xtick_interval, 411 | compute_percentages=plot_percentage, 412 | bar_labels=bar_labels, 413 | bar_labels_color=bar_labels_color, 414 | **kwargs, 415 | ) 416 | 417 | 418 | def raw_scale(df: pd.DataFrame) -> pd.DataFrame: 419 | """ 420 | The purpose of this function is to determine the scale(s) used in the dataset. 421 | """ 422 | df_m = df.melt() 423 | scale = df_m["value"].drop_duplicates() 424 | return scale 425 | -------------------------------------------------------------------------------- /docs/example.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import plot_likert" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np\n", 19 | "import pandas as pd" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "data": { 29 | "text/html": [ 30 | "
\n", 31 | "\n", 44 | "\n", 45 | " \n", 46 | " \n", 47 | " \n", 48 | " \n", 49 | " \n", 50 | " \n", 51 | " \n", 52 | " \n", 53 | " \n", 54 | " \n", 55 | " \n", 56 | " \n", 57 | " \n", 58 | " \n", 59 | " \n", 60 | " \n", 61 | " \n", 62 | " \n", 63 | " \n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | " \n", 100 | " \n", 101 | " \n", 102 | " \n", 103 | " \n", 104 | "
Question 1Question 2
0AgreeStrongly agree
1Neither agree nor disagreeStrongly agree
2Strongly agreeDisagree
3Neither agree nor disagreeNeither agree nor disagree
4Neither agree nor disagreeStrongly agree
5AgreeNeither agree nor disagree
6Strongly agreeDisagree
7AgreeDisagree
8AgreeStrongly agree
9Strongly disagreeAgree
\n", 105 | "
" 106 | ], 107 | "text/plain": [ 108 | " Question 1 Question 2\n", 109 | "0 Agree Strongly agree\n", 110 | "1 Neither agree nor disagree Strongly agree\n", 111 | "2 Strongly agree Disagree\n", 112 | "3 Neither agree nor disagree Neither agree nor disagree\n", 113 | "4 Neither agree nor disagree Strongly agree\n", 114 | "5 Agree Neither agree nor disagree\n", 115 | "6 Strongly agree Disagree\n", 116 | "7 Agree Disagree\n", 117 | "8 Agree Strongly agree\n", 118 | "9 Strongly disagree Agree" 119 | ] 120 | }, 121 | "execution_count": null, 122 | "metadata": {}, 123 | "output_type": "execute_result" 124 | } 125 | ], 126 | "source": [ 127 | "np.random.seed(42)\n", 128 | "data = pd.DataFrame(np.random.choice(plot_likert.scales.agree, (10,2)), columns=['Question 1',' Question 2'])\n", 129 | "data" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "data": { 139 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4IAAACaCAYAAAD8ZPYKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA5+0lEQVR4nO3de1yUZfo/8M/FIGdEEFQEEeU0gIAKaZqmdqRWyzJ3rUypr6ZWX0tXt9b8ZWut1W5WX3PbNFdNzbSzeVgty9NaWiCgHEUMM5A8AyoiM3P//pgHd5w4iM4w4nzer9e8mHkO133dz8wzwzX38zwjSikQERERERGR83BxdAJERERERETUslgIEhERERERORkWgkRERERERE6GhSAREREREZGTYSFIRERERETkZFgIEhERERERORlXRydwLQsMDFTh4eGOToPounfq1CkAgL+/v4MzISKia1VGRsZxpVSQo/Mgul6wEGxEeHg40tPTHZ0G0XVv6dKlAIC0tDSH5kFERNcuETnk6ByIric8NJSIiIiIiMjJsBAkIiIiIiJyMiwEiYiIiIiInAzPESQih+vWrZujUyAiImqWjIyMDq6urosA9AAHV+jaZAKQYzAYxiUnJx+1nslCkIgcbtCgQY5OgYiIqFlcXV0XderUKTYoKOiUi4uLcnQ+RNZMJpMcO3Ysrry8fBGAe6zn89sLIiIiIqLm6xEUFFTJIpCuVS4uLiooKKgC5lHr385v4XyIiH5jxYoVWLFihaPTICIiag4XFoF0rdNeo/XWfCwEicjhDAYDDAaDo9MgIiJqVZ599tlOkZGR8dHR0XF6vT7u22+/9QaA2bNnd6iqqrL7//nr1q3zHTJkSOSVrh8SEpJw5MgRVwDo1auX3naZ0eXgOYJERERERFdpbUREsi3jDSsuzmhs/ubNm703bdrUbt++fXmenp7qyJEjrjU1NQIACxYs6Dh+/PiTvr6+Juv1DAYDXF2vvRIgMzOzwF6xa2tr0aZNG3uFb7U4IkhERERE1MqUlpa2CQgIMHh6eioACA4ONoSHh9e+/PLLHY4ePdpm0KBB0X379o0GAC8vr17jx48PjYmJifvmm298XnzxxY5RUVHxUVFR8bNnz+4AAIWFhW7du3ePHzVqVNfIyMj4m266KerMmTMCANu2bfOqG3WcMGFCaFRUVLxlLkajEV27du1RVlbmWvc4LCzs4uM65eXluptuuikqMjIy/g9/+ENXpf57ZK2Xl1cvADh06FCblJSUGL1eHxcVFRW/ceNGHwB4+OGHw3r06BEbGRkZP2XKlM51661evdqvW7du8fHx8bFpaWld6kYop06d2nn48OHdevfurb///vu7lZWVud55550RPXr0iO3Ro0fsV1995Q0AlZWVLiNHjgxPSEiIjY2NjVuxYkU72z5T1y4WgkRERERErczw4cMry8rK3MLDw3uMHj06bP369T4AMHPmzKMdOnSo3bZt2/7du3fvB4Dq6mqXvn37ni0sLMzz8vIyrVy5sn1GRkZ+enp6/rJly4J27tzpCQA///yzx+TJk48eOHAg18/Pz7hs2TJ/ABg3bly3d95551BBQUGeTqf7zXmROp0ODzzwwIlFixYFAMCaNWvaxsbGVnfu3PmS8z6ee+65zv369Ttz4MCB3Pvuu+/0kSNH3KxjLV68OODWW2+tKCgoyMvPz8/t27fvOQB44403SnNycvILCgpyd+7c6bt7927Pc+fOydNPP9313//+d1Fubm7+iRMnLik8i4qKPLZv3164du3anyZMmNBl6tSpv+bk5OR//vnnxRMnTgwHgBkzZgQPGTKkct++ffk7duwonDlzZmhlZaVT1EhO0UkiurZFR0cjOjra0WkQERG1Gn5+fqacnJy8+fPnHwoKCjKMHTs2Yt68ee3rW1an0yEtLe0UAGzdutXn7rvvPt22bVuTn5+f6Xe/+92pLVu2+AJASEhITf/+/asBoFevXudKSkrcjx8/rjt79qzLbbfddhYAxo4de7K+NiZNmnR81apV7QFg8eLFgWlpacetl9m1a5fvY489dgIARo0aVdG2bVuj9TI33njj2Q8//DBw6tSpnX/44QdPf39/EwC8//77AXFxcbFxcXFxRUVFHtnZ2R5ZWVkeXbp0qdHr9Re0mJfklpqaetrHx0cBwM6dO9s+/fTTYXq9Pm7YsGGRZ86c0VVUVLhs3bq17Ztvvhms1+vjBgwYEFNTUyMHDhz4TYF6Pbr2DhAmsrI2IsLRKVy1uK++cnQK17SOHTsCAIqLix2cybXt1U3+jk6B6Jqw6MnFjk7B6Sk1zdEpEABXV1cMHTq0aujQoVWJiYnVy5cvbz958uQT1su5ubmZLue8QDc3t4ujfTqdTlVXV1/2oFFkZGRtYGCg4csvv/TNysry/uKLLw5edkcs3HXXXWe2b99e+Omnn/o99thj3Z566qlfb7vttqr58+d3zMjIyA8KCjKOGDEi/Pz5803m5u3tffEcSaUU9uzZk+/l5XXJiKZSCp988smBpKSkmivJtzXjiCARERERUSuTnZ3tvm/fPve6x5mZmZ6hoaEXAMDb29tYUVFR7//5Q4YMObNhw4Z2VVVVLpWVlS4bNmzwHzJkSFVD7QQGBhq9vb1NdVckXb58eUBDyz722GPHxo0b123YsGEn6ys8b7zxxqqlS5e2B4CPPvqobWVlpc56mf3797uFhobW/vGPfzw+ZsyYY3v27PE6deqUztPT0xQQEGA8fPiw69atW/0AIDEx8fzhw4fdCwsL3QBg9erVDeY2YMCAyldeeaVD3ePvvvvOU9selXPnzu1oMplrxrrDZJ0BRwSJiIiIiFqZyspK3eTJk8MqKyt1Op1OhYeH17z//vuHAGDs2LHHU1NTozt27Hih7jzBOgMGDDj30EMPnejdu3csADzyyCPHbrrppuq6Yqo+CxYsKJk4cWJXFxcX9OvXr8rX1/c3h3QCwIMPPljx1FNP6R5//PHfjEoCwKuvvlo2YsSI7pGRkfEpKSlngoODL1gvs2nTJt958+Z1cnV1VV5eXsYPPvjgJ71ef6FHjx7nIiIiegQHB19ITk4+AwA+Pj7qjTfeOJSamhrl5eVlSkpKOttQHxYuXHh43LhxYdHR0XFGo1H69u1b1b9//59fffXVsscffzxMr9fHmUwm6dKlS82WLVsONBTneiKWV+uhS6WkpKj09HRHp+H0eGgokRkPDSUy46GhjueIQ0NFJEMpldLiDTcgOzu7JCkp6TfnwV2PKioqXPz8/EwAMGPGjE5Hjhxps2TJksPWy23fvt1rypQpXTIyMgpbOjeTyYQxY8aERUVFnZ81a9bRlmq/NcjOzg5MSkoKt57OEUEiIiIiImrQRx995Dd37txgo9EoISEhNStXriyxXmbGjBmdli5dGrRkyZKfWjK3t956K/DDDz8MrK2tlfj4+HNTp051iuLcFjgi2AiOCF4bOCJIZMYRQSIzjgg6HkcEnWtEkFq3hkYEebEYIiIiIiIiJ8NCkIiIiIiIyMmwECQiIiIiInIyzSoERSRURNaISJGIHBSR+SLi3vSazWpjuIjEWTyeLSK32SBuexHZIiJnRGT+1cYjIiIiIiJqrS67EBQRAfAZgC+UUlEAogB4AvibjXMaDuBiIaiUekEptdkGcc8D+H8AWv7sZiIiIiIiG9PpdMl6vT4uMjIyPiYmJm7WrFkdjUbzT/xt377dKy0trYuDU6RrWHN+PuIWAOeVUksAQCllFJEpAA6JyPMAHgCQopR6CgBEZB2A15VSW0XkDgB/AeAOoBjAo0qpMyLyKoB7ABgAfAVzoXkPgEEiMhPACJiLt3VKqU9E5FYAr2t5/whgklKqRkRKALwPYBiANgBGKqUKLJNXSp0F8B8RiWzmNiIiIiIialTFX/6SbMt4frNmZTS1jLu7u6mgoCAPAEpLS11HjhzZvbKyUvfmm2+W3Xzzzeduvvnmc7bMyVJtbS3atGljr/DUAppzaGg8gEtekEqpSgAlABosrkQkEMBMALcppXoDSAcwVUTaA7gPQLxSKhHAy0qp7wB8CWC6UqqnUqrYIo4HgKUA/qCUSoC5GJxk0dRxLf4/wVE/IiIiInIiISEhhkWLFpUsWbKkg8lkwrp163yHDBkSCQDr16/30ev1cXq9Pi42Njbu1KlTLhUVFS79+vWLjouLi42Ojo5bsWJFu7pY06dPDw4PD++RnJwcM2zYsG4vvPBCRwDo06dPzGOPPdalR48esS+//HLHHTt2eN1www0x8fHxsQMGDIg6dOhQGwDIzc11HzhwYFR8fHxscnJyTGZmpodDNgo1qiV+UP5GmA/13Gk+uhRuAL4HUAHz4Zr/0kYP1zURJwbAT0qp/drj9wE8CeAt7fFn2t8MAPdfabIi8jiAxwEgLCzsSsMQEREREbWouLi4C0ajEaWlpZf8jz937txO8+bNO3THHXecraiocPHy8jIBwPr16w8EBASYjhw54tq3b1/9Qw89dHrHjh1ea9eu9c/Ly8utqamRnj17xvXq1eviyOKFCxckJycnv6amRm688caY9evXH+jcubPhvffe8582bVrIxx9/XDJu3LiuCxcuPJSQkFDz7bffek+aNCls165d+63zJcdqTiGYB/PhnxeJSFsAnQAUAuiBS0cY6yp/AfC1UupB64Ai0gfArVrcp2A+/PRK1Wh/jbiKAlcptRDAQsD8g/JXkQ8RERERkcPdeOONZ6ZNm9bl97///ckHH3zwVEREhKmmpkaeeeaZ0F27dvm4uLjg6NGjbr/88ovrtm3bfO66667TXl5eysvLS91+++2nLWM9+OCDJwFg79697kVFRZ633HJLNACYTCYEBQXVVlRUuGRmZvqMHDkyom6dCxcuSIt2mC5LcwqmbwC8KiJjlFLLREQHYC6A+Uqpau08vSdExAVACIA+2nq7APxDRCKVUgdExFubXwbASym1QUR2AjioLV8FwLee9gsBhNfFAfAIgG3N6y4RERER0fUpLy/PTafTISQkxJCdnX1x+pw5c8qHDx9esWbNGr+BAwfq169fX7Rjxw7vEydOuO7bty/f3d1dhYSEJFRXVzd52pivr68JAJRSEhkZWZ2VlXXJdTlOnjzp4uvra6g7d5GuXZd9jqBSSsF8Tt8DIlIE4AQAk1Lqr9oiOwH8BPPI4TwAe7T1jgFIA/ChiOyF+bBQPczF3jpt2n8ATNXirAIwXUQyReTiNwlKqfMAHgXwsYjsA2AC8G5zOqsVq28ASBORXyx/poKIiIiIqLUqKytzHT9+fNdHH330qIvLpf/i5+bmuvfp06f6r3/9a3liYuLZnJwcj4qKCl1gYGCtu7u7Wrt2rW9ZWZkbAAwaNOjMpk2b/M6dOycVFRUumzdvbldfe4mJiedPnjzpunnzZm8AqKmpkfT0dI+AgABTaGjohcWLF/sD5pHC77//3tO+vacr0axDKJVSh2G+qidEpD/MxV1vpdQerVB8uIH1vgVwQz2z+tSz7E5Y/HwEzEVk3bxvAPSqZ51wi/vpAAY3kEd4fdOJiIiIiFqbmpoaF71eH2cwGESn06k//OEPJ2bNmvWr9XJ/+9vfOnz33XdtRUTFxMRUP/DAAxWnT5/W3XXXXZHR0dFxiYmJ57p163YeAAYNGnQuNTW1Ii4uLr59+/a1MTEx1X5+fkbrmB4eHmrVqlXFkydPDquqqtIZjUaZNGnSrykpKec//PDDg+PHj+/62muvBRsMBrnvvvtO9uvXr7oltgldPjHXb1SflJQUlZ6e7ug0nN7aiIimF7rGxX31laNToOvAq5v8HZ0C0TVh0ZOLHZ2C01Oq5S/QLiIZSqmUFm+4AdnZ2SVJSUnHHZ2HPVRUVLj4+fmZqqqqXPr16xfz7rvvHhowYIDdfoqC7Cs7OzswKSkp3Hp6S1w1lIiIiIiIWonRo0d3LSoq8qypqZFRo0adYBF4fWIhSEREREREF61du/YnR+dA9tecH5QnIiIiIiKi6wALQSIiIiIiIifDQpCIiIiIiMjJsBAkIiIiIiJyMiwEiYiIiIhaIRFJHj9+fGjd4xdeeKHj1KlTOze2zgcffOA3Y8aMTgCwfPnydhkZGR518/r06ROzfft2L/tlfP3w8vLqBQAlJSVtUlNTuzs6nyvBq4YSEREREV2l4uLiZFvGi4iIyGhqGTc3N7Vhwwb/I0eOlAcHBxsuJ+7DDz9cAaACAL744ot2BoOhIjk5+fxVpova2lq0adPmasPYLV5zGQwGuLo2XSqFh4fXbty48aC98rDndmAhSNe8YcXFjk6B7Gzp0qUAgLS0NIfmca177wlHZ0B0bXjviZb/MXOia5FOp1Njxow5NmfOnI5vv/12qeW8srIy10cffbRraWmpGwC88cYbP99xxx1n582b1z49Pd37kUceObF58+Z2u3bt8n3ttdeCP/3002IA+PDDD/2ffPLJrlVVVbp33323JDU19YzBYMCTTz4ZunPnTt8LFy7I+PHjj06fPv34unXrfGfNmtXZz8/PePDgQY+SkpIcyxwefvjhsOzsbO/z58+7DBs27NSbb75ZBgCrV6/2e+6550K9vLxMN9xww5lDhw65b9my5cDUqVM7Hzx40P3nn392DwkJqVmwYMHh+vpQWVnp8j//8z9hBQUFngaDQZ5//vmy0aNHn7Zse926db6zZ8/uHBAQUFtYWOiZkJBw7osvvvjJxcUFa9as8X3uuee6GI1GJCUlnVu2bNkhT09PFRISknDPPfec3LZtW9tnnnmm/PHHHz9VF6+goMBt1KhR3c+dO+eSmpp6sa3CwkK3oUOHRhUVFeWmp6d7PProo91qa2vFZDLh008/LU5ISKi57bbbIo4cOeJWU1PjMnHixF+nTZt2HADefPPNwP/7v//r5Ovra4yPjz/n5uamli1b9vOIESPC3d3dTTk5OV59+vQ5M2XKlGMTJ04MO3nypKuHh4dp0aJFh3r16nW+oef4cl8/LASJiIiIiFqp6dOnH01ISIh/8cUXyy2nT5gwocvUqVN/vfPOO88UFRW53XnnnVEHDx7MrZt/++23n73ttttODx06tOLRRx+9WPAYDAbZt29f/urVq/1mz57dOTU1df9bb70V6OfnZ8zJycmvrq6WG264QT9s2LBKAMjLy/PKzMzM1ev1F6xze+ONN0o7duxoNBgM6N+/f8zu3bs9ExISzj/99NNdt27dWqDX6y8MGzasm+U6RUVFHrt37y7w8fFRw4YN61ZfH2bMmBE8ZMiQyo8//rjk+PHjupSUlNh77rmnsm3btibLWPn5+Z5ZWVkHw8PDa5OTk/Vff/21z8CBA89OmDCh21dffVWYmJhYc99994X//e9/D3rhhReOAkD79u0NeXl5+dZ9eeKJJ8LGjRt37KmnnjrxyiuvBNX3XLz99ttBTzzxxK+TJk06ef78eTEYzIO0H3zwQUnHjh2NZ86ckV69esWNHj361Pnz511ef/314D179uS1a9fO1L9//+j4+PjqulhHjhxx27NnT4Grqyv69esXvXDhwkMJCQk13377rfekSZPCdu3atb+p57gpLASJiIiIiFqpgIAA08iRI0+8+uqrHTw9PS8WQjt37mxbVFTkWff4zJkzuoqKiiavDzJy5MhTANC/f/+z06dPdwOAzZs3ty0oKPD68ssv/QGgqqpKl5eX5+Hm5qYSExPP1lcEAsD7778fsHTp0kCDwSDHjh1rk52d7WE0GtGlS5eaunVGjRp1ctGiRRcLq9TU1NM+Pj6qsT5s3bq17aZNm9rNmzevEwDU1NTIgQMH3Hr37n3JIa4JCQlnIyIiagEgPj7+XHFxsVvbtm2NoaGhNYmJiTUAkJaWduIf//hHBwBHAWDMmDGnUI89e/b4/Pvf/y4GgAkTJpx46aWXQq2X6dev39nXX389+JdffnEbNWrUqYSEhBoAeO211zquX7++HQCUl5e3yc3N9SgrK2vTt2/fqo4dOxoB4L777ju1f//+i+dr3n///adcXV1RUVHhkpmZ6TNy5MiIunkXLlyQxraPn5/fJQVxQ1gIEhERERG1Yn/+859/7d27d9yoUaOO101TSmHPnj35Xl5eqjmxPDw8FAC4urrCaDSKFkvmzp3784gRIyotl123bp2vl5dXvUVHQUGB2/z58ztmZGTkBwUFGUeMGBF+/vz5JgtRb2/vi/Ea6oNSCp988smBpKSkmsZiubu7X1xPp9PBYDBIU+37+vo2WES5uLg0ui0nTpx4cuDAgWc///xzv6FDh0a9/fbbh1xcXLBt2zbf9PT0Al9fX1OfPn1iqqurm9wOPj4+JgAwGo3w9fU1FBQU5Fkvc6XP8cX+XMlKRES21K9fP/Tr18/RaRAREbVKHTt2NA4bNuzUypUrA+umDRgwoPKVV17pUPf4u+++87Rez8fHx1hZWdlkPXD77bdX/POf/wyqqakRANi7d697U+udOnVK5+npaQoICDAePnzYdevWrX4AkJiYeP7w4cPuhYWFbgCwevXqgIZiNNSHIUOGVM6dO7ejyWSu2Xbu3PmbvjUkKSnpfGlpqVtOTo47ACxbtqz9wIEDq5par3fv3mfee++9AAB477332te3TF5enltsbGzNzJkzj955552ns7KyPE+fPq3z8/Mz+vr6mjIzMz2ys7O9tb6d3b17t++xY8d0tbW1WLNmjX99MQMCAkyhoaEXFi9e7A8AJpMJ33//vWdj2+dysRAkIoeLiYlBTEyMo9MgIiJqtZ5//vny06dPXzzab+HChYf37NnjHR0dHRcRERE/f/7835zX9vDDD5+cN29ep9jY2Ljc3Fz3hmJPmTLluF6vP5+QkBAbFRUVP378+K61tbWNjq7169evukePHuciIiJ6/P73v++enJx8BgB8fHzUG2+8cSg1NTUqPj4+1sfHx+jr62usL0ZDfXj11VfLDAaD6PX6uMjIyPiZM2eGXO528vLyUu+++27JyJEjI6Kjo+NcXFwwbdq0Y02t98477/y8cOHCDtHR0XGlpaX1XsZzxYoVAdHR0fF6vT4uPz/fc8KECSdGjBhRYTAYpHv37vHTp08PSUpKOgsA3bp1q50yZcqRlJSU2OTkZH2XLl1q/Pz86t0OH3744cElS5YExsTExEVFRcV/+umn7RrbPpdLlLqikUSnkJKSotLT0x2dBtF17/hx85EsgYGBTSxJRETOSkQylFIpjs6jTnZ2dklSUtLxppcka3XnsZlMJowZMyYsKirq/KxZs446Oq+WVrcdamtrceedd0ampaUdHzNmzGlbt5OdnR2YlJQUbj2dI4JE5HDr1q3DunXrHJ0GERERtYC33norUK/Xx0VFRcVXVlbqpk6d6pQF9fTp0zvr9fq46Ojo+LCwsBrrn8CwN14shoiIiIiIWsysWbOOOuMIoLWFCxf+4sj2OSJIRERERETkZFgIEhERERERORkWgkRERERERE6G5wgSkcPdfPPNjk6BiIiIyKlwRJCIHK579+7o3r27o9MgIiJqdZYvX95ORJIzMzM9HJ0LtS4cESQihysvLwcAdOrUycGZEBERXZnx75xMtmW8954IyLic5VatWhXQu3fvM8uWLQvo1atX2eXGNxgMcHVlKeDMOCJIRA63ceNGbNy40dFpEBERtSoVFRUuP/74o8+SJUtKPv/88wAAMBqNGD16dFi3bt3i+/fvHzVo0KDIJUuW+ANASEhIwqRJk0Li4uJiFy9e7P/ZZ5+17dmzpz4uLi72rrvu6l5RUeECADt27PC64YYbYuLj42MHDBgQdejQoTaO7CfZBwtBIiIiIqJWaOXKle0GDx5ckZiYWOPv72/YsWOH17Jly/wPHz7sduDAgdxVq1b9lJmZ6WO5Tvv27Q15eXn5w4YNq5ozZ07w9u3b9+fl5eX37t373EsvvdSxpqZGJk+eHLZmzZri3Nzc/LFjxx6fNm1aiKP6SPbD8WAiIiIiolboo48+Cpg8efJRABgxYsTJ5cuXBxgMBrn//vtP6XQ6hIWFGW688cYqy3XGjBlzCgC2bt3qXVxc7NGnTx89ANTW1kpycvKZvXv3uhcVFXnecsst0QBgMpkQFBRU29J9I/tjIUhERERE1Mr8+uuvul27dvkWFhZ6PvXUUzAajSIiKjU19XRj6/n6+poAQCmFAQMGVK5du/Yny/k//PCDZ2RkZHVWVlaBHdOnawAPDSUiIiIiamWWL1/uf999950sKyvbV1pauq+8vHxvaGjohYCAAMMXX3zhbzQacfjwYdfdu3f71rf+4MGDz6anp/vk5OS4A0BlZaXL3r173RMTE8+fPHnSdfPmzd4AUFNTI+np6bwi6XWII4JE5HC33nqro1MgIiJqVT7++OOA6dOnl1tOu/fee0/l5+d7BAcHX4iMjIwPDg6+EB8ff65du3ZG6/U7d+5sWLBgQcmoUaO6X7hwQQBg1qxZpYmJiTWrVq0qnjx5clhVVZXOaDTKpEmTfk1JSTnfUn2jliFKKUfncM1KSUlR6enpjk6DiIiIyOmJSIZSKsXRedTJzs4uSUpKOu7oPOpTUVHh4ufnZyovL9fdcMMNsTt37iwICwszODovcozs7OzApKSkcOvpHBEkIoc7fPgwAKBLly4OzoSIiKj1u/3226MqKyt1tbW1Mn369CMsAqk+LASJyOG++eYbAEBaWppjEyEiIroO/PDDD4WOzoGufbxYDBERERERkZNhIUhERERERORkWAgSERERERE5GZ4j6GAVf/mLo1Og68Dx0aMdncJVGThwIACguLjYwZlcuVc3+Ts6hau26MnFjk6B6Jqg1DRHp0BEZHccESQiIiIiaoWeffbZTpGRkfHR0dFxer0+7ttvv/UGgNmzZ3eoqqqy+//569at8x0yZEikvdsh++CIIBERERHRVRJ5PdmW8ZSaltHY/M2bN3tv2rSp3b59+/I8PT3VkSNHXGtqagQAFixY0HH8+PEnfX19TdbrGQwGuLq2zhKgNed+LeKIIBERERFRK1NaWtomICDA4OnpqQAgODjYEB4eXvvyyy93OHr0aJtBgwZF9+3bNxoAvLy8eo0fPz40JiYm7ptvvvF58cUXO0ZFRcVHRUXFz549uwMAFBYWunXv3j1+1KhRXSMjI+NvuummqDNnzggAbNu2zatu1HHChAmhUVFR8Za5GI1GdO3atUdZWZlr3eOwsLCLj+ts2bLFq2fPnvrY2Ni4Xr166bOzs90BoKqqyuXuu+/uHhEREX/77bdHJCYm6rdv3+5VX+7vvPNOQEJCQqxer4976KGHuhoM5p9I/Oyzz9r27NlTHxcXF3vXXXd1r6ioYJ3TBG4gIiIiIqJWZvjw4ZVlZWVu4eHhPUaPHh22fv16HwCYOXPm0Q4dOtRu27Zt/+7du/cDQHV1tUvfvn3PFhYW5nl5eZlWrlzZPiMjIz89PT1/2bJlQTt37vQEgJ9//tlj8uTJRw8cOJDr5+dnXLZsmT8AjBs3rts777xzqKCgIE+n0ynrXHQ6HR544IETixYtCgCANWvWtI2Nja3u3LnzJT9kn5SUdP7HH38syM/Pz5s1a1bpn/70p1AA+Pvf/x7Url07Y3Fxce6cOXNK8/LyvOvWscw9KCjI8MknnwSkp6cXFBQU5Lm4uKh33323/ZEjR1znzJkTvH379v15eXn5vXv3PvfSSy91tNe2v16wECQiIiIiamX8/PxMOTk5efPnzz8UFBRkGDt2bMS8efPa17esTqdDWlraKQDYunWrz9133326bdu2Jj8/P9Pvfve7U1u2bPEFgJCQkJr+/ftXA0CvXr3OlZSUuB8/flx39uxZl9tuu+0sAIwdO/ZkfW1MmjTp+KpVq9oDwOLFiwPT0tKOWy9z8uRJ3d133x0RFRUV/6c//anL/v37PQDgu+++83nwwQdPAsANN9xwPjo6+lx9uW/cuNE3JyfHKykpKVav18f95z//aXvw4EH3rVu3ehcXF3v06dNHr9fr41atWtX+559/drvyresceJAtEREREVEr5OrqiqFDh1YNHTq0KjExsXr58uXtJ0+efMJ6OTc3N9PlnFvn5uZ2cbRPp9Op6urqyx40ioyMrA0MDDR8+eWXvllZWd5ffPHFQetlnn322ZBBgwZVff3118WFhYVut9xyS8xl5HQxd6WUjBw58sQ//vGPUstlVq5c6TdgwIDKtWvX/nS5+RJHBImIiIiIWp3s7Gz3ffv2udc9zszM9AwNDb0AAN7e3saGzpEbMmTImQ0bNrSrqqpyqaysdNmwYYP/kCFDqhpqJzAw0Ojt7W2quyLp8uXLAxpa9rHHHjs2bty4bsOGDTtZX+FZWVmpq8txwYIFgXXT+/Xrd2bVqlX+AJCRkeGxf/9+z/rip6amVq5bt86/tLTUFQB+/fVX3f79+90GDx58Nj093ScnJ8dda8dl79697vXFoP9iIUhERERE1MpUVlbqxowZ0y0iIiI+Ojo6rqCgwPO1114rA4CxY8ceT01NvXixGEsDBgw499BDD53o3bt3bHJycuwjjzxy7KabbqpurK0FCxaUTJw4sater487e/asi6+vr7G+5R588MGKc+fO6R5//PHfjEoCwLPPPlv+4osvhsbGxsbVXeQFAKZPn37sxIkTrhEREfF//vOfQyIjI8/7+/v/po3k5OTzM2fOLL311lujo6Oj42655Zbow4cPt+ncubNhwYIFJaNGjeoeHR0dl5KSot+3b59HE5vQ6YlSvznfkzQpKSkqPT3drm3wB+XJFlr7D8pfD/iD8kTXD/6g/LVJRDKUUimOzqNOdnZ2SVJS0m/Og7seVVRUuPj5+ZkAYMaMGZ2OHDnSZsmSJYetl9u+fbvXlClTumRkZBQ2J77BYMCFCxfEy8tL5ebmut9xxx3RxcXFOR4eHixUbCA7OzswKSkp3Hp6s84RFBE/AG8D6A9AAOwC8JRS6pQtktTaGAzgglLqO+3xRADnlFLLrjJuTwD/BNAWgBHAX5VSq68qWSIiIiKi69xHH33kN3fu3GCj0SghISE1K1euLLFeZsaMGZ2WLl0atGTJkmafp1dVVeUycODAmNraWlFK4c033zzEItD+mnuxmH8ByFFKjQEAEfkLgKUA7rVhToMBnAHwHQAopd61UdxzAMYopYpEpDOADBHZpJQ6baP4RERERETXnfHjx58aP358owM/c+bMKZ8zZ075lcT39/c35eTk5F9ZdnSlLvscQRGJBJAM4CWLybMBJIlIjIgMFpF1FsvPF5E07X6yiGwTkQwR2SQiwdr0ySKSJyJ7RWSViIQDmAhgiohkichAEXlRRKZpy/cUkV3a8p+LiL82fauIvCYiP4jIfhEZaJ2/Umq/UqpIu18G4CiAoOZsLCIiIiIioutBcy4WEwcgSyl18cRN7X4mgNiGVhKRNjAfTvqAUioZwGIAf9VmPwegl1IqEcBEpVQJgHcBvKmU6qmU2mEVbhmAZ7Xl9wGYZTHPVSnVB8AzVtPry6kPADcAxY32mIiIiIiofiaTySSOToKoMdpr1FTfvJa4amgMgB4AvhaRLAAzAYRq8/YC+EBERgMw1L+6mXZ+Yjul1DZt0vsAbrZY5DPtbwaA8EbiBANYDuBRpdRvNoqIPC4i6SKSfuzYsSa6RkREREROKufYsWN+LAbpWmUymeTYsWN+AHLqm9+ccwTzAPQUEZe6AkpEXAAkAdgDIAyXFpZ1l2wVALlKqX71xPwdzMXcMADPi0hCM/KxVqP9NaKBfolIWwDrATyvlNpV3zJKqYUAFgLmq4ZeRT5EREREdJ0yGAzjysvLF5WXl/cAf5KNrk0mADkGg2FcfTMvuxBUSh0QkUyYR/Rma5NnAvhGKfWziCgAcSLiDsATwK0A/gOgEECQiPRTSn2vHSoaDSAfQBel1BYR+Q+AUQB8AFTBfGVP6/YrROSUiAzUDhl9BMA26+UaIiJuAD4HsEwp9cnlrkdEREREZC05OfkogHscnQfRlWruVUMfA/C2iBTDXKz9CPNoHpRSh0XkI5iHHn+C+dxBKKUuiMgDAOZph3e6AngLwH4AK7RpAmCeUuq0iKwF8ImI3Avgf63aHwvgXRHxAnAQwKPNyP33MI8+tq+7iA2ANKVUVjNiEBERERERtXrNKgS1n1p4BABEJAbmwyzvBLBBm/8nAH+qZ70sXHo+X50B9Sy7H0CixaQdFvOyANxYzzqDLe4fRz3nCCqlVgBYUU8ORERERERETqW5I4IXKaUKAUTaMBciIiIiIiJqATyxlYiIiIiIyMmwECQiIiIiInIyLASJiIiIiIicDAtBIiIiIiIiJ8NCkIiIiIiIyMmwECQiIiIiInIyLASJiIiIiIicjCilHJ3DNSslJUWlp6c7Og2i615WVhYAoGfPng7Ng4iIrl0ikqGUSnF0HkTXC44IEpHDZWVlXSwGiYiIiMj+WAgSERERERE5GRaCREREREREToaFIBERERERkZNhIUhERERERORkXB2dABHRww8/7OgUiIiIiJwKC0Eicrg2bdo4OgUiIiIip8JDQ4nI4X788Uf8+OOPjk6DiIiIyGmwECQih8vNzUVubq6j0yAiIiJyGiwEiYiIiIiInAwLQSIiIiIiIifDQpCIiIiIiMjJsBAkIiIiIiJyMqKUcnQO1ywRqQJQaOdmAgEcb8XxW6KN1h6/Jdpo7fFboo3WHr8l2mjt8VuiDfbB8fFboo3WHr8l2miJPljrqpQKauE2ia5b/B3BxhUqpVLs2YCIpNuzDXvHb4k2Wnv8lmijtcdviTZae/yWaKO1x2+JNtgHx8dviTZae/yWaKMl+kBE9sVDQ4mIiIiIiJwMC0EiIiIiIiInw0KwcQuvgzbYB8fHb4k2Wnv8lmijtcdviTZae/yWaIN9cHz8lmijtcdviTZaog9EZEe8WAwREREREZGT4YggERERERGRk3HqQlBEdCKSKSLrtMdLReQnEcnSbj216SNEJFdEdohIe21ahIisbmb8biKyW0QOiMhqEXHTpv+viOSIyAaLaQNE5M1GYnuIyA8ikq3l9hdb9qGR+LbsQxcR2SIieVobT2vTXxSRUos+3K1Nv0lE9opIuohEadPaichXIvKb13Ij8QNE5GsRKdL++l/JNtLmLxaRoyKSYzHNJvk3Et9m+dfTXomI7NPyTtemvablvcxiudEi8szlxrVYL1VECrXXz3PatA+0+HMslpspIsObG99efbD389ACryO77guNxLdlH+z6ntRI/FbzudBAfFvnX9/+Zct9ob74NnsdWSzziYgUiEi+iPSzcR/qi2+rz7UYixhZIlIpIs/YOP+G2rDp80BE1wCllNPeAEwFsBLAOu3xUgAP1LPcVgBeAEYD+F9t2ocAopoZ/yMAo7T77wKYpN3fBXNRPhPAMAACYBOAgEZiCwAf7X4bALsB3GirPjQS35Z9CAbQW7vvC2A/gDgALwKYVs/ynwEIBTAAwFxt2usABjcz/t8APKdNfw7Aa1f6PAO4GUBvADkW02ySfyPxbZZ/Pe2VAAi0eOwH4Gvt/iIACQA8AXwDoE0z9zcdgGIA3QG4AcgGkAhgkTb/a629YABrr2K/tnkf7P08tMDryK77QiPxbdkHu74nNRJ/KVrJ50ID8W2dfwks9i877Av1xbfZ60hb5n0A47T7bgDa2bgP9cW3aR+05XQAygF0tWX+jbRh8z7wxhtvjr057Tc1IhIK4Hcw/2PYFBMAd5jfTGtFZCCAcqVU0eXGFxEBcAuAT7RF3gcwvG5xmP/x8AJQC/Mb9r+VUicbiq/MzmgP22i3xk74bFYfGolvyz4cUUrt0e5XAcgHENJIH2q1+HV9iADQRSm1tZnx79Vyt+5Ds59npdR2AA328WrybyS+zfK/DCYAbbTXb91zOw3A20qp2mbG6gPggFLqoFLqAoBVMO8jntq3xm0AGAHMBjDrKnK2dtV9sPfz0AKvI7vuC/bel7W4dn1Psvd7KmD/zwV7f641oiXfkyw1+3UkIn4wf/HyLwBQSl1QSp22VR8aiW+zPli4FUCxUuqQrfJvog179IGIHMnRlaijbjB/8CYDGIxLvzktBLAXwJsA3LXptwPIALAW5tGFr9D0t7KXxAcQCPM/wXXzu0D79h/AIwAyAayA+dv0b3EZIxUwf1OXBeAM/vvtny37cEl8e/TBIlY4gJ8BtIX5W8cSrQ+LAfhry/SE+VvyLTB/+7gKl/+tpmX80xbTpe7xlWwji9jWIzk2y7+e+DbN36qtnwDs0eI8rk37k/Y6mAvzyM+6K9znHoA2+mfxmpkP4C0t/h+1bfSvq9y37dIHez8P9n4dtcS+UE98W+8Ldn1Pso6vTVuKVvK5YB3f1vk3sn/Z7HXUQHybvY60dX7QtksmzEWzt6360Eh8m/XBoq3FAJ6yx/tRA23YvA+88cabY28OT8AhnQaGAnhHuz8Y//3ADNbeQN1h/kbthXrWHQPgGZgPGfoEwHsAvJqKj0Y+8K3WfQHmb/Lu0eK/CcClif60096Ae9iqDw3EH2CPPgDw0T6o7tced4T5HzIXAH8FsLiedW7W4kYDWA3zP0sdLzP+aav5p65mG+G3/8DbOn/r+DbN32q9EO1vB5gP3bzZav4imA9hHAfzIW0zm7Hf1VsIWi2zFkBnAM9r8cc3Z9+2Zx/s/TzY+3XUQvuCXfdli3Xawb7vSXXxbfaeCjt/LtQXX7tv088E1LN/2fJ11EB8m72OAKQAMADoqz3+PwAv2aoPjcS39eeCG4DjdfNt+Rw00oZd9mfeeOPNcTeHJ+CQTgOvAPgF5m+2ygGcA7DCapnBsBo1gPmwh29hPlxnE8zf8o2F1T+rDcT/QHtDddWW6Qdgk9V6nfHfD+9t2hvuLAC3X0afXoDVsftX04cG4k+3dR8s8pjawPxwWP1jBPM/NV8BCNC2a1cAgwD89XLiw/zteLB2PxhA4dVso/pytFX+9cWwdf6NPOcvWr6mAPSC+XAn77rnHcASXP6315e8XgD8GcCfLR7fq7UZDe0fDC3/JgvYluiDvZ+HFngd2XVfqC++rftgta5d3pOs4tvsPRV2/lxoIL7NPtca279s+TpqbP+1xesIQCcAJRaPBwJYb6s+NBTfDvvzvQC+sse+3FAb9tyfeeONN8fcnPIcQaXUn5VSoUqpcACjAHyrlBotIsHAxfM2hgPIsVp1OoB5ynxekSfM54+YYH6DbSr+wzB/w/yAtthYAGus4r8E8z8faCy+lmOQiLTT7nvCfPhHga360ED8fBv3QWD+pzxfKfWGxfRgi8Xuq6cPYwBsUOZzZby0+PX1od74AL7Ucm+oD5e1jRpiq/wbYZf8RcRbRHzr7gO4wyr3lwD8P5j/kdBp05qT948AosR8lUQ3mPeNL7X22sD8TfXfLHKG1o7bZcZviT5YajWvI3vvC/bel7VYdn1Psvd7qr0/F+z9uabFaGj/stXrqN74tnwdKaXKARwWkRht0q0A8mzVh4bi2+Fz4UGYL/pSxx7vR5e00QKfbUTU0hxdiTr6hksPofkWwD6Y39xWQLuCnDavMyy+1QMwEkAugJ0Agi4zfneYzx04AOBjaOdqaPN6weLcKJj/Kc4FsNFyOYv5iTCff7BXy/cFW/ahkfi27MMAmD+M9sJ8Xk4WgLsBLNf6sBfmD7dgi3W8YP7HqY32eKC2bAaAmMuM3x7mK0YWAdgMi/Mlmvs8w/wheQTmk+V/AfA/tsq/kfg2y9+qre4wH4qVra3zvMW84QBetHj8upb3B83c3+6G+YqSxVbxnwGQpt0Xrd/7oJ2n1Yz4dumDvZ+HFngd2XVfaCS+Lftg1/ekRuK3ms+FBuLbLH80sH/Z8HXUUHybvY60ZXoCSNfifQHA31Z9aCS+LfcFbwAnAPhZTLPp50IDbdj0eeCNN94cfxOl6r54JyIiIiIiImfglIeGEhEREREROTMWgkRERERERE6GhSAREREREZGTYSFIRERERETkZFgIEhERERERORkWgkTkVETEKCJZIpIjIh+LSIv/xpWIDBaR/i3drkX7A0UkV9sOnlbzLLfP2rrf1iMiIqLrCwtBInI21UqpnkqpHgAuAJh4OSuJiKsNcxgMwGGFIICHAbyibYdqq3mW2+ckgCdbPj0iIiKyNxaCROTMdgCIFBFvEVksIj+ISKaI3AsAIpImIl+KyLcAvhERHxFZIiL7RGSviIzQlrtDRL4XkT3aKKOPNr1ERP6iTd8nInoRCYe5+JyijbwNFJFhIrJba3uziHTU1g8Ska+10btFInJIRAK1eaO1fLNEZIGI6Kw7JyK3ajH3af1zF5FxAH4P4CUR+aCJ7fM9gBAtVoSIbBSRDBHZISJ6bfpIbfQwW0S2W2y3NSKyVUSKRGSWRU5TteVzROQZbVq4iOSLyHtaX7+qG6kUkckikqdt71XatIaer3iLbbJXRKKa+4IgIiJyFvxBeSJyKiJyRinlo43wfQpgI4AuAPKUUiu0QyF/ANALwEgALwNIVEqdFJHXALgrpZ7RYvkD0AH4DMBdSqmzIvKstsxsESkBMFcp9baIPAGgt1JqnIi8COCMUup1izinlVJKK9RilVJ/FJH5AEqVUq+ISCqAfwMI0m5/A3C/UqpWRN4BsEsptcyinx4AigDcqpTaLyLLAOxRSr0lIksBrFNKfdLI9tEBWAXgX0qpjSLyDYCJSqkiEekL84jiLSKyD0CqUqpURNoppU6LSBqAVwD0AHAOwI8A0gAoAEsB3AhAAOwGMBrAKQAHAKQopbJE5CMAX2rPRxmAbkqpGov4cxp4vl7VtsMHIuIGQFfPiCcREREBsOWhTkRErYGniGRp93cA+BeA7wDcIyLTtOkeAMK0+18rpU5q928DMKoukFLqlIgMBRAHYKeIAIAbzCNpdT7T/mYAuL+BnEIBrBaRYG39n7TpAwDcp7W1UUROadNvBZAM4EetTU8AR61ixgD4SSm1X3v8PsyHeb7VQA516rZPCIB8AF9rI5z9AXystQcA7trfnQCWasXbZxZxvlZKnQAAEflM64sC8LlS6qzF9IEAvtRyzdLWzQAQrt3fC+ADEfkCwBfatDtQ//P1PYDnRSQUwGdKqaIm+kpEROS0WAgSkbOpVkr1tJwg5upmhFKq0Gp6XwBnm4gnMBc9DzYwv0b7a0TD77lvA3hDKfWliAwG8OJltPm+UurPTSx3JaqVUj3FfBGdTTAXj0thHrHsab2wUmqitp1+ByBDRJLrZlkv2kS7NRb3jTAXt9Di3gxgGMxFXgLM/f/N8wUgX0R2a+tsEJEJSqlvm2iXiIjIKfEcQSIic8Hzv1pBCBHp1cByX8Pi4inaIZ27ANwkIpHaNG8RiW6ivSoAvhaP/QCUavfHWkzfCfP5fBCROwD4a9O/AfCAiHTQ5gWISFerNgoBhNflBeARANuayOsipdQ5AJMB/BHmwzt/EpGRWnsiIkna/Qil1G6l1AsAjsF8mC0A3K7l5QlguNaXHQCGi4iXiHjDPNq5o6EcRMQFQBel1BYAz8K8nXzQwPMlIt0BHFRKzQOwBkDi5faXiIjI2bAQJCICXgLQBsBeEcnVHtfnZQD+dRdHATBEKXUM5vPfPhSRvTAfnqhvor21AO7TLmoyEOYRwI9FJAPAcYvl/gLgDhHJgfl8xXIAVUqpPAAzAXyltfk1gGDLBpRS5wE8qsXdB8AE4N2mN8UlMTJhPjTzQZivNPo/Wr9zAdyrLfZ3MV+MJgfmQ2yztek/wHwO5l4Anyql0pVSe2AeXfwB5vMDF2ltNEQHYIWWfyaAeUqp02j4+fo9gBzt0NYeAJb9JiIREREB4MViiIiuWSLiDsColDKISD8A/6zv8MxrjXaxmBSl1FOOzoWIiIjqx3MEiYiuXWEAPtIOkbwAYLyD8yEiIqLrBEcEiYiIiIiInAzPESQiIiIiInIyLASJiIiIiIicDAtBIiIiIiIiJ8NCkIiIiIiIyMmwECQiIiIiInIyLASJiIiIiIiczP8H7vlNSYKPVjAAAAAASUVORK5CYII=\n", 140 | "text/plain": [ 141 | "
" 142 | ] 143 | }, 144 | "metadata": { 145 | "needs_background": "light" 146 | }, 147 | "output_type": "display_data" 148 | } 149 | ], 150 | "source": [ 151 | "plot_likert.plot_likert(data, plot_likert.scales.agree, plot_percentage=True, figsize=(11,2));" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/html": [ 162 | "
\n", 163 | "\n", 176 | "\n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | "
Strongly disagreeDisagreeNeither agree nor disagreeAgreeStrongly agree
Question 11.00.03.04.02.0
Question 20.03.02.01.04.0
\n", 206 | "
" 207 | ], 208 | "text/plain": [ 209 | " Strongly disagree Disagree Neither agree nor disagree Agree \\\n", 210 | "Question 1 1.0 0.0 3.0 4.0 \n", 211 | " Question 2 0.0 3.0 2.0 1.0 \n", 212 | "\n", 213 | " Strongly agree \n", 214 | "Question 1 2.0 \n", 215 | " Question 2 4.0 " 216 | ] 217 | }, 218 | "execution_count": null, 219 | "metadata": {}, 220 | "output_type": "execute_result" 221 | } 222 | ], 223 | "source": [ 224 | "plot_likert.likert_counts(data, plot_likert.scales.agree)" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "data": { 234 | "text/html": [ 235 | "
\n", 236 | "\n", 249 | "\n", 250 | " \n", 251 | " \n", 252 | " \n", 253 | " \n", 254 | " \n", 255 | " \n", 256 | " \n", 257 | " \n", 258 | " \n", 259 | " \n", 260 | " \n", 261 | " \n", 262 | " \n", 263 | " \n", 264 | " \n", 265 | " \n", 266 | " \n", 267 | " \n", 268 | " \n", 269 | " \n", 270 | " \n", 271 | " \n", 272 | " \n", 273 | " \n", 274 | " \n", 275 | " \n", 276 | " \n", 277 | " \n", 278 | "
Strongly disagreeDisagreeNeither agree nor disagreeAgreeStrongly agree
Question 110.00.030.040.020.0
Question 20.030.020.010.040.0
\n", 279 | "
" 280 | ], 281 | "text/plain": [ 282 | " Strongly disagree Disagree Neither agree nor disagree Agree \\\n", 283 | "Question 1 10.0 0.0 30.0 40.0 \n", 284 | " Question 2 0.0 30.0 20.0 10.0 \n", 285 | "\n", 286 | " Strongly agree \n", 287 | "Question 1 20.0 \n", 288 | " Question 2 40.0 " 289 | ] 290 | }, 291 | "execution_count": null, 292 | "metadata": {}, 293 | "output_type": "execute_result" 294 | } 295 | ], 296 | "source": [ 297 | "percentages = plot_likert.likert_percentages(data, plot_likert.scales.agree)\n", 298 | "percentages" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "data": { 308 | "image/png": "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\n", 309 | "text/plain": [ 310 | "
" 311 | ] 312 | }, 313 | "metadata": { 314 | "needs_background": "light" 315 | }, 316 | "output_type": "display_data" 317 | } 318 | ], 319 | "source": [ 320 | "plot_likert.plot_counts(percentages, plot_likert.scales.agree);" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": {}, 327 | "outputs": [ 328 | { 329 | "data": { 330 | "image/png": "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\n", 331 | "text/plain": [ 332 | "
" 333 | ] 334 | }, 335 | "metadata": { 336 | "needs_background": "light" 337 | }, 338 | "output_type": "display_data" 339 | } 340 | ], 341 | "source": [ 342 | "plot_likert.plot_counts(percentages, plot_likert.scales.agree, plot_percentage=True);" 343 | ] 344 | } 345 | ], 346 | "metadata": { 347 | "kernelspec": { 348 | "display_name": "Python 3", 349 | "language": "python", 350 | "name": "python3" 351 | } 352 | }, 353 | "nbformat": 4, 354 | "nbformat_minor": 4 355 | } 356 | --------------------------------------------------------------------------------