这里说的是Python3，Python2的一些语法可能有差异。这里也主要是在Linux下的使用，一些命令可能在Windows系统中不适用，需要自己变通一下。不要只是看，而是要跟着练，不去执行这些命令，就不能体会各个命令的效果。

Windows电脑上可以自己去下载安装。Linux根据发行版本自己上网搜索一下如何安装。另外，还需要一款好用的纯文本编辑器，比如Notepad3。建议先在纯文本编辑器中编辑好代码，再复制到控制台执行，这样比较方便修改代码。

在Linux下，使用如下命令python进入互动模式的python解释器 (控制台)。或使用python程序文件的决定路径执行特定的版本。Windows下则像大家其它软件一样打开，或者在cmd里边用python进入，有可能需要设置好。比如如下是一个windows的cmd里边看起来的样子：

退出控制台，则使用命令exit()：这时候命令实际上已经是执行一个函数了，所以和Shell中的命令不同，这里后边需要跟一个括号。

Linux下中断正在运行的进程则使用Ctrl+C，而Windows中直接关掉或者在任务管理器中结束进程。

默认情况下， >>> 表示等待输入指令， ... 表示等待继续输入未完成的指令

print("Hello, WhLab!") 
 
1+1
 
2*3
 
"2"*3
 
2**3

值(value)是程序处理的基本东西，比如一个字母，一个数字。值的类型分为整数(integer, int)、浮点数（floating-point number, float）、逻辑值（booleans, ）和字符串（string， str）。使用type方程来查看值的类型。

type(2)
 
type(2006.07)
 
type("Hi WhLab")
 
type("2")   #引号将数字引起来，就变成了字符型的
type('2006.07')
 
1,000,000    #注意逗号的用法，这和平时写数字是不一样的。这里得到的是一个元祖
 
type(True)   #逻辑值，注意True和False的大小写
type(False)
bool(0)
bool(-1)
bool("a")   #python中所有的非0值都是True的，可以直接当逻辑值使用

注意同一个操作符对不同的类型的值的意义是不一样的

1 + 2	# 两数相加
 
"1" + '2'	# 两字符串相连接	
1 + '2'         # 不同类型的不能相加
 
1 - 2	# 两数相减
 
 - 2	# 表示负数
 
2*3	# 两个数相乘
 
"25"*3  # 重复字符串指定次数
 
8/4	# 两数相除
 
5/2          #注意结果， 不同的版本中可能结果不同，这里可能得到的是2，而没有后边的小数点
 
5.0/2        #注意整数形式相除与浮点数相除的区别
 
float(5)/2   #需要留意
 
 
13%5	 # 返回除法的余数
13.2%5   # 注意结果
2**3	 # 求幂
9//2	 # 整除
13.2//5 
 
a="WhLab"
a[2]    #方括号用于取值
b=[1, "b", 3, "a", 5]
b[4]

操作符的优先顺序为PEMDAS，即括号 (Parentheses) > 指数 (Exponentiation) > 乘(Multiplication)和除 (Division) > 加 (Addition) 和减 (Subtraction)。括号有最高的优先级，因此，拿不准的时候加上括号。

对于Python来说，说变量(variables)的时候，实际上上指的是对象的名字(names或identifiers)，比如

a = 1
b = a  #这样只是给值为1的对象加上两个names标签，并没有复制这个对象，这和别的一些语言是不一样的。
 
1029hao = '弘哥'   #变量名不能以数字开头
hao@    = '1000'   #变量名里不能含有非法字符
class   = "042班"  #变量名不能是python的关键词：False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise

表达式 (expression) 是值、变量以及操作符的组合。所有的值本身就是一个变量、也是一个表达式。当时在Python控制台输入一个表达式的时候，控制台将求它的值。

42
 
42 + 15

指令(statement)是一个代码单位，具有某个效果，比如赋值、展示某个值之类的。在控制带输入指令的时候，控制台执行它。大多数情况下，指令本身是没有值的。 这么看来，单独输入值、对象、表达式的时候，就包含将值展示出来的指令。

n = 42     #赋值指令
 
print(n)   #展现n的值

Python常用的对象类型有列表(list)、字典（Dictionary）、元组（tuple）等

字符串是一序列字符(字母、数字或符号)的有序的排列，可以通过方括号取值操作取出其中的字符。

