python中数据结构之列表，元组，字典，集合

一 列表

    列表
    引入一个新的概念：数据结构
    数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字或字符，甚至可以是其他数据结构，在 python 中，最基本的数据结构是序列，序列中的每个元素匾被分配一个序号–即元素的位置，也称为索引，第一个索引是0，第二个则是1，以此类推
    列表是什么
    列表由一系列特定顺序排列的元素组成，你可以创建包含字母表中所有字母，数字或所有家庭成员姓名的列表；也可>以将任何东西加入列表中，其中的元素之间可以没有任何关系
    列表类似于C语言中的数组

1）索引

service = ['http', 'ssh', 'ftp']
print service[0]
print service[-1]

2）切片

service = ['http', 'ssh', 'ftp']
print service[::-1] # 列表的翻转
print service[1:] # 除了第一个元素之外的其他元素
print service[:-1] # 除了最后一个元素之外的其他元素

3）重复

service = ['http', 'ssh', 'ftp']
print service * 3

4）连接

service = ['http', 'ssh', 'ftp']
service1 = ['mysql','firewalld']
print service + service1

5）成员操作符

service = ['http', 'ssh', 'ftp']
service1 = ['mysql','firewalld']
print 'firewalld' in service  #返回值为False
print 'firewalld' in service1  #返回值为True
print 'firewalld' not in service  #返回值为True

6）for循环遍历

service = ['http', 'ssh', 'ftp']
for i in service:
    print i

7）显示服务（也可以认为是美观的帽子）

print '显示服务'.center(50,'*')

8）列表的嵌套

service2 = [['http',80],['ssh',22],['ftp',21]]
# 索引
print service2[0][1]      
print service2[-1][1]
# 切片
print service2[:][1]
print service2[:-1][0]
print service2[0][:-1]

9）列表的增加

service = ['http', 'ssh', 'ftp']
# 1.
print service + ['firewalld']

# 2.append:追加 追加一个元素到列表中
service.append('firewalld')
print service

# 3.extend:拉伸 追加多个元素到列表中
service.extend(['mysql', 'firewalld'])
print service

# 4. insert:在指定索引位置插入元素
service.insert(1,'samab')
print service

10）列表的删除

扫描二维码关注公众号，回复： 3743578 查看本文章

service = ['http', 'ssh', 'ftp']

1.如果pop()不传递值的时候，默认弹出最后一个元素
print service.pop()
pop()也可以传递索引值
print service.pop(0)

2.remove:删除指定的元素
service.remove('ssh')
print service

3.del 关键字 从内存中删除列表
print service
del service 
print service

11）列表的修改

service = ['http', 'ssh', 'ftp']
# 通过索引，重新赋值
service[0] = 'mysql'
print service
# 通过切片
print service[:2]
service[:2] = ['samba','ladp']
print service

12）列表的查看

service = ['http', 'ssh', 'ftp','ftp']

# 查看列表中元素出现的次数
print service.count('ssh')

# 查看指定元素的索引值
print service.index('ssh')

13）列表的特性

# 列表里：可以存储不同的数据类型
li = [1,1.2,True,'hello']
print li
print type(li)

# 列表里面也可以嵌套列表(列表：也是一种数据类型)
li = [1,1.2,True,'hello',[1,2,3,4,5]]
print li
print type(li)

14）列表的排序

service = ['http', 'ssh', 'ftp','ftp']
#按照Ascii码进行排序的
service.sort()
print service
#进行倒序排序
#service.sort(reverse=True)
#print service

phones = ['bob', 'harry', 'Lily', 'Alice']
phones.sort()          
#对字符串排序不区分大小写
#phones.sort(key=str.lower)
#phones.sort(key=str.upper)
print phones

command = ['print','ls','ssh','cd','at','james']
print command
#临行排序
print sorted(command)
print command


command1=['hello','world','hello','python','so','skr']
print command1
#逆序
command1.reverse()
print command1

import random
li = list(range(10))
print li
#将原有的列表顺序打乱
random.shuffle(li)
print li

二 元组

Tuple（元组）与列表相似，不同之处在于元组的元素不能修改
元组表示多个元素组成的序列
元组在python开发中，有特定的应用场景用于存储一串信息，数据之间使用 , 分隔
元组用 () 定义
列表中通常保存相同类型的数据，而元组中通常保存不同类型的数据
不可对元组内容进行增添删除

1）定义一个元组

t = (1,2,3,4.0,'star')
print t,type(t)

2）元组的数据特性

# 元组本身不能增删改查，但是如果元组里面包含可变数据类型，可以间接修改元组的内容
t1 = ([1,2,3],4)
t1[0].append(4)
print t1

元组如果只有一个元素的时候，后面一定要加逗号，负责数据类型不确定

t2 = ('hello',)
t3 = (1,)
print type(t2),type(t3)

3）元组的特性
类似列表可参考

allowUsers = ('root','student','tom')
allowPasswd = ('123','456','789')

# 索引 # 切片
print allowUsers[0]
print allowUsers[-1]
print allowUsers[1:]
print allowUsers[2:]
print allowUsers[:-1]
print allowUsers[::-1]

