GPU排队脚本

python脚本

GPU排队脚本 ---- GPU一旦空闲触发脚本执行程序

参考： GPU排队脚本（python脚本）

cmd = 'bash run.sh' 该句设置要执行的python脚本

import os
import sys
import time

cmd = 'bash run.sh' #设置运行的脚本

def gpu_info():
    gpu_status = os.popen('nvidia-smi | grep %').read().split('|')
    gpu_memory = int(gpu_status[2].split('/')[0].split('M')[0].strip())
    gpu_power = int(gpu_status[1].split('   ')[-1].split('/')[0].split('W')[0].strip())
    return gpu_power, gpu_memory

def narrow_setup(interval = 2):
    gpu_power, gpu_memory = gpu_info()
    i = 0
    while gpu_memory > 10000 or gpu_power > 100:  #set waiting condition
        gpu_power, gpu_memory = gpu_info()
        i = i % 5
        symbol = 'monitoring: ' + '>' * i + ' ' * (10 - i - 1) + '|'
        gpu_power_str = 'gpu power: %d W |' % gpu_power
        gpu_memory_str = 'gpu memory: %d MiB |' % gpu_memory
        sys.stdout.write('\r' + gpu_memory_str + '\t' + gpu_power_str + '\t' + symbol)
        sys.stdout.flush()  #sys.stdout.flush()的作用就是显示地让缓冲区的内容输出
        time.sleep(interval)
        i += 1
    print("\n" + cmd)
    os.system(cmd)

if __name__ == '__main__':
    narrow_setup()

即可 监听nvidia-smi的信息， 以伺机触发python脚本， 当GPU的显存以及功耗低于某个值时，便会触发python脚本。

shell脚本

可以在shell脚本中直接添加训练训练模型的语句

#!/bin/bash
var=0

while [ $var -eq 0 ]
do
    count=0
    for i in $(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits)
    do
        if [ $i -lt 500 ]
        then
            echo 'GPU'$count' is available'
            bash run.sh #训练模型的语句
            var=1
            break
        fi
        count=$(($count+1))
        #echo $count
    done
done

Linux命令

more命令

more命令查看文件分页显示

（more +N file_name 从指定行开始显示）

（more -N file_name 设置每次屏幕显示的行数）

• 空格键：查看下一屏
• 回车键：往下滚动一行
• b键：往前查看一屏
• q键：退出

管道符 |

命令格式：命令A | 命令B (即命令A的正确输出作为命令B的操作对象)

cat file | more(先展示了file中的内容，然后more指令再处理file的内容)

grep指令

grep（global search regular expression(RE) and print out the line，全面搜索正则表达式并把行打印出来）：使用正则表达式搜索文本，并把匹配的行打印出来。

id    name    java
1     90      90
2     lisi    89
3     wangw   93
4     zhao    82

grep -c 字符串 文件名：计算找到搜索字符串的行数
grep -c "name" student.txt
#1

grep -o 字符串 文件名：指出匹配的内容
grep -o "zhang" student.txt
#
grep -o "zh" student.txt
#zh

grep -i 字符串 文件名：不区分大小写打印出一行信息
grep -i "zh" student.txt
#4    zhao    82

grep -n 字符串 文件名：显示行号
grep -n "zh" student.txt
5:4    zhao    82

cut指令

cut：提取某一列

cut -f 列号：提取第几列

-d 分隔符：按照指定分隔符分割列

awk指令

Shell脚本编写

Linux之Shell脚本编程（一）

shell脚本编程快速入门

Shell是命令解释器(command interpreter)，是Unix操作系统的用户接口。

Shell也是一门编程语言，即shell脚本，shell是解释执行的脚本语言，可直接调用linux命令。一个系统可以存在多个shell，可以通过cat /etc/shells命令查看系统中安装的shell，不同的shell可能支持的命令语法是不相同的。

一、shell种类

