组合数据类型

集合类型

集合与Java中的集合定义相同，都是组合的数据类型，将数据以某种方式进行存储，可以是链表（LinkedList），可以是数组（ArrayList），可以是哈希表（HashMap），可以是堆（PriorityQueue）。

在Python中，集合类型与数学上的集合概念一致，集合元素之间无序，唯一，不可重复 ， 并且集合中的元素不能被修改，不能是可变的数据类型！
因为如果集合类型中的数据可以被改变，在定义的时候，集合的元素是：1，2，3，4，5. 没有问题，但是如果把1 改为2 ，那么这个就不是一个集合了！

不可变数据类型：整形，浮点型，复数，字符串，元组等等，都是不可变类型

集合用 {} 表示，元素之间用逗号分隔
建立集合类型用 {} 或者 set()
(使用空集合必须用set())

#("python",123) 是一个元组
#用{}建立集合
A = {"python",123,("python",123)}
# A集合的元素，就是 {123，"python",("python",123)}# 用set() 建立集合
B = set("pytpyt123")
# B 集合的元素，是 “p”，1，“y”，3，“t”，2，
#因为字符串中pty 都是重复的，所以会直接去重，与Java中的HashSet是一样的，并且无序
#其实使用括号，也会有去重的效果

集合特性：用{} 或者set 去定义，元素用 ， 分隔；唯一，无序，不可改变

集合之间的运算

交 并 差 补 这四种运算是集合中一定有的

A = {1,2,3,4}
B = {2,3,5,"a","b"}#并集
print(A|B)
# 包含在A ，但不包含在B 的差集
print(A-B)
# 交集
print(A&B)
# 返回A 和 B 中不相同的元素
print(A^B)
# 返回True / False 判断A 和 B 的子集关系S = {1,2,3}
T={1,2}
print(S <= T)
print(S < T)
# 判断A 和 B 的包含关系
print(S >= T)
print(S > T)

结果：

增强操作符

除了交集 并集的操作，还有四种增强操作符，来更新集合

C = {1,2,3,4,6}
D = {2,3,7,8}
C |= D
print(C)
#结果: 1, 2, 3, 4, 6, 7, 8

集合的十大方法

S.add(x) :向集合S 中添加 x 元素

S.discard(x) ：删除集合S 中 x 元素，如果x 不存在，不会报错

S.remove(x) :删除S集合中的 x 元素，如果x不存在，产生 keyError 的异常

S.clear() : 清空集合S

S.pop()：随机拿出一个元素，并且更新集合，将此元素删除，如果S集合为空，就会产生KeyError异常

S.copy() ：返回S 的一个副本

len(S) : 返回集合S 的个数

x in S : 判断 x 是否在S 中，如果在返回True，否则返回False

x not in S : 判断 x 不在S 中， 如果不在，那么返回True，否则返回False

set(x) ： 将 x 转为集合类型

遍历集合元素：

for item in A:print(item,end=",")

应用场景

1.包含关系的比较
判断一个数据是否在整个集合中，或者一组数组是否在一个集合中。

#1.判断单个元素
"p" in {"p","y",123}
#结果True#2.判断一组数据
# >=  前一个集合是否包含 后一个集合
{"p","y"} >= {"p","y",123}
#结果 False

2.数据去重
相信学过Java的一定有整个印象，如果要对一个集合进行去重，直接放到HashSet中就行了 。
而python的集合本身就具备整个特性，所以如果我们有一组数据，要进行去重，直接使用 set（）函数，将它转为集合就可以了。

#定义一个列表，有重复的数据
a = [1,2,3,4,4,4,4,5,3]
A = set(a)
print(A)
#结果：{1，2，3，4，5}
# 如果还想将它以列表的方式去操作
#使用list() 即可
IS = list(A)
print(IS)
#结果: [1，2，3，4，5]

---

序列类型及操作

序列类型的定义

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

