当前位置： 首页 > news >正文

【Python】Python语言基础（中）

news 2026/2/9 4:05:46

第十章 Python的数据类型

基本数据类型

数字
整数
整数就是整数
浮点数
在编程中，小数都称之为浮点数
浮点数的精度问题
print(0.1 + 0.2)
---------------
0.30000000000000004
​

​1.可以通过round()函数来控制小数点后位数
round(a + b)，则表示结果不保留小数位部分
print(round(0.1 + 0.2))
---------------
0
​
round(a + b, x)，表示将a+b的结果保留x位小数位。
print(round(0.1 + 0.2, 1))
----------------
0.3
​
2.格式化输出
占位符
%d用于整数的占位符
%f用于浮点数的占位符
%s用于表示字符串的占位符
a = 5201314
b = 1314520
print("%d + %d的结果为%d" % (a, b, a+b))
----------------------
5201314 + 1314520的结果为6515834
 

%.2d：表示一共占2位，不足位补0，超过两位就原样输出
%03d：表示一共占3位，不足位补0，超过三位原样输出。
%13d：表示一共占13位，不足为补空格，超过十三位原样输出。
​
a = 0.1
b = 0.2
print("%.1f + %.1f的结果为%.1f" % (a, b, a+b)) # %.1f表示只保留1位小数部分
-------------------------
0.1 + 0.2的结果为0.3
 

布尔型
 

 
0[False,None]
1[True]：所有的非0字符
 

 

进制转换
 

十进制转其它进制
 

 
(1).十进制转二进制
bin()函数
用法：bin(十进制数值)
>>> bin(255)
'0b11111111'
>>> bin(32)
'0b100000'
​
(2).十进制转八进制
oct()函数
用法：oct(十进制数值)
>>> oct(255)
'0o377'
>>> oct(25)
'0o31'
​
(3).十进制转十六进制
hex()函数
用法：hex(十进制数值)
>>> hex(150)
'0x96'
>>> hex(250)
'0xfa'
 

 

其他进制转十进制
 

 
(1).二进制转十进制
int()函数
用法：int("二进制数值", 2)
print(int("1010", 2))
----------------------
10
​
(2).八进制转十进制
int()函数
用法：int("八进制数值", 8)
print(int("15", 8))
--------------------
13
​
(3).十六进制转十进制
int()函数
用法：int("十六进制数值", 16)
print(int("FF", 16))
--------------------
255
 

 

其它进制转其它进制
 

 
二进制--->八进制先将二进制的数值转换成十进制，再将十进制的数值转换成八进制11000011 --- > 八进制

 

 

a = int("11000011", 2)
print(a)
b = oct(a)
print(b)
------------------------
或
print(oct(int("11000011", 2)))
--------------------
0o303
 

数字的随机
 

random模块：可以实现随机的功能
import random
 

random()方法
 

.ranmdom()方法，表示随机生成一个[0,1)的的随机数
a = random.random()
print(a)
------------------------
0.06170779578031482
 

randint()方法
 

用于随机生成一个[x,y]之间的一个整数
import random
b = random.randint(0, 1)
print(b)
----------------------
0/1
 

randrange()方法
 

用于随机生成一个[x,y]范围内且递增基数为z的整数
用法:random.randrange(x, y, z)
import random
b = random.randrange(0, 10, 2)
print(b)
-----------------------------------
4
 

choice()方法
 

表示从某一个字符串中随机挑选出一个字符
用法：random.choice("字符串")
import random
print(random.choice('Python'))
--------------------
P
 

sample()方法
 

从某一个字符串中随机挑选出n个字符，并把它们放入列表中
用法：random.sample('字符串', n)
import random
print(random.sample('Python', 3))
-------------------
['y', 'o', 't']
 

请随机生成一个合法的IPv4地址并输出
import random
ip_address_1 = random.randint(1, 239)
ip_address_2 = random.randint(0, 255)
ip_address_3 = random.randint(0, 255)
ip_address_4 = random.randint(0, 255)
print("%d.%d.%d.%d" % (ip_address_1, ip_address_2, ip_address_3, ip_address_4))
print(ip_address_1, ip_address_2, ip_address_3, ip_address_4, sep='.')
----------------
182.13.178.37
182.13.178.37
 

字符串
 

 
在Python中，字符串必须用"" ''引起
 

 

字符串的定义
 

str1 = 'python'
print(str1)
print(type(str1))
----------------------
123
<class 'str'>
 

字符串的方法
 

(1).将字符串的首字母大写
 

title()方法
 

str1 = 'python'
print(str1)
print(str1.title())
------------------------
python
Python
 

(2).字符串全部字母大写
 

upper()方法
 

str1 = 'python'
print(str1)
print(str1.upper())
------------------------
python
PYTHON
 

(3).将字符串全部内字母全部改成小写
 

lower()
 

str2 = 'NANCY'
print(str2)
print(str2.lower())
----------------------
NANCY
nancy
 

(4).去除字符串的首部空白
 

lstrip()方法
 

str3 = '   nihaohahahaha   '
print(str3)
print(str3.lstrip())
--------------------------------nihaohahahaha   
nihaohahahaha  
 

(5).去除字符串的尾部空白
 

rstrip()
 

str3 = '   nihaohahahaha   '
print(str3)
print(str3.rstrip())
----------------------------------nihaohahahaha   nihaohahahaha
 

(6).去除字符串的所有空白
 

.strip()
 

str3 = '   nihaohahahaha   '
print(str3)
print(str3.strip())
-------------------------------------nihaohahahaha   
nihaohahahaha
 

字符串的拼接
 

字符串之间使用"+"来进行拼接
但必须保证拼接的每一段都是字符串
str1 = 'I'
str2 = 'am'
str3 = '23'
print(str1 + " " +  str2 + " " + str3)
----------------------------------------
I am 23
 