操作系统内核（kernel）与shell是独立的套件，而且都可以被替换。不同的操作系统使用不同的shell；同一个kernel之上可以使用不同的shell。

常见的shell分为两大主流：

sh:

• Bourne shell (sh), Solaris, hpux 默认shell
• Bourne again shell (bash), Linux系统默认shell

csh:

• C shell(csh)
• tc shell(tcsh)

查看使用的shell

echo $SHELL
#/bin/bash

shell环境定义 

临时环境变量：所谓临时环境变量是指用户在当前登陆环境生效的变量。用户登录系统后，直接在命令行上定义的环境变量只能在当前的登录环境中使用。当退出系统后，环境变量将不能在下次登录时使用

将环境变量永久生效：通过将环境变量定义写入到配置文件中，用户每次登录时系统自动定义，则无需再到命令行重新定义。定义环境变量的常见配置文件如下：

/etc/profile 针对系统所有用户生效，此文件应用于所有用户每次登录系统时的环境变量定义

$HOME_name/.bash_profile 针对特定用户生效，$HOME为用户的宿主目录，当用户登录系统后，首先继承/etc/profile文件中的定义，再应用$HOME/.bash_profile文件中的定义

系统预定义的环境变量：系统环境变量对所有用户有效，如：$PATH、$HOME、$SHELL、$PWD等等，用echo命令打印上述的系统环境变量

echo $PATH  #/opt/conda/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
echo $PWD
#/workspace
echo $SHELL
#/bin/bash
echo $HOME
#/root

shell脚本编程 

同传统的编程语言一样，shell提供了很多特性，这些特性可以使得shell脚本编程更为有用。

创建shell脚本

• 首行：第一行内容在脚本的首行左侧，表示脚本将要调用的shell解释器，内容如下：#!/bin/bash,  #! 符号能够被内核识别是一个脚本的开始，这一行必须位于脚本的首行， /bin/bash 是bash程序的绝对路径，在这里表示后续的内容将通过bash程序解释执行。
• 注释：注释符号 # 放在需注释内容的前面， 多行注释：需要注释多行代码:<<EOF    EOF将多行注释的内容嵌套在里面
• 内容：可执行内容和shell结构

shell脚本的权限

一般情况下，默认创建的脚本是没有执行权限的。没有权限不能执行，需要赋予可执行权限。

chmod +x test.sh

shell脚本的执行 

1.输入脚本的绝对路径或相对路径

• /workspace/test.sh
• ./test.sh

2.bash或sh + 脚本（当脚本没有x权限时，root和文件所有者通过该方式可以正常执行）

• bash test.sh
• sh test.sh

3. 在脚本的路径前加“.”或source

• source /workspace/test.sh
• . test.sh

第一种和第二种会新开一个bash，不同bash中的变量无法共享。但是使用. ./test.sh 这种方式是在同一个shell里面执行的。

二、shell变量

变量：是shell传递数据的一种方式，用来代表每个取值的符号名。当shell脚本需要保存一些信息时，即将它存放在一个变量中。

变量设置规则：

• 变量名称可以由字母，数字和下划线组成，但是不能以数字开头，环境变量名建议大写，便于区分
• 在bash中，变量的默认类型都是字符串型，如果要进行数值运算，则必须指定变量类型为数值型
• 变量用等号连接，等号左右两侧不能有空格
• 变量的值如果有空格，需要使用单引号或者双引号包括

变量分类：

Linux Shell中的变量分为用户自定义变量，环境变量，位置参数变量和预定义变量。可以通过set命令查看系统中存在的所有变量。

• 系统变量：保存和系统操作环境相关的数据。$HOME, $PWD, $SHELL, $USER等等。
• 位置参数变量：主要用来向脚本中传递参数或数据，变量名不能自定义，变量作用固定。
• 预定义变量：是Bash中已经定义好的变量，变量名不能自定义，变量作用也是固定的。

用户自定义变量

用户自定义的变量由字母或下划线开头，由字母，数字或下划线序列组成，并且大小写字母意义不同，变量名长度没有限制。只读类型变量，使用readonly命令

