本文目录一览:
- 1、Python协程之asyncio
- 2、python类和函数的区别
- 3、python语言abaqus子程序,这一步A=[(x1,y1,z1),出现SyntaxError: invalid syntax错误,怎么修改,谢
- 4、Python其实很简单 第十二章 函数与变量的作用域
- 5、python语言abaqus子程序报错,如何修改
- 6、Re:python 子程序怎么调用上一层程序生成
Python协程之asyncio
asyncio 是 Python 中的异步IO库,用来编写并发协程,适用于IO阻塞且需要大量并发的场景,例如爬虫、文件读写。
asyncio 在 Python3.4 被引入,经过几个版本的迭代,特性、语法糖均有了不同程度的改进,这也使得不同版本的 Python 在 asyncio 的用法上各不相同,显得有些杂乱,以前使用的时候也是本着能用就行的原则,在写法上走了一些弯路,现在对 Python3.7+ 和 Python3.6 中 asyncio 的用法做一个梳理,以便以后能更好的使用。
协程,又称微线程,它不被操作系统内核所管理,而完全是由程序控制,协程切换花销小,因而有更高的性能。
协程可以比作子程序,不同的是,执行过程中协程可以挂起当前状态,转而执行其他协程,在适当的时候返回来接着执行,协程间的切换不需要涉及任何系统调用或任何阻塞调用,完全由协程调度器进行调度。
Python 中以 asyncio 为依赖,使用 async/await 语法进行协程的创建和使用,如下 async 语法创建一个协程函数:
在协程中除了普通函数的功能外最主要的作用就是:使用 await 语法等待另一个协程结束,这将挂起当前协程,直到另一个协程产生结果再继续执行:
asyncio.sleep() 是 asyncio 包内置的协程函数,这里模拟耗时的IO操作,上面这个协程执行到这一句会挂起当前协程而去执行其他协程,直到sleep结束,当有多个协程任务时,这种切换会让它们的IO操作并行处理。
注意,执行一个协程函数并不会真正的运行它,而是会返回一个协程对象,要使协程真正的运行,需要将它们加入到事件循环中运行,官方建议 asyncio 程序应当有一个主入口协程,用来管理所有其他的协程任务:
在 Python3.7+ 中,运行这个 asyncio 程序只需要一句: asyncio.run(main()) ,而在 Python3.6 中,需要手动获取事件循环并加入协程任务:
事件循环就是一个循环队列,对其中的协程进行调度执行,当把一个协程加入循环,这个协程创建的其他协程都会自动加入到当前事件循环中。
其实协程对象也不是直接运行,而是被封装成一个个待执行的 Task ,大多数情况下 asyncio 会帮我们进行封装,我们也可以提前自行封装 Task 来获得对协程更多的控制权,注意,封装 Task 需要 当前线程有正在运行的事件循环 ,否则将引 RuntimeError,这也就是官方建议使用主入口协程的原因,如果在主入口协程之外创建任务就需要先手动获取事件循环然后使用底层方法 loop.create_task() ,而在主入口协程之内是一定有正在运行的循环的。任务创建后便有了状态,可以查看运行情况,查看结果,取消任务等:
asyncio.create_task() 是 Python3.7 加入的高层级API,在 Python3.6,需要使用低层级API asyncio.ensure_future() 来创建 Future,Future 也是一个管理协程运行状态的对象,与 Task 没有本质上的区别。
通常,一个含有一系列并发协程的程序写法如下(Python3.7+):
并发运行多个协程任务的关键就是 asyncio.gather(*tasks) ,它接受多个协程任务并将它们加入到事件循环,所有任务都运行完成后会返回结果列表,这里我们也没有手动封装 Task,因为 gather 函数会自动封装。
并发运行还有另一个方法 asyncio.wait(tasks) ,它们的区别是:
python类和函数的区别
一、主体不同
1、类:是面向对象程序设计实现信息封装的基础。
2、函数:是指一段在一起的、可以做某一件事儿的程序。也叫做子程序、(OOP中)方法。
二、特点不同
1、类:是一种用户定义的引用数据类型,也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
2、函数:分为全局函数、全局静态函数;在类中还可以定义构造函数、析构函数、拷贝构造函数、成员函数、友元函数、运算符重载函数、内联函数等。
三、规则不同
1、类:实质是一种引用数据类型,类似于byte、short、int(char)、long、float、double等基本数据类型,不同的是它是一种复杂的数据类型。
2、函数:函数必须声明后才可以被调用。调用格式为:函数名(实参)调用时函数名后的小括号中的实参必须和声明函数时的函数括号中的形参个数相同。
参考资料来源:百度百科-函数
参考资料来源:百度百科-类
python语言abaqus子程序,这一步A=[(x1,y1,z1),出现SyntaxError: invalid syntax错误,怎么修改,谢
看起来好复杂哦,干嘛不用class呢
#!/usr/bin/env python3
from random import *
from math import *
class Point3d:
def __init__(self):
self.x=uniform(0,10)
self.y=uniform(0,10)
self.z=uniform(0,10)
def __str__(self):
return '(%8g,%8g,%8g)' % (self.x,self.y,self.z)
def distance(self,B):
return sqrt((self.x-B.x)**2+(self.y-B.y)**2+(self.z-B.z)**2)
A=[Point3d()]
for i in range(1,10):
flag=True
while(flag):
B=Point3d()
ge2=True
for j in range(0,i):
if B.distance(A[j])2:
j=i
ge2=False
if ge2:
A.append(B)
flag=False
for i in range(len(A)-1):
print('point%d=%s,distance to %d=%g' % (i+1,A[i],(i+2)%10,A[i].distance(A[(i+1)%10])))
运行结果:
[willie@localhost zhidao]$ python3 point3d.py
point1=( 8.84149, 6.62191, 3.39638),distance to 2=6.32398
point2=( 7.1735, 8.88263, 9.06204),distance to 3=8.93643
point3=( 7.87404, 4.81449, 1.13618),distance to 4=10.2808
point4=(0.482862, 4.94775, 8.281),distance to 5=2.0724
point5=( 1.82308, 5.87645, 9.56013),distance to 6=10.7415
point6=( 7.24092, 6.67679,0.319634),distance to 7=7.51543
point7=(0.209371, 8.95756, 1.67499),distance to 8=7.33837
point8=( 2.28126, 1.93476, 2.16409),distance to 9=7.83986
point9=( 9.51192, 3.56082, 4.72081),distance to 0=6.54347
Python其实很简单 第十二章 函数与变量的作用域
在前面已经多次提到函数这个概念,之所以没有解释什么是函数,是因为程序中的函数和数学中的函数差不多,如input()、range()等都是函数,这些都是Python的标准函数,直接使用就可以了。根据需要,用户也可以自定义函数。
12.1 函数
函数的结构:
def 函数名(参数):
函数体
return 返回值
例如:数学中的函数f(x)=2x+5在Python中可以定义如下:
def f(x):
y=2*x+5
return(y)
如果x取值为3,可以使用如下语句调用函数:
f(3)
下面给出完整的程序代码:
def f(x):
y=2*x+5
return(y)
res=f(3)
print(res)
运行结果:11
如上例中的x是函数f(x)的参数,有时也被称为形式参数(简称形参),在函数被调用时,x被具体的值3替换y就是函数的返回值,这个值3也被称为实际参数(简称实参)。
上例中的y是函数f(x)的返回值。并不是所有的函数都有参数和返回值。如下面的函数:
def func():
print('此为无参数传递、无返回值的函数')
func()
输出结果:此为无参数传递、无返回值的函数
可以看出,该函数func()无参数,故调用时不用赋给参数值。
函数也可以有多个参数,如f(x,y)=x²+y²,可用Python语言定义如下:
def f(x,y):
z=x**2+y**2
return z
print(f(2,3)) #调用函数f(x,y)
输出结果:13
也可以通过直接给参数列表中的参数赋值的方法,为参数添加默认值,如果用户赋予参数值,则按照用户赋值执行,否则使用默认值。例如:
def f(x,y=3):
z=x**2+y**2
return z
若调用时参数列表为(2,1),即x赋值为2,y赋值为1:
print(f(2,1))
输出结果为:5
若调用时参数列表为(2),即x赋值为2,y赋值省缺,则y使用默认值:
print(f(2))
输出结果为:13
回调函数,又称函数回调,是将函数作为另一函数的参数。
例如:
def func(fun,m,n):
fun(m,n)
def f_add(m,n):
print('m+n=',m+n)
def f_mult(m,n):
print('m*n=',m*n)
func(f_add,2,3)
func(f_mult,2,3)
输出结果:
m+n= 5
m*n= 6
在f_add(m,n)和f_mult(m,n)被定义前,func(fun,m,n)中的fun(m,n)就已经调用了这两个函数,即“先调用后定义”,这也是回调函数的特点。
如果无法预知参数的个数,可以在参数前面加上*号,这种参数实际上对应元组类型。譬如,参会的人数事先不能确定,只能根据与会人员名单输入:
def func(*names):
print('今天与会人员有:')
for name in names:
print(name)
func('张小兵','陈晓梅','李大海','王长江')
运行后,输出结果为:
今天与会人员有:
张小兵
陈晓梅
李大海
王长江
参数为字典类型,需要在参数前面加上**号。
def func(**kwargs):
for i in kwargs:
print(i,kwargs[i])
func(a='a1',b='b1',c='c1')
输出结果为:
a a1
b b1
c c1
一个有趣的实例:
def func(x,y,z,*args,**kwargs):
print(x,y,z)
print(args)
print(kwargs)
func('a','b','c','Python','is easy',py='python',j='java',ph='php')
输出结果:
a b c # 前三个实参赋给前三个形参
('Python', 'is easy') # *args接收元组数据
{'py': 'python', 'j': 'java', 'ph': 'php'} # **kwargs接收字典数据
12.2 变量的作用域
变量的作用域即变量的有效范围,可分为全局变量和局部变量。
局部变量
在函数中定义的变量就是局部变量,局部变量的作用域仅限于函数内部使用。
全局变量
在主程序中定义的变量就是全局变量,但在函数中用关键字global修饰的变量也可以当做全局变量来使用。
全局变量的作用域是整个程序,也就是说,全局变量可以在整个程序中可以访问。
下面通过实例去讨论:
程序1:
a=1 # a为全局变量
def a_add():
print('a的初值:',a) # 在函数中读取a的值
a_add() # 调用函数a_add()
a+=1 # 主程序语句,a增加1
print('a现在的值是:',a) # 主程序语句,读取a的值
运行结果:
a的初值: 1
a现在的值是: 2
这个结果和我们想象的一样,全局变量a既可以在主程序中读取,也可以在子程序(函数)中读取。
程序2:
a=1
def a_add():
a+=1
print('a的初值:',a)
a_add()
print('a现在的值是:',a)
运行程序1时出现如下错误提示:
UnboundLocalError: local variable 'a' referenced before assignment
意思是:局部变量'a'在赋值之前被引用。
从语法上来讲,该程序没有错误。首先定义了一个全局变量a并赋值为1,又定义了一个函数a_add(),函数内的语句a+=1就是出错的根源,虽然我们的初衷是想让全局变量a的值增加1,但从错误提示看,这个语句中的a并不是全局变量,而是局部变量。看来,在函数中读取全局变量的值是没有问题的(在程序1中已经得到了验证),但要在函数中改变全局变量的值是不行的(在程序2的错误提示a+=1中的a 是局部变量,而非全局变量)。
怎样解决这个问题?
程序3:
a=1
def a_add(x):
x+=1
return x
print('a的初值:',a)
a=a_add(a)
print('a现在的值是:',a)
运行结果:
a的初值: 1
a现在的值是: 2
结果的确是正确的,但在函数a_add(x)中没有调用变量a(没有出现变量a)。
程序4:
a=1
def a_add(a):
a+=1
return a
print('a的初值:',a)
a=a_add(a)
print('a现在的值是:',a)
运行结果:
a的初值: 1
a现在的值是: 2
对比程序4和程序3不难发现,其实程序4只是简单的把函数的参数x变成了a,这个a的实质和程序3中的x还是一样的。这进一步证实,函数中的a是局部变量,与主程序的全局变量a有着本质的区别。
程序5:
a=1
def a_add():
global a
a+=1
print('a的初值:',a)
a_add()
print('a现在的值是:',a)
运行结果:
a的初值: 1
a现在的值是: 2
程序5和程序2相比较,仅仅是在函数中添加了一个定义“global a”,此时的局部变量a就可以当做全局变量使用,由于它和全局变量a同名,自然也就不用区分a究竟是全局变量还是局部变量了,在主程序和该函数内都可以访问、修改变量a的值了。
虽然使用global可使变量使用起来非常方便,但也容易引起混淆,故在使用过程中还是谨慎为好。
12.3 函数的递归与嵌套
递归,就是函数调用它自身。递归必须设置停止条件,否则函数将无法终止,形成死循环。
以计算阶乘为例:
def func(n):
if n==1:
return 1
else:
return n*func(n-1) #func( )调用func( )
print(func(5))
运行结果为:120
嵌套,指在函数中调用另外的函数。这是程序中常见的一种结构,在此不再赘述。
匿名函数
Python中可以在参数前加上关键字lambda定义一个匿名函数,这样的函数一般都属于“一次性”的。
例如:
程序1:这是一个常规的函数定义和调用。
def f_add(x,y):
return x+y
print(f_add(2,3))
输出结果:5
程序2:使用lambda定义匿名函数。
f_add=lambda x,y:x+y
print(f_add(2,3))
输出结果:5
从上面的代码可以看出,使用lambda仅仅减少了一行代码。f_add=lambda x,y:x+y中的f_add不是变量名,而是函数名。程序1和程序2的print( )语句中的参数都是一样的——调用函数f_add( )。所以,匿名函数并没有太多的优点。
python语言abaqus子程序报错,如何修改
中间似乎少了段代码。
没有用过这个mdb的方法。不过提示很明白。你自己造了一个数据结构A,但是这个结构不是字典。它需要是一个按指定类型存贮的字典。你查看一下translate的源代码,追进去,看一眼就知道那个字典的结构。然后略改一改就应该 可以了。
Re:python 子程序怎么调用上一层程序生成
在Python中,可以方便地使用os模块来运行其他脚本或者程序,这样就可以在脚本中直接使用其他脚本或程序提供的功能,而不必再次编写实现该功能的代码。为了更好地控制运行的进程,
可以使用win32process模块中的函数,如果想进一步控制进程,则可以使用ctype模块,直接调用kernel32.dll中的函数。下面介绍4种方式:
1、os.system()函数
os模块中的system()函数可以方便地运行其他程序或者脚本,模式如下:
os.system(command):command: 要执行的命令,如果要向脚本传递参数,可以使用空格分割程序及多个参数
实例:
#打开记事本os.system('notepad')#用记事本打开aa.txtos.system('notepad aa.txt') #aa.txt文件必须在当前程序目录#直接打开aa.txtos.system('aa.txt')#直接打开Excel文件os.system('aa.xlsx')#直接打开Word文件os.system('bb.docx')
filepath='测试.xlsx'#打开包含中文的文件os.system(filepath.decode('utf8').encode('GBK'))
2、ShellExecute函数
使用win32api模块中的ShellExecute()函数来运行其他程序,格式如下
ShellExecute(hwnd, op, file, args, dir, show)
hwnd: 父窗口的句柄,如果没有父窗口,则为0
op : 要运行的操作,为open,print或者为空
file: 要运行的程序,或者打开的脚本
args: 要向程序传递的参数,如果打开的是文件则为空
dir : 程序初始化的目录
show: 是否显示窗口
使用ShellExecute函数,就相当于在资源管理器中双击文件图标,系统会打开相应程序运行。
引用win32api,需要安装 pywin32,
实例:
import win32api
win32api.ShellExecute(0, 'open', 'notepad.exe', '', '', 0) # 后台执行win32api.ShellExecute(0, 'open', 'notepad.exe', '', '', 1) # 前台打开win32api.ShellExecute(0, 'open', 'notepad.exe', 'wmi.txt', '', 1) # 打开文件win32api.ShellExecute(0, 'open', 'iexplore.exe', '', '', 1) # 打开IE浏览器win32api.ShellExecute(0, 'open', 'iexplore.exe', '', '', 1) # 用IE浏览器打开百度网址win32api.ShellExecute(0, 'open', 'mspaint.exe', 'wxqr.png', '', 1) #用系统附件自带的画图打开图片wxqr.png
3、CreateProcess
参考实例:
3.1、创建进程
为了便于控制通过脚本运行的程序,可以使用win32process模块中的CreateProcess()函数创建一个运行相应程序的进程。其函数格式为:
CreateProcess(appName, cmdLine, proAttr, threadAttr, InheritHandle, CreationFlags, newEnv, currentDir, Attr)
appName 可执行文件名
cmdLine 命令行参数
procAttr 进程安全属性
threadAttr 线程安全属性
InheritHandle 继承标志
CreationFlags 创建标志
currentDir 进程的当前目录
Attr 创建程序的属性
3.2、结束进程
可以使用win32process.TerminateProcess函数来结束已创建的进程, 函数格式如下:
TerminateProcess(handle, exitCode)
handle 要操作的进程句柄
exitCode 进程退出代码
或者使用win32event.WaitForSingleObject等待创建的线程结束,函数格式如下:
WaitForSingleObject(handle, milisecond)
handle : 要操作的进程句柄
milisecond: 等待的时间,如果为-1,则一直等待.
import win32process# 打开记事本,获得其句柄handle = win32process.CreateProcess(r'C:\Windows\notepad.exe', '', None, None, 0, win32process.CREATE_NO_WINDOW, None, None, win32process.STARTUPINFO())
time.sleep(4)# 终止进程win32process.TerminateProcess(handle[0], 0)import win32event#等待进程结束 print win32event.WaitForSingleObject(handle[0], -1)
4、使用ctypes调用kernel32.dll中的函数
使用ctypes模块可以让Python调用位于动态链接库的函数。
ctypes模块为Python提供了调用动态链接库中函数的功能。使用ctypes模块可以方便地调用由C语言编写的动态链接库,并向其传递参数。
ctypes模块定义了C语言中的基本数据类型,并且可以实现C语言中的结构体和联合体。ctypes模块可以工作在Windows,Linux,Mac OS等多种操作系统,基本上实现了跨平台。
实例:
Windows下调用user32.dll中的MessageBoxA函数。
from ctypes import *user32 = windll.LoadLibrary('user32.dll')
a = user32.MessageBoxA(0, str.encode('Hello Ctypes!'), str.encode('Ctypes'), 0)print a
ctype模块中含有的基本类型与C语言类似,下面是几个基本的数据类型的对照: