首先声明！！！

  • 1、此为知识点总结内容；
  • 2、如有使用或转载请注明出处；
  • 3、如有不足，欢迎批评指正；

* 导言须知

  • Python方向：

    • 知识点主要面向小学5年级+的少儿编程Python课程，适用于各类竞赛；

    • 课程比较适合理工科父母的亲子互动，教培机构老师备课参考；

  • 课程知识点：

    • 1.基础篇：输入输出函数、变量及数据类型、条件判断、循环、函数、字符串、列表元祖字典、常用库；
    • x.数学篇：独立课程，采用OJ系统刷题教学；
    • 2.绘图篇：Turtle海龟绘图库，基础教学在系统课程里；
    • y.绘图扩展篇：Turtle海龟绘图库的提高扩展部分，面向竞赛的独立课程；
    • 以上部分，止步于小学5年级+，OJ刷题如需要更高年级或能力则会特别说明；
    • z.项目篇：独立课程，每个项目一个课程，常用软件和游戏开发课程（这部分在另一篇文章上）；

​ 特别说明：竞赛中理论部分会有大量本课程无法涉及的部分：比如进制问题（二进制、八进制等）、数据结构和算法部分（二叉树、排序、链表等）以及初等数学、离散、图论等均没有。

​

* 软件使用

​ 官网网站：https://codewith.mu/
​ **安装方式：**默认安装即可，但无法更改路径，所以一般在C:\Users\Administrator目录下，如果路径是中文，可能会出现无法打开的问题。需要自行搜索解决，或进入管理员模式下重新安装。

image-20230628104437744

​ 注意：以下内容比较超纲，但都是小概率才会出现，如果不幸出现，请一定要排除万难去解决问题。

​ 解决方案1：按照这个英文这个提示，去查询，有视频、文章去专门解决Qt platform plugin启动的问题。但我不推荐，而且比较难；

​ 解决方案2：卸载掉后，进入win10 管理员帐户下（Administrator），直接安装即可。怎么进入管理员帐户，直接搜索即可。在管理员帐户安装好后，切换到自己的帐户还找不到安装程序，直接去管理员目录下复制到桌面一个快捷方式即可。

3. print()输出函数

1
2
3
4
# 向控制台输出一行字：Hello, Python
# 注意1：括号和引号(单双均可)必须是英文状态下的
# 注意2：#号开头表示注释，它的作用是解释，并不会执行
print("Hello, Python!")

一、变量

1. 变量的声明

  • 什么是变量？变量就是一个可以存储东西的存储罐，具体特性如下：
    • 每次存储罐里只能存一次东西，也就是说再次存储时，上一次存储的东西会被替换掉；
    • 声明变量就好比你拿出了一个存储罐，实际上是在内存里开辟了一个空间；
    • 不管是现实中的存储罐还是内存开一个空间，多了防止混淆就需要贴个标签，命个名；
    • 我们来通过一张图来理解一下，这个声明概念：

那么，如何通过编程来实现变量的声明呢？

1
2
3
4
5
6
7
8
9
# 声明一个变量
# 注意1：= 不是等于的意思，是赋值的意思
# 注意2：阅读代码从右边向左边阅读，意为：将数字123赋值给变量a
a = 123
# 输出a
print(a)
# a变量被替换
a = 456
print(a)

2. 命名的规则

  • 从 a=123 的例子中，a是变量名，但变量的名字有什么要求？需要注意哪些规则？能乱起吗？

    • 变量名可以包含字母、数字、下划线，但数字不能在变量名首位；

      • abc（合法）、a123（合法）、_xyz（合法）、123a（不合法）

    • Python中的关键字无法作为变量名，编辑器会提示，比如：def、class，使用会直接报错；

    • Python中的英文是区分大小写的，大写的A和小写的a不是一种东西；

  • 为了让变量名更加的有可读性，比如：你的名字，当然，中文变量名也是支持的，但基本不用；

    • 第一种经典命名方式，驼峰式：yourName，或YourName，我比较喜欢前者；
    • 第二种经典命名方式：蛇形式：your_name，用的也比较多；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 关键字错误命名
def = 123
class = 123
print(class)

# 中文命名
你的名字 = 123
print(你的名字)

# 驼峰式
yourName = 123
print(yourName)

# 蛇形式
your_name = 123
print(your_name)

3. Shell模式

有时我们要对一些结果进行快速获取，可以直接使用命令行窗口直接输出：Shell模式；

1
2
3
4
5
6
7
8
9
10
11
>>> a = 123
>>> a
123

>>> b = 456
>>> print(b)
456

# 如果在主程序本身就已经运行赋值了，直接在命令行输出也是可以的
>>> c
798

二、算术

1. 算术运算符

虽说叫做四则运算，但其实运算符往往不止加减乘除这四种：

运算 符号 格式
加 + 1 + 1
减 - 2 - 1
乘 * 3 * 4
除 / 6 / 2
整除 // 9 // 7
求余 % 10 % 8
幂 ** 2**3
  • 在编程语法中乘法 x 用 ***** 号代替，除法 ÷ 用 / 代替。
  • 除法 / 是保留小数的，而整除 // 是直接取整的。
  • 幂运算中：2**3，2为底数，3为指数，换算成乘法为：2 x 2 x 2。
1
2
3
4
5
6
7
8
9
10
11
12
# 加减乘除，在末尾Ctrl+D复制
print(1 + 1)
print(3 - 2)
print(4 * 5)
print(9 / 7)
print(9 // 7)
print(10 % 7)
print(2 ** 3)

# 使用变量进行四则运算
a = 1 + 1
print(a)

2. 变量自运算

  • 所以自运算，就是让变量本身的值累计运算，比如累加、累减等；
    • += 累加，a += 1，相当于a = a + 1;
    • -= 累减，a -= 1，相当于a = a -1;
    • 其它雷同，不再赘述，加减最为常用；Python不支持a++语法；
1
2
3
# 累加
a+=1
print(a)

3. 温度转换器

  • 王二狗被夏天40度的高温热晕了，对于科学爱好者的他还是要计算一下华氏度是多少？
  • 转换公式为：F = 9 ÷ 5 × C + 32
1
2
3
4
# 温度转换
c = 40
f = 9 / 5 * c + 32
print(f)

三、转义

1. print()不详解

给命令行输出一段内容，可以使用 print() 函数；

说明 语法
函数名 print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
参数 objects --表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。
sep – 用来间隔多个对象。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。
file – 要写入的文件对象。
返回值 无
  • 如果只是单纯在控制台输出一些内容，只需要传递一个参数即可：
1
2
# 简单的数值输出
print(123)
  • 输出的内容可以多条数据，默认空格隔开显示，可以通过参数更改：
1
2
3
4
5
6
7
# 可以输出多个数据，默认英文逗号隔开
# 输出时，默认会以空格来隔开显示
print(123, 456, 789)

# 通过sep参数改变显示时间隔符号
# 注意，参数的值需要通过双引号包含，因为它不是数值而是字符串
print(123, 456, 789, sep="-")
  • 默认情况下，print输出会自动换行：
1
2
3
4
# 默认情况下一个print输出后会自动换行
# 可以通过end参数改变这一特性
print(123, end="|||")
print(456)

2. 转义字符

字符 说明
\\ 反斜杠
\’ 单引号
\" 双引号
\n 换行符
  • 以上是比较常用的转义字符，更多的可以搜索查询，暂时我们也用不到；
1
2
3
4
5
6
7
8
# 转义字符输出
print("\'\"\n123")

# 只使用一个print输出以下图形
***
  ***
    ***
print("***\n  ***\n    ***")

四、类型

1. 数据类型

类型名 转换函数 说明及示例
整型 int() 将合法的字符数值或浮点数转换成整数
字符串型 str() 将任意内容转换成字符串型
浮点型 float() 将合法的字符数值或整数转换成浮点数
布尔型 bool() 将任意内容转换成布尔型

为了判断一个变量或内容，可以采用**type()**函数；

说明 语法
函数名 type(object)
参数 object --表现需要获取类型的内容
返回值 返回一个<class ‘类型符号’> 
1
2
3
4
5
6
# 使用type()获取四种类型
print(type(10))
print(type(10.15))
print(type("王二狗"))
print(type(True))
print(type(False))

  • 布尔类型只有两个值：True和False，注意首字母是大写的；

  • 布尔类型一般用于条件表达式的判断，这在后续课程会使用；

  • 类型转换，有一些条件：

    • 转换成整数时，包含字母或其它字符都不能转成整数，只有纯数字才可以
    • 浮点数同上；
    • 布尔型只能转换成True和False；
1
2
3
4
5
6
7
# 类型转换
print(int("123"))
print(int(123.34))
print(float("123"))
print(bool(0))
print(bool(1))
print(type(str(123)))
  • 将整型转换成字符串时，无法直观的检查出，所以需要用type()判断；

2. 字符串拼接

字符串的连接可以使用 +号 或者 逗号 ，具体如下：

1
2
3
4
5
6
7
8
9
# 字符串拼接，+号紧凑，逗号松散
print("我"+"和"+"你")
print("我" + "和" + "你")
print("我","和","你")

# 变量同理
a = "我"
b = "你"
print(a + b)

3. 输出格式

格式符 说明
%d 格式化整数，会直接取整
%f 格式化浮点数，可以设置保留的小数点
%s 字符串
  • 格式化语法如下：
    • “字符串文字%d %s %f”%(3, “嗯嗯”, 3.1415926)
1
2
3
4
5
# %符的格式化处理
name = "小明"
age = 3.33
weight = 1.23456
print("我的名字叫%s，今年%d岁了，身高%.2f"%(name, age, weight))
  • %5.2f：可以理解为5个占位符，不足的用空格占用；
  • %10s和%-10s：可以理解为占用10个位置，占用前面和占用后面的区别；

五、输入

1. input()不详解

如果想让用户在键盘输入内容，可以使用 input() 函数；

说明 语法
函数名 input([prompt])
参数 prompt --表示提示输入，[]表示它是可选状态。
返回值 返回提示内容
  • 如果提示输入为空，则用户会黑灯瞎火的输入，除非本身知道；
1
2
3
4
5
6
7
8
9
# 在这里写上你的代码 :-)
# 无任何提示的输入，运行时控制台的光标闪烁
input()

# 可以将输入的内容，赋值给一个变量
# input()输入的内容，不管字面上是什么都是字符串类型
a = input()
print(a)
print(type(a))
  • 如果加上提示内容，将很好的提示用户正确的输入;
1
2
3
# 有提示的输入
b = input("请输入一个数，1-9之间：")
print(b)

2. 输入转换运算

通过输入的两个数值进行运算，必须进行转换；

1
2
3
4
# 通过输入进行数值计算
c = int(input("请输入第一个数，1-9之间："))
d = int(input("请输入第二个数，1-9之间："))
print("%d+%d=%d"%(c, d, c+d))
  • 最后，再做个经典的图形输出，输入指定图形元素（比如*）得到如下的图：
1
2
3
  *
 ***
*****
1
2
3
4
5
# 输出三角图形，这里的*号是字符乘法，复制显示数量
e = input("请输入任意字符：")
print(" ",e)
print("",e*3)
print(e*5)

六、布尔类型

1. 关系运算符

布尔类型的值，是专门用于各种表达式的判断，表达式的运算符如下：

名称 关系运算符 表达式返回值
大于 > 成立范围True（6 > 5），否则为False（6 > 7）
小于 < 成立返回True（6 < 8），否则为False（6 < 5）
等于 == 成立返回True（6 == 6），否则为False（6 == 7）
大于等于 >= 成立返回True（7 >= 6），否则为False（7 >= 8）
小于等于 <= 成立返回True（6 <= 6），否则为False（6 <= 5）
不等于 != 成立返回True（6 != 5），否则为False（6 != 6） 
1
2
3
4
5
6
7
8
9
10
# 表达式返回值
print(6 > 5)
print(6 > 7)
print(6 < 7)
print(6 < 5)
print(6 == 6)
print(6 == 7)
print(6 >= 7)
print(6 <= 7)
print(6 != 7)

2. 逻辑运算符

除了关系运算符之外，还有一种叫做逻辑运算符，具体如下：

名称 逻辑运算符 表达式返回值
and x and y x和y同时为True时，返回True，否则返回False
or x or y x和y只要其中之一为True，返回True，否则返回False
not not x x为True时，结果为False，否则为True 
1
2
3
4
5
6
7
# 逻辑运算符
print(5 > 6 and 5 > 4)
print(7 > 6 and 5 > 4)
print(5 > 6 or 5 > 4)
print(5 > 6 or 5 < 4)
print(not 5 > 6)
print(not True)

七、条件判断

1. if…单一条件

假设你一周七天中只有周一才能穿新衣服，那么就需要 if语句 中 单一条件判断：

条件判断流程图

  • 单一条件判断的if语句格式如下：
1
2
if 条件判断:
	条件满足时，执行
1
2
3
4
5
6
# 注意1：判断的数值需要转换为整数再判断
# 注意2：a == 1由于习惯或方式，可以加上括号(a == 1)
# 注意3：if条件判断内的语句，需要用Tab键缩进才能识别
a = int(input("请输入今天星期几，1-7之间："))
if a == 1:
    print("今天穿新衣")

2. if…else分支

单一if语句比较高冷，如果未满足条件，ta就不理你了；而else分支则可爱许多；

分支判断流程图

  • else分支条件判断的if语句格式如下：
1
2
3
4
if 条件判断:
	条件满足时，执行
else:
	条件不满足时，执行
1
2
3
4
5
6
# 注意1：else后面有冒号，表示结束
# 注意2：else需要和if在同一垂直位对齐，否则报错
if a == 1:
    print("今天穿新衣")
else:
    print("今天无法穿新衣")

3. 日常穿衣表

夏天到了，汗渍很多，每日换洗：1，3，5穿A款，2，4，6穿B款，星期日放假不出门；

1
2
3
4
5
a = int(input("请输入今天星期几，1-6之间："))
if a == 1 or a == 3 or a == 5:
    print("穿A款")
else:
    print("穿B款")

八、多重嵌套

1. elif…多重分支

年龄决定一个人当前的状态，8岁到80岁，你都在干什么？此时需要elif多重分支：

1
2
3
4
5
if 条件判断:
	条件满足时，执行
elif 条件判断:
	条件满足时，执行
...
1
2
3
4
5
6
7
8
9
10
11
12
# 8-25之间：求学阶段
# 26-60之间：工作阶段
# 大于60：退休阶段
a= int(input("请输入你的年龄：8-80之间："))
if a >= 8 and a <=25:
    print("我在上学！")
elif a >=26 and a<=60:
    print("我在工作！")
elif a > 60:
    print("我在退休！")
else:
    print("这个年龄，尚未被统计！")

2. if…嵌套判断

难道大于60岁就真的可以退休了吗？真实情况显然不是这样的，我们还需要具体判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
elif a > 60:
    # 如果爷爷有大伯，二伯和我爸
    # 且，我还有姐姐和弟弟
    # 再且，大伯、二伯每家还有三个
    # 为了存压岁钱，也无法退休呢！
    b = int(input("请输入子孙的数量，1-9之间："))
    if b >= 7 and b <=9:
        print("退休后打两份工")
    elif b >= 4 and b <=6:
        print("退休后打一份工")
    elif b <= 3:
        print("退休中！")
...

九、switch.for循环

1. for…有限循环

王二狗考试得了双百，就得意的要求买台switch，还保证一周只玩三小时，但妈妈让他自己存；

1
2
for 变量 in 集合:
	执行语句

循环流程图

2. rang()数值生成

想要实现一个月1-30号的自增循环，那需要使用**rang()**函数；

说明 语法
函数名 range(start[,end,step])
参数 start：计数从start开始，默认是从0开始
end：计数到end结束，但是不包括end
step：每次自增的数值，默认1
返回值 无 
1
2
3
4
5
6
# 注意1：for...in...语法核心
# 注意2：i是变量，随便定义，每次获取自增后的值
# 注意3：range(1,30)实际上循环到1-29
# 注意4：range第三个参数，设置2体会下
for i in range(1,30+1):
    print(i, end="|")
1
2
3
# 如果range只传入一个参数，默认从0开始到29
for i in range(30):
    print(i, end="|")
  • 此时，我们再回到上方的流程图，可能会略懂一二了；
  • 但是，我们怎么才能知道循环体内的语句在重复执行呢？
  • 这时，可以采用调试中的步进或步入来逐条执行语句；

3. 终于可以存钱了吗？

使用以上学到的循环语句，我们存一个月的钱，对自己狠一点，每天存的钱比前一天多一元；

1
2
3
4
5
# 存一个月的钱
t = 0
for i in range(1, 30+1):
    t += i;
print("一个月存了%d元！"%(t))

十、退出

1. break退出整体

过不下去啦，每天要存的金额越来越多，还是放弃吧，王二狗说道；此时，我们需要使用break终止循环；

1
2
3
4
5
6
for i in range(1, 30+1):
    # 坚持到第3天，就要放弃
    # 注意：如果将if放在print后面，将执行第3天
    if i == 3:
        break
    print(i, end="|")
  • break语句的作用：是退出整个循环；

2. continue退出当前

逃避的加锁禁锢着王二狗的内心，悟道自律才能获得自由；决定：偶数天存钱，奇数天放纵；理由：循序渐进，慢慢来；此时，我们就需要使用continue终止当前循环；

1
2
3
4
5
6
for i in range(1, 30+1):
    # 先来简单的，假设第三天不存
    # 注意：continue必须在执行语句前面执行，否则白搭
    if i == 3:
        continue
    print(i, end="|")
  • 计算偶数的方法：当天日期除以2的余数为0即为偶数，反之奇数；
1
2
3
4
5
6
for i in range(1, 30+1):
    #判断为奇数就退出当前循环
    #去自增执行下一次循环
    if i % 2 == 1:
        continue
    print(i, end="|")

十一、while循环

1. while常规循环

常规的 while循环 和 for循环 基本一致，只不过while更加灵活一点；

1
2
3
4
5
6
7
# 初始化变量1
i = 1
# 如果变量小于等于30，则执行循环体
while i <= 30:
    print(i, end="|")
    # 当执行完毕，自增1
    i += 1
  • while循环除了普通的循环，还有不少独有的做法，比如死循环；

2. while无限循环

王二狗家有一头拉磨的驴，ta的主人告诉ta，只要每天一直往前走，就会有精彩的未来；此时，我们就需要使用while中的无限循环，让其无穷无尽的执行下去；

1
2
# 只要判断表达式永远为True，则不停的执行
while True:
  • 请编写一只怀揣梦想、坚持不懈、勇往直前、誓不罢休的驴；
1
2
3
4
5
6
7
8
9
10
11
12
while True:
    print("驴：请问，到达路的尽头了吗？^.^")
    a = input("请告诉驴，到达与否，回车或输入yes：")
    if a != "yes":
        print("旁白：还没到，请继续向前！")
        print("驴：加油！加油！努力！奋斗！")
    else:
        print("旁白：已经到了！")
        print("驴：真好，我累了，要睡了！❤")
        break
        
    print("-----------------------")

十二、列表入门

1. 九宫格解析

列表其实就是一种可以同时存放多个数据的变量，就好比如下图存放了9条数据，但只有一个变量；

101 102 103
201 202 203
301 302 303
  • 分析上图的九宫格，王二狗家住在第三行第二列的位置上；整体看上去像个容器，例如超市存包的柜子；
  • 我们如何设置它，获取它，使用它？那就必须是用今天的列表变量；列表声明方式为：
    • 列表变量 = [ 数据1, 数据2, 数据3… ]
1
2
3
4
5
6
7
8
9
10
11
12
13
# 注意1，array是列表变量名，是随便定义的
# 注意2：列表的值外围是一个中括号，里面的每个数据可以称为元素
# 注意3：每个元素，用逗号隔开，元素太多，可以换行
# 注意4：元素遵循数据类型，如果是字符串元素，要加引号
# 注意5：其它语言一般称为数组，如果我不小心说数组啥啥啥的，等同
array = [101, 102, 103,
         201, 202, 203,
         301, 302, 303]

# 输出列表，带上中括号原封不动的输出
print(array)
# 看看什么类型，<class 'list'>列表类型
print(type(array))

2. 理解下标

什么是下标？即：列表中元素对应的位置编号，或称为：索引，默认从0开始计算；

0 1 2
3 4 5
6 7 8 
1
2
# 获取王二狗的家
print(array[7])

  • 除了直接通过下标获取指定位置的元素值，还有一些其它语法：

    • 为了避免混淆，我不把下标0说成第1个位置（我会说下标为0的元素）；

    • array[0]：获取下标为0的位置的元素，这里获取的是101；

    • array[2:4]：获取下标为2到3的元素，这里获取的是[103, 201]，返回一个新list；

    • array[2:]：获取下标为2到end的元素，这里获取的是[103…303]，返回一个新list；

    • array[:2]：获取下标为start到1的元素，这里获取的是[101,102]，返回一个新list；

    • array[-2]：获取倒数第2个元素，这里获取的是[302]；

    • array[-5:-2]：获取倒数第5到倒数第3的元素，这里获取的是：[202, 203, 301]，返回一个新list；

1
2
3
4
5
6
print(array[0])
print(array[2:4])
print(array[2:])
print(array[:2])
print(array[-2])
print(array[-5:-2])

十三、列表操作

1. 点语法启蒙

列表是一种容器类的结构，势必会给予它较为丰富的操作，比如点语法的操作方法：

1
列表变量.操作方法()
  • .操作方法()可以理解为列表变量下的特有函数；
方法名 说明
.append(o) 在列表末尾添加o元素
.insert(i, o) 在指定位置插入o元素
.remove(o) 移除匹配到o元素的第一个
.pop(i) 取出列表中最后一个元素，或指定元素；然后返回该元素的值
.extend(s) 在列表尾部合并另一个列表

2. 增删改查

通过自身语法以及点语法，我们可以对列表进行一系列的 增删改查 操作：

  • 先创建一个空列表，以便于我们操作：
1
2
3
# 创建一个空的列表
array = []
print(type(array))
  • .append()方法添加元素，会在列表尾部添加一条
1
2
3
4
5
# 使用.append()方法添加元素
array.append(101)
array.append(102)
array.append(103)
print(array)
  • .insert()方法在某一处插入元素，用下标来指定位置
1
2
3
# 使用.insert()在指定下标位置插入元素
array.insert(0, 109)
print(array)
  • .remove()方法删除元素，会找到第一个匹配值的元素删除
1
2
3
4
# 使用.remove()方法删除元素
# 注意：参数需填写元素的值
array.remove(102)
print(array)
  • .pop()方法取出元素，使用下标定位，再返回这个元素值
1
2
3
4
5
# 使用.pop()方法删除元素
# 注意1：这个删除严格意义上是取出返回的意思
# 注意2：参数需填写元素的下标
print(array.pop(1))
print(array)
  • 列表修改的方法，直接通过下标定位赋值
1
2
3
# 使用[]方式修改元素，传递下标位置即可
array[0] = 1001
print(array)
  • .extend()方法参数是要合并的列表，添加到尾部
1
2
3
4
# 使用.extend()方法合并列表
list = [1002, 1003]
array.extend(list)
print(array)

十四、超好用的列表工具箱

1. 工具方法

包括获取列表元素的数量、获取匹配的下标位置、排序、复制、清空等；

方法名 说明
.count(o) 统计元素o在列表中出现的次数
.index(o) 获取元素o在列表中第一次出现的位置
.reverse() 反转列表
.sort(reverse=True) 排序，默认从小到大排序，设置reverse参数为True则反之
.copy() 复制列表
.clear() 清空列表
  • 依旧先创建一个九宫格列表
1
2
3
4
# 根据不同演示的方法会做出修改
array = [101, 102, 103,
         201, 202, 203,
         301, 302, 303, 102, 102]
  • .count()方法获取指定元素出现的次数
1
2
# .count()方法
print(array.count(102))
  • .index()方法获取指定元素第一次出现的位置
1
2
# .index()方法
print(array.index(102))
  • .reverse()方法可以让原列表进行翻转
1
2
3
4
# .reverse()方法，反转原列表
# 注意：这个方法本身不返回反转，而是让原列表反转
array.reverse()
print(array)
  • .sort()方法可以让原列表进行排序，参数可以设置大小排序
1
2
3
4
5
6
# .sort()方法，默认从小到大排序原列表
# 参数reverse=True|False，从大到小和反之
array.sort()
print(array)
array.sort(reverse=True)
print(array)
  • .copy()方法，是拷贝一份独立的列表赋值给新变量
  • .clear()方法，清空列表
1
2
3
4
5
6
7
8
9
10
# .copy()方法，将列表复制出来交给新变量
# 注意：赋值和拷贝的区别，本课不深究
list = array.copy()
#list = array
array.pop()
print(array)
print(list)

# .clear()方法，清空
list.clear()

2. 工具函数

这里推荐三个极其常用的函数，来快速获取想要的对应数据：min()、max()、len()；

1
2
3
4
5
6
# len()函数，获取长度
print(len(array))
# min()函数，获取最小值
print(min(array))
# max()函数，获取最大值
print(max(array))

3. del语句和遍历

还有一个删除列表的快捷语句 del 和 循环列表 数据的遍历方法；

1
2
3
4
5
6
# 删除某一个元素或多个元素
del array[0]
del array[2:4]
# 删除整个列表
# 注意：这里不是清空，是直接把array变量给抹除了
del array
1
2
3
4
5
6
7
8
# 遍历列表，两种方法，1.没必要 2.不错
for i in range(len(array)):
    print(array[i], end="|")
 
print()

for i in array:
    print(i, end="|")

十五、元祖

1. 只读的列表

元祖相对于列表，有两个最主要的特性：1. 数据集用圆括号包含；2. 数据只读，无法修改删除；

1
2
3
4
5
6
7
8
# 注意1：创建时()包含，但输出还用[]
# 注意2：无法修改删除，array[0] = 1001 将报错
# 注意3：type()后得知元祖是tuple[tʌpl]类型
# 注意4：如果创建的元祖只有一条元素，需要补上逗号
array = (101, 102, 203)
print(array)
print(array[0])
print(type(array))

2. 元祖遍历

遍历和列表一致；

1
2
3
# 元祖遍历
for i in array:
    print(i, end="|")

十六、字典

1. 一一配对的概念

字典的核心就是：配对！即：键值对(key:value)！就是将列表中的下标索引进行自定义设计；

1
2
# 字典创建的语法，通过 花括号 以及 key:value 的方式构成：
字典变量 = {键:值, 键:值, ...}
  • 创建空的字典，有两种方式：
1
2
3
4
# 创建空字典，有两种方式1. {} 2. dict()
#array = {}
array = dict()
print(type(array))
  • 创建带数据的字典：
1
2
3
4
5
6
7
8
9
10
11
12
# 创建字典，键值配对
# 注意1：冒号左边称为：键(key)，右边称为：值(value)
# 注意2：依然遵循数据类型规则，key或value，数字不加引号，字符加
# 注意3：通过key找value，依然用中括号，但字符串不能省略引号
array = {
            "A1":"张三", 
            "A2":"李四", 
            "A3":"王二狗",
            "A4":"马六"
        }
print(array)
print(array["A3"])

2. 字典的操作

和列表一样，字典也需要进行增删查改的操作；

1
2
3
4
5
6
7
# 字典新增
array["A5"] = "王五"
# 字典删除，和列表一样
#del array["A4"]
array.pop("A4")
# 字典修改
array["A1"] = "张四"

  • 和列表一样，字典也具有**.copy()和.clear()方法以及min()**、**max()和len()**等函数，这里不再赘述；

  • 字典也有自己独有的方法，方便更好的操作：

方法名 说明
.get(key, default) 返回指定key的值，如果不存在则返回default默认值
.keys() 返回字典中所有的key组成的列表，可再通过遍历输出
.values() 同上
.items() 返回字典中所有的(key,value)组成的元祖，再通过遍历输出 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 获取指定key的value，如果不在，返回指定值
print(array.get("A3"))
print(array.get("A9", "不存在"))

# 通过.keys()返回所有key
for i in array.keys():
    print(i, end="|")

print()

# 通过.values()返回所有values
for i in array.values():
    print(i, end="|")
    
print()
    
# 通过.items()返回所有(key,value)
for i in array.items():
    print(i, end="|")

十七、学籍卡系统.二维查

1. 二维的概念

什么是一维？就是普通列表，一行数据；什么是二维？就是多行数据，表格式数据；

  • 我们首先要创建一个空的字典，用来存储每个学员的学籍卡；
1
2
# 初始化区
s = {}
  • 但是，为了测试查询方便，先填充三条学员数据，具体形式如下表格：
编号 姓名 性别 年龄
A1 张三 男 12
A2 李四 女 11
A3 王二狗 男 12 
1
2
3
4
5
6
7
8
9
10
11
# s是字典
# 注意1：整个学籍卡用字典来表示，这样直接可以通过key快速查找
# 注意2：但是value不是普通的数据，它是一个列表，是一串数据
# 注意3：对于字典里的value，本身可以通过s["A3"]访问，但得到是list类型
# 注意4：对于list列表类型，再通过[]号获取：s["A3"][0]得到"王二狗"
# 注意5：两个中括号，可以理解为嵌套list，或list里的list，这就是二维
s = {
        "A1":["张三", "男", 12], 
        "A2":["李四", "女", 11],
        "A3":["王二狗", "男", 12],
    }

2. while Ture

对于一款小软件，只有在用户主动关闭才能退出，我们通过死循环来实现；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 死循环
while True:
    # 选项开启
    n = int(input("请输入要操作的选项：\n1.查看学籍 2.添加学籍 3.修改学籍 4.删除学籍\n请选择，1-4之间："))
    # 判断选项
    if n == 1:
        print("show")
    elif n == 2:
        print("add")
    elif n == 3:
        print("update")
    elif n == 4:
        print("delete")
    else:
        print("error")
  • 用二维查询的方法建立表格，实现数据的展现
1
2
3
4
5
6
7
8
9
10
# 标头
print()
print("%-3s %-7s %-5s %-5s"%("编号", "姓名", "性别", "年龄"))
print("------------------------")

# 遍历学籍卡
for i in s.items():
	print("%-4s %-8s %-5s %-5s"%(i[0], i[1][0], i[1][1], i[1][2]))
	print("------------------------")
print()

十八、学籍卡系统.增删改

1. 增加数据

通过input()录入来写入数据到字典中，key是编号，而value是列表；

1
2
3
4
5
6
7
8
9
10
11
# 信息录入
a = input("请输入编号：")
b = input("请输入姓名：")
c = input("请输入性别：")
d = input("请输入年龄：")

# 写入s
s[a] = [b,c,d]

#空一行
print()

2. 修改数据

查询数据，通过input()获取编号后，录入修改的内容，再更新；

1
2
3
4
5
6
7
8
9
10
11
12
# 查询并修改
f = input("请输入编号：")
if s.get(f, "no") != "no":
    b = input("请输入姓名：")
    c = input("请输入性别：")
    d = input("请输入年龄：")
    s[f] = [b, c, d]
else:
    print("编号有误！")

#空一行
print()

3. 删除数据

查询数据，通过input()获取编号后，直接del即可；

1
2
3
4
5
6
7
8
9
# 查询并删除
f = input("请输入编号：")
if s.get(f, "no") != "no":
    del s[f]
else:
	print("编号有误！")
    
#空一行
print()

十九、重新回顾字符串类型

1. 常规功能合集

字符串本身有一些功能，有些之前运用过，这里总结如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 功能一：判断字符串类型
print(type("Hello"))
print(str(123))     # 转换

# 功能二：连接字符段片段
a = "hello"
b = "python!"
print(a + b)        # 没有空格
print(a, b)         # 包含一个空格 

# 功能三：重复字符
c = "^.^ "
print(c * 5)

2. 类似列表的特性

如果把字符串每个字符当成列表的元素，将会有很多处理方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 将字符串理解为列表
# 注意：但是列表中方法和工具不一定都能用
d = "abcdefghijklmn"
# 输入b，那么下标位置为1
print(d)
print(d[1])
print(d[2:8])
# 第三个冒号是step步长
print(d[2:8:2])
# 可以用工具函数
print(len(d))

# 字符串也可以像列表一样遍历
for i in d:
    print(i, end="|")

3. 格式化数据

之前已经学习过%d、%f、%s等格式化输出的方式，再看一些变种：

1
2
3
4
5
6
7
8
9
10
# 格式化输出
#t = "hello"
#s = t + "python"
t = "hello%s"
s = t%"python"
print(s)

x = "我叫%s，今年%d岁，身高%.2f米"
y = x%("王二狗",10,1.45)
print(y)

二十、超好用的字符串工具箱

1. 判断方法

字符串有一些用于判断数据的工具函数：成立返回True，失败返回False

方法名 返回值说明
.isnumeric()、.isdigit() 判断字符串是否只包含了数字
.isalpha() 判断字符串是否只包含了字母 
1
2
3
4
5
6
7
8
9
10
11
# 判断是否只包含数字
a = "123"
b = "123abc"
print(a.isdigit())
print(b.isdigit())

# 判断是否只包含字母
c = "abc"
d = "abc123"
print(c.isalpha())
print(d.isalpha())

2. 转换方法

字符串有一些用于转换数据的工具函数：直接返回转换后的数据

方法名 返回值说明
.lower() 将英文的字符串全部转换为小写
.upper() 同上，大写
.format() 格式化 
1
2
3
4
5
# 大小写转换，格式化
print("abCdeFghiJklmn".upper())
print("abCdeFghiJklmn".lower())
print("123{}45{}6".format("x","y"))
print("123{1}45{0}6".format("x","y"))

3. 查询处理方法

字符串有一些用于查询处理数据的工具函数：返回新的字符串

方法名 返回值说明
.find(s[, start, end]) 判断是否包含子字符串，返回下标索引，否则返回-1
start：开始下标索引位置，默认0，end：结束下标索引位置，默认为字符串长度
.replace(s1, s2[,max]) 将字符串中的s1替换成s2后生成新的字符串
s1：将要被替换的字符串 s2：新字符串 max：替换次数
.split(s, n) 将字符串切割后形成一个字符串列表
s：分隔符 n：切割次数 默认值：-1，即切割所有 
1
2
3
4
5
6
7
# 查询、替换、切割
print("abCdeFghiJklmn".find("d"))
print("abCdeFghiJklmn".find("d", 6,10))
print("1abCd1eFgh1iJk1lmn".replace("1", "2"))
print("1abCd1eFgh1iJk1lmn".replace("1", "2", 2))
print("1abCd1eFgh1iJk1lmn".split("1"))
print("1abCd1eFgh1iJk1lmn".split("1", 2))

二十一、随机库

1. 引入库概念

Python有大量的功能需要借助丰富的库来实现，随机库 random 是其中一种：

1
2
3
4
5
# 引入随机库
import random

# 随机1-100之间
print(random.randint(1,100))
  • 一般来说，库的原名太长，我们可以设置一个别名方便调用
1
2
3
# 设置库的别名
import random as r
print(r.randint(1, 100))

2. 常用的随机方法

除了上面的 .randint() 整数随机，还有其它的一系列随机数：

方法名 返回值说明
.randint(s, e) 返回s~e之间的一个随机整数
.uniform(s, e) 返回s~e之间的一个随机小数
.randrange(s, e, p) 同第一条，p是步长
.choice(s) 从元祖中随机获取一个元素
.shuffle(s) 打乱原列表
.sample(s, n) 随机从s列表中取出n个元素组成新列表 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 随机小数
print(r.uniform(1, 10))

# 随机规律整数
# 随机奇数，偶数
print(r.randrange(1, 10, 2))
print(r.randrange(2, 11, 2))

# 从元祖数据中随机产生一个
print(r.choice(("ScratchJR", "Scratch", "Python", "C++")))

# 打乱原列表
array = ["a", "b", "c", "d", "e"]
r.shuffle(array)
print(array)

# 随机取出元素组成新列表
list = [1, 2, 3, 4, 5]
print(r.sample(list, 3))

二十二、小海龟起航.turtle库

1. turtle库入门

turtle，即：海龟；和随机库一样，是Python中一种 绘图工具 库，也叫 海龟库：

  • 先用最少的代码，画上一笔，注意会有图形界面：
1
2
3
4
5
# 引入海龟库
import turtle as t

# 画一笔，向前(默认右)画100步(单位：像素)
t.forward(100)
方法名 返回值说明
.forward(d) 面朝当前方向前进d个距离，d单位是像素
.back(d) 同上，后退
  • 绘图结束时，需要使用.done()方法来暂停绘制：
1
2
3
4
5
6
# 暂停画笔绘制，不会关闭窗口，等待用户交互（比如关闭窗口）
# 注意1：在某些其它Python开发工具，没有.done()会自动关闭窗口
# 注意2：而.done()方法放在绘图代码结尾，保证窗口悬停
# 注意3：既然.done()是暂停的意思，后面再绘图便无效
# 注意4：本开发工具Mu Editor不会自动关闭，学习时不必每次调用
t.done()

2. 角度的概念

在绘制图形时，有时需要转向，那么就需要调整前进箭头的指向（角度）即可

方法名 方法说明
.left(a) 设置当前角度左转a度，a的取值0-360
.right(d) 同上，右转 
1
2
3
4
5
6
7
8
9
# 拐个弯，向左拐90度
t.left(90)
# 再向前100步
t.forward(100)
# 拐个弯，向右拐90度
t.right(90)
# 再向前100步，或后退
#t.forward(100)
t.back(100)

3. 设置箭头造型

为什么叫小海龟呢？因为箭头是可以设置为小海龟的，当然，默认是箭头

方法名 方法说明
.shape() 设置箭头的造型：arrow、turtle、circle、square、triangle、classic
.hideturtle() 设置绘图结束后，隐藏箭头
.showturtle() 同上，相反 
1
2
3
4
5
# 设置箭头造型
t.shape("turtle")

# 隐藏海龟
t.hideturtle()

二十三、正方形.三角形.多边形.圆

1. 正方形.三角形

通过计算总度数（360）除以要绘制的边数，就可以得到正方形和三角形的绘制角度

  • 正方形四条边，那么角度为：360 / 4 = 90°
  • 三角形三条边，那么角度为：360 / 3 = 120°
1
2
3
4
5
6
7
8
9
10
11
12
# 绘制正方形
# 注意1：forward可以简写fd，back=>bk
# 注意2：right可以简写rt，left=>lt
# 注意3：推荐初学者用完全单词，不然都不知道啥意思
for i in range(4):
    t.forward(200)
    t.right(90)
    
# 绘制三角形
for i in range(3):
    t.forward(200)
    t.left(120)

2. 多边形绘制

我们需要通过计算多边形的角度来获取要拐弯的角度，具体如下：

  • turtle库提供了类似input()函数的输入方法：
方法名 方法说明
.numinput(t, p) 弹窗输入框，t为标题文本，p为描述信息 
1
2
3
4
5
6
# 获取多边形的边
n = t.numinput("OK", "请输入多边形的边数：")
# 绘制多边形
for i in range(int(n)):
    t.forward(200)
    t.right(360 / n)

3. 圆

圆的绘制，有自己单独的方法：.circle()

方法名 方法说明
.circle(r[, extent=None, steps=None]) 绘制一个圆，r是半径，可负数
e可选，弧形的角度
s可选，多边形边数 
1
2
3
4
5
6
7
8
9
10
11
# 绘制圆
t.circle(150)
t.circle(-150)

# 半圆
t.circle(150, 180)

# 多边形
t.circle(150, 180, 7)
t.circle(150, 360, 7)
t.circle(150, steps=7)

二十四、画笔设置

1. 画笔设置

海龟库绘制时的线条是可以设置的：包括颜色、粗细以及绘制速度等

方法名 方法说明
.speed(s) 设置绘图的速度：0或大于10表示瞬间绘制，1~10之间，1最慢，10最快
.color(p[,f]) 设置所有颜色，包括笔头和绘制的线条，以及填充
.pencolor© 设置画笔颜色，绘制的线条以及笔头的轮廓部分
.pensize(s) 设置画笔粗细，填入数字，最小值1 
1
2
3
4
5
6
7
8
9
10
# 设置为海龟
t.shape("turtle")
# 设置颜色，只有一个参数，则设置所有，如有第二参数，为填充
t.color("blue", "green")
# 设置画笔颜色，箭头只会轮廓被覆盖
t.pencolor("red")
# 设置画笔粗细
t.pensize(5)
# 设置绘制速度
t.speed(0)
  • 设置颜色的方式推荐两种：英文单词和RGB代码
    • 英文单词比如：black、red、blue等；
    • RGB代码比如：(0, 0, 0)、(255, 255,255)，范围0~255之间；
红 黑 白 黄
red black white yellow
绿 粉 橙 紫
green pink orange purple
tkcolorchart

2. 填充设置

如何在绘制好的封闭区域进行填充呢？比如一个圆

方法名 方法说明
.fillcolor© 设置填充的颜色
.begin_fill() 在需要填充的封闭区域前设置
.end_fill() 在需要填充的封闭区域后设置 
1
2
3
4
5
6
7
# 绘制一个圆
# 默认会填充会依附于t.color()
# 单独设置使用t.fillcolor()
t.fillcolor("orange")
t.begin_fill()  # 开始填充
t.circle(100)
t.end_fill()    # 结束填充

3. 窗体设置

绘图部分都设置完毕了，那么运行的窗体、背景啥的能修改吗？

方法名 方法说明
.setup(w, h) 设置窗体的大小
.title(s) 设置窗体的标题
.Screen().bgcolor© 设置屏幕的背景颜色
.bgcolor© 同上 
1
2
3
4
5
6
7
8
9
# 设置窗体大小
t.setup(800, 600)
# 设置窗体标题
t.title("品味穿搭")

# 获取屏幕设置变量
s = t.Screen()
# 背景颜色
s.bgcolor("pink")

二十五、同心圆.坐标与定位

1. 坐标的概念

默认情况下，海龟绘图在屏幕中间开始。我们可以设置对应坐标让其在指定位置绘制

方法名 说明
.goto(x, y) 设置海龟箭头的位置，默认0, 0
.setx(n) 设置海龟箭头的x位置
.sety(n) 设置海龟箭头的y位置
.home() 回到初始位置，并设置初始方向 
1
2
3
4
5
6
7
# 将坐标定位至x:0,y:0
t.goto(0,0)
t.circle(200)

# 将坐标y轴上移100位置
t.goto(0, 100)		# 或t.sety(100)
t.circle(100)
  • 虽然，我们绘制出了同心圆，但暴露了两个问题：
    • 问题一：同心圆没有按照中心点绘制；
    • 问题二：当绘制第二个圆时，笔头划过路过的区域，并没有抬笔；
1
2
3
4
5
6
7
# 按照中心点绘制圆
n = t.numinput("同心圆", "请输入外围圆的半径：")
t.goto(0, 0 - n)
t.circle(n)

t.goto(0, 0 - n / 2)
t.circle(n / 2)

2. 抬笔与落笔

每次当笔头要位移绘制时，我们需要将笔头抬起，然后再绘制处再落笔即可

方法名 说明
.penup() 设置画笔抬起，此时无法绘制内容，简写为：.up()
.pendown() 设置画笔落下，此时可以绘制内容，简写为：.down() 
1
2
3
4
5
# 起始先抬笔
t.penup()

# 绘制时落笔
t.pendown()

二十六、点和文字

1. 坐标设计

想设计一个x轴和y轴的坐标图形，先利用已有的知识绘制出来

1
2
3
4
5
6
7
8
9
10
11
12
# x轴
t.penup()
t.goto(-50,0)
t.pendown()
t.forward(250)

# y轴
t.penup()
t.goto(0, -50)
t.left(90)
t.pendown()
t.forward(250)
  • 上面的代码有两个问题：
    • 我们可以通过设置箭头的方向，而不是left拐弯；
    • 箭头只能保持一个，需要使用驻留的功能保持；
方法名 说明
.seth(a) 设置海龟箭头方向，
右（0）、上（90）、左（180）、下（-90， 270）
.stamp() 将箭头标记驻留在绘制结尾 
1
2
3
4
5
6
7
# y轴
t.penup()
t.goto(0, -50)
t.seth(90)
t.pendown()
t.forward(250)
t.stamp()

2. 点和文字

在坐标（0, 0）位置设置一个中心点，并在点写上文字

方法名 说明
.dot(s[, c]) 绘制一个点，s为大小，c可选颜色
.write(s[, move, align, font]) 写入文字，s是文字，move是true或false，设置画笔初始位置
align是方向：left（左）、right（右）、center（中）
font是字体：“宋体”, 20, “bold”，字体是本机的字体，20是字体大小
bold是加粗，另外选项：noraml（正常）、italic（倾斜） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# x轴
t.penup()
t.goto(-50,0)
t.pendown()
t.forward(250)
t.stamp()
t.write("x", align="left", font=("宋体", 12, "bold"))

# y轴
t.penup()
t.goto(0, -50)
t.seth(90)
t.pendown()
t.forward(250)
t.stamp()
t.write("y", align="right", font=("宋体", 12, "bold"))

# 中心点
t.goto(0, 0)
t.dot(10)
t.write("(0,0)", align="left", font=("宋体", 12, "bold"))

# 隐藏箭头
t.hideturtle()

二十七、函数

1. 函数的概念

我们这里所说的函数有两个意思：系统内置函数和自定义函数

  • 具体区别如下：
    • 系统内置函数：之前学习的print()、input()等 固定英文+括号 的语法格式，并有独有的效果；
    • 自定义函数：今天即将要学习的自己创建的 自定义英文+括号 的语法格式，效果是自己的创意和算法；
    • 那么，先看一个需求：我要在屏幕左上、左下、右上、右下绘制四个圆：
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
# 引入海龟库
import turtle as t

# 加速
t.speed(10)

# 抬笔
t.penup()
# 去左上角
t.goto(-150, 150)
# 落笔
t.pendown()
# 画圆
t.circle(100)

# 抬笔
t.penup()
# 去右上角
t.goto(150, 150)
# 落笔
t.pendown()
# 画圆
t.circle(100)


# 抬笔
t.penup()
# 去左下角
t.goto(-150, -150)
# 落笔
t.pendown()
# 画圆
t.circle(100)


# 抬笔
t.penup()
# 去右下角
t.goto(150, -150)
# 落笔
t.pendown()
# 画圆
t.circle(100)

  • 从上面的例子中发现，非常简单的圆，只不过要重复四次，就花费了大量的代码片段，带来了很多问题：
    • 代码重复度高，可读性差，查询修改代码会错位；
    • 后期维护困难，如需升级，重复的地方都要修改；

2. 无参数的函数

函数的括号部分是用于传递参数的，如果留空那就是无参数的函数

  • 语法格式：
    • 创建函数：def 自定义函数名():
    • 调用函数：自定义函数名()
1
2
3
4
5
6
7
8
9
10
11
# 创建一个函数，关键字def开头
# 注意1：和if语句一样，创建函数结尾加上冒号
# 注意2：和if语句一样，在函数体内必须有Tab键间隔
def hello():
    print("我是函数！")
    
    
# 调用多次函数
hello()
hello()
hello()

3. 有参数的函数

函数的括号部分是用于传递参数的，如果留空那就是无参数的函数

  • 语法格式：
    • 创建函数：def 自定义函数名([参数1, 参数2, 参数3…]):
    • 调用函数：自定义函数名()
1
2
3
4
5
6
7
8
# 函数的参数，本质上就是变量
def info(name, age):
    print("我的名字叫：%s, 年龄：%d"%(name, age))

# 调用传递不同参数
info("张三", 12)
info("李四", 11)
info("王二狗", 12)
  • 此时，我们再回到之前重复绘制圆的问题，用函数去解决它：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 函数，解决了后期升级和可读性问题
def dc(x, y):
    # 抬笔
    t.penup()
    # 去左上角
    t.goto(x, y)
    # 落笔
    t.pendown()
    # 画圆
    t.circle(100)
    
# 左上
dc(-150, 150)
# 右上
dc(150, 150)
# 左下
dc(-150, -150)
# 右下
dc(150, -150)

二十八、传参

1. 参数传递

除了无参和固定参数外，还有带默认值的参数以及不确定个数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 带默认值的参数
# 注意1：不带默认值的参数是必须传递的，否则报错
# 注意2：带默认值的，如果传递了则覆盖默认值，反之则启用默认值
def info(id, name, gender="未知"):
    print(id, name, gender)
    

# 调用
#info(1)     # 报错
# 启用默认值
info(1, "王二狗")
# 覆盖默认值
info(1, "王二狗", "男")

2. 不确定参数

什么叫做不确定参数？传递参数的个数不确定，有多有少，从而设计的传参方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 不固定的传参
# 需求说明：给同时进入大厅的客户发表问候
# 例如：1.张三，欢迎光临！2. 张三，李四，王二狗，欢迎光临！
# 注意1：传递的参数名和普通参数一样，自定义，args单词为多组参数的意思
# 注意2：参数左边有一个 * 号，表示我是不固定个数的传参
# 注意3：不管传递了多少个参数，都将形成一个 turple（元祖）类型，可遍历
def hello(*args):
    for i in args:
        print(i, end="，")
    print("欢迎光临！")
    
hello()    
hello("张三")
hello("张三", "李四", "王二狗")
  • 如果想要在不固定参数的使用上，再添加一个固定参数，那需要在左边传递
1
2
3
4
5
6
def hello(info, *args):
    for i in args:
        print(i, end="，")
    print(info)
    
hello("恭喜发财", "张三", "李四", "王二狗")
  • 在不固定传参中，还有一种**args的传参方式，原理和上面一样，只是采用了key:value模式
1
2
3
4
5
6
7
8
9
10
11
12
# **args模式，特别适合key:value形式的数据传递
# 注意1：这个参数会返回一个 dict 字典数据
# 注意2：调用的时候，通过赋值传递即可
def student(**args):
    #print(type(args))
    for i in args.items():
        print(i)
    

student(id="A1", name="张三", age=11)
student(id="A2", name="李四", age=10)
student(id="A3", name="王二狗", age=12)

二十九、返回值

1. 无返回值函数

之前我们自定义的函数都是无返回值的函数，即：调用函数后，直接执行所有代码

1
2
3
4
5
6
7
8
# 无返回值函数
# 注意1：无返回值函数权限太高，自行执行需求，包括格式方法等
# 注意2：调用方只能调用和传参，没有任何其它权限
def hello(a, b):
    print("%dx%d=%d"%(a,b,a*b))
    
hello(10,20)
hello(30,50)
  • 我们希望函数能给调用者更多的权限，让调用者控制更多的需求和流程，可采用返回值模式

2. 有返回值函数

通过函数计算得到的结果后，不用去处理它的流程和显示格式，返回给调用方处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 有返回值函数
# 注意1：通过return关键字将结果返回出来
# 注意2：由于函数是返回结果，直接调用是无任何输出的
# 注意3：可以把有返回值的函数当前变量处理，输出或判断等
def info(a, b):
    return a * b

print(info(10, 20))
print("%dx%d=%d"%(10,20,info(10,20)))

# 对函数返回值进行判断
if info(10,20) > 150:
    print("结果正确！")

三十、全局与局部

1. 局部变量

有没有考虑过一个问题：函数体内声明的变量会不会被外部干涉？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 这里的num 叫全局变量
num = 100

# 在函数体内声明变量
def hello(x,y):
    # 这里的num 叫局部变量
    num = 10
    return x + y + num
    

# 在这里的返回值中，参与运算的是局部变量num    
print(hello(10, 20))
# 注意：这里的num一定是全局 num，局部num出了函数体就看不见了
print(num)
  • 归纳以下几点：
    • 局部变量只能在自己的函数体内参与操作，出了函数体就不认识了；
    • 全局变量就是在函数体外部声明的变量，它无法改变函数体声明的同名变量；
    • 局部变量比全局变量的优先度高，它会覆盖全局同名变量在函数体内的运行；
    • 如果函数体内不存在同名的局部变量声明，那么函数体内的变量将由全局变量接管；

2. 全局变量

全局变量除了在函数体外直接定义，也可以在函数体内声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 全局变量解析
def info():
    # 在函数体内创建一个全局变量
    global x
    x = 10
    y = 20
    
# 在未调用时，x无法访问
#print(x)

# 在调用时，x可以访问，y是局部变量无法访问
info()
print(x)
#print(y)

  • 归纳以下几点：

    • 全局函数在函数体需要定义为：global x，赋值需要单独进行，不可直接赋值；
    • global 关键字声明，必须在函数体的第一行；
    • 函数体内的全局变量，需要调用过函数才能实现声明可见；

  • 利用全局变量的特性，实现一个调用关系的小例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 调用关系
def your():
    print(name, age)
    
def my():
    global name
    name = "王二狗"
    age = 12
    
# 外部初始化全局变量name和age
name = "张三"     
age = 11

# 首先，调用your()，直接被全局变量接管
your()
# 其次，调用my()，会激活全局变量name和局部变量age
# 此时，name被新的全局变量覆盖，而age只是局部，无法接管另一个函数的同名变量
my()
your()

三十一、模块化处理.函数分组

1. 函数分组

函数太多怎么办？将函数独立里成文件用库的方式import导入，实现模块化

1
2
3
# 加法函数，addition.py
def sum(x, y):
    return x + y
1
2
3
4
5
6
# 模块其实就是引入库，比如import turtle
# 本节课主要是学会如何自己创建可以import的库
# 将函数存放到单独文件中，通过import调用
# import 导入同文件夹下的.py文件名
import addition as add
print(add.sum(10, 20))

2. from…import

引入模块库时，可以使用from…import可将指定方法导入模块中

1
2
3
4
5
6
7
8
9
10
11
12
# from...import只是将库中某一个或几个方法引入近来
# 多个方法，用逗号个开  circle,fd,bk
from turtle import circle
# 如果想将所有的turtle引入近来，直接import *
from turtle import *

print(add.sum(10, 20))
# 无法执行
#turtle.forward(100)
# 直接使用方法，当成函数语法使用
circle(100)
fd(100)

三十二、反复调用.递归函数

1. 简单递归

什么是递归，即：重复的执行自身函数，从而解决某些问题

  • 需求分析：阶乘问题

    • 输入一个数n：比如5，求出1-n之间的阶乘：1x2x3x4x5
    • 具体阶乘公式为：F(n) = n × F(n-1)

  • 思路分析：从后向前乘

    • 假设n为5，利用公式：n × F(n-1)
    • 第一轮：5 x (5-1)， 20
    • 第二轮：20 x (4 - 1) ， 60
    • 第三轮：60 x (3-1)， 120
    • 第四轮：120 x (2-1)，120
    • 第五轮：判断1退出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 阶乘递归函数
def F(n):
    # 当n为1时，就需要退出递归不再调用
    if n <= 1: 
        # return 除了返回还有类似break退出的作用
        return 1
        
    #print(123)
    else:
        # 5 * F(5-1)
        # 5 * 4 * F(4-1)
        # 5 * 4 * 3 * F(2-1)
        # 5 * 4 * 3 * 2 * 1
        return n * F(n - 1)
    
print(fn(5))

2. 斐波那契数列

提升一点难度，尝试用递归来算出第20位的经典数列：斐波那契数列

  • 数列公式分析：
    • F(n)=F(n-1)+F(n-2)
    • 1、1、2、3、5、8、13、21…
    • 从第三项开始，每一项都是前两项的和
1
2
3
4
5
6
7
8
9
10
11
12
# 斐波那契数列
def F(n):
    # 前两项固定为1
    if n == 1 or n == 2:
        return 1
    # 套用递归
    # 如果n=3，F(2) + F(1) = 2
    # 如果n=5, F(4) + F(3) = 3 + 2 = 5
    # 如果n=8，F(7) + F(6) = 5 + 3 + 5 + 5 + 2 + 1 = 21
    return F(n-1) + F(n-2)

print(F(20))

三十三、数学函数及Math库

1. 数学函数

头疼的数学计算，提供了不少快捷的函数方便我们直接使用

函数名 返回值说明
abs(x) 返回x的绝对值
round(x[, n]) 返回x四舍五入的值，n可选，保留小数的位数 
1
2
3
4
5
6
7
8
9
# 绝对值，不管正负，都取正
print(abs(-5))
print(abs(5))

# 四舍五入，遇5进位
print(round(3.55))
print(round(3.55, 1))
print(round(3.44))
print(round(3.44, 1))

2. math数学库

除了上述直接作用的函数外，math库也提供了更多的数学方法和属性

方法名 返回值说明
.ceil(x) 返回x向上取整的值
.floor(x[, n]) 返回x向下取整的值
.fsum(list) 返回list中所有元素的和
属性名 返回值说明
.pi 返回圆周率
.e 返回自然常数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 对小数向上取整，进位取整
print(m.ceil(2.55))
print(m.ceil(2.44))

# 对小数向下取整，截断取整
print(m.floor(2.55))
print(m.floor(2.44))

# 获取列表中所有元素的和
print(m.fsum([1, 2, 3, 4, 5]))

# 获取pi，圆周率的值
print(m.pi)

# 获取e，自然常数，无限不循环小数
print(m.e)

三十四、实训.璀璨星空

1. 实战内容

利用随机、海龟图、函数等知识点，绘制一张包含很多个五角星的星空

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
46
47
48
49
50
51
52
53
54
# 引入库
import turtle as t
import random as r

# 绘制速度
t.speed(0)

# 设置窗体大小
t.setup(800, 600)

# 晚间天空SlateBlue4
t.bgcolor("SlateBlue4")

# 五角星函数
def drawStar(x, y, color, size, angle):
    t.penup()
    t.goto(x,y)
    t.pendown()
    
    # 设置颜色
    t.color(color)
    # 设置角度
    t.left(angle)
    # 五角星绘制
    t.begin_fill()
    for i in range(5):
        t.forward(size)
        t.right(144)
    t.end_fill()
    
    
    
# 循环100次
for i in range(100):
    # 随机坐标
    x = r.randint(-400, 400)
    y = r.randint(-300, 300)
    
    # 随机颜色
    color = r.choice(["red", "blue", "pink", "white", "green", "orange", "maroon"])
    
    # 随机大小
    size = r.randint(10, 30)
    
    # 随机角度
    angle = r.randint(0, 360)
    
    # 调用五角星函数
    drawStar(x, y, color, size, angle)


# 绘制完毕
t.done()
t.hideturtle()