Lap Trinh Python Trong PSSE - 2

Ứng dụng ngôn ngữ Python trong PSS/E 1
MỤC LỤC
CHƯƠNG 1 BIẾN VÀ CẤU TRÚC DỮ LIỆU TRONG NGÔN NGỮ PYTHON ...................... 3
I. CÁC KIỂU DỮ LIỆU TRONG NGÔN NGỮ PYTHON ....................................................... 3
1. Kiểu Numbers ......................................................................................................................... 3
2. Kiểu String (kiểu chuỗi)......................................................................................................... 3
3. Kiểu list ................................................................................................................................... 4
4. Kiểu Tuple............................................................................................................................... 4
5. Kiểu Dictionary ...................................................................................................................... 6
6. Chuyển đổi giữa các kiểu dữ liệu trong Python................................................................... 6
7. Thứ tự các phần tử trong List hoặc Tuple ........................................................................... 7
8. Chú thích (Comment) ............................................................................................................ 7
II. BIẾN VÀ TOÁN TỬ TRONG PYTHON ............................................................................ 7
1. Biến .......................................................................................................................................... 7
2. Toán tử .................................................................................................................................... 8
CHƯƠNG 2 CẤU TRÚC ĐIỀU KHIỂN LUỒNG VÀ CẤU TRÚC VÒNG LẶP TRONG
NGÔN NGỮ PYTHON........................................................................................................................ 13
I. CẤU TRÚC ĐIỀU KHIỂN LUỒNG ...................................................................................... 13
1. Lệnh if ................................................................................................................................... 13
2. Lệnh if…else ......................................................................................................................... 14
3. Lệnh if…elif…else ................................................................................................................ 14
4. Lồng nhiều lệnh if................................................................................................................. 15
II. CẤU TRÚC VÒNG LẶP TRONG NGÔN NGỮ PYTHON ............................................ 16
1. Vòng lặp for .......................................................................................................................... 16
2. Vòng lặp While ..................................................................................................................... 19
3. Các lệnh điều khiển vòng lặp .............................................................................................. 20
CHƯƠNG 3 HÀM VÀ MODULE TRONG PYTHON ............................................................... 23
I. HÀM TRONG PYTHON ........................................................................................................ 23
1. Giới thiệu chung ................................................................................................................... 23
2. Định nghĩa hàm .................................................................................................................... 23
3. Ví dụ tạo một số hàm đơn giản ........................................................................................... 23
II. MODULE TRONG PYTHON ............................................................................................ 24
1. Giới thiệu............................................................................................................................... 24
2. Cách sử dụng module ........................................................................................................... 24
3. Build – in Module ................................................................................................................. 26
III. MODULE PSSPY................................................................................................................. 26
IV. MODULE REDIRECT ........................................................................................................ 28
CHƯƠNG 4 TRÍCH XUẤT VÀ THAY ĐỔI DỮ LIỆU HỆ THỐNG ĐIỆN ............................. 31
I. TRÍCH XUẤT DỮ LIỆU HỆ THỐNG ĐIỆN ....................................................................... 31
1. Các phương pháp trích xuất dữ liệu hệ thống ................................................................... 31

2. Lấy thông số của một nút .................................................................................................... 31
3. Lấy thông số của nhiều nút trong một subsystem ............................................................. 33
II. THAY ĐỔI DỮ LIỆU HỆ THỐNG ĐIỆN ........................................................................ 37
1. Thay đổi thông số nút........................................................................................................... 37
2. Thay đổi thông số đường dây .............................................................................................. 38
CHƯƠNG 5 TÍNH TOÁN TRÀO LƯU CÔNG SUẤT VÀ NGẮN MẠCH TRONG HỆ
THỐNG ĐIỆN ...................................................................................................................................... 41
I. TRÀO LƯU CÔNG SUẤT (POWER FLOW) ...................................................................... 41
1. Các lệnh để tính trào lưu công suất .................................................................................... 41
2. Ví dụ ...................................................................................................................................... 42
II. TÍNH TOÁN NGẮN MẠCH TRONG HỆ THỐNG ĐIỆN.............................................. 43
1. Các lệnh để tính toán ngắn mạch ........................................................................................ 43
2. Ví dụ ...................................................................................................................................... 44
III. MODULE EXCELPY .......................................................................................................... 46
1. Giới thiệu............................................................................................................................... 46
2. Ví dụ ...................................................................................................................................... 46
CHƯƠNG 1
BIẾN VÀ CẤU TRÚC DỮ LIỆU TRONG NGÔN NGỮ PYTHON
I. CÁC KIỂU DỮ LIỆU TRONG NGÔN NGỮ PYTHON
Ngôn ngữ Python có 5 kiểu dữ liệu chuẩn là:
 Numbers
 String
 List
 Tuple
 Dictionary
1. Kiểu Numbers
- Kiểu dữ liệu numbers chứa giá trị là một con số, nó được tạo ra khi ta gán các
giá trị là một con số cho biến nào đó.
- Python hỗ trợ 4 kiểu dữ liệu Numbers:
Kiểu dữ liệu Định nghĩa Ví dụ
Số nguyên giới giạn từ 4
Int
-2147483648 đến 2147483647
Số nguyên không giới hạn, để phân
long biệt với kiểu Int, kiểu long thường 592654L
đặt chữ “L” ở cuối giá trị
3.141592654
float Số thập phân
complex Số phức 1.23 + 4.56j

2. Kiểu String (kiểu chuỗi)
a) Định nghĩa
Kiểu dữ liệu strings được xác định khi giá trị được gán cho nó nằm giữa cặp dấu
' ' hoặc " " hoặc ''' ''' hoặc" ' ' " hoặc " " " " " "
Ví dụ:
# single quotes:
s = 'A string'
# double quotes:
s = "A string"
# double and single quotes:
s = "A 'string'"
# triple single quotes:
t = '''A string'''
u = '''This is
a multi-line string'''
# triple double quotes:
t = """A string"""
u = """This is a multi-line string"""
b) Tương tác với kiểu String

- Ghép nhiều chuỗi với nhau:
s = 'abcd' + 'efgh' # s = 'abcdefgh'

t = 'bus ' + str(576132) # t = 'bus 576132'
- Lặp lại các phần tử trong một chỗi:
u = '-' * 10 # u = '----------'
- Xác định một phần tử trong chuỗi dựa vào vị trí của nó
x = s[1] # x = 'b'
# Chuỗi s = 'abcdefgh'
- Xác định một chuỗi nằm trong một chuỗi khác dựa vào vị trí các phần tử
y = s[2:5] # y = 'cde'
3. Kiểu list
a) Định nghĩa
 List trong Python là một kiểu dữ liệu “danh sách có thứ tự”
 List chứa những phần tử được ngăn cách nhau bởi dấu "," và nằm trong cặp
dấu ngoặc vuông "[ ]".
 Theo một vài đánh giá thì List trong Python gần giống với Array trong C, sự
khác biệt chính là các phần tử của List có thể tồn tài nhiều kiểu dữ liệu khác
nhau.
 Các phần tử trong một list có thể thay đổi được.
Ví dụ
lst1 = [] # List trống
lst2 = [5] # List có 1 phần tử là số
lst3 = [5, 8, 'with parentheses', 628.7] # List có nhiều phần tử với nhiều kiểu
lst4 = [a, [1, 2, 3], 'AREA' , (7, 8, 9.1)] # List lồng trong một list khác
b) Tương tác với List
Cho list x có giá trị như sau:
x = [3, 2, 3, 4]
 Thêm phần tử vào một list
x + [9, 10] # x = [3, 2, 3, 4, 9, 10]
 Lấy các phần tử đến một vị trí xác định
Lấy 5 phần tử đầu tiên của list
x = x[:5] # x = [3, 2, 3, 4, 9]
(slice)
 Kiểm tra xem một phần tử có thuộc list hay không
4 in x # True
Giá trị trả về là “True” có nghĩa là phần tử này có nằm trong list và ngược lại
nếu là “False” thì phần tử này không nằm trong list
 Bỏ các phần tử của list đến một vị trí xác định
del x[4:] # x = [9]
4. Kiểu Tuple
a) Định nghĩa
 Tuple trong Python là một kiểu dữ liệu “danh sách có thứ tự”
 Tuple chứa những phần tử được ngăn cách nhau bởi dấu "," và nằm trong cặp
dấu ngoặc vuông "( )".
 Khác với List, các phần tử trong Tuple không thể thay đổi được.
Ví dụ
tup1 = () # Tuple trống
tup2 = (55,) # Tuple có 1 phần tử là số
tup3 = (5, 8, 'with parentheses',628.7)

# Tuple có các phần tử với những kiểu khac nhau
tup4 = 5, 8, 'no parentheses' , 628.7

# Không cần dấu ()
tup5 = (a, [1, 2, 3], 'AREA' , (7, 8, 9.1))

# Tuple chứa List và Turp khác
Một số hàm trong PSS/E có giá trị trả về là một Tuple

rtple = psspy.busint(bus, 'AREA')
Hàm này sẽ trả về 1 Tuple có 2 phần tử, phần tử thứ nhất để xác định có lỗi
xảy ra hay không và phần tử thứ 2 là chỉ số AREA của bus
Ví dụ: rtple = psspy.busint(42023, 'AREA')
bus 42023 là bus 35kV của AT2 Dốc Sỏi
Giá trị trả về là rtple = (0,30): Số 0 có nghĩa là không xảy ra lỗi, 30 là chỉ số
vùng của khu vực miền Trung
ierr, bus_area = psspy.busint(bus, 'AREA')
Ví dụ: rtple = psspy.busint(42023, 'AREA')
Giá trị trả về là ierr = (0) và bus_area = (30)
ierr, (number,) = psspy.abusint(string='NUMBER')
Giá trị trả về là ierr = (0) và (number,) là một Tuple chứa chỉ số của tất cả các
bus có trong file dữ liệu (file sử dụng là Tuan_10_max.sav)
ierr, (base, pu) =psspy.abusreal(string=['BASE', 'PU'])
Kết quả trả về là ierr = (0), (base,pu) là một Tuple chứa các giá trị điện áp cơ bả
(kV) và điện áp trong đơn vị tương đối của tất cả các nút trong file dữ liệu.
5. Kiểu Dictionary
a) Định nghĩa
 Được lấy ý tưởng từ cuốn từ điển hằng ngày, kiểu Dictionary là một tập hợp
