2.1温度转换

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("输入格式错误")

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

2.2Python程序语法元素分析

2.2.3命名字与保留字

Python 语言允许采用大写字母、小写字母、数字、
组合给变量命名，但名字的首字符不能是数字，中间不空格,长度无限制。
注意：标识符，保留字对大小写敏感:python3中可以采用中文等非英语语言字符对变量命名

                              33个保留字列表

• 1

2.2.4字符串

字符串包括:正向递增系列和反向递减系列

1. 正向递增系列以最左侧字符序号为0 向右依次递增,最右侧序号为 L-1
2. 反向递减系列以最右侧字符序号为 -L 向左依次递减,最左侧序号为 -L
3. 字符串区间访问方式,[N:M]格式,表示字符串中从N到M (不包含M) 的子字符串
   例:s[-1]表示字符串s最后一个字符串;s[0:-1]表示从0到最后一个字符串 (不包含最后一个字符)

2.2.5赋值语句

1. = 表示赋值,右值赋值左变量
2. 同步复制语句
   <变量1>,…,<变量N> = <表达式1>,…,<表达式N>
   首先运行表达式N,并赋值给变量N
   好处: 互换变量 不需要中间值,如:x,y=y,x

2.2.6 input函数 输入函数

input(<提示性文字>)函数从控制台获得用户输入,并输出带提示性文字
无论用户输出字符还是数字,input()统一以字符串型输出

2.2.7分支语句 if-elif-else

类型: if-elif-else
例:

if s[-1] in ['F','f''] :
	<语句块1>
elif <条件2>:
	<语句块2>
else:
	<语句块3>

• 1
• 2
• 3
• 4
• 5
• 6

列表: [元素1, ... ,元素n]

• 1

2.2.8 eval()函数 去掉最外层引号

例如:

>>>s="102C"
>>>eval(s[0:-1])
102

• 1
• 2
• 3

输入”‘hello’”时,eval()去掉最外层引号后.结果为字符串’hello’
输入数字运算时,可搭配input()使用

>>>s=eval(input("请输入一个数字: "))
请输入一个数字: 10024.256
>>>print(s*2)
2048.512

• 1
• 2
• 3
• 4

2.2.9 print() 输出函数

纯信息输出时 print(<带输出字符串>)
格式化输出时 print()函数用槽格式,通过format()函数将输出变量格式化输出

>>>c=10
>>>print("转换后温度为{:.2f}C".format(c))
转换后温度为10.00C

• 1
• 2
• 3

2.2.10 循环语句 while

TempStr = input("请输入带有符号的温度值: ")
while TempStr[-1] not in ['N','n']:
    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("输入格式错误")
    TempStr = input("请输入带有符号的温度值: ")

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

2.2.11 函数定义 def temp():

定义一个 temp(ch)函数

def temp(ch):
	c=ch+2
	retun c

• 1
• 2
• 3

主函数写法 if __name__ == '__main__':

2.3 python蟒蛇绘制

import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
    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)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

引用函数库方式

1. import <库名>
2. form <库名> import <函数名>
   form <库名> import * (其中* 是通配符,表示所有函数)
3. import <库名> as <自定义名>
   例如:
   import turtle as t
   使用函数式则可以 t.fd()格式引用

2.4 turtle库语法元素分析

2.4.1 绘图坐标体系

1. 初始时,小海龟位于 画布正中央,此处坐标(0,0),行进方向为 水平右方
2. turtle绘图体系 绝对方位的0度为 画布正右方
3. turtle坐标系的 原点默认在屏幕左上角
4. 画布设置
   turtle.setup(width,height,startx,starty)
   作用:设置主窗体的大小位置
   参数:
   width:窗口宽度 ，若值是整数，表示像素值；若值是小数，表示窗口宽度与屏幕的比例。
   height:窗口高度，若值是整数，表示像素值；若值是小数，表示窗口高度与屏幕的比例。
   startx:窗口左侧与屏幕左侧的像素距离，如果值是None，窗口位于屏幕水平中央。
   starty:窗口顶部与屏幕顶部的像素距离，如果值是None，窗口位于屏幕垂直中央。

2.4.2 画笔控制函数

1. turtle.penup()
   别名: turtle.pu() , turtle up()
   作用:抬起画笔,之后移动不绘制形状

