枣庄公众号代运营公司

发表日期： 2022-08-19 17:04:52 浏览次数：38

枣庄公众号代运营公司

网站建设.png

下测试情况会在交互模式下出现，脚本模式 is 和 == 结果是一样的。
python中会为每个出现的对象分配内存，哪怕他们的值完全相等（注意是相等不是相同）。如执行a=2.0，b=2.0这两个语句时会先后为2.0这个Float类型对象分配内存，然后将a与b分别指向这两个对象。所以a与b指向的不是同一对象：
```
>>> a=2.0>>> b=2.0>>> a is bFalse>>> a==bTrue>>> e
```
但是为了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，python采取重用对象内存的办法，如指向a=2，b=2时，由于2作为简单的int类型且数值小，python不会两次为其分配内存，而是只分配一次，然后将a与b同时指向已分配的对象：
```
>>> a=2>>> b=2>>> a is bTrue>>> a==bTrue
```
如但果赋值的不是2而是大的数值，情况就跟前面的一样了：
```
>>> a=4444>>> b=4444>>> a is bFalse>>> a==bTrue
```
CosmosHua
CosmosHua
cos***cosmos@163.com
5年前 (2017-06-23)
   Gy_GDUT
  634***603@qq.com
55
这里 is 和 == 类似编译原理中传值与传地址。又或者说是 is 只是传递的指针，判断是否指向同一个地址块，这样 is 两边的参数指向内存中同个地址块，毕竟我家电视跟你电视不是同一个东西。而 == 则是仅仅判断值相同
Gy_GDUT
   Gy_GDUT
  634***603@qq.com
5年前 (2017-07-06)

130

如果变量写在同一行,将会指向同一个对象

>>> a=4444; b=4444;   # 写在同一行>>> a is bTrue>>> a == bTrue>>> c = 5555   # 写在不同一行>>> d = 5555   # 写在不同一行>>> c is dFalse>>> c == dTrue>>>

以上情况在交互模式会出现，使用脚本运行，不管是否同一行，都是指向同一个地址：

# -*- coding: utf-8 -*-a = 4444; b = 4444print(a is b)          # truec = 5555d = 5555print(c is d)          # true

gjxie5年前 (2017-07-13)

   冯姜澎
  101***9418@qq.com
   参考地址
64
Python 中没有 ++ 或 -- 自运算符
因为在 Python 里的数值和字符串之类的都是不可变对象，对不可变对象操作的结果都会生成一个新的对象。
比如：
```
a = 1a += 1
```
在 C/java 之类的语言中，把 a 指向内存地址单元数据值由 1 改成了 2。
但是在 Python 中是完全不同的另一套机制。
解释器创建一个新的整数对象 2。
然后把这个对象的地址再次分配给 a。
见下面代码:
```
>>> id(1)41116008L>>> a = 1>>> id(a)41116008L>>> id(2)41115984L>>>a += 1>>> id(a)41115984L>>>
```
所以在 Python 中不可能出现C/java 之类那种单独一行一个 i++，i-- 的。
冯姜澎
   冯姜澎
  101***9418@qq.com
   参考地址
5年前 (2018-02-28)
广工陈不亮
113***2936@qq.com
85
Python 基础的发现个问题，有一个列表 a=[1,2,3,4,5]，赋值给 b 的两种方式：
```
# 第一种b=a 

# 第一种b=a[:]
```
结果都是: [1, 2, 3, 4, 5]
这两种赋值结果看起来都是一样的，但是他们有什么区别么？
区别就是:
Python 有个叫做 id 的函数能够得到对象的地址，你打印出来看看就清楚了。直接 = 是引用赋值，引用原来的对象；而 [:] 是重新推导，会生成新的对象。
```
>>> a=[1,2,3,4,5]>>> b=a>>> c=a[:]>>> id(a)4410359536>>> id(b)4410359536>>> id(c)4410358240
```
从以上结果上看 id(a) 与 id(b) 的内存地址一样的，而 i

前者传递引用
后者是拷贝

所以在 Python 中不可能出现C/java 之类那种单独一行一个 i++，i-- 的。

