Python数据之道

Manim社区版教程-02-文本使用介绍

Wed, 02 Mar 2022 00:00:00 +0000

Manim社区版教程-02-文本使用介绍

Table of Contents

视频制作工具Manim入门，文本使用详细介绍

视频制作工具Manim入门，文本使用详细介绍

1 写在前面

大家好，我是阳哥。

最近一段时间，我在微信视频号「价值前瞻」和「Python数据之道」发布了一些视频，有不少同学问到这些视频是怎么做的，用什么工具制作的。

在文章用 python 制作高逼格的数学动画中，我跟大家介绍了 Manim 这个视频制作工具，以及以及案例演示。

不少同学觉得这个工具不错，问到有没有完整的使用教程或者相关书籍。据我所知，目前应该是没有专门的书籍来介绍这个工具的。至于教程，不同版本的Manim有一部分文档，其中 Manim社区版的文档相对而言要完善些。

我将基于 Manim社区版(Manim Community)给大家分享Manim入门的内容，当前已有的教程包括：

01-基础形状

说明：Manim 社区版，经常缩写为 manimce，英文全称是 Manim Community Edition

本次介绍 Manim 中 文本 的使用，使用的版本为 Manim Community v0.14.0，本文内容主要如下：

2 Manim的安装与运行

安装

如何安装社区版Manim，参见下面的官方链接：

https://docs.manim.community/en/stable/installation.html

如何运行 Manim

用 Manim 绘制图形，首先需要引入 Manim 库，然后将需要绘制的内容封装到一个类(class) 里面。

社区版的导入代码如下：

from manim import *

对于编辑好的程序文件（ XXXX.py 文件），需要在同一个文件夹下运行命令来运行程序，命令格式如下：

manim -pql XXXX.py DemoSquare

上面的命令行中：

manim 是社区版Manim运行程序的主要标志用语；
p 表示程序运行后会进行预览（图片或视频）；
ql 表示低质量（quality low）, 其他的选项有 -ql, -qm, -qh, -qk, 分别表示低质量、正常质量、高质量、4K质量；
XXXX.py 是py代码文件；
DemoSquare 是 py代码文件中的一个类；

演示过程录屏如下：

命令行中，还有其他许多参数可以设置，可以通过社区版的支持文档来进一步了解：

https://docs.manim.community/en/stable/tutorials/configuration.html#command-line-arguments

3 文本使用介绍

在 Manim社区版中，文本的使用可以分为几个大类，分别是：

纯文本
标记文本
LaTex 文本
代码文本

3.1 纯文本

纯文本是最常见的一类文字，在视频中使用的标题、正文等，都可以使用纯文本，在Manim 中，纯文本可以通过 Text() 对象来实现。

比如要输出文字 “Python数据之道”，核心代码如下：

Text("Python数据之道")

效果如下：

设置文本大小

对于文本而言，设置文本在屏幕中显示的大小，是经常要做的一个事情，Text() 对象可以通过多种方法来实现：

设置 scale 属性值；
设置 set_width 属性值；
设置 font_size 参数值；

# 设置文本大小
class Demo2(Scene):
    def construct(self):
        WaterMark.construct(self)
        s = "Python数据之道"
        t1 = Text(s)
        t1.to_edge(UP,buff=0.5)
        t2 = Text(s).scale(2)
        t2.next_to(t1,DOWN)
        t3 = Text(s).set_width(10)
        t3.next_to(t2,DOWN)
        t4 = Text(s,font_size=40)
        t4.next_to(t3,DOWN)       
        self.add(t1)
        self.play(Write(t2))
        self.play(Create(t3))
        self.play(Write(t4))
        self.wait()

上述代码的实现效果如下：

设置文本颜色

文本颜色设置包括指定某种颜色以及渐变颜色设置，通常情况下，颜色通过 color 参数来设置，渐变颜色通过 gradient 参数来设置。

演示案例的代码如下：

# 设置文本颜色
class Demo3(Scene):
    def construct(self):
        WaterMark.construct(self)
        s = "Python数据之道"
        t1 = Text(s,color=BLUE)
        t1.to_edge(UP,buff=2)
        t2 = Text("一份价值，一份收获",gradient=[BLUE,YELLOW,RED]).next_to(t1,DOWN)
        t3 = Text("Hello World",gradient=[BLUE,YELLOW,RED]).next_to(t2,DOWN)
        t4 = Text("@Python数据之道",gradient=[BLUE,YELLOW,RED],font_size=30,fill_opacity=0.8)
        t4.next_to(t3,DOWN)
        t5 = Text("Python数据之道",gradient=[BLUE,YELLOW,RED]).next_to(t4,DOWN)
        # 当英文和汉字混合时， 当前的manim社区版，使用 gradient 时会出现 bug
        self.add(t1)
        self.play(Write(t2))
        self.play(Create(t3))
        self.play(Write(t4))
        self.play(Write(t5))
        self.wait()

上述代码的实现效果如下：

需要注意的是，当英文和汉字混合时，当前的manim社区版，使用 gradient 时可能会出现 bug，没有渐变的效果，上述案例中的变量 t5 实例就没有实现渐变效果。

设置文本样式

文本样式的设置，包括文本加粗、斜体文本、文本字体设置、文本透明度设置、文本换行以及行距设置等。

演示案例的代码如下：

# 设置字体样式
class Demo4(Scene):
    def construct(self):
        WaterMark.construct(self)
        t1 = Text("Python数据之道",font="Alibaba PuHuiTi")
        t1.to_edge(UP,buff=0.5)
        t2 = Text("Python数据之道",color=BLUE,font="Times")
        t2.next_to(t1,DOWN)
        t3 = Text("Python数据之道", weight=BOLD)
        t3.next_to(t2,DOWN)
        t4 = Text("Python数据之道", slant=ITALIC)
        t4.next_to(t3,DOWN)
        t5 = Text("Python数据之道", fill_opacity=0.5)
        t5.next_to(t4,DOWN)
        t6 = Text("Hello\nPython", line_spacing=0.5)
        t6.next_to(t5,DOWN,buff=1).shift(LEFT)
        t7 = Text("Hello\nPython", line_spacing=2)
        t7.next_to(t6,RIGHT,buff=1)
        self.add(t1)
        self.play(Write(t2))
        self.play(Write(t3))
        self.play(Write(t4))
        self.play(Write(t5))
        self.add(t6,t7)
        self.wait()

上述代码的实现效果如下：

需要主要的是，在选择字体设置时，所选择的字体需要在自己的电脑中已经安装了对应的字体，才会有效果。

此外，在对于非英文字体的设置时，可能有些样式设置会不起作用，具体的需要自己去根据实际情况测试下。

对于咱们而言，一般就是英文和中文的使用，常用的字体加粗、斜体文字、透明度等，是有效的。对于字体，我一般是使用 “Alibaba PuHuiTi” 字体，这个字体可以免费使用。

个性化设置部分文本

在控制显示过程中，经常会遇到只需要显示一段文本中一部分文本的情况，可以通过以下几个参数来进行设置：

t2c，全称为 “text2color”，用来设置部分文字的颜色；
t2f，全称为 “text2font”，用来设置部分文字的字体；
t2w，全称为 “text2weight”，用来设置部分文字加粗；
t2s，全称为 “text2slant”，用来设置部分文字为斜体；
t2g，全称为 “text2gradient”，用来设置部分文字的渐变颜色；

演示案例的代码如下：

# 个性化设置部分文本的样式
class Demo5(Scene):
    def construct(self):
        WaterMark.construct(self)
        t1 = Text("Python数据之道",t2c={"Python":RED,'[7:9]':YELLOW})
        t1.to_edge(UP,buff=0.5)
        t2 = Text("Python数据之道",t2s={"Python":ITALIC})
        t2.next_to(t1,DOWN)
        t3 = Text("Python数据之道", t2w={"Python":BOLD})
        t3.next_to(t2,DOWN)
        t4 = Text("Python数据之道", t2f={"Python":"Times"})
        t4.next_to(t3,DOWN)
        t5 = Text(
            "Hello,PyDataLab", 
            t2g={
                'PyData':[BLUE,YELLOW,RED],
                # 'offset':"1",
            },
            )
        t5.next_to(t4,DOWN)
        t6 = Text(
            "Hello,Python数据之道", 
            t2g={
                'Python':[BLUE,YELLOW,RED],
            },
            )
        t6.next_to(t5,DOWN)
        t7 = Text(
            "一份价值，一份收获", 
            t2g={
                '一份价值':[BLUE,YELLOW,RED],
            },
            )
        t7.next_to(t6,DOWN)
        # "t2c"、"t2s"、"t2w"、"t2g"、"t2f" 参数设置，可以直接是 字符串，或者是 字符串的位置切片
        self.add(t1)
        self.play(Write(t2))
        self.play(Write(t3))
        self.play(Write(t4))
        self.play(Write(t5))
        self.play(Write(t6))
        self.play(Write(t7))
        self.wait()

上述代码的实现效果如下：

通过上面的代码可以看出，”t2c”、”t2s”、”t2w”、”t2g”、”t2f” 参数设置，可以直接是字符串，或者是字符串的位置切片。

需要注意的是，当英文和汉字混合或者全部是中文时，当前的manim社区版，使用 t2g 对部分文字进行渐变设置时可能会出现 bug，会出现部分文字渐变效果不完整，或者全部文字都有渐变效果。

纯文本应用案例

下面咱们来看一个用纯文本实现 “Google” 彩色 logo 的案例，如下：

class Demo6(Scene):
    def construct(self):
        WaterMark.construct(self)
        text1 = Text(
            'Google',
            t2c={'[:1]': '#3174f0', '[1:2]': '#e53125',
                 '[2:3]': '#fbb003', '[3:4]': '#3174f0',
                 '[4:5]': '#269a43', '[5:]': '#e53125'}, font_size=58).scale(3)
        self.play(Write(text1),run_time=3)
        self.wait()
        self.play(FadeOut(text1))
        t2 = Text('Google',font_size=120)
        colors = [BLUE, ORANGE, PURPLE, PINK, TEAL,DARK_BROWN, RED,LIGHT_BROWN,GOLD,BLUE_L_C,ORANGE_L_A,PURPLE_E]*10
        # for i in range(len(t2)):
        #     t2[i].set_color(colors[i])
        for letter in t2:
            letter.set_color(np.random.choice(colors,size=1))
        self.play(Write(t2),run_time=3)
        self.wait()

上述代码的实现效果如下：

3.2 标记文本

Manim社区版使用 Pango 来渲染非 LaTex 文本。

Pango标记语言是一种类似 html 的标记语言，可以使用一系列的标记符号。

PangoMarkup is a small markup language like html and it helps you avoid using “range of characters” while coloring or styling a piece a Text. You can use this language with MarkupText.

标记文本的基础应用

一个简单的应用案例如下：

class Markup01(Scene):
    def construct(self):
        WaterMark.construct(self)
        t1 = MarkupText('<span foreground="yellow" size="x-large">Hello, </span> <i>Welcome to </i>ValueLab !"')
        t1.to_edge(UP,buff=2)
        self.add(t1)
        self.wait()

        t2 = MarkupText('<span foreground="yellow" size="x-large">一份价值，</span> 一份 <i>收获</i>!"')
        t2.next_to(t1,DOWN,buff=1)
        self.add(t2)
        self.wait()

上述代码的实现效果如下：

可以看到，对于 Markup 标记语言，在应用于英文文字的时候，应用效果是挺好的，但对于中文字体，上面的文字中，斜体效果就没有体现出来。不知道是 Pango本身渲染的问题还是 Manim社区版存在一些瑕疵。

当前，Manim中进行文字渲染，支持以下标签：

标记文本的样式设置

标记文本的样式设置包括文字加粗、下划线、斜体、上标、下表、删除线等，演示案例的代码如下：

# 样式设置，加粗、下划线、斜体等
class Markup02(Scene):
    def construct(self):
        WaterMark.construct(self)
        text1 = MarkupText("<b>Hello</b> <i>welcome to</i> <b><i>ValueLab</i></b>")
        text2 = MarkupText("<s>foo</s> <u>bar</u> <big>big</big> <small>small</small>")
        text3 = MarkupText("H<sub>2</sub>O and H<sub>3</sub>O<sup>+</sup>")
        text4 = MarkupText("type <tt>help</tt> for help")
        text5 = MarkupText(
            '<span underline="double">foo</span> <span underline="error">bar</span>'
        )
        group = VGroup(text1, text2, text3, text4, text5).arrange(DOWN)
        self.add(group)

上述代码的实现效果如下：

标记文本的颜色设置

标记文本的颜色设置，主要是渐变色的设置比较复杂，仔细看下面案例中渐变色设置时的各个参数：

# 颜色设置，设置不同的颜色、渐变色等
class Markup03(Scene):
    def construct(self):
        text1 = MarkupText(
            f'all in red <span fgcolor="{YELLOW}">except this</span>', color=RED
        )
        text2 = MarkupText("nice gradient", gradient=(BLUE, GREEN))
        text3 = MarkupText(
            'nice <gradient from="RED" to="YELLOW">intermediate</gradient> gradient',
            gradient=(BLUE, GREEN),
        )
        text4 = MarkupText(
            'fl ligature <gradient from="RED" to="YELLOW">causing trouble</gradient> here'
        )
        text5 = MarkupText(
            'fl ligature <gradient from="RED" to="YELLOW" offset="1">defeated</gradient> with offset'
        )
        text6 = MarkupText(
            'fl ligature <gradient from="RED" to="YELLOW" offset="1">floating</gradient> inside'
        )
        text7 = MarkupText(
            'fl ligature <gradient from="RED" to="YELLOW" offset="1,1">floating</gradient> inside'
        )
        group = VGroup(text1, text2, text3, text4, text5, text6, text7).arrange(DOWN)
        self.add(group)

上述代码的实现效果如下：

文字对齐

在书写英文文字时，为了排版效果好看，经常需要将文字进行对齐显示，这个在 Manim中，也可以实现。

演示案例的代码如下：

# 文字对齐
class Markup05(Scene):
    def construct(self):
        WaterMark.construct(self)
        ipsum_text = (
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
            "Praesent feugiat metus sit amet iaculis pulvinar. Nulla posuere "
            "quam a ex aliquam, eleifend consectetur tellus viverra. Aliquam "
            "fermentum interdum justo, nec rutrum elit pretium ac. Nam quis "
            "leo pulvinar, dignissim est at, venenatis nisi. Quisque mattis "
            "dolor ut euismod hendrerit. Nullam eu ante sollicitudin, commodo "
            "risus a, vehicula odio. Nam urna tortor, aliquam a nibh eu, commodo "
            "imperdiet arcu. Donec tincidunt commodo enim a tincidunt."
        )
        justified_text = MarkupText(ipsum_text, justify=True).scale(0.4)
        not_justified_text = MarkupText(ipsum_text, justify=False).scale(0.4)
        just_title = Title("Justified")
        njust_title = Title("Not Justified")
        self.add(njust_title, not_justified_text)
        self.play(
            Transform(
                not_justified_text,
                justified_text,
            ),
            Transform(
                njust_title,
                just_title,
            ),
            run_time=2,
        )
        self.wait(1)

上述代码的实现效果如下：

3.3 LaTex 文本

LaTeX（LATEX，音译“拉泰赫”）是一种基于ΤΕΧ的排版系统，由美国计算机学家莱斯利·兰伯特（Leslie Lamport）在20世纪80年代初期开发，利用这种格式，即使使用者没有排版和程序设计的知识也可以充分发挥由TeX所提供的强大功能，能在几天、甚至几小时内生成很多具有书籍质量的印刷品。

对于生成复杂表格和数学公式，这一点表现得尤为突出。因此它非常适用于生成高印刷质量的科技和数学类文档。这个系统同样适用于生成从简单的信件到完整书籍的所有其他种类的文档。

在 Manim 中使用 latex 文本，需要你的电脑环境中已经安装了 latex的相关软件和支持工具。

在 Manim 中，可以通过以下几种方法来使用 latex 文本，如下：

Tex
MathTex
Title
BulletedList

文本型的 LaTex 可以通过 Tex、Title、BulletedList 来实现，数学公式类型的文本，可以通过 Tex 或 MathTex 来实现。

基础应用

先来看一个 latex 的基础应用案例，如下：

class DemoTex01(Scene):
    def construct(self):
        WaterMark.construct(self)
        tex1 = Tex(r"\LaTeX", font_size=144)
        tex1.to_edge(UP,buff=1)
        self.add(tex1)
        self.wait()

        tex2 = Tex(r'$x^2 + y^2 = z^2$', font_size=144)
        tex2.next_to(tex1,DOWN,buff=0.5)
        tex3 = MathTex(r'x^2 + y^2 = z^2', font_size=144,color=BLUE)
        tex3.next_to(tex2,DOWN,buff=0.5)
        self.add(tex2)
        self.wait()
        self.add(tex3)
        self.wait()

上述代码的实现效果如下：

在 Tex 或 MathTex 中使用字符串时，一般会使用 r"..." 的形式，而不是 '...' 的形式，这是因为在 latex文本中，经常会涉及到一些特殊的字符，比如 \ 。

在进行数学公式的表达时，使用 Tex 时需要在字符串前后添加符号 $，形式为 r"$...$"，使用 MathTex 时，形式为 r"..." 就可以了。两者之间的区别，需要注意下。

使用 latex 工具包

在 latex 中输出特殊符号时，可以通过 latex 工具包来实现。

当然，需要你的电脑中已经安装了对应的 latex 工具包。对于没有使用过 latex 的同学来说，这个确实会有些繁琐。

演示案例的代码如下：

# 使用 latex 工具包
class DemoTex02(Scene):
    def construct(self):
        WaterMark.construct(self)
        myTemplate = TexTemplate()
        myTemplate.add_to_preamble(r"\usepackage{mathrsfs}")
        tex = Tex(r'$\mathscr{H} \rightarrow \mathbb{H}$}', tex_template=myTemplate, font_size=144)
        self.add(tex)

上述代码的实现效果如下：

数学公式的颜色设置

在 Manim 中，对于数学公式中字符的颜色设置，可以通过参数 set_color_by_tex 和 substrings_to_isolate 的组合来实现不同的效果。

演示案例的代码如下：

# 数学公式的颜色设置
class DemoTex03(Scene):
    def construct(self):
        WaterMark.construct(self)
        eq1 = MathTex(
            r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots"
        )
        eq1.scale(1.2)
        eq1.set_color_by_tex("x", YELLOW)
        eq1.to_edge(UP,buff=2)
        self.add(eq1)
        self.wait()
        # self.play(FadeOut(eq1))

        eq2 = MathTex(
            r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots",
            substrings_to_isolate="x",
        )
        eq2.scale(1.2)
        eq2.set_color_by_tex("x", RED)
        eq2.next_to(eq1,DOWN,buff=1)
        self.add(eq2)
        self.wait()

上述代码的实现效果如下：

在 eq1 中，仅设置参数 set_color_by_tex 时，是对于包含 “x” 的整个公式进行颜色设置；而在 eq2 中，同时设置参数 set_color_by_tex 和 substrings_to_isolate 时，仅仅对公式中的 “x” 字符进行颜色设置；这两种是不一样的应用场景，大家选择合适的去使用。

我在微信视频号「价值前瞻」中发布的视频 “复利效应” 中就使用到类似的案例。