2. turtle.pendown()
   别名:turtle.pd() ,turtle.down()
   作用:落下画笔,运动会绘制形状(与turtle.penup()一组)

3. turtle.pensize(width)
   别名: turtle.width()
   作用:设置画笔尺寸
   参数:width画笔的宽度,如果为None或空,则返回当前画笔宽度

4. turtle.pencoclor(colorstring)或turtle.pencolor((r,g,b))
   作用:设置画笔颜色,无参数时返回当前画笔颜色
   参数:colorstring 表示颜色字符串,如”purple”,“red”,“blue”
   (r,g,b)颜色对应的RGB数值,如(51,204,140)
   

2.4.3 形状绘制函数

1. turtle.forward(d)
   别名:turtle.fd(d)
   作用:向当前行进方向前进 d距离
   参数:d行进距离的像素值,当值为负数时,向相反方向前进

2. turtle.bk(d)
   作用:向海龟 负方向移动 d距离 (海龟方向不改变)

3. turtle.setheading(angle)
   别名:turtle.seth(angle)
   作用:设置海龟当前前进方向angle,该角度为绝对方向角度
   参数:angle行进方向的绝对角度的整数值

4. turtle.left(angle)
   作用:海龟向左转
   参数:angle在海龟当前行进方向上旋转的角度

5. . turtle.right(angle)
   作用:海龟向右转
   参数:angle在海龟当前行进方向上旋转的角度

6. turtle.circle(r,extent=None)
   作用:根据半径r绘制extent角度的弧形
   参数:r半径,当值为正数时,半径在海龟左侧:但值为负数时,半径在海龟右侧.
   extent,绘制弧形的角度,但不设参数或设置为None时,绘制整个圆

7. turtle.done()
   作用:绘图完后手动退出,若不加,则程序完成就自动退出(一般都在绘图程序后加此函数)

8. turtle.speed()
   设置画笔速度(0-10),速度越大越快,大于10小于0.5时默认为0,0是最快的速度

9. turtle.undo()
   撤销上一次命令

10. .hideturtle()
    隐藏海龟

11. turtle.showturtle()
    显示海龟

2.4.4 遍历循环for-in

格式:

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

range(n) 产生0至n-1的整数系列,共循环n次
range(n,m)产生n至m-1的整数系列,共循环m-n次

• 1
• 2
• 3
• 4
• 5

3.1数字类型

3.1.2 整数类型

整数类型包括:十进制、二进制、八进制、十六进制

1. 十进制:默认采用
2. 二进制:以 0b或0B 引导,由0和1组成,例如0b101
3. 八进制:以 0o或0O 引导,由0到7组成例如0o711
4. 十六进制:以 0x或0X 引导,由0到9,a到f,A到F组成.例如0xABC

pow(x,y),计算x^y (x的y次方)

3.1.3 浮点型类型

表示方法:十进制和科学计数法
科学计数法:以字母e或E 作为幂的符号,以10为基数,e=a*10^b
例如:4.3e-3=0.0043

3.1.4 复数类型

复数的虚部以后缀 “j”或”J” 表示
其实部与虚部的数值都是浮点数
z.real 获取z的实部
z.imag或缺z的虚部

3.2 数字类型的操作

3.2.1 内置的数值运算操作符

3种数字类型的扩展关系: 整数->浮点数->复数
不同数字类型间运算所生成结果是”更宽”的类型
例如:整数浮点数与分数运算,结果为分数

3.2.2 内置的数值运算函数

3.2.3 内置的数字类型转换函数

复数不能直接转换为其他数字类型,可以通过.real和.imag提取实部和虚部,然后分别转换
例如:

>>>float((10+99j).imag)
99.0

• 1
• 2

3.3 模块1:math库的使用(需import引用该库)

3.3.2 math库解析

3.4 实例天天向上

【实例代码3.3】天天向上。
一年365天，如果好好学习时能力值相比前一天提高1%，当放任时相比前一中国人 天下降1%。效果相差多少呢？
此时，天天向上的力量是(1+0.01)³⁶⁵，相反的力量是(1-0.01)³⁶⁵。从0.001、0.005到0.01，这个每天努力的因素根据需求的不同而不断变化，因此，新代码中采用dayfactor变量表示这个值。这种改变的好处是每次只需要修改这个变量值即可，而不需要修改后续与该变量相关位置的代码。代码如下：

