python子程序,python 子類

本文目錄一覽：

• 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語言類似，下面是幾個基本的數據類型的對照: