名字、对象、值、类型、引用

 

彩蛋

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.                                         # 美丽胜于丑陋
Explicit is better than implicit.                                      # 明确胜于晦涩
Simple is better than complex.                                         # 简单胜于复杂
Complex is better than complicated.                                    # 复杂胜于更复杂
Flat is better than nested.                                            # 扁平比嵌套好
Sparse is better than dense.                                           # 分开比密集好                           
Readability counts.                                                    # 代码可读性很重要
Special cases aren't special enough to break the rules.                # 即使情况特殊也不要打破规则
Although practicality beats purity.                                    # 虽然实用性胜于纯粹性
Errors should never pass silently.                                     # 错误也不能被忽略( 要精准的捕获异常 )
Unless explicitly silenced.                                            # 除非明确忽视
In the face of ambiguity, refuse the temptation to guess.              # 当存在多种可能性，不要去猜( 要去试 )
There should be one-- and preferably only one --obvious way to do it.  # 应该用一种最好的解决问题的方法
Although that way may not be obvious at first unless you're Dutch.     # 虽然并不容易, 因为你不是python之父
Now is better than never.                                              # 做好过不做
Although never is often better than *right* now.                       # 但不加思索就动手还不如不做 (做之前想清楚)
If the implementation is hard to explain, it's a bad idea.             # 如果代码很难理解, 不是好方法
If the implementation is easy to explain, it may be a good idea.       # 如果代码很容易理解，也许是个好方法
Namespaces are one honking great idea -- let's do more of those!       # 命名空间是非常好的理念，应该多加利用

名字、对象、引用

变量，随时变化的量, 用来存放和引用内存中的对象. 

规则:

• 变量名 = 对象   【先有对象才能有变量】
• 变量名可以是大小写字母、数字或下划线组成且第一个不能为数字
• 重新赋值会指向新的对象

要点:

• 一切皆对象, 对象是一种数据结构，它有属性和方法
• 赋值的过程实际上是建立名字 (name) 到对象 (objcet) 的引用关系, 变量指向这个对象
• 每个对象都有id标识 (内存地址)、类型(type), 值
• 变量本身没有类型，取决于对象的类型

>>> a = 3    # 将对象3赋给变量name
>>> a        # 引用对象
3

对于a=3 过程是：

• 先在内存中创建对象3, 然后创建变量a，将其关联。
• 将对象3赋给变量a, 那么a指向这个对象3，它们建立引用关系, 像是指针。用大白话说就是給对象3贴了一个'a'的标签, 如果重新赋值则相当于把标签a贴到了其它的对象

每个对象都有id、类型和值

>>> id(a)       # 通过id函数查看对象的内存地址
38973736
>>> 
>>> type(a)     # 通过type函数查看对象的类型, 可以看到对象的类型是int整型
<type 'int'>

1、对象的共享引用 (复用)

共享引用(复用)，一个对象可以被多个变量引用, 它们引用同一个内存地址

>>> a = 3   #1
>>> b = a   #2
>>> a = 4   #3
>>> b
3

#1, a=3 对象3赋值给变量a

#2, b=a 将a的引用赋给变量b, 即b指向a的引用, 也就是对象3

#3, a=4 将变量a重新赋值, 指向对象4

所以a重新指向对象4，但b没有变化，所以b还是3

2、对象引用计数

根据对象的引用次数来进行垃圾回收，如果一个对象在一定时间内引用次数为0则进行回收

>>> x = 10     # 将对象10赋给x，那么对象10的引用次数加1
>>> y = 10     # 将对象10赋给y，那么对象10的引用次数加1
>>> x = 20     # x指向了新的对象20, 那么对象20这个引用次数加1, 对象10引用次数减1

那么对于x = 100; x = 200那么对象100会立即回收吗？ 根据引用次数决定，如果对象的引用次数为0就会被回收

>>> x = 100
>>> x = 200

不过也没什么，python会自动管理内存

3、赋值方式

基本赋值、序列赋值、链式赋值、增强型赋值

基本赋值:

>>> a = 1
>>> b = 'abc'
# 也可以写成
>>> a=1;b='abc'

链式赋值:

• 多个变量指向同一个对象, 说明一个对象可以被多个变量所引用

>>> a = b = c = 100   # a,b,c都引用对象100, 多变量指向并引用同一个对象
>>> a
100
>>> a is b is c       # 通过is查看对象是不是引用同一个地址
True
# 等价于
>>> c = 100
>>> b = c
>>> a = b
>>> a is b is c
True

序列赋值:

• 序列赋值通过位置对应，也叫序列解包(unpack)。只要是iterable的对象都可以解包

>>> li = [1,2,3]
>>> a,b,c = li    # 解包, 通过位置对应
>>> a,b,c
(1, 2, 3)
>>> a,_,c = li    # 使用'_'作为占位符, 只取想要的对象
>>> a,c
(1, 3)
>>> s = 'hyz'
>>> a,b,c = s
>>> a
'h'
>>> b
'y'
>>> c
'z'

• python3还支持*args, 收集多个对象, 它是个list

>>> a, b, c, d, e = [400, 200, 300, 100, 500]
>>> a, b, c, *args = [400, 200, 300, 100, 500]
>>> args   # 得到一个list
[100, 500]

增强型赋值:

a = 10
a += 1        
a -= 1        
a *= 2        

交换位置:

>>> a,b = 1,2
>>> a,b
(1, 2)
>>> a,b = b,a   # 交换位置，不用中间值
>>> a,b
(2, 1)

三、赋值与命名空间

一个简单的赋值语句就是对当前名字空间中的名字与对象进行绑定，它是个dict,  变量名作为key，对象作为value，python会从命名空间里面搜索对象，通过globals()函数查看

总结

• 一切皆为对象, 对象是一种数据结构，它有属性和方法.
• 变量名理解为对象的别名
• 赋值是建立变量名到对象的引用关系, 变量指向对象，如重新赋值将指向新的对象.
• 变量本身没有类型，取决于对象的类型
• 一个对象有id、类型、值
• 注意对象的共享引用，一个对象可以被多个变量所引用
• 多种赋值方式，注意解包的使用
• 了解对象的引用计数
• 命名空间的概念