1. python中的引用变量(Python中的变量引用对象需注意的几点)

2. python引用变量的值(Python中的变量引用对象需注意的几点)

3. python类引用变量

4. python引用变量的值

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点：

普通引用：

Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python]

view plain copy

a = 3

a = "science"

上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。

共享引用：

[python]

view plain copy

a = 3

b = a

上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如：

[python]

view plain copy

a = “science”

在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如：

[python]

view plain copy

a = [1,2,3]

b = a

变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作

[python]

view plain copy

a[0] = 4

那么变量b就变随之变为[4,2,3]。避免这种情况可以使用copy操作，替换引用操作。

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点： 普通引用： Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。

赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python] view plain copy a = 3 a = "science" 上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。 共享引用： [python] view plain copy a = 3 b = a 上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。

正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如： [python] view plain copy a = “science” 在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如： [python] view plain copy a = [1,2,3] b = a 变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作 [python] view plain copy a[0] = 4 那么变量b就变随之变为[4,2,3]。

避免这种情况可以使用copy操作，替换引用操作。

用字符串格式化，前面占坑，后面变量去填坑。

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')

'a, b, c'

>>> '{}, {}, {}'.format('a', 'b', 'c') # 2.7+ only

'a, b, c'

>>> '{2}, {1}, {0}'.format('a', 'b', 'c')

'c, b, a'

>>> '{2}, {1}, {0}'.format(*'abc') # unpacking argument sequence

'c, b, a'

>>> '{0}{1}{0}'.format('abra', 'cad') # arguments' indices can be repeated

'abracadabra'

Python的类中引用成员变量必须加self

类（class）初始化之后会得到实例（instance）。 self就是用于代表初始化的到的实例。 明确地写一个self参数，使得类的方法（method）和普通的函数（function）本质上没有差异，所有的输入参数都显示地传递到方法/函数当中。 当然作为类的方法，作用的对.

self是只有在类中才会有的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。 但self的名称并不是一定的，在python中self不是关键词。在初始化函数中可以把self换成任意名字.

1. 使用连接符： +

1

2

world ="World"

print"Hello "+world +" ! "

2. 使用占位符来内插

1

2

world ="World"

print"Hello %s !"%world

3. 使用函数

1

2

3

li =['my','name','is','bob']

mystr =' '.join(li)

printmystr

上面的语句中字符串是作为参数传入的，可以直接用变量替换：

1

2

3

begin_date ='2012-04-06 00:00:00'

end_date ='2012-04-06 23:59:59'

select *fromusb where time between to_date(begin_date,'YYYY-MM-DD HH24:MI:SS') andto_date(end_date,'YYYY-MM-DD HH24:MI:SS')

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点：

普通引用：

Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python]

view plain copy

a = 3

a = "science"

上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。

共享引用：

[python]

view plain copy

a = 3

b = a

上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如：

[python]

view plain copy

a = “science”

在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如：

[python]

view plain copy

a = [1,2,3]

b = a

变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作

[python]

view plain copy

a[0] = 4

那么变量b就变随之变为[4,2,3]。避免这种情况可以使用copy操作，替换引用操作。

网页链接

python ctypes 第一句话：

ctypes is a foreign function library for Python. It provides C compatible data types, and allows calling functions in DLLs or shared libraries. It can be used to wrap these libraries in pure Python.

没看到有说可以直接访问data。

你可以这样加这样的函数：

int get_a()

{

return a;

}再在python里面调用。

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点： 普通引用： Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。

赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python] view plain copy a = 3 a = "science" 上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。 共享引用： [python] view plain copy a = 3 b = a 上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。

正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如： [python] view plain copy a = “science” 在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如： [python] view plain copy a = [1,2,3] b = a 变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作 [python] view plain copy a[0] = 4 那么变量b就变随之变为[4,2,3]。

避免这种情况可以使用copy操作，替换引用操作。

值传递仅仅传递的是值

引用传递，传递的是内存地址，修改后会改变内存地址对应储存的值。

用数组来举例就最清楚了，例如我们定义一个数组a[]={1,2};

那么a[0]=1,a[1]=2。

如果我们把数组a里的元素值作为参数传递，实际上只是进行了值传递，对数组本身没有影响

如果我们把 数组a的指针作为参数传递，那么假如处理的函数就可以直接修改数组a里的值。

代码实例：（只是写个大概的逻辑，语法可能有错误）

main()

{

int a[]={1,2};

test(a);

printf(a[0])； //此处打印的值是3， 这就是引用传递。

}

public void test(int b[])

{

b[0]=3;

}

Python的类中引用成员变量必须加self

类（class）初始化之后会得到实例（instance）。 self就是用于代表初始化的到的实例。 明确地写一个self参数，使得类的方法（method）和普通的函数（function）本质上没有差异，所有的输入参数都显示地传递到方法/函数当中。 当然作为类的方法，作用的对.

self是只有在类中才会有的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。 但self的名称并不是一定的，在python中self不是关键词。在初始化函数中可以把self换成任意名字.

你的原始代码有若干语法错误，现已帮你修正并做好注释，参考下列代码：

# -*- coding: cp936 -*-

#A.py

class a（)： #后面要有冒号

tmp='123' #直接在a类里定义tmp变量，不用写方法

# -*- coding: cp936 -*-

#B.py

import A #导入A模块

class b（)： #后面要有冒号

def fun1(self)： #类方法要有一个默认self参数

