cndaqiang Web Linux DFT

python(一)基本语法

2017-09-28
cndaqiang
RSS

2019-05-13重构文章

参考

简明python教程

Python 基础教程-菜鸟教程

Python3教程-菜鸟教程

Python转义字符

环境

Ubuntu 16.04.1 LTS (GNU/Linux 4.4.0-53-generic x86_64)

Python 3.5.2 (default, Jul 5 2016, 12:43:10)

[GCC 5.4.0 20160609] on linux

python简介

注意

  • python2与python3很多命令用法不一样,运行报错,可能是教程针对的版本不一样
  • python执行实时输出信息到屏幕python -u xxx.py
  • 不要把py脚本的名称命名为模块的名字,会影响在当前目录倒入相关模块

python文件

  • ubuntu 16.04 上python版本 apt-get install python安装2.7.11 apt-get install python3安装3.5.1 运行python时 pythonpython2都表示python2 python3才是python3
  • 拓展名.py
  • python3支持utf8可以支持中文,直接printf("你好"),python2需要在开头加入# -*- coding: UTF-8 -*- 或者 #coding=utf-8

1. 编写

  • 脚本式编程 编写 hello.py文件 运行
    $ python3 hello.py
    
  • 类似bash,参考20170805bash学习 vi hello.py 填入
    #!/usr/bin/python3
    print("hello");
    

    更推荐首行写为#!/usr/bin/env python3 添加执行权限,运行

    chmod +x hello.py
    ./hello.py
    
  • 在python解释器中运行,例
    $ python3
    Python 3.5.2 (default, Jul  5 2016, 12:43:10) 
    [GCC 5.4.0 20160609] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> print("hello")
    hello
    >>> exit()
    $ 
    
  • 使用IDE PyCharm 教育版

2. 格式

