Python基础笔记整理-嵩天版_嵩天python 笔记

01 Python基本语法元素

1.1 程序设计基本方法

计算机执行源程序的两种方式：编译和解释

• 编译： 将源代码一次性转换成目标代码的过程

执行编译的过程叫编译器

• 解释： 将源代码逐条转换成目标代码同时逐条运行目标代码的过程

执行解释过程的程序叫解释器

根据执行方式不同，编程语言分为：静态语言和脚本语言

• 静态语言： 使用编译执行的编程语言(C/C++，Java)

优化更充分，运行速度更快

• 脚本语言： 使用解释执行的编程语言(Python，JavaScript，PHP)

维护更灵活，跨平台操作

基本编写方法

I: input 输入，程序的输入

P: process 处理，程序的主要逻辑

O: output 输出，程序的输出

1.2 温度转换

TempStr = input("请输入带有符号的温度值:")
if TempStr[-1] in ['F', 'f']:
    C = (eval(TempStr[0:-1]) - 32)/1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C', 'c']:
    F = 1.8 * (eval(TempStr[0:-1])) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输出格式错误")
1
2
3
4
5
6
7
8
9

1.3 语法元素

变量和注释

变量：用来保存和表示数据类型的占位符号

命名规则：字母数字下划线组成，区分大小写，首字母不能是数字，不能是关键字

单行注释：# 多行注释：‘’’ ‘’’

数据类型

整数，字符串，浮点数，列表

输入输出评估

input() 从控制台获得用户输入的函数

print() 以字符形式向控制台输出结果的函数

eval() 去掉参数最外侧引号并执行余下语句的函数

eval("1+2")	# 3
eval("'1.2'")	# '1.2'
eval("Hello")	# Hello
1
2
3

02 Python基本图形绘制

2.1 深入了解Python语言

Python是唯一的"超级语言"

特点：通用性，简洁性，生态性

编程语言的种类

超级语言： 粘性整合已有程序，具备庞大计算生态

高级语言： 接近自然语言，编译器，与CPU型号无关

机器语言： 代码直接执行，与CPU型号有关

汇编语言： 有助记符，汇编器，与CPU型号有关

2.2 Python蟒蛇绘制

import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor('violet')
turtle.seth(-40)
for i in range(4):
    turtle.circle(40, 80)
    turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.3 turtle库的使用

库引用

# 方案一：turtle.
import turtle
# 方案二：直接调用
from turtle import *
# 方案三：t.
import turtle as t
1
2
3
4
5
6

控制函数

# 绘图窗口在屏幕中的布局
turtle.setup(800, 400, 0, 0)  # 宽,高,x坐标,y坐标(默认中心)
# 运动控制
turtle.goto(100, 100)	# 移动到坐标位置
turtle.circle() # 绘制圆：半径,角度(默认360)
turtle.fd() # 前进
turtle.bk() # 后退
# 方向控制
turtle.seth()   # 改变方向，绝对角度
turtle.left()   # 左转，逆时针相对角度
turtle.right()   # 右转，顺时针相对角度
# 色彩模式
turtle.colormode(1.0)   # RGB小数模式
turtle.colormode(255)   # RGB整数模式
# 画笔控制
turtle.penup()  # 抬笔
turtle.pendown()    # 落笔
turtle.pensize(20)    # 画笔宽度
turtle.pencolor('purple')   # 画笔颜色，紫色的三种表现形式
turtle.pencolor(0.63, 0.13, 0.94)
turtle.pencolor(160, 32, 240)
# 拓展函数
turtle.bgcolor('black')	# 窗口背景色
turtle.color('red', 'white')	# 画笔颜色，填充颜色
turtle.begin_fill()	# 开始填充
turtle.end_fill()	# 结束填充
turtle.write('文本', font=('Arial',20,'normal'))	# 打印文本，字体(中/英),大小,正常
turtle.hideturtle()	# 隐藏海龟图标
turtle.speed()	# 绘制速度，0-10
turtle.done()	# 停止画笔绘制，不关闭绘图窗口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2.4 循环语句

for i in range(5):
    print("Hello:", i)
1
2

03 基本数据类型

3.1 数字类型及操作

pow()函数：计算次方，可以嵌套

pow(2,3)	# 2的3次方
pow(2,pow(2,3))
1
2

四种进制： 十进制，二进制(0b)，八进制(0o)，十六进制(0x)

round()函数：四舍五入

round(3.1415,2)	# 保留两位小数
1

复数类型： z = a + bj，其中a为实部，b为虚部

z = 5 + 2j
print(z.real)   # 获取实部
print(z.imag)   # 获取虚部
1
2
3

操作符

+，-，*，/，//(整除)，%(取模)，**(幂运算)

数值运算函数

abs(-10)	# 绝对值
divmod(10,3)	# 商余，输出10//3,10%3
max(1,9,5,4)	# 最大值
min(3,5,9,6)	# 最小值
int(12.24)	# 转化为整数，输出12
float(12)	# 转化为浮点数，输出12.0
complex(4)	# 变复数，输出(4+0j)
1
2
3
4
5
6
7

3.2 天天向上的力量

# 工作(提升0.01)五天，休息(下降0.01)两天
dayup = 1.0
dayfactor = 0.01
for i in range(365):
    if i % 7 in [6,0]:
        dayup = dayup * (1-dayfactor)
    else:
        dayup = dayup * (1+dayfactor)
print('工作日的力量:{:.2f}'.format(dayup))

# 每天努力0.01，1.01^365=37.78，作5休2时工作日要怎么努力才能达到像每天努力0.01的程度
def dayUP(df):
    dayup = 1.0
    for i in range(365):
        if i % 7 in [6,0]:
        	dayup = dayup * (1-0.01)
    	else:
        	dayup = dayup * (1+df)
	return dayup           
dayfactor = 0.01
while dayUP(dayfactor) < 37.78:
    dayfactor += 0.001
print('工作日要付出的努力参数是:{:.2f}'.format(dayfactor))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.3 字符串类型及操作

索引：str[2]

切片：str[0:-1]

# 顾头不顾尾
str = "0123456789"
str[:3]	# 012
str[1:8:2]	# 步长为2，结果为1357
str[::-1]	# 9876543210
1
2
3
4
5

转义符

print("这里有一个引号(\")")	# 这里有一个引号(")
\b	# 回退
\n	# 换行(光标移动到下行首)
\r	# 回车(光标移动到本行首)
1
2
3
4

操作符及使用

x + y 连接两个字符串x和y

x * n 复制n次字符串x

x in s 如果x是s的子串返回True，否则False

字符串处理函数

len("abcdef")	# 字符串长度，6
str(123)	# 强制转换为字符串类型，"123"
hex(425)	# 十六进制，"0x1a9"
oct(425)	# 八进制，"0o651"
chr(10004)	# Unicode变字符，√
ord("√")	# 字符变Unicode，10004
1
2
3
4
5
6

字符串处理方法

str.lower('ABC')	# 变小写，abc
str.upper('abc')	# 变大写，ABC
str = "A,B,C"
str.split(',')	# 返回列表，以‘,’进行分割，['A','B','C']
str = "an apple a day"
str.count('a')	# 统计个数，4
str.replace('a','A')	# 替换，An Apple A dAy
str.center(20,'*')	# 根据所设宽度居中，***an apple a day***
str = "python"
str.strip('pn')	# 去掉左侧和右侧的字符
str.join('123')	# 将str插进字符串中，1python2python3
1
2
3
4
5
6
7
8
9
10
11

format()格式化

: 填充 对齐(<左[默认]>右^中) 宽度
print("{0:=^10}".format('python'))	# ==python==
print("{0:*>10}".format('python'))	# ****python
print("{0:-<10}".format('python'))	# python----
: ,(千位分隔符) .(精度) f(类型)
print("{0:,.2f}".format(1234.56))	# 保留两位小数，1,234.56
print("{0:b},{0:c},{0:d},{0:o},{0:x}".format(123))	# 整数类型，1111011,{,123,173,7b
print("{0:e},{0:f},{0:%}".format(12.3))	# 浮点数类型，1.230000e+01,12.300000,1230.000000%
1
2
3
4
5
6
7
8

3.4 time库的使用

调用time库：import time

时间获取

print(time.time())  # 1637232147.2817955
print(time.ctime()) # Thu Nov 18 18:42:27 2021
print(time.gmtime())    # time.struct_time(tm_year=2021, tm_mon=11, tm_mday=18, tm_hour=10, tm_min=42, tm_sec=27, tm_wday=3, tm_yday=322, tm_isdst=0)
1
2
3

