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

时间: 2024-11-03 20:50:57

Python内置容器(1)——列表,元组,集合的相关文章

数据类型内置方法:列表/元组/集合

list列表类型内置方法 作用:多个装备.多个爱好.多门课程,甚至是多个女朋友 定义方式:[]内用逗号隔开,可以有多个任意数据类型的元素 friends_list = ['longzeluola','canglaoshi','qiaobenai','nick'] lis = list('abcd') 方法: 优先掌握 索引取值(正向取值+反向取值) 即可取又可存 #list之索引取值 name_list={'nick','jason','tank','sean'} name_list[0]='n

Python基础【数据结构:列表 | 元组 | 集合 | 字典】

序列 序列是Python中最基本的数据结构.包括字符串,列表,元组,Unicode字符串,buffer对象,xrange对象.序列中的每个元素都分配一个数字,即它的索引第一个索引是0,第二个索引是1,依此类推. 列表和元组 列表一个方括号内的逗号分隔值列表中可以存放不同的数据类型. 例:[1,1.2,True,'str',[2,False]]元组与列表类似,不同之处在于元组的元素不能修改.元组使用小括号,列表使用方括号. 例:(1,1.2,True,'str',[2,False]) 列表和元组的

Python内置容器(2)——字典,迭代器,列表解析

1.迭代器 iterator iter 函数,构造集合. next 方法依次返回迭代器的值 In [42]: li Out[42]: [1, 2, 3, 4, 5] In [43]: it = iter(li) In [44]: it.next() Out[44]: 1 In [45]: it.next() Out[45]: 2 当所有的元素都返回完的时候,会抛出一个StopIterator 的异常. list,tuple,set 都属于集合. for 语句,当将一个列表传递给for 语句的时候

py3 字符串 字典 列表 元组 集合

目录 字符串 列表 元组 字典 集合 Python 字符串 字符串是 Python 中最常用的数据类型.我们可以使用引号('或")来创建字符串. 源码如下: class str(basestring): """ str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is t

python学习系列--python内置函数(一)

先列出所有的python内置函数,可以看到还是挺多的. abs()        求给定数的绝对值. all()          传入一个列表,只有当列表中所有元素都是真时,该函数返回真. any()        传入一个列表,只要列表中有一个元素为真,该函数即返回真. ascii()       执行对象中的__repr__方法.该函数在python2.7中已弃用. bin()         将给定的值转换成二进制. bool()       判断真假. bytearray()     

python——内置对象

python的内置对象 对象类型 常量示例/用法 Number(数字) 3.14159, 1234, 999L 3+4j String(字符串) 'spam', "guido's" List(列表) [1,[2, 'Three'],4] Dictionary(字典) {'food':'spam', 'taste':'yum'} Tuple(元组) (1,'spam',4,'U') File(文件) text=open('egges','r').read() 数字 常量 常量 解释 12

Python之路Python内置函数、zip()、max()、min()

Python之路Python内置函数.zip().max().min() 一.python内置函数 abs() 求绝对值 例子 print(abs(-2)) all() 把序列中每一个元素做布尔运算,如果全部都是true,就返回true, 但是如果是空字符串.空列表也返回true 例子 print(all([1,2,'1',''])) 输出结果 False 例子2 print(all('')) 输出结果 True any() 把序列中每一个元素做布尔运算,如果有一个为true就返回true, 但

函数生成器、推导式及python内置函数

函数生成器.推导式及python内置函数 函数生成器 生成器的定义 在 Python 中,使用了 yield 的函数被称为生成器(generator). 跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器. 在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行. 调用一个生成器函数,返回的是一个迭代器对象. 生成器与迭代器的区别 生成

Python内置函数_数学运算类

本文和大家分享的主要是python内置函数数据运算类相关内容,一起来看看吧,希望对大家学习python 有所帮助. abs abs(x) 求绝对值 · X可以是整型,也可以是复数 · 若X是复数,则返回复数的模 >>> abs(-1)1>>> abs(-3+4j)5.0>>> bin bin(x) 将整数x转换为二进制字符串 >>> bin(2)'0b10'>>> bin(3)'0b11' bool bool([x]