Python基础语法

0. 补充语法

1. print不换行语法

默认print语句输出内容会自动换行，如果输出不换行的语句，则需要在后面加上, end = ''即可

print("hello", end = '') print("world", end ='')输出为hello world(不换行形式的)

2. 制表符 \t

在字符串中，加上\t，效果等同于tab键，在多个print语句中机上\t可以是多行字符串进行对齐

print("hello\tworld")效果为在helloworld中间用tab控制缩进

3. 逻辑符号 & | =

利用逻辑符做判断时，两边必须是同一类型，不能是一边利用str一边利用int做判断

4. list列表元素int化

list = [int[i] for i in list]

1. 基础语法

1. 字面量

被写下来的固定的值称之为字面量，在print里面的内容也算是字面量

2. 注释

规范：
单行注释：# 注释内容 注意 #后带有一个空格
多行注释：“”“注释内容”“”

3. 变量

print中多份内容之间用逗号隔开

4. 数据类型

type(被查看类型的数据) type带有返回值

5. 数据类型转换

想要转换成的类型(被转换的数据) 数据类型转换带有返回值

注意：浮点数转整数时，会丢失精度，小数部分会直接丢失，不是四舍五入

6. 标识符

用于给变量、类、方法等命名

规范：

1. 内容限定
   1. 只允许出现：英文、中文(不推荐)、数字(不可以当做开头)、下划线
2. 大小写限定
   1. 能够完全区分大小写
3. 不可使用关键字

变量命名规范：见名知意、下划线命名法(用于将不用含义的英文字母分割student_name)、英文字母全小写

7. 运算符

/:除法，带小数

//:取整除，不带小数，没有四舍五入

**:指数，a**b:a的b次幂

8. 字符串扩展

字符串三种定义方式

1. 单引号定义法
2. 双引号定义法
3. 三引号定义法，注意：如果有变量接收则为字符串，如果没有变量接收，则为多行注释

引号嵌套(输出带有引号的字符串)：

1. 单引号定义法可以内套双引号
2. 双引号定义法可以内套单引号
3. 可以使用转移字符()将引号解除效用，变成普通字符串

字符串拼接

1. 字符串字面量之间拼接用+
2. 字符串字面量和字符串变量之间拼接用+

注意：其他数据类型与字符串进行拼接不能使用+

字符串格式化

占位拼接：

1. %s，其中%表示占位，s表示将变量变成字符串放入占位的地方
   1. eg："student name is %s id is %s" % (name, id)：即表示将name变量拼接到第一个s位置处，将id变量拼接到第二个s位置处
2. %d：将内容转换成整数，放入占位位置
3. %f：将内容转换成浮点型，放入占位位置

格式化的精度控制

使用辅助符号m.n控制数据的宽度和精度

1. m:控制宽度，是对数字的要求，若设置的宽度小于数字自身，不生效
   1. eg：%5d表示将宽度控制在5位，如数字11，被设置为5d时，就会变成空格空格空格11，用空格来填补不足的宽度
2. n:控制小数点精度，要求是数字，会进行小数的四舍五入
   1. eg：%7.2f表示将宽度控制在7为，小数部分精度为2位，如数字11.345，被设置为7.2f时，就会变成空格空格11.35，用空格来填补不足的宽度，对小数部分进行四舍五入为2位精度
   2. eg：%.2f表示对宽度没有要求，只对小数部分精度为2位，如数字11.345，被设置为.2f时，就会变成11.35，只对小数部分进行四舍五入为2位精度

字符串格式化方式2

f"内容{变量}"的格式进行快速格式化，但对变量不进行类型、精度控制

eg：f"str {变量} str {变量}"表示直接将变量快速与字符串进行拼接

对表达式进行格式化

表达式：一条具有明确执行结果的代码语句，一般等号右边的都是表达式

可以使用以上方法将表达式直接与字符串拼接

练习

name = "heu"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7
print(f"公司:{name},股票代码:{stock_code},当前股价{stock_price}")
print("每日增长系数是: %f, 经过 %s 天的增长后，股票达到了: %.2f" %(stock_price_daily_growth_factor, growth_days, stock_price * stock_price_daily_growth_factor ** growth_days))

9. 数据输入输出

使用一个变量接收input()获取的数据

print("who are you") name = input()等价于name = input("who are you")