设置变量，习惯上用大写字母来命名变量。变量名以字母表示的字符开头，不能用数字。

变量调用，在使用变量时，要在变量名前加上前缀"$"。使用echo命令查看变量值，eg: echo $A

变量赋值，

• 定义时赋值：变量=值（等号两侧不能有空格）eg：STR="hello world"        A=9
• 将一个命令的执行结果赋值给变量：
  • A=`ls -la`反引号，运行里面的命令，并把结果返回给变量A
  • A=$(ls -la)等价于反引号  eg：aa=$((4+5))    bb=`expr 4 + 5`
  • 将一个变量赋值给另一个变量  eg：A=$STR

变量叠加，

aa=123
echo $aa
#123
cc="$aa"456
echo $cc
#123456
dd=${aa}789
echo $dd
#123789

单引号和双引号的区别：

现象：单引号里的内容会全部输出，而双引号里的内容会有变化

原因：单引号会将所有特殊字符脱意 

• 在对变量进行取值时，使用"#"符号对字符串进行取值
• 提取子字符串，使用字符串的截取命令，用于提取部分字符串 str:k1:k2
• 查找字符串，用于查找字符的位置，输出结果为字符在字符串中所占的数据位置。如果查找多个字符，哪个字母先出现即先计算哪个

NUM=10
SUM="$NUM hehe"
echo $SUM
#10 hehe
SUM2='$NUM hehe'
echo $SUM2
#$NUM hehe
string="abcd"
echo ${#string}    #4
string="this is a test"
echo ${string:2:6}    #is is
string="this is a test"
echo `expr index "$string" "it"`    #1

列出所有的变量， set

删除变量，unset NAME（unset撤销变量，对于readonly B=2声明静态的变量B=2，不能unset）

用户自定义的变量，作用域为当前的shell环境

环境变量

用户自定义变量只在当前的shell中生效，而环境变量会在当前shell和其子shell中生效，如果把环境变量写入相应的配置文件，那么这个环境变量就会在所有的shell中生效。

export 变量名=变量值        申明变量

预定义变量

$?    执行上一个命令的返回值，执行成功，返回0， 执行失败，返回非0

$$    当前进程的进程号（PID），即当前脚本执行时生成的进程号

$!    后台运行的最后一个进程的进程号（PID），最近一个被放入后台执行的进程

expr命令：四则运算和字符串运算

expr的字符串运算能力

• match  match STRING REGEXP STRING中匹配REGEXP字符串并返回匹配字符串的长度
• substr  substr STRING POS LENGTH 从POS位置获取长度为LENGTH的字符串
• index  index STRING SUBSTR 查找子字符串的起始位置
• length  length STRING 计算字符串的长度

三、shell数组

在bash下，仅仅支持一维数组，并且没有限定数组的大小，不支持多维数组。类似于C语言，数组元素的下标由0开始编号。获取数组中的元素要利用下标，下标可以是整数或者算术表达式，其值应当大于或等于0。

定义数组：在shell中，用()来定义数组，数组中元素用"空格"符号分割开。定义数组一般形式为：

数组的三种定义形式；读取数组和读取变量名相同，使用$符号；获取数组长度的方法与获取字符串长度的方法相同。

#!/bin/bash

array_name=(value1 value2 value3 value4)
array_test=(
value1
value2
value3
value4
)
array_text[0]=value0
array_text[1]=value1
array_text[3]=value3

valuen=${array_name[2]}
echo $valuen    #输出    value3

echo ${array_name[n]}    #输出    value1
echo ${array_name[@]}    #输出    value1 value2 value3 value4

length=${#array_name[@]}
echo $length    #输出    4
length=${#array_name[*]}
echo $length    #输出    4
length=${#array_name[0]}
echo $length    #输出    6

四、shell传递参数 

在执行shell脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。n代表一个数字，1为执行脚本的第一个参数，2为执行脚本的第二个参数，以此类推……

在使用shell传递参数时，需要用到以下的几个字符来处理参数 

• $#：传递到脚本的参数个数
• $$：脚本运行的当前进程ID号
• $!：后台运行的最后一个进程的ID号
• $?：显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误
• $*：以一个单字符串显示所有向脚本传递的参数
• $@：与*相同，添加引号，在引号中返回每个参数

#!/bin/bash
echo "传递参数实例！";
echo "执行的文件名:$0";
echo "第一个参数为:$1";
echo "第二个参数为:$2";
echo "第三个参数为:$3";

echo "参数个数为：$#";
echo "脚本运行的进程ID号:$$";
echo "后台运行的最后一个进程的ID号:$!";
echo "显示最后命令的退出状态:$?";

echo "输出向脚本传递的参数：$*"
echo "输出向脚本传递的参数：$@"

#执行 bash test.sh 1 2 3

#输出
传递参数实例！
执行的文件名:test.sh
第一个参数为:1
第二个参数为:2
第三个参数为:3
参数个数为：3
脚本运行的进程ID号:24610
后台运行的最后一个进程的ID号:
显示最后命令的退出状态:0
输出向脚本传递的参数：1 2 3
输出向脚本传递的参数：1 2 3

五、shell运算符

shell运算符种类，shell同样支持多种运算符

• 算数运算符
• 关系运算符
• 布尔运算符
• 逻辑运算符
• 字符串运算符
• 文件测试运算符

shell想要使用这些运算符，需要结合其他命令和工具来使用，使用算术运算符需要搭配的常用两种工具是：awk、expr

• 表达式和运算符之间必须要用空格（必须写成3 + 2）        
• 完整的表达式要被两个"`"包含

运算符和数之间必须用空格隔开

算数运算符

+        -        *        /        %        =        ==        !=

        备注：算数运算符中的乘号(*)前面必须加反斜杠才能实现乘法运算

关系运算符

shell中使用特殊的字符表示关系运算符，并且只支持数字，不支持字符串，除非字符串是数字

-eq        -ne        -gt        -lt        -ge        -le

布尔运算符

! (非运算)       -o （或运算）       -a（与运算）

逻辑运算符

&&（逻辑中的AND）        ||（逻辑中的OR）

此处使用两层的[]符号，将两次关系运算的结果保存在条件句中

字符串运算符

=        !=        -z        ​​​​​​​-n        $(检测字符串是否为空)

文件测试运算符

shell中的文件测试运算符用于检测在类unix系统中，文件的各种属性

#!/bin/bash

val=`expr 3 + 2`
echo "两个数和为：$val" #两个数和为：5

a=10
b=20

if [ $a -eq $b ]
then
    echo "$a -eq $b : a 等于 b"
else
    echo "$a -eq $b ：a 不等于 b"
fi
#10 -eq 20 ：a 不等于 b

if [ $a -ne $b ]
then
    echo "$a -ne $b : a 不等于 b"
else
    echo "$a -ne $b : a 等于 b"
fi
#10 -ne 20 : a 不等于 b

a=10
b=20
if [ $a -eq 10 -o $b -eq 20 ]
then
    echo "TRUE"
else
    echo "FALSE"
fi
#TRUE

if [[ $a -lt 100 && $b -gt 100 ]]
then
    echo "返回 true"
else
    echo "返回 false"
fi
#返回 false

a="abc"
b="efg"
if [ $a != $b ]
then
    echo "$a != $b : a 不等于 b"
else
    echo "$a != $b : a 等于 b"
fi
#abc != efg : a 不等于 b

file="./test.sh"
if [ -r $file ]
then
    echo "文件可读"
else
    echo "文件不可读"
fi
#文件可读

六、 shell编程中的命令

echo命令(echo命令在shell中用于字符串的输出，调用的格式：echo string)

>        结果定向重定向至文件

-e        表示开启转义

#!/bin/bash
echo "this is a test"
echo \"this is a test\"
name="ohuohuo"
echo "your name is $name"
echo -e "Right! \n" # -e 表示开启转义
echo "this is other line"
echo "this is a test" > testfile
echo `date`
#执行命令
bash test.sh
#输出：
this is a test
"this is a test"
your name is ohuohuo
Right!

this is other line
Mon 18 Oct 2021 10:06:50 PM HKT

printf命令 （shell中的printf命令如同C语言中的一样，不过不会自动调用换行符号，调用的格式：printf format-string [arguments...]（format-string格式控制字符串， arguments参数列表））

printf命令可以使用较为强大的转义字符

echo "Hello, Shell"
#输出：Hello, Shell
printf "Hello, Shell\n"
#输出：Hello, Shell 

test命令

shell中的test命令用于检查某个条件是否成立，可以进行数值、字符和文件三个方面的测试

数值测试命令表

参数	说明
-eq（equal）	等于则为真
-ne（no equal）	不等于则为真
-gt（great than）	大于则为真
-ge（great and equal）	大于等于则为真
-lt（low than）	小于则为真
-le（low and equal）	小于等于则为真

#!/bin/bash

num1=100
num2=100
if test $[num1] -eq $[num2]
then
    echo '两个数相等!'
else
    echo '两个数不相等!'
fi
#输出：两个数相等!

字符串测试表 

参数	说明
=	等于则为真
!=	不相等则为真
-z 字符串	字符串长度为零则为真
-n 字符串	字符串长度bu'wei'l

num1="name"
num2="function"
if test $num1 = $num2
then
    echo '两个字符串相等！'
else
    echo '两个字符串不相等！'
fi
#输出：两个字符串不相等！

 文件测试表

参数	说明
-e 文件名	如果文件存在则为真
-r 文件名	如果文件存在且可读则为真
-w 文件名	如果文件存在且可写则为真
-x 文件名	如果文件存在且可执行则为真
-s 文件名	如果文件存在且至少有一个字符则为真
-d 文件名	如果文件存在且为目录则为真
-f 文件名	如果文件存在且为普通文件则为真
-c 文件名	如果文件存在且为字符型特殊文件则为真
-b 文件名	如果文件存在且为块特殊文件则为真

#!/bin/bash
if test -e ./test.sh
then
    echo '文件已存在！'
else
    echo '文件不存在！'
fi
#输出：文件已存在！

 七、shell流程控制

shell作为一种脚本语言，有着自己的流程控制，而shell中的流程控制主要由条件、循环组成。

if else条件

条件模板为 if - then - elif - then - else - fi

#!/bin/bash
num1=$[6]
num2=$[8]
if test $[num1] -eq $[num2]
then
    echo "两个数字相等"
else
    echo "两个数字不相等"
fi
#两个数字不相等

case条件

• 取值后面需要加上in
• 每一模式必须以右括号结束
• 每个模式结束后使用;;符号结尾
• 如果没有找到对应的模式。以*结尾，并跳出case
• case需要搭配esac结尾，与C语言中的switch … case语句类似

case中想要跳出循环有两个命令：break和continue

break命令：允许跳出所有循环（中止执行后面所有的循环）

continue命令：不会跳出所有循环，仅仅跳出当前循环，与其他类型的语言相同

#!/bin/bash
echo '输入1到4之间的数字：'
echo '你输入的数字为:'
read num
case $num in
    1)  echo '你选择了1'
    ;;
    2)  echo '你选择了2'
    ;;
    3)  echo '你选择了3'
    ;;
    4)  echo '你选择了4'
    ;;
    *)  echo '你没有输入1-4之间的数字'
    ;;
esac
#输出：
输入1到4之间的数字：
你输入的数字为:
3
你选择了3

while :
do
    echo "输入1-4之间的数字:"
    read num
    case $num in
        1|2|3|4) echo "你输入的数字为 $num !"
        ;;
        5) echo "你输入的数字是5"
            continue
            echo "游戏结束"
        ;;
        *) echo "你输入的数字不是1-5之间的！游戏结束"
            break
        ;;
    esac
done
#输出
输入1-4之间的数字:
5
你输入的数字是5
输入1-4之间的数字:
3
你输入的数字为 3 !
输入1-4之间的数字:
6
你输入的数字不是1-5之间的！游戏结束

for循环 

条件模板 for var in item1 item2 ... itemN -- do command1 -- done

while循环

条件模板 while condition -- do command -- done

until循环

条件模板 until condition -- do command -- done

for num in 1 2 3 4 5
do
    echo "The value is : $num"
done
#输出：
The value is : 1
The value is : 2
The value is : 3
The value is : 4
The value is : 5

num=1
while(( $num <= 5 ))
do
    echo $num
    let "num++"
done
#输出：
1
2
3
4
5

a=0
until [ ! $a -lt 5 ]
do
    echo $a
    a=`expr $a + 1`
done
#输出
0
1
2
3
4