该视频中涉及数学公式的部分代码如下：

class DemoTex04(Scene):
    def construct(self):
        WaterMark.construct(self)
        equations = VGroup(
            MathTex(
                r"1.01^{365} = 37.8",
                # size=80,
            ),
            MathTex(
                r"1.00^{365} = 1.00",
                # size=80,
            ),
            MathTex(
                r"0.99^{365} = 0.03",
                # size=80,
            ),
        )

        # 设置宽度
        # equations.set_width(FRAME_WIDTH-4)
        equations.set_width(8)

        for equation in equations:
            equation.set_color_by_tex_to_color_map({
                "1.01": BLUE,
                "0.99": RED,
            })

        equations.arrange(DOWN, buff=0.7, aligned_edge=LEFT)
        self.play(Write(equations[0]))
        self.wait()

        self.play(Write(equations[2]))
        self.wait()

        self.play(Write(equations[1]))
        self.wait()

        self.play(equations[1].animate.set_opacity(0.2))
        self.wait()

上述代码的实现效果如下：

tex 模板应用

在 LaTex 中，可以通过设置使用的模板，来设置使用的字体。此外，在使用中文字符时，经常需要设置中文的模板（一般使用 ctex）。

演示案例的代码如下：

# tex 模板应用
class DemoTex05(Scene):
    def construct(self):
        WaterMark.construct(self)
        tex1 = Tex(r'$x^2 + y^2 = z^2$', tex_template=TexFontTemplates.french_cursive, font_size=144)
        tex1.to_edge(UP,buff=1)
        self.add(tex1)
        self.wait()

        tex2 = Tex(r'Hello 你好 \LaTeX', tex_template=TexTemplateLibrary.ctex, font_size=144)
        tex2.next_to(tex1,DOWN,buff=0.5)
        self.add(tex2)
        self.wait()

上述代码的实现效果如下：

对于 TexFontTemplates，可以使用的模板说明如下：

A collection of TeX templates for the fonts described at http://jf.burnol.free.fr/showcase.html

公式换行

在数学公式中，可以实现换行效果，如下：

# 公式换行
class DemoTex06(Scene):
    def construct(self):
        WaterMark.construct(self)
        tex1 = MathTex(
            r'f(x) &= 3 + 2 + 1\\ &= 5 + 1 \\ &= 6', 
            font_size=96,
        )
        self.add(tex1)
        self.wait()
        self.play(FadeOut(tex1))

        tex2 = MathTex(
            r'f(x) &= 3 + 2 + 1\\ &= 5 + 1 \\ &= 6', 
            font_size=96,
            substrings_to_isolate=['5','3'],
        )
        tex2.set_color_by_tex_to_color_map({
                "5": BLUE,
                "3": RED,
            })
        self.add(tex2)
        self.wait()

上述代码的实现效果如下：

Title 对象应用

在视频中设置文字标题时，可以直接使用 Title 对象，需要说明的是，Title 对象是基于 Tex 来实现的，在涉及中文输出时，需要设置使用的模板为中文适用的模板。

演示案例的代码如下：

# Title 对象应用
class DemoTex07(Scene):
    def construct(self):
        WaterMark.construct(self)
        title1 = Title("Hello,title")
        self.add(title1)
        self.wait()
        self.play(FadeOut(title1))

        # 使用 “Title” 对象，当有中文时，需要设置中文字体模板（电脑中需要安装了 ctex）
        title2 = Title("你好,title",tex_template=TexTemplateLibrary.ctex)
        self.add(title2)
        self.wait()

上述代码的实现效果如下：

列表类型的文本

在文本的使用过程中，会时不时涉及到列表型文本，目前，在 Manim 中，可以直接实现无序号型的列表文本，通过 BulletedList 对象来实现。

演示案例的代码如下：

# 列表类型的文本
class DemoTex08(Scene):
    def construct(self):
        blist = BulletedList("Python", "Java", "C++", height=2, width=2)
        blist.set_color_by_tex("Python", RED)
        blist.set_color_by_tex("Java", GREEN)
        blist.set_color_by_tex("C++", BLUE)
        self.add(blist)

上述代码的实现效果如下：

3.4 代码文本

在 IT编程领域，代码的高亮显示是一个常见的需求，在 Manim 制作的视频中，也可以实现代码高亮的效果，主要是通过 Code() 对象来实现。

下面以快速排序的Python代码为例，来演示如何在视频中进行代码高亮显示。

class Code1(Scene):
    def construct(self):
        WaterMark.construct(self)
        code_str_1 = """
        def quickSort(Array):  
            n = len(Array)
            if n <= 1:
                return Array
            baseline = Array[0]
            left = [Array[i] for i in range(1, len(Array)) if Array[i] < baseline] 
            right = [Array[i] for i in range(1, len(Array)) if Array[i] >= baseline]
            return quickSort(left) + [baseline] + quickSort(right)
        """
        code1 = Code(
            code=code_str_1,
            tab_width=4,
            background="window",
            language="Python",
            font="Monospace",
            insert_line_no=False,  # 是否显示代码行数
            style='monokai',
        )

        code1.scale(0.8).to_edge(UP,buff=1)

        self.play(Write(code1))
        self.wait()

代码高亮效果如下：

上述代码中，变量 code_str_1 是快速排序算法的Python实现代码，变量 code1 是 Code() 对象的实例， Code() 有许多参数可以进行设置，这里只对部分参数进行设置：

background 参数，可以选择 “rectangle” 或 “window”，默认是 “rectangle”，我自己一般喜欢用 “window”；
language 参数是所用的编程语言，支持常用的编程语言；
font 参数，代码字体，默认为 “Monospac821 BT”，我一般用 “Monospace”；
insert_line_no 参数，是否显示代码行数，默认是 True；需要注意的是，在显示代码行数时，有时行数与代码的对齐效果不一定完美；
style 参数，代码显示风格，有多种风格可以选择，其可选代码样式来源于 “pygments” （https://pygments.org/docs/styles/）。可在Python中运行代码来获取支持的样式。
```
from pygments.styles import get_all_styles
styles = list(get_all_styles())
```
style支持的样式如下：
[‘default’, ‘emacs’, ‘friendly’, ‘colorful’, ‘autumn’, ‘murphy’, ‘manni’, ‘monokai’, ‘perldoc’, ‘pastie’, ‘borland’, ‘trac’, ‘native’, ‘fruity’, ‘bw’, ‘vim’, ‘vs’, ‘tango’, ‘rrt’, ‘xcode’, ‘igor’, ‘paraiso-light’, ‘paraiso-dark’, ‘lovelace’, ‘algol’, ‘algol_nu’, ‘arduino’, ‘rainbow_dash’, ‘abap’, ‘solarized-dark’, ‘solarized-light’, ‘sas’, ‘stata’, ‘stata-light’, ‘stata-dark’, ‘inkpot’] 默认的样式为 ‘vim’，我一般喜欢用 ‘monokai’ 样式。

再选择一款浅色的样式（’solarized-light’），并设置不同的参数值，来对比下效果，如下：

class Code1(Scene):
    def construct(self):
        WaterMark.construct(self)
        code_str_1 = """
        def quickSort(Array):  
            n = len(Array)
            if n <= 1:
                return Array
            baseline = Array[0]
            left = [Array[i] for i in range(1, len(Array)) if Array[i] < baseline] 
            right = [Array[i] for i in range(1, len(Array)) if Array[i] >= baseline]
            return quickSort(left) + [baseline] + quickSort(right)
        """
        code1 = Code(
            code=code_str_1,
            tab_width=4,
            background="window",
            language="Python",
            font="Monospace",
            insert_line_no=False,  # 是否显示代码行数
            style='monokai',
        )

        code1.scale(0.8).to_edge(UP,buff=1)

        self.play(Write(code1))
        self.wait()

        code2 = Code(
            code=code_str_1,
            tab_width=4,
            background="rectangle", # rectangle , window
            language="Python",
            font="Monospace",
            insert_line_no=True,  # 是否显示代码行数
            style='solarized-light',
            # line_spacing=0.3,
        )

        code2.scale(0.8)
        code2.next_to(code1,DOWN,buff=0.5)

        self.play(Write(code2))
        self.wait()

代码高亮效果如下：

Code() 对象还有更多的参数可以进行设置，详细的参数设置说明，大家可以通过官方文档来了解。

官方文档地址：

https://docs.manim.community/en/stable/reference/manim.mobject.svg.code_mobject.Code.html#manim.mobject.svg.code_mobject.Code

4 小结

文本的使用，是咱们最常见的领域，在使用文本时，从频率来看，纯文本是用的最多的，标记文本是对纯文本的进一步拓展，而 latex 文本，则是针对数学公式等特殊且频率较高的场景来使用的，至于代码高亮，则是在IT编程特定领域进行应用。

对于涉及中文的使用，经常需要通过 latex 来实现一些效果，因此，对想进一步深入了解中文排版的同学来，可能需要有一些 latex 的基础知识。

熟练的使用文本，可以给视频的排版和外观带来不少好处，不要小看这些哦。

本文中所使用的源代码，大家可以在公众号「Python数据之道」回复 manim 来获取。

相关阅读：

对我的文章感兴趣的朋友，可以关注我的微信公众号「Python数据之道」（ID：PyDataLab），接收我的更新通知。

用 Python 快速获取基金的股票持仓增减情况

Tue, 01 Mar 2022 00:00:00 +0000

用 Python 快速获取基金的股票持仓增减情况

Table of Contents

用 Python 快速获取基金的股票持仓增减情况

用 Python 快速获取基金的股票持仓增减情况

01 写在前面

大家好，我是阳哥。

大家知道，在财经领域，Python是有着广泛的用途的。2021年，量化基金开始成为弄潮儿。有不少消息称，量化基金贡献了相当比例的成交量，量化基金对成交量的贡献到底有多大，咱也不知道。

我们所知道的是，在金融量化领域，Python 是主力编程语言之一。

在2021年9月和2022年1月，阳哥曾分享过「用 Python 快速获取基金持仓增值与减持情况」这个内容，在1月份的内容上，发现有部分内容存在一些bug，本次将更新下文章内容，以及代码文件。

在财经领域，之前阳哥分享过部分Python实践应用的主题，包括：

大家知道，近几年，不少同学都是经由基金进入到股市中的。2020年就很流行“买股不如买基”的说话，至于股票和基金到底谁更好，这个仁者见仁智者见智，恐怕一时半会儿也说不清楚。

本文中，阳哥给大家分享的主题是用 Python 来追踪和更新基金的持仓结构以及基金的股票增持和减持情况，涉及到的Python库主要是 pandas 和 akshare 。

最终实现的效果包括两个方面：

单支基金的不同季度持仓变化情况
多支基金的十大持仓的历史信息

效果如下：

02 akshare 介绍

与 Tushare 类似， akshare 是国内比较的优秀的财经数据工具。

AKShare 是基于 Python 的财经数据接口库, 目的是实现对股票、期货、期权、基金、外汇、债券、指数、加密货币等金融产品的基本面数据、实时和历史行情数据、衍生数据从数据采集、数据清洗到数据落地的一套工具。

在使用 akshare 之前，需要进行安装，使用命令如下：

pip install akshare

在安装好 akshare 后，导入相关 Python库，如下：

import akshare as ak
import pandas as pd
import numpy as np

print(f'pandas version: {pd.__version__}')
print(f'akshare version: {ak.__version__}')

# pandas version: 1.3.2
# akshare version: 1.3.41

2022.1.10 更新内容：

本文中， akshare 使用的版本为 1.3.41

03 单支基金

对于单支基金的持仓情况变化，主要是通过对比临近的两个季度，来观察基金持仓的股票增持与减持情况，从而来跟踪基金的趋势变化。

由于基金季度报告中，1季度和3季度只披露前十大股票的持仓情况，而半年度（Q2）和年度（Q4）报告会披露全部持仓的情况，因此，也可以通过对更详细信息的对比来挖掘有些趋势信息。

下面，将详细的介绍获取并对比两个季度的持仓数据。

分步骤介绍

首先，咱们通过 akshare 来获取基金的季度持仓数据，以易方达蓝筹精选基金（基金代码：005827）为例，获取2019-2021年的持仓数据情况，代码如下：

# 易方达蓝筹精选，005827
# 前海开源公共事业股票，005669
years = ['2019','2020','2021']

data = pd.DataFrame()
for yr in years:
    # df_tmp = ak.fund_em_portfolio_hold(code="005827",year=yr) # akshare version: 1.0.91
    df_tmp = ak.fund_portfolio_hold_em(code="005827",year=yr) # akshare version: 1.3.41
    data = data.append(df_tmp)

data['季度']=data['季度'].apply(lambda x:x[:6])
data['季度'] = data['季度'].str.replace('年','Q')
data['占净值比例'] = pd.to_numeric(data['占净值比例'])
data

2022.1.10 更新内容：

基金持仓数据获取的接口，在 akshare 1.3.41 版本中，更新为 fund_portfolio_hold_em

结果如下：

假设咱们需要对比2021年1季度和2021年2季度的持仓变化情况，则只需要在上面的数据上选择 2021Q1 和 2021Q2 即可。

数据选取如下：

s1 = '2021Q1'
s2 = '2021Q2'
s1_share = s1+'持股数'
s2_share = s2+'持股数'
s1_value = s1+'持仓市值'
s2_value = s2+'持仓市值'
s1_ratio = s1+'持仓比例'
s2_ratio = s2+'持仓比例'

df1 =data[data['季度']==s1]
df1 = df1[['股票代码', '股票名称','持股数','持仓市值','占净值比例']]
df1 = df1.rename(columns={'持股数':s1_share,'持仓市值':s1_value,'占净值比例':s1_ratio})
df2 =data[data['季度']==s2]
df2 = df2[['股票代码', '股票名称','持股数','持仓市值','占净值比例']]
df2 = df2.rename(columns={'持股数':s2_share,'持仓市值':s2_value,'占净值比例':s2_ratio})
df1

2021年1季度数据结果如下：

在获取了两个季度的数据后，将数据按 “股票代码” 进行拼接，在得到的 dataframe 中，可以对持股的增减情况进行判断。

需要注意的是，由于Q2 和 Q4，即半年度和年度报告，是需要披露全部持仓的，因此在拼接后的dataframe 中，对应列的 NaN 数据应为 0，这一点可以细细品味下。

df_merge = pd.merge(df1,df2,on='股票代码',how='outer')

# Q2 和 Q4，即半年度和年度报告，是需要披露全部持仓的
# 合并后，在dataframe 中 NaN 的数据应为 0 
if s1.endswith('Q2') or s1.endswith('Q4'):
    df_merge[s1_share] = df_merge[s1_share].fillna(0)
    df_merge[s1_value] = df_merge[s1_value].fillna(0)
    df_merge[s1_ratio] = df_merge[s1_ratio].fillna(0)

if s2.endswith('Q2') or s2.endswith('Q4'):
    df_merge[s2_share] = df_merge[s2_share].fillna(0)
    df_merge[s2_value] = df_merge[s2_value].fillna(0)
    df_merge[s2_ratio] = df_merge[s2_ratio].fillna(0)


df_merge['持股数变化'] = df_merge[s2_share] - df_merge[s1_share]
df_merge = df_merge.sort_values(s2_value,ascending=False)


df_merge['股票名称'] = df_merge['股票名称_y']
# df_merge['股票名称'] = df_merge['股票名称'].fillna('0')
# df_merge.loc[df_merge['股票名称']=='0','股票名称'] = df_merge.loc[df_merge['股票名称']=='0','股票名称_x']
df_merge.loc[df_merge['股票名称'].isna(),'股票名称'] = df_merge.loc[df_merge['股票名称'].isna(),'股票名称_x']
df_merge = df_merge[['股票代码', '股票名称', s1_share, 
                     s1_value, s1_ratio, 
                     s2_share,s2_value, 
                     s2_ratio, '持股数变化']]

df_merge

结果如下：

上面的结果中，如果没有对 Q2 和 Q4 季度进行判断，则上图中红框内的数据会是 NaN，同时也计算不出减持的结果（结果会显示 NaN）。

因此，在进行调整后，可以真实的看到基金减持的情况。在2021年2季度，易方达蓝筹精选基金清仓了中炬高新等股票。

针对上述表格，咱们也可以通过 pandas 的样式设置，来较为清晰的查看基金的增减持情况，代码如下：

format_dict = {s1_share: '{0:.2f}', s2_share: '{0:.2f}', 
               s1_value: '{0:.0f}', s2_value: '{0:.0f}',
               s1_ratio: '{0:.2f}', s2_ratio: '{0:.2f}', 
               '持股数变化': '{0:.2f}'}

df_merge.style.hide_index()\
                .hide_columns(['股票代码'])\
                .format(format_dict)\
                .bar(subset=['持股数变化'],color=['#99ff66','#ee7621'],align='mid')

由于数据行数较多，只截取了部分，效果如下：

在上面的表格中，nan 数据结果，是由于数据披露的情况，有些数据咱们是获取不到的，因此也计算不了持仓增减情况，这些数据，在实际判断中，意义是不大的。

因此，咱们在显示数据结果的时候，也可以选择隐藏这些数据，如下：

df_merge_update = df_merge[~(df_merge['持股数变化'].isna())]
df_merge_update.style.hide_index()\
                .hide_columns(['股票代码'])\
                .format(format_dict)\
                .bar(subset=['持股数变化'],color=['#99ff66','#ee7621'],align='mid')

结果如下：

这样，咱们就可以得到，从两个季度信息对比，可以确定的增减持股票情况了（注意，不是全部的增减持，因为有些季度，有些持仓数据是不披露的）。

关于 Pandas表格样式设置的详细内容，请前往下面的链接：

Pandas表格样式配置指南

函数封装

将上面的详细过程封装成一个自定义函数，这样咱们就可以在后续重复使用该函数来获取不同基金的持仓变化信息了。

函数封装如下：

