一：获取列表的长度：使用len()
 
1:先定义一个列表
 
2：然后定义个一个变量length = len (列表名)
 
 
 
 
 
3：输出就可以。
 
 
 
 
 
二：我们现在进行多维列表的训练
 
1：我们可以定义一个变量
 
2：变量可以是一个多维列表
 
list= 【   【】，【】，【】 】这样就定义了一个多维列表。
 
我们可以访问列表。
 
3：进行一下测试。
 
 
 
 
 
 
 
 
 
 
 
 
 
 

      python的编程使用过程中，list列表结构我想是必不可少的，这也是python里面非常非常重要的一种数据结构，list可以用来模拟Queue队列还可以用来模拟Stack堆栈等等，非常的强大，今天在使用列表的时候有一个需求就是需要对嵌套列表进行排序，什么是嵌套列表呢，简单来说就是：列表内的元素也是列表，对于这样的列表对象我一般习惯称之为“嵌套列表”，当然如果只嵌套一层的话你也可以叫它矩阵。
 
      对于列表的排序，可以使用python内置的sort或者是sorted函数来快速地实现升序或者是降序的排序，但是对于嵌套列表这样的方法不能够直接使用了，因为在python中列表本身不是可直接比较的对象，sort和sorted就无法直接使用了，但是，无法直接使用并不代表不能使用，下面是我的具体实践，都很简单，觉得有必要总结一下，就在这里贴一下代码：
 
#!usr/bin/env python
#encoding:utf-8
from __future__ import division

'''
__Author__:沂水寒城
功能：  嵌套列表排序
'''

import operator


def sortFunc1(data_list,index=-3):
    '''
    借助于 operator 模块实现排序
    '''
    data_list.sort(key=operator.itemgetter(index)) 
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc2(data_list,index=-3):
    '''
    基于内置函数 sorted  实现排序
    '''
    data_list=sorted(data_list,key=lambda i:i[index])
    print '======================= sorted data_list ==================='
    print data_list
    data_list.sort(key=lambda i:i[index], reverse=True)
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc3(data_list):
    '''
    依据列表中元素的数量来排序
    '''
    data_list=sorted(data_list,key=lambda i:len(i))
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc4(data_list):
    '''
    依据列表中元素总和来排序
    '''
    data_list=sorted(data_list,key=lambda i:sum(i))
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc5(data_list):
    '''
    依据列表中元素绝对值的总和来排序
    '''
    data_list=sorted(data_list,key=lambda i:sum([abs(one) for one in i]))
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc6(data_list):
    '''
    依据列表中元素最大值来排序
    '''
    data_list=sorted(data_list,key=lambda i:max(i))
    print '======================= sorted data_list ==================='
    print data_list


def sortFunc7(data_list):
    '''
    依据列表中元素最小值来排序
    '''
    data_list=sorted(data_list,key=lambda i:min(i))
    print '======================= sorted data_list ==================='
    print data_list


if __name__=='__main__':
    data_list=[['A',2,3,'apple','p',45,9],['D',23,13,'orange','q',23,19],['C',12,3,'banana','s',22,29],['E',42,23,'water','p',14,98],
               ['F',2,3,'snow','k',5,8],['G',12,43,'rain','m',41,12],['L',12,33,'ice','n',15,19],['O',12,13,'cream','b',31,25]]

    sortFunc1(data_list,index=-3)
    sortFunc2(data_list,index=-3)


    data_list=[['E',42,12,23,'p',14,98],['A','p',45,9],['D',13,'orange','q',23,19],['C',3,'s',22,29],['E',42,12,23,'water','p',14,98]]
    sortFunc3(data_list)


    data_list=[[42,12,23,14,98],[45,9],[13,-100,3,19],[6,3,-5,22,29],[42,12,23,14,98]]
    sortFunc4(data_list)
    sortFunc5(data_list)
    sortFunc6(data_list)
    sortFunc7(data_list)
 
       结果如下：
 
======================= sorted data_list ===================
[['O', 12, 13, 'cream', 'b', 31, 25], ['F', 2, 3, 'snow', 'k', 5, 8], ['G', 12, 43, 'rain', 'm', 41, 12], ['L', 12, 33, 'ice', 'n', 15, 19], ['A', 2, 3, 'apple', 'p', 45, 9], ['E', 42, 23, 'water', 'p', 14, 98], ['D', 23, 13, 'orange', 'q', 23, 19], ['C', 12, 3, 'banana', 's', 22, 29]]
======================= sorted data_list ===================
[['O', 12, 13, 'cream', 'b', 31, 25], ['F', 2, 3, 'snow', 'k', 5, 8], ['G', 12, 43, 'rain', 'm', 41, 12], ['L', 12, 33, 'ice', 'n', 15, 19], ['A', 2, 3, 'apple', 'p', 45, 9], ['E', 42, 23, 'water', 'p', 14, 98], ['D', 23, 13, 'orange', 'q', 23, 19], ['C', 12, 3, 'banana', 's', 22, 29]]
======================= sorted data_list ===================
[['C', 12, 3, 'banana', 's', 22, 29], ['D', 23, 13, 'orange', 'q', 23, 19], ['A', 2, 3, 'apple', 'p', 45, 9], ['E', 42, 23, 'water', 'p', 14, 98], ['L', 12, 33, 'ice', 'n', 15, 19], ['G', 12, 43, 'rain', 'm', 41, 12], ['F', 2, 3, 'snow', 'k', 5, 8], ['O', 12, 13, 'cream', 'b', 31, 25]]
======================= sorted data_list ===================
[['A', 'p', 45, 9], ['C', 3, 's', 22, 29], ['D', 13, 'orange', 'q', 23, 19], ['E', 42, 12, 23, 'p', 14, 98], ['E', 42, 12, 23, 'water', 'p', 14, 98]]
======================= sorted data_list ===================
[[13, -100, 3, 19], [45, 9], [6, 3, -5, 22, 29], [42, 12, 23, 14, 98], [42, 12, 23, 14, 98]]
======================= sorted data_list ===================
[[45, 9], [6, 3, -5, 22, 29], [13, -100, 3, 19], [42, 12, 23, 14, 98], [42, 12, 23, 14, 98]]
======================= sorted data_list ===================
[[13, -100, 3, 19], [6, 3, -5, 22, 29], [45, 9], [42, 12, 23, 14, 98], [42, 12, 23, 14, 98]]
======================= sorted data_list ===================
[[13, -100, 3, 19], [6, 3, -5, 22, 29], [45, 9], [42, 12, 23, 14, 98], [42, 12, 23, 14, 98]]
 
      在日常的使用中，需要什么样的功能都可以基于上述的几个示例函数来进行改造，个人觉得还是比较方便的。

如果你看了很多其他博客然后都看不懂看到了这篇，你一定可以容易懂的！我佛了，这么简单的东西死板地讲题目不讲原理鬼看得懂啊，这种风气真的不行，我忍不住想骂一声垃圾，啥玩意儿，误人子弟！原理懂了啥题不会做？
 
要想知道 散列表查找失败的平均查找长度，就要知道什么叫做查找失败！举个栗子：8个数字  key%11  如下算好了：
 
散列地址
0
1
2
3
4
5
6
7
8
9
10
关键字
33
1
13
12
34
38
27
22
 
 
 
冲突次数
0
0
0
2
3
0
1
7
 
 
 
什么叫做查找失败？比如你要查55这个关键字，你必须%11，等于0，查地址0为33，不对，下一位1，不对，继续往下查找直到出现空的才知道这个关键字一定不存在，否则就放在空着的那个地址。所以以上表，计算地址为0的关键字查了9次才才知道没有这个关键字称为查找失败；计算地址为1的关键字只有探测完1-8号才能确定该元素不存在，以此类推。但是注意了，如果计算地址为8的或者9的、10的，只需要查找一次就知道该地址为空，失败了。因此查找一次就行。而且要知道如果查找成功是除以关键字个数，但是查找失败是除以你要模的数字本题是11，千万记住了，不是地址个数，不是关键字个数。综上所述，查找失败的平均查找长度为（9+8+7+6+5+4+3+2+1+1+1）/11=47/11。放心错不了，书上原题。
 
还要注意，如下题型H(key)=key%7：
 
散列地址
0
1
2
3
4
5
6
7
8
关键字
98
22
30
87
11
40
6
20
 
