《Python语言程序设计》课程笔记系列

Part1Python语言程序设计

本笔记主要参考中国大学MOOC北京理工大学嵩天教授开设的《Python语言程序设计》课程。

课程链接：https://www.icourse163.org/course/BIT-268001

Python语言程序设计

• 第一章 Python基本语法元素

  • 1.1 程序设计基本方法

  • 1.2 Python开发环境配置

  • 1.3 实例1: 温度转换

  • Python程序语法元素分析

• 第二章 Python基本图形绘制

  • 深入理解Python语言

  • 实例2: Python蟒蛇绘制

  • 模块1: turtle库的使用

  • turtle程序语法元素分析

• 第三章 基本数据类型

  • 实例3: 天天向上的力量

  • 字符串类型及操作

  • 模块2: time库的使用

  • 实例4: 文本进度条

• 第四章 程序的控制结构

  • 程序的分支结构

  • 实例5: 身体质量指数BMI

  • 程序的循环结构

  • 模块3: random库的使用

  • 实例6: 圆周率的计算

• 第五章 函数和代码复用

  • 函数的定义与使用

  • 实例7: 七段数码管绘制

  • 代码复用与函数递归

  • 实例8: 科赫雪花小包裹

• 第六章 组合数据类型

  • 集合类型及操作

  • 序列类型及操作

  • 实例9: 基本统计值计算

  • 字典类型及操作

  • 模块5: jieba库的使用

  • 实例10: 文本词频统计

• 第七章 文件和数据格式化

  • 文件的使用

  • 实例11: 自动轨迹绘制

  • 一维数据的格式化和处理

  • 二维数据的格式化和处理

  • 模块6: wordcloud库的使用

  • 实例12: 政府工作报告词云

• 第八章 程序设计方法学

  • Python程序设计思维

  • 实例13: 体育竞技分析

  • 模块7: os库的使用

  • 实例14: 第三方库自动安装脚本

• 第九章 Python计算生态概览

  • "霍兰德人格分析雷达图"实例展示

  • "玫瑰花绘制"实例展示

  • Python库

• 第十章 总结

  • 数字类型及操作

  • 字符串类型及操作

  • 程序的分支结构

  • 程序的循环结构

  • 函数的定义与使用

  • 代码复用与函数递归

  • 集合类型及操作

  • 序列类型及操作

  • 字典类型及操作

  • 文件的使用

  • 一维数据的格式化和处理

  • 二维数据的格式化和处理

1第一章 Python基本语法元素

1.1 程序设计基本方法

QGKWQ4

计算机与程序设计

• 计算机是根据指令操作数据的设备

• 程序设计是计算机可编程性的体现

• 程序设计语言是一种用于交互(交流)的人造语言

• 计算机的发展参照摩尔定律，表现为指数方式

• 摩尔定律 Moore’s Law：单位面积集成电路上可容纳晶体管的数量约每两年翻一番

编译和解释

U9m5N6

aGsBHo

静态语言和脚本语言

• 静态语言：使用编译执行的编程语言

• 脚本语言：使用解释执行的编程语言

程序的基本编写方法

IPO

• I：Input 输入，程序的输入

• P：Process 处理，程序的主要逻辑

• O：Output 输出，程序的输出

编程解决问题的步骤

• 分析问题：分析问题的计算部分，想清楚

• 划分边界：划分问题的功能边界，==规划IPO==

• 设计算法：设计问题的求解算法，关注算法

• 编写程序：编写问题的计算程序，==编程序==

• 调试测试：调试程序使正确运行，==运行调试==

• 升级维护：适应问题的升级维护，更新完善

计算机编程

• 编程体现了一种抽象交互关系、自动化执行的思维模式

• 计算思维：区别逻辑思维和实证思维的第三种思维模式

1.2 Python开发环境配置

• IDLE: Python解释器默认工具

• Visual Studio Code

• PyCharm

1.3 实例1: 温度转换

#TempConvert.py
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("输入错误")
#请输入带有符号的温度值：100C
#转换后的温度是：212.00F

Python程序语法元素分析

程序的格式框架

• 代码高亮：编程的色彩辅助体系，不是语法要求

• 缩进：一行代码开始前的空白区域，表达程序的格式框架

• 注释：用于提高代码可读性的辅助性文字，不被执行

命名与保留字

变量：程序中用于保存和表示数据的占位符号

命名：大小写敏感、首字符不能是数字、不与保留字相同

保留字：被编程语言内部定义并保留使用的标识符

FQqwnA

数据类型

• 数据类型：字符串、整数、浮点数、列表

字符串

字符串：由0个或多个字符组成的有序字符序列

字符串由一对单引号或一对双引号表示

字符串是字符的有序序列，可以对其中的字符进行索引

正向递增序号 和 反向递减序号

1w30ZY

• 索引：返回字符串中单个字符 <字符串>[M]

  "请输入带有符号的温度值: "[0] 或者 TempStr[-1]

• 切片：返回字符串中一段字符子串 <字符串>[M: N]

  "请输入带有符号的温度值: "[1:3] 或者 TempStr[0:-1]

数字类型

数字类型：整数和浮点数

• 整数：数学中的整数

• 浮点数：数学中的实数，带有小数部分

列表类型

列表类型：由0个或多个数据组成的有序序列

• 列表使用[ ]表示，采用逗号(,)分隔各元素 ['F','f']表示两个元素'F'和'f'

• 使用保留字 in 判断一个元素是否在列表中 TempStr[-1] in ['C','c']判断前者是否与列表中某个元素相同

语句与函数

赋值语句

赋值语句：由赋值符号构成的一行代码

• 赋值语句用来给变量赋予新的数据值

