Statistical data visualization using matplotlib


seaborn: statistical data visualization

PyPI Version License DOI Tests Code Coverage

Seaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics.


Online documentation is available at

The docs include a tutorial, example gallery, API reference, and other useful information.

To build the documentation locally, please refer to doc/


Seaborn supports Python 3.7+ and no longer supports Python 2.

Installation requires numpy, pandas, and matplotlib. Some functions will optionally use scipy and/or statsmodels if they are available.


The latest stable release (and required dependencies) can be installed from PyPI:

pip install seaborn

It is also possible to include the optional dependencies:

pip install seaborn[all]

You may instead want to use the development version from Github:

pip install git+

Seaborn is also available from Anaconda and can be installed with conda:

conda install seaborn

Note that the main anaconda repository typically lags PyPI in adding new releases.


Testing seaborn requires installing additional packages listed in ci/utils.txt.

To test the code, run make test in the source directory. This will exercise both the unit tests and docstring examples (using pytest) and generate a coverate report.

The doctests require a network connection (unless all example datasets are cached), but the unit tests can be run offline with make unittests.

Code style is enforced with flake8 using the settings in the setup.cfg file. Run make lint to check.


Seaborn development takes place on Github:

Please submit bugs that you encounter to the issue tracker with a reproducible example demonstrating the problem. Questions about usage are more at home on StackOverflow, where there is a seaborn tag.

  • Reboot of clustering

    Reboot of clustering

    This is pulled off of master this time instead of dev, fixing weird merging issues occurring in

    Trailing Todos:

    • [x] Reformat params with heatmap_kws, row_kws and col_kws or something to clean up the arguments
    • [x] Is there a way to set_axis_style('nogrid') within a single plot? I couldn't find a way to detect the current axis_style to switch, and then return the rcParams to what they were.
    • [ ] Allow for several levels of labeling groups in the heatmap (multiple levels of colors) [probably not in this release]
    • [x] Allow for user to specify their own linkage matrices
    • [x] Constrain colorbar scale to have at most 3 labels. Currently this works only for divergent, linear maps. [probably not in this release]

    Here's a notebook of the current abilities:

    enhancement plots 
    opened by olgabot 61
  • Refactor of clusteredheatmap

    Refactor of clusteredheatmap

    Here you go! Thanks for being patient with my awful code from before. This is a complete refactoring, so the dendrograms and linkage matrices are getting calculated separately, and DendrogramGrid is completely naive to all calculations.

    So far this just has basic functionality, I removed some concepts for simplicity:

    • data_na_ok or masked data, allowing for NAs.
    • {row,col}_labelsize: fontsize of the row and column labels
    • fig : user-provided fig. user can provide just figsize
    • title, title_fontsize: user can do this on their own using the DendrogramGrid instance
    • Multiple levels of color labels for rows and columns

    If anyone is willing and able to figure out how to make these work elegantly, please do! I couldn't figure it out.

    Other things of note:

    • Added the feature of user-specified {x,y}ticklabels to heatmap and _HeatMapper.
    • Moved all {col,row}_kws into explicit keyword arguments, e.g. {col,row}_linkage because I felt they were too hidden, and it's not like there's another function you can refer to, to see the possible inputs (like you can with joint_kws in jointgrid)
    • Naming is fluid. I just came up with names that made sense on the spot, and am open to more explicit or understandable naming.
    • I haven't completely tested all the combinations yet (!!) so any help here is very much appreciated

    Todos (copied from

    • [x] Tests
    • [x] Tutorial documentation
    • [x] Gallery example(s)
    • [x] Release notes
    opened by olgabot 56
  • Seaborn should respect categorical order when sorting pd.Categorical objects

    Seaborn should respect categorical order when sorting pd.Categorical objects

    For example, this adaption of the "Grouped boxplots" example should work (if using pandas 0.15 or higher) even without specifying x_order:

    import seaborn as sns
    tips = sns.load_dataset("tips")
    days = ["Thur", "Fri", "Sat", "Sun"]
    tips['days'] = pd.Categorical(tips['day'], days)
    g = sns.factorplot("day", "total_bill", "sex", tips, kind="box",
                       palette="PRGn", aspect=1.25)
    g.despine(offset=10, trim=True)
    g.set_axis_labels("Day", "Total Bill")

    If you using a pandas method to do the sorting, then this is a pandas bug.

    question plots 
    opened by shoyer 48
  • ENH: Added

    ENH: Added "spine_offset" function to utils

    Simple PR to add a spinesep kwarg to utils.despinse.

    Right now, the input is the outward offset in points -- so that leaves all of the tweaking up to the user if the figure size changes. It might make sense to specify it in axes fraction, but that require a little more logic. Feedback is much appreciated.

    Tests to follow later.


    enhancement themes 
    opened by phobson 43
  • Problems with default fonts when using seaborn inside a Virtual Machine

    Problems with default fonts when using seaborn inside a Virtual Machine

    I am running Enthought for all all scientific python development, from an Ubuntu VM using Virtual Box. For some reason, the installation of Seaborn fails to load the required default fonts setup in Seaborn.. grgwq

    opened by lmsanch 32
  • Add percentages instead of counts to countplot

    Add percentages instead of counts to countplot


    I would like to make a proposal - could we add an option to a countplot which would allow to instead displaying counts display percentages/frequencies? Thanks

    opened by hnykda 30
  • Should we override the matplotlib color shorthands?

    Should we override the matplotlib color shorthands?

    Matplotlib lets you specify colors like "b" for blue, "r" for red, etc. which is nice. But, those colors are mapped to the corners of RGB space, which, bleh.

    This is additionally problematic as some functions (like plt.scatter) hardcode these values as default.

    It occurs to me that seaborn could override this by messing with the values in the mpl.colors.ColorConverter.colors dictionary. But that might be too much manipulation?

    Opening this issue for discussion.

    question themes 
    opened by mwaskom 27
  • Clustered heatmap

    Clustered heatmap

    Here's an initial version of the clustered heatmap



    • [x] Reformat params with heatmap_kws, row_kws and col_kws or something to clean up the arguments
    • [x] Is there a way to set_axis_style('nogrid') within a single plot? I couldn't find a way to detect the current axis_style to switch, and then return the rcParams to what they were.
    • [ ] Allow for several levels of labeling groups in the heatmap (multiple levels of colors)
    • [x] Allow for user to specify their own linkage matrices
    • [ ] Constrain colorbar scale to have at most 3 labels. Currently this works only for divergent, linear maps.


    enhancement plots 
    opened by olgabot 26
  • Improve multiple semantic legend titles

    Improve multiple semantic legend titles

    Currently the legends for lineplot (#1285) and scatterplot (#1436) don't indicate what variable each of the levels represent. I punted on this but it needs a solution. One option is to cram everything into the legend title but that's not ideal. I think doing something with legend entries that have invisible handles and and then bumping the legend text so it looks centered would work:

    f, ax = plt.subplots()
    h1 = ax.scatter([], [], s=0, label="Title 1")
    h2 = ax.scatter([], [], label="level 1")
    h3 = ax.scatter([], [], s=0, label="Title 2")
    h4 = ax.scatter([], [], label="level 2")
    legend = ax.legend()
    for t in legend.get_texts()[::2]:
        xfm = transforms.offset_copy(t.get_transform(), ax.figure, x=-10, units="points")


    But getting this to be really robust is going to be tricky.

    opened by mwaskom 24
  • Letter Value Plots

    Letter Value Plots

    This pull request adds the _LVPlotter class, lettervalueplot function, documentation, and usage examples.


    • [x] PEP8 errors
    • [x] Rename plotting function lvplot
    • [x] Median lines should stay inside boxes
    • [x] Change default scale to "exponential"
    • [x] Rename box_widths to scale
    • [x] Put default values into function signature
    • [x] Remove deprecation warnings
    • [x] Rename p to outlier_prop
    • [x] Change outlier_prop to take float, [0, 1].
    • [x] Fix documentation
    • [x] Change outlier plotting symbol to d for internal consistency
    • [x] Make width functions class level functions
    • [x] Write tests
    opened by drewokane 24
  • Data is not showing on matplotlib 1.4.2

    Data is not showing on matplotlib 1.4.2


    thanks for this wonderful library; I noticed a weird behaviour when using seaborn with the latest matplotlib (1.4.2, with python 2.7 on linux64). A simple plot like this:

    plot(range(10), range(10), 'bo')

    which works fine using just matplotlib, appears completely blank after importing seaborn. I did some tests and it seems that the 'dots' marker don't work anymore. From what I've seen it used to work with a previous version of matplotlib (1.3.1).

    Thanks for your help, Marco

    question rough-edge 
    opened by mgalardini 24
  • so.Continuous().label(like = callable) provides two arguments

    so.Continuous().label(like = callable) provides two arguments

    Hi there, I'm loving seaborn.objects!

    The docs for so.Continuous().label() say that it can accept a callable that consumes a number and returns a string. However, so.Continuous() appears to provide not just a number to this function, but also an index. This means that single-argument formatting functions can't be used (see label_func3 below), and multi-argument formatting functions must be built with a second argument capable of taking an index. I can imagine that some formatting functions might like to get the index, so I can see why it might be done this way. But if it's not intended, maybe get rid of that second argument, or maybe just update the docs.

    import seaborn.objects as so
    import pandas as pd
    def label_func(x, decimals=0):
    	basestr = '{:,.'+str(decimals)+'f}'
    def label_func2(x, buffer = 0, decimals=0):
    	basestr = '{:,.'+str(decimals)+'f}'
    def label_func3(x):
    	basestr = '{:,.1f}'
    df = pd.DataFrame({'x':['a','b'],
    # see first graph below; the index number appears to be fed in as the second argument
    (so.Plot(df, x = 'x', y = 'y')
     .scale(y = so.Continuous().label(like = label_func)))
    # Second graph, this one works properly
    (so.Plot(df, x = 'x', y = 'y')
     .scale(y = so.Continuous().label(like = label_func2)))
    # Error: label_func3() takes 1 positional argument but 2 were given
    (so.Plot(df, x = 'x', y = 'y')
     .scale(y = so.Continuous().label(like = label_func3)))

    From label_func: Bar graph with more decimal places in the y-axis labels as we go up

    From label_func2: Bar graph with consistent decimal placement

    opened by NickCH-K 0
  • How to merge two sns.clustermap object?

    How to merge two sns.clustermap object?

    Hello seaborn team, This is my code. I want to merge 2 clustermaps into one PNG,but it does not work.


    How to repair it ? Thanks!

    opened by liujilei156231 1
  • Figure title being removed by seaborn objects API when plotting on subfigures

    Figure title being removed by seaborn objects API when plotting on subfigures

    I recently came across an odd behaviour with the seaborn objects API when using subfigures. Here is a minimal example :

    import seaborn as sns
    import seaborn.objects as so
    import matplotlib.pyplot as plt
    fig = plt.figure(constrained_layout=True)
    subfigs = fig.subfigures(1,2)
    tips = sns.load_dataset("tips")
    p = (
        so.Plot(tips, "total_bill")
        .add(so.Bars(), so.Hist())
    ax = subfigs[1].subplots()
    fig.suptitle("Test title")

    which results in the title missing from the image : title_issue_bad

    Commenting the p.on(subfigs[0]).plot() results in the title reappearing. I have done a bit of digging and found that changing line 186 from the _core/ file from figure = target.figure to figure = target seems to solve the issue. Is there a specific reason to why it fetches the parent figure currently, since Subfigure is supposed to be a drop-in replacement for Figure ? I also expect this will not have the intended behaviour if we deal with subfigures of subfigures.

    opened by thuiop 0
  • Changing move order when order is set in scale

    Changing move order when order is set in scale

    Fixes the issue described in #3015. It actually only happened in Stack (not in Dodge), because the Plot groupby was not used. This was the case because the computation of the baselines of the Stack required the groups to include every rectangle in each column, which was not the case if the Plot groupby is used.

    opened by thuiop 0
  • Fixed the issue with wrong width in log scale for Bar(s)

    Fixed the issue with wrong width in log scale for Bar(s)

    Fixes the issue #2907, but in a hacky way. The core issue is that currently, the bars' positions relative to each other are defined by a coordinate (say x) and their width. When applying a transform, what happens is that x is transformed (into transformed_x), and the new width is obtained with transformed_width = transform(x+width/2)-transform(x-width/2). While this is actually correct, it falls apart when passing the coordinates to the matplotlib API, which asks for the bottom left of the rectangle. It is currently obtained by doing transformed_x-transformed_width/2, whereas it should really be transform(x-width/2), which is obviously not the same in the case of the log. In this PR, I solve the problem by storing the transform(x-width/2) value and retrieving it when needed, but this feels a bit weird to have it as an additional variable ; however we cannot ditch the normal transformed_x as it is needed for other things than the bars. There is probably some underlying flow change that would make this more straightforward but I expect this to be a big change.

    opened by thuiop 4
  • Add box mark

    Add box mark

    This is a rectangular mark drawn between min/max values, sort of a cross between Bar and Range:

        so.Plot(tips, "day", "total_bill", color="sex")
        .add(so.Box(), so.Dodge())

    I think it's very likely that there will be a standalone mark for drawing a full box-and-whisker plot in one layer — name and implementation strategy TBD — but until then this mark provides what we need to have an (outlier-less) "box plot":

        so.Plot(tips, "day", "total_bill", color="sex")
        .add(so.Box(alpha=.35), so.Perc([25, 75]), so.Dodge())
        .add(so.Range(), so.Perc([0, 25]), so.Dodge())
        .add(so.Range(), so.Perc([75, 100]), so.Dodge())
        .add(so.Dash(), so.Perc([50]), so.Dodge())

    Couple notes:

    • Took a long time to decide on the name, considering other options such as Span, Rect, Plank, Beam, Lath. The first two are more useful for other planned marks, and the latter 3 are not obvious. This does commit us to using Boxplot or WhiskerBox or something like that for the proper "box plot" mark.
    • This uses the edge-clipping trick that Bar and Area marks use. I'm souring on this a bit and may revert it in a future release.
    objects-mark feature 
    opened by mwaskom 3
  • v0.12.2(Dec 30, 2022)

    v0.12.2 (December 2022)

    This is an incremental release that is a recommended upgrade for all users. It is very likely the final release of the 0.12 series and the last version to support Python 3.7.

    • |Feature| Added the objects.KDE stat (#3111).

    • |Feature| Added the objects.Boolean scale (#3205).

    • |Enhancement| Improved user feedback for failures during plot compilation by catching exceptions and re-raising with a PlotSpecError that provides additional context. (#3203).

    • |Fix| Improved calculation of automatic mark widths with unshared facet axes (#3119).

    • |Fix| Improved robustness to empty data in several components of the objects interface (#3202).

    • |Fix| Fixed a bug where legends for numeric variables with large values would be incorrectly shown (i.e. with a missing offset or exponent; #3187).

    • |Fix| Fixed a regression in v0.12.0 where manually-added labels could have duplicate legend entries (#3116).

    • |Fix| Fixed a bug in histplot with kde=True and log_scale=True where the curve was not scaled properly (#3173).

    • |Fix| Fixed a bug in relplot where inner axis labels would be shown when axis sharing was disabled (#3180).

    • |Fix| Fixed a bug in objects.Continuous to avoid an exception with boolean data (#3190).

    Source code(tar.gz)
    Source code(zip)
  • v0.12.1(Oct 18, 2022)

    This is an incremental release that is a recommended upgrade for all users. It addresses a handful of bugs / regressions in v0.12.0 and adds several features and enhancements to the new objects interface.

    • Added the objects.Text mark (#3051).
    • Added the objects.Dash mark (#3074).
    • Added the objects.Perc stat (#3063).
    • Added the objects.Count stat (#3086).
    • The objects.Band and objects.Range marks will now cover the full extent of the data if min / max variables are not explicitly assigned or added in a transform (#3056).
    • The objects.Jitter move now applies a small amount of jitter by default (#3066).
    • Axes with a objects.Nominal scale now appear like categorical axes in classic seaborn, with fixed margins, no grid, and an inverted y axis (#3069).
    • The objects.Continuous.label method now accepts base=None to override the default formatter with a log transform (#3087).
    • Marks that sort along the orient axis (e.g. objects.Line) now use a stable algorithm (#3064).
    • Added a label parameter to pointplot, which addresses a regression in 0.12.0 when pointplot is passed to FacetGrid (#3016).
    • Fixed a bug that caused an exception when more than two layers with the same mappings were added to objects.Plot (#3055).
    • Made objects.PolyFit robust to missing data (#3010).
    • Fixed a bug in objects.Plot that occurred when data assigned to the orient coordinate had zero variance (#3084).
    • Fixed a regression in kdeplot where passing cmap for an unfilled bivariate plot would raise an exception (#3065).
    • Addressed a performance regression in lineplot with a large number of unique x values (#3081).
    • Seaborn no longer contains doctest-style examples, simplifying the testing infrastructure (#3034).
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0(Sep 6, 2022)

    Introduction of the objects interface

    This release debuts the seaborn.objects interface, an entirely new approach to making plots with seaborn. It is the product of several years of design and 16 months of implementation work. The interface aims to provide a more declarative, composable, and extensible API for making statistical graphics. It is inspired by Wilkinson's grammar of graphics, offering a Pythonic API that is informed by the design of libraries such as ggplot2 and vega-lite along with lessons from the past 10 years of seaborn's development.

    For more information and numerous examples, see the tutorial chapter and API reference.

    This initial release should be considered "experimental". While it is stable enough for serious use, there are definitely some rough edges, and some key features remain to be implemented. It is possible that breaking changes may occur over the next few minor releases. Please be patient with any limitations that you encounter and help the development by reporting issues when you find behavior surprising.

    Keyword-only arguments

    Seaborn's plotting functions now require explicit keywords for most arguments, following the deprecation of positional arguments in v0.11.0. With this enforcement, most functions have also had their parameter lists rearranged so that data is the first and only positional argument. This adds consistency across the various functions in the library. It also means that calling func(data) will do something for nearly all functions (those that support wide-form data) and that pandas.DataFrame can be piped directly into a plot. It is possible that the signatures will be loosened a bit in future releases so that x and y can be positional, but minimal support for positional arguments after this change will reduce the chance of inadvertent mis-specification (2804).

    Modernization of categorical scatterplots

    This release begins the process of modernizing the categorical plots, beginning with stripplot and swarmplot. These functions are sporting some enhancements that alleviate a few long-running frustrations (2413, 2447):

    • The new native_scale parameter allows numeric or datetime categories to be plotted with their original scale rather than converted to strings and plotted at fixed intervals.
    • The new formatter parameter allows more control over the string representation of values on the categorical axis. There should also be improved defaults for some types, such as dates.
    • It is now possible to assign hue when using only one coordinate variable (i.e. only x or y).
    • It is now possible to disable the legend.

    The updates also harmonize behavior with functions that have been more recently introduced. This should be relatively non-disruptive, although a few defaults will change:

    • The functions now hook into matplotlib's unit system for plotting categorical data. (Seaborn's categorical functions actually predate support for categorical data in matplotlib.) This should mostly be transparent to the user, but it may resolve a few edge cases. For example, matplotlib interactivity should work better (e.g., for showing the data value under the cursor).
    • A color palette is no longer applied to levels of the categorical variable by default. It is now necessary to explicitly assign hue to see multiple colors (i.e., assign the same variable to x/y and hue). Passing palette without hue will continue to be honored for one release cycle.
    • Numeric hue variables now receive a continuous mapping by default, using the same rules as scatterplot. Pass palette="deep" to reproduce previous defaults.
    • The plots now follow the default property cycle; i.e. calling an axes-level function multiple times with the same active axes will produce different-colored artists.
    • Currently, assigning hue and then passing a color will produce a gradient palette. This is now deprecated, as it is easy to request a gradient with, e.g. palette="light:blue".

    Similar enhancements / updates should be expected to roll out to other categorical plotting functions in future releases. There are also several function-specific enhancements:

    • In stripplot, a "strip" with a single observation will be plotted without jitter (2413)
    • In swarmplot, the points are now swarmed at draw time, meaning that the plot will adapt to further changes in axis scaling or tweaks to the plot layout (2443).
    • In swarmplot, the proportion of points that must overlap before issuing a warning can now be controlled with the warn_thresh parameter (2447).
    • In swarmplot, the order of the points in each swarm now matches the order in the original dataset; previously they were sorted. This affects only the underlying data stored in the matplotlib artist, not the visual representation (2443).

    More flexible errorbars

    Increased the flexibility of what can be shown by the internally-calculated errorbars for lineplot, barplot, and pointplot.

    With the new errorbar parameter, it is now possible to select bootstrap confidence intervals, percentile / predictive intervals, or intervals formed by scaled standard deviations or standard errors. The parameter also accepts an arbitrary function that maps from a vector to an interval. There is a new user guide chapter demonstrating these options and explaining when you might want to use each one.

    As a consequence of this change, the ci parameter has been deprecated. Note that regplot retains the previous API, but it will likely be updated in a future release (2407, 2866).

    Other updates

    • It is now possible to aggregate / sort a lineplot along the y axis using orient="y" (2854).
    • Made it easier to customize FacetGrid / PairGrid / JointGrid with a fluent (method-chained) style by adding apply/ pipe methods. Additionally, fixed the tight_layout and refline methods so that they return self (2926).
    • Added FacetGrid.tick_params and PairGrid.tick_params to customize the appearance of the ticks, tick labels, and gridlines of all subplots at once (2944).
    • Added a width parameter to barplot (2860).
    • It is now possible to specify estimator as a string in barplot and pointplot, in addition to a callable (2866).
    • Error bars in regplot now inherit the alpha value of the points they correspond to (2540).
    • When using pairplot with corner=True and diag_kind=None, the top left y axis label is no longer hidden (2850).
    • It is now possible to plot a discrete histplot as a step function or polygon (2859).
    • It is now possible to customize the appearance of elements in a boxenplot with box_kws/line_kws/flier_kws (2909).
    • Improved integration with the matplotlib color cycle in most axes-level functions (2449).
    • Fixed a regression in 0.11.2 that caused some functions to stall indefinitely or raise when the input data had a duplicate index (2776).
    • Fixed a bug in histplot and kdeplot where weights were not factored into the normalization (2812).
    • Fixed two edgecases in histplot when only binwidth was provided (2813).
    • Fixed a bug in violinplot where inner boxes/points could be missing with unpaired split violins (2814).
    • Fixed a bug in PairGrid where an error would be raised when defining hue only in the mapping methods (2847).
    • Fixed a bug in scatterplot where an error would be raised when hue_order was a subset of the hue levels (2848).
    • Fixed a bug in histplot where dodged bars would have different widths on a log scale (2849).
    • In lineplot, allowed the dashes keyword to set the style of a line without mapping a style variable (2449).
    • Improved support in relplot for "wide" data and for faceting variables passed as non-pandas objects (2846).
    • Subplot titles will no longer be reset when calling or FacetGrid.map_dataframe (2705).
    • Added a workaround for a matplotlib issue that caused figure-level functions to freeze when was called (2925).
    • Improved robustness to numerical errors in kdeplot (2862).
    • Fixed a bug where rugplot was ignoring expand_margins=False (2953).
    • The patch.facecolor rc param is no longer set by set_palette (or set_theme). This should have no general effect, because the matplotlib default is now "C0" (2906).
    • Made scipy an optional dependency and added pip install seaborn[stats] as a method for ensuring the availability of compatible scipy and statsmodels libraries at install time. This has a few minor implications for existing code, which are explained in the Github pull request (2398).
    • Example datasets are now stored in an OS-specific cache location (as determined by appdirs) rather than in the user's home directory. Users should feel free to remove ~/seaborn-data if desired (2773).
    • The unit test suite is no longer part of the source or wheel distribution. Seaborn has never had a runtime API for exercising the tests, so this should not have workflow implications (2833).
    • Following NEP29, dropped support for Python 3.6 and bumped the minimally-supported versions of the library dependencies.
    • Removed the previously-deprecated factorplot along with several previously-deprecated utility functions (iqr, percentiles, pmf_hist, and sort_df).
    • Removed the (previously-unused) option to pass additional keyword arguments to pointplot.
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0rc0(Aug 14, 2022)

    This is the first release candidate for seaborn v0.12, a major update introducing an entirely new interface along with numerous features, enhancements, and fixes for existing functionality.

    To install for testing, run

    pip install seaborn==0.12.0rc0

    There were several renamings and API changes from the final beta release. See the referenced PRs for more information on each change.

    Mark renamings

    • Scatter -> Dots (#2942)
    • Ribbon -> Band (#2945)
    • Interval -> Range (#2945)

    Plot API changes

    • The stat= and move= parameters were removed from Plot.add, which now has the following signature: Plot.add(mark, *transforms, ...). (#2948)
    • The Plot.configure method was renamed to Plot.layout, with the figsize parameter changed to size. The share{x,y} parameters were removed from Plot.layout, with that functionality now supported by the new Plot.share method. (#2954)

    Additionally, the install extra for including statistical packages was changed from seaborn[all] to seaborn[stats]. (#2939)

    Source code(tar.gz)
    Source code(zip)
  • v0.12.0b3(Aug 4, 2022)

    This is the third and final beta release for seaborn v0.12, a major update introducing an entirely new interface along with numerous features, enhancements, and fixes for existing functionality.

    To install for testing, run

    pip install seaborn==0.12.0b3

    Changes from the second beta release:

    Objects interface

    • Added Est stat for aggregating with a flexible error bar interval (#2912)
    • Added Interval mark for drawing lines perpendicular to the orient axis (#2912)
    • Added Plot.theme for basic control over figure appearance (#2929)
    • Expanded Plot.label to control plot titles (#2934)
    • Fixed Plot.scale so that it applies to variables added during the stat transform (#2915)
    • Fixed a bug where the Plot.configure spec would not persist after further method calls (#2917)
    • Fixed a bug where dot marks ignored the artist_kws parameter (#2921)

    Function interface

    • Added .apply and .pipe methods to FacetGrid/PairGrid/JointGrid for fluent customization (#2928)
    • Added a workaround for an issue in matplotlib that caused figure-level plots to freeze or close (#2925)
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0b2(Jul 14, 2022)

    This is the second beta release for seaborn v0.12, a major update introducing an entirely new interface along with numerous features, enhancements, and fixes for existing functionality.

    To install for testing, run

    pip install seaborn==0.12.0b2

    Changes from the first beta release:

    Objects interface

    • Added Plot.label method for controlling axis labels/legend titles (#2902)
    • Added Plot.limit method for controlling axis limits (#2898)
    • Added Bars, a more efficient mark for histograms, and improved performance of Bar mark as well (#2893)
    • Improved the visual appearance of the Area and Ribbon marks used a simpler matplotlib artist class for them (#2896)
    • Improved the visual appearance of the Bar mark (#2889)
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0b1(Jun 27, 2022)

    This is the first beta release for seaborn v0.12, a major update introducing an entirely new interface along with numerous features, enhancements, and fixes for existing functionality.

    To install for testing, run

    pip install seaborn==0.12.0b1

    Changes from the final alpha release:

    Objects interface

    • Improve tick label defaults and customization (#2877)
      • Add Scale.label interface for formatting tick labels
      • Fix a bug where unshared axes would use the same locator
      • Default to scientific notation for log scale ticks
      • Default to log-spaced ticks with symlog scale
      • Shorten transform parameter name to trans
      • Simplify internal type structure
    • Allow suppression of legend for individual layers (#2834)

    Function interface

    • Add new errorbar API to pointplot and barplot (#2866)
    • Add width parameter to barplot (#2860)
    • Add orient parameter to lineplot (#2854)
    • Allow histplot to draw discrete histograms with step or poly marks (#2859)
    • Downgrade exception in relational plots with palette of incorrect length to a warning (#2856)
    • Use alpha from point mark for error bars in regplot (#2853)
    • Improve user-friendliness of jointplot (#2863)
    • Preserve upper left y axis label in pointplot with corner=True and diag_kind=None (#2850)
    • Improve support for anonymous data objects in relplot (#2846)
    • Fix histplot dodged bar widths with log scale (#2849)
    • Fix hue_order as a subset in scatterplot (#2848)
    • Fix several bugs in the new categorical scatterplot features (#2845)
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0a1(Jun 3, 2022)

    This is the second alpha release for seaborn v0.12, a major release introducing an entirely new interface along with numerous enhancements and fixes to existing functionality.

    To install for testing, run

    pip install

    Changes from the first alpha release:

    Objects interface

    • Add Norm move, for divisive scaling after stat computation (#2827)
    • Complete Line mark and add corresponding Path, Lines, and Paths marks (#2822)
    • Fix inferred y orientation with computed x variable (#2818)
    • Fix multiple moves while pairing (#2817)
    • Improve missing data handling (#2816)

    Categorical plots

    • Revert change to 1D "wide" data handling introduced in v0.12.0a0 (#2829)
    • Improve legend fore new features in categorical scatterplots (#2828)
    • Fix inner boxes with unpaired split violins (#2814)

    Distribution plots

    • Fix some edgecases in histplotwhen specifying binwidth (#2813)
    • Fix histplot/kdeplot normalization when using hue and weights (#2812)
    Source code(tar.gz)
    Source code(zip)
  • v0.12.0a0(May 16, 2022)

    This is the first alpha for seaborn v0.12.0, a major release that introduces an entirely new interface in the seaborn.objects namespace.

    For more information about the new interface, see the development docs at

    Please experiment with the alpha version and provide feedback on things that are confusing or don't work, but expect some rough edges and instability.

    Source code(tar.gz)
    Source code(zip)
  • v0.11.2(Aug 16, 2021)

    This is a minor release that addresses issues in the v0.11 series and adds a small number of targeted enhancements. It is a recommended upgrade for all users.

    • |Docs| A paper describing seaborn has been published in the Journal of Open Source Software. The paper serves as an introduction to the library and can be used to cite seaborn if it has been integral to a scientific publication.

    • |API| |Feature| In lmplot, added a new facet_kws parameter and deprecated the sharex, sharey, and legend_out parameters from the function signature; pass them in a facet_kws dictionary instead (

    • |Feature| Added a move_legend convenience function for repositioning the legend on an existing axes or figure, along with updating its properties. This function should be preferred over calling ax.legend with no legend data, which does not reliably work across seaborn plot types (

    • |Feature| In histplot, added stat="percent" as an option for normalization such that bar heights sum to 100 and stat="proportion" as an alias for the existing stat="probability" (,

    • |Feature| Added FacetGrid.refline and JointGrid.refline methods for plotting horizontal and/or vertical reference lines on every subplot in one step (

    • |Feature| In kdeplot, added a warn_singular parameter to silence the warning about data with zero variance (

    • |Enhancement| In histplot, improved performance with large datasets and many groupings/facets (,

    • |Enhancement| The FacetGrid, PairGrid, and JointGrid objects now reference the underlying matplotlib figure with a .figure attribute. The existing .fig attribute still exists but is discouraged and may eventually be deprecated. The effect is that you can now call obj.figure on the return value from any seaborn function to access the matplotlib object (

    • |Enhancement| In FacetGrid and functions that use it, visibility of the interior axis labels is now disabled, and exterior axis labels are no longer erased when adding additional layers. This produces the same results for plots made by seaborn functions, but it may produce different (better, in most cases) results for customized facet plots (

    • |Enhancement| In FacetGrid, PairGrid, and functions that use them, the matplotlib figure.autolayout parameter is disabled to avoid having the legend overlap the plot (

    • |Enhancement| The load_dataset helper now produces a more informative error when fed a dataframe, easing a common beginner mistake (

    • |Fix| |Enhancement| Improved robustness to missing data, including some additional support for the pd.NA type (,

    • |Fix| In ecdfplot and rugplot, fixed a bug where results were incorrect if the data axis had a log scale before plotting (

    • |Fix| In histplot, fixed a bug where using shrink with non-discrete bins shifted bar positions inaccurately (

    • |Fix| In displot, fixed a bug where common_norm=False was ignored when faceting was used without assigning hue (

    • |Fix| In histplot, fixed two bugs where automatically computed edge widths were too thick for log-scaled histograms and for categorical histograms on the y axis (

    • |Fix| In histplot and kdeplot, fixed a bug where the alpha parameter was ignored when fill=False (

    • |Fix| In histplot and kdeplot, fixed a bug where the multiple parameter was ignored when hue was provided as a vector without a name (

    • |Fix| In displot, the default alpha value now adjusts to a provided multiple parameter even when hue is not assigned (

    • |Fix| In displot, fixed a bug that caused faceted 2D histograms to error out with common_bins=False (

    • |Fix| In rugplot, fixed a bug that prevented the use of datetime data (

    • |Fix| In relplot and displot, fixed a bug where the dataframe attached to the returned FacetGrid object dropped columns that were not used in the plot (

    • |Fix| In relplot, fixed an error that would be raised when one of the column names in the dataframe shared a name with one of the plot variables (

    • |Fix| In the relational plots, fixed a bug where legend entries for the size semantic were incorrect when size_norm extrapolated beyond the range of the data (

    • |Fix| In lmplot and regplot, fixed a bug where the x axis was clamped to the data limits with truncate=True (

    • |Fix| In lmplot, fixed a bug where sharey=False did not always work as expected (

    • |Fix| In heatmap, fixed a bug where vertically-rotated y-axis tick labels would be misaligned with their rows (

    • |Fix| Fixed an issue that prevented Python from running in -OO mode while using seaborn (

    • |Docs| Improved the API documentation for theme-related functions (

    • |Docs| Added docstring pages for all methods on documented classes (

    Source code(tar.gz)
    Source code(zip)
  • v0.11.2.rc0(Aug 8, 2021)

  • joss_paper(Mar 29, 2021)

    This is a duplicate tag for seaborn v0.11.1.

    It is being created so that Zenodo will mint a DOI for the repository corresponding to seaborn's JOSS paper.

    Source code(tar.gz)
    Source code(zip)
  • v0.11.1(Dec 20, 2020)

  • v0.11.0(Sep 8, 2020)

  • v0.11.0.rc0(Sep 2, 2020)

    This is the first release candidate for v0.11.0, a major release with several important new features and changes to the library.

    Highlights of the new version include:

    Please test the release by installing from here or with python -m pip install --upgrade --pre seaborn

    Source code(tar.gz)
    Source code(zip)
    seaborn-0.11.0rc0-py3-none-any.whl(275.84 KB)
  • v0.10.1(Apr 26, 2020)

    This is minor release with bug fixes for issues identified since 0.10.0.

    • Fixed a bug that appeared within the bootstrapping algorithm on 32-bit systems.
    • Fixed a bug where regplot would crash on singleton inputs. Now a crash is avoided and regression estimation/plotting is skipped.
    • Fixed a bug where heatmap would ignore user-specified under/over/bad values when recentering a colormap.
    • Fixed a bug where heatmap would use values from masked cells when computing default colormap limits.
    • Fixed a bug where despine would cause an error when trying to trim spines on a matplotlib categorical axis.
    • Adapted to a change in matplotlib that caused problems with single swarm plots.
    • Added the showfliers parameter to boxenplot to suppress plotting of outlier data points, matching the API of boxplot.
    • Avoided seeing an error from statmodels when data with an IQR of 0 is passed to kdeplot.
    • Added the legend.title_fontsize to the plotting_context definition.
    • Deprecated several utility functions that are no longer used internally (percentiles, sig_stars, pmf_hist, and sort_df).
    Source code(tar.gz)
    Source code(zip)
  • v0.10.0(Jan 24, 2020)

    This is a major update that is being released simultaneously with version 0.9.1. It has all of the same features (and bugs!) as 0.9.1, but there are important changes to the dependencies.

    Most notably, all support for Python 2 has now been dropped. Support for Python 3.5 has also been dropped. Seaborn is now strictly compatible with Python 3.6+.

    Minimally supported versions of the dependent PyData libraries have also been increased, in some cases substantially. While seaborn has tended to be very conservative about maintaining compatibility with older dependencies, this was causing increasing pain during development. At the same time, these libraries are now much easier to install. Going forward, seaborn will likely stay close to the Numpy community guidelines for version support.

    This release also removes a few previously-deprecated features:

    • The tsplot function and seaborn.timeseries module have been removed. Recall that tsplot was replaced with lineplot.
    • The seaborn.apionly entry-point has been removed.
    • The seaborn.linearmodels module (previously renamed to seaborn.regression) has been removed.

    Looking forward

    Now that seaborn is a Python 3 library, it can take advantage of keyword-only arguments. It is likely that future versions will introduce this syntax, potentially in a breaking way. For guidance, most seaborn functions have a signature that looks like

    func(x, y, ..., data=None, **kwargs)

    where the **kwargs are specified in the function. Going forward it will likely be necessary to specify data and all subsequent arguments with an explicit key=value mapping. This style has long been used throughout the documentation, and the formal requirement will not be introduced until at least the next major release. Adding this feature will make it possible to enhance some older functions with more modern capabilities (e.g., adding a native hue semantic within functions like jointplot and regplot).

    Source code(tar.gz)
    Source code(zip)
  • v0.9.1(Jan 24, 2020)

    This is a minor release with a number of bug fixes and adaptations to changes in seaborn's dependencies. There are also several new features.

    This is the final version of seaborn that will support Python 2.7 or 3.5.

    New features

    • Added more control over the arrangement of the elements drawn by clustermap with the {dendrogram,colors}_ratio and cbar_pos parameters. Additionally, the default organization and scaling with different figure sizes has been improved.
    • Added the corner option to PairGrid and pairplot to make a grid without the upper triangle of bivariate axes.
    • Added the ability to seed the random number generator for the bootstrap used to define error bars in several plots. Relevant functions now have a seed parameter, which can take either fixed seed (typically an int) or a numpy random number generator object (either the newer numpy.random.Generator or the older numpy.random.mtrand.RandomState).
    • Generalized the idea of "diagonal" axes in PairGrid to any axes that share an x and y variable.
    • In PairGrid, the hue variable is now excluded from the default list of variables that make up the rows and columns of the grid.
    • Exposed the layout_pad parameter in PairGrid and set a smaller default than what matptlotlib sets for more efficient use of space in dense grids.
    • It is now possible to force a categorical interpretation of the hue varaible in a relational plot by passing the name of a categorical palette (e.g. "deep", or "Set2"). This complements the (previously supported) option of passig a list/dict of colors.
    • Added the tree_kws parameter to clustermap to control the properties of the lines in the dendrogram.
    • Added the ability to pass hierarchical label names to the FacetGrid legend, which also fixes a bug in relplot when the same label appeared in diffent semantics.
    • Improved support for grouping observations based on pandas index information in categorical plots.

    Bug fixes and adaptations

    • Avoided an error when singular data is passed to kdeplot, issuing a warning instead. This makes pairplot more robust.
    • Fixed the behavior of dropna in PairGrid to properly exclude null datapoints from each plot when set to True.
    • Fixed an issue where regplot could interfere with other axes in a multi-plot matplotlib figure.
    • Semantic variables with a category data type will always be treated as categorical in relational plots.
    • Avoided a warning about color specifications that arose from boxenplot on newer matplotlibs.
    • Adapted to a change in how matplotlib scales axis margins, which caused multiple calls to regplot with truncate=False to progressively expand the x axis limits. Because there are currently limitations on how autoscaling works in matplotlib, the default value for truncate in seaborn has also been changed to True.
    • Relational plots no longer error when hue/size data are inferred to be numeric but stored with a string datatype.
    • Relational plots now consider semantics with only a single value that can be interpreted as boolean (0 or 1) to be categorical, not numeric.
    • Relational plots now handle list or dict specifications for sizes correctly.
    • Fixed an issue in pointplot where missing levels of a hue variable would cause an exception after a recent update in matplotlib.
    • Fixed a bug when setting the rotation of x tick labels on a FacetGrid.
    • Fixed a bug where values would be excluded from categorical plots when only one variable was a pandas Series with a non-default index.
    • Fixed a bug when using Series objects as arguments for x_partial or y_partial in regplot.
    • Fixed a bug when passing a norm object and using color annotations in clustermap.
    • Fixed a bug where annotations were not rearranged to match the clustering in clustermap.
    • Fixed a bug when trying to call set while specifying a list of colors for the palette.
    • Fixed a bug when resetting the color code short-hands to the matplotlib default.
    • Avoided errors from stricter type checking in upcoming numpy changes.
    • Avoided error/warning in lineplot when plotting categoricals with empty levels.
    • Allowed colors to be passed through to a bivariate kdeplot.
    • Standardized the output format of custom color palette functions.
    • Fixed a bug where legends for numerical variables in a relational plot could show a surprisingly large number of decimal places.
    • Improved robustness to missing values in distribution plots.
    • Made it possible to specify the location of the FacetGrid legend using matplotlib keyword arguments.
    Source code(tar.gz)
    Source code(zip)
  • v0.10.0.rc0(Jan 24, 2020)

  • v0.9.1.rc0(Jan 22, 2020)

  • v0.9.0(Jul 16, 2018)

    v0.9.0 (July 2018)

    Note: a version of these release notes with working links appears in the online documentation.

    This is a major release with several substantial and long-desired new features. There are also updates/modifications to the themes and color palettes that give better consistency with matplotlib 2.0 and some notable API changes.

    New relational plots

    Three completely new plotting functions have been added: catplot, scatterplot, and lineplot. The first is a figure-level interface to the latter two that combines them with a FacetGrid. The functions bring the high-level, dataset-oriented API of the seaborn categorical plotting functions to more general plots (scatter plots and line plots).

    These functions can visualize a relationship between two numeric variables while mapping up to three additional variables by modifying hue, size, and/or style semantics. The common high-level API is implemented differently in the two functions. For example, the size semantic in scatterplot scales the area of scatter plot points, but in lineplot it scales width of the line plot lines. The API is dataset-oriented, meaning that in both cases you pass the variable in your dataset rather than directly specifying the matplotlib parameters to use for point area or line width.

    Another way the relational functions differ from existing seaborn functionality is that they have better support for using numeric variables for hue and size semantics. This functionality may be propagated to other functions that can add a hue semantic in future versions; it has not been in this release.

    The lineplot function also has support for statistical estimation and is replacing the older tsplot function, which still exists but is marked for removal in a future release. lineplot is better aligned with the API of the rest of the library and more flexible in showing relationships across additional variables by modifying the size and style semantics independently. It also has substantially improved support for date and time data, a major pain factor in tsplot. The cost is that some of the more esoteric options in tsplot for representing uncertainty (e.g. a colormapped KDE of the bootstrap distribution) have not been implemented in the new function.

    There is quite a bit of new documentation that explains these new functions in more detail, including detailed examples of the various options in the API reference and a more verbose tutorial.

    These functions should be considered in a "stable beta" state. They have been thoroughly tested, but some unknown corner cases may remain to be found. The main features are in place, but not all planned functionality has been implemented. There are planned improvements to some elements, particularly the default legend, that are a little rough around the edges in this release. Finally, some of the default behavior (e.g. the default range of point/line sizes) may change somewhat in future releases.

    Updates to themes and palettes

    Several changes have been made to the seaborn style themes, context scaling, and color palettes. In general the aim of these changes was to make the seaborn styles more consistent with the style updates in matplotlib 2.0 and to leverage some of the new style parameters for better implementation of some aspects of the seaborn styles. Here is a list of the changes:

    • Reorganized and updated some axes_style/plotting_context parameters to take advantage of improvements in the matplotlib 2.0 update. The biggest change involves using several new parameterss in the "style" spec while moving parameters that used to implement the corresponding aesthetics to the "context" spec. For example, axes spines and ticks are now off instead of having their width/length zeroed out for the darkgrid style. That means the width/length of these elements can now be scaled in different contexts. The effect is a more cohesive appearance of the plots, especially in larger contexts. These changes include only minimal support for the 1.x matplotlib series. Users who are stuck on matplotlib 1.5 but wish to use seaborn styling may want to use the seaborn parameters that can be accessed through the matplotlib stylesheet interface.
    • Updated the seaborn palettes ("deep", "muted", "colorblind", etc.) to correspond with the new 10-color matplotlib default. The legacy palettes are now available at "deep6", "muted6", "colorblind6", etc. Additionally, a few individual colors were tweaked for better consistency, aesthetics, and accessibility.
    • Calling color_palette (or set_palette) with a named qualitative palettes (i.e. one of the seaborn palettes, the colorbrewer qualitative palettes, or the matplotlib matplotlib tableau-derived palettes) and no specified number of colors will return all of the colors in the palette. This means that for some palettes, the returned list will have a different length than it did in previous versions.
    • Enhanced color_palette to accept a parameterized specification of a cubehelix palette in in a string, prefixed with "ch:" (e.g. "ch:-.1,.2,l=.7"). Note that keyword arguments can be spelled out or referenced using only their first letter. Reversing the palette is accomplished by appending "_r", as with other matplotlib colormaps. This specification will be accepted by any seaborn function with a palette= parameter.
    • Slightly increased the base font sizes in plotting_context and increased the scaling factors for "talk" and "poster" contexts.
    • Calling set will now call set_color_codes to re-assign the single letter color codes by default

    API changes

    A few functions have been renamed or have had changes to their default parameters.

    • The factorplot function has been renamed to catplot. The new name ditches the original R-inflected terminology to use a name that is more consistent with terminology in pandas and in seaborn itself. This change should hopefully make catplot easier to discover, and it should make more clear what its role is. factorplot still exists and will pass its arguments through to catplot with a warning. It may be removed eventually, but the transition will be as gradual as possible.
    • The other reason that the factorplot name was changed was to ease another alteration which is that the default kind in catplot is now "strip" (corresponding to stripplot). This plots a categorical scatter plot which is usually a much better place to start and is more consistent with the default in relplot. The old default style in factorplot ("point", corresponding to pointplot) remains available if you want to show a statistical estimation.
    • The lvplot function has been renamed to boxenplot. The "letter-value" terminology that was used to name the original kind of plot is obscure, and the abbreviation to lv did not help anything. The new name should make the plot more discoverable by describing its format (it plots multiple boxes, also known as "boxen"). As with factorplot, the lvplot function still exists to provide a relatively smooth transition.
    • Renamed the size parameter to height in multi-plot grid objects (FacetGrid, PairGrid, and JointGrid) along with functions that use them (factorplot, lmplot, pairplot, and jointplot) to avoid conflicts with the size parameter that is used in scatterplot and lineplot (necessary to make relplot work) and also makes the meaning of the parameter a bit more clear.
    • Changed the default diagonal plots in pairplot to use `func`:kdeplot` when a "hue" dimension is used.
    • Deprecated the statistical annotation component of JointGrid. The method is still available but will be removed in a future version.
    • Two older functions that were deprecated in earlier versions, coefplot and interactplot, have undergone final removal from the code base.

    Documentation improvements

    There has been some effort put into improving the documentation. The biggest change is that the introduction to the library has been completely rewritten to provide much more information and, critically, examples. In addition to the high-level motivation, the introduction also covers some important topics that are often sources of confusion, like the distinction between figure-level and axes-level functions, how datasets should be formatted for use in seaborn, and how to customize the appearance of the plots.

    Other improvements have been made throughout, most notably a thorough re-write of the categorical tutorial categorical_tutorial.

    Other small enhancements and bug fixes

    • Changed rugplot to plot a matplotlib LineCollection instead of many Line2D objects, providing a big speedup for large arrays.
    • Changed the default off-diagonal plots to use scatterplot. (Note that the "hue" currently draws three separate scatterplots instead of using the hue semantic of the scatterplot function).
    • Changed color handling when using kdeplot with two variables. The default colormap for the 2D density now follows the color cycle, and the function can use color and label kwargs, adding more flexibility and avoiding a warning when using with multi-plot grids.
    • Added the subplot_kws parameter to PairGrid for more flexibility.
    • Removed a special case in PairGrid that defaulted to drawing stacked histograms on the diagonal axes.
    • Fixed jointplot/JointGrid and regplot so that they now accept list inputs.
    • Fixed a bug in FacetGrid when using a single row/column level or using col_wrap=1.
    • Fixed functions that set axis limits so that they preserve auto-scaling state on matplotlib 2.0.
    • Avoided an error when using matplotlib backends that cannot render a canvas (e.g. PDF).
    • Changed the install infrastructure to explicitly declare dependencies in a way that pip is aware of. This means that pip install seaborn will now work in an empty environment. Additionally, the dependencies are specified with strict minimal versions.
    • Updated the testing infrastructure to execute tests with pytest (although many individual tests still use nose assertion).
    Source code(tar.gz)
    Source code(zip)
  • v0.8.1(Sep 3, 2017)

    v0.8.1 (September 2017)

    • Added a warning in FacetGrid when passing a categorical plot function without specifying order (or hue_order when hue is used), which is likely to produce a plot that is incorrect.

    • Improved compatibility between FacetGrid or PairGrid and interactive matplotlib backends so that the legend no longer remains inside the figure when using legend_out=True.

    • Changed categorical plot functions with small plot elements to use dark_palette instead of light_palette when generating a sequential palette from a specified color.

    • Improved robustness of kdeplot and distplot to data with fewer than two observations.

    • Fixed a bug in clustermap when using yticklabels=False.

    • Fixed a bug in pointplot where colors were wrong if exactly three points were being drawn.

    • Fixed a bug inpointplot where legend entries for missing data appeared with empty markers.

    • Fixed a bug in clustermap where an error was raised when annotating the main heatmap and showing category colors.

    • Fixed a bug in clustermap where row labels were not being properly rotated when they overlapped.

    • Fixed a bug in kdeplot where the maximum limit on the density axes was not being updated when multiple densities were drawn.

    • Improved compatibility with future versions of pandas.

    Source code(tar.gz)
    Source code(zip)
  • v0.8.0(Jul 8, 2017)

    • The default style is no longer applied when seaborn is imported. It is now necessary to explicitly call set or one or more of set_style, set_context, and set_palette. Correspondingly, the seaborn.apionly module has been deprecated.

    • Changed the behavior of heatmap (and by extension clustermap) when plotting divergent dataesets (i.e. when the center parameter is used). Instead of extending the lower and upper limits of the colormap to be symettrical around the center value, the colormap is modified so that its middle color corresponds to center. This means that the full range of the colormap will not be used (unless the data or specified vmin and vmax are symettric), but the upper and lower limits of the colorbar will correspond to the range of the data. See the Github pull request (#1184) for examples of the behavior.

    • Removed automatic detection of diverging data in heatmap (and by extension clustermap). If you want the colormap to be treated as diverging (see above), it is now necessary to specify the center value. When no colormap is specified, specifying center will still change the default to be one that is more appropriate for displaying diverging data.

    • Added four new colormaps, created using viscm for perceptual uniformity. The new colormaps include two sequential colormaps ("rocket" and "mako") and two diverging colormaps ("icefire" and "vlag"). These colormaps are registered with matplotlib on seaborn input and the colormap objects can be accessed in the namespace.

    • Changed the default heatmap colormaps to be "rocket" (in the case of sequential data) or "icefire" (in the case of diverging data). Note that this change reverses the direction of the luminance ramp from the previous defaults. While potentially confusing and disruptive, this change better aligns the seaborn defaults with the new matplotlib default colormap ("viridis") and arguably better aligns the semantics of a "heat" map with the appearance of the colormap.

    • Added "auto" as a (default) option for tick labels in heatmap and clustermap. This will try to estimate how many ticks can be labeled without the text objects overlapping, which should improve performance for larger matrices.

    • Added the dodge parameter to boxplot, violinplot, and barplot to allow use of hue without changing the position or width of the plot elements, as when the hue varible is not nested within the main categorical variable.

    • Correspondingly, the split parameter for stripplot and swarmplot has been renamed to dodge for consistency with the other categorical functions (and for differentiation from the meaning of split in violinplot).

    • Added the ability to draw a colorbar for a bivariate kdeplot with the cbar parameter (and related cbar_ax and cbar_kws parameters).

    • Added the ability to use error bars to show standard deviations rather than bootstrap confidence intervals in most statistical functions by putting ci="sd".

    • Allow side-specific offsets in despine.

    • Figure size is no longer part of the seaborn plotting context parameters.

    • Put a cap on the number of bins used in jointplot for type=="hex" to avoid hanging when the reference rule prescribes too many.

    • Turn off dendrogram axes in clustermap rather than setting the background color to white.

    • New matplotlib qualitative palettes (e.g. "tab10") are now handled correctly.

    • Some modules and functions have been internally reorganized; there should be no effect on code that uses the seaborn namespace.

    • Added a deprecation warning to tsplot function to indicate that it will be removed or replaced with a substantially altered version in a future release.

    • The interactplot and coefplot functions are officially deprecated and will be removed in a future release.

    Source code(tar.gz)
    Source code(zip)
  • v0.7.1(Jun 5, 2016)

    • Added the ability to put "caps" on the error bars that are drawn by barplot or pointplot (and, by extension, factorplot). Additionally, the line width of the error bars can now be controlled. These changes involve the new parameters capsize and errwidth. See the github pull request for examples of usage.
    • Improved the row and column colors display in clustermap. It is now possible to pass Pandas objects for these elements and, when possible, the semantic information in the Pandas objects will be used to add labels to the plot. When Pandas objects are used, the color data is matched against the main heatmap based on the index, not on position. This is more accurate, but it may lead to different results if current code assumed positional matching.
    • Improved the luminance calculation that determines the annotation color in heatmap.
    • The annot parameter of heatmap now accepts a rectangular dataset in addition to a boolean value. If a dataset is passed, its values will be used for the annotations, while the main dataset will be used for the heatmap cell colors.
    • Fixed a bug in FacetGrid that appeared when using col_wrap with missing col levels.
    • Made it possible to pass a tick locator object to the heatmap colorbar.
    • Made it possible to use different styles (e.g., step) for PairGrid histograms when there are multiple hue levels.
    • Fixed a bug in scipy-based univariate kernel density bandwidth calculation.
    • The reset_orig function (and, by extension, importing seaborn.apionly) resets matplotlib rcParams to their values at the time seaborn itself was imported, which should work better with rcParams changed by the jupyter notebook backend.
    • Removed some objects from the top-level seaborn namespace.
    • Improved unicode compatibility in FacetGrid.
    Source code(tar.gz)
    Source code(zip)
  • v0.7.0(Jan 25, 2016)

    This is a major release from 0.6. The main new feature is swarmplot which implements the beeswarm approach for drawing categorical scatterplots. There are also some performance improvements, bug fixes, and updates for compatibility with new versions of dependencies.

    • Added the swarmplot function, which draws beeswarm plots. These are categorical scatterplots, similar to those produced by stripplot, but position of the points on the categorical axis is chosen to avoid overlapping points. See the categorical plot tutorial for more information.
    • Added an additional rule when determining category order in categorical plots. Now, when numeric variables are used in a categorical role, the default behavior is to sort the unique levels of the variable (i.e they will be in proper numerical order). This can still be overridden by the appropriate {*_}order parameter, and variables with a category datatype will still follow the category order even if the levels are strictly numerical.
    • Changed some of the stripplot defaults to be closer to swarmplot. Points are somewhat smaller, have no outlines, and are not split by default when using hue.
    • Changed how stripplot draws points when using hue nesting with split=False so that the different hue levels are not drawn strictly on top of each other.
    • Improve performance for large dendrograms in clustermap.
    • Added font.size to the plotting context definition so that the default output from plt.text will be scaled appropriately.
    • Fixed a bug in clustermap when fastcluster is not installed.
    • Fixed a bug in the zscore calculation in clustermap.
    • Fixed a bug in distplot where sometimes the default number of bins would not be an integer.
    • Fixed a bug in stripplot where a legend item would not appear for a hue level if there were no observations in the first group of points.
    • Heatmap colorbars are now rasterized for better performance in vector plots.
    • Added workarounds for some matplotlib boxplot issues, such as strange colors of outlier points.
    • Added workarounds for an issue where violinplot edges would be missing or have random colors.
    • Added a workaround for an issue where only one heatmap cell would be annotated on some matplotlib backends.
    • Fixed a bug on newer versions of matplotlib where a colormap would be erroneously applied to scatterplots with only three observations.
    • Updated seaborn for compatibility with matplotlib 1.5.
    • Added compatibility for various IPython (and Jupyter) versions in functions that use widgets.
    Source code(tar.gz)
    Source code(zip)
  • v0.6.0(Jun 29, 2015)

    This is a major release from 0.5. The main objective of this release was to unify the API for categorical plots, which means that there are some relatively large API changes in some of the older functions. See below for details of those changes, which may break code written for older versions of seaborn. There are also some new functions (stripplot, and countplot), numerous enhancements to existing functions, and bug fixes.

    Additionally, the documentation has been completely revamped and expanded for the 0.6 release. Now, the API docs page for each function has multiple examples with embedded plots showing how to use the various options. These pages should be considered the most comprehensive resource for examples, and the tutorial pages are now streamlined and oriented towards a higher-level overview of the various features.

    Changes and updates to categorical plots

    In version 0.6, the "categorical" plots have been unified with a common API. This new category of functions groups together plots that show the relationship between one numeric variable and one or two categorical variables. This includes plots that show distribution of the numeric variable in each bin (boxplot, violinplot, and stripplot) and plots that apply a statistical estimation within each bin (pointplot, barplot, and countplot). There is a new tutorial chapter <categorical_tutorial> that introduces these functions.

    The categorical functions now each accept the same formats of input data and can be invoked in the same way. They can plot using long- or wide-form data, and can be drawn vertically or horizontally. When long-form data is used, the orientation of the plots is inferred from the types of the input data. Additionally, all functions natively take a hue variable to add a second layer of categorization.

    With the (in some cases new) API, these functions can all be drawn correctly by FacetGrid. However, factorplot can also now create faceted verisons of any of these kinds of plots, so in most cases it will be unnecessary to use FacetGrid directly. By default, factorplot draws a point plot, but this is controlled by the kind parameter.

    Here are details on what has changed in the process of unifying these APIs:

    • Changes to boxplot and violinplot will probably be the most disruptive. Both functions maintain backwards-compatibility in terms of the kind of data they can accept, but the syntax has changed to be more similar to other seaborn functions. These functions are now invoked with x and/or y parameters that are either vectors of data or names of variables in a long-form DataFrame passed to the new data parameter. You can still pass wide-form DataFrames or arrays to data, but it is no longer the first positional argument. See the github pull request for more information on these changes and the logic behind them.
    • As pointplot and barplot can now plot with the major categorical variable on the y axis, the x_order parameter has been renamed to order.
    • Added a hue argument to boxplot and violinplot, which allows for nested grouping the plot elements by a third categorical variable. For violinplot, this nesting can also be accomplished by splitting the violins when there are two levels of the hue variable (using split=True). To make this functionality feasible, the ability to specify where the plots will be draw in data coordinates has been removed. These plots now are drawn at set positions, like (and identical to) barplot and pointplot.
    • Added a palette parameter to boxplot/violinplot. The color parameter still exists, but no longer does double-duty in accepting the name of a seaborn palette. palette supersedes color so that it can be used with a FacetGrid.

    Along with these API changes, the following changes/enhancements were made to the plotting functions:

    • The default rules for ordering the categories has changed. Instead of automatically sorting the category levels, the plots now show the levels in the order they appear in the input data (i.e., the order given by Series.unique()). Order can be specified when plotting with the order and hue_order parameters. Additionally, when variables are pandas objects with a "categorical" dtype, the category order is inferred from the data object. This change also affects FacetGrid and PairGrid.
    • Added the scale and scale_hue parameters to violinplot. These control how the width of the violins are scaled. The default is area, which is different from how the violins used to be drawn. Use scale='width' to get the old behavior.
    • Used a different style for the box kind of interior plot in violinplot, which shows the whisker range in addition to the quartiles. Use inner='quartile' to get the old style.

    New plotting functions

    • Added the stripplot function, which draws a scatterplot where one of the variables is categorical. This plot has the same API as boxplot and violinplot. It is useful both on its own and when composed with one of these other plot kinds to show both the observations and underlying distribution.
    • Added the countplot function, which uses a bar plot representation to show counts of variables in one or more categorical bins. This replaces the old approach of calling barplot without a numeric variable.

    Other additions and changes

    • The corrplot and underlying symmatplot functions have been deprecated in favor of heatmap, which is much more flexible and robust. These two functions are still available in version 0.6, but they will be removed in a future version.
    • Added the set_color_codes function and the color_codes argument to set and set_palette. This changes the interpretation of shorthand color codes (i.e. "b", "g", k", etc.) within matplotlib to use the values from one of the named seaborn palettes (i.e. "deep", "muted", etc.). That makes it easier to have a more uniform look when using matplotlib functions directly with seaborn imported. This could be disruptive to existing plots, so it does not happen by default. It is possible this could change in the future.
    • The color_palette function no longer trims palettes that are longer than 6 colors when passed into it.
    • Added the as_hex method to color palette objects, to return a list of hex codes rather than rgb tuples.
    • jointplot now passes additional keyword arguments to the function used to draw the plot on the joint axes.
    • Changed the default linewidths in heatmap and clustermap to 0 so that larger matrices plot correctly. This parameter still exists and can be used to get the old effect of lines demarcating each cell in the heatmap (the old default linewidths was 0.5).
    • heatmap and clustermap now automatically use a mask for missing values, which previously were shown with the "under" value of the colormap per default plt.pcolormesh behavior.
    • Added the seaborn.crayons dictionary and the crayon_palette function to define colors from the 120 box (!) of Crayola crayons.
    • Added the line_kws parameter to residplot to change the style of the lowess line, when used.
    • Added open-ended **kwargs to the add_legend method on FacetGrid and PairGrid, which will pass additional keyword arguments through when calling the legend function on the Figure or Axes.
    • Added the gridspec_kws parameter to FacetGrid, which allows for control over the size of individual facets in the grid to emphasize certain plots or account for differences in variable ranges.
    • The interactive palette widgets now show a continuous colorbar, rather than a discrete palette, when as_cmap is True.
    • The default Axes size for pairplot and PairGrid is now slightly smaller.
    • Added the shade_lowest parameter to kdeplot which will set the alpha for the lowest contour level to 0, making it easier to plot multiple bivariate distributions on the same axes.
    • The height parameter of rugplot is now interpreted as a function of the axis size and is invariant to changes in the data scale on that axis. The rug lines are also slightly narrower by default.
    • Added a catch in distplot when calculating a default number of bins. For highly skewed data it will now use sqrt(n) bins, where previously the reference rule would return "infinite" bins and cause an exception in matplotlib.
    • Added a ceiling (50) to the default number of bins used for distplot histograms. This will help avoid confusing errors with certain kinds of datasets that heavily violate the assumptions of the reference rule used to get a default number of bins. The ceiling is not applied when passing a specific number of bins.
    • The various property dictionaries that can be passed to plt.boxplot are now applied after the seaborn restyling to allow for full customizability.
    • Added a savefig method to JointGrid that defaults to a tight bounding box to make it easier to save figures using this class, and set a tight bbox as the default for the savefig method on other Grid objects.
    • You can now pass an integer to the xticklabels and yticklabels parameter of heatmap (and, by extension, clustermap). This will make the plot use the ticklabels inferred from the data, but only plot every n label, where n is the number you pass. This can help when visualizing larger matrices with some sensible ordering to the rows or columns of the dataframe.
    • Added "figure.facecolor" to the style parameters and set the default to white.
    • The load_dataset function now caches datasets locally after downloading them, and uses the local copy on subsequent calls.

    Bug fixes

    • Fixed bugs in clustermap where the mask and specified ticklabels were not being reorganized using the dendrograms.
    • Fixed a bug in FacetGrid and PairGrid that lead to incorrect legend labels when levels of the hue variable appeared in hue_order but not in the data.
    • Fixed a bug in FacetGrid.set_xticklabels or FacetGrid.set_yticklabels when col_wrap is being used.
    • Fixed a bug in PairGrid where the hue_order parameter was ignored.
    • Fixed two bugs in despine that caused errors when trying to trim the spines on plots that had inverted axes or no ticks.
    • Improved support for the margin_titles option in FacetGrid, which can now be used with a legend.
    Source code(tar.gz)
    Source code(zip)
  • v0.5.1(Nov 22, 2014)

    This is a bugfix release that includes a workaround for an issue in matplotlib 1.4.2 and fixes for two bugs in functions that were new in 0.5.0.

    • Implemented a workaround for a bug in matplotlib 1.4.2 that prevented point markers from being drawn when the seaborn styles had been set. See this github issue for more information.
    • Fixed a bug in heatmap where the mask was vertically reversed relative to the data.
    • Fixed a bug in clustermap when using nested lists of side colors.
    Source code(tar.gz)
    Source code(zip)
  • v0.5.0(Nov 14, 2014)

    This is a major release from 0.4. Highlights include new functions for plotting heatmaps, possibly while applying clustering algorithms to discover structured relationships. These functions are complemented by new custom colormap functions and a full set of IPython widgets that allow interactive selection of colormap parameters. The palette tutorial has been rewritten to cover these new tools and more generally provide guidance on how to use color in visualizations. There are also a number of smaller changes and bugfixes.

    Plotting functions

    • Added the heatmap function for visualizing a matrix of data by color-encoding the values. See the docs for more information.
    • Added the clustermap function for clustering and visualizing a matrix of data, with options to label individual rows and columns by colors. See the docs for more information. This work was lead by Olga Botvinnik.
    • lmplot and pairplot get a new keyword argument, markers. This can be a single kind of marker or a list of different markers for each level of the hue variable. Using different markers for different hues should let plots be more comprehensible when reproduced to black-and-white (i.e. when printed). See the github pull request for examples.
    • More generally, there is a new keyword argument in FacetGrid and PairGrid, hue_kws. This similarly lets plot aesthetics vary across the levels of the hue variable, but more flexibily. hue_kws should be a dictionary that maps the name of keyword arguments to lists of values that are as long as the number of levels of the hue variable.
    • The argument subplot_kws has been added to FacetGrid. This allows for faceted plots with custom projections, including maps with Cartopy.

    Color palettes

    • Added two new functions to create custom color palettes. For sequential palettes, you can use the light_palette function, which takes a seed color and creates a ramp from a very light, desaturated variant of it. For diverging palettes, you can use the diverging_palette function to create a balanced ramp between two endpoints to a light or dark midpoint. See the palette tutorial <palette_tutorial> for more information.
    • Added the ability to specify the seed color for light_palette and dark_palette as a tuple of husl or hls space values or as a named xkcd color. The interpretation of the seed color is now provided by the new input parameter to these functions.
    • Added several new interactive palette widgets: choose_colorbrewer_palette, choose_light_palette, choose_dark_palette, and choose_diverging_palette. For consistency, renamed the cubehelix widget to choose_cubehelix_palette (and fixed a bug where the cubehelix palette was reversed). These functions also now return either a color palette list or a matplotlib colormap when called, and that object will be live-updated as you play with the widget. This should make it easy to iterate over a plot until you find a good representation for the data. See the Github pull request or this notebook (download it to use the widgets) for more information.
    • Overhauled the color palette tutorial to organize the discussion by class of color palette and provide more motivation behind the various choices one might make when choosing colors for their data.

    Bug fixes

    • Fixed a bug in PairGrid that gave incorrect results (or a crash) when the input DataFrame has a non-default index.
    • Fixed a bug in PairGrid where passing columns with a date-like datatype raised an exception.
    • Fixed a bug where lmplot would show a legend when the hue variable was also used on either the rows or columns (making the legend redundant).
    • Worked around a matplotlib bug that was forcing outliers in boxplot to appear as blue.
    • kdeplot now accepts pandas Series for the data and data2 arguments.
    • Using a non-default correlation method in corrplot now implies sig_stars=False as the permutation test used to significance values for the correlations uses a pearson metric.
    • Removed pdf.fonttype from the style definitions, as the value used in version 0.4 resulted in very large PDF files.
    Source code(tar.gz)
    Source code(zip)
  • v0.4.0(Sep 3, 2014)

    This is a major release from 0.3. Highlights include new approaches for quick, high-level dataset exploration (along with a more flexible interface and easy creation of perceptually-appropriate color palettes using the cubehelix system. Along with these additions, there are a number of smaller changes that make visualizing data with seaborn easier and more powerful.

    Plotting functions

    • A new object, PairGrid, and a corresponding function pairplot, for drawing grids of pairwise relationships in a dataset. This style of plot is sometimes called a "scatterplot matrix", but the representation of the data in PairGrid is flexible and many styles other than scatterplots can be used. See the docs for more information. Note: due to a bug in older versions of matplotlib, you will have best results if you use these functions with matplotlib 1.4 or later.
    • The rules for choosing default color palettes when variables are mapped to different colors have been unified (and thus changed in some cases). Now when no specific palette is requested, the current global color palette will be used, unless the number of variables to be mapped exceeds the number of unique colors in the palette, in which case the "husl" palette will be used to avoid cycling.
    • Added a keyword argument hist_norm to distplot. When a distplot is now drawn without a KDE or parametric density, the histogram is drawn as counts instead of a density. This can be overridden by by setting hist_norm to True.
    • When using FacetGrid with a hue variable, the legend is no longer drawn by default when you call Instead, you have to call FacetGrid.add_legend manually. This should make it easier to layer multiple plots onto the grid without having duplicated legends.
    • Made some changes to factorplot so that it behaves better when not all levels of the x variable are represented in each facet.
    • Added the logx option to regplot for fitting the regression in log space.
    • When violinplot encounters a bin with only a single observation, it will now plot a horizontal line at that value instead of erroring out.

    Style and color palettes

    • Added the cubehelix_palette function for generating sequential palettes from the cubehelix system. See the palette docs for more information on how these palettes can be used. There is also the choose_cubehelix which will launch an interactive app to select cubehelix parameters in the notebook.
    • Added the xkcd_palette and the xkcd_rgb dictionary so that colors can be specified with names from the xkcd color survey.
    • Added the font_scale option to plotting_context, set_context, and set. font_scale can independently increase or decrease the size of the font elements in the plot.
    • Font-handling should work better on systems without Arial installed. This is accomplished by adding the font.sans-serif field to the axes_style definition with Arial and Liberation Sans prepended to matplotlib defaults. The font family can also be set through the font keyword argument in set. Due to matplotlib bugs, this might not work as expected on matplotlib 1.3.
    • The despine function gets a new keyword argument offset, which replaces the deprecated offset_spines function. You no longer need to offset the spines before plotting data.
    • Added a default value for pdf.fonttype so that text in PDFs is editable in Adobe Illustrator.

    Other API Changes

    • Removed the deprecated set_color_palette and palette_context functions. These were replaced in version 0.3 by the set_palette function and ability to use color_palette directly in a with statement.
    • Removed the ability to specify a nogrid style, which was renamed to white in 0.3.
    Source code(tar.gz)
    Source code(zip)
  • v0.3.1(Apr 21, 2014)

    This is a minor release from 0.3 with fixes for several bugs.

    Plotting functions

    • The size of the points in pointplot and factorplot is now scaled with the linewidth for better aesthetics across different plotting contexts.
    • The pointplot glyphs for different levels of the hue variable are drawn at different z-orders so that they appear uniform.

    Bug Fixes

    • Fixed a bug in FacetGrid (and thus affecting lmplot and factorplot) that appeared when col_wrap was used with a number of facets that did not evenly divide into the column width.
    • Fixed an issue where the support for kernel density estimates was sometimes computed incorrectly.
    • Fixed a problem where hue variable levels that were not strings were missing in FacetGrid legends.
    • When passing a color palette list in a with statement, the entire palette is now used instead of the first six colors.
    Source code(tar.gz)
    Source code(zip)
Statistical data visualization using matplotlib

seaborn: statistical data visualization Seaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing

Michael Waskom 8.1k Feb 18, 2021
Data visualization using matplotlib

Data visualization using matplotlib project instructions Top 5 Most Common Coffee Origins In this visualization I used data from Ankur Chavda on Kaggl

null 13 Oct 27, 2021
Homework 2: Matplotlib and Data Visualization

Homework 2: Matplotlib and Data Visualization Overview These data visualizations were created for my introductory computer science course using Python

Sophia Huang 12 Oct 20, 2022
Declarative statistical visualization library for Python

Altair Altair is a declarative statistical visualization library for Python. With Altair, you can spend more time understa

Altair 8k Jan 5, 2023
Declarative statistical visualization library for Python

Altair Altair is a declarative statistical visualization library for Python. With Altair, you can spend more time understa

Altair 6.4k Feb 13, 2021
Declarative statistical visualization library for Python

Altair Altair is a declarative statistical visualization library for Python. With Altair, you can spend more time understa

Altair 6.4k Feb 18, 2021
Scientific Visualization: Python + Matplotlib

An open access book on scientific visualization using python and matplotlib

Nicolas P. Rougier 8.6k Dec 31, 2022
This is a super simple visualization toolbox (script) for transformer attention visualization ✌

Trans_attention_vis This is a super simple visualization toolbox (script) for transformer attention visualization ✌ 1. How to prepare your attention m

Mingyu Wang 3 Jul 9, 2022
An open-source plotting library for statistical data.

Lets-Plot Lets-Plot is an open-source plotting library for statistical data. It is implemented using the Kotlin programming language. The design of Le

JetBrains 820 Jan 6, 2023
An open-source plotting library for statistical data.

Lets-Plot Lets-Plot is an open-source plotting library for statistical data. It is implemented using the Kotlin programming language. The design of Le

JetBrains 509 Feb 17, 2021
The windML framework provides an easy-to-use access to wind data sources within the Python world, building upon numpy, scipy, sklearn, and matplotlib. Renewable Wind Energy, Forecasting, Prediction

windml Build status : The importance of wind in smart grids with a large number of renewable energy resources is increasing. With the growing infrastr

Computational Intelligence Group 125 Dec 24, 2022
Apache Superset is a Data Visualization and Data Exploration Platform

Superset A modern, enterprise-ready business intelligence web application. Why Superset? | Supported Databases | Installation and Configuration | Rele

The Apache Software Foundation 50k Jan 6, 2023
Apache Superset is a Data Visualization and Data Exploration Platform

Apache Superset is a Data Visualization and Data Exploration Platform

The Apache Software Foundation 49.9k Jan 2, 2023
Automatic data visualization in atom with the nteract data-explorer

Data Explorer Interactively explore your data directly in atom with hydrogen! The nteract data-explorer provides automatic data visualization, so you

Ben Russert 65 Dec 1, 2022
Data-FX is an addon for Blender (2.9) that allows for the visualization of data with different charts

Data-FX Data-FX is an addon for Blender (2.9) that allows for the visualization of data with different charts Currently, there are only 2 chart option

Landon Ferguson 20 Nov 21, 2022
basemap - Plot on map projections (with coastlines and political boundaries) using matplotlib.

Basemap Plot on map projections (with coastlines and political boundaries) using matplotlib. ⚠️ Warning: this package is being deprecated in favour of

Matplotlib Developers 706 Dec 28, 2022
Wikipedia WordCloud App generate Wikipedia word cloud art created using python's streamlit, matplotlib, wikipedia and wordcloud packages

Wikipedia WordCloud App Wikipedia WordCloud App generate Wikipedia word cloud art created using python's streamlit, matplotlib, wikipedia and wordclou

Siva Prakash 5 Jan 2, 2022
A Python-based non-fungible token (NFT) generator built using Samilla and Matplotlib

PyNFT A Pythonic NF (non-fungible token) generator built using Samilla and Matplotlib Use python [amount] The intention behind this generato

Ayush Gundawar 6 Feb 7, 2022
A simple python script using Numpy and Matplotlib library to plot a Mohr's Circle when given a two-dimensional state of stress.

Mohr's Circle Calculator This is a really small personal project done for Department of Civil Engineering, Delhi Technological University (formerly, D

Agyeya Mishra 0 Jul 17, 2021