2.6基本数据类型——列表
列表的创建
list_test=[‘张三‘,‘李四’,‘alex‘] #或 list_test=list(‘alex‘) #或 list_test=list([‘张三‘,‘李四’,‘alex‘])
列表的特点和常用操作
特性：
1.可存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3.可修改指定索引位置对应的值，可变
常规操作：
#索引
>>> l = [‘egon‘,‘alex‘,‘seven‘,‘yuan‘]
>>> l[0]
‘egon‘
>>> l[2]
‘seven‘
#切片
>>> l[0:2]
[‘egon‘, ‘alex‘]
>>> l[2:5]
[‘seven‘, ‘yuan‘]
>>> l[:2]
[‘egon‘, ‘alex‘]
>>> l[2:]
[‘seven‘, ‘yuan‘]
>>> l[:]
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘]
>>> l[::2]
[‘egon‘, ‘seven‘]
>>> l[::-1]
[‘yuan‘, ‘seven‘, ‘alex‘, ‘egon‘]
#追加
>>> l.append("eva")
>>> l
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘, ‘eva‘]
#删除
>>> l.remove(‘eva‘)
>>> l
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘]
>>> l.pop()
‘yuan‘
>>> l
[‘egon‘, ‘alex‘, ‘seven‘]
#长度
>>> len(l)
3
#包含
>>> ‘seven‘ in l
True
>>> ‘yuan‘ in l
False
#循环:为什么是“i”？
>>> for i in l:
print(i)
egon
alex
seven
列表与字符串——split和join
#分割 >>> s = ‘hello world‘ >>> s.split(‘ ‘) [‘hello‘, ‘world‘] >>> s2= ‘hello,world‘ >>> s2.split(‘,‘) #连接 >>> l = [‘hi‘,‘eva‘] >>> ‘!‘.join(l) ‘hi!eva‘
2.7基本数据类型——元素
元组的定义和特性
定义：与列表类似，只不过［］改成（）
特性：
1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
元素的创建：
ages = (11, 22, 33, 44, 55) #或 ages = tuple((11, 22, 33, 44, 55))
元素的常规操作：
#索引
>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55
#切片:同list
#循环
>>> for age in ages:
print(age)
11
22
33
44
55
#长度
>>> len(ages)
5
#包含
>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False
元素特性：
1.可以存放多个值
当它只有一个值时
t = (1,) t = (1) #<==>t = 1
元组中不仅可以存放数字、字符串，还可以存放更加复杂的数据类型
2.不可变原则
元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变
2.8可变、不可变数据类型和hash
可变类型：列表
不可变类型：数字、字符串、元组
列表：
>>> l = [1,2,3,4] >>> id(l) 4392665160 >>> l[1] = 1.5 >>> l [1, 1.5, 3, 4] >>> id(l) 4392665160
数字：
>>> a = 1 >>> id(a) 4297537952 >>> a+=1 >>> id(a) 4297537984
字符串：
#例1
>>> s = ‘hello‘
>>> s[1] = ‘a‘
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
s[1] = ‘a‘
TypeError: ‘str‘ object does not support item assignment
#例2
>>> s = ‘hello‘
>>> id(s)
4392917064
>>> s += ‘ world‘
>>> s
‘hello world‘
>>> id(s)
4393419504
元素——不允许修改
>> t = (1,2,3,4)
>>> t[1] = 1.5
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
t[1] = 1.5
TypeError: ‘tuple‘ object does not support item assignment
hash:
>>> hash("张三")
6480394008723176318
>>> hash("李四")
-114706925611844552
>>> hash("王老五")
3250319002057530081
注：不可变的数据类型是可以被hash的，可变类型是不可以hash的。
2.9基本数据类型——字典
字典是python语言中唯一的映射类型。
定义：｛key1:value1,key2:value2｝
1、键与值用冒号“：”分开； 2、项与项用逗号“，”分开；
特性：
1.key-value结构 2.key必须可hash、且必须为不可变数据类型、必须唯一 3.可存放任意多个值、可修改、可以不唯一 4.无序
字典创建：
person = {"name": "alex", ‘age‘: 20}
#或
person = dict(name=‘seven‘, age=20)
#或
person = dict({"name": "egon", ‘age‘: 20})
#或
person = dict(([‘name‘,‘苑昊‘],[‘文周‘,18]))
{}.fromkeys(seq,100) #不指定100默认为None
#注意
>>> dic={}.fromkeys([‘k1‘,‘k2‘],[])
>>> dic
{‘k1‘: [], ‘k2‘: []}
>>> dic[‘k1‘].append(1)
>>> dic
{‘k1‘: [1], ‘k2‘: [1]}
字典的常规操作：
键、值、键值对 1、dic.keys() 返回一个包含字典所有KEY的列表； 2、dic.values() 返回一个包含字典所有value的列表； 3、dic.items() 返回一个包含所有（键，值）元祖的列表； 4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表； 新增 1、dic[‘new_key‘] = ‘new_value‘； 2、dic.setdefault(key, None) ,如果字典中不存在Key键，由 dic[key] = default 为它赋值；_ 删除 1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常； 2、dic.clear() 删除字典中的所有项或元素； 修改 1、dic[‘key‘] = ‘new_value‘,如果key在字典中存在，‘new_value‘将会替代原来的value值； 2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中 查看 1、dic[‘key‘]，返回字典中key对应的值，若key不存在字典中，则报错； 2、dict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None） 循环 1、for k in dic.keys() 2、for k,v in dic.items() 3、for k in dic 长度 1、len(dic)
字典的工厂函数
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object‘s
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass
def copy(self): # real signature unknown; restored from __doc__
""" D.copy() -> a shallow copy of D """
pass
@staticmethod # known case
def fromkeys(*args, **kwargs): # real signature unknown
""" Returns a new dict with keys from iterable and values equal to value. """
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass
def items(self): # real signature unknown; restored from __doc__
""" D.items() -> a set-like object providing a view on D‘s items """
pass
def keys(self): # real signature unknown; restored from __doc__
""" D.keys() -> a set-like object providing a view on D‘s keys """
pass
def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass
def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass
def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass
def values(self): # real signature unknown; restored from __doc__
""" D.values() -> an object providing a view on D‘s values """
pass
....略....
2.10基本数据类型——集合
集合中元素的三个特征：
1.确定性（元素必须可hash)
2.互异性（去重）
3.无序性（集合中的元素没有先后之分），如集合{3，4，5}和{3，5，4}算同一个集合。
注意：集合存在的意义就在于去重和关系运算。
用集合解决问题
l={‘张三‘，’李四‘，’老男孩‘} #集合定义
p={’张三‘，’李四‘，‘alex‘}
l_p=l&p #集合求集
print(l_p)
集合的定义：
l={1,2,3,1} #此处应该说明集合“去重”的效果
#定义可变集合
>>> set_test=set(‘hello‘)#此处说明集合的“无序性”
>>>set_test
{‘l‘,‘o‘,‘e‘,‘h‘}
#改为不可变集合frozenset
>>>f_set_test=frozenset(sey_test)
>>>f_set_test
frozenset{‘l‘,‘e‘,‘h‘,‘o‘}
集合的关系运算：
|，|=合集，也叫并集
l={‘张三‘，‘李四‘，‘老男孩‘}
p={‘张三‘，‘李四‘，‘alex‘}
print(l.union(P))
print(l|p)
-,-=差集
l={‘张三‘,‘李四‘,‘老男孩‘}
p = {‘张三‘,‘李四‘,‘alex‘}
print(l.difference(p))
print(l-p)
^,^=对称差集
a = {1,2,3}
b = {2,3,4,5}
print(a.symmetric_difference(b))
print(a^b)
包含关系
in，not in：判断某元素是否在集合内
= =，!:判断两个集合是否相等
两个集合之间一般有是三种关系，相交、包含、不相交。在Python中分别用下面的方法判断:
- set.isdisjoint(s)：判断两个集合是不是不相交
- set.issuperset(s)：判断集合是不是包含其他集合，等同于a>=b
- set.issubset(s)：判断集合是不是被其他集合包含，等同于a<=b
集合的常用操作
元素的增加：
>>> a={1,2}
>>>a.update([3,4],[1,2,7])
>>>a
{1,2,3,4,7}
>>>a.update("hello")
>>>a
{1,2,3,4,7,‘h‘,‘e‘,‘l‘,‘o‘}
>>>a.add("hello")
>>>a
{1,2,3,4,‘hello",7,‘h‘,‘e‘,l‘,‘o‘}
元素的删除集合删除单个元素有两种方法：
元素不在原集合中时：
set.discard不会抛出异常
set.remove(x)会抛出Key Error错误
>>> a={1,2,3,4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.remove(1)
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 1
pop():由于集合是无序的，pop返回的结果不能确定，且当集合为空时调用pop会抛出Key Error错误，clear（）：清空集合
>>> a={3,"a",2.1,1}
>>> a.pop()
>>> a.pop()
>>> a.clear()
>>> a
set()
>>> a.pop()
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: ‘pop from an empty set‘
2.11collections模块
collections模块在内置数据类型（dict、list、set、tuple）基础上，还提供几个额外的数据类型：
Chain Map、Counter、dequ、defaultdict、namedtuple和orderdict等
1.namedtuple: 生成可以使用名字来访问元素内容的tuple子类
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
nameduple
amedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。（注：tuple是不变集合）
验证创建的Piont对象是tuple的一种子类：
>>>isinstance(p,Piont) True >>>isinstance(p,Piont) True
如果要用坐标和半径表示一个园，也可以用nameduple定义：
#namedtuple(‘名称‘，[属性list]): Circle=namedtuple(Circle‘,[‘x‘,‘y‘,‘r‘])
deque
deque是为了高效实现列表，适合队列和栈：
>>>from collections import deque >>>q=deque([‘a‘,‘b‘,‘c‘]) >>>q.append(‘x‘) >>>q.appendleft(‘y‘) >>>q deque([‘y‘,‘a‘,‘b‘,‘c‘,‘x‘])
deque除了实现listde append()和pop（）外，还支持append left（）和popleft()，这样就可以非常高效的往头部添加或删除元素
defaultdict
使用dict时，如果引用的Key不存在，就会抛出Key Error。如果不希望Key不存在时，返回一个默认值，就可以用defaultdict:
>>> from collections import defaultdict >>> dd = defaultdict(lambda: ‘N/A‘) >>> dd[‘key1‘] = ‘abc‘ >>> dd[‘key1‘] # key1存在 ‘abc‘ >>> dd[‘key2‘] # key2不存在，返回默认值 ‘N/A‘
ordereddict
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：
>>> from collections import OrderedDict
>>> d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
>>> d # dict的Key是无序的
{‘a‘: 1, ‘c‘: 3, ‘b‘: 2}
>>> od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
注意，orderdict的Key会按照插入的顺序排列，不是Key本身排序：
>>> od = OrderedDict() >>> od[‘z‘] = 1 >>> od[‘y‘] = 2 >>> od[‘x‘] = 3 >>> od.keys() # 按照插入的Key的顺序返回 [‘z‘, ‘y‘, ‘x‘]
ordereddict可以实现FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key：
from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict):
def __init__(self, capacity):
super(LastUpdatedOrderedDict, self).__init__()
self._capacity = capacity
def __setitem__(self, key, value):
containsKey = 1 if key in self else 0
if len(self) - containsKey >= self._capacity:
last = self.popitem(last=False)
print ‘remove:‘, last
if containsKey:
del self[key]
print ‘set:‘, (key, value)
else:
print ‘add:‘, (key, value)
OrderedDict.__setitem__(self, key, value)
Counter
counter是一个简单的计数器，例如，统计字符出现的个数：
>>>form collertions import Counter
>>>c=counter()
>>>for ch in ‘programming‘:
... c[ch]=c[ch]+1
...
>>>c
Counter({‘g‘,2,‘m‘:2,‘r‘:2,‘a‘:1,‘i‘:1,‘o‘:1,‘n‘:1,‘p‘:1})
Counter实际上也是dicde 一个子类，上面的结果可以看出，字符’g‘、‘m‘、‘r‘各出现了两次，其他字符各出现了一次。
2.12本章小结
基本数据类型：
可变的数据类型：list dict set
不可变数据类型：数字类（bool,int,float,cinpiex)、str tuple frozenset
扩展数据类型collectins:
1.namedtuple(): 生成可以使用名字来访问元素内容的tuple子类
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
原文地址：https://www.cnblogs.com/cnlogs1/p/9545188.html