Python学习笔记

最新推荐文章于 2021-03-12 16:57:33 发布

LZH0217

最新推荐文章于 2021-03-12 16:57:33 发布

阅读量348

点赞数

分类专栏： Python 文章标签： Python

本文链接：https://blog.csdn.net/weixin_44169557/article/details/102875238

版权

Python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Python学习笔记

实例1：温度转换

# TempConvert.py
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个空格或1个Tab
注释
1. 单行注释以#开头，其后内容为注释信息
2. 多行注释以’’'开头和结尾
变量用来保存和保存数据的占位符
1. 变量采用标识符（名字）来表示，关联标识符的过程叫命名
2. 可以使用等号（=）向变量赋值或修改值，=被称为赋值符号
命名
1. 命名规则大小写字母、数字、下划线和汉字等字符及组合
2. 注意事项大小写敏感、首字母不能是数字、不与保留字相同
保留字 被编程语言内部定义并保留使用的标识符（33个保留字）

and as assert break class continue
def elif else except finally for
from if import in is lambda
not or pass raise return try
while with yield del global nonlocal
True False None
数据类型
1. 数字类型
  - 整数
  - 浮点数
2. 字符串类型由0个或多个字符组成的有序字符序列
  - 字符串由一对单引号或一对双引号表示
  - 字符串是字符的有序序列，可以对其中的字符进行索引
3. 字符串的序号
  - 正向递增序号（开头是0，向后递增）
  - 反向递减序号（末尾是-1，一直向前递减）
4. 字符串的使用使用[]获取字符串中一个或多个字符
  - 索引：返回字符串中单个字符 <字符串>[M] 例如"请输入:"[0]、TempStr[-1]
  - 切片：返回字符串中一段字符子串 <字符串>[M:N] 例如"请输入:"[1:3]、TempStr[0:-1]
5. 列表类型由0个或多个数据组成的有序序列
  - 列表使用[]表示，采用逗号(,)分隔各元素
  - 使用保留字 in 判断一个元素是否在列表中
语句和函数
赋值语句
1. 赋值语句用来给变量赋予新的数据值
2. 赋值语句右侧的数据类型同时作用于变量
Python程序的输入输出
1. 输入函数input() 从控制台获得用户输入的函数
  - input()函数的使用格式：<变量> = input(<提示信息字符串>)
  - 用户输入的信息已字符串类型保存在<变量>中
2. 输出函数print() 以字符形式向控制台输出结果的函数
  - print()函数的基本使用格式：print(<拟输出字符串或字符串变量>)
  - print()函数的格式化：print("转换后的温度是{:.2f}C".format(C))，{}表示槽，后序变量填充到槽中，{:.2f}表示将变量C填充到这个位置时取小数点后2位
评估函数eval() 去掉参数最外侧引号并执行余下语句的函数，基本使用格式：eval(<字符串或字符串变量>)


and	as	assert	break	class	continue
def	elif	else	except	finally	for
from	if	import	in	is	lambda
not	or	pass	raise	return	try
while	with	yield	del	global	nonlocal
True	False	None

实例2：Python蟒蛇绘制

#PythonDraw.py
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)
turtle.done()

import保留字引入了一个绘图库，名字叫turtle

turtle库的使用

turtle(海龟)库是turtle绘图体系的Python实现，turtle绘图体系诞生于1969年，主要用于程序设计入门，是Python语言的标准库之一，是入门级的图形绘制函数库。

标准库
Python计生态 = 标准库 + 第三方库
标准库：随解释器直接安装到操作系统中的功能模块
第三方库：需要经过安装才能使用的功能模块
库Library、包Package、模块Module，统称模块

turtle绘制窗体布局

绘制turtle图形，首先需要一个绘图窗体，在操作系统上表现为一个窗口，它是turtle的一个画布空间，在窗口中使用的最小单位是像素
turtle.setup(width, height, startx, starty)
设置窗体大小和位置，4个参数后两个可选，setup()不是必须的，若没有后两个参数，那么系统会默认该窗口在屏幕正中心

turtle空间坐标体系（绝对坐标 & 海龟坐标）