可以理解为序列是一维元素向量，元素类型可以不同（可以对应Java中的ArrayList，但是序列类型的底层不是数组，后续的高级学习中，我会尽量的去找python关于解释器层面的知识，理解并学习）

序列是一个基类类型，也就是基本数据类型。但是一般使用的时候并不会使用序列类型，而是使用衍生的类型，字符串类型，元组类型，列表类型。
这三个类型都是序列类型的衍生，序列操作的对于这三个都是适用的，我们可以这样理解，序列类型，相当于一个父接口，而字符串，元组，列表，都是它的具体实现子类，子类总是比父类更强大的，所以也具备自己独特的操作。

序列类型的典型操作，索引，正向与反向的索引，对于这三个类型都是通用的。

序列类型的通用操作符

x in s ：如果 x 是序列 s 的元素，返回True，否则返回False

x not in s : 如果 x 不是序列 s 的元素，返回False，否则返回True

s + t : 连接两个序列 s 和 t ，返回一个新的序列（s+=t 也可以使用，将s + t 的列表直接返回s）

s*n 或者 n*s : 将序列 s 赋值 n 次

s[i]：返回 s列表中 i 号索引的元素

s[i:j] 或者s[i:j:k] :切片，返回s序列中 第 i 到 j 以k为步长的子序列（[ i ,j ）左闭右开区间 ）

另外的取反
ls[::-1] 或者 strs[::-1] 都是对整个序列进行取反

5个序列通用方法：

len(s) :返回序列 s 的长度

min(s) ：返回序列 s 中的最小值 ，序列中的元素一定要可比较，否则直接抛出异常

max(s) ： 返回序列 s 中的最大值

s.index(x) 或者 s.index(x,i,j) 返回序列 s 从i 开始到 j 位置中，第一次出现元素x 的位置

s.count(x) 返回序列中出现 x 的总次数

元组类型的定义和操作

元组是序列类型的扩展，元组一旦被创建则不能被修改。
使用小括号（） 或者 tuple() 创建， 元素之间用 逗号 分隔。
可以使用也可以不使用小括号
之前我们返回多组数据，也就是 return x，y 实际上就是返回的一个元组

元组类型的元素可以是元组类型。
例如

crearture = "cat" , "dog" , "tiger" ,"human"
print(creature)
#结果 ( "cat" , "dog" , "tiger" ,"human")color = (0x001100,"blue",creature)
print(color)
# 结果(4352，“blue”，( "cat" , "dog" , "tiger" ,"human"))

元组类型就是将元素进行简单排列，并且用小括号来组织

列表类型的定义和操作

列表是序列类型的一个扩展，与元组类型非常相似，经常被使用。

使用方括号 【】 或者 list() 来创建，元素间用逗号 分隔。
列表中元素类型可以不想通过，没有长度限制

ls = ["cat","dog",1024]
print(ls)
#结果: ["cat","dog",1024]lt = ls
print(lt)
#结果: ["cat","dog",1024]

在这里要注意，如果是直接以等号相连的两个列表，实际上是对【“cat”,“dog”,1024】 进行了浅拷贝，也就是现在又另一个引用来引用整个列表，用lt 也能对 ls 进行改变，也就是引用的是同一个内存地址

常用的操作函数和方法

ls[i] = x : 替换列表 ls 第 i 个元素为 x

ls[i:j:k] = it : 用列表lt 替换 ls 切片后所对应元素子列表也就是将ls 先进行切片，把【i,j) 给拿出来，然后重新赋值为 lt

del ls[i] : 删除列表中 ls 中 第 i 个元素

del ls[i：j：k] ：删除列表 ls 中【i，j） 中以K为步长的元素

ls += lt :更新ls 列表，将 lt 添加到 ls 的尾部

ls *= n ： 更新列表ls ，其元素重复n 次

ls.append(x) : 在列表的最后增加一个元素x

ls.clear() : 将列表清空

