一图胜千言，使用Python的matplotlib库，可以快速创建高质量的图形。
我们团队推出一个新的系列教程：Python数据可视化，针对初级和中级用户，将理论和示例代码相结合，分别使用matplotlib, seaborn, plotly等工具实现可视化。
本文主题是如何用Matplotlib创建柱状图。
import numpy as np
import matplotlib.pyplot as plt

%matplotlib inline

plt.style.use("ggplot")

1. 基础柱状图
柱状图(bar chart): 用长方形(柱子)的长度表示数值的统计图表，又称为条形图。柱状图常用来对比两个以上的数值，适用于较小的数据集。
Matplotlib创建柱状图的接口：$bar(x, height, width, bottom, align, color)$

x: 柱子的x轴坐标
height: 柱子高度，y轴坐标
width: 柱子宽度，默认0.8
bottom: 柱子底部的y轴坐标，默认为0
align: 柱子与x轴坐标的对齐方式，默认’center’
color: 柱子颜色
orientation: 柱子方向，‘horizontal’ or ‘vertical’

bar()默认创建垂直柱状图，barh()可创建水平柱状图，原理基本一致。
# 虚拟数据
x = ["A", "B", "C", "D", "E", "F", "G", "H"]
y = [150, 85.2, 65.2, 85, 45, 120, 51, 64]

# 柱状图和散点图不同，散点图的(x,y)均为数值变量
# 柱状图的x轴显示分类变量，有两种处理方式
# 方式1：自己创建x轴坐标，并提供对应的标签
# 方式2：让Matplotlib自动完成映射

# 方式1
# xticks = np.arange(len(x))  # 每根柱子的x轴坐标
# xlabels = x  # 每根柱子的标签
# fig, ax = plt.subplots(figsize=(10, 7))
# ax.bar(x=xticks, height=y, tick_label=xlabels)

# 方式2（推荐）
fig, ax = plt.subplots(figsize=(10, 7))
ax.bar(x=x, height=y)
ax.set_title("Simple Bar Plot", fontsize=15)


2. 调整样式
Matplotlib创建图表的优势在于，用户可以定制每一个细节，接下来调整柱状图的样式，包括改变柱子的宽度，对齐方式和颜色，以及如何把数值添加到图表中。
x = ["A", "B", "C", "D", "E", "F", "G", "H"]
y = [150, 85.2, 65.2, 85, 45, 120, 51, 64]

fig, ax = plt.subplots(figsize=(10, 7))
ax.bar(
    x=x,  # Matplotlib自动将非数值变量转化为x轴坐标
    height=y,  # 柱子高度，y轴坐标
    width=0.6,  # 柱子宽度，默认0.8，两根柱子中心的距离默认为1.0
    align="center",  # 柱子的对齐方式，'center' or 'edge'
    color="grey",  # 柱子颜色
    edgecolor="red",  # 柱子边框的颜色
    linewidth=2.0  # 柱子边框线的大小
)
ax.set_title("Adjust Styles of Bar plot", fontsize=15)

# 一个常见的场景是：每根柱子上方添加数值标签
# 步骤：
# 1. 准备要添加的标签和坐标
# 2. 调用ax.annotate()将文本添加到图表
# 3. 调整样式，例如标签大小，颜色和对齐方式
xticks = ax.get_xticks()
for i in range(len(y)):
    xy = (xticks[i], y[i] * 1.03)
    s = str(y[i])
    ax.annotate(
        s=s,  # 要添加的文本
        xy=xy,  # 将文本添加到哪个位置
        fontsize=12,  # 标签大小
        color="blue",  # 标签颜色
        ha="center",  # 水平对齐
        va="baseline"  # 垂直对齐
    )


3. 堆积柱状图
有时候想在同一根柱子上显示两个不同的数值，即所谓堆积柱状图(stacked bar chart)。
假设一个场景，有6家门店，每家门店都销售三种产品，用堆积柱状图显示每家门店三种产品的销量。
shops = ["A", "B", "C", "D", "E", "F"]
sales_product_1 = [100, 85, 56, 42, 72, 15]
sales_product_2 = [50, 120, 65, 85, 25, 55]
sales_product_3 = [20, 35, 45, 27, 55, 65]

fig, ax = plt.subplots(figsize=(10, 7))
# 先创建一根柱子，显示第一种产品的销量
ax.bar(shops, sales_product_1, color="red", label="Product_1")
# 第二根柱子“堆积”在第一根柱子上方，通过'bottom'调整，显示第二种产品的销量
ax.bar(shops, sales_product_2, color="blue", bottom=sales_product_1, label="Product_2")
# 第三根柱子“堆积”在第二根柱子上方，通过'bottom'调整，显示第三种产品的销量
ax.bar(shops, sales_product_3, color="green", 
       bottom=np.array(sales_product_2) + np.array(sales_product_1), label="Product_3")

ax.set_title("Stacked Bar plot", fontsize=15)
ax.set_xlabel("Shops")
ax.set_ylabel("Product Sales")
ax.legend()


4. 分组柱状图
分组柱状图的原理跟堆积柱状图类似，但柱子不再是堆叠在一起，而是在相同的X轴标签上分成几根更窄的柱子，这些柱子都属于同一个组。
沿用上面的案例。
shops = ["A", "B", "C", "D", "E", "F"]
sales_product_1 = [100, 85, 56, 42, 72, 15]
sales_product_2 = [50, 120, 65, 85, 25, 55]
sales_product_3 = [20, 35, 45, 27, 55, 65]

# 创建分组柱状图，需要自己控制x轴坐标
xticks = np.arange(len(shops))

fig, ax = plt.subplots(figsize=(10, 7))
# 所有门店第一种产品的销量，注意控制柱子的宽度，这里选择0.25
ax.bar(xticks, sales_product_1, width=0.25, label="Product_1", color="red")
# 所有门店第二种产品的销量，通过微调x轴坐标来调整新增柱子的位置
ax.bar(xticks + 0.25, sales_product_2, width=0.25, label="Product_2", color="blue")
# 所有门店第三种产品的销量，继续微调x轴坐标调整新增柱子的位置
ax.bar(xticks + 0.5, sales_product_3, width=0.25, label="Product_3", color="green")

ax.set_title("Grouped Bar plot", fontsize=15)
ax.set_xlabel("Shops")
ax.set_ylabel("Product Sales")
ax.legend()

# 最后调整x轴标签的位置
ax.set_xticks(xticks + 0.25)
ax.set_xticklabels(shops)

如果喜欢我们的文章，记得点赞和收藏哦，我们每天都会为大家带来Python，数据科学和量化交易的精品内容。
【关于我们】
蜂鸟数据：国内领先的金融数据API提供商。
蜂鸟数据团队由业界顶尖的数据工程师，数据科学家和宽客组成，我们正努力构建一个强大的金融数据库，并提供API接口，目标是令金融数据开源化和平民化。
浏览并测试我们接口吧，目前覆盖股票，外汇，商品期货，数字货币和宏观经济领域，包括实时报价(tick)和历史数据(分钟)，提供REST API和Websocket两种接入方式，能够满足金融分析师，量化交易和理财app的需求。
需要金融数据？利用蜂鸟API将数据整合到您的应用
如果您准备好了，请登录蜂鸟官网，注册免费获取API密钥，然后开始探索我们的金融数据库吧。

温度记录示例
演示如何创建一个带负值的柱状图，来形象地显示温度信息。
首先，创建两个柱状图，并添加数据，其中一组代表最低温度，另一组代表最高温度。
low = QBarSet('最低')high = QBarSet('最高')        low <
然后将这两个序列添加到QStackedBarSeries中
 barSeries = QStackedBarSeries() barSeries.append(low) barSeries.append(high)
创建图表对象，并将上面的序列添加到图表中，使用方法setAnimationOptions(QChart.SeriesAnimations)设置序列动画显示。在横坐标上使用QBarCategoryAxis来标志每个月份，纵坐标表示最低最高温度。然后创建图表视图，添加到窗口中显示出来。
代码
完整代码如下:
import sysfrom PyQt5.QtGui import QPainter, QPenfrom PyQt5.QtCore import Qtfrom PyQt5.QtWidgets import QApplication, QMainWindowfrom  PyQt5.QtChart import (QChartView, QChart, QStackedBarSeries, QBarSet,                             QLegend, QBarCategoryAxis, QValueAxis) class DemoStackedBarSeries(QMainWindow):    def __init__(self, parent=None):        super(DemoStackedBarSeries, self).__init__(parent)                    # 设置窗口标题        self.setWindowTitle('实战 Qt for Python: 显示温度')              # 设置窗口大小        self.resize(720, 480)                self.createChart()            def createChart(self):                #创建条状单元        low = QBarSet('最低')        high = QBarSet('最高')                low <
运行结果如下图：
温度显示可视化示例
本文知识点
使用QStackedBarSeries演示温度可视化显示。
请多多关注，评论，收藏，点赞，和转发。
前一篇： 实战PyQt5: 161-QChart图表之散点图交互操作

	

点击上方“Java知音”，选择“置顶公众号”
技术文章第一时间送达！
作者：莫那 鲁道
cnblogs.com/stateis0/p/9062171.html
目录
dubbo 的 Consumer 消费者如何使用 Netty
dubbo 的 Provider 提供者如何使用 Netty
总结
前言
众所周知，国内知名框架 Dubbo 底层使用的是 Netty 作为网络通信，那么内部到底是如何使用的呢？今天我们就来一探究竟。
1. dubbo 的 Consumer 消费者如何使用 Netty
注意：此次代码使用了从 github 上 clone 的 dubbo 源码中的 dubbo-demo 例子。
代码如下：
    System.setProperty("java.net.preferIPv4Stack", "true");
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});
    context.start();
     // @1
    DemoService demoService = (DemoService) context.getBean("demoService"); // get remote service proxy
    int a = 0;
    while (true) {
        try {
            Thread.sleep(1000);
            System.err.println( ++ a + " ");

            String hello = demoService.sayHello("world"); // call remote method
            System.out.println(hello); // get result

        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
当代码执行到 @1 的时候，会调用 Spring 容器的 getBean 方法，而 dubbo 扩展了 FactoryBean，所以，会调用 getObject 方法，该方法会创建代理对象。
这个过程中会调用 DubboProtocol 实例的 getClients(URL url) 方法，当这个给定的 URL 的 client 没有初始化则创建，然后放入缓存，代码如下：
这个 initClient 方法就是创建 Netty 的 client 的。
最终调用的就是抽象父类 AbstractClient 的构造方法，构造方法中包含了创建 Socket 客户端，连接客户端等行为。
public AbstractClient(URL url, ChannelHandler handler) throws RemotingException {
    doOpen();
    connect();
}
doOpent 方法用来创建 Netty 的 bootstrap ：
protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    bootstrap = new ClientBootstrap(channelFactory);
    bootstrap.setOption("keepAlive", true);
    bootstrap.setOption("tcpNoDelay", true);
    bootstrap.setOption("connectTimeoutMillis", getTimeout());
    final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        public ChannelPipeline getPipeline() {
            NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyClient.this);
            ChannelPipeline pipeline = Channels.pipeline();
            pipeline.addLast("decoder", adapter.getDecoder());
            pipeline.addLast("encoder", adapter.getEncoder());
            pipeline.addLast("handler", nettyHandler);
            return pipeline;
        }
    });
}
connect 方法用来连接提供者：
protected void doConnect() throws Throwable {
    long start = System.currentTimeMillis();
    ChannelFuture future = bootstrap.connect(getConnectAddress());
    boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);
    if (ret && future.isSuccess()) {
        Channel newChannel = future.getChannel();
        newChannel.setInterestOps(Channel.OP_READ_WRITE);
    } 
}
上面的代码中，调用了 bootstrap 的 connect 方法，熟悉的 Netty 连接操作。当然这里使用的是 jboss 的 netty3，稍微有点区别。当连接成功后，注册写事件，准备开始向提供者传递数据。
当 main 方法中调用 demoService.sayHello("world") 的时候，最终会调用 HeaderExchangeChannel 的 request 方法，通过 channel 进行请求。
public ResponseFuture request(Object request, int timeout) throws RemotingException {
    Request req = new Request();
    req.setVersion("2.0.0");
    req.setTwoWay(true);
    req.setData(request);
    DefaultFuture future = new DefaultFuture(channel, req, timeout);
    channel.send(req);
    return future;
}
send 方法中最后调用 jboss Netty 中继承了 NioSocketChannel 的 NioClientSocketChannel 的 write 方法。完成了一次数据的传输。
2. dubbo 的 Provider 提供者如何使用 Netty
Provider demo 代码：
System.setProperty("java.net.preferIPv4Stack", "true");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-provider.xml"});
context.start();
System.in.read(); // press any key to exit
Provider 作为被访问方，肯定是一个 Server 模式的 Socket。如何启动的呢？
当 Spring 容器启动的时候，会调用一些扩展类的初始化方法，比如继承了 InitializingBean，ApplicationContextAware，ApplicationListener 。而 dubbo 创建了 ServiceBean 继承了一个监听器。Spring 会调用他的 onApplicationEvent 方法，该类有一个 export 方法，用于打开 ServerSocket 。
然后执行了 DubboProtocol 的 createServer 方法，然后创建了一个 NettyServer 对象。NettyServer 对象的
构造方法同样是 doOpen 方法和。代码如下：
protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
    ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
    ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
    bootstrap = new ServerBootstrap(channelFactory);

    final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
    channels = nettyHandler.getChannels();
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        public ChannelPipeline getPipeline() {
            NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
            ChannelPipeline pipeline = Channels.pipeline();
            pipeline.addLast("decoder", adapter.getDecoder());
            pipeline.addLast("encoder", adapter.getEncoder());
            pipeline.addLast("handler", nettyHandler);
            return pipeline;
        }
    });
    channel = bootstrap.bind(getBindAddress());
}
该方法中，看到了熟悉的 boss 线程，worker 线程，和 ServerBootstrap，在添加了编解码 handler 之后，添加一个 NettyHandler，最后调用 bind 方法，完成绑定端口的工作。和我们使用 Netty 是一摸一样。
3. 总结
可以看到，dubbo 使用 Netty 还是挺简单的，消费者使用 NettyClient，提供者使用 NettyServer，Provider 启动的时候，会开启端口监听，使用我们平时启动 Netty 一样的方式。而 Client 在 Spring getBean 的时候，会创建 Client，当调用远程方法的时候，将数据通过 dubbo 协议编码发送到 NettyServer，然后 NettServer 收到数据后解码，并调用本地方法，并返回数据，完成一次完美的 RPC 调用。
好，关于 dubbo 如何使用 Netty 就简短的介绍到这里。
good luck！！！！
END
Java面试题专栏
【30期】说一下HashMap的实现原理？【29期】Java集合框架 10 连问，你有被问过吗？【28期】ZooKeeper面试那些事儿【27期】Dubbo面试八连问，这些你都能答上来吗？【26期】如何判断一个对象是否存活?(或者GC对象的判定方法)?【25期】这三道常见的面试题，你有被问过吗？【24期】请你谈谈单例模式的优缺点,注意事项,使用场景【23期】请你谈谈关于IO同步、异步、阻塞、非阻塞的区别【22期】为什么需要消息队列？使用消息队列有什么好处？【21期】你能说说Java中Comparable和Comparator的区别吗
我知道你 “在看”

	

前言
本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理。
以下文章来源于Trochil蜂鸟数据，作者：蜂鸟数据Trochil
本文的主题是如何用Matplotlib创建柱状图。
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
plt.style.use("ggplot")
1. 基础柱状图
柱状图(bar chart): 用长方形(柱子)的长度表示数值的统计图表，又称为条形图。柱状图常用来对比两个以上的数值，适用于较小的数据集。
Matplotlib创建柱状图的接口：bar(x, height, width, bottom, align, color)x: 柱子的x轴坐标
height: 柱子高度，y轴坐标
width: 柱子宽度，默认0.8
bottom: 柱子底部的y轴坐标，默认为0
align: 柱子与x轴坐标的对齐方式，默认'center'
color: 柱子颜色
orientation: 柱子方向，'horizontal' or 'vertical'
bar()默认创建垂直柱状图，barh()可创建水平柱状图，原理基本一致。
# 虚拟数据
x = ["A", "B", "C", "D", "E", "F", "G", "H"]
y = [150, 85.2, 65.2, 85, 45, 120, 51, 64]
# 柱状图和散点图不同，散点图的(x,y)均为数值变量
# 柱状图的x轴显示分类变量，有两种处理方式
# 方式1：自己创建x轴坐标，并提供对应的标签
# 方式2：让Matplotlib自动完成映射
# 方式1
# xticks = np.arange(len(x))  # 每根柱子的x轴坐标
# xlabels = x  # 每根柱子的标签
# fig, ax = plt.subplots(figsize=(10, 7))
# ax.bar(x=xticks, height=y, tick_label=xlabels)
# 方式2(推荐)
fig, ax = plt.subplots(figsize=(10, 7))
ax.bar(x=x, height=y)
ax.set_title("Simple Bar Plot", fontsize=15)
2. 调整样式
Matplotlib创建图表的优势在于，用户可以定制每一个细节，接下来调整柱状图的样式，包括改变柱子的宽度，对齐方式和颜色，以及如何把数值添加到图表中。
x = ["A", "B", "C", "D", "E", "F", "G", "H"]
y = [150, 85.2, 65.2, 85, 45, 120, 51, 64]
fig, ax = plt.subplots(figsize=(10, 7))
ax.bar(
x=x,  # Matplotlib自动将非数值变量转化为x轴坐标
height=y,  # 柱子高度，y轴坐标
width=0.6,  # 柱子宽度，默认0.8，两根柱子中心的距离默认为1.0
align="center",  # 柱子的对齐方式，'center' or 'edge'
color="grey",  # 柱子颜色
edgecolor="red",  # 柱子边框的颜色
linewidth=2.0  # 柱子边框线的大小
)
ax.set_title("Adjust Styles of Bar plot", fontsize=15)
# 一个常见的场景是：每根柱子上方添加数值标签
# 步骤：
# 1. 准备要添加的标签和坐标
# 2. 调用ax.annotate()将文本添加到图表
# 3. 调整样式，例如标签大小，颜色和对齐方式
xticks = ax.get_xticks()
for i in range(len(y)):
xy = (xticks[i], y[i] * 1.03)
s = str(y[i])
ax.annotate(
s=s,  # 要添加的文本
xy=xy,  # 将文本添加到哪个位置
fontsize=12,  # 标签大小
color="blue",  # 标签颜色
ha="center",  # 水平对齐
va="baseline"  # 垂直对齐
)
3. 堆积柱状图
有时候想在同一根柱子上显示两个不同的数值，即所谓堆积柱状图(stacked bar chart)。
假设一个场景，有6家门店，每家门店都销售三种产品，用堆积柱状图显示每家门店三种产品的销量。
shops = ["A", "B", "C", "D", "E", "F"]
sales_product_1 = [100, 85, 56, 42, 72, 15]
sales_product_2 = [50, 120, 65, 85, 25, 55]
sales_product_3 = [20, 35, 45, 27, 55, 65]
fig, ax = plt.subplots(figsize=(10, 7))
# 先创建一根柱子，显示第一种产品的销量
ax.bar(shops, sales_product_1, color="red", label="Product_1")
# 第二根柱子“堆积”在第一根柱子上方，通过'bottom'调整，显示第二种产品的销量
ax.bar(shops, sales_product_2, color="blue", bottom=sales_product_1, label="Product_2")
# 第三根柱子“堆积”在第二根柱子上方，通过'bottom'调整，显示第三种产品的销量
ax.bar(shops, sales_product_3, color="green",
bottom=np.array(sales_product_2) + np.array(sales_product_1), label="Product_3")
ax.set_title("Stacked Bar plot", fontsize=15)
ax.set_xlabel("Shops")
ax.set_ylabel("Product Sales")
ax.legend()
4. 分组柱状图
分组柱状图的原理跟堆积柱状图类似，但柱子不再是堆叠在一起，而是在相同的X轴标签上分成几根更窄的柱子，这些柱子都属于同一个组。
沿用上面的案例。
shops = ["A", "B", "C", "D", "E", "F"]
sales_product_1 = [100, 85, 56, 42, 72, 15]
sales_product_2 = [50, 120, 65, 85, 25, 55]
sales_product_3 = [20, 35, 45, 27, 55, 65]
# 创建分组柱状图，需要自己控制x轴坐标
xticks = np.arange(len(shops))
fig, ax = plt.subplots(figsize=(10, 7))
# 所有门店第一种产品的销量，注意控制柱子的宽度，这里选择0.25
ax.bar(xticks, sales_product_1, width=0.25, label="Product_1", color="red")
# 所有门店第二种产品的销量，通过微调x轴坐标来调整新增柱子的位置
ax.bar(xticks + 0.25, sales_product_2, width=0.25, label="Product_2", color="blue")
# 所有门店第三种产品的销量，继续微调x轴坐标调整新增柱子的位置
ax.bar(xticks + 0.5, sales_product_3, width=0.25, label="Product_3", color="green")
ax.set_title("Grouped Bar plot", fontsize=15)
ax.set_xlabel("Shops")
ax.set_ylabel("Product Sales")
ax.legend()
# 最后调整x轴标签的位置
ax.set_xticks(xticks + 0.25)
ax.set_xticklabels(shops)