Tuple、list的区别以及dict和set

元组(Tuple):

定义方法:使用小括号()

使用方法:

count:可以统计某个元组段在整个元组中出现的次数

index:可以查询某个元组段在整个元组中的元组号

name_tuple = ('xiaoming','xiaohong','xiaoli','xiaozhang','xiaoming')
#统计xiaoming出现的次数
print name_tuple.count('xiaoming')
#统计xiaoming在元组中的下标,默认从0开始计算
print name_tuple.index('xiaoming')
#统计xiaoming在元组中的下标,从指定的小标1,开始计算
print name_tuple.index('xiaoming',1)

返回结果:

2
0
4

列表(list):

1.可以增加列表内容 append

2.可以统计某个列表段在整个列表中出现的次数 count

3.可以插入一个字符串,并把整个字符串的每个字母拆分当作一个列表段追加到列表当中 extedn

4.可以查询某个列表段在整个列表的位置 index

5.可以在指定位置插入一个列表段 insert

6.可以删除列表的最后一个列表段 pop

7.可以删除指定列表中的某个列表段 remove

8.可以正向反向排序 reverse

9.可以按字母或数字排序 sort

10.定义列表时候使用中括号"[]"

name_list = ['sean','tom','jack','Angelia','Daisy','jack'] 
print name_list
#增加david列表
name_list.append('david')
print name_list
#统计jack出现的次数
print name_list.count('jack')
#使用extend向列表中增加一个列表
name_list.extend(['hello','world'])
print  name_list
#使用extend向列表中增加列表段
name_list.extend('sean')
print  name_list
#这里统计的是第一个为jacak的id号
print name_list.index('jack')
#在索引号为2的地方插入Adam
name_list.insert(2, 'Adam')
print name_list
#删除最后一个列表段
name_list.pop()
print name_list
#删除指定列表段,如果存在多个,删除第一个
name_list.remove('jack')
print name_list
#列表倒置
name_list.reverse()
print name_list
name_list.reverse()
#对整个列表进行列表段的首字母进行排序
name_list.sort()
print name_list

结果:

['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack']   #原始结果
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david']   #增加david后的结果
2  #统计jack出现次数
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world'] # 使用extend向列表中增加一个列表
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a', 'n']   #使用extend向列表中增加列表段
2   #统计的是第一个为jacak的id号
['sean', 'tom', 'Adam', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a', 'n']   #在索引号为2的地方插入Adam
['sean', 'tom', 'Adam', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a']  #删除最后一个列表段
['sean', 'tom', 'Adam', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a']   #删除指定列表段,如果存在多个,删除第一个
['a', 'e', 's', 'world', 'hello', 'david', 'jack', 'Daisy', 'Angelia', 'Adam', 'tom', 'sean']  #列表倒置
['Adam', 'Angelia', 'Daisy', 'a', 'david', 'e', 'hello', 'jack', 's', 'sean', 'tom', 'world']   #对整个列表进行列表段的首字母进行排序

相同点:都是序列类型

两者区别:tuple是不可变类型,大小固定,而 list 是可变类型、数据可以动态变化

1、元组是不可变对象,对象一旦生成,它的值将不能更改;列表是可变对象,对象生成后,可以对其元素进行更改、添加、删除、清空、排序等操作。

2、可哈希和不可哈希
可哈希对象就是能映射成内存地址的对象。在Python基本数据类型中,只有列表、字典和可变集合是不可哈希的。说元组是可哈希也不对,如果元组中某个元素是列表、字典或可变集合,那么这个元组也是不可哈希的。可哈希对象和不可哈希对象的区别体现在:可哈希对象可以作为字典的键和集合的元素,不可哈希对象则不可以。

tuple 用于存储异构(heterogeneous)数据,当做没有字段名的记录来用,比如用 tuple 来记录一个人的身高、体重、年龄。

person = (“zhangsan”, 20, 180, 80) 
比如记录坐标上的某个点

point = (x, y) 
而列表一般用于存储同构数据(homogenous),同构数据就是具有相同意义的数据,比如下面的都是字符串类型

[“zhangsan”, “Lisi”, “wangwu”] 
再比如 list 存放的多条用户记录

[(“zhangsan”, 20, 180, 80), (“wangwu”, 20, 180, 80)] 
数据库操作中查询出来的记录就是由元组构成的列表结构。

字典(dict)

字典的基本操作

如何访问字典中的值?
adict[key] 
    形式返回键key对应的值value,如果key不在字典中会引发一个KeyError,如何检查key是否在字典中?
has_key()
    形如:adict.haskey(‘name') 有–>True,无–>False
    b、innot in   形如:'name' in adict      有–>True,无–>False
如何更新字典?
    a、添加一个数据项(新元素)或键值对
adict[new_key] = value 形式添加一个项
    b、更新一个数据项(元素)或键值对
adict[old_key] = new_value
    c、删除一个数据项(元素)或键值对
del adict[key] 删除键key的项 / del adict 删除整个字典
adict.pop(key) 删除键key的项并返回key对应的 value值

字典的方法:

dict.keys() 返回一个包含字典所有KEY的列表; 
dict.values() 返回一个包含字典所有value的列表; 
dict.items() 返回一个包含所有(键,值)元祖的列表; 
dict.clear() 删除字典中的所有项或元素; 
dict.copy() 返回一个字典浅拷贝的副本; 
dict.fromkeys(seq, val=None) 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值(默认为None); 
dict.get(key, default = None) 返回字典中key对应的值,若key不存在字典中,则返回default的值(default默认为None); 
dict.has_key(key) 如果key在字典中,返回True,否则返回False。 现在用 innot in; 
dict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表; 
dict.pop(key[,default]) 和get方法相似。如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有给出default的值,则引发keyerror异常; 
dict.setdefault(key, default=None) 和set()方法相似,但如果字典中不存在Key键,由 adict[key] = default 为它赋值; 
dict.update(bdict) 将字典bdict的键值对添加到字典adict中。

集合(set)

s1={0}
s2={i / 2 for i in range(10)}
print s1,s2
s=set('hi')
t=set(['h','e','l','l','o'])
print s,t

print(s.intersection(t), s & t)     # 交集
print(s.union(t), s | t)            # 并集 
print(s.difference(t), s - t)       # 差集 
print(s.symmetric_difference(t), s ^ t)   # 对称差集 
print(s1.issubset(s2), s1 <= s2)          # 子集
print(s1.issuperset(s2), s1 >= s2)        # 包含

结果:

set([0]) set([0, 1, 2, 3, 4])
set(['i', 'h']) set(['h', 'e', 'l', 'o'])
(set(['h']), set(['h']))
(set(['e', 'i', 'h', 'l', 'o']), set(['e', 'i', 'h', 'l', 'o']))
(set(['i']), set(['i']))
(set(['i', 'e', 'l', 'o']), set(['i', 'e', 'l', 'o']))
(True, True)
(False, False)
原文地址:https://www.cnblogs.com/catxjd/p/9020661.html