các cặp “từ khóa” và “giá trị” (key, value).
 Các phần tử của Dictionary nằm giữa dấu { }, key và value ngăn cách bởi
dấu “:”, các cặp key và value ngăn cách bởi dấu “,”.
 Không thể có 2 từ khóa trùng nhau trong một Dictionary
 Từ khóa có thể có kiểu Number, String, hoặc là Tuple.
 Các bộ (key, value) có thể được thay thế và sửa đổi
Ví dụ:
 Dictionary gồm chỉ số bus và điện áp tại bus đó (p.u)
busvolts = {101 : 1.036,151 : 0.988,154 : 1.063 }
 Dictionary gồm số nhị phân và giá trị tương ứng của nó trong hệ thập phân
bits2bytes = { (0,0,0):0,
(0,0,1):1,
(0,1,0):2,
(0,1,1):3,
(1,0,0):4,
(1,0,0):5,
(1,1,0):6,}
 Key và value của Dictionary có thể có nhiều kiểu khác nhau

dict2 = {'N':7, (200, 310, '1'):'N.Sub', 100:3.0}
Ta có thể lấy giá trị của một từ khóa bằng cách:
dict2 = ['N'] # Giá trị trả về là 7
6. Chuyển đổi giữa các kiểu dữ liệu trong Python
a) Chuyển từ số nguyên sang số thực và ngược lại
 Ví dụ chuyển từ số nguyên sang số thực:
a=5
b=7
c = a/b # Giá trị trả về c = 0 (Bởi vì Python mặc định c là số nguyên)
d= float(a)/float(b) #Giá trị trả về d = 0.714… (Bởi vì lúc này a và b đã
chuyển sang số thực và c cũng là số thực)
 Ví dụ chuyển từ số thực sang số nguyên:
pi = 3.141562958
e = int(pi) # Kết quả trả về e = 3
b) Chuyển đổi giữa String, List và Tuple
 Ví dụ chuyển từ kiểu Tuple sang List
x = list((1, 2, 3, 4, 5)) # x = [1, 2, 3, 4, 5]
 Ví dụ chuyển từ String sang List
y = list('abcd') # y = ['a', 'b', 'c', 'd']

 Ví dụ chuyển từ kiểu List sang Tuple
x = tuple([1, 2, 3, 4, 5]) # x = (1, 2, 3, 4, 5)
 Ví dụ chuyển từ kiểu String sang Tuple
y = tuple('abcd') # y = ('a', 'b', 'c', 'd')
 Ví dụ chuyển từ kiểu List và Tuple sang String
x = str([1, 2, 3]) # x = '[1, 2, 3]'
y = str((1, 2, 3)) # y = '(1, 2, 3)'
z = str(['a', 'b', 'c']) # z = "['a', 'b', 'c']"
7. Thứ tự các phần tử trong List hoặc Tuple
Vị trí của các phần tử trong List hay Tuple được định nghĩa giống nhau
Xét một List như sau:
X = [1, 4, 5, 3, 7]
0 1 2 3 4 Thứ tự của các phần tử nếu xét từ trái sang
phải
-5 -4 -3 -2 -1 Thứ tự của các phần tử nếu xét từ phải sang
trái
Ví dụ ta muốn in ra phần tử ở vị trí thứ 2 xét từ trái sang phải:
X[1] # Giá trị trả về là 4, bởi vì số thứ tự từ trái sang phải bắt đầu bằng số 0
nên phần tử ở vị trí thứ 2 có số thứ tự là 1
In ra phần tử ở vị trí thứ 3 từ phải sang trái
X[-3] # Giá trị trả về là 5
Để thay đổi một phần tử ở vị trí nào đó của List ta thực hiện như sau:
X [0] = 3 #Lúc này phần tử ở vị trí đầu tiên của List X sẽ là 3 thay thế cho 1
8. Chú thích (Comment)
 Chú thích trong ngôn ngữ Python được đặt sau dấu #
# Day la chu thich
area = 17 # Co the dat chu thich sau nhung cau lenh
 Khi dấu # đặt giữa 2 dấu nháy đơn thì những ký tự sau dấu # đó chỉ là một
phần của String chứ không được xem như là comment
print('This # is not a comment')
II. BIẾN VÀ TOÁN TỬ TRONG PYTHON

1. Biến
 Trong Python, chúng ta không cần khai báo biến một cách tường minh.
 Khi gán bất cứ giá trị nào cho biến thì biến đó được khai báo một cách tự
động. Phép gán được thực hiện bởi toán tử =.
 Python sẽ tự xác định kiểu dữ liệu của biến khi biến được gán giá trị.
Ví dụ:
a = 2 # a la mot so nguyen
b = 17.6 # b la mot so thuc
c = 'This is a string' # c la mot chuoi
 Phép đa gán: Python cho phép bạn gán một giá trị đơn cho một số biến một
cách đồng thời. Python hỗ trợ hai kiểu đa gán sau:
- Gán giá trị đơn cho nhiều biến, ví dụ:
a = b = c = 1
- Gán nhiều giá trị cho nhiều biến, ví dụ:
a,b,c=5,10,15
2. Toán tử
Python hỗ trợ các loại toán tử sau:
o Toán tử số học
o Toán tử quan hệ (còn gọi là toán tử so sánh)
o Toán tử gán
o Toán tử logic
o Toán tử membership
o Toán tử identify
o Toán tử thao tác bit
a) Toán tử số học
Toán tử Miêu tả
// Thực hiện phép chia, trong đó kết quả là thương số sau khi đã xóa các chữ
số sau dấu phẩy (Chia lấy phần nguyên)
+ Phép cộng
- Phép trừ
* Phép nhân
/ Phép chia
% Phép chia lấy phần dư
** Phép lấy số mũ (ví dụ 2**3 cho kết quả là 8)
Ví dụ:
>>> 10+20
30
>>> 20-10
10
>>> 10*2
20
>>> 10/2
5
>>> 10%3
1
>>> 2**3
8
>>> 10//3
3
b) Toán tử quan hệ
< Nhỏ hơn. Nếu giá trị của toán hạng trái là nhỏ hơn giá trị của toán hạng
phải, thì điều kiện trở thành true
> Lớn hơn
<= Nhỏ hơn hoặc bằng
<= Lớn hơn hoặc bằng
== Bằng
!= Không bằng
<> Không bằng (tương tự !=)
Ví dụ:
>>> 10<20
True
>>> 10>20
False
>>> 10<=10
True
>>> 20>=15
True
>>> 5==6
False
>>> 5!=6
True
>>> 10<>2
True
c) Toán tử gán trong Python
= Phép gán
/= Chia toán hạng trái cho toán hạng phải, và gán kết quả cho toán hạng
trái
+= Cộng và gán
-= Trừ và gán
*= Nhân và gán
%= Chia lấy phần dư và gán
**= Lấy số mũ và gán
//= Thực hiện phép chia // và gán
Ví dụ:
>>> c=10
>>> c
10
>>> c+=5
>>> c
>>> c-=5
>>> c
10
>>> c*=2
>>> c
20
>>> c/=2
>>> c
10
>>> c%=3
>>> c
1
>>> c=5
>>> c**=2
>>> c
25
>>> c//=2
>>> c
12
d) Toán tử Logic
Toán Miêu tả
tử
and Phép Và. Nếu cả hai điều kiện là true thì kết quả sẽ là true
or Phép Hoặc. Nếu một trong hai điều kiện là true thì kết quả là true
not Phép phủ định. Được sử dụng để đảo ngược trạng thái logic của toán hạng
Ví dụ:
a=5>4 and 3>2
print a
>>>True
b=5>4 or 3<2
print b
>>>True
c=not(5>4)
print c
>>>False
e) Toán tử identify
Toán tử identify so sánh các vị trí ô nhớ của hai đối tượng. Python có hai
toán tử identify là:
is Trả về true nếu các biến ở hai bên toán tử cùng trỏ tới một đối tượng, nếu
không là false
is not Trả về false nếu các biến ở hai bên toán tử cùng trỏ tới một đối tượng,
nếu không là true
Ví dụ:
a=20
b=20
if( a is b):
print (‘a,b co cung identity’)
else:
print (‘a, b la khac nhau’)
>>>a,b co cung identity
b=10
if( a is not b):
print (‘a,b co identity khac nhau’)
else:
print (‘a,b co cung identity’)
>>>a,b co identity khac nhau
f) Toán tử membership
Toán tử membership trong Python kiểm tra xem biến này có nằm trong dãy
(có là một trong các thành viên của dãy) hay không. Có hai toán tử
membership trong Python là:
in Trả về true nếu một biến là nằm trong dãy các biến, nếu không là false
not in Trả về true nếu một biến là không nằm trong dãy các biến, nếu không là
false
Ví dụ:
a=10
b=60
list=[10,20,30,40,50];
if (a in list):
print ("a nam trong list da cho")
else:
print ("a khong nam trong list da cho")
if(b not in list):
print ("b khong nam trong list da cho")
else:
print ("b nam trong list da cho")
Kết quả trả về là:

>>>
a nam trong list da cho
b khong nam trong list da cho
g) Toán tử thao tác Bit
Toán tử thao tác bit làm việc trên các bit và thực hiện các hoạt động theo
từng bit. Giả sử a = 60 và b = 13 thì định dạng nhị phân của chúng lần lượt
là:
a = 0011 1100 và b = 0000 1101
Toán tử Miêu tả Ví dụ
& Sao chép một bit tới kết quả nếu bit này tồn tại trong cả (a & b) cho kết quả 0000 1100
hai toán hạng
| Sao chép một bit tới kết quả nếu bit này tồn tại trong bất (a | b) = 61 (tức là 0011 1101)
kỳ toán hạng nào
^ Sao chép bit nếu nó được set (chỉ bit 1) chỉ trong một (a ^ b) = 49 (tức là 0011 0001)
toán hạng
~ Đây là toán tử một ngôi, được sử dụng để đảo ngược bit (~a ) = -61 (tức là 1100 0011)
<< Toán tử dịch trái nhị phân. Giá trị của toán hạng trái a << = 240 (tức là 1111 0000)
được dịch chuyển sang trái một số lượng bit đã được
xác định bởi toán hạng phải
>> Toán tử dịch phải nhị phân. Giá trị của toán hạng trái a >> = 15 (tức là 0000 1111)
được dịch chuyển sang phải một số lượng bit đã được
xác định bởi toán hạng phải
CHƯƠNG 2
CẤU TRÚC ĐIỀU KHIỂN LUỒNG VÀ CẤU TRÚC VÒNG LẶP
TRONG NGÔN NGỮ PYTHON
I. CẤU TRÚC ĐIỀU KHIỂN LUỒNG
1. Lệnh if
 Lệnh này được sử dụng để kiểm tra một điều kiện, nếu điều kiện là đúng
thì lệnh của khối if sẽ được thực thi, nếu không nó sẽ bị bỏ qua.
 Cú pháp:
if biểu thức :
khối lệnh
 Lưu đồ như sau:
Ví dụ:
bus_A = 1.08
if bus_A > 1.05:
print('Dien ap tai bus A cao hon gioi han cho phep !!!')
Kết quả là:

>> Dien ap tai bus A cao hon gioi han cho phep !!!
 Lưu ý:
o Python không cung cấp các dấu ngoặc ôm ({}) để chỉ các khối code
cho định nghĩa lớp hoặc hàm hoặc điều khiển luồng.
o Các khối code được nhận biết bởi độ thụt dòng code (indentation)
trong Python và đây là điều bắt buộc.
o Số khoảng trống trong độ thụt dòng là khác nhau, nhưng tất cả các
lệnh bên trong khối phải được thụt cùng một số lượng khoảng trống
như nhau.
o Kết thúc một khối lệnh không có từ khóa “end” như những ngôn
ngữ khác.
2. Lệnh if…else
 Một lệnh else có thể được sử dụng kết hợp với lệnh if. Một lệnh else
chứa khối lệnh sẽ được thực thi nếu biểu thức điều kiện trong lệnh if
được ước lượng là sai.
 Lệnh else là lệnh tùy ý và chỉ có duy nhất một lệnh else sau lệnh if
 Cú pháp của lệnh if…else:
if biểu thức:
khối lệnh 1
else:
khối lệnh 2
Ví dụ:
status = 0
if status == 1:
print ('Thiet bi dang hoat dong')
else:
print ('Thiet bi khong hoat dong')
Kết quả:
>> Thiet bi khong hoat dong
3. Lệnh if…elif…else
 Lệnh elif cho phép kiểm tra nhiều điều kiện và thực thi khối lệnh ngay
khi một trong các điều kiện được ước lượng là đúng.
 Cũng giống như lệnh else, lệnh elif là tùy ý.
 Tuy nhiên, không giống else là chỉ có một lệnh được thực hiện theo sau
if, ta có thể sử dụng nhiều elif theo sau if.
 Cú pháp:
if biểu thức 1:
khối lệnh 1
elif: biểu thức 2:
khối lệnh 2
khối lệnh 3
else:
khối lệnh 4
Ví dụ:
bus_B = 1.03
if bus_B > 1.05:
print('Bus B co dien ap cao')
elif bus_B < 0.95:
print('Bus B co dien ap thap')
else:
print ('Bus B co dien ap binh thuong')
Kết quả:
>> Bus B co dien ap binh thuong
 Lưu ý: Cú pháp và lưu đồ ở trên chỉ thể hiện cho chương trình có 3 biểu thức
điều kiện, nhưng trong thực tế thì số lượng không hạn chế (số lệnh elif không
giới hạn).
4. Lồng nhiều lệnh if

 Khi muốn kiểm tra thêm một điều kiện khác sau khi một điều kiện đã được
ước lượng là đúng. Trong tình huống như vậy, có thể sử dụng các lệnh if
lồng nhau trong Python.
 Trong cấu trúc các lệnh if lồng nhau, có thể có cấu trúc if…elif…else bên
trong cấu trúc if…elif…else khác.
 Cú pháp:
if biểu thức 1:
khối lệnh 1
if: biểu thức 2:
khối lệnh 2
khối lệnh 3
else:
khối lệnh 4
else:
khối lệnh 5
Cú pháp trên chỉ mang tính chất minh họa cho một trường hợp lồng các
lệnh if, thực tế thì việc sử dụng cấu trúc này sẽ thay đổi linh hoạt tùy vào
mục đích của người dùng.
Ví dụ:
line_1 = 90
line_1_rated = 99.1
line_2 = 120
line_2_rated = 100
if line_1 > line_1_rated:
print ('duong day 1 va duong day 2 bi qua tai')
else:
print('duong day 1 bi qua tai va duong day 2 chua qua tai')
else:
print ('duong day 1 chua qua tai va duong day 2 qua tai')
else:
print ('duong day 1 va duong day 2 chua qua tai')
Kết quả:
>> duong day 1 chua qua tai va duong day 2 qua tai
II. CẤU TRÚC VÒNG LẶP TRONG NGÔN NGỮ PYTHON
1. Vòng lặp for
a) Cấu trúc vòn lặp
 Vòng lặp for được sử dụng để lặp một biến qua một dãy các phần tử (
trong List, String hoặc Tuple) theo thứ tự mà chúng xuất hiện.
 Vòng lặp for còn được gọi là vòng lặp xác định.
 Cú pháp:
for biến_vòng_lặp in dãy_phần_tử:
khối_lệnh
 Lưu đồ:
Ví dụ 1:
t = (2.95, 7.31, 5.66, 49.28)
for x in t:
print(x)
Kết quả:
>> 2.95
7.31
5.66
49.28
Ví dụ 2:
s = 'NLDC'
for c in s:
print(c)
Kết quả:
>> N
L
D
C
b) Một số hàm thường dùng trong vòng lặp for
 Hàm range ()
Ta có thể tạo một List gồm các số cách đều nhau nhau bằng hàm range
(), với cú pháp như sau:
 Để tạo một list gồm các số liên tiếp bắt đầu từ số 0:
range (số phần tử)
 Để tạp một list gồm các số cách đều nhau:
range (số bắt đầu, số giới hạn, bước tăng)
 Lưu ý: List tạo ra bởi hàm range sẽ không bao gồm “số giới
hạn” mà chỉ có đến số liền trước “số giới hạn”
Ví dụ 3:
A = range (5) # ket qua: A = [0, 1, 2, 3, 4]
B = range (1, 9, 2) # ket qua: B = [1, 3, 5, 7], so gioi han la 9 nen List
chi chua den so 7
Ví dụ 4: Sử dụng vòng lặp for với lệnh range:

for i in range (2,10,2):
print (i)
Kết quả:
>> 2
4
6
8
 Hàm enumerate ()
Hàm enumerate () trả về giá trị các phần tử và số thứ tự của nó trong
một dãy.
Ví dụ 5:
x = ['A', 'B', 'C']
for i, v in enumerate(x):
print i, v
Kết quả:
>> 0 A
1B
2C
 Hàm zip ()
Hàm zip () dùng để nối nhiều dãy (List, Tuple) với nhau
Ví dụ 6: Ta sẽ 3 List như sau: busnums chứa số nút, voltages chứa giá trị
điện áp tại các nút và areanums chứa chỉ số khu vực của các nút. Ta sẽ
nối các giá trị tương ứng với nhau để biểu thị thông tin về 1 nút (số nút,
điện áp, khu vực). Chương trình như sau:
busnums = [101, 202, 214, 227]

voltages = [1.05, 0.96, 1.02, 1.01]
areanums = [13, 14, 20, 13]
for b, v, a in zip(busnums, voltages, areanums):
print b, v, a
Kết quả:
>> 101 1.05 13 (Nút số 101 có điện áp 1.05 nằm tại khu vực 13)
202 0.96 14
214 1.02 20
227 1.01 13
2. Vòng lặp While
 Vòng lặp while trong Python thực thi lặp đi lặp lại các lệnh hoặc phần
thân của vòng lặp miễn là điều kiện đã cho là đúng.
 Khi điều kiện là sai, thì điều khiển sẽ thoát ra khỏi vòng lặp.
 Dưới đây là cú pháp của vòng lặp while trong Python:
While biểu thức điều kiện:
Khối lệnh
Ví dụ:
count = 0
while count < 5:
print ('So thu tu la:'), count
count = count +1
Kết quả:
>> So thu tu la: 0
So thu tu la: 1
So thu tu la: 2
So thu tu la: 3
So thu tu la: 4
Giải thích hoạt động của chương trình:
 Đầu tiên count = 0 nên điều kiện count < 5 là đúng do vậy sẽ thực
hiện lệnh print() in ra màn hình “So thu tu la: 0”, sau đó giá trị của
count sẽ được tăng thêm 1.
 Cứ tiếp tục đến khi count = 4, lúc này sau khi in ra màn hình câu “So
thu tu la: 4” thì count tăng thêm 1, vậy count = 5, điều kiện so sánh
sai (count<5), chương trình dừng lại.
 Lưu ý: Cũng như cấu trúc điều khiển luồng, cấu trúc vòng lặp cũng
có thể lồng các vòng lặp với nhau tùy vào mục đích của người sử
dụng
3. Các lệnh điều khiển vòng lặp
a) Lệnh pass
 Được sử dụng khi một lệnh là cần thiết theo cú pháp nhưng ta không
muốn bất cứ lệnh hoặc khối code nào được thực thi.
 Lệnh pass là một hoạt động null và không có gì xảy ra khi nó thực thi.
 Để có thể hiểu rõ hơn, ta xét ví dụ sau đây:
for letter in 'Python':

if letter == 'h':
pass
print ('Day la khoi pass')
print ('Chu cai hien tai :'), letter
print ("Good bye!")
Kết quả:
>> Chu cai hien tai : P
Chu cai hien tai : y
Chu cai hien tai : t
Day la khoi pass
Chu cai hien tai : h
Chu cai hien tai : o
Chu cai hien tai : n
Good bye!
Giải thích chương trình:
 Đầu tiên, biến letter sẽ được lần lượt được gán các phần tử trong
String “Python” và ở vòng lặp đầu tiên sẽ thực hiện lệnh print in ra
câu “Chu cai hien tai la: P”. Sau đó sẽ tiếp tục cho các vòng lặp tiếp
theo.
 Nếu letter = “h” thì sẽ bỏ qua (pass), không thực hiện lệnh print để
in ra màn hình câu “Chu cai hien tai la: h” mà thay vào đó sẽ in ra
câu “Day la khoi pass”.
 Vòng lặp tiếp tục đến phần tử cuối cùng của String (chữ “n”), sau
đó thoát vòng lặp, in ra câu “Good bye!”
b) Lệnh break
 Lệnh này dùng để kết thúc vòng lặp hiện tại và truyền điều khiển tới
cuối vòng lặp. Nói đơn giản thì khi gặp lệnh break, vòng lặp sẽ dừng
ngay tại đó và sẽ thực thi các câu lệnh tiếp theo ngoài vòng lặp.
 Lệnh break này có thể được sử dụng trong vòng lặp while và vòng lặp
for.
 Nếu đang sử dụng cấu trúc lồng vòng lặp, thì lệnh break kết thúc sự
thực thi của vòng lặp bên trong và bắt đầu thực thi dòng code tiếp theo
của khối.
 Ta xét ví dụ sau:
if letter == 'h':
break
print 'Chu cai hien tai :', letter
Kết quả:
 Ta lần lượt gán cho biến letter các phần tử của String “Python”, sau
đó thực hiện lệnh in ra màn hình “Chu cai hien tai:”
 Khi biến letter được gán giá trị là “h” thì vòng lặp sẽ dừng lại,
chương trình kết thúc.
c) Lệnh continue
 Lệnh này bỏ qua lần lặp hiện tại và bắt buộc lần lặp tiếp theo của vòng
lặp diễn ra.
 Lệnh continue có thể được sử dụng trong vòng lặp while hoặc vòng
lặp for.
 Ví dụ:
if letter == 'h':
continue
print 'Chu cai hien tai :', letter
Kết quả:
Chu cai hien tai : o
Chu cai hien tai : n

 Ta lần lượt gán cho biến letter các phần tử của String “Python”, sau
đó thực hiện lệnh in ra màn hình “Chu cai hien tai:”
 Khi biến letter được gán giá trị là “h” thì chương trình sẽ bỏ qua
vòng lặp đó và tiếp tục các vòng lặp sau. Có nghĩa là sẽ bỏ qua lệnh
print ra màn hình câu: “Chu cai hien tai: h”.
CHƯƠNG 3
HÀM VÀ MODULE TRONG PYTHON
I. HÀM TRONG PYTHON
1. Giới thiệu chung
 Hàm là một đoạn chương trình được định nghĩa để thực hiện một công
việc nào đó mà có thể sử dụng được khi cần đến.
 Có thể hiểu hàm là một chương trình con trong chương trình lớn, nó sẽ
luôn sẵn sàng để thực thi khi được gọi đến.
 Hàm nhận (hoặc không) các đối số truyền vào và trả về (hoặc không) một
giá trị nào đó cho chương trình gọi nó.
 Hàm giúp cho việc phân đoạn chương trình thành những thành phần riêng
lẻ, hoạt động độc lập với chương trình lớn, có nghĩa một hàm có thể được
sử dụng trong chương trình này mà cũng có thể được sử dụng trong
chương trình khác, dễ cho việc kiểm tra và bảo trì chương trình.
 Ở những chương trước, ta đã sử dụng một số hàm có sẵn như hàm print (
), range ( ), zip ( ), int ( ),…Tuy nhiên ta cũng có thể tạo riêng cho mình
một hàm với cách định nghĩa và kiểu giá trị cho riêng. Các hàm này được
gọi là user-defined function.
2. Định nghĩa hàm
Khi định nghĩa các hàm để cung cấp một tính năng nào đó, bạn cần theo các qui
tắc sau:
 Từ khóa def được sử dụng để bắt đầu phần định nghĩa hàm. Def xác định
phần bắt đầu của khối hàm.
 def được theo sau bởi ten_ham được theo sau bởi các dấu ngoặc đơn ().
 Các tham số được đặt vào bên trong các dấu ngoặc đơn. Ở cuối là dấu hai
chấm.
 Phải thụt dòng trước khi viết một lệnh. Độ thụt dòng này nên giống nhau
cho tất cả các lệnh bên trong hàm đó.
 Cú pháp như sau:
def tên_hàm( đối_số ):

Khối_lệnh
return [biểu_thức]
3. Ví dụ tạo một số hàm đơn giản

a) Hàm đổi đơn vị từ độ sang radian
def degrees2radians(degs):
return degs * 3.14159/180.0
# Để sử dụng hàm ta sẽ gọi tên hàm và truyền đối số để nhận được kết quả
Ví dụ muốn đổi 30o sang radian:
>>> degrees2radians(30)
0.5235983333333333
b) Hàm kiểm tra điện áp
def voltage_range_test(vpu, vlo=0.95, vhi=1.05):
if vpu < vlo:
return 'dien ap thap!'
elif vpu > vhi:
return 'dien ap cao !'
else:
return 'dien ap binh thuong.'
# Ta sẽ kiểm tra một số giá trị điện áp:
>>> voltage_range_test(0.8)
'dien ap thap!'
'dien ap binh thuong.'
'dien ap cao !'
II. MODULE TRONG PYTHON
1. Giới thiệu
 Module được sử dụng để “gói” code thành các phần nhỏ hơn liên quan
với nhau. Hay nói cách khác, Module giúp tổ chức Python code một cách
logic giúp dễ dàng hiểu và sử dụng code đó hơn.
 Trong Python, Module là một đối tượng với các thuộc tính có thể đặt tên
tùy ý và có thể gắn kết và tham chiếu.
 Về cơ bản, một Module là một file có đuôi .py, trong đó các lớp, hàm và
biến được định nghĩa. Tất nhiên, một Module cũng có thể bao gồm code
có thể chạy.
2. Cách sử dụng module
a) Sử dụng lệnh import
Ta có thể sử dụng bất cứ module nào đã có sẵn bằng cú pháp:
import module1[, module2][,... moduleN]

Ví dụ:
Tạo một hàm cộng 2 số:
def add(a,b):
c=a+b
return c
#Lưu lại code này với tên là addition.py

# Sử dụng module addition vừa tạo:
import addition
d = addition.add(2,3)
print (d)
>> 5
b) Sử dụng lệnh from…import

 Lệnh from…import được sử dụng để import thuộc tính cụ thể từ một
Module.
 Trong trường hợp không muốn import toàn bộ Module nào đó thì có
thể sử dụng lệnh này. Cú pháp của lệnh from…import là:
from module_name import name1[, name2[, ... nameN]]
Ví dụ: Ta sẽ tạo một module chứa các hàm để tính diện tích của một
số hình học phẳng:
def circle(r): # Hinh tron

print 3.14*r*r
return
def square(l): # Hinh vuong

print l*l
return
def rectangle(l,b): # Hinh chu nhat

print l*b
return
def triangle(b,h): # Hinh tam giac

print 0.5*b*h
return
# Lưu code sau bằng tên là area.py
# Bây giờ, ta muốn tính diện tích hình tròn, chỉ cần import hàm circle trong
module area:
from area import circle
circle (2)
>> 12.56
c) Sử dụng lệnh import … as…
 Lệnh này được sử dụng để sử dụng một module với một tên khác.
 Thường được dùng trong trường hợp tên module quá dài hoặc khó nhớ,
gây khó khăn trong việc sử dụng, cú pháp như sau:
import module_name as different_name
 Ví dụ: ta có một module có tên là my_updated_module_ver4, để sử

dụng dễ dàng ta có thể làm như sau:
import my_updated_module_ver4 as mymodule
print(mymodule.x)
Lúc này module my_updated_module_ver4 có thể sử dụng với tên
ngắn gọn là mymodule
3. Build – in Module
Build – in Module là những module đã được xây dựng sẵn trong Python, ví
dụ như: os, sys, math, random, time, string …
a) Module os
Module này dùng để tương tác với hệ điều hành của máy.
Ví dụ:
os.getcwd() #dùng để trả về địa chỉ mà chương trình đang hoạt
động
os.chdir(‘…’) # thay đổi địa chỉ
os.system('notepad.exe') # Khởi động notepad
b) Module sys
Module này dùng để tương tác với hệ thống Python
c) Module math
Module này chứa các hàm toán học
Ví dụ:
x = math.sqrt(25) # Căn bậc 2 của 25: x = 5
x = math.pi # Số pi: x = 3.14159265359
x = math.e # Số Euler: x = 2.71828182846
x = math.cos(1.2) # Cosin của 1.2: x = (0.362357754477 + 0j)
d) Module time
Module này chứa các hàm để lấy thông tin hoặc xử lý các vấn đề về thời
gian của hệ thống.
Ví dụ:
time.localtime() # Trả về kết quả là giờ địa phương
time.ctime() # Tương tự hàm trên: 'Sun May 14 10:26:09 2017'
e) Module Random
Module này cung cấp các hàm để tạo những giá trị ngẫu nhiên
Ví dụ:
x = random.random() # trả về một số thực ngẫu nhiên trong khoảng
0 dến 1
x = random.randint(2, 9) # Trả về một số nguyên ngẫu nhiên trong
khoảng từ đến 9
III. MODULE PSSPY
 Module psspy chứa hơn 1000 hàm được dùng để:
 Thực thi các tác vụ của chương trình PSS/E