时间格式化

t = time.gmtime()
s = time.strftime("%Y-%m-%d %H:%M:%S", t)
print(s)	# 2021-11-18 11:01:25
print(time.strptime(s, "%Y-%m-%d %H:%M:%S"))	# time.struct_time(tm_year=2021, tm_mon=11, tm_mday=18, tm_hour=11, tm_min=1, tm_sec=25, tm_wday=3, tm_yday=322, tm_isdst=-1)
1
2
3
4

程序计时

start = time.perf_counter()	# 记录开始时间
time.sleep(1.2)	# 休眠1.2秒
end = time.perf_counter()	# 记录结束时间
end - start

start = time.procoss_time()	# 不包含sleep
end = time.procoss_time()
end - start
1
2
3
4
5
6
7
8

3.5 文本进度条

import time
scale = 50
print('执行开始'.center(scale//2, '-'))
start = time.perf_counter()
for i in range(scale+1):
    a = '*' * i
    b = '.' * (scale-i)
    c = (i/scale)*100
    dur = time.perf_counter()-start
    print('\r{:^3.0f}%[{}->{}]{:.2f}s'.format(c, a, b, dur), end='')
    time.sleep(0.1)
print('\n'+'执行结束'.center(scale//2, '-'))
1
2
3
4
5
6
7
8
9
10
11
12

04 程序的控制结构

4.1 程序的分支结构

流程图的基本元素是：判断框

单分支：if

二分支：if - else

多分支：if - elif - else

表达式 if 条件 else 表达式

a, b = 10, 5
print('正确') if a > b else print('错误')	# 正确
1
2

条件判断及组合

== 等于，!= 不等于，>，>=，<，<=

and 逻辑与，or 逻辑或，not 逻辑非

程序的异常处理

# 方案一
try:
    num = eval(input("请输入一个整数:"))
    print(num)
except:
    print("输入的不是整数")
# 方案二
try:
    num = eval(input("请输入一个整数:"))
    print(num)
except NameError:
    print("输入的不是整数")
# 高级使用
try - except - else - finally
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.2 身体质量指数

height, weight = eval(input("请输入身高(米)和体重(公斤)[逗号隔开]:"))
bmi = weight/pow(height, 2)
print("BMI数值为{:.2}".format(bmi))
who, nat = "", ""
if bmi < 18.5:
    who, nat = "偏瘦", "偏瘦"
elif 18.5 <= bmi < 24:
    who, nat = "正常", "正常"
elif 24 <= bmi < 25:
    who, nat = "正常", "偏胖"
elif 25 <= bmi < 28:
    who, nat = "偏胖", "偏胖"
elif 28 <= bmi < 30:
    who, nat = "偏胖", "肥胖"
else:
    who, nat = "肥胖", "肥胖"
print("BMI指标为:国际'{0}',国内'{1}'".format(who, nat))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.3 程序的循环结构

遍历循环

for i in range(5):
    print(i)
for i in range(1,6):
    print(i)
for i in range(1,6,2):
    print(i)
for s in 'python':
    print(s, end=',')
for item in [12, 'python', 34]:	# 列表遍历循环
    print(item, end=',')
for line in fi:	# 文件遍历循环
    print(line)
1
2
3
4
5
6
7
8
9
10
11
12

无限循环

while True:

循环控制保留字

break 结束本层循环(可以终结一个循环)

continue 结束本次循环

4.4 random库的使用

调用random库：import random

作用：random库主要用于生成随机数

随机函数

# 基本
random.seed(10) # 给定随机数种子，产生种子10对应的序列
random.random() # [0.0到1.0)间的随机小数
# 扩展
random.uniform(10, 20)   # [10到20]间的随机小数
random.randint(10, 20)   # [10到20]间的随机整数
random.randrange(10, 20, 2) # [10到20]间步长为2的随机整数
random.getrandbits(8)   # 8位的随机整数
random.choice([1, 2, 3])    # 随机选择列表内的一个元素
ls = [1, 2, 3, 4]
random.shuffle(ls)  # 将列表内元素顺序打乱
print(ls)
1
2
3
4
5
6
7
8
9
10
11
12

4.5 圆周率的计算

from random import random
from time import perf_counter
darts = 1000*1000
hits = 0.0
start = perf_counter()
for i in range(1, darts+1):
    x, y = random(), random()
    dist = pow(x ** 2 + y ** 2, 0.5)
    if dist <= 1.0:
        hits = hits+1
pi = 4 * (hits/darts)
print("圆周率是:{}".format(pi))
print("运行时间是:{:.5}s".format(perf_counter()-start))
1
2
3
4
5
6
7
8
9
10
11
12
13

05 函数和代码复用

5.1 函数的定义与使用

函数作用：降低编程难度和代码复用

def fact(n):	# 函数名和参数
    s = 1
    for i in range(1, n+1):
        s *= i
	return s	# 返回值
fact(10)	# 函数调用

def fact():	# 参数可以没有，必须保留括号
    print("Python")

def fact(*n):	# 可变参数(不确定参数数量时可设置可变参数)
    s = 0
    for i in n:
        s += i
    return s
print(fact(1, 2, 3, 4))	# 10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

参数传递的两种方式：位置传递，名称传递

局部变量全局变量

可通过global声明全局变量

组合数据类型：如果局部变量未真实创建，则是全局变量

ls = ['A', 'B']
def fact(a):
    ls.append(a)	# ls未真实创建，等同于全局变量
	return
fact('C')	# 全局变量ls被修改
print(ls)	# ['A', 'B', 'C']

ls = ['A', 'B']
def fact(a):
    ls = []	# ls真实创建，是局部变量
    ls.append(a)
	return
fact('C')	# 全局变量ls未修改
print(ls)	# ['A', 'B']
1
2
3
4
5
6
7
8
9
10
11
12
13
14

lambda函数

匿名函数，用于定义简单且能在一行内表示的函数

f = lambda x,y : x+y
print(f(10, 15))	# 25

f = lambda : "Python"
print(f())	# Python
1
2
3
4
5

5.2 七段数码管绘制

import turtle,time
def drawGap():  # 绘制数码管间隔
    turtle.penup()
    turtle.fd(5)
def drawLine(draw): # 绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit):   # 根据数字绘制七段数码管
    drawLine(True) if digit in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180)
    turtle.penup()  # 为绘制后续数字确定位置
    turtle.fd(20)   # 为绘制后续数字确定位置
def drawDate(date): # 获得要输入的数字
    turtle.pencolor('red')
    for i in date:
        if i == '-':
            turtle.write('年', font=('Arial', 18, 'normal'))
            turtle.pencolor('green')
            turtle.fd(40)
        elif i == '=':
            turtle.write('月', font=('Arial', 18, 'normal'))
            turtle.pencolor('blue')
            turtle.fd(40)
        elif i == '+':
            turtle.write('日', font=('Arial', 18, 'normal'))
        else:
            drawDigit(eval(i))  # 通过eval()函数将数字变为整数
def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

5.3 代码复用与函数递归

紧耦合松耦合

模块内部紧耦合，模块之间松耦合

紧耦合： 两部分之间交流很多，无法独立存在

松耦合： 两部分之间交流较少，可以独立存在

递归的定义

函数定义中调用函数自身的方式

关键特征：①链条：计算过程存在链条 ②基例：存在一个或多个不需要再次递归的基例

递归的实现

函数 + 分支结构

# 递归求阶乘
def fact(n):
    if n == 0:
        return 1	# 基例
    else:
        return n * fact(n-1)	# 链条

# 字符串反转
s = input('请输入一个字符串:')
def reverse(s):
    if len(s) == 1:
        return s
    else:
        return reverse(s[1:])+s[0]
print(reverse(s))

# 斐波那契数列
def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n-1) + f(n-2)

# 汉诺塔
count = 0
def hannoi(n, src, dst,mid):
    global count
    if n == 1:
        print('{}:{}->{}'.format(1, src, dst))
        count += 1
    else:
        hannoi(n-1, src, mid, dst)
        print('{}:{}->{}'.format(n, src, dst))
        count += 1
        hannoi(n-1, mid, dst, src)
hannoi(3, 'A', 'C', 'B')
print(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

5.4 PyInstaller库的使用

作用：将.py文件转换成可执行的exe文件

安装(cmd命令行)：pip install pyinstaller

使用说明

打开cmd命令行，cd 进入文件夹

Pyinstaller -F 文件名.py	# 打包exe
Pyinstaller -F -w 文件名.py	# 不带控制台的打包
Pyinstaller -F -w -i 图标.ico 文件名.py	# 打包指定exe图标打包
1
2
3

5.5 科赫雪花绘制

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

06 组合数据类型

6.1 集合类型及操作

集合元素特点：无序，唯一，不可变

# 创建集合：set,{}
A = {'Python', 123, ('Python', 123)}	# {123, 'Python', ('Python', 123)}
B = set('Py12312')	# {'1', '2', 'y', '3', 'P'}
C = {'Python', 123, 'Python', 123}	# {123, 'Python'}
1
2
3
4

集合操作符

A = {'p', 'y', 123}
B = set('pypy123')
print(A - B)    # 差
print(A | B)    # 并
print(A & B)    # 交
print(A ^ B)    # 补
print(A < B)    # 返回False，同理：A <= B，A > B，A >= B
A |= B	# A与B的并集赋值给A，同理：A -= B，A &= B，A ^= B
1
2
3
4
5
6
7
8

集合处理方法

A = {'p', 'y', 123}
A.add(4)    # 新增元素
A.discard(4)    # 删除元素，不存在不报错
A.remove(4) # 删除元素，不存在则报错
A.clear()   # 删除所有元素
print(A.pop()) # 随机删除一个元素，集合为空则报错
print(A.copy()) # 返回集合副本
pirnt(len(A))	# 返回元素个数
123 in A	# True
123 not in A	# False
B = "Python"
set(B)	# 强制转换为集合类型
1
2
3
4
5
6
7
8
9
10
11
12

应用场景： 包含关系比较，数据去重

6.2 序列类型及操作

序列是具有先后关系的一组元素，是一个基类类型

通用操作符

X in s
X not in s
s + t	# 连接两个序列
s * n	# 序列s复制n次
s[i]	# 索引
s[i:j]或s[i:j:k]	# 切片
1
2
3
4
5
6

通用函数

len(s)	# 序列长度
min(s)	# 最小元素
max(s)	# 最大元素
s.index(x)或s.index(x,i,j)	# 序列从i到j，x第一次出现的位置
s.count(x)	# x出现的个数
1
2
3
4
5

元组类型

是序列类型的一种扩展，创建后不能修改

# 创建元组：(),无括号,tuple()
c = 'cat', 'dog', 123	# ('cat', 'dog', 123)
d = ('tiger', c)	# ('tiger', ('cat', 'dog', 123))
1
2
3

列表类型

是序列类型的一种扩展，创建后可以修改

# 创建列表：[],list()
ls = ['cat', 'dog', 123]
lt = ls
print(lt)	# ['cat', 'dog', 123]，[]是真正列表，赋值仅传递引用
# 操作函数
ls = [1, 2, 3, 4, 5]
ls[2] = 0   # [1, 2, 0, 4, 5]
lt = [6, 7, 8]
ls[0:5:2] = lt  # [6, 2, 7, 4, 8]
del ls[2]   # [1, 2, 4, 5]
del ls[0:5:2]   # [2, 4]
ls += lt    # [1, 2, 3, 4, 5, 6, 7, 8]
ls *= 2 # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
ls.append(x)	# 末尾添加一个元素x
ls.clear()	# 删除所有元素
la = ls.copy()
ls.insert(i,x)	# 在i位置增加元素x
print(ls.pop(i))
ls.remove(2)    # [1, 3, 4, 5]
ls.reverse()    # 反转元素，[5, 4, 3, 2, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

序列类型应用场景： 元组和列表

数据保护：若不希望数据被程序改变，可转换成元组类型

ls = ['cat', 'dog', 123]
lt = tuple(ls)
print(lt)	# ('cat', 'dog', 123)
1
2
3

6.3 基本统计值计算

def getNum():   # 获取用户不定长度的输入
    nums = []
    iNumStr = input("请输入数字(回车退出):")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        iNumStr = input("请输入数字(回车退出):")
    return nums
def mean(numbers):  # 计算平均值
    s = 0.0
    for num in numbers:
        s = s + num
    return s/len(numbers)
def dev(numbers, mean): # 计算方差
    sdev = 0.0
    for num in numbers:
        sdev = sdev+(num-mean)**2
    return pow(sdev/(len(numbers)-1), 0.5)
def median(numbers):	# 计算中位数
    sorted(numbers)
    size = len(numbers)
    if size % 2 == 0:
        med = (numbers[size//2-1]+numbers[size//2])/2
    else:
        med = numbers[size//2]
    return med
n = getNum()
m = mean(n)
print("平均值:{},方差:{:.2},中位数:{}".format(m, dev(n, m), median(n)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

6.4 字典类型及操作

映射是一种键（索引）和值（数据）的对应

字典是映射的体现，通过键获得值

type(x)	# 返回变量类型
# 创建字典：{:}
dic = {'中国':'北京', '美国':'华盛顿', '法国':'巴黎'}
dic['中国']	# 北京
# 操作函数
dic[k] = value	# 键k不在存在则添加键值对，存在则修改对应的值
del dic[k]	# 删除键k及对应的值
k in dic	# 判断键k是否在dic中
dic.keys()	# 返回所有键
dic.values()	# 返回所有值
dic.items()	# 返回键值对
print(dic.get('日本', '无'))	# 键k存在返回对应值，否者返回参数'无'
print(dic.pop('中国', '无'))	# 北京，{'美国': '华盛顿', '法国': '巴黎'}
print(dic.popitem())	# 随机删除一个键值对，('法国', '巴黎')，{'中国': '北京', '美国': '华盛顿'}
dic.clear()	# 删除所有键值对
len(dic)	# 键值对个数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.5 jieba库的使用

中文分词第三方库，提供三种分词模式（精确模式，全模式，搜索引擎模式）

安装(cmd命令行)：pip install jieba

使用说明

import jieba
s = "好好学习,天天向上"
print(jieba.lcut(s))    # 精准模式，['好好学习', ',', '天天向上']
print(jieba.lcut(s, cut_all=True))  # 全模式，['好好', '好好学', '好好学习', '好学', '学习', ',', '天天', '天天向上', '向上']
print(jieba.lcut_for_search(s)) # 搜索引擎模式，['好好', '好学', '学习', '好好学', '好好学习', ',', '天天', '向上', '天天向上']
1
2
3
4
5

6.6 文本词频统计

排序问题

sort()和sorted()的区别

sort函数没有返回值，会改变原元素的值，局限于list

sorted函数有返回值，不会改变原元素的值，不局限于list

key参数

key接受的是函数对象（自定义函数或匿名函数lambda），函数只能有一个参数

key=lambda 元素: 元素[字段索引]

元素字母可以随意修改，按照[]里面的维度进行排序，例：[0]按照第一维排序，[1]按照第二维排序

排序规则

reverse=True降序，reverse=False升序(默认升序)

使用方法

# sort函数：局限于list
a = [-5, 4, -2, 3, -1]
def f(x):
    return abs(x)
a.sort(key=f)   # 按绝对值正序，[-1, -2, 3, 4, -5]

b = ["hello", "good", "python"]
b.sort(key=lambda x: len(x), reverse=True)  # 按单词长度倒叙，['python', 'hello', 'good']

c = [("a", 3), ("b", 1), ("d", 2)]
c.sort(key=lambda x: x[1])  # 按元组里面第二个数排序，[('b', 1), ('d', 2), ('a', 3)]

# sorted函数：不局限于list
a = [2, 5, 3, 4, 1]
print(sorted(a))	# [1, 2, 3, 4, 5]
print(sorted(a, reverse=True))	# [5, 4, 3, 2, 1]

b = "python"
print(sorted(b))	# ['h', 'n', 'o', 'p', 't', 'y']

c = (2, 5, 3, 4, 1)
print(sorted(c))	# [1, 2, 3, 4, 5]

f = {"a": 3, "b": 1, "c": 2}
print(sorted(f.items(), key=lambda x: x[1]))	# [('b', 1), ('c', 2), ('a', 3)]

# 对比输出
dic = {'a': 2, 'b': 3, 'c': 1}
ls = list(dic.items())  # [('a', 2), ('b', 3), ('c', 1)]
ls.sort(key=lambda x: x[0], reverse=True)
print(sorted(ls, key=lambda x: x[0], reverse=True))   # [('c', 1), ('b', 3), ('a', 2)]
ls.sort(key=lambda x: x[1])
print(sorted(ls, key=lambda x: x[1]))   # [('c', 1), ('a', 2), ('b', 3)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Hamlet英文词频统计

def getText():
    txt = open("Files/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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三国演义人物出场统计

import jieba
txt = open("Files/三国演义.txt", "r", encoding='utf-8').read()
excludes = {"将军", "却说", "二人", "不可", "荆州", "不能", "如此"}
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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

07 文件和数据格式化

7.1 文件的使用

文件是数据存储的一种形式

文件的展示形态：文本文件和二进制文件

tf = open('f.txt', 'rt')	# 文本形式打开
tf = open('f.txt', 'rb')	# 二进制形式打开
print(tf.readline())
tf.close()
1
2
3
4

打开和关闭

f = open('f.txt')   # 默认文本只读
f = open('f.txt', 'rt') # 文本只读
f = open('f.txt', 'w')  # 文本覆盖写
f = open('f.txt', 'x')  # 文本创建写
f = open('f.txt', 'a+') # 文本追加写+读
f = open('f.txt', 'b')  # 二进制只读
f = open('f.txt', 'wb') # 二进制覆盖写
f.close()	# 文件关闭
1
2
3
4
5
6
7
8

内容的读取

s = f.read(2)   # 读入2长度，默认全读
s = f.readall()   # 读入整个文件内容
s = f.readline(2)    # 读入前2行，默认读一行
s = f.readlines(2)   # 读入前2行，默认读所有行(列表返回每一行)
1
2
3
4

数据的写入

f.write('中国是一个伟大的国家!')

ls = ['中国', '法国', '美国']
f.writelines(ls)

f.seek(0)   # 0-回到文件开头，1-当前位置，2-文件结尾
1
2
3
4
5
6

7.2 自动轨迹绘制

import turtle as t
t.title('自动轨迹绘制')
t.setup(800, 600, 0, 0)
t.pencolor('red')
t.pensize(5)
# 读取数据
datals = []
f = open('Files/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.right(datals[i][2])
    else:
        t.left(datals[i][2])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7.3 wordcloud库的使用

安装(cmd命令行)：pip install wordcloud

基本使用

import wordcloud
w = wordcloud.WordCloud()	# 设置词云的属性
w.generate('文本')    # 载入文本
w.to_file('图像.png') # 输出图像文件
1
2
3
4

属性设置

w = wordcloud.WordCloud(width=600)  # 宽度，默认400
w = wordcloud.WordCloud(height=400) # 高度，默认200
w = wordcloud.WordCloud(min_font_size=10)   # 最小字号，默认4
w = wordcloud.WordCloud(max_font_size=20)   # 最大字号
w = wordcloud.WordCloud(font_step=2)    # 步进间隔，默认1
w = wordcloud.WordCloud(font_path='msyh.ttc')   # 字体微软雅黑
w = wordcloud.WordCloud(max_words=20)   # 最大单词数量，默认200
w = wordcloud.WordCloud(stopwords={'Python'})   # 排除词云列表
w = wordcloud.WordCloud(background_color='white')   # 背景颜色
# 指定词云形状
import imageio
photo = imageio.imread('图像.png')
w = wordcloud.WordCloud(mask=photo)
1
2
3
4
5
6
7
8
9
10
11
12
13

应用实例

# 实例一
import wordcloud
txt = "life is short, you need python"
w = wordcloud.WordCloud(background_color='white')
w.generate(txt)
w.to_file('pywcloud.png')

# 实例二
import wordcloud, jieba
txt = '程序设计语言使计算机能够理解和识别用户操作意图的一种交互体系, \
      他按照特定规则组织计算机指令，使计算机能够自动进行各种运算处理。'
w = wordcloud.WordCloud(width=1000, height= 700, font_path='msyh.ttc')
w.generate(''.join(jieba.lcut(txt)))
w.to_file('pywcloud.png')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.4 政府工作报告词云

# 新时代中国特色社会主义
import wordcloud, jieba
f = open('Files/新时代中国特色社会主义.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', max_words=20)
w.generate(txt)
w.to_file('image.png')

# 关于实施乡村振兴战略的意见
import wordcloud, jieba, imageio
f = open('Files/关于实施乡村振兴战略的意见.txt', 'r', encoding='utf-8')
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = ''.join(ls)
photo = imageio.imread('Files/五角星.png')
w = wordcloud.WordCloud(width=1000, height=700, background_color='white', font_path='msyh.ttc', mask=photo)
w.generate(txt)
w.to_file('image.png')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22