python零基础入门笔记【源源老师】

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

扫描二维码关注公众号，回复： 17458111 查看本文章

（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
------------------------------------

for循环和while循环的比较：

• 需求：计算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
------------------------------------

补充： 【range函数】

#### 遍历数字
for i in range(4):
    print(i) #0 1 2 3
for i in range(0, 4):
    print(i) #0 1 2 3
for i in range(0, 4, 2):
    print(i) #0 2
for i in range(4, 0, -1):
    print(i) #4 3 2 1

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~2，内层循环i的取值范围：1~3

第一次外层循环：
	i = 1; 
		第一次进入内层循环：
			【内层循环第一次：】
			j = 1; //j的初始值为1
				print("Hello World!"); //此时输出一次 Hello World!
			【内层循环第二次：】
			j = 2; 
				print("Hello World!"); //此时输出一次 Hello World!
			【内层循环第三次：】
			j = 3;
				print("Hello World!"); //此时输出一次 Hello World!
第二次外层循环：
	i = 2; 
		第二次进入内层循环：
			【内层循环第一次：】
			j = 1; //j的初始值为1
				print("Hello World!"); //此时输出一次 Hello World!
			【内层循环第二次：】
			j = 2; 
				print("Hello World!"); //此时输出一次 Hello World!			
			【内层循环第三次：】
			j = 3; 
				print("Hello World!"); //此时输出一次 Hello World!

12. 退出循环

1. break

break语句的作用：退出整个循环 【指的是退出离他最近的循环】

（1）单个for循环

• 需求：输出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）for循环嵌套

# 外层循环 i 取值 1 ~ 4
for i in range(1, 5):
	print(f"执行第 {
      
      i} 次外层循环")

	# j 取值 1 ~ 3
	for j in range(1, 4):
		if j == 2:
			break
		print(f"执行第 {
      
      j} 次内层循环")

结果：

执行第 1 次外层循环
	执行第 1 次内层循环
执行第 2 次外层循环
	执行第 1 次内层循环
执行第 3 次外层循环
	执行第 1 次内层循环
执行第 4 次外层循环
	执行第 1 次内层循环

结论：

• 以上代码中，break是写在内层循环中的，当遇到内层循环的第二次循环 , 直接退出内层循环， 因此在内层循环中只能执行一次 ；
• 外层循环则会一直循环到对应的边界值，外层循环不受影响。

2. continue

continue语句的作用：退出当前循环【指的是退出离他最近的循环】

（1）单个for循环

沿用上面的例子，假如我们给出的序列为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|
------------------------------------

（2）for循环嵌套

# 外层循环 i 取值 1 ~ 3
for i in range(1, 4):
	print(f"执行第 {
      
      i} 次外层循环")
	# j 取值 1 ~ 3
	for j in range(1, 4):
		if j == 2:
			continue
		print(f"执行第 {
      
      j} 次内层循环")

结果：

执行第 1 次外层循环
	执行第 1 次内层循环
	执行第 3 次内层循环
执行第 2 次外层循环
	执行第 1 次内层循环
	执行第 3 次内层循环
执行第 3 次外层循环
	执行第 1 次内层循环
	执行第 3 次内层循环

结论：

• 以上代码中，continue是写在内层循环中的，当遇到内层循环的第二次循环 , 会退出这一次内层循环， 继续执行下一次内层循环；
• 外层循环则会一直循环到对应的边界值，外层循环不受影响。

13.枚举算法

• 枚举的定义：根据所需解决问题的条件，把该问题所有可能的解，一一列举出来，并逐个检验出问题真正解的方法。枚举法也称穷举法。

（1）判断水仙花数

水仙花数：指一个 n 位数（n≥3），它的每个位上的数字的 n 次幂之和等于它本身。例如，153是一个水仙花数，因为1^3 + 5^3 + 3^3 = 153。

题目：找出100~999整数中的所有水仙花数.

• 方法一：使用while循环

num = 100
while num < 1000:
    a = num // 100
    b = num % 100 // 10
    c = 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只脚，我们要找出有多少只鸡和多少只兔子。

• 解法一：假设法

先假设它们全是鸡，每少2只脚就说明有一只兔被看成了鸡；将少的脚数量除以2,就可以算出共有多少只兔，我们称这种解题方法为假设法。解题步骤：

