python基础知识讲解

薛定谔的猫就是我68767
238 阅读17分钟

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

1.输出命令

print

print("hello world")

a = "python"
print("我正在学习", a)

print不换行

print("Hello", end="")
print("world", end="")

2.数据类型

  1. 数字(Number)
    • 整数int
    • 浮点数float
    • 复数 4+3j 以j结尾表示复数
    • 布尔bool
  2. 字符串(String)
  3. 列表(List)
  4. 元祖(Tuple)
  5. 集合(Set)
  6. 字典(Dictionary)

3.注释

  • 单行python使用# 进行注释

    # 这是一个注释

    # 和后面注释内容后面要有一个空格

  • 多行注释 使用""" 或者 '''

    """
这是多行注释的内容
"""

    多行注释一般写在文件头部

4.变量

用来记录数据

变量的定义格式: 变量名称 = 变量的值

a = 12

5.查看数据类型

type()方法

用来输出类型消息

print(type("hello world"))

输出 <class 'str'>

6.数据类型转换

  • int(x) 将x转换为一个整数, 要是float会向下取整
  • float(x) 将x转换为一个浮点数
  • str(x) 将x转换为一个字符串

7.标识符(就是变量的名字)

  • 内容限定, 只能出现:

    • 英文

    • 中文

    • 数字

    • 下划线

    不推荐使用中文

    数字不能用作开头

  • 大小写敏感

  • 不可使用关键字

8.运算符

算数运算符

​ + - * / 表示加减乘除

​ // 取整除: 如9//4 返回2 , 9.0//2.0返回4.0

​ % 取余

​ ** 指数运算符

赋值运算符

​ = 赋值运算符

​ += -= *= /= **= //=

9.字符串

  1. 单引号

    name = '字符串'

  2. 双引号

    name = "字符串"

  3. 三引号

    name = """字
