Python基础——1.3运算符-格式化-赋值

用户交互就是人往计算机中input/输入数据，计算机print/输出结果。程序中必须有相应的机制来控制计算机接收用户输入的内容，并且输出结果。交互的本质就是输入、输出。

一、基本运算符

1.算术运算符

假设有两个变量：a=10, b=20

运算符	描述	实例
+	加——>两个数相加	a + b 输出结果 30
-	减——>得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘——>两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除——>b 除以 a	b / a 输出结果 2
%	取模（取余数）——>返回除法的余数	b % a 输出结果 0
**	幂——>返回a的b次幂	a**b为10的20次方，输出结果100000000000000000000
//	取整数——>返回商的整数部分（向下取整）	9 // 2 ——>4
()	小括号	提高运算符优先级，比如(1+2)*3

2.赋值运算符

a = 20 b = 10 c = 200

运算符	描述	实例
=	简单的赋值运算符	把 = 号右边的结果 赋给 左边的变量 如：num = 1 + 2 * 3
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c * *= a 等效于 c = c ** a
//=	取整数赋值运算符	c //= a 等效于 c = c // a

3.比较运算符

a = 10 b = 20

注意：True和False 的首字母为大写

运算符	描述	实例
==	等于 – 比较对象是否相等	(a == b) 返回 False
!=	不等于–比较两个对象是否不相等	(a != b) 返回 True
>	大于–返回x是否大于y	(a > b) 返回 False
<	小于–返回x是否小于y	(a < b) 返回True
>=	大于或者等于–返回x是否大于等于y	(a >= b) 返回 False
<=	小于或者等于–返回x是否小于等于y	(a <= b) 返回 True

# 所有的比较运算符返回1表示真，返回0表示假，这分别与True和False等价

与赋值一样，Python也支持链式比较：可同时使用多个比较运算符，如0 < age < 100。

4.逻辑运算符

p为真命题，q为假命题，那么p且q为假，p或q为真，非q为真。and 、or、not全部都是小写字母。

逻辑运算符	含义	基本格式	说明
and	逻辑与运算，”且“	a and b	当a和b两个表达式都为真时结果才为真，否则为假
or	逻辑或运算，”或“	a or b	当 a 和 b两个表达式都为假时结果才是假，否则为真
not	逻辑非运算，”非“	not a	如果 a 为真，那么not a的结果为假；如果 a 为假，那么not a的结果为真，相当于对 a 取反

a = 14 > 6  # True
b = 45 > 90  # False
print(a and b)  # False
print(a or b)  # True
print(not a)  # False 相当于对a取反

逻辑运算符的本质

对于and运算符，两边的值都为真时结果才为真，其中有一个值为假，结果就是假
	- 如果左边表达式的值为假，不计算右边表达式的值，and会把左边表达式的值作为最终结果
	- 如果左边表达式的值为真，最终值不能确定，and会继续计算右边表达式的值并将其作为最终结果
对于or运算符，两边值都为假时结果才为假，只要有一个值为真，那么结果就是真
	- 如果左边表达式的值为真，最终结果都是真，此时or会把左边表达式的值作为最终结果
	- 如果左边表达式的值为假，最终值不能确定，or会继续计算右边表达式的值，并将其作为最终结果

5.成员运算符

用于判断对象是某个集合的元素之一，返回结果是bool类型

运算符	描述
in	指定序列中找到值返回True，否则返回False
not in	指定的序列中没有找到值返回True，否则返回False

a = 'dog'
b = 'rabbit'
animals = ["dog","elephant","snake"]
print(a in animals)  # True
print(b in animals)  # False
print(a not in animals)  # False
print(b not in animals)  # True

6.身份运算符

运算符	描述	实例
is	is 判断两个标识符是否引用自一个对象	a is b，类似id(a) == id(b)，如果引用的是同一个对象则返回True，否则返回False
is not	is not 判断两个标识符是否引用自不同的对象	a is not b，类似id(a) ! = id(b)，如果引用的不是同一个对象则返回结果True，否则返回False

注意is和==两者有根本上的区别

• is用于判断两个变量的引用是否为同一个对象，is比较的是本质（也就是内存地址）
• ==用于判断变量引用的对象的值是否相等，==比较的是表面（也就是数值）

a=1
b=1.0
print(a == b)
print(a is b)

True
False

同一对象认定方法：查看某个变量或对象的内存地址 id()，两个相同的内存地址的对象被认为是同一对象