ls.copy() : 生成一个新的列表，赋值为ls 的所有元素

ls.insert(i,x) :在列表ls 的第 i 位置增加元素x

ls.pop(i) ：取出列表 ls 中的第 i 号下标元素

ls.remove(x) : 将列表ls 中出现的第一个元素 x 删除

ls.reverse() : 将列表中的元素进行反转

序列类型的应用场景

1.数据表示
表示一组有序的数据，进而进行操作，就可以是用列表。
如果作为多个返回值，那么就使用元组。

有了这些表示之后，就很容易的进行遍历。

2.数据保护
如果不希望程序对某些数据进行修改，直接转换为元组类型即可。

ls = ["cat","dog","tiger",1024]
lt = tuple(ls)
print(lt)
#结果 ： ("cat","dog","tiger",1024)

如此以来这些元素就变得不可更改了

练习：基本统计值计算

总个数：len()
求和 for in
平均值，求和 / 平均值
方差：各数据与平均数差的平方的和的平均值
中位数：排序之后，元素个数为奇数，就找最中间，为偶数个，找中间两个取平均

#先获取用户的输入
def getNum():nums = []iNumstr = input("请输入数字(回车退出)")while iNumstr != "":nums.append(eval(iNumstr))iNumstr = input("请输入数字(回车退出)")return nums
#求平均值
def mean(numbers):s = 0.0for item in numbers:s+=itemreturn s/len(numbers)#求方差
def dev(numbers,mean):#mean 代表平均值sdev = 0.0for num in numbers:sdev += (num - mean)**2return pow(sdev/(len(numbers)-1) , 0.5 )#计算中位数
def median(numbers):#需要使用到排序函数sortnumbers = sorted(numbers)size = len(numbers)#如果为偶数if size %2 == 0 :med = (numbers[size//2 -1] + numbers[size//2])/2else:med = numbers[size//2]return medn = getNum()
m = mean(n)
print("平均值：{} ，方差：{:.2f}， 中位数:{}".format(m,dev(n,m),median(n)))

字典类型及操作

字典类型的定义

字典存储的是一种键值对，也就是 K- V ,一个 Key - > Value 这是一个唯一关系，通过这Key 可以唯一获得整个Value。（类似HashMap）
存储的顺序是无序的。
采用带括号{} 和 dict（） 创建，键值对用冒号表示

#字典A 
A = {1:"a", 2:"b", 3:"c"}

获得 1 - > “a”

res = A[1]

修改1 ->“a” 为 1-》“x”

A[1] = "x"

生成空字典：

A = {} 

向字典中添加数据：

d = {}
# 添加 “k”  -》 “v”
d["k"] = "v"
# 添加 “k2”  -》 “v2”
d["k2"] = "v2"

字典操作函数

del d[k] ：删除字典 d 中的k 所对应的数据值

k in d : 判断键 k 是否在字典d 中，如果在，返回True，否则返回False

d.keys() :返回所有的 Key，类型为Key所对应的类型，可以用for in 来遍历，但是不能当作列表类型来操作

d.values() ：返回字典 d 中所有的Value，返回的是所有的

d.items() ：返回字典 d 中所有的键值对

d.get(k,<default>)：如果 字典 d 中存在 k 整个Key，那么就返回对应Value，否则返回default

d.pop(k,<default>) ：键 k 存在 ，则取出对应的值，否则，返回default

d.popitem() : 随机从字典中取出一个键值对，以元组的形式返回

d.clear() : 删除所有的键值对

len(d): 返回字典d 中元素的个数

遍历整个字典

d ={1 : "a" , 2:"b"}
for k in d:print(d.get(k))#或者print(d[k])#结果：
#a
#b

字典的应用场景

映射的表达
映射无处不在，假如这个字段存储的是人与电脑型号的关系，那么就可以是 人 -》电脑。如果是数据出现的次数，数据 -》 出现的次数
最主要的就是这种表达这种映射数据并且操作。