千万注意，%7只能映射到0-6，散列函数不可能映射7，因此查找失败平均查找长度为（9+8+7+6+5+4+3)/7=6。看到这你可能想骂娘，啥玩意儿，别急。我会让你看懂，因为我最讨厌虾鸡吧写博客的傻逼玩意儿，写的不清楚又不解释，还误人子弟，low咖！！！好了回归正题。首先要知道，我们求平均查找长度其实在求概率，对于成功的平均查找长度，查找每个元素的概率是1/8，这个8就是关键字个数。就是说，查找成功你只能选择8个中的一个，否则成功不了，所以都是在等概率1/8情况下。查找失败也是一样，这里对每个位置的查找概率都是1/7,注意7是你要模的数字，就是说，你随便拿几个数，模7，只能是0、1、2、3、4、5、6，其中一种情况，不可能是7、8以后的数字，所以只需要计算地址在0-6中的概率。如果计算地址后为0，那么需要比较9次，以此类推，所以只能是上面的计算式子，别搞错了噢！还有要注意有些散列表不是完全填满，中间有空位，那相信你看完上面原理就不用我解释了，找到了空位还没有就说明不存在嘛，否则它就占位这个空位了。注意以上所讨论的全部是线性探测，如果是平方探测注意左右跳动，具体问题具体分析，就不展开了。相信你看到这个已经真正明白了什么叫做查找失败平均查找长度。对于垃圾博客需要狠狠骂，对于我也是，我写的烂的大家给我狠狠骂，这样才能少一些误人子弟的渣渣了，只讲怎么怎么操作不讲原理有什么狗屁用，换个方式描述不还是不会。知其然要知其所以然！！！以上如果有错误，还请大家狠狠指出来，谢谢大家！
 
 
比如这篇博客，真佛了，一来就巴拉巴拉在那算算算，好像谁不会计算散列表似的，人家真正不懂的是查找失败的平均查找长度的计算，真正的标题党。垃圾文章！！！
 
 
 
 
 
 
 
 
 
 
 
 

前言:
 在利用线性探测再散列法处理冲突的散列表中,很多人对计算失败时的平均查找长度,作除数应该是散列表长,还是散列函数:mod后面的数不清楚,首先接下来我们先解决这一问题.
 
问题一:其除以的数是mod后面的数还是散列表长?
 
答:是散列表长.
 
首先我们要明确哈希表中下标每一个位置都有可能存储一个关键字数据,所以我们要求的失败平均查找长度即为:
 
失败平均查找长度=每一个位置查找失败的次数相加/哈希表长
 
那么每一个位置在什么情况下算是查找失败呢?
 在遇到第一个位置为NULL的时候才算失败,因为线性探测再散列法的设定,当哈希表为满表时,我们完全可以认为所有后面下标位置存储的数为下标为0时不断冲突得到的,比如mod为6,我们要存入序列{6,12,18,24,30,36}等序列.
 所以如果我们要找数字为30时,比较次数为5次,即我们用数除以mod得到散列函数值即下标为0,这时我们比较值6并不匹配,我们想会不会我们的要找的数在下标为0的时候出现了冲突,会不会线性探测再散列安排到了后面,所以我们延续着与下标为1的关键字值比较,这时比较值为12,依旧不匹配,那我们再想,会不会我们要找的数又发生了冲突,被线性探测再哈希安排到了后面,所以,我们只能再往后找,这时我们继续比较,依次类推我们当我们比较5次时,终于匹配上了我们要找的数.
 那如果我们要找的是42时,这时我们就能推出了下标为0时出现的失败次数,不断往后推,直到比较值为NULL,我们才算死心不再去找: 比较7次
 那下标为1时,失败次数会是多少呢?其实失败次数计算就是假设最极端的情况,不到黄河心不死,我们就认定我们要找的数如果与坐标位置不匹配,那就是发生冲突了,肯定在下一位.所以:
 当下标为1时:查找失败次数为6次,
 当下标为2时.查找失败次数为5次
 当下标为3时.查找失败次数为4次
 当下标为4时.查找失败次数为3次
 当下标为5时.查找失败次数为2次
 当下标为6时.查找失败次数为1次
 
因为我们的序列有6个数据元素,以上的推理皆是散列表长度为7时,推理的结果.下标为6的位置为NULL .
 
根据以上信息我们完全可以画出我们的散列表
 
关键字序列:{6,12,18,24,30,36},散列函数为H(Key)=Key MOD 6
 装填因子为6/7
 
 所以平均查找失败次数为
 (7+6+5+4+3+2+1)/7=4
 
例题:将关键字序列(7,8,30,11,18,6,13)散列存储在哈希表中,哈希存储空间是从下标0开始的一维数组,散列函数为H(Key)= Key MOD 7,处理冲突采用线性探测再散列法.要求装填因子为0.7
 (1) 画出构造的散列表:
 (2) 分别计算等概率情况下查找成功和查找失败时的平均查找长度:
 
 查找成功时的平均长度为:ASL(成功)=(1 * 5+2 * 2)/7=9/7
 查找失败时的平均长度为:
 ASL(失败)=(4+3+2+1+5+4+3+2+1+1)/10=26/10=13/5