python学习笔记——慕课的一些介绍（入门级）

    本笔记整理自MOOC上的Python课程，本课程介绍了Python的入门级经典编程例子、Python基础语法以及Python的计算生态。

    课程链接为：Python语言程序设计-北京理工大学

目录

 

Python技术的全局化视角概览图

写在前面

一、input（）

二、eval（）

三、print（）

四、import

五、异常处理

六、turtle库（Python标准库）

七、数据类型

八、time库（Python标准库）

九、进度条设计

十、程序的控制结构

十一、random库（Python标准库）

十二、函数

十三、ambda函数

十四、递归

十五、PyInstaller库（第三方库）

十六、组合数据类型

十七、jieba库（第三方库）

十八、文本词频统计

十九、文件及其使用

二十、自动轨迹绘制

二十一、map()函数

二十二、一维数据的格式化和处理

二十三、二维数据的格式化和处理

二十四、wordcloud库（第三方库）

二十五、程序设计方法学

二十六、Python第三方库安装

二十七、os库（Python标准库）

二十八、第三方库自动安装脚本——os库的应用示例

二十九、Python计算生态

三十、最后，在笔记结尾，就画个花吧

---

Python技术的全局化视角概览图

                                        

写在前面

 Python代码有着众所周知的强制的易读性。

其实Python代码中写分号也未尝不可，比如你非常明确地希望你的程序只有“一行”代码，那么就将原来的分行形式写成一行就好了，在每句后面跟加上Python代码的稀客——分号，如果你的代码只有顺序结构，而没有复杂的分支或者循环结构，你会发现你的代码依然运行完好。

如果你嫌弃自己的Python代码又臭又长（尤其是print语句），也有方法解决，那就是分行，并在除分出的最后一行外的所有分行句尾加上符号"\"，over.

一、input（）

        输出提示信息（可选），并接收输入的字符串。示例：control_str=input("haha! write it!")

二、eval（）

    去引号函数

三、print（）

    print("a:",b)        此种带逗号的写法，会在a:和b之间自动加上空格

    print(a,end="")  输出a，没有输出回车

   print("\r"+a,end="")  由于有end=""，且有\r这个回车符，在循环中，此句的输出将覆盖上一句

   "{:f}".format(xxx)  格式化输出

   举例：print("转换后的温度是{:.2f}F".format(F))     此句程序的打印效果是将F以".2f"的格式（即保留两位小数）打印在冒号之间的"{:.2f}"处。

四、import

    1. import [库名]

    2. form [库名] import *

    3. import [库名] as [自起名称]

五、异常处理

解释：try之后的语句块1正常，则执行之后跳过语句块2；否则，发生异常/发生指定异常，就执行语句块2。

解释：没异常，执行1、3、4；有异常，则执行1、2、4。

六、turtle库（Python标准库）

    调整绘图窗体在电脑屏幕中的布局

        turtle.setup(宽度，高度，x（可选），y（可选）)；

    设置绘制窗口的标题栏信息

       turtle.title(title)

    turtle空间坐标体系（画布上的）

        1. 绝对坐标

            turtle.goto(x,y)

        2. 海龟坐标

            turtle.foward(d) 或者 turtle.fd(d)   向前

            turtle.bk(d)   向后

            turtle.circle(r,angle)    以左侧的某点为圆心画弧线前进。r为半径，angle为行进角度，圆心默认为海龟左侧距离海龟r的地方。r为负数，即右转了。

        3. 角度坐标

           turtle.setheading(angle) 或者 turtle.seth(angle)           改变海龟运行方向（绝对角度）

           turtle.left(angle)                                                             向左改变海龟运行方向（相对角度）

           turtle.right(angle)                                                           向左改变海龟运行方向（相对角度）

    turtle的RGB色彩模式

       turtle.colormode(mode)    mode写成1.0时候，使用的是RGB小数值模式；写成255时，使用的是RGB整数值模式。

    画笔控制函数(成对出现)

        turtle.penup()                    画笔抬起来，或者海龟飞起来，即不留下痕迹。别名：turtle.pu()

        turtle.pendown()               画笔落下来，或者海龟着地，即留下痕迹。别名：turtle.pd()

      turtle.pensize(width)        设置画笔宽度，或者海龟腰围。别名：turtle.width(width)

     turtle.pencolor(color)    设置画笔色彩，即龟壳颜色。color有三种形式：颜色字符串，如："purple"；RGB的小数值，如：0.63,0.13,0.94；RGB的元组值，如：(0.63,0.13,0.94)。

      turtle.write()                   直接绘制字符，示例：         