def compare(code,years,s1,s2):
    """
    code,str,基金代码;
    years,list,年份列表,['yr1','yr2','……'];
    s1,str,靠前的季度, 格式为 'YYYYQ1',例如: '2021Q2';
    s2,str,靠后的季度, 格式为 'YYYYQ1',例如: '2021Q2';
    注意，s1和s2的年份应在 years 里
    """
    
    s1_share = s1+'持股数'
    s2_share = s2+'持股数'
    s1_value = s1+'持仓市值'
    s2_value = s2+'持仓市值'
    s1_ratio = s1+'持仓比例'
    s2_ratio = s2+'持仓比例'

    data = pd.DataFrame()
    for yr in years:
        # df_tmp = ak.fund_em_portfolio_hold(code=code,year=yr) # akshare version: 1.0.91
        df_tmp = ak.fund_portfolio_hold_em(code=code,year=yr) # akshare version: 1.3.41
        data = data.append(df_tmp)

    data['季度']=data['季度'].apply(lambda x:x[:6])
    data['季度'] = data['季度'].str.replace('年','Q')
    data['占净值比例'] = pd.to_numeric(data['占净值比例'])

    df1 =data[data['季度']==s1]
    df1 = df1[['股票代码', '股票名称','持股数','持仓市值','占净值比例']]
    df1 = df1.rename(columns={'持股数':s1_share,'持仓市值':s1_value,'占净值比例':s1_ratio})
    df2 =data[data['季度']==s2]
    df2 = df2[['股票代码', '股票名称','持股数','持仓市值','占净值比例']]
    df2 = df2.rename(columns={'持股数':s2_share,'持仓市值':s2_value,'占净值比例':s2_ratio})
    
    df_merge = pd.merge(df1,df2,on='股票代码',how='outer')

    # Q2 和 Q4，即半年度和年度报告，是需要披露全部持仓的
    # 合并后，在dataframe 中 NaN 的数据应为 0 

    if s1.endswith('Q2') or s1.endswith('Q4'):
        df_merge[s1_share] = df_merge[s1_share].fillna(0)
        df_merge[s1_value] = df_merge[s1_value].fillna(0)
        df_merge[s1_ratio] = df_merge[s1_ratio].fillna(0)

    if s2.endswith('Q2') or s2.endswith('Q4'):
        df_merge[s2_share] = df_merge[s2_share].fillna(0)
        df_merge[s2_value] = df_merge[s2_value].fillna(0)
        df_merge[s2_ratio] = df_merge[s2_ratio].fillna(0)


    df_merge['持股数变化'] = df_merge[s2_share] - df_merge[s1_share]
    df_merge = df_merge.sort_values(s2_value,ascending=False)


    df_merge['股票名称'] = df_merge['股票名称_y']
    # df_merge['股票名称'] = df_merge['股票名称'].fillna('0')
    # df_merge.loc[df_merge['股票名称']=='0','股票名称'] = df_merge.loc[df_merge['股票名称']=='0','股票名称_x']
    df_merge.loc[df_merge['股票名称'].isna(),'股票名称'] = df_merge.loc[df_merge['股票名称'].isna(),'股票名称_x']
    df_merge = df_merge[['股票代码', '股票名称', s1_share, 
                         s1_value, s1_ratio, 
                         s2_share,s2_value, 
                         s2_ratio, '持股数变化']]
    return df_merge

2022.1.10 更新内容：

基金持仓数据获取的接口，在 akshare 1.3.41 版本中，更新为 fund_portfolio_hold_em

自定义函数 compare() 涉及4个参数，参数的说明如下：

code,str,基金代码;
years,list,年份列表,[‘yr1’,’yr2’,’……’];
s1,str,靠前的季度, 格式为 ‘YYYYQ1’,例如: ‘2021Q2’;
s2,str,靠后的季度, 格式为 ‘YYYYQ1’,例如: ‘2021Q2’;
注意，s1和s2的年份应在 years 里

使用该自定义函数之前，先要设置好参数的具体数值，还是以易方达蓝筹精选基金（基金代码：005827）为例，获取 2020Q3 和 2021Q1 的持仓数据情况，代码如下：

code = "005827"
years = ['2020','2021']
s1 =  '2020Q3' 
s2 = '2021Q1'
s1_share = s1+'持股数'
s2_share = s2+'持股数'
s1_value = s1+'持仓市值'
s2_value = s2+'持仓市值'
s1_ratio = s1+'持仓比例'
s2_ratio = s2+'持仓比例'

df_merge = compare(code,years,s1,s2)

format_dict = {s1_share: '{0:.2f}', s2_share: '{0:.2f}', 
               s1_value: '{0:.0f}', s2_value: '{0:.0f}',
               s1_ratio: '{0:.2f}', s2_ratio: '{0:.2f}', 
               '持股数变化': '{0:.2f}'}

df_merge.style.hide_index()\
                .hide_columns(['股票代码'])\
                .format(format_dict)\
                .bar(subset=['持股数变化'],color=['#99ff66','#ee7621'],align='mid')

从数据计算结果来看，有 nan 的数据行，是不能直接判断出结果的。

但如果是在最新的季度出现，并且是在十大持仓里靠前的位置，大概率是增值了，或者是完全新增的股票持仓。

比如下面的招行：

注：一般是直接比较两个临近的季度，这里的 2020Q3 和 2021Q1 之间，还隔个一个 2020Q4 。

04 多支基金

同时获取多支基金的十大股票持仓信息时，在这里只获取每个季度股票名称的信息。

首先，来获取单支基金的十大持仓股票名称信息，自定义函数如下：

# 获取单只基金的十大股票名称信息
def fund_stock_holding(years,code):
    data = pd.DataFrame()
    for yr in years:
        # df_tmp = ak.fund_em_portfolio_hold(code=code,year=yr) # akshare version: 1.0.91
        df_tmp = ak.fund_portfolio_hold_em(code=code,year=yr) # akshare version: 1.3.41
        data = data.append(df_tmp)

#     data['季度']=data['季度'].apply(lambda x:x[:8])
    data['季度']=data['季度'].apply(lambda x:x[:6])
    data['季度'] = data['季度'].str.replace('年','Q')
    data['占净值比例'] = pd.to_numeric(data['占净值比例'])    
    data = data.sort_values(['季度','持仓市值'],ascending=[True,False])
    
    # 将序号按持仓市值排序，从大到小    
    data1 = pd.DataFrame()
    quarter = data['季度'].unique().tolist()
    for q in quarter:
        df_tmp = data.query('季度==@q')
        df_tmp['序号'] = list(range(1,len(df_tmp)+1)) 
        data1 = data1.append(df_tmp)
        
    df = data1.set_index(['序号','季度']).stack().unstack([1,2]).head(10)
    # df1.loc[:,(slice(None), ['股票名称','占净值比例'])]
    df = df.loc[:,(slice(None), '股票名称')]  # 只选取 股票名称
    df = df.droplevel(None,axis=1)
    df.columns.name=None
    df = df.reset_index()
#     df.index.name = None
    df['基金代码'] = code
    cols = df.columns.tolist()
    cols = cols[:1] + cols[-1:] + cols[1:-1]  # 将基金代码列名放前面
    df = df[cols]
    return df

2022.1.10 更新内容：

基金持仓数据获取的接口，在 akshare 1.3.41 版本中，更新为 fund_portfolio_hold_em

2022年3月更新内容：

自定义函数 fund_stock_holding 关于股票持仓市值的排序，之前的版本存在一些问题，此次更新计算持仓市值的序号。

以易方达蓝筹精选基金（基金代码：005827）为例，该基金2019-2021的十大持仓信息如下：

years = ['2020','2021']
df3 = fund_stock_holding(years,'005827')
df3

2022年3月更新内容：

年份只选取 2020 和 2021年，后面的图片内容同步更新

结果如下：

通过自定义函数 fund_stock_holding(years,code) 可以同时获取多支基金的十大持仓信息，代码如下：

codes = ['005669','006281','003956','001532',
         '001714','001054','001809','003853',
         '004890','001125','001808']
df = pd.DataFrame()
for code in codes:
    df_tmp = fund_stock_holding(years,code)
    df = df.append(df_tmp)
df

结果如下：

上面数据中，显示的是基金代码，一般情况下，咱们还是习惯看基金名称，因此可以把基金代码换成基金名称。

基金名称信息获取如下：

# 获取基金名称信息
df_fund_info = ak.fund_em_fund_name()
df_fund_info = df_fund_info.query('基金代码 in @codes')
df_fund_info = df_fund_info[['基金代码','基金简称']]
df_fund_info = df_fund_info.reset_index(drop=True)
df_fund_info

效果如下：

有了基金名称信息后，可以用 pandas 通过拼接的方式，将基金名称信息显示出来，代码如下：

df_fund = pd.merge(df,df_fund_info,on='基金代码')
cols = df_fund.columns.tolist()
cols = cols[:1] + cols[-1:] + cols[2:-1]  # 将基金简称放前面
df_fund =df_fund[cols]
df_fund

结果如下：

05 小结

至此，咱们就获取了本次想要得到的信息。针对单支基金或者多支基金，咱们可以定期来获取信息，可以方便快捷的给其他人员分享基金的持仓信息，以及增减持情况。

在今天的这个财经案例里，需求其实是很常见的。在这个案例里，主要用到的是 Pandas 和 akshare 工具。

对于 Pandas 而言，用到的知识点还是挺多的，包括数据筛选、数据合并、数据排序、字符换和数值转换、样式设置等，虽然都是基础知识点，但要做到熟练运用，也是需要一定功底的。

财经工具，本次主要使用的是 akshare，使用 tushare 或者其他的财经工具应该也是可以的。

在代码编写好后，复用性还是挺好的。

我自己也是经常性在另一个公号「价值前瞻」里分享读书和投资的一些经验与教训。

本文的代码，大家可以点击下面的公众号卡片，回复 “pyfin” 来获取代码。

风险提示： 文章主要目的是给大家分享 Python 在财经领域的应用，文中提到的品种或标的，仅作为文中技术实现之用。投资有风险，入市需谨慎，文中内容不构成投资建议，抄作业请理性分析市场。

Manim社区版教程-01-基础形状

Fri, 18 Feb 2022 00:00:00 +0000

Manim社区版教程-01-基础形状

Table of Contents

Manim社区版教程-01-基础形状

Manim社区版教程-01-基础形状

写在前面

大家好，我是阳哥。

最近几个月，我在微信视频号「价值前瞻」和「Python数据之道」发布了一些视频，有不少同学问到这些视频是怎么做的，用什么工具制作的。

在文章用 python 制作高逼格的数学动画中，我跟大家介绍了 Manim 这个视频制作工具，以及以及案例演示。

本次，我将基于 Manim社区版(Manim Community)给大家分享Manim入门的第一部分，基础形状的使用。

本次使用的版本为 Manim Community v0.14.0，文中介绍的基础形状如下：

Manim的安装与运行

安装

如何安装社区版Manim，参见下面的官方链接：

https://docs.manim.community/en/stable/installation.html

如何运行 Manim

用 Manim 绘制图形，首先需要引入 Manim 库，然后将需要绘制的内容封装到一个类(class) 里面。

社区版的导入代码如下：

from manim import *

对于编辑好的程序文件（ XXXX.py 文件），需要在同一个文件夹下运行命令来运行程序，命令格式如下：

manim -pql XXXX.py DemoSquare

上面的命令行中：

manim 是社区版Manim运行程序的主要标志用语；
p 表示程序运行后会进行预览（图片或视频）；
ql 表示低质量（quality low）, 其他的选项有 -ql, -qm, -qh, -qk, 分别表示低质量、正常质量、高质量、4K质量；
XXXX.py 是py代码文件；
DemoSquare 是 py代码文件中的一个类；

演示过程录屏如下：

命令行中，还有其他许多参数可以设置，可以通过社区版的支持文档来进一步了解：

https://docs.manim.community/en/stable/tutorials/configuration.html#command-line-arguments

Manim 的基础形状介绍

通用属性

Manim 中基础形状有些属性和方法，对于大部分形状是通用的，因此在介绍具体的形状之前，在这里通过 正方形 来讲解下形状的基础用法。

在下面的案例中，实现了对正方形的边框颜色设置、线宽度设置、填充颜色、旋转、大小变换等。

# manim -pql manimce-intro-01.py DemoSquare
class DemoSquare(Scene):
    def construct(self):
        WaterMark.construct(self)
        r = 1
        sq1 = Square(
            side_length=2 * r,
            color=BLUE,
        )
        sq1.to_corner(UL,buff=2)
        self.add(sq1)
        self.wait()

        sq2 = Square(
            side_length=2 * r,
            color=BLUE,
            stroke_width=10,  # 设置边框线的粗细
        )
        sq2.next_to(sq1,RIGHT,buff=1)
        self.add(sq2)
        self.wait()

        sq3 = Square(
            side_length=2 * r,
            color=BLUE,
            fill_color=ORANGE,  # 设置填充颜色
            fill_opacity=0.5,  # 设置透明度
        )
        sq3.next_to(sq2,RIGHT,buff=1)
        self.add(sq3)
        self.wait()

        # 形状大小变换
        sq4 = sq1.copy()
        sq4.scale(0.6) # 缩小到 60%
        sq4.next_to(sq1,DOWN,buff=0.5)
        self.add(sq4)
        self.wait()

        # 形状旋转
        sq5 = sq2.copy()
        sq5.rotate(45*DEGREES)  # 旋转45度
        sq5.next_to(sq2,DOWN,buff=0.5)
        self.add(sq5)
        self.wait()

演示效果如下：

点

对于 点 ， manim 中目前有几种不一样的形状可以来展示，包括：

Dot
AnnotationDot
LabeledDot

class DemoDot(Scene):
    def construct(self):
        WaterMark.construct(self)
        g = Group(
            # 点
            Dot(color=PINK),
            AnnotationDot(stroke_color=YELLOW, fill_color=BLUE,fill_opacity=1),
            # 带文字标签的点
            LabeledDot(Tex("2022", color=RED)),
            LabeledDot(MathTex("a", color=GREEN)),
            LabeledDot(Text("Python数据之道", color=BLUE)).scale(0.3),
            LabeledDot("Lemon"),
        )
        g.arrange(RIGHT,buff=0.5).scale(1.5)
        g[:2].move_to(UP*1.5)
        g[2:].next_to(g[:2],DOWN,buff=1)
        for shape in g:
            self.add(shape)
            self.wait(0.5)

演示效果如下：

线

在这里，线 的形状，包括直线、虚线、箭头、双箭头、弯曲的箭头等，如下：

Line
DashedLine
Arrow
DoubleArrow
CurvedArrow

class DemoLine(Scene):
    def construct(self):
        WaterMark.construct(self)
        g = Group(
            # 线
            Line(0.5*LEFT,0.5*RIGHT,color=YELLOW),
            # 虚线
            DashedLine(0.5*LEFT,0.5*RIGHT,color=TEAL),
            # 箭头
            Arrow(color=BLUE), 
            Arrow(color= BLUE, tip_shape=ArrowCircleFilledTip), #  ArrowCircleTip
            Arrow(color= BLUE, tip_shape=ArrowSquareTip),# ArrowSquareFilledTip
            # 双箭头
            DoubleArrow(color=BLUE),
            # 弯曲的箭头
            CurvedArrow(LEFT,RIGHT,angle=90*DEGREES,color= BLUE), 
        )
        g.arrange(RIGHT,buff=0.5)
        g[:3].move_to(UP*1.5)
        g[3:].next_to(g[:3],DOWN,buff=1)
        for shape in g:
            self.add(shape)
            self.wait(0.5)

演示效果如下：

圆形

圆形包括圆、圆环、扇形、椭圆、弧形等，如下：

Circle
Annulus
Ellipse
Sector
Arc
ArcBetweenPoints

class DemoCircle(Scene):
    def construct(self):
        WaterMark.construct(self)
        g = Group(
            # 圆形
            Circle(radius=0.8,color=YELLOW,fill_color=BLUE,fill_opacity=1),
            # 圆环
            Annulus(inner_radius=0.7, outer_radius=1,fill_color= DARK_BLUE, stroke_color=YELLOW, stroke_width=4), 
            # 椭圆
            Ellipse(color= BLUE),
            # 扇形
            Sector(inner_radius=0.7, outer_radius=1,fill_color= BLUE, stroke_color=YELLOW, stroke_width=4),
            # 弧形
            Arc(radius=1.3, start_angle=-PI/8, angle=PI,color= BLUE),
            ArcBetweenPoints(start=2 * RIGHT, end=2*LEFT, stroke_color=BLUE) ,
        )
        g.arrange(RIGHT,buff=0.5)
        g[:3].move_to(UP*1.5)
        g[3:].next_to(g[:3],DOWN,buff=1)
        for shape in g:
            self.add(shape)
            self.wait(0.5)

演示效果如下：

下面的这个视频，就是基于扇形（Sector）来制作的。

矩形

矩形类的形状，是咱们经常使用到的一类图形，在 manim 中包括：

Rectangle
RoundedRectangle
Square

class DemoRect(Scene):
    def construct(self):
        WaterMark.construct(self)
        g = Group(
            # 矩形
            Rectangle(width=1,height=0.6,color=BLUE,fill_color=ORANGE,fill_opacity=1),
            Rectangle(width=1,height=0.6,color=BLUE,grid_xstep=0.5,grid_ystep=0.2),
            # 圆角矩形
            RoundedRectangle(corner_radius=0.3,width=1,height=0.6,fill_color=PURPLE,fill_opacity=1),
            # 正方形
            Square(
            side_length=1,
            color=BLUE,
            fill_color=ORANGE,  # 设置填充颜色
            fill_opacity=0.5,  # 设置透明度
            ),
        )
        g.arrange(RIGHT,buff=0.5).scale(2)
        for shape in g:
            self.add(shape)
            self.wait(0.5)

演示效果如下：

多边形

多边形性，相对来说要复杂些，主要是需要设置边缘点的位置，在manim中有多种方式来表示多边形，包括：

Triangle
Polygon
RegularPolygon
Star
Polygram
RegularPolygram

class DemoPolygon(Scene):
    def construct(self):
        WaterMark.construct(self)
        g = Group(
            # 正三角形
            Triangle(radius=2,color=BLUE),
            # 三角形
            Polygon([-5, 1.5, 0], [-2, 1.5, 0], [-3.5, -2, 0]),
            # 多边形
            Polygon([-5, 1.5, 0], [-2, 1.5, 0], [-2.5, -2, 0], [-4.5, -1.5, 0]),
            #正多边形
            RegularPolygon(n=6,color=BLUE),
            # 星型
            Star(color=BLUE),
            #多边形
            Polygram(
                [[0, 2, 0], [-np.sqrt(3), -1, 0], [np.sqrt(3), -1, 0]],
                [[-np.sqrt(3), 1, 0], [0, -2, 0], [np.sqrt(3), 1, 0]],),
            RegularPolygram(num_vertices = 7),
            RegularPolygram(5, radius=1),
        )
        g.arrange(RIGHT,buff=0.5).scale(0.7)
        g[:4].move_to(UP*1.5)
        g[4:].next_to(g[:3],DOWN,buff=1)
        for shape in g:
            self.add(shape)
            self.wait(0.5)

演示效果如下：

符号

在manim 中，也经常会用到大括号等形状，如下：

class DemoCross(Scene):
    def construct(self):
        WaterMark.construct(self)

        # 十字叉
        cross = Cross(stroke_color = BLUE,stroke_width=20).scale(0.8)
        cross.to_corner(UL,buff=2)
        self.add(cross)
        self.wait(0.5)
        # 大括号
        br1 = Brace(Line(LEFT,RIGHT),color= BLUE)
        br1.next_to(cross,RIGHT,buff=0.5)
        self.add(br1)
        self.wait(0.5)

        # 带文字的大括号
        line=Line(LEFT,RIGHT) 
        br2= BraceLabel(line, text= "14cm", color= YELLOW, buff=0.1) 
        br2.submobjects[1].set_color(BLUE) 
        self.add(VGroup(line,br2).next_to(br1,RIGHT,buff=0.5))
        self.wait(0.5)

        # 带弧度的大括号
        arc = Arc(radius=1,start_angle=0,angle=3*PI/4) 
        br3 = ArcBrace(arc).set_color(BLUE)
        self.add(VGroup(arc,br3).next_to(VGroup(line,br2),RIGHT,buff=0.5))
        # self.add(arc,br3)
        self.wait(0.5)

演示效果如下：

小结

相对而言，manim 中的基础形状，还是比较齐全的，在这些基础形状的基础上，自己可以进一步来组合其他的形状。

对我的文章感兴趣的朋友，可以关注我的微信公众号「Python数据之道」（ID：PyDataLab），接收我的更新通知。

手把手教你用Python绘制圣诞树 - Manim实践