s="ATCATACGATCATGGGATCATCGGCATTGC"  #字符串
s[0:5]                       #取出其中的字符
 
s.find('C')     # 从字符串s的下标0开始查找，返回找到的第一个‘C’所在位置
s.find('C', 2)  # 从字符串s的下标2开始查找
s.find('X')     # 查询不到结果时，返回-1
 
s.startswith("A")  # 是否以A开头
s.startswith("G")  #
 
s.replace('C','X')   #将字符串s中的所有'C'替换为'X'
 
s.strip("A")  #去掉s中的首尾的字符"A"
 
" A\n".strip()  #不指定去除的字符时，默认去掉首尾的空格、制表符、换行符等
" A\t".strip()
 
s.split("GATTC")  #按照指定的字符或字符串将字符串拆除称为列表
s.split()    #体会一下区别
 
str.split(s, "GATC")   #体会一下方法与函数的用法
 
s.count("C")   #count字符串中字符或字符串的出现的次数
s.count("CT")
s.count("GGGGCCGGGGA")
 
list(s)    #字符串可以转成列表

list() #list函数创建一个空的列表
[]
[1, 2, 3]   #方括号创建列表
 
List=[1,"two",3,4,"last"]  #一个列表可以容纳不同类型的元素，一个列表甚至可以包含另一个列表。
List[0]   #你可以从某个索引访问列表的元素。
 
List[1]
 
List.append("x")	  # 元素添加到列表s
List
 
List.append(["x"])	  # 元素添加到列表s
List
 
List.count("two")	# 计数有
 
List.index("last") 	# 返回元素列表s的地方
 
List.remove("x")	       # 从列表s中删除元素
List
 
List.reverse()   	#反向列表
List
 
List.sort() 	#排序列表
List
 
 
List[3] = "y"   #列表中的元素是可以改变的，比如这里的第四个元素可以更改成别的值
List
 
"".join(List)    #列表转成字符串，因为列表中不全是字符型而报错
 
List = [str(i) for i in List]  #这样将所有的元素都转成字符型，后文会讲到这种用法
 
List
 
"_xx_".join(List)
 
 
list("ABCDEF")   #使用list函数可以将字符串转为列表
list((1, 2, 3))  #将元组转成列表
list(set([1, 2, 4 6, 2 , 3, 5, 4]))  #将set转成列表
list({"A":"a", "B":"b"})  #将字典的键转成列表

元组与列表不一样的地方在于元组内的元素是不可更改的。元组用圆括号表示。

(1,)   #注意在创建元组的时候，逗号是必须的
 
(1)
 
()    #创建一个空的元组的时候，确不需要逗号
 
1，
 
1，2，3  # 还能这样创建元组
 
tuple()   #使用tuple函数创建元组
 
tuple(1)
 
tuple([1])   
 
tuple([1,2,3])  #将一个列表转成元组
 
x = (1, 2, 3, 4, 6)
 
x[2:4]      #和列表一样的取值方式
 
x[2] = "a"   #元组的元素不可能更改

字典比列表更一般化，列表的索引可以是任何类型的值，不像列表那样局限于整数。字典中的索引称为键 (keys)，每个键最对应一个值（value），称为键值对（key-value pair），或者有时称为条目(item)。字典中的键必须是唯一的，不可变的，而值可以取任何数据类型，如字符串，数字或元组。

coord=dict()
coord
 
coord={}
coord
 
coord["name"]="Wh"  #增加条目
coord
 
coord={"name":"Wh", "what":"Lab"}
coord["what"]   #索引条目
 
len(coord)      #字典中的条目数
 
coord.values()  #所有的值
 
coord.keys()    #所有的键
 
coord.items()   #所有的条目，一个条目中的键和值放到一个元祖中
 
coord.clear()   #删除字典内所有元素
 
coord

集合(set)是一个无序不重复元素集。通常有来检验元素归属，去除重复，以及一些数学上的集合的运算。

{"a", "B", 1, 3, "a", 1}   #用花括号来创建一个set，可以看到，重复被去除，顺序也不保证
 
s = set(["a", "B", 1, 3, "a", 1])  #set()函数将列表转换成集合
 
s
 
len(s)
 
"a" in s   # 判断元素从属
 
"A" in s
 
"A" not in s 
 
y = {"A", "b", 2}
z = {"B", 3}
 
