1、列表

     （1）定义：通过中括号括起、逗号分隔的一组数据

     （2）基本的列表操作：

          给元素赋值

>>> x = [1,1,1]>>> x[1] = 2>>> x[1, 2, 1]

          删除元素

>>> name = ['xiaoming','xiaohong','xiaohei']>>> del name[2]>>> name['xiaoming', 'xiaohong']

          给切片赋值

>>> name = list('zhang')>>> name['z', 'h', 'a', 'n', 'g']>>> name[2:] = list('11')>>> name['z', 'h', '1', '1']

          还可以不替换原有元素的情况下插入元素

>>> name = list('zhang')>>> name['z', 'h', 'a', 'n', 'g']>>> name[1:1] = [1,2,3]>>> name['z', 1, 2, 3, 'h', 'a', 'n', 'g']

          替换空切片

>>> name = list('zhang')>>> name['z', 'h', 'a', 'n', 'g']>>> name[1:4] = []>>> name['z', 'g']

     （3）列表方法：

          list.append(x)：在列表的末尾添加一个元素。相当于a[len(a)] = [x]

>>> a = [1,2,3]>>> b = [4,5,6]>>> a.append(b)>>> a[1, 2, 3, [4, 5, 6]]

          list.insert(i, x)：在给定的位置插入一个元素。第一个参数是要插入的元素的索引，以a.insert(0, x)插入列表头部，a.insert(len(a), x)等同于a.append(x)

          list.remove(x)：移除列表中第一个值为x的元素。如果没有这样的元素，则抛出异常ValueError

          list.pop([i])：删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop()将会删除并返回列表中的最后一个元素

          list.sort(key=None,reverse=False)：对列表中的元素进行排序（参数可用于自定义排序，解释请参考见sorted()）

          list.reverse()：反转列表中的元素

          list.clear()：删除列表中所有的元素。相当于del a[:]

          list.extend(iterable)：使用可迭代对象中的所有元素来扩展列表。相当于a[len(a)] = iterable

>>> a = [1,2,3]>>> b = [4,5,6]>>> a.extend(b)>>> a[1, 2, 3, 4, 5, 6]

          list.count(x)：返回元素x在列表中出现的次数

          list.copy()：返回列表中的一个浅拷贝。相当于a[:]

          list.index(x[,start[,end]])：返回列表中第一个值为x的元素的从零开始的索引。如果没有这样的元素将会抛出ValueError异常。       可选参数start和end是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是start参数。

注意：

          insert， remove或者sort方法，只修改列表，并没有打印返回值——它们返回默认值None。这是python中所有可变数据结构的设计原则。

          并非所有数据或可以排序或者比较（字符串和数字等）

     （3）列表推导式

          list = [i**2 for i in rang(1,4)]

          list = [i**2 for i in rang(1,4) if i !=1]

          list = [i**j for i in rang(1,4) for j in rang(1,4)]

2、元组

     （1）定义：元组使用()进行定义，tuple、list、range都是序列数据类型，元组是不可变的，可以通过解包、索引来访问

     （2）元组的不可变特性：

          当元组中嵌套列表时可以修改

>>> a = [1,2,3]>>> b = (1,2,a)>>> b(1, 2, [1, 2, 3])>>> b[2][0] = "a">>> b(1, 2, ['a', 2, 3])

     （3）元组方法：

          tuple.count(x)：返回元素x在元组中出现的次数

          tuple.index(x)：返回列表中第一个值为x的元素的从零开始的索引。如果没有这样的元素将会抛出ValueError异常。

3、集合

     （1）定义：集合是由不重复元素组成的无序的集，它的基本用法包括成员检测和消除重复元素，可以使用{}或者set()函数创建集合，要创建一个空集合只能用set()而不能用{}

     （2）集合的特性：

          不同元素组成、无序、集合中的元素必须是不可变类型

     （3）集合方法：

          自动去重：集合是有不同元素组成，所以即便里面的值重复了，也会去重。

