python 基础数据类型 之 列表

Posted 2020-12-02 yanxiatingyu

列表：定义 和特性

列表定义和创建：

　　定义：[,]内以逗号分隔，按照索引，存放各种数据类型，一般没有限制，每个位置代表一个元素

　　

range_create = list(range(0, 10))
print(range_create)
>>:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

str = ‘yanxiatingyu‘
str_create = list(str)
print(str_create)
>>:[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]

iter_create=[lis for lis in range(0,10)]
print(iter_create)
>>:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

特性：
1.可以存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3.可修改指定索引位置对应的值，可变

#取值
#索引 取值 基本上和string 操作差不多
name=‘yanxiatingyu‘
name_list=list(name)
print(name_list[0])
>>:y

print(name_list[：])#不设限

print(name_list[：：2])#正向步长

print(name_list[::-1])#取反

#追加
name_list.append(‘new_element‘)


#在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
#插入
name_list.insert()

name_list=(‘yan xia ting yu‘).split()
print(name_list)
name_list.insert(3,‘hello insert‘)
print(name_list)
[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]
[‘yan‘, ‘xia‘, ‘ting‘, ‘hello insert‘, ‘yu‘]

#删除 
方式一
　　name_list.remove(‘new_element‘)

方式二
name_list.append(‘new_element‘)
del name_list[name_list.index(‘new_element‘)]
print(name_list)

list.pop() 删最后一个元素

list.pop(n)指定下标，删除指定的元素，如果删除一个不存在的元素会报错

list.remove(xx) 删除list 里面的一个元素，有多个相同的元素，删除第一个 

print(list.pop()) 有返回值

print(list.remove()) 无返回值

del  list[n] 删除指定下标对应的元素 

del list 删除整个列表， list删除后无法访问

 

 

list.reverse()将列表反转

list.sort()排序，默认升序

list.sort(reverse=True) 降序排列

注：list 中有字符串，数字时不能排序，排序针对同类型

六，列表操作的函数

1、len(list)：列表元素个数 
2、max(list)：返回列表元素最大值 
3、min(list)：返回列表元素最小值 
4、list(seq)：将元组转换为列表

5、enumerate 用法（打印元素对应的下标）

同时取下标，元素

长度
print(len(name_list))


【in 与 not in 操作符】包含 与 不包含关系

if ‘new_element‘ in name_list:
　　print(‘存在此元素‘)
if ‘new_element‘ not in name_list:
　　print(‘不存在此元素‘)

【count 统计字符在list出现的次数】
print(name_list.count(‘统计‘))

【查找值，并且返回索引】
name_list.index(‘a‘)#假如存在则返回元素第一次出现处的索引，不存在报错：ValueError:element is not in list

name_list.index(‘a‘,0,5)#返回element 在指定切片内第一次出现的位置

三，查看列表中的值

print(list)    遍历列表

等价于    for i in list:

                      print i

print(list[n])  使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符

print(list.count(xx)) 查看某个元素在这个列表里的个数，如果改元素不存在，那么返回0

print(list.index(xx))找到这个元素的小标，如果有多个，返回第一个，如果找一个不存在的元素会报错

【list 与 可迭代循环】
for i,item in enumerate(name_list):#可迭代循环
　　print(‘name_list[%s]:%s‘%(i,item))


#列表与字符串
name=‘yan xia ting yu‘
name_list=name.split(‘ ‘)
print(name_list)
>>:[‘yan‘,‘xia‘,‘ting‘,‘yu‘]

print(‘ ‘.join(name_list))
>>:yan xia ting yu

#列表 高级操作 以及 效率问题
name_list = (‘yan xia ting yu‘).split(‘ ‘)
list_zhang = ‘zhang huan huan‘.split(‘ ‘)
name_list += list_zhang
#说明：用 + 号连接符此效率较低，
# 先创建新列表，并将所有对象复制过去，
# 而用extend将元素附加到现有列表
# (尤其是在构建一个大列表时)就会好很多
name_list.extend(list_zhang)
print(name_list)