C=(eval(TempStr[0:-1])-32)/1.8 #右侧运算结果赋给变量C

• 赋值语句右侧的数据类型同时作用于变量

TempStr=input("") #input()返回一个字符串，TempStr也是字符串

分支语句

分支语句：由判断条件决定程序运行方向的语句

使用保留字if elif else构成条件判断的分支结构

函数

函数：根据输入参数产生不同输出的功能过程

函数采用 <函数名>(<参数>) 方式使用

eval(TempStr[0:-1]) #TempStr[0:-1]是参数

Python程序的输入输出

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

input()函数的使用格式：

<变量> = input(<提示信息字符串>)

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

cSPzXn

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

tUddj1

练习题

#数字形式转换 I
chiStr = ['零','一','二','三','四','五','六','七','八','九']
intStr = input()
for i in intStr:
    b = eval(i)
    print(chiStr[b])
#123
#一
#二
#三

# 货币转换 I
MoneyStr = input()
if MoneyStr[0:3] in ['RMB', 'rmb']:
    USD = eval(MoneyStr[3:]) / 6.78
    print("USD{:.2f}".format(USD))
else:
    RMB = eval(MoneyStr[3:]) * 6.78
    print("RMB{:.2f}".format(RMB))
#USD20
#RMB135.60

2第二章 Python基本图形绘制

深入理解Python语言

编程语言的种类

超级语言 高级语言 汇编语言 机器语言

• 粘性整合已有程序，具备庞大计算生态

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

• 有助记符，汇编器，与CPU型号有关

• 代码直接执行，与CPU型号有关

实例2: Python蟒蛇绘制

# PythonDraw.py
import turtle as t
t.setup(650,350,200,200)
t.penup()
t.fd(-250)
t.pendown()
t.pensize(25)
t.pencolor('purple')
t.seth(-40)
for i in range(4):
    t.circle(40,80)
    t.circle(-40,80)
t.circle(40, 80/2)
t.fd(40)
t.circle(16,180)
t.fd(40 * 2/3)

EXtaMC

模块1: turtle库的使用

turtle库基本介绍

库Library、包Package、模块Module，统称模块

turtle的绘图窗体

ssYGWX

turtle空间坐标体系

• 绝对坐标

CDdJqn

• 海龟坐标

5x6nwf

turtle角度坐标体系

• 绝对角度

EsXw5q

• 海龟角度

tui7jr

RGB色彩体系

• RGB指红蓝绿三个通道的颜色组合

• 覆盖视力所能感知的所有颜色

• RGB每色取值范围0-255整数或0-1小数

t.colormode(255)

turtle程序语法元素分析

库引用与import

r1X5fF

import turtle
import turtle as t
from turtle import *

turtle画笔控制函数

画笔操作后一直有效，一般成对出现

penup() 
pendown() 
pensize(width) 
pencolor(colorstring) 
pencolor(r,g,b) 
pencolor((r,g,b))

turtle运动控制函数

控制海龟行进：走直线 & 走曲线

• turtle.forward(d)

别名 turtle.fd(d) 向前行进，海龟走直线

• d: 行进距离，可以为负数

turtle.circle(r, extent=None)

根据半径r绘制extent角度的弧形

• r: 默认圆心在海龟左侧r距离的位置

• extent: 绘制角度，默认是360度整圆

turtle方向控制函数

turtle.setheading(angle)

改变行进方向，海龟走角度。行进方向的绝对角度

turtle.left(angle)

turtle.right(angle)

循环语句与range()函数

• range(N)

  产生 0 到 N-1的整数序列，共N个

• range(M,N)

  产生 M 到 N-1的整数序列，共N-M个

练习题

#RectDraw.py
import turtle as t
t.pensize(2)
for i in range(4):
    t.fd(150)
    t.left(90)

#HexagonDraw.py
import turtle as t
t.pensize(2)
for i in range(6):
    t.fd(150)
    t.left(60)

#TwoRoundDraw.py
import turtle as t
t.pensize(2)
for i in range(9):
    t.fd(150)
    t.left(80)  #720/9

dGDwiI

#WindWheel.py
import turtle as t
t.pensize(2)
for i in range(4):
    t.seth(90*i)
    t.fd(150)
    t.right(90)
    t.circle(-150, 45)
    t.goto(0,0)

rIyRos

3第三章 基本数据类型

数字类型及操作

整数类型

pow(x,y)函数：计算 xy，想算多大算多大

浮点数类型

浮点数间运算存在不确定尾数，不是bug

round(0.1+0.2, 1) == 0.3
#True

数值运算操作符

Cf0fSE

QFgzvk

9d44VP

数值运算函数

SzwbaL

实例3: 天天向上的力量

"天天向上的力量"第一问

问题1：1‰的力量

#DayDayUpQ1.py 
dayup = pow(1.001, 365) 
daydown = pow(0.999, 365) 
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))
#向上：1.44,向下：0.69

"天天向上的力量"第二问

问题2：5‰和1%的力量

#DayDayUpQ1.py 
dayfactor = 0.01
dayup = pow(1+dayfactor, 365) 
daydown = pow(1-dayfactor, 365) 
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))
#向上：37.78,向下：0.03

##DayDayupQ1.py
dayfactor = 0.005
dayup = pow(1 + dayfactor, 365)
daydown = pow(1 - dayfactor, 365)
print("向上：{:.2f},向下：{:.2f}".format(dayup, daydown))
#向上：6.17,向下：0.16

#DayDayUpQ1.py 
dayfactor = 0.001
dayup = pow(1 + dayfactor, 365)
daydown = pow(1 - dayfactor, 365)
print("向上：{:.2f},向下：{:.2f}".format(dayup, daydown))
#向上：1.44,向下：0.69