jieba库的使用

jieba 是优秀的中文分词第三方库。
中文文本需要通过分词来获得单个词语，jieba提供了三种分词模式，最简单只需要掌握一个函数，简单有效。

安装: 打开cmd 终端，输入: pip install jieba

简单来说jieba库是通过中文词库的方式来识别分词的。
汉字见概率大的组成分词，形成分词结果

jieba简单使用：

jieba 有三种模式： 精确模式，全模式，搜索引擎模式

精确模式： 把文本精确的切分开，不存在冗余单词

全模式：把文本中所有可能的词语都扫描出来，有冗余

搜索引擎模式：在精确模式的基础上，对长的词语再次进行切分，切分成短的词语

函数就只有4个：

本质上就一个函数，jieba.lcut(str)

练习：文本词频统计

需求：一篇文章，出现了哪些词？哪些词出现的最多？

文本是中文还是中文呢？？

两个都做一下吧，作为测试用例，所以我们需要中文文本和英文文本的资源

英文《哈姆雷特》
中文《三国演义》

哈姆雷特词频统计：1.先对单词进行划分，将文章划分为一个一个的单词，然后进行统计处理

#哈姆雷特词频统计
#第一步，先打开文件 ,进行预处理
def getText():txt = open("hamlet.txt","r").read()#先将大小写统一txt = txt.lower()#使用空格替换 文本中的特殊符号for ch in '!"#$%&()*+,./:;<=>@[\\]^_{|}~':txt = txt.replace(ch," ")return txt
hamleTxt = getText()
#以空格为间隔，分割成一个列表
words = hamleTxt.split()
#定义一个字典，来统计词以及出现次数的映射
counts = {}
#遍历这段文本，如果在字典中存在整个词，那么就将它的次数对应+1
#如果不在，那么就添加
for word in words:counts[word] = counts.get(word,0)+1
#把字典变为列表，方便我们操作
items = list(counts.items())
# 排序的Key 就是 出现的次数，也就是每一个列表元素的第二个值
#默认排序是从小到大，那么reverse 为 True 就是从大到小了
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))

结果：

三国演义人物出场次数对比。
首先，我们要对中文进行分词，所以需要用到 jieba 库。

import jieba
#先打开文件， 编码格式为UTF-8，将整个文件读取
txt = open("ThreeKingdoms.txt","r",encoding="utf-8").read()
#使用精确模式将文本进行分词
words = jieba.lcut(txt)
#使用字典保存 人物- 》 出现的次数
counts = {}
for word in words:#人名最少2个字，所以当字符的长度为1时直接跳过if len(word) == 1:continueelse:counts[word] = counts.get(word,0)+1
items = list(counts.items())
items.sort(key = lambda x : x[1],reverse=True)
for i in range(15):word,count = items[i]print("{0:<10}{1:>5}".format(word,count))

结果:

可以看出来，将军，却说，玄德曰，他们要么不是人名，要么因为分词的原因重复了人名。
所以我们要对他进行修改。
很简单，面向问题分析一下，不断地运行代码，我们直接将将军，却说，荆州，二人这些经常出现，但不是人名的这些词做一个汇总，词频统计之后，将这些词直接删除即可。
第二个问题就是重名，这个也是需要测试，不断地看前几名那些是很容易重名的，我们将人物相同，称谓不同的词进行整合。

import jieba
#首先打开文件
txt = open("ThreeKingdoms.txt",encoding= "utf-8").read()
#使用jieba 进行分词
words = jieba.lcut(txt)
#经常出现的非人名词
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
#定义一个字典 保存 人名 - 》 出场次数
counts = {}
#遍历words，
for word in words:#如果words[i]的长度为1 ，那么不是人名，跳过if len(word) ==1 : continue#将同一个人不同称谓的人进行一个汇总#把 word 看作 rword 去统计elif word == "诸葛亮" or word == "孔明曰":rword = "孔明"elif word == "关公" or word == "云长":rword = "关羽"elif word == "玄德" or word == "玄德曰":rword = "刘备"elif word == "孟德" or word == "丞相":rword = "曹操"else:rword = wordcounts[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 , counts = items[i]print("{:<10}{:>5}".format(word,counts))