八、shell函数

Linux中的shell同样可以定义函数，然后在函数中调用执行相关的shell命令，完成功能。

所有的函数在使用前必须定义，因为shell解释器是顺序逐层执行的，当shell解释器发现定义的函数时，才会找到对应的功能，进而执行。

[function] funname[()]
{
    action;
    [return int;]
}
function fun()表示有返回参数的函数
fun()表示无返回参数的函数
使用return可以返回参数值，如果不使用，将默认以最后一条命令运行的结果作为返回值

#!/bin/bash

FunReturn(){
    echo "两个数字进行相加运算..."
    echo "输入第一个数字："
    read num
    echo "输入第二个数字："
    read anothernum
    echo "两个数字分别为 $num 和 $anothernum "
    return $(( $num + $anothernum ))    #分别返回数值
}

FunReturn   #调用函数
echo "输入的两个数字之和为 $? !"    #使用通配符获取上一条指令的返回值
#输出
两个数字进行相加运算...
输入第一个数字：
3
输入第二个数字：
4
两个数字分别为 3 和 4
输入的两个数字之和为 7 !

九、shell重定向 

Linux命令中的shell重定向

Python脚本编写

python的sys、os、time模块的使用

sys模块

1. sys.argv:实现从程序外部向程序传递参数。

位置参数argv[0]代表py文件本身， 运行方法python test.py 参数1， 参数2