"天天向上的力量"第三问

问题3：工作日的力量

#DayDayUpQ3.py 
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))
#工作日的力量：4.63
### 介于0.001和0.005之间

"天天向上的力量"第四问

问题4：工作日的努力

def dayUp(df):
    dayup = 1
    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("工作日的努力参数：{:.3f}".format(dayfactor))
#工作日的努力参数：0.019
#工作日模式，每天要努力到1.9%，相当于365模式每天1%的效果！

字符串类型及操作

字符串类型的表示

由0个或多个字符组成的有序字符序列

由一对单引号或双引号表示，仅表示单行字符串

由一对三单引号或三双引号表示，可表示多行字符串

''' Python

语言

'''
#' Python\n\n语言\n\n'
''' 这里既有单引号(')又有双引号 (") '''

<字符串>[M: N: K]，根据步长K对字符串切片

"〇一二三四五六七八九十"[::-1] 结果是 "十九八七六五四三二一〇"

转义符 \

• 转义符表达特定字符的本意

"这里有个双引号(\")" 结果为这里有个双引号(")

• 转义符形成一些组合，表达一些不可打印的含义

"\b"回退 "\n"换行(光标移动到下行首) "\r" 回车(光标移动到本行首)

字符串操作符

hrd5oS

#WeekNamePrintV1.py
weekStr = "星期一星期二星期三星期四星期五星期六星期日"
weekId = eval(input("请输入星期数字(1-7)："))
pos = (weekId - 1) * 3
print(weekStr[pos:pos+3])
#请输入星期数字(1-7)：7
#星期日

#WeekNamePrintV2.py 
weekStr = "一二三四五六日" 
weekId = eval(input("请输入星期数字(1-7)：")) 
print("星期" + weekStr[weekId-1])
#请输入星期数字(1-7)：4
#星期四

字符串处理函数

BuyF2R

"1 + 1 = 2 " + chr(10004)
#'1 + 1 = 2 ✔'
for i in range(12):
    print(chr(9800 + i), end="")
#♈♉♊♋♌♍♎♏♐♑♒♓

字符串处理方法

"方法"在编程中是一个专有名词

• "方法"特指.()风格中的函数()

rGvOG4

d1TZaN

Oum3WP

字符串类型的格式化

<模板字符串>.format(<逗号分隔的参数>)

gp7Qaz

v41Zf8

ElK6lw

模块2: time库的使用

time库基本介绍

• 时间获取：time() ctime() gmtime()

• 时间格式化：strftime() strptime()

• 程序计时：sleep(), perf_counter()

时间获取

W2vG9k

ii7Sp7

时间格式化

FS5LPL

bWRcIW

程序计时应用

• 程序计时指测量起止动作所经历时间的过程

• 测量时间：perf_counter()

• 产生时间：sleep()

cRMKkw

VO6uve

实例4: 文本进度条

"文本进度条"简单的开始

#TextProBarV1.py 
import time 
scale = 10 
print("------执行开始------") 
for i in range(scale+1):
  a = '*' * i
  b = '.' * (scale - i)
  c = (i/scale)*100
 print("{:^3.0f}%[{}->{}]".format(c,a,b))
 time.sleep(0.1) 
print("------执行结束------")

YnlBSy

"文本进度条"单行动态刷新

#TextProBarV2.py 
import time 
for i in range(101):
  print("\r{:3}%".format(i), end="") 
  time.sleep(0.1)

"文本进度条"实例完整效果

#TestProBarV3.py
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, "-"))

p32N4i

练习题

#三次方格式化
a = eval(input())
print("{:-^20}".format(pow(a,3)))
#10
#--------1000--------
#星号三角形
n = eval(input())
for i in range(1,n+1,2):
    print("{0:^{1}}".format('*'*i, n)) # 槽中可以嵌套槽，用来表示宽度、填充等含义。

qKS7AI

恺撒密码是古罗马恺撒大帝用来对军事情报进行加解密的算法，它采用了替换方法对信息中的每一个英文字符循环替换为字母表序列中该字符后面的第三个字符，即，字母表的对应关系如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

原文：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

密文：D E F G H I J K L M N O P Q R S T U V W X Y Z A B C‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

对于原文字符P，其密文字符C满足如下条件：C=(P+3) mod 26‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

上述是凯撒密码的加密方法，解密方法反之，即：P=(C-3) mod 26

#凯撒密码1
Str = input()
for i in range(0,len(Str)):
    if Str[i] == ' ':
        print(' ', end="")
    elif Str[i] in ['x','y','z',"X","Y","Z"]:
         print(chr(ord(Str[i])-23), end="")
    else:
        print(chr(ord(Str[i])+3), end="")
#python is good
#sbwkrq lv jrrg

#凯撒密码2
s = input()
t = ""
for c in s:
    if 'a' <= c <= 'z': 
        t += chr( ord('a') + ((ord(c)-ord('a')) + 3 )%26 )
    elif 'A' <= c <= 'Z':
        t += chr( ord('A') + ((ord(c)-ord('A')) + 3 )%26 )
    else:
        t += c
print(t)
#python is good
#sbwkrq lv jrrg

counter(counterh2)第四章 程序的控制结构

程序的分支结构

单分支结构

Iwcu1S

二分支结构

lKhlnd

guess = eval(input()) 
print("猜{}了".format("对" if guess==99 else "错"))

多分支结构

FpF8rJ

s0dPf5

条件判断及组合

9njD2k

jyPI9r

程序的异常处理

WB81sE

tmJq0x

try:
    num = eval(input("请输入一个整数："))
    print(pow(num,2))
except NameError:
    print("你输错了")
else:
    print("Yeah!!!")
