python源反补,进制转换,运算符

进制

常用的四种进制,二进制,八进制,十进制,十六进制

二进制用0b开头 bin() 满2进1 本位跳0 数字为0.1

八进制是0o开头 oct() 满8进1 本位跳0 数字为1.2.3.4.5.6.7

十进制 int() 满10进1 本位跳0 数字为1.2.3.4.5.6.7.8.9

十六进制是x开头 hex() 满进1 本位跳0 最大数字为1.2.3.4.5.6.7.8.9.a.b.c.d.e.f

进制转换方法一

转为二进制bin()

转为八进制oct()

转为十进制int()

转为十六进制hex()

print(bin(26))       #十进制26转化为二进制0b11010
print(oct(0b11010))   #二进制转化为八进制  0o32
print(int(0b11010))  #二进制转化为十进制26
print(hex(0b11010))  #二进制转化为十六进制0x1a
print(hex(26))       #十进制转化为十六进制0x1a

电脑自带的计算器中有一个程序员的功能,有二进制 八进制 十进制 十六进制 可以一次性转换

python中int类型是根据你的电脑的位数改变的 你是64位的,最大值就2的64次方减一到正的2的64次方

bit位 一个字节等于八个bit位 1kb=1024b

也就是说一个字节等于八个二进制位 0000 0000 就是八个二进制位

二进制中 八位数能代表的最大的数字是 128 64 32 16 8 4 2 1

进制转换方法二

二进制转十进制

转换就是 根据二进制最大的八位数, 十进制数与二进制数中的八个位置一一做减法

比如十进制数 10

10减去128 不够,10减去64 不够,10减去32,不够…10减去8=2, 这里就写上一个1, 剩下的2-4 不够, 2-2=0 够的, 0-1不够

够的写1 , 不够就写0 , 所以10转化为二进制就是00001010

又比如十进制数20

20-128 20-64 20-32 20-16=4 4-8 4-4=0 0-2 0-1

所以20的二进制位0001 0100

二进制转八进制

看三位一组,二进制转十六进制 看四位一组

二进制中 128 64 32 16 8 4 2 1

1111 1111 共有八位数字,以最后三位数为一组, 4 2 1 加在一起就是7

这时候比如 二进制为 0001 1011 那么十进制为

​ 三位一组,最后三位011.对应的是4 2 1 ,十进制的0 1 1对应的2进制4 2 1相加等于2+1=3

​ 二进制的第二组三位数为0 1 1,对应的二进制4 2 1,对应的二进制相加等于 2+1=3

​ 所以二进制转为十进制等于33

二进制转十六进制

十六进制中 128 64 32 16 8 4 2 1 二进制为0011 1011

​ 四位一组,四位为8 4 2 1 第一组为1 0 1 1 为11

​ 第二组为0 0 1 1,对应的8 4 2 1 的值的和为3 所以是3 1 1 11对应的十六进制为b

​ 所以二进制0011 1011转化为十六进制为3b

源码 反码 补码

计算机中的所有运算都是补码运算

1. 源码就是十进制转化的二进制,

2. 反码就是源码的基础上0变1,1变0,按位取反

3. 补码就是反码的基础上+1

正数三码一致 源码=反码=补码

比如22 二进制为0001 0110 这是源码,反码补码也都是这个

但是负数三码不一致

比如-22 二进制位1001 0110 -->反码就是0110 1001 --> 补码是 0110 1010

源码求补码 源码先取反 再加一

补码求源码 补码先减一 再取反

类型转换

int(需要转化的字符串 , 当前字符串中数字的进制)

1. int(x , [字符串]) int(需要转化的字符串 , 当前字符串中数字的进制)
2. float(x) 转为浮点数
3. str(x) 转为字符串
4. bool(x) 转为布尔值

print(int("123"))  # 123 将字符串转换成为整数
print(int(123.78))  # 123 将浮点数转换成为整数
print(int("123.711"))  #这个会直接报错,因为这个字符型123.711有个点点

这里注意int只可以转化 只有数字的字符型 和 可带小数点的number型

print("转化为浮点型")
f1 = float("12.34")          
print(f1)   # 12.34  

浮点型可随意,但是转换int型 or 字符串里面是int型会带小数点后一位

比如 float(“12”) -->得 12.0

print("转化为字符串")
str1 = str(45)                
str2 = str(34.56)

可随意转化为字符串,无任何要求,不会多也不会少

