python运算符

算数运算符

• 加法：数值相加，序列拼接

>>> 1 + 2
3
>>> "123" + "456"
'123456'

• 减法：数值相减  -
• 乘法：数值相乘，序列增倍  +

>>> 3 * 6
18
>>> "我爱你" * 3
'我爱你我爱你我爱你'

• 除法：小数除 /，整数除 //

• 在Java中5/2代表求整，但在python中代表除法运算，在python中需要求整时请用双斜杠//

整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为0）

>>> 10 / 2
5.0
>>> 10 // 2
5
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10.0 // 3
3.0
>>> 10.5 // 3
3.0

•  幂运算  

  幂次

  **

>>> 2 ** 3
8
>>> 16 ** 0.5
4.0

取余：10 / 3 = 3 ~ 1

>>> 10 % 3
1
取余经常用于哪些场景，带有数据重复或循环的情况
22日对应周五，22 % 7 = 1 余数为1 则对应周五 0 对应周四....
30 % 7 = 2 对应周六

• 布尔判断运算符

运算结果一律为布尔值
大于 小于 大于等于 小于等于 不等于 等于
> < >= <= != ==

bool() 函数也可以评估任何值，并返回True或False。
Python允许连续比较

>>> 1 < 2 < 3
True
>>> 1 < 2 and 2 < 3
True

在Python当中 == 到底比得是啥？
答：比的是具体对象的值

>>> a = 1
>>> b = 1
>>> id(a) # id 取变量中存储的数据对象在内存中的地址
140715464473016
>>> id(b)
140715464473016
>>> a = 1000
>>> b = 1000
>>> id(a)
3267440575376
>>> id(b)
3267440589968
可以发现a和b在为1000时 对象地址不一样？
因为在Python当中 只有-5~256 Python会自动创建这些数据对象，提供给调用者使用
也就意味着如果创建该范围之外的数据对象的话，Python则重新创建新的对象出来
a = 1000, b = 1000 其实是两个1000数据的对象 
a == b 比的是对象的内容 但是a和b存的地址不一样
a = 1, b = 1, 其实只有一个 1 数据的对象 

a == b 比的是对象的内容 但是a和b存的地址一样

• 增强型赋值运算符 

+= -= *= /= //= **= %=
a += 2
a = a + 2
b **= 2
b = b ** 2

在Python中 是不存在 ++ --这种自增运算符的！ 

int i = 1;
i++;
System.out.println(i);
System.out.println(i++);
int j = i++;
System.out.println(i);
System.out.println(j);
i = i++;
System.out.println(i);
i = i++;
System.out.println(i);

i++流程

1. 1. 开辟临时存储区
2. 2. 将i的值复制到临时存储区内
3. 3. i自身+1
4. 4. 临时存储区的值等待被调用（输出 赋值 参与运算）

System.out.println(x++ + ++x + ++x + x++); // 12
System.out.println(x); // 5 

 逻辑运算符

与 或 非 = and or not （&& || !）
与：全真则真 有假则假
或：有真则真 全假则假
非：取反

>>> 1 < 2 and 2 < 3
True
>>> 1 < 2 or 2 > 3
True
>>> not 1 < 2
False
& 与 &&的区别

int x = 0;
int y = 0;
System.out.println(x++ < 0 & y ++ < 0); //无论左边是否为假 右边都要计算
System.out.println(x); //1
System.out.println(y); //1
int x = 0;
int y = 0;
System.out.println(x++ < 0 && y ++ < 0); //如果左边是假 右边不计算
System.out.println(x); //1
System.out.println(y); //0
&& 就是为了避免一些没有必要的计算 提高效率

•  位运算符：& |  >>  << ~  ^

&按位与
>>> 13 & 7
5
1101
0111
0101 = 5
|按位或
>>> 13 | 7
15
1101
0111
1111 = 15
>> 右移
>>> 16 >> 2
10000
  100|00
  100 = 4
16 / 2 ^ 2
<< 左移
>>> 2 << 3
16
0010
0010000
  10000 = 16
2 * 2 ^ 3
~取反 符号取反再减1
>>> ~15
-16
01111 = 15
10000 = -16

^ 异或：相等为假 不同为真

>>> 13 ^ 7
10

1101
0111
1010 = 10

 关于变量交换值

1.方法一

a = 1
b = 3
temp = a
a = b
b = temp

2.

a, b = b, a # Python自带的交换特点：此方法是python中特有的方法，将变量放到元组中，再通过元组按照index进行赋值的方式对变量进行重新赋值，并不受限于两个变量，多个变量也是可以

只针对整数

a = 10
b = 100
a = a + b # 110
b = a - b # 10
a = a - b # 100
只针对整数
a = a ^ b
b = a ^ b
a = a ^ b

        #通过异或运算，将两个值进行互换：

就是计算机会先把十进制数转化为二进制数，并且对二进制数进行从右到左进行比较，如果比较的两个二进制数相同，结果为0，不同结果为1，1^1=0，1^0=1，0^0=0。

        

 

成员运算符： in 和 not in

判断一个元素是否在另一个序列中

>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False
>>> "abc" in "sakjdgabca"
True
>>> 1 in [2,3,4]
False

 从属/身份运算符：is 和 not is

判断两个变量指向的对象是否是同一个对象（比地址）

>>> a = 1
>>> b = 1
>>> a == b
True
>>> a is b
True
>>> a == 1000
False

>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> a = "abc" # 字符串
>>> b = "abc" # 之前已经创建了"abc" 这里直接复用 而不是重新创建 跟整数是有区别的
>>> a == b
True
>>> a is b
True
>>> id(a)
140715463387184
>>> id(b)
140715463387184