python的d函数用法 d在python中含义

python中del函数的用法

首先我们要清楚python中的del函数不同于C的free和C++的delete。

创新互联公司服务项目包括荆门网站建设、荆门网站制作、荆门网页制作以及荆门网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，荆门网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到荆门省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

由于python都是引用，而python有GC机制，所以，del语句作用在变量上，而不是数据对象上。

我们来看一个例子：

del删除的是变量，而不是数据。

我们再来看：

推荐教程：python教程以上就是小编分享的关于python中del函数的用法的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

关于python中几个函数的用法

函数调用

myFun()

# 函数的参数

# 单个参数

# 场景

# 需要动态的调整函数体中某一个处理信息

# 则可以, 以参数的形式接收到相关数据

# 定义

# def 函数名(参数名称):

# 函数体

# 函数体中, 可以直接以变量的方式使用该参数

# 函数的调用

# 函数名(参数值)

# 形参和实参的概念

# 上述函数定义中, "参数名称"即为形参;

# 在调用函数的时候, 传递的真实数据, 即为实参

# 多个参数

# 场景

# 需要动态的调整函数体中多个处理信息时

# 则可以以 逗号 做分割, 接收多个参数

# 定义

# def 函数名(参数名称1, 参数名称2):

# 函数体

# 函数体中, 可以直接以变量的方式使用所有参数

# 调用

# 方式1

# 函数名(参数1, 参数2, 参数3...)

# 形参和实参一一对应

# 方式2

# 函数名(参数名称1=参数1, 参数名称n = 参数n...)

# 可以指明形参名称

# 称为"关键字参数"

# 不需要严格按照顺序

# 不定长参数

# 场景

# 如果函数体中, 需要处理的数据, 不确定长度

# 则可以以不定长参数的方式接收数据

# 方式1

# 定义

# def 函数名(*args):

# 元组

# 函数体

# 函数体中, 可以直接以元组变量的方式使用该参数

# 使用

# 函数名(参数1, 参数2, 参数3...)

python字典操作函数

字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的操作包括如下：

(1)len()：返回字典中键—值对的数量；

(2)d[k]:返回关键字对于的值；

(3)d[k]=v:将值关联到键值k上；

(4)del d[k]:删除键值为k的项；

(5)key in d:键值key是否在d中，是返回True，否则返回False。

(6)clear函数：清除字典中的所有项

(7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题

(8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

(9)get函数：访问字典成员

(10)has_key函数：检查字典中是否含有给出的键

(11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

(12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

(13)pop函数：删除字典中对应的键

(14)popitem函数：移出字典中的项

(15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

(16)update函数：用一个字典更新另外一个字典

(17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

一、字典的创建

1.1 直接创建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通过dict创建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的内容:'

printitems

printu'利用dict创建字典，输出字典内容:'

d=dict(items)

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的内容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict创建字典，输出字典内容:

{'four':4,'three':3,'two':2,'one':1}

查询字典中的内容:

或者通过关键字创建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'输出字典内容:'

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出字典内容:

{'three':3,'two':2,'one':1}

查询字典中的内容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1 clear函数：清除字典中的所有项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

请看下面两个例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。

3.2 copy函数：返回一个具有相同键值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X复制到Y：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，观察输出：'

printy

printx

printu'删除Y中的值，观察输出'

y['test'].remove('c')

printy

printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X复制到Y：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，观察输出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

删除Y中的值，观察输出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'输出：'

printy

printz

printu'修改后输出：'

x['test'].append('e')

printy

printz

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后输出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默认的对应值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4 get函数：访问字典成员

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函数可以访问字典中不存在的键，当该键不存在是返回None

3.5 has_key函数：检查字典中是否含有给出的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6 items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8 pop函数：删除字典中对应的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9 popitem函数：移出字典中的项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

运算结果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11 update函数：用一个字典更新另外一个字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

Python 的函数是怎么传递参数的

首先你要明白，Python的函数传递方式是赋值，而赋值是通过建立变量与对象的关联实现的。

对于你的代码：

执行 d = 2时，你在__main__里创建了d，并让它指向2这个整型对象。

执行函数add(d)过程中：

d被传递给add()函数后，在函数内部，num也指向了__main__中的2

但执行num = num + 10之后，新建了对象12，并让num指向了这个新对象——12。

如果你明白函数中的局部变量与__main__中变量的区别，那么很显然，在__main__中，d仍在指着2这个对象，它没有改变。因此，你打印d时得到了2。

如果你想让输出为12，最简洁的办法是：

在函数add()里增加return num

调用函数时使用d = add(d)

代码如下：

def add(num):

num += 10

return num

d = 2

d = add(d)

print d

python d=map怎么理解

Python中map()、filter()、reduce()这三个都是应用于序列的内置函数。

格式：

map(func, seq1[, seq2,…])

第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

Python函数编程中的map()函数是将func作用于seq中的每一个元素，并将所有的调用的结果作为一个list返回。如果func为None，作用同zip()。

1、当seq只有一个时，将函数func作用于这个seq的每个元素上，并得到一个新的seq。

让我们来看一下只有一个seq的时候，map()函数是如何工作的。

从上图可以看出，函数func函数会作用于seq中的每个元素，得到func(seq[n])组成的列表。下面举得例子来帮助我们更好的理解这个工作过程。

#使用lambda

print map(lambda x: x % 2, range(7))

[0, 1, 0, 1, 0, 1, 0]123123

#使用列表解析

print [x % 2 for x in range(7)]

[0, 1, 0, 1, 0, 1, 0]123123

一个seq时，可以使用filter()函数代替，那什么情况不能代替呢？

2、当seq多于一个时，map可以并行（注意是并行）地对每个seq执行如下图所示的过程：

从图可以看出，每个seq的同一位置的元素同时传入一个多元的func函数之后，得到一个返回值，并将这个返回值存放在一个列表中。下面我们看一个有多个seq的例子：

print map(lambda x , y : x ** y, [2,4,6],[3,2,1])

[8, 16, 6]1212

如果上面我们不使用map函数，就只能使用for循环，依次对每个位置的元素调用该函数去执行。还可以使返回值是一个元组。如：

print map(lambda x , y : (x ** y, x + y), [2,4,6],[3,2,1])

[(8, 5), (16, 6), (6, 7)]1212

当func函数时None时，这就同zip()函数了，并且zip()开始取代这个了，目的是将多个列表相同位置的元素归并到一个元组。如：

print map(None, [2,4,6],[3,2,1])

[(2, 3), (4, 2), (6, 1)]1212

需要注意的是：

map无法处理seq长度不一致、对应位置操作数类型不一致的情况，这两种情况都会报类型错误。如下图：

3、使用map()函数可以实现将其他类型的数转换成list，但是这种转换也是有类型限制的，具体什么类型限制，在以后的学习中慢慢摸索吧。这里给出几个能转换的例子：

***将元组转换成list***

map(int, (1,2,3))

[1, 2, 3]

***将字符串转换成list***

map(int, '1234')

[1, 2, 3, 4]

***提取字典的key，并将结果存放在一个list中***

map(int, {1:2,2:3,3:4})

[1, 2, 3]

***字符串转换成元组，并将结果以列表的形式返回***

map(tuple, 'agdf')

[('a',), ('g',), ('d',), ('f',)]

#将小写转成大写

def u_to_l (s):

return s.upper()

print map(u_to_l,'asdfd')