一开始输入了

a = 00111100

这么个赋值语句被提示了错误，于是去搜了下相关的博客得知 python 中数字有以下的表示方式：

2 进制是以 0b 开头的: 例如: 0b11 则表示十进制的 3

8 进制是以 0o 开头的: 例如: 0o11 则表示十进制的 9

16 进制是以 0x 开头的: 例如: 0x11 则表示十进制的 17

但是在测试的时候又遇到了个问题，那就是输出来的被自动转化成了十进制：

>>> a=0b111100
>>> a
60

于是又去找了怎么输出二进制，得到了以下内容：

分别使用 bin，oct，hex 可输出数字的二进制，八进制，十六进制形式，例如：

>>> a=0b111100
>>> a=60
>>> bin(a)
'0b111100'
>>> oct(a)
'0o74'
>>> hex(a)
'0x3c'

疑问解决!

纠正一下楼上的一些观点

楼上的同学所说的在脚本式编程环境中没有问题。但是在交互式环境中，编译器会有一个小整数池的概念，会把（-5，256）间的数预先创建好，而当a和b超过这个范围的时候，两个变量就会指向不同的对象了，因此地址也会不一样，比如下例：

>>> a=1000
>>> b=1000
>>> id(a);id(b)
2236612366224
2236617350384
>>>

is 和 ==

is 判断两个变量是否是引用同一个内存地址。

== 判断两个变量是否相等。

如果不用 a = b 赋值，int 型时，在数值为 -5~256（64位系统）时，两个变量引用的是同一个内存地址，其他的数值就不是同一个内存地址了。

也就是，a b 在 -5~256（64位系统）时：

a = 100
b = 100
a is b # 返回 True

其他类型如列表、元祖、字典让 a、b 分别赋值一样的时：

a is b  # 返回False

关于 is 和 == 的标识问题

（1）只要是变量的值相同，标识都相同，没有-5~256的限制，看下面的例子：

a = 100000
b = 100000
if a is b:
    print('a 和 b 标识相同，标识为：',id(a))
else:
    print('a 和 b 标识不相同,a 标识为：',id(a),'b 标识为：',id(b))

输出结果为：

a 和 b 标识相同，标识为： 2158477874512

（2）同样的如果是负数，仍然没有上述限制：

a = -100000
b = -100000
if a is b:
    print('a 和 b 标识相同，标识为：',id(a))
else:
    print('a 和 b 标识不相同,a 标识为：',id(a),'b 标识为：',id(b))

输出结果为：

a 和 b 标识相同，标识为： 2137845175632

（3）列表也是一样的，只要是列表项数值一样，那么标识也是一样的。例子如下：

list1 = [10000,20000,30000]
list2 = [10000,12000,15000]
if list1[0] is list2[0]:
    print('list1[0] 和 list2[0] 标识相同，标识为：',id(list1[0]))
else:
    print('list1[0] 和 list2[0] 标识不相同,list1[0]标识为：',id(list1[0]),'list2[0]标识为：',id(list2[0]))

输出结果为：

list1[0] 和 list2[0] 标识相同，标识为： 1375086286224

（4）元组的标识是跟着变量名的，变量名不一样，标识也不一样，上例子：

tuple1 = (10000,20000,30000)
tuple2 = (10000,12000,15000)
if tuple1[0] is tuple2[0]:
    print('tuple1[0] 和 tuple2[0] 标识相同，标识为：',id(tuple1[0]))
else:
    print('tuple1[0] 和 tuple2[0] 标识不相同,tuple1[0] 标识为：',id(tuple1[0]),'tuple2[0]标识为：',id(tuple2[0]))

输出结果为：

tuple1[0] 和 tuple2[0] 标识不相同,tuple1[0] 标识为： 1375086286384 tuple2[0]标识为： 1375086286480

（5）字典和列表是一样的，只要是列表项数值一样，那么标识也是一样的。例子如下：

dict1 = {1:10000,2:20000,3:30000}
dict2 = {1:10000,2:12000,3:15000}
if dict1[1] is tuple2[1]:
    print('dict1[1] 和 tuple2[1] 标识相同，标识为：',id(dict1[1]))
else:
    print('dict1[1] 和 tuple2[1] 标识不相同,dict1[1] 标识为：',id(dict1[1]),'tuple2[1] 标识为：',id(dict2[1]))

输出结果为：

dict1[1] 和 tuple2[1] 标识不相同,dict1[1] 标识为： 1375086286224 tuple2[1] 标识为： 1375086286224

深刻理解 and、or 逻辑运算符:

print(0 and 1)      # =>0,0等同于False
print(False and 1)  # =>False
print(-1 and 1)     # =>1
print(1 or False)   # =>1,非零等同于True
print(True or False)# =>True
print(-1 or 0)      # =>-1

• and：前面为假（0 或者 False）则表达式为假，否则表达式为后面的值；
• or：前面为真（非 0 或者非 False）则表达式为前面的值，否则表达式为后面的值；

优先级：not>and>or

print(1 and 0 or  not False) #=>True
print( not False or 1 and 0) #=>True
print( 1 or not True and 0)  #=>1

and or not

优先级：

() > not > and > or

1.or

在 Python 中，逻辑运算符 or，x or y， 如果 x 为 True 则返回 x，如果 x 为 False 返回 y 值。因为如果 x 为 True 那么 or 运算就不需要在运算了，因为一个为真则为真，所以返回 x 的值。如果 x 的值为假，那么 or 运算的结果取决于 y，所以返回 y 的值。

print(1 or 2)   # 1
print(3 or 2)   # 3
print(0 or 2)   # 2
print(0 or 100) # 100
print(0 or 0)

2.and

在 Python 中，逻辑运算符 and，x and y，如果 x 为 True 则返回 y 值。如果 x 为 False 则返回 y 值。如果 x 的值为 True，and 的运算不会结束，会继续看 y 的值，所以此时真与假取决于 y 的值，所以 x 如果为真，则返回 y 的值。如果 x 为假，那么 and 运算就会结束运算过程了，因为有一个为假则 and 为假，所以返回 x 的值。

print(1 and 2)  # 2
print(3 and 0)  # 0
print(0 and 2)  # 0
print(3 and 2)  # 2
print(0 and 0)  # 0

3.混合例子与解析

按照从左向由，优先级高的先执行优先级高的规则，首先因为比较运算符优先级高于逻辑运算符，很简单，如果运算符低于了逻辑运算符优先级那还如何运算呢。and 优先级大于 or，not 优先级大于 and 和 or。

not 4 > 5 为 True

1 > 2 为 False

3 < 2 为 False

Flase and 3 为 False，因为False为假所以and不在运算直接返回False

4 and False 为 False，因为 4 为真所以 and 运算符会继续运算后面的，以 False 为主，所以返回 False。

False or False 为 False

False or True 为 True

False or False 为 False，因为 False 为假，所以 or 运算符会继续运算后面的，以 False 为主，所以返回后面的 False 值