linux下，通过一台主机上的脚本程序启动和关闭同一局域网下其它几台电脑主机
通过电脑主机a，启动电脑b(主要是为了方便不用跑过去按开机键)

引用 皆我百晓生 小程序回复内容作答：
要实现通过一台主机上的Python脚本程序来启动和关闭同一局域网下的其他电脑主机，你需要以下几个步骤：

1. 了解局域网内其他主机的IP地址：在Python脚本中，你需要获取到其他主机的IP地址才能与它们进行通信。可以通过使用socket模块来获取IP地址。

   import socket
   
   def get_ip_address():
       hostname = socket.gethostname()
       ip_address = socket.gethostbyname(hostname)
       return ip_address
   

   使用get_ip_address函数可以获取当前主机的IP地址。

2. 与其他主机建立网络连接：在Python脚本中，你需要使用socket模块的socket函数来与其他主机建立网络连接。

   import socket
   
   def connect_to_host(host_ip, port):
       s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
       s.connect((host_ip, port))
       return s
   

   使用connect_to_host函数可以连接到指定IP地址和端口号的主机。

3. 发送指令给其他主机：一旦与其他主机建立了连接，你可以使用sendall方法发送指令给其他主机。请记住，其他主机必须运行一个能够接收并执行指令的程序。

   def send_command_to_host(connection, command):
       connection.sendall(command.encode())
   

   使用send_command_to_host函数可以发送指令给其他主机。

4. 接收来自其他主机的响应：其他主机收到指令后可能会返回一些响应结果，你需要使用recv方法接收并解析响应。

   def receive_response_from_host(connection):
       response = connection.recv(1024).decode()
       return response
   

   使用receive_response_from_host函数可以接收来自其他主机的响应。

5. 关闭与其他主机的连接：任务完成后，记得关闭与其他主机的连接。

   def close_connection_to_host(connection):
       connection.close()
   

   使用close_connection_to_host函数可以关闭与其他主机的连接。

通过以上步骤，你就可以编写一个Python脚本，实现通过一台主机启动和关闭局域网内其他主机了。记得在其他主机上运行一个能够接收和执行指令的程序。

要实现通过一台主机上的脚本程序启动和关闭同一局域网下其它几台电脑主机，可以使用ssh远程连接的方式来实现：

1. 首先需要配置局域网内多台主机之间可以实现ssh远程连接。

2. 编写脚本程序，使用ssh命令连接局域网内指定的主机，执行启动或关闭的命令。例：

#!/bin/bash
# start.sh
for HOST in host1 host2 host3 # 替换成你需要管理的主机IP或主机名
do
    echo "Starting server on $HOST..."
    ssh user@$HOST "/path/to/start_server.sh" # /path/to/start_server.sh替换成启动脚本的实际路径
done

#!/bin/bash
# stop.sh
for HOST in host1 host2 host3 # 替换成你需要管理的主机IP或主机名
do
    echo "Stopping server on $HOST..."
    ssh user@$HOST "/path/to/stop_server.sh" # /path/to/stop_server.sh替换成关闭脚本的实际路径
done

3. 然后使用终端或者其他运行脚本的方式来运行启动脚本或关闭脚本即可。例如：

$ bash start.sh # 启动脚本
$ bash stop.sh # 关闭脚本

需要注意的是，通过ssh远程连接需要进行身份验证，因此需要提前配置密钥认证或者手动输入密码验证。根据具体情况选择适合的身份验证方式。

援引讯飞星火：
要实现这个功能，你可以使用Python的os库和socket库。首先，你需要在主机上运行一个脚本，该脚本将作为服务器，监听特定的端口。然后，其他计算机可以通过发送网络请求到该端口来启动和关闭主机。

以下是一个简单的示例：

1. 在主机上创建一个名为server.py的脚本，内容如下：

import socket
import sys