注意input语句写入的数据一律当字符串看待

默认print语句输出内容会自动换行，如果输出不换行的语句，则需要在后面加上, end = ''即可

print("hello", end = '') print("world", end ='')输出为hello world(不换行形式的)

2. 判断语句

1. 布尔类型和比较运算符

变量 = 布尔类型字面量 eg:result = 5 >0，则result = True result为布尔类型

比较运算符：== 、！=、<=、>=、<、>

2. if 语句

if 判断条件:

3. 循环语句

1. while循环

while 条件;

'''99乘法表'''
'''方法1'''
i = 1
while i < 10:
    num =  1
    while num < i + 1:
        if num == i:
            print(f"{num} * {i} = {num * i} ")
            num += 1
        else:
            print(f"{num} * {i} = {num * i} ",end='')
            num += 1
    i += 1
    '''方法2'''
i = 1
while i < 10:
    num =  1
    while num < i + 1:
        print(f"{num} * {i} = {num * i}\t ", end='')
        num += 1
    i += 1
    print()

2. for循环

for 临时变量 in 序列类型: ：将序列类型中的数据挨个取出赋值给临时变量，然后在循环体内使用临时变量即可

序列类型指其内容可以一个个一次取出的类型，包括字符串、列表、元组等

range()

语法1：range(num),获取一个从零0开始到num结束的数字序列，不包含num本身

语法2：range(num1, num2),获取一个从num1开始到num2结束的数字序列，不包含num2本身

语法3：range(num1, num2, step),获取一个从num1开始到num2结束的数字序列，不包含num2本身，数字之间的步长为step

'''99乘法表'''
for i in range(1,10):
    for x in range(1,i):
        print(f"{i} * {x} = {i * x} ", end='')
        x += 1
    print()
    i += 1

3. 循环中断：break、continue

continue：中断本次循环，直接进入下一次循环，属于临时中断

break：直接中断循环

import random

money = 10000
for x in range(1,21):
    score = random.randint(1, 10)
    if score < 5:
        print(f"{x}号员工,绩效为{score},低于5,不发放工资")
        x += 1
    else:
        if money >= 1000:
            money -= 1000
            print(f"{x}号员工,绩效为{score},发放工资1000,余额{money}")
            x += 1
        else:
            print(f"余额不足,{x}号员工,不发放工资")
            x += 1

3. 函数

1. 定义

def 函数名 (传入参数):
	函数体
	return 返回值
#参数、返回值不需要时可以省略
#在函数体内写注释，""""""回车自动添加参数

无返回值时，返回值为None，返回值类型是<class 'NoneType'>，None等同于False

在函数体内使用全局变量，需要global关键字

2. 练习

money = 5000
def query(flag):
    if flag:
        print("--------查询余额--------")
    print(f"余额为:{money}")

def add_money():
    global money
    money_add = int(input("存款金额:"))
    money += money_add
    query(False)

def reduce_money():
    global money
    money_reduce = int(input("取款金额金额:"))
    money -= money_reduce
    query(False)

def main():
    print("---------主菜单---------")
    print("查询余额\t1")
    print("存款\t\t2")
    print("取款\t\t3")
    print("退出\t\t4")
    return input("请输入你的选择:")

while True:
    keyboard_input = int(main())
    if keyboard_input == 1:
        query(True)
        continue
    elif keyboard_input == 2:
        add_money()
        continue
    elif keyboard_input == 3:
        reduce_money()
        continue
    elif keyboard_input == 4:
        break

3. 函数的多返回值

def function1():
    return 1
    return 2
x = function1()	# x = 1
def function2():
    return 1, 2
x , y = function2()	# x = 1, y = 2

如果有多个return，则接收的函数返回值为第一个return的值

如果在一个return内有多个返回值，则只需要写对应顺序的多个变量接收即可，变量之间用 , 隔开，每个变量可以是不同的数据类型

4. 函数多种传参方式

位置参数

调用函数参数时根据函数定义的参数位置来传递参数，注意顺序和数量必须一致

关键字参数

调用函数时通过“键=值”的形式传递参数，注意如果有位置参数时，位置参数必须在关键字参数前，但关键字参数之间不存在顺序问题

缺省参数(默认参数)

用于定义函数，为参数提供默认值，调用函数时刻不传默认参数的值，注意所有位置参数必须出现在默认参数前