字符串与整数的切换
 

字符串转整数
 

int()函数
 

num1 = '123'
print(num1)
print(type(num1))
num2 = int(num1)
print(num2)
print(type(num2))
--------------------------
123
<class 'str'>
123
<class 'int'>
 

整数转字符串
 

str()函数

 

number1 = 12345
print(number1)
print(type(number1))
number2 = (str(number1))
print(number2)
print(type(number2))
------------------------------
12345
<class 'int'>
12345
<class 'str'>
 

 

组合数据类型
 

 
组合数据类型就是指将多个基本数据类型糅合在一块，组成组合数据类型
组合数据类型：列表、元组、字典、集合
 

 

列表
 

列表的定义
 

[]：空列表

 

list1 = []    # 空列表
list2 = [1, 2, 'Hello']    # 定义一个列表
print(list2)
print(type(list2))
--------------------------------
[1, 2, 'Hello']
<class 'list'>
 

访问列表中的元素值
 

索引
列表的索引都是从0开始，依次递增的
访问列表中的元素值的方法：list1[元素值所在的索引号]
list1 = []    # 空列表
list2 = [1, 2, 'Hello']    # 定义一个列表
print(list2[1])
------------------------------------
2
​
# 如果要快速到取到列表中最后一个索引的元素值，则可以将索引号置为-1
list2 = [1, 2, 3, 252, 253, 254, 210]
print(list2[-1])
-------------------------------
210
​
列表的嵌套：
list1 = [1, 2, ['A', 'B', 'C']]
print(list1[2][2])
-----------------------
C
 

确定列表的长度
 

len()：用于确定列表的长度/ 用于确定列表中有多少个索引

 

list1 = [1, 2, ['A', 'B', 'C']]
print(len(list1))  
-------------------
3
 

列表的常见操作
 

# 列表的操作：增、删、改、查
 

列表的增加
 

所谓列表的增，就是往列表中添加新的索引及其对应的元素值。
(1).append方法：在列表的末尾新增一个元素值
​
 

list2 = [1, 2, 3]
print(list2)
list2.append(4)
print(list2)
list2.append("A")
print(list2)
-------------------------
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 'A']
 

​
(2).insert方法 .insert(索引值, 元素值)可以在指定索引的位置，添加一个元素的值
​
 

list2 = [1, 2, 3]
print(list2)
list2.insert(2, 250)
print(list2)
--------------------------
[1, 2, 3]
[1, 2, 250, 3]
 

