本文介绍了Python的内置数据结构，包括字符串的操作、变量名的合法性检查、常用内置方法的使用，以及深入探讨列表、元组、集合和字典的创建、特性、操作方法。此外，还讲解了Python中的深拷贝与浅拷贝概念，以及字典在实际问题中的应用，如学生学号去重与排序。
1.字符串
1.判断字符串 变成‘标题’
In [1]: 'Hello'.istitle()
Out[1]: True
In [2]: 'hello'.istitle()
Out[2]: False
In [7]: 'heLLo'.islower()
Out[7]: False
In [8]: 'heLLo'.isupper()
Out[8]: False
2.将字符串全部变为大写
In [3]: 'hello'.upper()
Out[3]: 'HELLO'
3.将字符串全部变为小写
In [4]: 'heLLo'.lower()
Out[4]: 'hello'
In [5]: 'heLLo'.title()
Out[5]: 'Hello'
In [6]: 'heLLo'.swapcase()
Out[6]: 'HEllO'
[[:digit:]] [[:alnum:]]
[[:upper:]] [[:lower:]]
[[:space:]]
4.变量名是否合法？
1).变量名可以由字母，数字或下划线组成
2).变量名只能以字母或下划线开头
1.变量名的第一个字符是否为字母或下划线
2.如果是，继续判断
3.如果不是，报错，不合法
4.依次判断除了第一个字符之外的其他字符
5.判断这个字符是否为数字或下划线
while True:
s = input('变量名：')
if s == 'exit':
print('欢迎下次使用')
break
if s[0].isalpha() or s[0] == '_':
for i in s[1:]:
if not(i.isalnum() or i =='_'):
print('%s变量名不合法' %(s))
break
else:
print('%s变量名合法' %(s))
else:
print('变量名不合法')
变量名：asda
asda变量名合法
变量名：1dsasd
变量名不合法
变量名：sdada_
sdada_变量名合法
变量名：dasd-
dasd-变量名不合法
2.python常用内置方法
In [1]: min(2,4)
Out[1]: 2
In [2]: max(2,4)
Out[2]: 4
In [3]: sum(range(1,101))
Out[3]: 5050
In [4]: sum(range(2,101,2))
Out[4]: 2550
In [5]: sum(range(1,101,2))
Out[5]: 2500
枚举：返回索引值和对应的value值
In [8]: for i,v in enumerate('hello'):
...: print(str(i) + '--------->' + v)
...:
0--------->h
1--------->e
2--------->l
3--------->l
4--------->o
In [9]: s1 = 'abc'
In [10]: s2 = '123'
In [11]: for i in zip(s1,s2):
...: print(i)
...:
('a', '1')
('b', '2')
('c', '3')
In [12]: for i in zip(s1,s2):
...: print(''.join(i))
...:
a1
b2
c3
In [13]: for i in zip(s1,s2):
...: print('-'.join(i))
...:
a-1
b-2
c-3
星星
n = int(input('Num:'))
for i in range(1,n):
print(('*' * i).center(3*n))
for i in range(n,0,-1):
print(('*' * i).center(3*n))
Num:10
*
**
***
****
*****
******
*******
********
*********
**********
*********
********
*******
******
*****
****
***
**
*
3.pycharm的使用
pycharm设置界面(ctrl+alt+s)
修改编辑界面字体
修改控制台界面字体
如何快速创建文件(alt+insert)
格式化python代码，使编程风格好看
如何撤销代码的修改(ctrl + z)
如何取消撤销的代码的修改(ctrl + shift + z)
快速重命名(shift + F6)
快速注释代码(ctrl + /)
快速取消注释代码(ctrl + /)
4.列表
1.列表的创建
数值类型：int float (long)
布尔型
字符串
列表(list)
数组：存储同一种数据类型的集和 scores=[1,2,33,44]
列表(打了激素的数组)：可以存储任意数据类型的集和
li = [1,2.2,True,'hello']
print(li,type(li))
列表里面是可以嵌套列表的
li = [1,2,3,False,'python',[1,2,3,4,5]]
print(li,type(li))
import random
li = list(range(10))
random.shuffle(li)
print(li)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
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)
print('ftp' not in service)
#列表里面嵌套列表
service2 = [['http',80],['ssh',22],['ftp',21]]
#索引
print(service2[0][0])
print(service2[-1][1])
http
ftp
['ftp', 'ssh', 'http']
['ssh', 'ftp']
['http', 'ssh']
['http', 'ssh', 'ftp', 'http', 'ssh', 'ftp', 'http', 'ssh', 'ftp']
['http', 'ssh', 'ftp', 'mysql', 'firewalld']
False
True
True
False
http
21
3.列表练习
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('冬季')
Month:3
春季
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])
I have fentiao,fendai,fensi and fish
4.列表元素的增加
service = ['http', 'ssh', 'ftp']
print(service + ['firewalld'])
append:追加,追加一个元素到列表中
service.append('firewalld')
print(service)
extend:拉伸，追加多个元素到列表中
service.extend(['hello','python'])
print(service)
insert:在索引位置插入元素
service.insert(0,'firewalld')
print(service)
5.列表元素的删除
service = ['http', 'ssh', 'ftp']
#remove
service.remove('ftp')
print(service)
service.remove('https')
print(service)
#claer:清空列表里面的所有元素
service.clear()
print(service)
#del(python关键字) 从内存中删除列表
del service
print(service)
print('删除列表第一个索引对应的值：',end='')
del service[1]
print(service)
print('删除前两个元素之外的其他元素:',end='')
del service[2:]
print(service)
6.元素列表的修改
service = ['http', 'ssh', 'ftp']
#通过索引，重新赋值
service[0] = 'mysql'
print(service)
#通过slice(切片)
service[:2] = ['mysql','firewalld']
print(service)
7.列表元素的查看
service = ['ftp','http', 'ssh', 'ftp','ssh','ssh']
#查看元素出现的次数
print(service.count('ftp'))
2
#查看制定元素的索引值(也可以指定范围)
print(service.index('ssh'))
print(service.index('ssh',4,8))
2
4
#排序查看(按照ascii码进行排序)
print(service.sort(reverse=True))
print(service)
None
['ssh', 'ssh', 'ssh', 'http', 'ftp', 'ftp']
print(service.sort(reverse=False))
print(service)
None
['Ssh', 'ftp', 'ftp', 'http', 'ssh', 'ssh']
#对字符串排序不区分大小写
phones = ['alice','bob','harry','Borry']
#phones.sort(key=str.lower)
phones.sort(key=str.upper)
print(phones)
['alice', 'bob', 'Borry', 'harry']
8.列表练习
1）stack = [1,2,3,4]
栈的工作原理：先进后出
入栈
出栈
栈顶元素
栈的长度
栈是否为空
info = """
栈操作
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
q.退出
"""
stack = []
while True:
print(info)
choice = input('请输入元素：')
if choice == '1':
item = input('入栈元素：')
stack.append(item)
print('入栈成功')
elif choice == '2':
if not stack:
print('栈是空的，无法出栈')
else:
item = stack.pop()
print('出栈成功')
elif choice == '3':
if not stack:
print('栈是空的,无栈顶元素')
else:
print('栈顶元素是%s，%(stack[-1])')
elif choice == '4':
print('栈的长度为%s' %(len(stack)))
elif choice == '5':
if not stack:
print('栈是空的')
else:
print('栈不是空的')
elif choice == 'q':
print('退出')
exit()
else:
print('请输入正确命令')
栈操作
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
q.退出
请输入选择：1
入栈元素：1
元素1入栈成功
栈操作
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
q.退出
请输入选择：5
栈不是空的
1). 系统里面有多个用户， 用户信息目前保存在列表里面;
users = [‘root’, ‘westos’]
passwds = [‘123’, ‘456’]
2). 用户登陆(判断用户登陆是否成功):
3). 判断用户是否存在?(inuser in users)
#如果存在:
判断用户密码是否正确?
(先找出用户对应的索引值， 根据passwds[索引值拿出该用户的密码)
如果正确:
登陆成功， 退出循环；
如果密码不正确:
重新登陆， 总共有三次登陆机会
#如果不存在:
重新登陆， 总共有三次登陆机会
users = ['user1','user2']
passwds = ['qqq','www']
trycount = 0
while trycount < 3:
trycount += 1
user = input('请输入用户名：')
passwd = input('请输入密码：')
if user in users:
index = users.index(user)
passwds = passwds[index]
if passwd == passwds:
print('登陆成功')
break
else:
print('%s登录失败:密码错误' %(user))
else:print('用户%s不存在' %(user))
else:
print('尝试次数超过3次，请稍后再试')
请输入用户名：qqq
请输入密码：qqq
用户qqq不存在
请输入用户名：user1
请输入密码：www
user1登录失败:密码错误
请输入用户名：qqq
请输入密码：qqq
用户qqq不存在
尝试次数超过3次，请稍后再试
请输入用户名：user1
请输入密码：qqq
登陆成功
1). 系统里面有多个用户， 用户信息目前保存在列表里面;
users = [‘root’, ‘westos’]
passwds = [‘123’, ‘456’]
2). 用户登陆(判断用户登陆是否成功):
3). 判断用户是否存在?(inuser in users)
#如果存在:
判断用户密码是否正确?
(先找出用户对应的索引值， 根据passwds[索引值拿出该用户的密码)
如果正确: 登陆成功， 退出循环；
如果密码不正确, 重新登陆， 总共有三次登陆机会
#如果不存在:
重新登陆， 总共有三次登陆机会
stacku = ['qqq', 'www']
stackp = ['qqq', 'www']
user = 'admin'
passwd = 'admin'
inuser = input('请输入用户名：')
inpasswd = input('请输入密码：')
if inuser == user and inpasswd == passwd:
print('登陆成功：')
while True:
print("""
1.添加会员信息
2.删除会员信息
3.查看会员信息
q.退出
""")
choice = input('请输入元素：')
if choice == '1':
itemu = input('请输入会员帐号：')
if itemu in stacku:
print('该会员已经存在')
else:
itemp = input('请输入会员密码：')
stacku.append(itemu)
stackp.append(itemp)
print('添加会员信息成功')
elif choice == '2':
itemdp = input('请输入会员帐号：')
if itemdp not in stacku:
print('该会员不存在')
else:
itempd = ('请输入密码：')
itemdu = stacku.index(itemdp)
stacku.remove(itemdp)
stackp.pop(itemdu)
elif choice == '3':
print('\t用户名\t密码')
usercount = len(stacku)
for i in range(usercount):
print('\t%s\t%s' % (stacku[i], stackp[i]))
elif choice == 'q':
exit()
else:
print('请输入正确操作')
else:
print('登录失败')
请输入用户名：admin
请输入密码：admin
登陆成功：
1.添加会员信息
2.删除会员信息
3.查看会员信息
q.退出
请输入元素：1
请输入会员帐号：q
请输入会员密码：q
添加会员信息成功
1.添加会员信息
2.删除会员信息
3.查看会员信息
q.退出
请输入元素：3
用户名 密码
qqq qqq
www www
q q
1.添加会员信息
2.删除会员信息
3.查看会员信息
q.退出
请输入元素：2
请输入会员帐号：q
1.添加会员信息
2.删除会员信息
3.查看会员信息
q.退出
请输入元素：2
请输入会员帐号：q
该会员不存在
5.元组
列表：打了激素的数组
元组:带了紧箍咒的列表
不可变数据类型，没有增删改查
可以存储任意数据类型
1.元组的创建
#定义元组
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))
(1, 1.2, True, 'westos') <class 'tuple'>
([1, 2, 3, 4], 4)
()
()
[]
(1,) <class 'tuple'>
2.元组的特性
tuple = (1,1.0,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 * 5)
#for循环
for i in tuple:
print(i)
#成员操作符
print(1 in tuple)
print(i not in tuple)
1
westos
(1.0, True, 'westos')
(1, 1.0, True)
('westos', True, 1.0, 1)
(1, 1.0, True, 'westos', 1, 2, 3)
(1, 1.0, True, 'westos', 1, 1.0, True, 'westos', 1, 1.0, True, 'westos', 1, 1.0, True, 'westos', 1, 1.0, True, 'westos')
1
1.0
True
westos
True
False
3.元组的常用方法
t = (1,2,'a','c','a')
# 查看元素的索引值
print(t.index('c'))
# 查看元素在元组中出现的次数
print(t.count('a'))
3
2
4.元组的应用场景
#变量交换数值
a = 1
b = 2
b,a = a,b
"""
1.先把(a,b)封装成了一个元组 (1,2)
2. b,a = a,b ===> b,a = (1,2)
3. b = (1,2)[0] a =(1,2)[1]
"""
print(a,b)
#打印变量值
name = 'westos'
age = 11
t = (name,age)
print('name:%s,age:%d' %(name,age))
print('name:%s,age:%d' %t)
#元组的赋值：有多少个元素，就用多少个变量接收
t = ('Westos',10,100)
name,age,score = t
print(name,age,score)
2 1
name:westos,age:11
name:westos,age:11
Westos 10 100
#比赛计分器
scores = (100,89,98,60,90,67)
#scores.sort()
scores = sorted(scores)
#python2中*middle不能使用的
min_score,*middle,max_score = scores
print('平均成绩为：%s' %(sum(middle)/3))
print(min_score,*middle,max_score)
平均成绩为：114.66666666666667
60 67 89 90 98 100
6.is和==的区别
id:在内存中存储的位置
type：变量的类型
value:变量的值
== :type,value
is:type,value,id
结论：
is 表示两个变量的值是否在同一块内存空间
== 表示的是值是否相等
总结: is 返回的值是True ==返回的一定是true
In [1]: a = '1'
In [2]: b = 1
In [3]: a == b
Out[3]: False
In [4]: a = '1'
In [5]: b = a
In [6]: a is b
Out[6]: True
In [7]: li = [1,2,3]
In [8]: li1 = li
In [9]: li == li1
Out[9]: True
In [10]: li2 = li.copy()
In [11]: id(li)
Out[11]: 140233732343752
In [12]: id(li1)
Out[12]: 140233732343752
In [15]: id(li2)
Out[15]: 140233732186888
In [16]: id(li1)
Out[16]: 140233732343752
In [17]: id(li)
Out[17]: 140233732343752
In [18]: li2
Out[18]: [1, 2, 3]
In [19]: li
Out[19]: [1, 2, 3]
In [20]: li1
Out[20]: [1, 2, 3]
In [21]: li == li1
Out[21]: True
In [22]: li == li2
Out[22]: True
In [23]: li1 == li2
Out[23]: True
In [24]: li2 is li
Out[24]: False
In [25]: li2 is li1
Out[25]: False
In [26]: li1 is li
Out[26]: True
7.深拷贝和浅拷贝
当一个变量=xxx的时候,约定为: 指向地址的过程
浅拷贝:copy.copy()
深拷贝:copy.deepcopy()
In [38]: import copy
In [39]: a = [11,22]
In [40]: b = [33,44]
In [41]: c = [a,b]
In [42]: c
Out[42]: [[11, 22], [33, 44]]
In [43]: d = copy.copy(c)
In [44]: id(c)
Out[44]: 140233732341960
In [45]: id(d)
Out[45]: 140233713050888
In [46]: id(c[0])
Out[46]: 140233732292488
In [47]: id(d[0])
Out[47]: 140233732292488
In [48]: id(a)
Out[48]: 140233732292488
In [49]: e = copy.deepcopy(c)
In [50]: id(e)
Out[50]: 140233732321800
In [51]: id(c)
Out[51]: 140233732341960
In [52]: id(c[1])
Out[52]: 140233731307720
In [53]: id(e[1])
Out[53]: 140233713173832
In [54]: id(d[1])
Out[54]: 140233731307720
"""
"""
In [55]: a = [11,22]
In [56]: b = [33,44]
In [57]: c = [a,b]
In [58]: d = copy.copy(c)
In [59]: e = copy.deepcopy(c)
In [60]: id(c)
Out[60]: 140233732324104
In [61]: id(d)
Out[61]: 140233740633608
In [62]: id(e)
Out[62]: 140233732090888
In [63]: c.append([55,66])
In [64]: c
Out[64]: [[11, 22], [33, 44], [55, 66]]
In [65]: d
Out[65]: [[11, 22], [33, 44]]
In [66]: e
Out[66]: [[11, 22], [33, 44]]
如果copy.copy()拷贝的是元组,那么它不会进行浅拷贝,仅仅是指向
因为元组是不可变数据类型,那么意味着数据一定不能修改,因此用copy.copy的
时候它会自动判断,是指向
如果,用copy.copy() copy.deepcopy()对一个全部是不可变类型的数据进行
数据拷贝,那么它们的结果相同,都是引用
如果拷贝的是一个拥有可变类型的数据,那么deepcopy依然是深拷贝,而copy.copy
还是指向
In [73]: a = [11,22]
In [74]: b = [33,44]
In [75]: c = (a,b)
In [76]: c
Out[76]: ([11, 22], [33, 44])
In [77]: d = copy.copy(c)
In [78]: id(c)
Out[78]: 140233732322440
In [79]: id(d)
Out[79]: 140233732322440
In [80]: e = copy.deepcopy(c)
In [81]: id(e)
Out[81]: 140233713145672
In [82]: id(c)
Out[82]: 140233732322440
In [83]: id(c[1])
Out[83]: 140233713122504
In [84]: id(e[1])
Out[84]: 140233731173640
In [85]: id(d[1])
Out[85]: 140233713122504
In [86]: a.append(55)
In [87]: c
Out[87]: ([11, 22, 55], [33, 44])
In [88]: e
Out[88]: ([11, 22], [33, 44])
8.集和
1.集和的定义
# 集和里面的元素是不可重复的
s = {1,2,3,4,5,6,6,3,3,2}
print(s,type(s))
s1 = {1}
print(s1,type(s1))
# 如何定义一个空集和
s2 = {} #默认情况是dict,称为字典
print(s2,type(s2))
# 定义一个空集和
s3 = set([])
print(s3,type(s3))
# 集和应用1:列表去重
li = [1,2,3,4,1,2,3]
print(list(set(li)))
{1, 2, 3, 4, 5, 6} <class 'set'>
{1} <class 'set'>
{} <class 'dict'>
set() <class 'set'>
[1, 2, 3, 4]
2.集和的特性
s = {1,2,3}
print(1 in {1,2,3})
print(1 not in s)
#for循环
for i in s:
print(i,end=' ')
print()
print('~~~~~~')
#for + index
for i,v in enumerate(s):
print('index:%s,value:%s' %(i,v))
True
False
1 2 3
~~~~~~
index:0,value:1
index:1,value:2
index:2,value:3
3.集和的常用方法
# 可变数据类型
# 添加顺序,和在集合中存储的顺序不同
s = {6,7,3,1,2,3}
# 增加
s.add(8)
s.add(4)
print(s)
# 增加多个元素
s.update({9,10,11})
print(s)
# 删除
s.pop()
s.pop()
print(s)
# 删除指定元素(元素要存在)
s.remove(3)
print(s)
s1 = {1,2,3}
s2 = {2,3,4}
# 并集
print('并集:',s1 | s2)
print('并集:',s1.union(s2))
# 交集
print('交集:',s1 & s2)
print('交集:',s1.intersection(s2))
# 差集
# 可以理解为s2中有哪些s1中没有的元素
print('差集:',s2.difference(s1)) # s2 - (s1&s2)
print('差集:',s1 - s2)
# 对等差分:并集 - 交集
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))
并集: {1, 2, 3, 4}
并集: {1, 2, 3, 4}
交集: {2, 3}
交集: {2, 3}
差集: {4}
差集: {1}
对等差分: {1, 4}
对等差分: {1, 4}
True
False
False
4.华为机测题:
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，对于
其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不同的学生的学号，然后再把这些
数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“去重”与排序工作
import random
# 先 生成n个随机数
# 有先选择集和
s = set([])
for i in range(int(input('N:'))):
s.add(random.randint(1,1000))
print(sorted(s))
N:10
[9, 121, 129, 133, 202, 265, 415, 627, 689, 905]
9.字典
1.字典的创建
# 字典:key-value 键值对存储的一种数据结构
# value值可以是任意数据类型:int float long list tuple set dict
d = {
'小明':[18,'男','玩手机'],
'小李':[18,'男','修手机']
}
print(d)
print(d['小李'])
d2 = {
'a':1,
'b':2
}
print(d2)
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'])
# 工厂函数
d5 = dict(a=1,b=2)
print(d5)
{'小明': [18, '男', '玩手机'], '小李': [18, '男', '修手机']}
[18, '男', '修手机']
{'a': 1, 'b': 2}
{'a': {1, 2, 3}, 'b': {2, 3, 4}}
小王
{'a': 1, 'b': 2}
2.字典的特性
d = {
'1':'a',
'8':'b',
'2':'a'
}
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])
a
True
False
1
8
2
1 a
8 b
2 a
3.字典的增加
services = {
'http': 80,
'ftp': 21,
'ssh': 22
}
"""
1.增加一个元素
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值
"""
services['mysql'] = 3306
print(services)
services['http'] = 443
print(services)
"""
2.添加多个key-value值
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值
"""
service_backup = {
'tomcat':8080,
'https':443,
'http':8888
}
services.update(service_backup)
print(services)
services.update(flask=9000,http=999)
print(services)
"""
3.setdefault添加key值:
1).如果key值存在,则不做修改
2).如果key值不存在,则添加对应的key-value值
"""
services.setdefault('http',9000)
print(services)
services.setdefault('oracle',44575)
print(services)
{'http': 80, 'ftp': 21, 'ssh': 22, 'mysql': 3306}
{'http': 443, 'ftp': 21, 'ssh': 22, 'mysql': 3306}
{'http': 8888, 'ftp': 21, 'ssh': 22, 'mysql': 3306, 'tomcat': 8080, 'https': 443}
{'http': 999, 'ftp': 21, 'ssh': 22, 'mysql': 3306, 'tomcat': 8080, 'https': 443, 'flask': 9000}
{'http': 999, 'ftp': 21, 'ssh': 22, 'mysql': 3306, 'tomcat': 8080, 'https': 443, 'flask': 9000}
{'http': 999, 'ftp': 21, 'ssh': 22, 'mysql': 3306, 'tomcat': 8080, 'https': 443, 'flask': 9000, 'oracle': 44575}
4.字典的删除
services = {
'http': 80,
'ftp': 21,
'ssh': 22,
'mysql':3306
}
# 1.del关键字
del services['ftp']
print(services)
"""
2.pop删除指定的key的key-value值
1.)如果key存在,删除,并且返回删除key对应的value值
2.)如果key不存在,直接报错
"""
item = services.pop('http')
print(item)
print(services)
"""
3.popitem删除最后一个key-value
"""
item = services.popitem()
print('删除的key-value对应的是:',item)
print(services)
"""
4.清空字典内容
"""
services.clear()
print(services)
{'http': 80, 'ssh': 22, 'mysql': 3306}
80
{'ssh': 22, 'mysql': 3306}
删除的key-value对应的是: ('mysql', 3306)
{'ssh': 22}
{}
5.字典的修改与查看
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值
# key值不存在,程序会报错
dict_keys(['http', 'mysql'])
dict_values([80, 3306])
http ----> 80
mysql ----> 3306
http ----> 80
mysql ----> 3306
80
None
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
