python摘抄

在​ython 2.x中

  raw_print() 可以直接读取控制台的任何类型输入，并且只会读入您输入的任何内容， 返回字符串类型 。即可用把控制台所有输入作为字符串看待，并返回字符串类型。

  input() 能够读取一个合法的 python 表达式， 返回数值类型 ，如int，float。即如果你在控制台输入的字符串必须用单引号或双引号将它括起来，否则会引发 SyntaxError 。

+=和=+的赋值意义:

1，python的赋值会产生一个新对象 

2，执行’=+'操作时会产生一个新对象 

3，执行’+='操作时，对于可变对象，例如列表，其会对原对象进行本地修改值，不会产生新对象，而对于不可变对象，则会还是会产生新的对象。

’=+'就是a=a+1这类的操作 

’+='就是a+=1这类的操作 

是不是看起来一样？其实有点区别 

先看一个例子：

def add(p):

    print '进来时，p的id是',id(p)

    p+=[1]

    print 'p执行p+=[1]运算后的值为：',p

    print '加法后p的id是：',id(p)

a=[1,3,3,3]

print 'a进入函数前的id是：',id(a)

add(a)

print 'a进入函数后的值是：',a

print 'a进入函数后的id是：',id(a)

1def add(p):

    print '进来时，p的id是',id(p)

    p+=[1]

    print 'p执行p+=[1]运算后的值为：',p

    print '加法后p的id是：',id(p)

a=[1,3,3,3]

print 'a进入函数前的id是：',id(a)

add(a)

print 'a进入函数后的值是：',a

print 'a进入函数后的id是：',id(a)

猜猜a进入函数后，其的值是多少？ 

附上结果：

a进入函数前的id是： 116958664

进来时，p的id是 116958664

p执行p=p+[1]运算后的值为： [1, 3, 3, 3, 1]

加法后p的id是： 116958664

a进入函数后的值是： [1, 3, 3, 3, 1]

a进入函数后的id是： 116958664

1

2

3

4

5

6

发现a的值是变了的，因为列表是可变对象，’+='操作是直接在a所指向的对象上进行修改，并没有产生新的引用。 

再看下面的例子：

def add(p):

    print '进来时，p的id是',id(p)

    p=p+[1]

    print 'p执行p=p+[1]运算后的值为：',p

    print '加法后p的id是：',id(p)

a=[1,3,3,3]

print 'a进入函数前的id是：',id(a)

add(a)

print 'a进入函数后的值是：',a

print 'a进入函数后的id是：',id(a)

1

2

3

4

5

6

7

8

9

10

得出结果为：

a进入函数前的id是： 186860104

进来时，p的id是 186860104

p执行p=p+[1]运算后的值为： [1, 3, 3, 3, 1]

加法后p的id是： 116958664

a进入函数后的值是： [1, 3, 3, 3]

a进入函数后的id是： 186860104

1

2

3

4

5

6

发现a的值并没有变，这是因为在执行p=p+[1]时，有一个赋值动作’='，会产生一个新的对象，所以p这时已经指向了别的对象，这也说明了python没有赋值，它的赋值是产生一个新的对象。 

正如：

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

>>> b=[1,2,3]

>>> id(a),id(b)

(45735624L, 45791816L)

>>> a=a+[2]

>>> id(a)

45793224L

1

2

3

4

5

6

7

a,b都是将[1,2,3]付给a,b，但是他们分别产生了新的对象（id不同）。 

但是也有这样的情况：

>>> a=3

>>> b=3

>>> strA='asd'

>>> strB='asd'

>>> id(a),id(b)

(38102392L, 38102392L)

>>> id(strA),id(strB)

(45829736L, 45829736L)

1

2

3

4

5

6

7

8

发现他们的id一样是不是，那是因为python对一些整型数字和字符串会进行缓存，使得他们id一样，造成了他们没有创建新对象的假象。

继续刚才’=+'与’+='的话题，一开始我们是使用的列表，如果现在我使用元组呢： 

观察结果： 

’=+'：

def add(p):

    print '进来时，p的id是',id(p)

    p=p+(1,)

    print 'p执行p=p+(1,)运算后的值为：',p

    print '加法后p的id是：',id(p)

a=(1,3,3)

print 'a进入函数前的id是：',id(a)

add(a)

print 'a进入函数后的值是：',a

print 'a进入函数后的id是：',id(a)

1

2

3

4

5

6

7

8

9

10

结果为：

a进入函数前的id是： 186690296

进来时，p的id是 186690296

p执行p=p=p+(1,)运算后的值为： (1, 3, 3, 1)

加法后p的id是： 185401496

a进入函数后的值是： (1, 3, 3)

a进入函数后的id是： 186690296

1

2

3

4

5

6

发现a一样没有发生改变，和a是list的情况一样。 

再看’+='：

def add(p):

    print '进来时，p的id是',id(p)

    p+=(1,)

    print 'p执行p+=(1,)运算后的值为：',p

    print '加法后p的id是：',id(p)

a=(1,3,3)

print 'a进入函数前的id是：',id(a)

add(a)

print 'a进入函数后的值是：',a

print 'a进入函数后的id是：',id(a)

1

2

3

4

5

6

7

8

9

10

结果为：

a进入函数前的id是： 186690656

进来时，p的id是 186690656

p执行p+=(1,)运算后的值为： (1, 3, 3, 1)

加法后p的id是： 185401496

a进入函数后的值是： (1, 3, 3)

a进入函数后的id是： 186690656

1

2

3

4

5

6

欸，怎么a为元组和a为列表的情况不一样，现在a没有发生变化。那是因为元组是不可变对象，在执行p+=(1,)时，无法对p之前指向的对象进行本地操作，只能创建一个新对象了。 

同样的，字符串等不可变对象也是会产生一个新对象： 

如：

>>> a="sd"

>>> id(a)

45643056L

>>> a+='***'

>>> id(a)

45829016L

(内容同上)列表引用

首先看2个示例：

  def add_list(p):

      p = p + [1]

  p1 = [1,2,3]

  add_list(p1)

  print p1

  >>> [1, 2, 3]

  

  def add_list(p):

      p += [1]

 p2 = [1,2,3]

 proc2(p2)

 print p2

 >>>[1, 2, 3, 1]

这主要是由于“=”操作符会新建一个新的变量保存赋值结果，然后再把引用名指向“=”左边，即修改了原来的p引用，使p成为指向新赋值变量的引用。而+=不会，直接修改了原来p引用的内容，事实上+=和=在python内部使用了不同的实现函数。