Python的变量

变量的概念

Python中,变量可以赋任意类型的值。

Python中的变量不需要声明。-------要说成把值赋值给变量名

Python中的变量在第一次赋值后,变量名就指向了存储区中的值

Python中的变量可以重新赋值。

[1,2,3,4]称为列表A,[5,6]称为列表B,把列表A*2，再加上列表B，再加上列表A

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

如果运算需要多次引用列表AB，就不能这样写了，会占用很多的空间，就引入一个变量的概念
可以写成如下形式：

>>> A=[1,2,3,4]------等号'='被称为赋值符号，等号左边是变量名，右边是变量值
>>> B=[5,6]
>>> A*2+B+A

变量命名的规则

1.变量名由字母、数字、下划线组成，不能以数字开头，不能用其他的特殊字符
2.变量名不能是Python中的保留字keyword，比如if、while、def、class等

import keyword
print(keyword.kwlist)

3.变量名不能包含空格
4.Python建议用下划线的方式组合命名，如：usr_account，但其他语言可能倾向于用驼峰的方式命名，如：usrAccount

变量命名一定要有意义，最好用对应的英文单词表示
变量名是区分大小写的
变量的值可以是任何数据类型-----而静态语言在定义变量的时候前面都需要加上一个类型声明，比如int、float、string等

变量的特性

1.变量可以重复赋值
2.变量可以修改

举例：

>>> A=1
>>> B=A
>>> A=3-----------思考：此时如果print(B)，会等于几
>>> print(B)----->1 #B没有跟着A一起变化

但是

>>> A=[1,2,3,4]
>>> B=A
>>> A[0]='8'------------思考：此时如果print(B)，会等于几
>>> print(A)----->['8',2,3,4]
>>> print(B)----->['8',2,3,4]-------为什么会和上面的情况不一样？

引用一个新的概念，int是值类型，list是引用类型
引用类型的值是可以改变的，值类型不能改变

关键点就在于A[0]='8'的时候，实际上并没有改变A的指向，还是指向原来的列表，只不过是把原来的列表改变了；
但是上面修改A=3，实际上是把A的指向修改到了3,内存地址发生了变化,而B=A发生在A改变内存地址之前,B还是指向原来的A的地址,所以B不会跟着一起变

值类型有：int、str、tuple
引用类型有：list、dict、set
值类型的值不能改变，引用类型的值可以改变(没必要过分纠结是哪个类型，主要关注的是性质)

>>> a='hello '
>>> a=a+'python'--------思考：此时a的值会等于什么
hello python

上一步的操作其实是生成了另一个字符串a，字符串的地址发生了改变(可以用id()命令查看)
同理用id()命令可以验证上面的列表指向问题，可以发现，列表的内存地址并没有改变，只是列表中的值发生了改变

提取变量中不同数据类型的值

a=(1,2,3,[2,3,4]),要提取元组中的’4’

>>> a[3]----->[2,3,4]
>>> a[3][2]----->4

思考：要提取a=(1,2,3,[2,3,['a','b','c']])中的’b’呢？

>>> a[3][2][1]----->'b'

继续思考：a=(1,2,3,[2,3,['a','b','c']])中的1可以改变吗，'a'呢？

答:1不能改，'a’可以改
因为1在元组中，'a’在列表中(也就是说，嵌套在元组中的列表的值可以改变)

运算符

1.算数运算符
2.赋值运算符
3.关系(比较)运算符
4.逻辑运算符
5.成员运算符
6.身份运算符
7.位运算符

1.算数运算符

>>> 1+1-----加
>>> 1-1-----减
>>> 1*1-----乘
>>> 1/1-----除
>>> 1//1-----整除
>>> 1%1-----取余数
>>> 1**1-----乘方

2.赋值运算符

>>> a=1-----赋值
>>> a+=1-----a=a+1的简写------重点在于赋值，a的值被改写了,但是内存地址不变

如果：a=3,b=2,要输出a+b，怎么用赋值运算符实现

a+=b
print(a)----->5
print(b)----->2

>>> a-=1-----a=a-1的简写
>>> a*=1-----a=a*1的简写
>>> a/=1-----a=a/1的简写
>>> a//=1-----a=a//1的简写
>>> a%=1-----a=a%1的简写

3.关系运算符

返回值是bool类型

>>> 1==1-----等于
>>> 1!=1-----不等于
>>> 1<1-----小于
>>> 1>1-----大于
>>> 1<=1-----小于等于
>>> 1>=1-----大于等于

