1.计算机文件大小单位

b = bit 位（比特） 位代表 0 1

B = Byte字节

1Byte = 8 bit //一个字节等于8位

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

2.进制转换

1. 二进制：有两个数字组成，0（低电平）、1（高电平） 例：0b(二进制标志)101001

   • 二进制转10进制 x*2所在幂位

2. 八进制：0、1、2、3、4、5、6、7 例：0o(八进制标志)15746

   • 八进制转十进制 x*8所在幂位

3. 十进制：0 1 2 3 4 5 6 7 8 9 例： 2121

   • 十进制转二进制 x/2取余数 从底部排序
   • 十进制转八进制 x/8取余数 从底部排序
   • 十进制转十六进制 x/16取余数 从底部排序

4. 十六进制： 0 1 2 3 4 5 6 7 8 9 a b c d e f 例：0x(十六进制标志)ff

   • 十六进制转10进制 x*16所在幂位

5. 原码或补码都是二进制数据

   • 原码：二进制的表现形式
   • 反码：二进制0变1，1变0，【原码】【补码】之间的转换形式（首位符号不去反）
   • 补码：二进制的存储形式
   • 数据用补码形式存储
   • 数据用原码形式显示
   • 原码和补码 可以通过 反码 互相转换，互为取反+1

6. 提出补码的原因

   • 补码的提出表达一个数的正负
   • 计算机默认只能做加法，实现减法用符号：5+（-30）=5-3
   • 乘法除法，是通过左移右移 << >>来实现

7. 原码 形式正负府关系：

   • 原码特点：第一位都是1
   • 0000 000 1 表达数字+1
   • 1000 000 1 表达数字-1

8. 补码 形式的正负关系：

   • 原码特点：高位数都是1
   • 0000 000 1 表达数字+1
   • 1111 111 1 表达数字-1

9. 运算顺序

补码 -> 原码

禁止转换时需要先把内存存储的补码拿出来变成原码进行转换输出

转换规律：

正数： 原码=反码=补码
负数： 原码与反码，互为取反+1
        原码 = 补码取反码+1 给补码求原码
        补码 = 原码取反码+1 给原码求补码

例：5-3=5+（-3）

5

原码：101

反码：101

补码：101

-3

原码：1000…011

反码：1111…100

补码：1111…101

3.数据类型

1. Number 数据类型（int float bool complex）
2. str 字符串类型
3. list 列表类型（有序，读取，修改）
4. tuple 元组类型（有序，获取）
5. set 集合（无序，自动去重）
6. dict 字典（无序，获取，修改）3.6版本后 键值对存取的数据表面上有序，实际上无序

当两个不同类型的数据运算是，默认项更高经度转换

数据类型转换的经度从低到高：bool int float complex

Number部分

• int: 整型 浮点型 布尔 纯数字字符串
• float: 整型 浮点型 布尔 纯数字字符串
• complex: 整型 浮点型 布尔 纯数字字符串(复数)
• bool: 容器类型 /number 都可以 (0 0.0 0j false "" [] () set() {} None )

容器类型部分

• str: 容器类型 /number 都可以

• list: 字符串 列表 元组 集合 字典

• tuple: 字符串 列表 元组 集合 字典

• set: 字符串 列表 元组 集合 字典(相同的值智慧保留一位)

• dict: 使用二级列表，二级元组，二级集合（里边的容器数据只能是元组）（等长的二级容器并且元素数是二个）

  ####哈希算法
  #定义

4 运算符

%取余 //地板除 **幂运算

+ - * / 

//: 返回整数
    numvar = 5//2 => 2
    如果除数或被除数存在小数，那吗结果上加.0
    numvar = 5//2.0 =>2.0
%:  如果除数和被除数符号相同，取余结果加上符号
    如果除数和被除数符号不相同，取余结果与被除数符号相同加上除数
    numvar =  81 % 11 => 4
    numvar = -81 % 11 => -4 + 11 =7
    numvar =  81 % -11 => 4 - 11 = -7
    numvar = -81 % -11 => -4
**: 幂运算

==比较两个值是否相等 !=比较两个值是否不同

> < >= <= == !=


= += -= *= /= //= %= **=
a +=1 => a = a + 1


is 和 is not(监测连个数据在内存中是否为同一个值)
判断内存地址是够相同
str tuple list set dict

整数 -5 至正无穷 内存地址相同
浮点型 非负数
complex 实数+虚数永不相同（只有虚数除外）


and 逻辑与，全真则真 一假则假
or  逻辑或，全假则假 一真则真
not 逻辑非，真变假 假变真

逻辑短路: 如果出现短路效果后面的代码就不执行了
print() 返回值默认是 None
优先级：() > not > and > or


in not in(针对容器型数据)
判断某个值是否包含在一个容器类型数据中

优先级：(<< 或 >>) > & > ^ > |

1. & 按位于：(二进制数据按照逻辑于的定义进行比较)

   var1 = 19
   var2 = 15
   print(var1 & var2)
   19的二进制
   000 … 10011
   15的二进制
   000 … 01111
   1 => true
   0 => false

   000 … 10011 = 19
   000 … 01111 = 15
   000 … 00011 = 3

2. | 按位或：(二进制数据按照逻辑或的定义进行比较)

   var1 = 19
   var2 = 15
   print(var1 | var2)
   19的二进制
   000 … 10011
   15的二进制
   000 … 01111
   1 => true
   0 => false

   000 … 10011 = 19
   000 … 01111 = 15
   000 … 11111 = 31

3. ~ 按位非 针对于补码进行操作，按位取反，包括符号位

公式：-(n+1)

var = ~19 = -20
var = ~(-21) = 20
print(var)

求19的按位非
原码：000...10011
反码：000...10011
补码：000...10011

补码：  000...10011
按位非：111...01100 求出来的是补码
给补码求原码：
补码：111...01100
反码：100...10011
原码：100...10100 = -20

求-21的按位非
原码：100...10101
反码：111...01010
补码: 111...01011

补码:   111...01011
按位非：000...10100

补码：000...10100
反码: 000...10100
原码：000...10100 = 20

1. ^ 按位异或：两者不一样返回真，一样返回假

   var1 = 19
   var2 = 15
   print(var1 | var2)
   19的二进制
   000 … 10011
   15的二进制
   000 … 01111
   1 => true
   0 => false

   000 … 10011 = 19
   000 … 01111 = 15
   000 … 11100 = 28

2. << 左移 用来做乘法操作 x << n = x * 2**n

   res = 5 << 2 = 20
   000…101 = 5
   往左移动两位
   000…10100 = 20

3. 右移 用来做除法操作 x >> n = x / 2**n

   res = 8 << 2 = 2
   000…1000 = 8
   往右移动两位
   000…0010 = 2

   1 个别运算符
   优先级最高的** 幂运算
   优先级最低的= 赋值运算
   ()括号可以提升运算的优先级
   2 整体 一元运算符 > 二元运算符
   一元运算符：同一时间 只操作一个值 - ~
   二元运算符：同一时间 操作两个值 + - * / …
   3 同一层级
   逻辑：() > not > and > or
   算数： 乘除 > 加减
   位运算：(<< >>) > & > ^ >|
   4 其他情况
   算数 > 位 > 比较 > 身份 > 成员 > 逻辑 > 赋值