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。

第一个Bit位	第二个Bit位	结果
0	0	0
0	1	0
1	0	0
1	1	1

例如，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 运算符优先级

实际编程中，建议使用括号明确运算符执行顺序，不要过分依赖运算符优先级，避免引发没必要要的错误。