不定长参数(可变参数)

用于不确定调用的时候会传递多少个参数(不传参也可以)

• 类型
• 位置传递
  • def function(*args)：传进去的参数都会被args变量收集，会根据传进参数的位置合并为一个元组，args是元组类型
• 关键字传递
  • def function(**args)：参数是“键=值”的形式下，所有的“键=值”都会被**args接收，同时根据“键=值”组成字典
  • 调用时：function(Hello = "hello", World = "world", ...)

5. 匿名函数

函数作为参数传递

def function1(): def function2(function1)：函数本身作为参数传入另一个函数

**lambda函数

函数的定义中：

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数(无名称)
• 有名称的函数，可以基于名称重复使用
• 无名称的函数，只可临时使用一次

lambda 传入参数: 函数体(一行代码)：注意函数体只能写一行，无法写多行

4. 数据容器

1. list(列表)

有序、可以重复、可以修改元素，可以存储不同数据类型元素

[参数1, 参数2, 参数3...]，可以存储不同类型的数据类型，可以进行列表的嵌套

下标索引

列表[下标]

正向：0、1、2…

反向：…、-2、-1

列表.index("元素")：获取元素的下标索引

插入元素

列表.append("插入一个元素")：添加一个元素到列表末尾

列表.extend("插入元素1", "插入元素2", ...)：插入一批元素到列表末尾，也可以追加一个新的列表

列表.insert(index, "插入元素")：添加到列表指定位置

删除元素

列表.pop(index)：删除指定下标元素

del 列表[index]：删除指定下标元素

列表.remove("删除元素")：删除列表中第一个匹配的指定元素

请空列表

列表.clear()

修改列表

列表[index] = "新元素"：修改制定index的元素值，注意只有存在index时才可以修改，不然只能用append方法

列表.reverse()：反转列表

统计元素个数

列表.count("指定元素")：统计指定元素的数量

len(列表)：统计列表所有元素的数量

列表的遍历

while index < len(列表)：
	element = 列表[index]
	print(element)
	index += 1
for 临时变量 in 列表:
        循环体

• while：可以自定循环条件、实现无限循环
• for：不可以自定循环条件、不可以实现无线循环

列表的sort排序

list.sort(key = 选择排序依据的函数, reverse = True|False)：key要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据元素，reverse是否反转排序结果，True表示降序，False表示升序

2. tuple(元组)

可以存储不同数据类型元素，不可以修改，一般用于封装不希望被修改的元素

(元素1, 元素2, ...)

注意：当定义一个元素的元组时，需要在后面添加一个空格(元素1, )

tuple[index]：获取指定下标元素

tuple.index(元素)：获取指定元素的下标

tuple.count(元素)：获取指定元素在元组中的个数

len(tuple)：获取元组的元素个数

在元组内定义一个列表，虽然元组元素不能修改，但可以修改元组内的列表元素，先找列表，再找列表元素

tuple[list的index][list元素的index]

3. str(字符串)

不可以修改，允许重复，只存储字符串

str[index]：支持下标索引，从前向后，下标从0开始，从后向前，下标从-1开始

str.index("xxx")：查找字符串中xxx的起始下标

str.replace("xxx","sss")：将字符串中xxx替换为sss，成为一个新的字符串

str.split(分隔符字符串)：将字符串按指定分隔符字符串分隔为多个字符串，并存入列表对象中，注意分隔符不存入列表中

str.strip()：将字符串前后空格和换行符去除

str.strip("xxx")：将字符串去除前后指定字符串，注意传入的是12，其实是按照单个字符去除1和2

str.count("xxx")：统计字符串中xxx的出现次数

大小比较

利用ASCII码值作比较，从左到右依次比较同一位置的ASCII值，只要有一个位置的字母ASCII值大，则此字符串整体大

4. 序列切片

内容连续、有序、可以使用下标索引，列表、元组、字符串均可以为序列

序列[起始下标: 结束下标: 步长]：从起始下标(可以为空，即从头开始)开始，到结束下标(可以为空，即到末尾结束)(不含结束下标)结束，每次跳过步长-1个位置取元素，得到一个新的序列，注意如果步长为负数，则起始下标和结束下标要从右到左反着写，即倒序执行

