python 负数十六进制_Python 训练营--TISI上海团队

天池实验室DSW新手使用手册-天池技术圈-天池技术讨论区​tianchi.aliyun.com

Task 1 第一天：

• 变量，运算符与数据类型

'''多行注释开始
。。。
多行注释结束'''
"""多行注释开始
。。。
多行注释结束"""

• 运算符

print(1 + 1)  # 2     加
print(2 - 1)  # 1     减
print(3 * 4)  # 12    乘
print(3 / 4)  # 0.75  除
print(3 // 4)  # 0    整除(地板除)
print(3 % 4)  # 3     取余
print(2 ** 3)  # 8    幂

• 位运算符

print(bin(4))  # 0b100
print(bin(5))  # 0b101
print(bin(~4), ~4)  # -0b101 -5              按位取反
print(bin(4 & 5), 4 & 5)  # 0b100 4          按位与
print(bin(4 | 5), 4 | 5)  # 0b101 5          按位或
print(bin(4 ^ 5), 4 ^ 5)  # 0b1 1            按位异或
print(bin(4 << 2), 4 << 2)  # 0b10000 16     左移
print(bin(4 >> 2), 4 >> 2)  # 0b1 1          右移

• 三元运算符

x, y = 4, 5
small = x if x < y else y
print(small)  # 4

• 其他运算符

操作符	名称	示例
in	存在	'A' in ['A', 'B', 'C']
not in	不存在	'h' not in ['A', 'B', 'C']
is	是	"hello" is "hello"
not is	不是	"hello" is not "hello"

a = "hello"
b = "hello"
print(a is b, a == b)  # True True
print(a is not b, a != b)  # False False

a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False

注意：

is, is not 对比的是两个变量的内存地址
==, != 对比的是两个变量的值
比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

• 运算符优先级

运算符	           描述
**	           指数（最高优先级）
~+-	           按位翻转，一元加号和减号
* / % //	   乘，除，取模和取整除）
+ -	           加法减法
>> <<	           右移，左移运算符
&	           位‘AND’
^|	           位运算符
<=<>>=	           比较运算符
<>==!=	           等于运算符
=%=/=//=-=+==*=	   赋值运算符
is is not	   身份运算符
in not in	   成员运算符
not and or	   逻辑运算符

变量和赋值

在使用变量之前，需要对其先赋值。
变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
Python 变量名是大小写敏感的，foo != Foo。

set_1 = {
      "欢迎", "学习","Python"}
print(set_1.pop())

b = dir(int)
print(b)

# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__',
# '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__',
# '__float__', '__floor__', '__floordiv__', '__format__', '__ge__',
# '__getattribute__', '__getnewargs__', '__gt__', '__hash__',
# '__index__', '__init__', '__init_subclass__', '__int__', '__invert__',
# '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__',
# '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__',
# '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__',
# '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
# '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
# '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
# '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__',
# 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
# 'numerator', 'real', 'to_bytes']


有时候我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。

import decimal
from decimal import Decimal

a = decimal.getcontext()
print(a)

# Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
# capitals=1, clamp=0, flags=[], 
# traps=[InvalidOperation, DivisionByZero, Overflow])

decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)

# 0.3333

位运算

• 原码、反码、补码
  • 二进制有三种不同的表示形式：原码、反码和补码，计算机内部使用补码来表示。
  • 符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。

整数	原码	反码	补码	规律
3	00 00 00 11	00 00 00 11	00 00 00 11	正数始终不变
-3	10 00 00 11	11 11 11 00	11 11 11 01	负数，符号位为1，反码符号位不变其他位取反，补码及反码加1

• 按位运算
  • 按位非操作 ~ 记忆方法是~(A) = -(A+1)

按位非运算符 - Tinypan - 博客园​www.cnblogs.com

• 按位与操作 & 记忆方法 只有两个对应位都为 1 时才为 1

00 00 01 01 -> 5
&
00 00 01 10 -> 6
---
00 00 01 00 -> 4

• 按位或操作 | 记忆方法 只要两个对应位中有一个 1 时就为 1

00 00 01 01 -> 5
|
00 00 01 10 -> 6
---
00 00 01 11 -> 7

• 按位异或操作 ^ 记忆方法 只有两个对应位不同时才为 1
  • 异或操作的性质：满足交换律和结合律

00 00 01 01 -> 5
^
00 00 01 10 -> 6
---
00 00 00 11 -> 3

• 按位左移操作 << num << i将num的二进制表示向左移动i位所得的值。
• 按位右移操作 >> num >> i 将num的二进制表示向右移动i位所得的值。

利用位运算实现快速计算

