第一章--python入门之新手村的试炼

本教程面向广大python爱好者提供，欢迎探讨学习。有需要反馈的欢迎在评论区留言

本章节视频链接 点击观看

第一节–飘洋过海来看你 之 一个海龟的旅行

先给海归画笔举个栗子【手动滑稽】

1.神笔马良也想有的海龟画笔

2.也类似于 火影忍者里的忍术 超兽伪画

1.海龟简介

大白话版：海龟就是利用画图的方式帮助练代码玩的小可爱

来自官网的解释https://docs.python.org/3.9/library/turtle.html
海龟绘图是python编程绘图的一部分，是一种流行的向孩子们介绍编程的方式。1967年便被人们使用，可谓经典永存。
Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

先来展示一下

打开计算机 在终端输入以下代码 然后回车

python -m turtledemo

出现一个界面，之后你就可以在界面左上角选择不同的选项然后 点击开始 看绘制结果

2.本节大纲和目标

    1.学习海龟画笔的使用
    2.能够绘制一个卡通头像
    3.课下能够做到自由绘制

3.绘图学习辅助代码的准备

这篇文章里有准备好的学习代码，可以直接复制到编辑器中使用
不用也行，用的话课后创作比较方便,因为支持鼠标对画笔的拖动和移动

代码链接:https://blog.csdn.net/weixin_43521165/article/details/108807063

具体的使用方法，读一下代码的前几行就知了。如果有在看视频教程的话，可以跟着视频边用边学。

4.本节主要画图功能的总结

配合初始代码：
import turtle
t = turtle.Pen()
…
turtle.done()

注意点1：turtle.Pen() 的P是大写的 而且后面有个括号
注意点2：利用goto()方法移动画笔的时候，要先抬起画笔，避免留下痕迹。完事要落下画笔
注意点3：填充颜色设置后，要配合begin_fill() 和 end_fill() 才能填充画笔的起始闭合区域

---

功能代码	作用	使用方法
	导入海龟画笔工具箱	import turtle
	从工具箱子获取海龟画笔	t = turtle.Pen()
	关闭画笔工具箱，但保留画面	turtle.done()
circle(半径)	画圆	t.circle(100)
circle(半径,弧度)	画弧线	t.circle(100,180)
circle(半径,弧度,边数)	画圆内接多边形	t.circle(100,180,6)
pencolor(‘颜色单词’)	修改画笔颜色	t.pencolor(‘red’)
fillcolor(‘颜色单词’)	设置填充颜色	t.fillcolor(‘skyblue’)
begin_fill()	开始填充	t.begin_fill()
end_fill()	结束填充	t.end_fill()
forward(距离)	控制画笔前进	t.forward(100)
goto(横向位置,纵向位置)	控制画笔移动到指定位置	t.goto(20,60)
penup()	抬起画笔	t.penup()
pendown()	落下画笔	t.pendown()
left(旋转角度)	设置画笔左转	t.left(20)
right(旋转角度)	设置画笔右转	t.right(30)
setheading(指向角度)	设置画笔的指向	t.setheading(155)
undo()	撤销上一步操作	t.undo()
write()	写字	t.write(‘杨老师编程’)
	修改字体大小	t.write(‘真帅’,font=60)
hideturtle()	隐藏画笔的箭头	t.hideturtle()
showturtle()	显示画笔箭头	t.showturtle()
done()	结束绘制	turtle.done()

第二节–python的生命基础(1)

1.变量 abc – 存放工具的小抽屉

像我们人的名字一样，名字给人做一个标记，然后用一个具体人名就可以代表这个人。
例如张三，就是一个人具体名字。

而在计算机里也一样，变量给数据做一个标记，然后用一个具体变量名就可以代表他所储存的数据。

例如： zhangsan = '我是张三，在B站人送外号 法外狂徒’
PS：张三已经在罗翔老师的引用下成为法律界名人了，此处募集一个类似张三的新名字，在以后编程界中举例使用。

等号前面的是 变量 相当于一个小抽屉
等号后面的是 抽屉里所装的具体内容
而zhangsan 就是这个小抽屉的名字，也就是这个变量的名字

1.1 变量的命名规则

变量的名字可以有4种字符组成，即 数字 字母 下划线 和 中文汉字 组成，切记不能以数字开头，而且大小写有区别。在命名时候，记得尽量要让变量名有意义，让人读得懂才是好的。
补充：(python3已经可以用中文做变量名，但是为了不造成内容混淆，最好别用中文命名变量。)

例如存储年龄时可以用 age = 18 或者拼音 nian_ling = 18

2.赋值 = – 从此我就是你，你就是我

赋值在前面学变量时，其实已经用过了。他由一个等号连接前后的内容 ，并会把等号后面的数据作为变量交给左边的变量名去指代，这个过程就称为赋值。即赋给变量名一个数据值。这样的语句，也叫做赋值语句。

3.注释 # ’ ’ " "-- 皇上，您还记得大明湖畔的夏雨荷吗

注释：就是对代码起到解释说明的作用，可以让程序员更好的去理解代码的含义。其本身并不会被程序所执行
例如：

print(‘皇上，您还记得大明湖畔的夏雨荷吗’)
#夏雨荷 《还珠格格》里紫薇格格的母亲

可以类比语文课文下面的小字，对注释得功能做进一步巩固记忆

python中注释的形式分为2种：

序号	符号名称	符号	作用
第一种	井号	#	# 注意今后讲到的符号都是英文输入法下的符号 即英文符号
第二种	单引号	’ ‘	‘有双引号和单引号，但是都要成对出现’
	双引号	“ ”	“就是语文书中常见的形式了”
	三引号	’‘’ ‘’‘	‘’‘也就是前后各有三个单引号组成的，可以对换行的内容进行注释

代码演示如下：

刚才谈到语文课本，忍不住留个类似的课后练习：
要求：尝试利用海龟库，在这张图片上作诗《忆江南》并截图保存
（如果无法直接用代码换行，也可以使用上节课用的海龟辅助工具，使用鼠标右键点击指定位置实现换行）

第三节–python的生命基础 (2)

4.数字和基本运算 + - * / – 就是纯粹的整数和小数啦

识别符号：int
数字类型相关更多功能请参阅：数字类型拓展链接

4.1 数字类型介绍

数字分类	举例	识别符号
整数型	3 或 20	int
小数型（也叫浮点型）	3.0 或 3.1	float

补充：使用type()可以查看某数据的类型
例如：print(type(123)) 或者查看某个变量代表的数据类型 type(a)

要识别的内容	代码	结果	代表类型
a=123	print(type(a))	int	整数型
a2=12.3	print(type(a2))	float	小数型
b=“123”	print(type(b))	str	字符串型

整数和小数类型之间可以实现相互转换

补充知识点：
1 数字类型可以直接转化为 字符串类型 ，但是字符串类型的数字需要根据情况转化为相应数字类型
2 字符串类型的数字 不能和 数字类型的数字直接加减

4.2 运算符号介绍

符号	功能	举例	运算结果
+	加	1+2	3
-	减	6-3	3
*	乘	1*3	3
/	除以	9/3	3.0
//	取整	9//3	3
%	取余	13%5	3
**	次方	3**3	27
==	判等	1+2 == 3	True
!=	判不等	1+2 != 3	False
>	大于	3>2	True
<	小于	3<2	False
>=	大于或等于	3>=2	True
<=	小于或等于	2<=3	True

备注： True 意思是 ：真的（即条件成立） False 意思是： 假的（即条件不成立）后续会讲到

4.2.1 数字运算常用方法

方法	功能	举例	运算结果
abs(x)	求绝对值	abs(-9)	9
pow(x,y)	x的y次方	pow(2,4)	16
round(x)	四舍五入后的整数	round(3.6)	4
round(x,z)	对x四舍五入并保留z位小数	round(3.1415926,4)	3.1416
	四舍五入后保存成小数类型	round(3.1415926,0)	3.0
	只对整数部分四舍五入	round(13.52,-1)	round(13.52,-1)

4.3进制转换

4.3.1 任意进制转化为10进制

int（）括号里传入两个参数。第一个参数中数字要写在引号里
int(“要转化的数字字符”,要转化的数字是几进制)
例如

int(“1234”,5) 把5进制的1234转为10进制结果是194

进制	数字举例	转10进制方法	结果
二进制	1101	int(“1101”,2)	13
	1101	int(1101,2)	报错
八进制	77	int(“77”,8)	63
	0o77	int(“0o77”,8)	63
十六进制	2D	int(“2D”,16)	45
	0x2D	int(“2D”,16)	45

二进制在计算机中显示 一般是 0b开头 例如 0b1101
八进制在计算机中显示 一般是 0o开头 例如 0o77
十六进制在计算机中显示一般是 0x开头 例如 0x2D

4.3.2 把10进制转为其他进制的内置方法

10进制数字	转几进制	方法	代码	结果
18	转二进制	bin()	bin(18)	0b10010
18	转八进制	oct()	oct(18)	0o22
18	转十六进制	hex()	hex(18)	0x12

5.字符串 – 一串待在引号里的字符

识别符号 str
字符串相关更多功能请参阅：字符串拓展链接

5.1字符串概念：

像常规文本内容一样，写在成对儿的英文引号里的内容统称为字符串,一般会赋值给变量然后使用

a = '我是一个字符串，我是绿色的'
b = "我也是一个字符串"
c = '''虽然有三个引号，但我也是而且在我里面的内容，换
了行也还是一个整体，不赋值的时候可以做注释，赋值的时候可以当字符串'''

5.2 字符串的常用方法

假设有一个字符串a，a = “i love python” 空格也占用一个字符的位置哦

插播：字符串中字符的排序（索引）是从0开始的，从前往后数的时候，我们称第一个字符的索引是0，往后依次增加1。从后往前数的时候，倒数第一个的索引是 -1，从后往前依次减少1

5.2.1归纳总结

方法名	作用	用法	结果
+	拼接字符串	“1”+“1”	11
f	把变量嵌套进入字符串中	f"{a}"	i love python
len()	求长度	len(a)	13
find()	查找某字符的位置序号(索引)	a.find(‘e’)	5
	找不到就是-1	a.find(‘w’)	-1
index()	查找某字符的位置序号(索引)	a.index(‘v’)	5
	找不到这个字符程序就会报错	a.index(‘w’)	程序报错
split()	分割字符串,并将结果存为列表	a.split(‘e’)	[‘i lov’, ’ python’]
	没有该字符则不分割	a.split(‘f’)	[‘i love python’]
replace(“old”,“new”)	字符替换	a.replace(“i”,“I”)	I love python
		a.replace(“o”,“O”)	i lOve pythOn
[:]	切片，以某两个位置为断点，切开字符串，然后按顺序取到开始断点到结束断点前的内容	a[0:5]	i lov
切片	第一个冒号前面是起点,后面是终点，起点不写则默认从0开始，终点不写则默认取到最后	a[:5]	i lov
[::]	跳跃切片,可以设置每隔几个数字取一次值，和取值方向	a[0:5:2]	ilv
	反向取值，将第二个冒号后的数字前加上负号即可	a[-1::-2]	nhy vli

5.2.2 代码示例

5.3 练习

尝试定义一个字符串，I love python. 然后使用本节所学方法，使字符串变为I love coding.

第三节–python的生命基础 (3)

6.列表 [ ] – 一个有抽屉的大大大大桌子

6.1列表的概念：

名词解释：

（大白话版）
如果把变量理解为抽屉的话，列表就是一个很大很大的桌子，桌子可以有很多按顺序排列的抽屉，于是他能存储更多的内容。

（书面版）
列表是python中一个可以被更改内部内容的数据结构。他的内容由中括号[ ] 包裹，中括号内可以依次存放很多元素，不同元素之间用英文逗号隔开。