序列[起始下标1: 结束下标1: 步长1][起始下标2: 结束下标2: 步长2][起始下标3: 结束下标3: 步长3]...：也按从左到右的顺序一直切片，每次切片的字符串为得到的新字符串

5. set(集合)

不可以重复，无序，不支持下标索引，不支持while下标循环，支持for循环利用len()关键字

{元素1, 元素2, 元素3, ...}

变量名称 = set()：定义空集合

set.add("元素1")：添加新元素

set.remove("元素")：移除指定元素

set.pop()：随机取出元素，得到一个元素结果，并且集合本身被修改，取出的元素不再存在

set.clear()：清空集合

set1.difference(set2)：取出set1和set2中的差集(set1有set2没有的)，返回一个新集合，原本的两个集合不改变内容

set1.difference_update(set2)：消除set1中与set2相同的元素，结果set1元素被修改

set1.union(set2)：合并set1和set2，得到一个新集合

6. dict(字典)

通过key找到响应的value，不允许key重复，新key的value值会覆盖之前的value值，没有下标索引，key和values可以是任意数据类型（key不可以为字典），可以修改，支持for循环，不支持while循环

{key1 : value1, key2 : value2, ...}

变量名称 = dict()或变量名称 = {}：定义空字典

dict["key"]：获取key所对应的value值

dict["key"] = value：新增或修改元素，如果key存在则是修改元素，如果key不存在则是新增元素

dict.pop(key)：删除指定key的value值

dict.clear()：清空字典

dict.keys()：获取字典中所有的key

循环字典：

方式1：先获取字典中的所有key，然后利用for循环遍历所有的key，再利用遍历的key获取字典相应的value值

方式2：直接for循环字典，获取的就是字典中的每一个key，然后再利用遍历的key获取相应的value值

注意：一般操作嵌套字典时，只for循环得到第一层的key值，然后利用第一层的key值修改第二层字典满足条件的key的value值

7. 容器总结

	列表	元组	字符串	集合	字典
元素数量	[元素1, 元素2, ...]	(元素1, 元素2, ...)	"元素1, 元素2, ..."	{元素1, 元素2, ...}	{key1: value1, key1: value2, ...}
元素类型	任意	任意	仅字符串	任意	任意，其中key不可以为字典
下表索引	支持索引	支持索引	支持索引	不支持索引	不支持索引
重复元素	支持重复	支持重复	支持重复	不支持重复	不支持重复
可修改性	支持修改	不支持修改	不支持修改	支持修改	支持修改
数据有序	有序	有序	有序	无序	无序
使用场景	可修改、可重复的一批数据	不可修改、可重复的一批数据	仅限于字符的数据	不可重复的数据	以key为检索条件的数据
循环	for、while循环	for、while循环	for、while循环	for循环	for循环
其他类型转换	list(元组或字符串或集合或字典)	tuple(列表或字符串或集合或字典)	str(列表或元组或集合或字典)	set(列表或元组或字符串或字典)	dict(列表或元组或字符串或集合)

注意，字典转到其他类型时，存入的是key值，而非键值对或者value值，其他类型转字典时，存入的是key值，对应的value值为空

通用操作：(对字典的操作，都是针对key而非value)

• len(容器)：求容器数量
• max(容器)：求容器最大值
• min(容器)：求容器最小值
• sorted(容器, [reverse = True])：reverse = True时从小到大或字典序排序，reverse = False时从大到小或反字典序排序，排序的结果会变成列表对象，对字典的排序，最后结果也只会将key放入新列表中

5. 文件

open(name, mode, encoding)：打开已存在的文件，或创建一个新文件，返回的是文件对象

with open(name, mode, encoding) as file: xxx：打开文件，并在完成xxx操作后，自动关闭close文件

file.close()：关闭已打开的文件，如果不关闭文件，则程序一直占用此文件

• name：要打开的目标文件名的字符串(可以包含文件所在的具体路径)，位置顺序为第一位，可以使用位置参数
• mode：设置打开文件的模式，只读、写入、追加，位置顺序为第二位，可以使用位置参数
  • r：只读
  • w：写入 ，原有内容会被删除，如果文件不存在，则直接创建新文件
  • a：追加，新内容写入已有内容之后，如果文件不存在，则直接创建新文件
• encoding：编码格式，注意encoding需要使用关键字参数直接指定