turtle.write('我',font=("Arial",180,"normal"))

  海龟隐藏

         turtle.hideturtle()     隐藏海龟，或者说画笔 

  退出

          turtle.done()         程序末尾加上此句，则图像不会自动退出，而是停留在最后的状态。

七、数据类型

整数类型的四种进制表示形式：十进制、二进制（0b或0B开头）、八进制（0o或0O开头）、十六进制（0x或0X开头）

浮点数的取值范围约为-10^308~10^308，精度10^(-16)

浮点数的计算存在不确定尾数问题，这是计算的底层设计问题（计算机内部是二进制），不是bug。举例：python在判断(0.1+0.2==0.3)时候将返回false。

round(x,d)函数，可以进行四舍五入操作，其中的d表示保留的小数位数。

浮点数支持科学计数法表示。举例：3e4=3*10^4；8E-9=8*10^(-9)。

复数类型举例：z=1+2j    z.real获得实部，z.imag获得虚部

python中两个整数相除是浮点数。这一点比较特殊。举例：10/3=3.333333...；10//3=3，注意，"//"这个符号得到的是整数。

x**y=x^y

支持增强操作符：x+=y、x**=y等

基本数值运算函数：abs(x)  取绝对值； divmod（x,y） 做商余操作，输出（x//y,x%y);

                                   pow(x,y)   输出x^y； pow(x,y,z)   输出(x^y)%z;

                                   round(x,d) 保留d位小数； round(x)  对x取整;

                                   max(...)、min(...)；

                                   int(x)  将浮点数甚至字符串x变成整数; float(x) 将整数甚至字符串x变成浮点数;

                                   complex(x)  将x变成复数。

字符串中，'''这里可以输入"和'都能够显示出来，因为两端是三单引号'''

字符串中，可以通过str[m,n,step]对字符串进行切片

转义符为\，\b表示回退，\n表示换行（光标移到下行首），\r表示回车（光标移到本行首）

字符串操作符

            x+y           连接字符串x和y;         n*x       将字符串x复制n次；

            x in s        如果x是s的子串，返回true，否则返回false

字符串处理函数

           len(x)       返回字符串x的长度；  

           str(x)       将任何类型的x转化成字符串，这与eval()函数相反；

          hex(x)、oct(x) 将整数x转化成十六进制或八进制的小写形式字符串，如oct(8)相当于"0o10"；

          chr(u)     u为unicode编码，此函数将返回对应此编码的字符

          ord(x)     x为单字符，此函数将返回此单字符对应的unicode编码

字符串处理方法

          str.lower()、str.upper()     返回字符串的副本，此副本是原副本的全小写/全大写形式

          str.split(s)                         返回以s分割的子字符串列表

          str.count(sub)                   返回str中子字符串sub出现的次数

          str.replace(old,new)         返回字符串的副本，此副本中的子字符串old全部被字符串new替换

          str.center(num,ch)            str根据宽度num居中，宽度两侧的部分以字符ch填充

          str.strip(chars)                  去掉str的左侧和右侧，出现在字符串chars（或者说是字符数组）中的字符，然后返回

          str.join(iter)                      举例说明吧：",".join("12345")的返回值是"1,2,3,4,5"

字符串类型的格式化

          槽，一个字符串中的定义。槽默认对应于后面的format（）中的顺序；如果槽中有整数，则有以下意义：

        另外，槽中可以通过冒号来引导对格式化的配置方式，以下罗列六种：

其中，如果设置的宽度小于实际输出的宽度，输出依然会正常输出出来，宽度默认为输出自身的宽度。

八、time库（Python标准库）