1. 假设全部是鸡，此时总的脚数：7x2 = 14 只
2. 一共被看少的脚数量：18-14 = 4 只
3. 兔子的数量：4/2 = 2 只
4. 鸡的数量：7-2 = 5 只

• 解法二：一元一次方程

设笼子里有 x 只鸡，那么兔子有：7-x 只。根据题目，我们可以建立以下方程：

1. 脚的总数是 2x + 4*（7-x） = 18（鸡有2只脚，兔子有4只脚，总脚数就是2倍的鸡脚数加上4倍的兔脚数）。

2. 现在我们要来解这个方程组，找出 x 的值。计算结果为：x = 5。所以，笼子里有 5 只鸡和 2 只兔子。

• 解法三：一元二次方程

设笼子里有 x 只鸡和 y 只兔子。根据题目，我们可以建立以下方程：

1. 头的总数是 x + y = 7（鸡和兔子的头数加起来）。
2. 脚的总数是 2x + 4y = 18（鸡有2只脚，兔子有4只脚，总脚数就是2倍的鸡脚数加上4倍的兔脚数）。
3. 现在我们要来解这个方程组，找出 x 和 y 的值。计算结果为： {x: 5, y: 2}。所以，笼子里有 5 只鸡和 2 只兔子。

• 解法四：枚举算法

• 以上我们用的是数学中列举方程的形式求解，我们也可以利用枚举法，通过python代码帮我们计算最终的结果。

• 枚举的思路如图所示：一一列举，最终得到总的脚数量为18的组合，答案即为5 只鸡和 2 只兔子。

# 使用while循环求解
head = 7 #鸡和兔总的个数
foot = 18 #鸡和兔总的脚数量
chicken = 0
rabbit = 0
while True:
    if 2*chicken + 4*rabbit == 18:
        break   
    chicken += 1
    rabbit = head-chicken
print(chicken,rabbit) #5 2

-----------------------------------
# 也可使用for循环求解
chicken = 1
rabbit = 6
for i in range(1, 7):
    if 2*chicken + 4*rabbit == 18:
        print(chicken, rabbit)
        break
    chicken += 1
    rabbit = 7- chicken

（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

（4）找质数

题目：找出1到20内的所有质数

提示：质数是指大于1的自然数，除了1和它本身以外没有任何正因数（除了1和它本身外不能被其他整数整除）。换句话说，质数是只有两个正因数的数，这两个因数就是1和它自己。

for num in range(2, 21):  # 起始值为2，对于范围在2到20的每一个数字
    for i in range(2, num):  # 对于从2到num-1的每一个数字
        if num % i == 0:  # 如果num能被i整除
            break  # 退出内层循环，说明num不是质数
    else:
        print(num)  # 如果内层循环完整执行（即未中断），则说明num是质数，打印输出
# 结果：2、3、5、7、11、13、17、19

14. 列表(list)

1. 创建列表

• 列表(list)是一种有序的容器，放入list中的元素，将会按照一定顺序排列。创建list的方式非常简单，使用中括号[]把需要放在容器里面的元素括起来，就定义了一个列表。

L = ['Alice', 66, 'Bob', True, 'False', 100]

2. 访问元素

• 列表中的元素既可以使用正向索引访问，也可以使用反向索引访问，正向索引从0开始，反向索引从-1开始。

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 访问元素
print(L[0]) #Alice
# print(L[6]) #错误：越界了
print(L[-1]) #100

3. 添加元素

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 添加元素
L.append('LiMing') #末尾追加
print(L) #['Alice', 66, 'Bob', True, 'False', 100, 'LiMing']
L.insert(3,99)
print(L) #['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing']
L.extend(['False',33])
print(L) #['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing', 'False', 33]

4. 删除元素

L = ['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing', 'False', 33]

#### 删除元素
L.remove(99)
print(L) #['Alice', 66, 'Bob', True, 'False', 100, 'LiMing', 'False', 33]
del L[2]
print(L) #['Alice', 66, True, 'False', 100, 'LiMing', 'False', 33]
L.pop(2)
print(L) #['Alice', 66, 'False', 100, 'LiMing', 'False', 33]
L.clear()
print(L) #[]

5. 列表切片

• list[start : end] 访问的是从索引start开始，一直到索引end的元素，但不包括索引end所在的元素
• list[start: ] 访问的是从索引start开始，一直到列表结束的元素
• list[: end] 访问的是从索引0开始，一直到索引end的元素，但不包括索引end所在的元素

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 列表切片
print(L[1:5]) #[66, 'Bob', True, 'False']
print(L[0:5:2]) #['Alice', 'Bob', 'False']
print(L[-5:-1:3]) #[66, 'False']

6. 元素个数

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 元素个数
print(len(L)) #6
print(L.count(100)) #1

7. 列表运算符

#### 列表运算符
L1 = ['Alice', 66, 'Bob']
L2 = [True, 'False', 100]
print(L1+L2) #['Alice', 66, 'Bob', True, 'False', 100]
print(L1*2) #['Alice', 66, 'Bob', 'Alice', 66, 'Bob']
print(100 in L2) #True
print(True not in L2) #False

8. 拷贝列表

#### 拷贝列表

#### 赋值操作
L1 = ['Alice', 66, 'Bob']
L2 = L1
L1.append('AA')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob', 'AA']
L2.append('BB')
print(L1) #['Alice', 66, 'Bob', 'AA', 'BB']
print(L2) #['Alice', 66, 'Bob', 'AA', 'BB']
##原因:L1和L2的地址一样
print(id(L1)) #1986677652992 [电脑随机生成的]
print(id(L2)) #1986677652992

#### copy操作
L1 = ['Alice', 66, 'Bob']
L2 = L1.copy()
L1.append('AA')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob']
L2.append('BB')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob', 'BB']

9. 列表排序

#### 列表排序

L1 = ['Alice', 66, 'Bob']
L1.reverse()
print(L1) #['Bob', 66, 'Alice']
# 切片反转
print(L1[::-1]) #['Alice', 66, 'Bob']

# 升序
L2 = [1, 66, 33, 16]
L2.sort()
print(L2) #[1, 16, 33, 66]

10. 列表转换

#### 列表转换【list函数】
a = 'python'
print(list(a)) #['p', 'y', 't', 'h', 'o', 'n']
b = 123
res = str(b)
print(res) #字符串123
L = list(res) 
print(L) #['1', '2', '3']

11. 遍历列表

• 列表的遍历，我们可以使用for in 循环，或者搭配range函数一起都可以。

#### 【range函数】

#### 遍历数字
for i in range(4):
    print(i) #0 1 2 3
for i in range(0, 4):
    print(i) #0 1 2 3
for i in range(0, 4, 2):
    print(i) #0 2
   
#### for in遍历列表
L = ['10', '20', '30']
for i in L:
    print(i) # #10 20 30
    
#### range遍历列表    
L = ['10', '20', '30']
for i in range(len(L)):
    print(L[i]) #10 20 30

12. 其他函数

### 其他函数
list = [1,2,3,4]
print(min(list)) #1
print(max(list)) #4
print(sum(list)) #10

list = ['aaa','bbb','ccc']
print(min(list)) #aaa
print(max(list)) #ccc
print(sum(list)) #报错

15. 元组(tuple)

1. 创建元组

# 创建一个空元组
T = ()

# 创建单个元素的元组
T = (1,) #【注意】：如果不加逗号，会变为整数类型

# 创建多个元素的元组
T = (1, 2, 2, 3, 3)

T = 1, 2, 2, 3, 3 #不带括号也可以创建元组，但尽量不要这么写吧
print(type(T)) #<class 'tuple'>

2. 访问元素

• 和列表一样，元组中的元素既可以使用正向索引访问，也可以使用反向索引访问，正向索引从0开始，反向索引从-1开始。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
print(T[-2]) # ==> David

# 切片访问(和列表一样)
print(T[1:3]) # ==> ('Bob', 'Candy')

3. 元组的特性(不可删除)

• 元组和列表不一样的是，元组中的每一个元素都不可被改变，无法修改删除或者添加，而列表是可以的。所以我们也可以称，元组是只读的列表。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

# 不允许替换元素
T[1] = 'Boby' # 报错

# 不允许删除元素
del T[1] # 报错

# 不允许添加元素
T[5] = 'Mike' # 报错

【扩展】：以上元组的特性，针对的是元组中仅包含基础数据类型（数字类型、布尔类型、字符串类型）的元素，对于组合数据类型的元素，我们是可以改变这个组合数据类型中的某个值的。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