turtle.goto(x, y) 让海龟到达某一个坐标位置
海龟坐标
以海龟自身的运动方向为参照，对于海龟来讲它的当前行进方向为前进方向，反方向为后退方向，海龟运行的左侧叫左侧方向，右侧叫右侧方向
- turtle.fd(d) 前进
- turtle.bk(d) 后退
- turtle.circle(r,angle) 以海龟当前位置的左侧距离为r的点为圆心进行角度为angle的曲线运动

turtle的角度坐标体系

绝对角度 可以用turtle.seth(angle)来改变海龟的行进角度，注意seth()只改变方向但不前进，angle为绝对度数
turtle.setheading(angle) 别名 turtle.seth(angle)
海龟角度
- turtle.left(angle) 向左旋转angle度
- turtle.right(angle) 向右旋转angle度注意只改变角度但不改变位置

RGB色彩体系

由三种颜色构成万物色
RGB指红蓝绿三个通道的颜色组合，覆盖视力所能感知的所有颜色，RGB每色取值范围0-255整数或0-1小数
turtle库默认采用RGB的小数值来表示颜色，当然也可以使用整数值来表示颜色
turtle.colormode(mode) 切换RGB色彩模式，1.0：RGB小数模式，255：RGB整数模式

画笔控制函数

turtle.penup()
turtle.pendown()
turtle.pensize(width)
turtle.pencolor(colorstring) 改变画笔颜色有三种写法字符串
turtle.pencolor(r,g,b) 数值
turtle.pencolor((r,g,b)) 元组

循环语句和range()函数

循环语句按照一定次数循环执行一组语句

for <变量> in range(<参数>):
<被循环执行的语句>

range()函数

range(N) 产生0到N-1的整数序列，共N个
range(M,N) 产生M到N-1的整数序列，共N-M个

基本数据类型

整数类型

可正可负，没有取值范围限制
pow(x,y)函数：计算 $x^y$ ，想算多打算多大
4种进制表示形式
- 十进制
- 二进制，以0b或0B开头
- 八进制，以0o或0O开头
- 十六进制，以0x或0X开头

浮点类型

与数学中实数的概念一致

带有小数点及小数的数字
浮点数取值范围和小数精度都存在限制，但常规计算可忽略
取值范围数量级约 ${-10}^{308}$ 至 ${10}^{308}$ ，精度数量级 ${10}^{-16}$
浮点数间运算存在不确定尾数，这不是bug
round(x,d)，对x四舍五入，d是小数截取位数
浮点数间运算及比较用round()函数辅助
不确定尾数一般发生在 $10^{-16}$ 左右，round()十分有效

复数类型

与数学中的复数概念一致

定义 $j=\sqrt{-1}$ ，以此为基础，构建数学体系
$a + b j$ 被称为复数，其中a是实部，b是虚部

复数实例 $z = 1.23 e - 4 + 5.6 e + 89 j$

z.real获得实部
z.imag获得虚部

客观讲复数类型在常规的计算机编程中很少使用但是它却是进行空间变换尤其是跟复变函数相关的科学体系中最常用的一种数据类型

数值运算操作符

$x + y$
$x - y$
$x * y$
$x / y$ 除，结果是浮点类型
$x / / y$ 整数除，结果是整数
$+ x$
$- y$
$x\%y$ 余数，模运算
$x * * y$
- 幂运算，x的y次幂， $x^y$ ，与pow(x,y)的效果一样
- 当y是小数时，开方运算，10**0.5的结果是 $\sqrt{10}$
$x + = y$
$x - = y$
$x * = y$
$x / = y$
$x / / = y$
$x\%=y$
$x * * = y$

不同数字类型间可进行混合运算，生成结果为“最宽”类型
三种类型存在一种逐渐“扩展”或“变宽”的关系：整数 -> 浮点数 -> 复数

数值运算函数