finally:
    print("Hello World")

实例5: 身体质量指数BMI

#CalBMIv3.py
height,weight = eval(input("请输入身高(米)和体重(公斤)[逗号隔开]："))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".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))

程序的循环结构

遍历循环

Aq3SxO

#计数循环(特定次)
for i in range(N) :
for i in range(M,N,K) :
#字符串遍历循环
for c in "Python123":
  print(c, end=",")
#列表遍历循环
for item in [123, "PY", 456] :
  print(item, end=",")
#文件遍历循环
for line in fi :
  print(line)

无限循环

q3mQuK

循环控制保留字

Zwd8uf

# continue结束当次循环
for c in "PYTHON":
    if c == "T":
        continue
    print(c, end="")
#PYHON    
for c in "PYTHON":
    if c == "T":
        break
    print(c, end="")
#PY    
s = "PYTHON"
while s != "":
    for c in s:
        print(c, end="")
    s = s[:-1]
#PYTHONPYTHOPYTHPYTPYP

## break仅跳出当前最内层循环
s = "PYTHON"
while s != "":
    for c in s:
        if c == "T":
            break
        print(c, end="")
    s = s[:-1]
#PYPYPYPYPYP

iP1vHZ

# 循环与else
# 当循环没有被break语句退出时，执行else语句块
for c in "PYTHON":
    if c == "T":
        continue
    print(c, end="")
else:
    print("正常退出")
#PYHON正常退出
for c in "PYTHON":
    if c == "T":
        break
    print(c, end="")
else:
    print("正常退出")
#PY

模块3: random库的使用

• random库主要用于生成随机数

• 使用random库: import random

• 伪随机数: 采用梅森旋转算法生成的

Dk9aUq

OenTYf

SEWeBw

n4gR9N

实例6: 圆周率的计算

"圆周率的计算"问题分析

BGIe0v

#CalPiV1.py
## 数学公式计算
pi = 0
N = 100
for k in range(N):
    pi += 1/pow(16,k)*(\
                      4/(8*k+1) - 2/(8*k+4) - \
                      1/(8*k + 5) - 1/(8*k + 6))
print("圆周率的值为：{}".format(pi))
#圆周率的值为：3.141592653589793

# 圆周率：蒙特卡罗方法
#CalPiV2.py
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("运行时间是：{:.5f}".format(perf_counter() - start))
#圆周率的值为：3.144192
#运行时间是：0.47377

练习题

#整数的加减和
s = 0
count = 1
while count <= 966:
    if count % 2 == 0:
        s -= count
    else:
        s += count
    count += 1
print(s)
#-483

##三位水仙花数
s = ""
for i in range(100, 1000):
    t = str(i)
    if pow(eval(t[0]),3) + pow(eval(t[1]),3) + pow(eval(t[2]),3) == i :
        s += "{},".format(i)
print(s[:-1])
#153,370,371,407

#用户登录的三次机会
count = 0
while count < 3:
    name = input()
    passwd = input()
    if name == "Kate" and passwd == '666666':
        print("登陆成功")
        break
    else:
        count = count + 1
        if count == 3:
            print("3次用户名或者密码均有误！退出程序。")

1第五章 函数和代码复用

函数的定义与使用

函数的理解和定义

MbQWgA

9qAgJs

函数的使用及调用过程

JXclr2

• 函数可以有参数，也可以没有，但必须保留括号

• 函数定义时可以为某些参数指定默认值，构成可选参数

BWyF9w

• 函数定义时可以设计可变数量参数，既不确定参数总数量

04DAq2

• 函数调用时，参数可以按照位置或名称方式传递

qgpOrU

函数的返回值

• return保留字用来传递返回值

• 函数可以有返回值，也可以没有，可以有return，也可以没有

• return可以传递0个返回值，也可以传递任意多个返回值

wbjV1B

局部变量和全局变量

PjYlbr

规则1: 局部变量和全局变量是不同变量

• 局部变量是函数内部的占位符，与全局变量可能重名但不同

• 函数运算结束后，局部变量被释放

• 可以使用global保留字在函数内部使用全局变量

Ffz92G

规则2: 局部变量为组合数据类型且未创建，等同于全局变量

OHcaLw

2MkI2F

lambda函数

lambda函数返回函数名作为结果

• lambda函数是一种匿名函数，即没有名字的函数

• 使用lambda保留字定义，函数名是返回结果

• lambda函数用于定义简单的、能够在一行内表示的函数

aypw6s

HRe6Z9

实例7: 七段数码管绘制

import turtle as t
import time
def drawGap(): #绘制数码管间隔
    t.penup()
    t.fd(5)
def drawLine(draw):   #绘制单段数码管
    drawGap()
    t.pendown() if draw else t.penup()
    t.fd(40)
    drawGap()
    t.right(90)
def drawDigit(d): #根据数字绘制七段数码管
    drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,6,8] else drawLine(False)
    t.left(90)
    drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
    t.left(180)
    t.penup()
    t.fd(20)
def drawDate(date): #获取日期
    t.pencolor("red")
    for i in date:
        if i == "-":
            t.write('年',font = ("Arial", 18, "normal"))
            t.pencolor("green")
            t.fd(40)
        elif i == "=":
            t.write("月",font=("Arial",18,"normal"))
            t.pencolor("green")
            t.fd(40)
        elif i == "+":
            t.write("日",font=("Arial",18,"normal"))
        else:
            drawDigit(eval(i))
def main():
    t.setup(800, 350, 200, 200)
    t.penup()
    t.fd(-300)
    t.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    t.done()
main()

BSOYtv

代码复用与函数递归

代码复用与模块化设计

miOfZi

函数递归的理解

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