print A.a.tmp #输出A模块中a类的tmp值

tb=b（) #需要把b类实例化，才可以使用里面的fun1方法

tb.fun1（) #直接输出tmp值

A.a.tmp='321' #修改tmp的值

tb.fun1（) #看到tmp值已被修改

input（'完成，按任意键退出'）

以上代码在python2.6环境测试通过

希望对你有所帮助~

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点： 普通引用： Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。

赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python] view plain copy a = 3 a = "science" 上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。 共享引用： [python] view plain copy a = 3 b = a 上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。

正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如： [python] view plain copy a = “science” 在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如： [python] view plain copy a = [1,2,3] b = a 变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作 [python] view plain copy a[0] = 4 那么变量b就变随之变为[4,2,3]。

避免这种情况可以使用copy操作，替换引用操作。

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点：

普通引用：

Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python]

view plain copy

a = 3

a = "science"

上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。

共享引用：

[python]

view plain copy

a = 3

b = a

上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如：

[python]

view plain copy

a = “science”

在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如：

[python]

view plain copy

a = [1,2,3]

b = a

变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作

[python]

view plain copy

a[0] = 4

那么变量b就变随之变为[4,2,3]。避免这种情况可以使用copy操作，替换引用操作。

Python的类中引用成员变量必须加self类（class）初始化之后会得到实例（instance）。

self就是用于代表初始化的到的实例。 明确地写一个self参数，使得类的方法（method）和普通的函数（function）本质上没有差异，所有的输入参数都显示地传递到方法/函数当中。

当然作为类的方法，作用的对.self是只有在类中才会有的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

但self的名称并不是一定的，在python中self不是关键词。在初始化函数中可以把self换成任意名字。

你这个代码很有问题，

1. class Student:

def __init__(self):

for name in Name:

for id in ID:

self.name = name

self.id = id

最终Student得到的是实例有两个变量name和id，他们的值分别是Kay和3，初始化时候的遍历完全没有意义。

2. self.lst.append("{} of {}".format(Student.__init__(self.id), Student.__init__(self.name)))

Student是一个类型，你都没创建一个实例，__init__是实例的初始化函数，使用"__"修饰，是私有函数，不能在外部调用，然后那个里面参数的self是Students的self肯定是访问不到id和name的属性的。

总的来说，代码存在很多的问题。

想要获得的结果是两个列表中元素所有组合的可能性，可以这样实现：

Name = ['Stella','Kay']

ID = [1,3]

result = [(a, b) for a in ID for b in Name]

这样得到的result就是两个列表的元素的组合

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点：

普通引用：

Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python]

view plain copy

a = 3

a = "science"

上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。

共享引用：

[python]

view plain copy

a = 3

b = a

上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如：

[python]

view plain copy

a = “science”

在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如：

[python]

view plain copy

a = [1,2,3]

b = a

变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作

[python]

view plain copy

a[0] = 4

那么变量b就变随之变为[4,2,3]。避免这种情况可以使用copy操作，替换引用操作。

网页链接

python ctypes 第一句话：

ctypes is a foreign function library for Python. It provides C compatible data types, and allows calling functions in DLLs or shared libraries. It can be used to wrap these libraries in pure Python.

没看到有说可以直接访问data。

你可以这样加这样的函数：

int get_a()

{

return a;

}再在python里面调用。

给你介绍Python中普通引用和共享引用在引用对象中需要注意的点： 普通引用： Python中，变量的作用仅仅是一个标识，只有赋值后才被创建，它可以引用任何类型的对象，而且在引用之前必须赋值。

赋值后的变量指向响应的对象，拥有该对象的空间。类型属于对象，但是不是变量。

[python] view plain copy a = 3 a = "science" 上述代码说明数值3和字符串“science”分别是两种对象，初始变量a赋值对象3被创建，变量a指向对象3的内存空间，之后变量a又指向了字符串的内存空间。 共享引用： [python] view plain copy a = 3 b = a 上述代码说明变量a,b同时引用了对象3，两个变量引用了相同的对象。

正是因为两者都是指向了相同的对象，所以当其中一个变量引用其他对象的时候，不会对另一个变量造成影响。例如： [python] view plain copy a = “science” 在上面代码的基础上，变量a引用了字符串对象“science”，此时变量b依旧引用对象3，而不是“science”。

但是有些对象的操作会在原处修改，例如列表。例如： [python] view plain copy a = [1,2,3] b = a 变量a,b应用了包含1,2,3对象的列表，自然而然的a[0]引用对象1，如果在变量a中执行操作 [python] view plain copy a[0] = 4 那么变量b就变随之变为[4,2,3]。

避免这种情况可以使用copy操作，替换引用操作。

值传递仅仅传递的是值

引用传递，传递的是内存地址，修改后会改变内存地址对应储存的值。

用数组来举例就最清楚了，例如我们定义一个数组a[]={1,2};

那么a[0]=1,a[1]=2。

如果我们把数组a里的元素值作为参数传递，实际上只是进行了值传递，对数组本身没有影响

如果我们把 数组a的指针作为参数传递，那么假如处理的函数就可以直接修改数组a里的值。

代码实例：（只是写个大概的逻辑，语法可能有错误）

main()

{

int a[]={1,2};

test(a);

printf(a[0])； //此处打印的值是3， 这就是引用传递。

}

public void test(int b[])

{

b[0]=3;

}

转载请注明出处编程代码网 » python如何引用变量