import math
dayfactor = 0.01
dayup = math.pow((1.0 + dayfactor), 365) # 提高dayfactor
daydown = math.pow((1.0 - dayfactor), 365) # 放任dayfactor
print("向上: {:.2f}, 向下: {:.2f}.".format(dayup, daydown))

• 1
• 2
• 3
• 4
• 5

【实例代码3.5】天天向上。
每周工作5天，休息2天，休息日水平下降0.01，工作日要努力到什么程度，一年后的水平才与每天努力1%取得的效果一样呢？
代码如下：

#e3.5DayDayUp365.py
def dayUP(df):
    dayup = 1.0
    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."%dayfactor)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

3.5 字符串类型及其操作

3.5.1字符串类型的表示

1. 单引号字符串:’单引号表示,可以使用双引号”作为字符串一部分
2. 双引号字符串:”双引号表示,可以使用单引号’作为字符串一部分
3. 三引号字符串:‘’‘三引号表示,可以使用’单引号’
   “双引号”
   也可以换行
   ‘’’

3.5.2 基本的字符串操作符

1. 5个字符串的基本操作符

2. 格式化控制字符 (\ 转义符)

3.5.3 内置的字符串处理函数

python3以Unicode字符为计数基础,字符串中英文字符和中文字符都是一个长度单位

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

恺撒密码

信息中每一个英文字符循环替换为字母表顺序中该字符后面第三个字符

plaincode = input("请输入明文: ")
for p in plaincode:
    if ord("a") <= ord(p) <= ord("z"):
        print(chr(ord("a") + (ord(p) - ord("a") + 3)%26),end='')
    else:
        print(p, end='')

• 1
• 2
• 3
• 4
• 5
• 6

3.5.4 内置的字符串处理方法

常用的16个内置字符串处理方法(全部共43个)

str为字符串或变量

3.6 字符串类型的格式化

3.6.1 format()方法的基本使用

