03-字典

本文先介绍映射概念,然后利用字典格式化字符串,最后介绍一些字典的方法。

字典的使用

字典是python中唯一内建的映射类型,字典中的值没有特殊的顺序,但是都存储在一个特定的键(Key)下,键可以使数字、字符串甚至是元组。字典:可以通过轻松查找某个特定的词语(键),从而找到它的定义(值)。
例如:表示一个游戏棋盘的状态,每个键都是由坐标值组成的元组;

创建字典

字典可以通过下面的方式创建:

phonebook={‘Alice’:’2341’,’Beth’:’9102’,’Cecil’:’3528’}

字典由多个及与其对应的构成的键-值对组成(键-值对也成为项)。在这个例子中名字是,电话号码是。每个键和值之间用冒号(:)隔开,项之间用逗号(,)而整个字典用一对大括号括起来。空字典(不包括任何项)由两个大括号组成,如:{}

  • 字典中的键是唯一的,而值是不唯一的。

dict函数

可以通过dict函数来创建字典:

1.(键,值)对

1.通过(键,值)对的序列建立字典 (列表->字典)

>>> items =[('names','Gumby'),('age','42')]
>>> d = dict(items)
>>> d
{'age': '42', 'names': 'Gumby'}
2.关键字参数

2.通过关键字参数来创建字典 (指定-字典)

>>> d=dict(name='Gumby',age=42)
>>> d
{'age': '42', 'names': 'Gumby'}

基本字典操作

  • len(d)返回d中项(键-值对)的数量。
  • d[k]返回关联到键k上的值。
  • d[k]=v将值v关联到键k上。
  • del d[k]删除键为k的项。
  • k in d检查d中是否含有键为k的项。

字典和列表不同之处:
键类型:字典的键不一定为整型数据,键也可以是浮点型(实型)、字符型或者元组。
自动添加:即使键在字典中起初并不存在,也可以为它赋值,这样字典就会建立新的项。
成员资格:表达式 k in d(d为字典)查找的事键,而不是值。

#将‘Foobar’关联到空字典的键42上
x={}
x[42]='Foobar'
print x

Demo

#字典使用人名作为键,每个人用另一个字典来表示,其键‘phone’和'addr'分别表示他们的电话号码和地址。
people={
    'Alice':{
        'phone':'2341',
        'addr':'Foo drive 23'
    },

    'Beth':{
        'phone':'9012',
        'addr':'Bar street 42'
    },

    'Cecil':{
        'phone':'3158',
        'addr':'Baz avenue 90'
    }
}

#针对电话号码和地质使用的描述性标签,会在打印输出的时候用到

labels ={
    'phone':'phone number',
    'addr':'address'            
}
name =raw_input('Name: ')

#查找电话号码还是地址?

request = raw_input('Phone number(p) or address(a)?')

#使用正确的键:
if request == 'p' : key = 'phone'
if request == 'a':key ='addr'

if name in people: 
    print "%s's %s is %s."%(name,labels[key],people[name][key])

字典的格式化字符串

在每个转换说明符中的%字符后面,加上键(用圆括号括起来),后面再跟上其他说明元素(其实就是引用字典当中某个键的内容)。

>>>phonebook={'Alice':'2341','Beth':'9102','Cecil':'3528'}
>>>'Cecil's phone number is %(Cecil).' %phonebook
'Cecil's phone number is 3258'

字典方法

1.clear

clear方法清除字典中所有的项,这是个原地操作(类似于list.sort),所以无返回值(或者说返回None)。

>>> d ={}
>>> d['name'] = 'Gumby'
>>> d['age'] = 42
>>> print d
{'age': 42, 'name': 'Gumby'}
>>> return_value =d.clear()
>>> print d
{}
>>> print return_value
None
2.copy

copy方法返回一个具有相同键-值对的新字典。

浅复制(shallow copy)

dic1={'A':'a1','B':['b1','b2']}
print '----------copy----------'
print 'dic1=',dic1
dic2=dic1.copy()
print'dic2',dic2
print '----------change----------'
dic2['A']='a0'
print 'dic1=',dic1
print 'dic2',dic2
print '----------remove----------'
dic2['B'].remove('b1')
print 'dic1=',dic1
print 'dic2',dic2