例如:
a = [1,3.5,‘小明’,‘小刚’,[“列表中的列表”,“23333”]，“记得元素都用逗号隔开哦”]
可以留意到这里的列表里,存储了多种不同的数据类型，这也是python的方便之处，甚至可以在列表里再存储新的子列表等本节将讲到的其他数据结构。
注：
列表的索引从左往右也是从0开始的，从右 往左是从-1开始，所以对字符串的切片方法依然适用于、列表

6.2 列表的常用方法介绍

6.2.1 列表的增删改查

假设有一个列表

list_a = ['你好','我','是','列表',['我知道','abc'],456]

操作	方法	用法	结果	结果的类型
求长度	使用len()方法查看列表长度即元素个数	len(list_a)	6	int
查询元素	通过索引取到具体位置元素的值(元素)	list_a[1]	我	str
	列表名[索引值]	list_a[-1]	456	int
		list_a[4]	[‘我知道’, ‘abc’]	list
	子列表内容读取	list_a[4][0]	我知道	str
index()	逆向通过某元素查索引值	list_a.index(“我”)	1	int
切片读取	从起点到终点前的内容	list_a[1:3]	[‘我’, ‘是’]	list
	切片终点索引超出范围，则取到最后	list_a[1:9:2]	[‘我’, ‘列表’, 456]	list
修改元素	对读取到的元素重新赋值即可	list_a[3] = ‘谁’	原列表变为	[‘你好’, ‘我’, ‘是’, '谁', [‘我知道’, ‘abc’], 456]
	使用切片做整体修改	list_a[1:4]= “帅”	原列表变为	[‘你好’, '帅', [‘我知道’, ‘abc’], 456]
	使用切片做跳跃修改	list_a[1:9:2]= “哈哈哈”	原列表变为	[‘你好’, '哈', ‘是’, '哈', [‘我知道’, ‘abc’], '哈']
删除元素	列表名.pop()	list_a.pop(1)	索引为1的元素被删掉	[‘你好’, ‘是’, ‘列表’, [‘我知道’, ‘abc’], 456]
pop	pop()不传入索引时默认删除最后一个	list_a.pop()	最后一个元素被删掉	[‘你好’, ‘我’, ‘是’, ‘列表’, [‘我知道’, ‘abc’]]
del	del 读取到的内容	del list_a[1]	del 后的内容被删除	[‘你好’, ‘是’, ‘列表’, [‘我知道’, ‘abc’], 456]
切片删除	只要读到的都删，也可以删除列表本身	del list[1:3]		[‘你好’, ‘列表’, [‘我知道’, ‘abc’], 456]
指定删除	remove() 删除时，无需索引，指名道姓即可	list_a.remove(“你好”)	“你好”这个元素被指定删除	[‘我’, ‘是’, ‘列表’, [‘我知道’, ‘abc’], 456]
添加元素	列表名.append(‘新元素’) 默认往列表后面添加	list_a.append(“789”) list_a.append(10)	留意下789是字符串，10是数字	[‘你好’, ‘我’, ‘是’, ‘列表’, [‘我知道’, ‘abc’], 456, ‘789’, 10]
插入新元素	使用insert(“位置”,“新内容”)方法插入元素	list_a.insert(1,“白云”)	原列表变为	[‘你好’,'白云', ‘我’, ‘是’, ‘列表’, [‘我知道’, ‘abc’], 456]

补充：
1、pop()方法有返回值，即他删除的内容会单独拿起来，然后可以赋值给别的变量使用
2、当列表中没有元素的时候，使用pop()，程序会报错,因为以无内容可删
3、del 列表名 # 删除列表本身后，后续程序将不能在使用这个列表，因为删没了
例如：
list_a = [‘你好’,‘我’,‘是’,‘列表’,[‘我知道’,‘abc’],456]
x = list_a.pop()
此时x 的值 就是删除掉的那个元素的值

6.2.2 列表的运算操作

假设有两个列表

list_1 = [1,2,3]
list_2 = [4,5,6]
list_3 = ["小明","小红","张三","李四","小明"]
list_4 = [11,19,12,21,32]

方法	解释	用法	结果	结果的类型
+	合并列表	list_1 + list_2	[1, 2, 3, 4, 5, 6]	list
*	复写列表内容	list_1 * 2	[1, 2, 3, 1, 2, 3]	list
max()	求列表中最大值	max(list_1)	3	int
min()	求列表中最小值	min(list_1)	1	int
sum()	求数字列表中的数字和	sum(list_1)	6	int
count()	求某个元素出现的次数	list_3.count(“小明”)	2	int

6.2.3 列表的排序操作

方法	解释	用法	结果	结果的类型
reverse()	颠倒排序	list_2.reverse()	[6, 5, 4]	list
sort()	对原列表进行从小到大排序	list_3.sort() print(list_3)	[‘小明’, ‘小明’, ‘小红’, ‘张三’, ‘李四’]	list
sort(reverse=True)	从大到小排序	list_3.sort(reverse=True) print(list_3)	[‘李四’, ‘张三’, ‘小红’, ‘小明’, ‘小明’]	list
sorted()	排完序后，返回新的列表，原来的列表不改变	x = sorted(list_4) print(x)	[11, 12, 19, 21, 32]	list
sorted(reverse=True)	从大到小排序	y = sorted(list_4,reverse=True) print(y)	[32, 21, 19, 12, 11]	list

再次补充：
sort()是直接在原来的列表上进行排序，而sorted()是在原来列表的复制品上进行排序操作 前者影响原来列表的顺序，后者不影响

6.2.4 列表的常用方法代码示例

7.元组 tuple（） – 这个桌子上锁了

7.1元组的概念：

名词解释：

（大白话版）
如果把列表理解为一个玻璃桌子，那他抽屉里内容大家都可以动，为了达到不被人直接那么容易就更改的目的，我们给整个桌子上了把锁，虽然他还是桌子，但是大家却只能看不能动，这就是元组。

（书面版）
元组是python中一个不可以被更改内部内容的数据结构。他的内容由小括号（） 包裹，小括号内可以依次存放很多元素，不同元素之间用英文逗号隔开。