y <= s    #是否y中的元素都在s中，同样你可以知道 ==、<、 > 、 >= 的用法
z <= s
 
s^y      #在x或y且不同时在x和y中
 
s.union(y)         # 在s中或者y中的
s
s.intersection(y)  # 在s中且在y中的
s
s.difference(y)    # 在s中而不再y中的
s
s.update(y, z, {8, 9})
s
s.add(11)
s
s.add({12})  #报错，add只用来增加元素，而集合的元素不能是集合
 
s.remove(11)
s
 
s.pop()   #任意移除一个元素并返回。 注意，不是随机的。是怎么选择移除的元素的我也不知道
s.pop()
s.pop()
 
{"A", "B", "C"}.pop()
{"A", "B", "C"}.pop()
{"A", "B", "C"}.pop()
 
s.clear()  #移除所有的元素
s

迭代器(iterator)是指遍历一序列元素的对象，类似于列表，但是迭代器不是容器，不能通过索引取出它的元素，只能按顺序取出，取空了则不能再取了。

x=["A", "B", "C"]
y=iter(x)
y
 
for i in y:
    print(i)
 
for i in y:
    print(i)   #只能取一次
 
y=iter(x)
list(y)
list(y)     #只能转一次list
 
 
for i in x:
    print(i)
 
for i in x:
    print(i)

函数(Function)就是把一序列的指令放在一起，通过函数的名称就可以调用这一系列的指令，这些指令中的一些变量可以通过参数的形式传进去。

type(42)   #这里type就是函数，42是参数，输出是42的类型，其底层
 
int('32')  #字符转成整数
 
int('This sentence could not be a integer')  #句子不可能是一个数字，这样就不可能作为int的参数

def test():          #定义函数, 注意缩进，冒号
    print("Hi WhLab")
    n=2+3
    print(n)
 
test()
 
def add(a, b):      #包括参数的
    print("Do addition for you.")
    n=a+b
    print(str(a) +"+"+str(b) + "=" + str(n))
 
add(3, 4)
 
add(8, 7)

方法是一种特殊的函数，与特定对象对应，在值或者对象后边用点加函数来。方法是对象的属性之一。

"AA\tBB".split("\t")   # split就是一个方法， 将字符串按照分隔符分开
" AA\tBB\n".strip()    # 去掉首尾的空格，换行符等，或者指定的字符

map(f, list): 通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 。

def f(x):
    return x*x
 
map(f, [1, 2, 3])

reduce(f, List): 和 map()类似，但行为和 map不同，reduce传入的函数 f 必须接收两个参数，reduce对list的每个元素累积地调用函数f，也就是将结果当作第一个参数与下元素当作第二个元素进行运算，最终获得一个值。

def f(x, y):
    return x + y
 
reduce(f, [1, 3, 5, 7, 9])   #  ((((1+3)+5)+7)+9)
 
def f(x, y):
    return x**2 * y
 
reduce(f, [1, 2, 3, 4])
reduce(f, [4])     #当List中只有一个元素的时候返回这个元素
reduce(f, [1], 6)  #当提供第三个参数的时候，把第三个参数放在最前边进行运算

filter(f, List): filter以函数 f 的作用是对每个元素进行判断，根据判断结果自动过滤掉不符合条件的元素，返回由符合条件的元素组成的新list。

# 编写一个判断奇数的函数,然后用filter进行筛选
def is_odd(x):
    return x % 2 == 1
 
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])  #将不是奇数的过滤掉

产生整数等差数列列表或者range类型，在python2.x中返回一个list，在python3.x中返回的是一个range类型。 range类型占用更低的内存。无论返回的是一个列表还是一个range，一般使用的时候都是直接使用到for语句中。

range(10)         # range(stop), 从0开始
range(2, 5)       # range(start, stop[, step])  ， 从2到4，默认步长为1
range(2, 10, 3)   # range(start, stop[, step])  ， 指定步长为3
 
for i in range(10):
    print(i)
 
for i in range(2, 5):
    print(i)
 
for i in range(2, 10, 3):
    print(i)

对列表里的每个元素进行运算，结果依次返回存到一个新的列表里，这样的操作除了使用for语句以外，还能使用列表生成式。很显然，列表生成式更为方便。

# 比如，对0-10依次算平方，可以使用for语句，如下：
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y=[]
for n in x:
    result.append(n**2)
 
y
 