a=1
b=1.0
print(id(a))
print(id(b))

1647214704
1647997751656

7.运算符的优先级

运算符	描述
**	指数（最高优先级）
~ + -	按位翻转，一元加号和减号（最后两个的方法名为 +@ 和 -@）
* / % //	乘，除，取模和取整数
+ -	加法减法
>> <<	右移，左移运算符
&	位 “AND”
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is，is not	身份运算符
in，not in	成员运算符
not or and	逻辑运算符

优先级高的运算符优先计算或处理，同级别按从左往右的顺序计算（赋值运算符除外，它从右往左）

• 算术运算符 优先级大于 比较运算符
• 比较运算符 优先级大于 逻辑运算符
• 逻辑运算符的内部有三个优先级：not>and>or

按照执行流程划分，Python 程序可分为 3 大结构，即顺序结构、选择(分支)结构和循环结构：

• 顺序结构是让程序从头到尾依次执行每一条 Python 代码，不重复执行任何代码，也不跳过任何代码
• 选择结构也称分支结构，有选择性的执行代码；可以跳过没用的代码，只执行有用的代码
• 循环结构就是让程序“杀个回马枪”，不断地重复执行同一段代码

一、输出print

print() 函数可同时输出多个变量，print函数具有打印功能，打印时去掉了引号且输出值没有类型。

print (value, ..., sep='', end='\n', file=sys.stdout, flush=False)

1.value

value可接受任意多个变量或值，打印时默认以空格隔开多个变量。

user_name ＝ 'Charlie'
user_age = 8
# 同时输出多个变量和字符串
print("读者名:", user_name, "年龄:", user_age)
# 读者名: Charlie 年龄: 8

2.sep

可通过 sep 参数进行设置以改变默认的分隔符。

# 同时输出多个变量和多个字符串，指定分隔符
user_name = "Charlie"
user_age = "8"
print("读者名:", user_name, "年龄:", user_age, sep='|')
# 读者名:|Charlie|年龄:|8

3.end=‘\n’

默认下print()输出完后换行，因为end参数默认值是"\n"。不换行则重设 end 参数即可

#设置end 参数，指定输出之后不再换行
print(40,'\t',end＝"")
print(50,'\t',end＝"")
print(60,'\t',end＝"")
# 40    50    60

4.file

file参数指定 print() 函数的输出目标，默认值为 sys.stdout，代表系统标准输出，既屏幕。可改变该参数让 print() 输出到特定文件中

f = open("demo.txt","w")#打开文件以便写入
print('沧海月明珠有泪',file=f)
print('蓝回日暖玉生烟',file=f)
f.close()
# open()函数用于打开demo.txt文件，接连2个print函数会将这2段字符串依次写入此文件，最后调close()函数关闭文件

5.flush=False

print() 函数的 flush 参数用于控制输出缓存，该参数一般保持为 False 即可，这样可以获得较好的性能

二、格式化format

编写新代码时，应选择使用字符串方法format。每个替换字段都用花括号括起，其中可能包含名称，还可能包含有关如何对相应的值进行转换和格式设置的信息。替换字段由如下部分组成，其中每个部分都是可选的。

• 字段名：索引或标识符，指出设置哪个值的格式并使用结果来替换该字段。除指定值外，还可指定值的特定部分，如列表的元素。
• 转换标志：跟在叹号后的单个字符。当前支持的字符包括r（表示repr）、s（表示str）和a（表示ascii）。如果指定转换标志将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。
• 格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

要在最终结果中包含花括号，可在格式字符串中使用两个花括号（即{{或}}）来指定。

print("{{ceci n'est pas une replacement field}}".format())
# {ceci n'est pas une replacement field}

1.替换字段名

在最简单的情况下，替换字段没有名称或将索引用作名称。

print("{}, {} and {}".format("first", "second", "third"))
# first, second and third
print("{0}, {1} and {2}".format("first", "second", "third"))
# first, second and third

# 索引无需像上面这样按顺序排列。
print("{3} {0} {2} {1} {3} {0}".format("be", "not", "or", "to"))
# to be or not to be