4. 元组运算符

• 元组的运算符和列表都是一样的

#### 列表运算符
T1 = ('Alice', 66, 'Bob')
T2 = (True, 'False', 100)
print(T1+T2) #('Alice', 66, 'Bob', True, 'False', 100)
print(T1*2) #('Alice', 66, 'Bob', 'Alice', 66, 'Bob')
print(100 in T2) #True
print((100) in T2) #True 
print(True not in T2) #False

5. 元组和列表相互转换

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
T = tuple(L)
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L2 = list(T)
print(L2) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

6. 遍历元祖

• 元组的遍历和列表一致；

#### for in遍历元组
T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
for i in T:
    print(i, end="|") # Alice|Bob|Candy|David|Ellena|
    
#### range遍历元组    
T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
for i in range(len(T)):
    print(T[i], end="|") # Alice|Bob|Candy|David|Ellena|

7. 其他函数

count	用来统计元组中某个元素出现的次数
index	返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置，如果没有该元素，会直接报错
min	查找最小值
max	查找最大值
sum	求和

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1
print(T.count(10)) # ==> 0

print(T.index(9)) # ==> 10
print(T.index(5)) # ==> 8
print(T.index(1)) # ==> 0 # 多次出现，返回第一次出现的位置
# print(T.index(100)) # ==> 报错

print(min(T)) # ==> 1
print(max(T)) # ==> 9
print(sum(T)) # ==> 37

16. 字典(dict)

1. 创建元素

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

# 字典创建的语法，通过 花括号 以及 key:value 的方式构成：
字典变量 = {
    
    key:value,key:value...}

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49,
    'Gaven': 86
}
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45
print(d['Dodo']) # 报错，不存在

# get方法读取【推荐】
# print(d.get('Dodo')) # ==> None 【dict本身提供get方法，把key当作参数传递给get方法，
# 就可以获取对应的value，当key不存在时，也不会报错，而是返回None】

2. 访问元素

方法名	说明
.get(key)	返回key对应的值，当key不存在时，返回None
dict[key]	返回key对应的值，当key不存在时，会报错

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49,
    'Gaven': 86
}

# get方法读取【推荐】
print(d['Bob']) # ==> 60
print(d.get('Dodo')) # ==> None

# 直接通过索引key读取
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45
print(d['Dodo']) # 报错，不存在

3. 增加元素

增加字典元素只需要添加一个key，再写上对应的value值就可以；如果新增的key重复，value值会被替换。

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}

d['Dodo'] = 88
d['Alice'] = 100 # 因为Alice存在，所以它的值会被替换成100
print(d) # {'Alice': 100, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Dodo': 88}

4. 删除元素

方法名	说明
.pop(key)	指定需要删除的元素的key，当key不存在时，会引起错误
.clear()	清除所有元素

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
#使用pop删除字典元素
d.pop('Alice')
print(d) #{'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

#使用clear清除所有元素
d.clear()
print(d) #{}

5. 字典的特性

字典的一个重要特性：key不可变。key可以是数字、字符串、元组，但不能是列表，因为列表是可变的。

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
key = (1, 2, 3) # 以tuple作为key
d[key] = True
print(d) # {'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, (1, 2, 3): True}
key2 = [1, 2, 3]
d[key2] = True # 报错，列表不能作为key

6. 遍历字典

• 遍历dict有两种方法， 第一种是遍历dict的所有key，并通过key获得对应的value。

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for key in d: 
    value = d[key]
    print(key, value)
    
#以上输出的结果：   
'''
Alice 45
Bob 60
Candy 75
David 86
Ellena 49
'''

• 第二种方法是通过dict提供的items()方法

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for key, value in d.items():
    print(key, value)
    
#以上输出的结果：   
'''
Alice 45
Bob 60
Candy 75
David 86
Ellena 49
'''

【注意】：如果只想遍历字典中的key，可以直接这么做：

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for x in d:
    print(x,end=' ') #Alice Bob Candy David Ellena 

【注意】：如果只想遍历字典中的value，可以直接这么做：

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for x in d.values():
    print(x,end=' ') #45 60 75 86 49 

7. 其他函数

方法名	说明
len(dict)	计算字典元素的个数，即key的总数
str(dict)	输出字典的字符串表示
type(dict)	输入字典，会返回字典类型

d = {
    
    
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
print(len(d)) #5
print(str(d)) #转为字符串类型：{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}
print(type(d)) #<class 'dict'>
{
    
    'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

17. 集合(set)

1. 创建集合

集合的创建，大体上分为两种：

• 使用{}直接创建，将元素放在{}中，注意集合{}不能为空，否则会默认创建的是一个空字典；
• 使用set()函数来创建一个集合。

# 1.直接使用集合字面量  
my_set1 = {
    
    1, 2, 3, 4, 5, 1}
print(my_set1) #{1, 2, 3, 4, 5} #自动去掉重复元素,以下雷同
  
# 2.使用列表来初始化集合  
my_list = [1, 2, 3, 4, 5, 1]  
my_set2 = set(my_list)
print(my_set2) #{1, 2, 3, 4, 5}
  
# 4.使用元组来初始化集合  
my_tuple = (1, 2, 3, 4, 5, 1)  
my_set3 = set(my_tuple)
print(my_set3) #{1, 2, 3, 4, 5}
  
# 5.不必要的冗余写法，相当于集合中又套了一个{}  
my_set4 = set({
    
    1, 2, 3, 4, 5, 1})
print(my_set4) #{1, 2, 3, 4, 5}

2. 添加元素

方法名	返回值说明
.add()	往集合中逐个添加元素
.update()	往集合中批量添加元素

name_set = set(['Alice', 'Bob'])
name_set.add('Gina') #add：逐个添加
print(name_set) # ==> {'Bob', 'Alice', 'Gina'}

my_list = ['Hally', 'Isen']
name_set.update(my_list) #update：批量添加
print(name_set) # ==> {'Isen', 'Gina', 'Bob', 'Alice', 'Hally'}

3. 删除元素

方法名	返回值说明
.remove()	删除集合中的元素
.pop()	删除集合中的第一个元素
.clear()	清空集合中的元素

name_set = set(['Jenny', 'Ellena', 'Alice', 'Bob'])
name_set.remove('Jenny')
print(name_set) # {'Bob', 'Ellena', 'Alice'} 【注意】：删除Jenny这个元素后，集合中的元素是随机摆放的，所以后面使用pop删除首个元素，可能得到的结果是不一致的

name_set.pop()
print(name_set) # {'Ellena', 'Alice'}

name_set.clear()
print(name_set) #set()

4. 判断元素是否存在

由于set里面的元素是没有顺序的，因此我们不能像list那样通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中，这个时候我们可以使用in来判断某个元素是否在set中。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(1 in s) #True
print(6 in s) #False

5. 集合的特性

• set里面的元素不允许重复。【如果重复了，会自动进行去重处理】

• set里面的元素没有顺序。

18. 序列（总结篇）

19.函数

1. 定义

• 函数：是组织好的，可重复使用的，用来实现特定功能的代码段。例如：

res = len('I like python')
print(res) #13

• 为什么我们随时可以使用len函数？因为len函数是python的内置函数，已经提前写好了，可以重复被使用，len函数的作用就是用来统计长度的。我们使用过的：input()、print()、str()、int()等都是Python的内置函数。

函数主要有两大作用：

• 将功能封装在函数内，可供随时随地重复利用
• 提高代码的复用性，减少重复代码，提升效率

2. 语法

def 函数名(参数):
	函数体
	return 返回值

注意： ① 参数如不需要，可以省略 ② 返回值如不需要，可以省略 ③ 函数必须先定义后使用

举例：

def fn():
	print('我喜欢python')

#调用函数，也就是让fn函数执行
fn()

3. 参数

参数的作用是：在函数进行计算的时候，接受外部（调用时）提供的数据

有如下代码，完成了2个数字相加的功能：

def add():
    sum = 1+2
    print(sum)
    
#调用函数    
add()

这个函数的功能非常局限，只能计算1 + 2。有没有可能实现：每一次使用函数，用户给出任意两个数字，都能进行相加呢？可以的，使用函数的传入参数功能，即可实现。

def add(x, y):
    sum = x+y
    print(sum)
    
add(1,2) #每次调用函数时，可以传入想要的参数
add(3,4) #每次调用函数时，可以传入想要的参数

• 形参：函数定义中，提供的x和y，称之为 形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号进行分隔。
• 实参：函数调用中，提供的1和2，称之为 实际参数（实参），表示函数执行时真正使用的参数值。传入的时候，按照顺序传入数据，使用逗号分隔。

【注意】：在Python中，如果一个方法定义时声明了某个参数，那么在调用这个方法时就必须提供这个参数的值，否则程序会报错。

4. 返回值

• 返回值：就是程序中函数完成事情后，最后给调用者的结果

def add(x, y):
    sum = x+y
    return sum
    
res = add(1,2)
print(res) #3

以上add函数用来对两个数进行相加，最后，会将相加的结果sum返回给函数调用者res
所以，变量res接收到了函数的执行结果，也就是res = 3.

• 【扩展】：思考以下问题
  

5. 函数的嵌套

• 函数嵌套：指的是一个函数里面又调用了另外一个函数

def fn():
    print('I like python')
    
def add(x, y):
    sum = x+y
    print(sum)
    fn()
      
add(1,2)

6. 变量作用域

• 变量作用域指的是变量的作用范围（即变量在哪里可用，在哪里不可用）。变量作用域主要分为两类：局部变量和全局变量。

（1）局部变量

• 局部变量：定义在函数体内部的变量，即只在函数体内部生效

变量num是定义在testA函数内部的变量，在函数内部访问不会报错，但在函数外部访问会报错。

（2）全局变量

• 全局变量：在函数体内、函数体外都能访问的变量

思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？
答：将这个数据存储在一个全局变量里面

（3）小试牛刀

举例：

num = 10

def A():
    num = 20
    print(num) #20
def B():
    print(num) #10

A()
B()

解读代码：

• A函数中定义了一个局部变量num，输出print(num)，结果是20，它访问的是离自己最近的已经被定义过的变量。
• B函数中并没有定义局部变量num，当它输出print(num)，结果是10，它访问的是全局变量num，即10。

7. 递归函数

• 递归：即函数自己调用自己的特殊写法。

（1）计算n的阶乘

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
res = fact(5)
print(res) #120

我们可以拆解fact(5)计算的详细逻辑:

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

8. 递推算法

• 递推算法：通常是通过循环来实现，直接从边界出发，直到求出函数值。

（1）斐波那契数

• 斐波那契数 ：该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。例如：0 1 1 2 3 5 8…

n = input('please input number: ')
n = int(n)
def fn(n):
    if n==0:
        return 0;
    list = [0,1]
    for i in range(2,n+1):
        list.append(list[i-1]+list[i-2]);
    return list[-1]
print(fn(n))

9. 分治算法

• 分治算法：将一个问题分成多个和原问题相似的小问题，递归解决小问题，再将结果合并以解决原来的问题。常见的分治算法：快速排序、归并排序、二分搜索。

分治算法的基本步骤包括：

• 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题。
• 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题。
• 合并：将各个子问题的解合并为原问题的解。

10. 算法复杂度

• 时间复杂度：描述了一个算法执行所需的时间，随输入数据量的增长而增长的量级。通常用大O符号（O）来表示。时间复杂度越高，意味着算法运行所需的时间越长。因此，在选择算法时，我们希望选择时间复杂度较低的算法以提高效率。

• 空间复杂度：对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度越高，意味着算法运行所需的额外空间越大。因此，在选择算法时，我们也需要考虑其空间复杂度，以确保算法在运行时不会占用过多的空间资源。

11. python第三方库

Python使用import语句导入一个模块，导入官方模块，不需要考虑路径的问题，例如，导入系统自带的模块 math，直接导入即可。

import math

导入以后，你就可以认为math是一个指向已导入模块的变量，通过该变量，我们可以访问math模块中所定义的所有公开的函数、变量和类：

# 属性：圆周率
import math
print(math.pi) # 3.141592653589793

# 函数：次方
print(math.pow(2, 3)) # 8.0

如果希望导入模块的指定部分属性或函数，比如我们希望导入math模块的圆周率pi，那么可以使用from…import…语句。

# 属性：圆周率
from math import pi
print(pi) # 3.141592653589793

这个时候，由于pow()函数没有导入，所以是不能使用pow()函数的。如果希望导入模块里面的所有内容，那么使用from …import *语句。

from math import *
print(pi) # 3.141592653589793
print(pow(2, 3)) # 8.0