# test.py
import sys
if __name__ == "__main__":
    self = sys.argv[0]
    name = sys.argv[1]
    age = sys.argv[2]
    print(self, name, age)
# 运行程序
python test.py xiaoming 18

2. sys.getdefaultencoding()：获取系统当前编码，一般默认为ascii。

print(sys.getdefaultencoding())

3. sys.path：获取指定模块搜索路径的字符串集合

print(sys.path)

4.sys.platform：获得当前系统平台

print(sys.platform)

5.sys.exit()：执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用sys.exit()函数，带有一个可选的整数参数返回给调用它的程序， 表示在主程序中捕获对sys.exit()的调用 

import os
if __name__ == "__main__":
    for i in range(1, 10):
        print("第%s次："%i)
        if i == 5:
            print("第五次退出")
            sys.exit(0)

os模块

1.os.name: 判断现在正在使用的平台，Windows返回'nt', Linux返回’posix‘

print(os.name)    #posix

2.os.getcwd()：得到当前工作的目录

print(os.getcwd())    #/workspace/CCF_2021/question_matching

 3. os.listdir()：指定所有目录下所有的文件和目录名

print(os.listdir('.'))

4. os.remove()：删除指定文件

os.remove('test.txt')

5.os.rmdir()：删除指定目录(不能够嵌套删除目录)

os.rmdir('test')

6.os.mkdir()：创建目录（该方法只能建立一层目录，递归建立使用os.makedirs()）

os.mkdir('test')
os.makedirs('test/test')

