1. print() 输出
（1）认识英文单词
print: 输出
（2）print() 的作用
print()：用于在控制台上输出你想要的内容。
（3）代码演示
- 举例1：
【注意：】用双引号包裹的，引号里面是啥，就会输出啥
print("Hello Python")
- 举例2：
print('100+200')
- 举例3：
【注意：】如果只输出纯数字，不需要加引号
print(123)
- 举例4：
直接进行数学运算的输出
print(100+200)
2. 变量
（1）创建变量
- 举例1：
# 创建a变量
a = 123
# 输出a变量的值
print(a) #结果：123
解读代码：
- 【注意1】：= 不是等于的意思，是 “赋值” 的意思
- 【注意2】：a = 123，这行代码阅读的顺序是从右边往左边阅读，意思为：将数字123赋值给变量a
- 【注意3】：创建变量就相当于创建了一个空盒子，我们把这个盒子命名为: a，然后把数字123放到盒子里面，print(a)相当于拿出a盒子里面存放的东西，结果会输出123。
- 举例2：
a = 100
print(a) #100
a = 200
print(a) #200
解读代码：
变量中的值是可以被修改的，一开始我们将100放进了a盒子，之后我们执行了a = 200这行代码，表示将a盒子之前的存储的数字换成200，所以最终输出a盒子，结果为200
（2）变量名的规则
- 【规则1】：变量名可以包含字母、数字、下划线，但数字不能在变量名首位，例如以下变量名：
a（合法）、a123（合法）、_xyz（合法）、2b（不合法，不能以数字开头）
- 【规则2】：具有特殊含义的单词不能作为变量名，否则会报错，因为它们在python中已经代表了特定的意思，例如以下单词：
False，True，None，and，as，def，del，elif，else，for，while，from，if，import，in，is，not，or 等等。
举例：
True = 123
print(True) #报错啦
3. 数据类型
python中数据类型有很多，我们先学习以下4种基本的数据类型：
| 类型名 | 意思 | 示例 |
|---|---|---|
| int | 整数 | 100、200 |
| str | 字符串 | '123'、'abc' |
| float | 小数 | 3.14 、 5.5 |
| bool | 布尔型 | True、False |
当我们创建变量时，我们可以创建出以上四种数据类型的任意一种，例如：
为了更方便的判断变量属于哪一种数据类型，可以使用type()来进行判断：
（1）type判断类型
# 使用type()获取判断数据类型
print(type(10))
print(type(10.15))
print(type("哈哈"))
print(type(True)) #注意：首字母需要大写
print(type(False)) #注意：首字母需要大写
结果：
（2）数据类型转换
以上4中数据类型相互之间都可以进行转换，例如：
注意：
其他类型转换成整数型时，包含字母或其它字符都不能转成整数，只有纯数字才可以，浮点数也是一样的。请看下面例子：
print(int('13a')) #报错
print(float('42abc')) #报错
4. input() 输入
（1）认识英文单词
input: 输入
（2）input 的作用
input()：如果你想向电脑输入内容，就可以使用它。
（3）代码演示
- 举例1：
重点：使用input() 输入的内容，不管输入什么，赋值给a变量后，a一定是字符串类型。
5. 字符串
（1）字符串写法
Python字符串支持使用单引号、双引号和三引号三种写法。
print('Hello World!!!')
print("Hello World!!!")
print('''Hello World!!!''')
（2）字符串的拼接
字符串的连接可以使用 +号 或者 逗号 ，具体如下：
# 字符串拼接，+号紧凑，逗号松散
print("我"+"和"+"你")
print("我","和","你")
结果：
我们还可以使用 * 号来对字符串进行拼接组合，比如：
a = "*"*3
print(a) #结果：***
下面的例子中，如果我们想要输出字符串小明666，直接用加号拼接是不行的，这样会报错。
name = '小明'
num = 666
res = name + num
print(res) #报错
使用"+"运算符连接字符串时，两边的必须都是字符串类型。如果有其他类型的操作数，需要先将其转换为字符串类型，再进行拼接。正确的做法是：
name = '小明'
num = str(666)
res = name + num
print(res) #结果：字符串的 小明666
print(type(res)) #<class 'str'>
（3）输出格式
| 格式符 | 说明 |
|---|---|
| %d | 格式化整数，会直接取整 |
| %f | 格式化浮点数，可以设置保留的小数点 |
| %s | 字符串 |
name = "小明"
age = 3.33
weight = 1.23456
print("我的名字叫%s，今年%d岁了，身高%.2f"%(name, age, weight)) #我的名字叫小明，今年3岁了，身高1.23
- %10.2f：可以理解为10个占位符，不足的用空格占用；
- %10s和%-10s：可以理解为占用10个位置，占用前面和占用后面的区别；
6. 布尔类型
- 在int整数型中，有非常多的数字，例如1，2，3 等等，但是在布尔类型中，它只有两个值：True 和 False。True就是真的意思，代表成立；False就是假的意思，代表不成立。
（1）关系运算符
布尔类型的值，是专门用于各种表达式的判断，表达式的运算符如下：
| 名称 | 关系运算符 | 表达式返回值 |
|---|---|---|
| 大于 | > | 成立返回True，否则为False |
| 小于 | < | 成立返回True，否则为False |
| 等于 | == | 成立返回True，否则为False |
| 大于等于 | >= | 成立返回True，否则为False |
| 小于等于 | <= | 成立返回True，否则为False |
| 不等于 | != | 成立返回True，否则为False |
# 表达式返回值
print(6 > 5) #True
print(6 > 7) #False
print(6 < 7) #True
print(6 < 5) #False
print(6 == 6) #True
print(6 == 7) #False
print(6 >= 7) #False
print(6 <= 7) #True
print(6 != 7) #True
（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；x为False时，结果为True |
print(0 and 1) #0
print(1 and 2) #2
print(0 or 1) #1
print(1 or 2) #1
# 表达式
print(5 > 6 and 5 > 4) #False
print(7 > 6 and 5 > 4) #True
print(5 > 6 or 5 > 4) #True
print(5 > 6 or 5 < 4) #False
print(not 5 > 6) #True
print(not True) #False
（3）布尔型的数据类型转换
【1】其他类型转为布尔类型
- 其他类型转为布尔型是通过bool()来进行的，最终只能转换成True和False。
- bool()进行转换时，括号中如果时以下情况：None、0、‘’、[]、()、{}、None将被转换为False，其他所有值都将被转换为True。
# 数字转布尔
print(bool(0)) # False
print(bool(1)) # True
# 字符串转布尔
print(bool('')) # False
print(bool('Hello')) # True
# 空列表转布尔
print(bool([])) # False
print(bool([1, 2, 3])) # True
# 空元组转布尔
print(bool(())) # False
print(bool((1, 2))) # True
# 空字典转布尔
print(bool({})) # False
print(bool({'key': 'value'})) # True
# None转布尔
print(bool(None)) # False
print(bool(not None)) # True
【2】布尔类型转为其他类型
# 布尔值转换为整数
print(int(True)) # 输出 1
print(int(False)) # 输出 0
# 布尔值转换为字符串
print(str(True)) # 字符串的True
print(str(False)) # 字符串的False
7. 四则运算
（1）算术运算符
虽说叫做四则运算，但其实运算符往往不止加减乘除这四种，请看下表：
| 运算 | 符号 | 格式 | 结果 |
|---|---|---|---|
| 加 | + | 1 + 1 | 2 |
| 减 | - | 2 - 1 | 1 |
| 乘 | * | 3 * 4 | 12 |
| 除 | / | 6 / 2 | 3.0 |
| 整除 | // | 9 // 7 | 1 |
| 求余 | % | 10 % 8 | 2 |
| 幂 | ** | 2**3 | 8 |
注意：
- 在编程语法中乘法 x 用 * 号代替，除法 ÷ 用 / 代替。
- 除法 / 是保留小数的，而整除 // 是直接取整的。
- 幂运算中：2**3，2为底数，3为指数，换算成乘法为：2 x 2 x 2 = 8。
python运算符的优先顺序：
| 运算符说明 | Python运算符 | 优先级顺序 |
|---|---|---|
| 小括号 | ( ) | 高——>低 |
| 乘方 | ** | |
| 乘、除、取余、取整 | *、/、%、// | |
| 加减 | +、- | |
| 比较运算符 | ==、!=、>、>=、<、<= | |
| 逻辑非 | not | |
| 逻辑与 | and | |
| 逻辑或 | or |
#小括号
number = (3 + 2) * 2
print(number) #10
#乘方
number = 3 * 2 ** 2
print(number) # 12
number = 8 / 2 ** 2
print(number) # 2.0
number = 7 % 2 ** 2
print(number) # 3
number = 7 // 2 ** 2
print(number) # 1
#乘法
number = 5 + 2 * 2
print(number) # 9
#除法
number = 5 - 2 / 2
print(number) # 4.0
#取余数
number = 5 - 2 % 2
print(number) # 5
#取整数
number = 5 + 2 // 2
print(number) # 6
#加减运算高于比较运算
print(5 < 3 + 2) # False
print(5 == 3 + 3) # False
#比较运算高于not
print(not 6<=6) #False
#not高于and
print(True and not False) #True
#and高于or
print(True or True and False) #True
（2）变量自运算
- 自运算，就是让变量本身的值累计运算，比如累加、累减等；
- += 累加，a += 1，相当于a = a + 1;
- -= 累减，a -= 1，相当于a = a -1;
- 注意：Python不支持a++语法；
# 累加
a = 1
a+=1
print(a) #2
8. if 条件判断
（1）if…单一条件
假设你一周七天中只有周一才能穿新衣服，那么就需要 if语句 中 单一条件判断：
- 单一条件判断的if语句格式如下：
if 条件判断:
条件满足时，执行
# 注意1：判断的数值需要转换为整数再判断
# 注意2：a == 1由于习惯或方式，可以加上括号(a == 1)
# 注意3：if条件判断内的语句，需要用Tab键缩进才能识别
a = int(input("请输入今天星期几，1-7之间："))
if a == 1:
print("今天穿新衣")
（2）if…else分支
单一if语句比较高冷，如果未满足条件，它就不理你了；而else分支则可爱许多；
- else分支条件判断的if语句格式如下：
if 条件判断:
条件满足时，执行
else:
条件不满足时，执行
# 注意1：else后面有冒号，表示结束
# 注意2：else需要和if在同一垂直位对齐，否则报错
if a == 1:
print("今天穿新衣")
else:
print("今天无法穿新衣")
9. 多重嵌套
（1） elif…多重分支
年龄决定一个人当前的状态，8岁到80岁，你都在干什么？此时需要elif多重分支：
if 条件判断:
条件满足时，执行
elif 条件判断:
条件满足时，执行
...
# 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岁就真的可以退休了吗？真实情况显然不是这样的，我们还需要具体判断：
...
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("退休中！")
...
10. while循环
1. 认识while循环
（1）while循环简介
- while循环是一种条件控制循环，只要给定的条件为真，循环就会持续执行。它通常用于重复执行一个任务，直到条件不再满足，跳出循环。
（2）while循环示意图
（3）while循环语法
2. while常规循环
- 需求：输出1~3之间所有的整数
i = 1 # 初始化变量1
while i <= 3: # 如果变量小于等于3，则执行下面的循环体
print(i)
i += 1 # 当执行完毕，自增1
# 以上循环最终结果：
# 1
# 2
# 3
------------------------------------
这里我们依次拆解while循环的过程：
第一次循环：
i = 1
i <= 3 条件成立
print(i) ---> 结果：输出1
i += 1，相当于 i = 2
第二次循环：
i = 2 因为第一次循环结束后i已经变为2了
i <= 3 条件成立
print(i) ---> 结果：输出1 2
i += 1，相当于 i = 3
第三次循环：
i = 3
i <= 3 条件成立
print(i) ---> 结果：输出1 2 3
i += 1，相当于 i = 4
第四次循环：
i = 4
i <= 3 条件不成立，循环终止
------------------------------------
- 需求：计算1到3之间所有整数的和
i = 1 # 初始化变量1
sum = 0 #初始化求和变量，用于统计最终的结果
while i <= 3: # 如果变量小于等于3，则执行下面的循环体
sum += i # 累加
i += 1 # i自增1
print(sum) # 6
------------------------------------
这里我们依次拆解while循环的过程：
第一次循环：
i = 1
sum = 0
i <= 3 条件成立
sum += i 相当于sum = sum+i = 0+1
i += 1，相当于 i = 2
第二次循环：
i = 2
sum = 0+1
i <= 3 条件成立
sum += i 相当于sum = sum+i = 0+1+2
i += 1，相当于 i = 3
第三次循环：
i = 3
sum = 0+1+2
i <= 3 条件成立
sum += i 相当于sum = sum+i = 0+1+2+3
i += 1，相当于 i = 4
第四次循环：
i = 4
sum = 0+1+2+3
i <= 3 条件不成立，循环终止,最终sum = 6
------------------------------------
3. while死循环
- while循环除了普通的循环，有时候也会出现死循环的情况，比如：
# 只要判断表达式永远为True，则不停的执行
while True:
print(1)
# 以上代码会不停的输出1的值，因为条件始终是成立的，所以循环会一直执行，也就出现了所谓的死循环，这时候计算机会卡死，性能消耗太大了；但是，死循环也不是一无是处，我们可以利用死循环的特性，结合break语句，帮助我们做一些特殊的处理，后面我们会讲到。
11. for循环
1. 认识for循环
（1）for循环简介
- 在Python中，
for循环是一种用于遍历序列（如列表、元组、字典、字符串）或其他可迭代对象（如range对象等）的控制流语句。
（2）for循环示意图
（3）for循环语法
for 变量 in 序列:
循环体
【注】：在这个结构中，变量是一个临时变量，用于获取序列中的每一个元素。循环体会针对序列中的每个元素各执行一次。
2. for循环示例
- 需求：输出1~3之间所有的整数
for i in range(1,4): # 使用range函数生成一个从1到3的整数序列: [1,2,3]
print(i)
# 结果：
1
2
3
------------------------------------
这里我们依次拆解for循环的过程：
第一次循环：
i = 1 【range生成的第一个数】
print(i) ---> 结果：输出1
第二次循环：
i = 2 【range生成的第二个数】
print(i) ---> 结果：输出2
第三次循环：
i = 3 【range生成的第三个数】
print(i,) ---> 结果：输出3
------------------------------------
- 需求：计算1到3之间所有整数的和
sum = 0 #初始化求和变量，用于统计最终的结果
for i in range(1,4):
sum += i # 累加
print(sum) # 6
------------------------------------
这里我们依次拆解for循环的过程：
第一次循环：
sum = 0
i = 1 【range生成的第一个数】
sum += i，即sum = sum + i = 0+1
第二次循环：
sum = 0+1
i = 2 【range生成的第二个数】
sum += i，即sum = sum + i = 0+1+2
第三次循环：
sum = 0+1+2
i = 3 【range生成的第三个数】
sum += i，即sum = sum + i = 0+1+2+3 = 6
------------------------------------
3. for循环嵌套
- 循环语句和分支语句一样，也是可以进行嵌套的。具体可以while循环中嵌套while，可以for循环中嵌套for。因为for的循环变量定义更明确，所以一般用双for循环嵌套会多一些。
for i in range(1, 3):
for i in range(1, 4):
print("Hello World!")
结果：
分析代码：拆解以上循环嵌套的执行过程
第一次外层循环：
i = 1; //i的初始值为1
i < 3 //条件成立，进入内层循环
第一次进入内层循环：
【内层循环第一次：】
j = 1; //j的初始值为1
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为2
【内层循环第二次：】
j = 2;
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为3
【内层循环第三次：】
j = 3;
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为4
【内层循环第四次：】
j = 4;
j < 4 //条件不成立，内层循环结束
i++; //i的值变为2
第二次外层循环：
i = 2;
i < 3 //条件成立，进入内层循环
第二次进入内层循环：
【内层循环第一次：】
j = 1; //j的初始值为1
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为2
【内层循环第二次：】
j = 2;
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为3
【内层循环第三次：】
j = 3;
j < 4 //条件成立
print("Hello World!"); //此时输出一次 Hello World!
j++; //j的值变为4
【内层循环第四次：】
j = 4;
j < 4 //条件不成立，内层循环结束
i++; //i的值变为3
第三次外层循环：
i = 3;
i < 3 //条件不成立，外层循环结束，整个循环都终止了
12. 退出循环
1. break退出整体循环
break语句的作用：立即退出整个循环；
- 需求：输出1~10之间所有的整数，并用“|”分隔开
for i in range(1, 11):
print(i, end="|")
#最终结果：1|2|3|4|5|6|7|8|9|10|
假如我们给出的序列为range(1, 11) ，依旧是1到11的序列，但是我们只想要输出1~3之间的整数，该怎么做呢？此时，我们就可以使用break语句了。
for i in range(1, 11):
print(i, end="|")
if i == 3:
break
#最终结果：1|2|3|
------------------------------------
这里我们依次拆解for循环的过程：range范围[1,2,3,4,5,6,7,8,9,10]
第一次循环：
i = 1 【range生成的第一个数】
print(i, end="|") ---> 结果：输出1|
if i == 3: 条件不成立，break语句不执行，循环继续
break
第二次循环：
i = 2 【range生成的第二个数】
print(i, end="|") ---> 结果：输出1|2|
if i == 3: 条件不成立，break语句不执行，循环继续
break
第三次循环：
i = 3 【range生成的第三个数】
print(i, end="|") ---> 结果：输出1|2|3|
if i == 3: 条件成立，进入下面的break语句，立即停止整个循环，所以最终结果为：1|2|3|
break
2. continue退出当前循环
continue语句的作用：终止当前循环；
沿用上面的例子，假如我们给出的序列为range(1, 11) ，依旧是1到11的序列，现在我们的需求是输出1~10之间所有的整数，但不想要3这个整数，该如何做呢？此时，我们就可以使用continue语句了。
for i in range(1, 11):
# 注意：这里continue必须在输出语句前面执行，否则白搭
if i == 3:
continue
print(i, end="|")
#最终结果：1|2|4|5|6|7|8|9|10|
------------------------------------
这里我们依次拆解for循环的过程：range范围[1,2,3,4,5,6,7,8,9,10]
第一次循环：
i = 1 【range生成的第一个数】
if i == 3: 条件不成立，continue语句不执行，循环继续
continue
print(i, end="|") ---> 结果：输出1|
第二次循环：
i = 2 【range生成的第二个数】
if i == 3: 条件不成立，continue语句不执行，循环继续
continue
print(i, end="|") ---> 结果：输出1|2|
第三次循环：
i = 3 【range生成的第三个数】
if i == 3: 条件成立，进入下面的continue语句，会跳过本次循环，但是下面的循环仍会继续
continue
print(i, end="|") ---> 结果：输出1|2|
第四次循环：
i = 4 【range生成的第四个数】
if i == 3: 条件不成立，continue语句不执行，循环继续
continue
print(i, end="|") ---> 结果：输出1|2|4|
以下循环依次类推：......
最终结果：结果：1|2|4|5|6|7|8|9|10|
------------------------------------
13.枚举算法
- 枚举的定义：根据所需解决问题的条件，把该问题所有可能的解，一一列举出来，并逐个检验出问题真正解的方法。枚举法也称穷举法。
（1）判断水仙花数
水仙花数：指一个 n 位数（n≥3），它的每个位上的数字的 n 次幂之和等于它本身。例如，153是一个水仙花数，因为1^3 + 5^3 + 3^3 = 153。
题目：找出100~999整数中的所有水仙花数.
- 方法一：使用while循环
num = 100
while num<1000:
a = int(num/100)
b = int(num%100/10)
c = int(num%10)
if a**3+b**3+c**3==num:
print(num,'是一个水仙花数')
num+=1
#提示：“/”表示除法，“%”表示取余，“**”表示幂次方
- 方法二：使用for循环
for x in range(100,1000):
a = int(x/100) #百位数
b = int(x%100/10) #十位数
c = int(x%10) #个位数
if a**3+b**3+c**3==x:
print(x,'是一个水仙花数')
x+=1
结果：
（2）鸡兔同笼
有一个笼子，里面有鸡和兔子。我们知道总共有7个头和18只脚，我们要找出有多少只鸡和多少只兔子。
假设笼子里有 x 只鸡和 y 只兔子。根据题目，我们可以建立以下方程：
- 头的总数是 x + y = 7（鸡和兔子的头数加起来）。
- 脚的总数是 2x + 4y = 18（鸡有2只脚，兔子有4只脚，总脚数就是2倍的鸡脚数加上4倍的兔脚数）。
现在我们要来解这个方程组，找出 x 和 y 的值。计算结果为： {x: 5, y: 2}。所以，笼子里有 5 只鸡和 2 只兔子。
以上我们用的是数学中列举方程的形式求解，我们也可以利用枚举法，通过python代码帮我们计算最终的结果。
- 枚举的思路如图所示：一一列举，最终得到总的脚数量为18的组合，答案即为5 只鸡和 2 只兔子。
# 使用while循环求解
head = 7 #鸡和兔总的个数
foot = 18 #鸡和兔总的脚数量
checkin = 0
rabbit = 0
while True:
if 2*checkin+4*rabbit == 18:
break
checkin += 1
rabbit = head-checkin
print(checkin,rabbit) #5 2
-----------------------------------
# 也可使用for循环求解
for i in range(1,head):
if 2*checkin+4*rabbit == 18:
break
checkin+=1
rabbit = head-checkin
print(checkin,rabbit) #5 2
（3）因式分解
题目：有两个两位数，他们的乘积等于1691，求这两个数分别是多少？
for i in range(10,100):
for j in range(10,100):
if i*j == 1691:
print(i,j)
break
思考：以上结果为何会输出两遍？代码能否进行优化呢？
代码优化：
for i in range(10,100):
for j in range(i,100):
if i*j == 1691:
print(i,j)
break