abs(x)，绝对值，x的绝对值
divmod(x,y)，商余，(x//y,x%y)，同时输出商和余数，例如 divmod(10,3)，结果为(3,1)
pow(x,y[,z])，幂余，(x**y)%z，[…]表示参数z可省略
round(x[,d])，四舍五入，d是保留小数位数，默认值为0，也就是取整
max(x1,x2,...,xn)，返回最大值，n不限
min(x1,x2,...,xn)，返回最小值，n不限
int(x)，将x变成整数，舍弃小数部分
float(x)，将x变成浮点数，增加小数部分
complex(x)，将x变成复数，增加虚数部分

实例3

#DayDayUp.py
dayup = pow(1.001, 365)
daydown = pow(0.999, 365)
print("向上:{:.2f}, 向下:{:.2f}".format(dayup, daydown))

运行结果
向上:1.44, 向下:0.69

#DayDayUp3.py
dayup = 1.0
dayfactor = 0.01
for i in range(365):
   if i % 7 in [6,0]:
      dayup = dayup * (1 - dayfactor)
   else:
      dayup = dayup * (1 + dayfactor)
print("工作日的力量:{:.2f}".format(dayup))

#DayDayUp4.py
def dayUP(df):
   dayup = 1
   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("工作日的努力参数是:{:.2f}".format(dayfactor))

字符串类型及操作

字符串

字符串有2类共4种表示方法

如果希望在字符串中出现单引号，那么两侧可以使用双引号来表示字符串，这样其中的单引号就变成了字符
如果希望在字符串中出现双引号，那么两侧可以使用单引号来表示字符串，这样其中的双引号就变成了字符
如果希望在字符串中既出现单引号又出现双引号，可以用三个单引号表示字符串，那么其中出现的一个单引号或者一个双引号就变成了字符串中的字符

字符串的序号

正向递增序号和反向递减序号

字符串的使用

索引和切片

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

索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符子串 <字符串>[M:N]

字符串切片高级用法

使用[M:N:K]根据步长对字符串切片

<字符串>[M:N]，M缺失表示至开头，N缺失表示至结尾
<字符串>[M:N:K]，根据步长对字符串切片
- 例如：
  “〇一二三四五六七八九”[1:8:2]结果是"一三五七"
  “〇一二三四五六七八九”[::-1]结果是"十九八七六五四三二一〇"

字符串的特殊字符

转义符 \

转义符表达特定字符的本意

字符串操作符

x+y
n*x 或 x*n，n是整数，将字符串x复制n次
x in s

字符串处理函数

len(x)

返回字符串长度

str(x)

任意类型x所对应的的字符串形式

hex(x) 或 oct(x)

整数x的十六进制或八进制小写形式字符串

chr(u)

u为Unicode编码，返回其对应的字符

ord(x)

x为字符，返回其对应的Unicode编码

字符串处理方法

“方法”在编程中是一个专有名词

“方法”特指<a>.<b>()风格中的函数<b>()
方法本身也是函数，但与<a>有关，<a>.<b>()风格使用
字符串及变量也是<a>，存在一些方法

<a>.<b>()风格是面向对象的一种使用风格，其中a是对象，b是某一个对象能够提供的功能，我们叫方法。方法必须要用 . 的形式来使用

八个常用的字符串处理方法

str.lower()或str.upper()返回字符串的副本，全部字符小写/大写
str.split(sep=None)返回一个列表，由str根据sep被分隔的部分组成
str.count(sub)返回子串sub在str中出现的次数
str.replace(old,new)返回字符串str副本，所有old子串被替换为new
str.center(width [,fillchar])字符串str根据宽度width居中，fillchar可选，空余部分填充fillchar
str.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符
str.join(iter)在iter变量除最后元素外每个元素后增加一个str

字符串类型的格式化

格式化是对字符串进行格式表达的方法

字符串格式化使用.format()方法
- <模板字符串>.format(<逗号分隔的参数>)
槽占位信息符
- 使用 {} 表示

format()方法的格式控制

槽内部对格式化的配置方式
{<参数序号>:<格式控制标记>}

:	<填充>	<对齐>	<宽度>	< , >	<.精度>	<类型>
引导符号	用于填充的单个字符	<左对齐，>右对齐，^居中对齐	槽设定的输出宽度	数字的千位分隔符	浮点数小数精度或字符串的最大输出长度	整数类型b,c,d,o,x,X 浮点数类型e,E,f,%

time库的使用

time库是Python中处理时间的标准库

时间获取

time()
获取当前的时间戳，即计算及内部的时间值，浮点数，它表示从1970年1月1日0:00开始到当前这一时刻为止的一个以秒为单位的数值
ctime()
获取当前时间并以易读方式表示，返回字符串
gmtime()
获取当前时间，表示为计算机可处理的时间格式，我们叫它struct_time格式

时间格式化

strftime(tpl,ts)
tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量

import time
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S",t)

结果：'2019-10-23 09:50:37'

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999，例如：2019
%m	月份	01~12，例如：10
%B	月份名称	January~December，例如：April
%b	月份名称缩写	Jan~Dec，例如：Apr
%d	日期	01~31，例如：25
%A	星期	Monday~Sunday，例如：Wednesday
%a	星期缩写	Mon~Sun，例如：Wed
%H	小时（24h制）	00~23，例如：12
%I	小时（12h制）	01~12，例如：7
%p	上/下午	AM/pm，例如：PM
%M	分钟	00~59，例如：26
%S	秒	00~59，例如：26

strptime(str,tpl)
str是字符串形式的时间值
tpl是格式化模板字符串，用来定义输入效果

import time
t = '2019-10-23 09:50:37'
time.strptime(t, "%Y-%m-%d %H:%M:%S")

结果：time.struct_time(tm_year=2019, tm_mon=10, tm_mday=23, tm_hour=9, tm_min=50, tm_sec=37, tm_wday=2, tm_yday=296, tm_isdst=-1)

程序计时

perf_counter()
返回一个CPU级别的精确时间计数值，单位为秒，由于这个计数值起点不确定，连续调用差值才有意义
sleep(s)
s拟休眠的时间，单位是秒，可以是浮点数

实例4 文本进度条

import time
scale = 50
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)