# 重复
print allowUsers * 3
# 连接
print allowUsers + ('lili','kaka')
# 成员操作符
print 'student' in allowUsers
print 'tom' not in allowUsers

4）元组的应用的场景

1.变量交换数值
a = 1
b = 2
b,a = a,b
# 先把(a,b)封装成了一个元组(1,2)
#b,a = a,b            
#b =(1,2)[0] a=(1,2)[1]   #转化的原理
print a,b

2.打印变量值
name = 'tom'
age = 10
t = (name,age)
print 'name: %s,age: %d' %(name,age)
print 'name: %s,age: %d' %t     #简化代码

3.元组的赋值：有多少个元素，就用多少个变量接收
t1 = ('tom',10,100)
name,age,score = t1
print name,age,score

scores = (100,89,45,78,65)
scoresLi = list(scores)   # 把元组数据类型返回值类型改成列表
print type(scoresLi)   #查看数据类型
print scoresLi
#scores = sorted(scores)  排序
print scores

5）python中常用的内置方法

枚举：返回索引值和对应的value值
s = 'hello'
#遍历
for i in s:
    print i
#枚举
for i,v in enumerate('tom'):
    print i
    print type(i)
    print v
    print type(v)
    print str(i) + '---->' + v

s1 = 'abc'
s2 = '123'
#zip()的使用
for i in zip(s1,s2):
    print i
    #print '-'.join(i)

三 字典

    1 字典的定义
    dictionary(字典)是除列表以外 python 中最灵活的数据类型
    字典同样可以用来存储多个数据，通常用于存储描述一个物体的相关信息
    2 字典和列表的区别
    列表是有序的对象集和
    字典是无序的对象集和
    3 字典用 {} 定义
    字典使用键值对存储数据，键值对之间使用 : 分隔
    键key是索引
    值value是数据
    键和值之间使用;分隔
    键必须是唯一的（因为我们必须通过键来找到数据）
    值可以取任何数据类型，但键只能使用字符串，数字或元组
    4 字典是一个无序的数据集和，使用print函数输出字典时，通常输出的顺序和定义的顺序是不一致的

1）定义字典

message = {
    'name':'tom',
    'age':18,
    'height':1.80,
    'weight':75.5
}
print message
print type(message)

d = dict(a=1,b=2)
print d,type(d)

2）字典的特性

d = dict(a=1,b=2)
print d
# 成员操作符(默认判断key值是否存在)
print 'a' in d
print 1 in d
# for循环(默认循环遍历字典的key值)
for i in d:
    print i

3）字典的增加

d = dict(a=1, b=2)
print d
# 添加或者更改key-value对
d['g'] = 10
print d   #把'g':10加入到d中去
d['a'] = 10
print d   #把'a':10加入到d中去
"""
update:
    如果key值存在，更新value值
    如果key值不存在，添加key-value值
"""
d.update({'a':4,'f':1})
print d
#####
{'a': 1, 'b': 2}
{'a': 4, 'b': 2, 'f': 1}
#####
"""
setdefault
    如果key值已经存在，不做修改
    如果key值不存在，添加key-value值
"""
d.setdefault('a',10)
print d
#####
{'a': 1, 'b': 2}
{'a': 1, 'b': 2}
#####

四 集合
1 ) 集合的定义
集合是不重复的数据结构

s = {1,2,3,1,2,3,4,5}
print s,type(s)
s1 = {1}
print s1,type(s1)

2 )集合的特性
集合只支持 成员操作符 for循环

s = {1,2,3}
print s[0]
#重复
print s * 3
#连接
print s + {5,4,6}
#成员操作符
print 1 in s
#遍历
for i in s:
    print i,
#枚举
for i,v in enumerate(s):
    print 'index: %s,value:%s' %(i,v)

3 )集合的常用方法
1 集合的增加

s = {6, 7, 8, 1, 2, 3}
s.add(10)   #默认已经排序
s.add(8)
print s
# 增加多个元素
s.update({4,5})
print s

2 集合的删除

s = {6, 7, 8, 1, 2, 3}
print s
s.pop()
print s
# 删除指定的元素
s.remove(2)
print s

3 )交集 并集 差集

s1 = {1, 2, 3}
s2 = {2, 3, 4}

# 并集
print '并集：', s1.union(s2)
print '并集:', s1 | s2

# 交集
print '交集:', s1.intersection(s2)
print '交集:', s1 & s2

# 差集
# 可以理解为s1中有哪些s2中没有的元素
print '差集:', s1.difference(s2)  # s1-(s1&s2)
print '差集:', s1 - s2
# 可以理解为s2中有哪些s1中没有的元素
print '差集:', s2.difference(s1)  # s2-(s1&s2)
print '差集:', s2 - s1

对等差分:并集-交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
print '对等差分:', s1.symmetric_difference((s2))
print '对等差分:', s1 ^ s2

s3 = {1, 2}
s4 = {1, 2, 3}

# s3是否为s4的子集
print s3.issubset(s4)
# s3是否为s4的超集
print s3.issuperset(s4)
# 两个集合是不是不相交
print s3.isdisjoint(s4)