Python(模块)

1 Python3 模块

2 Python模块库

1 Python3 模块

我们脚本上是用 python 解释器来编程,如果你从 Python 解释器退出再进入,那么你定义的所有的方法和变量就都消失了。

为此 Python 提供了一个办法,把这些定义存放在文件中,为一些脚本或者交互式的解释器实例使用,这个文件被称为模块。使用模块可以提高代码的可维护性。

模块是一个包含所有你定义的函数和变量的文件,其后缀名是.py

模块可以被别的程序引入,以使用该模块中的函数等功能。模块之间可以相互导入,从而可以使用其他模块中的代码。这也是使用 python 标准库的方法。

import sys
def test():
    args=sys.argv
    if len(args)==1:
        print('hello')
    elif len(args)==2:
        print('hello,%s!'%args[1])
    else:
        print('too many arguments')
if __name__=='__main__':#前后两个下划线
    test()#被导入时不执行, 

如果没有if,其他文件import本文件时,也会print输出

执行结果如下所示:

runcell(0, 'C:/Users/Administrator/.spyder-py3/a.py')
hello

(一) 模块基础知识

1. import 语句

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

import module1[, module2[,... moduleN]

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support,需要把命令放在脚本的顶端:

support.py 文件代码

#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
    print ("Hello : ", par)
    return

test.py 引入 support 模块:

test.py 文件代码

#!/usr/bin/python3
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

以上实例输出结果:

$ python3 test.py 
Hello :  Runoob

一个模块只会被导入一次,不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。


当我们使用import语句的时候,Python解释器是怎样找到对应的文件的呢?

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量,事实上,也可以通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量,做一个简单的实验,在交互式解释器中,输入以下代码:

>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
#或者
runfile('C:/Users/Administrator/.spyder-py3/未命名2.py', wdir='C:/Users/Administrator/.spyder-py3')

sys.path 输出是一个列表,其中第一项是空串’’,代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),亦即我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

因此若像我一样在当前目录下存在与要引入模块同名的文件,就会把要引入的模块屏蔽掉。

了解了搜索路径的概念,就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

sys.path.append(r'c:\abc')
#将C盘下的abc文件夹添加到搜索路径中

现在,在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件,代码如下:

实例

# 斐波那契(fibonacci)数列模块
def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()
def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

然后进入Python解释器,使用下面的命令导入这个模块:

>>> import fibo

这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里,只是把模块fibo的名字写到了那里。

可以使用模块名称来访问函数:

实例

>>>fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

如果你打算经常使用一个函数,你可以把它赋给一个本地的名称:

>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

2. from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

from modname import name1[, name2[, ... nameN]]

例如,要导入模块 fibo 的 fib 函数,使用如下语句:

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

3. from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

4. 三者区别

  • import模块:导入一个模块,相当于导入了一个文件夹,是个相对路径。
  • from…import…:导入一个模块中的某一个函数,相当于导入了文件,绝对路径。
  • from…import *:批量上面的过程。绝对路径(使用函数不用指定路径)

5. 深入了解模块

模块除了方法定义,还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

所以,模块的作者可以放心大胆的在模块内部使用这些全局变量,而不用担心把其他用户的全局变量搞混。

从另一个方面,当你确实知道你在做什么的话,你也可以通过modname.itemname (模块名.方法名)这样的表示法来访问模块内的函数。

模块是可以导入其他模块的。在一个模块(或者脚本,或者其他地方)的最前面使用 import 来导入一个模块,当然这只是一个惯例,而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中,所以不能有变量与导入的名称同名。

还有一种导入的方法,可以使用 import 直接把模块内(函数,变量的)名称导入到当前操作模块。比如:

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这还有一种方法,可以一次性的把模块中的所有(函数,变量)名称都导入到当前模块的字符表:

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这将把所有的名字都导入进来,但是那些由单一下划线 ( _ ) 开头的名字不在此例。大多数情况, Python程序员不使用这种方法,因为引入的其它来源的命名,很可能覆盖了已有的定义。

6. __name__ 属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用双下划线:__name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

运行输出如下:

$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块

说明: 每个模块都有一个__name__属性,当其值是'__main__'时,表明该模块自身在运行,否则是被引入。

说明:__name____main__底下是双下划线, _ _ 是这样去掉中间的那个空格。

7. dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数,那么 dir() 函数会罗列出当前定义的所有名称:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一个当前模块中定义的属性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一个新的变量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 删除变量名a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>

8. 标准模块

Python 本身带着一些标准的模块库,在 Python 库参考文档中将会介绍到(就是后面的”库参考文档”)。

有些模块直接被构建在解析器里,这些虽然不是一些语言内置的功能,但是他却能很高效的使用,甚至是系统级调用也没问题。

这些组件会根据不同的操作系统进行不同形式的配置,比如 winreg 这个模块就只会提供给 Windows 系统。

应该注意到这有一个特别的模块 sys ,它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Runoob!')
Runoob!
C> 

(二)包

9. 包的基本概念

包是一种管理 Python 模块命名空间的形式,采用”点模块名称”。

比如一个模块的名称是 A.B, 那么他表示一个包 A中的子模块 B 。

就好像使用模块的时候,你不用担心不同模块之间的全局变量相互影响一样,采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

这样不同的作者都可以提供 NumPy 模块,或者是 Python 图形库。

不妨假设你想设计一套统一处理声音文件和数据的模块(或者称之为一个”包”)。

现存很多种不同的音频文件格式(基本上都是通过后缀名区分的,例如: .wav,:file:.aiff,:file:.au,),所以你需要有一组不断增加的模块,用来在不同的格式之间转换。

并且针对这些音频数据,还有很多不同的操作(比如混音,添加回声,增加均衡器功能,创建人造立体声效果),所以你还需要一组怎么也写不完的模块来处理这些操作。

这里给出了一种可能的包结构(在分层的文件系统中):

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
             ...

在导入一个包的时候,Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包,主要是为了避免一些滥俗的名字(比如叫做 string)不小心的影响搜索路径中的有效模块。

最简单的情况,放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为(将在后面介绍的) __all__变量赋值。

用户可以每次只导入一个包里面的特定模块,比如:

import sound.effects.echo

这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

from sound.effects import echo

这同样会导入子模块: echo,并且他不需要那些冗长的前缀,所以他可以这样使用:

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

from sound.effects.echo import echofilter

同样的,这种方法会导入子模块: echo,并且可以直接使用他的 echofilter() 函数:

echofilter(input, output, delay=0.7, atten=4)

注意当使用 from package import item 这种形式的时候,对应的 item 既可以是包里面的子模块(子包),或者包里面定义的其他名称,比如函数,类或者变量。

import 语法会首先把 item 当作一个包定义的名称,如果没找到,再试图按照一个模块去导入。如果还没找到,抛出一个 :exc:ImportError 异常。

反之,如果使用形如 import item.subitem.subsubitem 这种导入形式,除了最后一项,都必须是包,而最后一项则可以是模块或者是包,但是不可以是类,函数或者变量的名字。

10. 从一个包中导入*

设想一下,如果我们使用 from sound.effects import *会发生什么?

Python 会进入文件系统,找到这个包里面所有的子模块,一个一个的把它们都导入进来。

但是很不幸,这个方法在 Windows平台上工作的就不是非常好,因为Windows是一个大小写不区分的系统。

在这类平台上,没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。

(例如,Windows 95就很讨厌的把每一个文件的首字母大写显示)而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。

为了解决这个问题,只能烦劳包作者提供一个精确的包的索引了。

导入语句遵循如下规则:如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量,那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

作为包的作者,可别忘了在更新包之后保证 __all__ 也更新了啊。你说我就不这么做,我就不使用导入*这种用法,好吧,没问题,谁让你是老板呢。这里有一个例子,在:file:sounds/effects/__init__.py中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import * 这种用法时,你只会导入包里面这三个子模块。

如果__all__真的没有定义,那么使用from sound.effects import * 这种语法的时候,就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来(可能运行__init__.py里定义的初始化代码)。

这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

这个例子中,在执行 from…import 前,包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。(当然如果定义了 __all__就更没问题了)

通常我们并不主张使用 * 这种方法来导入模块,因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫,而且一些模块都设计成了只能通过特定的方法导入。

记住,使用 from Package import specific_submodule这种方法永远不会有错。事实上,这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

如果在结构中包是一个子包(比如这个例子中对于包sound来说),而你又想导入兄弟包(同级别的包)你就得使用导入绝对的路径来导入。比如,如果模块sound.filters.vocoder 要使用包 sound.effects 中的模块 echo,你就要写成 from sound.effects import echo。

from . import echo
from .. import formats
from ..filters import equalizer

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__",一个Python应用程序的主模块,应当总是使用绝对路径引用。

包还提供一个额外的属性__path__。这是一个目录列表,里面每一个包含的目录都有为这个包服务的__init__.py,你得在其他__init__.py被执行前定义哦。可以修改这个变量,用来影响包含在包里面的模块和子包。

这个功能并不常用,一般用来扩展包里面的模块。

2 Python模块库

python标准库:https://docs.python.org/zh-cn/3/library/

第三方模块(包)库——PyPI(Python Package Index):https://pypi.org/


案例一:使用datetime计算日期差

datetime 模块提供了可以通过多种方式操作日期和时间的类。在支持日期时间数学运算的同时,实现的关注点更着重于如何能够更有效地解析其属性用于格式化输出和数据操作。

重要三个类型:datetime.date~.time~.datetime

  • (1) 引入datetime模块 使用前需要引入datetime模块,datetime中包含了一个date的对象。我们主要使用datetime模块下的date对象来进行操作。
  • (2) datetime.datetime.date(YYYY,MM,DD)可以获取变量YYYY年,MM月,DD日的date类型数据 例如:使用 datetime.date(2020,1,1) 获取2020年1月1日的对应日期类型值,其中年月日均应为整数类型。年的整数值为4位,月和日均应1位或2位,而且第一位不能为0。
  • (3) 使用 datetime.date.today() 可获取当前日期值,date类型
  • (4) 两个日期可求差值,单差值是一个时间差类型,timedelta类型
  • (5) timedelta类型,两个日期值的差值为一个时间差类型,这个类型的days属性可获取时间差的天数。 例如

【例子:】

"""
计算今天距离2022年2月4日
北京冬奥会开幕还有多少天?
"""
import datetime                            #引入日期时间模块
import time                                #引入时间模块
d1=datetime.date.today()                #获取今天的日期类型值
d2=datetime.date(2022,2,4)                #获取2022年2月4日的日期类型值
d3=d2-d1                                #timedelta类型,d3.days获取天数
print( time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) )#格式化输出日期和时间
print(d1)    #输入日期
print('今天距离冬奥会开幕还有%d天'%d3.days)     #通过d3.days获取时间差的天数,整型

【结果:】

2020-05-27 14:28:39
2020-05-27
今天距离冬奥会开幕还有618天

案例二:使用turtle画图

步骤:

  1. 导入模块
  2. 创建海龟
  3. 控制海龟画图

下表给出了turtle的部分运动函数:

函数 别名(缩写) 功能
forward(d) fd(d) 向前移动距离d代表距离
backward(d) bk(d)或back(d) 向后移动距离d代表距离
right(degree) rt(degree) 向右转动多少度
left(degree) It(degree) 向左转动多少度
goto(x,y) 将画笔移动到坐标为(x,y)的位置
stamp() 绘制当前图形
speed(speed) 画笔绘制的速度范围[0,10]整数
setheading(degree) seth(degree) 海龟朝向,degree代表角度
circle(radius,extent) 绘制一个圆形,其中,radius为半径,extent为度数,例如,若extent为180,则画一个半圆;如果画一个圆形,可不必写第2个参数

下表给出了turtle的部分画笔控制函数:

函数 别名(缩写) 功能
pendown() down()或pd() 画笔落下,移动时绘制图形
penup() up()或pu() 画笔拾起,移动时不绘制图形
reset() 恢复所有设置
pensize(width) width() 画笔的宽度
pencolor(colorstring) 画笔的颜色
fillcolor(colorstring) 绘制图形的填充颜色

综合例子:

#导入模块
import turtle
#创建海龟 
t=turtle.Turtle()
#画边长100的正方形
t.reset()   #重画 
for i in range(4):
    t.forward(100)  #向前走100, t.back(100)向后走100
    t.left(90)      #向左拐90°

t.reset()   #重画    
#画边长200三角形    
for i in range(3):
    t.forward(200) #向前走200
    t.left(120)     #向左拐120°

t.reset()   #重画    
#画一个实心圆
t.pensize(10)       #笔粗 设置为10
t.fillcolor('red')  #红色的填充
t.pencolor('green') #绿色的笔
t.begin_fill()      #开始填充
t.circle(100)       #半径100的圆
t.end_fill()        #结束填充

#此时海龟→,+100海龟左边-100海龟右边,+180顺时针-180逆时针
t.reset()   #重画  
t.circle(-100,180) #画右下 的 半圆
t.undo()    #撤回上一步
t.circle(-100,-180) #画左下 的 半圆
t.undo()    #撤回上一步
t.circle(100,180) #画右上 的 半圆
t.undo()    #撤回上一步
t.circle(100,-180) #画左上 的 半圆
t.undo()    #撤回上一步

#画坐标
t.reset()   #重画 
t.up()      #抬起笔,不画线
t.goto(-300,0)  #移动坐标
t.down()    #下笔,开始画线
t.forward(600)  #默认方向是右,前进600
t.up()
t.goto(0,-300)
t.left(90)
t.down()
t.forward(600)

#画曲线
'''
x:[-100,100]
y:sin(x/10)*100 放大100倍
'''
t.reset()   #重画 
import math
x=list(range(-100,101))     #生成散点x坐标
y=[100*math.sin(t/10) for t in x]   #生成散点y坐标
t.up()
t.goto(x[0],y[0])   #最左边的点(-100,y)
t.down()
t.pencolor('black')
for i in range(1,201):
    t.goto(x[i],y[i])   #从左到右 连接各个散点