#也可以用上文中提到的map函数
def pf(x):    
    return(x*x)
 
map(pf, x)
 
# 另外就是使用列表生成式，如下
[n ** 2 for n in x]
 
"".join(x)  # 当list里边不全是字符型的时候，要join起来就会报错，这时候就可以使用列表生成式
 
"".join([str(i) for i in x])

生成器表达式类似于列表生产式，不同的是使用的是小括号，结果是一个生成器，生成器知道怎么去遍历一序列的值。生成器表达式和列表生成式不同，它并不会一下就计算所有的值，而是在需要的时候再计算。 生成器经常和sum、max、min这样的函数一起使用。

g = (x**x for x in range(5))
list(g)
list(g)  #遍历一遍之后就空了
 
g = (x**x for x in range(5))
next(g)
next(g)
next(g)
next(g)
next(g)
next(g)   #空了就报错了
 
g = (x**x for x in range(5))
for i in g:
    print(i)
 
g = (x**x for x in range(5))
sum(g)
max(g)   #用一次之后就不能再用了
 
sum((x**x for x in range(5)))
max((x**x for x in range(5)))
min(x**x for x in range(5))    #可以省略一对括号

查看现在工作空间里的对象。

dir()
 
new_object="This is a new string"
 
dir()  #可以看到，多了一个new_object

除了上边所说的一些内建(builtin)的函数以外，python可以使用一些其它模块里的函数，导入相应的包之后可以使用。导入模块

import os  # 导入os模块

dir()  #多了os

from os import *   #导入os模块里的所有对象，为了避免不同模块里的同名对象的相互干扰，一般不这么做

dir()  #多了很多的内容，大都是os里的函数名，现在可以直接调用了

os.system用来调用系统命令，是很常用的, os.chdir用来改变当前工作目录，os.getcwd用来查看当前工作目录。还有其它很多的函数，我个人来说最常用的os.system， 有了它就能使用系统的命令，其它的函数自然用得就少了。

import os   #导入os这个包，
os.system("ls")
os.system("pwd")   # 查看当前工作目录
PWD=os.getcwd()        # 查看当前工作目录
PWD
 
os.chdir("/home")   # 改变当前工作目录
os.system("pwd")    #
os.getcwd()
 
os.system("cd /")   # 并不会改变当前工作目录
os.system("pwd")
os.getcwd()
 
os.chdir(PWD)
 
os.listdir(".")   #列出当前路径的所有文件和文件夹，可以看出不似系统命令那么好用是吧

reversed用来将列表中的元素或者字符串中的字符倒序排列，返回一个迭代器，可以转成list。

x="ATCGATGCATGGCC"
X = reversed(x)
X
list(X)
list(X)                # 迭代器只能遍历一次
 
y=list(x)
y
Y=reversed(y)
Y
for i in Y:
    print(i)
 
for i in Y:
    print(i)    # 迭代器只能遍历一次
 
Z = list(reversed(x))       
for i in Z:
    print(i)
 
for i in Z:
    print(i)  #list可以这样用无数次
 
x
"".join(reversed(x))   #这样就可以将字符串颠倒了
 
# 对于列表，还有reverse方法可用
x.reverse()    #字符串没有这个方法
 
y
y.reverse()   
y

sorted可以用来对list里的元素进行排序，如果list里的元素是元祖或者列表，那么可以按照元祖或列表的某等几个元素进行sort。

x=[1, 4, 2, 5, 3]
y=[(1, 8, 18), (3, 6, 9), (2, 10, 8), (1, 2, 5)]
z=[[1, 8, 18], [3, 6, 9], [2, 10, 8], [1, 2, 5]]
 
 
sorted(x)
sorted(x, reverse=True)    #可以reverse参数可以倒过来排序
 
sorted(y)
sorted(y, key=lambda i:i[0], reverse=True)  #使用key来控制按第几个元素来排序
sorted(y, key=lambda i:i[1], reverse=True)
sorted(y, key=lambda i:i[2], reverse=True)
 
sorted(z)
sorted(z, key=lambda i:i[0])  #使用key来控制按第几个元素来排序
sorted(z, key=lambda i:i[1])
sorted(z, key=lambda i:i[2])
 
 
#另外还有sort方法可以使用
x.sort()
x
 
y.sort(key=lambda i:i[0], reverse=True)
y
 