Fri, 24 Dec 2021 00:00:00 +0000

手把手教你用Python绘制圣诞树

Table of Contents

手把手教你用Python绘制圣诞树 - Manim实践

手把手教你用Python绘制圣诞树 - Manim实践

写在前面

大家好，我是阳哥。

前几天，我跟大家介绍了视频制作工具 Manim，不少同学都觉得不错，想进一步学习。

用 python 制作高逼格的数学动画

刚好圣诞节快要到了，我之前在视频号「Python数据之道」上发了圣诞树制作的视频。

今天，我来介绍下视频中的效果是怎么制作的。

Manim 基础知识

如何运行 Manim

用 Manim 绘制图形，首先需要引入 Manim 库，然后将需要绘制的内容封装到一个类(class) 里面。

from manim import *

对于编辑好的程序文件（例如christmas-intro.py 文件），需要在同一个文件夹下运行命令来运行程序，命令格式如下：

manim -pql christmas-intro.py DemoSquare

上面的命令行中：

manim 是运行程序的主要标志用语；
p 表示程序运行后会进行预览（图片或视频）；
ql 表示低质量（quality low）, 其他的选项有 -ql, -qm, -qh, -qk, 分别表示低质量、正常质量、高质量、4K质量；
christmas-intro.py 是py代码文件；
DemoSquare 是 py代码文件中的一个类；

命令行中，还有其他许多参数可以设置，可以通过社区版的支持文档来进一步了解：

https://docs.manim.community/en/stable/tutorials/configuration.html#command-line-arguments

圣诞树中的元素

绘制圣诞树，有不少同学是用 Python 的 Turtle 包来绘制的，在这里我用 Manim 进行了绘制，效果如下：

在视频中，一共绘制了 3 颗不同的圣诞树，这里以下面的这棵树为例，来介绍 Manim 的一些用法。

对于圣诞树中的细分元素，通过观察，只涉及到正方形和圆形，以及填充不同的颜色。

绘制正方形

用 Manim 绘制正方形，Manim 提供了类对象 Square 来绘制，如下：

class DemoSquare(Scene):
    def construct(self):
        # WaterMark.construct(self)
        r = 1
        sq = Square(
            side_length=2*r,
            color=GREEN_LEMON,
            )
        self.add(sq)

通过下面的命令来运行：

manim -pql christmas-intro.py DemoSquare

绘制效果如下：

如果需要对正方形进行填充，则可以设置参数 fill_color 和 fill_opacity ，代码和效果如下：

class DemoSquare(Scene):
    def construct(self):
        # WaterMark.construct(self)
        r = 1
        sq = Square(
            side_length=2*r,
            color=GREEN_LEMON,
            fill_color=GREEN_LEMON, 
            fill_opacity=1,
            )
        self.add(sq)

绘制圆形

对于绘制圆形，与绘制正方形类似，Manim 提供了类对象 Circle 来绘制，如下：

class DemoCircle(Scene):
    def construct(self):
        # WaterMark.construct(self)
        r = 1
        circle = Circle(
            radius=r,
            color=GREEN_LEMON,
            fill_color=GREEN_LEMON,
            fill_opacity=1,
        )
        self.play(Create(circle))
        self.wait()

运行的命令行如下：

manim -pql --disable_caching christmas-intro.py DemoCircle --format=gif

其中：

--format=gif 表示保存为 .gif ；
--disable_caching 一般是视频帧数很多的时候，加上这个参数，可以加快渲染的速度，一般情况下，可以不加这个参数。

效果如下：

在代码中添加了 play 、Create 因此会有动态的效果了。

绘制圣诞树

对于这个圣诞树，在用 Manim 制作时，对于形状部分可以分为三个部分，如下：

第 1 部分和第 3 部分，相对而言要简单些，第2部分，看起来复杂些，但其实也是由三个类似的单元组合起来的。

绘制第2部分

对于第2部分中的每一个细分单元，可以用通过一个自定义函数来实现：

def draw_tree(n, buff=1):
  shapes = Group()
  for i in range(4):
      sq_lst = [
          Square(
              side_length=2 * r,
              color=GREEN_LEMON,
              fill_color=GREEN_LEMON,
              fill_opacity=1,
          )
          for j in range(2 * (i + n) + 1)
      ]
      sq_group = Group(*sq_lst).arrange(RIGHT)
      sq_group.to_edge(UP, buff=buff)
      if i == 2:
          sq_side_lst = [
              Square(
                  side_length=2 * r,
                  color=YELLOW,
                  fill_color=YELLOW,
                  fill_opacity=1,
              )
              for j in range(2)
          ]
          sq_side_group = Group(*sq_side_lst)
          sq_side_group[0].next_to(sq_group, LEFT)
          sq_side_group[1].next_to(sq_group, RIGHT)
          self.add(sq_side_group[0])
          self.wait(time_wait)
          for sq in sq_group:
              self.add(sq)
              self.wait(time_wait)
          self.add(sq_side_group[1])
          self.wait(time_wait)
          shapes.add(sq_side_group[0])
          shapes.add(sq_group)
          shapes.add(sq_side_group[1])
      elif i == 3:
          circle_side_lst = [
              Circle(
                  radius=r,
                  color=RED_LEMON,
                  fill_color=RED_LEMON,
                  fill_opacity=1,
              )
              for j in range(2)
          ]
          circle_side_group = Group(*circle_side_lst)
          circle_side_group[0].next_to(sq_group, LEFT)
          circle_side_group[1].next_to(sq_group, RIGHT)
          self.add(circle_side_group[0])
          self.wait(time_wait)
          for sq in sq_group:
              self.add(sq)
              self.wait(time_wait)
          self.add(circle_side_group[1])
          self.wait(time_wait)
          shapes.add(circle_side_group[0])
          shapes.add(sq_group)
          shapes.add(circle_side_group[1])

      else:
          shapes.add(sq_group)
          for sq in sq_group:
              self.add(sq)
              self.wait(time_wait)

      buff += buff_gap
  return shapes

上面这个代码片段，看起来很长，其实逻辑还是不复杂的。主要是根据图形之间的布局关系来编写代码的。有兴趣的同学可以先自行研究下。

通过上面的这个自定义函数，咱们可以将第二部分绘制出来，关键代码如下：

tree_caps = Group()
        for n in range(3):
            tree_cap = draw_tree(n, buff=buff_gap * 2 + buff_gap * n * 4)
            tree_caps.add(tree_cap)

绘制第3部分

第3部分，在代码中，我称之为 tree_root ，主要是绘制正方形组成的矩形方阵，然后控制视频演示的顺序。

代码如下：

tree_root = Group()
  for i in range(3):
      sq_lst = [
          Square(
              side_length=2 * r,
              color=RED_LEMON,
              fill_color=RED_LEMON,
              fill_opacity=1,
          )
          for j in range(5)
      ]
      sq_group = Group(*sq_lst).arrange(RIGHT)
      tree_root.add(sq_group)
  for i in range(1, len(tree_root)):
      tree_root[i].next_to(tree_root[i - 1], DOWN, buff=buff_gap / 2)

  tree_root.next_to(tree_caps, DOWN, buff=buff_gap / 2)

  for i in range(len(tree_root)):
      for j in range(len(tree_root[i])):
          self.add(tree_root[i][j])
          self.wait(time_wait)
  self.wait()

缩小放大效果

对于图形的所辖和放大效果，在 Manim 中，可以通过 animate 以及 scale 的设置来实现：

tree = Group(circle, tree_caps, tree_root)
self.play(tree.animate.move_to(ORIGIN).scale(0.5), run_time=4)
self.play(tree.animate.scale(2), run_time=4)

完整的代码

这颗树的完整代码，我已经封装在 christmas-intro.py 文件的类 Tree02 中，大家可以运行下面的命令来运行代码：

manim -pql christmas-intro.py Tree02

完整的代码文件 christmas-intro.py，大家可以在公众号「Python数据之道」回复 manim 来获取。

代码文件 christmas-intro.py 中，还包括 Tree01 和 Tree03，大家也可以运行看看。

对于代码运行过程中的一些问题，欢迎一起交流。

一个高逼格的数学视频制作神器：Manim

Wed, 22 Dec 2021 00:00:00 +0000

一个高逼格的数学视频制作神器

Table of Contents

一个高逼格的数学视频制作神器

一个高逼格的数学视频制作神器

大家好，我是阳哥。

写在前面

最近几个月，我在微信视频号「价值前瞻」和「Python数据之道」发布了一些视频，有不少同学问到这些视频是怎么做的，用什么工具制作的。

今天来给大家揭秘。

视频制作神器：Manim

最近，我在视频号上的视频，主要是用视频制作工具 Manim 来制作的。

Manim 真的是一款高逼格的视频制作工具，尤其是数学动画领域。

Manim 是斯坦福大学数学系小哥 Grant Sanderson 开源的python库，并用于油管频道 3Blue1Brown，来解说数学等相关内容。

可能大家没有听说过 3Blue1Brown 频道, 该频道在油管上拥有 400万+ 的粉丝，其发布的视频浏览量大部分都在百万级以上，有不少在千万级别，作为一个专业领域的博主，不得不令人佩服。

Manim 的魅力

Manim 是一个非常优秀的数学动画制作引擎，可以制作视频格式(.mp4)或动图格式的动画(.gif)，先来几个动画感受一下 Manim 的魅力：

版本说明

对于 Manim 的初学者，使用 Manim 时，对于其版本的选择还是有些需要注意的地方。

不同版本的代码、教程等，还是有稍许差异的。

目前 Manim 主要有三个版本：

3b1b 旧版：3blue1brown 自己维护的版本，使用 Cairo 作为后端；
3b1b 新版：3blue1brown 自己维护的版本，使用 OpenGL 和 moderngl 来进行 GPU 渲染，优点是速度快；
Manim 社区版：社区版是2020年下半年才出来的版本，目前主要是 Manim 旧版的衍生，更新更活跃，有很好的文档和社区支持。当然，随着社区版的迭代更新，目前 3b1b 新版的某些特性也在逐步容纳进来。

关于这几个版本如何选择的建议：

如果你是新接触这个工具的，建议可以从社区版开始，主要是社区版的文档教程比较齐全，其迭代的频率更快。
如果你是 Python 或者其他编程领域的资深人士，想体自己动手深入理解并优化这个工具，可以使用 3b1b 新版
对于 3b1b 旧版，我暂时没有更多的想法

Manim 的安装

在 Manim 3b1b 版本和社区版均提供了如何安装的文档：

3b1b 新版的安装文档： https://github.com/3b1b/manim
社区版的安装文档： https://docs.manim.community/en/stable/installation.html

有同学说安装是比较容易的，不过，我自己在安装过程中还是遇到了一些麻烦。

最终，上述两个版本我都安装了，大家可以自行尝试安装下。由于不同的电脑环境，有时候总会出现一些意想不到的bug，在这里我就不介绍如何安装了。

一些有意思的经历，在2019年的时候，我曾经尝试安装 3b1b 旧版的 Manim，几次安装失败后，成功的被劝退了。

要不是开始弄视频，估计也不会再次去尝试安装 Manim，毕竟之前的阴影还在。

我的 Manim 之路

3b1b 新版的 Manim 和社区版的 Manim 我都有安装并使用。

在最初的时候，我只安装了 3b1b 新版，在制作了一些视频后，觉得支持文档这方面对我而言还是有不少难度，不然就需要自己花大量时间去熟悉这个工具的源代码。

总的来说，刚开始使用 3b1b 新版，在效率方面会有一些折扣。

后面折腾了一阵，将社区版也安装好了，所以我主要是以使用社区版 Manim 为主。

社区版的文档、教程，可以在下面这个网站查询：

https://docs.manim.community/en/stable/tutorials/quickstart.html

我制作的视频主要在微信视频号「价值前瞻」和「Python数据之道」上发布：

价值前瞻，主要是读书、财经、思维等相关内容
Python数据之道，主要是Python、算法、数学、IT等相关内容

价值前瞻

思维类

对于读书笔记、思维模型等内容，其实也是可以用 Manim 这个工具的，尤其是某些思维模型如果涉及某些数学常识相关的内容。

当然，这类视频，并不一定要用 Manim 这个稍显生硬的工具，也还是有其他很多更好的工具的。

我制作了一个 “复利效应” 相关的视频，如下：

注：视频需要在手机端观看

财经类

时序数据的曲线绘制，在 Manim 上并没有提供现成的方法，但经过研究，其实也是可以实现的，如下：

对于企业的财务数据，分阶段的可视化，也可以想办法来实现，如下：

上面的效果，个人觉得，后续还可以继续优化，使切换过程更加平滑。

Python数据之道

在视频号「Python数据之道」上，目前主要有算法系列、数学系列的视频。

算法方面，目前已经跟大家分享了10大经典排序算法的视频。

排序算法： 汇总 , 冒泡排序 , 选择排序 , 快速排序 , 归并排序 , 堆排序 , 插入排序 , 希尔排序 , 计数排序 , 桶排序 , 基数排序

数学方面，主要是一些经典图形，以及一些基础内容的介绍，要做好数学类的视频，最最最主要的，还是要对数学原理有比较深入的理解，这个是最难滴~

此外，我还想弄一些跟Python相关的视频，暂时称之为 “好玩的Python”，最近的就是做了一个如何绘制圣诞树的视频。

类似的视频，有不少同学是用 Python 的 Turtle 包来绘制的，在这里我用 Manim 进行了绘制，效果如下：

小结

不得不说，用 Manim 制作出来的视频，效果确实挺不错的。在使用过程中，也有一些小小的经验，想用 Manim 制作出高逼格的视频，需要注意的是：

每一个视频花费的时间，都会不少；
对 Manim 这个工具的源代码有足够的理解；
对数学或算法知识有一定的理解；
所谓的高逼格，其实主要是在内容领域和视觉领域，内容领域体现的是内容的专业性，而视觉领域，则更多的是艺术效果，比如布局、配色等。

所有的这些因素，每个人在刚开始的时候，并不是都熟悉，但随着知识与经验的积累，会越来越好的。

为了更好的使用 Manim，我建立一个 github 仓库，来整理相关的资源，目前还是一个起始阶段，欢迎大家提供建议！

地址如下：

https://github.com/liyangbit/ManimLab

对我的文章感兴趣的朋友，可以关注我的微信公众号「Python数据之道」（ID：PyDataLab），接收我的更新通知。

用 Python 快速追踪基金的收益情况

Thu, 26 Aug 2021 00:00:00 +0000

2022年4月更新

Table of Contents

用 Python 快速追踪基金的收益情况 | Python财经实践

用 Python 快速追踪基金的收益情况 | Python财经实践

大家好，我是阳哥。

在文章《股票亏惨了，用Python来做一个投资计划》发布后，有同学留言，希望能够有更多的关于 Python 在财经领域应用的案例分享。

其实，在财经领域，我之前也是有过部分内容分享的：

大家知道，近几年，不少同学都是经由基金进入到股市中的。去年就很流行“买股不如买基”的说话，至于股票和基金到底谁更好，这个仁者见仁智者见智，恐怕一时半会儿也说不清楚。

今天，阳哥给大家分享的主题是用 Python 来追踪和更新基金的收益情况，涉及到的Python库主要是 pandas 和 tushare 。

最终实现的效果如下：

上面表格中的信息，主要涉及四个方面：

基金基础信息，包括基金名称、基金费率、基金公司、基金成立时间等；
基金经理的信息，包括姓名、性别、任职时间等；
基金规模，体现出来的是基金金额的规模，是通过基金份额以及基金净值计算出来的；
基金年度收益情况，一般是计算基金近几年的收益情况。

上面的这些信息，在财经工具 tushare 中，目前是都已经提供了的。因此，咱们有必要稍微介绍下 tushare 。

01 tushare 介绍

关于财经数据，有多个Python库可以供咱们选择，其中 tushare 是国内较早开始发布财经数据的社区，其内容比较完善，今天我们使用的就是 tushare 。

Tushare 是一个金融大数据平台，数据内容包含股票、指数、基金、期货、债券、外汇、行业大数据等，同时包括了数字货币行情等区块链数据，为各类金融投资和研究人员提供适用的数据和工具，概览如下：

全部内容很丰富，为了有助于大家有个整体的了解，阳哥绘制了一张完整的思维导图，截图如下：

使用 Tushare

Tushare 平台的数据，已全面升级到 tushare pro 了，通常情况下，还是称之为 tushare。

想使用 tushare 中的数据和功能，首先需要进行注册，获得一份 token （一串字母和数字组成的文本），然后才可以获取到数据，大家可以通过以下链接来注册（也可以点击文末的“阅读原文”）：

https://tushare.pro/register?reg=129033

在 tushare 中注册后，通过 “个人主页”——“接口TOKEN” 可以找到自己的 token 值，界面如下：

复制 token 值，然后在代码中进行如下设置：

# 设置 token
# tushare 注册地址： https://tushare.pro/register?reg=129033
# 以上方法只需要在第一次或者token失效后调用，完成调取tushare数据凭证的设置，正常情况下不需要重复设置。
ts.set_token('你的token值')

pro = ts.pro_api()

在设置好 token 值后，我们就可以开始获取数据。

关于 tushare 的详细介绍，请点击下面的链接前往：

神器Tushare，财经数据必备工具！

02 基金信息获取

首先，导入本次需要用到的 python 库，并设置好 tushare ，如下：

import pandas as pd
import datetime
import numpy as np
import tushare as ts

# token='XXXXXXX'  
# ts.set_token(token)

pro = ts.pro_api()

需要说明的是，tushare 中不同的数据获取需要的权限是不一样的，如果权限不够，可能获取不到数据哦。

获取基金基础信息

首先，咱们来获取基金基础信息，包括基金名称、基金费率、基金公司、基金成立时间等。在 tushare 中，提供了 fund_basic() 接口来获取这些信息。

该接口有两个参数，咱们主要关注的是第一个参数 market，由于基金有场内基金（ETF和LOF）和场外基金，因此，全部的基金是这两者之和。

所有基金的基础信息获取代码如下：

# 获取基金中文名称信息
df_e = pro.fund_basic(market='E')
df_o = pro.fund_basic(market='O')
# df_fund_info = df_e.append(df_o)
df_fund_info = pd.concat([df_e,df_o])
df_fund_info = df_fund_info[['ts_code','name', 'management','m_fee', 'c_fee','found_date']]
df_fund_info.columns = ['fund_code','fund_name', 'management','m_fee', 'c_fee','found_date']
df_fund_info = df_fund_info.reset_index(drop=True)
df_fund_info

结果如下：

这个数据框中，有 1.6万多支基金，是不是超出你的想象了啊~~~

实际上，目前整个市场上总数应该多于这个数，tushare中有部分信息还没有纳入进来。

当然了，这是包括了混合型、股票型、债券型、货币基金类等全部的基金。

获取基金经理信息

对于主动型基金而言，挑选基金时，选择一个好的基金经理是很重要的因素，因此，在追踪基金的收益情况时，是有必要将基金经理的信息一并获取的。

在tushare 中，可通过接口 fund_manager 来获取某只基金过往基金经理的信息。

在获取基金经理信息后，可以跟之前获取基金基础信息进行合并。

这个过程，阳哥写了一个自定义函数，如下：

# 获取单个基金的信息

