列表、元组、集合

一、列表

1.1 列表创建
数组：存储同一种数据类型的集合 scores = [12,23.5,423]，列表可以理解为(打了激素的数组)：可以存储任意数据类型的集合。
例如：

列表中也可以嵌套列表

1.2列表特性
#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(‘ftp’ in service)
#print(‘firewalld’ not in service)

##for 循环遍历
#print(‘服务显示’.center(50,’*’))
#for service in service:
##print不换行输出
#print(service,end=’ ')
“”"
python2：不换行输出
print ‘hello’,
“”"
#列表里面嵌套列表
service2 = [[‘http’,80],[‘ssh’,22],[‘ftp’,21]]

#索引
print(service2[0][0])
print(service2[-1][1])

#切片
print(service2[:][1])
print(service2[:-1][0])
print(service2[0][:-1])

练习1：

练习2：
假定有下面这样的列表:
names = [‘fentiao’, ‘fendai’, ‘fensi’, ‘apple’]
输出结果为:‘I have fentiao, fendai, fensi and apple.’

1.3列表元素的增加

1.4列表元素的删除
In [1]: servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]

In [2]: servers.pop()
Out[2]: ‘ftp’

In [3]: servers
Out[3]: [‘ftp’, ‘ssh’, ‘http’]

In [4]: a = servers.pop()

In [5]: a
Out[5]: ‘http’

In [6]: servers
Out[6]: [‘ftp’, ‘ssh’]

In [7]: servers.pop(0)
Out[7]: ‘ftp’

In [8]: servers
Out[8]: [‘ssh’]

In [9]: servers.pop()
Out[9]: ‘ssh’

In [10]: servers
Out[10]: []

In [11]: servers.pop() ####列表为空时再删除会报错
‘-----------------------------------------------------------------------------‘
IndexError Traceback (most recent call last)
in
----> 1 servers.pop()

IndexError: pop from empty list

#remove：删除列表元素
servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]
#a = servers.remove(‘ftp’)
#print(servers)
#print(a)

#从内存中删除
del servers[1]
print(servers)

1.5 列表元素的修改

1.6 列表的查看

1.7 列表的排序
import random
#排序查看 按照Ascii码进行排序的
services = [‘ftp’, ‘ssh’, ‘http’, ‘ftp’]
services.sort()
print(services)

#对字符串排序不区分大小写
In [15]: phones = [‘alice’,‘bob’,‘harry’,‘Borry’]

In [16]: phones.sort()

In [17]: phones
Out[17]: [‘Borry’, ‘alice’, ‘bob’, ‘harry’]

In [18]: phones.sort(key=str.lower)

In [19]: phones
Out[19]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

In [20]: phones.sort(key=str.upper)

In [21]: phones
Out[21]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

In [22]: phones.sort(key=str.upper)

In [23]: phones
Out[23]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

li = list(range(10))
print(li)

#将原有的列表顺序打乱
random.shuffle(li)
print(li)

实验：用户管理系统
1.系统里面有多个用户，用户的信息目前保存在列表里面
users = [‘root’,‘westos’]
passwd = [‘123’,‘456’]
2.用户登陆(判断用户登陆是否成功
1).判断用户是否存在
2).如果存在
1).判断用户密码是否正确
如果正确，登陆成功，推出循环
如果密码不正确，重新登陆，总共有三次机会登陆
3).如果用户不存在
重新登陆，总共有三次机会

实验：通过列表实现栈的数据结构
栈的工作原理
入栈
出栈
栈顶元素
栈的长度
栈是否为空


实验：后台管理员管理前台信息
#1. 后台管理员只有一个用户: admin, 密码: admin
#2. 当管理员登陆成功后， 可以管理前台会员信息.
#3. 会员信息管理包含:
添加会员信息
删除会员信息
查看会员信息
退出

二、元组

元组：带了紧箍咒的列表，元组是一个不可变数据类型，没有增删改查，可以存储任意的和数据类型
2.1 元组的创建
#定义一个元组
t = (1,1.2,True,‘westos’)
print(t,type(t))

#如果元组里面包含可变数据类型，可以间接修改元组内容
t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)

#元组如果只有一个元素，后面一定要加逗号，否则数据类型不确定
t2 = (1,)
t3 = (‘hello’,)
print(type(t2))
print(type(t3))
t4 =()
print(type(t4))

2.2 元组的常用方法
t = (1,1.2,True,‘westos’)
print(t.count(‘westos’))
print(t.index(1))

2.3 元组的特性
allowUsers = (‘root’,‘westos’,‘redhat’)
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 + (‘linux’,‘python’))

#成员操作符
print(‘westos’ in allowUsers)
print(‘westos’ not in allowUsers)

#for循环
for user in allowUsers:
print(user)

for index,user in enumerate(allowUsers):
print(‘第%d个白名单用户: %s’ %(index+1,user))

#zip:两个元组的元素之间一一对应
for user,passwd in zip(allowUsers,allowPasswd):
print(user,’:’,passwd)

2.4 元组的应用场景
##变量交换数值
#a = 1
#b = 2
#b,a = a,b

#1.先把(a,b)封装成一个元组(1,2)
#2.b,a=a,b ====>b,a=(1,2)
#b=(1,2)[0] a=(1,2)[1]

#print(b)
#print(a)

##打印变量的值
#name = ‘westos’
#age = 11
#t = (name,age)
#print(‘name: %s,age:%d’ %(name,age))
#print(‘name:%s,age:%d’ %t)

##元组的赋值，有多少个元素，就用多少个变量接收
#t = (‘westos’,11,100)
#name,age,score = t
#print(name,age,score)

scores = (100,89,45,78,65)
#scoreLi = list(scores)
#scoreLi.sort()
#print(scoreLi)
scores = sorted(scores)
print(scores)
#python3
minscore,*middlescore,maxscore = scores
print(minscore)
print(middlescore)
print(maxscore)
print(‘最终成绩为： %.2f’ %(sum(middlescore)/len(middlescore)))

三、集合

3.1 集合的定义
#集合里面的元素不可重复
s = {1,2,3,3,4,4,5,6}
print(s,type(s))

s1 = {1}
print(s1,type(s1))

#如何定义一个空集合
s2 = set([])
print(type(s2))

#列表去重
li = [1,2,2,2,3,4,4,5]
print(list(set(li)))

3.2 集合的特性
集合支持的特性只有：成员操作符，索引 切片 重复 连接 均不支持

3.3 集合常用方法
集合：
无序数据类型
添加顺序和在集合中存储的顺序是不同的

#s = {6,7,8,9}
##增加一个元素
#s.add(1)
#print(s)
##增加多个元素
#s.update({5,3,2})
#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)

#差集
print(‘差集:’,s1.difference(s2)) # s1-(s1&s2)
print(‘差集:’,s2.difference(s1)) # s2-(s1&s2)

#对等差分:并集-差集
print(‘对等差分:’,s1.symmetric_difference(s2))
print(‘对等差分:’,s1^s2)

s3 = {1,2}
s4 = {1,2,3}
#s3是否为s4的超集
print(s3.issuperset(s4))
#s3是否为s4的子集
print(s3.issubset(s4))
#两个集合是不是 不相交
print(s3.isdisjoint(s4))

华为机测题:
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，对于
其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不同的学生的学号，然后再把这些
数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“去重”与排序工作