tuple_a = (1,2,3,4,5,"元组a")

需要注意的是
如果元组内的元素只有1个，那么在定义时元素右边要加上逗号
tuple_a = (元素1，)

7.2 元组的常用查询方法介绍

由于元组不支持直接修改其中的内容（不能改变原来数据，不能增加或者减少），所以，这里只讲解查询方法（列表的查询方法也适用于元组）。

7.2.1 元组的查寻

假设有一个元组

tuple_a = ('你好','我','是','列表',['我知道','abc'],456)

操作	方法	用法	结果	结果的类型
求长度	使用len()方法查看元组长度即元素个数	len(tuple_a)	6	int
查询元素	通过索引取到具体位置元素的值(元素)	tuple_a[1]	我	str
	元组名[索引值]	tuple_a[-1]	456	int
index()	元组名.index(“元素”)	tuple_a.index(“我”)	1	int
切片读取	切片方法类似列表，但结果是元组	tuple_a[1:3]	('我', '是')	tuple
	就像切火腿肠，人家本来是火腿	切了还是火腿	本来是黄瓜	切了还是黄瓜

7.2.2 元组的查寻代码示例

第三节–python的生命基础 (4)

8.字典dict {:} – 中医的药草你要怎么找

比如有一个班级同学的信息表，每人都会有多条数据，每个数据都单独用一个列表或者元组存储相当麻烦，而且不易维护。这时候字典就可以大显身手。

dict_a = {"键1"："值1","键2"："值2"}
dict_b = {"身高"：183,"体重"：80，"爱好":["编程","篮球","读书"]}
# 下面是一个字典嵌套结构
dict_c = {"小明"：{"身高":183,"体重"：80，"爱好":["编程","篮球","读书"]}，
"小刚"：{"身高":173,"体重"：70，"爱好":["编程","羽毛球","读书"]}}

8.1字典的概念：

名词解释：

（大白话版）
字典也是pyhton数据结构的一种，之前学习列表和元组等，都是按顺序排列的数据结构，而字典是一种无序的数据结构,即在字典中不存在索引的概念，无法通过索引对他进行操作。它的结构是由不同的键和相配对的值构成，就像中医的药草柜子，我们并不是按照具体索引去查找，而是通过查看柜子上的标签【键】去取药【值】

（书面版）
字典是python中一个无序的数据结构，他的元素存储是在{}大括号内，以键和值配对的方式构成，单独键值对之间用冒号连接，不同键值对用逗号隔开，在操作时要通过键取得值的内容，而不是索引。

注意他的键必须时唯一的，值可以是任何其他类型数据，如果由重复的键，那么排后面的同名键值才起作用。

8.2 字典的常用方法介绍

8.2.1 字典的增删改查

定义字典时候如果内容比较多比较长，可以适当使用换行，并不影响字典结构

假设有如下字典

dict_y = {"昵称":"杨老师","身高":183,"生活轨迹":{2020:"python讲师",2021:"UP主"},
"爱好":["编程","篮球","读书","街舞","古筝"]}
dict_y2 = {"地点":"台湾省"}

操作	方法	用法	打印结果	结果的类型
求长度	使用len()方法是老朋友了	len(dict_y)	4	int
查询元素	通过键取到具体的值	dict_y[“昵称”]	杨老师	str
	字典嵌套结构	dict_y[“生活轨迹”]	{2020: ‘python讲师’, 2021: ‘UP主’}	dict
	连续取值	dict_y[“生活轨迹”][2021]	UP主	str
get()	字典名.get(“键”)	dict_y.get(“身高”)	183	int
	获取不到则返回None	dict_y.get(“体重”)	None	NoneType
keys()	字典名.keys()取所有的键	dict_y.keys()	dict_keys([‘昵称’, ‘身高’, ‘生活轨迹’, ‘爱好’])	dict_keys
values()	字典名.values()取所有的值	dict_y.values()	dict_values([‘杨老师’, 183, {2020: ‘python讲师’, 2021: ‘UP主’}, [‘编程’, ‘篮球’, ‘读书’, ‘街舞’, ‘古筝’]])	dict_values
增加元素	对新键赋新值	dict_y2[“水果”]=“凤梨”	{‘地点’: ‘台湾省’, ‘水果’: ‘凤梨’}	dict
更改元素	对旧键赋新值	dict_y2[“水果”]=[“凤梨”,“莲雾”]	{‘地点’: ‘台湾省’, ‘水果’: [‘凤梨’, ‘莲雾’]}	dict
删除元素	del 要删除的内容	del dict_y2[“水果”]	{‘地点’: ‘台湾省’}	dict
	del 字典的名字		会把整个字典删掉,后续程序不可用
pop()	字典名.pop(“键”)	dict_y2.pop(“水果”)	{‘地点’: ‘台湾省’}	dict

8.2.2 字典的常用方法代码示例

9.集合 set() – 世界再大，也只有一个我呀

试想，当我们的列表存储了很多网络上获取的内容，里面不乏有重复的元素，影响我们对数据的解析，这时候就需要先进行去重操作，而python正好就帮我们准备好了这个功能，那就是集合。一行代码就可以实现数据去重。
而且还可以像数学中一样，使用集合求解 差集、交集、 并集、补集等集合操作。

9.1集合的概念：

名词解释：

（大白话版）
集合也是pyhton数据结构的一种，它里面不会存在相同的元素，是一个天然的去重结构。他的元素也存储是在{}大括号内，但是不需要键值对，而且里面的内容必须是不可以原地更改的，所以集合里面并不能存储 列表、 字典、 集合这样的可变数据类型【下面图片有补充解释】

（书面版）
集合是python中一个无序的且不带有重复元素的数据结构。
它里面的元素内容类型也必须是不可变的类型（整数，浮点数，字符串、元组），因此我们只可以增加或者减少集合中的元素，但不可以直接修改其中的元素。

可变类型和不可变类型的解释 主要是看修改后原来存储这个数据的内存地址是原来的还是说新的，如果还是原来的，就说明这个数据是可变类型，如果是新的，就说明这个数据是不可变类型。