结果：

还是有一些非人名的词汇，我们再加一些要排除的词。经过不断的测试
最后要排除的词有：

excludes = {"将军","却说","荆州","二人","不可","不能","如此","商议","如何"\,"主公","军士","引兵","左右","军马","次日","大喜","东吴","天下"\,"于是","今日","不敢","魏兵","陛下","一人","都督","人马","不知"}

结果：

练习：数字不同数之和

s = set(input())
res = 0
for item in s:res+=eval(item)
print(res)

练习人名最多统计

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''d = {}
s = s.split()
for ch in s:d[ch] = d.get(ch,0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1],reverse = True)
print(ls[0][0])##或者这样处理
ls = s.split()
d = {}
for i in ls:d[i] = d.get(i, 0) + 1
max_name, max_cnt = "", 0
for k in d:if d[k] > max_cnt:max_name, max_cnt = k, d[k]
print(max_name)

文件与数据格式化

先了解一下什么是格式化。
前面我们了解过字符串格式化，对字符串的输出形式惊醒一定规格和样式的规范。
数据格式化，就是将一组数据，按照一定的规格和样式进行规范，表示，存储，运算等等

文件的使用

文件类型：文件时数据的抽象和集合，文件本质上就是二进制集合，它用来表示一组数据，而这组数据并不是运行在内存上，而是存储到了磁盘上，他有不同的展示形态，一般我们把他看成，文本文件和二进制文件。我们可以将文本文件，以字符为单位进行处理，这样会提高我们的效率，将二进制文件以字节的方式进行处理。

文本文件简单定义：由单一特定编码组成的文件，如UTF-8 ，GBK 等等，文件名后缀常为 txt
二进制文件 ： 直接由比特0和1 进行组织结构，即文件格式，文件名后缀非常多，.png , .avi 都是二进制文件

文件的读写操作：
首先我们将字符串： “中国是个伟大的国家” 保存为一个txt文件（在对应的目录下，因为我的程序中大多用的是相对路径不是绝对路径）

打开文件

#打开文件，以文本的形式打开，编码为utf-8
tf = open("f.txt","rt",encoding="utf-8")
#读出一行
print(tf.readline())
#关闭这个文件资源
tf.close()#打开文件，以二进制的形式打开
bf = open("f.txt","rb")
#读出一行
print(bf.readline())
#关闭资源
bf.close()

以上是简单的文件打开和关闭操作。
打开文件：f = open(<文件名>，<打开模式> ) 文件名，可以是绝对路径，也可以是相对路径，打开模式，也就是规定权限，读 或者 写，或者读写，函数最后返回一个文件句柄。
（这里的路径要注意一下，由于 \ 在python中是转移符，所以我们在写路径时，要么把 \ 替换为 / ,要么，把 \ 替换为 \ ）

打开模式：
r : 只读模式 ，是默认值，如果文件不存在，抛出FileNotFoundError 异常

w : 覆盖写模式，文件如果不存在，自动创建，如果存在，则从最初的位置进行覆盖写

x : 创建写模式，文件不存在，自动创建，如果存在，抛出 FileExistsError 异常

a : 追加写模式，文件不存在，自动创建 ，存在，就在文件的尾部进行追加写

b : 以二进制的方式打开文件，将文件规范为二进制

t : 以文本的方式进行打开，默认值，将文件规范为文本

+： 与r / w / x / a 一同使用，在原功能基础上增加同时读写功能

关闭文件：f.close()

读文件，主要使用三个方法。
f.read(size) :读出全部内容，如果size 给定了参数，那么就读出 size 长度

f.readline(size) :读入一行的内容，如果给定参数，那么就读取这一行中前 size 个字符

f.readlines(hint) : 读出所有行，如果给定了参数，那么就读取前 size 行

那么会了读操作，我们就可以遍历全文本了。

#方法1 : 一次读入，统一处理
#操作简单直接
fname = input("请输入要打开的文件路径")
#打开，并且权限为只读
fo = open(fname,"r")
#读取全部内容
txt = fo.read()
#对全文 txt 进行处理
#关闭文件资源
fo.close()

#方法二 分批次，多次处理
fname = input("请输入要打开的文件路径")
fo = open(fname,"r")
#一次只处理两个字节
txt = fo.read(2)
while txt != "":##对txt 进行处理txt = fo.read(2)
fo.close()

#方法3：一次读入，分行处理
fname = input("请输入要打开的文件路径")
fo = open(fname,"r")
#对所有行进行遍历
for line in fo.readlines():print(line)
fo.close()

#方法4 ， 逐行读取，逐行处理
fname = input("请输入要打开的文件路径")
fo = open(fname,"r")
for line in fo:print(line)
fo.close()

同样写文件也有两个方法，一个辅助函数：

f.write(s) : 向文件直接写入一个字符串 s 或者字节流 s

f.writelines(lines) : 将一个元素全为字符串的列表写入文件，这里的 lines 是一个列表，将列表中的字符串，挨个写入到文件中，元素与元素之间，没有换行，也没有空格。

f.seek(offset) :改变当前文件指针的位置的函数，offset 就是当前文件指针的位置，seek(0) 指针回到文件开头，seek（1） 返回当前位置，seek（2）将指针移动到文件结尾

小练习:

#打开一个outopt.txt 文件，
# 权限为w+ 也就是写模式增强，让它具备读的能力
fo = open("output.txt","w+")
ls = ["我","好","帅"]
fo.writelines(ls)
#此时文件的指针移动到了文件的末尾
#使用seek将文件指针指向文件最开始的
#读取文件的每一行
for line in fo:print(line)
#所以不会打印任何信息
fo.close()

#我们对上面的代码进行修改
fo = open("output.txt","w+")
ls = ["我","好","帅"]
fo.writelines(ls)
#此时文件的指针移动到了文件的末尾
#使用seek函数将指针移动到文件开始的位置
fo.seek(0)
#读取文件的每一行
for line in fo:print(line)
fo.close()

自动轨迹绘制

准确来说整个需求就是根据脚本来绘制图形，并不是由写代码的方式去绘制图形，之前使用turtle库去绘制贪吃蛇，年月日的展示也好，都只是用代码去绘制。
自动化的第一步就是数据脚本！

上面的图片上就是我们要做到的，给出一些数据参数，它只是一个参数，就可以自动的绘制图形。

步骤1：定义数据文件格式（通常称位接口，就是文件和数据之间的一种规范）
步骤2：编写程序，根据文件接口解析参数绘制图形
步骤3：编制数据文件

定义数据文件格式和接口，完全是一种个性化的设计，并没有什么规范。
这里给出简单的接口，用一行数据表示一次操作

我们将绘制的图形保存为这样的绘制格式

#data.txt: 这里有个天坑，数据有多少行，就写多少行，不要有空行！不要有空行 ！不要有空行！
300, 0,144,1,0,0
300,0,144,0,1,0
300,0,144,0,0,1 
300, 0,144,1,1,0
300,0,108,0,1,1
184, 0,72,1,0,1
184,0,72,0,0,0
184,0,72,0,0,0
184,0,72,0,0,0 
184,1,72,1,0,1
184,1,72,0,0,0
184,1,72,0,0,0
184,1,72,0,0,0
184,1,72,0,0,0
184,1,720,0,0,0 