Ví dụ như gọi một file .sav để làm việc, ta dùng hàm sau:
ierr = psspy.case (abc.sav)
 Thay đổi thông số các phần tử trong hệ thống
Ví dụ để thay thông số một nút ta dùng hàm sau:
ierr = psspy.bus_number(ibus, newbus)

 Lấy thông số của các phần tử trong hệ thống
Ví dụ để lấy thông số của nút ta dùng hàm sau:
ierr, btyp = psspy.busint(ibus, 'TYPE')
 Xuất kết quả sau khi tính toán
Ví dụ để lấy điện áp thứ tự thuận của một nút sau khi tính ngắn
mạch, ta dùng hàm:
ierr, bvpos = psspy.scbus2(ibus, 'VPOS')
 Thực hiện một số chức năng khác
 Để nắm được chức năng của các hàm trong module psspy, ta cần tham
khảo tài liệu API kèm theo chương trình, với đường dẫn: C:\Program
Files (x86)\PTI\PSSE34\DOCS. Tài liệu này giới thiệu đầy đủ các hàm
trong psspy cũng như cú pháp tương đương trong ngôn ngữ Fortran.
 Trên IDE của python, ta chỉ cần nhập psspy thì sẽ tự động có một menu
đổ xuống cho phép lựa chọn các hàm có sẵn trong module này:
 Đối số của các hàm trong psspy có thể được nhập với nhiều cách
khác nhau. Ví dụ:
 Code báo lỗi ierr cho ta biết hàm được gọi có được sử dụng đúng cách
hay không, nếu ierr = 0 thì không có lỗi, còn iree khác 0 tức là có lỗi
và tùy vào mỗi hàm thì những lỗi này sẽ được biểu thị với một số khác
nhau.
 Các thông số trong PSS/E có thể được cài đặt và truy xuất bằng nhiều
cách
Ví dụ:
psspy.base_frequency(50.0) # Cài đặt tần số cho hệ thống là 50Hz
Hoặc có thể dùng cú pháp với chức năng tương đương
psspy.param.base_frequency = 60.0
ierr, basefreq = psspy.base_frequency() # Truyền cho biến basefreq
giá trị tần số của hệ thống đang được gọi
Hoặc có thể dùng cú pháp với chức năng tương đương
basefreq = psspy.param.base_frequency
 Để xuất kết quả sau khi xử lý ở môi trường Python ra cửa sổ Progress
thì ta có thể dùng hàm: psspy.progress('abc')
 Để xuất kết quả sau khi xử lý ở môi trường Python ra cửa sổ Report
thì ta có thể dùng hàm: psspy.report('abc')
IV. MODULE REDIRECT
 Module redirect cung cấp một số hàm để ta có thể chạy các tác vụ của
PSS/E trực tiếp trên trình biên dịch của Python.
 Nếu một chương trình python được viết để xử lý mộ tác vụ nào đó của
PSS/E nhưng không sử dụng module redirect thì lúc chạy chương trình
sẽ xuất hiện các pop-up như sau:
 Để không hiện các pop-up như trên và thực thi các tác vụ trực tiếp trên
trình biên dịch, ta phải import module redirect và sử dụng hàm:
import redirect
redirect.psse2py()
 Ngược lại, để hiển thị các kết quả được xử lý trên python ra cửa sổ
chương trình PSS/E, ta dùng hàm:
import redirect
redirect.py2psse()
 Để ngắt kết nối giữa PSS/E và môi trường Python ta dùng hàm:
import redirect
redirect.reset()
CHƯƠNG 4
TRÍCH XUẤT VÀ THAY ĐỔI DỮ LIỆU HỆ THỐNG ĐIỆN
I. TRÍCH XUẤT DỮ LIỆU HỆ THỐNG ĐIỆN
1. Các phương pháp trích xuất dữ liệu hệ thống
Có 2 cách để lấy thông số các phần tử trong lưới điện:
 Lấy một thông số của một phần phần tử đơn lẻ trong hệ thống.
 Lấy nhiều thông số của nhiều phần tử trong một Subsystem (hệ thống
con). Subsystem là một tập hợp một số nút nằm trong hệ thống, người
dùng có thể tạo nhiều subsystem tùy thuộc vào mục đích công việc cần
làm.
2. Lấy thông số của một nút
a) Lấy thông số từng nút đơn lẻ
Để lấy thông số của một số nút đơn lẻ với chỉ số các nút tăng dần ta thực
hiện như sau:
Các hàm được sử dụng

 Hàm inibus ()
 Hàm inibus () được dùng để khởi tạo bus đầu tiên trong một dãy các
bus cần lấy thông số
ierr = psspy.inibus(ibus)
Trong đó:
- ibus là chỉ số của nút đầu tiên
- ierr là biến báo lỗi:
+ ierr = 0: Không có lỗi
+ ierr = 1: Không tìm thấy bus có số nút như đã khai báo
 Hàm nxtbus ()
 Có cú pháp như sau:
ierr, ibus, cval = psspy.nxtbus()
Trong đó:
- ierr là biến báo lỗi
- ibus biến chứa chỉ số nút
- cval tên của nút ibus
 Chức năng của hàm này là gán chỉ số của nút tiếp theo (nút được khởi
tạo bởi hàm inibus () vào biến ibus.
 Hàm này thường được dùng với vòng lặp
 Hàm busint
 Dùng để lấy thông số (là số nguyên) của một nút.
ierr, ival = psspy.busint(ibus ,string)
Trong đó:
- ierr: Biến báo lỗi
- ival: Biến chứa kết quả
- ibus: Chỉ số của bus muốn lấy thông số
- string: loại thông số mà người dùng muốn lấy:
+ string = ‘TYPE’ : Trả về loại của nút
+ string = ‘AREA’: Trả về chỉ số AREA của nút
+ string = ‘ZONE’: Trả về chỉ số ZONE của nút
+ string = ‘OWNER’: Trả về chỉ số OWNER của nút
+ string = ‘DUMMY’: Kiểm tra xem nút có phải nút DUMMY hay
không, nếu là nút DUMMY sẽ trả về giá trị là 1, còn không thì trả
về 0.
 Hàm busdat
 Dùng để lấy thông số (là số thực) của một nút.
ierr, rval = psspy.busdat(ibus ,string)
Trong đó:
- rval: Biến chứa kết quả
- ibus: Chỉ số của bus muốn lấy thông số
- string: loại thông số mà người dùng muốn lấy:
+ string = ‘BASE’ : Trả về điện áp cơ bản của nút, kV
+ string = ‘PU’: Trả về điện áp thực của nút trong đơn vị tương đối
+ string = ‘KV’: Trả về điện áp thực của nút trong đơn vị có tên.
+ string = ‘NVLMHI’: Trả về giới hạn trên của điện áp nút trong
tình trạng bình thường.
+ string = ‘NVLMLO’: Trả về giới hạn dưới của điện áp nút trong
tình trạng bình thường.
+ string = ‘EVLMHI’: Trả về giới hạn trên của điện áp nút trong
tình trạng khẩn cấp.
+ string = ‘EVLMLO’: Trả về giới hạn dưới của điện áp nút trong
tình trạng khẩn cấp.
Để rõ hơn, xét ví dụ sau: lấy thông tin về điện áp thực và Zone của
các nút có chỉ số từ 825021 đến 826001:
#######################################################
# Đoạn chương trình này luôn phải có khi viết một chương trình python
để xử lý các tác vụ trên PSS/E, nó có chức năng tạo đường dẫn đến nơi
chứa các module cần thiết và khởi tạo môi trường PSS/E và gọi file cần
làm việc
import os, sys
PYTHONPATH = r'C:\Program Files (x86)\PTI\PSSE33\pssbin'
sys.path.append(PYTHONPATH)
os.environ['PATH'] += ';' + PYTHONPATH
import psspy
psspy.throwPsseExceptions = True
import redirect
redirect.psse2py()
psspy.psseinit(100)
psspy.case(r'C:\Users\nhanlp\Desktop\pss\Tuan_10_max.sav')
#######################################################
ibus = 0
# Khởi tạo nút đầu tiên là 825021
ierr = psspy.inibus(825021)
#Tạo vòng lặp với điều kiện các nút phải nhỏ hơn 82600
while ibus < 826000:
# Mỗi lần lặp sẽ tự động gán nút tiếp theo vào biến ibus
ierr, ibus, cval = psspy.nxtbus()
#Lấy thông tin về điện áp thực của nút ibus
ierr, rval = psspy.busdat(ibus ,'KV')
#Lấy thông tin về Zone của nút ibus
ierr, ival = psspy.busint(ibus ,'ZONE')
# In thông tin kết quả ra màn hình
print (ibus), cval, rval, ival
 Kết quả như sau:

825021 XUAN_HA 110.00 117.080307007 703
825024 XUAN_HA_T2 22.000 23.3006782532 703
825029 XUAN_HA_T2 6.6000 6.69634437561 703
825501 LIEN_TRI 110.00 116.548851013 703
825515 LIEN_TRI_T1 22.000 24.1731319427 703
825525 LIEN_TRI_T2 22.000 25.1672973633 703
826001 CAU_DO 110.00 117.430938721 703
3. Lấy thông số của nhiều nút trong một subsystem
Để lấy thông số của nhiều nút trong một subsystem, ta thực hiện như sau:
Các hàm được sử dụng:

 Hàm psspy.bsys
 Cú pháp của hàm như sau:
ierr = psspy.bsys(sid, usekv, basekv, numarea, areas, numbus, buses,
numowner, owners, numzone, zones)
Trong đó:
- sid: Chỉ số của subsystem cần tạo, sid có thể có giá trị từ 0 đến 11,
nếu sid = -1 có nghĩa là subsystem chính là cả hệ thống đang xét.
- usekv: usekv = 1 Sử dụng giá trị điện áp basekv
usekv = 0 Không dụng giá trị điện áp basekv
- basekv: Là một list có 2 giá trị: Điện áp định mức nhỏ nhất và lớn
nhất mà các nút trong subsystem có thể có.
- numarea: Số lượng các AREA
- areas: Là một list gồm các chỉ số của các AREA của các nút trong
subsystem.
- numbus: Số lượng các bus có trong subsystem
- buses: Là một list gồm các chỉ số của các AREA của các nút trong
subsystem.
- numowners: Số lượng các OWNER có trong subsystem
- owners: Là một list gồm các chỉ số của các OWNER của các nút
trong subsystem.
- numozones: Số lượng các ZONE có trong subsystem
- zones: Là một list gồm các chỉ số của các ZONE của các nút trong
subsystem.
 Hàm psspy.aBusInt
 Hàm này trả về giá thông số (số nguyên) của các nút trong một subsystem.
 Cú pháp như nhau:
ierr, iarray = abusint(sid, flag, string)

Trong đó:
- ierr: Biến báo lỗi.
- iarray: Một list chứa thông số chứa thông số của các nút.
- sid: Chỉ số của subsystem.
- flag: flag = 1 chỉ lấy thông số các nút đang hoạt động.
flag = 2 Lấy thông số tất cả các nút.
- string: string = ’NUMBER’ : Lấy chỉ số các các nút
string = ’TYPE’ : Loại nút
string = ’AREA’: Lấy chỉ số AREA của các nút
string = ’ZONE’: Lấy chỉ số ZONE của các nút
string = ’OWNER’: Lấy chỉ số OWNER của các nút
string = ’DUMMY’ : Xác định nút có phải là nút DUMMY hay
không nếu giá trị trả về là 1 thì đó là nút DUMMY và 0 hì ngược
lại.
 Hàm aBusReal
 Hàm này trả về giá thông số (số thực) của các nút trong một subsystem.
 Cú páp như sau:
ierr, rarray = abusreal(sid, flag, string)
Trong đó:
- rarray: Một list chứa thông số chứa thông số của các nút.
- sid: Chỉ số của subsystem.
- flag: flag = 1 chỉ lấy thông số các nút đang hoạt động.
flag = 2 Lấy thông số tất cả các nút.
- string: string = ’BASE’ : Lấy điện áp cơ bản của các nút, kV.
string = ’PU’ : Lấy điện áp thực của các nút trong đơn vị tương
đối.
string = ’KV’: Lấy điện áp thực của các nút, kV.
string = ’ANGLE’: Lấy góc pha của điện áp nút, radian.
string = ’ ANGLED’: Lấy góc pha của điện áp nút, độ.
string = ’NVLMHI’: Giới hạn trên của điện áp trong điều kiện
bình thường, kV.
string = ’NVLMLO’: Giới hạn dưới của điện áp trong điều kiện
bình thường, kV.
string = ’EVLMHI’: Giới hạn trên của điện áp trong điều kiện
khẩn cấp, kV.
string = ’EVLMLO’: Giới hạn dưới của điện áp trong điều kiện
khẩn cấp, kV.
string = ’MISMATCH’: Độ lệch công suất tại nút, MVA.
 Để rõ hơn, xét ví dụ sau: Tạo Subsystem là các nút 110kV tại khu vực
thành phố Đà Nẵng, lấy chỉ số nút, điện áp thực và góc pha của các nút
đó:
###########################################################
# Đoạn chương trình này đã được giải thích ở ví dụ trên
import os, sys
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(100)
###########################################################
# Cho id của bussystem cần tạo là 0
sid = 0
# Sử dụng điện áp định mức
usekv = 1
# Các nút ở khu vực 703 chỉ có điện áp từ 110kV trở xuống, do vậy lấy điện
áp định mức nhỏ nhất của subsytem là 110 thì sẽ lấy được tất cả các nút 110kV
và loại những nút dưới 100kV
basekv = [110, 500.]
# Không tạo subsytem theo AREA
numarea = 0
areas = []
# Không tạo subsytem theo BUS
numbus = 0
buses = []
# Không tạo subsytem theo OWNER
numowner = 0
owners = []
# subsystem có 1 ZONE
numzone = 1
# ZONE Đà Nẵng có chỉ số là 703
zone = [703]
# Tạo subsytem
ierr = psspy.bsys(sid, usekv , basekv , numarea, areas, numbus, buses,
numowner, owners, numzone, zone)
# Lấy số nút của các nút trong subsystem
ierr, iarray = psspy.abusint(sid = 0, flag = 2, string = 'NUMBER')
# Lấy điện áp thực của các nút trong subsystem
ierr, rarray_1 = psspy.abusreal(sid = 0, flag = 2, string= 'KV')

# Lấy góc pha của các nút trong subsystem
ierr, rarray_2 = psspy.abusreal(sid = 0, flag = 2, string= 'ANGLED')
#In kết quả
print ('So nut:'), iarray
print ('Dien ap:'), rarray_1
print ('Goc pha:'), rarray_2
Kết quả là:

So nut: [[823001, 823501, 824001, 824301, 824501, 825001, 825021,
825501, 826001, 826501, 827001, 827501]]
Dien ap: [[117.82196807861328, 117.68585968017578,

117.66433715820312,
117.78779602050781,117.87603759765625,117.08030700683594,
117.08030700683594,116.5488510131836,117.43093872070312,
116.75641632080078, 116.43423461914062, 117.40988159179688]]
Goc pha: [[7.4029927253723145, 7.205630302429199,
7.185743808746338,
7.311567306518555,7.4159369468688965,6.92713737487793,
6.92713737487793,6.6564226150512695,7.550564765930176,
6.854454040527344, 6.562218189239502, 7.705606937408447]]
II. THAY ĐỔI DỮ LIỆU HỆ THỐNG ĐIỆN
Các hàm thay đổi dữ liệu của hệ thống có thể tham khảo tại Chapter 2 – Power
Flow Change ở tài liệu API. Sau đây sẽ trình bày cách thay đổi thông số của nút
và đường dây trong hệ thống.
1. Thay đổi thông số nút
 Để thay đổi thông số hoặc thêm một nút mới vào work case ta sử dụng hàm
bus_data_3.
 Cú pháp hàm như sau:
ierr = psspy.bus_data_3(i, intgar, realar, name)
Trong đó:
- i: Nút muốn thay đổi
- ingar là một list gồm 4 phần tử (ingar chỉ có giá trị khi muốn tạo nút
mới):
 INTGAR(1) IDE, loại nút
 INTGAR(2) AREA, chỉ số AREA của nút
 INTGAR(3) ZONE, chỉ số ZONE của nút
 INTGAR(4) OWNER, chỉ số OWNER của nút
- realar là một list gồm 7 phân tử, đó là các thông số của nút có thể thay
đổi:
 REALAR(1) BASKV, Điện áp cơ bản của nút (0.0 by default).
 REALAR(2) VM, Biên độ điện áp của nút trong đơn vị tương
đối (1.0 by default)
 REALAR(3) VA, Góc lệch pha điện áp (0.0 by default).
 REALAR(4) NMAXV, Giới hạn trên của điện áp nút trong điều
kiện bình thường, pu
 REALAR(5) NMINV, Giới hạn dưới của điện áp nút trong điều
kiện bình thường, pu
 REALAR(6) EMAXV, Giới hạn trên của điện áp nút trong điều
kiện khẩn cấp, pu
 REALAR(7) EMINV, Giới hạn dưới của điện áp nút trong điều
kiện khẩn cấp, pu
- name: Tên của nút mới cần tạo
Ví dụ: Thay đổi góc lệch điện áp của nút Hòa Liên 110kV từ 7.30 lên 100 và giới
hạn trên của điện áp trong điều hiệm khẩn cấp từ 1.1 lên 1.15.
import os, sys
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(100)
# Thay đổi thông số của nút 824301, ở đây không sử dụng đối số là: ingar và
name của hàm bus_chng_3 bởi vì ta chỉ thay đổi thông số của muốn đã tồn tại
chứ không tạo nút mới.
psspy.bus_chng_3(824301,realar3 = 10, realar6 = 1.15)
Kết quả:
Power flow data changed for bus 824301 [HOA_LIEN 110.00]:
X--ORIGINAL--X X-NEW VALUE--X DATA ITEM
7.31157 10.0000 VA
1.10000 1.15000 EMAXV
2. Thay đổi thông số đường dây
 Để thay đổi thông số đường dây hoặc tạo đường dây mới, ta dùng hàm
branch_data_3.
ierr = psspy.branch_data_3(i, j, ckt, intgar, realer, ratings, namear)
Trong đó:
- i: Nút đầu đường dây
- j: Nút cuối đường dây
- ckt: Chỉ số thứ tự của đường dây nếu giữa 2 nút i, j có nhiều đường
dây
- intgar: là một list gồm 6 phần tử (chỉ dùng khi tạo đường dây mới):
 INTGAR(1) ST, trạng thái vận hành của đường dây (đang vận
hành hay đang cắt)
 INTGAR(2) METBUS, Vị trí đặt thiết bị đo đếm (ở nút i hay
nút j)
 INTGAR(3) O1, OWNER thứ nhất (mặc định là OWNER nút
i)
 INTGAR(4) O2, OWNER thứ hai.
 INTGAR(5) O3, OWNER thứ ba.
 INTGAR(6) O4, OWNER thứ tư.
- realar: là một list gồm 12 phần tử, là các thông số đường dây có thể
thay đổi:
 REALAR(1) R, Điện trở của đường dây
 REALAR(2) X, Điện kháng của đường dây.
 REALAR(3) B, Dung dẫn đường dây.

 REALAR(4) GI, điện dẫn tại nút i.
 REALAR(5) BI, dung dẫn tại nút i.
 REALAR(6) GJ, điện dẫn tại nút j.
 REALAR(7) BJ, dung dẫn tại nút j.
 REALAR(8) LEN, chiều dài đường dây.
 REALAR(9) F1, tỉ lệ sở hữu của OWNER 1.
- Rating: mức mang tải của đường dây, PSS34 cho phép người dùng đặt
tối đa 12 mức mang tải.
- namear: Tên đường dây
Ví dụ: Thay đổi dường dây Lăng Cô – Hòa Khánh đang sử dụng loại dây
AC-185 sang loại dây AC – 240:
import os, sys
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(100)
_i = psspy.getdefaultint()
_f = psspy.getdefaultreal()
# Thay đổi thông số đường dây
ierr = psspy.branch_chng(819001,824501,r"""1""",[_i,_i,_i,_i,_i,_i],
[0.03715,0.11397,0.01158,_f,_f,_f,_f,_f,_f,_f,_f,_f,_f,_f,_f])
Kết quả:
Power flow data changed for non-transformer branch circuit "1"
from 819001 [LANG_CO 110.00] to 824501 [HOA_KHANH
110.00]:
X--ORIGINAL--X X-NEW VALUE--X DATA ITEM
0.124400E-01 0.371500E-01 R
0.317500E-01 0.113970 X
0.310000E-02 0.115800E-01 B
 Lưu ý:
- Các biến _i, _f, _s gọi là các biến “giữ vị trí”, đó là những thông số
không cần thay đổi, ví dụ như trong ví dụ trên là chiều dài đường dây.
- _i sử dụng để thay thế cho một số nguyên, _f để thay thế cho một số
thực, _s để thay thế cho một chuỗi.
- Để sử dụng được các biến này, ta phải khai báo bằng hàm:
_i = psspy.getdefaultint() # for integers
_f = psspy.getdefaultreal() # for floating points
_s = psspy.getdefaultchar() # for strings
CHƯƠNG 5
TÍNH TOÁN TRÀO LƯU CÔNG SUẤT VÀ NGẮN MẠCH
TRONG HỆ THỐNG ĐIỆN
I. TRÀO LƯU CÔNG SUẤT (POWER FLOW)
1. Các lệnh để tính trào lưu công suất
a) Lệnh fnsd:
 Tính trào lưu công suất theo phương pháp Fixed slope decoupled Newton-