​
扩展：
如何使用.insert方法实现.append方法的功能--->(如何使用insert方法总是在列表的末尾插入元素）

 

list2 = [1, 2, 3, 252, 253, 254, 210]
print(list2)
list2.insert(len(list2), 'A')
print(list2)
---------------------
[1, 2, 3, 252, 253, 254, 210]
[1, 2, 3, 252, 253, 254, 210, 'A']
 

列表的删除
 

列表的删，也就意味着将某个元素值从列表中删除。
(1)del语句del list[索引值]

 

list2 = [1, 2, 3]
del list2[2]
print(list2)
del list2[0]
print(list2)
-------------------------------
[2]
 

​如果要使用del语句快速删除列表中的最后一个元素，则可以使用del list[-1]的方式
 

list2 = [1, 2, 3, 210, 2, 3, 4, 5]
print(list2[-1])  # 用于确认是否可以取到最后一个元素值
del list2[-1]   # 删除最后一个元素值
print(list2)
------------------------------
5
[1, 2, 3, 210, 2, 3, 4]
 

​
(2).pop方法list.pop()如果括号内什么都不加，则默认弹出列表中的最后一个元素
 

list2 = [1, 2, 3, 210, 2, 3, 4, 5]
list2.pop()
print(list2)如果括号内加的是某个元素具体的索引号，则弹出这个索引号上的元素
list2 = [1, 2, 3, 210, 2, 3, 4, 5]
list2.pop(0)
print(list2)
---------------------------------
[2, 3, 210, 2, 3, 4, 5]
 

​
(3).remove()方法remove(元素值)

 

list2 = [1, 2, 3, 210, 2, 3, 4, 5]
print(list2)
list2.remove(210)
print(list2)
----------------------------------
[1, 2, 3, 210, 2, 3, 4, 5]
[1, 2, 3, 2, 3, 4, 5]
​
# 如果列表中存在多个值相同的元素时，则默认只会删除索引靠前的元素
list2 = [1, 2, 3, 210, 2, 3, 4, 5]
print(list2)
list2.remove(2)
print(list2)
----------------------------------
[1, 2, 3, 210, 2, 3, 4, 5]
[1, 3, 210, 2, 3, 4, 5]
 

列表的修改
 

# 所谓列表的修改，就是指将列表中的某个元素值进行修改，不会大动干戈的去动整个列表。
# 先使用索引号取到原先索引的位置，然后直接进行赋值修改。
​
list[索引] = 元素值

 

list1 = [1, 2, 3]
print(list1)
list1[2] = 6
print(list1)
---------
[1, 2, 3]
[1, 2, 6]
 

列表的查看
 

列表的查看，也叫遍历列表，就是将列表中的元素一个一个的打印出来。
​
控制结构，循环。
理解一下控制结构：所谓的控制结构，就是指不按照原先的顺序执行代码for 变量 in 集合:循环体代码
​
(1).通过访问列表元素来进行遍历
 

---------------------------------
list1 = ['A', 'B', 'C', 1, 2, 3]
for i in list1:print(i)
print("查询完成！")
--------------------------
A
B
C
1
2
3
查询完成！
 

​
(2).通过索引值进行遍历
range(n)函数：可以生成[0,n-1]的整数
​
 

list1 = ['A', 'B', 'C', 1, 2, 3]
for i in list(range(6)):print(list1[i])
print("大功告成！")
---------------------------
A
B
C
1
2
3
大功告成！
 

​
(3)通过列表长度来遍历列表
 

list1 = ['A', 'B', 'C', 1, 2, 3]
for i in list(range(len(list1))):print(list1[i])
print("大功告成！")
-----------------------
A
B
C
1
2
3
大功告成！
 

​
range()函数的补充： range(x, y) # 生成从x开始，到y-1为止的整数range(x, y, z)# 生成从x开始，到y-1，且递增基数为z的整数
​range()函数的使用示例：生成192.168.1.0/24所有可用的IP地址并输出
​

 

list1 = []
for i in range(1, 255):a = "192.168.1." + str(i) # 字符串拼接或# a = "192.168.1.%d " % i # 格式化输出list1.append(a)
print(list1)
----------------------------
['192.168.1.1', '192.168.1.2', '192.168.1.3', '192.168.1.4', '192.168.1.5', '192.168.1.6', '192.168.1.7', '192.168.1.8', '192.168.1.9', '192.168.1.10', '192.168.1.11', '192.168.1.12', '192.168.1.13', '192.168.1.14', '192.168.1.15', '192.168.1.16', '192.168.1.17', '192.168.1.18', '192.168.1.19', '192.168.1.20', '192.168.1.21', '192.168.1.22', '192.168.1.23', '192.168.1.24', '192.168.1.25', '192.168.1.26', '192.168.1.27', '192.168.1.28', '192.168.1.29', '192.168.1.30', '192.168.1.31', '192.168.1.32', '192.168.1.33', '192.168.1.34', '192.168.1.35', '192.168.1.36', '192.168.1.37', '192.168.1.38', '192.168.1.39', '192.168.1.40', '192.168.1.41', '192.168.1.42', '192.168.1.43', '192.168.1.44', '192.168.1.45', '192.168.1.46', '192.168.1.47', '192.168.1.48', '192.168.1.49', '192.168.1.50', '192.168.1.51', '192.168.1.52', '192.168.1.53', '192.168.1.54', '192.168.1.55', '192.168.1.56', '192.168.1.57', '192.168.1.58', '192.168.1.59', '192.168.1.60', '192.168.1.61', '192.168.1.62', '192.168.1.63', '192.168.1.64', '192.168.1.65', '192.168.1.66', '192.168.1.67', '192.168.1.68', '192.168.1.69', '192.168.1.70', '192.168.1.71', '192.168.1.72', '192.168.1.73', '192.168.1.74', '192.168.1.75', '192.168.1.76', '192.168.1.77', '192.168.1.78', '192.168.1.79', '192.168.1.80', '192.168.1.81', '192.168.1.82', '192.168.1.83', '192.168.1.84', '192.168.1.85', '192.168.1.86', '192.168.1.87', '192.168.1.88', '192.168.1.89', '192.168.1.90', '192.168.1.91', '192.168.1.92', '192.168.1.93', '192.168.1.94', '192.168.1.95', '192.168.1.96', '192.168.1.97', '192.168.1.98', '192.168.1.99', '192.168.1.100', '192.168.1.101', '192.168.1.102', '192.168.1.103', '192.168.1.104', '192.168.1.105', '192.168.1.106', '192.168.1.107', '192.168.1.108', '192.168.1.109', '192.168.1.110', '192.168.1.111', '192.168.1.112', '192.168.1.113', '192.168.1.114', '192.168.1.115', '192.168.1.116', '192.168.1.117', '192.168.1.118', '192.168.1.119', '192.168.1.120', '192.168.1.121', '192.168.1.122', '192.168.1.123', '192.168.1.124', '192.168.1.125', '192.168.1.126', '192.168.1.127', '192.168.1.128', '192.168.1.129', '192.168.1.130', '192.168.1.131', '192.168.1.132', '192.168.1.133', '192.168.1.134', '192.168.1.135', '192.168.1.136', '192.168.1.137', '192.168.1.138', '192.168.1.139', '192.168.1.140', '192.168.1.141', '192.168.1.142', '192.168.1.143', '192.168.1.144', '192.168.1.145', '192.168.1.146', '192.168.1.147', '192.168.1.148', '192.168.1.149', '192.168.1.150', '192.168.1.151', '192.168.1.152', '192.168.1.153', '192.168.1.154', '192.168.1.155', '192.168.1.156', '192.168.1.157', '192.168.1.158', '192.168.1.159', '192.168.1.160', '192.168.1.161', '192.168.1.162', '192.168.1.163', '192.168.1.164', '192.168.1.165', '192.168.1.166', '192.168.1.167', '192.168.1.168', '192.168.1.169', '192.168.1.170', '192.168.1.171', '192.168.1.172', '192.168.1.173', '192.168.1.174', '192.168.1.175', '192.168.1.176', '192.168.1.177', '192.168.1.178', '192.168.1.179', '192.168.1.180', '192.168.1.181', '192.168.1.182', '192.168.1.183', '192.168.1.184', '192.168.1.185', '192.168.1.186', '192.168.1.187', '192.168.1.188', '192.168.1.189', '192.168.1.190', '192.168.1.191', '192.168.1.192', '192.168.1.193', '192.168.1.194', '192.168.1.195', '192.168.1.196', '192.168.1.197', '192.168.1.198', '192.168.1.199', '192.168.1.200', '192.168.1.201', '192.168.1.202', '192.168.1.203', '192.168.1.204', '192.168.1.205', '192.168.1.206', '192.168.1.207', '192.168.1.208', '192.168.1.209', '192.168.1.210', '192.168.1.211', '192.168.1.212', '192.168.1.213', '192.168.1.214', '192.168.1.215', '192.168.1.216', '192.168.1.217', '192.168.1.218', '192.168.1.219', '192.168.1.220', '192.168.1.221', '192.168.1.222', '192.168.1.223', '192.168.1.224', '192.168.1.225', '192.168.1.226', '192.168.1.227', '192.168.1.228', '192.168.1.229', '192.168.1.230', '192.168.1.231', '192.168.1.232', '192.168.1.233', '192.168.1.234', '192.168.1.235', '192.168.1.236', '192.168.1.237', '192.168.1.238', '192.168.1.239', '192.168.1.240', '192.168.1.241', '192.168.1.242', '192.168.1.243', '192.168.1.244', '192.168.1.245', '192.168.1.246', '192.168.1.247', '192.168.1.248', '192.168.1.249', '192.168.1.250', '192.168.1.251', '192.168.1.252', '192.168.1.253', '192.168.1.254']
 

 

列表的排序
 

列表的排序是指将列表中所有元素的值进行比较，按照一定的顺序来进行排列。
升序：从小到大
降序：从大到小
 

1.永久性排序(谨慎使用)
 

.sort()方法

 

升序：
list1 = [1, 10, 3, 5, 2, 6]
print(list1)
list1.sort()
print(list1)
---------------------------
[1, 10, 3, 5, 2, 6]
[1, 2, 3, 5, 6, 10]
​
降序：
list1 = [1, 10, 3, 5, 2, 6]
print(list1)
list1.sort(reverse=True)
print(list1)
[1, 10, 3, 5, 2, 6]
[10, 6, 5, 3, 2, 1]
 

永久性排序结束后，列表就再也回不到之前的形态了。
如果要永久性排序，建议先备份原列表。
 

2.临时性排序
 

sorted()函数

 

升序：
​list1 = [1, 10, 3, 5, 2, 6]
print(list1)
print(sorted(list1))
print(list1)
-----------------------------
[1, 10, 3, 5, 2, 6]
[1, 2, 3, 5, 6, 10]
[1, 10, 3, 5, 2, 6]
​
降序：
list1 = [1, 10, 3, 5, 2, 6]
print(list1)
print(sorted(list1, reverse=True))
print(list1)
---------------------
[1, 10, 3, 5, 2, 6]
[10, 6, 5, 3, 2, 1]
[1, 10, 3, 5, 2, 6]
 

3.反转列表
 

.reverse()方法永久性反转

 

list1 = [1, 10, 3, 5, 2, 6]
print(list1)
list1.reverse()
print(list1)
-----------------------
[1, 10, 3, 5, 2, 6]
[6, 2, 5, 3, 10, 1]
 

列表解析式
 

列表解析式一个固定格式的东西列表中存放的是一个变量的值，这个变量值在后面的循环中依次赋值

 

list1 = [i for i in range(2, 101, 2)] # 后面的for循环为i提供值
print(list1)
----------------------------------
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
 

列表和字符串之间的转换
 

列表转字符串
 

列表转字符串：
str()函数

 

list1 = ['CCIE']
print(list1)
print(type(list1))
str1 = str(list1)
print(str1)
print(type(str1))
-----------------------
['CCIE']
<class 'list'>
['CCIE']
<class 'str'>
​
​
list1 = ['C', 'C', 'I', 'E']
str1 = str(list1)
print(str1)
str2 = list1[0] + list1[1] + list1[2] + list1[3]
print(str2)
--------------------------
['C', 'C', 'I', 'E']
CCIE
 

字符串转列表
 

list()函数

 

str1 = 'Putty'
print(str1)
print(type(str1))
list1 = list(str1)
print(list1)
print(type(list1))
----------------------------
Putty
<class 'str'>
['P', 'u', 't', 't', 'y']
<class 'list'>
 

列表的切片
 

当列表范围过大，需要只取部分值的时候
list[起始索引:结束索引+1]
​

 

list1 = [i for i in range(2, 101, 2)]
print(list1)
list2 = list1[0:5]
print(list2)
list3 = list1[5:10]
print(list3)
-----------------------------------
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
[2, 4, 6, 8, 10]
[12, 14, 16, 18, 20]
 

字符串的切片
 

方法一：先将字符串转为列表，进行列表的切片，切完之后再转回字符串
 

str1 = 'HappyNationalDay'
list1 = list(str1)
print(list(str1))
print(list1)
list2 = list1[0:5]
print(list2)
str2 = list1[0] + list1[1] + list1[2] + list1[3] + list1[4]
print(str2)
print(type(str2))
-----------------------------
['H', 'a', 'p', 'p', 'y', 'N', 'a', 't', 'i', 'o', 'n', 'a', 'l', 'D', 'a', 'y']
['H', 'a', 'p', 'p', 'y', 'N', 'a', 't', 'i', 'o', 'n', 'a', 'l', 'D', 'a', 'y']
['H', 'a', 'p', 'p', 'y']
Happy
<class 'str'>
 

​
​
字符串的方法： .join()方法将列表内的字符一一拼接
 

str1 = 'HappyNationalDay'
list1 = list(str1)  # 将字符串转为列表
list2 = list1[0:5]  # 进行列表的切片 [起始索引:结束索引+1]
str2 = ""   # 定义一个新的空字符串
str2 = str2.join(list2)  # 使用join()方法将list2中的所有元素作为字符串， 填入str2中
print(str2)
----------------------------------
Happy
 

​
方法二：
直接对字符串进行切片，方法和列表类似，[起始索引:结束索引+1]
 

str1 = 'HappyNationalDay'
str2 = str1[0:5]
print(str2)
-----------------------------------
Happy
 

​
方法三：
split()方法，可以在指定的字符处切片

 

str1 = '192.168.11.128'
str2 = str1.split('.')
print(str2)
-----------------------------
['192', '168', '11', '128']
​
​
str1 = '192.168.11.128'
str2 = str1.split('.', maxsplit=1)  # maxsplit用于控制切的次数
print(str2)
-------------------------------------
['192', '168.11.128']
 

可变数据类型与不可变数据类型
 

可变数据类型：列表，字典
不可变数据类型：元组。
描述性地址相同的是可变数据类型，描述性地址不相同的是不可变数据类型。

 

# id()函数 用于查看存放在内存中的地址
a = [1, 2, 3]
print(id(a))    # 查看a这个列表存储在内存中的地址
-----------------
2439173331328    # 描述性地址
 

元组
 

元组的定义
 

元组的定义：()

 

tuple1 = ()    # 空元组
tuple2 = (1, 2, 3)
print(tuple2)
print(type(tuple2))
(1, 2, 3)
<class 'tuple'>
 

元组元素值的修改
 

元组不能直接修改元素值，但是列表可以
所以，可以先把元组转成列表修改，修改完再转回元组。列表转元组:tuple(list)元组转列表:list(tuple)

 

第一步，将元组转为列表
tuple2 = (1, 2, 3)
list2 = list(tuple2)
print(list2)
print(type(list2))
​
第二步，在列表中进行元素值的修改
list2[2] = 300
print(list2)
​
第三步，将修改好元素的列表转回为元组，输出元组
tuple2 = tuple(list2)
print(tuple2)
print(type(tuple2))
---------------------------------------
[1, 2, 3]
<class 'list'>
[1, 2, 300]
(1, 2, 300)
<class 'tuple'>
 

修改嵌套在元组里面的列表元素值
 

tuple8 = (1, 2, [1, 2, 3])
print(tuple8)
tuple8[2][2] = 300
print(tuple8)
----------------------
(1, 2, [1, 2, 3])
(1, 2, [1, 2, 300])
 

字典
 

字典是组合数据类型中的可变数据类型
字典的组成：键值对一个键对应一个值一个键可以有多个值。
 

字典的定义
 

{}

 

dict1 = {}  # 空字典
dict2 = {"R1": "192.168.1.1", "Mask": "/24"}
print(dict2)
-----------------------------------
{'R1': '192.168.1.1', 'Mask': '/24'}
 

字典规范化写法
 

dict1 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.123.1.1","Lo0 Mask": "255.255.255.0"
}
 