>>> a ={1,1,2,2,3,3}>>> a{1, 2, 3}

          打印内容是无序的：

>>> a ={'你','是', '谁'}>>> a{'谁', '你', '是'}

          set.add(x)：在集合set中添加一个元素x

          set.pop()、set.remove(x)和set.discard(x)：pop会从集合中随机删除一个数,remove 可以传参数删除指定的值，但是要注意，如果传的值不存在会报错。discard()与remove()用法相同，但是如果元素不存在，不会报错。

          set.intersection(x)：取set与x的交集

          set.union(x)：取set与x的并集

          set.difference(x)：取set与x的差集

          set.symmetric_difference(x)：取set与x的交叉补集，集合A 是1、2、3 集合B 是 2、3、4 交叉补集就只保留 1 和 4 。因为 1 是 A 独有的， 4 是B 独有的。交叉补集会去掉共有的部分，只保留双方独有的部分。

4、字符串

     （1）定义：字符串使用引号进行定义

     （2）字符串方法：

          str.center(w,“f”)：在两边填充w个字符f（默认为空格），让字符串居中

          str.find(x)：在字符串中查找子串x，如果找到就返回子串的第一个字符的索引，否则返回-1

          str.join(x)：合并字符串

>>> dirs = '','user','bin'>>> '/'.join(dirs)'/user/bin'>>> print('c:'+ '\\'.join(dirs))c:\user\bin

          str.lower()：返回字符串的小写版本

          str.replace(‘ab’,‘cd’)：将字符串中的子串ab替换为cd，并返回替换后的结果

          str.split()：切割字符串

          str.strip()：将字符串开头和末尾的空白（不包括中间的空白）删除，并返回删除后的结果

          str.translate()：同replace一样替换字符，不同点的是他只能进行单字符替换

5、字典

     （1）定义：字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可能是数、字符串或者元组。

     （2）创建字典：第一种：item = {“a”:1,“b”:2},第二种：item = dict(a=1, b=2)

     （3）基本的字典操作：

          len(d)：返回字典d包含的项（键-值对）数

          d[k]：返回与键k相关联的值

          d[k] = v：将值v关联到键k

          del d[k]：删除键为k的项

          k in d：检查字典d是否包含键为k的项

     （4）字典方法：

          dict.update(x)：对于通过参数提供的字典，将其项添加到当前字典中，如果当前字典包含键相同的项，就替换它

          dict.clear()：删除所有的字典项，这种操作是就地执行的（就像list.sort一样），因此什么都不返回（或者说返回None）

          dict.copy()：返回一个新字典，其包含的键-值对与原来的字典相同（这个方法执行的是浅复制，因为值本身是原件，而非副本）

>>> x = {'username':'admin','password':['foo','bar','baz']}>>> y = x.copy()>>> y['username'] = 'zhs'>>> y['password'].remove('bar')>>> y{'username': 'zhs', 'password': ['foo', 'baz']}>>> x{'username': 'admin', 'password': ['foo', 'baz']}

可以看到，当替换副本中的值是，原件不受影响。然而，如果修改副本中的值，原件也将发生变化，为避免这种问题，一种办法是执行深复制，可使用模块copy中的函数deepcopy。

          dict.fromkeys()：创建一个新字典，其中包含指定的键，且每个键对应的值都是None。

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

如果不想使用默认值None，可提供特定的值

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

          dict.get(‘name’, ‘N/A’)：访问字典中name的值，不存在时返回N/A（默认返回None）

          dict.items()：返回一个包含所有字典项的列表

          dict.keys()：返回一个字典视图，其中包含指定字典中的键

          dict.values()：返回一个由字典中的值组成的字典视图，不同于方法keys，方法values返回的视图可能包含重复的值

          dict.pop(‘x’)：获取与键x相关联的值，并将该键-值对从字典中删除

          dict.popitem()：随机的删除一个字典项

          dict.setdefault()：与get相似，也是获取与指定键相关联的值，但setdefault还在字典不包含指定的键时，在字典中添加指定的键-值对

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