关于python:Python学习笔记Day3-Python运算符

1. Python 类型转换

2. Python 算术运算符

• 2.1 加法 (+) 运算符

    m = 10
    n = 97
    sum1 = m + n
    x = 7.2
    y = 15.3
    sum2 = x + y
    print("sum1=%d, sum2=%.2f" % (sum1, sum2) )  

运行后果：sum1=107, sum2=22.50

拼接字符串

当 + 用于数字时示意加法，然而当 + 用于字符串时，它还有拼接字符串（将两个字符串连贯为一个）的作用：

name = "我的集体博客"  
url = "www.linuxleesinloveyy.cn"  
age = `  
info = name + "的网址是" + url + "，它曾经" + str(age) + "岁了"  
print(info)  

运行后果：我的集体博客的网址是 www.linuxleesinloveyy.cn，它曾经 1 岁了

• 2.2 减法 (-) 运算符

    n = 45
    m = -n
    x = -83.5
    y = -x
    print(m, ",", y)  

运行后果：-45 , 83.5

求负

-除了能够用作减法运算之外，还能够用作求负运算（负数变正数，正数变负数）:

n = 45
n_neg = -n
f = -83.5
f_neg = -f
print(n_neg, ",", f_neg)  

运行后果：-45 , 83.5

• 乘法 (*) 运算符

    n = 4 * 25
    f = 34.5 * 2
    print(n, ",", f)

运行后果：100 , 69.0

反复字符串

*除了能够用作乘法运算，还能够用来反复字符串，也行将 n 个同样的字符串连接起来：

str1 = "hello"
print(str1 * 4)  

运行后果：hello hello hello hello

• 2.3 / 和 // 除法运算符

Python 反对 / 和 // 两个除法运算符，但它们之间是有区别的：

• /示意一般除法，应用它计算出来的后果和数学中的计算结果雷同。
• //示意整除，只保留后果的整数局部，舍弃小数局部；留神是间接丢掉小数局部，而不是四舍五入。

实例：

# 整数不能除尽
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)  

运行后果：

23/5 = 4.6
23//5 = 4
23.0//5 = 4.0
-------------------
25/5 = 5.0
25//5 = 5
25.0//5 = 5.0
-------------------
12.4/3.5 = 3.542857142857143
12.4//3.5 = 3.0  

从运行后果能够发现：

1. /的计算结果总是小数，不论是否能除尽，也不论参加运算的是整数还是小数。
2. 当有小数参加运算时，//后果才是小数，否则就是整数。

• 2.4 求余 (%) 运算符

Python % 运算符用来求得两个数相除的余数，包含整数和小数。Python 应用第一个数字除以第二个数字，失去一个整数的商，剩下的值就是余数。对于小数，求余的后果个别也是小数。

留神：求余运算的实质是除法运算，所以第二个数字也不能是 0，否则会导致 ZeroDivisionError 谬误

Python % 应用示例：

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)  

运行后果：

----- 整数求余 -----
15%6 = 3
-15%6 = 3
15%-6 = -3
-15%-6 = -3
----- 小数求余 -----
7.7%2.2 = 1.0999999999999996
-7.7%2.2 = 1.1000000000000005
7.7%-2.2 = -1.1000000000000005
-7.7%-2.2 = -1.0999999999999996
--- 整数和小数运算 ---
23.5%6 = 5.5
23%6.5 = 3.5
23.5%-6 = -0.5
-23%6.5 = 3.0
-23%-6.5 = -3.5  

从运行后果能够发现两点：

• 只有当第二个数字是正数时，求余的后果才是正数。换句话说，求余后果的正负和第一个数字没有关系，只由第二个数字决定
• %两边的数字都是整数时，求余的后果也是整数；然而只有有一个数字是小数，求余的后果就是小数。
• 次方（乘方）运算符

Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。

Python ** 运算符示例：

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

运行后果：

---- 次方运算 ----
3**4 = 81
2**5 = 32
---- 开方运算 ----
81**(1/4) = 3.0
32**(1/5) = 2.0  

3. Python 赋值运算符

Python 中最根本的赋值运算符是等号 =；联合其它运算符，= 还能扩大出更弱小的赋值运算符。

• 根本赋值运算符号

    #将字面量（间接量）赋值给变量
    n1 = 100
    f1 = 47.5
    s1 = "http://c.biancheng.net/python/"
    #将一个变量的值赋给另一个变量
    n2 = n1
    f2 = f1
    #将某些运算的值赋给变量
    sum1 = 25 + 46 
    sum2 = n1 % 6
    s2 = str(1234)  #将数字转换成字符串
    s3 = str(100) + "abc"  

• 赋值运算符扩大

= 还可与其余运算符（包含算术运算符、位运算符和逻辑运算符）相结合，扩大成为性能更加弱小的赋值运算符

运算符扩大实例：

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

运行后果：

n1=20
f1=255.00  

4. 位运算符

Python 位运算符只能用来操作整数类型，它依照整数在内存中的二进制模式进行计算

• 4.1 & 按位与运算符

按位与运算符 & 的运算规定是：只有参加 & 运算的两个位都为 1 时，后果才为 1，否则为 0。

例如，9&5 能够转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101（5 在内存中的存储）--------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001（1 在内存中的存储）

• 4.2 | 按位或运算符

按位或运算符 | 的运算规定是：两个二进制位有一个为 1 时，后果就为 1，两个都为 0 时后果才为 0。

例如，9 | 5 能够转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101（5 在内存中的存储）---------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101（13 在内存中的存储）

-9 | 5 能够转换成如下的运算：

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101（5 在内存中的存储）----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）

• 4.3 ^ 按位异或运算符

按位异或运算 ^ 的运算规定是：参加运算的两个二进制位不同时，后果为 1，雷同时后果为 0。

9 ^ 5 能够转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101（5 在内存中的存储）----------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100（12 在内存中的存储）

-9 ^ 5 能够转换成如下的运算：

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101（5 在内存中的存储）----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010（-14 在内存中的存储）

• 4.4 ~ 按位取反运算符

按位取反运算符~ 为单目运算符（只有一个操作数），右联合性，作用是对参加运算的二进制位取反。

~9 能够转换为如下的运算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110（-10 在内存中的存储）

~- 9 能够转换为如下的运算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）----------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000（8 在内存中的存储）

• 4.5 << 左移运算符

Python 左移运算符 << 用来把操作数的各个二进制位全副左移若干位，高位抛弃，低位补 0。

9<<3 能够转换为如下的运算：相当于乘以 2 **3

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）-----------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000（72 在内存中的存储）

(-9)<<3 能够转换为如下的运算：相当于除以 2 **3

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）------------------------------------------------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000（-72 在内存中的存储）

• 4.6 >> 右移运算符

Python 右移运算符 >> 用来把操作数的各个二进制位全副右移若干位，低位抛弃，高位补 0 或 1。
如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。

9>>3 能够转换为如下的运算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001（9 在内存中的存储）----------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001（1 在内存中的存储）

(-9)>>3 能够转换为如下的运算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111（-9 在内存中的存储）-----------------------------------------------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110（-2 在内存中的存储）

5. Python 比拟运算符

比拟运算符，也称关系运算符，用于对常量、变量或表达式的后果进行大小比拟。
如果这种比拟是成立的，则返回 True（真），反之则返回 False（假）。

Python 比拟运算符的应用举例：

print("89 是否大于 100：", 89 > 100)
print("24* 5 是否大于等于 76：", 24*5 >= 76)
print("86.5 是否等于 86.5：", 86.5 == 86.5)
print("34 是否等于 34.0：", 34 == 34.0)
print("False 是否小于 True：", False < True)
print("True 是否等于 True：", True < True)  

运行后果：

89 是否大于 100：False
24* 5 是否大于等于 76：True
86.5 是否等于 86.5：True
34 是否等于 34.0：True
False 是否小于 True：True
True 是否等于 True：False  

== 和 is 的区别: == 用来比拟两个变量的值是否相等，而 is 则用来比对两个变量援用的是否是同一个对象

import time  #引入 time 模块
t1 = time.gmtime() # gmtime()用来获取以后工夫
t2 =  time.gmtime()
print(t1 == t2) #输入 True
print(t1 is t2) #输入 False  

运行后果：

True
False  

剖析：

time 模块的 gmtime() 办法用来获取以后的零碎工夫，准确到秒级，因为程序运行十分快，所以 t1 和 t1 失去的工夫是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。尽管 t1 和 t2 的值相等，但它们是两个不同的对象（每次调用 gmtime() 都返回不同的对象），所以 t1 is t2 返回 False。这就如同两个双胞胎姐妹，尽管她们的外貌是一样的，但它们是两个人。

如何判断两个对象是否雷同呢？答案是判断两个对象的内存地址。如果内存地址雷同，阐明两个对象应用的是同一块内存，当然就是同一个对象了。

6. Python 逻辑运算符

逻辑运算符实例：

age = int(input("请输出年龄："))
height = int(input("请输出身高："))
if age>=18 and age<=30 and height >=170 and height <= 185 :
    print("祝贺，你合乎报考飞行员的条件")
else:
    print("道歉，你不合乎报考飞行员的条件")  

可能的运行后果：

请输出年龄：23↙
请输出身高：178↙
祝贺，你合乎报考飞行员的条件  

在 Python 中，and 和 or 不肯定会计算左边表达式的值，有时候只计算右边表达式的值就能失去最终后果。

另外，and 和 or 运算符会将其中一个表达式的值作为最终后果，而不是将 True 或者 False 作为最终后果。

对于 and 运算符：

• 如果右边表达式的值为假，那么就不必计算左边表达式的值了，因为不论左边表达式的值是什么，都不会影响最终后果，最终后果都是假，此时 and 会把右边表达式的值作为最终后果。
• 如果右边表达式的值为真，那么最终值是不能确定的，and 会持续计算左边表达式的值，并将左边表达式的值作为最终后果。

对于 or 运算符：

• 如果右边表达式的值为真，那么就不必计算左边表达式的值了，因为不论左边表达式的值是什么，都不会影响最终后果，最终后果都是真，此时 or 会把右边表达式的值作为最终后果.
• 如果右边表达式的值为假，那么最终值是不能确定的，or 会持续计算左边表达式的值，并将左边表达式的值作为最终后果。

应用代码验证下面的论断：

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

运行后果：

----False and xxx-----
False
----True and xxx-----
http://c.biancheng.net/cplus/
None
----False or xxx-----
http://c.biancheng.net/cplus/
None
----True or xxx-----
True  

7. Python 运算符优先级

理论编程中，倡议应用括号明确运算符执行程序，不要适度依赖运算符优先级，防止引起不必要的谬误。