def get_fund(fund_code,df_fund_info):    
    # 获取基金经理信息，以及开始管理该基金的日期
    df_manager = pro.fund_manager(ts_code=fund_code)
    df_manager = df_manager[df_manager['end_date'].isna()]
    df_manager = df_manager.sort_values('begin_date',ascending=True).head(1)
    begin_date = df_manager['begin_date'].values[0] # 开始管理该基金的日期
    df_manager = df_manager[['ts_code', 'name', 'gender','begin_date']]
    df_manager.columns = ['fund_code', 'manager_name', 'gender','begin_date']
    
    # 合并
    df_fund = pd.merge(df_manager,df_fund_info,how='left',on='fund_code')

    return df_fund

假如你想获取易方达优质精选（以前叫易方达中小盘）的信息，可以基于上面的自定义函数 get_fund ，使用如下的代码：

# 110011.OF,易方达优质精选（易方达中小盘）

df_fund = get_fund('110011.OF',df_fund_info) 
df_fund

获取的信息如下：

计算基金规模和收益情况

接下来，咱们还需要获取两个信息，基金规模和基金近几年的收益情况。

基金规模，可以从一个角度来观察该基金在市场上的受欢迎度，一般来说，规模较大的基金，说明该基金过往的表现应该还是可以的。不过这里也有两点需要注意：

基金过往业绩并不代表未来依然会如此；
基金规模小，并不一定说明该基金未来表现会不好。

除了基金规模，另一个咱们经常关注的，也是基金营销机构经常拿出来宣传的，就是基金的过往收益情况。

基金规模的计算公式如下：

\[基金规模(亿元) = 基金份额数量 \times 基金单位净值\]

在 tushare 中基金份额数量由函数 fund_share 来获取，基金单位净值（unit_nav）数据由函数 fund_nav 来获取。

此外，在计算基金的过往年度收益时，也是基于其累计净值（accum_nav）来实现的。

因此，阳哥将基金规模获取过程和基金近几年收益情况计算合并在一个自定义函数里，代码如下：

# 获取单支基金的年度收益,基金规模等信息

def get_returns(fund_code,start_year):
    """获取单支基金的年度收益,基金规模等信息
    Keyword arguments:
    fund_code -- 基金代码，如：110011.OF
    start_year -- 开始获取基金数据的年份
    """
    df_fund_nav = pro.fund_nav(ts_code=fund_code)
    df_fund_nav['date'] = pd.to_datetime(df_fund_nav['nav_date'])
    df_fund_nav = df_fund_nav.set_index('date').sort_index()
    
    years = df_fund_nav['accum_nav'].resample('AS').sum().to_period('A')
    # 获取年度数据，类型为 pandas 的 period
    years = years.index.tolist()
    
    # 有些基金的开始日期晚于2018年，需要对齐列，补空白
    year_list = [yr.year for yr in years if yr.year>=start_year]
    
    # 将 period 时间数据转为 string 的年度数据
    years = [str(yr.year) for yr in years]

    df_yrs_index = pd.DataFrame()
    for yr in years:
        df_yr_index = df_fund_nav.loc[yr].tail(1)
#         df_yrs_index = df_yrs_index.append(df_yr_index) # append 将被替代
        df_yrs_index = pd.concat([df_yrs_index,df_yr_index])
#     df_yrs = df_fund_nav.head(1).append(df_yrs_index)
    df_yrs = pd.concat([df_fund_nav.head(1),df_yrs_index])

    # 计算每年的收益率，即涨跌幅度
    df_yrs['returns'] = df_yrs['accum_nav'].pct_change()

    # 删除收益率为 NA 的行 （第1天有数据记录的日期）
    df_yrs = df_yrs.dropna(subset=['returns'])

    # 筛选自开始年份以来的数据
    df_yrs = df_yrs.loc[str(start_year):]

    df_yrs = df_yrs.reset_index()
    df_yrs['year'] = df_yrs['date'].dt.year

    # 透视表
    df_yr_returns = pd.pivot_table(
        df_yrs, index=['ts_code'],
        values=['returns'], columns=['year'], fill_value=""
    )

    # 将多层索引转变为单层索引
    df_yr_returns = df_yr_returns['returns']
    df_yr_returns = df_yr_returns.reset_index()
    df_yr_returns.columns.name = None
    
    df_yr_returns = df_yr_returns.rename(columns={'ts_code':'fund_code'})
    
    # 基金份额
    df_fund_share = pro.fund_share(ts_code=fund_code).head(1)
    df_fund_share.columns = ['fund_code', 'fd_share_date', 'fd_share', 'fund_type', 'market']
    # fd_share,单位是 万份
    fd_share_date = df_fund_share['fd_share_date'].values[0] # 份额对应的日期
    
    # 份额日期的净值数据
    df_ann_nav = df_fund_nav.loc[fd_share_date:fd_share_date].sort_values('update_flag',ascending=False).head(1)
    df_ann_nav = df_ann_nav[['ts_code', 'accum_nav','unit_nav']]
    df_ann_nav.columns = ['fund_code', 'accum_nav','unit_nav']
    
    # 计算基金规模，amount，单位：亿元
    df_fund_amount = pd.merge(df_fund_share,df_ann_nav,how='left',on='fund_code')    
    df_fund_amount['amount'] = df_fund_amount['fd_share'] * df_fund_amount['unit_nav']/10000
    df_fund_amount = df_fund_amount[['fund_code','amount','fd_share_date']]
    
    # 合并数据    
    df_yr_returns = pd.merge(df_fund_amount,df_yr_returns,how='left',on='fund_code')

    for yr in year_list:
        if yr not in df_yr_returns.columns.tolist():
            df_yr_returns[yr]=np.nan
    
    return df_yr_returns

假如你想获取易方达优质精选基金的2018年以来的收益情况信息，可以基于上面的自定义函数 get_returns ，使用如下的代码：

df_return = get_returns('110011.OF',2018)
df_return

获取的信息如下：

同时获取多只基金的信息

上面已经实现了获取单只基金所需要的信息，接下来，咱们需要拼接之前获取的信息。

同时，我们一般会同时关注多只基金，因此同时获取多只基金的信息，也是基本必备的需求。

实现的代码如下：

# 获取多只基金的信息

def get_data_fund(df_fund_info,fund_code_short,start_year):
    df_filter_info = pd.DataFrame()
    for code in fund_code_short:
        df_tmp = df_fund_info[df_fund_info['fund_code'].str.contains(code)].head(1)
#         df_filter_info = df_filter_info.append(df_tmp)
        df_filter_info = pd.concat([df_filter_info,df_tmp])
    df_filter_info = df_filter_info.reset_index(drop=True)   
    fund_codes = df_filter_info['fund_code'].tolist()
    # fund_codes

#     df = pd.DataFrame()
    frames = [] # 用来装载 df_fund_merge
    i=0
    for code in fund_codes:
        print(f'i:{i},code:{code}')
        if i<78:
#             print(code)
#             print(f'i:{i},code:{code}')
            df_fund = get_fund(code,df_fund_info)    
            df_return = get_returns(code,start_year)
            df_fund_merge = pd.merge(df_fund,df_return,how='left',on='fund_code')
            frames.append(df_fund_merge)
            i +=1
        else:
            i=0
            time.sleep(61)
#         df = df.append(df_fund_merge)
    df = pd.concat(frames)
    df = df.reset_index(drop=True)
    
    df = df.rename(columns={
        'fund_code':'基金代码','manager_name':'基金经理',
        'gender':'性别','begin_date':'上任日期',
        'fund_name':'基金名称','management':'基金公司',
        'm_fee':'管理费','c_fee':'托管费',
        'found_date':'成立时间','amount':'基金规模(亿元)',
        'fd_share_date':'规模对应日期'
    })
    
    # 调整列的排序
    cols = df.columns.tolist()
    col_1 = cols[:4]
    col_2 = cols[4:5]
    col_3 = cols[5:]
    cols = col_2 + col_1 + col_3
    df = df[cols]

    return df

在上面的函数 get_data_fund 中，还对最后显示的列的顺序也进行了调整，该过程的实现的详细内容，可以在下面的链接中来了解：

Pandas实用技能，将列（column）排序的几种方法

基于自定义函数 get_data_fund，设置好函数所需要的参数后，就可以获取多只基金的信息了，具体参数如下：

# 需要获取的基金代码简称列表
fund_code_short = ['001938', '162605', '005911', '005827','007119', 
                   '110011', '161005', '000800', '519736', '163402',
                   '003095', '163406', '002190', '164908', '000772']

# 设置基金收益开始的年份
start_year = 2018
# 设置基金收益截止的年份
end_year = 2022
year_list = list(range(start_year,end_year+1))

df_fund_final = get_data_fund(df_fund_info,fund_code_short,start_year)
df = df_fund_final.sort_values('基金经理',ascending=True,ignore_index=True)
# df.to_csv('./data/fund_manager.csv',index=False)
df

得到的结果如下：

Pandas 中，可以通过 Style 对表格样式进行设置，对收益情况进行红涨绿跌的设置。

代码如下：

def color_returns(val):
    if val >=0:
        color = '#EE7621' # light red 
    elif val <0:
        color = '#99ff66' # light green 
    else:
        color = '#FFFAFA' # ligth gray 
    return f'background-color: {color}'

format_dict = {'基金规模(亿元)': '￥{0:.1f}', 
               '管理费': '{0:.1f}', 
               '托管费': '{0:.2f}', 
               2017: '{0:.1%}', 
               2018: '{0:.1%}', 
               2019: '{0:.1%}', 
               2020: '{0:.1%}', 
               2021: '{0:.1%}', 
               2022: '{0:.1%}', 
                }


df.style.hide(axis='index')\
                    .hide(['规模对应日期','成立时间'],axis='columns')\
                    .format(format_dict)\
                    .applymap(color_returns,subset=year_list)\
                    .background_gradient(subset=['基金规模(亿元)'],cmap='Blues')

得到的结果如下：

关于 Pandas 中表格样式设置，阳哥之前分享了一份详细的内容，有兴趣的同学可以前往查看：

Pandas表格样式配置指南，看这一篇就够了

03 小结

至此，咱们就获取了本次想要得到的信息，这个表格可以定期更新，用于给其他人员分享基金的基本信息以及年度收益情况。

在今天的这个财经案例里，需求其实是很常见的。在这个案例里，主要用到的是 Pandas 和 Tushare 工具。

对于 Pandas 而言，用到的知识点还是挺多的，包括数据筛选、数据合并、数据排序、数据透视表、样式设置等，虽然都是基础知识点，但要做到熟练运用，也是需要一定功底的。

阳哥近期在分享「图解Pandas」系列内容，对 Pandas 有兴趣的同学可以来了解下：

对于 tushare ，主要是关注该工具中财经信息的完整性、准确性以及及时性。

如果其他财经工具有这样的功能，也是可以了。

在代码编写好后，复用性还是挺好的。

我自己也是经常性在另一个公号「价值前瞻」里分享读书和投资的一些经验与教训。

本文的代码，大家可以点击下面的公众号卡片，回复 “pyfin” 来获取代码。

Python数据类型-字典(dict)介绍

Mon, 23 Aug 2021 00:00:00 +0000

Python数据类型-字典(dict)介绍

Python基础-Python数据类型-字典(dict)介绍

Table of Contents

01 基本用法
02 字典推导式（dict comprehension）
03 嵌套型字典
04 小结

大家好，我是阳哥。

字典（dict）是 python 中的基础数据类型之一，字典的设计并不复杂，我们经常会用到这种数据类型。

同时，字典也有一些比较实用的情景。

学习任何一种编程语言，基础数据类型都是必备的底层基础，今天，我们来学习下 Python 中字典的使用。

主要内容包括：

字典的基本用法
字典推导式
嵌套字典

01 基本用法

在 Python 中，字典是一种可以将相关的两个信息关联起来的操作，并且字典可存储的信息量几乎不受限制。

字典是 Python 提供的一种常用的数据结构，它用于存放具有映射关系的数据。为了保存具有映射关系的数据，Python 提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来访问，被称为 value。

创建字典

字典是以 key、value 的形式创建的。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

一般情况下，字典的创建可以有以下几种方式：

# 创建一个空的字典
my_dict1 = {}

# 创建 key 值为整数的字典
my_dict2 = {1: 'apple', 2: 'ball'}

# 创建 key 值为 string 的字典
my_dict3 = {'name1': 'apple', 'name2': 'ball'}

# 创建 key 值为 数字 和 string 混合的字典
my_dict4 = {'name': 'apple', 1: [2, 4, 3]}

# 用 dict() 函数创建字典
my_dict5 = dict({1:'apple', 2:'ball'})

# 以元组的形式组成序列创建字典
my_dict6 = dict([(1,'apple'), (2,'ball')])

print('my_dict1:', my_dict1)
print('my_dict2:', my_dict2)
print('my_dict3:', my_dict3)
print('my_dict4:', my_dict4)
print('my_dict5:', my_dict5)
print('my_dict6:', my_dict6)

结果如下：

    my_dict1: {}
    my_dict2: {1: 'apple', 2: 'ball'}
    my_dict3: {'name1': 'apple', 'name2': 'ball'}
    my_dict4: {'name': 'apple', 1: [2, 4, 3]}
    my_dict5: {1: 'apple', 2: 'ball'}
    my_dict6: {1: 'apple', 2: 'ball'}

也可以通过下面的方式来创建空白字典

# 创建空白字典的另一种方式
my_dict7 = dict()

# print('my_dict7:', my_dict7)
my_dict7

结果如下：

{}

获取字典中的元素

通过 key 来获取 value

获取字典中的元素，可以直接通过 key 值来获取对应的 value，如下：

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]}

print(my_dict8['name'])
print(my_dict8.get('name'))

结果如下：

    John
    John

请注意，如果字典的key值中没有该元素，则不能获取相应的 value，这种情况下产生错误。

print(my_dict8['name1'])

结果如下：

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

    KeyError                                  Traceback (most recent call last)

    <ipython-input-4-eedb02e2ace8> in <module>
    ----> 1 print(my_dict8['name1'])
    
    KeyError: 'name1'

通过 value 来获取 key

通过 value 来获取 key 值，在 Python 中并没有提供直接的方法，我们可以通过自定义函数来实现，如下：

def get_keys(d, value):
    return [k for k,v in d.items() if v == value]

函数中，d 是字典。

在字典中修改或添加元素

在字典中，可以修改已有 key 对应的 value 值，或者添加新的 key-value 键值对数据，如下：

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]}

# 修改已有 key 对应的 value 的值
my_dict8['age'] = 98

# 添加新的 key-value 数据组
my_dict8['gender'] = 'man'

my_dict8

结果如下：

    {'name': 'John', 'age': 98, 1: [2, 4, 3], 'gender': 'man'}

从字典中删除元素

从字典中删除元素，或者删除整个字典，有以下一些方式。

pop() 方法

移除字典数据pop()方法的作用是：删除指定给定键所对应的值，返回这个值并从字典中把它移除。

# 使用 pop()方法来删除
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]}

my_dict8.pop('age')

my_dict8

结果如下：

    {'name': 'John', 1: [2, 4, 3]}

del 方法

# 使用 del 方法来删除
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]}

del my_dict8['name']

my_dict8

结果如下：

    {'age': 25, 1: [2, 4, 3]}

popitem() 方法

# 使用 popitem()方法来删除
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 
            'gender': 'man', 'school': 'UCI', 'city': 'NewYork'}

my_dict8.popitem()

my_dict8

结果如下：

    {'name': 'John', 'age': 25, 1: [2, 4, 3], 'gender': 'man', 'school': 'UCI'}

关于 popitem() 方法：

在Python 3.5版本以及之前的时候，使用 popitem() 可能是随机删除的，但我曾经用的 Python3.6版本，好像不是随机删除的，是删除的最后一项。

从 Python 3.7 版本开始，使用 popitem() 方法是删除最后一项，因为字典默认是记住了顺序的：

Ordered dictionaries are just like regular dictionaries but have some extra capabilities relating to ordering operations. They have become less important now that the built-in dict class gained the ability to remember insertion order (this new behavior became guaranteed in Python 3.7).

另外，我查阅了一下 Python3.7 版本中的描述，如下：

popitem()

Remove and return a (key, value) pair from the dictionary. Pairs are returned in LIFO order.

popitem() is useful to destructively iterate over a dictionary, as often used in set algorithms. If the dictionary is empty, calling popitem() raises a KeyError.

Changed in version 3.7: LIFO order is now guaranteed. In prior versions, popitem() would return an arbitrary key/value pair.

https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

在 Python3.7 版本中，是按照 LIFO 的原则进行删除的，是有序进行删除的。

LIFO （Last-in, first-out）即后进来的先删除（也可理解为按后面往前的排序进行删除）

clear()方法

clear()方法是用来清除字典中的所有数据，因为是原地操作，所以返回 None（也可以理解为没有返回值）

# 使用 clear()方法来清空字典中的所有数据，返回的是一个空字典
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

my_dict8.clear()

my_dict8

结果如下：

{}

del 方法

del 方法可以删除字典中指定 key 值的内容。

另外， del 可以删除整个字典，与 clear() 方法的清空字典中所有数据是不一样的。演示如下：

使用 del方法是删除字典中指定 key 值对应的内容

# 使用 del方法是删除字典中指定 key 值对应的内容
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

del my_dict8['age']

my_dict8

结果如下：

    {'name': 'John', 1: [2, 4, 3], 'gender': 'man'}

使用 del方法是删除整个字典，删除后，再运行程序，会报错误

# 使用 del方法是删除整个字典，删除后，再运行程序，会报错误
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

del my_dict8

my_dict8

结果如下：

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

    NameError                                 Traceback (most recent call last)

    <ipython-input-11-3d2a02242727> in <module>
          4 del my_dict8
          5 
    ----> 6 my_dict8
    

    NameError: name 'my_dict8' is not defined

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典可打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

len(), str(), type() 函数

my_dict6 = dict([(1,'apple'), (2,'ball')])
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

print(len(my_dict8))
print(str(my_dict6))
print(type(my_dict8))

结果如下：

    4
    {1: 'apple', 2: 'ball'}
    <class 'dict'>

Python字典包含以下一些方法：

函数	函数描述
clear()	删除字典内所有元素，返回空字典
copy()	返回一个字典的浅复制
fromkeys(seq[, val])	创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
get(key, default=None)	返回指定键的值，如果值不在字典中返回 default 值
items()	以列表返回可遍历的(键, 值) 元组数组
keys()	以列表返回一个字典所有的键
setdefault(key, default=None)	和 get()类似, 但如果键不存在于字典中，将会添加键并将值设为 default
update(dict2)	把字典 dict2 的键/值对更新到 dict里
values()	以列表返回字典中的所有值
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。 key 值必须给出。否则，返回 default值。
popitem()	随机返回并删除字典中的一对键和值。 Python 3.6及以后版本，以 LIFO 的原则进行删除的，是有序进行删除的。

clear(), get(), pop(), popitem() 等在上面已介绍的方法，这里不做重复，仅演示其他方法的使用。

copy, keys, values, items 方法

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

print('copy:', my_dict8.copy())
print('keys:', my_dict8.keys())
print('values:', my_dict8.values())
print('items:', my_dict8.items())