1. 读取

• file.read(num)：读取文件num长度的数据，如果没有指定num，则读取文件所有的数据
• file.readlines()：按照行的形式将文件的所有内容进行一次性读取，并且返回一个列表，每一行的数据为一个元素，每一个元素会自动拼接一个\n换行符
• file.readline()：一次读取一行数据
• 利用for循环读取文件行：for line in file:，每一个line记录文件的一行数据

注意：如果有多个read、readlines()、file.readline()操作读取同一个文件，则每次read、readlines()、file.readline()都是从上一次read、readlines()、file.readline()读取内容的结尾开始继续读取，而非从头读取

f = open("F:/xxx.txt","r",encoding="UTF-8")

"""
f内容:
        hello world yang zi chen
        hello world hello world
        hello
        world
"""

# 方式1
# num_hello_1 = f.read().count("hello")
# print(num_hello_1)

#方式2
lines = f.readlines()
count = 0
for line in lines:
    line = line.replace("\n","")
    print(line)
    num = line.count("hello")
    print(num)
    count += num
print(count)
f.close()

2. 写入

file = open(name, 'w')：模式为w

file.write("***")：写入缓冲区

file.flush()：内容刷新，真正写入文件，原有文件内容会被清空

file.close()

3. 追加

file = open(name, 'a')：模式为a

file.write("***")：写入缓冲区

file.flush()：内容刷新，真正写入文件，原有文件内容会被清空

file.close()

6. 异常、模块、包

1. 异常的捕获方法

提前假设某处会出现异常，做好提前准备，当好真的出现异常的时候，可以有后续手段

try: 可能发生错误的代码 except Exception as e: 如果出现异常执行的代码：捕获所有的异常

try: *** except 想要捕获的异常名 as e: print('想要捕获的异常名错误')：捕获指定一个异常，如果尝试执行的代码的异常类型和要捕获的异常没醒不一样，则无法捕获异常，一般try下方只放一行尝试执行的代码，e为异常的具体信息

try: *** except (想要捕获的多个异常名) as e: print('想要捕获的异常名错误')：捕获指定多个异常，如果尝试执行的代码的异常类型和要捕获的异常没醒不一样，则无法捕获异常，一般try下方只放一行尝试执行的代码

try: 可能发生错误的代码 except Exception as e: 如果出现异常执行的代码 else: 如果没有出现异常则执行的代码

try: 可能发生错误的代码 except Exception as e: 如果出现异常执行的代码 finally: 无论是否出现异常都执行的代码

2. 异常的传递性

异常具有传递性，在函数的嵌套中，只需要在顶层函数加入异常捕获，就可以将底层出现的异常捕获

3. python的模块

模块是一个python文件，以.py结尾，模块能定义函数，类和变量，也能包含可执行的代码

模块的作用：python中有很多各种不同的模块，每个模块都可以实现一些功能，每个模块类似于一个工具包。

即模块就是一个python文件，里面有类、函数、变量等，是可以导入响应模块，继而使用模块内的功能

from 模块名 import 模块名| 类| 函数| 变量| * as 别名：from可以省略

自定义模块

新建一个xxx.py文件，在文件内部写上所需的类、函数、变量等等，然后在别的.py文件中import xxx，即可使用xxx.py里面的内容

当导入多个模块的时候，且模块内有同名功能，则调用这个功能时，会调用最后一个模块的这个功能

一般在自定义模块时，都会在模块内部对函数进行测试，if _main_ == "_main_"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入，_all_ = ["方法名"]变量可以控制impot *的时候那些方法可以被导入

4. python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py 文件，该文件夹可用于包含多个模块文件，从逻辑上看，包的本质依然是模块

import 包名.模块名：导入包中的某一个模块，此时调用模块中的方法需要包名.模块名.方法名

from 包名 import 模块名：导入包中的某一个模块，此时调用模块中的方法需要模块名.方法名

常用的第三方包

• 科学计算中常用的: numpy
• 数据分析中常用的:pandas
• 大数据计算中常用的: pyspark、apache-flink
• 图形可视化常用的: matplotlib、pyecharts
• 人工智能常用的: tensorflow、pytorch
• 等

7. 数据可视化

1. json格式

JSON是一种轻量级的数据交互格式，可以按照JSON指定的格式去组织和封装数据，JSON本质上是一个带有特定格式的str字符串