2.1 代码块

Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。 缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量(同级别的代码块,前面必须缩进相同

例如 错误缩进

print("hello")
 print("你好")

同一级别,缩进不同,报错

  File "hi.py", line 2
    print("你好")
    ^
IndentationError: unexpected indent

缩进相同的一组语句构成一个代码块,我们称之代码组。 像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。 我们将首行及后面的代码组称为一个子句(clause)。

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

2.2 多行语句

使用反斜杠\实现多行语句

total = one + \
        two + 
        three

[], {}, 或 () 中的多行语句,不需要使用反斜杠\ 需要回头重新写此处,缩进

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

2.3 代码分隔符

一行一条语句不需要代码分隔符,有也可以 一行多个语句,中间用代码分隔符;隔开

2.2 注释

单行注释
#单行注释
多行注释

单引号'多引号"

'''
多行注释
多行注释
多行注释
'''

"""
多行注释
多行注释
多行注释
"""

3. 标识符

与其他语言类似,字母数字下划线,不能数字开头,区分呢大小写

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入; 以双下划线开头的 __foo 代表类的私有成员;以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数。

查看保留字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量,类,对象的关系

Python程序中的任何内容都为对象,1也是一个对象,它属于int

>>> type(1)
<class 'int'>

变量更像是一个指针,当被赋予新值时,指向新的对象,我们所说的”类型”是变量所指的内存中对象, 变量可以用于调用对应类定义的方法和属性.如

>>> a=1
>>> type(a)
<class 'int'>
>>> a.
a.bit_length(  a.denominator  a.imag         a.real         
a.conjugate(   a.from_bytes(  a.numerator    a.to_bytes(
>>> a.real #这里就体现出和其他语言不一样的地方,a指向一个整型类的对象
1

有些对象(如数组,字符串,列表等类定义的对象)可以通过[]使用对象的内部元素,类似matlab的随用随赋值

常用的命令

  • type()输出数据的类
  • print()输出显示
  • 变量=对象 声明/赋值变量

数字number类

长整数 int

>>> type(1)
<class 'int'>

浮点数 float

1.2,3e5(3*10^5)

复数 complex

5+3.4j
complex(5,3.4)

复数求共轭

>>> a=1+2j
>>> a.conjugate()
(1-2j)

布尔 bool

True,False

字符串string

python中没有char类型

定义

Python中的字符串用单引号'或双引号"括起来,同时使用反斜杠\转义特殊字符 多行字符串用'''或者"""之间包含多行字符串,三个单/双引号内可自由的使用一个单/双引号 如

>>> print("hello"+'word')
helloword
>>> str='''zheshi
... kejf
... fe3f
... '''
>>> str
'zheshi\nkejf\nfe3f\n'

字符串索引

Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始,下述下标就是索引数字

str[下标]

str[头下标:尾下标]

str[头下标:]表示从头下标到所有

非常奇怪的地方

str[n:m]表示下标n到下标m-1截取(注,下标从0开始)

如图

例,

>>> str="123454321"
>>> str[0]
'1'
>>> str[1]
'2'
>>> str[-1]
'1'
>>> str[0:1]
'1'
>>> str[0:2]
'12'
>>> str[0:-1]
'12345432'

字符串连接+

字符串1+字符串2

字符串复制*

字符串*[次数] 次数不能省略

>>> print('字符串'+'连接'+'复制'*5)
字符串连接复制复制复制复制复制

转义字符

使用反斜杠\进行转义,不希望转义时在字符转前加r表示初始字符 例

>>> print('转义\n'+r'不专义\n')
转义
不专义\n

例如\在行尾时可以回车继续写

>>> print('zhunayi\
... hello')
zhunayihello

字符串元素不能被改变

>>> str='hello'
>>> str='word'
>>> str[1]='y'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

字符串操作

字符串分割

str.split("分隔符", 分裂次数)
>>> a="21314151617"
>>> a.split("1", 2)
['2', '3', '4151617']
>>> a.split("1", -1)
['2', '3', '4', '5', '6', '7']
  • 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等。
  • 分割次数。默认为 -1, 即分隔所有。

替换

>>> a.replace("1","A")
'2A3A4A5A6A7'

使用多个字符串进行分割

>>> line='TDTimeStep=0.002/eV     #\hbar/eV  0.001*0.658211951 = 0.000658211951'
>>> import re
>>> re.split('=|#',line)
['TDTimeStep', '0.002/eV     ', '\\hbar/eV  0.001*0.658211951 ', ' 0.000658211951']

删除空白字符

>>> a=' hello \t \n'
#删除首位空白字符
>>> a.strip()
'hello'
>>> a.replace(' ','')
'hello\t\n'

列表list

列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号[]之间、用逗号分隔开的元素列表。

定义

>>> list=['hello','word',1,3.6,5+6j]

索引,连接,复制,换行

类似字符串,

也有那个奇怪的现象,list[2:3]表示从下标2到下标(3-1)个(下标从0开始),而list[2:2]则为空 例

>>> list=[1,2,3,4,5,6,7,8]
>>> print(list[0:3]+list*2)
[1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8]

注意: list[n]表示list中的某元素,类型如果不是list时不能使用+与list类型连接,如int和list无法连接

>>> print(list[0]+list*2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'list' 

反斜线代表换行,不过在[],(),{}内的换行,不用\也可以

>>> list=[3,5,6 \
... ,7]
>>> list
[3, 5, 6, 7]

list元素可修改

与字符串不同

#在最后增加元素
>>> list.append(9)
>>> list
[6, 4, 5, 6, 7, 8, 9]
#修改
>>> list[2]=6
>>> list[0:2]=[1,2]
#删除指定下标元素
>>> list[0:2]=[]
>>> list
[6, 4, 5, 6, 7, 8]
>>> del list[0:3]
#删除最后一个元素
>>> list.pop()
#删除内容为xxx的元素
>>> list.remove(xxx)

元组Tuple

与列表类似,不同之处在于元组的元素不能修改。元组写在小括号()里,元素之间用逗号隔开

定义

tup=(值,值)
tup= 值,值  #可以不加括号表示元组

元组在输出时总是有括号的,以便于正确表达嵌套结构。在输入时可能有或没有括号, 不过括号通常是必须的(如果元组是更大的表达式的一部分)

类似: 使用,索引,复制,连接 类似list

不同

不能修改元素

构造包含 0 个或 1 个元素的元组,有一些额外的语法规则:

>>> tup = ()     # 空元组
>>> tup1 = (1)    # 一个元素
>>> tup2 = (1,) # 一个元素,需要在元素后添加逗号
>>> tup1
1
>>> tup2
(1,)

集合 set

无序不重复元素的序列,所以不支持索引

基本功能是进行成员关系测试和删除重复元素 使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典

  • list与tuple可以互相嵌套,list,tuple也可包含集合set,但是set不可以包含list和tuple

定义/声明

>>> set0={1,3,'rt'}
>>> set1=set()  #空集

set()用法需要再学习

应用

#判断元素是否存在,存在返回True
x in set
#交并补
a - b     # a和b的差集
a | b     # a和b的并集
a & b     # a和b的交集
a ^ b     # a和b中不同时存在的元素

字典 dictionary

字典类似php中数组可以用key:value的形式,只不过python里的字典是无序的

列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。 字典是一种映射类型,字典用{ }标识,它是一个无序的键(key) : 值(value)对集合。 键(key)必须使用不可变类型(字符串,数字)。 在同一个字典中,键(key)必须是唯一的

字典定义/声明

{}用于定义空字典 {key:value,key:value}

>>> dic={}
#修改或添加
>>> dic['name']='xiaoming'
>>> dic[1]=11
>>> dic
{1: 11, 'name': 'xiaoming'}
>>> dic={'name':'cndaqiang','site':'blog','num':123456}
>>> dic.keys()
dic_keys(['name', 'site', 'num'])
>>> dic.values()
dic_values(['cndaqiang', 'blog', 123456])
>>> dic.items()
[('num', 123456), ('name', 'cndaqiang'), ('site', 'blog')]
#判断
>>> dic.has_key('name')
True
# 字典长度
len(dict)


#删除元素
del dic[key]
#删除字典(dic变量被清除)
del dic
#清空字典(dic变量还在)
dic.clear()

对比

类型 有序 引用元素 [] 修改元素 元素类型 定义示例 备注
字符串string 索引下标 × 字符(串) str0='string'  
列表list 索引下标 任意组合 list0=[1,2,'3']  
元组tuple 索引下标 × 任意组合 tup0=(1,2,'3')  
集合set × 不包含list,tuple,dict set0={1,2,'3'} {}用于定义空字典,set()为空集合
字典dict × key 任意组合 dict0={1:1,'2':2,3:'3'}  

类class

也可以把一个数据集存在class里面,见python(三)对象

类型转换

python各种类型转换-int,str,char,float,ord,hex,oct等

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  
#![](http://blog.cndaqiang.online/wp-content/uploads/2017/09/270b71679767300e9bfcef83efc2cbe4.png)

指定整数转为字符串后的小数点位数

str(round(1.2345,2))

变量

变量

Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

  • 变量的赋值就是指向某一对象的地址,变量更像一个指针/地址,指向被赋值的对象

例如:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a,

  • b=a 表示把a的对象(指针)传给b,即b和a指向相同的地址,例
    >>> a=[1,2,3]
    >>> b=a
    >>> a[2]=4 #使用a[]改变对象中的内容
    >>> a=1  #a被指派新对象的地址
    >>> b
    [1, 2, 4]
    >>> a
    1
    
  • 字符串,列表,元组,集合,字典等类型,必须先定义,至少定义为空(分配对象/地址),不然变量没有指向的对象(或者说,没有指向的地址,怎么调用/赋值),才能继续使用内部元素
  • 数组类元素为数组时,也是指针,改变指针指向的值,数组也会变,如
    >>> a=[1,2,3]
    >>> b=['a','b','c']
    >>> c=a,b
    >>> c
    ([1, 2, 3], ['a', 'b', 'c'])
    >>> a[:]=[]
    >>> c
    ([], ['a', 'b', 'c'])
    

变量定义/声明

a=4
#多变量可以这样一次定义
a=b=c=d=5
#变量依次复制
a,b,c=1,3,'char'

变量的使用

直接使用变量名

print(a)

指向数组型(字符串,列表,元组,集合,字典等)对象的变量 详见对象的数据类型

运算

算术运算

运算符 描述 备注
+  
-  
*  
/  
% 取余  
**  
// 除完取整 9.0//2结果为4.0 ,9//2结果为4
>>> a=10
>>> b=3
>>> a/b
3.3333333333333335
>>> a%b
1
>>> a**b
1000
>>> a//b
3

取整

#向下取整
>>> int(0.9)
0
#四舍五入
>>> round(0.9)
1
>>> round(0.4)
0

赋值运算

运算符 描述 备注
= 等于  
+= c+=a等价于c=c+a
以下同理,略
 
-=    
*=    
/=    
**=    
//=    

比较

成立返回True,不成立返回False

运算符 描述 备注
== 等于  
!= 不等于  
> 大于  
< 小于  
>= 大于等于  
<= 小于等于  

逻辑运算符

运算符 描述 备注
and a and b ,如果a=0/False 返回False,如果a=非0/True,返回b(即b=False返回False,b为其他值,返回b的值)
or a or ba为True,返回a的值,否则返回b的值(即b=False返回False,b为其他值,返回b的值)
not not ( a and b ) ,返回True/False

位运算符

运算符 描述 实例(a=0b111100,b=0b1101)
& 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ,二进制解释: 0000 1100
按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (ab) 输出结果 61 ,二进制解释: 0011 1101
^ 按位异或运算符:当两对应的二进位相异时,结果为1 (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
~ 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
« 左移动运算符:运算数的各二进位全部左移若干位,由”«“右边的数指定移动的位数,高位丢弃,低位补0。 a « 2 输出结果 240 ,二进制解释: 1111 0000
» 右移动运算符:把”»“左边的运算数的各二进位全部右移若干位,”»“右边的数指定移动的位数 a » 2 输出结果 15 ,二进制解释: 0000 111

>>> a=60
>>> bin(a)
'0b111100'
>>> b=13
>>> bin(b)
'0b1101'
>>> bin(a^b)
'0b110001'
>>> a^b
49

成员运算符

测试实例中包含了一系列的成员,包括字符串,列表或元组

运算符 描述 备注
in 如果在指定的序列中找到值返回 True,否则返回 False  
not in 如果在指定的序列中没有找到值返回 True,否则返回 False  

身份运算符

身份运算符用于比较两个对象的存储单元 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False

即指向同一对象为True,不同对象为False

运算符 描述 备注
is is 是判断两个标识符是不是引用自一个对象  
is not is not 是判断两个标识符是不是引用自不同对象  
>>> a=[1,2,3]
>>> b=[1,2,3]
>>> c=a #把a的指向赋予c
>>> d=a[:] #把a的值传给d,等价于新建了个和a指向对象一样的对象并让d指向新对象
>>> a is b
False
>>> a is c
True
>>> a is d
False
>>> d
[1, 2, 3]

运算符优先级

先略

流程控制

  • 注意缩进

条件 if elif else

  • 注意缩进
  • python中无switch条件
  • if可以缩进嵌套
  • 简短可以 if 条件1:语句
  • if (条件):也可以,这样比Fortran就多一个:更好记
    if 条件1:
      语句1
      语句2
      语句3
    elif 条件2:
      语句1
      语句2
    else:
      语句1
      语句2
    

python3.10之前没有提供case类的语法

In Python 3.10, they introduced the pattern matching.

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

循环

while

while 条件判断:
	循环语句

while else

while 条件判断:
	循环语句
else:
	while条件为false执行语句

当循环体中只有一条语句时

while 条件判断:循环语句

for

for x in 数列:
	循环语句

也可以像while那样,加个else,或者一行写语句
只有一个循环语句时可以

for x in 数列: 循环语句
for i in range(0,5):print(i)

另一种常用操作产生一组数据,可以嵌套使用

[ 操作 for x in 数列  ]
files=[ i[:-1] for i in files] #去掉结尾的"\n"

break 跳出循环

之后有else语句也不糊被执行

continue 进入下一个循环

pass 不做任何事情,空语句,自动执行下一个

可以使用循环中只有pass且无限循环来等待ctrl+c 打断 例 while True:pass

函数

  • 先定义后使用 为了方便阅读,可以变相的把主干写在开头,如
    def main()
      fun1()
    def fun1()
      函数体
    main()
    

定义

def 函数名():
	函数体

函数体结构比def要小,所以前面至少有一个空格缩进

  • return 表达式用于返回值,可以省略

调用

函数名()

参数传递

  • 类型属于对象,变量是没有类型的,所以传参数时不能指定类型
  • python 中一切都是对象,严格意义我们不能说值传递还是引用传递(类似c中传递地址)

传递数组,如果函数内改变了数组,那么函数之外这个数组也会被改变
所以用numpy的copy来复制数组而不是赋值

   time=time[skip:].copy()
   yvalue=yvalue_in[skip:,:].copy()

可更改与不可更改对象/传值&传址

在 python 中,数字numbers,字符串strings, 元组tuples是不可更改的对象,而 列表list,字典 dict 等则是可以修改的对象。

  • 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a
    传递不可变类型对象的变量等价于c语言中的传值,在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的对象的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了
    传递可变类型对象的变量等价于c中的传址在fun(la)内修改了la内元素,则函数外la也改变,如果在函数内la指向新对象,则外面la不变(就是传址嘛,地址改变了,原来地址内容肯定不受影响)

传递参数的方式

必须参数

就是正常的传递参数,所有参数按照定义的顺序一个不少的传入

def bixu(str,num):
	print(str,num)
bixu('hello',123)
关键字参数

在传递时,指明fun(参数1=值1,参数2=值2),因此不需要按照顺序

def bixu(str,num):
	print(str,num)
bixu(num=123,str='hello') #关键字参数,不需指定顺序
默认参数

定义时赋值作为默认参数 默认参数必须放在最后,不然报错

    def bixu(str='hello',num):
            ^
SyntaxError: non-default argument follows default argument

正常例


def bixu(num,str='hello'):
	print(str,num)
bixu(123)

不定长参数

函数能处理比当初声明时更多的参数。这些参数叫做不定长参数 用*变量名指代不定长参数,传入一个元组

def bixu(num,str,*wuming): #不定长参数wuming
	print(str,num)
	for x in wuming:  #调用不定长参数wuming中的元素
		print('\n',x)
bixu(123,'hello',4,'word')

匿名函数

使用lambda函数体只能有一条语句 也支持关键字传参,默认参数

函数名=lambda 参数1,参数2,参数。。。:只能一条语句

bixu=lambda num,str:print(num,str)
bixu(123,'ss')

变量作用范围

Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的

作用域

  • L (Local) 局部作用域 // 函数等作用域内定义改变
  • E (Enclosing) 闭包函数外的函数中 //函数嵌套时子函数外,父函数里,用nonlocal声明
  • G (Global) 全局作用域 // 全局,在局部用 blobal声明
  • B (Built-in) 内建作用域 //我觉得和定义与全局一样,只不过局部未使用global声明

优先级 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找,

关于global和nonlocal

按照优先级调用变量,无须使用global和nonlocal,只有在局域调用并且希望改变时上级作用域时才使用global和nonlocal

也就是说函数里的函数不做任何处理的情况下可以按照 L –> E –> G –>B 的优先级调用变量,而一旦在局域内定义或修改了某一变量则为局部与变量,只会调用局部的不会调用上级的

如果要在局部改变上级作用域的变量值要用global或者nonlocal来声明

g_quan=2
b_nei='word'
def fun():
 l_local='hello' #局部变量
 global g_quan  #全局变量可更改
 print(g_quan,l_local,b_nei) #未global,则b_nei为内建变量,可以直接调用
 g_quan=3
fun()
print(g_quan)

结果

2 hello word
3

其他 代码段被执行的区块,定义变量才有效,即if 内的变量定义,只有if 成立被执行,相应定义才有效

常用函数

有趣

脚本输入参数

import sys
print("输入参数个数",len(sys.argv))
print("输入参数",sys.argv)

运行

cndaqiang@girl:~/work/dfft-yimin$ ./simple_plot.py 1 2 34 
输入参数个数 4
输入参数 ['./simple_plot.py', '1', '2', '34']

ls 查看文件

import os
files=os.popen("ls ").readlines()
files=[ i[:-1] for i in files] #去掉结尾的"\n"
print(file)

输出

['cndaqiang', 'data', 'lost+found', 'windows']

python脚本常用开头

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@Time    : 2020-09-03 @IOP
@Author  : cndaqiang
@Blog    : cndaqiang.github.io
@File    : LrTDDFT光谱画图
"""

import sys
import os

#-----Input File
if len(sys.argv) > 1:
    inputfile = str(sys.argv[1])
else:
    inputfile = "./spectrum.dat"
if os.path.exists(inputfile):
    print("read from",inputfile)
else:
    print("EXIT: There are not "+inputfile)
    exit()
if len(sys.argv) > 2:
    method=str(sys.argv[2])
else:
    method=""
if os.path.exists("parameter"):
    with open("parameter",'r') as f:
        para=f.readline()
        dumpling=float(para)
else:
        dumpling=None

当使用并行命令行调用时mpiexec -n 8 gpaw python ./Lr-TDDFT.py第0个参数仍是./Lr-TDDFT.py

读入参数

import sys
para_len=len(sys.argv)
i=1
p_help=[ '-h','-help']
p_dt=['-dt']
p_win=['-win']
#default value
dt=1.0
win="None"
#input value
while i < para_len :
   para=str(sys.argv[i])
   if para in p_help:
      print("HELP")
      print(" -dt [dt] \t .{def: 1.0} ")
      print(" -win [win] possible value cos, \t .{def: None} ")
      exit
   elif para in p_dt:
      dt=float(sys.argv[i+1])
   elif para in p_win:
      win=str(sys.argv[i+1])
   else:
      pass
   i=i+1

print(dt,win)

报错

py脚本名和模块名冲突

重命名当前文件夹下面的脚本命即可

    from ase import Atoms
ImportError: cannot import name 'Atoms' from 'ase' (/home/data/work/gpaw/learn/ase.py)

本文首发于我的博客@cndaqiang.
本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!



评论


广告

目录

广告
访客数据