devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用 Python 获取 Linux 系统信息_platform python3 linux

作者：小桥流水78 | 2024-08-01 12:13:01

赞

踩

platform python3 linux

在本文中，我们将会探索使用Python编程语言工具来检索Linux系统各种信息。走你。

　哪个Python版本?

　　当我提及Python，所指的就是CPython 2(准确的是2.7).我会显式提醒那些相同的代码在CPython 3 (3.3)上是不工作的，以及提供一份解释不同之处的备选代码。请确保你已经安装了CPython,在终端上输入python或者python3回车，然后你在终端上应该能看到python的提示符(prompt)。

　　请注意，所有的程序在它们第一行都是#!/usr/bin/env/python，也就是说，我们想要Python的解释器来执行这些脚本。因此，如果你想你的脚本具有执行性，请使用chmod +x your-script.py， 那么你就可以使用./your-script.py来执行它了（在本文中你将会看到这种方式）

　探索platform模块

　　platform模块在标准库中，它有很多运行我们获得众多系统信息的函数。让我们运行Python解释器来探索它们中的一些函数，那就从platform.uname()函数开始吧：

1
2
3
>>> import platform
>>> platform.uname()
( 'Linux' , 'fedora.echorand' , '3.7.4-204.fc18.x86_64' , '#1 SMP Wed Jan 23 16:44:29 UTC 2013' , 'x86_64' )

　　如果你已知道linux上的uname命令，那么你就会认出来这个函数就是这个命令的一个接口。在Python 2上，它会返回一个包含系统类型(或者内核版本)，主机名，版本，发布版本，机器的硬件以及处理器信息元组(tuple)。你可以使用下标访问个别属性，像这样：

1
2
>>> platform.uname()[ 0 ]
'Linux'

　　在Python 3上，这个函数返回的是一个命名元组：

1
2
3
4
5
>>> platform.uname()
 
