cndaqiang Web Linux DFT

python(一)基本语法

2017-09-28
cndaqiang
Python
RSS
Star

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时 python和python2都表示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')

不过通常采用的不定长参数名都是args,另外指定了名字的变量在调用时要放在最后
参考致谢:Python中的*args和**kwargs

  • *args 不指定变量名的参数
  • **kwargs指定了变量名的参数
def test_kwargs(first, *args, **kwargs):
    print("必须传入参数first",first)
    print("args类型",type(args))
    print("kwargs类型",type(kwargs)) 
    print(args)
    print(kwargs)

test_kwargs(1234,567,890,a=2,b=1,c=3)

结果

必须传入参数first 1234
args类型 <class 'tuple'>
kwargs类型 <class 'dict'>
(567, 890)
{'a': 2, 'b': 1, 'c': 3}

而且这些参数可以继续传递下去, 如

@_copy_docstring_and_deprecators(Axes.plot)
def plot(*args, scalex=True, scaley=True, data=None, **kwargs):
    return gca().plot(
        *args, scalex=scalex, scaley=scaley,
        **({"data": data} if data is not None else {}), **kwargs)

匿名函数

使用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)

查看源代码

import inspect
print(inspect.getsource(plt.plot))

显示

@_copy_docstring_and_deprecators(Axes.plot)
def plot(*args, scalex=True, scaley=True, data=None, **kwargs):
    return gca().plot(
        *args, scalex=scalex, scaley=scaley,
        **({"data": data} if data is not None else {}), **kwargs)

报错

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 协议 ，转载请注明出处！

上一篇 openvz增加swap分区

下一篇 Ubuntu创建sudo用户

评论

广告

目录

广告
访客数据