7.os.path.isfile()：判断指定对象是否为文件。是则返回True， 否则False

print(os.path.isfile('test.py'))

8.os.path.isdir()：判断指定对象是否为目录。是则返回True， 否则False

print(os.path.isdir('test'))

9.os.path.exists()：判断指定对象是否存在。是则返回True，否则False(判断文件夹或者文件等是否存在)

os.path.exists(test)

 10.os.path.split()：返回路径的目录和文件名

os.path.split('/workspace/CCF_BDCI2021/question_matching/data')
#输出：('/workspace/CCF_BDCI2021/question_matching', 'data')

11.os.getcwd()：获得当前工作的目录

print(os.getcwd())

12.os.system()：执行shell命令

var = 123
os.environ['var'] = str(var)    #注意此处[]内的是“字符串”
os.system('echo $var')
#输出：
123
0

13.os.chdir()：用于改变当前工作目录到指定的目录(将工作目录改到指定目录)

print(os.getcwd())
#输出：/workspace/CCF_BDCI2021/question_matching/test
os.chdir('/workspace')
print(os.getcwd())
#输出：/workspace

14.os.path.getsize()：获得文件的大小

print(os.path.getsize('test.py'))

15.os.path.abspath('.')：获得绝对路径

print(os.path.abspath('.'))
#输出：/workspace/CCF_BDCI2021/question_matching

16.os.path.join(path, name)：连接目录和文件名

os.path.join('/workspace/CCF_BDCI2021/question_matching', 'file')
#输出：'/workspace/CCF_BDCI2021/question_matching/file'

17.os.path.realpath()：获得文件所在的目录

import os
import sys
if __name__ == "__main__":
    print(sys.argv[0])    #文件的名字
    print(os.path.realpath(sys.argv[0]))    #文件的路径
    print(os.path.split(os.path.realpath(sys.argv[0])))    #将文件的路径和文件名分割开
    print(os.path.split(os.path.realpath(sys.argv[0]))[0])    #输出文件的路径


#输出：
test.py
/workspace/CCF_BDCI2021/question_matching/test.py
('/workspace/CCF_BDCI2021/question_matching', 'test.py')
/workspace/CCF_BDCI2021/question_matching

18.os.path.basename()：获得路径中文件名        os.path.dirname()：获得文件路径名

print(os.path.basename('/workspace/CCF_BDCI2021/question_matching/test.py'))
#输出：test.py
print(os.path.dirname('/workspace/CCF_BDCI2021/question_matching/test.py'))
#输出：/workspace/CCF_BDCI2021/question_matching

time模块

获取时间

import time

ticks = time.time()
print(ticks)    

localtime = time.localtime(time.time())
print(localtime)    

localtime = time.asctime(time.localtime(time.time()))
print(localtime)

#1634397810.7200205
#time.struct_time(tm_year=2021, tm_mon=10, tm_mday=16, tm_hour=23, tm_min=23, tm_sec=55, tm_wday=5, tm_yday=289, tm_isdst=0)
#Sat Oct 16 23:24:41 2021

格式化日期

import time

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

import calendar
cal = calendar.month(2021, 10)
print(cal)


#输出
2021-10-16 23:39:59
Sat Oct 16 23:40:51 2021
    October 2021
Mo Tu We Th Fr Sa Su
             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

python脚本编写实际操作

sys.stdout.write()将str写到输出流（只能输出一个str， 原封不动输出， 不会默认添加'\n'）

sys.stdout.flush()的作用是显示地让缓冲区中的内容输出（如果缓冲区的内容新增了换行符， 那么stdout就会自动将缓冲区内的内容输出）

python中执行shell命令

• 使用os.system()命令， os.system('cat /proc/cpuinfo')
• 使用os.popen()命令，output = os.popen('cat /proc/cpuinfo')        print(output.read())，通过os.popen()返回的是file read的对象， 对其进行读取read()的操作可以看到执行的输出，但是无法读取程序执行的返回值。