uname_result(system = 'Linux' , node = 'fedora.echorand' ,
release = '3.7.4-204.fc18.x86_64' , version = ' #1 SMP Wed Jan 23 16:44:29
UTC 2013 ', machine=' x86_64 ', processor=' x86_64')

　　因为返回结果是一个命名元组，这就可以简单地通过名字来指定特定的属性，而不是必须记住下标，像这样：

1
2
>>> platform.uname().system
'Linux'

　　platform模块还有一些上面属性的直接接口，像这样：

1
2
3
4
5
>>> platform.system()
'Linux'
 
>>> platform.release()
'3.7.4-204.fc18.x86_64'

　　linux_distribution()函数返回的有关你所在的linux发布版本的详细信息。例如，在Fedora 18系统上，这个命令会返回如下信息：

1
2
>>> platform.linux_distribution()
( 'Fedora' , '18' , 'Spherical Cow' )

　　这个返回结果中包含了版本发布名，版本以及代号元组。特定的Python版本支持的发布版本上可以通过_supported_dists显示的值获得。

1
2
3
4
>>> platform._supported_dists
( 'SuSE' , 'debian' , 'fedora' , 'redhat' , 'centos' , 'mandrake' ,
'mandriva' , 'rocks' , 'slackware' , 'yellowdog' , 'gentoo' ,
'UnitedLinux' , 'turbolinux' )

　　如果你的linux发布版本不在其中（或者其中之一的衍生发行版）。那么你很可能调用了上面这个函数而看不到任何有用的信息。

　　platform模块的最后一个函数，我们将会看看architecture()函数。当你无参的调用这个函数，它会返回包含架构位数以及python可执行的格式的元组，像这样：

1
2
>>> platform.architecture()
( '64bit' , 'ELF' )

　　在32位的系统上，你将会看到：

1
2
>>> platform.architecture()
( '32bit' , 'ELF' )

　　如果你指定了系统上其他任何可执行的，你都将会获得相似的结果，如同这样：

1
2
>>> platform.architecture(executable = '/usr/bin/ls' )
( '64bit' , 'ELF' )

　　鼓励探索platform模块的除了这些的其它函数，找出你现在运行的Python版本。如果你想知道这个模块是如何获取这些信息的，你可以深入查看PYthon源码目录下的Lib/platform.py文件。

　　os和sys模块也可以获得一些系统属性，例如原生的字节序。接下来，我们超越Python标准库模块，去探索一些在linux系统通过proc和sysfs文件系统使之访问信息成为可能。注意的是通过文件系统来访问信息将会在不同的硬件架构有所不同。所以在读本文或是写脚本时要时刻记住可以试图从这些文件获取信息。

　CPU信息

　　/proc/cpuinfo文件包含了你的系统处理器单元的信息。例如，这里就是python版的linux命令cat /proc/cpuinfo所做的事：

1
2
3
4
5
6
7
8
9
10
#! /usr/bin/env python
""" print out the /proc/cpuinfo
     file
"""
 
from __future__ import print_function
 
with open ( '/proc/cpuinfo' ) as f:
     for line in f:
         print (line.rstrip( '\n' ))

　　当你使用Python 2 或者 Python 3执行这个程序时，你会在屏幕上看到所有/proc/cpuinfo的内容（在上面的程序里，rstrip()方法用来删除每行末尾的换行符）

　　在下面的代码里列举了使用startwith()字符串方法来显示你的处理器单元的模式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#! /usr/bin/env python
 
""" Print the model of your
     processing units
 
"""
 
from __future__ import print_function
 
with open ( '/proc/cpuinfo' ) as f:
     for line in f:
         # Ignore the blank line separating the information between
         # details about two processing units
         if line.strip():
             if line.rstrip( '\n' ).startswith( 'model name' ):
                 model_name = line.rstrip( '\n' ).split( ':' )[ 1 ]
                 print (model_name)

　　当你运行这个程序后，你应该会看到你的每个处理器单元的模式名。例如，这里就是在我电脑上所看到的。

1
2
3
4
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz

　　迄今为止，我们已有两种方式来找出我们所使用的系统的架构。从技术上讲是正确的，两个方 式实际上报告了你系统运行的内核架构，所以，如果你的电脑是64位的，但是运行的是32位的内核，然后上面的方法还是将会显示为32位的架构。你可以通过从/proc/cpuinfo所列举的标志中查找lm标志，来找到你的电 脑的真实的架构。lm标志代表了长模式，只有64位架构的才会显示它。下面的程序将会指导你怎样做：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#! /usr/bin/env python
 
""" Find the real bit architecture
"""
 
from __future__ import print_function
 
with open ( '/proc/cpuinfo' ) as f:
     for line in f:
         # Ignore the blank line separating the information between
         # details about two processing units
         if line.strip():
             if line.rstrip( '\n' ).startswith( 'flags' ) \
                     or line.rstrip( '\n' ).startswith( 'Features' ):
                 if 'lm' in line.rstrip( '\n' ).split():
                     print ( '64-bit' )
                 else :
                     print ( '32-bit' )

　　如我们所看到那样，读取/proc/cpuinfo文件以及使用简单文本处理技术就可以获得我们要查找的数据是可能的。为了给其他程序更好的使用这些数据，一个更好的主意就是使/proc/cpuinfo的内容成为标准的数据结构，譬如字典(dictionary)。这个注意很简单：如果你查看这个文件的内容，你就会发现对于每个处理器单元，都有好些键值对(在先前的例子中，我们打印了每个处理器的模型名，即模型名就是关键字)。不同的处理器 单元的信息可以使用空白行隔开。构造一个字典数据结构包含每个处理器单元的关键字是很简单的。对于每个关键字，对于处理器单元的值都在/proc/cpuinfo文件中。下面的代码将会指导你怎么做。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/usr/bin/env/ python
 
"""
/proc/cpuinfo as a Python dict
"""
from __future__ import print_function
from collections import OrderedDict
import pprint
 
def cpuinfo():
     ''' Return the information in /proc/cpuinfo
     as a dictionary in the following format:
     cpu_info['proc0']={...}
     cpu_info['proc1']={...}
 
     '''
 
     cpuinfo = OrderedDict()
     procinfo = OrderedDict()
 
     nprocs = 0
     with open ( '/proc/cpuinfo' ) as f:
         for line in f:
             if not line.strip():
                 # end of one processor
                 cpuinfo[ 'proc%s' % nprocs] = procinfo
                 nprocs = nprocs + 1
                 # Reset
                 procinfo = OrderedDict()
             else :
                 if len (line.split( ':' )) = = 2 :
                     procinfo[line.split( ':' )[ 0 ].strip()] = line.split( ':' )[ 1 ].strip()
                 else :
                     procinfo[line.split( ':' )[ 0 ].strip()] = ''
             
     return cpuinfo
 
if __name__ = = '__main__' :
     cpuinfo = cpuinfo()
     for processor in cpuinfo.keys():
         print (cpuinfo[processor][ 'model name' ])

　　这段代码中使用了OrderedDict(有序字典)而不是常规的字典，能够使用键值有序的存储在文件里。所以，第一个处理器单元的数据之后就是第二个处理器单元的数据，以此类推。你可以使用过滤器来过滤你所查找的信息（如同在if __name__ == '__main__'块中演示的那样）。上面的程序每次执行后都会打印每个处理器单元的模型名（如通过cpuinfo[processor]['model name']语句表明的那样）

1
2
3
4
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz
Intel(R) Core(TM) i7 - 3520M CPU @ 2.90GHz

　内存信息

　　和/proc/cpuinfo相似，文件/proc/meminfo包含了你电脑的主存的信息。下面的这个程序创建了一个使用这个文件的内容填充的字典。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
 
from __future__ import print_function
from collections import OrderedDict
 
def meminfo():
     ''' Return the information in /proc/meminfo
     as a dictionary '''
     meminfo = OrderedDict()
 
     with open ( '/proc/meminfo' ) as f:
         for line in f:
             meminfo[line.split( ':' )[ 0 ]] = line.split( ':' )[ 1 ].strip()
     return meminfo
 
if __name__ = = '__main__' :
     #print(meminfo())
     
     meminfo = meminfo()
     print ( 'Total memory: {0}' . format (meminfo[ 'MemTotal' ]))
     print ( 'Free memory: {0}' . format (meminfo[ 'MemFree' ]))

　　像先前的，通过它的关键字，你可以访问任何你查询的指定信息(在if __name__==__main__块中有所表示)。当你执行这个程序，你该会看到像下面类似的输出：

1
2
Total memory: 7897012 kB
Free memory: 249508 kB

　网络统计信息

　　接下来，我们会探索我们电脑系统的网络设备。我们将会获得系统的网络接口，以及当系统重启之后通过它们数据发送和接受数据的信息。 /proc/net/dev文件让这些信息可用。如果你检查了这个文件的内容，你就会注意到头一两行包含了头信息等等，这个文件第一列是网络接口名，第二和第三列显示了接收和发送的字节数信息（例如总发送字节数，包数，错误等等）。这里我们所感兴趣的就是他哦难过不同的网络设备提取出总发送数据和接收数据。下面的代码展示了怎么从/proc/net/dev文件中提取出这些信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python
from __future__ import print_function
from collections import namedtuple
 
def netdevs():
     ''' RX and TX bytes for each of the network devices '''
 
     with open ( '/proc/net/dev' ) as f:
         net_dump = f.readlines()
     
     device_data = {}
     data = namedtuple( 'data' ,[ 'rx' , 'tx' ])
     for line in net_dump[ 2 :]:
         line = line.split( ':' )
         if line[ 0 ].strip() ! = 'lo' :
             device_data[line[ 0 ].strip()] = data( float (line[ 1 ].split()[ 0 ]) / ( 1024.0 * 1024.0 ),
                                                 float (line[ 1 ].split()[ 8 ]) / ( 1024.0 * 1024.0 ))
     
     return device_data
 
if __name__ = = '__main__' :
     
     netdevs = netdevs()
     for dev in netdevs.keys():
         print ( '{0}: {1} MiB {2} MiB' . format (dev, netdevs[dev].rx, netdevs[dev].tx)) 

　　当你运行上面的程序，下面这个输出就会显示从你最近重启之后网络设备总接收和发送的数据，单位为兆。

1
2
em1: 0.0 MiB 0.0 MiB
wlan0: 2651.40951061 MiB 183.173976898 MiB

　　你可以使用持久的数据存储机制来连接，来写出自己的数据使用监控程序。

　进程信息

　　/proc目录包含了所有正运行的进程目录。这些目录的名字和进程的标识符是一样的。所以，如果你遍历/proc目录下那些使用数字作为它们的名字的目录，你就会获得所有现在正在运行的进程列表。在下面的代码中process_list()函数返回所有现在正在运行的进程的标识符列表。当你执行这个程序后，这个列表的长度就是在系统上运行的总进程数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
"""
  List of all process IDs currently active
"""
 
from __future__ import print_function
import os
def process_list():
 
     pids = []
     for subdir in os.listdir( '/proc' ):
         if subdir.isdigit():
             pids.append(subdir)
 
     return pids
 
 
if __name__ = = '__main__' :
 
     pids = process_list()
     print ( 'Total number of running processes:: {0}' . format ( len (pids)))

　　上面的程序当执行后会显示和下面类似的输出：

1
Total number of running processes:: 229

　　每个进程目录包含了一些其他文件和目录，如进程命令的调用，它正使用的共享库以及其它的。

　块设备

　　下一个程序通过读sysfs虚拟文件系统列出所有块设备。你系统中的块设备可以从/sys/block目录中找到。因此可能会有/sys/block/sda、/sys/block/sdb等这样的目录。为了获取所有这些设备，我们使用正则表达式对/sys/block目录进行扫描提取感兴趣的块设备。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/env python
 
"""
Read block device data from sysfs
"""
 
from __future__ import print_function
import glob
import re
import os
 
# Add any other device pattern to read from
dev_pattern = [ 'sd.*' , 'mmcblk*' ]
 
def size(device):
     nr_sectors = open (device + '/size' ).read().rstrip( '\n' )
     sect_size = open (device + '/queue/hw_sector_size' ).read().rstrip( '\n' )
 
     # The sect_size is in bytes, so we convert it to GiB and then send it back
     return ( float (nr_sectors) * float (sect_size)) / ( 1024.0 * 1024.0 * 1024.0 )
 
def detect_devs():
     for device in glob.glob( '/sys/block/*' ):
         for pattern in dev_pattern:
             if re. compile (pattern).match(os.path.basename(device)):
                 print ( 'Device:: {0}, Size:: {1} GiB' . format (device, size(device)))
 
if __name__ = = '__main__' :
     detect_devs()

　　如果你运行该程序，你将会看到下述类似的输出：

1
2
Device:: / sys / block / sda, Size:: 465.761741638 GiB
Device:: / sys / block / mmcblk0, Size:: 3.70703125 GiB

　　当我运行该程序的时候，有个SD内存卡插在电脑上，因此你会看到程序检测到了它。你也可以扩展该程序识别其它块设备（比如虚拟硬盘）。

　建立命令行实用工具

　　linux中命令行使用工具是无所不在的[@Lesus 注：曾有人说过：linux没有了命令行就是个渣。]，它允许人么指定命令行参数来定制程序的默认行为。argparse模块就提供了和linux命令行实用工具类似的接口。下面的代码展示了程序如何获得系统上的所有用户以及打印它们的登录shell(使用了pwd标准库模块)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
 
"""
Print all the users and their login shells
"""
 
from __future__ import print_function
import pwd
 
 
# Get the users from /etc/passwd
def getusers():
     users = pwd.getpwall()
     for user in users:
         print ( '{0}:{1}' . format (user.pw_name, user.pw_shell))
 
if __name__ = = '__main__' :
     getusers()

　　当运行这个程序之后，它会打印系统上所有的用户以及他们登录shell名。

　　现在，你想要程序的用户能够选择是否想看系统用户(像daemon, apache)。我们扩展前面的代码，第一次使用argparse模块来实现这个特性，如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#!/usr/bin/env python
 
"""
Utility to play around with users and passwords on a Linux system
"""
 
from __future__ import print_function
import pwd
import argparse
import os
 
def read_login_defs():
 
     uid_min = None
     uid_max = None
 
     if os.path.exists( '/etc/login.defs' ):
         with open ( '/etc/login.defs' ) as f:
             login_data = f.readlines()
             
         for line in login_data:
             if line.startswith( 'UID_MIN' ):
                 uid_min = int (line.split()[ 1 ].strip())
             
             if line.startswith( 'UID_MAX' ):
                 uid_max = int (line.split()[ 1 ].strip())
 
     return uid_min, uid_max
 
# Get the users from /etc/passwd
def getusers(no_system = False ):
 
     uid_min, uid_max = read_login_defs()
 
     if uid_min is None :
         uid_min = 1000
     if uid_max is None :
         uid_max = 60000
 
     users = pwd.getpwall()
     for user in users:
         if no_system:
             if user.pw_uid > = uid_min and user.pw_uid < = uid_max:
                 print ( '{0}:{1}' . format (user.pw_name, user.pw_shell))
         else :
             print ( '{0}:{1}' . format (user.pw_name, user.pw_shell))
 
if __name__ = = '__main__' :
 
     parser = argparse.ArgumentParser(description = 'User/Password Utility' )
 
     parser.add_argument( '--no-system' , action = 'store_true' ,dest = 'no_system' ,
                         default = False , help = 'Specify to omit system users' )
 
     args = parser.parse_args()
     getusers(args.no_system)

　　使用--help选项执行上面的程序，你会看到友好的帮助信息：可选项以及它们的作用。

1
2
3
4
5
6
7
8
$ . / getusers.py - - help
usage: getusers.py [ - h] [ - - no - system]
 
User / Password Utility
 
optional arguments:
   - h, - - help   show this help message and exit
   - - no - system  Specify to omit system users

　　上面程序使用的一个例子，如下所示：

1
2
$ . / getusers.py - - no - system
gene: / bin / bash

　　当你传入一个非法的参数，这个程序就会发牢骚(报错)

1
2
3
$ . / getusers.py - - param
usage: getusers.py [ - h] [ - - no - system]
getusers.py: error: unrecognized arguments: - - param

　　在上面的程序中，我们简单的理解了如何使用argparse模块。parser = argparse.ArgumentParser(description="User/Password Utility")语句创建了一个带说明程序是做什么的可选描述的ArgumentParser对象，

　　然后,我们添加参数。我们想要程序能够识别接下来这条语句 add_argument()。parser.add_argument('--no-system', action='store_true', dest='no_system', default = False, help='Specify to omit system users')。第一个方法的参数是当系统调用这个程序,程序使用着将要提供这个参数的名称,接下来的参数acton=store_true表明它是一个布尔选择。那就是说,它真或假影响程序的某些行为。dest为可定制化参数,它的值可以提供给程序使用。假如这个值用户不提供,这个值默认false。最后的参数程序显示的帮助信息。最后,参数被解析通过args=parser.parse_args()方法。一旦解析方法被做,用户选项的值能够被抓取到通过相应的语法参数option_dest,当你配置参数的时候,option_dest是一个你指定的目的变量。getusers(args.no_system)这条语句使用用户提供参数的值将会回调getusers()方法。

　　下面的程序展示了如何指定非布尔类型的选项。该程序是对第6个程序的重写，附加了一个选项用于指定你感兴趣的网络设备。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/env python
from __future__ import print_function
from collections import namedtuple
import argparse
 
def netdevs(iface = None ):
     ''' RX and TX bytes for each of the network devices '''
 
     with open ( '/proc/net/dev' ) as f:
         net_dump = f.readlines()
     
     device_data = {}
     data = namedtuple( 'data' ,[ 'rx' , 'tx' ])
     for line in net_dump[ 2 :]:
         line = line.split( ':' )
         if not iface:
             if line[ 0 ].strip() ! = 'lo' :
                 device_data[line[ 0 ].strip()] = data( float (line[ 1 ].split()[ 0 ]) / ( 1024.0 * 1024.0 ),
                                                     float (line[ 1 ].split()[ 8 ]) / ( 1024.0 * 1024.0 ))
         else :
             if line[ 0 ].strip() = = iface:
                 device_data[line[ 0 ].strip()] = data( float (line[ 1 ].split()[ 0 ]) / ( 1024.0 * 1024.0 ),
                                                     float (line[ 1 ].split()[ 8 ]) / ( 1024.0 * 1024.0 ))   
     return device_data
 
if __name__ = = '__main__' :
 
     parser = argparse.ArgumentParser(description = 'Network Interface Usage Monitor' )
     parser.add_argument( '-i' , '--interface' , dest = 'iface' ,
                         help = 'Network interface' )
 
     args = parser.parse_args()
 
     netdevs = netdevs(iface = args.iface)
     for dev in netdevs.keys():
         print ( '{0}: {1} MiB {2} MiB' . format (dev, netdevs[dev].rx, netdevs[dev].tx))

　　当你不带任何参数执行程序的时候，程序的行为与之前的版本完全一致。然后，你也可以指定感兴趣的网络设备。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ . / net_devs_2.py
 
em1: 0.0 MiB 0.0 MiB
wlan0: 146.099492073 MiB 12.9737148285 MiB
virbr1: 0.0 MiB 0.0 MiB
virbr1 - nic: 0.0 MiB 0.0 MiB
 
$ . / net_devs_2.py  - - help
usage: net_devs_2.py [ - h] [ - i IFACE]
 
Network Interface Usage Monitor
 
optional arguments:
   - h, - - help            show this help message and exit
   - i IFACE, - - interface IFACE
                         Network interface
 
$ . / net_devs_2.py  - i wlan0
wlan0: 146.100307465 MiB 12.9777050018 MiB

　脚本的系统范围可用性

　　在本文的帮助下，你可能已经可以写一个或多个有用的脚本，就像其它linux命令一样，你想要每天都使用它们。最简单的方式是将脚本设置为可执行的，然后为脚本设置一个BASH别名。你也可以移除.py扩展名，然后将脚本放在诸如/usr/local/sbin这样的标准位置。

　其它有用的标准库模组

　　除了本文中已经提到的标准库模组，还有很多其它有用的标准模组：subprocess、ConfigParser、readline和curses。

　接下来做什么？

　　在这个阶段，依靠你自己使用Python的经验，探索Linux内部，你可以参考下面的任一方式。如果你曾经需要写很多shell脚本/命令流水线来探索Linux内部，那么试一下Python。如果你想要一个更简单的方式来编写执行很多任务的实用程序脚本，那么试一下Python。最后，如果你已经使用Python在Linux上别写其它目的的程序，那么试一下用Python探索Linux内部。

　资源

　　Python资源

　　系统信息

　　原文地址：http://amitsaha.github.io/site/notes/articles/python_linux/article.html

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号