#排序
#用sort方法可以实现就地排序(无需创建新对象，字符串按首字母进行排序)
name=‘yanxiatingyu‘
name_list=list(name)
print(name_list)
name_list.sort()
print(name_list)
#[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘, ‘zhang‘, ‘huan‘, ‘huan‘, ‘zhang‘, ‘huan‘, ‘huan‘]
#[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]
#[‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]
#sort有几个很好用的选项，一个是次要排序键，
# 即一个能够产生可用于排序的值的函数。如可以通过长度对一组字符串进行排序
#使用sort 排序 不会返回新列表

name_list=list(‘yanxiatingyu‘)
name_list.sort(key=len)#
print(name_list)
>>:[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]
#是否进行降序排列：
# 下面例子是根据首字母进行排序操作

name_list.sort(key= lambda  x:x[0],reverse=True)
print(name_list)）

>>:[‘y‘, ‘y‘, ‘x‘, ‘u‘, ‘t‘, ‘n‘, ‘n‘, ‘i‘, ‘i‘, ‘g‘, ‘a‘, ‘a‘]

二分搜索及维护有序列表（bisect）

       内置的bisect模块实现了二分查找以及对有序列表的插入操作。bisect.bisect可以找出新元素应该被插入到哪个位置以保持元列表的有序性，bisect.insort则将新元素插入到那个正确的位置上。

  注意：bisect模块的函数不会判断原列表是否有序，因为这样做开销太大；因此将他们用作无序列表时虽然不会出错，但可能会导致不正确的结果。基于此，建议在使用bisect模块的函数前，先对原列表执行排序的操作。

#https://blog.csdn.net/shaxiaozilove/article/details/79685168 　　　　#原文：管理list操作
#https://www.cnblogs.com/yanxiatingyu/p/9277019.html　　　　　　　　　　#关于bisect 模块
#https://www.cnblogs.com/skydesign/archive/2011/09/02/2163592.html　　#关于bisect模块

切片（索引运算符[]及start：stop）

       可以对序列类型（数组、列表、元组等）进行切片操作，start索引处元素被包括在切片的结果中，stop索引处的元素未被包括在结果中，元素数量为 stop-start。start或stop都是可以省略的，此时他们分别默认为序列的起始处和结尾处。

 

切片操作：可以参考我的博文，striing 这块

列表内置的序列函数 enumerate

enumerate函数可以逐个返回序列的(key，value)组合，你可以根据这个得到自己想要的容器类型
如下：

name = ‘yanxiatingyu‘
name_list = list(name)
name_dict= dict((key + 1, value) for key, value in enumerate(name_list))
print(type(name_dict), name_dict)
>>:<class ‘dict‘> {1: ‘y‘, 2: ‘a‘, 3: ‘n‘, 4: ‘x‘, 5: ‘i‘, 6: ‘a‘, 7: ‘t‘, 8: ‘i‘, 9: ‘n‘, 10: ‘g‘, 11: ‘y‘, 12: ‘u‘}

六，列表操作的函数

1、len(list)：列表元素个数 
2、max(list)：返回列表元素最大值 
3、min(list)：返回列表元素最小值 
4、list(seq)：将元组转换为列表

5、enumerate 用法（打印元素对应的下标）

同时取下标，元素

#sorted()排序是返回一个新的list
#sort()是就地排序
print(sorted(name_list))
[‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]

#sorted 和set 配合使用，得到一个有序，元素不重复的    list

print(sorted(‘yan xia ting yu‘))
print(sorted(set(‘yan xia ting yu‘)))
# [‘ ‘, ‘ ‘, ‘ ‘, ‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]
# [‘ ‘, ‘a‘, ‘g‘, ‘i‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘]
print(set(‘yan xia ting yu‘))
print(set(sorted(‘yan xia ting yu‘))) #字典是无序的，所以下列内容也是无序的，不信可以试一试多运行几遍
# {‘i‘, ‘a‘, ‘x‘, ‘g‘, ‘ ‘, ‘n‘, ‘y‘, ‘t‘, ‘u‘}
# {‘i‘, ‘a‘, ‘g‘, ‘x‘, ‘ ‘, ‘n‘, ‘u‘, ‘t‘, ‘y‘}

zip用于将多个序列（列表、元组等）中的元素“配对”，从而产生一个新的元组列表；zip可以接受任意数量的序列，最终得到的元组数量由最短的序列决定；zip最常见的用法是同时迭代多个序列，还可以结合enumerate一起使用，如下：

 