python中处理时间的标准库。

主要的三类函数：

时间获取的函数中,

time()返回值是一个浮点数（最原生的状态）；ctime()返回一个人能看懂的字符串格式；gmtime()返回一个可供计算机处理的时间格式。

时间格式化的函数中，

可以看出，前一个函数是获取时间信息，后一个函数是将字符串形式的时间信息转换成计算机可认的时间格式。

补充一下常见的格式化字符串：

程序计时中，

九、进度条设计

        实验表明，在用户体验上，如实的进度条，不如在整体上先慢后快的进度条让人愉悦。

       下面是一个模拟“如实”的进度条程序片段：

import time
scale=50
print("begin".center(scale,"-"))
start=time.perf_counter()
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    d=time.perf_counter()
    print("\r{:3.0f}%[{}->{}]{:.2f}s".format(c,a,b,d),end="")
    time.sleep(0.1)
print("\n"+"end".center(scale,'-'))

十、程序的控制结构

二分支结构的紧凑形式：<表达式1> if <条件> else <表达式2>   如果满足条件，执行表达式1；否则执行表达式2。

紧凑形式中只能支持表达式，而不是语句。所以复杂语句还得用"if...else..."这个二分支结构。

多分支结构：if xxx: ... elif xxx: ... else: ...

操作符：== 表示“等于”； != 表示“不等于”。

用于两个条件进行组合的三个保留字： x and y  与运算;           x or y       或运算;             x not y  非运算。

分支结构是阅读代码时候的重要部分，看清它对阅读代码很重要。

遍历循环：for <循环变量> in <遍历结构>：<语句块> 

        解释：从遍历结构中依次取东西到循环变量，然后执行语句块，重复此操作直到遍历完成。

        计数循环： for i in range(N):...            这里的range()函数提供一个0到N-1的整数序列

                           for i in range(M,N):...        这里的range()函数产生一个M到N-1的整数序列

                           for i in range(M,N,K):...     这里的range()函数产生一个0到N-1，且步长为K的整数序列

        字符串遍历循环： for c in s:...            这里的字符串s依次提供它的每个字符给c

        列表遍历循环：     for item in ls:...     这里的列表ls依次提供它的每个元素给item

        文件遍历循环：     for line in fi:...       这里的文件标识符fi依次提供它所对应文件的每一行给line

        还有元组、字典等类型可以通过此种方式进行遍历。

无限循环：while xxx:...

循环控制保留字：break、continue

循环的扩展

            循环+else。如果循环执行到了break语句，则else部分的语句将不会被执行；否则，即循环正常执行完成（与continue无关哦），程序在循环完成之后将执行else之后的语句作为奖励。

十一、random库（Python标准库）

Python中用于生成（伪）随机数的库。

原理：随机数种子->梅森旋转算法->随机序列（其中的每一个数，即产生的“随机数”）

主要的两个函数

                   random.seed()        设置种子的函数

                   random.random()    根据种子返回生成的一个（伪）随机实数，它在[0,1)范围内

                   手动设置的相同种子产生的随机序列是相同的，即，有可以复现的性质；

                   不手动设置种子，用random()产生的随机数，默认是程序第一次调用random()时候的系统时间，因此它产生的随机序列几乎不可复现。

扩展的六个函数：

                 random.randint(a,b)                   生成一个[a,b]范围内的随机整数

                 random.randrange(m,n[,k])        生成一个[m,n)范围内以k为步长的随机整数。自然，没有k参数时候就是默认k=1咯

                 random.getrandbits(k)                生成一个k比特长的随机整数

                 random.uniform(a,b)                   生成一个[a,b]范围内的随机小数

                 random.choice(seq)                    返回从序列seq中随机选择的一个元素

                 random.shuffle(seq)                    将序列seq中的元素随机打乱，并重新赋值给seq。不返回东西，或者说返回None也行。即，此函数直接操作了序列seq。           

十二、函数

python使用保留字def进行函数的定义。其来源应是"define"（定义）这个英文单词。

函数是一段代码的表示：

def <函数名>（<函数参数>）:

    <函数体>

   return <返回值>