9.2 集合的常用方法介绍

假设有如下集合

set_x = {"花生","大豆","高粱"}
set_y = {"大豆","玉米"}

9.2.1 集合的常用方法

功能	方法	示例	打印结果	结果的类型
创建集合	set() 创建空集合	set_a = set()	set()	set
	{1,2,3}直接创建有数据的集合	set_b = {1,2,3}	{1, 2, 3}	set
	set()括号里直接传入数据也可以	set_c = set([1,2,3,1,2,3])	已去重{1, 2, 3}	set
	如果直接用空的{}创建，那么会是创建字典	set_d = {}	{}	dict
添加元素	集合名.add()	set_x.add(“小麦”)	{‘小麦’, ‘花生’, ‘大豆’, ‘高粱’}	set
删除元素	集合名.pop()随机删除	set_x.pop()	{‘大豆’, ‘高粱’}	set
pop()	当集合内没有元素时	再用pop()就会报错
discard()	集合名.discard(“元素”)	set_x.discard(“大豆”)	{‘花生’, ‘高粱’}	set
	当要删的元素不存在时	不会报错	返回值都是None
remove()	集合名.remove(“元素”)	set_x.remove(“大豆”)	{‘花生’, ‘高粱’}	set
	元素不存在则会报错	set_x.remove(“小麦”)	KeyError: '小麦'	程序报错
max()	求最大值
min()	求最小值
sum()	求和	如果集合内都是数字则可以用

9.2.2 集合专属的集合操作方法

set_x = {"花生","大豆","高粱"}
set_y = {"大豆","玉米"}

交集：两个集合都有的部分 （重复的元素）
并集：两个集合合并到一起的整体（重复的元素只计一个）
差集：我有你没有，或者，你有我没有的部分
对称差集：我单独有的和你单独有的（即去掉两个集合共有的部分【并集-交集】）

功能	方法	示例	打印结果	结果的类型
交集	&	set_x & set_y	{‘大豆’}	set
并集	|	set_x | set_y	{‘花生’, ‘玉米’, ‘大豆’, ‘高粱’}	set
差集	-	set_x - set_y	{‘花生’, ‘高粱’}	set
对称差集	^	set_x ^ set_y	{‘花生’, ‘高粱’, ‘玉米’}	set

10.公共方法合集 和 数据类型间的转化

10.1 常用数据类型公共方法

方法	作用
len()	求字符串、列表、元组、字典、集合里的数据长度(不包含数字类型哦哦)

10.2 乾坤大挪移 之 数据类型转化

字符串、列表、元组、字典、集合的转化

方法	作用
str()	把其他数据类型转化为字符串类型
list()	把其他数据类型转化为列表类型
tuple()	把其他数据类型转化为元组类型
set()	把其他数据类型转化为集合类型（ 并去重）
zip(a,b)	把两个其他数据类型，按对应位置拼成一个zip()类型（不够拼的则不拼）
dict()	把上面的zip()类型转化为字典型 具有键值对

第四节–python的生命基础 (5)

11.1 if判断

格式：

if 条件:
    条件成立时执行的代码段

举例：

a_salary = 1700
if a_salary < 28000:
    print('a说他薪资不到三万')

11.2 if…else…

格式：

if 条件：
    条件成立时执行的代码段
else:
    条件不成立时执行的代码段

举例：

a_salary = 1700
b_salary = 13000
if a_salary > b_salary:
    print('a薪资大于b，今晚a请客')
else:
    print('a薪资小于b，今晚b请客')

11.3 if…elif…else…

格式：

if 条件1：
    条件1成立时执行的代码段
elif 条件2：
    条件1不成立 且 条件2成立 时执行的代码段
elif:
    pass
else:
    条件1和条件2都不成立时执行的代码段

举例：

a_salary = 12000
​
if a_salary > 15000:
    print('a薪资大于1万5')
elif a_salary > 11000:
    print('a薪资大于1万1')
else:
    print('a薪资不到1万1')

11.4 多重判断

用多个 elif 进行递进判断

a_salary = 1700
​
if a_salary > 15000:
    print('a薪资大于1万5')
elif a_salary > 11000:
    print('a薪资大于1万1')
elif a_salary < 5000:
    print('a薪资小于5000')
else:
    print('a薪资在5千到1万1之间')

11.5 判断嵌套

在一个判断的代码体里面 加入另一个判断

a_salary = 17000
​
if a_salary > 5000:
    print('a薪资大于5千')
    if a_salary > 10000:
        print('a薪资大于1万')
        if a_salary > 18000:
            print('a薪资大于1万8')
        else:
            print('a薪资大于1万,小于1万8')
    else:
        print('a薪资大于5000，小于1万')
else:
    print('a薪资小于等于5千')

第五节–python的生命基础 (6)

12.1 for循环

格式：

for 循环变量 in 被循环对象：
    循环体代码段

假设小组里有6位队员，现在开始让大家报数
原始写法：

# 在未使用循环情况下报数
print('报数')
print(1)
print(2)
print(3)
print(4)
print(5)
print(6)
print('...')
print('i am tired....')

直接用数字6放在循环中试一下

for i in 6:
    print(i)

发现会报错 如下

---

TypeError                                 Traceback (most recent call last)
<ipython-input-46-b7b067965098> in <module>
----> 1 for i in 6:
      2     print(i)

TypeError: 'int' object is not iterable

发现数字不能被直接循环 字符串 列表 元祖 字典 等有一定排列的数据结构才可以

尝试对列表进行循环

# 使用循环进行报数的情况
print('报数')
for i in [1,2,3,4,5,6]:
    print(i)

# 使用for 循环 和 else结合
print('报数')
for i in [1,2,3,4,5,6]:
    print(i)
else:
    print('报数完毕')

12.2 range()函数

range(起点,终点,步长) 取值范围是从起点开始 到终点前的一个数据

