python3变量与运算符（5）

5.1 什么是变量

>>> [1,2,3,4,5,6] * 3 + [1,2,3]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3]

上面这种算法太长了
想要变得简洁，需要引入变量的概念
怎么理解变量？
变量就是一组数据的名字

定义一个变量

>>> A = [1,2,3,4,5,6]
>>> print(A)
[1, 2, 3, 4, 5, 6]

“= ”在python中是赋值符号

用变量实现上述代码的计算

>>> A = [1,2,3,4,5,6]
>>> B = [1,2,3]
>>> A * 3 + B
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3]

写出优质的代码最基本的要求是可读性强，所以变量的命名要有意义，要见名知意

5.2 变量的命名规则

变量名只能由字母、数字、下划线组成且首字符不能是数字
变量名不能是系统的保留关键字
变量名区分大小写
在Python中变量没有类型限制，字符串、整型、元组、集合等统统都可以赋值给变量

在IDLE中橙色的是系统的保留关键字
紫色的不是系统的保留关键字（能作为变量名，但极易引起错误，不建议使用）
黑色的是常规变量

>>> type = 1
>>> type(1)
    Traceback (most recent call last):
      File "<pyshell#78>", line 1, in <module>
        type(1)
    TypeError: 'int' object is not callable

错误原因：‘int’类型的变量并不是可调用的；
原因在于我们现在把type当成了变量，然后又把整型数字“1”赋值给了type，根据变量的基本规则，现在这个type就是“int”类型的数据值，然后又把“int”类型的变量当作一个方法来调用，这显然是不对的；上面的type(1)就等同于1(1)

>>> 1(1)
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    1(1)
TypeError: 'int' object is not callable

错误提示是一样的，这就说明虽然 type（IDLE中紫色的）不是系统的保留关键字，然后你也可以把它当作变量名，但是问题是如果在后续的代码中，你不再使用 type的函数调用方式，只是把它打印出来，即

>>> type = 1
>>> print(type)
1

那么是没有问题的，所以强烈建议大家对于这种非系统保留关键字，但是又被用作方法来调用的单词，也不要当作普通的变量来命名，因为极易引起后续代码的错误！
5.3 值类型与引用类型

>>> a = 1
>>> b = a
>>> a = 3
>>> print(b)
1               //b没有改变
>>> a = [1,2,3,4]
>>> b = a
>>> a[0] = '1'
>>> print(a)
 ['1', 2, 3, 4]
>>> print(b)
['1', 2, 3, 4]    //b改变了

int和list截然不同，int是值类型，list是引用类型
值类型（不可变）：int str tuple
引用类型（可变）：list set dict

>>> a = 'hello'
>>> a = a + 'python'    //a得到的是新的字符串，不是原来的字符串了
>>> print(a)
hellopython    

利用id()证明其得到的是新的字符串

>>> b = 'hello'
>>> id(b)
62915904
>>> b += 'python'
>>> id(b)
62890296         //两次id不同，内存地址不一样

证明字符串是不可改变的类型

>>> 'python'[0] = 'o'
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    'python'[0] = 'o'
TypeError: 'str' object does not support item assignment

5.4 列表的可变与元组的不可变

查看内存地址用id

>>> a = [1,2,3]
>>> id(a)
63873192
>>> a[0] = '1'
>>> id(a)
63873192            //列表的id没有改变

>>> a = (1,2,3)
>>> a[0] = '1'
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    a[0] = '1'
TypeError: 'tuple' object does not support item assignment    //元组为值类型，不可变

追加元素用.append()

>>> b = [1,2,3]
>>> b.append(4)
>>> print(b)
[1, 2, 3, 4]        //列表可以追加元素，元组不行

对于元组来说，一旦定义就不可改变。
列表支持追加元素，显然功能更强大一些，为什么还要用元组类型？？
编码最重要的是要保持代码的稳定性，如果我们写一些简单的代码，只由我们一个人来完成，没有其他人来调用或修改我们的代码，这样是没有问题的；如果在一个比较复杂的项目里面，我们不可能一个人来完成，而是很多人共同协作完成，那么就涉及到代码之间的调用，那么对于一些不可改变的类型，是有优势的，因为一旦有人尝试修改，程序马上就会报错，运行就会失败，从而避免了一些隐藏的错误，所以如果能用元组来表示一组元素就尽量用元组，最好不要用列表；如果需要动态的改变一组元素还是用列表；即能用元组就用元组，不能用元组再用列表。
总之，在复杂的项目里协作写代码，涉及到数据调用，用元组可以保证数据的稳定。

二维数组的访问

>>> a = (1,2,3,[1,2,4])
>>> a[2]
3
>>> a[3][2]
4
>>> a[3][2] = '4'       //回车没有报错，说明运行成功了
>>> print(a)
(1, 2, 3, [1, 2, '4'])    //可以实现修改，因为我们改变的是列表不是元组

5.5 运算符号

算术运算符：
（+）加
（- ）减
（* ）乘
（/）除
// 取整
% 求余数
** 次方

>>> 2**2
4
>>> 2**5
32

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

