Python内置容器（1）——列表，元组

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的时候,若列表中存在重复元素,则移除重复的元素。