能够训练思维：
题目本身简单，但学会这种思维，其他常见的"转换"问题解决方法同理。
程序的格式框架
命名与保留字
import keyword
print(keyword.kwlist)
数据类型
补充
法（1）索引：返回字符串中单个字符 <字符串>[M] ,如TempStr[0]为串的第0个字符，TempStr[-1]为串的最后一个字符
法（2）切片：返回字符串中子串 <字符串>[M:N]， 注意子串是第M个字符开始到第N个之前的字符（不包含第N个字符）
是去掉参数最外侧引号并执行余下语句的函数，引号不区分单引号’ '和双引号" "
如：eval(“1”)执行结果为1；eval(’“1+2”’)执行结果为’1+2’；eval(‘print(“Hello”)’)执行print(“Hello”)语句，结果为Hello
语句与函数
赋值语句
分支语句
函数
例子
1946-1981：计算机系统结构时代（35年）：
1981-2008：网络和视窗时代（27年）
2008-2016：复杂信息系统时代（8年）
2016- ：人工智能时代
计算能力问题–>交互问题–>数据问题–>人类的问题
C: 性能
Java：跨平台
C++： 大规模程序
VB： 桌面应用
Python：计算时代演进的选择
通用语言
脚本语言
开源、跨平台、多模型语言
C/C++：python归python ，c归c
Java：针对特定开发和岗位需求
HTML/CSS/JS：不可替代的前端技术，全栈能力
其他语言： R/Go/Matlab等，特定领域
工具决定思维：关注工具变革的力量！
机器语言 --> 代码直接执行，与CPU有关
汇编语言 --> 助记符，汇编器，与CPU有关
高级语言 --> 编译器，与CPU无关
超级语言 --> 整合已有程序，庞大计算生态
== python是唯一的超级语言！ ==
== import turtle == 导入海归绘图库
“举一反三：”
Python蟒蛇绘制问题是各类图形绘制问题的代表
–圆形绘制、五角星绘制、国旗绘制、机器猫绘制…
--注：turtle库是turtle绘图体系的python实现
--1969年诞生，是python标准库之一，入门级图形绘制函数库
--Python计算生态 = 标准库 + 第三方库
-库Library、包Package、模快Module，统称模块
turltle.setup(width, height, startx, starty)
--注：- setup()设置窗体大小及位置
4个参数后两个可选，不选则默认在窗口的正中间，setup（）不是必须的
–1)绝对坐标：和数学中的坐标系（象限）知识相同
–turtle.goto(x,y)
–2)海龟坐标：后退<–>前进；左侧<–>右侧
–3)空间坐标体系：turtle.bk(d),turtle.fd(d),burtle.circle(r,angle)
--1)绝对角度：0/360,90/-270,180/-180,270/-90
--turtle.seth(angle):改变海龟行进方向，angle为绝对度数，只改变方向不前进。
--2)海龟角度：turtle.left(angle),turtle.right(angle)
--RGB指 红 蓝 绿 组合
--RGB整数值，小数值
--turtle.colormode(mode),默认小数值
mode = 1 表示rgb小数值模式
mode = 255 表示rgb整数值模式
import turtle
turtle. 格式：<a>.<b>()
<库名>.<函数名>(<函数参数>)
或 <库别名>.<函数名>(<函数参数>)
画笔操作后一直有效，一般成对出现
画笔设置后一直有效，直至下次重新设置
turtle.pensize(width) 别名 turtle.width(width)
画笔宽度，海龟的腰围
turtle.pencolor(color) color为颜色字符串或r,g,b值
画笔颜色，海龟在涂装
pencolor(color)的color可以有三种形式
控制海龟行进：走直线 & 走曲线
产生循环计数序列
range(N)产生 0 到 N-1的整数序列，共N个
range(M,N)产生 M 到 N-1的整数序列，共N-M个
--3.1.1整数类型：与数学中概念一致，+|-均可，无范围限制
--pow(x,y)函数
--3.1.2 4种进制表示形式：
十进制，二进制(0b,0B开头)，八进制(0o,0O开头)，十六进制(0x,0X)
--3.1.3浮点数类型：浮点数范围和小数精度都存在限制，但常规计算可以忽略
浮点数间运算存在不确定尾数，发生在10E-16左右，不是bug
-- round(x,d):对x四舍五入，d是小数截取位数。用于浮点数间运算及比较。
-- 浮点数采用科学计数法表示<a>e<b>表示 a*10b
例如：4.3e-3 值为0.0043 9.6E5 值为960000.0
--3.1.4复数类型：
z = 1.23e-4+5.6e+89j
Z.real获得实部，Z.imag获得虚部
–3.1.5数值运算操作符：类型间可以混合运算，生成结果为“最宽”类型。
–数值运算函数：
– abs(x) 绝对值
– divmod(x,y) => 同时输出商和余数
– pow(x,y[,z]) => 幂余，(x**y)%z
– round(x[,d]) => 四舍五入，d小数位数，默认为0
– max()最大值
– min()最小值
– int(x)
– float()
– complex(x)
略
– 单引号，双引号；三引号
– 索引 [M]
– 切片 [M,N,K]
str[::1] 的结果是012345678910
– 转义字符：\b回退，\n换行，\r回车（光标移到本行行首）
– + 字符串拼接
– * 复制n次字符串
– in
– len(x)
– str(x) 任意类型所对应的字符串形式
– hex(x)或oct(x) 整数x的十六进制或八进制小写形式字符串
– chr(u) u为Unicode编码，返回其对应的字符
– ord(x) x为字符，返回其对应的Unicode编码
补充
若不想使print换行，添加end=""（空），
如print(t [eval (c )-1],end=’’)
– S.lower()或S.upper() 返回字符串副本，全部字符小写/大写
– S.split(sep=None) 返回一个列表，由str根据sep被分隔部分组成
– S.count(sub) 返回子字符串sub在str中出现的次数
– S.replace(old,new)
– S.center(width[,fillchar])
“python”.center(20,"=") 结果为 ‘=python=’
在一个20字符的宽度中，让我们的python字符居中，同时在空余的部分用等号来填充。
– S.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符。
– S.join(iter) 在iter变量除最后元素外每个元素增加一个S。例如：’,’.join(“12345”) #主要用于字符串分割
** “{:10}”.format(“BIT”) ** 中默认是空格填充左对齐
所有字符都用英文半角
时间获取：time() ctime() gmtime()
gmtime（）得到一个计算机内部可以操作的时间，struct_time格式
时间格式化： strftime() ，strptime()
.time() 获取当前时间戳，即计算计算机内部时间值，浮点数。
.ctime()获取当前时间并以易读方式表示，返回字符串
.gmtime()获取当前时间，表示为计算机可处理的时间格式
.strftime(tpl,ts) : tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)
timeStr = “2018-01-26 12:55:20”
time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")
采用sleep()模拟一个持续的进度
这里理解一个重要的系统概念:刷新
刷新的关键是\r
# TextProBarV3.py
import time
scale = 50 # 文本进度条的大概的宽度
print("执行开始".center(scale//2,"-")) # p3.3.4 center填充函数
start = time.perf_counter() # 确定了一个开始时间
for i in range(scale + 1):
a = "*" * i # 字符串与整数的乘积，表示复制字符串的次数，a是i个*的字符串
b = "." * (scale - i)
c = (i / scale) * 100
dur = time.perf_counter() - start
# 给end赋值空字符串，可以是print每一次输出字符串之后不会增加换行，只会把光标停留在当次输出字符串的后面
# 这里的\r
print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end="")
time.sleep(0.1)
print("\n" + "执行结束".center(scale // 2, "-"))
“程序的控制结构”：顺序结构、分支结构、循环结构
语法： if <条件>:
<语句块>
语法： if <条件>:
<语句块1>
else:
<语句块2>
紧凑形式：适用于简单表达式的二分支结构
<表达式1> if <条件> else <表达式2>
语法：if <条件1>:
<语句块1>
elif <条件2>：
<语句2>
…
else:
<语句块N>
注： 注意多条件之间的包含关系，注意变量取值范围的覆盖。 通俗点： 多分支结构中，如果一个分支判断条件通过后，会执行对应的语句块，之后结束分支程序。即使，后续的elif条件也满足，也不会执行对应的语句块.所以这里其实也有一个顺序关系。
–条件判断操作符：<,<=,>=,>,==,!=
–条件组合三个保留字：and,or,not
try:
<语句块1>
except [<异常类型>]：
<语句块2>
注：标注异常类型后，仅响应该异常，异常类型名字等同于变量。
高级使用：
try:
<语句块1>
except:
<语句块2>
else: # 不发生异常的时候执行(奖励)
<语句块3>
finally: # 无论是否异常一定会执行
<语句块4>
BMI = 体重(Kg)/身高2(m2)
略
注：阅读代码的时候，快速的方法是：先搞懂分支的范围关系，再深入看每个分支在做什么。而不是从上到下的顺序结构。
#CalBMIv1.py
height, weight = eval(input("请输入身高(米)和体重(公斤)[逗号隔开]: "))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
who = ""
if bmi < 18.5:
who = "偏瘦"
elif 18.5 <= bmi < 25:
who = "正常"
elif 25 <= bmi < 30:
who = "偏胖"
else:
who = "肥胖"
print("BMI 指标为:国际'{0}'".format(who))
#CalBMIv2.py
height, weight = eval(input("请输入身高(米)和体重\(公斤)[逗号隔开]: "))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
nat = ""
if bmi < 18.5:
nat = "偏瘦"
elif 18.5 <= bmi < 24:
nat = "正常"
elif 24 <= bmi < 28:
nat = "偏胖"
else:
nat = "肥胖"
print("BMI 指标为:国内'{0}'".format(nat))
#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))
for <循环变量> in <遍历结构>:
<语句块>
–从遍历结构中逐一提取元素，放在循环变量中。
–完整遍历所有元素后结束
–每次循环，所获得元素放入循环变量，并执行一次语句块
应用：计数循环、字符串遍历循环、列表遍历循环、文件遍历循环、等等
line每次读fi文件的一行
while <条件>:
<语句块>
break 跳出并结束当前循环，执行循环后的语句
continue 结束当次循环，继续执行后续次数循环
break和continue可以与for和while循环搭配使用。
一个break只能跳出一个循环
random库是使用随机数的Python标准库
- randint(a,b) 生成[a,b]之间的整数
- randrange(m,n[,k]) 生成一个[m,n)之间以k为步长的随机整数
- getrandbits(k) 生成一个k比特长的随机整数
- uniform(a,b) 生成一个[a,b]之间的随机小数
- choice(seq) 从序列seq中随机选择一个元素
- shuffle(seq) 将序列seq中元素随机排列，返回打乱后的序列
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 += 1
pi = 4 * (hits / DARTS)
print("圆周率是：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter() - start))
函数是一段具有特定功能、可重用的语句组
降低编程难度 和 代码复用
def <函数名>(<参数(0个或多个)>)：
<函数体>
return <返回值>
不调用不会被执行
调用是运行函数代码的方式
-调用时给出实际参数，替代定义中的形式参数
-函数调用得到返回值
参数的个数：0，1，或多个。但是必须保留括号
可变数量参数，既不确定参数总数量
传递参数两种方式：位置参数，名称传递
return 保留字用来传递返回值
可以传，可以不传，可以传递0个，也可以传多个
方括号括着元素里面用逗号隔开属于列表，圆括号括着里面用逗号隔开，是元组
– (一般函数外部是全局变量，函数内部的变量是局部变量)
**规则一：**局部变量和全局变量是不同变量
–局部变量是函数内部的占位符，与全局变量可能重名但不同
–函数运算结束后，局部变量被释放
–可以用 global保留字在函数内部使用全局变量
(这里还分可变类型和不可变类型)
**规则二：**局部变量为组合数据类型且未创建，等同于全局变量
使用规则：
-基本数据类型，无论是否重名，局部变量与全局变量不同
-可以通过global保留字在函数内部声明全局变量
-组合数据类型，如果局部变量未真实创建，则是全局变量
1.分析单个数码管：
#SevenDigitsDrawV2.py
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(d): #根据数字绘制七段数码管
## 如果属于[2,3,4,5,6,8,9]中有的线就画，没有就飞过去，准备第二条线的判断
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)
turtle.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)
turtle.left(180)
turtle.penup() ## 为绘制后续数字确定位置
turtle.fd(20) ## 为绘制后续数字确定位置
def drawDate(date):
turtle.pencolor("red")
for i in date:
if i == '-':
#font是字体的参数，分别为字体名称，大小和类型
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))
def main():
turtle.setup(800, 350, 200, 200)
turtle.penup()
turtle.fd(-350)
turtle.pensize(5)
# drawDate('2018-10=10+')
drawDate(time.strftime('%Y-%m=%d+',time.gmtime())) ## 读取系统年月日时间
turtle.hideturtle()
turtle.done()
main()
模块化思维：确定模块接口，封装功能
规则化思维：抽象过程为规则，计算机自动执行
化繁为简：将大功能变为小功能，分而治之(松耦合，紧耦合)
绘制带小数点的七段数码管
带刷新的时间倒计时效果
绘制高级的数码管(多段)
代码复用：把代码当成资源进行抽象
代码复用：|函数|和|对象|是代码复用的两种主要形式
函数：(将代码命名)：在代码层面建立了初步抽象
对象：(属性和方法):在函数基础上再次组织进行抽象
模块化设计：分而治之
模块化设计：紧耦合、松耦合
定义：函数定义中调用函数自身的方式
两个关键特征：
链条：计算过程存在递归链条
基例：存在一个或多个不需要再次递归的基例
类似数学归纳法：递归是数学归纳法思维的编程体现
递归的实现：函数+分支语句
递归本身是一个函数，需要函数定义方式的描述
函数内部，采用分支语句对输入参数进行判断
基例和链条，分别编写对应的代码
字符串反转
斐波那契数列
汉诺塔 PS：学会找到基例和链条
将.py源码转换成无需源代码的可执行文件
在命令窗口输入后回车可以查看对应的方法参数帮助
要配置Path，关闭后再开cmd窗口
PS：分形几何，自然界常见
基本方法：
递归思想：函数+分支
递归链条：线段的组合
递归基例：初识线段
运用 PyInstaller库
举一反三
修改分形几何绘制阶数
修改科赫曲线的基本定义及旋转角度
修改绘制科赫雪花的基础框架图形
分形几何扩展：
康托尔集、谢尔宾斯基三角、门格海绵…
龙形曲线、空间填充曲线、科赫曲线…
函数递归的深入应用…
组合类型的三种表达形式：
4个增强操作符
**解释：**其中A.pop()的意思是每次从A中取出一个元素，当A为空集合的时候会产生异常异常，这个异常能被try和except捕捉到，程序可以正常退出
序列是一个基类类型
def func():
return1,2
这里的返回值就是元组
序列类型的一种扩展
定义:方括号[]真正创建一个列表，赋值仅传递引用（贴标签）
因为这里没有创建列表it，所以只是赋值引用，相当于吧ls改名为lt
函数和方法
增删改查
注意：列表中的第一个元素在第0个位置
数据表示：元组和列表
需求：给出一组数，对它们有个概要理解
基本统计值：总个数、求和、平均值、方差、中位数……
len()
for in 求和
均值：求和/总个数
方差： pow()函数
中位数：排序，然后……
代码主要思路：
#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
# 方差公式就是除以n-1
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
关键是jieba.lcut(s)：能将能将字符串s进行精确的分词处理，并且返回一个列表类型
#CalHamletV1.py
def getText():
txt = open("hamlet.txt", "r").read()
txt = txt.lower() # 把txt中字母全部变小写
for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
txt = txt.replace(ch, " ") #将文本中特殊字符替换为空格
return txt
hamletTxt = getText()
# .split()采用空格将hamletTxt中的字符串进行分隔，并且以列表形式返回给变量
words = hamletTxt.split()
#为了表示一个单词和它出现的次数构成映射，用字典来表示
counts = {}
for word in words:
# 表示如果键word存在就返回其对应的值，不存在就返回0，所以第一次不
#存在返回0，此时word键在counts里面生成，对应的值是1。
#第二次遇到同一个word时，返回对应值1，然后word对应的值变成1+1=2
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))
items = list(counts.items())的使用，问：一个列表里面能放元组吗？
列表,元组,字典的元素可以是任何类型
items.sort(key=lambda x:x[1], reverse=True) 还不懂？？？？
#CalThreeKingdomsV2.py
import jieba
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
if len(word) == 1:
continue
elif word == "诸葛亮" or word == "孔明曰":
rword = "孔明"
elif word == "关公" or word == "云长":
rword = "关羽"
elif word == "玄德" or word == "玄德曰":
rword = "刘备"
elif word == "孟德" or word == "丞相":
rword = "曹操"
else:
rword = word
counts[rword] = counts.get(rword,0) + 1
for word in excludes:
del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(10):
word, count = items[i]
print ("{0:<10}{1:>5}".format(word, count))
文件是数据的抽象和集合
文本文件 VS 二进制文件
文本文件：
二进制文件：
例子
# f.txt文件保存: "中国是个伟大的国家!"
# 文本形式打开文件
tf= open("f.txt", "rt") # 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'
a.read(size)
a.readline(size)
a.readlines(hint)
a.write(s)
a.writelines(lines)
a.seek(offset)
文件的存储状态文件的占用状态a = opne( , )a.close()文件的存储状态文件的占用状态
读文件：3种方法 VS 写文件： 3种方法 -文件的打开： <变量名> = open(<文件名>，<打开模式>)
变量名：文件句柄
文件名：文件路径和名称(源文件同目录可省略)
打开模式：文本or二进制；读or写
补充：windows下，文件目录之间用\，这个和python冲突，解决方式两种：\，或者用/ .
打开模式：
例子
f = open("f.txt") # -文本形式、只读模式、默认值
f = open("f.txt", "rt")# -文本形式、只读模式、同默认值
f = open("f.txt", "w")# -文本形式、覆盖写模式
f = open("f.txt", "a+")# -文本形式、追加写模式+ 读文件，如果没有+，就只能追加写模式，不能读文件
f = open("f.txt", "x")# -文本形式、创建写模式
f = open("f.txt", "b")# -二进制形式、只读模式
f = open("f.txt", "wb")# -二进制形式、覆盖写模式
操作方法 描述
文件的全文本操作
fo = open(filename,"r")
txt = fo.read(2)
while txt != "":
# 对txt进行处理
txt = fo.read(2)
fo.close()
fo = open(filename,"r")
for line in fo.readlines():
print(line)
fo.close()
fo = open(filename,"r")
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()
需求：根据脚本来绘制图形？
不是写代码而是写数据绘制轨迹
数据脚本是自动化最重要的第一步
基本思路：
#AutoTraceDraw.py
importturtle ast
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","")
# map的作用就是将第一个参数的功能作用到第二个参数
# 每一行处理之后的信息作为列表，并且这个列表是我们定义的datals中的一个元素
datals.append(list(map(eval, line.split(","))))
# 至此，datals列表中每一个元素就是一行的信息，也就是一个小的列表
f.close()
#自动绘制
for i in range(len(datals)):
#获得每个元素中的rgb值，改变当前画笔的颜色
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])
理解方法思维
自动化思维：数据和功能分离，数据驱动的自动运行
接口化设计：格式化设计接口，清晰明了
二维数据应用：应用维度组织数据，二维数据最常用
应用问题扩展：
扩展接口设计，增加更多控制接口
扩展功能设计,增加弧形等更多功能
扩展应用需求，发展自动轨迹绘制到动画绘制
一维数据的表示
一维数据的存储
一维数据的处理
# 从空格分隔的文件中读入数据
# 中国 美国 日本 德国 法国 英国 意大利
txt= open(fname).read()# 用.read把文件读进来变成一个大字符串
ls = txt.split() # 根据空格分隔字符串中的信息，将每一个元素变成一个列表
f.close()
>>> ls
['中国', '美国', '日本', '德国', '法国', '英国', '意大利']
#从特殊符号分隔的文件中读入数据
#中国$美国$日本$德国$法国$英国$意大利
txt= open(fname).read()
ls = txt.split("$")
f.close()
>>> ls
['中国', '美国', '日本', '德国', '法国', '英国', '意大利']
将程序表示的数据写入文件
将程序表示的数据写入文件
从一维数据的表示的列表形式写入文件的方法
# 采用空格分隔方式将数据写入文件
ls = ['中国','美国','日本']
f = open(fname, 'w')
# join方法的作用：将join前面的字符串分隔放置到后面join参数中各个元素之间的
# 如ls其中三个元素之间增加空格，生成的字符串就是'中国 美国 日本'
f.write(''.join(ls))
f.close()
# 采用特殊分隔方式将数据写入文件
ls = ['中国','美国','日本']
f = open(fname, 'w')
f.write('$'.join(ls))
f.close()
读入处理：
#从CSV格式的文件中读入数据
fo = open(filename)
ls = []
for line in fo:
line = line.replace("\n", "") # 去掉每一行的最后一个回车换行符
ls.append(line.split(","))
fo.close()
写入处理：
#将数据写入CSV格式的文件
ls = [[], [], []] # 二维列表
f = open(fname, "w")
for item in ls:
f.write(",".join(item) + "\n")
f.close()
二维数据的逐一处理
ls = [[1,2],[3,4],[5,6]] #二维列表
for row in ls:
for column in row:
print(column)
wordcloud库概述：wordcloud是优秀的词云展示第三方库
wordcloud库基本使用：wordcloud库把词云当作一个WordCloud对象
wordcloud库常规方法
三步法
import wordcloud
c = wordcloud.WordCloud()# 步骤1：配置对象参数
c.generate("wordcloudby Python")# 步骤2：加载词云文本
c.to_file("pywordcloud.png")# 步骤3：输出词云文件
配制参数
例子
# wordcloud中我们是利用空格分隔单词的
import wordcloud
txt = "life is short, you need python"
w = wordcloud.WordCloud( \
background_color= "white")
w.generate(txt)
w.to_file("pywcloud.png")
# 中文没有空格，所以需要事先分好
import jieba
import wordcloud
txt = "程序设计语言是计算机能够理解和\
识别用户操作意图的一种交互体系，它按照\
特定规则组织计算机指令，使计算机能够自\
动进行各种运算处理。"
w = wordcloud.WordCloud( width=1000,\
font_path="msyh.ttc",height=700)
# 下面这句话的意思是，能够将这段文本通过jieba.lcut函数编程一个列表
# 进一步用join方法，将jion中的元素用jion前面的空格字符串来分隔来构成一个长字符串，这个厂字符串会赋值给WordCloud对象
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")
https://pypi.org/
PyPI：Python Package Index
PSF维护的展示全球Python计算生态的主站
学会检索并利用PyPI，关键词检索
Win+r =>输入cmd回车，进入cmd，pip -h，可以常看常用命令及介绍
Anaconda —— 数据计算
某些第三方库pip下载后，需要编译再安装
直接下载编译后的安装，推荐一个个人博客：http://www.lfd.uci.edu/~gohlke/pythonlibs/
os库是标准库，包含几百个函数，常用路径操作、进程管理、环境参数等几类
import os.path as op
函数 描述
os.system(command)
执行程序或命令command
在windows系统中，返回值为cmd的调用返回信息
eg1: os.system("C:\\windows\\System32\\calc.exe")
#打开画图程序并同时用它打开一张图
eg2: os.system(C:\\windows\\System32\\mspaint.exe D:\\pycode\\grwordcloud.png")
函数 描述
os.chdir(path) 修改当前程序操作的路径
os.getcwd() 返回程序的当前路径
os.getlogin() 获得当前系统登陆用户名
os.cpu_count() 获得当前系统的CPU数量
os.urandom(n) 获得n个字节长度的随机字符串，通常用于加解密运算