# 不能同时使用手工编号和自动编号，因为这样很快会变得混乱不堪
print("{foo} {1} {bar} {0}".format(1, 2, bar=4, foo=3) 
# 3 2 4 1

# 命名字段的工作原理与你预期的完全相同。
from math import pi

# 格式说明符.2f使用包含2位小数的浮点数格式。
print("{name} is approximately {value:.2f}.".format(value=pi, name="π"))
# π is approximately 3.14.

如果变量与替换字段同名，还可使用简写。在这种情况下，可使用f字符串——在字符串前面加上f。

from math import e

print(f"Euler's constant is roughly {e}.")
# Euler's constant is roughly 2.718281828459045.

# 创建最终的字符串时，将把替换字段e替换为变量e的值。这与下面这个更明确一些的表达式等价：
print("Euler's constant is roughly {e}.".format(e=e))
# Euler's constant is roughly 2.718281828459045.

2.基本转换

指定要在字段中包含的值后可添加设置其格式的指令。首先可提供一个转换标志。s、r和a指定分别使用str、repr和ascii进行转换。函数str通常创建外观普通的字符串版本（这里没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示。

print("{pi!s} {pi!r} {pi!a}".format(pi="π"))
# π 'π' '\u03c0'

指定要转换值的类型，可在格式说明（即冒号后面）使用字符f（表示定点数）

print("The number is {num}".format(num=42))
# The number is 42
print("The number is {num:f}".format(num=42))
# The number is 42.000000

# 你也可以将其作为二进制数进行处理。
print("The number is {num:b}".format(num=42))
# The number is 101010

类型	含义
b	将整数表示为二进制数
c	将整数解读为Unicode码点
d	将整数视为十进制数进行处理，这是整数默认使用的说明符
e	使用科学表示法来表示小数（用e来表示指数）
E	与e相同，但使用E来表示指数
f	将小数表示为定点数
F	与f相同，但对于特殊值（nan和inf），使用大写表示
g	自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数
G	与g相同，但使用大写来表示指数和特殊值
n	与g相同，但插入随区域而异的数字分隔符
o	将整数表示为八进制数
s	保持字符串的格式不变，这是默认用于字符串的说明符
x	将整数表示为十六进制数并使用小写字母
X	与x相同，但使用大写字母
%	将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

3.宽度

设置浮点数（或其他更具体的小数类型）的格式时默认在小数点后面显示6位小数，根据需要设置字段宽度，不进行任何形式填充。可根据需要在格式说明中指定宽度和精度。

宽度使用整数指定，数和字符串的对齐方式不同

print("{num:10}".format(num=3))
#          3
print("{name:10}".format(name="Bob"))
# Bob         

4.精度

精度也使用整数指定，需要在它前面加上一个表示小数点的句点

print("Pi day is {pi:.2f}".format(pi=3.1415926))
# Pi day is 3.14

# 可同时指定宽度和精度。
print("{pi:10.2f}".format(pi=3.1415926))
#       3.14

# 实际上，对于其他类型也可指定精度，但是这样做的情形不太常见。
print("{:.5}".format("Guido van Rossum"))
# Guido

5.千位分隔符

可使用逗号来指出你要添加千位分隔符。同时指定其他格式设置元素时，这个逗号应放在宽度和表示精度的句点之间。如果要使用随区域而异的千位分隔符，应使用类型说明符n

print('One googol is {:,}'.format(10 ** 100))
# One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000

6.符号

在一栏中同时包含字符串和数时要修改默认对齐方式。可在指定宽度和精度的数前面添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

print('{:010.2f}'.format(3.1415926))
# 0000003.14

7.对齐

指定左对齐、右对齐和居中可分别使用<、>和^。:左边的0表示正号

print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(3.1415926))
# 3.14      
#    3.14   
#       3.14

8.填充

使用填充字符来扩充对齐说明符，将使用指定的字符而不是默认的空格来填充

print("{:$^15}".format(" WIN BIG "))
# $$$ WIN BIG $$$

说明符=指定将填充字符放在符号和数字之间。:左边的1表示负号。

print('{0:10.2f}\n{1:10.2f}'.format(3.1415926, -3.1415926))
#       3.14
#      -3.14
print('{0:10.2f}\n{1:=10.2f}'.format(3.1415926, -3.1415926))
#       3.14
# -     3.14

如果要给正数加上符号，可使用说明符+（将其放在对齐说明符后面），而不是默认的-。如果将符号说明符指定为空格，会在正数前面加上空格而不是+