Raphson.
 Cú pháp: ierr = psspy.fdns(options)
Trong đó:
- option: Là một list gồm 8 phần tử, dùng để thiết lập các điều kiện
của phương pháp giải:
 OPTIONS(1) Điều chỉnh nấc phân áp
OPTIONS(1) = 0 Không cho điều chỉnh nấc phân áp;
OPTIONS(1) = 1 Điều chỉnh nấc tự động theo từng nấc;
OPTIONS(1) = 2 Điều chỉnh nấc phân áp trực tiếp đến vị trí xác lập
tối ưu;
 OPTIONS(2) Điều chỉnh công suất nút slack để giữ vùng liên kết
trong giới hạn cho phép.
OPTIONS(2) = 0 Không sử dụng;
OPTIONS(2) = 1 Chỉ đối với đường dây liên kết;
OPTIONS(2) = 2 Đối với đường dây liên kết và tải;
 OPTIONS(3) Điều chỉnh góc pha của bộ thay đổi pha.
OPTIONS(3) = 0 Kích hoạt
OPTIONS(3) = 1 Không kích hoạt
 OPTIONS(4) Điều chỉnh nấc phân áp của bộ chuyển đổi DC.
 OPTIONS(5) Điều chỉnh các thiết bị bù có thể đóng cắt.
OPTIONS(5) = 0 Khóa tất cả;
OPTIONS(5) = 1 Kích hoạt tất cả;
OPTIONS(5) = Kích hoạt bù trơn, khóa bù từng cấp;
 OPTIONS(6) Tính toán sử dụng trạng thái ban đầu
OPTIONS(6) = 0 Không sử dụng trạng thái ban đầu
OPTIONS(6) = 1 Sử dụng trạng thái ban đầu
OPTIONS(6) = 2 Khởi tạo trạng thái ban đầu sau đó ước lượng biên
độ điện áp;
OPTIONS(6) = 3 Khởi tạo trạng thái ban đầu sau đó ước lượng góc
pha;
OPTIONS(6) = 4 Khởi tạo trạng thái ban đầu sau đó ước lượng biên
độ điện áp và góc pha;
 OPTIONS(7) Giới hạn VAR
OPTIONS(7) = 0 Áp dụng ngay từ vòng lặp đầu
OPTIONS(7) = 0 Áp dụng cho vòng lặp thứ n (hoặc sớm hơn nếu
sai số nhỏ)
OPTIONS(7) = -1 Không áp dụng

 OPTIONS(8) non-divergent solution flag (use non-divergent
solution option setting by default)
b) Lệnh fnsl
 Tính trào lưu công suất theo phương pháp Full Newton-Raphson.
 Cú pháp: ierr = psspy.fnsl(options)
c) Lệnh nsol
 Tính trào lưu công suất theo phương pháp Decoupled Newton Raphson.
 Cú pháp: ierr = psspy.nsol(options)
 Các option của lệnh fnsl và nsol tương tự với lệnh fnsd đã giải thích ở trên.
d) Lệnh solv
 Tính trào lưu công suất theo phương pháp Gauss-Seide.
 Cú pháp: ierr = psspy.solv(options)
e) Lệnh mslv
 Tính trào lưu công suất theo phương pháp Gauss-Seide điều chỉnh.
 Cú pháp: ierr = psspy.mslv(options)
2. Ví dụ
Tính trào lưu công suất của hệ thống bằng phương pháp Full Newton –
Raphson và đưa ra số vòng lặp đã thực hiện.
import os, sys
PYTHONPATH = r'C:\Program Files\PTI\PSSE33\PSSBIN'
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(100)
psspy.case(r'C:\Users\nhanlp\Desktop\pss\pss\Tuan_09_max.sav')
# Tính trào lưu công suất bằng phương pháp Full Newton - Raphon
psspy.fnsl([0,0,0,1,1,0,0,0])
# Gán số vòng lặp đã thực hiện cho biến munber_iterations
number_iterations = psspy.iterat()
# In số vòng lặp ra màn hình
msg = "So vong lap la: %s"
print msg % number_iterations
Kết quả:
TUAN 10 (27/02/2017 - 05/03/2017)
CHE DO CAO DIEM CHIEU - VAN HANH BINH THUONG
The Saved Case in file C:\Users\nhanlp\Desktop\pss\Tuan_10_max.sav was saved on THU,

FEB 23 2017 9:03
The following option settings are changed to the settings contained in the Saved Case File:
** SHORT CIRCUIT UNITS option setting set to PHYSICAL UNITS
** SHORT CIRCUIT COORDINATES option setting set to POLAR

** MATRIX GROWTH FACTOR option setting set to 2.25
** MULTI-SECTION LINE REPORTING option setting set to DISABLE
** TRANSFORMER PERCENT LOADING UNITS option setting set to CURRENT
ITER DELTAP BUS DELTAQ BUS DELTA/V/ BUS DELTAANG BUS

0 0.0000( 300712 ) 0.0000( 300750 )
0.00000( 144814 ) 0.00000( 144814 )
1 0.0000( 165321 ) 0.0000( 300750 )
Reached tolerance in 1 iterations
Largest mismatch: 0.00 MW -0.00 Mvar 0.00 MVA at bus 300712 [HOA_BINH
220.00]
System total absolute mismatch: 0.00 MVA
SWING BUS SUMMARY:
BUS# X-- NAME --X BASKV PGEN PMAX PMIN QGEN QMAX QMIN
7052 TAN_KIEU 220.00 67.3 300.0 0.0 20.6 200.0 -200.0
7152 MA_GUAN 220.00 108.0 300.0 0.0 -7.7 200.0 -200.0
300710 HOA_BINH_H1 15.750 -226.5* 240.0 170.0 15.1 114.7 -160.0
So vong lap la: 1
II. TÍNH TOÁN NGẮN MẠCH TRONG HỆ THỐNG ĐIỆN

1. Các lệnh để tính toán ngắn mạch
a) Lệnh ascc_3
 Được dùng để tính tất cả các dạng ngắn mạch: 3 pha, 1 pha, 2 pha, 2
pha chạm đất.
 Có thể tính được nhiều sự cố một lúc.
 Cú pháp: iree = psspy. ascc_3(sid, all, status, values, relfil, fcdfil,
scfile)
Trong đó:
- sid: Chỉ số subsystem
- all: Số lượng các bus được lựa chọn để tính ngắn mạch
 all = 1: Tính cho tất cả các bus trong hệ thống
 all = 2: Tính cho các bus trong subsystem đã lựa chọn
 status: là một list gồm 17 phần tử dùng để cài đặt các điều kiện và trạng
thái để tính toán ngắn mạch, ý nghĩa của từng phần tử có thể tham khảo
chi tiết ở tài liệu API kèm theo chương trình.
 relfil: File dữ liệu rơle, mặc định để trống.
 fcdfil: File điều khiển sự cố.
 scfile: File kết quả tính toán.
b) Lệnh scmu_2
 Dùng để tính toán và xuất kết quả các dạng ngắn mạch đối xứng và
không đối xứng.
 Cú pháp: iree = scmu_2 (apiopt, options, rval, cktarg)
