1.列表list
1.1定义和初始化 list
# 定义个空列表
In [1]: li = []
In [2]: type(li)
Out[2]: list
# 初始化list,list 中的元素没有类型要求,可以是任何类型
In [3]: li = [1,2,‘a‘,[‘a‘,4]]
In [4]: li
Out[4]: [1, 2, ‘a‘, [‘a‘, 4]]
1.2列表的下标
python中列表的下标是从0开始的。
In [4]: li
Out[4]: [1, 2, ‘a‘, [‘a‘, 4]]
In [5]: li[2]
Out[5]: ‘a‘
In [6]: li[4]
---------------------------------------------------------------------------
IndexError
Traceback (most recent call last)
<ipython-input-6-5889debca501> in <module>()
----> 1 li[4]
IndexError: list index out of range
# 得到list 长度
In [7]: len(li)
Out[7]: 4
1.3 in关键字
在for循环中使用表示遍历list中的所有元素:
In [8]: for x in li:
...:
print x
...:
1
2
a
[‘a‘, 4]
in 也可以作为一个二元操作符使用,查找某个元素是否在list中存在:
In [9]: ‘a‘ in li
Out[9]: True
del 删除list中某个元素:
In [10]: li
Out[10]: [1, 2, ‘a‘, [‘a‘, 4]]
In [11]: del li[0]
In [12]: li
Out[12]: [2, ‘a‘, [‘a‘, 4]]
1.4 在python中一切皆为对象,显然,list也是对象,针对于列表对象来说,常用的操作:
In [13]: dir(li)
Out[13]:
[‘__add__‘,
‘__class__‘,
.........
‘__str__‘,
‘__subclasshook__‘,
‘append‘,
‘count‘,
‘extend‘,
‘index‘,
‘insert‘,
‘pop‘,
‘remove‘,
‘reverse‘,
‘sort‘]
1.4.1查看list对象append方法的帮助信息:
In [14]: help(li.append)
In [15]: li
Out[15]: [2, ‘a‘, [‘a‘, 4]]
In [16]: li.append(666)
In [17]: li
Out[17]: [2, ‘a‘, [‘a‘, 4], 666]
1.4.2 extend 方法,接受一个迭代器,将迭代器的所有元素追加到list中:
In [17]: li
Out[17]: [2, ‘a‘, [‘a‘, 4], 666]
In [18]: li.extend([‘abc‘,‘cba‘])
In [19]: li
Out[19]: [2, ‘a‘, [‘a‘, 4], 666, ‘abc‘, ‘cba‘]
1.4.3 insert 方法
li.insert(2,‘x‘) , li.insert(-1,‘mm‘) ,在某个索引下标之前插入某个数据。
1.4.4 remove 方法
li.remove(‘a‘) ,从list中移除某个元素。
1.4.5 pop 方法
接受一个可选参数index,remove下标所指向的元素,并将钙元素返回,li.pop() , li.pop(2) :
In [19]: li
Out[19]: [2, ‘a‘, [‘a‘, 4], 666, ‘abc‘, ‘cba‘]In [20]: li.pop()
Out[20]: ‘cba‘
In [21]: li
Out[21]: [2, ‘a‘, [‘a‘, 4], 666, ‘abc‘]
In [22]: li.pop(2)
Out[22]: [‘a‘, 4]
In [23]: li
Out[23]: [2, ‘a‘, 666, ‘abc‘]
1.4.6 count 方法
返回某个值在list出现的次数, li.count(‘a‘)
1.4.7 index 方法,返回第一个匹配value的下标:
In [28]: li
Out[28]: [2, ‘a‘, 666]
In [29]: li.index(‘a‘)
Out[29]: 1
In [30]: li.index(‘b‘)
---------------------------------------------------------------------------
ValueError
Traceback (most recent call last)
<ipython-input-30-4639cb7d3bae> in <module>()
----> 1 li.index(‘b‘)
ValueError: ‘b‘ is not in list
# 还可以指定起始和结束查找的范围参数 li.index(‘a‘,2,6)
In [33]: li
Out[33]: [2, ‘a‘, 666, ‘a‘, ‘a‘, ‘b‘]
In [34]: li.index(‘a‘,2)
Out[34]: 3
1.4.8 sort 方法
直接修改list内容,不返回值. li.sort() ,还可以接受三个可选参数。L.sort(cmp=None, key=None, reverse=False)
1.4.9 reverse 方法。 li.reverse()
1.5 list的切片
li[i],li[a:b],li[a:e:b]--第三个参数为步长,index每次加几,默认为1
In [40]: li
Out[40]: [‘b‘, ‘a‘, ‘a‘, ‘a‘, 666, 2]
In [41]: li[2:4]
Out[41]: [‘a‘, ‘a‘]
####
In [43]: li[:2]
Out[43]: [‘b‘, ‘a‘]
###
In [44]: li[4:]
Out[44]: [666, 2]
## 对list 做一次深copy
In [45]: li[:]
Out[45]: [‘b‘, ‘a‘, ‘a‘, ‘a‘, 666, 2]
####
In [46]: li[2:4:2]
Out[46]: [‘a‘]
## 用切片实现list 翻转
In [47]: li
Out[47]: [‘b‘, ‘a‘, ‘a‘, ‘a‘, 666, 2]
In [48]: li[::-1]
Out[48]: [2, 666, ‘a‘, ‘a‘, ‘a‘, ‘b‘]
# 得到下标为偶数的list
In [50]: li
Out[50]: [‘b‘, ‘a‘, ‘a‘, ‘a‘, 666, 2]
In [51]: li[::2]
Out[51]: [‘b‘, ‘a‘, 666]
# 得到下标为奇数的值
In [52]: li[1::2]
Out[52]: [‘a‘, ‘a‘, 2]列表的切片操作是一个复制操作,并不对原始列表进行修改。
2.元组 tuple
2.1 定义和初始化元组
In [1]: t = ()
In [2]: type(t)
Out[2]: tuple
In [3]: t = (1,2,3)
In [4]: t
Out[4]: (1, 2, 3)
2.2元组也支持下标和切片操作。
元组是不可变对象,不能对元祖的内容做修改
In [4]: t
Out[4]: (1, 2, 3)
In [5]: t[1]
Out[5]: 2
In [6]: t[1] = 100
---------------------------------------------------------------------------
TypeError
Traceback (most recent call last)
<ipython-input-6-4f066cd5e53f> in <module>()
----> 1 t[1] = 100
TypeError: ‘tuple‘ object does not support item assignment
2.3 元组的不可变是相对的,因为元祖里面的内容可以是各种类型,如,元组的元素值为列表:
In [7]: t1 = ([2,3,4],[19,23,45])
In [8]: t1
Out[8]: ([2, 3, 4], [19, 23, 45])
In [9]: t1[0][2]
Out[9]: 4
In [10]: t1[0][2] = 100 #list 的值是可变的,可以被修改的
In [11]: t1
Out[11]: ([2, 3, 100], [19, 23, 45])
2.4 count , index 操作
In [12]: t
Out[12]: (1, 2, 3)
In [13]: t.count(2)
Out[13]: 1
In [14]: t.index(3)
Out[14]: 2
元组支持切片操作与列表的切片操作一样。
3.集合 set
3.1定义和初始化集合
列表和元组都是有序的,但是集合是无序的。
In [17]: s = {1,2,3}
In [18]: type(s)
Out[18]: set
3.2 集合中的元素不重复
In [19]: s = {1,1,1,12,2,2,3,4}In [20]: s
Out[20]: {1, 2, 3, 4, 12}
3.3python根据集合中的每个元素的hash值来判断是否重复,所以集合中的每个元素必须是可hash的对象。在python中如果一个对象有一个__hash__ 的方法,
表示该对象可hash.
In [21]: 1.__hash__ # 整数1 的对象有该方法,但是__hash__ 方法不能直接调用。
1.__hash__
hash() 函数直接返回某个对象的hash值。如hash(1)
集合不支持切片操作。
3.4集合的操作:
3.4.1 add 操作
In [21]: s
Out[21]: {1, 2, 3, 4, 12}
In [22]: s.add(100)
In [23]: s
Out[23]: {1, 2, 3, 4, 12, 100}
3.4.2 update 操作,迭代器作为参数,将迭代器中的所有元素追加到集合中
In [23]: s
Out[23]: {1, 2, 3, 4, 12, 100}
In [24]: s.update([101,102,103])
In [25]: s
Out[25]: {1, 2, 3, 4, 12, 100, 101, 102, 103}
3.4.3 remove 删除某个元素,若该元素不存在则报错
3.4.4 discard 删除某个元素,若该元素不存在则不做任何操作。
3.4.5 pop() 随机删除某个元素,并返回该元素
3.4.6 clear 清空集合。s.clear()
3.5 集合的运算
3.5.1 difference 两个集合的差集,不修改原来的两个集合
In [26]: s1 = {1,2,3,4,5,‘a‘}
In [27]: s2 = {4,5,7,8,‘b‘,‘c‘}
In [28]: s1.diff
s1.difference
s1.difference_update
In [28]: s1.difference(s2)
Out[28]: {1, 2, 3, ‘a‘}
# 减号可以直接求两个集合的差集
In [29]: s1 - s2
Out[29]: {1, 2, 3, ‘a‘}
3.5.2 difference_update 两个集合的差集,但修改原来的集合,不返回值
In [30]: s1
Out[30]: {1, 2, 3, 4, 5, ‘a‘}
In [31]: s2
Out[31]: {4, 5, 7, 8, ‘b‘, ‘c‘}
In [32]: s1.difference_update(s2)
In [33]: s1
Out[33]: {1, 2, 3, ‘a‘}
In [34]: s2
Out[34]: {4, 5, 7, 8, ‘b‘, ‘c‘}intersection 两个集合的交集,返回值,不修改原来的集合
3.5.3 intersection_update 两个集合的交集,无返回值,修改原来的集合
3.5.4 & , s1 & s2 直接求两个集合的交集
3.5.5 union 两个集合的并集
3.5.6 | , s1 | s2 也是求两个集合的并集
3.5.7 isdisjoint 查看两个集合是否有交集,返回bool, s1.isdisjoint(s2)
3.5.8 issubset 查看是否是子集
4. 列表,元组,集合之间的转换
4.1 list 函数
In [35]: list()
Out[35]: []
In [36]: list(‘hello‘)
Out[36]: [‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]
4.2 tuple 函数
4.3 set 函数
In [37]: t = (1,2,3)
In [38]: type(t)
Out[38]: tuple
In [39]: list(t)
Out[39]: [1, 2, 3]
将list转换为set的时候,若列表中存在重复元素,则移除重复的元素。
本文出自 “技术人生，简单不简单” 博客，请务必保留此出处http://willis.blog.51cto.com/11907152/1854915
原文地址：http://willis.blog.51cto.com/11907152/1854915