字典的操作
 

访问字典中的值
 

通过键来访问值

 

dict2 = {"R1": "192.168.1.1", "Mask": "/24"}
print(dict2["Mask"])
------------------------------------
/24
 

向字典中添加键值对
 

dict2 = {"R1": "192.168.1.1", "Mask": "/24"}
dict2["Description"] = "This is R1"  # dict2["键"] = "值"
print(dict2)
-----------------------------
{'R1': '192.168.1.1', 'Mask': '/24', 'Description': 'This is R1'}
 

删除键值对
 

del语句

 

dict1 = {}  # 空字典
dict2 = {"R1": "192.168.1.1", "Mask": "/24"}
del dict2["R1"]
print(dict2)
-------------------------
{'Mask': '/24'}
 

修改键值对
 

通过访问键，重新赋值。

 

dict2 = {"R1": "192.168.1.1", "Mask": "/24"}
dict2["R1"] = "10.1.1.1"
print(dict2)
--------------------------
{'R1': '10.1.1.1', 'Mask': '/24'}
 

遍历字典
 

(1)遍历所有的键值对
.items()：可以遍历字典中的所有键值对
 

for key, value in dict1.items():print("这是键:" + key)print("这是键:" + value)
----------------------------------
这是键:device
这是键:Cisco IOS-L3 Switch
这是键:Description
这是键:This is a Core-Switch
这是键:Lo0 IP Address
这是键:10.123.1.1
这是键:Lo0 Mask
这是键:255.255.255.0
 

