python列表评价

1. 能不能详细解释下python列表

一、概念

在Python中，列表(list)是常用的数据类型。列表由一系列按照特定顺序排列的项(item)组成。列表用方括号“[]”括起来，并用逗号“,”来分隔其中的项。

例如，下面的列表包含了几种用字符串表示的水果：

列表中的项和项之间的数据类型也可以不同。例如，下面的列表包含了数字和字符串：

关于Python的基础问题可以看下这个网页的视频教程，网页链接，希望我的回答能帮到你。

2. python 数组和列表的区别

python没有数组，只有元组(tuple)和列表(list)。
元组与列表最大的不同在于，元组一旦创建便不可改变，
因此不像列表，元组不能够在末尾追加(append)元素，弹出(pop)元素，
只能对元组中的元素进行索引t[0]，不能对其中的元组进行赋值t[0]=8。
使用元组的好处在于对元组进行操作更为高效，适合存放一组常量。

3. python中列表和元组之间有什么区别

除了元组是不可变的之外，还应有语义上的区别来指导它们的用法。元组是异构数据结构（即它们的条目具有不同的含义），而列表是同类序列。元组具有结构，列表具有顺序。
使用这种区别可以使代码更加明确和易于理解。
一个示例是成对的页和行号，以成对参考书中的位置，如：
my_location = (42, 11) # page number, line number

然后，可以将其用作字典中的键来存储有关位置的注释。另一方面，列表可用于存储多个位置。自然地，人们可能想在列表中添加或删除位置，因此使列表可变是有意义的。另一方面，从现有位置添加或删除项目没有意义-因此，元组是不可变的。
在某些情况下，可能想更改现有位置元组中的项目，例如在页面的各行中进行迭代时。但是元组不变性迫使您为每个新值创建一个新的位置元组。从表面上看，这似乎很不方便，但是使用这样的不可变数据是值类型和函数式编程技术的基石，它可以具有很多优点。
官方Python文档也提到了这一点
“组是不可变的，并且通常包含一个异类序列…”。
在像Haskell这样的静态类型语言中，元组中的值通常具有不同的类型，并且元组的长度必须固定。在列表中，所有值都具有相同的类型，并且长度不是固定的。因此区别非常明显。

4. Python判断列表是否已排序的各种方法及其性能

本节判断列表排序的函数名格式为IsListSorted_XXX()。为简洁起见，除代码片段及其输出外，一律以_XXX()指代。
2.1 guess
def IsListSorted_guess(lst):
listLen = len(lst) if listLen <= 1: return True

#由首个元素和末尾元素猜测可能的排序规则
if lst[0] == lst[-1]: #列表元素相同
for elem in lst: if elem != lst[0]: return False
elif lst[0] < lst[-1]: #列表元素升序
for i, elem in enumerate(lst[1:]): if elem < lst[i]: return False
else: #列表元素降序
for i, elem in enumerate(lst[1:]): if elem > lst[i]: return False

return True

_guess()是最通用的实现，几乎与语言无关。值得注意的是，该函数内会猜测给定列表可能的排序规则，因此无需外部调用者指明排序规则。
2.2 sorted
def IsListSorted_sorted(lst):
return sorted(lst) == lst or sorted(lst, reverse=True) == lst

_sorted()使用Python内置函数sorted()。由于sorted()会对未排序的列表排序，_sorted()函数主要适用于已排序列表。
若想判断列表未排序后再对其排序，不如直接调用列表的sort()方法，因为该方法内部会判断列表是否排序。对于已排序列表，该方法的时间复杂度为线性阶O(n)——判断为O(n)而排序为O(nlgn)。
2.3 for-loop
def IsListSorted_forloop(lst, key=lambda x, y: x <= y):
for i, elem in enumerate(lst[1:]): #注意，enumerate默认迭代下标从0开始
if not key(lst[i], elem): #if elem > lst[i]更快，但通用性差
return False
return True

