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

本文主要是介绍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

（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)  # 12number = 8 / 2 ** 2
print(number)  # 2.0number = 7 % 2 ** 2
print(number)  # 3number = 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 = 1i <= 3 条件成立print(i) ---> 结果：输出1i += 1，相当于 i = 2
第二次循环：i = 2 因为第一次循环结束后i已经变为2了i <= 3 条件成立print(i) ---> 结果：输出1  2i += 1，相当于 i = 3
第三次循环：i = 3 i <= 3 条件成立print(i) ---> 结果：输出1  2  3i += 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 = 1sum = 0i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1i += 1，相当于 i = 2
第二次循环：i = 2 sum = 0+1i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1+2i += 1，相当于 i = 3
第三次循环：i = 3 sum = 0+1+2i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1+2+3i += 1，相当于 i = 4 
第四次循环：i = 4 sum = 0+1+2+3i <= 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+1i = 2 【range生成的第二个数】sum += i，即sum = sum + i = 0+1+2
第三次循环：sum = 0+1+2i = 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的初始值为1i < 3  //条件成立，进入内层循环第一次进入内层循环：【内层循环第一次：】j = 1; //j的初始值为1j < 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的初始值为1j < 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:continueprint(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 只兔子。根据题目，我们可以建立以下方程：

1. 头的总数是 x + y = 7（鸡和兔子的头数加起来）。
2. 脚的总数是 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 += 1rabbit = head-checkin
print(checkin,rabbit) #5 2-----------------------------------
# 也可使用for循环求解
for i in range(1,head):if 2*checkin+4*rabbit == 18:break   checkin+=1rabbit = 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

这篇关于python零基础入门笔记【源源老师】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---