Python 入门（二）- 变量与运算符

发表于   |   分类于

运算符号

  • 算术运算符：+、-、*、/、//、%、**
  • 赋值运算符：=、+=、*=、/=、%=、**=、//=
  • 比较（关系）运算符：==、!=、>、<、>=、<=
  • 逻辑运算符：and、or、not
  • 成员运算符：in、not in
  • 身份运算符：is、is not
  • 位运算符：&、|、^、~、<<、>>

算术运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'Hello'+' world'
# Hello world

[1,2,3]*3
# [1,2,3,1,2,3,1,2,3]

3-1
# 2

3/2
# 1.5

3//2
# 1

5%2
# 1

2**5
# 32 平方

赋值运算符

先做运算再赋值。
注：python 中变量不需要定义，因此 c=1 表示赋值

1
2
3
4
5
6
7
8
9
10
11
c+=1
# 等价于： c = c+1
# 注：python 中不支持 c++/c-- 自增自减运算

b=5
a=3
b-=a 
# 2

b*=a
# 6

比较（关系）运算符

比较两组数据类型是否相等，结果为布尔值。
不只是数字才能做比较运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
b = 1
b = b+True
// 2 注：int(True) = 1

'a'>'b'
// False 比较的是ASCII码，ord('a') = 97，ord('b') = 98

'abc'>'abd'
// False 当字符串有多个字母时，解析规则为依次做比较

[1,2,3] < [2,3,4]
// True 解析规则为依次做比较

(1,2,3) < (2,3,4)
// True

逻辑运算符

逻辑运算符：and、or、not，主要操作对象为布尔类型，返回结果也为布尔类型

and 表示且，如果两个均为 True，才返回 True，否则返回False
or 表示或，任意一个为 True，返回 True。只有两个均为 False，才返回 False。
not 取反。 

1
2
3
4
5
6
7
8
9
10
11
1 and 1 
#True

'a' and 'b' 
#'b'

'a' or 'b' 
#'b'

not 'a'  
False

非布尔类型的转换

由于很少直接把变量设置为布尔类型，因此在大多数为非布尔类型的变量运算中，遵循如下法则：

  • 整数和浮点数：0表示False，非0为True
  • 字符串：空字符串为False，非空字符串为True
  • 列表：空列表为False，非空列表为True
  • 元组、集合、字典：同列表

划重点：

  • 被判定为False的值：False,0,'',[],{},()
  • 逻辑运算符的返回结果可以用非布尔类型表示，结果显示为非布尔类型

or和and返回值的规律

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[] or [1]
# [1]

[1] or [] 
# [1]

'a' and 'b'
# 'b'

'' and 'b'
# ''

0 and 1
#0

1 and 0
#0

计算返回的结果，是当计算机解析出结果时的值。以0和1为例，当0 and 1时，0已经可以判断出返回结果为False，因此返回结果为0。而当1 and 0时，只有当判断到0时，才能判定为结果为False，因此返回的值仍然是0。

成员运算符

成员运算符包括：in、not in

用于判断一个元素是否在另外一组元素里，返回值为布尔类型。
适用于列表、字符、元组、集合和字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
a1 = 1
a1 in [1,2,3,4,5] #True

a2 = 76
a2 in [1,2,3,4,5] #False

a3 = 'h'
a3 in 'hello' #True
a3 not in (1,2,3,4,5) #True
a3 not in [1,2,3,4,5] #True

a4 = 'a'
a4 in {'c':1} #False

a5 = 1
a5 in {'c':1} #False

a6 = 'c'
a6 in {'c':1} #True

注：字典的成员运算符是针对 key 进行判断的，而非 value

身份运算符

身份运算符包括：is、is not

身份运算的返回类型为布尔值，与关系运算符的区别：

  • not is：两个变量身份不同时返回True
  • is：两个变量身份，即id()（内存地址）相等时返回True
  • ==：两个变量取值相等时返回True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = 1
b = 2
a is b  #False

a = 1
b = 1.0
a is b  #False id(a)=4473961600 id(b)=4498600872
a == b  #True

a = {1,2,3}
b = {2,1,3}
a == b #True  集合是无序的
a is b #False 内存地址不同

a = (1,2,3)
b = (2,1,3)
a == b #False 元组属于序列，是有序的
a is b #False 内存地址不同

对象的三大特征：值、类型和身份

补充：类型的判断 isinstance

第一个参数：变量
第二个参数：变量类型
注：第二个参数可接受元组，当满足元组中任意一种，则返回True 

1
2
3
4
5
6
7
8
9
10
11
a = 1
type(a) == int #True

a = '1'
type(a) == int #False

a = 'a'
isinstance(a,str) #True

a = 'a'
isinstance(a,(int,str,float)) #True

为什么不推荐使用 type() 进行类型判断？
答：无法判断对象的子类型是否属于该类型

位运算符

位运算符：把数字当作二进制数进行运算

  • &：按位与：
  • |：按位或
  • ^：按位异或
  • ~：按位取反
  • <<：左移动
  • >>：右移动
1
2
3
4
5
6
7
8
9
10
a = 2
b = 3

a & b #2

### 运算规则:0&1=0 1&1=1
   a = 10(二进制)
+  b = 11(二进制)
-----------------
       10