turtle.bye()    #结束画图程序

案例三:使用matplotlib绘制曲线

步骤:

  1. 导入matplot
  2. 准备数据
  3. 定义标签等信息
  4. 绘图

1 绘制曲线

import matplotlib.pyplot as plt #重命名为plt
x=[i/30 for i in range(-300,300)]
y=[0.5*t**2 for t in x]
plt.xlabel('x')
plt.ylabel('1/2 * x^2') # matplotlib不支持中文
plt.plot(x,y)

2 绘制基础柱状图

matplotlib模块使用bar函数绘制柱状图,其调用方式如下:

matplotlib.pyplot.bar(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)

参数x表示x轴标量序列,可以是列表、元组、或是一维数组;参数height表示柱形高度,也为一组标量序列;参数width表示柱形宽度。其他具体参数配置可参见官方文档


例子1:

import matplotlib.pyplot as plt
x=[1,2,3,4]
y=[100,130,110,90]
plt.xlabel('month')
plt.ylabel('sales')
for i in range(4):#每根柱状图加文字
    plt.text(x[i],y[i],y[i])
plt.bar(x,y)

例子2:

import matplotlib.pyplot as plt
# A班计算机程序设计课5个小组的平均成绩柱状图
means_score = (90, 85, 77, 82, 79) #y轴序列数据
index = list(range(5)) #生成 x 轴序列数据,对应第 i 个柱,从 0 开始
bar_width = 0.35 #条形宽度
x_labels = ['Group 1', 'Group 2', 'Group 3', 'Group 4', 'Group 5']
# x 坐标上 柱形 所对应的标签列表,注意要对应柱形个数
plt.xticks(index, x_labels) #使用xticks给柱状图添加横轴标签
plt.bar(index, means_score, bar_width, alpha=0.7, color='b') #绘制柱状图,alpha表示颜色的透明程度

例子3:

import matplotlib.pyplot as plt
#数据:xstring为年份字符串,ystring为每年评价价格字符串
xstring = '2015 2014 2013 2012 2011 2010 2009 2008 2007 2006 2005 2004 2003 2002 2001 2000'
ystring = '12914 11826 12997 12306.41 12327.28 11406 10608 8378 8667.02 8052.78 6922.52 5744 4196 4336 4588 4751'
x=list(map(eval,xstring.split()))
y=list(map(eval,ystring.split()))
#通过reverse函数将列表逆序存放
x.reverse()
y.reverse()
index=list(range(len(x)))
index=list(range(len(y)))
#使用xticks给柱状图添加横轴标签,倾斜45°
plt.xticks(index, x , rotation = 45) 
#plt.yticks(range(start,end,step))来指定y轴坐标的开始值、终止值和间隔值
plt.yticks(range(4000,13000+1000,1000))
#通过plt.ylim(begin,end)来指定 y 轴的显示的起始和结束。
plt.ylim(4000,13500)
plt.bar(index,y,color ='#800080')

3 绘制饼图

matplotlib模块使用pie函数绘制饼图,其调用方式如下:

matplotlib.pyplot.pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, data=None)[source]

饼图是逆时针绘制的,参数x表示绘制的序列数据,explode用于突出某个楔形(切片),具体值为偏移圆中心的占比,labels是一个字符串序列,用于给每个楔形打标签,colors用于指定楔形的颜色,autopct参数表示用数值标记楔形,可指定显示方式且标记在内部。其它参数可参见官方文档

例子1:

import matplotlib.pyplot as plt
labels = ['Frogs', 'Hogs', 'Dogs', 'Logs'] # 标签列表
sizes = [15, 30, 45, 10] # 绘制数据
explode = (0, 0.1, 0, 0)  # 只突出第二个切块,偏移比例为0.1 (i.e. 'Hogs')
plt.pie(sizes, explode=explode, labels=labels, autopct='%0.1f%%',
        shadow=True, startangle=90) # shadow表示添加阴影,startangle表示旋转角度
plt.axis('equal')  # 用于显示为一个长宽相等的饼图

输出图像如下所示:

例子2:

import matplotlib.pyplot as plt
data='2052380, 11315444, 20435242, 7456627, 3014264, 1972395, 185028'
labels=['none', 'primary', 'junior', 'senior', 'specialties', 'bachelor', 'master']
colors=['red','orange','yellow','green','purple','blue','black']
explode=[0,0,0.1,0,0,0,0]
data=data.split(',')
data=[eval(x) for x in data]
plt.pie(data, explode=explode, labels=labels,colors =colors,shadow=True) # shadow表示添加阴影,startangle表示旋转角度,colors颜色,labels标签
plt.axis('equal')  # 用于显示为一个长宽相等的饼图
打赏
  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!

客官,赏一瓶怡宝吧。

支付宝
微信