# 取某一个范围内的数据，终点是7，默认起点是0 
x = range(7)
print(x)
print(list(x))
print()

# 取起点到终点的元素 起点是1 终点是7
y = range(1,7) 
print(y)
print(list(y))
print()

# 步长为2进行取值
z = range(1,7,2)
print(z)
print(list(z))

12.3 range()函数在循环中的使用

# for循环结合range()函数的使用
print('报数')
for i in range(1,7):
    print(i)

12.4 while循环

格式：

while 条件：
    满足条件时的循环体代码

# while循环
n = 1
while n < 3:
    print('n 进来是',n,'小于10')
    n = n+1
    print('----n 出去是',n)
    print()

12.5 while循环和else的结合

# while循环和else的结合

n = 6
while n < 10:
    print('n 进来是',n,'小于10')
    n = n+1
    print('----n 出去是',n)
else:
    print('n不满足n < 10的条件，到我这里了，现在是：',n)

12.6 循环控制语句

12.6.1 break

for 循环中 break 的使用

# for 循环中 break 的使用
for i in range(1,7):
    if i == 3 :
        break
    else:
        print(i)

while 循环中 break 的使用

#  while 循环中 break 的使用
n = 6 
while n < 12:
    print(n)
    n = n + 1
    if n == 10:
        break

#  while  true 循环中 break 的使用
n = 6 
while True:
    print(n)
    n = n + 1
    if n == 10:
        break

12.6.2 continue

作用： 终止当前循环，继续下一次循环

for 循环中 continue 的使用

# for 循环中 continue 的使用
for i in range(1,7):
    if i == 3 :
        continue
    else:
        print(i)

while 循环中 continue 的使用

# while 循环中 continue 的使用
n = 6 
while n < 12:
    print(n)
    n = n + 1
    if n == 10:
        print('a = 10 的时候我打印了')
        continue
        print('你会看到我没有被打印')

# 求某个范围内的奇数  注意这个程序对起始值无法判断
n = 6
while n < 12:
    n = n + 1
    if n % 2 == 1:  # 百分号% 是一个取余符号 
        print(n)
        continue

12.7 循环和判断结合

# 以火影忍者中 药师兜 和 宇智波’鼬 的对战为例

status_dou = '执迷不悟'

# 由于不知道同样的剧情循环多少次 所以用while循环
while status_dou == '执迷不悟':
    print('兜继续在伊邪那美中循环打斗')
    jie_shou = input('兜要接受自己吗？回答 要 或 不要即可：')
    print()
    if jie_shou == '要':
        status_dou = '解脱'
        print()
        print('兜接受了自己，跳出了伊邪那美的循环')
    else:
        print('兜执迷不悟，还要在伊邪那美中玩耍')

第六节 – 邀你参加python达人秀

任务：绘制进阶邀请卡

第七节 – 函数的使用

7.1、函数是什么

以前我们学的代码就相当于锅碗瓢盆、柴米油盐。这些物品现在放的家里到处都是，但是，由于放的太零散。我们就想归类一下，放到一起，那放到哪里呢？厨房，对的。厨房就是这个函数。以后你需要做什么，告诉厨房就好了。（大户人家了hhh）而不是每次要做饭，再重新找工具。函数已经帮我们整理好了。

当代码越写越多，读起来越来越不好归类的时候 我们就需要用到函数了。
其实简单理解，函数就是对过往零散代码的一次打包。让代码更有结构化，不至于散乱。而且还方便整体某部分代码的重复使用。

7.2、函数的基本使用

7.2.1 常规函数的定义和使用

# demo 009-2.1-01  函数的定义
# 定义一个名为Square的函数 函数体内容暂无
def Square():
    print(1)
    pass
Square()

1

# demo 009-2.1-02  函数的结构
# 定义一个名为Square的函数 函数体内容为 求固定值的平方
def Square():
    answer = 10*10
    print(answer)
Square()


# 带返回值的形式
def Square2():
#     answer = 10*10
    雪 = 10*10
    return 雪
res1 = Square2()
print(res1)

100
100

7.2.1.1 带一般参数的函数

一般参数 有个专业名称 叫 位置参数

# demo 009-2.1-03  带必须参数的函数 传递时必须带参数
# 定义一个名为Square的函数,函数体内容为 求给定参数值的平方
def Square(n):  # 此处n 叫做 形参 形式参数
#     a = str(n)
    answer = n*n
    print(answer)
Square(10)  # 此处的 10 代表实参  实际参数

100

7.2.1.2 带多参数的函数

# demo 009-2.1-04  带常规参数的函数
# 定义一个名为cheng_ji的函数,函数体内容为 求给定参数值的乘积
def cheng_ji(n,m):
    print('n',n)
    print('m',m)
    answer = n*m
    print(answer)
cheng_ji(20,10)

# 参数会按照相对应的顺序位置 进行相应传递 

n 20
m 10
200

7.2.1.3 带关键字参数的函数

# demo 009-2.1-05  带关键字参数的函数 
# 定义一个名为cheng_ji的函数,函数体内容为 求给定参数值的乘积
def cheng_ji(n,m):
    print('n',n)
    print('m',m)
    answer = n*m
    print(answer)
cheng_ji(m = 10,n = 20)

# 参数会按照相对应的名字 进行相应传递和接收

n 20
m 10
200

7.2.1.4 带默认参数的函数

# demo 009-2.1-06  带默认参数的函数 
# 定义一个名为cheng_ji的函数,函数体内容为 求给定参数值的乘积
def cheng_ji(n,m,v=3):
    print('n',n ,'m',m,'v',v)
    answer = n*m*v
    print(answer)
cheng_ji(m = 10,n = 20)
print('----换行-----')
cheng_ji(10,20,4)

print('----换行-----')

# 参数会先按顺序接收，然后按关键字接收，所以关键字参数要写在常规参数后面 不然报错
# cheng_ji(v=20,3,10) 

n 20 m 10 v 3
600
----换行-----
n 10 m 20 v 4
800
----换行-----

7.2.1.5 不定长位置参数 (后续参数传递，基础仅做了解即可)