• 链条：计算过程存在递归链条

• 基例：存在一个或多个不需要再次递归的基例

函数递归的调用过程

• 递归本身是一个函数，需要函数定义方式描述

• 函数内部，采用分支语句对输入参数进行判断

• 基例和链条，分别编写对应代码

lFUEli

C2ZLCG

#字符串反转
s = "Python"
def rvs(s):
    if s == '':
        return s
    else:
        return rvs(s[1:]) + s[0]
print(rvs(s))
#nohtyP

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

n = eval(input())
print(fbi(n))

#汉诺塔
steps = 0
def hanoi(src, des, mid, n):
    global steps
    if n == 1:
        steps += 1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))
    else:
        hanoi(src, mid, des, n-1)
        steps += 1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))        
        hanoi(mid, des, src, n-1)
N = eval(input())
hanoi("A", "C", "B", N)

5g9vob

实例8: 科赫雪花小包裹

"科赫雪花小包裹"问题分析

PotGMJ

"科赫雪花小包裹"实例讲解

#KochDrawV1.py
import turtle as t
def koch(size, n):
    if n == 0:
        t.fd(size)
    else:
        for angle in [0, 60, -120, 60]:
            t.left(angle)
            koch(size/3, n-1)
def main():
    t.setup(600,600)
    t.penup()
    t.goto(-200,100)
    t.pendown()
    t.pensize(2)
    level = 3
    koch(400, level)
    t.right(120)
    koch(400, level)
    t.right(120)
    koch(400, level)
    t.hideturtle()
main()

#任意累积
def cmul(a, *b):
    m = a
    for i in b:
        m *= i
    return m

print(eval("cmul({})".format(input())))
#1,2,4,5
#40

2第六章 组合数据类型

集合类型及操作

集合类型定义

集合是多个元素的无序组合

• 集合类型与数学中的集合概念一致

• 集合元素之间无序，每个元素唯一，不存在相同元素

• 集合元素不可更改，不能是可变数据类型

• 集合用大括号 {} 表示，元素间用逗号分隔

• 建立集合类型用 {} 或 set()

• 建立空集合类型，必须使用set()

集合操作符

## 集合
A = {"p", "y", 123}
B = set("pypy123")
A - B,A | B, A & B, A ^ B
#({123}, {'1', 123, '2', '3', 'p', 'y'}, {'p', 'y'}, {'1', 123, '2', '3'})

dnFMjx

dRTsZ3

集合处理方法

g5uIwu

pmrcMm

A = {"p", "y", 123}
try:
    while True:
        print(A.pop(), end="")
except:
    pass
#p123y
for item in A:
    print(item, end = "")
#p123y

集合类型应用场景

包含关系比较

"p" in {"p", "y", 123}
#True
{"p","y"} <= {"p", "y", 123}
#True

数据去重：集合类型所有元素无重复

ls = ["p", "p", "y", "y", 123]
s = set(ls) # 利用了集合无重复元素的特点
s
#{123, 'p', 'y'}
lt = list(s);lt # 还可以将集合转换为列表
['p', 123, 'y']

序列类型及操作

序列类型定义

序列是具有先后关系的一组元素

• 序列是一维元素向量，元素类型可以不同

• 类似数学元素序列： s0 , s1 , … , sn-1

• 元素间由序号引导，通过下标访问序列的特定元素

ezm5x4

序列处理函数及方法

pJCrbD

ls = ["python", 123, ".io"]
ls[::-1]
#['.io', 123, 'python']
s = "python123.io"
s[::-1]
#'oi.321nohtyp'

W8BHK2

ls = ["python", 123, ".io", 123]
ls.index(123,0,3)
#1
ls.count(123)
#2

元组类型及操作

• 元组是一种序列类型，一旦创建就不能被修改

• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

• 可以使用或不使用小括号

## tuple
creature = "cat", "mouse", "tiger", "human"
creature,creature[::-1]
#(('cat', 'mouse', 'tiger', 'human'), ('human', 'tiger', 'mouse', 'cat'))
color = (0x001100, "blue", creature)
color,color[-1][2]
((4352, 'blue', ('cat', 'mouse', 'tiger', 'human')), 'tiger')
ter = [1,4,"er"]
test = tuple(ter)
test
#(1, 4, 'er')

列表类型及操作

• 列表是一种序列类型，创建后可以随意被修改

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔

• 列表中各元素类型可以不同，无长度限制

方括号 [] 真正创建一个列表，赋值仅传递引用

chkkIK

# list
ls = ["cat", "tiger", 1024]
ls[1:2] = [1,2,3,4]
ls
#['cat', 1, 2, 3, 4, 1024]
del ls[::3]
ls
[1, 2, 4, 1024]
ls = ls*2
ls
[1, 2, 4, 1024, 1, 2, 4, 1024]

xoyCuM

lt = list()
lt
#[]
lt += ["python", "1","23","r", "7"]
lt
#['python', '1', '23', 'r', '7']
lt.pop(1)
lt
#['python', '23', 'r', '7']
lt.remove("r")
lt
#['python', '23', '7']
lt[1] = "23"
lt
#['python', '23', '23', 'r', '7']
lt.insert(1, "help")
lt
['python', 'help', '23', '23', 'r', '7']
del lt[0]
lt
#['help', '23', '23', 'r', '7']
del lt[0:2]
lt
#['23', 'r', '7']
"0" in lt
#False
lt.index("0")
#3
lt.clear()
lt
#[]

序列类型应用场景

#数据保护
ls = ["cat", "dog", "tiger", 1024]
lt = tuple(ls)
lt
('cat', 'dog', 'tiger', 1024)
#元素遍历
for item in ls :
  <语句块>

实例9: 基本统计值计算