#输出结果
----------copy----------
dic1= {'A': 'a1', 'B': ['b1', 'b2']}
dic2 {'A': 'a1', 'B': ['b1', 'b2']}
----------change----------
dic1= {'A': 'a1', 'B': ['b1', 'b2']}
dic2 {'A': 'a0', 'B': ['b1', 'b2']}
----------remove----------
dic1= {'A': 'a1', 'B': ['b2']}
dic2 {'A': 'a0', 'B': ['b2']}

深复制(deep copy)

from copy import deepcopy
d={}
d['names']=['A','B']
print 'd=',d
c =d.copy()
print 'c=',c
dc=deepcopy(d)
print 'dc=',dc
d['names'].append('C')
print 'd=',d
print '---------------------------------------'
print 'c=',c
print 'dc=',dc

#输出结果
d= {'names': ['A', 'B']}
c= {'names': ['A', 'B']}
dc= {'names': ['A', 'B']}
d= {'names': ['A', 'B', 'C']}
---------------------------------------
c= {'names': ['A', 'B', 'C']}
dc= {'names': ['A', 'B']}
3.fromkeys

fromkeys方法使用给定的键建立新的字典,每个键都对应一个默认的值None。

>>>{}.fromkeys(['name','age'])
{'age': None, 'name': None}