# demo 009-2.1-07  带不定长参数的函数 
# 定义一个名为cheng_ji的函数,函数体内容为 求给定参数值的乘积
def cheng_ji(n,m,*arg):
    print('n',n ,'m',m,'arg',arg)
    answer = n*m*arg[0]
    print(answer)
cheng_ji(10,20,2,3)

cheng_ji(10,20,2,3,v = 2) 

n 10 m 20 arg (2, 3)
400



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-20-db15a118ee23> in <module>
      7 cheng_ji(10,20,2,3)
      8 
----> 9 cheng_ji(10,20,2,3,v = 2)


TypeError: cheng_ji() got an unexpected keyword argument 'v'

7.2.1.6 不定长关键字参数

# demo 009-2.1-08  带不定长参数的函数 

def cheng_ji(n,m,*arg,**argv):
    print('n:',n ,'m:',m,'arg:',arg,'argv:',argv,'v:',argv['v'])
    answer = n*m*arg[0]
    print(answer)

cheng_ji(10,20,4,2,3,v = 2) 

n: 10 m: 20 arg: (4, 2, 3) argv: {'v': 2} v: 2
800

# demo 009-2.1-09  带不定长关键字参数的函数 

def cheng_ji(n,m,**argv):
    print('n:',n ,'m:',m,'argv:',argv)
    answer = n*m
    print(answer)

cheng_ji(10,20,v = 2,p = 3) 

n: 10 m: 20 argv: {'v': 2, 'p': 3}
200

7.2.1.7 常规函数总结

函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

任何传入参数和自变量必须放在小括号中间，小括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号 : 起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cGVKltXS-1630578424360)(attachment:image.png)]

7.2.2 匿名函数(拓展)

lanbda 表达式 （仅做了解）

可以不用去构造常规结构函数，就可以处理一些简单的数据。

格式： lambda 参数：表达式

# demo 009-2.2-01 
# 将列表中数据都计算为平方值

num_list1 = [1,3,5,7,9]
num_list2 = []
def Square():
    for i in  num_list1:
        x = i * i
        num_list2.append(x)
    print(num_list2)
Square()

[1, 9, 25, 49, 81]

# demo 009-2.2-02
# 结合高级map函数  配套使用lambda表达式

num_list1 = [1,3,5,7,9]
Square_list  = map(lambda n: n*n, num_list1)
print(Square)
print(list(Square_list))

<function Square at 0x0000020FB6FEB160>
[1, 9, 25, 49, 81]

7.3.综合练习

# BMI质量指数计算 
print(round(80/(1.83**2),2))

23.89

# 伪代码 打通思路
def body_health(接收用户传入的身高，体重):
    根据用户传入的数据 计算BMI
    判断BMI值所在的区间，根据不同区间得出不同结论
    return 结论
    

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ABxYHXUp-1630578424366)(attachment:BMI%E4%B8%96%E7%95%8C%E6%A0%87%E5%87%86.webp)]

def body_health(height,weight):
    BMI = round(weight / height**2,2)  # 两个*号 代表乘方的意思
    print(BMI)
#     return
    if  BMI < 18.5:
        result = '体重过低'
    elif  18.5 <= BMI < 24 :
        result = '正常范围'
    elif  24 <= BMI < 28:
        result = '超重，肥胖前期'
    elif BMI >= 28:
        result = '肥胖'
    return result
height = float(input('请输入身高值，然后按回车键结束：（单位m）'))
weight = float(input('请输入体重值，然后按回车键结束（单位kg）'))
res = body_health(height,weight)
print('您的BMI计算结果为：',res)

请输入身高值，然后按回车键结束：（单位m）1.83
请输入体重值，然后按回车键结束（单位kg）80
23.89
您的BMI计算结果为： 正常范围

第八节 – 类的使用

虽然python中我们也说一切皆对象，但从学习类开始，才是学习面向对象编程的开始。
类 就是 一个类对象

8.1.类是什么

如果你已经明白了函数是什么，那么类就更好理解了。类就是对函数的打包，是比函数更高级的语法格式。
以前学的变量，放到类里，叫做属性。
以前学的函数，放到类里，叫做方法。

8.2 .类的定义

# demo-012-2-01 

# 类名  不  带括号  的形式

class Joke:
    pass

Joke()

<__main__.Joke at 0x2d433f26bb0>

# demo-012-2-02  
# 类名  带括号  的形式    建议使用

class Joke2():
    pass

Joke2()

<__main__.Joke2 at 0x1b494a20ee0>

8.2.1属性定义

# demo-012-2-03 
# 定义类变量(属性) 并直接调用

class Joke3():
    name = '马冬梅'  # 定义一个类变量（属性）
    
Joke3()
Joke3().name  # 是在解释器进行的输出  在编辑器的话看不到

'马冬梅'

# demo-012-2-04 
# 定义类变量(属性) 间接调用

class Joke4():
    name = '马冬梅'  # 定义一个类变量(属性)
    
jok = Joke4() 
# print(jok)
print(jok.name)

马冬梅

8.2.2方法定义

# demo-012-2-05 
# 定义类方法（类函数） 间接调用

class Joke5():
    name = '马冬梅'  # 定义一个类变量(属性)
    
    def answer(self):
        print('我是answer')
        return self.name

    def answer2(self):  #不加self  是错误举例
        print('我是answer2')
        return self.name
    
jok = Joke5() 

print('调用answer')
print(jok.answer())  

print('调用answer 2')
print(jok.answer2())  # 类方法 不带第一个参数self 就无法调用 且类变量也无法调用

调用answer
我是answer
马冬梅
调用answer 2
我是answer2
马冬梅

8.3 类的基本使用

8.3.1类的实例化

# demo-12-3-01 
# 类的实例化

class Joke():
    name = '马冬梅'  # 定义一个类变量(属性)
    
    def answer(self):
        print('我是answer')
        return self.name
    
# 把一个类 赋值给 某一个实际的变量 进而让该变量使用该类的功能  可以赋值给多个变量，每次拿到的实例都是全新的
jok = Joke() 
jok.name