#CalStatisticsV1.py
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("平均值:{:.2f},方差:{:.2},中位数:{}".format(m, dev(n,m),median(n)))
#请输入数字(回车退出): 1
#请输入数字(回车退出): 2
#请输入数字(回车退出): 3
#请输入数字(回车退出): 4
#请输入数字(回车退出): 
#平均值:2.50,方差:1.3,中位数:2.5

#CalstatisticsV2.py
def getNum():
    nums = eval(input())
    ls = list(nums)
    return ls
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):
    numbers.sort() # 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("平均值:{:.2f},方差:{:.2},中位数:{}".format(m, dev(n,m),median(n)))
#1,2,3,4
#平均值:2.50,方差:1.3,中位数:2.5

字典类型及操作

• 映射是一种键(索引)和值(数据)的对应

• 键值对：键是数据索引的扩展

• 字典是键值对的集合，键值对之间无序

• 采用大括号{}和dict()创建，键值对用冒号: 表示

q1cGie

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
d
#{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
de = {} ; type(de)
#<class 'dict'>

字典处理函数及方法

BzwKxh

buQSp0

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
'中国' in d
#True
d.keys()
#dict_keys(['中国', '美国', '法国'])
d.values()
#dict_values(['北京', '华盛顿', '巴黎'])
del d["美国"]
d
#{'中国': '北京', '法国': '巴黎'}
d.get("中国", "伊斯兰堡")
#'北京'
d.pop("中国","巴黎")
d
#{'美国': '华盛顿', '法国': '巴黎'}
d.popitem(),d
#(('法国', '巴黎'), {'中国': '北京', '美国': '华盛顿'})

OC6O7p

模块5: jieba库的使用

jieba库使用说明

1RoMTW

zKoXmj

实例10: 文本词频统计

"Hamlet英文词频统计"实例讲解

#CalHamletV1.py
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))

8YfIPR

"《三国演义》人物出场统计"实例讲解

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(10):
    word,count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

waTbPS

