列表 在py中是有序集合对象 类型 字符创是不能去修改 而列表是可以的

列表是以方括号为表示的 【】里面的元素用逗号隔开

python map方式是什么

列表是有序的所以 可以通过索引get需要的值

矩阵可以通过列表来实现

pop和栈的方式 是一样的 取的是最后的一个值

列表：重要数据类型

列表中的对象可以是任何对象，列表是可变对象，支持原处修改的操作

Python列表是：

有序对象的有序集合

通过偏移读取

可变长度、异构以及任意嵌套

属于可变序列的分类

对象引用数组

列表的操作与字符串相同

列表的迭代

for i inlist：

      print（）

为了兼容Python 3 和 2的版本需要对数据进行适当的处理

列表的索引、分片和矩阵与字符串相同

matrix[i][j] = 值：矩阵 类似于二维数组

列表的排序：sort（key=str.lower（））

reserve（）你置列表

任务10、列表

一、创建列表：

（1）直接创建；a = []

（2） 列表推导

（3）赋值：

创建时赋值：a = [1, 2, 3]

元素赋值：a[0] = 1

（4）引用

listb = lista

（5）list()

list()可将元组、字符串转换为列表

二、基础操作

加：

>>> a = [1,2]

>>> b = [3, 4]

>>> a+b

[1, 2, 3, 4] #效率低于extend

乘

>>> a*3

[1, 2, 1, 2, 1, 2]

三、列表推导

通过一个列表而生成一个新列表时，可以使用列表推到。

好处：列表推导不会导致变量泄露的问题

（1）如，普通列表：codes = [ord(x) for x in symbols]

（2）如，笛卡尔积：thirts = [(color, size) for color in colors for size in sizes ]

（3）如，生成器，笛卡尔积：for thirts in (（color, size）for color in colors for size in sizes):

四、内置函数

五、切片：

整个数组

>>> a[:]

[1, 2, 3, 4]

复制列表（而不是引用）

>>> b = a[:]

>>> b

[0, 2, 4, 6, 8]

插入新值

>>> a[1:1] = [2,3,4]

>>> a

[1, 2, 3, 4, 2, 3, 4]

删除元素

>>> a[1:4] = []

>>> a

[1, 2, 3, 4]

正向切片

>>> a[:2]

[1, 2]

反向切片

>>> a[:-2]

[1, 2]

带步长切片

>>> a = list(range(0 , 99))

>>> a[12::10]

[12, 22, 32, 42, 52, 62, 72, 82, 92]

取索引为12的数，并且每隔13个再取

倒序

>>> a[::-1]

[4, 3, 2, 1]

倒序切片

>>> a[::-2]

[4, 2]

值相等

>>> a[:]==a

True

内存地址不相等

>>> id(a[:])==id(a)

False

六、数字列表：

（1）创建数字列表：list(range(start,end))

>>> a = list(range(0, 10))

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）带步长的数字列表：

>>> a = list(range(0, 10, 2))

>>> a

[0, 2, 4, 6, 8]

（3）最大值，max(数字列表)

>>> max(a)

8

（4）最小值，min(数字列表)

>>> min(a)

0

（5）求和，sum(数字列表)

>>> sum(a)

20

字符串不可以在原处修改，列表可以修改

list.append( ) 添加

list.sort 排列

list.extend( [ 1,2,3 ] )  与相加类似

list.pop( ) 取最后一个值，会去掉此值

Python的类型与运算-列表

• 列表的简介
• 列表的操作
• 列表的方法

列表在Python里是有序集合对象类型。
列表里的对象可以是任何对象：数字，字符串，列表或者之后会讲到的字典，元祖等等。与字符串不同，列表是可变对象，支持原处修改的操作。

Python中的列表可以完成大多数集合体数据结构的工作，而这些在稍底层一些的语言中你不得不手工去实现。

Python的列表是：
• 任意对象的有序集合
• 通过偏移读取
• 可变长度、异构以及任意嵌套
• 属于可变序列的分类
• 对象引用数组

之前在字符串里的大部分操作都可以用在列表：
合并／重复：
List1 + List2 : 结果是两个列表按顺序结合。
List1 * 3 : 结果是列表1重复三次。
for i in List1: print i : 按顺序打印列表里的内容
3 in List : 判断列表里有没有一个对象是对象3
List1.index(1) : 查找列表里第一个为1的对象的位置
List1.count(1): 查找列表里对象为1的个数
List1[x:y]: 取第x到y的对象，重新建立一个列表
len(List1): List1里的对象个数

列表

l[0:3]它取的是右开区间，所以只会取到2

print(i,end=' ')可以用空格隔开for循环的输出，而不用换行

list=[c*4 for c in 'adfada']就会将重复4次的字符串作为列表元素

list(map(abs,[-1,-32,0]))

可以产生一个绝对值列表

嵌套可以产生矩阵

字符串不可以修改，而列表却可以

list.append()可以增加元素

list.sort可以派列，按照字母顺序

list.sort(key=str.lower)这样就可以先按照小写字母来排序

list.sort（reverse=True)就可以

+和extend（list2）一样

.pop取最后一个值，会消失

列表：列表的操作（合并/重复）查找：list 1.index()   列表的迭代和解析（list (map(abs())）

列表的索引，分片与矩阵：list [0:2]（分片）矩阵：matrix=[[1,2,3],[4,5,6]]

列表可以在原处修改（字符串不可以在原处修改）

列表的添加：list.append()

列表的排列：list.sort(key=str.lower()，reverse)

=====列表

==插入
names = ['','',12,3.14]
#可存放不同类型元素
names.append('666')
#在原有列表最后添加元素
names.insert(0,'八戒')
#在指定索引插入数据，原来的元素后退
names2 = ['a','b','c']
name3=names+names2 #可以合并
names.extend(name3)
#会把指定列表合并到该列表中

==删除
list.pop()
#删除最后一个元素
list.remove()
names.remove('a')
#从左边删除指定内容
del names[0]
#按下标删除

==改
list[index] = values

==查
values in list
values not in list

#返回值为布尔型

###注意：列表经常用于存放相同的信息
###extend与append的不同：
extend是元素之间的合并
append是将一个列表当作一个元素插入到另一个列表中

 list1+list2   两个列表顺序结合

list*3  列表1重复三次

for i in list:print  i 打印列表内容

3 in list  判断3是否在列表中

list1  index(1) 查找列表第一个为1的对象的位置

list1.count(1)  列表中对象为1的个数

list1[x:y] 取第x到第y的对象 重新建表

len(list1):list1的对象个数