【Python从入门到入门】一、基础学习笔记【转载】

本文转载于简书，链接为：https://www.jianshu.com/p/8b87c6e9798f
因学习需要，转载至CSDN供自己和更多有兴趣的开发者学习查看。

第一部分 初识Python语言

第1章 程序设计基本方法

1.1 计算机的概念

• 计算机是根据指令操作数据的设备，具备功能性和可编程性两个基本特性。

• 计算机技术发展阶段：

1. 第一阶段：1946-1981年，“计算机系统结构阶段”。
2. 第二阶段：1982-2007年，“计算机网络和视窗阶段”。
3. 第三阶段：2008年至今，“复杂信息系统阶段”。
4. 第四阶段：月20年后某个时期开始，“人工智能阶段”。

1.2程序设计语言

1.2.1程序设计语言概述

• 机器语言：直接使用二进制代码表达指令，可被计算机硬件直接识别和执行。不同计算机结构的机器指令不同。

• 汇编语言：使用助记符对应机器语言中的指令，可直接操作计算机硬件。不同计算机结构的汇编指令不同。

机器语言和汇编语言都直接操作计算机硬件并基于此设计，统称“低级语言”。

• 高级语言：用更接近自然语言的方式描述计算问题。代码只与编程语言有关，与计算机结构无关。

1.2.2编译和解释

高级语言按执行方式可分为采用编译执行的静态语言和采用解释执行的脚本语言。

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

1.2.3计算机编程

• 我学习Python的原因：

1. 通过编程实现自动化，提高效率。
2. 通过编程了解一个新的广阔世界。

• 学习一门编程语言（重点在于练习）

1. 掌握该语言的语法
2. 结合问题设计程序结构
3. 掌握解决问题的能力

1.3Python语言概述

1.3.1 Python语言的发展

Python语言是一个语法简洁、跨平台、可扩展的开源通用脚本语言。

• Python语言诞生于1990年，创世人为Guido。
• 2000年10月，Python 2.0正式发布，2010年，Python 2.x系列发布最后一版（2.7）。
• 2008年12月，Python 3.0正式发布，解释器内部采用完全面向对象的方式实现，代价是3.x系列版本无法向下兼容2.x系列的既有语法。

Python 2.x已经是遗产，Python 3.x是这个语言的现在和未来。

1.3.2编写Hello程序

print("Hello World")

1.3.3 Python语言的特点

• 语法简洁
• 可跨平台
• 应用广泛
• 支持中文
• 强制可读：通过强制缩进体现语句间的逻辑关系提高了程序的可读性
• 模式多样：语法层面同时支持面向过程和面向对象两种编程方式
• 粘性扩展：通过接口和函数集成其他语言编写的代码
• 开源理念
• 库类丰富

1.4 Python语言开发环境配置

• Python解释器
• IDLE开发环境
• 交互式启动
• 文件式启动
• Python语言集成开发环境——PyCharm

1.5 程序的基本编写方法

1.5.1 IPO程序编写方法

每个程序都有统一的运算模式：输入数据、处理数据和输出数据。这种朴素的运算模式形成了基本的程序编写方法：IPO（Input,Process,Output)方法。

IPO不仅是程序设计的基本方法，也是描述计算问题的方式。

1.5.2理解问题的计算部分

• 使用计算机解决问题的6个步骤：

1. 分析问题
2. 划分边界
3. 设计算法
4. 编写程序
5. 调试测试
6. 升级维护

---

第2章 Python程序解析

2.1 Python程序语法元素分析

Python程序包括格式框架、注释、变量、表达式、分支语句、循环语句、函数等语法元素。

程序的格式框架

• Python语言采用严格的“缩进”来表明程序的格式框架，缩进表达了所属关系

• 在代码编写中缩进可通过Tab键实现，也可用多个空格实现，建议采用4个空格方式书写代码

注释

• 注释是辅助性文字，不被执行
• 单行注释：以#开头

#这是注释