print('{0:-.2}\n{1:-.2}'.format(3.1415926, -3.1415926))  # 默认设置
# 3.1
# -3.1
print('{0:+.2}\n{1:+.2}'.format(3.1415926, -3.1415926))
# +3.1
# -3.1
print('{0: .2}\n{1: .2}'.format(3.1415926, -3.1415926))
#  3.1
# -3.1

9.井号

井号（#）可放在符号说明符和宽度之间（如果指定了这两种设置）。这个选项将触发另一种转换方式，转换细节随类型而异。如对二进制、八进制和十六进制转换，将加上一个前缀

print("{:b}".format(42)) 
# 101010

print("{:#b}".format(42)) 
# 0b101010

# 对于各种十进制数，它要求必须包含小数点（对于类型g，它保留小数点后面的零）。
print("{:g}".format(42)) 
# 42

print("{:#g}".format(42)) 
# 42.0000

字符串格式设置示例

# 根据指定的宽度打印格式良好的价格列表
width = int(input('Please enter width: '))
price_width = 10
item_width = width - price_width
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width)
fmt = '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width)
print('=' * width)
print(header_fmt.format('Item', 'Price'))
print('-' * width)
print(fmt.format('Apples', 0.4))
print(fmt.format('Pears', 0.5))
print(fmt.format('Cantaloupes', 1.92))
print(fmt.format('Dried Apricots (16 oz.)', 8))
print(fmt.format('Prunes (4 lbs.)', 12))
print('=' * width)
# Please enter width: 40
# ========================================
# Item                               Price
# ----------------------------------------
# Apples                              0.40
# Pears                               0.50
# Cantaloupes                         1.92
# Dried Apricots (16 oz.)             8.00
# Prunes (4 lbs.)                    12.00
# ========================================

三、赋值魔法

1.序列解包

序列解包（或可迭代对象解包）：将一个序列（或任何可迭代对象）解包，并将得到的值存储到一系列变量中。在使用返回元组（或其他序列或可迭代对象）的函数或方法时很有用。

# 可同时（并行）给多个变量赋值
x, y, z = 1, 2, 3
print(x, y, z)
# 1 2 3

# 还可交换多个变量的值
x, y = y, x
print(x, y, z)
# 2 1 3

values = 1, 2, 3 
print(values)
# (1, 2, 3)
x, y, z = values 
print(x)
# 1

使用方法popitem从字典中随机获取（或删除）一个键-值对以元组的方式返回，直接将返回的元组解包到两个变量中。这让函数能返回被打包成元组的多个值，通过一条赋值语句轻松访问这些值。要解包的序列包含的元素个数必须与等号左边列出的目标个数相同，否则Python将引发异常。

scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
key, value = scoundrel.popitem()
print(key)
# girlfriend
print(value)
# Marion

可使用星号运算符（*）来收集多余的值，这样无需确保值和变量的个数相同

a, b, *rest = [1, 2, 3, 4]
print(rest)
# [3, 4]

# 还可将带星号的变量放在其他位置。
name = "Albus Percival Wulfric Brian Dumbledore"
first, *middle, last = name.split()
print(middle)
# ['Percival', 'Wulfric', 'Brian']

# 赋值语句的右边可以是任何类型的序列，但带星号的变量最终包含的总是一个列表。在变量和值的个数相同时亦如此。
a, *b, c = "abc"
print(a, b, c)
# 'a', ['b'], 'c'
# 这种收集方式也可用于函数参数列表中

2.链式赋值

链式赋值是一种快捷方式，用于将多个变量关联到同一个值。只涉及一个值

x = y = somefunction() 

# 上述代码与下面的代码等价：
y = somefunction() 
x = y 

# 请注意，上面两条语句可能与下面的语句不等价：
x = somefunction() 
y = somefunction()

3.增强赋值

可以不编写代码x = x + 1，而将右边表达式中的运算符（这里是+）移到赋值运算符（=）的前面，从而写成x += 1。这称为增强赋值，适用于所有标准运算符，如*、/、%等

x = 2 
x += 1 
x *= 2 
print(x)
# 6

增强赋值也可用于其他数据类型（只要使用的双目运算符可用于这些数据类型）

fnord = 'foo' 
fnord += 'bar' 
fnord *= 2 
print(fnord)

通过使用增强赋值，可让代码更紧凑、更简洁，同时在很多情况下的可读性更强

小编文章免费分享，当然啦，如果能支持一下就再好不过啦，一点点就可以！一点点就能让小编更有创作动力