1、堆栈
栈的工作原理
入栈
出栈
查看栈顶元素
栈的长度
栈是否为空
练习：使用python测试堆栈
stack = []
info = """
栈操作
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
q.退出
"""
while True:
print(info)
choice = input('请输入选择:')
if choice == '1':
item = input('入栈元素:')
stack.append(item)
print('元素%s入栈成功' %item)
elif choice == '2':
#先判断栈是否为空
if not stack:
print('栈为空，不能出栈')
else:
item = stack.pop()
print('%s元素出栈成功' %item)
elif choice == '3':
if len(stack) == 0:
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 == 'q':
print('退出')
break
else:
print('请输入正确的选择')
2、python中常用的内置方法
1）求最小值，最大值，求和
In [1]: min(3,4) ##求最小值
Out[1]: 3
In [2]: max(3,4) ##求最大值
Out[2]: 4
In [3]: sum(range(1,101)) ##求1-100的和
Out[3]: 5050
In [4]: sum(range(1,101,2)) ##求1-100的奇数和
Out[4]: 2500
In [5]: sum(range(2,101,2)) ##求1-100的偶数和
Out[5]: 2550
2）枚举：返回索引值和对应的value值
for i,v in enumerate('hello'):
print(i,v)
实验结果
0 h
1 e
2 l
3 l
4 o
3）zip
s1 = 'abc'
s2 = '123'
for i in zip(s1,s2):
print(i)
print(''.join(i))
实验结果
('a', '1')
a1
('b', '2')
b2
('c', '3')
c3
3.元组
1)元组的创建
一、元组（tuple）：元组本身是不可变数据类型，没有增删改查
元组内可以存储任意数据类型
测试
t = (1,2.3,True,'star')
print(t)
print(type(t))
结果
(1, 2.3, True, 'star')
<class 'tuple'>
二、元组里面包含可变数据类型，可以间接修改元组的内容
t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)
结果
([1, 2, 3, 4], 4)
三、元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
t2 = ('hello',)
t3 = (1,)
t4 = (1)
print(type(t2))
print(type(t3))
print(type(t4))
结果
<class 'tuple'>
<class 'tuple'>
<class 'int'>
2)元组的特性
一、索引 切片
allowUsers=(1,2,3,4)
print(allowUsers[0]) ##输出第一个元素
print(allowUsers[-1]) ##输出最后一个元素
print(allowUsers[1:]) ##输出除了第一个元素的其他元素
print(allowUsers[2:]) ##输出除了前两个元素的其他元素
print(allowUsers[:-1]) ##输出除了最后一个元素的其他元素
print(allowUsers[::-1]) ##倒序输出元素
结果
1
4
(2, 3, 4)
(3, 4)
(1, 2, 3)
(4, 3, 2, 1)
二、重复
print(allowUsers * 3)
结果
(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
三、连接
print(allowUsers + ('linux','python'))
结果
(1, 2, 3, 4, 'linux', 'python')
四、成员操作符
print('westos' in allowUsers)
print('westos' not in allowUsers)
结果
False
True
五、for循环
for user in allowUsers:
print(user)
结果
1
2
3
4
for index,user in enumerate(allowUsers):
print('第%d个白名单用户: %s' %(index+1,user))
六、zip:两个元组的元素之间一一对应
for user,passwd in zip(allowUsers,allowPasswd):
print(user,':',passwd)
3）元组的常用方法---计数和下标
t = (1,2.3,True,'westos','westos')
print(t.count('westos'))
print(t.index(2.3))
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(a)
# print(b)
结果：
2
1
二、打印变量的值
# name = 'westos'
# age = 11
# t = (name,age)
# print('name:%s , age:%d' %(name,age))
# print('name:%s , age:%d' %t)
结果
name:westos , age:11
name:westos , age:11
三、元组的赋值，有多少个元素，就用多少个变量接收
# t = ('westos',11,100)
# name,age,score = t
# print(name,age,score)
结果：
westos 11 100
元组两端的值和中间值
练习：求平均成绩（去掉最高最低分）
score = (100,89,45,78,65)
# scoreLi = list(score)
# scoreLi.sort()
# print(scoreLi)
scores = sorted(score)
# print(scores)
minscore,*middlescore,maxscore = scores
print(minscore)
print(middlescore)
print(maxscore)
print('最终成绩为: %.2f' %(sum(middlescore) / len(middlescore)))
4、集和
1）集和的定义
一、集合里面的元素是不可重复的
s = {1,2,3,1,2,3,4,5}
print(s)
print(type(s))
s1 = {1}
print(s1)
print(type(s1))
结果：
{1, 2, 3, 4, 5}
<class 'set'>
{1}
<class 'set'>
二、如何定义一个空集合
# s2 = {}
# print(type(s2))
#
# s3 = set([])
# print(s3)
# print(type(s3))
结果
<class 'dict'>
set()
<class 'set'>
三、集合的应用
li = [1,2,3,1,2,3]
print(list(set(li)))
2）集和的特性
#集合只支持成员操作符，不支持索引，重复，连接 for循环
s = {1,2,3}
# print(s[0])
# print(s * 3)
# print(s + {4,5,6})
print(1 in s)
结果：
True
for i in s:
print(i,end='|')
for i,v in enumerate(s):
print('index: %s,value: %s' %(i,v))
结果：
1|2|3|index: 0,value: 1
index: 1,value: 2
index: 2,value: 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(5)
# 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('对等差分:',s2.symmetric_difference(s1))
print('对等差分:',s1^s2)
s3 = {1,2}
s4 = {1,2,3}
三、集和的包含关系---超集，子集，是否相交
#s3是否为s4的超集
#超集:如果s3中的每一个元素都在集合s4中,且s4中可能包含s3中没有的元素,
#那么s4就是s3的一个超集
print(s3.issuperset(s4))
print(s4.issuperset(s3))
#s3是否为s4的子集
print(s3.issubset(s4))
#两个集和是不是 不相交
print(s3.isdisjoint(s4))
集和的练习：
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入>的，对于
其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着
不同的学生的学号，然后再把这些
数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“>去重”与排序工作
代码
import random
s = set([])
for i in range(int(input('N:'))):
s.add(random.randint(1,1000))
print(s)
print(sorted(s))
结果
N:5
[57, 243, 811, 620, 970]
[57, 243, 620, 811, 970]
5、字典
1)字典的定义
一、字典是一个无序的数据集合,使用print输出字典时
#通常输出的顺序和定义的顺序不一致
# users = ['user1','user2']
# passwd = ['123','456']
# print(zip(users,passwd))
# print(list(zip(users,passwd)))
# print(dict(zip(users,passwd)))
# s = {}
# print(type(s))
结果
<zip object at 0x7f4394379248>
[('user1', '123'), ('user2', '456')]
{'user1': '123', 'user2': '456'}
<class 'dict'>
二、字典:key-value 键值对
#value值可以是任意数据类型
格式：
key：value
# s = {
# 'linux':[100,99,88],
# 'westos':[190,564,645]
# }
#
# print(s)
# print(type(s))
结果
{'linux': [100, 99, 88], 'westos': [190, 564, 645]}
<class 'dict'>
三、工厂函数
# d = dict()
# print(d)
# print(type(d))
#
# d1 = dict(a=1,b=2)
# print(d1)
# print(type(d1))
结果：
{}
<class 'dict'>
{'a': 1, 'b': 2}
<class 'dict'>
四、字典的嵌套
students = {
'03113009':{
'name':'tom',
'age':18,
'score':80
},
'03113010':{
'name': 'laoli',
'age': 19,
'score':30
}
}
print(students['03113010']['name'])
结果
laoli
五、所有的key的value值是一样的情况的定义
print({}.fromkeys({'1','2'},'03113009'))
结果
{'1': '03113009', '2': '03113009'}
2）字典的特性
d = {
'1':'a',
'2':'b'
}
一、字典不支持索引
# print(d['1'])
二、字典不支持切片
# print(d[:])
三、字典的重复和连接无意义,因为字典的key值是唯一的
四、成员操作符
print('1' in d)
print('1' not in d)
结果
True
False
五、for循环,默认遍历字典的key值
for key in d:
print(key)
结果
1
2
遍历字典
for key in d:
print(key,d[key])
for key,value in d.items():
print(key,value)
结果
1 a
2 b
1 a
2 b
3）字典的增加，删除，查找
一、字典的增加
service = {
'http':80,
'ftp':21,
'ssh':22
}
增加一个元素
#如果key值存在,则更新对应的value值
#如果key值不存在,则添加对应的key-value值
service['mysql'] = 3306
print(service)
service['http'] = 443
print(service)
结果：
{'http': 80, 'ftp': 21, 'ssh': 22, 'mysql': 3306}
{'http': 443, 'ftp': 21, 'ssh': 22, 'mysql': 3306}
添加多个key-value值
service_backup = {
'https':443,
'tomcat':8080,
'http':8080
}
service.update(service_backup)
print(service)
service.update(flask=9000,http=8000)
print(service)
结果：
{'http': 8080, 'ftp': 21, 'ssh': 22, 'https': 443, 'tomcat': 8080}
{'http': 8000, 'ftp': 21, 'ssh': 22, 'https': 443, 'tomcat': 8080, 'flask': 9000}
setdefault添加key值
#如果key值存在,不做修改
#如果key值不存在,则添加对应的key-value
service.setdefault('http',9090)
print(service)
service.setdefault('oracle',44575)
print(service)
结果
{'http': 80, 'ftp': 21, 'ssh': 22}
{'http': 80, 'ftp': 21, 'ssh': 22, 'oracle': 44575}
二、字典的删除
del删除
service = {
'http':80,
'ftp':21,
'ssh':22
}
del service['http']
print(service)
结果：
{'ftp': 21, 'ssh': 22}
pop删除指定key的key-value
#如果key存在,删除,并且返回删除key对应的value
#如果key不存在,报错
# item = service.pop('http')
# print(item)
# print(service)
结果
80
{'ftp': 21, 'ssh': 22}
popitem删除最后一个key-value值
item = service.popitem()
print('删除的key-value对是:',item)
print(service)
结果
删除的key-value对是: ('ssh', 22)
{'http': 80, 'ftp': 21}
清空字典内容
service.clear()
print(service)
结果
{}
三、字典的查找
service = {
'http':80,
'ftp':21,
'ssh':22
}
#查看字典的key值
print(service.keys())
结果：
dict_keys(['http', 'ftp', 'ssh'])
#查看字典的value值
print(service.values())
结果：
dict_values([80, 21, 22])
#查看key的value值;key不存在,报错
# print(service['https'])
#查看key的value值
#key不存在,默认返回None
#key不存在,有default,则返回default
print(service.get('https',443))
print(service.get('https'))
结果
443
None
4）字典的遍历
# for k,v in service.items():
# print(k,'--->',v)
if 'https' in service:
print(service['https'])
else:
print('key not exist')
结果：
http ---> 80
ftp ---> 21
ssh ---> 22
key not exist
5）get方法获取指定key对应的value值
#如果key值存在,返回对应的value值
#如果key值不存在,默认返回None,如果需要指定返回值,传值即可
print(service.get('https','ket not exist'))
结果
ket not exist
字典练习1：
#数字重复统计:
1)随机生成1000个整数;
2)数字范围[20,100];
3)升序输出所有不同的数字及其每个数字重复的次数
"""
import random
all_nums = []
for item in range(1000):
all_nums.append(random.randint(20,100))
#对生成的1000个数进行排序,然后加到字典中
sorted_nums = sorted(all_nums)
num_dict = {}
for num in sorted_nums:
if num in num_dict:
num_dict[num] += 1
else:
num_dict[num] = 1
print(num_dict)
实验结果
{20: 5, 21: 10, 22: 9, 23: 15, 24: 12, 25: 17, 26: 14, 27: 19, 28: 7, 29: 7, 30: 16, 31: 15, 32: 13, 33: 10, 34: 13, 35: 17, 36: 14, 37: 15, 38: 18, 39: 11, 40: 12, 41: 9, 42: 7, 43: 13, 44: 7, 45: 9, 46: 11, 47: 16, 48: 12, 49: 12, 50: 8, 51: 16, 52: 18, 53: 8, 54: 14, 55: 10, 56: 10, 57: 10, 58: 13, 59: 14, 60: 12, 61: 13, 62: 16, 63: 8, 64: 8, 65: 7, 66: 11, 67: 8, 68: 13, 69: 16, 70: 17, 71: 9, 72: 16, 73: 7, 74: 16, 75: 12, 76: 13, 77: 15, 78: 15, 79: 16, 80: 12, 81: 16, 82: 11, 83: 12, 84: 18, 85: 13, 86: 11, 87: 16, 88: 14, 89: 16, 90: 10, 91: 12, 92: 11, 93: 10, 94: 10, 95: 16, 96: 16, 97: 13, 98: 8, 99: 14, 100: 7}
字典练习2：
重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
# 1. 用户输入一句英文句子；
# 2. 打印出每个单词及其重复的次数;
"hello java hello python"
# hello 2
# java 1
# python 1
代码
sentence = input('请输入句子')
for i in sentence:
if i in [',', '.']:
sentence = sentence.replace(i, '')
sentence = sentence.split()
print(sentence)
wordlist={}
for word in sentence:
if word in wordlist:
wordlist[word] += 1
else:
wordlist[word] = 1
print(wordlist)
实验结果
请输入句子shi wen, chang
['shi', 'wen', 'chang']
{'shi': 1, 'wen': 1, 'chang': 1}
作业：
# 1. 随机生成100个卡号；
# 卡号以6102009开头， 后面3位依次是 （001， 002， 003， 100>），
# 2. 生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";
# 3. 输出卡号和密码信息， 格式如下:
卡号 密码
6102009001 000000
代码
import random
s = set([])
for i in range(int(input('N:'))):
s.add(str(random.randint(0, 999)))
s = sorted(s)
d = {'帐号': '密码'}
for i in s:
if len(i) == 1:
d['610200900' + i] = 'redhat'
elif len(i) == 2:
d['61020090' + i] = 'redhat'
else:
d['6102009' + i] = 'redhat'
for j,k in d.items():
print(j,k)
结果
N:10
帐号 密码
6102009269 redhat
6102009392 redhat
6102009562 redhat
6102009575 redhat
6102009704 redhat
6102009726 redhat
6102009774 redhat
6102009793 redhat
6102009890 redhat
6102009909 redhat
# s = []
# for i in range(100):
# s1 = '6101009%.3d' %(i+1)
# s.append(s1)
# s2={}.fromkeys(s,'redhat')
# print('银行卡号\t\t\t密码')
# for key, value, in s2.items():
# #print('%s\t\t\t%s' %(key, s2[key]))
# print('%s\t\t\t%s' % (key, value))