end是print()函数的一个参数，默认情况下不加它指的是我输出了一个信息之后，默认在最后增加一个换行\n，但是如果增加 “,end=” 这样一个参数，就会改变每次print输出最后增加的那个信息
\r指在打印输出字符串前，它能够使光标退回到当前行的行首

程序的控制结构

顺序结构分支结构和循环结构

程序的分支结构

单分支结构
if <条件>:
<语句块>
二分支结构
- if <条件>:
  <语句块1>
  else:
  <语句块2>
- 紧凑形式：<表达式1>if<条件>else<表达式2>
多分支结构
if <条件>:
<语句块1>
elif:
<语句块2>
…
else:
<语句块3>
条件判断及组合
- and 与
- or 或
- not 非
异常处理
- try:
  <语句块1>
  except:
  <语句块2>
- try:
  <语句块1>
  except <异常类型>:
  <语句块2>
- try:
  <语句块1>
  except <异常类型>:
  <语句块2>
  else:
  <语句块3>
  finally:
  <语句块4>
  
  finally对应语句块4一定执行
  else对应语句块3在不发生异常时执行

实例5 身体质量指数

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 <= 25:
   who, nat = "正常", "偏胖"
elif 25 <= bmi <28:
   who, nat = "偏胖", "偏胖"
elif 28 <= bmi <30:
   who, nat = "偏胖", "偏胖"

程序的循环结构

遍历循环for
- 计数循环
- 字符串遍历循环
- 列表遍历循环
- 文件遍历循环
- 元组
- 字典
- …
无限循环while
循环控制保留字
- break跳出循环
- continue继续循环
循环与else
循环正常结束(没有被break强制跳出)时，执行else后的语句块

模块3 random库的使用

random库是使用随机数的Python标准库

伪随机数：采用梅森旋转算法生成的（伪）随机序列中的元素
random库主要用于生成随机数
使用random库 import random

random库包括两类函数，常用共8个

基本随机数序列
- seed(a=None) 初始化给定的随机数种子，默认为当前系统时间
- random() 生成一个[0.0,1.0]之间的随机小数
扩展随机数序列
- 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中元素随机排列，返回打乱后的序列

实例6 圆周率的计算

圆周率的近似计算公式
$\pi=\sum^{\inf}_{k=0}[\frac{1}{16^k}(\frac{4}{8k+1}-\frac{2}{8k+4}-\frac{1}{8k+5}-\frac{1}{8k+6})]$
蒙特卡罗方法

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
可选参数传递 (赋初值)
函数定义时可以为某些参数指定默认值，构成可选参数，可选参数必须放必选参数的后面

#例 可选参数
def fact(n, m=1):
   s = 1
   for i in range(1, n+1):
      s *= i
   return s//m

可变参数传递(*b)
函数接受的参数是可变数量的，即不确定参数总数量
在确定参数后面增加一个*b