无论列表是否已排序，本函数的时间复杂度均为线性阶O(n)。注意，参数key表明缺省的排序规则为升序。
2.4 all
def IsListSorted_allenumk(lst, key=lambda x, y: x <= y):
return all(key(lst[i], elem) for i, elem in enumerate(lst[1:]))import operatordef IsListSorted_allenumo(lst, oCmp=operator.le):
return all(oCmp(lst[i], elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allenumd(lst):
return all((lst[i] <= elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allxran(lst, key=lambda x,y: x <= y):
return all(key(lst[i],lst[i+1]) for i in xrange(len(lst)-1))def IsListSorted_allzip(lst, key=lambda x,y: x <= y):
from itertools import izip #Python 3中zip返回生成器(generator)，而izip被废弃
return all(key(a, b) for (a, b) in izip(lst[:-1],lst[1:]))

lambda表达式与operator运算符速度相当，前者简单灵活，后者略为高效(实测并不一定)。但两者速度均不如列表元素直接比较(可能存在调用开销)。亦即，_allenumd()快于_allenumo()快于_allenumk()。
若使用lambda表达式指示排序规则，更改规则时只需要改变x和y之间的比较运算符；若使用operator模块指示排序规则，更改规则时需要改变对象比较方法。具体地，lt(x, y)等效于x < y，le(x, y)等效于x <= y，eq(x, y)等效于x == y，ne(x, y)等效于x != y，gt(x, y)等效于x > y，ge(x, y)等效于x >= y。例如，_allenumo()函数若要严格升序可设置oCmp=operator.lt。
此外，由all()函数的帮助信息可知，_allenumk()其实是_forloop()的等效形式。
2.5 numpy
def IsListSorted_numpy(arr, key=lambda dif: dif >= 0):
import numpy try: if arr.dtype.kind == 'u': #无符号整数数组执行np.diff时存在underflow风险
arr = numpy.int64(lst) except AttributeError: pass #无dtype属性，非数组
return (key(numpy.diff(arr))).all() #numpy.diff(x)返回相邻数组元素的差值构成的数组

NumPy是用于科学计算的Python基础包，可存储和处理大型矩阵。它包含一个强大的N维数组对象，比Python自身的嵌套列表结构(nested list structure)高效得多。第三节的实测数据表明，_numpy()处理大型列表时性能非常出色。
在Windows系统中可通过pip install numpy命令安装NumPy包，不建议登录官网下载文件自行安装。
2.6 rece
def IsListSorted_rece(iterable, key=lambda x, y: x <= y):
cmpFunc = lambda x, y: y if key(x, y) else float('inf') return rece(cmpFunc, iterable, .0) < float('inf')

rece实现是all实现的变体。累加器(accumulator)中仅存储最后一个检查的列表元素，或者Infinity(若任一元素小于前个元素值)。
前面2.1~2.5小节涉及下标操作的函数适用于列表等可迭代对象(Iterable)。对于通用迭代器(Iterator)对象，即可以作用于next()函数或方法的对象，可使用_rece()及后面除_rand()外各小节的函数。迭代器的计算是惰性的，只有在需要返回下一个数据时才会计算，以避免不必要的计算。而且，迭代器方式无需像列表那样切片为两个迭代对象。
2.7 imap
def IsListSorted_itermap(iterable, key=lambda x, y: x <= y):
from itertools import imap, tee
a, b = tee(iterable) #为单个iterable创建两个独立的iterator
next(b, None) return all(imap(key, a, b))

2.8 izip
def IsListSorted_iterzip(iterable, key=lambda x, y: x <= y):
from itertools import tee, izip
a, b = tee(iterable) next(b, None) return all(key(x, y) for x, y in izip(a, b))def pairwise(iterable):
from itertools import tee, izip
a, b = tee(iterable) next(b, None) return izip(a, b) #"s -> (s0,s1), (s1,s2), (s2, s3), ..."def IsListSorted_iterzipf(iterable, key=lambda x, y: x <= y):
return all(key(a, b) for a, b in pairwise(iterable))

第三节的实测数据表明，虽然存在外部函数调用，_iterzipf()却比_iterzip()略为高效。
2.9 fast
def IsListSorted_fastd(lst):
it = iter(lst) try:
prev = it.next() except StopIteration: return True
for cur in it: if prev > cur: return False
prev = cur return Truedef IsListSorted_fastk(lst, key=lambda x, y: x <= y):
it = iter(lst) try:
prev = it.next() except StopIteration: return True
for cur in it: if not key(prev, cur): return False
prev = cur return True

_fastd()和_fastk()是Stack Overflow网站回答里据称执行最快的。实测数据表明，在列表未排序时，它们的性能表现确实优异。
2.10 random
import randomdef IsListSorted_rand(lst, randNum=3, randLen=100):
listLen = len(lst) if listLen <= 1: return True

#由首个元素和末尾元素猜测可能的排序规则
if lst[0] < lst[-1]: #列表元素升序
key = lambda dif: dif >= 0
else: #列表元素降序或相等
key = lambda dif: dif <= 0

threshold, sortedFlag = 10000, True
import numpy if listLen <= threshold or listLen <= randLen*2 or not randNum: return (key(numpy.diff(numpy.array(lst)))).all() from random import sample for i in range(randNum):
sortedRandList = sorted(sample(xrange(listLen), randLen))
flag = (key(numpy.diff(numpy.array([lst[x] for x in sortedRandList])))).all()
sortedFlag = sortedFlag and flag return sortedFlag

_rand()借助随机采样降低运算规模，并融入其他判断函数的优点。例如，猜测列表可能的排序规则，并在随机采样不适合时使用相对快速的判断方式，如NumPy。
通过line_profiler分析可知，第20行和第21行与randLen有关，但两者耗时接近。因此randLen应小于listLen的一半，以抵消sorted开销。除内部限制外，用户可以调节随机序列个数和长度，如定制单个但较长的序列。
注意，_rand()不适用于存在微量异常数据的长列表。因为这些数据很可能被随机采样遗漏，从而影响判断结果的准确性。

5. python列表有哪些深入的特性

迭代 iterable 里所有内容, 每一次迭代, 都把 iterable 里相应内容放到 iter_var 中, 再在表达式 exp 中应用该 iter_var 的内容, 最后用表达式的计算值生成一个新的列表.

6. 在Python中列表与字符串这两种数据结构有何区别你认为采用哪种更可靠

字符串是immutable的，list是mutable的

也就是说字符串一旦定义不可改变，list则可以。

eg.

s="abc"
d=['a','b','c']
d.append('e')

而

new_s=s+'e'

而且，

immutable意味着可以作字典的key，而mutable则不可。

此外两种东西的方法不同。

7. Python 列表

是不是这个list让你感觉有些困扰呢，你看一下我下面的表示方式：

你的list和我的abc都是表示一个列表名。

del abc[1]：调用系统方法del，删除列表abc中索引为1的项；

abc.pop()：调用列表（这里为abc）本身的方法pop()，删除abc列表的最后一项。

abc[1]中用方括号是列表的索引操作，为列表自身的规则；pop()中也可以传入参数用于表示索引位置，但此处为向方法内传入位置参数。

方法来源不一样，使用规则有差别。

8. python中的列表中常用的方法有哪些，分别是什么作用

Python列表定义:按特定顺序排列的元素组成。在Python中，用方括号[]来表示列表，并用逗号来分隔其中的元素。Python列表是编程中很常见的数据类型 。
列表是一种可修改的集合类型，其元素可以是数字、string等基本类型，也可以是列表、元组、字典等集合对象，甚至可以是自定义的类型。其定义方式如下：>>> nums = [1,2,3,4]>>> type(nums)>>> print nums[1, 2, 3, 4]>>> strs = ["hello","world"]>>> print strs['hello', 'world']>>> lst = [1,"hello",False,nums,strs]>>> type(lst)>>> print lst[1, 'hello', False, [1, 2, 3, 4], ['hello', 'world']]
下面我们来看一下列表中有哪些常见的方法：count():统计某个元素在列表中出现的次数。index():从列表中找出某个值第一个匹配项的索引位置。append():在列表末尾添加新对象。extend():在列表末尾一次性追加另一个序列的多个值。insert():在列表的指定位置插入对象。pop():移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值。remove():移除列表中某个值的第一个匹配项。reverse():将列表中的元素反向，不重新拷贝一个列表。reversed():将列表中的元素反向，重新拷贝一个列表。sort():将列表中的元素排序，不重新拷贝一个列表。sortd():将列表中的元素排序，重新拷贝一个列表。():浅拷贝，只是给原来的列表贴上了一个新标签，对于一个复杂对象的子对象并不会完全复制，如果有子列表，改变原来的值，新的拷贝对象也会改变。deep():深拷贝，将复杂对象的每一层复制一个单独的个体出来。就是完全拷贝。常见内置函数：max()、min()、sum()、len()、all()、any()、zip()、enumerate()

9. python的元组和列表的区别

1. 元组一旦设定不可改变，试图改变会出错

2. 第一条带来一个好处，就是元组可以用作字典的键，可以排列，等等（“因为有了哈希值”）

列表随意改，长度和内容都可变

10. Python列表操作

1、append（）
append()对于列表的操作主要实现的是在特定的列表最后添加一个元素，并且只能一次添加一个元素，并且只能在列表最后；
m.append(元素A)
2、extend（）
extend（）对于列表的操作主要实现的是对于特定列表的扩展和增长，可以一次添加多个元素，不过也只能添加在列表的最后；
m.extend([元素A，元素B，……])
3、insert（）
insert（）对于列表的操作主要是在列表的特定位置添加想要添加的特定元素，比较常用，这里的特定位置是指元素所在列表中的位置索引号，需要注意的是这里的索引号都是从0开始的，不是从1开始的，这个大家需要特别注意。
m.insert(A,元素B)：表示在列表m里面的第A+1处加入元素B

1、m.remove()
m.remove的作用是移除掉列表m里面的特定元素；
m.remove(元素A)
2、del m[n]
它的作用是删除掉列表里面的索引号位置为n 的元素，这里需要注意的是del是一种操作语句。
del m[n]
3、m.pop（）
它的作用是将列表m的最后一个元素返回，并且在此基础上进行删除掉

1、Temp=m[n]
获取m列表第n+位置处的元素

1、Temp=m[A:B]
表示将m列表里从索引号位置为A开始的元素到B-1处元素之间的列表获取赋给temp.

1、+:它主要实现的是多个列表之间的拼接
常见的列表操作符
2、*：主要实现的是列表的复制和添加
3、比较>,<:主要进行数据型列表的元素比较
4、and等：；逻辑运算符，可以进行列表之间的逻辑判断

1、m.count(A)：输出元素A在列表m里面出现的次数
2、m.index(A)：输出元素A在列表m里面的索引位置号
m.index(A,a,b)：对于列表m里面包含多个元素A时，输出在列表m索引号a-b之间的特定索引号
3、m.reverse()：将列表m进行前后的翻转，前变后，后变前
4、m.sort()：将列表m里面地数据进行从小到大的排列
5、m.sort(reverse=True)：将列表m里面地数据进行从大到小的排列
其实对于列表m里面的元素进行从大到小的排列还可以用以下方法：
N=m.sort()
N.reverse()

1） 深拷贝：
M=[A,b,a,c]
N=M[:]
2） 浅拷贝：
N=M