def start_host(ip, port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((ip, port))
        s.listen()
        print(f"Host {ip} started on port {port}")
        conn, addr = s.accept()
        with conn:
            print(f"Connected by {addr}")
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                conn.sendall(data)

def stop_host(ip, port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((ip, port))
        s.sendall(b'stop')
        print(f"Host {ip} stopped on port {port}")

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python server.py <start|stop> <ip> <port>")
        sys.exit(1)

    action = sys.argv[1]
    ip = sys.argv[2]
    port = int(sys.argv[3])

    if action == "start":
        start_host(ip, port)
    elif action == "stop":
        stop_host(ip, port)
    else:
        print("Invalid action. Use 'start' or 'stop'.")
        sys.exit(1)

2. 在其他计算机上运行以下命令，启动服务器：

python server.py start <ip> <port>

其中<ip>和<port>是主机的IP地址和端口号。

3. 要启动或关闭主机，只需向服务器发送相应的请求即可。例如，要启动主机，可以运行：

python server.py start <ip> <port>

要关闭主机，可以运行：

python server.py stop <ip> <port>

注意：这个示例仅用于演示目的，实际应用中可能需要考虑更多的安全和错误处理措施。

import socket
import sys
def start_host(ip, port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((ip, port))
        s.listen()
        print(f"Host {ip} started on port {port}")
        conn, addr = s.accept()
        with conn:
            print(f"Connected by {addr}")
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                conn.sendall(data)
def stop_host(ip, port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((ip, port))
        s.sendall(b'stop')
        print(f"Host {ip} stopped on port {port}")
if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python server.py <start|stop> <ip> <port>")
        sys.exit(1)
    action = sys.argv[1]
    ip = sys.argv[2]
    port = int(sys.argv[3])
    if action == "start":
        start_host(ip, port)
    elif action == "stop":
        stop_host(ip, port)
    else:
        print("Invalid action. Use 'start' or 'stop'.")
        sys.exit(1)

解决方法

使用Python第三方库 paramiko 来实现

以下部分参考GPT

安装

pip install paramiko

运行

python3 start.py

start.py

修改 target_hosts为需要远程主机的ip，user,password, 要有sudo权限

import paramiko

def shutdown_remote_host(hostname, username, password):
    try:
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        client.connect(hostname, username=username, password=password)
        
        command = "sudo shutdown -h now"
        stdin, stdout, stderr = client.exec_command(command)
        
        print(f"Command executed on {hostname}:")
        print(stdout.read().decode())
        print(stderr.read().decode())
        
    except Exception as e:
        print(f"Error: {e}")
    finally:
        client.close()

if __name__ == "__main__":
    target_hosts = [
        {"hostname": "host1.example.com", "username": "your_username", "password": "your_password"},
        {"hostname": "host2.example.com", "username": "your_username", "password": "your_password"},
        # 可以添加其他主机信息
    ]
    
    for host_info in target_hosts:
        shutdown_remote_host(host_info["hostname"], host_info["username"], host_info["password"])

---

如有问题随时沟通
如有帮助欢迎采纳

该回答引用chatgpt
要实现这个功能，需要使用 Python 的 paramiko 库来连接到远程 Linux 主机并执行命令。以下是一个简单的示例脚本，可以启动和关闭同一局域网下的其他 Linux 主机上的脚本程序。

import paramiko

# 远程主机的 IP 地址和用户名
host = "192.168.0.2"
username = "username"
password = "password"

# 启动命令和关闭命令
start_command = "python /path/to/program.py start"
stop_command = "python /path/to/program.py stop"

# 创建 SSH 客户端并连接到远程主机
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(host, username=username, password=password)

# 启动脚本程序
stdin, stdout, stderr = client.exec_command(start_command)
print(stdout.read().decode())

# 关闭脚本程序
stdin, stdout, stderr = client.exec_command(stop_command)
print(stdout.read().decode())

# 关闭 SSH 客户端连接
client.close()

在上面的示例中，我们首先定义了远程主机的 IP 地址、用户名和密码。然后，我们定义了启动命令和关闭命令，对应于要在远程主机上执行的脚本程序的启动和关闭操作。接着，我们创建了一个 SSH 客户端对象，使用 set_missing_host_key_policy() 方法设置主机密钥策略，并使用 connect() 方法连接到远程主机。然后，我们使用 exec_command() 方法执行启动命令，并输出命令的输出结果。最后，我们使用同样的方式执行关闭命令，并关闭 SSH 客户端连接。

注意，上述示例仅适用于需要使用用户名和密码连接到远程主机的情况。如果您使用 SSH 密钥进行身份验证，则需要使用 client.connect() 方法的相关参数进行连接。

要通过一台主机上的脚本程序启动和关闭同一局域网下的其他几台电脑主机，您可以使用以下方法之一：

1. 使用SSH：Linux提供了SSH（Secure Shell）协议，可以在网络上安全地远程连接到其他计算机。您可以在脚本中使用SSH命令来远程执行命令，并启动或关闭其他计算机上的程序。例如，使用以下命令通过SSH连接并执行远程命令：ssh user@remote_host command

2. 使用远程执行工具：有许多工具可用于在本地主机上执行远程命令。例如，您可以使用Fabric、Ansible或Salt等工具来管理和控制远程主机。这些工具提供了方便的方法来自动化执行命令、脚本或程序，并在局域网中的多台主机之间进行通信。

3. 利用广播：您可以编写一个脚本，该脚本向局域网中的所有主机发送广播消息，并在接收到该消息的主机上执行相应的操作。这需要一定的网络编程知识，例如使用Python的socket库发送和接收广播消息。

无论您选择哪种方法，都需要确保在执行远程命令或控制其他主机之前具有足够的权限和访问凭据，并且网络连接是可靠且安全的。

请注意，远程执行程序或控制其他主机可能需要您提前做好适当的设置和配置，以确保您具有足够的权限和授权来执行相关操作。同时也要谨慎操作，以免对网络中的其他设备或数据产生不良影响。

首先，这个任务需要一些前提条件。你需要有足够的权限在目标电脑上执行命令。你也需要知道如何通过网络远程执行命令。

以下是一个简单的Python脚本，使用paramiko库在目标机器上执行关机命令。

首先，你需要安装paramiko库。如果你还没有安装，你可以使用以下命令安装：

pip install paramiko

然后，你可以使用以下脚本：

import paramiko  
  
def shutdown_remote_server(ip, username, password):  
    # 创建一个SSH客户端  
    client = paramiko.SSHClient()  
    # 自动添加不在known_hosts的服务器的主机密钥  
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())  
    # 连接目标服务器  
    client.connect(ip, username=username, password=password)  
    # 通过SSH客户端运行关机命令  
    client.exec_command(command="shutdown -h now")  
    # 关闭SSH客户端连接  
    client.close()  
  
# 用目标电脑的IP，用户名和密码替换以下变量  
ip = "目标电脑的IP"  
username = "用户名"  
password = "密码"  
shutdown_remote_server(ip, username, password)

这个脚本会立即关闭目标电脑。如果你想让电脑在一定时间后关机，你可以将 "shutdown -h now" 替换为 "shutdown -h +1"（1分钟后关机）或 "shutdown -h +5"（5分钟后关机）等。

注意：这个脚本需要你有足够的权限在目标电脑上执行关机命令。如果没有，你可能需要使用sudo或者作为root用户运行这个脚本。

第二种方法

在Linux下，你可以使用SSH（Secure Shell）来远程控制其他主机。以下是一个简单的Python脚本，使用paramiko库，一个用于SSH的Python库。

首先，你需要安装paramiko库。你可以使用pip来安装：

pip install paramiko

然后，你可以使用以下Python脚本来远程启动另一台电脑：

import paramiko  
  
def start_host(ip, username, password):  
    client = paramiko.SSHClient()  
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())  
    client.connect(ip, username=username, password=password)  
  
    # 如果你想通过SSH运行某些命令来确认电脑是否已启动，可以取消下面这行注释：  
    #stdin, stdout, stderr = client.exec_command('ls')  
  
    # 然后，你需要找到适合的命令来启动你的电脑。一般来说，这可能取决于你的硬件和操作系统。  
    # 对于大多数Linux系统，一个可能的方法是尝试运行 'shutdown -r now' 来立即重启电脑。  
    # 如果你的电脑需要按电源按钮才能启动，那么你可能需要找到一种方法来“模拟”按下电源按钮。  
    # 这是一个复杂的问题，可能需要硬件级别的知识或者特殊的软件。  
  
    client.close()  
  
# 用你的电脑的IP地址、用户名和密码替换下面的值  
ip = '192.168.1.100'  
username = 'your_username'  
password = 'your_password'  
  
start_host(ip, username, password)

这个脚本会尝试连接到指定的IP地址，然后关闭连接。如果你想通过SSH运行某些命令来确认电脑是否已启动，可以取消exec_command('ls')这行注释，并替换为你想要运行的命令。然而，如果你想通过脚本启动电脑，就需要找到一个适合你的硬件和操作系统的命令。对于大多数Linux系统，尝试运行 shutdown -r now 来立即重启电脑可能会有效。然而，如果你的电脑需要按电源按钮才能启动，那么你可能需要找到一种方法来“模拟”按下电源按钮，这是一个复杂的问题，可能需要硬件级别的知识或者特殊的软件。

参考gpt

1. 确保目标电脑（电脑b）已经开启了远程登录服务。在Linux下，可以使用SSH服务来实现。确保SSH服务已经安装并启动。

2. 在启动电脑b之前，你需要在电脑a上安装SSH客户端。在Linux下，大多数发行版都预装了OpenSSH客户端。如果没有安装，可以使用以下命令安装：

   sudo apt-get install openssh-client
   

3. 在电脑a上，使用Python的subprocess模块来执行远程命令。以下是一个示例代码：

   import subprocess
   
   def start_remote_computer(ip_address, username, password):
       command = f'sshpass -p {password} ssh {username}@{ip_address} "sudo systemctl start"'
   
       # 执行远程命令
       subprocess.run(command, shell=True)
   
   def stop_remote_computer(ip_address, username, password):
       command = f'sshpass -p {password} ssh {username}@{ip_address} "sudo systemctl stop"'
   
       # 执行远程命令
       subprocess.run(command, shell=True)
   
   # 使用示例
   ip_address = '192.168.0.2'  # 电脑b的IP地址
   username = 'your_username'  # 电脑b的用户名
   password = 'your_password'  # 电脑b的密码
   
   start_remote_computer(ip_address, username, password)  # 启动电脑b
   stop_remote_computer(ip_address, username, password)  # 关闭电脑b
   

   在上述代码中，start_remote_computer函数用于启动远程电脑，stop_remote_computer函数用于关闭远程电脑。你需要替换ip_address、username和password为电脑b的实际信息。

   注意：在示例代码中，使用了sshpass工具来自动输入密码。请确保在电脑a上已经安装了sshpass工具。你可以使用以下命令安装：

   sudo apt-get install sshpass
   

   另外，为了安全起见，建议使用SSH密钥对进行身份验证，而不是使用密码。这样可以更安全地进行远程访问。

import paramiko

target_ip = '192.168.1.2'  # 目标电脑的IP地址
ssh_username = 'your_username'
ssh_password = 'your_password'

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(target_ip, username=ssh_username, password=ssh_password)

# 执行关机命令，具体命令可能因操作系统而异
# 例如，在Linux上可以使用 'sudo shutdown -h now'
# 在Windows上可以使用 'shutdown /s /f /t 0'
shutdown_command = 'sudo shutdown -h now'  # 适用于Linux
stdin, stdout, stderr = ssh.exec_command(shutdown_command)

ssh.close()

import paramiko
 def start_remote_computer(host, username, password):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username=username, password=password)
    ssh.exec_command("sudo systemctl start poweroff.target")
    ssh.close()
 def shutdown_remote_computer(host, username, password):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username=username, password=password)
    ssh.exec_command("sudo systemctl poweroff")
    ssh.close()
 # Usage example