两种特殊函数的写法如下：

（1）可选参数函数

（2）可变参数函数

两种参数传递的方式（位置传递、名称传递）如下：

return返回多个值时，默认返回一个元组。

保留字global用于在函数内部定义和使用全局变量；

不用global，如果在函数内部没有真实创建某个组合数据类型，仅仅对其进行操作了，那它实际操作了函数外部的同名的全局变量（那个某个组合数据类型）。

十三、ambda函数

lambda函数是匿名函数，即没有名字。或者说，它的函数名就是返回值。

它使用保留字lambda进行定义。

<函数名> = lambda <参数>:<表达式>

示例如下：

使用方式：

十四、递归

思路就是，找到链条和基例。链条一般需要分析上下过程的关系才能清楚。

示例1——字符串反转：

def rvs(s):
    if s=="":
        return s
    else:
        return rvs(s[1:])+s[0]

示例2——求解斐波那契数列

示例3——汉诺塔问题

示例4——科赫雪花

import turtle
def koch(size, n):
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, 60, -120, 60]:
           turtle.left(angle)
           koch(size/3, n-1)
def main():
    turtle.setup(600,600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    level = 3      # 3阶科赫雪花，阶数
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
    turtle.done()
main()

十五、PyInstaller库（第三方库）

通过这个库，我们可以将python文件转换成exe等可以直接被Windows、Linux等系统直接识别的文件格式。

安装命令（windows）:    pip install pyinstaller

Windows下的使用(cmd命令行环境，而不是python环境)

      pyinstaller -F <文件名.py>       这句命令将生成以下三个文件夹，其中前两个可以直接删除，最后一个里面就有我们要的exe文件。

     

     常见参数如下：

     

十六、组合数据类型

三种主要结构：集合类型、序列类型（元组、列表）、字典类型

（1）集合

特点：无序、唯一、不可修改；不可修改是指集合元素是非可变数据类型。

使用{}或set()进行创建；

但补充一点，当创建空集合的时候，不能用{}，因为它会导致创建了一个空的字典，所以非要创建空集合的话，建议用set()。

示例：A={123,"abc",(a,b,c)}、B=set("python")、C=set(['p','y','t','h','o','n'])   这里的B集合和C集合都相当于{'p','y','t','h','o','n'}

集合间操作符

集合的处理方法

应用场景

判断包含关系；数据去重；

（2）序列

特点：一维元素向量、由序号引导且可通过下标进行访问

它是一种基类类型，下面的子类型有：字符串、元组、列表。

序列类型的通用操作符：

序列类型的通用函数及方法

元组类型：

              特点：是序列类型的一种，一旦创建不能被修改。

              使用()或tuple()进行创建；也可以不使用()来表示一个元组，如：return 1,2   creaturn=a,b,c

             应用：用于需要有序、不需要改动元素的场景，比如我需要保护我的数据被其它人修改，或用在返回的地方。

列表类型

              特点：是序列类型的一种，创建后可以随意被修改。

              使用[]或list()进行创建。

              如果将一个列表直接用=赋值给另外一个名称，此时并未真正创建一个新的列表！

              列表类型的操作符、函数及方法：

             

                   

                  应用：用在需要有序，且更灵活的场景。

（3）字典

特点：字典是键值对的集合，键值对之间无序。

使用{}或dict()创建，键值对中键与值用冒号分割；

补充一点，用{}可以直接创建了一个空的字典，这点是为了避免与集合冲突，非要创建空集合的话，建议用set()。

示例：mydic1={"a":1,"b":2,"c":3}           mydic2=dict([('spam', 1), ('egg', 2), ('bar', 3)] )

mydic3=dict(zip('abc', [1, 2, 3]))          mydic4=dict(spam = 1, egg = 2, bar =3)

mydic5={i:2*i for i in range(3)}             mydic6=dict.fromkeys(range(3), 'x')

向字典中增加元素的方法（举例说明）：

字典类型操作函数和方法：

字典的应用场景：表达映射，并操作它们。

十七、jieba库（第三方库）

中文文本需要通过分词获得单个的词语，jieba库就是一种提供三种分词模式的第三方库。

原理：该库利用一个中文词库，确定汉字之间的关联概率；汉字之间概率大的组成词组，这就是分词的结果。另外，用户可以向该库自行增加词组。

jieba分词的三种模式：

jieba库常用函数（第一个属于精确模式，第二个属于全模式，第三个属于搜索引擎模式，第四个是增加词组）：

十八、文本词频统计

统计文本中的词汇出现的频率。

以下代码对用Python做中英文词频统计有一定参考价值：

#Hamlet词频统计（含Hamlet原文文本）

     def getText():
        txt = open("hamlet.txt", "r").read()
        txt = txt.lower()
        for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
            txt = txt.replace(ch, " ")   #将文本中特殊字符替换为空格
        return txt
     
    hamletTxt = getText()
    words  = hamletTxt.split()
    counts = {}
    for word in words:           
        counts[word] = counts.get(word,0) + 1
    items = list(counts.items())
    items.sort(key=lambda x:x[1], reverse=True) 
    for i in range(10):
        word, count = items[i]
        print ("{0:<10}{1:>5}".format(word, count))


#《三国演义》人物出场统计（上）（含《三国演义》原文文本）

    import jieba
    txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
    words  = jieba.lcut(txt)
    counts = {}
    for word in words:
        if len(word) == 1:
            continue
        else:
            counts[word] = counts.get(word,0) + 1
    items = list(counts.items())
    items.sort(key=lambda x:x[1], reverse=True) 
    for i in range(15):
        word, count = items[i]
        print ("{0:<10}{1:>5}".format(word, count))

#《三国演义》人物出场统计（下）（含《三国演义》原文文本）

     import jieba
    excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
    txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
    words  = jieba.lcut(txt)
    counts = {}
    for word in words:
        if len(word) == 1:
            continue
        elif word == "诸葛亮" or word == "孔明曰":
            rword = "孔明"
        elif word == "关公" or word == "云长":
            rword = "关羽"
        elif word == "玄德" or word == "玄德曰":
            rword = "刘备"
        elif word == "孟德" or word == "丞相":
            rword = "曹操"
        else:
            rword = word
        counts[rword] = counts.get(rword,0) + 1
    for word in excludes:
        del counts[word]
    items = list(counts.items())
    items.sort(key=lambda x:x[1], reverse=True) 
    for i in range(10):
        word, count = items[i]
        print ("{0:<10}{1:>5}".format(word, count))

十九、文件及其使用

文件类型

          文本文件：由单一特定编码组成的文件，如.txt文件、.py文件；

          二进制文件：直接由比特0、1构成的文件，没有统一的字符编码，如.png文件，.avi文件。

无论哪种文件，都实际以二进制存储。

文件的操作步骤一般是这样的：打开——>操作——>关闭。

（1）文件的打开

     不给打开模式这个参数时候，默认模式是"rt"模式。

     这里注意一点，就是路径的写法。由于在Python中斜杠"\"表示转义，而windows目录默认是以它分割的，所以实际填写路径时候为了让这两者不冲突，我们一般使用反斜杠"/"来替代原来路径中的斜杠"\"；或者在原来路径的斜杠前加上一个斜杠，形成双斜杠"\\"。  当然，程序一般更适合使用相对路径。

      文件的打开模式：

 

（2）文件的关闭

      

（3）文件的读取

  

 

利用上述函数，进行一起读入、逐行处理：

但其实不用上述函数，就可进行逐行读入、逐行处理：

（4）文件的数据写入

seek(0)非常常用；比如你刚写入的数据，又去取数据，此时文件指针在文件写入内容的末尾，你取的数据就为空，所以这个时候就要在取数据前进行seek(0)操作。

二十、自动轨迹绘制

含义：读取一个文件，解析其中的数据，根据解析结果进行图形绘制。

目的：通过分离数据和功能，并设计良好清晰的接口，以实现自动化，体验数据驱动带来的快感。

实现步骤：

       

接口定义(这是其中一种，当然可以自定义此文件格式)：

        

对应上面定义的接口的代码示例：

import turtle as t
t.title('自动轨迹绘制')
t.setup(800, 600, 0, 0)
t.pencolor("red")
t.pensize(5)
#数据读取
datals = []
f = open("data.txt")
for line in f:
    line = line.replace("\n","")
    datals.append(list(map(eval, line.split(","))))
f.close()
#自动绘制
for i in range(len(datals)):
    t.pencolor(datals[i][3],datals[i][4],datals[i][5])
    t.fd(datals[i][0])
    if datals[i][1]:
        t.rt(datals[i][2])
    else:
        t.lt(datals[i][2])

二十一、map()函数

    map()    第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

二十二、一维数据的格式化和处理

（1）一维数据的表示

    一般来讲，有序的一维数据就用列表表示和处理，无序的一维数据就用集合表示和处理。

（2）一维数据的存储

    存储方式一：使用空格分隔数据；

    存储方式二：使用逗号分隔数据；

    存储方式三：使用很少用到的特殊符号进行数据分割。

（3）一维数据的处理

     将数据从文件中读取出来并使之变成列表：

    

    将数据写入文件：

二十三、二维数据的格式化和处理

（1）二维数据的表示

         基础Python部分，一般用二维列表就可以了。

（2）CSV格式

CSV:Comma-Separated Values

它是国际通用的存储一二维数据存储格式，一般以.csv作为扩展名；每行一个一维数据，以逗号分割；无空行；很多编辑软件都可以编辑此文件格式。

且，

（3）二维数据的处理

二维数据的读取：

 

二维数据的写入：

 

二维数据的遍历：

二十四、wordcloud库（第三方库）

windows下的pip安装：pip install wordcloud

简介

内部处理原理

wordcloud库的常规函数或方法

使用步骤

配置参数

 

   

   

由于中文的词语不以空格分割，因此需要先用jieba库进行预处理，一个简单示例如下：

词云绘制示例代码：

#常规矩形词云

    import jieba
    import wordcloud
    f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
     
    t = f.read()
    f.close()
    ls = jieba.lcut(t)
     
    txt = " ".join(ls)
    w = wordcloud.WordCloud( \
        width = 1000, height = 700,\
        background_color = "white",
        font_path = "msyh.ttc"    
        )
    w.generate(txt)
    w.to_file("grwordcloud.png")


#不规则图形词云

     import jieba
    import wordcloud
    from scipy.misc import imread
    mask = imread("chinamap.jpg")
    excludes = { }
    f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
    t = f.read()
    f.close()
    ls = jieba.lcut(t)
    txt = " ".join(ls)
    w = wordcloud.WordCloud(\
        width = 1000, height = 700,\
        background_color = "white",
        font_path = "msyh.ttc", mask = mask
        )
    w.generate(txt)
    w.to_file("grwordcloudm.png")

二十五、程序设计方法学

想法很重要，编程只是手段，多元化的思维方式则有利于想法的产生。

计算思维

         区别于逻辑思维和实证思维的计算思维：抽象+自动化；

         它基于计算机的思维、利用工具的思维；

         它关注设计和构造，而非因果；

         它利用编程手段实现自动化的过程。

         编程：分而治之、模块化集成、配置化设计：程序引擎+配置文件，等思想。

计算生态与Python

        开源有大教堂模式和集市模式之分。

       

         Python语言的计算生态：

      

     

           计算生态区别于API的一点就是它有着野蛮生长和竞争的特性。

关于编程

         

用户体验

       1.合理增加进度条；

       2.健壮性，即适当抛出错误提示；

       3.合理打印输出；

       4.保存日志文件；

       5.提供帮助信息；等。

二十六、Python第三方库安装

Python社区：PyPI社区

PyPI社区介绍：

PyPI社区的使用：

Python第三方库的三种安装方式

      （1）pip安装

                  安装：

                 更新：

                 卸载：

                下载但不安装：

               列出库详细信息：

              搜索库介绍或者库名包含指定关键词的库：

              列出已经安装的库：pip list

       （2）集成安装

            Anaconda（嗯，如果你的机器还没装Python环境，个人推荐，别装了，直接装这个吧！）

       （3）文件安装方法

             有的库只能下载，但因为你电脑上没有相关环境，导致不能安装。

             这里有一个神奇的网站，UCI页面（非正式称谓）

             我们可以在这里找编译后的库文件。

            具体的神操作方法：

           

二十七、os库（Python标准库）

它提供通用的、基本的操作系统交互功能。如：路径操作、进程管理、环境参数等等等。

路径操作

        基本介绍：

       

      相关函数：

      

        

          

        

        

进程管理

        可以调用其它的程序或命令。

        最主要的一个函数：

      

     使用示例：

    

环境参数

      指的是获取或改变系统的环境信息。

     常见函数：

    

   

  

二十八、第三方库自动安装脚本——os库的应用示例

话不投机半句多，直接上示例中的代码：

import os
libs = {"numpy","matplotlib","pillow","sklearn","requests",\
        "jieba","beautifulsoup4","wheel","networkx","sympy",\
        "pyinstaller","django","flask","werobot","pyqt5",\
        "pandas","pyopengl","pypdf2","docopt","pygame"}
try:
    for lib in libs:
        os.system("pip3 install "+lib)
    print("Successful")        
except:
    print("Failed Somehow")

这个用Python写的脚本直接用cmd运行，即可下载代码中列举的Python库。

里面用了os库。其实调用其它的计算机程序或自编程序，Python脚本会更有意思。

二十九、Python计算生态

（1）从数据处理到人工智能

Python与上述计算生态的联系——相关Python库

Python库之数据分析——Numpy和它的儿子们：Pandas、Scipy

           Numpy库介绍：

           

          Pandas库介绍：

         

         Panda库对一维数据和二维数据的扩展形成的两种数据类型：

       

         Scipy库介绍：

         

       

Python库之数据可视化——Numpy的儿子：Matplotlib；Matplotlib的儿子：Seaborn；Mayavi

               Matplotlib库介绍：

             

             Seaborn库介绍：

            

                Mayavi库介绍：

                

Python库之文本处理——PyPDF2、NLTK、Python-docx

             PyPDF2库介绍：

            

           NLTK库介绍：

          

            Python-docx库介绍：

           

Python库之机器学习——Scikit-learn、TensorFlow、MXNet

           Scikit-learn库介绍：

           

         TensorFlow库介绍：

          

         MXNet库介绍：

        

小试牛刀——霍兰德人格分析雷达图（直接代码）：

#HollandRadarDraw
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['font.family']='SimHei'
radar_labels = np.array(['研究型(I)','艺术型(A)','社会型(S)',\
                         '企业型(E)','常规型(C)','现实型(R)']) #雷达标签
nAttr = 6
data = np.array([[0.40, 0.32, 0.35, 0.30, 0.30, 0.88],
                 [0.85, 0.35, 0.30, 0.40, 0.40, 0.30],
                 [0.43, 0.89, 0.30, 0.28, 0.22, 0.30],
                 [0.30, 0.25, 0.48, 0.85, 0.45, 0.40],
                 [0.20, 0.38, 0.87, 0.45, 0.32, 0.28],
                 [0.34, 0.31, 0.38, 0.40, 0.92, 0.28]]) #数据值
data_labels = ('艺术家', '实验员', '工程师', '推销员', '社会工作者','记事员')
angles = np.linspace(0, 2*np.pi, nAttr, endpoint=False)
data = np.concatenate((data, [data[0]]))
angles = np.concatenate((angles, [angles[0]]))
fig = plt.figure(facecolor="white")
plt.subplot(111, polar=True)
plt.plot(angles,data,'o-', linewidth=1, alpha=0.2)
plt.fill(angles,data, alpha=0.25)
plt.thetagrids(angles*180/np.pi, radar_labels,frac = 1.2)
plt.figtext(0.52, 0.95, '霍兰德人格分析', ha='center', size=20)
legend = plt.legend(data_labels, loc=(0.94, 0.80), labelspacing=0.1)
plt.setp(legend.get_texts(), fontsize='large')
plt.grid(True)
plt.savefig('holland_radar.jpg')
plt.show()

 

（2）从Web解析到网络空间

Python与Web计算生态的联系——相关Python库

Python库之网络爬虫——Requests、Scrapy、Pyspider

          Requests库介绍：

        

       Scrapy库介绍：

      

      Pyspider库介绍：

    

Python库之Web信息提取——Beautiful Soup、Re、Python-Goose

               Beautiful Soup库介绍：

        

       

       Re库介绍：

      

         Python-Goose库介绍：

        

Python库之Web网站开发——Django、Pyramid、Flask

          Django库介绍：

        

     

     Pyramid库介绍：

     

      Flask库介绍：

     

Python库之网络应用开发——WeRoBot、aip、MyQR

            WeRoBot库介绍：

          

            aip库介绍：

          

          MyQR库介绍：

         

（3）从人机交互到艺术设计

Python相关库：

Python库之图形用户界面——PyQt5、wxPython、PyGObject

            PyQt5库介绍：

            

              wxPython库介绍：

           

         PyGObject库介绍：

          

Python库之游戏开发——PyGame、Panda3D、cocos2d

           PyGame库介绍：

         

        Panda3D库介绍：

        

        cocos2d库介绍：

        

Python库之虚拟现实——VR Zero、pyvor、Vizard

            VR Zero库介绍：

           

            树莓派简介：

           pyovr库介绍：

            

             Vizard库介绍：

           

Python库之图形艺术——Quads、ascii_art、turtle

             Quads库介绍：

             

               ascii_art库介绍：

             

            turtle前面有详细介绍，这里不多废话了。

三十、最后，在笔记结尾，就画个花吧

import turtle as t
# 定义一个曲线绘制函数
def DegreeCurve(n, r, d=1):
    for i in range(n):
        t.left(d)
        t.circle(r, abs(d))
# 初始位置设定
s = 0.2 # size
t.setup(450*5*s, 750*5*s)
t.pencolor("black")
t.fillcolor("red")
t.speed(100)
t.penup()
t.goto(0, 900*s)
t.pendown()
# 绘制花朵形状
t.begin_fill()
t.circle(200*s,30)
DegreeCurve(60, 50*s)
t.circle(200*s,30)
DegreeCurve(4, 100*s)
t.circle(200*s,50)
DegreeCurve(50, 50*s)
t.circle(350*s,65)
DegreeCurve(40, 70*s)
t.circle(150*s,50)
DegreeCurve(20, 50*s, -1)
t.circle(400*s,60)
DegreeCurve(18, 50*s)
t.fd(250*s)
t.right(150)
t.circle(-500*s,12)
t.left(140)
t.circle(550*s,110)
t.left(27)
t.circle(650*s,100)
t.left(130)
t.circle(-300*s,20)
t.right(123)
t.circle(220*s,57)
t.end_fill()
# 绘制花枝形状
t.left(120)
t.fd(280*s)
t.left(115)
t.circle(300*s,33)
t.left(180)
t.circle(-300*s,33)
DegreeCurve(70, 225*s, -1)
t.circle(350*s,104)
t.left(90)
t.circle(200*s,105)
t.circle(-500*s,63)
t.penup()
t.goto(170*s,-30*s)
t.pendown()
t.left(160)
DegreeCurve(20, 2500*s)
DegreeCurve(220, 250*s, -1)
# 绘制一个绿色叶子
t.fillcolor('green')
t.penup()
t.goto(670*s,-180*s)
t.pendown()
t.right(140)
t.begin_fill()
t.circle(300*s,120)
t.left(60)
t.circle(300*s,120)
t.end_fill()
t.penup()
t.goto(180*s,-550*s)
t.pendown()
t.right(85)
t.circle(600*s,40)
# 绘制另一个绿色叶子
t.penup()
t.goto(-150*s,-1000*s)
t.pendown()
t.begin_fill()
t.rt(120)
t.circle(300*s,115)
t.left(75)
t.circle(300*s,100)
t.end_fill()
t.penup()
t.goto(430*s,-1070*s)
t.pendown()
t.right(30)
t.circle(-600*s,35)
t.done()