5.6 赋值运算符

为了给变量赋值，先做运算再赋值

>>> c = 1     //把1赋值给变量C，python的变量是不需要定义的，所以不说是定义一个变量C
>>> c += 1
>>> print(c)
2        //python中没有自增、自减运算符，即“++”  “--”
>>>b = 2
>>>a = 3
>>>b += a
>>>print(b)
5
>>>b -= a
>>>print(b)
2
>>>b *= a
>>>print(b)
6

赋值运算符最终一定要落实在赋值上面

5.7 比较（关系）运算符

两个变量之间比较，不仅仅限于数字，字符串、bool都可以比较
比较运算符关键在于操作完成后返回一个bool值

>>> 1 == 1
True
>>> 1 > 1
False
>>> 1 >= 1
True

5.8 不只是数字才能做比较运算

>>> b = 1
>>> b += b >= 1      //b = 1 + True，答案为2
>>> print(b)    
2

解析计算：

>>> print( b >= 1)    
True

上面的代码就可转换成：

>>>b += True

根据赋值运算规则又可转换成：

>>>b = b + True      //b目前的取值是1

上式转换成：

>>>b = 1 + True         //bool类型本身就是Number类型中的一种

因为：

>>>int(True)
1

所以：
该式为：

>>>b = b + 1
2

字符串关系运算

>>> 'a' > 'b'             //比较的是ascll码
False
>>> 'abc' < 'abd'     //字符串中，每个字符单独做比较
True    

列表、元组等都可以做关系运算

>>> [1,2,3] < [2,3,4]           //每个字符单独做比较
True
>>> (1,2,3) < (1,3,2)           //每个字符单独做比较
True

5.9 逻辑运算符

主要操作bool类型，且返回类型也为bool类型
and:且（与）
or:或
not:非

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

非bool类型中，
int、float中0被认为是False，非0被认为是True

>>> not 0.1
False

str中空字符串被认为是被认为是False，否则是True

>>> not ' '    //空字符串
True
>>> not '0'    //0不是空字符串
False

空列表、元组、集合、字典被认为是False，否则是True

>>> not []    //空列表
True
>>> not [1,2,3] 
False
>>> [1] or []
[1]                     //返回结果用非bool值表示
>>> [] or [1]
[1]                     //专注返回元素的是True还是False

and结果为True时，返回后面的值，因为and是全真才为真

>>> 1 and 2
2                    //读到第二个值才能确定为True，所以返回2
>>> 2 and 1
1

or结果为True时，返回前面的值，因为or是有真即为真

>>> 1 or 2
1                            //读第一个值时就已经确定为True了所以返回1

5.10 成员运算符

in 和 not in 是用来判断一个元素是否在另外一组元素中，返回值是bool类型

>>> a = 1
>>> a in [1,2,3,4,5]
True
>>> b = 6
>>> b in [1,2,3,4,5]            //in表示是否在
False
>>> b not in [1,2,3,4,5]       //not in表示是否不在
True

字典是对于key:value中的key来操作的

>>> b = 'a'
>>> b in {'c':1}
False
>>> b = 1
>>> b in {'c':1}
False
>>> b = 'c'
>>> b in {'c':1}                   //针对key来判断
True

5.11 身份运算符

is 和 is not 返回的是bool值

>>> a = 1
>>> b = 2
>>> a is b
False    

如果两个变量取值相等，则is返回True
is 和 == 的区别：
关系运算符==比较的是两个变量的值是否相等，身份运算符is比较的是两个变量的身份是否相等，即内存地址

>>> a = 1
>>> b =1.0
>>> a == b
True                //关系运算符比较值相等，返回True
>>> a is b
False               //两个变量身份(内存地址)运算，返回False 

5.12 如何判断变量的值、身份、类型

值value==、身份id（is）、类型type(isinstance)是对象的三大特征，python中一切都是对象
分别用==、is、isintance()来判断

>>> a = {1,2,3}
>>> b = {2,1,3}
>>> a == b
True                     //集合是无序的，值相等
>>> a is b
False                  //内存地址不一样
>>> c = (1,2,3)
>>> d = (2,1,3)
>>> c == d
False               //元组是有序的，值不相等
>>> c is d
False              //内存地址不一样

对类型type的判断

>>> a = 1
>>> type(a) == int
True
>>> a = 'hello'
>>> type(a) == int
False

推荐使用isinstance(判断对象，判断类型)

>>> isinstance(a,str)
False
>>> isinstance(a,(str,int,float))       //判断a是不是这三种元组中的任意一种
True

5.13 位运算符

&：按位与
|：按位或
^：按位异或
~：按位取反
<<：左移动
‘>>：右移动
位运算符都是把数字当作二进制数进行运算
并不是只能做二进制数计算，如果是其他进制会自动转换成二进制数

>>> a = 2         //十进制的2转换成二进制是10
>>> b = 3         //十进制的3转换成二进制是11  
>>> a & b        //10&11   结果是10
2
>>> a = 2        
>>> b = 3        
>>> a | b               //10&11   结果是11
3