hostB = "192.168.0.2"  # IP address or hostname of the remote computer B
username = "your_username"  # Username for remote computer B
password = "your_password"  # Password for remote computer B
 start_remote_computer(hostB, username, password)  # Start remote computer B
shutdown_remote_computer(hostB, username, password)  # Shutdown remote computer B

该回答通过自己思路及引用到GPTᴼᴾᴱᴺᴬᴵ搜索,得到内容具体如下：
要通过一台主机启动同一局域网下的其他电脑主机，您可以使用远程登录工具（如SSH）和命令行工具（如sshpass）来实现。下面是一个使用Python脚本启动和关闭其他主机的示例：

import subprocess

def start_remote_host(host, username, password):
    command = f"sshpass -p {password} ssh {username}@{host} 'sudo systemctl start your_service'"
    subprocess.call(command, shell=True)

def stop_remote_host(host, username, password):
    command = f"sshpass -p {password} ssh {username}@{host} 'sudo systemctl stop your_service'"
    subprocess.call(command, shell=True)

# 用法示例
host = '192.168.0.2'  # 要启动的远程主机的IP地址
username = 'your_username'  # 远程主机的用户名
password = 'your_password'  # 远程主机的密码

start_remote_host(host, username, password)  # 启动远程主机
# 或者
stop_remote_host(host, username, password)  # 关闭远程主机