import turtle as t
#标题，也就是窗口的标题
t.title("自动轨迹绘制")
t.setup(800,600,0,0)
t.pencolor("red")
t.pensize(5)
#使用列表来存储每一行的数据
data = []
#打开文件读取所有的数据
f = open("data.txt",encoding="utf-8")
for line in f:#将每一行的换行字符去除line = line.replace("\n","")#map : 内置函数 将第一个参数， 作用于第二个参数的每一个元素#简单来说，就是line.split分割之后，形成的是一个列表#对列表的每一个元素，都执行eval#最后将这个列表添加到data整个列表中，当作一个元素使用current = list( map( eval,line.split(",") ) )data.append(current)
f.close()#遍历列表
for i in range(len(data)):#设置画笔颜色，将列表中的颜色对应数据读取t.pencolor(data[i][3],data[i][4],data[i][5])t.fd(data[i][0])## 如果第二个参数位1 也就是向右转if data[i][1]:t.right(data[i][2])##否则向左转else :t.left(data[i][2])
t.done()

结果：

自动化思维：数据和功能分离，数据驱动的自动运行。例如我们这里的功能就是要绘制图形，我们使用一行数据，来驱动代码的自动完成，这就是数据驱动。

接口化设计：格式化设计接口，清晰明了

二维数据应用：应用维度组织类型，二维数据最常用（简单来说二维数组）

扩展接口设计，天界更多的控制接口
扩展功能设计，增加弧形等更多的功能
扩展应用需求，发展自动轨迹绘制到动画绘制

一维数据格式化和处理

数据组织的维度

一个数据表达一个含义，一组数据表示多个含义
一维数据：由对等关系的有序或无序数据构成的，采用线性方式组织
二维数据：有多个一维数据构成
多维数据，多个一维数据组成的数据

高维数据：

一维数据的表示

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

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

数据之间没有顺序，就用字典去表达

一维数据的存储

采用标点，空格进行分割，但是缺点就是数据不能有空格，标点，所以一般来说采用特殊字符来分割数据进行存储。

a$b$c$d
实际数据 ： a b c d

一维数据的处理

实际上就是将文件中的一维数据类型，转为程序中的列表，或者字典来进行操作。

读入：

写入：

join：将join 前的那个字符串，添加到后面那个数据的每一个元素后面。

二维数据格式化和处理

二维数据的表示

二维数据同样，我们也可以用列表类型来表达。
使用的是二维列表，也就是列表中过的元素，又是一个列表。

CSV数据存储格式

CSV: Comma-Separated Values
简单来说就是用 ， 分割值的一种方式。国际通用的一二维数据存储格式，一般以 .csv 为扩展名
每行一个以为数据，采用 ， 分隔

二维数据的处理

从CSV格式的文件中读入数据

fo = open(fname)
ls = []
for line in fo:line = line.split("\n","")ls.append(line.split(","))
fo.close()

将数据写入CSV格式的文件

ls = [[],[],[]] 
f = open(fanme,"w")
for item in ls:f.write(",".join(item)+"\n")
f.close()

遍历二维数据

ls = [[1,2,3],[4,5,6],[7,8,9]]
for row in ls:for col in row:print(col)

wordcloud库的使用

wordcloud 是非常优秀的词云展示第三方库

就是将词语为基本单位，更加直观和以数的展示文本

安装： 打开终端，输入pip install wordcloud

使用说明

wordclod.WordCloud()代表一个文本对应的词云，一个文本对应一个词云，一个词云对应一个对象，有关于这个词云的形状，尺寸，颜色都可以进行设定。

常用方法：
w = wordcloud.WordCloud() ：生成一个词云对象w

w.generate(txt):向WordCloud 对象中加载文本txt。

w.to_file(filename) ： 将词云输出为图形文件， .png 或者 .jpg 格式 filename = xxx.jpg 或者 xxx.png

参数：
width :wordcloud.WordCloud(width = 600) 将生成的图片文件的宽度设置为600像素（默认是400像素）