'马冬梅'

8.3.2属性调用

# demo-12-3-02
# 类的实例化  为什么不用类名直接调用类方法 反而 用实例化的对象去调用
 
class Joke():
    name = '马冬梅'  # 定义一个类变量(属性)
    
    def answer(self):
        print('我是answer')
        return self.name
    
Joke().name
jok = Joke() # 实例化类   也就是 把一个类 赋值给 某一个实际的变量 进而让该变量在后续代码中使用该类的功能
# jok.name  # 这样和直接用类名调用没什么区别
person_name = jok.name
print(person_name)

马冬梅

8.3.3方法调用

# demo-12-3-03
# 类方法的调用
 
class Joke():
    name = '马冬梅'  # 定义一个类变量(属性)
    
    def answer(self):
        print('我是answer')
        return self.name
    
Joke().answer()  # 不打印的话 只是在解释器里有结果 Out[xx]:xxxxx
print(Joke().answer())

# jok = Joke().answer() # 接收返回值 然后优点在于后续程序可以使用 
# print(jok)

我是answer
我是answer
马冬梅

8.3.4类的初始化

# demo-12-3-04
# 类的 初始化

class Joke():
    # 类的实例化操作会自动调用 __init__() 方法
    def __init__(self):
        print('我是实例化方法')
        self.name = '马冬梅'  # 定义类属性
        self.gender = '女'
    
    def answer(self):  # 定义一个类方法
        print('我是answer')
        return self.name

print('实例化之前')
jok = Joke() # 实例化类
print('实例化之后')
print(jok)
print(jok.name,jok.gender)

ans = jok.answer()  # 如果分不清什么时候要赋值 什么时候不要赋值 就记得  如果你的结果后续代码要多次用到 那就赋值  只用一次那就免了
print(ans)

实例化之前
我是实例化方法
实例化之后
<__main__.Joke object at 0x000001B494AE3490>
马冬梅 女
我是answer
马冬梅

8.3.5类的传参

# demo-12-3-05
# 类的 传参  
# 根据用户调用的次数 返回不同的结果


class Joke():
    def __init__(self,name,gender,times=1):  #初始化时需要传递相应的参数进来
        print('我是实例化方法，我在实例化时就被自动调用')
#         self.name = '马冬梅' 
#         self.gender = '女'
        self.name = name
        self.gender = gender
        self.times = times
        self.response = ''
        self.response_list = [self.name,'什么冬梅？','马冬什么？','刘德华']
    
    def answer(self):
        if self.times == 1:
            self.response = self.response_list[0]
        elif self.times == 2:
            self.response = self.response_list[1]
        elif self.times == 3:
            self.response = self.response_list[2]
        elif self.times == 4:
            self.response = self.response_list[3]
        elif self.times > 4:
            self.response = '游戏结束咯'
        
#         # 上面 if 判断的优化
#         if self.times > len(self.response_list):
#             self.response = '游戏结束咯'
#         else:
#             self.response = self.response_list[self.times-1]


        self.times = self.times + 1        
        return  self.response
        
        

jok = Joke('马冬梅','女') # 实例化类 

print(jok.name,jok.gender,jok.times)

print('------开始传话------')
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())
print('第',jok.times,'次传话',jok.answer())

print('------开始传话-------')
jok2 = Joke('马冬梅','女')
print('jok2','第',jok2.times,'次传话','jok2.answer',jok2.answer())
print('jok2','第',jok2.times,'次传话','jok2.answer',jok2.answer())

我是实例化方法，我在实例化时就被自动调用
马冬梅 女 1
------开始传话------
第 1 次传话 马冬梅
第 2 次传话 什么冬梅？
第 3 次传话 马冬什么？
第 4 次传话 刘德华
第 5 次传话 游戏结束咯
第 6 次传话 游戏结束咯
第 7 次传话 游戏结束咯
------开始传话-------
我是实例化方法，我在实例化时就被自动调用
jok2 第 1 次传话 jok2.answer 马冬梅
jok2 第 2 次传话 jok2.answer 什么冬梅？

8.4.类的继承

# demo-12-4-01
# 类的 继承

class HouYi():
    
    def __init__(self):
        self.name = '后羿'
        self.gender = '男'
        self.weapon = '弓箭'
        self.hobby = '打猎'
        
    def skill(self):
        return '射箭，百发百中'
        
    #该方法也是类本身默认会调用的方法  用于返回类对象的名称
    def __repr__(self):
        return self.name
    

class HouYiWife():
    def __init__(self):
        self.name = '后羿妻子'
        self.gender = '女'
        self.weapon = '爱的魔力转圈圈'
        self.hobby = '烹饪'
        
    def skill(self):
        return '打后羿，不许还手'
    def skill2(self):
        return '养兔子'
        
class Son(HouYi):
    pass

#     def __init__(self):
#         self.name = 'son'
        
class Son2(HouYi,HouYiWife):
    
    def __init__(self):
        self.name = 'son2'
    
    def skill(self):
        return '我自己会 吹大牛'
    
houyi = HouYi()
print(houyi)
print('houyi.name',houyi.name)
print('houyi.skill',houyi.skill()) # 后羿的技能
print()

hou_yi_wife = HouYiWife()
print('hou_yi_wife.name',hou_yi_wife.name)
print('hou_yi_wife.skill',hou_yi_wife.skill())
print()

son = Son()
print('son.name',son.name)
print('son.skill',son.skill())
print()

son2 = Son2()
print('son2.name',son2.name)
print('son2.skill',son2.skill())
print('son2.skill2',son2.skill2())

<__main__.HouYi object at 0x000001B494BEF730>
houyi.name 后羿
houyi.skill 射箭，百发百中

hou_yi_wife.name 后羿妻子
hou_yi_wife.skill 打后羿，不许还手

son.name 后羿
son.skill 射箭，百发百中

son2.name son2
son2.skill 我自己会 吹大牛
son2.skill2 养兔子