成功解决TypeError: distplot() got an unexpected keyword argument ‘y‘

成功解决TypeError: distplot() got an unexpected keyword argument 'y'

目录

解决问题

解决思路

解决方法

解决问题

TypeError: distplot() got an unexpected keyword argument 'y'

解决思路

类型错误:distplot()得到了一个意外的关键字参数'y'

解决方法

fg=sns.JointGrid(x=cols[0],y=cols[1],data=data_frame,)
fg.plot_marginals(sns.distplot)

distplot()函数中，只接受一个输入数据，即有x，没有y

def distplot Found at: seaborn.distributions
 
def distplot(a=None, bins=None, hist=True, kde=True, rug=False, fit=None, 
    hist_kws=None, kde_kws=None, rug_kws=None, fit_kws=None, 
    color=None, vertical=False, norm_hist=False, axlabel=None, 
    label=None, ax=None, x=None):
    """DEPRECATED: Flexibly plot a univariate distribution of observations.
    
    .. warning::
    This function is deprecated and will be removed in a future version.
    Please adapt your code to use one of two new functions:
    
    - :func:`displot`, a figure-level function with a similar flexibility
    over the kind of plot to draw
    - :func:`histplot`, an axes-level function for plotting histograms,
    including with kernel density smoothing
    
    This function combines the matplotlib ``hist`` function (with automatic
    calculation of a good default bin size) with the seaborn :func:`kdeplot`
    and :func:`rugplot` functions. It can also fit ``scipy.stats``
    distributions and plot the estimated PDF over the data.
    
    Parameters
    ----------
    a : Series, 1d-array, or list.
    Observed data. If this is a Series object with a ``name`` attribute,
    the name will be used to label the data axis.
    bins : argument for matplotlib hist(), or None, optional
    Specification of hist bins. If unspecified, as reference rule is used
    that tries to find a useful default.
    hist : bool, optional
    Whether to plot a (normed) histogram.
    kde : bool, optional
    Whether to plot a gaussian kernel density estimate.
    rug : bool, optional
    Whether to draw a rugplot on the support axis.
    fit : random variable object, optional
    An object with `fit` method, returning a tuple that can be passed to a
    `pdf` method a positional arguments following a grid of values to
    evaluate the pdf on.
    hist_kws : dict, optional
    Keyword arguments for :meth:`matplotlib.axes.Axes.hist`.
    kde_kws : dict, optional
    Keyword arguments for :func:`kdeplot`.
    rug_kws : dict, optional
    Keyword arguments for :func:`rugplot`.
    color : matplotlib color, optional
    Color to plot everything but the fitted curve in.
    vertical : bool, optional
    If True, observed values are on y-axis.
    norm_hist : bool, optional
    If True, the histogram height shows a density rather than a count.
    This is implied if a KDE or fitted density is plotted.
    axlabel : string, False, or None, optional
    Name for the support axis label. If None, will try to get it
    from a.name if False, do not set a label.
    label : string, optional
    Legend label for the relevant component of the plot.
    ax : matplotlib axis, optional
    If provided, plot on this axis.
    
    Returns
    -------
    ax : matplotlib Axes
    Returns the Axes object with the plot for further tweaking.
    
    See Also
    --------
    kdeplot : Show a univariate or bivariate distribution with a kernel
    density estimate.
    rugplot : Draw small vertical lines to show each observation in a
    distribution.
    
    Examples
    --------
    
    Show a default plot with a kernel density estimate and histogram with bin
    size determined automatically with a reference rule:
    
    .. plot::
    :context: close-figs
    
    >>> import seaborn as sns, numpy as np
    >>> sns.set_theme(); np.random.seed(0)
    >>> x = np.random.randn(100)
    >>> ax = sns.distplot(x)
    
    Use Pandas objects to get an informative axis label:
    
    .. plot::
    :context: close-figs
    
    >>> import pandas as pd
    >>> x = pd.Series(x, name="x variable")
    >>> ax = sns.distplot(x)
    
    Plot the distribution with a kernel density estimate and rug plot:
    
    .. plot::
    :context: close-figs
    
    >>> ax = sns.distplot(x, rug=True, hist=False)
    
    Plot the distribution with a histogram and maximum likelihood gaussian
    distribution fit:
    
    .. plot::
    :context: close-figs
    
    >>> from scipy.stats import norm
    >>> ax = sns.distplot(x, fit=norm, kde=False)
    
    Plot the distribution on the vertical axis:
    
    .. plot::
    :context: close-figs
    
    >>> ax = sns.distplot(x, vertical=True)
    
    Change the color of all the plot elements:
    
    .. plot::
    :context: close-figs
    
    >>> sns.set_color_codes()
    >>> ax = sns.distplot(x, color="y")
    
    Pass specific parameters to the underlying plot functions:
    
    .. plot::
    :context: close-figs
    
    >>> ax = sns.distplot(x, rug=True, rug_kws={"color": "g"},
    ...                   kde_kws={"color": "k", "lw": 3, "label": "KDE"},
    ...                   hist_kws={"histtype": "step", "linewidth": 3,
    ...                             "alpha": 1, "color": "g"})
    
    """
    if kde and not hist:
        axes_level_suggestion = "`kdeplot` (an axes-level function for kernel 
         density plots)."
    else:
        axes_level_suggestion = "`histplot` (an axes-level function for 
         histograms)."
    msg = "`distplot` is a deprecated function and will be removed in a future 
     version. "\
    "Please adapt your code to use either `displot` (a figure-level function 
     with "\
    "similar flexibility) or " + axes_level_suggestion
    warnings.warn(msg, FutureWarning)
    if ax is None:
        ax = plt.gca()
     Intelligently label the support axis
    label_ax = bool(axlabel)
    if axlabel is None and hasattr(a, "name"):
        axlabel = a.name
        if axlabel is not None:
            label_ax = True
     Support new-style API
    if x is not None:
        a = x
     Make a a 1-d float array
    a = np.asarray(a, float)
    if a.ndim > 1:
        a = a.squeeze()
     Drop null values from array
    a = remove_na(a)
     Decide if the hist is normed
    norm_hist = norm_hist or kde or fit is not None
     Handle dictionary defaults
    hist_kws = {} if hist_kws is None else hist_kws.copy()
    kde_kws = {} if kde_kws is None else kde_kws.copy()
    rug_kws = {} if rug_kws is None else rug_kws.copy()
    fit_kws = {} if fit_kws is None else fit_kws.copy()
     Get the color from the current color cycle
    if color is None:
        if vertical:
            line, = ax.plot(0, a.mean())
        else:
            line, = ax.plot(a.mean(), 0)
        color = line.get_color()
        line.remove()
     Plug the label into the right kwarg dictionary
    if label is not None:
        if hist:
            hist_kws["label"] = label
        elif kde:
            kde_kws["label"] = label
        elif rug:
            rug_kws["label"] = label
        elif fit:
            fit_kws["label"] = label
    if hist:
        if bins is None:
            bins = min(_freedman_diaconis_bins(a), 50)
        hist_kws.setdefault("alpha", 0.4)
        hist_kws.setdefault("density", norm_hist)
        orientation = "horizontal" if vertical else "vertical"
        hist_color = hist_kws.pop("color", color)
        ax.hist(a, bins, orientation=orientation, color=hist_color, **hist_kws)
        if hist_color != color:
            hist_kws["color"] = hist_color
    if kde:
        kde_color = kde_kws.pop("color", color)
        kdeplot(a, vertical=vertical, ax=ax, color=kde_color, **kde_kws)
        if kde_color != color:
            kde_kws["color"] = kde_color
    if rug:
        rug_color = rug_kws.pop("color", color)
        axis = "y" if vertical else "x"
        rugplot(a, axis=axis, ax=ax, color=rug_color, **rug_kws)
        if rug_color != color:
            rug_kws["color"] = rug_color
    if fit is not None:
        def pdf(x):
            return fit.pdf(x, *params)
        
        fit_color = fit_kws.pop("color", "282828")
        gridsize = fit_kws.pop("gridsize", 200)
        cut = fit_kws.pop("cut", 3)
        clip = fit_kws.pop("clip", (-np.inf, np.inf))
        bw = stats.gaussian_kde(a).scotts_factor() * a.std(ddof=1)
        x = _kde_support(a, bw, gridsize, cut, clip)
        params = fit.fit(a)
        y = pdf(x)
        if vertical:
            x, y = y, x
        ax.plot(x, y, color=fit_color, **fit_kws)
        if fit_color != "282828":
            fit_kws["color"] = fit_color
    if label_ax:
        if vertical:
            ax.set_ylabel(axlabel)
        else:
            ax.set_xlabel(axlabel)
    return ax