A

ka
rs
ha
n
A
ro
ra
 CONTENTS

ra
ro
1 Chapter 1: Why Python for VLSI Engineers? 2
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Why Python is Better than Tcl and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Why Learning Python is Essential for the Future . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

A
2 Chapter 2: Installing Python for VLSI Engineers 5
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Installing Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Installing pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Choosing a Code Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
n
3 Chapter 3: Understanding the Basics Before Writing Python Code 8
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
ha
3.2 What is a Variable? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3 What is a Data Type? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.4 What is a Comment? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.5 What is a Script? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.6 What is a Function? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.7 What is a Module? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
rs

3.8 What is a Package? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.9 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4 Chapter 4: Writing Your First Python Script 14

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ka

4.2 Step-by-Step Guide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.3 Explaining the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.4 Common Mistakes to Avoid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.5 Comparison to TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.6 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
A

5 Chapter 5: Understanding Data Types with VLSI Use Cases 16

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.2 Numeric Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.3 Text Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.4 Boolean (bool) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.5 List (list) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.6 Dictionary (dict) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.7 Tuple (tuple) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

i
 5.8 None Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.9 Summary Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6 Chapter 6: Exploring Integer Operations for VLSI Use Cases 21

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.2 Common Use Cases of Integers in VLSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.3 Basic Arithmetic Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.4 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.5 Useful Integer Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

ra
6.6 Type Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.7 Bitwise Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.8 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

ro
7 Chapter 7: Working with Floats for VLSI Use Cases 25
7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2 Common Use Cases of Floats in VLSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.3 Declaring Float Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.4 Basic Float Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.5 Comparison of Floats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

A
7.6 Type Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.7 Useful Functions with Floats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.8 Float Precision and Tolerance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.9 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

8 Chapter 8: Working with Strings for VLSI Use Cases 29

n
8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2 Common Use Cases of Strings in VLSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3 Declaring Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
ha
8.4 String Concatenation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.5 String Formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.6 Useful String Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
8.7 Regular Expressions (Advanced) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.8 Comparing Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.9 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
rs

9 Chapter 9: Boolean Logic and Control Flow for VLSI Automation 33

9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2 What is a Boolean? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3 Values Interpreted as Boolean in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
ka

9.4 Boolean Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

9.5 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.6 Control Flow: if, elif, else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.7 Use Case: Checking File Existence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.8 Use Case: Enable/Disable Feature Based on Flag . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.9 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
A

10 Chapter 10: Working with Lists for VLSI Data Handling 39

10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.2 What is a List? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.3 VLSI Use Cases for Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.4 Creating Lists in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.5 Accessing List Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.6 Modifying Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.7 Adding Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

ii
 10.8 Removing Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.9 Looping Through a List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.10 Checking Membership . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.11 List Length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.12 Sorting Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.13 Other Useful Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.14 Comparing with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.15 List Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
10.16 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

ra
11 Chapter 11: Using Dictionaries for Structured Data in VLSI 44
11.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
11.2 What is a Dictionary? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
11.3 VLSI Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

ro
11.4 Creating a Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.5 Accessing Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.6 Adding and Modifying Entries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.7 Deleting Entries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.8 Dictionary Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.9 Looping Over a Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

A
11.10 Nested Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.11 Comparison with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.12 Summary Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

12 Chapter 12: Using Tuples for Fixed Data in VLSI 48

12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
n
12.2 What is a Tuple? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
12.3 VLSI Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
12.4 Creating Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
ha
12.5 Accessing Tuple Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.6 Looping Through Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.7 Why Use Tuples? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.8 Tuple in Lists and Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.9 Comparison with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
12.10 Common Pitfalls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
rs

12.11 Summary Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

13 Chapter 13: Using Sets for Unique Data in VLSI 52

13.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
13.2 What is a Set? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
ka

13.3 VLSI Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

13.4 Creating Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
13.5 Adding and Removing Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
13.6 Checking Membership . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
13.7 Set Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
13.8 Why Use Sets? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
A

13.9 Common Pitfalls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

13.10 Comparison with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
13.11 Summary Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

14 Chapter 14: Control Flow in Python for VLSI Automation 56