name = ‘yan xia ting yu‘
name_list =name.split()
print(name_list)
girl=‘girl1 girl2 girl3 girl4‘
girl_list=girl.split()
print(girl_list)
iter_zip=zip(girl_list,name_list)
print(type(iter_zip))
print(‘iter_zip‘)
for v,k in iter_zip:
    print(v,k)

print(‘enumerate(iter_zip)‘)
for i,v in enumerate(iter_zip):#这里无法输出？
    print(‘%s %s ‘%(i+1,v))

print(‘enumerate(zip(girl_list,name_list))‘)
for i,(v,k) in enumerate(zip(girl_list,name_list)):
    print(‘%s %s %s‘%(i+1,v,k))

# [‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]
# [‘girl1‘, ‘girl2‘, ‘girl3‘, ‘girl4‘]
# <class ‘zip‘>
# iter_zip
# girl1 yan
# girl2 xia
# girl3 ting
# girl4 yu
# enumerate(iter_zip)
# enumerate(zip(girl_list,name_list))
# 1 girl1 yan
# 2 girl2 xia
# 3 girl3 ting
# 4 girl4 yu

 对于“已压缩的”（zipped）序列，zip还有一个很巧妙的用法，即对该序列进行解压（unzip，用*表示）
。其实就是             【将一组行转换为一组列】
如下：

teacher=[(‘egon‘,18),(‘lqz‘,16),(‘wxx‘,20)]
name,age=zip(*teacher)
print(type(name),name)
# <class ‘tuple‘> (‘egon‘, ‘lqz‘, ‘wxx‘)
print(type(age),age)
# <class ‘tuple‘> (18, 16, 20)


teacher=[(‘egon‘,18),(‘lqz‘,16)]
name1,name2=zip(teacher)
print(type(name1),name1)
# <class ‘tuple‘> ((‘egon‘, 18),)
print(type(name2),name2)
# <class ‘tuple‘> ((‘lqz‘, 16),)
name_list=(‘yan xia ting yu‘).split()
print(name_list)
[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]

【数据解压】
x,y,z,_=name_list
print(_)
x,y,*_=name_list
print(x)
print(*_)

#yu
#yan
#ting yu

#逆向排序 reversed()    函数是返回序列seq的反向访问的迭代子。参数可以是列表，元组，字符串，不改变原对象。

print([x for x in reversed([1,2,5,4,-1])])

>>:[-1, 4, 5, 2, 1]

head　first Python 总结：

1，列表是一个有序的对象集合
2，一个对象在另外一个对象中吗？用 in 来检查

3，从列表中删除对象 remove
remove:取一个对象值作为唯一参数。remove方法会从列表中删除指定数据值的第一次出现。

如果在列表中找到了这个数据值，就会从列表中删除包含这个值的对象（同时列表的大小减一）。如果在列表中没有找到这个数据值，会报错。

4，从列表中弹出对象 pop
pop:取一个可选的索引值（indexof）作为参数。pop方法根据对象的索引值从现有列表删除和返回一个对象。

如果调用pop时没有指定索引值，将删除和返回列表中的最后一个对象。如果指定了一个索引值，则会删除和返回那个位置上的对象。

如果列表为空或者调用pop时指定了一个不存在的索引值，会报错。

5，用对象扩展列表 extend 
extend:取一个对象列表作为唯一参数。extend方法接收第二个列表，将其中的各个对象增加到现有列表。如果要将两个列表合并为一个列表，这个方法就非常有用。

6，在列表中插入一个对象 insert/append
insert:取一个索引值和一个对象作为参数。insert 方法将一个对象插入到现有列表中指定索引值的前面。

这样就可以将对象插入到现有列表的开头，或者插入到列表中的任何位置。要把对象插入到列表末尾，用append 。用法 num.insert(2,"abc")

7，如何复制一个数据结构？不要使用赋值操作符复制列表；应当使用copy方法。
赋值操作都指向同一个数据，如果修改一个列表，另一个也会改变；如果想让另一个变量引用一个现有列表，可以使用赋值操作（=）
copy:list2 = list1.copy() ；如果想建立现有列表中对象的副本，用他们初始化一个新列表，就一定要使用copy 方法

8，列表切片的使用【start:stop:step】不包含stop 索引值
step 为正数时，从右至左；step 为负数时，从左至右