上述示例中，start_remote_host()函数用于启动远程主机，stop_remote_host()函数用于关闭远程主机。您需要将your_service替换为实际要启动或关闭的服务的名称。在函数中，使用subprocess模块执行基于命令行的SSH命令，通过sshpass提供密码来进行远程登录。

请注意，为了使脚本能够执行远程登录，确保您的主机已经安装了sshpass工具，并且远程主机已正确配置SSH访问。

另外，为了方便使用，您可以将要启动或关闭的主机的IP地址、用户名和密码存储在配置文件或数据库中，以便动态读取和使用。

这只是一个简单的示例，您可以根据您的实际需求进行修改和扩展。希望对您有帮助！

---

如果以上回答对您有所帮助，点击一下采纳该答案～谢谢

结合GPT给出回答如下请题主参考
要远程启动同一局域网下的其他电脑主机，可以使用Wake-on-LAN（WOL）技术。WOL需要支持该技术的网卡和BIOS。以下是一些步骤：

1. 确定需要远程启动的电脑主机的MAC地址。可以在目标电脑主机上使用命令ifconfig -a或者ipconfig /all来查看MAC地址。

2. 安装Python的wakeonlan库。可以使用以下命令安装:

pip install wakeonlan

3. 在Python脚本中导入库，并使用以下代码远程启动目标电脑主机：

