python学习2019/05/11

无限循环

while
反复执行语句块，知道条件不满足

a = 3
while a>0:
a = a-1
print(a)

输出 2，1，0

如果条件一直满足会无限循环
使用ctrl + c，停止

循环跳出保留字
break，continue

for c in ‘Python’:
if c == ‘t’:
break
# continue
print(c,end=’’)

break 从t开始，全部停止
continue 跳过t

s = ‘Python’
while s != ‘’:
for c in s:
if c == ‘t’:
break #仅跳出当前最内层循环
print(c,end=’’)
s = s[:-1]

还可以加入else

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

s = ‘Python’
while s != ‘’:
for c in s:
if c == ‘t’:
break #仅跳出当前最内层循环
print(c,end=’’)
else:
print(‘我没遇到t所以没被break’)
s = s[:-1]
else:
print(‘那你不是好棒棒’)

RANDOM库

随机数
seed = （a= none）
初始化给定的随机数种子，默认为当前系统时间
random.seed(10)
#产生种子10对应的序列
random（）
生成一个【0.0，1.0）之间的随机小数
random。random（）

import random
random.seed(10)
#设置随机数种子，产生可复现的情况
#如果不设置，那么随机数默认调用系统时间产生不可复现的情况。
a = random.random()*2+100
#默认0.0-1.0之间的随机数
#设置需要在后面加算式。。
print(a)
b = random.randint(1,100)
#随机一个a-b 之间的整数
print(b)
c = random.randrange(10,100,10)
#随机生成一个（M,N[,K]）从M-K之间的整数，K为步长
print©
d = random.getrandbits(10)
#生成一个（k）比特长的随机整数
print(d)
e = random.uniform(10,100)
#生成一个（a，b）之间的随机小数
print(e)
f = random.choice([1,2,3,4,5,6,7,8,9])
#生成序列（seq）之间的随机元素
print(f)
g = [1,2,3,4,5,6,7,8,9]
random.shuffle(g)
#生成随机序列（seq），生成的是打乱的序列
print(g)

输出：
101.14280518937983
55
80
591
11.334920142209832
8
[3, 9, 7, 4, 1, 2, 6, 5, 8]

圆周率

#圆周率的近似计算公式
pi = 0
N = 100 #取一个无限大的值，这边先取100
for k in range(N): #\使代码进行换行
pi += 1/pow(16,k)(
4/(8k+1)-2/(8k+4)-
1/(8k+5)-1/(8*k+6))
print(‘圆周率是：{}’.format(pi))

#蒙特卡罗方法
#抛洒无限多的点，计算在需要求的面积内与面积外的点的比例
#取一个半径为1的圆的1/4开始计算
from random import random #调用随机函数
from time import perf_counter #调用计时函数
DARTS = 1000000 #设置一个初始变量，作为总抛洒数量
hits = 0.0 #初始在圆内的点数量
start = perf_counter() #计时开始
for i in range(1,DARTS+1): #开始抛洒，i= 1-1000000的遍历
x,y = random(),random() #x，y的坐标轴为随机值
dist = pow(x2+y2,0.5) #取x的平方与y平方之和的开方，也就是在圆内的情况
if dist <= 1.0: #如果dist小于等于圆的半径1那么就是这个点在圆内部
hits = hits+1 #那么hits计数+1
pi = 4*(hits/DARTS) #抛洒1000000次有hits次在圆内部，hits/DARTS
#因为取的是1/4的圆，所以需要再*4，求得的面积
print(‘圆周率是：{}’.format(pi))
print(‘运行时间是：{:.5f}秒’.format(perf_counter()-start))

理解方法思维

数学思维，找到公式，利用公式求解
计算思维，抽象一种过程，用计算机自动化求解

程序运行时间分析

利用time库的计时方法获得程序运行时间
以便更好的优化程序

#for x in range(1,966,2):
#for y in range(2,966,2):
#a = x-y
#print(a)
#print(a)

