既然python中的变量存储的都是堆中数据的地址，就类似于指针，所以将变量名赋值给另一个变量就相当于将新的变量指向了同一个内存地址。至于修改值以后两个变量的值如何改变，只需要根据上面数据类型的内存地址变换规律去推就好了。

举几个例子。

不可变对象中的整数

In [17]: a=123                                                                                                                                                               
In [18]: b=a                                                                                                                                                                 
In [19]: id(a)                                                                                                                                                               
Out[19]: 94805275202240
In [20]: id(b)                                                                                                                                                               
Out[20]: 94805275202240
In [21]: b                                                                                                                                                                   
Out[21]: 123
这里变量a和b指向同一个地址，之后修改a的值，根据前面的规律，同一变量修改内容后的内存地址不一样
 
In [22]: a+=1                                                                                                                                                                
In [23]: id(a)                                                                                                                                                               
Out[23]: 94805275202272
In [24]: id(b)                                                                                                                                                               
Out[24]: 94805275202240
所以变量a的值变了，而b得值维持不变
 
In [25]: a                                                                                                                                                                   
Out[25]: 124
In [26]: b                                                                                                                                                                   
Out[26]: 123
可变对象中得列表
 
In [27]: c=[1,2,3]                                                                                                                                                           
In [28]: d=c                                                                                                                                                                 
In [29]: id(c)                                                                                                                                                               
Out[29]: 139780440014600
In [30]: id(d)                                                                                                                                                               
Out[30]: 139780440014600
之后修改c得内容，根据上面得规律，c得地址不会变，还是指向源地址，所以c和d得值都改变了
 
In [31]: c.append(4)                                                                                                                                                         
In [32]: id(c)                                                                                                                                                               
Out[32]: 139780440014600
In [33]: id(d)                                                                                                                                                               
Out[33]: 139780440014600
In [34]: c                                                                                                                                                                   
Out[34]: [1, 2, 3, 4]
In [35]: d                                                                                                                                                                   
Out[35]: [1, 2, 3, 4]
理解了上面得变量名赋值，再来看函数传参就简单了。因为传参都是将栈中得变量内容传递到函数内，相当于传递一个指针到函数内，所以在函数内对变量得操作也分为可变对象和不可变对象两种情况。
 
如果传递的是不可变对象，在函数内得修改只是将变量指向了另一个地址，所以不会影响函数外得变量内容；如果传递得是可变对象，在函数内得修改还是在原地址进行修改，所以还会影响到函数外的变量内容。
 
 
补充：用javascript做为对比，js中的基础变量都是直接将值保存在栈内，所以相当于传值给函数，函数内的操作不会影响函数外的变量值。而js中的复合变量同样也是将值保存在堆内，所以相当于传递指针，函数内的操作也会影响到函数外的变量值
 
总结下知识点
 
 
真实数据都是存储在堆中，栈中的变量都只是存储堆中数据的引用
 
 
不可变对象中的小整数、短字符串和布尔值，只要值相同内存地址就相同。其余类型不管值是否相同内存地址都不同
 
 
可变对象对于单个变量不管值如何变，内存地址都是固定的。但是不同变量，不管值是否相同，内存地址都不同
 
 
传参的时候都是传指针，根据修改内容是否改变内存地址来看看是否会影响到外部变量，不可变对象不影响，可变对象会影响
 
 
做为对比的javascript，基础变量是传值，函数内修改不影响外部变量，复合变量是传指针，函数内修改会影响外部变量
 
 
 
我是T型人小付，一位坚持终身学习的互联网从业者。喜欢我的博客欢迎在csdn上关注我，如果有问题欢迎在底下的评论区交流，谢谢。
 
                    对内存的高效利用一直是程序编写过程中的一个亘古不变的话题，这一节我们就用实际操作来看看python3中各种变量的内存使用区别，以及它们在进行函数传参时候的注意事项。文章目录内存中的堆栈不同数据类型内存使用不可变对象小整数和大整数短字符串和长字符串浮点数元组布尔值可变对象匿名对象变量名赋值给变量函数传参总结内存中的堆栈因为是动态语言，python中的所有变量内容都存在堆（heap）中，而变量名只是堆中内容的引用，存放在栈（stack）中，便于用户去间接操作堆中的数据。这对于后面理解函数参数的传递非常重要
				
python的数据类型有：数字(int)、浮点(float)、字符串(str)，列表(list)、元组(tuple)、字典(dict)、集合(set)
一般通过以下方法进行判断：
1、isinstance(参数1,参数2)
描述：该函数用来判断一个变量（参数1）是否是已知的变量类型(参数2) 类似于type()
参数1：变量
参数2：可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值: 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False
#判断变量类型的函数
def typeof(variate):
  type=None
				
本文实例讲述了Python3中函数参数传递方式。分享给大家供大家参考，具体如下：
之前在看北理工嵩天等老师的python3的课程，在第五周中老师讲到了函数的调用传递。老师讲了这样一个例子
#处理多个银行账户的余额信息
def addInterest(balances, rate):
  for i in range(len(balances)):
    balances[i] = balances[i] * (1+rate)
def test():
  amounts = [1000, 105, 3500, 739]
  rate = 0.05
  addInterest(amounts,
我将向你们展示我们如何在Python中将函数分配给变量。我将向您展示如何将函数分配给变量。
现在假设我们有一个名为 hello 的函数，我们要做的就是打印单词 hello。
您知道要调用此函数，您将键入函数的名称，后跟一组括号。
<span style="color:var(--syntax-text-color)"><span style="color:var(--syntax-text-color)"><code>hello()..