c) Lệnh ansi_2
 Dùng để tính ngắn mạch theo tiêu chuẩn ansi.
 Cú pháp: ierr = psspy.ansi_2(options, values, inarg, busary, vltary,
cptary, filarg)
2. Ví dụ
Tính ngắn mạch 3 pha và 1 pha trên thanh cái 110kV của trạm An Đồn.
import os, sys
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(100)
# Tạo subsystem gồm 1 nút 827001
psspy.bsys(1,0,[0.0,0.0],0,[],1,[827001],0,[],0,[])
# Tính ngắn mạch 3 pha và 1 pha
psspy.ascc_3(1,0,[1,0,0,0,0,3,0,0,0,0,1,0,0,0,0,0,0], 1.0,"","","")
Kết quả:
Ngắn mạch 3 pha:
AT BUS 827001 [AN_DON 110.00] AREA 30 *** FAULTED BUS IS: 827001 [AN_DON 110.00] *** 0 LEVELS AWAY ***
(kV L-G) V+:/0.000/0.00 VA:/0.000/0.00 VB:/0.000/0.00 VC:/0.000/0.00
THEVENIN IMPEDANCE, X/R (PU) Z+:/0.052373/72.380, 3.14850
THEVENIN IMPEDANCE, X/R (OHM) Z+:/6.337/72.380, 3.14850
X----------------------------------------THREE PHASE FAULT---------------------------------------X
X--------- FROM ----------X AREA CKT I/Z /I+/ AN(I+) /IA/ AN(IA) /IB/ AN(IB) /IC/ AN(IC) /Z+/ AN(Z+) APP X/R
826501 [NGU HANH SON110.00] 30 1 AMP/OHM 10607.9 -65.82 10607.9 -65.82 10607.9 174.18 10607.9 54.18 2.00 68.60 2.551
827014 [AN DON_T1 22.000] 30 1 AMP/OHM 0.0 0.00 0.0 0.00 0.0 0.00 0.0 0.00 0.00 0.00 0.000
827024 [AN DON_T2 22.000] 30 1 AMP/OHM 0.0 0.00 0.0 0.00 0.0 0.00 0.0 0.00 0.00 0.00 0.000
INITIAL SYM. S.C. CURRENT(I''k)(RMS) AMP 10607.9 -65.82 10607.9 -65.82 10607.9 174.18 10607.9 54.18
-------------------------------------------------------------------------------------------------------------------
Ngắn mạch 1 pha:

AT BUS 827001 [AN_DON 110.00] AREA 30 *** FAULTED BUS IS: 827001 [AN_DON 110.00] *** 0 LEVELS AWAY ***
(kV L-G) V+:/47.343/7.51 V-:/19.971/-175.70 V0:/27.426/-170.15 VA:/0.000/0.00 VB:/73.237/-117.55 VC:/69.378/132.85
THEVENIN IMPEDANCE, X/R (PU) Z+:/0.052373/72.380, 3.14850 Z-:/0.052552/72.367, 3.14605 Z0:/0.072170/77.916, 4.67075
THEVENIN IMPEDANCE, X/R (OHM) Z+:/6.337/72.380, 3.14850 Z-:/6.359/72.367, 3.14605 Z0:/8.733/77.916, 4.67075
X------------------------------------LINE TO GROUND (LG) FAULT-----------------------------------X
X--------- FROM ----------X AREA CKT I/Z /I+/ AN(I+) /I-/ AN(I-) /I0/ AN(I0) /3I0/ AN(I0) /Z+/ AN(Z+) APP X/R
826501 [NGU HANH SON110.00] 30 1 AMP/OHM 3193.6 -65.77 3116.9 -69.04 3140.7 -68.07 9422.0 -68.07 2.99 -98.16 6.975
827014 [AN DON_T1 22.000] 30 1 AMP/OHM 71.8 -179.32 30.3 -2.53 0.0 0.00 0.0 0.00 0.00 0.00 0.000
827024 [AN DON_T2 22.000] 30 1 AMP/OHM 66.0 -179.73 27.8 -2.94 0.0 0.00 0.0 0.00 0.00 0.00 0.000
INITIAL SYM. S.C. CURRENT(I''k)(RMS) AMP 3140.7 -68.07 3140.7 -68.07 3140.7 -68.07 9422.0 -68.07
--------------------------------------------------------------------------------------------------
X--------- FROM ----------X AREA CKT I/Z /IA/ AN(IA) /IB/ AN(IB) /IC/ AN(IC) /ZA/ AN(ZA) APP X/R
826501 [NGU HANH SON110.00] 30 1 AMP/OHM 9448.4 -67.61 176.5 -103.51 172.0 102.93 3.24 72.71 3.213
827014 [AN DON_T1 22.000] 30 1 AMP/OHM 41.6 -176.98 92.0 76.68 89.7 -76.87 3.61 87.10 19.726
827024 [AN DON_T2 22.000] 30 1 AMP/OHM 38.2 -177.39 84.5 76.27 82.3 -77.28 3.93 87.48 22.752
INITIAL SYM. S.C. CURRENT(I''k)(RMS) AMP 9422.0 -68.07 0.0 0.00 0.0 0.00
III. MODULE EXCELPY

1. Giới thiệu
 Module excelpy dùng để liên kết giữa môi trường python và excel, để điều khiển
các tiến trình trên excel thông qua ngôn ngữ python.
 Được ứng dụng để xuất kết quả sau khi tính toán trên python ra các bảng excel hoặc
nhập các thông số từ excel vào python để xử lý.
 Module này được cài đặt kèm theo chương trình PSS/E.
 Chi tiết về module excelpy có thể tham khảo Chapter 20 ở tài liệu API.
2. Ví dụ
Xuất ra bảng Excel số nút, tên và điện áp của các nút 110kV thuộc Zone Đà Nẵng:
# Cài đặt đường dẫn cho các module cần thiết

import os, sys
import excelpy
# Mở một workbook excel
xl = excelpy.workbook()
xl.show()
# Tại ô A1 điền vào Bus Numbers
xl.set_cell('a1', 'Bus Numbers')
# Tại ô B1 điền vào Bus Names
xl.set_cell('b1', 'Bus Names')
# Tại ô C1 điền vào Voltage (kV)
xl.set_cell('c1', 'Voltage (kV)')
import psspy
import redirect
redirect.psse2py()
psspy.psseinit(10000)
# Tạo một subsystem gồm các nút 110kV của Zone Đà Nẵng
sid = 0
usekv = 1
basekv = [110, 110]
numarea = 0
areas = []
numbus = 0
buses = []
numowner = 0
owners = []
numzone = 1
zone = [703]
ierr = psspy.bsys(sid, usekv , basekv , numarea, areas, numbus, buses, numowner,

owners, numzone, zone)
# Gán chỉ số nút của các nút trong subsystem vào biến buses
ierr, buses = psspy.abusint(sid = 0, flag = 2, string = 'NUMBER')
# Gán tên của các nút trong subsystem vào biến names
ierr, names = psspy.abuschar(sid = 0, flag = 2, string = 'NAME')
# Gán điện áp của các nút trong subsystem vào biến volts
ierr, volts = psspy.abusreal(sid = 0, flag = 2, string= 'KV')
# Xuất dữ liệu sang bảng Excel
xl.set_range(2,'a', zip(*buses))
xl.set_range(2,'b', zip(*names))
xl.set_range(2,'c', zip(*volts))
Kết quả:

Lap Trinh Python Trong PSSE - 2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lap Trinh Python Trong PSSE - 2

Uploaded by

Copyright:

Available Formats

Ứng dụng ngôn ngữ Python trong PSS/E 1

1. Các phương pháp trích xuất dữ liệu hệ thống ................................................................... 31

complex Số phức 1.23 + 4.56j

b) Tương tác với kiểu String

s = 'abcd' + 'efgh' # s = 'abcdefgh'

- Lặp lại các phần tử trong một chỗi:

tup1 = () # Tuple trống

tup2 = (55,) # Tuple có 1 phần tử là số

tup3 = (5, 8, 'with parentheses',628.7)

tup4 = 5, 8, 'no parentheses' , 628.7

tup5 = (a, [1, 2, 3], 'AREA' , (7, 8, 9.1))

Một số hàm trong PSS/E có giá trị trả về là một Tuple

 Key và value của Dictionary có thể có nhiều kiểu khác nhau

y = list('abcd') # y = ['a', 'b', 'c', 'd']

print('This # is not a comment')

II. BIẾN VÀ TOÁN TỬ TRONG PYTHON

% Phép chia lấy phần dư

** Phép lấy số mũ (ví dụ 2**3 cho kết quả là 8)

> Lớn hơn

<= Nhỏ hơn hoặc bằng

<= Lớn hơn hoặc bằng

<> Không bằng (tương tự !=)

c) Toán tử gán trong Python

%= Chia lấy phần dư và gán

**= Lấy số mũ và gán

//= Thực hiện phép chia // và gán

Kết quả trả về là:

 Lưu đồ như sau:

Kết quả là:

 Lưu đồ như sau:

4. Lồng nhiều lệnh if

Ví dụ 4: Sử dụng vòng lặp for với lệnh range:

busnums = [101, 202, 214, 227]

for letter in 'Python':

Chu cai hien tai : n

def tên_hàm( đối_số ):

3. Ví dụ tạo một số hàm đơn giản

import module1[, module2][,... moduleN]

#Lưu lại code này với tên là addition.py

b) Sử dụng lệnh from…import

def circle(r): # Hinh tron

def square(l): # Hinh vuong

def rectangle(l,b): # Hinh chu nhat

def triangle(b,h): # Hinh tam giac

import module_name as different_name

 Ví dụ: ta có một module có tên là my_updated_module_ver4, để sử

ierr = psspy.bus_number(ibus, newbus)

Các hàm được sử dụng

 Kết quả như sau:

Các hàm được sử dụng:

ierr, iarray = abusint(sid, flag, string)

ierr, rarray_1 = psspy.abusreal(sid = 0, flag = 2, string= 'KV')

Kết quả là:

Dien ap: [[117.82196807861328, 117.68585968017578,

 REALAR(3) B, Dung dẫn đường dây.

OPTIONS(7) = -1 Không áp dụng

The Saved Case in file C:\Users\nhanlp\Desktop\pss\Tuan_10_max.sav was saved on THU,

** SHORT CIRCUIT COORDINATES option setting set to POLAR

** MATRIX GROWTH FACTOR option setting set to 2.25

** MULTI-SECTION LINE REPORTING option setting set to DISABLE

** TRANSFORMER PERCENT LOADING UNITS option setting set to CURRENT

ITER DELTAP BUS DELTAQ BUS DELTA/V/ BUS DELTAANG BUS

II. TÍNH TOÁN NGẮN MẠCH TRONG HỆ THỐNG ĐIỆN

Phép lấy số mũ (ví dụ 23 cho kết quả là 8)