格式:<模板字符串>.format(<逗号分隔的参数>)
format()中逗号分隔的参数按照 序号关系替换到模板字符串的槽中,槽用{}表示,如果槽中没有序号,则按照顺序替换
如果`需要输出大括号,采用{{{表示,}}表示}

>>>"圆周率{{{1}{2}}}是{0}",format("无理数",3.14,"...")
'圆周率{3.14...}是无理数'

• 1
• 2

3.6.2 format()方法的格式控制

格式如下表:

1. format()参数长度比<宽度>设定值大,则使用参数时间长度:如小于设定值,则默认以空格字符补充
2. <填充>指宽度内除参数外用什么表示,默认空格
3. <类型> 对于整数,输出格式包括一下6种
   (1) b: 输出整数的二进制形式
   (2) c: 输出整数对应的Unicode字符
   (3) d: 输出整数的十进制形式
   (4) o: 输出整数的八进制形式
   (5) x: 输出整数的小写十六进制方式
   (6) X: 输出整数的大写十六进制方式
   对于浮点数类型:
   (1) e: 输出浮点数对应的小写字母e的指数形式
   (2) E: 输出浮点数对应的大写字母E的指数形式
   (3) f: 输出浮点数的标准浮点形式
   (4) %: 输出浮点数的百分形式
   注:输出浮点数尽量 <.精度> 表示小数部分的宽度,更好控制输出格式

3.7 实例4: 文本进度条

1. import调用python标准时间库time,使用 time.sleep(t)将当前程序暂时挂起ts t可以是小数
2. 注意 默认情况下print()输出结尾自动产生一个’\n’ 换行符
   在print()中更换参数end的默认值为’’ ,即每次输出完不换行
3. 采用 time.clock()函数 增加运行时间的监控,该函数一般多次出现,第一次调用时计时开始,第二次及后续调用时 返回与第一次的时间差,单位为秒

实例:带刷新的文本进度条

多行文本进度条

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

带时间进度条

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,"-"))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

普通进度条

import time
def pace():
    for i in range(1, 101):
        print("\r", end="")
        print("下载进度: {}%: ".format(i), "▋" * (i // 2), end="")
        time.sleep(0.1)
pace()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

tpdm进度条

from time import sleep
from tqdm import tqdm
# tqdm 进度条库

for i in tqdm(range(1,1001)):
   # 模拟你的任务
   sleep(0.01)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

可视化进度条

import PySimpleGUI as sg
import time
mylist = [1,2,3,4,5,6,7,8,9,10]
for i, item in enumerate(mylist):
    sg.one_line_progress_meter('进度', i+1, len(mylist), '-key-')
    time.sleep(1)

• 1
• 2
• 3
• 4
• 5
• 6
• 7

4.1 程序的基本结构

程序基本结构组成: 顺序结构,分支结构和循环结构

4.2 分支结构

python的关系操作符

注意:
1.使用’=‘表示赋值语句,使用’==’ 表示等于
2. 字符串比较依次按照字典顺序进行,英文大写字符对于unicode编码比小写字符小

>>>"Python" > "python"
False

• 1
• 2

1. 单分支结构 if

格式:

if <条件>:
	<语句>

• 1
• 2

2.二分支结构 if-else

格式1:

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

• 1
• 2
• 3
• 4

格式2:紧凑结构

<表达式1> if <条件> else <表达式2>
#表达式1,2 一般是数字类型或字符串类型中的一个值

• 1
• 2

3. 多分支机构 if-elif-else

if <条件1>:
	<语句1>
elif <条件2>:
	<语句2>
else:
	<语句3>
#elif 可以多个

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

4.4 循环结构

1.遍历循环 for

格式:

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

• 1
• 2

遍历结构可以是 字符串,文件,组合数字类型或range()函数 等

# 循环n次
for i in range(n):

# 遍历文件fi的每一行
for line in fi :

# 遍历字符串s
for c in s:

# 遍历列表ls
for ltem inls:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

2.无限循环 while

while <条件>:
	<语句>
#其中 条件与if  中判断条件一样,结果为 True或False

• 1
• 2
• 3

3.循环保留字 break 和 continue

break : 跳出最内层for或while循环
continue : 结束当前当次循环,继续循环条件中的未执行语句

4. for和while的扩展模式

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

• 1
• 2
• 3
• 4
• 5

while <条件>:
	<语句>
else :
	<语句2>

• 1
• 2
• 3
• 4
• 5

for循环和while循环中都存在一个else扩展用法。else中的语句块只在一种条
件下执行，即循环正常遍历了所有内容或由于条件不成立而结束循环，没有因为
break 或returm(函数返回中使用的保留字)而退出。
continue保留字对else 没有影响

4.5 random库的使用 生成为随机数

蒙特卡罗方法求解π值

from random import random
from math import sqrt
from time import clock
DARTS = 1000
hits = 0.0
clock()
for i in range(1, DARTS+1):
    x, y = random(), random()
    dist = sqrt(x ** 2 + y ** 2)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits/DARTS)
print("Pi值是{}.".format(pi))
print("运行时间是: {:5.5}s".format(clock()))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

4.7 异常处理

1. 异常处理 try-except语句

格式1:

try :
	<语句1>
except:
	<语句2>

• 1
• 2
• 3
• 4

语句1的正常执行的程序内容,当发生异常时执行except后面的语句

格式2: 异常高级用法 支持多个except

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

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

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

else: 当try的语句1正常执行结束且没有发生异常时,else中语句3运行
finally: 无论try语句1是否异常,语句4都执行

5.1 函数的基本使用

1.函数的定义

1. 创建函数
   在 Python 中，使用 def 关键字定义函数：

def happy():
  print("happy")

• 1
• 2

2. 调用函数
   如需调用函数，请使用函数名称后跟括号：

def happy():
  print("happy")

happy()

• 1
• 2
• 3
• 4

3. lambda函数 -匿名函数
   函数可接受任意数量的参数，但只能有一个表达式。
   格式: <函数名> = lambda <参数列表 > : <表达式>

x = lambda a, b : a * b
print(x(5, 6))
>30
type(x)
> <class 'function>

• 1
• 2
• 3
• 4
• 5
• 6

2 函数的参数传递

1. 可选参数必须定义在非可选参数的后面,可选参数带有默认值
2. 可以设计可变数量的参数,通过在参数前加 ==*==实现,带星的可变参数只能放在参数列表最好,调用时这些参数被当成 元组 类型传递
3. 传参 :
   位置传参:调用时按照位置输入参数
   名称传参:按照形参名称输入实参,顺序可以任意调整

>>> func(x1,x2,x3,x4)
#位置传参
>>>result = func(1,2,3,4)
#名称传参:
>>> result = func( x1=1,x3=3,x2=2,x4=4)

• 1
• 2
• 3
• 4
• 5
• 6

4. 函数返回值 return
   可返回0个,1个或者多个结果
   返回多个结果时,以 元组类型 保存
   函数可以没有return,此时不返回值
5. pass 语句
   函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。
6. == 变量的作用域==
   全局变量: 定义在函数外,不缩进
   局部变量: 函数内部定义使用, 只在函数内部有效,函数结束后,局部变量被释放

1.局部变量可以与全局变量重名,但函数内局部变量不改变全局变量的值

total = 0 # 这是一个全局变量

def sum( arg1, arg2 ):
   total = arg1 + arg2 # total在这里是局部变量.
   print ("函数内是局部变量 : ", total)
   # 这里输出的是30
   return total

sum( 10, 20 )
print ("函数外是全局变量 : ", total)
# 输出全局变量 0

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

2. 简单数据类型变量用 global 声明后,作为全局变量使用,函数退出后 变量保留且值被函数改变

def myfunc():
  global x
  x = 100

myfunc()
print(x)
>100

• 1
• 2
• 3
• 4
• 5
• 6
• 7

3.组合数据类型的全局变量 (列表字典),如果在函数内部没有被真实创建的同名变量,则函数内部可以中间使用并修改全局变量的值, 如果函数内部存在同名真实创建的列表,则函数使用该列表不会改变全局变量

ls = []
def f( a ,b ):
	li.append(b) #将局部变量b增加到全局变量ls中
	return a*b
s = f ( "kno~",2)
print( s ,ls)
#输出 kno~kno~ [2]

• 1
• 2
• 3
• 4
• 5
• 6
• 7

ls = [ ]#全局变量ls
def f( a ,b ):
	ls = [] #同名的局部变量 ls
	li.append(b) #将局部变量b增加到局部变量ls中
	return a*b
s = f ( "kno~",2)
print( s ,ls)
# 输出 kno~kno~ []

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

3 datatime库的使用 —-标准时间库

1.datatime 的概述

2.datatime的解析

创建datatime对象的三种方法datetime.now()，datetime.utcnow()，datetime.datetime().
1.datatime.now() 获取当前的日期和时间对象,返回datatime.datatime类型,
2.datatime.utchow ()获取当前日期和时间对应的UTC时间,返回datatime类型
3.datatime()构造一个日期时间对象
方法 datatime(year,moth,day,hour=0,minute=0,second=0,microsecond=0)

>>> from datetime import datetime
>>> today= datetime.now()      #返回一个datetime类型，表示当前日期和时间，精确到微秒。
>>> today
datetime.datetime(2020, 9, 19, 9, 46, 35, 391262)

>>> today= datetime.utcnow()	#返回一个datetime类型，表示当前日期和时间的UTC（世界标准时间）表示，精确到微秒。
>>> today
datetime.datetime(2020, 9, 19, 1, 48, 53, 506101)

>>> today = datatime(2020, 9, 19, 1, 48, 53, 506101)
datetime.datetime(2020, 9, 19, 1, 48, 53, 506101)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

datatime类常用的属性,创建today为datetime对象:

datatime 对象常用的时间格式化方法:

today= datetime(2020,9,19,10,0,35,397865)
today.isoformat() #运行结果：'2020-09-19T10:00:35.397865'
today.isoweekday() #运行结果：6
today.strftime("%Y-%m-%d %H:%M:%S")#运行结果'2020-09-19 10:00:35'

• 1
• 2
• 3
• 4
• 5

strtime()格式化字符串的数字左侧会自动补零

strftime()方法的格式化控制符表:

4 七段数码管绘制

import turtle, datetime
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): #根据数字绘制七段数码管
    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 == '-':
            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(datetime.datetime.now().strftime('%Y-%m=%d+'))
    turtle.hideturtle()
main()    

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45

5 代码复用和模块化设计

基本要求:
1.紧耦合: 功能块内部耦合紧密
2.松耦合: 功能块之间耦合度底

6.函数递归

使用递归一定要有基例的构建,可以多个基例,基例决定递归的深度
默认情况调用1000层,python解释器终止程序,
若需要超过1000层,可用下面代码设定

import sys
sys.setrecursionlimit(2000)  #2000是新的递归层数

• 1
• 2

1. 字符串反转

def reverse(s):
    if s == "":
        return s
    else:
        return reverse(s[1:]) + s[0]
str = input("请输入一个字符串: ")
print(reverse(str))

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2. 阶乘

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7

3. 科赫雪花

import turtle
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.setup(600,600)
    turtle.speed(0)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    level = 5
    koch(400,level) 
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
main()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

8 python内置函数68个

1.数学运算：

2.类型转换：

3.序列操作：

4.对象操作：

5.反射操作：

6.变量操作：

7.交互操作：

8.文件操作：

9.编译执行:

10.装饰器：

常用函数解析

1. hasattr(object,name)）
   判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object,name)是否抛出异常来实现的）

hasattr(list,'add')
Out[4]: False
hasattr(list,"append")
Out[5]: True

• 1
• 2
• 3
• 4
• 5

2. all(x)
   x为组合类型数据,可迭代对象（列表、元组、字典）
   如果其中全部元素为True,则都返回True,否则False
   注意: ==整数0,空字符串””,空列表[]等都当初False

检查列表中的所有项目是否为 True：

mylist = [0, 1, 1]
x = all(mylist)

• 1
• 2
• 3
• 4

3. any()
   与all()相反,只要组合数据类型有一个是True,则返回True,全部元素为False,则返回False

4.id()
返回元组对象的唯一 id,可以通过比较两个变量编号是否相同判断数据是否一致

5. reversed()返回组合数据类型的逆序形式

反转列表的顺序，并打印每个项目：

alph = ["a", "b", "c", "d"]
ralph = reversed(alph)
for x in ralph:
  print(x)

• 1
• 2
• 3
• 4
• 5
• 6

6. sorted(iterable, key=key, reverse=reverse)
   对一个系列进行排序,默认从小到大
   参数 描述
   iterable 必需。要排序的序列，列表、字典、元组等等。
   key可选。执行以确定顺序的函数。默认为 None。
   reverse可选。布尔值。False 将按升序排序，True 将按降序排序。默认为 False。

7.type() 返回数据对应类型

6.1 组合数据类型概述

组合数据类型: 序列类型,集合类型,映射类型

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

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

映射类型：是键—值数据项的组合，每个元素是一个键值对，表示为（key，value）

6.1.1 序列类型

1. 序列类型是一维元素向量，元素之间存在先后关系，通过序号访问
2. 序列中可以存在数值相同但位置不同的元素
3. 序列类型支持成员关系操作符in、长度计算函数len()、分片[]以及元素本身也可以是序列类型
4. 序列类型有str（字符串）、tuple（元组）、list（列表）等。
5. 只要是序列类型，都可以使用相同的索引体系，即正向递增序号和反向递减序号

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

6.1.2 集合序列

1. 包含0个或多个数据项的无序组合,不可索引,无位置概念,分片,元素不可重复，元素类型只能是固定数据类型，例如整数、浮点数、字符串以及元组等。列表、字典以及集合类型本身都是可变数据类型，不能作为集合元素出现，能够进行哈希运算的类型都可以作为集合的元素
2. hash() 哈希运算函数,对数据类型生成一个哈希值
3. 可以动态增加或删除
4. 打印效果与定义顺序不一定一致,其元素唯一性,可用于 过滤重复元素
5. 集合用大括号{}表示, set(x)可用于生成集合
6. 直接使用{}无法生成集合,生成的是空字典
7. 集合四种基本操作 交集(&),并集(|),差集(-),补集(^)
8. 集合主要用于 成员关系测试,元素去重,删除数据项

>>> A = {"python", 123, ("python", 123)} 
>>> print(A);
{123, 'python', ('python', 123)}
>>> B = set("pypy123"); #使用set建立集合
>>> print(B);
{'y', '3', 'p', '2', '1'}
>>> C = {"python", 123, "python", 123};
>>> print(C);
{123, 'python'}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

集合类型的操作符

集合类型的操作函数或方法

6.1.3映射类型

映射类型是“键—值”的数据项的组合，每个元素是一个键值对，即元素是（key，value），元素之间是无序的，键值对（key，value）是一种二元关系。
键和值通过冒号连接，不同键值对通过逗号隔开。主要是以字典(dist)体现,字典是集合类型的延续，所以各个元素并没有顺序之分。键和值可以是任意数据类型，包括程序自定义的类型。

6.2.1 元组概述

1. 元组tuple是包含0个或多个数据项的不可变序列类型,因为它一旦创建就不能被修改，并且元组生成后固定的，其中的任何数据项不可替换或者删除
2. 元组类型在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历等情况下十便利。
3. Python中元组采用逗号和圆括号来表示。
4. 生成元组只需要使用逗号将元素隔离开即可。也可以增加圆括号，但圆括号在不混淆语义的情况下不是必须的。
5. 一个元组可以作为另一个元组的元素，并且可以采用多级索引来获取信息。
6. 也可以使用 tuple() 构造函数来创建元组

元组tuple是包含0个或多个数据项的不可变序列类型，并且元组生成后
固定的，其中的任何数据项不可替换或者删除

>>>print( 'abc', -4.24e93, 18+6.6j, 'xyz')
>>>x, y = 1, 2
>>>print( "Value of x , y : ", x,y)
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

• 1
• 2
• 3
• 4
• 5

6.2.2 列表概述

1. 是一种有序和长度内容可更改。允许重复的成员。没有长度限制
2. 列表也支持成员关系操作符in、长度len（）以及分片[]等操作。
3. 列表可以同时使用正向递增序号何反向递减序号，也可以采用标准的比较操作符（<=/==/!=/>=/>）进行比较，列表比较其实是单个数据项的逐个比较。
4. 列表用中括号[]表示，也可以通过list（）函数将元组或字符串转化成列表。直接使用list（）函会返回一个空列表。
5. 简单将一个列表赋值给另一个列表不会生成新列表对象
   因为：list2 将只是对 list1 的引用，list1 中所做的更改也将自动在 list2 中进行。

>>>is=[1,"b",1]
>>>it=is #it只是对is的引用,it不包括真实数据,修改is同时也会修改it
>>>is[0]=0
>>>print(it)
[0,"b",1]

• 1
• 2
• 3
• 4
• 5
• 6
• 7

列表类型特有的函数和方法

当使用一个列表改变另一个列表时，Python不要求两个列表长度一样，但遵循“多增少减”的原则

如下：

>>>vlist=list[range(5)]
>>>vlist[1:3] = ["new","bit",1]
>>>vlist
[0,"new","bit",1,3,4]
>>>vlist[1:3]=["fewer"]
>>>vilst
[0,"fewer",1,3,4]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

#检查列表中是否存在 “apple”：
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
  print("Yes, 'apple' is in the fruits list")

• 1
• 2
• 3
• 4

6.2.3 字典概述

1. Python 最强大的数据类型之一，通过键-值对的方式建立数据对象之间的映射关系。字典的每个键-值对用冒号:分割，每个键-值对间用逗号,分隔开，字典则包含在{}中。每个键都与一个值相关联，我们可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何 Python 对象用作字典中的值。
   格式如下：

d = { key1 : value1, key2 : value2 }  

• 1

2. 键值对之间没有顺序且不能重复,打印效果可能跟定义顺序不一致
3. 键值对的访问模式

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

• 1

4. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
5. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
6. 直接使用大括号{}可以创建一个空字典,并通过中括号[]向其增加元素
   注意: 直接使用大括号不能生成空集合,需要使用set()

>>> d={}
>>>d['2^10']=1024
>>>print(d)
{'2^10:1024}

• 1
• 2
• 3
• 4

字典类型的函数和方法

list1 = ['Author', 'age', 'sex']
dic1 = dict.fromkeys(list1)
dic2 = dict.fromkeys(list1, 'Python')

# dic1 = {'Author': None, 'age': None, 'sex': None}
# dic2 = {'Author': 'Python', 'age': 'Python', 'sex': 'Python'}

• 1
• 2
• 3
• 4
• 5
• 6

如果希望方法返回的是列表类型,可以使用list()