结果如下：

    copy: {'name': 'John', 'age': 25, 1: [2, 4, 3], 'gender': 'man'}
    keys: dict_keys(['name', 'age', 1, 'gender'])
    values: dict_values(['John', 25, [2, 4, 3], 'man'])
    items: dict_items([('name', 'John'), ('age', 25), (1, [2, 4, 3]), ('gender', 'man')])

update 方法

通过 update 方法，可以更新字典的数据内容：

my_dict6 = {'name': 'Lemon', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

my_dict8.update(my_dict6)

my_dict8

结果如下：

    {'name': 'Lemon', 'age': 25, 1: [2, 4, 3], 'gender': 'man'}

fromkeys 方法

fromkeys（）方法的演示如下：

请注意，该结果与 zip（）方法之后的结果是不一样的。

seq = ['name', 'age', 'city']
value = ['Lemon', 18, 'cs']

my_dict9 = dict.fromkeys(seq, value)

my_dict9

结果如下：

    {'name': ['Lemon', 18, 'cs'],
     'age': ['Lemon', 18, 'cs'],
     'city': ['Lemon', 18, 'cs']}

zip（）方法

seq = ['name', 'age', 'city']
value = ['Lemon', 18, 'cs']

my_dict10 = dict(zip(seq, value))

my_dict10

结果如下：

    {'name': 'Lemon', 'age': 18, 'city': 'cs'}

setdefault 方法

dict.setdefault(key, default=None)

该方法接收两个参数，第一个参数是健的名称，第二个参数是默认值。

假如字典中不存在给定的键，则把默认值赋值给对应的value，并返回默认值；

反之，不修改value，只返回value。

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

print('字典中存在的key，返回对应value：', my_dict8.setdefault('age', 0))
print('字典中不存在的key，返回默认值：', my_dict8.setdefault('age1', 0))

结果如下：

    字典中存在的key，返回对应value： 25
    字典中不存在的key，返回默认值： 0

此外，还可以用 setdefault() 方法统计一个列表里单词出现的次数：

# 用 setdefault() 方法统计一个列表里单词出现的次数
strings = ('Lemon', 'kitten', 'Lemon', 'Lemon',
           'lemon_zs', 'Lemon', 'Lemon', 'lemon_zs')
counts = {}
for kw in strings:
    counts[kw] = counts.setdefault(kw, 0) + 1

counts

结果如下：

    {'Lemon': 5, 'kitten': 1, 'lemon_zs': 2}

02 字典推导式（dict comprehension）

字典推导式的一般表达式如下：

{key: value for (key, value) in iterable}

有些用法与列表推导式是类似的，可以参考下面的内容：

用字典推导式的方法创建字典：

my_dict01 = {x: x*x for x in range(6)}

my_dict01

结果如下：

    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

通过两个list创建字典：

keys = ['name', 'age', 'city']
values = ['Lemon', 18, 'cs']

my_dict02 = {k:v for (k,v) in zip(keys,values)}

my_dict02

结果如下：

    {'name': 'Lemon', 'age': 18, 'city': 'cs'}

在特定条件下，用字典推导式的方法创建字典：

my_dict03 = {x: x*x for x in range(10) if x%2==0}

my_dict03

结果如下：

    {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

03 嵌套型字典

什么是嵌套型的字典

字典是以 key、value 的形式创建的，而嵌套型的字典有一个特征，就是 key 对应的 value 值也可以是一个字典。最简洁的嵌套型字典如下：

d = {key1 : {key3 : value3}, 
     key2 : {key4 : value4} }

创建一个嵌套型字典

nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'},
                2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}}
nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
     2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changsha'}}

上述的嵌套型字典中，字典第一层的 key 分别是 1 和 2，而他们对应的 value 值又是都是字典，里面的字典的 key 都是 “name”, “age” 和 “city”，但对应的 value 不一样。

从嵌套型字典中获取元素

从嵌套型字典中获取元素，跟从 list，以及数组中获取元素时有些类似的。

嵌套型字典用 [] 进行不同层级元素的获取。

nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'},
                2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}}

print(nested_dict01[1]['name'])
print(nested_dict01[2]['city'])

结果如下：

    Lemon
    changsha

修改嵌套型字典的元素（更改、增加或删除元素）

针对嵌套型字典，同样是可以更新、增加或删除元素的.

增加一个空的字典

nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'},
                2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}}

# 增加一个空的字典
nested_dict01[3] = {}

nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
     2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changsha'},
     3: {}}

修改或增加新的元素

# 修改元素内容
nested_dict01[2]['age'] = '26'

# 增加新的元素
nested_dict01[3]['name'] = 'zws'
nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
     2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'},
     3: {'name': 'zws'}}

在嵌套型字典中直接添加一个字典

# 在嵌套型字典中直接添加一个字典
nested_dict01[5]={'name': 'rx', 'age':'3', 'city':'ly'}
nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
{'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'},
{'name': 'zws'},
{'name': 'rx', 'age': '3', 'city': 'ly'}}

删除某个具体元素内容

# 删除某个具体元素内容
del nested_dict01[5]['city']
nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
{'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'},
{'name': 'zws'},
{'name': 'rx', 'age': '3'}}

删除嵌套字典里面的某个字典

# 删除嵌套字典里面的某个字典
del nested_dict01[5]
nested_dict01

结果如下：

    {1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
     2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'},
     3: {'name': 'zws'}}

通过 for 循环来获取嵌套字典内的元素

for main_id, main_info in nested_dict01.items():
    print('\nmain id: ', main_id)
    
    for key in main_info:
        print(key+':', main_info[key])

结果如下：

    
    main id:  1
    name: Lemon
    age: 18
    city: cs
    
    main id:  2
    name: Lemon_zs
    age: 26
    city: changsha
    
    main id:  3
    name: zws

用 pprint 输出嵌套型字典

用 pprint 可以使字典显示层次更清晰，需要安装 pprint，安装命令如下：

pip install pprint

演示如下：

# 需要安装 pprint
# pip install pprint
# pprint 可以使字典显示层次更清晰
import pprint

menu = {'dinner':{'chicken':'good','beef':'average',
                  'vegetarian':{'tofu':'good',
                                'salad':{'caeser':'bad',
                                         'italian':'average'}},
                  'pork':'bad'}}
pprint.pprint(menu)

结果如下：

    {'dinner': {'beef': 'average',
                'chicken': 'good',
                'pork': 'bad',
                'vegetarian': {'salad': {'caeser': 'bad', 'italian': 'average'},
                               'tofu': 'good'}}}

嵌套型字典的一些用途

可能有些疑惑，字典嵌套这么多层，在哪些地方可以用呢？

这里分享一个用途。嵌套型字典，经常在机器学习中的决策树算法中涉及到。

比如下面的 menu，是一个字典。它也可以用树的形式显示出来，这在决策树中会经常用到。

menu = {'dinner':{'chicken':'good','beef':'average',
                  'vegetarian':{'tofu':'good',
                                'salad':{'caeser':'bad',
                                         'italian':'average'}},
                  'pork':'bad'}}

示例：

from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import tree
from sklearn.datasets import load_wine
from IPython.display import SVG
from graphviz import Source
from IPython.display import display
# load dataset
data = load_wine()

# feature matrix
X = data.data

# target vector
y = data.target

# class labels
labels = data.feature_names

# print dataset description
# print(data.DESCR)
estimator = DecisionTreeClassifier()
estimator.fit(X, y)

graph = Source(tree.export_graphviz(estimator, out_file=None
   , feature_names=labels, class_names=['0', '1', '2'] 
   , filled = True))
display(SVG(graph.pipe(format='svg')))

可视化效果如下：

04 小结

以上就是 python 中关于字典使用的基础内容，在实践中，咱们还会大量应用到字典。相对来说，嵌套字典会比较复杂些。当我们熟练使用字典的基本方法时，还是可以应对这些问题的。

有时候，也会有一些比较独特的字典，比如 key-value 键值对中的 value 是 pandas 中的 dataframe ，其基础原理，一些常用的方法还是一样的。

Pandas实用技能，将列（column）排序的几种方法

Sat, 07 Aug 2021 00:00:00 +0000

Pandas实用技能，将列（column）排序的几种方法

Table of Contents

Pandas实用技能，将列（column）排序的几种方法

Pandas实用技能，将列（column）排序的几种方法

大家好，我是阳哥。

Pandas 可以说是在Python数据科学领域应用最为广泛的工具之一。

Pandas是一种高效的数据处理库，它以 dataframe 和 series 为基本数据类型，呈现出类似excel的二维数据。

在数据处理过程中，咱们经常需要将列按照一定的要求进行排序，以方便展示。

这里，阳哥来给大家分享下在 Pandas 中将列排序的几种常用方法。

数据准备

文中主要使用了 pandas 和 akshare ，首先导入 Python 库，如下：

import pandas as pd
import akshare as ak

print(f'pandas version: {pd.__version__}')

本次使用的数据如下：

data = {
    'brand':['Python数据之道','价值前瞻','菜鸟数据之道','Python','Java'],
    'B':[4,6,8,12,10],
    'A':[10,2,5,20,16],
    'D':[6,18,14,6,12],
    'years':[4,1,1,30,30],
    'C':[8,12,18,8,2],
}

df = pd.DataFrame(data=data)
df

现将现有的 columns 输出，方便后面 copy 使用。

df.columns

# Index(['brand', 'B', 'A', 'D', 'years', 'C'], dtype='object')

Method 1

第一种方法，也是我自己常用的方法，就是自己将列的名称按需要进行手动排序，然后运行代码如下：

Method 2

第二种方法，是使用 .iloc 方法，通过列的位置来进行排序，如下：

Method 3

第三种方法，是使用 .loc 方法，通过列的名称来进行排序，如下：

这种方法跟第一种方法类似，个人觉得第一种方法更简洁些。

Method 4

第四种是逆序排序，算是排序中一种特定的排序方式。

# Method 4 ,逆序

cols = list(df.columns)

cols.reverse()

df[cols]

上述代码中，cols.reverse() 是将列表（list）进行逆序排序。

此外，列表（list）的逆序排序，还可以用 cols[::-1] 来实现。因此，下面的方法也可以实现逆序排序。

# Method 4 ,逆序

cols = list(df.columns)

df[cols[::-1]]

关于 Python数据类型 list 的介绍，详细内容可以前往下面的链接：

实战案例：自由排序

有时候，当存在变量、列的数量较多，或者不同的dataframe中列的名称不完全一致等情况出现时，咱们不一定会通过列名称来实现排序。

这里分享一个实战案例，是关于制作基金的十大持仓数据表的，具体过程我就不在这里描述了，下面给出实现的函数，有兴趣的同学可以研究下。

自定义函数如下：

# 需要安装 akshare
# pip install akshare

years = ['2019','2020','2021']

def fund_stock_holding(years,code):
    data = pd.DataFrame()
    for yr in years:
        df_tmp = ak.fund_em_portfolio_hold(code=code,year=yr)
        data = data.append(df_tmp)

    data['季度']=data['季度'].apply(lambda x:x[:8])
    data['占净值比例'] = pd.to_numeric(data['占净值比例'])
    data = data.sort_values(['季度','持仓市值'],ascending=[True,False])
    df = data.set_index(['序号','季度']).stack().unstack([1,2]).head(10)
    # df1.loc[:,(slice(None), ['股票名称','占净值比例'])]
    df = df.loc[:,(slice(None), '股票名称')]
    df = df.droplevel(None,axis=1)
    df.columns.name=None
    df = df.reset_index()
#     df.index.name = None
    df['基金代码'] = code
    return df
    
df = fund_stock_holding(years,'005669')
df

得到的数据表格如下：

上面的表格中，我需要将 基金代码 这一列移动到 序号 这列的后面，由于 years = ['2019','2020','2021'] 这是一个变量，当具体的值不同时，会导致列名称不一样，因此，在这种情况下我们不能直接使用列的具体名称，但咱们可以通过列的位置组合来实现，列的调整具体如下：

    cols = df.columns.tolist()
    cols = cols[:1] + cols[-1:] + cols[1:-1]  # 将基金代码列名放前面
    df = df[cols]

将上面的调整过程整合到自定义函数中，完整的代码如下：

# 需要安装 akshare
# pip install akshare

years = ['2019','2020','2021']

def fund_stock_holding_update(years,code):
    data = pd.DataFrame()
    for yr in years:
        df_tmp = ak.fund_em_portfolio_hold(code=code,year=yr)
        data = data.append(df_tmp)

    data['季度']=data['季度'].apply(lambda x:x[:8])
    data['占净值比例'] = pd.to_numeric(data['占净值比例'])
    data = data.sort_values(['季度','持仓市值'],ascending=[True,False])
    df = data.set_index(['序号','季度']).stack().unstack([1,2]).head(10)
    # df1.loc[:,(slice(None), ['股票名称','占净值比例'])]
    df = df.loc[:,(slice(None), '股票名称')]
    df = df.droplevel(None,axis=1)
    df.columns.name=None
    df = df.reset_index()
#     df.index.name = None
    df['基金代码'] = code
    cols = df.columns.tolist()
    cols = cols[:1] + cols[-1:] + cols[1:-1]  # 将基金代码列名放前面
    df = df[cols]
    return df
    
df = fund_stock_holding_update(years,'005669')
df

效果如下：

当然，我最后实现的效果是将基金代码换成基金名称，这个可以想办法实现，效果如下：

小结

以上就是关于 Pandas 中列名称排序的介绍，看似很简单的内容，在最后的实践中，也还是有些小技巧的。

欢迎大家来畅聊，Pandas 中有哪些实用的小技巧~~

对我的文章感兴趣的朋友，可以关注我的微信公众号「Python数据之道」（ID：PyDataLab），接收我的更新通知。

Pandas实用技能，数据筛选query函数详细介绍

Wed, 28 Jul 2021 00:00:00 +0000

Pandas实用技能，数据筛选query函数详细介绍

Table of Contents

Pandas实用技能，数据筛选query函数详细介绍

Pandas实用技能，数据筛选query函数详细介绍

大家好，我是阳哥。

Pandas 可以说是在Python数据科学领域应用最为广泛的工具之一。

Pandas是一种高效的数据处理库，它以 dataframe 和 series 为基本数据类型，呈现出类似excel的二维数据。

在数据处理过程中，咱们经常会用到数据筛选，Pandas 中提供了数据筛选的多种方法，这里，阳哥来给大家分享下在Pandas中应用 query 函数来进行数据筛选。

query 函数的一般用法如下：

df.query('expression')

文中的代码是在 Jupyter Notebook 中运行的（也可以是其他IDE），本次使用的 Pandas 版本是 1.3.0 版，如下：

import pandas as pd

print(f'pandas version: {pd.__version__}')

# pandas version: 1.3.0rc1

在开始之前，先创建一份数据，供后续使用：

data = {
    'brand':['Python数据之道','价值前瞻','菜鸟数据之道','Python','Java'],
    'A':[10,2,5,20,16],
    'B':[4,6,8,12,10],
    'C':[8,12,18,8,2],
    'D':[6,18,14,6,12],
    'till years':[4,1,1,30,30]
}

df = pd.DataFrame(data=data)
df

数据如下：

常用方法

筛选 “brand” 列中值为 “Python数据之道” 的行，如下：

df.query('brand == "Python数据之道"')

结果如下：

说明一下，上面代码中的单引号和双引号是可以互换的，下面的写法，其结果也是一样的：

df.query(" brand == 'Python数据之道' ")

上面用 query 函数筛选数据，用下面的方法也是可以实现的：

df[df['brand']=="Python数据之道"]

上面是筛选字符串的值，也可以是筛选数字，如下：

通过数学表达式筛选

除了直接通过等于某个值来筛选， query 函数还支持通过数学表达式来进行数据筛选，包括 >、 <、 +、 -、 *、 / 等。

示例如下：

通过变量筛选

在程序比较长的时候，经常会使用变量来作为筛选条件， query 函数在使用变量作为判断标准时，通过在变量前面添加 @ 符号来实现，示例如下：

# 通过变量来筛选数据，在变量前使用 @ 符号即可

name = 'Python数据之道'

df.query('brand == @name')

列表数据筛选

当需要在某列中筛选多个符合要求的值的时候，可以通过列表（list）来实现，示例如下：

# 需要注意下 双引号 和 单引号的分开使用

df.query('brand in ["Python数据之道","价值前瞻"]')
# df.query("brand in ['Python数据之道','价值前瞻']")

多条件筛选

有很多情况下，咱们需要通过多个条件来筛选数据，query 函数支持多种条件的组合，

两者都需要满足的并列条件使用符号 & ,或单词 and
只需要满足其中之一的条件使用符号 | ,或单词 or

示例如下：

列名称有空格的情况

当 dataframe 的列名称中有空格或其他特殊符号的时候，需要使用 反引号（backtick mark），即键盘ESC键下面的按键(就是键盘上第二排第一个按键，有‘~’这个符号的按键) 来将列名包裹起来，示例如下：

df.query("`till years` < 5")

注意，如果使用单引号，将会报错，如下：

筛选后选取数据列

在数据筛选后，还可以选择需要的数据列，如下：

小结

以上就是关于 Pandas 中 query 函数的主要内容介绍，应用 query函数进行数据筛选，其语言还是比较简洁的，尤其是当条件比较多的时候，会显得更优雅。

比如下面的对比，假设都是三个筛选条件（假设数据量较多，符合的结果也较多）：

没有使用query函数时

df[(df['brand']=="Python数据之道") & (df['A'] >2) & (df['C'] >4)]

可以看出上面的表达式是比较长的，略显繁琐。

使用query函数时

df.query(" brand == 'Python数据之道' & A>2 & C>4 ")

相对来说，使用query 函数会显得更加简洁，如果觉得这个功能不错，就赶紧用起来吧~~

对我的文章感兴趣的朋友，可以关注我的微信公众号「Python数据之道」（ID：PyDataLab），接收我的更新通知。

Plotly Express 可视化使用指南

Thu, 22 Jul 2021 00:00:00 +0000

Plotly Express 可视化使用指南

Table of Contents

Plotly Express 可视化使用指南

Plotly Express 可视化使用指南

作者阳哥

出品 Python数据之道（ID：PyDataLab）

Plotly Express 是 Python 交互式可视化库 Plotly 的高级组件，受 Seaborn 和 ggplot2 的启发，它专门设计为具有简洁，一致且易于学习的 API ：只需一次导入，您就可以在一个函数调用中创建丰富的交互式绘图，包括分面绘图（faceting）、地图、动画和趋势线等。

使用 Plotly Express 可以轻松地进行数据可视化，一旦导入Plotly Express（通常简称 px ），大多数绘图只需要一个函数调用，接受一个整洁的 Pandas dataframe，并简单描述你想要制作的图。如果你想要一个基本的散点图，它只是px.scatter（dataframe，x =“column_name”，y =“column_name”）。

Plotly Express 语法简洁，同时功能强大，可以绘制咱们遇到的大部分图表类型，比如线形图、散点图、柱状图、面积图、树形图、旭日图、甘特图等，本文将从如下20个方面，详细介绍 Plotly Express 的使用，看完内容介绍后，相应你也会喜欢上这个工具的。

部分动态图如下：

Plotly 以及 Plotly Express 是交互式可视化工具，阳哥录制了一段简短的视频，来展示下其强大与优雅之处。

视频：Plotly Express 可视化图表

00 环境与数据准备

环境准备

现在 Plotly Express 不需要单独安装，它是包含在 Plotly 中的，用 pip install plotly 命令可以安装 Plotly，如果你用的是 Anaconda，也可以用 conda install plotly 命令来安装，然后导入如下：