height ：wordcloud.WordCloud(height = 400) 将生成的图片文件的宽度设置为400像素（默认是200像素）

min_font_size : 指定词云中最小的字号，默认为4号。wordcloud.WordCloud(min_font_size=10) 设置最小字号为10

max_font_size：指定次允中字体的最大字号，根据高度自动调节 wordcloud.WordCloud(max_font_size = 20) 设置最大字号为20

font_step ：指定词云中字体i找的步进间隔，从最小字号到最大字号，也就是对文本出现次数的大小排名，第二名和第一名之间字体大小的差距，就是步进。

font_path : 指定字体文件的路径，默认None， wordcloud.WordCloud(font_path = “xx.ttc”) 就是指定词云的字体，字体文件为xx.ttc

max_words : 指定词云的最大词的数量，默认为200。 wordcloud.WordCloud(max_words=20)设置最大单词数量为20

stop_words : 指定词云不显示的词的集合， wordcloud.WordCloud(stop_words={“python”})，执行词云不显示 词，python

mask :指定词云形状为mask 。 mask 的使用： 1. 导入一个函数imread ：from scipy.misc import imread
2. 指定词云的形状 mk = imread(“pic.png”) 3.传入WordCloud参数

background_color : 指定词云的背景颜色，默认为黑色。 wordcloud.WordCloud(background_color = “white”) 设置词云北京为白色

绘制一个词云，主要有三个步骤
1.配置对象参数
2.加载词云文本
3.输出词云文件

举个例子：

import wordcloud
#生成一个词云对象
w = wordcloud.WordCloud()
#向词云中添加文本
w.generate("python and WordCloud")
#生成图片文件
w.to_file("pythonWordCloud.png")

中文实例：

中文需要分词，组成空格分隔的字符串再导入词云对象中。

那么从文本生成词云，wordcloud做了哪些事？

1.分隔，以空格为单位分隔单词
2.统计，单词出现的次数并过滤，出现次数多的单词，显示的就会比较大，出现次数少的，显示的就比较小。并且将只有1 - 2 个字母和字符组成的单词直接过滤，不进行显示
3.配置字体，根据统计的清空配置字号
4.进行布局，根据颜色环境布局尺寸

练习 政府工作报告词云

需求：直观理解政策文件。
需求，对于政府工作报告等政策文件，如何直观理解？
体会直观的价值：生成词云&优化词云

报告：新时代中国特色社会主义
关于实施乡村振兴战略的意见

政府工作报告词云你的基本思路
步骤1：读取文件，分词整理
步骤2：设置并输出词云
步骤3：观察

import jieba
import wordcloud
#把文件打开，权限为只读
f = open("新时代中国特色社会主义.txt","r",encoding="utf-8")
#因为文本不算非常巨大，可以直接全部读入
t = f.read()
f.close()
#进行分词
ls = jieba.lcut(t)
#将空格加入到分词的间隔中
txt = " ".join(ls)
#导入到WordCloud 对象中
w = wordcloud.WordCloud(width = 1000, height = 700,backgroud_color = "white")

如果想将词云设置为指定的形状，那么就使用 imread（文件） 这个图片文件，必须是白色背景

练习：

文本平均列数

f  = open("latex.log")
#统计行
rows = 0
#统计列
col = 0
for line in f:#先去除换行line = line.strip("\n")#统计有效行if line != "":rows+=1col += len(line)
f.close()
res = col / rows
print(int(round(res,0)))

CSV格式清洗与替换

f = open("data.csv")
#先按行读取添加到列表中
ls = []
for line in f:line = line.strip("\n")#先把逗号替换为分号line = line.replace(",",";")#将空格替换line = line.replace(" ","")#逆置line = line[::-1]ls.append(line)
f.close()
#将列表逆序输出for i in range(len(ls)):print(ls[len(ls)-i-1])