Python笔记2 变量与运算符

变量的命名可以是：字母、数字、下划线，不能是保留关键字（系统关键字）

int 类型（值类型）的赋值与 list 类型（引用类型）赋值的区别：

1. 对于引用类型来说，它本身的值是可以改变的
2. 但是值类型是不可变的，如果想要改变值类型，只能生成新的数值

>>> a = 1    #a 指向整形数字1
>>> b = a    #b 同样指向整形数字1
>>> a = 3    #a 指向整形数字3
>>> b        #此时 b 依旧是指向整形数字1
1

>>> a = [1,2,3]    #a 指向列表[1,2,3]
>>> b = a          #b 指向列表[1,2,3]
>>> a[0] = 100     #此时并不是让 a 指向一个新的列表，而是将原来的列表[1,2,3]改变为了[100,2,3]
>>> a
[100, 2, 3]
>>> b              #这就使得b 指向的列表发生了改变
[100, 2, 3]

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

但是要理解如下这种情况：尽管字符串类型时不可变的，但是此处是将 a + 'python' 重新赋给一个新的 a, 从 id 可以看出 

>>> a = 'hello'
>>> id(a)
88561600
>>> a = a + 'python'
>>> id(a)
88579992

list 类型可以通过 append 函数添加，但是 tuple 不可改变

>>> a = [1,2,3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> b = (1,2,3)
>>> b.append(4)
Traceback (most recent call last):
  File "<pyshell#84>", line 1, in <module>
    b.append(4)
AttributeError: 'tuple' object has no attribute 'append'

元祖中嵌套列表：二维数组

>>> a = (1,2,3,[1,2,3])
>>> a = (1,2,3,[1,2,4])
>>> a[2]
3
>>> a[3][2]
4
>>> a = (1,2,3,[1,2,['a', 'b']])
>>> a[3][2][1]
'b'
>>> a = (1,2,3,[1,2,4])
>>> a[2] = 4                #元祖中的 int类型不可以改变
Traceback (most recent call last):
  File "<pyshell#92>", line 1, in <module>
    a[2] = 4
TypeError: 'tuple' object does not support item assignment
>>> a[3][2] = '4'
>>> a                        #但元祖中的列表可以改变
(1, 2, 3, [1, 2, '4'])

运算符

算术运算符：

>>> 'hello' + 'world'
'helloworld'
>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]
>>> 3 //2
1
>>> 3 /2
1.5
>>> 3 % 2
1
>>> 2 ** 3        #乘方
8

赋值运算符

Python中不存在变量的定义，变量在Python中就是一个名字

>>> a = 1
>>> a += 1
>>> a
2
>>> a++    #Python中没有自增自减
SyntaxError: invalid syntax
>>> b = 5
>>> b -= a
>>> b
3
>>> b *= a
>>> b
6

除此之外，还有 /=,  %=,  **=, //=

比较（关系）运算符

>>> 1 == 1
True
>>> 1 >= 1
True
>>> True < False
False
>>> 'abcf' < 'abde'    #两个字符串（列表、元祖）的比较规则：依次对每一个字符的ASCII码比大小
True
>>> [1,2] < [1,3]
True
>>> (1,2) < (1,3)
True
>>> [1] < ['1']        #但是不同类型是不可以比较的
Traceback (most recent call last):
  File "<pyshell#131>", line 1, in <module>
    [1] < ['1']
TypeError: '<' not supported between instances of 'int' and 'str'

除此之外还有 != 

+= 与 > 的运算：> 的优先级高于 +=

int 与 bool 的加法运算：True可以转化为1

>>> b = 1
>>> b += b > 1    #先运算 b > 1, 得到结果为 True，此时等价于计算 b += True
>>> b
1
>>> int(True)
1
>>> int(False)
0

逻辑运算符

主要操作 bool 类型，返回类型也是 bool（不一定）

>>> True and True
True
>>> True and False
False
>>> True or False
True
>>> not True
False

尽管 逻辑运算符只是针对于 bool 类型的，但是在遇到 int 或者字符串时，会转化为 bool 来运算

1. int float 类型时，0 被认为是 False， 非0 表示 True
2. 字符串类型，空字符串被认为 False
3. 列表、元祖、集合、字典：空的列表被认为 False

对于 and 运算符来说，要读完前后两个值，才可以确认当前 and 运算的结果

对于 or 运算符，当第一个为 True，则可以判断当前运算结果为 True，后面的不会读

但是返回第一个还是第二个，并不是重点，重点要关注的是结果是False还是True

>>> not ''
True
>>> not []
True
>>> not ()
True

>>> 'a' and 'b'    #当 and 前后均为真时，返回第二个
'b'
>>> 'b' and 'a'
'a'
>>> '' and 'b'    #and 前后有一个为False，返回False的那个
''

>>> [1] or [2]    #当 or 前后均为 True时，返回第一个
[1]
>>> [2] or [1]
[2]
>>> [] or [1]    #当 or 前后一个False，另一个True，返回 True的那个
[1]

成员运算符

in， not in

列表、字符串、元祖、集合均可以

对于字典：判断的是 key 键值是否在该字典中

>>> b = 1
>>> b in {'c':1}
False
>>> b = 'c'
>>> b in {'c':1}
True

身份运算符

is , is not 返回结果是 bool

与 关系运算符 == 区别：

1. == 表示 值是否相等
2. is 不是比较值是否相等，而是比较身份是否相等（内存地址）

两个变量值相同，可能身份不同（即就是内存地址不同）

>>> a = 1
>>> b = 1.0
>>> a is b
False
>>> id(a)
1822910592
>>> id(b)
81404432
>>> a == b
True

区别在 元祖 与 集合中的运用：

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

>>> c = (1,2,3)    
>>> d = (2,1,3)
>>> c == d        #元祖是一个序列，它是有序的
False
>>> c is d        #内存地址不同
False

对象三个特征：值、身份、类型，对应的判断为：== , is , isinstance

判断变量的类型：

>>> a = 'hello'
>>> isinstance(a, str)
True
>>> isinstance(a, int)
False
>>> isinstance(a, (int, str, float))    #第二个参数可以是一个元祖
True

位运算符

& 按位与 ，| 按位或， ^ 按位异或， ~ 按位取反， << 左移动， >> 右移动

把数字转化为二进制数进行运算

>>> a = 2
>>> b = 3
>>> a & b
2
>>> bin(a)
'0b10'
>>> bin(b)
'0b11'
>>> a | b
3