#可以赋初始值
{}.fromkeys(['name','age'],'(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}
4.get

get方法是个更宽松的访问字典项的方法,当访问一个不存在的键时,没有异常,而得到了None值,还可以定义默认值。

>>>d={}
print d.get('name')

#定义默认值
>>> d={}
>print d.get('name','N/A')
'N/A'
5.has_key

has_key方法可以检查字典中是否含有特定的键,表达式d.has_key(k)相当于表达式k in d。

>>> d = {}
>>> d.has_key('name')
False
>>> d['name']='Eric'
>>> d.has_key('name')
True
6.items和iteritems

items方法将字典所有的项以列表方式返回,列表中的每一项都表示为(键,值)对的形式。(字典->列表)

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.items()
[('url', 'http://www.python.org'), ('spam', 0), ('title', 'Python web Site')]

7.key和iterkeys

keys方法将字典中的键以列表形式返回,而iterkeys则返回针对键的迭代器。

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.keys()
['url', 'spam', 'title']
>>> d.iterkeys()
<dictionary-keyiterator object at 0x000000000B102C78>
8.pop

pop方法用于获得对应于给定键的值,然后将这个键-值对从字典中移除。

>>> d={'x':'1','y':'2'}
>>> d.pop('x')
1
>>>d
{'y': '2'}
9.popitem

popitem方法类似于list.pop,后者会弹出列表的最后一个元素。但不同的是,popitem弹出随机的项,因为字典并没有给出‘最后的项’或者其他有关顺序的概念(随机弹出一个(键-值)对)

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.popitem() 
('url', 'http://www.python.org') 
>>> d 
{'spam': 0, 'title': 'Python web Site'}
10.setdefault

setdault方法在某种程度上类似于get方法,能够获得与给定键相关联的值,除此之外,setdault还能在字典中不含有给定键的情况下设定相应的键值。

>>> d={}
>>> d.setdefault('name','N/A')
N/A
>>> d
{'name': 'N/A'}
>>> d['name'] = 'Gaumy'
>>> d.setdefault('name','N/A')
>>> d
{'name': 'Gaumy'}

1>当键不存在的时候,setdefault返回默认值并且相应更新字典。
2>如果键存在,那么就返回与其对应的值,但不改变字典。

11.update

update方法可以利用一个字典项更新另一个字典项

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> x={'title':'Python Language Website'}
d.update(x)
>>> d
{'url': 'http://www.python.org', 'spam': 0, 'title': 'Python Language Website'}
12.values

values方法以列表的形式返回字典中的值(itervalues返回值的迭代器),与返回键的列表不同的是,返回值的列表中可以包含重复的元素。

>>> d={}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d[4]=1
>>> d
{1: 1, 2: 2, 3: 3, 4: 1}
>>> d.values()
[1, 2, 3, 1]
<think>嗯,用户给了一个包含重复元素的列表,想要用Python程序去重。首先,我需要理解用户的需求。列表中的元素都是字符串,看起来像是一些设备编号或者类似的标识符。用户可能是在处理数据时遇到了重复项,需要清理这些重复的数据。 那Python中常用的去重方法有哪些呢?首先想到的是用集合(set),因为集合的特性就是元素唯一。不过集合会打乱原来的顺序,如果用户需要保持原有顺序,可能需要用其他方法。比如遍历列表,保留首次出现的元素。 接下来看用户提供的列表,里面明显有重复,比如"BTCTB03-1"出现了两次,"BTCTB03-3"也重复了。用户可能希望得到一个没有重复项的列表,同时可能还关心顺序是否保持。虽然用户没有明确说明是否需要保持顺序,但作为开发者,应该考虑到这一点,提供不同的解决方案。 外,用户可能对Python不太熟悉,所以需要给出简单易懂的方法。比如,使用集合是最简单的,但会失去顺序;使用列表推导式或者循环来保留顺序。此外,还可以提到Python3.7+之后字典保持插入顺序的特性,利用dict.fromkeys()来去重并保持顺序,这可能是一个更高效的方法。 需要检查用户提供的示例列表中的元素是否都是字符串,是否有其他类型的元素可能影响去重。在这个例子中,所有元素都是字符串,所以直接处理即可。还要考虑到是否有大小写敏感的问题,但在这个例子里,所有字符都是大写,应该没有问题。 最后,可能需要给出不同方法的代码示例,并解释它们的优缺点,让用户根据自己的需求选择合适的方法。比如,如果用户不需要保持顺序,用集合最快;如果需要保持顺序,用dict.fromkeys()或者列表循环的方法更合适。同时提醒用户注意Python版本的问题,因为dict保持顺序的特性是在3.7之后才有的。 总结一下,应该分步骤给出几种不同的去重方法,并说明每种方法的适用场景,帮助用户选择最适合自己需求的方式。</think>以下是针对该列表去重的Python实现方法,按照不同需求提供多种解决方案: **方法一:使用集合去重(不保持顺序)** ```python chambers_list = [ "BTCTB03-1", "BTCTB03-3", "BTCTB03-4", "BTCTB03-2", "BTCTB03-D", "BTCTB03-5", "BTCTB03-C", "BTCTB03-1", "BTCTB03-3", "BTCTB03-4", "BTCTB03-2", "BTCTB03-D", "BTCTB03-5", "BTCTB03-C" ] # 使用集合去重(无序) unique_list = list(set(chambers_list)) print(unique_list) ``` **方法二:保持原有顺序去重(Python 3.7+)** ```python # 利用字典保持插入顺序的特性(Python 3.7+) unique_ordered = list(dict.fromkeys(chambers_list)) print(unique_ordered) ``` **方法三:传统顺序保持方法(兼容所有版本)** ```python # 传统遍历方法保持顺序 seen = set() result = [] for item in chambers_list: if item not in seen: seen.add(item) result.append(item) print(result) ``` **输出结果示例**: ```python # 方法一可能输出(顺序随机): ['BTCTB03-2', 'BTCTB03-3', 'BTCTB03-4', 'BTCTB03-5', 'BTCTB03-C', 'BTCTB03-D', 'BTCTB03-1'] # 方法二/三输出(保持首次出现顺序): ['BTCTB03-1', 'BTCTB03-3', 'BTCTB03-4', 'BTCTB03-2', 'BTCTB03-D', 'BTCTB03-5', 'BTCTB03-C'] ``` **方案选择建议**: 1. 如果只需要简单去重且不关心顺序 → 使用**方法一** 2. 需要保持元素首次出现顺序 → 推荐使用**方法二**(Python 3.7+) 3. 需要兼容旧版本Python使用**方法三** **扩展功能**(带数字排序): ```python # 如果需要按末尾字符排序(1,2,3,4,5,C,D) def custom_sort(item): suffix = item.split('-')[-1] try: return (0, int(suffix)) # 数字类型 except ValueError: return (1, suffix) # 字母类型 sorted_list = sorted(unique_ordered, key=custom_sort) print(sorted_list) # 输出:['BTCTB03-1', 'BTCTB03-2', 'BTCTB03-3', 'BTCTB03-4', 'BTCTB03-5', 'BTCTB03-C', 'BTCTB03-D'] ``` **注意事项**: 1. 字符串匹配区分大小写("C""c"会被视为不同) 2. 如果存在不同格式的条目(如"BTCTB03-01""BTCTB03-1")需要预先标准化 3. 大规模数据处理建议使用生成器表达式(内存优化) 以上代码可以直接复制到Python环境中运行测试,根据实际需求选择最适合的去重策略。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值