import plotly.express as px

本文中，还用到 Pandas 等工具，完整的导入如下：

import plotly.express as px
import plotly.io as pio
import plotly.graph_objects as go
import pandas as pd

本文代码测试的时候，使用的环境如下：

Mac系统
Jupyter Notebook
Python版本为 v3.8
Plotly version: 5.1.0
Pandas version: 1.3.0rc1

数据准备

本文涉及的图形种类比较多，原本阳哥想用一份数据来覆盖这些图形的，后来发现不太现实，因此使用了多份数据。

对于大部分图形，阳哥在文中使用的是 covid-19 的数据，此外，还使用了跟股票投资相关的一些数据。

这里，先介绍下 covid-19 相关的数据。

我们需要读取并整理出需要的DataFrame，以便在后续可视化时使用。

分为三个小的步骤

(a) 读取数据及调整格式

data = pd.read_csv('./data/covid-19.csv',parse_dates=['date'],index_col=0)

# 将数据复制一份
df_all = data.copy()

# 将时间格式转为字符串格式的日期，以 YYYY-mm-dd 的形式保存
df_all['dates'] = df_all['date'].apply(lambda x:x.strftime('%Y-%m-%d'))

# 添加现存确诊列
df_all['current'] = df_all['confirmed'] - df_all['cured'] - df_all['dead']

df_all.fillna('', inplace=True)

print(df_all.info())

df_all

(b) 获取全球的数据

# 国内总计数量
df_cn = df_all.query("country=='中国' and province==''") 
df_cn = df_cn.sort_values('date',ascending=False)

# 国外，按国家统计
df_oversea = df_all.query("country!='中国'") 
df_oversea = df_oversea.fillna(value="")
df_oversea = df_oversea.sort_values('date',ascending=False)

df_global =  df_cn.append(df_oversea)
df_global = df_global.sort_values(['country','date'])
df_global

countries_all = list(df_global['country'].unique())

df_global_new = pd.DataFrame()

for item in countries_all:
    df_item = df_global.query('country==@item')
    df_i = df_item.copy(deep=False)
    df_i['new-confirmed'] = df_i['confirmed'].diff()
    df_i['new-cured'] = df_i['cured'].diff()
    df_global_new = df_global_new.append(df_i)
    
df_global_new = df_global_new.dropna()

df_global_new

这两个 DataFrame： df_global 和 df_global_new我们会在后续可视化时多次用到。

说明：

文中使用的数据文件，在文末提供获取方式。

01 线形图（Line）

线形图是所有可视化工具中最常见的图表之一，在 px 中，用 px.line() 来进行可视化。

单条曲线

def plot_line():
    df = df_global.groupby('date')[['confirmed','current','cured','dead']].sum()
    df['new-confirmed'] = df['confirmed'].diff()
    df = df.dropna()
    df = df.sort_index().loc['20200122':,:]
    fig = px.line(df,x=df.index,y='confirmed')
    return fig

fig = plot_line()
# fig.write_image('./images/px/01-line-1.png')
fig.show()

代码函数说明：

需要说明的是，在最简洁的情况下，绘制线形图只需要用 px.line(df,x =“column_name”，y =“column_name”) 来绘制即可，比如上面示例中的 px.line(df,x=df.index,y='confirmed')

由于本文涉及可视化图表比较多，需要调整的DataFrame也比较多，因此，阳哥一般以自定义函数的形式进行封装，这样显得逻辑要清楚些。

实际上， Plotly Express 默认的可视化，一般就是一行代码，这点咱们需要在脑海里有个印象。

同时，在本文后续的图表可视化中，也是以这种形式进行的。

图片保存

在使用 Plotly 绘制图片时，是可以将静态图片保存下来的，具体方法请前往下面的链接查看：

Plotly中如何保存jpeg等图片？

多条曲线绘制

在 Plotly v4.8 版本以后，支持同时绘制多条曲线，其语法格式为 px.line(df,x =“column_name”，y =[“column_name_1”,“column_name_2”,“column_name_3”,……])

示例如下：

def plot_line_multi():
    df = df_global.groupby('date')[['confirmed','current','cured','dead']].sum()
    df['new-confirmed'] = df['confirmed'].diff()
    df = df.dropna()
    df = df.sort_index().loc['20200122':,:]
    fig = px.line(df,x=df.index,y=['confirmed','current','dead'])
    return fig

fig = plot_line_multi()
# fig.write_image('./images/px/01-line-2.png')
fig.show()

分列绘制曲线

Plotly Express 支持绘制分列或行的曲线图，通过设置参数 facet_row 或 facet_col 来实现，示例如下：