#例 使用可变参数
def fact(n, *b):
   s = 1
   for i in range(1, n+1):
      s *= i
   for item in b:
      s *= item
   return s

参数传递的两种方式
- 位置传递
- 名称传递

#位置传递
fact(10, 5)
#名称传递
fact(m=5, n=10)

函数的返回值 return
可以返回任意多个结果
局部变量和全局变量

规则1：局部变量和全局变量是不同的
- 局部变量是函数内部的占位符，与全局变量可能重名但不同，
- 函数运算结束后，局部变量被释放
- 可以使用global保留字在函数内部使用全局变量
规则2：局部变量为组合数据类型且未创建，等同于全局变量
lambda函数 (不是常用函数定义形式，建议使用def定义的普通函数)
lambda函数是一种匿名函数，返回值是函数名
形式：<函数名> = lambda<参数>:<表达式>
举例：
f = lambda x,y : x+y
f(10,15)
或
f = lambda : "lambda函数"
print(f())

实例7：七段数码管绘制

# 七段数码管绘制
import turtle, time

def draw_gap():
    turtle.penup()
    turtle.fd(5)

# 绘制单段数码管
def draw_line(draw):
    draw_gap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    draw_gap()
    turtle.right(90)

# 根据数字绘制七段数码管
def draw_digit(digit):
    draw_line(True) if digit in [2, 3, 4, 5, 6, 8, 9] else draw_line(False)
    draw_line(True) if digit in [0, 1, 3, 4, 5, 6, 7, 8, 9] else draw_line(False)
    draw_line(True) if digit in [0, 2, 3, 5, 6, 8, 9] else draw_line(False)
    draw_line(True) if digit in [0, 2, 6, 8] else draw_line(False)
    turtle.left(90)
    draw_line(True) if digit in [0, 4, 5, 6, 8, 9] else draw_line(False)
    draw_line(True) if digit in [0, 2, 3, 5, 6, 7, 8, 9] else draw_line(False)
    draw_line(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else draw_line(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)

# 获得要输出的数字
def draw_date(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:
            draw_digit(eval(i))

def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-320)
    turtle.pensize(5)
    str_time = time.strftime("%Y-%m=%d+", time.gmtime())
    # print(str_time)
    draw_date(str_time)
    turtle.hideturtle()
    turtle.done()

if __name__ == '__main__':
    main()

代码复用与函数递归

模块化设计思想：松耦合、紧耦合
函数递归的两个特征：基例和链条

# 汉诺塔 递归实现
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)

if __name__ == '__main__':
    x = int(input())
    hanoi(x, 'A', 'C', 'B')
    print(count)

模块4：pyinstaller库的使用

将.py源代码转换成无需原代码的可执行文件
pyinstaller是第三方库

安装：打开 cmd

$ pip3 install pyinstaller

使用

$ pyinstaller -F <文件名.py>

执行命令后打开目录，会看到另外生成的三个目录 __pycache__ build dist ，然后 __pycache__ build 这两个目录可以安全地删除。在 dist 文件夹中会看到与 .py 文件同名的 exe 文件，这个文件就是打包之后生成的文件。

常用参数

-h 查看帮助
```
$ pyinstaller -h
```
--clean 清理打包过程中的临时文件
使用 pyinstaller 是加上参数 --clean ，比如产生的 __pycache__ 和 build 文件夹等其他的没用的文件都会被清理掉。
-D 默认值，生成dist文件夹
通过加 -D 参数或者什么都不加，生成dist文件夹，这个文件夹中的所有文件都是必须的。
-F 在dist文件夹中只生成独立的打包文件
```
$ pyinstaller -F <文件名.py>
```
-i <图标名称.ico> 指定打包文件使用的图标文件
```
$ pyinstaller -i <图标名.ico> -F <文件名.py>
```

实例8：科赫雪花小包裹

# 科赫雪花
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.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    level = 3
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.hideturtle()
    turtle.done()

if __name__ == '__main__':
    main()

LZH0217

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记

Python学习笔记实例1：温度转换# TempConvert.pyTempStr = input("请输入带有符号的温度值：")if TempStr[-1] in ['F', 'f']: C = (eval(TempStr[0:-1]) - 32) / 1.8 print("转换后的温度是{:.2f}C".format(C))elif TempStr[-1] in ['...
复制链接

扫一扫