• 通过<<，>>快速计算2的倍数问题。

n << 1 ->      计算 n*2
n >> 1 ->      计算 n/2，负奇数的运算不可用
n << m ->      计算 n*(2^m)，即乘以 2 的 m 次方
n >> m ->      计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n  计算2的n次方

• 通过^快速交换两个整数

a ^= b
b ^= a
a ^= b

• 通过a & (-a)快速获取a的最后为 1 位置的整数。

00 00 01 01 -> 5
&
11 11 10 11 -> -5
---
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
---
00 00 00 10 -> 2

利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。

比如集合 `{1, 3, 4, 8}`，可以表示成 `01 00 01 10 10` 而对应的位运算也就可以看作是对集合进行的操作。

元素与集合的操作：

```python
a | (1< 把 i 插入到集合中
a & ~(1< 把 i 从集合中删除
a & (1< 判断 i 是否属于该集合（零不属于，非零属于）
```

集合之间的操作：

```python
a 补   -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)
```

注意：整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。

bin()返回一个整数 int 或者长整数 long int 的二进制表示。

print(bin(3))  # 0b11
print(bin(-3))  # -0b11

print(bin(-3 & 0xffffffff))
# 0b11111111111111111111111111111101

print(bin(0xfffffffd))    
# 0b11111111111111111111111111111101

print(0xfffffffd)  # 4294967293

• Python中bin一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号，巨坑。
• Python中的整型是补码形式存储的。
• Python中整型是不限制长度的不会超范围溢出。

所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff进行按位与操作，再交给bin()进行输出，得到的才是负数的补码表示。

assert 关键词

my_list = ['lsgogroup']
my_list.pop(0)
assert len(my_list) > 0

# AssertionError

for 循环

dic = {
      'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep=':', end=' ')
    
# a:1 b:2 c:3 d:4 

for else

for num in range(10, 20):  # 迭代 10 到 20 之间的数字
    for i in range(2, num):  # 根据因子迭代
        if num % i == 0:  # 确定第一个因子
            j = num / i  # 计算第二个因子
            print('%d 等于 %d * %d' % (num, i, j))
            break  # 跳出当前循环
    else:  # 循环的 else 部分
        print(num, '是一个质数')

# 10 等于 2 * 5
# 11 是一个质数
# 12 等于 2 * 6
# 13 是一个质数
# 14 等于 2 * 7
# 15 等于 3 * 5
# 16 等于 2 * 8
# 17 是一个质数
# 18 等于 2 * 9
# 19 是一个质数

推导式

列表推导式

x = [-4, -2, 0, 2, 4]
y = [a * 2 for a in x]
print(y)
# [-8, -4, 0, 4, 8]

x = [i ** 2 for i in range(1, 10)]
print(x)
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

x = [(i, i ** 2) for i in range(6)]
print(x)

# [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

元组推导式

a = (x for x in range(10))
print(a)

#  at 0x0000025BE511CC48>

print(tuple(a))

# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

字典推导式

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

集合推导式

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

异常处理

BaseException：所有异常的 基类
Exception：常规异常的 基类
StandardError：所有的内建标准异常的基类
ArithmeticError：所有数值计算异常的基类
FloatingPointError：浮点计算异常
OverflowError：数值运算超出最大限制
ZeroDivisionError：除数为零
AssertionError：断言语句（assert）失败
AttributeError：尝试访问未知的对象属性
EOFError：没有内建输入，到达EOF标记
EnvironmentError：操作系统异常的基类
IOError：输入/输出操作失败
OSError：操作系统产生的异常（例如打开一个不存在的文件）
WindowsError：系统调用失败
ImportError：导入模块失败的时候
KeyboardInterrupt：用户中断执行
LookupError：无效数据查询的基类
IndexError：索引超出序列的范围
KeyError：字典中查找一个不存在的关键字
MemoryError：内存溢出（可通过删除对象释放内存）
NameError：尝试访问一个不存在的变量
UnboundLocalError：访问未初始化的本地变量
ReferenceError：弱引用试图访问已经垃圾回收了的对象
RuntimeError：一般的运行时异常
NotImplementedError：尚未实现的方法
SyntaxError：语法错误导致的异常
IndentationError：缩进错误导致的异常
TabError：Tab和空格混用
SystemError：一般的解释器系统异常
TypeError：不同类型间的无效操作
ValueError：传入无效的参数
UnicodeError：Unicode相关的异常
UnicodeDecodeError：Unicode解码时的异常
UnicodeEncodeError：Unicode编码错误导致的异常
UnicodeTranslateError：Unicode转换错误导致的异常

Python 异常类型

raise语句

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    
# An exception flew by!