初级Python

[toc]

一、数据类型

1.1基本数据类型

1.1.1数字类型

1、整数类型
十进制：1010，-219
二进制：以0b或0B开头：0b010，-0B101
八进制，以0o或0O开头：0o123，-0O234
十六进制，以0x或0X开头：0x9a，-0X89

2、浮点数类型

1. 运算存在不确定尾数，但不是bug
   round(x,d)：对x四舍五入，d是小数截取位数（浮点数间运算、比较可用该函数辅助）
2. 可采用科学计数法表示
   使用字母e或E作为幂的符号，以10为基数，格式：<a>e<b>，表示 a*10^b。如：4.3e-3 为0.0043，9.6E5 为960000.0

3、数值运算操作符
/ 除运算，结果为浮点数
// 整除运算
** 幂运算
类型间可以进行混合运算，生成结果为“最宽”类型：整数->浮点数->复数

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

#daydayupQ2.py
def dayUP(df): # def保留字用于定义函数
    dayup=1
    for i in range(365):
        if i%7 in [6,0]:
            dayup*=1-0.01 #休息日能力退步
        else:
            dayup*=1+df #工作日能力进步
    return dayup

dayfactor=0.01
while dayUP(dayfactor)<37.78:
    dayfactor+=0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

1.1.2字符串类型

1、字符串

1. 定义：由0个或多个字符组成的有序字符序列

• 由一对单引号或双引号表示单行字符串
• 由一对三单引号或三双引号表示多行字符串。多行注释也是一种字符串，只是没有赋给变量
• 是字符的有序序列，可以对其中的字符进行索引

1. 两类四种表示方法
   (1)希望在字符串中包含双引号或单引号（包含单引号时，外侧用双引号；包含双引号时，外侧用单引号），如：'这里有个双引号(")' 或 "这里有个单引号(')"
   (2)希望在字符串中既包括单引号又包括双引号（外侧使用三单引号），如：'''这里既有单引号(' ')又有双引号(" ")'''
2. 字符串的序号：正向递增序号（第一个字符从0开始），反向递减序号（最后一个字符从-1开始）

2、字符串的使用

1. 使用[]获取字符串中一个或多个字符

• 索引：返回字符串中单个字符 <字符串>[M]，如：TempStr[-1]
• 切片：返回字符串中一段字符子串 <字符串>[M:N]（从第M个开始，不到第N个。M缺失表示从头开始，N缺少表示到结尾），如：TempStr[0:-1]
  高级用法：使用[M:N:K]根据步长对字符串切片，如："0123456789"[1:8:2] 的结果为 "1357"。如果想对字符串逆序，可用"0123456789"[::-1]

1. 转义符
   表达特定字符的本意，如："这里有个双引号(")"，即外侧也可使用双引号
   形成组合，表示特殊含义，如：\n，\b等

3、字符串操作符

• x+y：连接两个字符串
• xn 或 nx：复制 n次字符串 x
• x in s：若 x是 s的子串，返回True，否则返回False

4、字符串处理函数

• len(x)：返回字符串 x的长度（Python中，数字、标点符号、字母、汉字都是一个字符），如：len("一二三456") 为 6
• str(x)：任意类型 x对应的字符串形式，如：str([1,2]) 为 "[1,2]"
• hex(x)或oct(x)：整数 x的十六进制或八进制小写形式字符串，如：hex(425) 为 "0x1a9"，oct(425) 为 "0o651"
• chr(u)：u为Unicode编码，返回对应字符
• ord(x)：x为字符，返回对应Unicode编码

5、字符串处理方法
方法：特指 <a>.<b>()风格中的函数 <b>()；其本身也是函数，但与 <a>有关，以 <a>.<b>()风格使用；字符串及变量也是 <a>，存在一些方法

• str.lower()或str.upper()：返回字符串的副本，全部字符小写/大写
• str.split(sep=None)：返回一个列表，由 str根据 sep被分隔的部分组成，如："A,B,C".split(",") 为 ['A','B','C']
• str.count(sub)：返回子串 sub在 str中出现的次数，如："an apple a day".count("a") 为 4
• str.repiace(old,new)：返回字符串 str的副本，所有 old子串被替换为 new
• str.center(width,[,fillchar])：字符串 str根据宽度 width居中，fillchar可选，如："python".center(20,"=") 为 '=python='
• str.strip(chars)：从 str中去掉在其左侧和右侧 chars中列出的每个字符（而不是整体的字符串），如："= python=".strip(" =np") 为 "ytho"
• str.join(iter)：在 iter变量除最后元素外每个元素后增加一个 str（主要用于字符串分隔），如：",".join("12345") 为 "1,2,3,4,5"

#获取星期字符串
#输入：1-7的整数，表示星期几
#输出：输入整数对应的星期字符串

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

#简化
weekStr="一二三四五六日"
weekID=eval(input("请输入星期数字(1-7)："))
print("星期"+weekStr[weekID-1])

1.2组合数据类型

1.2.1集合

1、定义
（与数学中的集合概念一致）
集合元素不可更改，不能是可变数据类型

• 用大括号 表示，元素间用逗号分隔
• 建立集合类型用 或 set()
• 建立空集合类型，必须使用 set()

A={"python",123,("python",123)}
#为：{123,'python',('python',123)}
B=set("python123")
#为：{'1','p','2','3','y'}    无序的
C={"python",123,"python",123}
#为：{'python',123}

2、操作符

• S|T：返回一个新集合，包括在集合 S和 T中的所有元素
• S-T：返回一个新集合，包括在集合 S但不在 T中的元素
• S&T：返回一个新集合，包括同时在集合 S和 T中的元素
• S^T：返回一个新集合，包括集合 S和 T中的非相同元素
• S<=T或S<T：返回 True/False，判断 S和 T的子集关系
• S>=T或S>T：返回 True/False，判断 S和 T的包含关系

增强操作符

• S|=T：更新集合 S，包括在集合 S和 T中的所有元素
• S-=T：更新集合 S，包括在集合 S但不在 T中的元素
• S&=T：更新集合 S，包括同时在集合 S和 T中的元素
• S^=T：更新集合 S，包括集合 S和 T中的非相同元素

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

3、处理方法

• S.add(x)：如果 x不在集合 S中，将 x增加到 S
• S.discard(x)：移除 S中元素 x；如果 x不在集合 S中，不报错
• S.remove(x)：移除 S中元素 x；如果 x不在集合 S中，产生 KeyError异常
• S.clear()：移除 S中所有元素
• S.pop()：随即返回 S的一个元素，更新 S，若 S为空产生 KeyError异常

A={"p","y",123}
for item in A:
    print(item,end="")

try:
    while True:
        print(A.pop(),end="") #从 A中弹出一个元素，当列表为空时返回异常
except:
    pass #此时 A为空

4、应用场景

• 关系比较
• 数据去重

"p" in {"p","y",123}
#为：True
{"p","y"}>={"p","y",123}
#为：False

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

1.2.2序列

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

• 一维元素向量，元素可以相同，元素类型可以不同（如：）
• 类似数学元素序列：S0,S1,...Sn-1
• 元素间由序号引导，通过下标访问序列的特定元素

基类类型，衍生出 字符串类型，元组类型，列表类型

2、操作符

• x in s：如果 x是序列 s中的元素，返回 True，否则返回 False
• x not in s：如果 x是序列 s中的元素，返回 False，否则返回 True
• s+t：连接两个序列 s和 t
• sn或ns：将序列 s复制 n次
• s[i]：索引，返回 s中第 i 个元素，i 是序列的序号

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

3、函数与方法

• len(s)：返回序列 s的长度
• min(s)：返回序列 s的最小元素，s中元素需要可比较
• max(s)：返回序列 s的最大元素，s中元素需要可比较
• s.index(x)或s.index(x,i,j)：返回序列 s从 i开始到j位置中第一次出现元素 x的位置
• s.count(x)：返回序列 s中出现 x的总次数

ls=["python",123,".io"]
len(ls)
#为：3
s="python123.io"
max(s)
#为：'y'

4、元组

• 一种序列类型，一旦创建就不能扩展
• 使用小括号()或tuple()创建，元素用逗号分隔
• 小括号不是必需的

def func():
    return 1,2
#实际返回的是(1,2)的元组

creature="cat","dog","tiger","human"
#为：('human','tiger','dog','cat')
color=(0x001100,"blue",creature)
#为：(4352,'blue',('cat','dog','tiger','human'))
color[-1][2]
#为：'tiger'

5、列表
(1)定义

