首页 > 代码库 > 列表，元组，集合
列表，元组，集合
一 列表
列表是可变类型的序列,而元组与字符串是不可变类型的序列
1.列表的定义:
# 定义一个空列表
In [21]: list = []
In [22]: type(list)# 通过python的内置函数type查看list的数据类型
Out[22]: list
In [23]: print list
[]
# 定义一个包含元素的列表,元素可以是任意类型,包括数值类型,列表,字符串等均可。
In [24]: list1 = ["fentiao","5","male"] 此处定义一列表,名为list1
In [25]: print list1
[‘fentiao‘, ‘5‘, ‘male‘]
2. 列表的修改
修改列表的元素:直接重新赋值;.
此处我查看下标为1元素的值,重新给这个索引赋值,我们发现列表的元素是可变的;
In [36]: list1
Out[36]: [‘fendai‘, 4, ‘female‘]
In [37]: list1[1]
Out[37]: 4
In [38]: list1[1]=7
In [39]: list1
Out[39]: [‘fendai‘, 7, ‘female‘]
In [16]: list1 = ["fentiao","5","male"]
In [17]: list1[0] = "hello"
In [18]: print list1
[‘hello‘, ‘5‘, ‘male‘]
列表的修改
>>> list1
[‘fentiao‘, 5, ‘male‘, ‘cat‘]
>>> id(list1)
140205776057408
>>> list1[0] = "fendai"
>>> id(list1)
140205776057408
列表的操作:理解"对象=属性+方法"与类
3.列表的索引和切片
# 列表的索引:下标是从0开始计算,比如list[0]读取的是列表的第1个元素;
list[-1]读取的是列表的倒数第1个元素;
In [39]: list1
Out[39]: [‘fendai‘, 7, ‘female‘]
In [40]: list1[0]
Out[40]: ‘fendai‘
In [41]: list1[-1]
Out[41]: ‘female‘
# 列表的切片
>>> list1[:] //通过切片的方式可以实现列表的复制
[‘fentiao‘, 5, ‘male‘]
# 0代表从哪个索引开始切片,3代表切片到哪个位置,并且不包含第三个索引,2代表切片的步长;
>>> list1[0:3:2]
[‘fentiao‘, ‘male‘]
In [42]: list1[:]
Out[42]: [‘fendai‘, 7, ‘female‘]
In [43]: list1[1:]
Out[43]: [7, ‘female‘]
In [44]: list1[:2]
Out[44]: [‘fendai‘, 7]
4.列表的添加:
列表可通过append方法添加元素;
In [45]: list1.
list1.append list1.extend list1.insert list1.remove list1.sort
list1.count list1.index list1.pop list1.reverse
In [45]: list1.append("cat")#####在列表的末尾添加
In [46]: list1
Out[46]: [‘fendai‘, 7, ‘female‘, ‘cat‘]
In [48]: help(list1.append) ####查看list1.append的使用方法;
列表的长度:
In [51]: len(list1) #####查看列表的长度
Out[51]: 4
In [52]: list1
Out[52]: [‘fendai‘, 7, ‘female‘, ‘cat‘]
列表可通过方法添加元素;
截图:
In [16]: list.extend(‘hel‘)
In [17]: list
Out[17]: [‘qqqqqq‘, ‘fentiao‘, ‘5‘, ‘male‘, ‘hello‘, ‘h‘, ‘e‘, ‘l‘]
在指定位置添加元素使用inert方法;L.insert(index, object)
截图：
5.列表的删除:
方法一:
In [19]: list1 = ["fentiao","5","male"]
In [20]: list1.remove("fentiao")
In [21]: list1
Out[21]: [‘5‘, ‘male‘]
方法二:
In [22]: list1 = ["fentiao","5","male"]
In [23]: list1.remove(list1[2])
In [24]: list1
Out[24]: [‘fentiao‘, ‘5‘]
方法三:
In [25]: list1 = ["fentiao","5","male"]
In [26]: del(list1[1])
In [27]: list1
Out[27]: [‘fentiao‘, ‘male‘]
6.列表元素的查找:var in list
判断一个var元素是不是属于list列表:
var in list ####元素属于列表
var not in list ####元素属于列表
In [1]: list=[‘fentiao‘,‘5‘,‘male‘]
In [2]: ‘fentiao‘ in list ####‘fentiao‘元素属于列表
Out[2]: True
In [3]: ‘fentiao‘ not in list ####‘fentiao‘元素不属于列表
Out[3]: False
7.重复、连接及计算长度
In [4]: list =[1,2,3]+[5,6,7] ######连接
In [5]: list
Out[5]: [1, 2, 3, 5, 6, 7]
In [6]: list1=list*3 #####重复
In [7]: list1
Out[7]: [1, 2, 3, 5, 6, 7, 1, 2, 3, 5, 6, 7, 1, 2, 3, 5, 6, 7]
In [8]: len(list1) ##########计算长度
Out[8]: 18
练习
(1)打印1-100中所有的偶数 打印1-100中所有的奇数
In [8]: range (2,100,2)
In [9]: range (1,100,2)
(2)控制出栈，入栈
代码：
stack = []
def pushstack():
item = raw_input(‘new item:‘)
stack.append(item)
def popstack():
if len(stack)== 0:
print "can not pop fromempty item"
else:
print "%s pop from stack"%stack .pop()
def viewstack():
print stack
def showmenu():
pro = ‘‘‘
welcome to stackmanage
p(U)sh
P(O)p
(V)iew
(Q)uit
Enter choice:‘‘‘
while True:
choice =raw_input(pro).lower()
if choice =="u":
pushstack()
elif choice =="o":
popstack()
elif choice == "v":
viewstack()
elif choice == "q":
print "quit stackmanage"
break
else:
print "inputu,o,v,q"
showmenu()
运行结果图：
(3)break与continue区别：
截图：
二 元组tuple
1.元组的定义:
#定义空元组
tuple = ()
#定义单个值的元组
tuple = (fentiao,)
#一般的元组
tuple = (fentiao, 8, male)
#为什么需要元组?
>>> userinfo1 = "fentiao 4 male"
>>> userinfo2 = "westos 10 unknown"
>>> userinfo1[:7]
‘fentiao‘
>>> userinfo2[:6]
‘westos‘
字符串中操作提取姓名/年龄/性别的方式不方便,诞生元组与列表这两个数据类型
>>> t1 = ("fentiao",4,"male")
>>> t2 = ("westos", 10, "unknown")
>>> type(t1)
<type ‘tuple‘>
>>> type(t2)
<type ‘tuple‘>
>>> t1[0]
‘fentiao‘
>>> t2[0]
‘westos‘
>>> t2[0:2]
(‘westos‘, 10)
2.元组特性
(1)不能对元组的值任意更改
>>> t1
(‘fentiao‘, 4, ‘male‘)
>>> t1[1] = 5
Traceback (most recent call last):
File "<stdin>", line 1,in <module>
TypeError: ‘tuple‘ object does not support item assignment
(2)对元组分别赋值,引申对多个变量也可通过元组方式分别赋值
In [4]: a,b,c=(1,2,3)
In [5]: print a,b,c
1 2 3
In [6]: print a
1
In [7]: print b
2
In [8]: print c
3
注意:C语言中,定义一类型,必须先开辟一存储空间,当后期重新赋值时也一定是整型的;
python中,先在内存上存储数据后,再通过标签去引用。不同的字符串占用不同的存储空间。
>>> str1
‘12345‘
>>> id(str1)
140205776037520
>>> str1 = "abcde"
>>> id(str1)
140205776037424
>>> str2 = "12345"
>>> id(str2)
140205776037520
3.元组的操作
元组也属于序列,可执行的操作如下:
索引、切片、重复、连接和查看长度
In [9]: yuan = (1,2,3,4)
In [10]: type(yuan) ####查看数据类型
Out[10]: tuple
In [11]: yuan[1] ####索引
Out[11]: 2
In [14]: yuan[:] #####切片
Out[14]: (1, 2, 3, 4)
In [15]: yuan[1:] #####切片
Out[15]: (2, 3, 4)
In [16]: yuan[:2] #####切片
Out[16]: (1, 2)
In [9]: yuan =(1,2,3)
In [10]: l=yuan*3 #####重复
In [11]: l
Out[11]: (1, 2, 3, 1, 2, 3, 1, 2, 3)
In [12]: yuan =(1,2,3)+(4,5,6) #####连接
In [13]: yuan
Out[13]: (1, 2, 3, 4, 5, 6)
In [14]: len(yuan) #####查看长度
Out[14]: 6
注意：
In [25]: t = (1) #####赋值时输入单个数字时，数据类型是整形
In [26]: type(t)
Out[26]: int
In [28]: t = (‘hello‘)#####赋值时输入字符串时，数据类型是字符串
In [29]: type(t)
Out[29]: str
In [30]: t = (1,)#####赋值时输入单个数字加，时，数据类型才是元组
In [31]: type(t)
Out[31]: tuple
4.元组的方法
t.count(value)-->int 返回value在元组中出现的次数;
t.index(value) 返回value在元组中的偏移量(即索引值)
In [16]: t = (‘hello‘,‘linux‘)
In [17]: type(t)
Out[17]: tuple
In [18]: t.count(‘hello‘) ####hello在元组中出现的次数
Out[18]: 1
In [19]: t.index(‘linux‘) #####linux在元组中的偏移量
Out[19]: 1
In [20]: t.index(‘hello‘) #####hello在元组中的偏移量
Out[20]: 0
5.删除元组
In [28]: t= (1,2,3)
In [29]: del t
In [30]: t
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-30-b7269fa25085> in <module>()
----> 1 t
NameError: name ‘t‘ is not defined
150pxp
In [23]: t= (1,2,3)
In [24]: cmp(t,(1,2))
Out[24]: 1
In [25]: cmp(t,(1,2,3,))
Out[25]: 0
In [26]: cmp(t,(1,2,3,4))
Out[26]: -1
In [27]: cmp(t,(1,2,3,4,5))
Out[27]: -1
三 集合
1.集合的定义
set = {}
set = {1,2,3}
set = {1,2,3,1,2,3}
set = {1,2,3,‘hello‘}
set = {1,2,3,‘hello‘,(1,2,3)}
set = {1,2,3,‘hello‘,(1,2,3),[1,2,3]}
看看是否都可以成功定义集合?
截图：集合里有列表不能成功
2.set的应用场景
集合是一个无序的,不重复的数据组合。
列表去重
关系测试:如交集、差集、并集的关系测试
3.集合的关系测试操作
交集: list_1.intersection(list_2)
并集: list_1.union(list_2)
差集: list_1.difference(list_2)
list_2.difference(list_1)
对等差分 list_1.symmetric_difference(list_2)
子集 list_1.issubset(list_2)
父集 list_1.issuperset(list_2)
有无交集 list_1.isdisjoint(list_2)
交集: list_1 & list_2
并集: list_1 | list_2
差集: list_1 - list_2
list_2 - list_1
对等差分 list_1 ^ list_2
4.集合的添加
s.add(1) 在集合中添加一项
s.update([1,3,4]) 在集合中添加多项,跟的参数应该是可迭代类型
集合的删除
s.remove(1) 删除集合中指定的元素
s.pop() 随机删除集合中的某个元素,并返回删除的元素
5.集合的其他操作
len(s) 显示集合set的长度
"1" in s 检测某元素是否为集合s的成员,返回布尔值集合的其他操作
s.copy() 集合的浅拷贝,此处不深入研究,后面会说
s.clear() 清空集合的所有元素
列表，元组，集合