针对@小恶魔的问题，回复一下

python里面一切皆对象， 比如a=1。在java里面是int a = 1，相当于先声明了一个int类型的变量a，然后给这个变量赋值为1。但在python中，是先在内存中申请一份空间，存的值为1，然后再给这块空间贴上一个标签，叫变量a，因此python中变量实际上是一个便利贴，可以贴在任何地方。并且还可以通过值来推断出变量的类型，这一步是由解释器来完成的。所以python虽然不需要显式声明变量，但它其实是强类型语言。
def func(d):
    d['a'] = 10
    d['b'] = 20
    d = {'a': 1, 'b': 2}


d = {}
func(d)
print(d) # {'a': 10, 'b': 20}

至于这里为什么会是这个结果，当我们将d传递给func的时候，其实func里面的d和外面的d指向的是同一片内存。相当于一开始d={},存放{}这份空间只有d这一个便利贴，但是func(d)的时候，这份空间又多了一个便利贴。尽管都叫d，但一个是全局变量d，一个是函数的参数d
当d['a'] = 10和d['b']=20的时候，由于字典是可变类型，所以外面的d也被修改了，此时外面的d和函数里面的d都指向了{'a': 10, 'b': 20}, 但是当d = {'a': 1, 'b': 2}的时候，这是属于赋值。因此python会在内存中再开辟一份空间，空间存放{'a': 1, 'b': 2}，然后让函数里面的局部变量d指向它，相当于将原本位于{'a':10,'b':20}上的便利贴撕下来，贴在了另一块空间。但这只是函数里面的d，对外面的d是没有影响的，所以外面的d依旧是{'a': 10, 'b': 20}。

首先更正下，需要先定义d={}。
然后，局部变量与全局变量的区别，函数内定义的d为全局变量，在没有关键字声明的情形下不能改变全局变量，由于字典可变，遵循可变则可变的原则，输出为{'a': 10, 'b': 20}。
最后，看实验：
def func(d):
    print(id(d))
    d['a'] = 10
    d['b'] = 20
    print(id(d))
    d = {'a':1, 'b':2}
    print(id(d))
    print(d)

d = {}
print(id(d))
func(d)
print(d)
print(id(d))

执行结果：
3072243980
3072243980
3072243980
3072244108
{'a': 1, 'b': 2}
{'a': 10, 'b': 20}
3072243980

第一题，用id（）打印出来后可以证明，l1和l2不是同一个对象，l2和l3是同一个对象。由于列表是可变的，所以l1和l2指向不同的内存区域。
第二题，做了一下修改，如下：
def func(d):
    d['a'] = 10
    d['b'] = 20
    d={'a':1,'b':2}

d={}
func(d)
print(d)

执行结果：
{'a': 10, 'b': 20}

d = {'a': 1, 'b': 2}应该是指向了新的对象

# C++

- 按值传递：拷贝参数的值构建新的变量传递到函数
- 按引用传递：把参数的引用（i.e. 地址）传递到函数

# Python

- 按赋值传递/按对象的引用传递
- 凡是对对象本身进行的操作，都会影响传递的原对象；凡是生成了新对象的操作，都不会影响传递的原对象
- 正如【一个人可以死两次，第一次是肉体死去，第二次是当没人记得它的时候】，python 中如果有多个变量指向同一个对象，那么当删除一个变量时并不会真正删除其所指定的对象；只有当所有指定该对象的变量都被删除时，python 才会回收该对象所占用的资源
- 一般原则：对于不可变的数据类型，operator 等操作会返回新的对象，不会影响原对象；对于可变的数据类型，任何对【对象本身】的操作都会影响所有指向该对象的变量
- 补充上一条：e.g. 对于 list 而言，l += [1] 和 l = l + [1] 不同！前者是在 l 本身的末尾添加新元素，后者是在 l 的基础上添加新的元素并返回新的对象
- 在工程上，偏爱类似于上一条后者的作法——即通过【创建新的对象+将其返回】的作法，来减少出错的概率

# 思考题

1. l1 与 l2 不同，l3 与 l2 同；
2. 严格来说，如果没有上下文，这是一段错误的代码，因为没有预先定义 d 变量；不妨假设在第 6 行之前补充语句 d = {}，则输出结果为 {'a': 10, 'b': 20}，因为 func 中前两行才是改变了对象的操作。而第 3 行只是将函数中的局部变量 d 指向了新的字典 {'a': 1, 'b': 2}，但全局变量 d 仍然指向着刚刚被修改过的字典对象。

def my_func2(b):
    print('a的值是{}'.format(a))
    print('b的值是{}'.format(a))
    b = 2
    print('b的值是{}'.format(b))
    return b


a = 1
a = my_func2(a) #这句话so 重要，重新用返回值对于a进行了赋值，看起来debug来逐步分析很重要啊
print('a的值是{}'.format(a))

遇到了下面一个问题

```
def demo1(array):
    array += [4, 5]
    return array


def demo2(array):
    array = array + [4, 5]
    return array


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

c = demo1(a)
print('a list is {}\nc list is {}\na is c :{}'.format(a, c, a is c)) # True
# 输出结果
a list is [1, 2, 3, 4, 5]
c list is [1, 2, 3, 4, 5]
a is c :True

d = demo2(b)
print('b list is {}\nd list is {}\nb is d :{}'.format(b, d, b is d)) # False
# 输出结果
b list is [1, 2, 3]
d list is [1, 2, 3, 4, 5]
b is d :False

# 函数内部为什么 array += [4, 5] 与 array = array + [4, 5] 对传入的列表影响结果不同
```

总结:Python中参数传递既不是传值也不是传引用，而是赋值传递，或传对象的引用。不是指向一个具体的内存地址，而是指向具体的对象。
如果对象是不变的，改变对象会新建一个对象，并将其中一个变量指向该对象，其它变量不变。如果对象是可变的，改变一个变量时，其它所有指向该对象的变量都会受影响。要想在函数中改变对象，可以传入可变数据类型(列表，字典，集合)，直接改变；也可以创建一个新对象，修改以后返回。建议用后者，表达清晰明了，不易出错。
思考题1:
l2与l3指向同一对象，与l1不同。
# 思考题1
 l1 = [1,2,3,4]
 l2 = [1,2,3,4]
 l3 = l2
 print(id(l1), id(l2), id(l3))
思考题2
{"a":10, "b":20}
课程的练习代码: https://github.com/zwdnet/PythonPractice