# 绘制分列或行的曲线图
def plot_line_facet():  
    df = df_global_new.set_index('date').loc['20201204':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    df = df[df['country'].isin(countries_list)]
    fig = px.line(df,
              x=df.index,
              y='new-confirmed',
              color='country',
              line_group='country',
              facet_col='country',
#               log_y=True,
             )
    fig.update_traces(mode='markers+lines')
    return fig

fig = plot_line_facet()
# fig.write_image('./images/px/01-line-3.png')
fig.show()

在 Plotly Express 中，不止 px.line() 支持参数 facet_row 或 facet_col ，还有其他一些图形也是支持的，比如散点图、柱状图等，大家可以在 Jupyter Notebook 中查看其是否有这两个参数：

02 面积图（Area）

面积图，跟线形图有点类似，曲线下带阴影面积，因此称之为面积图。

Plotly Express 中通过 px.area() 来实现，示例如下：

# 绘制填充的面积曲线图
def plot_area():
    df = df_global_new.set_index('date').loc['20200904':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    df = df[df['country'].isin(countries_list)]

    fig = px.area(df,
                  x=df.index,
                  y='confirmed',
                  color='country',
                  line_group='country'
                 )
    return fig

fig = plot_area()
# fig.write_image('./images/px/02-area-1.png')
fig.show()

03 散点图（Scatter）

散点图，也是咱们常用的图形之一，Plotly Express 中通过 px.scatter() 来实现，示例如下：

def plot_scatter_line():
    df = df_global.groupby('date')[['confirmed','current','cured','dead']].sum()
    df['new-confirmed'] = df['confirmed'].diff()
    df = df.dropna()
    df = df.sort_index().loc['20200122':,:]
    fig = px.scatter(df,x='confirmed',y='dead')
    return fig

fig = plot_scatter_line()
# fig.write_image('./images/px/03-sactter-1.png')
fig.show()

上面这张图，初看起来，跟线形图有点类似，实际它是散点图，只是点比较密集。

再来看一个示例，对全球多个国家的数据进行可视化后，散点分布就明显了：

def plot_scatter():
    df = df_global_new.set_index('date').loc['20201208':'20201208']
    df = df.sort_values('confirmed',ascending=False).head(30)
    fig = px.scatter(df,x='confirmed',y='dead',
                     color='country',size='confirmed'
                    )
    return fig

fig = plot_scatter()
# fig.write_image('./images/px/03-sactter-2.png')
fig.show()

散点矩阵图

在 Plotly Express 中，针对散点矩阵图，专门有一个API来实现 px.scatter_matrix()，示例如下：

def plot_scatter_matrix():
    df = df_global_new.set_index('date').loc['20201208':'20201208']
    df = df.sort_values('confirmed',ascending=False).head(30)
    fig = px.scatter_matrix(df,dimensions=['confirmed','cured','dead'],
                        color='country',
#                         size='confirmed'
                )
    return fig

fig = plot_scatter_matrix()
# fig.write_image('./images/px/03-sactter-3.png')
fig.show()

04 饼图（Pie）

绘制饼图时，用的是跟股票投资相关的数据，数据如下：

数据文件可在文末获取

上面这份数据，可以更方便的以饼图的形式来展示，在 Plotly Express 中，通过 px.pie() 来进行饼图的可视化，示例如下：

fig = px.pie(df_invest,values='持有市值',names='指数名称')
fig.update_traces(textposition='inside', 
                  textinfo='percent+label'
                 )
# fig.write_image('./images/px/04-pie-1.png')
fig.show()

通过设置参数 hole，还可以将饼图变为环形图，如下：

fig = px.pie(df_invest,values='持有市值',
             names='指数名称',
             hole=0.6
            )
fig.update_traces(textposition='inside', 
                  textinfo='percent+label'
                 )
# fig.write_image('./images/px/04-pie-2.png')
fig.show()

05 柱状图（Bar）

柱状图，是数据可视化中必不可少的基础图形，在 Plotly Express 中，通过 px.bar() 来实现。

垂直柱状图

默认情况下，px.bar() 绘制的是垂直柱状图，示例如下：

def plot_bar():
    df = df_global_new.set_index('date').loc['20201208':'20201208']
    df = df.sort_values('confirmed',ascending=False).head(30)
    fig = px.bar(df,x='country',y='confirmed',color='country')
    return fig

fig = plot_bar()
# fig.write_image('./images/px/05-bar-1.png')
fig.show()

水平柱状图

通过设置参数 orientation 的值，可以绘制水平柱状图，示例如下：

def plot_bar_h():
    df = df_global_new.set_index('date').loc['20201208':'20201208']
    df = df.sort_values('confirmed',ascending=False).head(30)
    fig = px.bar(df,x='confirmed',y='country',
                 color='country',orientation='h'
                )
    return fig

fig = plot_bar_h()
# fig.write_image('./images/px/05-bar-2.png')
fig.show()

对数坐标

上面的水平柱状图，由于最大的数值和最小的数值差异比较大，用数据绝对值进行可视化时，图表的展示效果可能不是太好，这个时候，可以考虑用对数坐标来展示，通过设置参数 log_x 或 log_y 来实现，如下：

def plot_bar_log():
    df = df_global_new.set_index('date').loc['20201208':'20201208']
    df = df.sort_values('confirmed',ascending=False).head(30)
    fig = px.bar(df,x='confirmed',y='country',
                 color='country',orientation='h',
                 log_x=True  # log_x 对数坐标
                )
    return fig

fig = plot_bar_log()
# fig.write_image('./images/px/05-bar-3.png')
fig.show()

柱状图的展现方式

当同一系列中有不同的类型时，绘制柱状图的时候，通常有堆积和分组两种展示形式，默认情况下，是堆积柱状图，如下：

def plot_bar_stack():
    df = df_global_new.set_index('date').loc['20201201':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    df = df[df['country'].isin(countries_list)]
    fig = px.bar(df,x=df.index,
                 y='confirmed',
                 color='country'
                )
    return fig

fig = plot_bar_stack()
# fig.write_image('./images/px/05-bar-4.png')
fig.show()

通过设置参数 barmode="group" 可以转变为分组的柱状图，如下：

def plot_bar_group():
    df = df_global_new.set_index('date').loc['20201201':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    df = df[df['country'].isin(countries_list)]
    fig = px.bar(df,x=df.index,
                 y='confirmed',
                 color='country',
                 barmode='group'
                )
    return fig

fig = plot_bar_group()
# fig.write_image('./images/px/05-bar-6.png')
fig.show()

此外，在 Plotly 5.1版本中，还支持设置样式形状，有两个相关的参数，pattern_shape 和 patter_shape_sequence，如下：

def plot_bar_shape():
    df = df_global_new.set_index('date').loc['20201201':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    df = df[df['country'].isin(countries_list)]
    fig = px.bar(df,x=df.index,
                 y='confirmed',
                 color='country',
                 pattern_shape="country", 
                 pattern_shape_sequence=[".", "x", "+",'/','\\'],
                )
    return fig

fig = plot_bar_shape()
# fig.write_image('./images/px/05-bar-5.png')
fig.show()

06 箱形图（Box）

又称为盒须图、盒式图或箱线图，是一种用作显示一组数据分散情况资料的统计图，因形状如箱子而得名。它能显示出一组数据的最大值、最小值、中位数、及上下四分位数。

在股票以及指数基金投资时，我个人喜欢用箱形图来对标的的估值分布情况进行可视化，效果如下：

因此，针对箱形图，我准备了一份类似的数据，是ETF的净值数据，数据结构如下：

针对ETF的累计净值数据绘制箱形图，通过 px.box() 来实现，如下：

fig = px.box(df3,x='code',y='累计净值',color='code')
# fig.write_image('./images/px/06-box-1.png')
fig.show()

通过设置参数 orientation 的值，可以绘制水平箱形图，示例如下：

fig = px.box(df3,x='累计净值',y='code',color='code',orientation='h')
# fig.write_image('./images/px/06-box-2.png')
fig.show()

07 小提琴图（Violin）

小提琴图 (Violin Plot)是用来展示多组数据的分布状态以及概率密度。这种图表结合了箱形图和密度图的特征，主要用来显示数据的分布形状。跟箱形图类似，但是在密度层面展示更好。在数据量非常大不方便一个一个展示的时候小提琴图特别适用。

Plotly Express 中通过 px.violin() 来实现，如下：

fig = px.violin(df3,x='code',y='累计净值',color='code')
# fig.write_image('./images/px/07-violin-1.png')
fig.show()

上面的图只展示了数据密度分布情况，没有显示箱体及具体的分位数值情况，可以通过设置参数 box=True 来显示箱体，如下：

fig = px.violin(df3,x='code',y='累计净值',
                color='code',
                box=True)
# fig.write_image('./images/px/07-violin-2.png')
fig.show()

在显示箱体后，可以更好的体现出数据的密度分布以及数值分位情况。

此外，通过设置参数 points='all' ，可以在小提琴图旁边展示数据的密度分布情况，如下：

fig = px.violin(df3,x='code',y='累计净值',
                color='code',
                box=True,
                points='all')
# fig.write_image('./images/px/07-violin-3.png')
fig.show()

同样地，我们也可以以水平的方式来展示小提琴图，通过设置参数 orientation='h' 即可，如下：

fig = px.violin(df3,x='累计净值',y='code',
                color='code',box=True,
                points='all',
                orientation='h'
               )
# fig.write_image('./images/px/07-violin-4.png')
fig.show()

在小提琴图中，数据密度分布是通过设置参数 point 来实现的，在 Plotly Express 中，还有一个专门的函数 px.strip()，来绘制数据密度分布，如下：

fig = px.strip(df3,y='code',x='累计净值')
# fig.write_image('./images/px/07-violin-5.png')
fig.show()

08 联合分布图（Marginal）

还可以创建联合分布图（marginal rugs），使用直方图，箱形图（box）或小提琴来显示双变量分布，也可以添加趋势线。 Plotly Express 甚至可以帮助你在悬停框中添加线条公式和 R² 值！它使用 statsmodels 进行普通最小二乘（OLS）回归或局部加权散点图平滑（LOWESS）。

使用小提琴图和箱形图

def plot_marginal():
    df = df_global_new.query('country=="美国" or country=="印度"')
    fig = px.scatter(df,x='new-confirmed',y='new-cured',
                     color='country',
    #                  size='confirmed',
                     trendline='ols',
                     marginal_x='violin',
                     marginal_y= 'box'
                    )
    return fig

fig = plot_marginal()
# fig.write_image('./images/px/08-marginal-1.png')
fig.show()

使用小提琴图和直方图

def plot_marginal_hist():
    df = df_global_new.query('country=="美国" or country=="印度"')
    fig = px.scatter(df,x='new-confirmed',y='new-cured',
                     color='country',
    #                  size='confirmed',
                     trendline='ols',
                     marginal_x='violin',
                     marginal_y= 'histogram'
                    )
    return fig

fig = plot_marginal_hist()
# fig.write_image('./images/px/08-marginal-2.png')
fig.show()

09 直方图（Histogram）

直方图(Histogram)，又称质量分布图，是一种统计报告图，由一系列高度不等的纵向条纹或线段表示数据分布的情况。一般用横轴表示数据类型，纵轴表示分布情况。

在 Plotly Express 中，通过 px.histogram() 来实现。

默认情况下，纵轴以计数形式（count）表示数据分布情况。

df_hist = df3[df3['code']=='515180']
fig = px.histogram(df_hist,x='return')
# fig.write_image('./images/px/09-hist-1.png')
fig.show()

通过参数 histnorm 可以设置纵轴数据分布的展现方式，其值可以是 'percent', 'probability', 'density', 或 'probability density'

纵轴为百分比的示例如下：

fig = px.histogram(df_hist,x='return',histnorm='percent')
# fig.write_image('./images/px/09-hist-2.png')
fig.show()

通过设置参数 color ，可以同时对多个对象进行可视化，示例如下：

fig = px.histogram(df3,x='return',color='code')
# fig.write_image('./images/px/09-hist-3.png')
fig.show()

10 漏斗图（Funnel）

漏斗图是一种形如漏斗状的明晰展示事件和项目环节的图形。漏斗图由横行或竖形条状形状一层层拼接而成，分别组成按一定顺序排列的阶段层级。每一层都用于表示不同的阶段，从而呈现出这些阶段之间的某项要素/指标递减的趋势。

漏斗图在常常应用于各行业的管理。

网站转化率是指用户通过网站进行了相应目标行动的访问次数与总访问次数的比率，相应的行动可以是用户注册、用户参与、用户购买等一系列用户行为，而漏斗图是最能表示网站转化率的图表。

示例如下：

data = dict(
    number=[10000, 7000, 4000, 2000, 1000],
    stage=["浏览次数", "关注数量", "下载数量", "咨询数量", "成交数量"])
fig = px.funnel(data, x='number', y='stage')
# fig.write_image('./images/px/10-funnel-1.png')
fig.show()

还有一种是面积漏斗图，通过 px.funnel_area() 来实现。

fig = px.funnel_area(names=["第一阶段", "第二阶段", "第三阶段", "第四阶段", "第五阶段"],
                    values=[10000, 7000, 4000, 2000, 1000])
# fig.write_image('./images/px/10-funnel-2.png')
fig.show()

11 平行坐标图（Parallel）

平行坐标图 (parallel coordinate plot) 是可视化高维多元数据的一种常用方法，为了显示多维空间中的一组对象，绘制由多条平行且等距分布的轴，并将多维空间中的对象表示为在平行轴上具有顶点的折线。顶点在每一个轴上的位置就对应了该对象在该维度上的中的变量数值。

平行坐标图可以方便的展示数据标签分类或者数据流向。

数据标签分类的示例如下：

def plot_para():
    df = df_global_new.set_index('date').loc['20201125':'20201208',:]
    countries_list = ['美国','印度','俄罗斯','巴西','法国']
    n = len(countries_list)
    countries_dict = {countries_list[x]:n-x for x in range(n)}
#     countries_dict = {'美国': 5, '印度': 4, '俄罗斯': 3, '巴西': 2, '法国': 1}
    df = df[df['country'].isin(countries_list)]
    df = df.reset_index()
    df = df[['country','confirmed','current','cured','dead']]
    df['country_id'] = df['country'].apply(lambda x: countries_dict[x])
#     print(df)
    fig = px.parallel_coordinates(df,color='country_id', labels={"country_id": "Country",
                      "confirmed": "confirmed", "current": "current",
                      "cured": "cured", "dead": "dead", },
                        color_continuous_scale=px.colors.diverging.Tealrose, 
#                         color_continuous_midpoint=3
                                 )
    return fig

fig = plot_para()
# fig.write_image('./images/px/11-para-1.png')
fig.show()

上图展示的是5个国家的疫情数据特征分布，展示不同国家（国家以 1、2、3、4、5代表）在累计确诊人数、现存确诊人数、累计治愈人数、累计死亡人数的分布情况。

这种类型的平行坐标图适合对数据分类进行可视化。

还有一类平行坐标图，适合对数据流向进行可视化，有点类似桑基图，不过展现形式稍微有点区别。在 Plotly Express 中，通过 px.parallel_categories() 来实现。

下面以投资数据为例，来进行演示：

def plot_para_cat():
    df = df_invest.reindex(columns=['市场','指数名称','标的名称','持有市值'])
    fig = px.parallel_categories(df, 
                             color="持有市值", 
                             color_continuous_scale=px.colors.sequential.PuBu
                            )
    return fig

fig = plot_para_cat()
# fig.write_image('./images/px/11-para-2.png')
fig.show()

从上面这个数据流向的平行坐标图，可以从市场、指数名称、标的名称等维度来对投资数据的情况进行分析。

12 密度图（Density）

密度图表现与数据值对应的边界或域对象的一种理论图形表示方法，一般用于呈现连续变量。

在 Plotly Express 中，通过 px.density_contour() 来实现。

示例如下：

iris = px.data.iris()
fig = px.density_contour(iris, x="sepal_width", y="sepal_length")
# fig.write_image('./images/px/12-density-1.png')
fig.show()

可以通过设置参数 color 来显示不同类别的颜色，如下“

fig = px.density_contour(iris, x="sepal_width", y="sepal_length",color='species')
# fig.write_image('./images/px/12-density-2.png')
fig.show()

13 极坐标图（Polar）

极坐标图可用来显示一段时间内的数据变化，或显示各项之间的比较情况。适用于枚举的数据，比如不同地域之间的数据比较。

极坐标柱状图

在极坐标下，以柱状图的形式对数据进行可视化，在 Plotly Express 中，通过 px.bar_polar() 来实现。

以疫情数据为例，对不同国家的数据演示如下：

# 将累计确诊人数划分为不同的范围等级
def confirm_class(x):
    if x<=50000:
        y='1'
    elif 50000<x<=100000:
        y='2'
    elif 100000<x<=500000:
        y='3'
    elif 500000<x<=900000:
        y='4'
    elif 900000<x<=1200000:
        y='5'
    elif 1200000<x<=1700000:
        y='6'
    elif x>1700000:
        y='7'
    return y

countries_list = ['法国','意大利','英国','西班牙','阿根廷',
                  '哥伦比亚','德国','墨西哥','波兰','伊朗',
                  '秘鲁','土耳其','乌克兰','南非'
                 ]

df_global_top10_tmp = df_global_new[df_global_new['country'].isin(countries_list)]
# SettingWithCopyWarning
df_global_top10 = df_global_top10_tmp.copy(deep=False)
df_global_top10['gradient'] = df_global_top10['confirmed'].apply(confirm_class)
# df_global_top10
fig = px.bar_polar(df_global_top10, r="confirmed", 
                   theta="country", color="gradient", 
                   color_discrete_sequence= px.colors.sequential.Blugrn
                  )
# fig.write_image('./images/px/13-polar-2.png')
fig.show()

极坐标散点图

此外，在极坐标下，也可以使用散点图来对数据进行可视化，在 Plotly Express 中，通过 px.scatter_polar() 来实现，示例如下：

fig = px.scatter_polar(df_global_top10, r="confirmed", 
                       theta="country", color="gradient", 
                       symbol="gradient",
                       color_discrete_sequence=px.colors.sequential.Blugrn)

# fig.write_image('./images/px/13-polar-3.png')
fig.show()

雷达图

在 Plotly Express 中，还支持极坐标线形图（实际上是雷达图），通过 px.line_polar() 来实现，继续以上面的数据为例，如下：

fig = px.line_polar(df_global_top10, r="confirmed", 
                    theta="country", color="gradient", 
                    line_close=True,
                    color_discrete_sequence=px.colors.sequential.Blugrn)

# fig.write_image('./images/px/13-polar-4.png')
fig.show()

总觉得上面的雷达图，用于这个疫情数据时，没有太多实际意义。

不妨来看看官方的示例，如下：

df = px.data.wind()
fig = px.line_polar(df, r="frequency", theta="direction", 
                    color="strength", line_close=True,
                    color_discrete_sequence=px.colors.sequential.Plasma_r)

# fig.write_image('./images/px/13-polar-5.png')
fig.show()

对于风力强度，以及方位分布的可视化，显得更加形象和符合实际情况。

14 图片显示（Imshow）

在 Plotly Express 中，还可通过 px.imshow() 来显示图片以及绘制热力图。

图片显示

读取一张图片，并在jupyter notebook 中显示出来，如下：

from skimage import io
img = io.imread('./data/QR-PyDataLab.jpg')
fig = px.imshow(img)
# fig.write_image('./images/px/14-imshow-1.png')
fig.show()

如果不想图片中显示坐标轴中的数字，可以调整轴的参数设置来实现，如下：

fig = px.imshow(img)

fig.update_yaxes(
#     title=None, # 不显示轴标题
    visible = False,
#     showticklabels=True
)

fig.update_xaxes(visible = False)
# fig.write_image('./images/px/14-imshow-2.png')
fig.show()

热力图

此外，px.imshow() 还可以用来绘制热力图。利用热力图可以看数据表里多个特征两两的相似度，在投资中，经常会考察不同投资产品之间的相关性强弱情况，就可以用热力图来表示，效果如下：

这里，阳哥也以前文的数据，对三支不同的ETF之间的相关性用热力图来绘制，示例如下：

df_im = pd.pivot_table(df3,index=['净值日期'],
                       columns=['code'],values=['累计净值']
                      )
# 删除外层索引
df_im.columns = df_im.columns.droplevel()

# 隐藏列名称
df_im.columns.name = None

# 计算指数点位数值每日变化
returns = df_im.pct_change().dropna()

# 计算相关性
corr = returns.corr()
# corr

fig = px.imshow(corr,color_continuous_scale='PuBu')
# fig.write_image('./images/px/14-imshow-3.png')
fig.show()

Plotly Express 中，还支持绘制热力密度图，通过 px.density_heatmap() 来实现，示例如下：

df_hp = df_global_new.set_index('date').loc['20201208':'20201208']

countries_list = ['法国','意大利','英国','西班牙','阿根廷',
                  '哥伦比亚','德国','墨西哥','波兰','伊朗',
                  '秘鲁','土耳其','乌克兰','南非','比利时',
                  '印度尼西亚','伊拉克','荷兰','智智利','捷克','罗马尼亚'
                 ]

df_hp = df_hp[df_hp['country'].isin(countries_list)]
fig = px.density_heatmap(df_hp, 
                         x="confirmed", 
                         y="cured", 
                         nbinsx=20, 
                         nbinsy=20, 
                         color_continuous_scale="Blues"
                        )
fig.write_image('./images/px/14-imshow-4.png')
fig.show()

15 旭日图（Sunburst）

旭日图（Sunburst Chart）是一种现代饼图，它超越传统的饼图和环图，能表达清晰的层级和归属关系，以父子层次结构来显示数据构成情况。旭日图中，离远点越近表示级别越高，相邻两层中，是内层包含外层的关系。

在实际项目中使用旭日图，可以更细分溯源分析数据，真正了解数据的具体构成。而且，旭日图不仅数据直观，而且图表用起来特别炫酷，分分钟拉高数据汇报的颜值！

在下面这个视频中，针对投资组合的分布，阳哥就使用了旭日图，还是蛮直观实用的。

视频：Plotly 和 Dash 在投资领域的应用

Plotly Express 中，，通过 px.sunburst() 来实现，示例如下：

fig = px.sunburst(df_invest,path=['市场','指数名称','标的名称'],values='持有市值')
# fig.write_image('./images/px/15-sunburst-1.png')
fig.show()

可以通过设置参数 textinfo 的值来控制不同的交互显示方式。

fig = px.sunburst(df_invest,path=['市场','指数名称','标的名称'],values='持有市值')

fig.update_traces(
        textinfo='label+percent entry'
        # 'label+percent root',    都是按照根节点来计算百分比，根节点为100%
        # 'label+percent entry',   根据当前位置来计算百分比，当前的最大节点为100%
        # 'label+percent parent'  当前最大节点占它的上一级节点的百分比不变，其他节点根据当前最大节点来计算百分比
    )
# fig.write_image('./images/px/15-sunburst-2.png')
fig.show()

16 甘特图（Timeline）

在进行项目进度管理时，经常会用到甘特图，在 Plotly Express 中，，通过 px.timeline() 来实现进度可视化，示例如下：

def plot_timeline():

    df = pd.DataFrame([
        dict(Task="项目1", Start='2021-02-01', Finish='2021-03-25',Manager='Lemon',Completion_pct=90),
        dict(Task="项目2", Start='2021-03-05', Finish='2021-04-15',Manager='Lee',Completion_pct=60),
        dict(Task="项目3", Start='2021-02-20', Finish='2021-05-30',Manager='Zhang',Completion_pct=70),
        dict(Task="项目4", Start='2021-04-20', Finish='2021-09-30',Manager='Lemon',Completion_pct=20),
    ])

    fig = px.timeline(df, x_start="Start", x_end="Finish", y="Task")
    fig.update_yaxes(autorange="reversed")
    return fig

fig = plot_timeline()
# fig.write_image('./images/px/16-timeline-1.png')
fig.show()

针对不同的项目人员或者其他非数值型因素，还可以设置颜色分组，如下：

def plot_timeline_update():

    df = pd.DataFrame([
        dict(Task="项目1", Start='2021-02-01', Finish='2021-03-25',Manager='Lemon',Completion_pct=90),
        dict(Task="项目2", Start='2021-03-05', Finish='2021-04-15',Manager='Lee',Completion_pct=60),
        dict(Task="项目3", Start='2021-02-20', Finish='2021-05-30',Manager='Zhang',Completion_pct=70),
        dict(Task="项目4", Start='2021-04-20', Finish='2021-09-30',Manager='Lemon',Completion_pct=20),
    ])

    fig = px.timeline(df, x_start="Start", x_end="Finish", y="Task",color='Manager')
    fig.update_yaxes(autorange="reversed")
    return fig

fig = plot_timeline_update()
# fig.write_image('./images/px/16-timeline-2.png')
fig.show()

对于数值型因素（比如完成进度比例），设置颜色分组，如下：

def plot_timeline_color():

    df = pd.DataFrame([
        dict(Task="项目1", Start='2021-02-01', Finish='2021-03-25',Manager='Lemon',Completion_pct=90),
        dict(Task="项目2", Start='2021-03-05', Finish='2021-04-15',Manager='Lee',Completion_pct=60),
        dict(Task="项目3", Start='2021-02-20', Finish='2021-05-30',Manager='Zhang',Completion_pct=70),
        dict(Task="项目4", Start='2021-04-20', Finish='2021-09-30',Manager='Lemon',Completion_pct=20),
    ])

    fig = px.timeline(df, x_start="Start", 
                      x_end="Finish", 
                      y="Task",
                      color='Completion_pct',
                      color_continuous_scale=px.colors.sequential.RdBu
                     )
    fig.update_yaxes(autorange="reversed")
    return fig

fig = plot_timeline_color()
# fig.write_image('./images/px/16-timeline-3.png')
fig.show()

17 树形图（Treemap）

树形图（Treemap）适用于显示大量分层结构（树状结构）的数据。

在一个树形图中，图表被分为若干个矩形，这些矩形的大小和顺序取决于制定变量，除此之外还常用颜色不同来表示另一个变量。

在 Plotly Express 中，，通过 px.treemap() 来实现树形图的可视化，如下：

颜色为字符型，即离散型

fig = px.treemap(df_sunburst, path=[px.Constant('Invest portfolio'), '市场', '指数名称','标的名称'], 
                 values='持有市值',
                 color='市场', 
                 color_discrete_sequence= px.colors.sequential.RdBu_r  # 字符型，离散颜色
                )

# fig.write_image('./images/px/17-treemap-1.png')
fig.show()

颜色为数值型，即连续型

fig = px.treemap(df_sunburst, path=[px.Constant('Invest portfolio'), '市场', '指数名称','标的名称'], 
                 values='持有市值',
                 color='持有市值', 
                 color_continuous_scale='YlGnBu',  # 数值型，连续颜色
                )
# fig.write_image('./images/px/17-treemap-2.png')
fig.show()

冰柱图(icicle)

还有一种特殊的树状图，称之为冰柱图（icicle），冰柱图形状类似于冬天屋檐上垂下的冰柱，因此得名。

在 Plotly Express 中，，通过 px.icicle() 来实现，示例如下：

fig = px.icicle(df_invest, 
                path=[px.Constant("Total Portfolio"), '市场', '指数名称','标的名称'], 
                values='持有市值',
#                 color_continuous_scale='YlGnBu',  # 数值型，连续颜色
                color_discrete_sequence= px.colors.sequential.RdBu_r  # 字符型，离散颜色
               )
fig.update_traces(root_color="lightgrey")
fig.update_layout(margin = dict(t=50, l=25, r=25, b=25))
# fig.write_image('./images/px/17-treemap-3.png')
fig.show()

18 三维散点图（Scatter 3D）

对散点图从三个维度进行可视化，在 Plotly Express 有 px.scatter_3d 和 px.scatter_ternary() 两个函数来实现。

三维立体空间的可视化：

df_global_top_latest = df_global_new.set_index('date').loc['20201208':'20201208',:]
countries_list = ['美国','印度','俄罗斯','巴西','法国','意大利','英国','西班牙','阿根廷','哥伦比亚','德国']

df_global_top_latest = df_global_top_latest[df_global_top_latest['country'].isin(countries_list)]

fig = px.scatter_3d(df_global_top_latest, 
                    x="confirmed", y="cured", z="dead", 
                    color="country", size="dead", 
                    hover_name="country",
                   )
# fig.write_image('./images/px/18-3d-1.png')
fig.show()

同一个平面下，从三个维度进行可视化：

df = px.data.election()
fig = px.scatter_ternary(df, a="Joly", b="Coderre", c="Bergeron", 
                         color="winner", size="total", 
                         hover_name="district",
                         size_max=15, 
                         color_discrete_map = {"Joly": "blue", "Bergeron": "green", "Coderre":"red"} )
# fig.write_image('./images/px/18-3d-2.png')
fig.show()

19 地图（Map）

Plotly Express 对于地图的可视化提供了许多的功能，由于我自己用的并不多，这里直接给大家介绍了官方的应用案例。

大家有兴趣的话，可以进一步研究下。

示例（1）：

df = px.data.gapminder().query("year == 2007")
fig = px.scatter_geo(df, locations="iso_alpha",
                     size="pop", # size of markers, "pop" is one of the columns of gapminder
                     )
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})

# fig.write_image('./images/px/19-map-1.png')
fig.show()

示例（2）：

df = px.data.gapminder().query("year == 2007")
fig = px.line_geo(df, locations="iso_alpha",
                  color="continent", # "continent" is one of the columns of gapminder
                  projection="orthographic")
# fig.write_image('./images/px/19-map-2.png')
fig.show()

示例（3）：

df = px.data.election()
geojson = px.data.election_geojson()

fig = px.choropleth(df, geojson=geojson, color="Bergeron",
                    locations="district", featureidkey="properties.district",
                    projection="mercator"
                   )
fig.update_geos(fitbounds="locations", visible=False)
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})

# fig.write_image('./images/px/19-map-3.png')
fig.show()

示例（4）：

# us_cities.to_csv('./data/us_cities.csv',index=False)
us_cities = pd.read_csv('./data/us_cities.csv')
# us_cities = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/us-cities-top-1k.csv")
fig = px.scatter_mapbox(us_cities, lat="lat", lon="lon", hover_name="City", hover_data=["State", "Population"],
                        color_discrete_sequence=["fuchsia"], zoom=3, height=300)
fig.update_layout(
    mapbox_style="white-bg",
    mapbox_layers=[
        {
            "below": 'traces',
            "sourcetype": "raster",
            "sourceattribution": "United States Geological Survey",
            "source": [
                "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}"
            ]
        },
        {
            "sourcetype": "raster",
            "sourceattribution": "Government of Canada",
            "source": ["https://geo.weather.gc.ca/geomet/?"
                       "SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&BBOX={bbox-epsg-3857}&CRS=EPSG:3857"
                       "&WIDTH=1000&HEIGHT=1000&LAYERS=RADAR_1KM_RDBR&TILED=true&FORMAT=image/png"],
        }
      ])
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
# fig.write_image('./images/px/19-map-4.png')
fig.show()

示例（5）：

us_cities = us_cities.query("State in ['New York', 'Ohio']")

fig = px.line_mapbox(us_cities, lat="lat", lon="lon", color="State", zoom=3, height=300)

fig.update_layout(mapbox_style="stamen-terrain", mapbox_zoom=4, mapbox_center_lat = 41,
    margin={"r":0,"t":0,"l":0,"b":0})
# fig.write_image('./images/px/19-map-5.png')
fig.show()

示例（6）：

df = px.data.election()
geojson = px.data.election_geojson()

fig = px.choropleth_mapbox(df, geojson=geojson, color="Bergeron",
                           locations="district", featureidkey="properties.district",
                           center={"lat": 45.5517, "lon": -73.7073},
                           mapbox_style="carto-positron", zoom=9)
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
# fig.write_image('./images/px/19-map-6.png')
fig.show()

示例（7）：

df_eq = pd.read_csv('./data/earthquakes.csv')

fig = px.density_mapbox(df_eq, lat='Latitude', lon='Longitude', z='Magnitude', radius=10,
                        center=dict(lat=0, lon=180), zoom=0,
                        mapbox_style="stamen-terrain")
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
# fig.write_image('./images/px/19-map-7.png')
fig.show()

20 颜色（Colors）

在 Plotly Express 使用过程中，经常会设置多种颜色，Plotly 中内置了多种颜色，咱们可以熟悉下，方便使用。

下面跟大家分享两种我常用的颜色体系：

对于颜色搭配，有兴趣的同学可以自行研究。配色是一门高深的艺术，里面门道还是很多的哈~~

Plotly 生态系统的一部分

Plotly Express 在 2019年初刚发布的时候，是一个单独的 Python 库，在后来的版本中，Plotly 官方将 Plotly Express 合并到 Plotly 中了，因此， Plotly Express 可以使用 Plotly 中大部分接口来对图形进行个性化设置。这个也可以认为是 Plotly Express 相对其他基于 Plotly 的第三方库（比如 cufflinks）的一些优势之处。

能够与 Dash 完美匹配

Dash 是 Plotly 的开源框架，用于构建具有 Plotly.py 图表的分析应用程序和仪表板。

Plotly Express 产生的对象与 Dash 100％兼容。

在下面这个视频中，针对投资组合的分析，阳哥就综合使用了Plotly、Plotly Express 以及Dash，还是蛮实用的。

视频：Plotly 和 Dash 在投资领域的应用

最后，Plotly Express 作为一个简洁实用的 Python 可视化库，在 Plotly 生态系统下，发展迅速，所以不要犹豫，立即开始使用 Plotly Express 吧！

数据获取

为方便大家运行文中的内容，阳哥已经整理好数据文件以及完整的 《Plotly Express 可视化使用指南》 （高清pdf版），大家可以在公众号「Python数据之道」回复 px 来获取。