print("转化为布尔值")  #这些都是false
print(bool(''))
print(bool(""))
print(bool(0))
print(bool({}))
print(bool([])）
print(bool(())）
print(bool(None)）

在python中，只有空字符串’’,""，数字0,空字典{},空列表[],空元组(),和空数据None会被转换成为False,其他的都会被转换成为True,就是说空的和数字0才会被转化为false

相加

python中字符串和数字类型不可以直接相加,会直接报错,所以要转化

name = "张三"
age = 18
flag = True
print(name + str(age) +str(flag))

运算符

优先级

() 最高 ,然后是** 然后是+ - 然后是 * / // %

为了以防万一可以直接加(),因为他的运算级别最高

算数运算符

有以下的运算符:​ + - * / // (向下取整) %(取余) ** (次方)

不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

需要注意的: //:正数为先下取整,负数也是 比如5//2=2 -5//2=-3

注意事项

1. 两个字符串做加法 , 会直接拼成一个字符串
2. 数字和字符串直接加法运算,直接报错
3. 数字和字符串乘法运算,会把这个字符串重复数字的次数

赋值运算符

= 把=号左边的常数赋值给=号左边的变量, 注意赋值的个数不可以超过未知数的个数

可以这么用

num1,str1,str2= 1, "hello", 3
print(num1, str1, str2)

延伸版本

+= -+ *= /= //= **= %=

列a+=1 就是a=a+1 以此类推

比较运算符

< > >= <= != == <>

<>这个就是!= 是python3.0以后不支持了

比较运算符连接起来的叫比较表达式 表达式的返回值要么是True 要么是False 不可能有其他值

数字和字符串做运算结果是false,除了 == 以外的逻辑运算时，会直接报错。(后半句说的是,只有数字和字符串可以,并且为false,其他的都会直接报错,比如字典,集合啥的,但是集合,字典都是false啊,这句话到底啥意思,老实说不用管,)

== 两边相等返回True 两边不同返回False

!= 两边不同返回True 两边相同返回False

字符串的比较根据ASCII码表进行比较 (A65 Z90 a97 z122)

比较方法: 找到第一对不一样的字符来比较,比如abcdf 和abcde 那么这两组就是比较f和e谁大谁小,因为这两个字母前的字母都一样

逻辑运算符

and 与 or 或 not 非 取相反数

and和or左右两边连接的一般都是布尔表达式

and(一真则真) 左右两边都为True 结果为True 只要有一个为False 结果就是False

or(一假则假) 左右两边都为False 结果才是False 只要有一个为True 那么最终结果就是True

短路效果 :and 第一个为false 后面的就不看了

​ or 第一个为true 后面的就不看了

and一假则假:做取值运算时，取第一个为False的值，如果所有的值都为True,取最后一个值(不是布尔值就取第二个表达式的值)。

​ 1 and 0 and 2–>结果是0; 1 and 2 and 3–>结果是3

or一真则真:做取值运算时，取第一个为True的值，如果所有的值都为False,取最后一个值。

​ 何为取值运算 1 or 0 or 2–>结果是1 ; 0 or None or () or ‘’ or {} -->结果是{}

not 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

​ not(a and b) 返回 False

在python中，只有空字符串’’,""，数字0,空字典{},空列表[],空元组(),和空数据None会被转换成为False,其他的都会被转换成为True,就是说空的和数字0才会被转化为false

位运算符

a = 0011 1100  # 60的二进制 a=60
b = 0000 1101  # 13的二进制  b=13

这么比较:

1. 0 0 1 1 1 1 0 0 =a
2. 0 0 0 0 1 1 0 1 =b 竖排一个个0 1 去比较​

& 与(一假则假)

先找到运算符左右两边的数据的二进制形式, 然后开始&运算, 两个数字对应的位数, 都为1, 结果为1, 有一个为0, 结果就是0

a&b = 0000 1100  #与运算,一假则假

| 或(一真则真)

先找到运算符左右两边的数据的二进制形式, 然后开始|运算, 两个数字对应的位数 , 只要有一个为1 , 结果为1

如果两个都为0 结果才为0

a|b = 0011 1101 #或运算,一真则真

^ 异或(不同则真)

先找到运算符左右两边的数据的二进制形式, 然后开始^运算 , 两个数字对应的位数 相同为0 不同为1

a^b = 0011 0001  #异或运算, 不同则真 #49

~取反

按位取反 相当于-x-1

a = 0011 1100  # 60的二进制  a=60
b = 0000 1101  # 13的二进制  b=13
~a  = 1100 0011  #-61
~b =                        #-13

>>右移动

print(8>>2) --> 得2

当高位为1的时候 右移以后 补1 当高位为0的时候 右移补0

比如十进制8.二进制为0000 1000 ,右移动一位 ,就变成了0 0000 100 =4 ,在移动一位就变成了00 0000 10=2

print(-9>>2) -->得 -3

比如十进制-9,二进制为1000 1001,但是电脑的所有运算都是补码运算,所以先找-9的补码,

​ -9的源码为1000 1001, 反码为1111 0110,补码为1111 0111,补码右移动一位 ,就变成了1 1111 011在移动一位就变成了

​ 11 1111 01, 这是补码,先变成反码11 1111 00 ,在变成源码10 0000 11=-3

注意:右移容易出现精度丢失现象

比如9, 源码为0000 1001,直接右移一位变 0 0000 100 =4

比如11, 源码为0000 1011,直接右移一位变0 0000 101=5 他们连个都丢失了精确度,所以要注意

总结:右移就是除二,同时向下取整

<<左移动

每左移一位相当于乘以2 目前来看 没有尽头

比如9, 源码为0000 1001, 左移一位变 000 1001 0=18 ,在左移一位变000 1001 00=36

比如8, 源码为0000 1000,左移一位变000 1000 0=16,在左移一位变00 1000 00=32

因为python空间很大,所以负号不会消失,会一直存在

总结:左移就是乘2

运算符的优先级

1. ()

2. **

3. ~ + -

4. / * // %

5. 加法减法

6. << >>

7. &

8. ^

9. <= < > >=

10. != <> ==

11. = %= /= //= -= += *= **=

12. is is not

13. in not in

14. not>and>or

​