python入门基础-格式化输出（f-string、%s、format）、基础运算符（in、and、or、...）（超详细！！！）（4）

前言

本篇内容不多，但是非常详细，从格式化输出到基础运算符，细致的进行了分类，列举多个例子和说明，帮助大家更好的理解并掌握该部分知识点，希望大家多多关注

1、格式化输出

利用特殊语法，使一段字符串形成固定格式后的输出，其中有一些内容是可以变化的，一般用变量进行代替，除了变量部分的其他内容都是固定的，不会改变

简单说明：
从上面的话理解起来，可能会有些困难，这里我用简单的话给大家解释一下：
通常 字符串是不能与整数或其他类型得数据直接进行拼接的，在我前面这篇文章有说到；而如何解决这个问题呢？答案很明显，就是该小节的主角，说白了格式化输出就是让 一段字符串与变量拼接在一起然后输出，而变量可以为任意数据类型，这样就可以解决前面字符串不能与其他类型的数据拼接的问题了；这里我们也不用钻牛角尖，直接往下看就行。

格式化输出有多种方法，我们通常记住其中两种，就可以覆盖大部分场景了；如：

1.1 f-string（推荐使用，简单，常用）

格式：f'字符串{变量名}'

例子：

a = '阿豪'
b = '打篮球'
c = '帅'
print(f'{a}的爱好是{b},并且他长得{c}') # 变量名可以在字符串中的任意位置
1
2
3
4

输出结果：

阿豪的爱好是打篮球,并且他长得帅
1

1.2 占位符方式-%s（了解即可，不必死记）

格式：print("%s字符串"%变量) ；%s 是占位符，用来与后面的变量进行替换

1.2.1 单个占位符

b = '打篮球'
print("阿呆的爱好是%s"%b) # %b 中b是变量，%s为占位符
1
2

输出结果：

阿呆的爱好是打篮球
1

1.2.2 多个占位符

a = '阿豪'
b = '打篮球'
print("%s的爱好是%s"%(a,b)) # 当字符串中有多个占位符 %s 时，后面多个变量就需要用括号包裹，用逗号分隔
1
2
3

输出结果：

阿豪的爱好是打篮球
1

1.2.3 占位符定义变量并赋值

a = '阿豪'
b = '打篮球'
print("%(m1)s的爱好是%(m2)s"%{'m1':a,'m2':b}) # 这里字符串中的m1和m2都是变量，在后面我们通过{'变量':值}的方式给m1和m2赋值；这里值是变量 a和b
print("%(m1)s的爱好是%(m2)s"%{'m1':'哈哈哈','m2':'阿阿阿'}) # 这里直接给 m1和m2 赋值，没有使用变量
1
2
3
4

输出结果：

阿豪的爱好是打篮球
哈哈哈的爱好是阿阿阿
1
2

扩展：

当我们使用的变量数据类型为整型和浮点型时，其中占位符 %s 可以用 %d 或 %f代替，%d结果默认为整数，%f 结果默认为小数；如:

a = 100 # 整型
b = 19.50 # 浮点型
print('我给你%d,你找我%d'%(a,b)) # 这里都使用%d ，结果都为整数
print('我给你%d,你找我%f'%(a,b)) # 这里使用 变量b 使用%f，结果为小数
1
2
3
4

输出结果：

我给你100,你找我19
我给你100,你找我19.500000
1
2

1.3 format（拓展）

格式：“{}字符串”.format(值)，这里值可以为任意数据类型

1.3.1 直接赋值

print('我的名字是{},我的余额为{}'.format('阿豪',110)) # 直接赋值
a = '阿呆'
b = 1100
print('我的名字是{},我的余额为{}'.format(a,b)) # 也可以用变量来赋值
1
2
3
4

输出结果：

我的名字是阿豪,我的余额为110
我的名字是阿豪,我的余额为110
1
2

1.3.2 通过索引赋值

print('我的名字是{1},我的余额为{0}'.format('阿豪',120)) # 通过索引，更换位置；在 format后括号内的值都有一个位置，在前面字符串中的 {}内 ，可以通过索引变换位置赋值，1和0都是索引，0表示第一个值（阿豪），1表示第二个值（120）
1

输出结果：

我的名字是120,我的余额为阿豪
1

1.3.3 通过变量赋值

print('我的名字是{a},我的余额为{b}'.format(b=100,a='阿豪')) # 在前面字符串中 {} 内定义好变量，后面可以直接给变量赋值，且位置可随意改变
1

输出结果：

我的名字是阿豪,我的余额为100
1

2、基础运算符

2.1 数学运算符（加、减、乘、除、取模、取余、取幂）