• 多行注释：以'''(3个单引号)开头和结尾

'''
这是注释
这也是注释
这还是注释
'''

命名

• 命名是为变量关联标识符的过程，用于确保程序元素的唯一性
• 标识符由字母、数字、下划线（和汉字）等字符及其组合构成
• 标识符的首字符不能是数字 ，且中间不能出现空格
• 标识符对大小写敏感

保留字

• 保留字（Keyword）也被称为关键字，是被编程语言内部定义并保留使用的标识符
• Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> ls=keyword.kwlist
>>> ls
>>>len(ls)
33

Python 3 有33个保留字

1. True
2. False
3. None
4. and
5. as
6. assert
7. break
8. class
9. continue
10. def
11. del
12. elif
13. else
14. except
15. finally
16. for
17. from
18. global
19. if
20. import
21. in
22. is
23. lambda
24. nonlocal
25. not
26. or
27. pass
28. raise
29. return
30. try
31. while
32. with
33. yield

字符串

• 字符串（string）类型在程序中表示文本
• 字符串是字符的序列，可以按照单个字符或字符片段进行索引
• 字符串包括两种序号体系：正向递增序号、反向递减序号
• 正向递增序号：0~L-1
• 反向递减序号：-L~-1
• 区间访问方式：[N：M]（不包含M），可以混合使用正向递增序号和反向递减序号
• 字符串比较本质上是字符串对应Unicode编码的比较

赋值语句

• Python语言中，“=”表示“赋值”，将右侧的计算结果赋给左侧变量
• 同步赋值语句：可同时给多个变量赋值

<变量1>,…,<变量N>=<表达式1>,…,<表达式N>

分支语句

• 分支语句的作用是根据判断条件选择程序执行路径

if<条件1>：
　　　　<语句块1>

elif<条件2>：
　　　　<语句块2>
…
else：
　　　　<语句块N>

循环语句

• 循环语句的作用是根据判断条件确定一段程序是否再执行一次或多次

while (<条件>) ：
　　　　<语句块1>
<语句块2>

for i in range(<循环次数>)：
　　　　<语句块1>

input()函数

• 使用input()函数从控制台获得用户输入
• input()函数以字符串类型返回结果

<> = input("提示性文字")

>>>input("请输入：")

eval()函数

• eval(<字符串>)函数的作用是间输入的字符串变成Python语句并执行

x=eval(input("请输入："))

Python语法允许在表达式内部标记之间增加空格，适当增加空格有助于提高代码可读性。但应注意，不能改变与缩进相关的空格数量、不能再变量名等命名中间增加空格。

print()函数

• print()函数可以输出字符信息，也可以用字符的形式输出变量
• 输出字符信息时，可以直接将待输出内容传递给print()函数
• 输出变量值时，print()函数用槽格式和过format()方法将变量和字符串结合到一起输出

函数

• 函数可以理解为对一组表达特定功能表达式的封装，将特定功能代码编写在一个函数里，使程序模块化更好，便于阅读和复用
• 可通过保留字def自定义函数

2.2 对象（库）的调用

• .()表示调用一个对象的方法()，或调用一个函数库中的函数()

面向对象编程是一种基于对象的编程范式。对象是事物的一种抽象，是一个实体，包含属性和方法两部分。属性是对象中的变量，方法是对象能完成的操作。

• 通过保留字import引用函数库

1. import <库名>：程序调用库中所有函数，使用库中函数格式如下

<库名>.<函数名>(<函数参数>)

import turtle
turtle.fd(100) #控制画笔向当前行进方向前进100

2. from <库名> import ：

from <库名> import <函数名,函数名,…,函数名>
from <库名> import *，“ * ”是通配符，表示所有函数

• 调用库中函数不再需要使用库名，格式如下

<函数名>(<函数参数>)

from turtle import *
fd(100)

2.3 turtle库语法元素分析

tuetle库是一个图形绘制函数图

绘图坐标体系

• tuetle库绘制图形的基本框架是一个海龟在坐标系中爬行（前进、后退、左转、右转），其轨迹形成了绘制图形。
• 初始位置位于坐标（0,0），行进方向为水平右方。
• 使用turtle.setup()函数设置主窗体的大小和位置。

turtle.setup(width,height,startx,stary)

• width,height分别表示窗口宽度和高度，值是整数表示像素值，值时小数表示与屏幕的比例
• startx,stary分别表示窗口左侧和顶部与屏幕左侧和顶部的像素距离，如果值是none，窗口位于屏幕水平/垂直中央

turtle.setup（0.8,0.8）

画笔控制函数

• turtle.penup()：抬起画笔，之后移动画笔不绘制形状
  别名：turtle.pd()、turtle.down()
• turtle.pensize(width)：设置画笔宽度，width无参数或为None时返回当前画笔宽度
  别名：turtle.width()
• turtle.pencolor()：设置画笔颜色，无参数输入时返回当前画笔颜色。

(colorstring)参数表示颜色的字符串；(r,g,b)参数表示颜色对应的RGB值

颜色	颜色字符串	GRB	十六进制
黑色	black	0,0,0	#FFFFFF
白色	white	255,255,255	#000000
灰色	grey	190,190,190	#BEBEBE

形状绘制函数

• turtle.fd(distance)：控制画笔向当前行进方向前进distance，值为负数表示向相反方向前进
  别名：turtle.forward(distance)
• turtle.seth(to_angle)：控制画笔绘制方向，（to_angle）参数是绝对方向角度值（turtle库的坐标体系以正东方向为绝对0度、正北方向为绝对90度）
• turtle.circle(radius,extent=None)：根据半径radius绘制extent角度的弧形
  radius值为正时，半径在画笔左侧，值为负时，半径在画笔右侧；
  extent为正时，画笔逆时针前进，extent为负时，画笔顺时针倒退，extent不设置参数或参数为None时，绘制整圆。

---

第二部分 深入Python语言

第3章 基本数据类型

3.1 数字类型

• Python语言提供整数、浮点数、复数3种数字类型

整数类型

• 整数类型共有4种进制表示：十进制、二进制、八进制和十六进制
• 默认情况整数采用十进制，其他进制需要增加引导符号

进制种类	引导符号	描述
十进制	无	默认情况
二进制	0b或0B	由字符0和1组成
八进制	0o或0O	由字符0到7组成
十六进制	0x或0X	由字符0到9、a到f、A到F组成

浮点数类型

• 浮点数类型与数学中实数的概念一致，表示带有小数的数值
• Python语言要求所有浮点数必须带有小数部分（可以是0），一区分浮点数和证书类型
• 浮点数有2中表示方法：十进制表示和科学计数法表示

科学计数法使用字母e或E作为幂的符号，以10为基数,含义如下：

<a>e<b>=a*10b^2

• 由于计算机内部采用二进制运算，浮点数进行超过15位数字计算会产生误差

使用整数表达浮点数的方法是高精确度运算的基本方法之一。

• 对于高精度科学计算外的绝大部分运算而言，浮点数类型已足够可靠，一般认为浮点数类型没有范围限制，运算结果准确

复数类型

• 复数类型表示数学中的复数

复数可以看作是二元有序实数对(a,b),表示为a+bj，其中a是实数部分，简称实部，b是虚数部分，简称虚部。

• Python 语言中，复数的虚部通过后缀"j"或"J"表示

1.23e-4+5.67e+89j

• 复数类型中实数部分和虚数部分的数值都是浮点数类型，对于实数z，可用z.real和z.imag分别获得它的实部和虚部

(1.23e-4+5.67e+89j).real
(1.23e-4+5.67e+89j).imag

3.2 数字类型的操作

• Python 解释器为数字类型提供数值运算操作符、数值运算函数、类型转换函数等操作方法

内置的数值运算操作符（共9个）

操作符	描述
x+y	x与y之和
x-y	x与y之差
x*y	x与y之积
x/y	x与y之商
x//y	x与y之整数商，即不大于x与y之商的最大整数
x%y	x与y之商的余数，也称为模运算
-x	x的负值
+x	x本身
x**y	x的y次幂，即x^y

• 操作符运算的结果可能会改变数字类型，3种数字类型之间存在一种逐渐扩展的关系：整数→浮点数→复数
• 上述9个二元数学操作符都有与之对应的增强赋值操作符

x+=y 等价于 x=x+y

• 模运算（%）在编程中主要应用于具有周期规律的场景

内置的数值运算函数（共6个）

函数	描述
abs(x)	x的绝对值
divmod(x,y)	(x//y,x%y),输出为二元组形式（也称为元组类型）
pow(x,y[,z])	(x**y)%z,[…]表示该参数可省略
round(x[,ndigits])	对x四舍五入，保留ndigits位小数，round(x)返回四舍五入的整数值
max(x1,x2,…,xn)	x1,x2,…,xn的最大值，n没有限定
min(x1,x2,…,xn)	x1,x2,…,xn的最小值，n没有限定

内置的数字类型转换函数（共3个）

函数	描述
int(x)	将x转换为整数，x可以是浮点数或字符串
float(x)	将x转换为浮点数，x可以是整数或字符串
complex(re[,im])	生成一个复数，实部为re，虚部为im，re可以是整数、浮点数或字符串，im可以是整数或浮点数但不能为字符串

• int()函数将浮点数类型转换为整数时，小数部分会直接被舍弃
• 复数不能直接转换为其他数字类型，可通过.real和.imag将复数的实部和虚部分别转换

3.3 字符串类型及其操作

字符串类型的表示

• 字符串是字符的序列表示
• 单引号字符串：'单引号表示可以使用"双引号"作为字符串的一部分'
• 双引号字符串："双引号表示可以使用'单引号'作为字符串的一部分"
• 三引号字符串：'''三引号表示可以使用"双引号"、'单引号'作为字符串的一部分
  也可以换行
  '''
• Python 字符串提供区间访问方式，采用[N:M]格式。表示从字符串中从N到M（不包含M）的字符串，可以混合使用正向递增序号和反向递减序号
• 反斜杠字符(\)在字符串中表示转义

1. \n 表示换行
2. \\ 表示反斜杠
3. \' 表示单引号
4. \" 表示双引号
5. \t 表示制表符(Tab)

基本的字符串操作符（共5个）

操作符	描述
x+y	连接两个字符串x与y
x*n或n*x	复制n次字符串x
x in s	如果x是s的子字符串，返回Ture，否则返回False
str[i]	索引，返回第i个字符
str[N:M]	切片，返回索引第N到第M个字符

内置的字符串处理函数（共6个）

函数	描述
len('x')	返回字符串x的长度，也可返回其他组合数据类型元素个数
str('x')	返回任意类型x所对应的字符串形式
chr(x)	返回Unicode编码x对应的单字符
ord('x')	返回单字符表示的Unicode编码
hex(x)	返回整数x对应十六进制数的小写形式字符串
oct(x)	返回整数x对应八进制数的小写形式字符串

内置的字符串处理方法（共43个，常用16个）

• 在Python解释器内部，所有数据类型都采用面向对象的方式实现，封装为一个类
• 字符串是一个类，具有类似.()形式的字符串处理函数，称为方法

方法	描述
str.lower()	返回字符串str的副本，全部字符小写
str.upper()	返回字符串str的副本，全部字符大写
str.islower()	当str所有字符都是小写时，返回Ture，否则返回False
str.isprintable()	当str所有字符都是可打印的，返回Ture，否则返回False
str.isnumeric()	当str所有字符都是数字时，返回Ture，否则返回False
str.isspace()	当str所有字符都是空格，返回Ture，否则返回Flase
str.endswith(suffix[,start[,end]])	str[start:end]以suffix结尾返回Ture，否则返回Flase
str.srartswith(prefix[,start[,end]])	str[start:end]以prefix开始返回Ture，否则返回Flase
str.split(sep=None,maxsplit=-1)	返回一个列表，由str根据sep被分割的部分构成
str.count(sub[,start[,end]]	返回str[start:end]中sub子串出现的次数
str.replace(old,new[,count])	返回字符串str的副本，所有old子串被替换为new，如果count给出，则前count次old出现被替换
str.center(width[,fillchar])	字符串居中函数
str.strip([chars])	返回字符串str的副本，在其左侧和右侧去掉chars中列出的字符
str.zfill(width)	返回字符串str副本，长度为width。不足部分在其左侧添加0
str.format()	返回字符串str的一种排版格式
str.join(iterable)	返回一个新字符串，由组合数据类型iterable变量的每个元素组成，元素间用str分隔

3.4 字符串类型的格式化

• 字符串通过format()方法进行格式化处理

字符串格式化用于解决字符串和变量同时输出时的格式安排

format()方法的基本使用

• 字符串format()方法的基本使用格式：<字模板符串>.format(<逗号分隔的参数>)
• 模板字符串由一系列槽组成，用来控制修改字符串中嵌入值出现的位置（槽用{}表示，如果{}中没有序号，则按照出现顺序替换）
• 如需输入{}，采用{{表示{；}}表示}

"圆周率{{{1}{2}}}是{0}".format("无理数",3.1415926,"……")

format()方法的格式控制

• format()方法模板字符串的槽除了包括参数序号，还可包括格式控制信息。槽内部样式：{<参数序号>：<格式控制标记>}
• 格式控制标记用于控制参数显示时的格式

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充的单个字符	<左对齐、>右对齐、^居中对齐	槽的设定输出宽度	数字的千位分隔符 适用于整数和浮点数	浮点数小数部分的精度或字符串的最大输出长度	整数类型b,c,d,o,x,X；浮点数类型e,E,f,%

• <填充>指宽度内除了参数外的字符采用什么方式表示，默认为空格
• <对齐>指参数在宽度内输出时的对齐方式
• <宽度>指当前槽的设定输出字符宽度，若实际参数长度比设定值大，则使用参数实际长度
• <,>用于显示数字类型的千分位分隔符
• <.精度>对于浮点数，表示小数部分输出的有效位数；对于字符串，表示输出的最大长度
• <类型>表示输出整数好浮点数类型的格式规划。
  对于整数类型，

1. b：整数的二进制；
2. c：整数对应的Unicode字符；
3. d：整数的十进制；
4. o：整数的八进制
5. x：整数的小写十六进制
6. X：整数的大写十六进制
   对于浮点数类型，
7. e：浮点数对应的小写字母e的指数形式
8. E：浮点数对应的大写字母E的指数形式
9. f：浮点数的标准浮点形式
10. %：浮点数的百分形式

第4章 程序的控制结构

4.1 程序的基本结构

程序流程图

• 起止框表示一个程序的开始和结束
• 判断框判断一个条件是否成立，并根据判断结果不同选择不同的执行路径
• 处理框表示一组处理过程
• 输入/输出框表示数据输入或结果输出
• 注释框增加程序的解释
• 流向线以带箭头的直线或曲线形式指示程序的执行路径
• 连接点将多个流程图连接到一起

程序的基本结构

• 程序有3种基本结构组成：顺序结构、分支结构和循环结构
• 顺序结构：程序按照线性顺序依次执行
• 分支结构：程序根据条件判断结果而选择不同向前执行路径的一种运行方式（分支结构包括单分支结构和二分支结构；p97）
• 循环结构：程序根据条件判断结果向后反复执行（根据触发条件不同，循环结构包括条件循环和遍历循环）

4.2 程序的分支结构

单分支机构：if语句

if语句语法格式：

if <条件>：
    <语句块>

• 语句块是if条件满足后执行的一个或多个语句序列
• 语句块中语句通过与if所在行形成缩进表达包含关系
• if语句首先评估条件的结果值，若为Ture则执行语句块中的语句序列；若为False则跳过语句块中的语句
• if语句中条件部分可以使用任何能够产生Ture或False的语句或函数

形成判断条件最常见的方式是采用关系操作符

关系操作符	数学符号	操作符含义
<	<	小于
>	>	大于
<=	≤	小于等于
>=	≥	大于等于
==	=	等于
!=	≠	不等于

• Python使用"="表示赋值语句，使用"=="表示等于

二分支结构：if-else语句

if-else语句语法格式：

if <条件>:
    <语句块1>
else <条件>:
    <语句块2>

• 二分支语句用于区分条件的两种可能
• if条件满足时执行语句块1
• if条件不满足时执行语句块2

二分支结构的简洁表达（适合通过判断返回特定值）

<表达式1> if <条件> else <表达式2>

• 表达式1/2一般是数字类型或字符串类型的一个值

多分支结构：if-elif-else语句

if-elif-else语句语法格式：

if <条件1>:
    <语句块1>
elif <条件2>:
    <语句块2>
...
else:
    <语句块N>

• Python依次评估寻找第一个结果为Ture的条件，执行该条件下的语句并跳过整个if-elif-else结构，执行后面的语句
• 如果没有任何条件成立，执行else下面的语句块
• else语句是可选的

4.3 程序的循环结构

遍历循环：for语句

for语句语法格式

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

• 遍历循环可以理解为从遍历结构中中逐一提取元素，放在循环变量中，对于所提取的每个元素执行一次语句块

循环N次：

for i in rang(N):
    <语句块>

遍历文件的每一行：

for line in fi:
    <语句块>

遍历字符串s

for c in s:
    <语句块>

遍历列表ls

for item in ls:
    <语句块>

遍历循环的扩展模式

for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>

当for循环正常执行后，程序会继续执行else语句

遍历循环：while语句

while语句语法格式

while <条件>:
    <语句块>

• 当条件判断为Ture时，循环体重复执行语句块中的语句；当条件为Flase时，循环终止，执行与while同级别缩进的后续语句

无限循环的扩展模式

while <条件>：
    <语句块1>
else:
    <语句块2>

• 当while循环正常执行后，程序会继续执行else语句中的内容，else语句只在循环正常执行后才执行

循环保留字：break和continue

• break用来跳出最内层for或while循环，脱离该循环后程序从循环代码后继续执行
• continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环

for s in "BIT":
    for i in rang(2):
        print(s,end="")
        if s=="I":
            break

>>>BBTT

• break语句与continue语句的区别是,break语句结束整个循环过程，不再判断执行循环的条件是否成立；continue语句只结束本次循环，而不终止整个循环的执行

for循环和while循环中都有一个else扩展用法。else语句仅在循环正常遍历了所有内容或由于条件不成立而结束循环的条件下执行。

for s in "PYTHON":
    if s =="T":
        continue
    print(s,end="")
else:
    print("正常退出")
>>>
PYHON 正常退出

for s in "PYTHON":
    if s =="T":
        break
    print(s,end="")
else:
    print("正常退出")
>>>
PY

4.4 random库的使用

random库采用梅森旋转算法生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用

• Python内置的random库主要用于产生各种分布的伪随机数序列
• random库提供9个常用函数

函数	描述
seed(a=None)	初始化随机数种子，默认值为当前系统时间
random()	生成一个[0.0,1.0]之间的随机小数
randint(a,b)	生成一个[a,b]之间的整数
getrandbits(k)	生成一个k比特长度的随机整数
randrange(start,stop[,step])	生成一个[start,stop]之间以step为步数的随机整数
uniform(a,b)	生成一个[a,b]之间的随机小数
choice(seq)	从序列类型，例如列表中随机返回一个元素
shuffle(seq)	将序列类型中的元素随机排列，返回打乱后的序列
sample(pok,k)	从pop类型中随机选取k个元素，以列表类型返回

• 生成随机数之前可通过seed()函数指定随机数种子，随机数种子一般是一个整数，只要种子相同，每次生成的随机数序列也相同

4.5 程序的异常处理

Python通过try、except等保留字提供异常处理功能

异常处理：try-except语句

• Python使用try-except语句实现异常处理

try:
    <语句块1>
except <异常类型>:
    <语句块2>

异常的高级用法

• try-except语句可以支持多个except语句

try:
    <语句块1>
except <异常类型1>：
    <语句块2>
...
except <异常类型N>:
    <语句块N+1>
except <异常类型N+!>:
    <语句块N+2>

• 异常语句还可以与else和finally保留字配合使用

try:
    <语句块1>:
except <异常类型1>：
    <语句块2>
else:
    <语句块3>
finally：
    <语句块4>

第5章 函数和代码复用

5.1 函数的基本使用

函数的定义

• 函数是一段具有特定功能的、可重用的语句组
• 使用函数主要有两个目的：降低编程难度和代码重用
• Python使用def保留字定义一个函数

def<函数名>(<参数列表>):
    <函数体>
    return<返回值列表>

• 函数名可以是任何有效的Python标识符
• 参数列表是调用该函数是传递给它的值，可以有零个（保留圆括号）、一个或多个（用逗号分隔）
• 函数体是函数每次被调用是执行的代码
• 当需要返回值时使用保留字return和返回值刘表，否则函数可以没有return语句，在函数体结束时将控制权返回给调用者

函数调用和执行的一般形式

<函数名>(<参数列表>)

函数的调用过程

1. 调用程序在调用处暂停执行
2. 在调用时将实参复制给形参
3. 执行函数体语句
4. 函数调用结束给出返回值，程序回到调用前的暂停处继续执行

lambda函数

• lambda函数又称匿名函数，将函数名作为函数结果返回

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

lambda函数与正常函数一样，等价于下面表达式：

def<函数名>(<参数列表>):
    return<表达式>

• lambda函数用于定义简单的、能够在一行内表示的函数，返回一个函数类型

f=lambda q,w,e,r:q+w+e+r
f(1,2,3,4)
10

• lambda函数用于需要函数对象的场景

5.2 函数的参数传递

函数可定义可选参数，使用参数的位置或名称传递参数值，根据函数中变量的不同作用域有不同的函数返回值方式

可选参数和可变数量参数

• 函数定义时部分参数可直接为存在默认值的参数指定默认值，当函数被调用时如果没有传入对应的参数值则使用函数定义时的的默认值替代
• 默认参数必须指向不变对象
• 函数调用时需要按顺序输入参数，可选参数必须定义在非可选参数后

dfe r(str,times=2):
    print(str*times)
r("T")
TT
r("T")
TTTT

• 函数定义时可设计可变数量参数，通过在参数前加星号(*)实现
• 带有星号的可变参数只能出现在参数列表最后，调用时这些参数被单指元组类型传递到函数中

def vfunc(a,*b)
    print(type(b)
    for n in b:
        a+=n
    return a
vfunc(1,2,3,4,5)
<class 'tuple'>
15 #1+2=3;3+3=6;6+4=10;10+5=15

参数的位置和名称传递

• 函数定义时实参默认采用按照位置顺序的方式传递给函数，这种方式在参数很多的情况下可读性较差
• Python提供了按照形参名称输入实参的方式，调用函数时指定参数名称，参数之间的顺序可任意调整

函数的返回值

• return语句用来退出函数并将程序返回到函数被调用的位置继续执行
• return语句可同时将0个、1个或多个函数运算后的结果返回给函数被调用的位置
• 函数可以没有return，此时函数不返回值
• 函数也可以用return返回多个值，多个值以元组类型保存

def func(a,b):
    return b,a
s=func("t",2)
print(s,type(s))
(2, 't') <class 'tuple'>

5.4 datetime库的使用

Python时间处理的标准函数库datetime提供里一批显示日期和时间的格式化方法。

datetime库概述

datetime库可以从系统中获得时间，并以用户选择的格式输出

• datetime库以格林威治时间为基础，每天由3600*24秒精准定义
  datetime库以类的方式提供多种日期和时间

1. datetime.date：日期表示类，坑人表示年、月、日等。
2. datetime.time：时间表示类，可表示小时、分钟、秒、毫秒等。
3. datetime.datetime：日期和时间表示类，功能覆盖date和time类。
4. datetime.timedelta：与时间间隔有关的类。
5. datetime.tzinfo：与时区有关的信息表示类。

datetime库解析（datetime类）

• datetime.datetime类的使用方式是首先创建一个datetime对象，然后通过对象的方法和属性显示时间
  创建datetime对象的3种方法：

1. datetime.now()：返回一个datetime类型，表示当前日期和时间，精确到毫秒

>>>from datetime import datetime
>>>now=datetime.now()
>>>now
datetime.datetime(2018, 5, 13, 16, 49, 38, 627464)

2. datetime.utcnow()：返回一个datetime类型，表示当前日期和时间的UTC（世界标准时间）表示，精确到毫秒

>>>from datetime import datetime
>>>utcnow=datetime.now()
>>>utcnow
datetime.datetime(2018, 5, 13, 8, 53, 59, 788612)

3. 直接使用datetime()构造一个日期和时间对象：datetime(Y,M,D,hour=0,minute=0,second=0,microsecond=0)

>>>some=datetime(2018,5,13,17,0,0,0)
>>>some
datetime.datetime(2018, 5, 13, 17, 0)

-创建datetime对象后，可利用该对象的属性显示时间
（以上述“some”为例）

• datetime类的常用属性

属性	描述
some.min	固定返回datetime的最小时间对象，datetime(1,1,1,0,0)
some.max	固定返回datetime的最大时间对象，datetime(9999,12,31,23,59,59,999999)
some.year	返回some包含的年份
some.month	返回some包含的月份
some.day	返回some包含的日期
some.hour	返回some包含的小时
some.minute	返回some包含的分钟
some.second	返回some包含的秒钟
some.microsecond	返回some包含的毫秒

• datetime类的常用时间格式化方法

属性	描述
some.isofomat()	采用ISO8601标准显示时间
some.isoweekday()	根据日期计算星期
some.strftime()	根据格式化字符串format进行格式显示的方法

• strftime()方法用于输出特定格式时间

格式化字符串	对象	取值范围
%Y	年	0001~9999
%m	月	1~12
%B	月名	January~December
%b	月名缩写	Jan~Dec
%d	日期	01~31
%A	星期	Monday~Sunday
%a	星期缩写	Mon~Sum
%H	小时（24h制）	00~23
%I	小时（12h制）	01~12
%p	上、下午	AM/PM
%M	分钟	00~59
%S	秒	00~59

>>>some=datetime(2018,5,13,17,0,0,0)
>>>some.strftime("%Y年%m月%d日，%H时%M分%S秒")
'2018年05月13日，17时00分00秒'

>>>print(‘今天是{0:%Y}年{0:%m}月{0:%d}日’.format(some))
今天是2018年05月13日

5.5 代码复用和模块化设计

• 当代编程语言从代码层面采用函数和对象两种抽象方式，分别对应面向过程和面向对象两种编程思想
• 函数是程序的一种基本抽象方式，它将一系列代码组织起来通过命名提供其他程序使用，任何其他代码只有输入参数即可调用函数，更新函数功能时，所有被调用处的功能都被更新。
• 对象是程序的一中高级抽象方式，它将程序代码组织为更高级的类。对象包括表征对象特征的属性和代表对象操作的方法。
• 模块化设计值通过函数或对象的封装功能将程序划分成主程序、子程序和子程序间关系的表达。
• 模块化设计的两个基本要求：

1. 紧耦合：尽可能合理划分功能块，功能块内部耦合紧密
2. 松耦合：模块间关系尽可能简单，功能块之间耦合度低

5.6 函数的递归

递归的定义：函数定义中调用函数自身的方式称为递归

• 数学经典递归案例——阶乘

n!=n(n-1)(n-2)...(1)

n!=1 (n=0)
n!=n(n-1)! (otherwise)

• 递归的两个关键特征

1. 存在一个或多个基例，基例不需要再次递归，是确定的表达式
2. 所有递归链要以一个或多个基例结尾

递归的使用方法

def fact(n):
    if n==0:
        return 1
    else:
        return n*fact(n-1)
num=eval(input('请输入一个整数：'))
print(fact(abs(int(num))))

• 使用递归一定要注意基例的构建，否则递归无法返回

5.7 科赫曲线绘制

科赫曲线属于分形几何分支，它的绘制过程体现了递归思想

from turtle import *
def koch(size,n):
    if n==0:
        fd(size)
    else:
        for angle in [0,60,-120,60]:
            left(angle)
            koch(size/3,n-1) # 递归
def main(size,level):
    setup(600,600) # 设置主窗体大小
    speed(0) # 设置画笔速度，（1~10）
    hideturtle() # 隐藏turtle箭头
    penup()
    goto(-150,50)
    pendown()
    pensize(1) # 设置画笔尺寸
    koch(size,level)
    right(120)
    koch(size,level)
    right(120)
    koch(size,level)
main(300,3)

5.8 Python内置函数

Python提供68个内置函数

• abs()
• all()
• any()
• asci()
• bin()
• bool()
• chr()
• complex()
• dict()
• divmod()
• eval()
• float()
• hash()
• hex()
• id()
• input()
• int()
• len()
• list()
• max()
• min()
• oct()
• open()
• ord()
• pow()
• print()
• range()
• reversed()
• round()
• set()
• sorted()
• str()
• tuple()
• type()
• zip()

---

• bytes()
• delattr()
• bytearray()
• callable()
• classmethod()
• compile()
• dir()
• exec()
• enumerate()
• filter()
• format()
• frozenset()
• getattr()
• globals()
• hasattr()
• help()
• isinstance()
• issubclass()
• iter()
• locals()
• map()
• memoryview()
• next()
• object()
• properyty()
• repr()
• setattr()
• slice()
• staticmethod()
• sum()
• super()
• vars()
• _import()_

第6章 组合数据类型

6.1 组合数据类型概述

组合数据类型为多个类型或不同类型数据提供单一表示，使数据操作更有序、更容易。组合数据类型分为序列类型、集合类型和映射类型3类。

序列类型

序列类型是一维元素向量，元素间存在先后关系，通过序号访问，元素之间不排他。

1. 字符串（str）可以看做是单一字符的有序组合，属于序列类型

• 字符串被看做基本数据类型

2. 元组（tuple）是包含零个或多个数据项的不可变序列类型

• 一个元组可作另一个元组的元素，可采用多级索引获取信息

>>>X=('a','b','c') #等同 X='a','b','c'
>>>Y=(1,2,3,X)
>>>Y[3][2] #多级索引
'c'

• Python中元组采用逗号和圆括号（可选）表示

3. 列表（list）是包含零个或多个对象引用的有序数列

• 列表的长度和内容都是可变的
• 列表用中括号([])表示，也可通过list()函数将元组或字符串转化成列表
• 列表必须通过显式赋值才能生成，简单将一个列表赋值给另一个列表不会生成新的列表对象

序列类型的通用操作符和函数

操作符或函数	描述
x in s	如果x是s的元素，返回True，否则返回Flase
x not in s	如果x不是s的元素，返回True，否则返回Flase
s+t	连接s和t
s*n或n*s	将序列s复制n次
s[i]	索引，返回序列s的第i个元素
s[i:j]	分片，返回包含序列s第i到第j（不含）个元素的子序列
s[i:j:k]步骤分片，返回包含序列s第i到第j（含）个元素以k为步长的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x[,i[,j]])	序列s中从i开始到j位置第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

集合类型

集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。

• 集合的元素类型只能是固定数据类型（能够进行哈希运算的类型都可以作为集合元素）

哈希运算可以将任意长度的二进制值映射为较短的固定长度的二进制值，哈希值是对数据的一种有损且紧凑的表示形式，是数据在另一个数据维度的体现。

• 集合是无序组合，没有索引和位置的概念，不能分片
• 集合不包含重复元素，可使用集合类型过滤重复元素
• 集合中元素可以动态增加或删除
• 集合用大括号（{}）表示（直接使用大括号生成一个空的字典而不是集合）
• 生成空集合需要使用函数set()

集合类型的操作符（10个）

操作符	描述
S-T	差集：返回一个集合，包括在集合S中但不在集合T中的元素
s-=T	更新集合S，包括在集合S中但不在集合T中的元素
S&T	交集：返回一个新集合，包括同时在集合S和T中的元素
S&=T	更新集合S,包括同时在集合S和T中的元素
S^T	补集：返回一个新集合，包括集合S和T中的元素，但不包括同时在其中的元素
S=^T	更新集合S,包括集合S和T中的元素，但不包括同时在其中的元素
S|T	并集：返回一个新集合，包括集合S和T中的所有元素
S=|T	更新集合S,包括集合S和T中的所有元素
S<=T	判断S是否是T的真子集
S>=T	判断S是否是T的真超集

集合类型的操作函数或方法（10个）

操作函数或方法	描述
S.add.(x)	如果数据项x不在集合S中，将x增加到S
S.clear()	移除S中的所有数据项
S.copy	返回集合S的一个副本
S.pop()	随机返回集合S中的一个元素，若S为空，产生KeyError异常
S.discard(x)	如果x在集合S中，则移除x；若不在也不报错
S.remove(x)	如果x在集合S中，则移除x；否则产生KeyError异常
S.isdisjoint(T)	如果集合S与T没有相同元素，则返回True
len(S)	返回集合S的元素个数
x in S	如果x是S的元素，返回True，否则返回False
x not in S	如果x不是S的元素，返回True，否则返回False

映射类型

映射类型是“键-值”数据项的组合，每个元素是一个键值对，表示为(key,value)。

列表类型的操作

列表类型特有的函数或方法（14个）

函数或方法	描述
ls[i]=x	替换列表ls第i个数据为x
ls[i:j]=lt	用列表lt替换列表ls中第i到第j（不含）项的数据
ls[i:j:k]=lt	用列表lt替换列表ls中第i到第j（不含）项以k为步数的数据
del ls[i:j]	删除列表ls中第i到第j（不含）项的数据，等价于ls[i:j]=[]
del ls[i:j:k]	删除列表ls中第i到第j（不含）项以k为步数的数据
ls+=lt或ls.extend(lt)	将列表lt的元素增加到列表ls中
ls*=n	更新ls列表，使其元素重复n次
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除列表ls中的所有元素
ls.copy()	生成一个新列表，复制ls中的所有元素
ls.insert(i,x)	在列表ls的第i个位置增加元素x
ls.pop(i)	将列表ls中的元素取出并删除该元素
ls.remove(x)	将列表ls中出现的第一个x元素删除
ls.reverse()	将列表ls中的元素反转

6.3 实例：基本统计值计算

from math import *
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 sqrt(sdev/(len(numbers)-1))
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(‘平均值：{},方差：{},中位数：{}’.format(m,dev(n,m),median(n)))

• 列表是一个动态长度的数据结构，可以跟需求增减元素
• 列表的一系列方法或操作符为计算提供了简单的元素运算手段
• 列表提供了对每个元素的简单访问方式及所有元素的遍历方式

6.4 字典类型和操作

字典是包含零个或多个键值对的集合，没有长度限制，可以根据减值索引内容

字典类型的概念

• 编程术语中，根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系
• 通过任意键信息查找一组数据中值信息的过程叫映射
• Python语言中通过字典实现映射，字典通过大括号({})建立，键和值通过冒号(:)连接，不同键值对通过逗号(,)隔开

{<键1>:<值1>,<键2>:<值2>,...<键n>:<值n>}

• 字典是集合的延续，各个元素没有顺序之分
• 字典通过索引符号查找与特定键相对应的值

<值>=<字典变量>[<键>]

• 字典中对某个键值的修改可以通过中括号的访问和赋值实现

字典类型的操作

• 使用大括号创建字典并指定初始值
• 使用中括号增加新的元素
• 键和值可以是任何数据类型？
• 采用固定数据类型的键数据作为索引

字典类型的函数和方法

函数和方法	描述
.keys()	返回所有的键信息
.values()	返回所有的值信息
.items()	返回所有的键值对
.get(,)	键存在则返回相应值，否则返回默认值
.pop(,)	键存在则返回相应值，同时删除键值对，否则返回默认值
.popitem()	随机从字典中取出一个键值对，以元组(key,value)形式返回
.clear()	删除所有的键值对
del[]	删除字典中某一个键值对
in	如果键在字典中则返回Ture，否则返回False

6.5 jieba库的使用

jieba库概述

• 提取英文文本中的单词，可使用字符串处理的split()方法
• jieba库是Python中一个第三方中文分词函数库
• jieba库的分词原理是利用一个中文词库，将待分词的内容与分词词库进行比对，通过图结构和动态规划方法找到最大概率的词组
• jieba库支持3种分词模式：精确模式、全模式、搜索引擎模式

1. 精确模式：将句子最精确地切开，适合文本分析
2. 全模式：把句子中所有可以成词的词语都扫描出来，速度快，但不能消除歧义
3. 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词

jieba库解析

• jieba库主要提供分词功能，可以辅助自定义分词词典
  jieba库常用的分词函数
  |函数|描述|
  |---|---|
  |jieba.cut(s)|精确模式，返回一个可迭代的数据类型|
  |jieba.cut(s,cut_all=Ture)|全模式，输出文本s中所有可能的单词|
  |jieba.cut_for_search(s)|搜索引擎模式，适合搜索引擎建立索引的分词结果|
  |jieba.lcut(s)|精确模式，返回一个列表类型，建议使用|
  |jieba.lcut(s，cut_all_=Ture)|全模式，返回一个列表类型，建议使用|
  |jieba.lcut_for_search(s)|搜索引擎模式，返回一个列表类型，建议使用|
  |jieba.add_word(w)|向分词词典中增加新词w|

• jieba.lcut()函数返回精确模式，输出的分词能够完整且不多余地组成原始文本

• jieba.lcut(,True)函数返回全模式，输出原始文本中可能产生的所有问题，冗余性最大

• jieba.lcut_for_search()函数返回搜索引擎模式，该模式首先执行精确模式，然后再对其中的长词进一步分切得出结果

• 无识别的分词，可通过jieba.add_word()函数向分词库中添加

6.6文本词频统计

词频统计只是累加问题，即对文档中每个词设计一个计数器，词语每出现一次，相关计数器加1.。如果以词语为键，计数器为值，构成<单词>:<出现次数>的键值对，采用字典数据结构统计词语出现的频次，将很好第解决问题

Hamlet英文词频统计

1. 分解并提取英文文章的单词

• ①通过txt.lower()函数将字母变成小写
• ②通过txt.repla()方法将特殊字符替换为空格以统一单词分隔方式

2. 对每个单词进行计数
3. 对单词的统计值从高到低进行排序

• ①将字典类型转换为有顺序的列表类型
• ②使用sort()方法和lambda函数配合实现根据单词出现的次数对元素进行排序

4. 采用集合类型构建一个排除词汇库（排除语法型词汇）

excludes={'the','and','to','of','you','a','i','my','in','it','that','is','not','his','this','but','with'}#排除词汇库集合
def getText():
    txt = open("D:\\python\\fenci\\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
for word in excludes:
    del(counts[word])
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
print(items)
for i in range(20):
    word,count=items[i]
    print('{0:<10}{1:>5}'.format(word,count))

《三国演义》人物出场统计

中文文章需要分词才能进行词频统计，需要用到jieba库。

import jieba
excludes={"将军","却说","荆州","二人","不可","不能","如此","商议","如何","主公",\
          "军士","左右","军马","引兵","次日","大喜","天下","于是","东吴","今日",\
          "不敢","魏兵","陛下","人马","不知","都督","一人","汉中"}\
          #与人名无关的词汇库集合
txt=open("D:\\python\\fenci\\三国演义.txt","r",encoding='utf-8').read()
words=jieba.lcut(txt)#jieba库分词
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="曹操"
    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))

6.7 Python之禅

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

s = """Gur Mra bs Clguba, ol Gvz Crgref

Ornhgvshy vf orggre guna htyl.
Rkcyvpvg vf orggre guna vzcyvpvg.
Fvzcyr vf orggre guna pbzcyrk.
Pbzcyrk vf orggre guna pbzcygrq.
Syng vf orggre guna arfgrq.
Fcnefr vf orggre guna qrafr.
Ernqnovyvgl pbhagf.
Fcrpvny pnfrf nera’g fcrpvny rabhtu gb oernx gur ehyrf.
Nygubhtu cenpgyvgl orngf chevgl.
Reebef fubhyq arire cnff fvyragyl.
Hayrff rkcyvpvgyl fvyraprq.
Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff.
Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg.
Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh’er Qhgpu.
Abj vf orggre guna arire.
Nygubhtu arire vf bsgra orggre guna evtug abj.
Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg’f n onq vqrn.
Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.
Anzrfcnprf ner bar ubaxvat terng vqrn – yrg’f qb zber bs gubfr!"""

d = {}
for c in (65, 97):#chr(65)_chr(97)为az、A~Z
for i in range(26):
d[chr(i+c)] = chr((i+13) % 26 + c)#将循环编号增加了13，直接好处是原文和密文之间的相互转换可以使用同一个程序

print("".join([d.get(c, c) for c in s]))

第7章 文件和数据格式化

7.1文件的使用

Python能够以文本和二进制两种方式处理

文件概述

• 文件是一个储存在辅助存储器上的数据序列，可以包含任何数据内容
• 文件包括文本文件和二进制文件两种类型
• 文本文件一般由单一特定编码的字符组成，可被看作是存储在磁盘上的长字符串
• 二进制文件直接由比特0和比特1组成，由于没有统一字符编码，职能当做字节流
  无论是创建为文本文件还是二进制文件，都可以用“文本文件方式”和“二进制文件方式”打开，但打开后操作方式不同。
• 采用文本方式读入文件，文件经过编码形成字符串，打印出有含义的字符
• 采用二进制方式打开文件，文件被解析为字节流

文件的打开关闭

• Python通过解释器内置的open()函数打开一个文件，并实现该文件与一个程序变量的关联

<变量名>=open(<文件名>,<打开模式>)

• 文件名可以是文件的实际名字，也可以是包含完整路径的名字
• 打开模式用于控制使用何种方式打开文件，open()提供7种基本的打开模式

文件的打开模式

文件的打开模式	含义
‘r’	只读模式，如果文件不存在，返回异常FileNotFoundError,默认值
‘w’	覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’	创建写模式，文件不存在则创建，存在则返回异常FileExistsError
‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’	二进制文件模式
‘t’	文本文件模式，默认值
‘+’	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

• 打开模式使用字符串方式表示
• 文件使用结束后要用close()方法关闭，释放文件的使用授权

<变量名>.close()

文件的读写

• 当文件以文本文件方式打开时，读写按照字符串方式，采用当前计算机使用的编码或指定编码
• 当文件以二进制文件方式打开时，读写按照字节流方式

文件内容读取方法

操作方法	含义
.readall()	读入整个文件内容，返回一个字符串或字节流
.read(size=-1)	从文件中读入整个文件内容，如果给出参数，读入前size长度的字符串或字节流
.readline(size=-1)	从文件中读入一行内容，如果给出参数，读入该行前size长度的字符串或字节流
.readlines(hint=-1)	从文件中读入所有行，以没行为元素形成一个列表，如果给出参数，读入hint行

备注：返回字符串或字节流取决于文件打开模式

#逐行读入内容到内存有利于优化程序执行速度
fname=input('请输入要打开的文本文件')
fo=open(fname,'r')
for line in fo:#处理一行数据
    print(line)
fo.close

文件内容写入方法

方法	含义
.write(s)	向文件写入一个字符串或字节流
.writelines(lines)	将一个元素全为字符串的列表写入文件
.seek(offset)	改变当前文件操作指针的位置，offset的值：0——文件开头；1——当前位置；2——文件结尾

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

数据组织的维度

• 一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应数学中的数组和集合等概念
  无论采用任何方式分隔和表示，一维数据都具有线性特点
• 二维数据也称表格数据，由关联关系数据构成，采用表格方式组织，对应数学中的矩阵
• 高维数据由键值对类型的数据构成，采用对象方式组织，属于整合度更好的数据组织方式
  高维数据相比一维和二维数据能表达更加灵活和复杂的数据关系

---

对于数据处理，需要考虑存储格式以及表示和读写两个问题

---

一二维数据的存储格式

• 一维数据是最简单的数据组织类型，常用空格、逗号以及其他符号或符号组合分隔
• 二维数据由多条一维数据构成，可以看做是一维数据的组合形式
  逗号分隔数值的存储格式叫做CSV（Comma-Separated Values,逗号分隔值）格式，它是一种通用的、相对简单的文件格式，尤其应用在程序之间转移表格数据

CSV格式应用基本规则

1. 纯文本格式，通过单一编码表示字符
2. 以行为单位，开头不留空行，行之间没有空行
3. 每行表示一个一维数据，多行表示二维数据
4. 以逗号（英文，半角）分隔每列数据，数据列为空也要保留逗号
5. 对于表格数据，可以包含或不包含列名，包含时列名放置在文件第一行

一二维数据的表示和读写

• CSV文件的每一行是一维数据，可以使用Python中的列表类型表示
• 整个CSV文件是一个二维数据，由表示每一行的列表类型作为元素，组成一个二维列表

1.csv :
列1,列2,列3,列4,列5
1,1,1,1,1
2,2,2,2,2
3,3,3,3,3
4,4,4,4,4
5,5,5,5,5

---

导入CSV格式数据到列表

fo=open('1.csv','r')
ls=[]
for line in fo:
    line=line.replace('\n','')
    ls.append(line.split(','))  #  以split(',')方法从CSV文件中获得内容时，每行最后一个元素后面包含了一个换行符('\n')，应去掉。
print(ls)
fo.close()
>>>
[ ['列1', '列2', '列3', '列4', '列5'], ['1', '1', '1', '1', '1'], ['2', '2', '2', '2', '2'], ['3', '3', '3', '3', '3'], ['4', '4', '4', '4', '4'], ['5', '5', '5', '5', '5'] ]

---

逐行处理CSV格式数据

fo=open('1.csv','r')
ls=[]
for line in fo:
    line=line.replace('\n','')
    ls=line.split(',')
    ins=''
    for s in ls:
        ins+='{}\t'.format(s)
    print(ins)
fo.close()
>>>
列1  列2  列3  列4  列5  
1   1   1   1   1   
2   2   2   2   2   
3   3   3   3   3   
4   4   4   4   4   
5   5   5   5   5

---

一维数据写入CSV文件

• 对于Python列表变量保存一维数据结果，可以用字符串的join()方法组成逗号分隔形式在通过文件的write()方法存储到CSV文件中

fo=open('1.csv','a')
ls=['6','6','6','6','6']
fo.write(','.join(ls)+'\n')
fo.close()

---

二维数据写入CSV文件

fr=open('1.csv','r',encoding='UTF-8')
fw=open('2.csv','w',encoding='UTF-8')
ls=[]
for line in fr:  #将CSV文件中的二维数据读入到列表变量
    line=line.replace('\n','')
    ls.append(line.split(','))
for i in range(len(ls)):  #遍历列表变量
    if i==0:  #跳过第一行列名
        continue
    for j in range(len(ls[i])):
        ls[i][j]=str(int(ls[i][j])*2)
for row in ls:  #将列表变量输出到CSV文件
    print(row)
    fw.write(','.join(row)+'\n')
fr.close()
fw.close()
'''注意事项
1.UnicodeDecodeError: 'gbk' codec can't decode byte...在open()最后添加“encoding='UTF-8'”
2.line.replace('\n','')，换行符是“\n”而不是“n”——注意不要打错符号
3.ls.append(line.split(','))，split(',')而不是split('')——注意不要打错符号
4.ls[i][j]=str(int(ls[i][j])*2)，注意列表中嵌套列表情况下的索引；注意“ls[i][j]”类型为str
5.",".join(row)生成一个新的字符串，它由字符串“,”分隔列表row中的元素形成
6.fr.close()，注意close()方法后要有括号“()”
'''

7.5 CSV格式的HTML展示

HTML（HyperText Markup Language）超文本标记语言，本质上是键值对的标记，它采用value的方式表达键key对应的值value。

将CSV文件转换成HTML文件分3步骤：

1. 读入CSV文件，获得文件数据
2. 对数据进行格式化处理和转换
3. 输出HTML格式文件

7.6 高维数据的格式化

键值对是高维数据的特征

• 高维数据能展示数据间更为复杂的组织关系，为了保持灵活性，高维数据不采用任何结构形式，仅采用最基本的二元关系，即键值对
  JSON（JavaScript Objct Notation）是一种轻量级的数据交换格式，可以对高维数据进行表达和存储

JSON格式表达键值对的基本格式："key":"value"
多个键值对放在一起的规则

1. 数据保存在键值对中
2. 键值对之间由逗号分隔
3. 大括号用于保存键值对数据组成的对象
4. 中括号用于保存键值对数据组成的数组

• 采用对象、数组方式组织起来的键值对可以表示任何结构的数据

7.7 json库的使用

• json库主要包括两类函数，操作类函数和解析类函数
• 操作类函数主要完成外部JSON格式和程序内部数据类型之间的转换功能
• 解析类函数主要用于解析键值对内容
• json格式包括对象和数组
• 对象用大括号({})表示，对应键值对的组合关系（被json库解析为字典）
• 数组用中括号({})表示，对应键值对的对等关系（被json库解析为列表）

json库解析

• json库包含编码（encoding）和解码（decoding）两个过程
• 编码将Python数据类型变换成JSON格式
• 解码是从JSON格式中解析数据对应到Python数据类型的过程
  json库的操作类函数

函数	描述
json.dumps(obj,sort_keys=Flase,indent=None)	将Python的数据类型转换为JSON格式，编码过程
json.loads(string)	将JSON格式字符串转换为Python的数据类型，解码过程
json.dump(obj,fp，sort_keys=Flase,indent=None)	与dumps()功能一致，输出到文件fp
json.load(fp)	与loads()功能一致，从文件fp读入

• json.dumps()中的obj可以是Python的列表或字典类型，当输入字典类型时，dumps()函数将其变为JSON格式字符串
• 默认生成的字符串是顺序存放的，sort_keys可以对字典元素按照key进行排序控制输出结果
• indent参数用于增加数据缩进，使得生成的JSON格式字符串更具可读性

7.8 CSV和JSON格式相互转换

将CSV格式转换成JSON格式

import json
fr=open('1.csv','r',encoding='UTF-8')
ls=[]
for line in fr:
    line=line.replace('\n','')
    ls.append(line.split(','))
fr.close()
fw=open('1.json','w')
for i in range(1,len(ls)):
    ls[i]=dict(zip(ls[0],ls[i]))  #zip()将两个长度相同的列表组合成一个关系对
json.dump(ls[1:],fw,sort_keys=True,indent=4,ensure_ascii=False)
fw.close()
'''
ls[1:] 表示列表第2项到最后一项
ensure_ascii=False 使json库输出中文呢字符
'''

将JSON格式转换成CSV格式

import json
fr=open('1.json','r')
ls=json.load(fr)
data=[list(ls[0].keys())]  #ls[0].keys()返回所有的键信息
for item in ls:
    data.append(list(item.values()))  #item.values()返回所有的值信息
fr.close()
fw=open('1-1.csv','w')
for item in data:
    fw.write(','.join(item)+'\n')
fw.close()