冯姜澎

101***9418@qq.com

参考地址

5年前 (2018-02-28)

广工陈不亮

113***2936@qq.com

Python 基础的发现个问题，有一个列表 a=[1,2,3,4,5]，赋值给 b 的两种方式：

# 第一种

b=a

# 第一种

b=a[:]

结果都是: [1, 2, 3, 4, 5]

这两种赋值结果看起来都是一样的，但是他们有什么区别么？

区别就是:

前者传递引用

后者是拷贝

Python 有个叫做 id 的函数能够得到对象的地址，你打印出来看看就清楚了。直接 = 是引用赋值，引用原来的对象；而 [:] 是重新推导，会生成新的对象。

>>> a=[1,2,3,4,5]

>>> b=a

>>> c=a[:]

>>> id(a)

4410359536

>>> id(b)

4410359536

>>> id(c)

4410358240

从以上结果上看 id(a) 与 id(b) 的内存地址一样的，而 id(a) 与 id(c) 内存地址不一样。

广工陈不亮

113***2936@qq.com

4年前 (2018-07-21)

BNG

459***40967@qq.com

自上而下，优先级逐步提高。

运算符描述

lambda Lambda 表达式（优先级最低）

or 布尔“或”

and 布尔“与”

not x 布尔“非”

in，not in 成员测试

is，is not 同一性测试

<，<=，>，>=，!=，== 比较

| 按位或

^ 按位异或

& 按位与

<<，>> 移位

+，- 加法与减法

*，/，% 乘法、除法与取余

+x，-x 正负号

~x 按位翻转

** 指数

x.attribute 属性参考

x[index] 下标

x[index:index] 寻址段

f(arguments...) 函数调用

(experession,...) 绑定或元组显示

[expression,...] 列表显示

{key:datum,...} 字典显示

'expression,...'（优先级最高）字符串转换

BNG

459***40967@qq.com

4年前 (2018-07-23)

jun***hu1995@163.com

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

a is b 相当于 id(a)==id(b)，id() 能够获取对象的内存地址。

如果 a=10;b=a; 则此时 a 和 b 的内存地址一样的;

但当 a=[1,2,3]; 另 b=a[:] 时，虽然 a 和 b 的值一样，但内存地址不一样。

如果此时定义 a=10、b=10, 然后再对比 a is b 会发现返回的结果是 True，这是因为在 Python 中会实现创建一个小型的整形池，范围为 [-5,256]，为这些整形开辟好内存空间，当代码中定义该范围内的整形时，不会再重新分配内存地址。而我在 Pycharm 中进行测试：

#coding=utf-8

a=100000000000;

b=100000000000;

print a is b

结果：

True

后来查了资料才发现是：Python出于对性能的考虑，但凡是不可变对象，在同一个代码块中的对象，只有是值相同的对象，就不会重复创建，而是直接引用已经存在的对象。

jun***hu1995@163.com

4年前 (2018-08-02)

Rounie

zha***51282436@sina.com

回复一楼：

验证了一楼的回答，正如其所说，python 中用 is 关键字判断两个小一点数，的确和 == 运算符一样，结果同为 true，但是这个小一点数取值到底小到多少，上限多少，经过测试，当数小于等于 256 时，两者结果相同，大于 256 后，is 判断结果就为 false 了。

本人猜测：256 刚好为 8 为二进制数，是一个字节，所以可以归纳为当数可以用一个字节来表示时，is 和 == 结果相同，当数超过一个字节时，按不同对象来对待，python 为不同数分配了不同内存，不同数为不同的对象，只是值相同而已，is 结果为 false，== 依然为 true。

看了楼上回答，才明白 python 创建了一个小型整型池来存放这些可以用一个字节表示的数，这样做避免了为小点数值重复分配内存，也即重复创建对象，提高了语言运行性能。

枣庄公众号代运营公司

上一页：枣庄企业网站设计 - 枣庄高端网站定制 - 枣庄品牌网站搭建 - 上往建站

下一页：德州淘宝装修/德州京东店铺设计/德州拼多多网店装修公司/德州企业网店开通申请-网店装修设计