​
​
(2).遍历所有的键
 

for key in dict1.keys():print(key)
---------------------------
device
Description
Lo0 IP Address
Lo0 Mask
 

​
(3).遍历所有的值

 

for value in dict1.values():print(value)
-----------------------------------
Cisco IOS-L3 Switch
This is a Core-Switch
10.123.1.1
255.255.255.0
 

字典的方法操作
 

1.清空所有键值对
 

.clear()方法：

 

dict1 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.123.1.1","Lo0 Mask": "255.255.255.0"
}
print(dict1)
dict1.clear()
print(dict1)
------------------------
{'device': 'Cisco IOS-L3 Switch', 'Description': 'This is a Core-Switch', 'Lo0 IP Address': '10.123.1.1', 'Lo0 Mask': '255.255.255.0'}
{}
 

2.根据key获取value
 

.get()方法，相当于是[]的增强版。如果get后面跟的键，在字典中存在且有对应值，则直接返回指。如果get后面跟的键，在字典不存在，则返回None而非报错

 

dict1 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.123.1.1","Lo0 Mask": "255.255.255.0"
}
device_id = dict1.get("device")
print(device_id)
------------------------
Cisco IOS-L3 Switch
 

3.更新现有字典中key的value
 

.update()方法使用新字典中的值替换旧字典中的值

 

dict1 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.123.1.1","Lo0 Mask": "255.255.255.0"
}
dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
dict1.update(dict2)    # 用dict2来更新dict1
print(dict1)
------------------------------- 
{'device': 'Cisco IOS-L3 Switch', 'Description': 'This is a Core-Switch', 'Lo0 IP Address': '10.1.1.1', 'Lo0 Mask': '255.255.255.0'}
 

4.以列表形式返回可遍历的(键，值)元组
 

.items()方法

 

dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
key_value = dict2.items()
print(key_value)
----------------------------------
dict_items([('device', 'Cisco IOS-L3 Switch'), ('Description', 'This is a Core-Switch'), ('Lo0 IP Address', '10.1.1.1'), ('Lo0 Mask', '255.255.255.0')])
 

5.将一个字典所有的键生成列表并返回
 

.keys()方法
​

 

dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
key = dict2.keys()
print(key)
-----------------------------------------
dict_keys(['device', 'Description', 'Lo0 IP Address', 'Lo0 Mask'])
​
 