# 如果要根据字典里的键或者值来进行对另一个进行排序，则使用items()方法做成元祖, 然后在排序后取出想要的值即可
d={"A":2, "B":5, "C":3, "D":1}
 
sorted(d.items(), key=lambda i:i[0])
 
sorted(d.items(), key=lambda i:i[1])
 
[i[1] for i in sorted(d.items(), key=lambda i:i[0])]
 
[i[0] for i in sorted(d.items(), key=lambda i:i[1])]

zip将两个列表里的元素依次一一对应存到一个元祖里，按顺序存到一个列表(python2.x)或者zip对象(python3.x)里，zip对象是一个迭代器。如果两个列表不等长，则到较短的一个完成为止。zip的一个很有用的用处在于可以根据一个list来sort另一个list。

x=["C", "A", "B", "D"]
y=[4, 1, 3, 2]
zip(x, y)   #python2.x返回一个list， python3.x返回一个zip对象
 
for i in zip(x, y):
    print(i)
 
dict(zip(x, y))   # 可以这样转成字典
 
[b for a,b in sorted(zip(x,y))]  # 根据x来sort y
[y for x,y in sorted(zip(y,x))]  # 根据y来sort x

对一系列的数值依次执行，试一下如下两个例子

for i in ["a", "b", "c"]:
    i

for i in range(10):
    print(i)
    i+=2

执行直到不再满足条件，尝试如下几个例子：

i=1
while i < 10:
    print(i)
    i += 1

i=1
while i < 10:
    print(i)
    i += 3

i=1
while i < 10:
    print(i)

进入死循环了，使用Ctrl + C终止。

试一下如下两个例子

i = 5
if i < 4:
    print("A")
elif i < 10:
    print("B")
else:
    pirnt("C")

for i in range(10):
    if i < 4:
        print("A")
    elif i < 8:
        print("B")
    else:
        print("C")

可以只有if部分

elif即为 else if ，可以没有elif这一部分， 也可以连续有多个。

# 我们先来尝试写一个文件作为示例, 这里使用的是with语句的用法，这个用法的好处在于可以不用考虑关闭文件的问题。
with open("test1.txt", "w") as f:
    f.write('''>seq1
ATGCTGGTAGCTAGTAC
GCTAGTCAATGGCCTAG
TCGAC
>seq2
ATGCTGGTAGCTCCTAGTCGAC
GCTAGTCAATGGAGTAC
''')
 
import os     #导入os模块
os.system("cat test1.txt")  #使用系统命令， 最后一行的0是命令执行的状态，不是文件内容
os.system("head -n 5 test1.txt")  
 
#我们再逐行读入，然后把它打印到屏幕
with open("test1.txt", "r") as f:
    for line in f:
        print(line)   
 
 
with open("test1.txt", "r") as f:
    for line in f:
        print(line.strip())   #strip掉line后边的换行符\n
 
f.closed      # 用来判断是否关闭了， 可以看到，不用可以去关闭f
 
# 除了with语句以外，还可以这样
f1=open("test1.txt", "r") 
for line in f1:
    print(line.strip())
 
for line in f1:
    print(line.strip())  #第二次再用就没了，上一次打开读取的时候已经读到文末了
 
f1.close()    #读写之后要记得关闭
 
f1=open("test1.txt", "r") 
f2=open("test2.txt", "w") 
for line in f2:     
    print(line.strip())  #报错，因为f2是打开来写而不是读的
 
for line in f1:
    f2.write(line)
 
f1.close()    
 
f3=open("test2.txt", "r") 
for line in f3:     
    print(line.strip())   #f2还没有关闭的时候test2.txt 还是空的
 
f3.close()
 
f2.closed    # f2还没关
 
f2.close()  
 
f2.closed    # f2已经管理
 
f3=open("test2.txt", "r") 
for line in f3:     
    print(line.strip())  #f2关闭之后就可以读取了
 
f3.closed()
 
f1=open("test1.txt", "r") 
f1.read()     # 全部读入
f1.close()    # 读写之后要记得关闭
 
f1=open("test1.txt", "r") 
f1.readline()     # 每次读一行
f1.tell()
f1.readline()     
f1.tell()
f1.readline()     
f1.tell()
 
f1.close()    # 读写之后要记得关闭

fasta格式的文件如下

test.fa