import wakeonlan

# 目标电脑主机的MAC地址
mac_address = '00:11:22:33:44:55'

# 向目标电脑发送wake-on-LAN信号
wakeonlan.send_magic_packet(mac_address)

要关闭目标电脑主机，可以使用SSH协议连接该主机并执行命令sudo shutdown -h now来实现。

需要注意的是，为了使用WOL技术远程启动电脑主机，需要在目标电脑主机BIOS中启用“Wake-on-LAN”选项。同时，目标电脑主机和主机a必须在同一局域网下才能成功启动。

有个ssh命令吧。可以一次性群控多个电脑的。

【以下回答由 GPT 生成】

我想要优化一个算法的执行时间。

【相关推荐】

• 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7443956
• 这篇博客你也可以参考下：Python练习题——第八题：有两个磁盘文件A和B,各存放一行字符串，要求首先把小写字母全部转换成大写字母，然后再把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

建个集群，以a为主机
Linux之shell脚本——集群关机、重启多台虚拟机

#!/bin/bash
if [ $# -lt 1 ]
 then 
   echo "NO Args Input Error!!!"
   exit     
fi          
case $1 in  
"shutdown") 
  echo "===========shutdown now============"
  ssh -t hadoop103 "echo \"123456\" | sudo -S shutdown -h now"
  ssh -t hadoop104 "echo \"123456\" | sudo -S shutdown -h now"
  ssh -t hadoop102 "echo \"123456\" | sudo -S shutdown -h now"
;;  
"reboot")
  echo "=========reboot============="
  ssh -t hadoop103 "echo \"123456\" | sudo -S reboot"
  ssh -t hadoop104 "echo \"123456\" | sudo -S reboot"
  ssh -t hadoop102 "echo \"123456\" | sudo -S reboot"
;;
*)
echo "INput args Error!!"
;;
esac

题主，这个问题我来替你解决，若有帮助，还望采纳，点击回答右侧采纳即可。

在Linux下，可以使用Paramiko库实现远程SSH登录和执行命令，通过Python脚本程序实现主机之间的相互控制。

以下是启动电脑B的Python脚本程序示例：

import paramiko

# 定义远程主机IP、用户名和密码
ip = '192.168.1.2'
username = 'user'
password = 'pass'

# 创建SSH客户端
ssh = paramiko.SSHClient()
# 添加目标主机的公钥
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# SSH连接目标主机
ssh.connect(ip, username=username, password=password)

# 在目标主机上执行命令
stdin, stdout, stderr = ssh.exec_command('shutdown -h now')

# 输出命令执行结果
print(stdout.read().decode())

# 关闭SSH连接
ssh.close()

该脚本会连接到电脑B（IP为192.168.1.2）并执行“shutdown -h now”命令，将电脑B关机。

关闭电脑B可以使用类似的方式，只需要将命令修改为“shutdown -r now”即可。

注意：在实际应用中，需要根据实际情况修改IP、用户名和密码等参数，并确保目标主机开启了SSH服务并允许远程登录。同时，使用远程控制电脑需要谨慎操作，避免造成不必要的损失。

linux中通过脚本，一台机器控制多台机器_冯小瑞的博客-CSDN博客 如果我们要通过一台机器查看所有机器的jps，我们需要对jps做软连接1、which jps查看位置2、运行sudo ln -s /root/apps/jdk1.8.0_201/bin/jps /usr/local/bin/jps语句在每一台虚拟机上#注：当我们运行脚本时，在给与权限的情况下必须./~运行，如果将脚本放到/usr/local/bin下的话可以省略./3、在/u... https://blog.csdn.net/Romantic_sir/article/details/104255369

可以使用SSH（Secure Shell）来进行远程控制。但是，如果你想通过一台主机启动和关闭其他电脑的电源，这可能需要更专业的硬件支持，因为你需要能够物理访问到那些电脑的电源开关。

如果你的所有电脑都在一个局域网内，并且已经设置了SSH，你可以使用一个脚本来SSH到其他电脑并运行相应的命令。

通过SSH来控制

参考结合AI智能、文心一言等综合回答，若有帮助，恭请采纳。

要实现这个需求，可以使用SSH协议和脚本程序来实现在电脑主机a上远程启动电脑主机b。

以下是实现步骤：

1. 在电脑主机b上安装SSH服务

在电脑主机b上安装SSH服务，这样可以通过SSH协议连接到电脑主机b。

2. 在电脑主机a上生成SSH公钥和私钥

在电脑主机a上使用ssh-keygen命令生成SSH公钥和私钥。将公钥复制到电脑主机b的~/.ssh/authorized_keys文件中，这样就可以无密码连接到电脑主机b。

3. 编写启动电脑主机b的脚本

在电脑主机a上编写一个启动脚本，通过ssh命令连接到电脑主机b，并执行开机命令。如下：

#!/bin/bash

# 定义电脑主机b的IP地址
IP="192.168.1.100"

# 执行开机命令
ssh root@$IP "power on"

4. 编写关闭电脑主机b的脚本

在电脑主机a上编写一个关闭脚本，通过ssh命令连接到电脑主机b，并执行关机命令。如下：

#!/bin/bash

# 定义电脑主机b的IP地址
IP="192.168.1.100"

# 执行关机命令
ssh root@$IP "power off"

5. 设置脚本的执行权限

在电脑主机a上设置脚本的执行权限：

chmod +x start.sh
chmod +x stop.sh

6. 在需要启动或关闭电脑主机b时，执行对应的脚本即可

在需要启动或关闭电脑主机b的时候，执行对应的脚本即可。

注意：在执行脚本的时候，要确保电脑主机b已经开机，并且已经安装了SSH服务。

import paramiko

# 连接到目标主机
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('目标主机IP', username='用户名', password='密码')

# 启动目标主机
stdin, stdout, stderr = ssh.exec_command('启动命令')

# 关闭目标主机
stdin, stdout, stderr = ssh.exec_command('关闭命令')

# 关闭SSH连接
ssh.close()

可以通过使用SSH协议和脚本程序来实现