列表（list）
列表的创建
数值类型：int float long
布尔型：bool
字符串类型：str
列表：list
数组：存储同一种数据类型的集合
列表(打了激素的数组)：可以存储任意数据类型的集合
列表
li = [1,2.2,True,'hello']
print(li,type(li))
列表里面嵌套列表：
li = [1,2.2,True,'hello',[1,2,3,4]]
print(li,type(li))
生成随机数列表
import random
li = list(range(10))
random.shuffle(li)
print(li)
打印菱形
代码：
n = int(input('NUM:'))
for i in range(1,2*n,2):
print(('*' * i).center(3 * n))
s = range(1,2*(n-1),2)
for i in s[::-1]:
print(('*' * i).center(3 * n))
运行结果：
列表的特性
定义列表
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)
for循环
for i in service:
print(i)
成员操作符
print('firewalld' in service)
print('ftp' in service)
print('firewalld' not in service)
print('ftp' not in service)
列表里面嵌套列表
service2 = [['http',80],['ssh',22],['ftp',21]]
索引
print(service2[0][0])
print(service2[-1][1])
练习：
1.根据用于指定月份，打印该月份所属的季节。
----提示: 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
代码：
month = int(input('Month:'))
if month in [3,4,5]:
print('春季')
elif month in [6,7,8]:
print('夏季')
elif month in [9,10,11]:
print('秋季')
else:
print('冬季')
运行结果：
2.假设有下面这样的列表：
----names = [‘fentiao’,‘fendai’,‘fensi’,‘fish’]
----输出的结果为：‘I have fentiao,fendai,fensi and fish’
代码：
names = ['fentiao','fendai','fensi','fish']
print('I have ' + ','.join(names[:-1]) + ' and ' + names[-1])
运行结果：
列表元素的添加
service = ['http', 'ssh', 'ftp']
连接
print(service + ['firewalld'])
append:追加，追加一个元素到列表中
service.append('mysql')
print(service)
extend:拉伸，追加多个元素到列表中
service.extend(['hello','python'])
print(service)
insert:插入，在索引位置插入元素
service.insert(0,'firewalld')
print(service)
列表元素的删除
service = ['http', 'ssh', 'ftp']
remove
service.remove('ftp')
print(service)
#不能删除不存在的元素
#service.remove('https')
#print(service)
clear:清空列表中的所有元素
service.clear()
print(service)
del(python关键字):从内存中删除列表
#del service
#print(service)
print('删除列表第一个索引对应的值：',end='')
del service[1]
print(service)
print('删除前两个元素之外的其他元素:',end='')
del service[2:]
print(service)
pop:通过索引删除元素
service.pop(0)
print(service)
service.pop(-1)
print(service)
列表元素的修改
service = ['ftp','http', 'ssh', 'ftp']
通过索引（重新赋值）
service[0] = 'mysql'
print(service)
通过slice(切片)
service[:2] = ['mysql','firewalld']
print(service)
列表元素的查看
service = ['ftp','http','ssh','ftp','ssh','ssh']
查看元素出现的次数
print(service.count('ftp'))
查看指定元素的索引值(也可以指定范围)
print(service.index('ssh'))
print(service.index('ssh',1,3))
排序查看(按照ascii码进行排序)
#正向排序
service.sort()
print(service)
#反向排序
service.sort(reverse=True)
print(service)
字符串排序会区分大小写
names = ['alice','bob','tom','Barry']
names.sort()
print(names)
#对字符串排序不区分大小写
names.sort(key=str.lower)
print(names)
names.sort(key=str.upper)
print(names)
列表练习
栈的实现
stack = [1,2,3,4]
栈的工作原理：先进后出
入栈
出栈
栈顶元素
栈的长度
栈是否为空
代码：
stack = []
info = """
操作目录
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
6.退出
"""
while True:
print(info)
choice = input('请输入你的选择:')
if choice == '1':
i = input('输入元素:')
stack.append(i)
print('元素%s入栈成功' % i)
elif choice == '2':
if len(stack) == 0:
print('栈为空，不能出栈')
else:
i = stack.pop()
print('元素%s出栈成功' % i)
elif choice == '3':
if not stack:
print('栈为空，无栈顶元素')
else:
print('栈顶元素为%s' %(stack[-1]))
elif choice == '4':
print('栈的长度为:%s' %(len(stack)))
elif choice == '5':
if len(stack) == 0:
print('栈为空')
else:
print('栈不为空')
elif choice == '6':
print('欢迎下次使用')
break
else:
print('请输入正确的操作！')
运行结果：
用户管理
1.系统里面有多个用户， 用户信息目前保存在列表里面;
users = [‘root’, ‘westos’]
passwds = [‘123’, ‘456’]
2.用户登陆(判断用户登陆是否成功):
1) 判断用户是否存在(inuser in users)
2) 如果存在:
----判断用户密码是否正确(先找出用户对应的索引值， 根据passwds[索引值]拿出该用户的码)
----如果正确: 登陆成功， 退出循环；
----如果密码不正确, 重新登陆， 总共有三次登陆机会
3.如果不存在:
----重新登陆， 总共有三次登陆机会
代码：
user = ['user1','user2']
passwds = ['123','456']
for i in range(3):
inuser = input('用户名:')
inpasswd = input('密码:')
if inuser in user:
index = user.index(inuser)
passwd = passwds[index]
if inpasswd == passwd:
print('登录成功')
break
else:
print('密码错误，登录失败')
else:
print('%s用户不存在，登录失败' % inuser)
else:
print('机会已经用完')
运行结果：
元组（tuple）
元组的创建
元组
列表：打了激素的数组
元组：带了紧箍咒的列表
不可变数据类型，没有增删改查
可以存储任意数据类型
定义元组
t = (1,1.2,True,'westos')
print(t,type(t))
#如果元组里面包含可变数据类型，可以间接修改元组内容
t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)
#定义空元组
t2 = ()
print(t2)
#列表和元组的转换
t3 = tuple([])
print(t3)
l4 = list(())
print(l4)
#元组如果只有一个元素，后面一定要加逗号，否则数据类型不确定
t4 = (1,)
print(t4,type(t4))
元组的特性
tuple = (1, 2.2, True, 'westos')
# 索引
print(tuple[0])
print(tuple[-1])
# 切片
print(tuple[1:])
print(tuple[:-1])
print(tuple[::-1])
# 连接
# 不同数据类型可以连接吗(除了数值类型，不同的数据类型之间不能连接)
print(tuple + (1, 2, 3))
# print(tuple + [4,5,6])
# print(tuple + 'westos')
#重复
print(tuple * 3)
#成员操作符
print(1 in tuple)
print(1 not in tuple)
#for循环
for i in tuple:
print(i)
元组的常用方法
t = (1,2,'a','c','a')
# 查看元素的索引值
print(t.index('c'))
# 查看元素在元组中出现的次数
print(t.count('a'))
元组的应用场景
1.变量交换数值
先把(a,b)封装成了一个元组 (1,2)
b,a = a,b ===> b,a = (1,2)
b = (1,2)[0] a =(1,2)[1]
a = 1
b = 2
b,a = a,b
print(a,b)
2.打印变量值
name = 'westos'
age = '18'
#直接打印变量值
print('name:%s,age:%s' %(name,age))
#应用元组打印变量值
t = (name,age)
print('name:%s,age:%s' %t)
3.元组的赋值
# 有多少个元素，就用多少个变量接收
t = ('westos',10,100)
name,age,score = t
print(name,age,score)
4.元组的排序
scores = (100,89,93,79,53,65)
#先将元组转换成列表
scoreli = list(scores)
scoreli.sort()
print(scoreli)
#sorted排序
score_sort = sorted(scores)
print(score_sort)
5.比赛计分器(列表)
#列表
#scores = [100,89,93,79,53,65]
#scores.sort()
#元组
scores = (100,89,93,79,53,65)
scores = sorted(scores)
min_score,*middle,max_score = scores
print('最终成绩:%s' %(sum(middle)/4))
浅拷贝和深拷贝
当一个变量 = xxx 的时候,约定为: 指向地址的过程
浅拷贝:copy.copy()
深拷贝:copy.deepcopy()
如果用copy.copy()拷贝的是元组,那么它不会进行浅拷贝,仅仅是指向,因为元组是不可变数据类型,那么意味着数据一定不能修改。
因此用copy.copy的时候它会自动判断,是指向
如果,用copy.copy() copy.deepcopy()对一个全部是不可变类型的数据进行数据拷贝,那么它们的结果相同,都是引用
如果拷贝的是一个拥有可变类型的数据,那么deepcopy依然是深拷贝,而copy.copy还是指向
In [13]: import copy
# 可变数据类型
In [14]: a = [11,22]
In [15]: b = [33,44]
In [16]: c = [a,b]
In [20]: d = copy.copy(c)
In [21]: e = copy.deepcopy(c)
In [22]: id(c)
Out[22]: 140061397861064
In [23]: id(d)
Out[23]: 140061397862728
In [24]: id(e)
Out[24]: 140061397240904
In [25]: id(c[0])
Out[25]: 140061389664328
In [26]: id(d[0])
Out[26]: 140061389664328
In [27]: id(e[0])
Out[27]: 140061396927816
#不可变数据类型
In [28]: a = (11,22)
In [29]: b = (33,44)
In [30]: c = (a,b)
In [31]: d = copy.copy(c)
In [32]: e = copy.deepcopy(c)
In [33]: id(c)
Out[33]: 140061389613000
In [34]: id(d)
Out[34]: 140061389613000
In [35]: id(e)
Out[35]: 140061389613000
In [36]: id(c[0])
Out[36]: 140061370709384
In [37]: id(d[0])
Out[37]: 140061370709384
In [38]: id(e[0])
Out[38]: 140061370709384
#含可变数据类型
In [39]: a = [11,22]
In [40]: b = [33,44]
In [41]: c = (a,b)
In [42]: d = copy.copy(c)
In [43]: e = copy.deepcopy(c)
In [44]: id(a)
Out[44]: 140061396446856
In [45]: id(c)
Out[45]: 140061396089480
In [46]: id(d)
Out[46]: 140061396089480
In [47]: id(e)
Out[47]: 140061396772296
In [48]: id(c[0])
Out[48]: 140061396446856
In [49]: id(d[0])
Out[49]: 140061396446856
In [50]: id(e[0])
Out[50]: 140061396443400
集合（set）
集合的定义
集和里面的元素是不可重复的
s = {1,2,3,4,5,6,6,3,3,2}
print(s,type(s))
s1 = {1}
print(s1,type(s1))
应用:列表去重
li = [1,2,3,4,1,2,3]
print(list(set(li)))
定义一个空集和
#默认是dict,称为字典
s2 = {}
print(s2,type(s2))
#定义空集和
s3 = set([])
print(s3,type(s3))
集合的特性
集合支持的特性只有 成员操作符 for循环(索引 切片 重复 连接 均不支持)
s = {1,3,5}
#成员操作符
print(1 in s)
print(1 not in s)
#for循环
for i in s:
print(i,end=' ')
print()
#枚举(for + index)
for i,v in enumerate(s):
print('index:%s\tvalue:%s' %(i,v))
集合的常用方法
s = {6, 7, 3, 1, 2, 3}
# 添加
# 添加顺序和在集合中的存储顺序不同
s.add(8)
print(s)
# 添加多个元素
s.update({9, 10, 11})
print(s)
# 删除
s.pop()
print(s)
# 删除指定元素(元素要存在)
s.remove(3)
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中没有的元素 #s2 - (s1 & s2)
print('差集:',s2.difference(s1))
print('差集:',s2 - s1)
# 对等差分:并集 - 交集
print('对等差分:',s1.symmetric_difference(s2))
print('对等差分:',s1 ^ s2)
s3 = {1, 2}
s4 = {1, 2, 3}
#s3是否为s4的子集(返回值为True/False)
print(s3.issubset(s4))
#s3是否为s4的超集(返回值为True/False)
#超集:如果一个集合s4中的每一个元素都在集合s3中，且集合s3中可能包含s4中没有的元素，则集合s3就是s4的一个超集
print(s3.issuperset(s4))
#两个集合是不是不相交(返回值为True/False)
print(s3.isdisjoint(s4))
集合练习
去重排序
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，对于其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不同学生的学号，然后再把这些数从小到大排序，按照排好的顺序去找同学做调查
代码：
import random
#生成n个随机数
#优先选择集合
N = int(input('请输入一个不大于1000的整数:'))
s = set([])
for i in range(N):
s.add(random.randint(1,1000))
print(sorted(s))
运行结果：
字典（dict）
字典的创建
字典
key-value 键值对存储的一种数据结构
value值可以是任意数据类型:int / float / long / list / tuple / set / dict
# 定义空字典
d = {}
print(type(d))
# list
d1 = {
'王超':[18,'男','玩手机'],
'王凯':[18,'男','修手机']
}
print(d)
print(d['王凯'])
# int
d2 = {
'a':1,
'b':2
}
print(d2)
# set
d3 = {
'a':{1,2,3},
'b':{2,3,4}
}
print(d3)
字典的嵌套
students = {
'06163012':{
'name':'王凯',
'age':18,
'score':90
},
'03162003':{
'name':'管良虎',
'age':19,
'score':80
}
}
print(students['03162003']['name'])
fromkeys创建字典
fromkeys第一个参数可以是 list / tuple / str / set
将第一个参数的元素作为字典的key值，并且所有key的value值一致
d4 = {}.fromkeys({'1','2','3'},'a'))
print(d4)
工厂函数
d5 = dict(a=1,b=2)
print(d5)
字典的特性
d = {
'1': 'a',
'2': 'b',
'3': 'c'
}
# 查找key值对应的value值
print(d['1'])
# 字典不支持索引
# print(d[0])
# 字典不支持切片
# print(d[::-1])
# 字典的重复和连接是无意义的，字典的key是唯一的
# 成员操作符:判断的是 某个值是否为字典的key
print('1' in d)
print('1' not in d)
# for循环
# 默认遍历字典的key值
for key in d:
print(key)
# 遍历字典
for key in d:
print(key,d[key])
字典的增加
services = {
'http':80,
'ftp':21,
'ssh':22
}
1.添加一个元素
----如果key值不存在，则添加对应的key-value值
----如果key值存在，则更新对应的key值
services['mysql'] = 3306
print(services)
services['http'] = 443
print(services)
2.添加多个key-value值
----如果key值不存在，则添加对应的key-value值
----如果key值存在，则更新对应的key值
services_backup = {
'tomcat':8080,
'https':443,
'http':8888
}
services.update(services_backup)
print(services)
services.update(flask=9000,http=999)
print(services)
3.setdefault添加key值:
----如果key值不存在，则添加对应的key-value值
----如果key值存在，则不做修改
services.setdefault('oracle',44575)
print(services)
services.setdefault('http',9000)
print(services)
字典的删除
services = {
'http': 80,
'ftp': 21,
'ssh': 22,
'mysql': 3306
}
1.del关键字
del services['http']
print(services)
2.pop删除指定的key-value值
# 如果key存在，删除并返回删除key对应的value值
item = services.pop('http')
print(item)
print(services)
# 如果key不存在，直接报错
# item = services.pop('https')
# print(item)
# print(services)
3.popitem删除最后一个key-value值
item = services.popitem()
print('删除的key-value对应的是:',item)
print(services)
4.清空字典内容
services.clear()
print(services)
字典的查看和修改
service = {
'http': 80,
'mysql': 3306
}
# 查看字典里的key值
print(service.keys())
# 查看字典里的value值
print(service.values())
# 遍历字典
for k, v in service.items():
print(k, '---->', v)
for k in service:
print(k, '---->', service[k])
# 查看指定key对应的value值
print(service['http'])
# key值不存在，程序会报错
# print(service['https'])
# get查看指定key对应的value值
#如果key值存在，返回对应的value值
print(service.get('http'))
#如果key值不存在，默认返回None，如果需要指定返回值，传值即可
print(service.get('https'))
print(service.get('https','Not is exist'))
字典练习
随机生成100个卡号；
----卡号以6102009开头， 后面3位依次是 （001， 002， 003， 100），
生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat"；
输出卡号和密码信息， 格式如下：
| 卡号 | 密码 |
|---|---|
| 6102009001 | 000000 |
代码：
# 存储所有卡号列表,也可以通过集合来存储
card_ids = []
# 生成100个卡号
for i in range(100):
# %.3d代表这个整型数占3位 eg:1--->001
s = '6102009%.3d' %(i+1)
# 将每次生成的卡号都加入到列表中
card_ids.append(s)
card_ids_dict = {}.fromkeys(card_ids,'redhat')
print('卡号\t\t\t\t\t密码')
for key in card_ids_dict:
print('%s\t\t\t%s' %(key,card_ids_dict[key]))
运行结果：
python内置数据结构总结
数据类型
数值（int float）
bool
str
list tuple set dict
可变数据类型和不可变数据类型
可变数据类型：list set dict
不可变数据类型：tuple
判断依据：是否可以增删改查
有序数据类型和无序数据类型
有序数据类型：str list tuple
无序数据类型：数值 bool set
python2:dict无序 python3中：dict有序
一般情况下:有序数据类型可以索引，切片，连接，重复 但是字典除外
可以for循环数据结构
495
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