#CalThreeKingdomsV2.py
# 词频统计
import jieba
txt = open("threekingdoms.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))

#CalThreeKingdomsV2.py
# 人物统计
import jieba
txt = open("threekingdoms.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))

az11ts

练习题

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄'''
ls = s.split()
ss = set(ls)
print(len(ss))
#36

#字典翻转输出
s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")
#{"a": 1, "b": 2}
#{1: 'a', 2: 'b'}

#《沉默的羔羊》之最多单词
import jieba
f = open("沉默的羔羊.txt", encoding = 'utf-8')
ls = jieba.lcut(f.read())
d = {}
for w in ls:
    if len(w) >= 2:
        d[w] = d.get(w,0) + 1
    else:
        continue
maxc = 0
maxw = ""
for k in d:
    if d[k] > maxc:
        maxc = d[k]
        maxw = k
    elif d[k] == maxc and k > maxw:
        maxw = k
print(maxw)
f.close()
#史达琳

3第七章 文件和数据格式化

文件的使用

文件的类型

文件是数据的抽象和集合

• 文件文件和二进制文件只是文件的展示方式

• 本质上，所有文件都是二进制形式存储

• 形式上，所有文件采用两种方式展示

文本文件

• 由单一特定编码组成的文件，如UTF-8编码

• 由于存在编码，也被看成是存储着的长字符串

• 适用于例如：.txt文件、.py文件等

二进制文件

• 直接由比特0和1组成，没有统一字符编码

• 一般存在二进制0和1的组织结构，即文件格式

• 适用于例如：.png文件、.avi文件等

#f.txt文件保存: "中国是个伟大的国家!"

#文本形式打开文件 
tf = open("f.txt", "rt") 
print(tf.readline()) 
tf.close()
#中国是个伟大的国家!
#二进制形式打开文件 
bf = open("f.txt", "rb") 
print(bf.readline()) 
bf.close()
#b'\xd6\xd0\xb9\xfa\xca\xc7\xb8\xf6\xce\xb0 \xb4\xf3\xb5\xc4\xb9\xfa\xbc\xd2\xa3\xa1'

文件的打开和关闭

lSsSOi

E0qsc0

icnhXx

9j2cwv

文件内容的读取

6N1K6F

tFU1cl

rxZSbS

PCz2fo

数据的文件写入

DxunSU

sqm6cu

fo = open("output.txt","w+") 
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
for line in fo:
    print(line) 
fo.close()
#没有任何输出
fo = open("output.txt","w+") 
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
fo.seek(0)
for line in fo:
    print(line) 
fo.close()
#中国法国美国

实例11: 自动轨迹绘制

数据脚本是自动化最重要的第一步

"自动轨迹绘制"实例讲解

• 步骤1：定义数据文件格式（接口）

• 步骤2：编写程序，根据文件接口解析参数绘制图形

• 步骤3：编制数据文件

image-20211006192023951

#AutoTracedraw.py
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.right(datals[i][2])
    else:
        t.left(datals[i][2])

ueWxTs

一维数据的格式化和处理

一维数据的表示

如果数据间有序：使用列表类型

ls = [3.1398, 3.1349, 3.1376]

• 列表类型可以表达一维有序数据

• for循环可以遍历数据，进而对每个数据进行处理

如果数据间无序：使用集合类型

st = {3.1398, 3.1349, 3.1376}

• 集合类型可以表达一维无序数据

• for循环可以遍历数据，进而对每个数据进行处理

一维数据的存储

空格分隔、逗号分隔、其他方式

一维数据的处理

#一维数据读入
# 中国 美国 日本 德国 法国 英国 意大利
txt = open("fname.txt").read()
ls = txt.split()
f.close()
ls
#['中国', '美国', '日本', '德国 ', '法国', '英国', '意大利']
##一维数据写入
ls = ['中国', '美国', '日本']
f = open("fname2.txt", "w")
f.write("\n" + ' '.join(ls))
f.close()
#
#中国 美国 日本

二维数据的格式化和处理

二维数据的表示

• 使用二维列表

[[3.1398, 3.1349, 3.1376], [3.1413, 3.1404, 3.1401]]

• 使用两层for循环遍历每个元素

• 外层列表中每个元素可以对应一行，也可以对应一列

CSV格式与二维数据存储

• 按行存或者按列存都可以，具体由程序决定

• 一般索引习惯：先行后列

• 根据一般习惯，外层列表每个元素是一行，按行存

二维数据的处理

#从csv读入文件
fo = open("fname2.txt")
ls = []
for line in fo:
    line = line.replace("\n","")
    ls.append(line.split(","))
ls
#[['国家', '城市'], ['中国', '北京'], ['美国', '华盛顿']]
#数据写入csv文件
ls = [['国家', '城市'], ['中国', '北京'], ['美国', '华盛顿']]
f = open("fname2.txt", "w")
for item in ls:
    f.write(','.join(item) + '\n')
f.close()

模块6: wordcloud库的使用

wordcloud库使用说明

wordcloud库把词云当作一个WordCloud对象

• 可以根据文本中词语出现的频率等参数绘制词云

• 词云的绘制形状、尺寸和颜色都可以设定

3AWGQM

9nom4W

87SAa9

N7Odyn

XVvGiE

5zHJQq

import wordcloud
txt = "life is short, you need python" 
w = wordcloud.WordCloud(\
                        background_color = "white") 
w.generate(txt) 
w.to_file("pywcloud.png")

UAePxT

实例12: 政府工作报告词云

import jieba
import wordcloud
from imread import imread
mask = imread("fivestar.png")
f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()
#中文需要先分词并组成空格分隔字符串
ls =jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud(font_path = "/System/Library/Fonts/STHeiti Light.ttc",\
                       width=1000, height=700, background_color= "white",\
                       max_words=15, mask=mask)
w.generate(txt)
w.to_file("grwordcloud2.png")

1sCmbC

练习题

#文件行数
f = open("latex.log")
s = 0
for line in f:
    line = line.strip('\n')
    if len(line) == 0:
        continue
    s += 1
print("共{}行".format(s))
#共4951行

#文件字符分布
f = open("latex.log")
cc = 0
d = {}
for i in range(26):
    d[chr(ord("a") + i)] = 0
for line in f:
    for c in line:
        d[c] = d.get(c,0) + 1
        cc += 1
print("共{}字符".format(cc), end = "")
for i in range(26):
    if d[chr(ord("a")+i)] != 0:
        print(",{}:{}".format(chr(ord('a')+i), d[chr(ord('a')+i)]), end ="")
#共244019字符,a:9620,b:525,c:8769,d:1046,e:15585,f:8653,g:4548,h:8882,i:17587,j:62,k:122,l:9090,m:736,n:25730,o:13812,p:961,q:132,r:13755,s:12948,t:14049,u:4850,v:294,w:427,x:276,y:359,z:4

#文件独特行数
f = open("latex.log")
ls = f.readlines()
s = set(ls)
for i in s:
    ls.remove(i)
t = set(ls)
print("共{}独特行".format(len(s)-len(t)))
#共291独特行

#CSV格式列变换
f = open("data.csv")
for line in f:
    line = line.strip('\n')
    ls = line.split(",")
    ls = ls[::-1]
    print(ls)
f.close()
#4,3,2,1
#d,c,b,a
#CSV格式数据清洗
f = open("data.csv")
s = f.read()
s =s.replace(" ","")
print(s)
f.close()

import turtle as t
t.penup()
t.seth(-90)
t.fd(160)
t.pendown()
t.pensize(20)
t.colormode(255)
for j in range(10):
    t.speed(1000)
    t.pencolor(25*j, 5*j, 15*j)
    t.seth(130)
    t.fd(200)
    for i in range(23):
        t.circle(-80, 10)
    t.seth(100)
    for i in range(23):
        t.circle(-80,10)
    t.fd(220)

EcWUMB

4第八章 程序设计方法学

Python程序设计思维

计算思维

D99FjZ

计算生态与Python语言

实例13: 体育竞技分析

• 双人击球比赛：A & B，回合制，5局3胜

• 开始时一方先发球，直至判分，接下来胜者发球

• 球员只能在发球局得分，15分胜一局

自顶向下和自底向上

自顶向下(设计): 解决复杂问题的有效方法

自底向上(执行): 逐步组建复杂系统的有效测试方法

• 理解自顶向下的设计思维：分而治之

• 理解自底向上的执行思维：模块化集成

"体育竞技分析"实例讲解

• 步骤1：打印程序的介绍性信息 printInfo()

• 步骤2：获得程序运行参数：proA, proB, n getInputs()

• 步骤3：利用球员A和B的能力值，模拟n局比赛 simNGames()

• 步骤4：输出球员A和B获胜比赛的场次及概率 printSummary()

jyP6gw

# 第一阶段
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行需要A和B的能力值（以0到1之间的小数表示）")
def getInputs():
    a = eval(input("请输入选手A的能力值(0-1): "))
    b = eval(input("请输入选手B的能力值(0-1): "))
    n = eval(input("模拟比赛的场次: "))
    return a, b, n
def printSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{:.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比{:.1%}".format(winsB, winsB/n))

NipB8o

def simNGames(n, probA, probB):
    winsA, winsB = 0, 0
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB)
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB

WmHdON

from random import random
def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while not gameOver(scoreA, scoreB):
        if serving == "A":
            if random() < probA:
                scoreA += 1
            else:
                serving="B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving="A"
    return scoreA, scoreB
def gameOver(a,b):
    return a==15 or b==15

QcKUaW

#MatchAnalysis.py
from random import random
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行需要A和B的能力值（以0到1之间的小数表示）")
def getInputs():
    a = eval(input("请输入选手A的能力值(0-1): "))
    b = eval(input("请输入选手B的能力值(0-1): "))
    n = eval(input("模拟比赛的场次: "))
    return a, b, n
def gameOver(a,b):
    return a==15 or b==15
def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while not gameOver(scoreA, scoreB):
        if serving == "A":
            if random() < probA:
                scoreA += 1
            else:
                serving="B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving="A"
    return scoreA, scoreB
def simNGames(n, probA, probB):
    winsA, winsB = 0, 0
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB)
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB
def printSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{:.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比{:.1%}".format(winsB, winsB/n))
def main():
    printIntro()
    probA, probB, n = getInputs()
    winsA, winsB = simNGames(n, probA, probB)
    printSummary(winsA, winsB)
main()

#这个程序模拟两个选手A和B的某种竞技比赛
#程序运行需要A和B的能力值（以0到1之间的小数表示）
#请输入选手A的能力值(0-1): 0.4
#请输入选手B的能力值(0-1): 0.5
#模拟比赛的场次: 1000
#竞技分析开始，共模拟1000场比赛
#选手A获胜213场比赛，占比21.3%
#选手B获胜787场比赛，占比78.7%

模块7: os库的使用

os库之路径操作

XbFqkP

4mItEQ

XYtaep

qifYUs

WTzQzx

os库之进程管理

import os
os.system("C:\\Windows\\System32\\calc.exe")

os库之环境参数

XS728j

ELlBU5

jSJV7F

实例14: 第三方库自动安装脚本

#BatchInstall.py
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("pip install " + lib)
    print("Sucessfully")
except:
     print("Failed Somehow")

5第九章 Python计算生态概览

"霍兰德人格分析雷达图"实例展示

#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()

雷达图

"玫瑰花绘制"实例展示

#RoseDraw.py
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()

S1S6jA

Python库

Numpy: 表达N维数组的最基础库

Pandas: Python数据分析高层次应用库

SciPy: 数学、科学和工程计算功能库

Matplotlib: 高质量的二维数据可视化功能库

Seaborn: 统计类数据可视化功能库

TensorFlow：AlphaGo背后的机器学习计算框架

。。。还有很多python第三方库

6第十章 总结

数字类型及操作

• 整数类型的无限范围及4种进制表示

• 浮点数类型的近似无限范围、小尾数及科学计数法

• +、-、*、/、//、%、**、二元增强赋值操作符

• abs()、divmod()、pow()、round()、max()、min()

• int()、float()、complex()

字符串类型及操作

• 正向递增序号、反向递减序号、<字符串>[M:N:K]

• +、*、len()、str()、hex()、oct()、ord()、chr()

• .lower()、.upper()、.split()、.count()、.replace()

• .center()、.strip()、.join(）、.format()格式化

程序的分支结构

• 单分支 if 二分支 if-else 及紧凑形式

• 多分支 if-elif-else 及条件之间关系

• not and or > >= == <= < !=

• 异常处理 try-except-else-finally

程序的循环结构

• for…in 遍历循环: 计数、字符串、列表、文件…

• while无限循环

• continue和break保留字: 退出当前循环层次

• 循环else的高级用法: 与break有关

函数的定义与使用

• 使用保留字def定义函数，lambda定义匿名函数

• 可选参数(赋初值)、可变参数(*b)、名称传递

• 保留字return可以返回任意多个结果

• 保留字global声明使用全局变量，一些隐式规则

代码复用与函数递归

• 模块化设计：松耦合、紧耦合

• 函数递归的2个特征：基例和链条

• 函数递归的实现：函数 + 分支结构

集合类型及操作

• 集合使用{}和set()函数创建

• 集合间操作：交(&)、并(|)、差(-)、补(^)、比较(>=<)

• 集合类型方法：.add()、.discard()、.pop()等

• 集合类型主要应用于：包含关系比较、数据去重

序列类型及操作

• 序列是基类类型，扩展类型包括：字符串、元组和列表

• 元组用()和tuple()创建，列表用[]和set()创建

• 元组操作与序列操作基本相同

• 列表操作在序列操作基础上，增加了更多的灵活性

字典类型及操作

• 映射关系采用键值对表达

• 字典类型使用{}和dict()创建，键值对之间用:分隔

• d[key] 方式既可以索引，也可以赋值

• 字典类型有一批操作方法和函数，最重要的是.get()

文件的使用

• 文件的使用方式：打开-操作-关闭

• 文本文件&二进制文件，open( , )和.close()

• 文件内容的读取：.read() .readline() .readlines()

• 数据的文件写入：.write() .writelines() .seek()

一维数据的格式化和处理

• 数据的维度：一维、二维、多维、高维

• 一维数据的表示：列表类型(有序)和集合类型(无序)

• 一维数据的存储：空格分隔、逗号分隔、特殊符号分隔

• 一维数据的处理：字符串方法 .split() 和 .join()

二维数据的格式化和处理

• 二维数据的表示：列表类型，其中每个元素也是一个列表

• CSV格式：逗号分隔表示一维，按行分隔表示二维

• 二维数据的处理：for循环+.split()和.join()

Python基础语法 (全体系)

推荐阅读：

史上最详细axios,读完你就全部懂了

vue后台项目中遇到的技术难点以及解决方案

前端面试题拿到百度京东offer的，前端面试题2021及答案