s = 0 #设起始值为0
count = 1 #从1开始计算
while count <= 966: #count的值为1-966
if count%2 == 0: #如果count为偶数
s -= count #减去之前得出的count的值
else:
s += count #否则加上当前count的值
count += 1 #当前count的值加1再进行判断
print(s) #循环结束，输出s的值

s = ‘’ #赋值s字符串
for i in range(100,1000): #要求i为一个三位整数
t = str(i) #把i变为字符串形式
if pow(eval(t[0]),3)+
pow(eval(t[1]),3)+
pow(eval(t[2]),3)== i:
#i的第1，2，3位的三次方链接起来都是与i相等的水仙花数
s += ‘{},’.format(i)
#输出这几个数并组成列表，并在每个数后加，号
print(s[:-1]) #输出这个列表至最后一位，不要，号

count = 0 #设置输入次数初始值为0
while count<3: #在次数小于3时循环
name = input() #要求用户输入账户名
password = input() #要求用户输入密码
if name == ‘Kate’ and password == ‘666666’:
#如果账户名与密码都正确
print(‘登录成功！’)
break #跳出
else:
count += 1 #否则次数+1
if count == 3: #如果次数等于3
print(‘3次用户名或密码均有误！退出程序’)

def f(n): #设置函数f ，参数列表n
max = pow(10,n) #设置max=10的n次方
ls = [] #设置ls为一个list
for i in range(1,max): #遍历i = 1- max-1。
t = str(i) #设置t为字符串i
l = len(t) #设置l为t的字符串长度
sum = 0 #设置sum的初始值为0
for j in range(l): #遍历j = 1- l-1
sum += pow(int(t[j]),n)
#sum 赋值+ t的第j位字符转化为int的n次方
if sum == i: #如果sum等于i
ls.append(i) #在ls列表的末尾添加i
return ls #输出ls列表

ls = f(4) #ls列表内f函数的n值为4
for i in ls: #设置i遍历 列表ls
if i >= 1000: #当i大于等于1000时，输出i
print(i)

def f(n): #设置一个函数f ，参数为n
sum = 0 #起始数字为 0
for n in range(2,n): #设置n遍历2- n-1
x = int(pow(n,0.5))+1 #设置x为 n开方+1的整数
for i in range(2,x): #设置i 遍历 2- x-1
if n % i == 0: #如果n/i的值余0
break #跳出
else:
sum += n #否则起始数字+n
return sum #返回起始数字

sum = f(100) #设置起始数字=函数f内n参数为100
print(sum) #输出sum

函数

def <函数名>(参数0个或者多个):
<函数体>
return <返回值>
函数可以没有参数，但是也必须保留括号

函数外定义的变量叫全局变量
函数内定义的叫局部变量
1.局部变量和全局变量是不同的变量，
局部变量与全局变量可能重名但是不同

n,s = 10,100
def fact(n):
s = 1 #global s
for i in range(1,n+1):
s *= i
return s
print(fact(n),s)
#输出为3628800 ，100
#如果要在函数内部使用全局变量。
#需要使用保留字global

2。局部变量为组合数据类型且未创建，等同于全局变量
ls = [‘F’,‘f’]
def func(a):
ls.append(a)
return
func(‘c’)
print(ls)
#输出为[‘F’, ‘f’, ‘c’]

lambda函数

匿名函数
用于定义简单的，可以在一行内表示的函数
《函数名》 = lambda《参数》：《表达式》
f = lambda x,y:x+y
print(f(10,15))

七段数码管绘制

1.绘制单个数字对应的数码管
2。绘制一串数字，绘制对应的数码管
3.获得当前系统时间，绘制对应的数码管
from turtle import *
from time import *
def DrawGap():
penup()
fd(5)

def DrawLine(draw): #画一条40长的线，#当draw为True时下笔，False时收笔
DrawGap()
pendown() if draw else penup()
fd(40)
DrawGap()
right(90)

