python判断是否在数组元素

1.列表
列表是有序集合，没有固定大小，能够保存任意数量任意类型的的python对象。

linklist=[1,2,3,"lsgo",2.0]
print (linklist)
#[1, 2, 3, 'lsgo', 2.0]

混合列表

linklist=[1,2,3,"lsgo",2.0]
print (linklist,type(linklist))
for i in linklist:
    print (i,type(i))
#
[1, 2, 3, 'lsgo', 2.0] <class 'list'>
1 <class 'int'>
2 <class 'int'>
3 <class 'int'>
lsgo <class 'str'>
2.0 <class 'float'>

向列表中添加元素
·**append（obj）**在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在列表中保持原数据结构。

linklist=[1,2,3,"lsgo",2.0]
print (linklist,type(linklist))
linklist.append("i love lsgo")
print (linklist,type(linklist))
for i in linklist:
    print (i,type(i))

结果
[1, 2, 3, 'lsgo', 2.0] <class 'list'>
[1, 2, 3, 'lsgo', 2.0, 'i love lsgo'] <class 'list'>
1 <class 'int'>
2 <class 'int'>
3 <class 'int'>
lsgo <class 'str'>
2.0 <class 'float'>
i love lsgo <class 'str'>

·**extend（seq）**在列表末尾一次性追加另一个列表中的多个值（用新链表原来的列表）

linklist=[1,2,3,"lsgo",2.0]
linklist1=linklist[:]
print (linklist,type(linklist))
linklist.append(['i' ,'love ','lsgo'])
print (linklist,type(linklist))
linklist1.extend(['i' ,'love ','lsgo'])
print(linklist1,type(linklist1))
结果
[1, 2, 3, 'lsgo', 2.0] <class 'list'>
[1, 2, 3, 'lsgo', 2.0, ['i', 'love ', 'lsgo']] <class 'list'>
[1, 2, 3, 'lsgo', 2.0, 'i', 'love ', 'lsgo'] <class 'list'>
>>>

注意
严格来说append是追加，把一个东西整体的添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。
**·insert（index,obj）**在编号index位置前插入obj

linklist=[1,2,3,"lsgo",2.0]
linklist.insert(3,"位置为3（插入的）")
print (linklist,type(linklist))
结果
[1, 2, 3, '位置为3（插入的）', 'lsgo', 2.0] <class 'list'>

从列表中获取元素
·跟数组一样，我们可以通过元素的索引值，从链表获取单个元素，链表索引值从0开始。

linklist=[1,2,3,"lsgo",2.0]
print (linklist[0])
结果
1

从列表中删除元素
·remove（链表中某个值的第一匹配项）

linklist=[1,2,3,"lsgo",2.0]
linklist.remove("lsgo")
print (linklist)
结果
[1, 2, 3, 2.0]

·pop（index”该值默认为-1“）

linklist=[1,2,3,"lsgo",2.0]
print("删除了index为3的：",linklist.pop(3))
print (linklist)
结果
删除了index为3的： lsgo
[1, 2, 3, 2.0]

注意调用pop（）时，返回该元素的值。
·del var1[,var2…]语句：删除单个或多个对象，其参数可以为整形或切片

linklist=[1,2,3,"lsgo",2.0]
del linklist[0]，linklist[0]
print (linklist)
结果
[3, 'lsgo', 2.0]



linklist=[1,2,3,"lsgo",2.0]
del linklist[0:2]
print (linklist)
结果
[3, 'lsgo', 2.0]

列表分片
切片的通用写法是 start：stop：step
注意最后把step设置为-1，相当于将列表反向排列
左闭右开

linklist=[1,2,3,"lsgo",2.0]
print (linklist[1:3])
结果
[2, 3]

拷贝

linklist=[4,1,2,3]
linklist1=linklist
linklist2=linklist[:]
linklist.sort ()
print ("linklist为：",linklist)
print("linklist1为：",linklist1)
print("linklist2为：(拷贝)",linklist2)
结果
linklist为： [1, 2, 3, 4]
linklist1为： [1, 2, 3, 4]
linklist2为：(拷贝) [4, 1, 2, 3]

列表的常用操作符
·比较操作符：>、<、==。注意，列表比较大小的时候是从第一个元素开始比较，而不看列表长度，返回True或者False
·逻辑操作符：and、or、not等，可以加括号，也可以不加。例如