主要功能：json是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互

查看json文件:json在线解析

python数据和Json数据相互转换

步骤：

1. import json
2. data = json.dumps(data, ensure_ascii = False)：将python数据转换为json数据，ensure_ascii 表示数据转换中防止中文乱码，转换后的json格式为str类型
3. data = json.loads(data, ensure_ascii = False)：将json数据转换为python数据，ensure_ascii 表示数据转换中防止中文乱码，转换后的python格式为list或者dict类型

注意，data数据格式要符合json数据格式(字典或列表里面嵌套字典)

2. pyecharts模块

pyecharts中文文档

pyecharts画廊中文文档

全局配置

line.set_global_opts(...)用于设置全局配置，例如标题配置项(TitleOpts)、图例配置项(LegendOpts)、工具箱配置项(ToolboxOpts)等等，可以使用中文文档查找响应的全局配置项

注意：需要导入from pyecharts import options包

系列配置

折线图

from pyecharts.charts import Line
# 准备线条对象
line = Line()
# 准备线条数据
line.add_xaxis(["xxx", "xxx", ...])	#X轴上的坐标点
line.add_yaxis("x", [xx, xx, ...])	#Y轴上的坐标点，x表示这条线的名称
# 绘图
line.render()	#当画图完成后，将创建一个新的`html`文件，用于存放生成的图像，可以使用浏览器打开网址，查看图像

• 导入包：from pyecharts.charts import Line 、import json
• 处理数据
  • 打开下载好的JSON文件
  • file = open(name, model, encoding = "UTF-8")
  • file_data = file.read()
• 去掉不合JSON格式规范的开头
  • file_data.replace("xxx", "")：xxx为字典{前所有字符
• 去掉不合JSON格式规范的结尾
  • file_data.replace(");", "")：去掉结尾的);
• JSON转换为Python字典
  • file_data_dict = json.loads(file_data)
• 通过相应的key取到响应的列表数据
• 创建Line对象：line = Line()
• 将获取到的列表数据画图到X、Y轴上line.add_xaxis(...),line.add_xaxis(...)
• 设置全局配置项：map.set_global_opts()
• line.render(xxx.html)
• 关闭打开的json文件

地图

from pyecharts.charts import Map
# 准备地图对象
map = Map()
# 准备数据
data = [
    ("北京", 99),
    ("上海", 199),
    ("湖南", 299),
    ("台湾", 399),
    ("广东", 499)
]
# 添加数据
map.add("测试地图", data, "china")
# 绘图
map.render("地图可视化基本使用.html")

• 导入包：from pyecharts.charts import Map 、import json
• 处理数据
  • 打开下载好的JSON文件
  • file = open(name, model, encoding = "UTF-8")
  • file_data = file.read()
• JSON转换为Python字典
  • file_data_dict = json.loads(file_data)
• 通过相应的key取到响应的列表数据
• 将所需的数据转换为元组数据存入列表中，data_list
• 创建Map对象：map = Map()
• 添加相应数据：map.add("name", data_list, "name_map")：name为地图图像的标题，name_map为相应的真实地图的名称
• 设置全局配置项：map.set_global_opts()
• map.render("xxx.html")：绘图
• 关闭打开的文件：file.close()

柱状图

静态柱状图

from pyecharts.charts import Bar
# 使用Bar构建基础柱状图
bar = Bar()
# 添加x轴的数据
bar.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))	
#label_opts=LabelOpts(position="right") 数字柱状图标签在右侧显示
# 反转x和y轴
bar.reversal_axis()
# 绘图
bar.render("基础柱状图.html")

动态柱状图

• 创建时间线：Timeline()，如果说Bar、Line是一张图表的话，则时间线就是创建一个一维的X轴，轴上的每一个点就是一个图标对象
  • 导入包：from pyecharts.charts import Bar, Timeline
• 创建所有的单例柱状图对象
  • bar1 = Bar()、bar2 = Bar()、…
• 创建时间线对象
  • timeline = Timeline()
• 向时间线对象中添加图标对象
  • timeline.append(bar1, "name1")、timeline.append(bar2, "name2")、…
• 设置全局配置项：map.set_global_opts()
• 通过时间线对象绘图
  • timeline.render("xxx.html")