def DrawDigit(digit): #当digit取值为【】内值时时下笔，False时收笔。每次右转90度
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)
left(90) #左转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)
left(180) #左转180度
penup() #提笔
fd(20) #前行20

def DrawDate(date): #设置一个时间函数
pencolor(‘red’) #字体颜色
for i in date:
if i == ‘-’: #输入-字符时
write(‘年’,font=(‘Arial’,20,‘normal’))
#输出年，【字体，字号，字形】
pencolor(‘green’) #颜色
fd(40) #前进40
elif i == ‘=’:
write(‘月’,font=(‘Arial’,20,‘normal’))
pencolor(‘blue’)
fd(40)
elif i == ‘+’:
write(‘日’,font=(‘Arial’,20,‘normal’))
else:
DrawDigit(eval(i)) #将i变为整数变量

def main(): #定义函数主程序
setup(800,350,200,200) #创建一个窗体
penup() #提笔
fd(-300) #后退300
pensize(5) #画笔尺寸5
DrawDate(strftime(’%Y-%m=%d+’,gmtime())) #输出函数DrawDate
hideturtle() #隐藏画笔
done() #结束
main() #运行主程序

理解方法思维

模块化思维
确定模块接口，封装功能

规则化思维
抽象过程为规则，计算机自动执行

化繁为简
将大功能变为小功能组合，分而治之

代码复用与函数递归

把代码当成资源进行抽象
代码资源化
程序代码是一种用来表达计算的资源
代码抽象化
使用函数等方法对代码赋予更高级别的定义
代码复用
同一份代码在需要时可以被重复使用

函数和对象是代码复用的两种主要形式
函数：对代码命名
在代码层面建立了初步抽象
对象：属性和方法
《a》。《b》和
《a》。《b》（）
在函数之上再次组织进行抽象

分而治之
通过函数或对象封装将程序划分为模块及模块之间的表达
具体包括：
主程序与子程序和子程序之间的关系
分而治之：
一种分而治之，分层抽象，体系化的设计思想

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

模块内部紧耦合
模块之间松耦合

链条
计算过程存在递归链条
基例
存在一个或多个不需要再次递归的基例
类似数学归纳法、
数学归纳法、
证明当n取第一个值n0时命题成立
假设当nk时命题成立，证明当nk+1时，命题也成立
递归是数学归纳法在编程中的体现

递归的实现
函数+分支语句
递归本身是一个函数，需要函数定义方式描述
函数内部，采用分支语句对输入参数进行判断
基例和链条，分别编写对应代码

def fact(n):
if n == 0:
return 1
else:
return n * fact(n-1)
fact(5)
print(fact(5))

反转字符串

def rvs(s):
if s == ‘’:
return s
else:
return rvs(s[1:])+s[0]

a = rvs(‘asdfadf’)
print(a)

斐波那契数列

def f(n):
if n == 1 or n == 2:
return 1
else:
return f(n-1)+f(n-2)

b = f(10)
print(b)

汉诺塔

count = 0
def hanoi(n,scr,dst,mid):
global count
if n == 1:
print(’{}:{}->{}’.format(1,scr,dst))
count += 1
else:
hanoi(n-1,scr,mid,dst)
print(’{}:{}->{}’.format(n,scr,dst))
count += 1
hanoi(n-1,mid,dst,scr)

hanoi(3,‘a’,‘b’,‘c’)
print(count)

输出
1:a->b
2:a->c
1:b->c
3:a->b
1:c->a
2:c->b
1:a->b
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():
setup(600,600)
penup()
goto(-200,100)
pendown()
pensize(2)
level = 4 #科赫雪花，阶数
koch(400,level)
right(120)
koch(400,level)
right(120)
koch(400,level)
hideturtle()
done()
main()

课后习题
分形几何，举一反三
练习编译康托尔集，谢尔宾斯基三角形，门罗海绵，
龙型曲线，空间填充曲线，等