6.以列表返回字典中的所有值
 

.values()方法

 

dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
values = dict2.values()
print(values)
---------------------------------
dict_values(['Cisco IOS-L3 Switch', 'This is a Core-Switch', '10.1.1.1', '255.255.255.0'])
 

7.获取指定key的value，并删除这个key的value
 

.pop()方法    #弹出根据key弹出value

 

dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
pop_key = dict2.pop("Description")
print(dict2)
print(pop_key)
--------------------
{'device': 'Cisco IOS-L3 Switch', 'Lo0 IP Address': '10.1.1.1', 'Lo0 Mask': '255.255.255.0'}
This is a Core-Switch
 

8.键值对一起弹出，弹出后变为元组
 

.popitems()

 

dict2 = {"device": "Cisco IOS-L3 Switch","Description": "This is a Core-Switch","Lo0 IP Address": "10.1.1.1","Lo0 Mask": "255.255.255.0"
}
print(dict2)
dict2.popitem()
print(dict2)
--------------------
{'device': 'Cisco IOS-L3 Switch', 'Description': 'This is a Core-Switch', 'Lo0 IP Address': '10.1.1.1', 'Lo0 Mask': '255.255.255.0'}
{'device': 'Cisco IOS-L3 Switch', 'Description': 'This is a Core-Switch', 'Lo0 IP Address': '10.1.1.1'}
 

字典的演练
 

请按照以下要求生成一个字典：字典中的键为R1、R2、R3、R4等共计50个(R1....R50)每个键对应的值为一个随机生成的IP地址。
​

 

import random
dict1 = {}
for i in range(1, 51):ip_add_1 = random.randint(0, 239)ip_add_2 = random.randint(0, 256)ip_add_3 = random.randint(0, 256)ip_add_4 = random.randint(0, 256)ip_add = "%d.%d.%d.%d" % (ip_add_1, ip_add_2, ip_add_3, ip_add_4)key = "R" + str(i)  或  key = "R%s" % idict1[key] = ip_add
print(dict1)
--------------------- 
{'R1': '118.35.62.190', 'R2': '168.3.24.235', 'R3': '116.248.67.84', 'R4': '63.98.30.57', 'R5': '184.117.11.151', 'R6': '231.13.14.229', 'R7': '204.146.102.2', 'R8': '30.67.193.142', 'R9': '103.147.193.241', 'R10': '152.35.111.245', 'R11': '102.116.239.167', 'R12': '121.175.89.60', 'R13': '152.212.41.252', 'R14': '120.12.47.64', 'R15': '103.19.58.104', 'R16': '175.227.69.134', 'R17': '44.250.4.191', 'R18': '61.109.194.212', 'R19': '185.6.183.147', 'R20': '38.239.59.52', 'R21': '31.247.205.187', 'R22': '97.53.203.194', 'R23': '94.175.165.69', 'R24': '209.45.42.86', 'R25': '13.190.147.99', 'R26': '93.124.123.116', 'R27': '239.126.116.77', 'R28': '97.160.18.72', 'R29': '56.67.163.47', 'R30': '45.199.174.11', 'R31': '178.175.249.103', 'R32': '122.164.248.197', 'R33': '147.133.82.37', 'R34': '1.69.201.174', 'R35': '100.244.111.91', 'R36': '78.238.42.109', 'R37': '91.4.236.82', 'R38': '215.220.221.123', 'R39': '120.78.63.190', 'R40': '77.20.18.128', 'R41': '86.242.90.88', 'R42': '178.199.167.228', 'R43': '106.86.256.176', 'R44': '164.100.39.62', 'R45': '171.35.153.11', 'R46': '138.85.61.59', 'R47': '131.13.91.225', 'R48': '44.60.75.88', 'R49': '59.135.155.208', 'R50': '125.55.13.223'}
 















相关文章：
















【Python】Python语言基础（中）




第十章 Python的数据类型 
基本数据类型 
数字 
整数 
整数就是整数 
浮点数 
在编程中&#xff0c;小数都称之为浮点数 
浮点数的精度问题 
print(0.1  0.2)
---------------
0.30000000000000004
​​1.可以通过round()函数来控制小数点后位数
round(a  b)&#xff0c;则表示…...






编程日记
2023/10/15 0:51:04



















观察者模式、订阅者发布者模式、vtk中的观察者模式




文章目录 什么是观察者模式vtk是如何实现的观察者模式.AddObserver什么时候使用观察者模式&#xff1f;什么使用订阅发布者模式?观察者模式的实现订阅发布者的实现总结知识补充: 什么是观察者模式 
用于在对象之间建立一对多的依赖关系&#xff0c;当一个对象的状态发生变化时…...






编程日记
2023/10/15 0:50:03



















关于element-ui中，页面上有多个el-table并通过v-if、v-else等控制是否显示时，type=selection勾选框失效或不显示的问题




刚开始是勾选框那一列直接空了什么都不显示&#xff0c;搜索了一下说是给el-table标签增加id&#xff0c;加了之后是显示了&#xff0c;但是点击任何选框都会直接取消全部选中效果&#xff0c;翻了半天源码也没发现到底是哪里事件冲突了还是怎么回事&#xff0c;烦了&#xff0…...






编程日记
2023/10/15 0:48:59



















Stewart六自由度正解、逆解计算-C#和Matlab程序




目录 
一、Stewart并联六自由度正解计算    
&#xff08;一&#xff09;概况      
&#xff08;二&#xff09;Matlab正解计算 
1、参考程序一 
2、参考程序二 
&#xff08;三&#xff09;C#程序正解计算 
1、工程下载链接 
2、正解运行计算 
&#xff08;四&#xff09;正程…...






编程日记
2023/10/15 0:47:58



















C语言 驼峰命名法和下划线命名法