14.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
14.2 Conditional Statements: if, elif, else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
14.3 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
14.4 Logical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

iii
 14.5 Loops in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
14.6 Loop Control Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
14.7 pass Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
14.8 match Statement (Python 3.10+) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
14.9 Comparison with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
14.10 Summary Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

15 Chapter 15: Functions in Python for VLSI Automation 63

15.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
15.2 Why Use Functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

ra
15.3 Functions with Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
15.4 Return Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
15.5 Default Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
15.6 Positional vs Keyword Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

ro
15.7 *args: Variable-Length Positional Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
15.8 **kwargs: Variable-Length Keyword Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
15.9 Comparison with TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
15.10 Common Pitfalls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
15.11 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

A
16 Chapter 16: File Handling in Python for VLSI Engineers 69
16.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
16.2 Opening Files in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
16.3 Reading Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
16.4 Writing to Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
16.5 Reading Compressed Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
n
16.6 File Existence and Type Checks with pathlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
16.7 Why pathlib is Better Than os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
16.8 Comparison: TCL and Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
ha
16.9 Common Pitfalls (with Fixes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
16.10 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

17 Chapter 17: Parsing Structured Data with Python 76

17.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
17.2 Reading and Splitting Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
rs

17.3 Using Delimiters in .split() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

17.4 Filtering Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
17.5 Store and Sort Violations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
17.6 Using in to Search for Terms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
17.7 Parsing with Regular Expressions (re) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
ka

17.8 VLSI Use Case: Extract Net Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

17.9 Common Pitfalls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
17.10 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

18 Chapter 18: Command-Line Arguments in Python for VLSI Engineers 81

18.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
A

18.2 Using argparse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

18.3 Using click . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
18.4 Sample Netlist File Content (design.v) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
18.5 Why click is Better than argparse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
18.6 Common Pitfalls and Fixes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
18.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

iv
 CHAPTER

ONE

CHAPTER 1: WHY PYTHON FOR VLSI ENGINEERS?

ra
1.1 Introduction

ro
VLSI design involves handling large data files, automating tool runs, and analyzing reports. Traditionally, engineers
have used scripting languages like Tcl and Perl for these tasks. However, Python is quickly becoming the preferred
choice due to its simplicity, readability, and powerful libraries.
In this chapter, we will explore why Python is better than Tcl and Perl and why learning it is essential for the future of

A
VLSI engineering.

1.2 Why Python is Better than Tcl and Perl

n
1.2.1 Readability and Simplicity
Python is easier to read and write compared to Tcl and Perl. Its syntax is clear, making scripts more maintainable.
ha
Python:

with open("report.txt", "r") as file:

for line in file:
print(line.strip())
rs

Perl:

open(my $fh, '<', "report.txt") or die "Cannot open file: $!";

while (my $line = <$fh>) {
ka

chomp $line;
print "$line\n";
}
close($fh);

Tcl:
A

set file [open "report.txt" r]

while {[gets $file line] != -1} {
puts $line
}
close $file

Python requires fewer lines of code and is easier to understand, making it ideal for engineers who are new to program-
ming.

2
 Crack VLSI Python Interview

1.2.2 Modern and Future-Proof

• Python is widely used across industries, including AI, data science, and automation.
• New tools and frameworks are being developed in Python, while Tcl and Perl are becoming outdated.
• Python is supported by major EDA vendors (Synopsys, Cadence, ANSYS), ensuring its relevance in VLSI work-
flows.
• Python’s active community and continuous updates make it more adaptable to future needs in the semiconductor
industry.

ra
• Python is much faster than Tcl and Perl.
• AI provides much better code for Python than Tcl and Perl.

1.2.3 Better Libraries and Integration

ro
Python provides built-in libraries for automation and data analysis:
• Pandas: Process output reports
• Matplotlib: Plot scatter plots, histograms, and box plots.

A
• NumPy: Perform complex calculations efficiently.
• OS & Subprocess: Automate running of tool from python code itself.
• Streamlit: For dashboarding.
• Click: For creating beautiful command line applications.
n
• JINJA2: For template based programming.
Example: Running a command-line EDA tool from Python:
ha
import os
os.system("calibre -drc my_design.gds")

Tcl and Perl lack such robust libraries, making Python a better choice for modern automation and data processing needs.
These libraries are also free. So no impact on the budget.
rs

1.3 Why Learning Python is Essential for the Future

ka

1.3.1 Industry Adoption

• Python is being integrated into modern EDA tools.
• Companies are shifting from Tcl/Perl to Python-based automation.
• Essential for learning AI and machine learning.
A

1.3.2 Career Growth

• Learning Python opens doors to roles in VLSI automation, AI-driven chip design, and verification.
• Python allows engineers to develop custom scripts to improve productivity, making them valuable assets in any
organization.

1.3. Why Learning Python is Essential for the Future 3

 Crack VLSI Python Interview

1.3.3 Easy to Learn, Powerful to Use

• Even beginners can start coding in Python quickly.
• Its power grows as you explore automation, data processing, and visualization.
• Python’s object-oriented and scripting capabilities provide flexibility that Tcl and Perl cannot match.
• The ability to integrate Python with hardware description languages (Verilog/VHDL) allows for powerful hybrid
solutions.

ra
1.3.4 Open-Source and Community Support
• Python has a vast, active developer community that continuously improves its ecosystem.
• Thousands of open-source libraries are available, making it easy to find solutions for specific problems in VLSI
design.

ro
• Forums, tutorials, and online courses make it easy to learn and improve Python skills.
• Well maintained documentations make understanding package features easy.

A
1.4 Summary
Python is simpler, more powerful, and future-proof compared to Tcl and Perl. It is becoming the standard for VLSI
automation, making it a must-learn skill for engineers. Python’s readability, extensive library support, and integration
with EDA tools ensure that it will continue to be a critical tool in the semiconductor industry.
n
In the next chapter, we will start with python installation before diving into practical VLSI applications.
ha
rs
ka
A

1.4. Summary 4
 CHAPTER

THREE

CHAPTER 3: UNDERSTANDING THE BASICS BEFORE WRITING

ra
PYTHON CODE

ro
3.1 Introduction
Before we start writing Python code, it’s important to understand some basic concepts. These ideas will help you
understand how Python works and why it’s so powerful. Think of this chapter as learning the language of Python
before you speak it.

A
In the VLSI world, many engineers are familiar with languages like TCL and Perl. While those tools are powerful,
Python is much easier to read, write, and maintain. It is designed to be beginner-friendly while still being robust
enough for professional automation. It also has a huge community, modern syntax, strong support for packages, and is
becoming the de facto standard for scripting in semiconductor companies.
n
3.2 What is a Variable?
ha
A variable is like a labeled box in your computer’s memory that stores information. You can give that box a name and
put any kind of data in it—like a number or a string.
In TCL:

set voltage 1.2

rs

In Perl:

$voltage = 1.2;
ka

In Python:

voltage = 1.2

3.2.1 Python Pros:

A

• Clean syntax, no special characters

• No need to declare types
• Easier to understand for beginners

8
 Crack VLSI Python Interview

3.2.2 TCL/Perl Cons:

• TCL requires set and doesn’t support modern structures well
• Perl uses special characters like $ which may confuse beginners

3.3 What is a Data Type?

ra
A data type defines what kind of value a variable holds. Python automatically figures out the type of data you’re working
with.

3.3.1 Common Data Types:

ro
• Integer (int) – whole numbers: 10, -5
• Float – decimal numbers: 3.14, 0.01
• String (str) – text: 'VLSI', 'Design'
• Boolean (bool) – true or false: True, False

A
In Perl:

$nodes = 5; # Integer
$temp = 75.5; # Float
$chip_name = "ASIC"; # String
$is_ready = 1; #
n
Boolean (no real bool type)

In Python:
ha
nodes = 5
temp = 75.5
chip_name = "ASIC"
is_ready = True
rs

3.3.2 Python Pros:

• Automatically manages types
• Has actual boolean type
ka

• Cleaner syntax

3.3.3 Perl Cons:

• All scalar values use $
• No real separation of types, more error-prone
A

3.3. What is a Data Type? 9

 Crack VLSI Python Interview

3.4 What is a Comment?

Comments are notes in your code meant for humans. Python ignores them when it runs your program.
In TCL, Perl, and Python, comments start with #:

# Calculate power based on voltage and current

power = voltage * current

ra
3.4.1 Python Pros:
• Simple and consistent commenting

3.4.2 TCL/Perl Cons:

ro
• Similar syntax, but overall readability of the script can be more complex

A
3.5 What is a Script?
A script is just a file with code instructions. In Python, you create a .py file and run it to execute tasks.

ò Note
n
Chapter4 - Chapter18 can be practicsed using a single file. All of the code can be executed after writing it in a
single python(.py) file.
ha
3.5.1 Python:
voltage = 1.1
current = 0.3
power = voltage * current
rs

print("Power is:", power)

3.5.2 TCL:
ka

set voltage 1.1

set current 0.3
set power [expr $voltage * $current]
puts "Power is: $power"
A

3.5.3 Perl:
$voltage = 1.1;
$current = 0.3;
$power = $voltage * $current;
print "Power is: $power\n";

3.4. What is a Comment? 10

 Crack VLSI Python Interview

3.5.4 Python Pros:

• Minimal syntax
• Easier for beginners to understand
• print() is clearer and works across data types

3.5.5 TCL/Perl Cons:

• TCL requires brackets and expr, increasing complexity

ra
• Perl uses semicolons, escape characters, and $ for all variables

3.6 What is a Function?

ro
A function is a reusable block of code that performs a specific task.

3.6.1 Python:

A
def calculate_power(v, i):
return v * i

print("Power:", calculate_power(1.1, 0.3))

3.6.2 TCL:
n
proc calculate_power {v i} {
ha
return [expr {$v * $i}]
}
puts "Power: [calculate_power 1.1 0.3]"

3.6.3 Perl:
rs

sub calculate_power {
my ($v, $i) = @_;
return $v * $i;
}
ka

print "Power: ", calculate_power(1.1, 0.3), "\n";

3.6.4 Python Pros:

• Intuitive syntax
• Parameters are clearly defined
A

• Easy to read and reuse

3.6.5 TCL/Perl Cons:

• TCL has clunky proc syntax and expr
• Perl requires unpacking parameters and semicolons

3.6. What is a Function? 11

 Crack VLSI Python Interview

3.7 What is a Module?

A module is a file containing functions and variables that you can import into another script.

3.7.1 Python:
import math
print(math.sqrt(16))

ra
3.7.2 Perl:
use POSIX;
print sqrt(16);

ro
3.7.3 Python Pros:
• Rich standard library
• Easy to use with import

A
3.7.4 Perl Cons:
• use and require can be confusing
• Namespaces and module paths are more complex
n
ha
3.8 What is a Package?
A package is a group of related modules. You can install external packages using pip.

3.8.1 Python:
rs

pip install numpy

import numpy as np
array = np.array([1, 2, 3])
ka

print(array)

3.8.2 Perl:
cpan install Math::Complex
A

use Math::Complex;
print cplx(1, 2);

3.8.3 Python Pros:

• pip is fast, simple, and modern
• Clean integration of external libraries

3.7. What is a Module? 12

 Crack VLSI Python Interview

3.8.4 Perl Cons:

• CPAN is powerful but outdated and less beginner-friendly
• Module dependencies can be hard to manage

3.9 Summary

ra
Before writing Python code, you should understand:
• Variables: containers to hold data (simpler than TCL’s set or Perl’s $var)
• Data Types: kinds of data (auto-detected in Python, clearer than Perl)

ro
• Comments: #-style notes to explain code
• Scripts: executable .py files (cleaner and more readable)
• Functions: reusable blocks of logic (Python is simpler than proc or sub)
• Modules: built-in or user-made libraries (easy to import and use)

A
• Packages: installable libraries (Python’s pip is modern and widely supported)
Python offers a modern and beginner-friendly scripting experience, far simpler and more intuitive than TCL or Perl.
As VLSI flows become increasingly automated and data-driven, Python is the language best suited for the future.
In the next chapter, we’ll write our first working Python script using these building blocks.
n
ha
rs
ka
A

3.9. Summary 13
 CHAPTER

FOUR

CHAPTER 4: WRITING YOUR FIRST PYTHON SCRIPT

ra
4.1 Introduction

ro
Now that you understand variables, data types, functions, and other basics, let’s create your first complete Python
script. This will help you apply what you’ve learned and see Python in action. Our goal is to create a simple script that
calculates and displays power consumption using voltage and current values.

A
4.2 Step-by-Step Guide
4.2.1 Step 1: Open a Text Editor
You can use any simple text editor like vim or vs-code.

4.2.2 Step 2: Create a New File

n
Save the file with a .py extension. For example:
ha
power_calc.py

4.2.3 Step 3: Write the Script

# This script calculates power from voltage and current
rs

# Define input values

voltage = 1.2 # in volts
current = 0.5 # in amperes
ka

# Calculate power
power = voltage * current

# Print the result

print("Voltage:", voltage, "V")
A

print("Current:", current, "A")

print("Power:", power, "W")

4.2.4 Step 4: Run the Script

To run your script:

python3 power_calc.py

14
 Crack VLSI Python Interview

You should see this output:

Voltage: 1.2 V
Current: 0.5 A
Power: 0.6 W

4.3 Explaining the Script

ra
• Comments (# ...) describe each step.
• Variables voltage and current hold numeric data.
• power = voltage * current performs a calculation.
• print() displays the result to the user.

ro
4.4 Common Mistakes to Avoid
• Don’t forget the .py extension.

A
• Make sure Python is properly installed and accessible from your terminal.
• Check indentation (Python is sensitive to spaces).

4.5 Comparison to TCL and Perl

4.5.1 TCL Version:
n
set voltage 1.2
ha
set current 0.5
set power [expr {$voltage * $current}]
puts "Power: $power W"

4.5.2 Perl Version:

rs

$voltage = 1.2;
$current = 0.5;
$power = $voltage * $current;
print "Power: $power W\n";
ka

4.5.3 Why Python is Better Here:

• Cleaner syntax without $, set, or expr
• Easier for beginners to understand and maintain
A

• Easier to add features like file input, graphs, or GUIs later

4.6 Summary
In this chapter, you wrote your first Python script that performs a basic power calculation. This is the foundation for
automating tasks in your VLSI workflow using Python.
Next, we’ll look at how to store data in terms of various data types.

4.3. Explaining the Script 15

 CHAPTER

FIVE

CHAPTER 5: UNDERSTANDING DATA TYPES WITH VLSI USE CASES

ra
5.1 Introduction

ro
Data types are the backbone of programming. They define what kind of value a variable holds and how it can be used.
In VLSI automation and scripting, choosing the right data type can make your code faster, easier to understand, and
more maintainable.
In this chapter, we’ll go deeper into Python’s data types, when to use them in VLSI workflows, and how they compare

A
to TCL and Perl.

5.2 Numeric Types

n
5.2.1 1. Integer (int)
Use when you need whole numbers: pin counts, layer numbers, instance counts.
ha
Python Example:

num_pins = 24
layer_number = 5
rs

TCL:

set num_pins 24
set layer_number 5
ka

Perl:

$num_pins = 24;
$layer_number = 5;

5.2.2 2. Float (float)

A

Used for decimal values like voltage, power, resistance, timing.

Python:

voltage = 1.2
slack = -0.03

TCL:

16
 Crack VLSI Python Interview

set voltage 1.2

set slack -0.03

Perl:

$voltage = 1.2;
$slack = -0.03;

ra
5.2.3 Why Python is Better:
• No need to declare data types
• Automatically switches between int and float in expressions

ro
5.3 Text Type
5.3.1 String (str)

A
Use for cell names, file names, messages, paths, etc.
Python:

cell_name = "U1"
report_path = "/home/user/reports/timing.rpt"
n
TCL:
ha
set cell_name "U1"
set report_path "/home/user/reports/timing.rpt"

Perl:

$cell_name = "U1";
rs

$report_path = "/home/user/reports/timing.rpt";

5.3.2 Common Operations in VLSI:

• Concatenating paths:
ka

full_path = base_dir + "/log.txt"

• Searching in strings:

if "ERROR" in line:
A

print("Found issue")

5.3.3 Python Advantage:

• Strings are objects, with methods like .split(), .replace(), .startswith()
• No $ or set clutter like TCL/Perl

5.3. Text Type 17

 Crack VLSI Python Interview

5.4 Boolean (bool)

Use when you need true/false flags like:
• Is cell clock-gated?
• Is IR drop within limit?
Python:

is_gated = True

ra
is_valid = False

TCL:

set is_gated 1

ro
set is_valid 0

Perl:

$is_gated = 1;

A
$is_valid = 0;

5.4.1 Python Advantage:

• True and False are actual types
• Cleaner than using 0/1 manually
n
ha
5.5 List (list)
Used for storing multiple items: cell names, voltages, violations, etc.
Python:
rs

cells = ["U1", "U2", "U3"]

voltages = [1.2, 0.9, 1.1]

TCL:
ka

set cells {U1 U2 U3}

set voltages {1.2 0.9 1.1}

Perl:

@cells = ("U1", "U2", "U3");

A

@voltages = (1.2, 0.9, 1.1);

5.5.1 Common Use Cases:

• Iterate over netlist cells
• Loop through violations
• Collect timing slacks

5.4. Boolean (bool) 18

 Crack VLSI Python Interview

Python:

for cell in cells:

print("Cell:", cell)

5.5.2 Python Advantage:

• Lists support sorting, slicing, filtering
• Easily readable and modifiable

ra
5.6 Dictionary (dict)

ro
Used to store key-value pairs: cell to slack, net to delay, pin to layer.
Python:

slack_map = {"U1": 0.15, "U2": -0.05}

A
Access:

print(slack_map["U2"]) # -0.05

TCL: (No direct dictionary type; simulate using arrays)

array set slack_map {U1 0.15 U2 -0.05}

n
puts $slack_map(U2)
ha
Perl:

%slack_map = ("U1" => 0.15, "U2" => -0.05);

print $slack_map{"U2"};
rs

5.6.1 Python Advantage:

• dict is a first-class type
• Safer and more powerful than TCL arrays
ka

• Supports methods like .get(), .keys(), .values()

5.7 Tuple (tuple)

A

Used for fixed sets of values: (x, y) coordinates, (start, end) times.
Python:

bbox = (100, 200)

timing = (0.01, 0.12)

5.6. Dictionary (dict) 19

 Crack VLSI Python Interview

5.7.1 Python Advantage:

• Tuples are immutable
• Great for storing read-only paired values

5.8 None Type

ra
Represents absence of value (like NULL). Useful in flows that detect optional data.
Python:

result = None

ro
if result is None:
print("No data found")

TCL/Perl: No exact equivalent; use empty strings or undef.

A
5.9 Summary Table

Type Use Case in VLSI Python Example TCL Equivalent Perl Equivalent
int Pin count, layer number
nnum_pins = 24 set num_pins 24 $num_pins = 24;
float Voltage, timing, IR drop slack = -0.03 set slack -0.03 $slack = -0.03;
str Cell names, paths, logs cell = "U1" set cell "U1" $cell = "U1";
ha
bool Flags, control checks is_valid = True set is_valid 1 $is_valid = 1;
list Cell lists, voltages ["U1", "U2"] {U1 U2} ("U1", "U2")
dict Key-value mappings {"U1": 0.1} array set %slack_map
tuple Coordinates, timing points (0.1, 0.3) No native Use list or array ref
None No result/placeholder result = None empty string workaround undef
rs

5.10 Conclusion
ka

Understanding and choosing the right data type is key to writing clean, reliable VLSI scripts. Python’s flexibility,
readability, and built-in types make it far superior to TCL and Perl, especially when handling complex data structures
like lists and dictionaries.
Next, we’ll return to various use cases of int for VLSI applications.
A

5.8. None Type 20

 CHAPTER

SIXTEEN

CHAPTER 16: FILE HANDLING IN PYTHON FOR VLSI ENGINEERS

ra
16.1 Introduction

ro
In VLSI automation, file handling is foundational. Engineers often interact with files like:
• Liberty files (.lib) defining cell timing
• Netlists (.v, .vhd) defining circuit connectivity

A
• DEF/LEF files describing layout constraints
• SDC constraints defining clock and timing
• STA reports (.rpt) from tools like PrimeTime
Python simplifies file operations, offering intuitive syntax, built-in safety, and powerful modules.
n
ha
16.2 Opening Files in Python
Use the open() function to work with files.

o = open("file.txt", "r") # 'r' is read mode

rs

Always prefer the with statement:

with open("file.txt", "r") as file:

content = file.read()
ka

16.2.1 File Modes

Mode Description
‘r’ Read only
A

‘w’ Write (overwrites existing file)

‘a’ Append to end of file
‘x’ Create new file, error if exists
‘b’ Binary mode
‘t’ Text mode (default)

69
 Crack VLSI Python Interview

16.2.2 Common Pitfall

file = open("log.txt", "r")
# Forgot to close manually

Instead:

with open("log.txt") as file:

print(file.read())

ra
The with block ensures file is closed automatically.

ro
16.3 Reading Files
16.3.1 Entire File
with open("sta.log") as f:

A
content = f.read()
print(content)

16.3.2 Line-by-Line
with open("sta.log") as f:
for line in f:
n
print(line.strip())
ha
• .strip() removes trailing \n, whitespace
• Useful when parsing line-structured reports

16.3.3 Into List

rs

with open("nets.txt") as f:
lines = f.readlines()
print(lines)

• Each line becomes a string in a list

ka

16.3.4 VLSI Use Case: Report Filtering

with open("sta_hold.rpt") as f:
for line in f:
if "VIOLATION" in line:
A

print("Hold Violation:", line.strip())

16.3. Reading Files 70

 Crack VLSI Python Interview

16.4 Writing to Files

16.4.1 Overwriting File
with open("summary.txt", "w") as f:
f.write("Slack Violations: 3\n")

• Overwrites content each time

ra
16.4.2 Appending
with open("summary.txt", "a") as f:
f.write("New check complete.\n")

ro
• Useful when logging over time

16.4.3 VLSI Use Case

nets = ["clk", "reset", "vdd"]

A
with open("critical_nets.txt", "w") as f:
for net in nets:
f.write(net + "\n")

16.4.4 Common Pitfall

n
Overwriting important data due to incorrect mode:

# Accidentally overwrites file

ha
with open("report.rpt", "w") as f:
f.write("Oops!")
rs

16.5 Reading Compressed Files

Use the gzip module for .gz files (common in STA, logs).

import gzip
ka

with gzip.open("sta.rpt.gz", "rt") as f:

for line in f:
if "VIOLATION" in line:
print(line.strip())
A

• 'rt' = read text mode for gzip

16.5.1 Common Pitfall

# Wrong mode for gzip
with gzip.open("sta.rpt.gz") as f:
content = f.read() # Binary output by default

16.4. Writing to Files 71

 Crack VLSI Python Interview

Always use 'rt' for text or 'rb' for binary.

16.6 File Existence and Type Checks with pathlib

The pathlib module provides an elegant and consistent API for working with filesystem paths.

16.6.1 Basic Existence Check

ra
from pathlib import Path

path = Path("netlist.v")
if path.exists():

ro
print("Netlist exists")

16.6.2 File Type Checks

A
if path.is_file():
print("It's a file")
elif path.is_dir():
print("It's a directory")

16.6.3 Other Useful Checks

n
if path.suffix == ".rpt":
print("This is a report file")
ha
if path.stat().st_size == 0:
print("File is empty")

if path.name.startswith("sta"):
print("STA report detected")
rs

16.6.4 Iterating Over Files in a Directory

reports_dir = Path("reports")
ka

for rpt in reports_dir.glob("*.rpt"):

if rpt.is_file():
print("Parsing:", rpt.name)

16.6.5 VLSI Use Case: Checking for Required Inputs

A

required_files = ["netlist.v", "constraints.sdc", "cells.lib"]

for fname in required_files:
p = Path(fname)
if not p.exists():
print("Missing file:", fname)

16.6. File Existence and Type Checks with pathlib 72

 Crack VLSI Python Interview

16.7 Why pathlib is Better Than os

16.7.1 1. Object-Oriented vs String-Based
• os.path is string-based:

import os
if os.path.exists("file.txt"):
print("Exists")

ra
• pathlib is object-oriented:

from pathlib import Path

if Path("file.txt").exists():
print("Exists")

ro
16.7.2 2. Cleaner and Chainable Syntax
• pathlib allows chaining:

A
p = Path("logs") / "sta" / "report.rpt"
print(p.name, p.suffix)

• More readable and Pythonic than os.path.join

16.7.3 3. Integrated Methods

n
• Instead of multiple os functions:
ha
os.path.isfile(path)
os.path.isdir(path)
os.path.getsize(path)

• Use:
rs

path.is_file()
path.is_dir()
path.stat().st_size
ka

16.7.4 4. Easier Directory Traversal

• pathlib supports glob, rglob:

for file in Path("logs").rglob("*.rpt"):

print(file)
A

16.7.5 5. Easier Cross-Platform Paths

• pathlib handles / and \ transparently
• No need to worry about platform-specific separators

16.7. Why pathlib is Better Than os 73

 Crack VLSI Python Interview

16.8 Comparison: TCL and Perl

16.8.1 TCL
set f [open "file.txt" r]
while {[gets $f line] >= 0} {
puts $line
}
close $f

ra
• Manual closing required
• Lacks context management

ro
16.8.2 Perl
open(my $fh, '<', "file.txt") or die $!;
while(my $line = <$fh>) {
print $line;
}

A
close $fh;

• Compact, but symbols-heavy

• Less intuitive for beginners

16.8.3 Python Advantages

n
• with handles file lifecycle
ha
• Simple syntax (for line in file:)
• Built-in modules like gzip, pathlib, os
• Easier to read and write
• Better support for large ecosystems and visualization
rs

16.9 Common Pitfalls (with Fixes)

ka

16.9.1 1. Forgetting to close file

f = open("log.txt")
# file left open → risk of memory leak, locking
A

Fix:

with open("log.txt") as f:
...

16.8. Comparison: TCL and Perl 74

 Crack VLSI Python Interview

16.9.2 2. Wrong file mode

with open("data.txt", "r") as f:
f.write("test") # UnsupportedOperation: not writable

Fix: use 'w' or 'a'

16.9.3 3. File not found

ra
with open("missing.rpt") as f:
... # FileNotFoundError

Fix:

ro
from pathlib import Path
if Path("missing.rpt").exists():
...

16.9.4 4. Incorrect encoding

A
Some .lib files contain special characters.

with open("std.lib", encoding="utf-8") as f:

...

16.9.5 5. Gzip binary mode confusion

n
with gzip.open("rpt.gz") as f:
ha
f.read() # Outputs bytes

Fix:

with gzip.open("rpt.gz", "rt") as f:

f.read() # Outputs str
rs

16.10 Summary
ka

Task Python Syntax

Open file open("file.txt", "r")
Read all f.read()
Read line-by-line for line in file:
Write/append to file 'w' or 'a' modes
A

Check file existence Path("file").exists()

Check type Path(...).is_file() / .is_dir()
Gzip file gzip.open("file.gz", "rt")
Pathlib usage Path("file").suffix, .name, .stat()

File I/O is essential for automating VLSI design flows. From parsing tool outputs to managing constraint files, Python
provides a clean and powerful way to handle all your data. In the next chapter, we’ll explore parsing structured data
to extract useful information efficiently.

16.10. Summary 75