linklist=[4,1,2,3]
linklist1=linklist
linklist2=linklist[:]
print(linklist==linklist1)
print(linklist==linklist2)
结果
True
True

linklist=[4,1,2,3]
linklist1=linklist
linklist2=linklist[:]
print(linklist==linklist1)
print(linklist==linklist2)
linklist2.sort()
print(linklist==linklist1)
print(linklist==linklist2)
print(linklist==linklist2 and linklist==linklist1)
print(linklist==linklist2 or linklist==linklist1)
结果
True
True
True
False
False
True

·连接操作符：+；例如：通过‘+’可以将两个列表连接起来

l1=['lsgo','i']
l2=['love','u']
print(l1)
print(l2)
print(l1+l2)
结果
['lsgo', 'i']
['love', 'u']
['lsgo', 'i', 'love', 'u']

·重复操作符：‘*’，也就是乘法操作符，具体运用如下：

l1=['lsgo','i','love','u']
print(l1)
print(l1*5)
结果
['lsgo', 'i', 'love', 'u']
['lsgo', 'i', 'love', 'u', 'lsgo', 'i', 'love', 'u', 'lsgo', 'i', 'love', 'u', 'lsgo', 'i', 'love', 'u', 'lsgo', 'i', 'love', 'u']

·成员关系操作符：in 和 not in。可以判断某个元素在不在该列表里面，返回True和False,例如：

l1=['lsgo','i','love','u']
print('lsgo'in l1)
print('lsgo'not in l1)
结果
True
False

其中[加号+]和[乘号*]，前者首尾拼接，后者复制拼接。
使用（append，extend,insert）可以对列表增加元素，他们没有返回值是直接修改了原数据对象。
将两个list相加，需要创建新的list对象，从而需要消耗额外的内存，因此不建议用‘+’操作符。
列表的其他方法
·count（obj）方法：统计某个元素在列表中出现的次数

l1=[12,34]*3
print(l1.count(12))
结果
3

·index（obj[,start[,end]]）方法：从列表中找出某个值第一个匹配项的索引位置

l1=[12,34]*3
print(l1.index(12))
print(l1.index(12,3,5))
结果
0
4

·sort(key=None,reverse=False)方法：对原列表进行排序

l1=[12,34]*3
l1.sort()
print(l1)
结果
[12, 12, 12, 34, 34, 34]

2.元组
python3的元组和列表类似，不同之处在于元组的元素不能修改。

元组使用的是()，列表使用的[]。
·当元组内只包含一个元素的话，需要在后边加上一个逗号，否则括号会被当做运算符使用。

l1=(1,)
l2=(1)
print(type(l1))
print(type(l2))
结果
<class 'tuple'>
<class 'int'>

·访问元组
访问元组和列表相似，下标索引从零开始，可以进行截取组合。

l1=(0,1,2,3,4,5)
print(l1[4])
print(l1[:])
结果
4
(0, 1, 2, 3, 4, 5)

·修改元组
元组中的元素是不允许进行修改的，但我们可以对元组进行连接组合（用[加号+]和[乘号*]前者首尾拼接，后者复制拼接），例子：

l1=(0,1,2,3,4,5)
l2=(6,7,8)
print(l1+l2)
print(l1*2)
结果
(0, 1, 2, 3, 4, 5, 6, 7, 8)
(0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5)

·删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，例子：

l1=(0,1,2,3,4,5)
l2=(6,7,8)
del l1
print(l1)
结果
 line 4, in <module>
    print(l1)
NameError: name 'l1' is not defined
（再次进行数据类型的打印的时候，就会报错，因为此时tup1元组已经被删除掉了）

内置方法
元组的大小和内容都不可更改，因此只有 count和index两种方法。

l1=(0,1,2,3,4,5)
print(l1.count(0))
print(l1.index(3))
结果
1
3

·count（obj）是记录元组l1中该元素出现几次，显然是一次。
·index（3）是找到该元素在元组l1的索引，显然是3.
解压元组

l1=(0,1,2,3,4)
(a,b,c,d,e)=l1
print(a,b,c,d,e)
(a,b,*rest,c)=l1
print(a,b,c)
结果
0 1 2 3 4
0 1 4

二元数组

l1=(0,1,2,(3,4))
(a,b,c,(d,e))=l1
print(a,b,c,d,e)
结果
0 1 2 3 4