列表，元组，集合，字典

• 列表和元组

数组:存储同一种数据类型的集合

1. 列表的基本概念:可以存储任意数据类型的集合
2. 列表的增加:

(1)append:追加 追加一个元素到列表中

(2)extend:拉神 追加多个元素到列表中

(3)insert:插入 在指定索引位置插入元素

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

1. 列表的删除:

1. pop

如果pop()不传递值的时候默认弹出最后一个元素

Pop()也可以传递索引值

1. remove:删除指定的元素
2. del:关键字 从内存中删除列表

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

1. 列表的修改

1. 通过索引，直接赋值
2. 通过切片

 

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

# 通过索引，重新赋值

service[0] = 'mysql'

print service

 

# 通过切片

print service[:2]

service[:2] = ['samba','ladp']

print service

1. 列表的排序

1. 按照Ascii码进行排序的
2. 对字符串排序不区分大小写
3. 将原有的列表顺序打乱

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

 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

 

 import random

 li = list(range(10))

 print li

 # 将原有的列表顺序打乱

 random.shuffle(li)

 print li

1. 列表的查看

1. 查看列表中元素出现的次数
2. 查看指定元素的索引

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

 

# 查看列表中元素出现的次数

print service.count('ssh')

 

# 查看指定元素的索引值

 

print service.index('ssh')

 

1. 列表的特性

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

 

# # 索引

# print service[0]

# print service[-1]

# # 切片

# print service[::-1] # 列表的翻转

# print service[1:] # 除了第一个元素之外的其他元素

# print service[:-1] # 除了最后一个元素之外的其他元素

# # 重复

# print service * 3

# # 连接

# service1 = ['mysql','firewalld']

# print service + service1

# # 成员操作符

# print 'firewalld' in service

# print 'firewalld' in service1

# print 'firewalld' not in service

# for循环遍历

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

# for se in service:

#     print se

 

# 列表里嵌套列表

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]

 

 

 

 

 

元组:

元组的应用场景：

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 = 'westos'

age = 10

t = (name,age)

print 'name: %s,age: %d' %(name,age)

print 'name: %s,age: %d' %t

 

3.元组的赋值：有多少个元素，就用多少个变量接收

t = ('westos',10,100)

name,age,score = t

print name,age,score

 

scores = (100,89,45,78,65)

# scoresLi = list(scores)

# scoresLi.sort()

# print scoresLi

scores = sorted(scores)

print scores

 

 

元组的特性:

allowUsers = ('root','westos','fentiao')

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 + ('fensi','fendai')

# 成员操作符

print 'westos' in allowUsers

print 'westos' not in allowUsers

 

 

 

 

 

 

 

 

 

 

• 集合和字典

集合:

集合的基本属性:

# 集合里面的元素是不可重复的

s = {1,2,3,1,2,3,4,5}

print s,type(s)

s1 = {1}

print s1,type(s1)

 

定义一个空列表

s3 = set([])

print s3,type(s3)

 

# 集合的应用

li = [1,2,3,1,2,3]

print list(set(li))

集合的常用方法：

s = {6, 7, 8, 1, 2, 3}

#  增加

# s.add(10)

# s.add(9)

# print s

# 增加多个元素

# s.update({4,5})

# print s

# 删除

# print s

# s.pop()

# print s

# 删除指定的元素

# s.remove(2)

# print s

 

 

# 交集 并集 差集

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

 

# 对等差分:并集-交集

print '对等差分:', s1.symmetric_difference((s2))

print '对等差分:', s1 ^ s2

 

s3 = {1, 2}

s4 = {1, 2, 3}

 

# s3是否为s4的子集

print s3.issubset(s4)

# s3是否为s4的超集

# 什么是超集：如果s3中的每一个元素都在集合s4中，且

# s4中可能包含s3中没有的元素，则s3就是s4的一个超集

print s3.issuperset(s4)

 

# 两个集合是不是不相交

print s3.isdisjoint(s4)

 

 

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

s = {1,2,3}

print 1 in s

 

for i in s:

    print i,

for i,v in enumerate(s):

    print 'index: %s,value:%s' %(i,v)

 

 

 

 

 

 

字典

字典的定义：字典是一个无序的数据集合，使用print打印字典时通常打印出来的顺序和定义的顺序不一致

 

定义字典的方法

d = dict()

print d,type(d)

 

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

print d,type(d)

 

字典的增加

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

# print d

# # 添加或者更改key-value对

# d['g'] = 10

# print d

# d['a'] = 10

# print d

"""

update:

    如果key值存在，更新value值

    如果key值不存在，添加key-value值

"""

# d.update({'a':4,'f':1})

# print d

 

"""

setdefault

    如果key值已经存在，不做修改

    如果key值不存在，添加key-value值

"""

d.setdefault('a',10)

print d

字典的删除

d = dict(a=1, b=2,c=3)

# pop:弹出指定的key-value值

# d.pop('a')

# print d

# print d

# d.popitem()

# print d

 

del d['a']

print d

字典的修改与查看

service = {

    'http':80,

    'mysql':3306

}

 

# 查看字典里面所有的key值

print service.keys()

 

# 查看字典里面所有的value值

print service.values()

 

# 查看字典里面所有的key-value值

print service.items()

 

# 遍历

for k,v in service.items():

    print k,'---->',v

 

for k in service:

    print k,'----->',service[k]

 

# print service['https']

# if 'https' in service:

#     print service['https']

# else:

#     print 'key not exist'

 

"""

*****************************************************

get方法获取指定key对应的value值

    如果key值存在，返回对应的value值

    如果key值不存在，默认返回None,如果需要指定返回值，传值即可

"""

print service.get('http','key not exist')

******************************************************

字典的特性

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

 

 

 

 

 

 

列表的去重

# 1. 列表去重：转换为集合

li = [1, 2, 3, 4, 65, 1, 2, 3]

print(list(set(li)))

 

 

# 2. 通过字典的方式去重

# ** 字典的key值是不能重复的.

# d = {'a':1, 'b':2}

# d['a'] = 3

li = [1, 2, 3, 4, 65, 1, 2, 3]

print({}.fromkeys(li).keys())

 

 

 

 

 

 

# 数值:

# bool：

# str

# list, tuple, set, dict

 

 

 

 

#1.  可变数据类型or不可变数据类型

 

#           可变数据类型： list, set, dict(是否可以增删改查)

 

 

# 2. 有序数据类型和无序数据类型

#     - 有序: str, list, tuple

#     - 无序: 数值:， bool, set

 

# python2: dict无序， python3： dict有序

 

 

# *****一般情况下， 有序数据类型可以索引， 切片， 连接， 重复， 但是字典除外, 因为d[key]；