运算符

1.赋值运算符

# 最基本的赋值运算符是等号 =
# 运算符    说 明      用法举例       等价形式
# =    最基本的赋值运算    x = y        x = y
# +=    加赋值           x += y       x = x + y
# -=    减赋值            x -= y       x = x - y
# *=    乘赋值           x *= y       x = x * y
# /=    除赋值           x /= y       x = x / y
# %=    取余数赋值     x %= y       x = x % y
# **=    幂赋值           x **= y       x = x ** y
# //=    取整数赋值       x //= y       x = x // y
# &=    按位与赋值       x &= y       x = x & y
# |=    按位或赋值       x |= y       x = x | y
# ^=    按位异或赋值   x ^= y       x = x ^ y
# <<=    左移赋值      x <<= y    x = x << y，这里的 y 指的是左移的位数
# >>=    右移赋值      x >>= y    x = x >> y，这里的 y 指的是右移的位数

n1 = 100
f1 = 25.5
a = b = c = 100
n1 -= 80  #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)

2.逻辑运算符

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

# 例如 p 为真命题，q 为假命题，那么“p且q”为假，“p或q”为真，“非q”为真
age = int(input("请输入年龄："))
height = int(input("请输入身高："))
if age>=18 and age<=30 and height >=170 and height <= 185 :
    print("恭喜，你符合报考飞行员的条件")
else:
    print("抱歉，你不符合报考飞行员的条件")

#在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。
#另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
url = "http://c.biancheng.net/cplus/"
print("----False and xxx-----")
print( False and print(url) )
print("----True and xxx-----")
print( True and print(url) )
print("----False or xxx-----")
print( False or print(url) )
print("----True or xxx-----")
print( True or print(url) )

3.算术运算符

# 运算符    说明        实例          结果
#  +        加        12.45 + 15      27.45
#  -        减        4.56 - 0.26        4.3
#  *        乘        5 * 3.6            18.0
#  /       除法      7 / 2            3.5
# //       整除        7 // 2            3
#  %      取余       7 % 2            1
# **    幂运算/次方运算，即返回 x 的 y 次方    2 ** 4    16

# + 加法运算符  当+用于字符串时，它还有拼接字符串（将两个字符串连接为一个）的作用
m = 10
n = 97
sum1 = m + n
x = 7.2
y = 15.3
sum2 = x + y
print("sum1=%d, sum2=%.2f" % (sum1, sum2) )

# - 减法运算符   可以用作求负运算（正数变负数，负数变正数）
n = 45
m = -n
x = -83.5
y = -x
print(m, ",", y)

# *乘法运算符
n = 4 * 25
f = 34.5 * 2
print(n, ",", f)

# *除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来
str1 = "hello "
print(str1 * 4)

# / 和 // 除法运算符
#整数不能除尽
print("23/5 =", 23/5)
print("23//5 =", 23//5)
print("23.0//5 =", 23.0//5)
print("-------------------")
#整数能除尽
print("25/5 =", 25/5)  # /的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------")
#小数除法
print("12.4/3.5 =", 12.4/3.5)
print("12.4//3.5 =", 12.4//3.5)# 当有小数参与运算时，//结果才是小数，否则就是整数

# % 求余运算符
print("-----整数求余-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)
#只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
# %两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。

# ** 次方（乘方）运算符
print('----次方运算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))

4.位运算符

#位运算符  说明       使用形式         举 例
# &          按位与    a & b        4 & 5
# |          按位或    a | b        4 | 5
# ^          按位异或    a ^ b        4 ^ 5
# ~          按位取反    ~a          ~4
# <<      按位左移    a << b        4 << 2，表示整数 4 按位左移 2 位
# >>      按位右移    a >> b        4 >> 2，表示整数 4 按位右移 2 位

#& 按位与运算符  只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0
# 第一个Bit位    第二个Bit位    结果
# 0                  0           0
# 0                  1           0
# 1                  0        0
# 1                  1           1

# &运算符操作的是数据在内存中存储的原始二进制位，而不是数据本身的二进制形式；其他位运算符也一样

# | 按位或运算符  两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0
# 第一个Bit位    第二个Bit位    结果
#  0            0           0
#  0            1           1
#  1            0           1
#  1            1           1

# ^按位异或运算符  参与运算的两个二进制位不同时，结果为 1，相同时结果为 0
# 第一个Bit位    第二个Bit位    结果
#   0            0           0
#   0            1           1
#   1            0           1
#   1            1           0

# ~按位取反运算符  右结合性，作用是对参与运算的二进制位取反

# <<左移运算符  用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0
print("%X" % (9<<3) )
print("%X" % ((-9)<<3) )

# >>右移运算符 用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1
print("%X" % (9>>3) )
print("%X" % ((-9)>>3) )
#例如，9>>3可以转换为如下的运算：
#>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
#-----------------------------------------------------------------------------------
#   0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001  （1 在内存中的存储）
#所以9>>3的结果为 1。

#又如，(-9)>>3可以转换为如下的运算：
#>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在内存中的存储）
#-----------------------------------------------------------------------------------
#   1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110  （-2 在内存中的存储）
#所以(-9)>>3的结果为 -2

#如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）