思考：

>>>b=2
>>>b+=b>1
>>>b+=b>1
>>>print(b)----------结果是多少？

答：正常运算b+=b,结果应该是4，但是b>1,结果是True，那b+=b>1，就是b=b+True，而bool值True在计算中实际上为1，即b=b+1,结果是3

思考： 其他类型的值如何比较？

答：通过ASCII码比较单个字符，元素一一对应比较，忽略相等的对应字符，返回第一个不相等的字符的比较结果

>>>(1,2,3)<(1,3,2)----->True
>>>(1,3,2)<(1,2,3)----->False

4.逻辑运算符

主要用于bool类型的运算，并且返回值也是bool类型

a and b-----逻辑与and
规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false

a or b-----逻辑或or
规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false

not a-----取反not
规则：当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true

问题：1 & 1会输出什么，1 & 2会输出什么，'a' and 'b'会输出什么，not 'a'会输出什么？

答：1 & 1------>1 ；
1 & 2------>0 ；
‘a’ and ‘b’------>‘b’ ;--------非数字类型在逻辑运算时，不能用&符号，只能用and
not ‘a’------>False

总结:

• 1.int和float类型逻辑运算时，0被认为是False，非0被认为True；

那么思考：1 and 2 和 2 and 1分别会输出什么？

python在and运算时，必须要先读取到后面的值，才能做出运算，因为第一个值的真假并不能直接做出判断，如果运算的两个值都满足输出的逻辑，会优先返回最后读取的值

1 and 2------>2
2 and 1------>1

但是，不一样的是，在进行or运算时，如果第一个值就是True，就不用再读取后面的值了，直接返回第一个值

• 2.str类型逻辑运算时，空字符串被认为是False，非空字符串被认为是True；----会返回空字符串(表示False)和非空字符串(表示True)，实际上还是bool值;
• 3.list类型逻辑运算时，空列表被认为是False，非空列表被认为是True

5.成员运算符in

判断某个值是否是某个集合的成员，返回值是bool类型

>>> 1 in [1,2,3]------>True
>>> 1 not in [1,2,3]------>False

思考:

第一种情况 >>>b='a'
         >>>b in {'c':1}------>False

第二种情况 >>>b=1
         >>>b in {'c':1}------>False

第三种情况 >>>b='c'
         >>>b in {'c':1}------>True

所以，字典类型判断值是否是成员时，会判断字典的Key是否和值相等，如果相等，就返回True，否则返回False

6.身份运算符is

判断两个变量的id是否相等，返回值是bool类型(与后面学习的对象有关)

>>> 1 is 1------>True
>>> 1 is not 1------>False

看似是比较两个变量的值是否相等，那和前面的关系运算符的==有什么区别呢？

实际上比较的是两个变量的id是否相等，即比较两个变量是否是同一个内存地址

举例：

>>>a = 1
>>>b = 1.0  
>>>a == b------>True
>>>a is b------>False--------注意到区别了吧

由此可以得到对象的三个特征：值，身份，类型------一切皆对象

7.位运算符

会把数字当作二进制进行运算

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

以按位与&为例：

>>>a=2
#a的二进制是10
>>>b=3
#>>b的二进制是11
>>>a & b

把两个二进制数按位数进行比对，个位的0和1比对，得到0，十位的1和1进行比对，得到1，最后结果是二进制10，转换成十进制是2

按位与比对规则：如果两个都是1，则得到1，如果两个有一个是0，或者两个都是0，得到0(与逻辑与一样)

所以最后输出结果是2

8.运算符优先级

1.算数运算符与基本的数学运算优先级一样
2.逻辑运算符优先级：not>and>or
其他优先级关系可以上网查阅资料
可以像数学运算一样用()强制优先运算，也就是()的优先级最高
同优先级的运算符，一般都是从左到右进行运算，但有一个特列：赋值运算符=，从右到左进行运算

思考：

>>>a=1
>>>b=2
>>>c=2
>>>not a or b + 2 == c------>False------运算顺序是什么?

答:(not a) or ((b + 2) == c)
最好是在写代码的时候加上括号，辅助理解，前提是不改变原有的运算优先级

匿名变量

list_a = [a,b,c,d]
for _,item in enumerate(list_a):    
#'_'用于表示匿名变量，本来这个位置是index，但如果只是占位并不使用，可以用匿名函数占位
    print(item)