符
串"""

    name = '''
	字
	符
	串
'''

    可以使用\ 来进行转义

    ​

  4. 字符串拼接使用

    • + 无法和其他数据类型进行拼接

    • 字符串格式化

      name = "张三"
message = "我叫%s" % name

num1 = 100 
num2 = 200
message = "数学%s分, 语文 %s分" % (num1, num2)
      • %s 表示站位符
      • 可以使用多个站位符, 变量要用括号括起来, 按照占位顺序进行占位

    • 占位符

      • %s 将内容转为字符串, 放入占位位置
      • %d 将内容转为整数, 放入占位位置
      • %f 将内容转为浮点数, 放入占位位置

      ​

  5. 数字精度控制, 使用辅助符号m.n , 来控制数据的宽度和精度设置

    • m 控制宽度, 要求是数字(很少使用), 设置宽度小于数字自身, 不生效
    • n 控制小数点精度, 要求是数字, 会对数字进行四舍五入
    %5d # 表示数字的宽度控制在5位, 不够的用空格代替
%5.2d  # 表示将数字宽度设置为5位, 将小数点精度设置为2, 小数位数也会进入宽度计算
%.2f # 表示只进行小数精度限制

  6. 字符串格式化-快速写法

    语法: f"内容{变量}"

    f 代表format , 这里也可以使用大写

    name = "张三"
age = 18
print(f"我是{name}, 年龄{age}")
    • 不理会类型
    • 不会控制精度

  7. 表达式格式化

    是一条具有明确执行结果的代码语句, 比如 1+1, 5*2

    print("1*1的结果是%d" % (1*1))
print("'str'的数据类型是%s" % type('str'))

10.数据输入input

使用 input() , 使用一个变量去接受就可以了

a = input()
b = input("请输入:")
print(a, b)

c = int(input("请输入:"))
print(f"输入的数据类型是: {type(c)}")

11.布尔值和比较运算符

布尔值

python 中的布尔值首字母要大写

  • True 被标记1
  • False 被标记0

比较运算符

  • == 相等
  • != 不等于
  • >
  • >=
  • <
  • <=

12.判断if语句

if

基本格式:

age = 19
if age > 18:
    print("我成年了")
  • 判断语句后面注意冒号
  • 第二行注意空格

else

age = 16
if age >= 18:
  print("我成年了")
else:
  print("我未成年")

elif

age = 16
if age<10:
  print("我是儿童")
elif age <18:
  print("我是青少年")
else:
  print("我是成年人")

13. 循环

while循环

语法:

while 条件:

​ something......

只要条件满足, 就会一直执行

 i = 0
 while i < 100:
    print(i)
    i+=1

获取随机整数:

import random
# 获取1-100的整数
num = random.randint(1,100)

for循环

遍历字符串(for ... in ...)

可以使用的数据:

  • 字符串
  • 列表
  • 元组
name = "zhangsan"
for x in name:
  print(x)
range语句
语法1:

range(num): 从0开始, 到num结束的数字序列, range(4)==> [0,1,2,3]

语法2:

range(num1, num2): 从num1开始, 到num2(不含)结束, range(2,4) ==> [2,3]

语法3:

range(num1, num2, step), 从num1开始, 到num2(不含)结束,数字之间的步长以step(默认为1)为准

如: range(5,10,2) ==> [5,7,9]

for i in range(0, 10, 2):
    print(i)

continue和break

  • continue: 跳过本次循环, 直接进入下一次循环
  • break: 直接结束循环

14.函数

def my_len(data):
  count = 0
  for i in data:
    count += 1
  return count
print(my_len("str"))
定义:
def 函数名(data):
    #函数体
    return #返回值
  • def 要定义函数
  • data 参数名称
global关键字

在函数内部声明变量是全局变量

num = 100
def testA():
    global num  # 声明是全局变量
    num = 500
print(num)

15.数据容器

1.列表list: (js 中的数组)

定义:

  1. 字面量:

    [元素1, 元素2,.....]

  2. 定义变量

    变量 = [元素1, 元素2,.....]

    name = ['java', 'python', 'php']
name2 = ['java', 666, True, ['hello', 'world']]

  3. 定义空列表

    变量 = []

    变量 = list()

使用type() 得到<class 'list'>

列表中的方法:
索引:

用中括号[] 来取索引, 索引是从0开始的, 超出范围是会报错的

从右向左是用-, 从-1开始, 依次递减(-1,-2,-3)

name = ['java', 'python', 'php']
name[0]  # 'java'
name[2]  # 'php'
name[-2] # 'python'
操作:

  • 查找元素下标: list.index(元素), 找不到会报错

    list1 = ['java', 'python', 'php']
list1.index('java')

  • 修改值: list[下标] = 值

    list1 = ['java', 'python', 'php']
list1[0] = 'javascript'

  • 插入: insert(下标, 索引): 在制定的下标位置, 插入指定的元素

    list1 = ['java', 'python', 'php']
list1.insert(1, 'js')

  • 追加:append(元素), 追加到列表的尾部

    list1 = ['java', 'python', 'php']
list1.append("js")

  • 追加2: .extend(其他数据容器), 将其他数据容器中的元素依次追加到列表的尾部

    list1 = ['java', 'python', 'php']
list2 = ['js', 'go', 'c++']
list1.extend(list2)

  • 删除和清空:

    • del 列表[下标]

      list1 = ['java', 'python', 'php']
del list1[1]

    • list.pop(下标): 返回删除的元素, 默认删除最后一个元素

      list1 = ['java', 'python', 'php']
list1.pop(1)

    • remove: list.remove(元素): 删除某元素的在列表的第一个匹配项

      list1 = ['java', 'python', 'php']
list1.remove("python")

    • clear(): 清空列表

      list1 = ['java', 'python', 'php']
list1.clear()

  • 统计数量: list.count(元素), 返回列表中元素出现的数量

    list1 = ['java', 'python', 'php', 'java']
list1.count('java')

  • len(list), 统计列表元素的数量

    list1 = ['java', 'python', 'php', 'java']
len(list1)
遍历:

  • while:

    list1 = ['java', 'python', 'php', 'java']
index = 0
while index < len(list1):
    print(list[index])
    index += 1

  • for

    list1 = ['java', 'python', 'php', 'java']
for element in list1:
    print(element)

2.元组

定义:同列表, 一旦定义完成, 就不能修改
  • (元素1, 元素2,...)
  • 变量 = (元素1, 元素2,...)
  • 变量 = ()
  • 变量 = tuple()

type()的返回值 => <class 'tuple'>

只有单个元素的的时候, 要在后面加上, t1 = ("python",) 否者是字符串

方法: 和list相似
遍历: 和list相似

3.字符串

字符串是字符的容器, 也是不可以修改的, 只能重新赋值一个新的字符串

方法:

  • 通过索引取字符, 从0开始, 从后面是从-1开始

    str = "python"
str[2]  # t

  • index: 方法, 根据字符取索引

    str = 'python'
str.index('t')
str.index('on')

  • replace: 字符串替换 replace(str1, str2): 将字符串中的全部str1 替换为 str2, 不修改字符串本身, 只会得到一个新的字符串

    str = 'pythen'
str1 = str.replace('en', 'on')
print(str1)

  • split: 字符串分割 .split(str): 按照指定的字符分割字符串, 得到多个字符串, 并存入列表对象中

    str = 'pythonandjavaandjsandgo'
newList = str.split('and')
print(newList) # ['python', 'java', 'js', 'go']

  • strip: 字符串的规整操作:

    • str.strip(): 去掉前后空格
    • str.strip(字符串): 去掉前后指定字符 按照单个字符匹配
    str1 = " python "
str2 = "12python21"
print(str1.strip()) # python
print(str2.strip('12'))  # python

  • count() : 统计字符串出现的次数

    str = "java and javascript"
str.count('a')

  • len(): 统计字符串的长度

    str = "java and javascript"
len(str)

4.容器切片[::]

序列: 内容连续, 有序, 可使用下标索引操作

语法: 序列[起始下标:结束下标:步长]

  • 起始下标: 从何处开始, 可留空, 视为从头开始

  • 结束下标:从何处结束, 可以留空, 视为截取到结尾(不包含本身)

  • 步长:依次取元素的间隔

    • 步长1, 一个个取元素(默认值)
    • 步长2: 每次跳过一个元素
    • 步长N: 每次跳过N-1个元素
    • 步长为负数, 反向取, 注意:起始下标和结束下标也要反向标记
    list1 = [0,1,2,3,4]
list1[0:4]
list[1:3]
list[::2]
list[::-1]

5.集合set

不支持元素重复, 无序,集合使用{}

不支持下标索引

定义
  • {元素, 元素, 元素...}
  • 变量 = {元素, 元素, 元素...}
  • 变量 = set() # 空集合
set1 ={"python", 'java', 'js', 'python'}
print(set1, type(set1))   #{'java', 'js', 'python'} <class 'set'>
方法

  • add: 添加新元素

    set1 ={"python", 'java', 'js', 'python'}
set.add("go")

  • remove: 移除指定元素

    set1 ={"python", 'java', 'js', 'python'}
set1.remove("java")

  • pop:随机取一个元素, 会改变原来的集合

    set1 ={"python", 'java', 'js', 'python'}
ele = set1.pop()

  • clear: 清空集合

    set1 = {"python", 'java', 'js', 'python'}
set1.clear()

  • difference: 集合1.difference(集合2): 取出集合的差集(集合1有, 集合2没有的), 返回一个新的集合

set1 = {"python", 'java', 'js', 'python'}
set2 = {"python", "js"}
newSet = set1.difference(set2)  # {'java'}

  • difference_update: 消除差集: 集合1.difference_update(集合2): 在集合1内, 删除和集合2相同的元素

    集合1被修改, 集合2不变

    set1 = {"python", 'java', 'js', 'python'}
set2 = {"python", "js", "go"}
set1.difference_update(set2)
print(set1, set2)   # {'java'} {'go', 'js', 'python'}

  • union: 合并集合: 集合1.union(集合2), 将集合1和集合2组合成新集合

    得到一个新的集合, 原来的集合不变

    set1 = {"python", 'java', 'js', 'python'}
set2 = {"python", "js", "go"}
newSet = set1.union(set2)
print(newSet)   #{'python', 'java', 'js', 'go'}

  • len(): len(集合), 统计集合中元素的数量

  • 遍历: 只能用for循环

    不可以用while 进行遍历, 因为不支持下标索引

    set1 = {"python", 'java', 'js', 'python'}
for ele in set1:
   print(ele)

6.字典dict

1. 定义
  • {key: value,key: value, key: value, key: value, ... }
  • 变量 = {key: value,key: value, key: value, key: value, ... }
  • 变量 = {} 或者 变量 = dict() # 空字典

重复的key, 后面的key 值会覆盖前面的key值

dict1 = {"nickname": "张三",  "age": 23, "age": 24}
print(dict1) # {'nickname': '张三', 'age': 24}
2.获取value

使用[]

dict1 = {"nickname": "张三",  "age": 23, "age": 24}
dict1["nickname"] # "张三"
3.字典操作

  • 新增元素: 字典[key] = value

    dict1 = {"nickname": "张三",  "age": 23}
dict1["color"] = "red"

  • 修改元素: 字典[key] = value

    dict1 = {"nickname": "张三",  "age": 23}
dict["age"] = 24

  • 删除元素: .pop(key)

    dict1 = {"nickname": "张三",  "age": 23}
dict1.pop("age")
print(dict1)

  • 清空字典: .clear()

    dict1 = {"nickname": "张三",  "age": 23}
dict1.clear()

  • 获取全部的key: .keys()

    dict1 = {"nickname": "张三",  "age": 23}
dict1.keys()

  • 遍历字典:

    • 方式1: 使用keys()

      dict1 = {"nickname": "张三",  "age": 23}
for key in dict1.keys():
    print(f"{key}--{dict1[key]}")

    • 方式2:直接使用for: 每一次循环 得到的都是key

      dict1 = {"nickname": "张三",  "age": 23}
for key in dict1:
    print(f"{key}--{dict1[key]}")

  • 统计字典元素数量: len()

    dict1 = {"nickname": "张三",  "age": 23}
let(dict1)

7. 总结和通用操作

1-1.png

  • max(容器): 统计容器最大的元素

    dict1 = {"nickname": "张三",  "age": 23, "age2": 24}
print(max(dict1))   # 'nickname'

  • min(容器): 统计容器最小的元素

  • list(obj): 将obj转为list数据, 字典将会只剩下key

  • tuple(obj): 将obj 转为tuple 元祖数据

  • str(obj): 将obj转为字符串 str

  • set(obj): 将obj 转为 集合 set

  • sorted(容器, [reverse = True]): 通用的排序功能, 排序后都变为list 类型

    list1 = [3, 1, 3, 4, 54, 34, 4, 4, 3]
print(sorted(list1))
print(sorted(list1, reverse=True))   # 反向排序

16. 函数扩展

1.函数的多返回值

def test_return():
    return 1, 2
x, y = test_return()
  • 按照返回值的顺序, 写对应顺序的多个变量接受即可
  • 变量之间用, 隔开
  • 支持不同数据类型的return , 本质上是返回元组

2.函数多个参数

  • 位置参数

    调用函数时候根据函数定义的参数位置来传递参数

    def user_info(name, age, gender): 
    print(name, age, gender)

    传递的参数和定义参数的顺序及个数必须一致

  • 关键字参数

    函数调用的时候, 可以通过 "键 = 值" 的形式传递参数

    def user_info(name, age, gender): 
    print(name, age, gender)
    
user_info("小明", gender="男", age=10 )

    函数调用是, 如果有位置参数, 位置参数必须在前面, 关键字不存在前后顺序

  • 缺省参数

    定义函数的时候, 可以给参数提供一个默认值, 调用函数的时候可以不传递该默认参数的值

    (注意: 不管函数是定义还是调用, 所有的位置参数必须出现在默认参数前面)

    def user_info(name, age = 18, gender="男"):
    print(name, age , gender)
user_info("张三")
user_info("李四", gender="女")

  • 不定长参数(可变参数)

    不确定调用的时候传递多少个参数

    • 位置不定长 *

      传递进来的所有参数都会被args变量收集, 会根据传进来的位置合并为一个元组(tuple), args是元组类型, 这就是位置传递

      def user_info(*args):
    print(args)
user_info(1,2,3,1,2,3)

    • 关键字不定长 **

      参数是"键=值"的形式的情况下, 所有的键=值 都会被kwargs接受, 同时会根据键=值组成字典

      def user_info(**kwargs):
    print(kwargs)
user_info(name="张三", age="18")

      混合

      def user_info(a, **kwargs):
  print(a, kwargs)
user_info(a=2, name="张三", age="18")   # 2 {'name': '张三', 'age': '18'}

3.函数作为参数

def test_func(callback, x, y):
  print(type(callback))     # <class 'function'>
  result = callback(x, y)
  return result

def compute(x, y):
  return x + y

print(test_func(compute, 1, 5))

4.匿名函数(lambda)

函数定义:

  • def 关键字, 可以定义带有名称的函数

  • lambda 关键字, 可以定义匿名函数(无名称)

    语法: lambda 参数: 函数体(一行代码) 只能写一行

    默认return 一行的计算值

def test_func(callback, x, y):
  print(type(callback))     # <class 'function'>
  result = callback(x, y)
  return result

num = test_func(lambda x,y: x+y, 2,3)
print(num)

17.文件操作

1.文件读取

  • 打开文件

    open()函数: 打开一个已经存在的文件, 或者可以创建一个新的文件: open(name, mode, encoding)

    • name: 要打开的目标文件名的字符串(可以包含文件所在的具体路径)
    • mode: 设置打开文件的模式(访问模式): 只读, 写入, 追加等
      • r : 只读模式打开, 文件的指针将会放在文件的开头, 默认模式
      • w :打开一个文件只用于写入, 如果该文件存在, 则打开文件, 并从头开始编辑, 原有的内容会被删除, 如果该文件不存在, 则创建新文件
      • a :打开一个文件用于追加操作, 如果该文件存在, 则打开文件, 新的内容将会被写入到已有内容之后, 如果该文件不存在, 则创建新文件进行写入
    • encoding:编码格式(推荐使用utf-8), 顺序不是第三位, 不能用位置参数, 这里要用关键字参数
    f = open("python.txt", 'r', encoding="UTF-8")
f2 = open("D:/python.txt", 'r', encoding="UTF-8")

  • 读取文件

    读取文件的时候是有一个指针的, 每一次读取操作后, 指针都会往后移动, 会影响接下来的读取操作

    • read(): read(num), num表示要从文件中读取数据的长度(单位是字节), 如果没有传入num, 就会读取文件中所有的数据

      f = open("python.txt", 'r', encoding="UTF-8")
print(f.read(10))
print(f.read())

    • readLines() : 按照行的方式, 把整个文件的内容进行一次性读取, 返回的是一个列表, 其中, 每一行的数据为一个元素

      f = open("python.txt", 'r', encoding="UTF-8")
print(f.readlines())  # ['哈哈hello world\n', 'java\n', 'python']

    • readline() : 一次读取一行内容

      f = open("python.txt", 'r', encoding="UTF-8")
print(f.readline()) 
print(f.readline()) 
print(f.readline())

    • for 循环读取: 一次读取一行数据

      f = open("python.txt", 'r', encoding="UTF-8")
for line in f:
    print(line)

  • 关闭文件

    .close() 可以关闭文件占用

    f = open("python.txt", 'r', encoding="UTF-8")
for line in f:
    print(line)
f.close()

    with open 语法:

    • 通过 with open的语句块中对文件进行操作
    • 可以在操作完成后自动关闭close文件, 避免忘掉close方法
    with open("python.txt", "r", encoding="UTF-8") as f:
  print(f.readlines())

2.文件写入

f.write("hello world") 文件写入

f.flush() 内容刷新

close() 内置了flush() 的功能

注意:

  • 直接调用write, 内容并未真正写入文件, 而是会积攒在内存中, 称之为缓冲区
  • 当调用flush的时候, 内容会真正写入文件
  • 可以避免频繁操作硬盘, 提升效率
  • open() 使用w 会覆盖, 要是追加,请用 a
f = open("python.txt", 'w', encoding="UTF-8")
f.write("新加的一行")
# f.flush()
f.close() #close()内置了flush() 的功能

3.文件追加

open() 使用w 会覆盖, 要是追加,请用 a

f = open("python.txt", 'w', encoding="UTF-8")
f.write("\n新加的一行")
f.close()

18.异常

捕获异常

语法:

try:
	# 可能发生的错误
except:
	# 如果出现异常执行的代码
1.常规异常
try:
    f = open('1.txt', 'r', encoding="utf-8")
except:
    f = open('1.txt', 'w', encoding="utf-8")
2.捕获指定异常
try: 
    print(abc)    # NameError: name 'abc' is not defined. Did you mean: 'abs'?
except NameError:
    abc = 10

可以通过as 设置异常的别名

try:
  f = open('ttttest.txt', 'r', encoding="utf-8")
except FileNotFoundError as e:    #  通过as设置别名
  print(e)
  f = open('ttttest.txt', 'w', encoding="utf-8")
3.捕获多个异常
try:
  f = open('ttttest.txt', 'r', encoding="utf-8")
except (FileNotFoundError, NameError) as e:    #  通过as设置别名
  print(e)
  f = open('ttttest.txt', 'w', encoding="utf-8")
4.捕获全部异常
try:
  print(aaa)  
except Exception as e:
  print(e)
5.异常的else和finally语法(可选)

如果没有异常, 则会执行else

aaa = 10
try:
  print(aaa)
except Exception as e:
  print(e)
else:
  print("没有异常")
# 10
# 没有异常

finally: 无论有没有异常 都会执行

aaa = 10
try:
  print(aaa)
except Exception as e:
  print(e)
else:
  print("没有异常")
finally:
  print("执行结束了")

# 10
# 没有异常
# 执行结束了

异常的传递性

当函数func01 中发生异常, 并且没有捕获处理这个异常的时候, 异常会传递到函数 func02 , 当func02 也没有处理这个异常的时候, 会依次向上传递, 直到被捕获或者报错为止

def func01():
  print(1/0)

def func02():
  return func01()

def main():
  try:
    func02()
  except Exception as e:
    print(e)

main()  # division by zero

19.模块

模块的导入

模块(module), 是一个python文件, 以.py结尾, 模块能定义函数, 类和变量, 也可能包含可执行的代码, 就是一个工具包

导入方式:

[from 模块名] import [模块|类|变量|函数 ] [ as 别名]

常用的方式:

  • import 模块名
  • from 模块名 import 类 ,变量, 方法等
  • from 模块名 import * * 表示全部
  • import 模块名 as 别名
  • from 模块名 import 功能名 as 别名
# 示例 导入time
import time
time.sleep(10)   # 睡眠10秒钟

###################################################
from time import sleep
sleep(10)
print("hello world")

###################################################
import time as t
t.sleep(5)
print("hh")

###################################################
from time import sleep as sl
sl(5)
print("hello")

自定义模块

定义:

def test(a, b):
  return a + b

使用:

import my_module_01
print(my_module_01.test(1, 2))

使用 __name__ 可以使模块定义的时候, 测试的方法不执行, __name__ 是模块的内置变量

def test(a, b):
  return a + b

if __name__ == '__main__':
  test(1, 2)

默认py文件运行的时候, 模块的内置变量 __name__ 就是 "__main__"

注意 __all__ 变量是一个列表 , 如果一个模块文件中有__all__ 变量, 当时用 from xxx import * 导入时, 只能导入这个列表中元素

__all__ = ['test_a']
def test_a():
  return 'a'

def test_b():
  return "b"

from my_module import * # 只能导入test_a
test_a()

python包

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

自定义包

__init__.py (有它就是包, 没它就是文件), 可以使一个空的py文件, 里面也有__all__ 变量, 控制* 导入的模块

__all__ = ["mod_01"]   # 控制*可以导入的模块

from my_module_01 import *

导入包:

  • import 包名.模块名 使用: 包名.模块名.目标

    import my_module_01.mod_01
import my_module_01.mod_02

my_module_01.mod_01.info_01()
my_module_01.mod_02.info_02()

  • from 包名 import 模块名

    from my_module_01 import mod_01
from my_module_01 import mod_02

mod_01.info_01()
mod_02.info_02()

  • from 包名.模块名 from 方法

    from my_module_01.mod_01 import info_01

info_01()
安装第三方包

pip install 包名称 安装第三方包名称

使用国内安装地址

pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

20.综合案例

1.json

  • dumps : 将数据转为json数据

    import json

data = [
    {"name": "张三", "age": 23},
    {"name": "李四", "age": 24},
    {"name": "王五", "age": 25}
]

jdata = json.dumps(data, ensure_ascii=False)   #ensure_ascii 表示中文不转码

print(jdata)

  • loads 将json转为python数据格式

    str = '[{"name": "张三", "age": 23}, {"name": "李四", "age": 24}, {"name": "王五", "age": 25}]'
jdata = json.loads(str)
print(jdata, type(jdata))

    ​

2.pyecharts

from pyecharts.charts import Line

line = Line()

line.add_xaxis(["中国", "美国", "英国"])
line.add_yaxis("GDP", [30, 20, 100])
line.render()
全局配置

通过set_global_opts 全局设置

from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts

line = Line()

line.add_xaxis(["中国", "美国", "英国"])
line.add_yaxis("GDP", [30, 20, 100])

line.set_global_opts(
    title_opts=TitleOpts(title="标题", pos_left="center", pos_bottom="1%"),
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True),
    visualmap_opts=VisualMapOpts(is_show=True)
)

line.render()
avatar
文章
阅读
粉丝