x = 9
y = 2
print(x+y) # 相加
print(x-y) # 相减
print(x*y) # 相乘
print(x/y) # 相除
print(x//y) # 取模，相除后向下取整，这里9/2=4.5，向下取整后为 4
print(x%y) # 取余，相除后取余数，这里 9/2=4...1,取余数为 1
print(x**y) # 取幂，也就是x的y次方，这里为 9的2次方，等于81
1
2
3
4
5
6
7
8
9

输出结果：

11
7
18
4.5
4
1
81
1
2
3
4
5
6
7

小问题？
我们在使用数学运算时，若有负数存在，一定要将其加上括号 ()，这一点很多人容易忽视，跟我们学的数学是一样的；如：

print(-1**2) # 这里没加括号，结果为 -1
print((-1)**2)
1
2

输出结果：

-1
1
1
2

2.2 比较运算符（> , < , <= , >= , != , ==）

比较运算符，通常用作数字类型数据的判断，判断结果为bool（布尔值）；如

x = 9
y = 2
print(x>y) # 大于
print(x<y) # 小于
print(x==y) # 等于，注意有两个等号，一个等号是赋值符号，用于变量赋值的
print(x>=y) # 大于等于
print(x<=y) # 小于等于
print(x!=y) # 不等于
print(x is y) # 判断左右两边是否为同一个，False
print(x is not y) # 取反，判断左右两边是否不是同一个，True
1
2
3
4
5
6
7
8
9
10

输出结果：

True
False
False
True
False
True
False
True
1
2
3
4
5
6
7
8

注意：

1. python中一个等号 = 是赋值符号，用来创建变量的；如：变量名=值，而两个等号 == 才是等于号，用于比较数据，判断数值的
2. python中的比较运算符，不是只能用于数字类型数据的判断，不同数据类型的数据也可以进行判断；如：

print('1' == 1) 
print('我' >= '你')
print('阿豪' == 1)
# 这里只举了个别例子，当然有些比较符无法进行不同数据间的判断
#大家可以自己尝试，我们常用的还是数字类型间的判断，大家了解即可
1
2
3
4
5

输出结果：

False
True
False
1
2
3

3. 在上面我们学习了 is 比较符，那么这个符号是基于什么标准来判断两边的数据呢？难道只是单纯的看双方有什么不同吗？其实， is 是通过比较两边数据的内存地址（id）是否相同来判断的；如：
   

说明：
这里，可以看到当 a和b 都等于 10时，他们的 内存地址(id)相同，a is b 结果为 True；当 x和y 都等于300时，他们内存地址（id）不同，结果为 False。
这里可能会有人疑惑，为什么都等于10时，内存地址相同，但等于300时，内存地址就不同了，这是因为python解释器在启动时，会默认开辟一个小整数池，范围在 [-5,256]，若变量赋值为这个范围类相同的数时，内存地址相同；具体解释可以点击这里看我前面写的文章；在最后的扩展内容有介绍
还有一点，大家在测验这个结论时，最好使用IDLE，因为pycharm中开辟的小整数池非常大，需要很大的数值才能测验出效果

2.3 赋值运算符（=）

赋值运算符 = 除了用来赋值变量外，通常还可以搭配算术运算符，简写算数式子；如：

x = 9
x+=1 # 相当于 x=x+1
print(x)

x = 9
x-=1 # 相当于 x=x-1
print(x)

x = 9
x *=1 # 相当于 x=x*1
print(x) 

x = 9
x /=1 
print(x) # 相当于 x=x/1 ，用除法得到的结果都为浮点数

# 除了上面的几种方式，还有 取模（//）、取余（%）、取幂（**），都可以与等号（=）结合使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

10
8
9
9.0
1
2
3
4

2.4 扩展：赋值方式

python语言的代码非常简洁、方便，这是很多人喜爱它的原因，这得益于它独特的语法，下面我们就介绍几种使代码更加简洁的几种赋值方法

2.4.1. 链式赋值

同时给多个变量绑定同一个值

a = 520
b = 520
c = 520
print(a,b,c) # 分别给每个变量赋值
a = b = c =520 # 同时给多个变量赋值，推荐使用，使代码更简洁
print(a,b,c)
1
2
3
4
5
6

2.4.2 交叉赋值

给多个变量同时绑定不同的值

a,b,c='点赞','关注','收藏' # 给多个变量赋值时，左右两边数量要相同，从左到右依次赋值，用逗号隔开
print(a,b,c)
1
2

输出结果：

点赞 关注 收藏
1

小知识？

在python中交叉赋值通常不会直接用来给多个变量赋值，而是处理其它问题；如：

在许多编程语言中，当拥有多个变量时，若想交换这几个变量的值，通常会定义第三个变量作为中间人，进行交换，但这种方法很麻烦，而在python中就可以使用交叉赋值来解决问题；如：

笨方法：

a = '点赞'
b = '关注'
c = a # 先将a 的值赋值给 第三个变量 c
a = b # 将 b 的值赋值给 a
b = c # 将 c的值赋值给 b
print(a,b) # a和b的值互换
1
2
3
4
5
6

输出结果：

关注 点赞
1

从上面可以看出，a和b是通过第三个变量c才将值互换掉，这样非常麻烦，这里我们使用交叉赋值；如：

a = '点赞'
b = '关注'
a,b = b,a # 直接替换
print(a,b)

c = 1
d = 2
e = 3
a,b,c,d,e = e,b,c,a,d # 可以多个变量同时替换，两边的变量数量要相同
print(a,b,c,d,e)
b,c,d = a,a,a # 绑定同一个变量的值
print(b,c,d)
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

关注 点赞
3 点赞 1 关注 2
3 3 3
1
2
3

2.4.3 解压赋值

可以用来将字符串、列表、字典、元组、集合中的元素解压出来，依次赋值给变量；整型、浮点型、布尔型不可以解压，因为他们是一个整体，不可分割

例子：

list1 = ['点赞','关注','收藏'] # 列表
a = list1[0]
b = list1[1]
c = list1[2]
print(a,b,c) # 不使用解压赋值，来定义变量

a,b,c = list1 # 直接用解压赋值将列表中的元素依次赋值给每个变量
print(a,b,c)

b,c,d = '我爱你' # 将字符串中的每个字依次赋值给变量
print(b,c,d)

b,c,d = {'阿':1,'豪':2,'帅':3} # 字典这里是将 键 依次赋值给每个变量
print(b,c,d)
# 注意：
#赋值的变量个数要与解压的值数量相同，按顺序依次赋值
#元组和集合这里我就不展示了，大家可以自己去多尝试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

点赞 关注 收藏
点赞 关注 收藏
我 爱 你
阿 豪 帅
1
2
3
4

拓展：替代符（*_）

代替变量进行赋值

list1 = ['点赞','关注','收藏']

a,*_ = list1
print(a) # 赋值了第一个元素，剩余的被 *_ 替代掉了，相当于赋值给 *_ 了 
print(*_) # 赋值了剩下两个元素

b,*_ = '我爱你一万年'
print(b) # 赋值第一个字
*_,c = '我爱你一万年'
print(c) # 赋值最后一个字
a,*_,b = '我爱你一万年'
print(a,b)
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

点赞
关注 收藏
我
年
我 年
1
2
3
4
5

2.5 成员运算符（in和not in）

in 判断左边的数据是否在右边，
not in 取反，判断左边的数据是否不在右边
字符串、列表、字典、元组、集合都支持成员运算符，整型、浮点型、布尔型不支持
返回结果都为布尔值（bool），True或False

print('我' in '我爱你') # 判断左边的字符是否在右边的字符串内
print('我' in ['我','爱','你']) # 判断左边的值，是否为列表中的元素
print(['我'] in ['我','爱','你']) # 这里 ['我'] 是一个列表，很明显右边的列表中没有元素是它
print('我' not in '我爱你') # not in 取反
print('我' not in ['我','爱','你'])
print(['我'] not in ['我','爱','你'])
# 更多用法，希望大家可以自己去探索
1
2
3
4
5
6
7

输出结果：

True
True
False
False
False
True
1
2
3
4
5
6

2.6 逻辑运算符（and 、or、not）

and（与）：当 and 左右两边都是对的，结果才是对的，有一个不对，结果为错
or （或）：当 or 的左右两边有一个是对的，结果就是对的，当两个都是错的，结果才为错
not （非）：将对的变为错的，错的变为对的

print(5>2 and 6>5) # True，两边都对
print(10>100 and 5>2) # False，有一个错误
print(5>2 or 6>5) # True，有一个对的
print(10>100 or 5>2) # False，两边都错
print(not 1) # False，对的变错的
print(not 0) # True，错的变对的
1
2
3
4
5
6

输出结果：

True
False
True
False
False
True
1
2
3
4
5
6

小问题？
大家通常都会认为逻辑运算符的结果都为 布尔值；实则不然，逻辑运算符只是用来判断对错、真假的，它并不会生成结果，而是将判断后的结果输出；我们需要了解其本质；如下：

# 布尔类型中，除了 0，0.0，''，[]，{}，()，None为False，其余都为True
print(3 and 4) # 这里先判断 3 是对的，然后继续判断 4，也是对的，则结果为真，输出最后判断正确的值 4
print(3 and 0) # 这里先判断 3是对的，继续判断 0 为错的，结果为假，输出错误的值 0
print(0 or 3) # 先判断 0 为假，再判断3为真，结果为真，输出正确的值 3
1
2
3
4

输出结果：

4
0
3
1
2
3

说明：
从上面可以看出，通过逻辑运算符判断后，结果为真，就输出正确的值，结果为假，就输出错误的值；而前面 print(5>2 and 6>5) 为什么输出的是布尔值呢？那是因为其中使用了 比较判断符，程序先执行比较判断符得到结果为布尔值后，在进行逻辑运算符的判断，因此最后输出的结果为 布尔值

扩展：

and ： 满足左右两边都是对的才能判断结果为真，所以：

1. 若左边错了，右边的对错就不重要了，结果已经注定，程序不会在判断右边，直接输出结果
2. 若左边对了，右边的结果重要，程序会继续判断右边的对错，在输出结果

or：满足左右两边有一个是对的，结果就为真；所以：

1. 若左边错了，右边的结果重要，程序继续判断右边，然后输出结果
2. 若左边对了，右边的结果不重要，程序不会判断右边，直接输出结果