在C语言中&#xff0c;变量命名遵循以下规则&#xff1a; 
变量名只能由字母、数字和下划线组成。变量名必须以字母或下划线开头。变量名不能使用C语言中的关键字。变量名中不能出现连续的两个下划线。变量名区分大小写&#xff0c;例如&#xff0c;count和Count被视为两个不同…...






编程日记
2023/10/15 0:46:57



















大数据学习(8)-hive压缩




&&大数据学习&& 
&#x1f525;系列专栏&#xff1a; &#x1f451;哲学语录: 承认自己的无知&#xff0c;乃是开启智慧的大门 &#x1f496;如果觉得博主的文章还不错的话&#xff0c;请点赞&#x1f44d;收藏⭐️留言&#x1f4dd;支持一下博>主哦&#x…...






编程日记
2023/10/15 0:44:55



















[sqoop]hive导入mysql,其中mysql的列存在默认值列




一、思路 
直接在hive表中去掉有默认值的了列&#xff0c;在sqoop导入时,指定非默认值列即可&#xff0c; 
二、具体 
mysql的表 hive的表  
create table dwd.dwd_hk_rcp_literature(id string,literature_no string,authors string,article_title string,source_title string…...






编程日记
2023/10/15 0:43:51



















Stream流中的常用方法（forEach，filter，map，count，limit，skip，concat）和Stream流的特点




1、forEach方法 该方法接收一个Consumer接口是一个 消费型 的函数式接口&#xff0c;可以传递Lambda表达式&#xff0c;消费数据用来遍历流中的数据&#xff0c;是一个 终结 方法&#xff0c;遍历 之后就不能继续调用Stream流中的其他方法 package com.csdn.stream;
import jav…...






编程日记
2023/10/15 0:42:50



















2023大联盟2比赛总结




比赛链接 
反思 
T1 
奇怪的贪心和构造题一直是我的软肋部分 
T2 
简单题 
T3 
也不难 
T4 
套路没学过&#xff0c;感觉还是太菜了 
题解 
A 
考虑先给图随便染色&#xff0c;然后调整 因为每个点的度数为  3 3 3&#xff0c;所以如果有  x → u → v x\to u\to v x→u→v 的颜…...






编程日记
2023/10/15 0:41:49



















Flutter笔记：电商中文货币显示插件Money Display




Flutter笔记  电商中文货币显示插件 Money Display 作者&#xff1a;李俊才 &#xff08;jcLee95&#xff09;&#xff1a;https://blog.csdn.net/qq_28550263 邮箱 &#xff1a;291148484163.com 本文地址&#xff1a;https://blog.csdn.net/qq_28550263/article/details/1338…...






编程日记
2023/10/15 0:40:47



















腾讯云上创建 对象存储cos




1. 登录腾讯云, 找到对象存储cos 2. 创建存储桶 3. 获取4个配置参数 桶名称 / 地域secretId / secretKey...






编程日记
2023/10/15 0:39:46



















微信小程序生成海报




效果： js1: 
const cloudHelper = require(../../../helper/cloud_helper.js);async function config1({cover,title,desc,qr,bg = 
}) {var qr1 ="images/qr.png"var qr2 ="https://636c-cloud1-0gu29f2j63906b7e-1319556650.tcb.qcloud.la/activitycomm/setu…...






编程日记
2023/10/15 0:37:42



















stm32学习笔记：EXIT中断




1、中断系统 
中断系统是管理和执行中断的逻辑结构&#xff0c;外部中断是众多能产生中断的外设之一。 
1.中断&#xff1a; 
在主程序运行过程中&#xff0c;出现了特定的中断触发条件 (中断源&#xff0c;如对于外部中断来说可以是引脚发生了电平跳变&#xff0c;对于定时器来…...






编程日记
2023/10/15 0:36:42



















css 块元素、行内元素、行内块元素相互转换




在HTML和CSS中&#xff0c;元素可以分为三类&#xff1a;块级元素&#xff08;Block-level Elements&#xff09;、内联元素&#xff08;Inline Elements&#xff09;和内联块级元素&#xff08;Inline-block Elements&#xff09;。 块级元素&#xff08;Block-level Elements…...






编程日记
2023/10/15 0:35:39



















【JUC】多线程基础概述




文章目录 1. 一锁二并三程2. 用户线程和守护线程 1. 一锁二并三程 
一锁&#xff1a;synchronized 
二并: 
并发&#xff1a;一台处理器“同时”处理多个任务&#xff0c;同一时刻只有一个事件发生并行&#xff1a;多台处理器同时处理多个任务&#xff0c;同一时刻多个处理器分…...






编程日记
2023/10/15 0:34:37



















Git 回退代码的两种方法对比




Git 回退代码版本 
在项目的开发中&#xff0c;有时候还是会出现&#xff0c;一些误提交了一些代码&#xff0c;这时候就会想撤回提交的代码&#xff0c;在Git中有两种方法可以使用&#xff0c;现在通过对比方法比较这两种方法的区别&#xff0c;分别适用于哪些情况&#xff1f…...






编程日记
2023/10/15 0:33:36



















Avalonia常用小控件Charts




1.项目下载地址&#xff1a;https://gitee.com/confusedkitten/avalonia-demo 
2.UI库Semi.Avalonia&#xff0c;项目地址  https://github.com/irihitech/Semi.Avalonia 
3.Charts库&#xff0c;LiveChartsCore.SkiaSharpView.Avalonia&#xff0c;Nuget获取只有预览库&#x…...






编程日记
2023/10/15 0:32:35



















【Hugging Face】管理 huggingface_hub 缓存系统




摘要 
这篇文档介绍了Hugging Face Hub的缓存系统。该系统旨在提供一个中央缓存，以便不同版本的文件可以被下载和缓存。缓存系统将文件组织成模型、数据集和空间等不同的目录，每个目录包含特定类型的文件。系统确保如果文件已经下载并更新，除非明确要求，否则不会再次下载。…...






编程日记
2023/10/15 0:31:34



















Python学习基础笔记六十六——对象的方法




我们已经学习到的对象类型&#xff1a; 
整数类型的对象 
字符串类型的对象 
列表类型的对象 
元组类型的对象 对象通常都有属于自己的方法&#xff08;method&#xff09; 
调用对象的方法和调用函数差不多&#xff0c;只要在前面加上所属对象的一个点。 var1  [1, 2, 3,4, 5,…...






编程日记
2023/10/15 0:30:32



















建立一个新的高阶数学教授模式，知其然，知其用，知其之所以然，知其所以然




1. 传统常用的模式 概念&#xff0c;性质&#xff0c;定理&#xff0c;定理证明&#xff0c;定理应用&#xff1b; 
这个学习模式挺好的&#xff0c;但是定理证明过程往往很冗长&#xff0c;而且不易记忆&#xff0c;也就是说&#xff0c;即使推导了定理&#xff0c;初学者也记…...






编程日记
2023/10/15 0:29:30





















观成科技：隐蔽隧道工具Ligolo-ng加密流量分析




1.工具介绍 
Ligolo-ng是一款由go编写的高效隧道工具&#xff0c;该工具基于TUN接口实现其功能&#xff0c;利用反向TCP/TLS连接建立一条隐蔽的通信信道&#xff0c;支持使用Let’s Encrypt自动生成证书。Ligolo-ng的通信隐蔽性体现在其支持多种连接方式&#xff0c;适应复杂网…...






编程新知
2026/2/8 4:37:24



















深度学习在微纳光子学中的应用




深度学习在微纳光子学中的主要应用方向 
深度学习与微纳光子学的结合主要集中在以下几个方向&#xff1a; 
逆向设计 通过神经网络快速预测微纳结构的光学响应&#xff0c;替代传统耗时的数值模拟方法。例如设计超表面、光子晶体等结构。 
特征提取与优化 从复杂的光学数据中自…...






编程新知
2026/2/8 15:03:04



















可靠性+灵活性：电力载波技术在楼宇自控中的核心价值




可靠性灵活性&#xff1a;电力载波技术在楼宇自控中的核心价值 
在智能楼宇的自动化控制中&#xff0c;电力载波技术&#xff08;PLC&#xff09;凭借其独特的优势&#xff0c;正成为构建高效、稳定、灵活系统的核心解决方案。它利用现有电力线路传输数据&#xff0c;无需额外布…...






编程新知
2025/9/27 2:43:26



















Golang dig框架与GraphQL的完美结合




将 Go 的 Dig 依赖注入框架与 GraphQL 结合使用&#xff0c;可以显著提升应用程序的可维护性、可测试性以及灵活性。 
Dig 是一个强大的依赖注入容器&#xff0c;能够帮助开发者更好地管理复杂的依赖关系&#xff0c;而 GraphQL 则是一种用于 API 的查询语言&#xff0c;能够提…...






编程新知
2025/12/31 8:38:23



















（二）原型模式




原型的功能是将一个已经存在的对象作为源目标，其余对象都是通过这个源目标创建。发挥复制的作用就是原型模式的核心思想。 
一、源型模式的定义 原型模式是指第二次创建对象可以通过复制已经存在的原型对象来实现，忽略对象创建过程中的其它细节。 
📌 核心特点： 避免重复初…...






编程新知
2026/2/7 10:59:04



















A2A JS SDK 完整教程：快速入门指南




目录 
什么是 A2A JS SDK?A2A JS 安装与设置A2A JS 核心概念创建你的第一个 A2A JS 代理A2A JS 服务端开发A2A JS 客户端使用A2A JS 高级特性A2A JS 最佳实践A2A JS 故障排除 
什么是 A2A JS SDK? 
A2A JS SDK 是一个专为 JavaScript/TypeScript 开发者设计的强大库&#xff…...






编程新知
2025/12/12 8:42:24



















【从零学习JVM|第三篇】类的生命周期(高频面试题)




前言&#xff1a; 
在Java编程中&#xff0c;类的生命周期是指类从被加载到内存中开始&#xff0c;到被卸载出内存为止的整个过程。了解类的生命周期对于理解Java程序的运行机制以及性能优化非常重要。本文会深入探寻类的生命周期&#xff0c;让读者对此有深刻印象。 
目录 
​…...






编程新知
2026/1/26 8:42:13



















深度剖析 DeepSeek 开源模型部署与应用：策略、权衡与未来走向




在人工智能技术呈指数级发展的当下&#xff0c;大模型已然成为推动各行业变革的核心驱动力。DeepSeek 开源模型以其卓越的性能和灵活的开源特性&#xff0c;吸引了众多企业与开发者的目光。如何高效且合理地部署与运用 DeepSeek 模型&#xff0c;成为释放其巨大潜力的关键所在&…...






编程新知
2025/12/27 19:12:07



















[USACO23FEB] Bakery S




题目描述 
Bessie 开了一家面包店! 
在她的面包店里&#xff0c;Bessie 有一个烤箱&#xff0c;可以在  t C t_C tC​ 的时间内生产一块饼干或在  t M t_M tM​ 单位时间内生产一块松糕。  ( 1 ≤ t C , t M ≤ 10 9 ) (1 \le t_C,t_M \le 10^9) (1≤tC​,tM​≤109)。由于空间…...






编程新知
2026/1/10 19:08:23



















C# winform教程(二)----checkbox




一、作用 
提供一个用户选择或者不选的状态&#xff0c;这是一个可以多选的控件。 
二、属性 
其实功能大差不差&#xff0c;除了特殊的几个外&#xff0c;与button基本相同&#xff0c;所有说几个独有的 checkbox属性 名称内容含义appearance控件外观可以变成按钮形状checkali…...






编程新知
2026/1/26 17:05:57