>1
AATCGACGCCACACGCAGGGACCTGCTCCATATCTGAACCAGTTCCGAGCTGCATCTGGG
GCAATCCTTTCTCTCCTATACGGGTCAGGATCCAGGGATTGCACCTGCCGGTTCATTCCA
GTCATCTTTTCTAGGTCATCGGA
>2
ATGTAGCCACGACGGGATTTCCTCACAACGTCATTTTCATGCCTGCTGGAAGTTTAGTTC
TTGTTCTAGGTCATCGGAGCATCAGCCCAGTCATCTTGTTT

以>开头的为注释行，第一个空格前的为ID。 接下来的在下一个>出现之前的序列都属于这一条序列。而接下来的序列可能分许多行，因此在读入fasta的时候不能简单地通过奇偶行来判断。

这里的方法读入fasta文件的逻辑是，当遇到>的时候，将这一行存为ID，时建立一个位置类存放序列，往后遇到的序列都连接到这个位置即可。

IDs=[]              # 建立一个空的列表来存放ID
Seqs=[]             # 建立一个空的列表来存放Seqs
for line in open("test.fa", "r"):
    Line=line.strip()                   # 去掉换行符，首尾可能存在的空格等
    if Line.startswith(">"):            
        IDs.append(Line.strip(">"))      # 如果以>开头，则存到
        Seqs.append("")                  # 同时在Seqs里边增加一个元素，这个元素是空的
    else:                                # 这里可以用elif len(Seqs) > 0 以免有的fasta第一行不是以 > 开头的, 不过那种情况还没遇到过
        Seqs[-1] += Line                 # 否则把这一接到最后的一个Seqs元素上，因为每次遇到>都会新增Seqs的元素，所以每次都是针对最后一个来进行即可

以上这个样就可以简单地把一个fasta文件的ID和序列读到两个列表里，顺序是对应的，只要按照顺序处理就可以对应ID和处理的结果。 另外，基于上边的这种思路，也可以逐条序列处理之后输出，不用存在内存，甚至可以逐行进行处理。

也可以试用BioPython的一些函数来处理fasta文件，这里不多说，感兴趣的搜索一下即可知如何用。

from Bio import SeqIO

这一节的命令在shell中执行，带文件名的代码块存储到当前工作目录下使用。

我们也可以把所有的代码放到一个文件中，作为一个脚本来运行。比如,把下边这部分代码保存为test1.py文件：

test1.py

print("Hi Wh")
print("Hi Lab")

那么我们就能这样来执行：

python test1.py

脚本的好处就是我们可以很容易地反复地使用，有时候我们可能需要做些改变，比如让它处理不同的文件等等的，这时候，就可以把脚本中的一些变量以参数的形式传递进去。

test2.py

import sys            
person1=sys.argv[1]    
person2=sys.argv[2]    
 
print("Hi %s" %(person1))
Print("Hi %s" %(person2))

那么我们就能这样来执行：

python test2.py  Lab  Wh

test3.py

# _*_ coding:utf-8 _*_      #当脚本有汉字的时候，需要加上这一行
import argparse      #导入argparse
parser = argparse.ArgumentParser(prog = "test3.py", description="随便说点啥都行，包括不说") 
parser.add_argument('--person1', required=True, help='''说明''')  #添加参数，。
parser.add_argument('--person2', required=True, help='''说明''')  #添加参数，。
argv = parser.parse_args()   #参数传递到 argv对象中
person1=argv.person1  # 取出参数来用
 
print("Hi %s" %(person1))
print("Hi %s" %(argv.person2))   #也可以这么用

那么我们就能这样来执行：

python test3.py --person1 Wh --person2 Lab
 
python test3.py --person2 Wh --person1 Lab

可以看到，这样顺序是不影响的。 当参数很多的时候，就可以这样，每个参数都有一个名字，这样就不会乱了。

我们可以将脚本变成可执行的形式，这样可以直接调用，只需要在第一行指明解释器。第一行#! 后边的内容通过如下命令获取:

which python

test4.py

#!/bin/python
print("Hi Wh")
print("Hi Lab")

那么我们将这个文件增加可执行权限

chmod +x test4.py   #转换成可执行的

然后就能执行了：

./test4.py

我们还能将这个文件所在的目录添加到PATH变量中

export PATH=`pwd`:$PATH

然后可以直接调用

test4.py

本网页已被访问10678次；最后编辑时间(Last modified)： 2020/07/27 16:23