• 一种序列类型，创建后可以随意修改
• 使用方括号[]或list[]创建，元素用逗号分隔
• 各元素类型可以不同，无长度限制

(2)函数

• ls.append(x)：在列表 ls最后增加一个元素 x
• ls.clear()：删除列表 ls的所有元素
• ls.copy()：生成一个新列表，赋值 ls中所有元素
• ls.insert(i,x)：在列表 ls的第 i个位置插入元素 x
• ls.pop(i)：将列表 ls中第 i个位置的元素取出并删除该元素
• ls.remove(x)：将列表 ls中出现的第一个元素 x删除

6、应用场景

• 元素遍历
• 数据保护（转换成不能扩展的元组类型）

ls=["cat","dog","tiger",1024]
#为：['cat','dog','tiger',1024]
lt=ls
#lt为：['cat','dog','tiger',1024]。赋值仅传递引用，lt和ls其实指向的是同一个

1.2.3字典

1、定义
映射是一种键（索引）和值（数据）的对应
字典类型是“映射”的体现

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 使用大括号和 dist()创建，键值对用冒号 : 表示，如：{<键1>:<值1>,<键2>:<值2>,...,<键n>:<值n>}

字典变量中通过键获得值

• <字典变量>={<键1>:<值1>,<键2>:<值2>,...,<键n>:<值n>}
• <值>=<字典变量>[<键>] <字典变量>[<键>]=<值>
• [] 用来向字典变量中索引或增加元素

d={"中国":"北京","法国":"巴黎"}
d["中国"]
#为：北京

de={}
#大括号仅用于建造 空字典

2、函数

• del d[k]：删除字典 d中键 k对应的数据
• k in d：判断键 k是否在字典中，在则返回 True
• d.keys()：返回字典 d中所有键的信息
• d.values()：返回字典 d中所有值的信息
• d.items()：返回字典 d中所有键值对的信息
• d.get(k,)：键 k存在则返回对应值，否则返回 default
• d.pop(k,)：键 k存在则取出对应值，否则返回 default
• d.popitem()：随即从字典中取出一个键值对，以元组形式返回
• d.clear()：删除所有键值对
• len(d)：返回字典中元素个数

二、控制结构

2.1分支结构

2.1.1异常处理

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

2.1.2高级异常处理

try:
    <语句块1>
except:
    <语句块2>
else:
    <语句块3>
finally:
    <语句块4>

首先执行语句块1的一部分代码；如果不发生异常则“奖励性地”执行语句块3；如果发生了异常，执行语句块2；无论是否发生异常，都要执行语句块4

try:
    num=eval(input("请输入一个整数"))
    print(num**2)
except NameError: #异常类型不是必需，且名称是预定义的。标注异常类型后，仅响应该异常（异常类型名等同于变量）
    print("输入不是整数\n")

#身体质量指数BMI
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))

2.2循环结构

2.2.1遍历循环

遍历某个结构形成的循环运行方式

for <循环变量> in <遍历结构>:
    <语句块>
#每次循环，从遍历结构中获得元素放入循环变量，执行一次语句块

1、计数循环（N次）

/*
for i in range(N):
    <语句块>
for i in range(M,N,K):
    <语句块>
*/
for i in range(5):
    print(i)

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

2、字符串遍历循环

/*
for c in s:
    <语句块>
# s是字符串，遍历字符串每个字符，产生循环
*/
for c in "python123":
    print(c,end=",")
#结果：p,y,t,h,o,n,1,2,3,

3、列表遍历循环

/*
for item in ls:
    <语句块>
# ls是一个列表，遍历其每个元素，产生循环
*/
for item in [123,"py",456]:
    print(item,end=",")
#结果：123,py,456,

4、文件遍历循环

for line in fi:
    <语句块>
# fi是一个文件标识符，遍历其每行，产生循环

2.2.2无限循环

由条件控制的循环运行方式

/*
while <条件>:
    <语句块>
#反复执行语句块，直到条件不满足时结束
*/
a=3
while a>0:
    a=a-1
    print(a)

2.2.3循环控制保留字

break：跳出并结束当前最内层循环，执行循环后的语句
continue：结束当次循环，继续执行后续次数循环

for c in "python":
    if c=="t":
        continue
    print(c,end="")

for c in "python":
    if c=="t":
        break
    print(c,end="")

2.2.4循环的扩展

/*
for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>
或
while <条件>:
    <语句块1>
else:
    <语句块2>

当循环没有被 break语句退出时，执行 else语句块，当作“正常”完成循环的奖励
*/

#使用continue
for c in "python":
    if c=="t":
        continue
    print(c,end="")
else:
        print("正常退出")
#结果：python正常退出

#使用break
for c in "python":
    if c=="t":
        break
    print(c,end="")
else:
        print("正常退出")
#结果：py

三、函数

3.1定义

/*
def <函数名>(<参数>):
    <函数体>
    return <返回值>
*/
#计算 n!
def fact(n):
    s=1
    for i in range(1,n+1):
        s*=i
    return s

3.2可变参数传递

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

/*
def <函数名>(<非可选参数>,<可选参数>):
    <函数体>
    return <返回值>
#可选参数必须放在非可选参数后面
*/
#计算 n!//m
def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m

2、函数定义时可设计可变数量参数，即不确定参数的数目

/*
def <函数名>(<参数>,*b):
    <函数体>
    return <返回值>
*/
def fact(n,*b):
    s=1
    for i in range(1,n+1):
        s*=i
    for item in b:
        s*=item
    return s

#函数的返回值中，如果 return了多个数据，则用“()”括住，用“,”分隔，即元组类型
def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m,n,m

fact(10,5)
#结果：(725760,10,5)

a,b,c=fact(10,5)
print(a,b,c)
#结果：725760 10 5

3.3局部变量和全局变量

规则1：基本数据类型，无论是否重名，局部变量与全局变量不同

#规则1
n,s=10,100
def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s #此处局部变量 s是3628800
print(fact(n),s) #此处全局变量 s是100

n,s=10,100
def fact(n,m=1):
    global s #可通过 global保留字在函数内部声明全局变量
    for i in range(1,n+1):
        s*=i
    return s #此处 s是全局变量362880000
print(fact(n),s) #此处全局变量 s被函数修改，是362880000

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

#规则2 例1
ls=["F","f"]
def func(a):
    ls.append(a) #此处 ls是列表类型，未真实创建，等同于全局变量
    return
func("C") #全局变量 ls被修改
print(ls)
#结果：['F','f','C']

#规则2 例2
ls=["F","f"] #通过使用 []真是创建了一个全局变量列表 ls
def func(a):
    ls=[] #此处 ls是列表类型，真实创建，局部变量
    ls.append(a)
    return
func("C") #局部变量 ls被修改
print(ls)
#结果：['F','f']

3.4代码复用与模块化设计

函数 和 对象 是代码复用的两种主要形式

• 函数：将代码命名.在代码层面建立了初步抽象
• 对象：属性和方法。<a>.<b>和<a>.<b>()。在函数之上再次组织进行抽象

紧耦合、松耦合

• 紧耦合：两个部分交流很多，无法独立存在
• 松耦合：两个部分交流很少，可以独立存在
• 模块内部紧耦合，模块之间松耦合

3.5函数递归

函数定义中调用自身的方式
两个关键特征

• 链条：计算过程存在递归链条
• 基例：存在一个或多个不需要再次递归的基例

实现：函数+分支语句，分别对应链条和基例

#例1、求 n!
def fact(n):
    if( n==0):
        return 1
    else:
        return n*fact(n-1)

#例2、字符串反转
def rva(s):
    if s=="":
        return s
    else:
        return rvs(s[1:])+s[0] #每次将首个字符放在字符串的最后

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

#例4、汉诺塔
count=0
def hanoi(n,src,dst,mid):
    global count
    if n==1:
        print("{}:{}->{}".format(1,src,dst))
        count+=1
    else:
        hanoi(n-1,src,mid,dst)
        print("{}:{}->{}".format(n,src,dst))
        count+=1
        hanoi(n-1,mid,dst,src)

四、文件和数据格式化

4.1文件

4.1.1使用

• 文件是存储在辅助存储器上的数据序列
• 文件是数据存储的一种形式
• 文件展现形态：文本文件和二进制文件（本质上所有文件都是二进制形式存储）

文本文件

• 由单一特定编码组成的文件
• 由于存在编码，也被看成是存储的长字符串
• 适用于：.txt文件，.py文件等

二进制文件

• 直接由比特0和1组成，没有统一字符编码
• 一般存在二进制0和1的组织结构，即文件格式
• 适用于：.png文件，.avi文件等

#文本形式打开文件
tf=open("f.txt","rt")
print(tf.readline())
tf.close()
#二进制形式打开文件
bf=open("f.txt","rb")
print(bf.readline())
bf.close()

4.1.2打开和关闭

文件一般存储在硬盘上，为存储状态；如果要处理一个文件，首先要使该文件变成占用状态
状态的转换通过打开和关闭进行转换

• 变量名：文件句柄
• 文件名：文件路径和名称（源文件同目录可省路径）
• 打开模式：文本 or 二进制（读 or 写）

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

• 'r'：只读模式，默认值，若文件不存在返回 FileNotFoundError
• 'w'：覆盖写模式，文件不存在则创建，存在则完全覆盖
• 'x'：创建写模式，文件不存在则创建，存在则返回 FileExistsError
• 'a'：追加写模式，文件不存在则创建，存在则在文件最后追加内容
• 'b'：二进制文件模式
• 't'：文本文件模式，默认值
• '+'：与 r/w/x/a一同使用，在原功能基础上增加同时读写功能

2、关闭
<变量名>.close()

4.1.3内容读取

• <f>.read(size=-1)：读取全部内容，如果给出参数，读取前 size长度
• <f>.readline(size=-1)：读入一行内容，如果给出参数，读取该行前 size长度
• <f>.readlines(hint=-1)：读入文件所有行，以每行为元素形成列表；如果给出参数，读取前 hint行

#全文本操作

#法一：一次读入，统一处理.对大文件代价很大
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()

#逐行操作

#法一：一次读入，分行处理
fname=input("输入要打开的文件名")
fo=open(fname,"r")
for line in fo.readline():
    print(line)

#法二：分行读入，逐行处理
fname=input("输入要打开的文件名")
fo=open(fname,"r")
for line in fo:
    print(line)
fo.close()

4.1.4文件写入

• <f>.write(s)：向文件写入一个字符串或字节流
• <f>.writelines(lines)：将一个元素都是字符串的列表写入文件
• <f>.seek(offset)：改变当前文件操作指针的位置，offset含义：0-文件开头，1-当前位置，2-文件结尾

fo=open("output.txt","w+")
ls=["中国","法国","美国"]
fo.writelines(ls)
fo.seek(0) #如果没有该行代码，则文件操作指针默认在最后，程序不会有任何输出
for line in fo:
    print(line)
fo.close()

4.2数据的格式化好处理

4.2.1数据组织的维度

1、一维数据
由对等关系的有序或无序数据构成，采用线性方式组织
对应列表、数组和集合等概念

2、二维数据
由多个一维数据构成，是一维数据的组合形式
表格是典型的二维数据（表头可以算作二维数据的一部分，也可以不算）

3、数据的操作周期
存储 ↔ 表示 ↔ 操作
即
存储格式 ↔ 数据类型 ↔ 操作方式

#高维数据 举例：键值对
{
    'firstname':'Xinxin',
    'lastname':'Wang',
    'address':{
                'stressAddr':'瀍河',
                'city':'洛阳',
                'zipcode':'471000'
                },
    'professional':['Data','Analysis']
}

4.2.2一维数据

1、表示
如果数据间有序，使用 列表 类型
如果数据间无序，使用 集合 类型
进而可以通过 for循环遍历处理数据

2、存储
采用空格，英文半角逗号，特殊字符等分隔
缺点：需要根据数据特点定义，通用性较差（如采用空格分隔时，存储内容中不能出现空格）

3、处理
存储格式与(列表或集合的)表示方式之间的转换：将存储的数据读入程序，将程序表示的数据写入文件

#一维数据的处理
 #1、从空格分隔的文件中读入数据
 #中国 美国 日本 法国
txt=open(fanme).read()
ls=txt.split()
txt.close() #ls为：['中国','美国','日本','法国']
 #2、采用特殊分隔方式将数据写入文件
ls=['中国','美国','日本']
f=open(fname,"w")
f.write('$'.join(ls))
f.close() #为：中国$美国$日本

4.2.3 二维数据

1、表示
使用列表类型

• 列表类型可以表达二维数据
• 使用二维列表（列表中的每一个元素也是列表，代表二维数据的一行或一列）

2、存储
CSV数据存储格式

• CSV：Comma-Separated Values #由逗号分隔的值
• 国际通用的一二维数据存储格式，一般.csv扩展名
• 每行一个一维数据，采用逗号分隔，无空行
• Excel好一般编辑软件都可以读入或另存为csv文件

注意

• 如果某个元素缺失，逗号仍要保留
• 二维数据的表头可以作为数据存储，也可以另行存储
• 一般索引习惯：ls[row][column]，先行后列

3、处理
CSV格式文件

#二维数据的处理

#1、从CSV格式的文件中读入数据
fo=open(fname)
ls=[]
for line in fo:
    line=line.replace("\n","") #把每行最后的回车替换为空字符串
    ls.append(line.split(",")) #把每行的元素用逗号分隔开形成列表
fo.close()
 #2、将数据写入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)

五、简单实例与部分库使用

5.1简单实例

5.1.1蟒蛇绘制

import turtle #引入绘图库
turtle.setup(650,350,200,200) #不是必需的，对窗口有要求时设置即可
#turtle.setup(width,height,startx,starty)，括号内前两者设置窗口大小，后两者是相对屏幕坐标原点的窗口坐标
turtle.penup() #拿起画笔，画布不显示痕迹。海龟默认位置在画布中央
turtle.fd(-250)
turtle.pendown() #放下画笔，画布显示痕迹
turtle.pensize(25) #画笔宽度，pensize可换成 width
turtle.pencolor("purple") #可用颜色字符串(小写)或 RGB小数值或 RGB元组值(小数值的括号外再加一层括号)设置
turtle.seth(-40)

for i in range(4): # i默认从0开始
    # range(N) 产生0到 N-1的整数序列
    # range(M,N) 产生 M到 N-1的整数序列
    turtle.circle(40,80)
    turtle.circle(-40,80)
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done() #程序运行完后不能自动退出，需要手动关闭窗体；去掉即可自动退出

小知识1.0

1、空间坐标体系

1. 绝对坐标：
   turtle.goto(x,y) 从当前位置直线前往(x,y)所在位置
2. turtle坐标：（都是前进方向，只是分前后左右）
   turtle.circle(r,angle)：根据半径 r绘制 angle角度的弧形（r默认海龟左侧 r距离的位置；若是右侧，用负数。angle默认360度整圆）
   turtle.bk(d)：后退
   turtle.fd(d)：前进

2、角度坐标体系

1. 绝对角度
   turtle.seth(angle) 改变海龟行进方向，但不前进。angle为绝对度数
2. turtle角度(以当前方向为基准)
   turtle.left(angle)：向左转
   turtle.right(angle)：向右转

3、RGB色彩
turtle默认采用小数值（0_{1），可切换为整数值（0}255）
turtle.colormode(mode)

• 1.0：RGB小数值模式
• 255：RGB整数值模式

4、库引用

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

简化库名方式：使用 from和 import保留字共同完成，即

from <库名> import <函数名>
from <库名> import *
<函数名>(<函数参数>)

#修改后代码
from turtle import*
setup(650,350,200,200)
penup()
fd(-250)
pendown()
pensize(25)
pencolor("purple")
seth(-40)

for i in range(4):
    circle(40,80)
    circle(-40,80)
circle(40,80/2)
fd(40)
circle(16,180)
fd(40*2/3)
done()

注意：当 import多个库时，可能出现函数重名问题
解决办法：使用 import和 as保留字共同完成（相当于给调用的外部库关联一个更短、更适合的名字），即

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

#修改后代码
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)
t.done()

5.1.2温度转换

#TempConvert.py
TempStr=input("请输入带有符号的温度值\n")
if TempStr[-1] in ['F','f']:
    C=(eval(TempStr[0:-1])-32)/1.8
    print("转换后的温度是{:.2f}C\n".format(C))
elif TempStr[-1] in ['C','c']: #注意最后的冒号和下两行代码的缩进
    F=(eval(TempStr[0:-1]))*1.8+32
    print("转换后的温度是{:.2f}F\n".format(F))
else:
    print("输入格式错误\n")

小知识2.0

1、列表：由0个或多个数据组成的有序序列

• 使用[]表示，采用逗号分隔各元素
• 使用保留字 in判断一个元素是否在列表中

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

eval("1")               -> 1
eval("1+2")             -> 3
eval('"1+2"')           -> '1+2'
eval('print("Hello")')  -> Hello

3、输出函数——print()函数的格式化
print("转换后的温度是{:.2f}C\n".format(C))

• 表示槽，后续变量填充到槽中
• 表示将变量C填充到这个位置时取小数点后2位
• ":计算机的CPU占用率为%".format("2019-9-5","C",10) 字符串中槽的默认顺序和 format()中参数的顺序一致
• "{1}:计算机{0}的CPU占用率为{2}%".format("2019-9-5","C",10) format()中参数标号默认从0开始，字符串中槽内的数字代表 format()中对应位置的参数

4、format()方法的格式控制

举例：

• "{0:=^20}".format("python") 为 '=python='
• "{0:*>20}".format("bit") 为 '*****************bit'
• "{:10}".format("bit") 为 'bit '
• "{0:,.2f}".format(123456.789) 为 '12,345.68'
• "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425) 为 '110101001,Σ,425,651,1a9,1A9'
• "{0:e},{0:E},{0:f},{0:%}".format(3.14) 为 '3.140000e+00,3.140000E+00,3.140000,314.000000%'

5.1.3文本进度条

#简单版
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(1)
print("------执行结束------")
print("\n")

#单行动态刷新
for i in range(101):
    print("\r{:3}%".format(i),end='')
    time.sleep(0.1)
print("\n")

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

5.1.4七段数码管绘制

#基本思路
#步骤1：绘制单个数字对应的数码管
import turtle,time

def drawGap(): #绘制数码管间隔
    turtle.penup()
    turtle.fd(5)
def drawLine(draw): #绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit): #根据数字绘制七段数码管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup() #为绘制后续数字确定位置
    turtle.fd(20) #为绘制后续数字确定位置

  #drawDigit(7)
  #time.sleep(2)

#步骤2：获得一串数字，绘制对应的数码管
def drawDate(date): # date为日期，格式为 '%y-%m=%d+%h*%m&%s#'
    turtle.pencolor("red")
    for i in date:
        #增加年月日标记且使用不同颜色
        if i=='-':
            turtle.write('年',font=("Arial",18,"normal"))
            turtle.pencolor("orange")
            turtle.fd(40)
        elif i=='=':
            turtle.write('月',font=("Arial", 18, "normal"))
            turtle.pencolor("yellow")
            turtle.fd(40)
        elif i=='+':
            turtle.write('日',font=("Arial", 18, "normal"))
            turtle.pencolor("green")
            turtle.fd(40)
        elif i=='*':
            turtle.write('时',font=("Arial", 18, "normal"))
            turtle.pencolor("blue")
            turtle.fd(40)
        elif i=='&':
            turtle.write('分',font=("Arial", 18, "normal"))
            turtle.pencolor("purple")
            turtle.fd(40)
        elif i=='#':
            turtle.write('秒',font=("Arial", 18, "normal"))
        else:
            drawDigit(eval(i))
def main():
    turtle.penup()
    turtle.fd(-600)
    turtle.pensize(5)
# 步骤3：获得当前系统时间，绘制对应的数码管
    drawDate(time.strftime('%Y-%m=%d+%H*%M&%S#',time.gmtime()))
    turtle.hideturtle()
    turtle.done()

main()

5.1.5科赫雪花

import turtle,time
def koch(size,n):
    if n==0:
        turtle.fd(size)
    else:
        for angle in [0,60,-120,60]:
            turtle.left(angle)
            koch(size/3,n-1)
def main():
    turtle.penup
    turtle.goto(-200,100)
    turtle.pendown()
    turtle.pensize(2)
    level=3 #3阶科赫曲线，雪花
    koch(400,level)
    turtle.right(120)
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.hideturtle()

main()
time.sleep((3))

5.1.6基本统计值计算

#简单版
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(1)
print("------执行结束------")
print("\n")

#单行动态刷新
for i in range(101):
    print("\r{:3}%".format(i),end='')
    time.sleep(0.1)
print("\n")

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

5.1.7文本词频统计

#hamlet英文词频统计
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))

#《三国演义》人物出场统计
import jieba
txt=open("三国演义.txt","r",encoding="utf-8").read()
words=jieba.lcut(txt)
counts={}
for word in words:
    if len==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))
    #第二个例子有些瑕疵，比如“孔明说”“却说”这些不是人名的字眼也会出现，只能通过结果筛选，在程序中指名道姓地避免，较为繁琐

5.1.8自动轨迹绘制

/*
给出一些参数，根据参数利用脚本绘制图形

基本思路
    1、定义数据文件格式（接口）
    2、编写程序，根据文件接口解析参数绘制图形
    3、编制数据文件

300,0,144,1,0,0
前三个参数对应：行进距离，转向判断（0：左转，1：右转），转向角度.后三个参数是RGB三个颜色通道（0~1间的浮点数）
*/
import turtle as t
t.title('自动轨迹绘制')
t.pencolor('red')
t.pensize(5)

#数据读取
datals=[]
f=open('data.txt')
for line in f:
    line=line.replace("\n","")
    #读取遍历每一行，并将最后的换行符变为空字符.此时 line存放的是定义的文件中每一行数据的接口的值
    datals.append(list(map(eval,line.split(","))))
    # split函数用逗号把字符串分割，生成列表（每个元素是用逗号分割的字符串）
    # map 函数的作用是把第一个参数作用于第二个参数上.本例中是将列表中每个元素的引号去掉
    # list将内部参数转换为列表
    #文件中的每一行经过三步处理后转为6个数值，作为列表的一个元素填入 datals中
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])

5.2库使用

5.2.1 time库

/*
time库是Python中处理时间的标准库
    计算机时间的表达
    提供获取系统时间并格式化输出功能
    提供系统级精确计时功能，用于程序性能分析
*/
import time
time.time() #获取当前时间戳，即计算机内部时间值，浮点数
#为：1567670013.2207754

time.ctime() #获取当前时间并以易读方式表示，返回字符串
#为：'Thu Sep  5 15:53:41 2019'

T=time.gmtime() #获取当前时间，表示为计算机可处理的时间格式
#为：time.struct_time(tm_year=2019, tm_mon=9, tm_mday=5, tm_hour=7, tm_min=53, tm_sec=48, tm_wday=3, tm_yday=248, tm_isdst=0)

/*
时间格式化：将时间以合理的方式展示出来
    格式化：类似字符串格式化，需要展示模板
    展示模板由特定的格式化控制符组成
strftime(tpl,ts) tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
strptime(str,tpl) str是字符串形式的时间值，tpi是格式化模板字符串，用来定义输入效果
*/
time.strftime("%Y-%m-%d %H:%M:%S",T)
#为：'2019-09-05 16:31:01'

timeStr='2019-09-05 16:37:55'
time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")
#time.struct_time(tm_year=2019, tm_mon=9, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=55, tm_wday=3, tm_yday=248, tm_isdst=-1)

/*
程序计时：测量起止动作所经历时间的过程
    测量时间：perf_counter() 返回一个CPU级别的精确时间计数值，单位为秒。由于该计数值起点不确定，连续调用取差值才有意义
    产生时间：sleep(s) s为休眠时间，单位是秒，可以是浮点数
*/
start=time.perf_counter()
end=time.perf_counter()
end-start
#为：5.327739800000018

def wait():
    time.sleep(3.3)
wait()
#程序将等待3.3秒后再继续运行

5.2.2 random库

/*
random库是Python中用于生成随机数的标准库
计算机无法生成真的随机数，但是可以通过梅森旋转算法生成伪随机数

1、基本随机数函数
Python中的随机数使用随机数种子生成，只要种子相同，产生的随机序列都是一样的
    seed(a=None) 初始化给定的随机数种子，默认为当前系统时间。如：random.seed(10) #产生种子10对应的序列
    random() 生成一个[0.0,1.0)之间的随机小数
*/
import random
random.seed(10)
random.random()
#为：0.5714025946899135
random.random()
#为：0.4288890546751146

/*
2、扩展随机数函数
    randint(a,b) 生成一个[a,b]之间的随机整数
    randrande(m,n[,k]) 生成一个[m,n]之间以 k为步长的随机整数
    getrandbits(k) 生成一个 k比特长的随机整数
    uniform(a,b) 生成一个[a,b]之间的随机小数
    choice(seq) 从序列 seq中随机选择一个元素
    shuffle(seq) 将序列 seq中元素随机排序，返回打乱后的序列
*/