ASCII Values of Alphabets – A Complete A-Z Guide

Updated on April 16, 2026

•

22 min read

ARTICLE OUTLINE

What is ASCII?ASCII Values of Uppercase Alphabets (A-Z)ASCII Values of Lowercase Alphabets (a-z)ASCII Value of Digits (0–9)ASCII Values Before 33 (0–32) – Control Characters ASCII Values Beyond 126 (127–255) – Extended ASCII ASCII Value of Special Characters Relationship Between Uppercase and Lowercase ASCII Values ASCII Value of A to Z in Java How to Find ASCII Value of a Character in Python Practical Applications of ASCII Values Difference Between ASCII and Unicode Quick Reference: ASCII Value Chart Conclusion People Also Ask FAQs

ASCII stands for the American Standard Code for Information Interchange and defines a mapping between English letters, symbols, control codes, and numbers. The ascii values of alphabets – especially the ascii value of a to z – are foundational knowledge for anyone working in programming, data processing, or computer science.

The standard ascii value chart maps 128 characters to decimal values 0–127, with uppercase letters occupying 65–90, lowercase letters 97–122, and control characters 0–31. This article provides a complete, thorough A-Z guide on ascii code for alphabets, complete with reference tables, Python guide and Java code examples, a special characters breakdown, and a full ascii table alphabets quick reference.

Whether you need the ascii value of a, want to understand the difference between ASCII and Unicode, or need to know how to find ascii value of a character in python – this guide covers everything.

What is ASCII?

ASCII (American Standard Code for Information Interchange) is a character encoding standard that maps characters, symbols, and control codes to numerical values. Created in the 1960s as both a telecommunication protocol and a computer text encoding system, ASCII became the universal foundation for digital text representation.

The ascii values of alphabets, digits, and symbols defined by ASCII allow computers – which operate in binary – to store, transmit, and process human-readable text. Rather than “seeing” the letter ‘A’, a computer processes its decimal ASCII value (65), which in binary is 1000001.

Structure of the ASCII Table

The ascii value chart contains 128 characters (0–127), split into three groups:

• Control Characters (0–31): Non-printable characters used for device control – carriage return (CR), line feed (LF), tab (HT), etc. The ascii value of space is 32, technically the first printable character.

• Printable Characters (32–126): Characters that can be displayed on screen – letters, digits, punctuation, and symbols. The ascii table alphabets range from 65–90 (uppercase) and 97–122 (lowercase).

• Extended ASCII (128–255): Not part of original ASCII; includes accented letters, currency symbols, and graphical characters using 8-bit encoding.

Why is ASCII Important?

ASCII acts as a bridge between human-readable characters and the binary language computers understand. Without a shared standard like ASCII, a file created on one system would appear as garbled text on another. Key reasons ASCII remains important:

• Standardisation: Provides a universal character representation standard, enabling cross-system communication

• Space Efficiency: 7-bit encoding means one character = 7 bits, minimising memory use for English-language text

• Global Baseline: Found in virtually all operating systems, programming languages, and text-processing software

• Programming Foundation: The ascii code for alphabets underpins string manipulation, sorting, encryption, and I/O across all major languages

How Does ASCII Work?

Each character is assigned a specific 7-bit binary code. For example:

• The ascii value of a (lowercase) is 97 → binary: 1100001

• The ASCII value of ‘A’ (uppercase) is 65 → binary: 1000001

• The ascii value of space is 32 → binary: 0100000

When a computer processes text, it doesn’t handle the letters themselves – it handles their numerical ASCII equivalents in binary form.

POSTGRADUATE PROGRAM IN

Multi Cloud Architecture & DevOps

Master cloud architecture, DevOps practices, and automation to build scalable, resilient systems.

ASCII Values of Uppercase Alphabets (A-Z)

Uppercase letters in the ascii table alphabets range occupy decimal values 65 to 90. The ascii value of capital letters starts at 65 for ‘A’ and increments by 1 for each subsequent letter through 90 for ‘Z’. The ascii value of a to z (uppercase) is one of the most frequently referenced parts of the standard ASCII specification.

Letter	ASCII Decimal	Binary
A	65	1000001
B	66	1000010
C	67	1000011
D	68	1000100
E	69	1000101
F	70	1000110
G	71	1000111
H	72	1001000
I	73	1001001
J	74	1001010
K	75	1001011
L	76	1001100
M	77	1001101
N	78	1001110
O	79	1001111
P	80	1010000
Q	81	1010001
R	82	1010010
S	83	1010011
T	84	1010100
U	85	1010101
V	86	1010110
W	87	1010111
X	88	1011000
Y	89	1011001
Z	90	1011010

Key fact: The ascii value of capital letters – specifically A=65 – is the anchor point. All other uppercase ASCII values can be derived by adding the letter’s position in the alphabet minus 1 to 65. For example: E is the 5th letter → 65 + 4 = 69. ✓

Example 1: Finding the ASCII Value of A Single Uppercase Letter in Python

letter = 'A'

ascii_value = ord(letter)

print(f'The ASCII value of {letter} is {ascii_value}.')

# Output: The ASCII value of A is 65.

The built-in ord() function returns the ASCII integer for any character – this is the standard way to find the ascii value of a (or any letter) in Python.

Example 2: Displaying ASCII Values for All Uppercase Alphabets

for letter in range(65, 91):

print(f'The ASCII value of {chr(letter)} is {letter}.')

# Output (first 3 lines shown):

# The ASCII value of A is 65.

# The ASCII value of B is 66.

# The ASCII value of C is 67.

# ... (continues to Z = 90)

This loop uses chr() to convert the decimal back to the character and range(65, 91) to iterate over all ascii value of capital letters.

ASCII Values of Lowercase Alphabets (a-z)

Lowercase letters occupy decimal values 97 to 122 in the ascii code for alphabets standard. The ascii value of a (lowercase) is 97 – exactly 32 more than its uppercase counterpart (65). This 32-unit offset is consistent across all 26 letters and is heavily used in programming for case conversion.

Letter	ASCII Decimal	Binary
a	97	1100001
b	98	1100010
c	99	1100011
d	100	1100100
e	101	1100101
f	102	1100110
g	103	1100111
h	104	1101000
i	105	1101001
j	106	1101010
k	107	1101011
l	108	1101100
m	109	1101101
n	110	1101110
o	111	1101111
p	112	1110000
q	113	1110001
r	114	1110010
s	115	1110011
t	116	1110100
u	117	1110101
v	118	1110110
w	119	1110111
x	120	1111000
y	121	1111001
z	122	1111010

Example 1: Finding the ASCII Value of a Single Lowercase Letter

letter = 'a'

ascii_value = ord(letter)

print(f'The ASCII value of {letter} is {ascii_value}.')

# Output: The ASCII value of a is 97.

Example 2: Displaying ASCII Values for All Lowercase Alphabets

for letter in range(97, 123):

print(f'The ASCII value of {chr(letter)} is {letter}.')

# Output (first 3 lines):

# The ASCII value of a is 97.

# The ASCII value of b is 98.

# The ASCII value of c is 99. ... (continues to z = 122)

ASCII Value of Digits (0–9)

Alongside the ascii code for alphabets, the ascii value of 0 to 9 is equally important in programming. Numeric digit characters in ASCII occupy the range 48 to 57. Note that these are the ASCII values of the digit characters (e.g., the character ‘0’) – not the numeric values themselves.

Digit Character	ASCII Decimal	Binary	Note
‘0’	48	0110000	First digit character
‘1’	49	0110001
‘2’	50	0110010
‘3’	51	0110011
‘4’	52	0110100
‘5’	53	0110101
‘6’	54	0110110
‘7’	55	0110111
‘8’	56	0111000
‘9’	57	0111001	Last digit character

Key insight: To get the numeric value from a digit character, subtract 48. To get the character from a digit, add 48. The ascii value of 0 to 9 is critical in parsing integer strings and validating numeric input.

Example: Working with ASCII Value of Digits in Python

# Find ascii value of 0 to 9 characters

for digit in range(48, 58):

print(f'Character: {chr(digit)} | ASCII: {digit}')

# Output:

# Character: 0 | ASCII: 48

# Character: 1 | ASCII: 49

# ... (continues to 9 = 57)

# Convert digit character to integer using ASCII

char = '7'

numeric_value = ord(char) - 48

print(f'Numeric value of character {char}: {numeric_value}') # Output: 7

Understanding the ascii value of 0 to 9 is also essential when implementing custom number parsers, input validators, or when working with low-level character stream processing in C, C++, and Java.

82.9%

of professionals don't believe their degree can help them get ahead at work.

ASCII Values Before 33 (0–32) – Control Characters

Values 0–32 in the ascii value chart are known as control characters – non-printable codes originally designed to control hardware devices like printers and terminals. The most important for modern programming is ascii value of space = 32, which is technically the first ‘separator’ character and the gateway to the printable range.

ASCII	Character	Description
0	NUL	Null character (marks end of string)
1	SOH	Start of Header
2	STX	Start of Text
3	ETX	End of Text
4	EOT	End of Transmission
5	ENQ	Enquiry (request for info)
6	ACK	Acknowledgment
7	BEL	Bell (causes an alert sound)
8	BS	Backspace
9	TAB	Horizontal Tab
10	LF	Line Feed (newline)
11	VT	Vertical Tab
12	FF	Form Feed (new page)
13	CR	Carriage Return
14	SO	Shift Out
15	SI	Shift In
16	DLE	Data Link Escape
17	DC1	Device Control 1 (XON)
18	DC2	Device Control 2
19	DC3	Device Control 3 (XOFF)
20	DC4	Device Control 4
21	NAK	Negative Acknowledgment
22	SYN	Synchronous Idle
23	ETB	End of Transmission Block
24	CAN	Cancel
25	EM	End of Medium
26	SUB	Substitute
27	ESC	Escape
28	FS	File Separator
29	GS	Group Separator
30	RS	Record Separator
31	US	Unit Separator
32	SP	Space – the ascii value of space is 32

Note on ASCII value of space: Space (ASCII 32) is technically a printable character – it creates visible whitespace. It is the most frequently used character in natural language text. Understanding the ascii value of space (32) is essential for string trimming, whitespace handling, and tokenisation in programming.

ASCII Values Beyond 126 (127–255) – Extended ASCII

Values 127–255 fall into the Extended ASCII range. The conventional ASCII standard only defines 0–127 (7-bit). Extended ASCII uses 8-bit encoding, expanding to 256 values:

Range	Type	Examples
127	Control character	DEL – Delete character
128–159	Non-printable extended control	System-reserved in many encodings
160–175	Punctuation & symbols	Non-breaking space, inverted !, ¢, £, ¥, §
176–191	Graphical symbols	Box-drawing characters, fractions (¼, ½, ¾)
192–223	Accented uppercase	À, Á, Â, Ã, Ä, Å, Æ, Ç, È, É, Ê, Ë…
224–246	Accented lowercase	à, á, â, ã, ä, å, æ, ç, è, é, ê, ë…
247–255	Additional symbols	÷, ø, ù, ú, û, ü, ý, þ, ÿ

Extended ASCII enabled early computing to handle Western European languages without switching encoding systems. However, it lacked support for non-Latin scripts – a limitation that eventually led to the development of Unicode.

ASCII Value of Special Characters

Beyond letters and digits, the ascii value of special characters covers punctuation marks, mathematical symbols, brackets, and other symbols within the printable range (32–126). Knowing the ascii value of special characters is critical for input validation, lexing/parsing, and building custom encoding routines.

Character	Name	ASCII Value
(Space)	Space	32
!	Exclamation Mark	33
“	Double Quote	34
#	Hash/Pound	35
$	Dollar Sign	36
%	Percent	37
&	Ampersand	38
‘	Single Quote	39
(	Left Paren	40
)	Right Paren	41
*	Asterisk	42
+	Plus Sign	43
,	Comma	44
–	Hyphen/Minus	45
.	Period/Dot	46
/	Forward Slash	47
:	Colon	58
;	Semicolon	59
<	Less Than	60
=	Equals Sign	61
>	Greater Than	62
?	Question Mark	63
@	At Symbol	64
[	Left Bracket	91
\	Backslash	92
]	Right Bracket	93
^	Caret	94
_	Underscore	95
`	Backtick	96
{	Left Brace	123
\\|	Pipe/Vertical Bar	124
}	Right Brace	125
~	Tilde	126

The ascii value of special characters in the range 33–47 and 58–64 are punctuation marks that appear between digits and uppercase letters in the ASCII order. Characters 91–96 fall between uppercase and lowercase letter ranges. Understanding this ordering is key for correct string comparison and sorting.

Example: Checking Special Characters Using ASCII Values in Python

def is_special(char):

v = ord(char)

# ascii value of special characters: 33-47, 58-64, 91-96, 123-126

return (33 <= v <= 47) or (58 <= v <= 64) or (91 <= v <= 96) or (123 <= v <= 126)

test_chars = ['A', '!', '@', 'z', '#', '5', '$']

for ch in test_chars:

print(f'{ch} (ASCII {ord(ch)}) - Special: {is_special(ch)}')

# Output:

# A (ASCII 65) - Special: False

# ! (ASCII 33) - Special: True

# @ (ASCII 64) - Special: True

# z (ASCII 122) - Special: False

# # (ASCII 35) - Special: True

# 5 (ASCII 53) - Special: False

# $ (ASCII 36) - Special: True

Relationship Between Uppercase and Lowercase ASCII Values

One of the most elegant properties of the ascii table alphabets is the consistent 32-unit offset between uppercase and lowercase letters. The ascii value of a (lowercase) is 97, and the ASCII value of 'A' (uppercase) is 65 - a difference of exactly 32. This is true for every letter A–Z.

Uppercase	ASCII	Lowercase	ASCII	Difference
A	65	a	97	32
B	66	b	98	32
C	67	c	99	32
G	71	g	103	32
M	77	m	109	32
Z	90	z	122	32

Rule: Lowercase ASCII = Uppercase ASCII + 32. Uppercase ASCII = Lowercase ASCII − 32. In binary, this 32-unit difference corresponds to flipping a single bit (bit 5), making case conversion extremely efficient at the hardware level.

Example 1: Converting Uppercase to Lowercase via ASCII in Python

# how to find ascii value of a character in python - and use it for case conversion

for letter in ['B', 'C', 'G', 'M', 'Z']:

lowercase = chr(ord(letter) + 32)

print(f'{letter} (ASCII {ord(letter)}) → {lowercase} (ASCII {ord(lowercase)})')

# Output:

# B (ASCII 66) → b (ASCII 98)

# C (ASCII 67) → c (ASCII 99)

# G (ASCII 71) → g (ASCII 103)

# M (ASCII 77) → m (ASCII 109)

# Z (ASCII 90) → z (ASCII 122)

Example 2: Converting Lowercase to Uppercase via ASCII in Python

for letter in ['b', 'c', 'z']:

uppercase = chr(ord(letter) - 32)

print(f'{letter} (ASCII {ord(letter)}) → {uppercase} (ASCII {ord(uppercase)})')

# Output:

# b (ASCII 98) → B (ASCII 66)

# c (ASCII 99) → C (ASCII 67)

# z (ASCII 122) → Z (ASCII 90)

ASCII Value of A to Z in Java

Java handles ASCII natively through its char data type, which stores characters as 16-bit Unicode values. Since Unicode's first 128 characters are identical to ASCII, every ASCII value is directly accessible in Java. The ascii value of a to z in java can be accessed by casting a char to int.

Example 1: Finding the ASCII Value of a Single Character in Java

public class ASCIIExample {

public static void main(String[] args) {

char letter = 'A';

int asciiValue = (int) letter; // Cast char to int

System.out.println("ASCII value of " + letter + " is: " + asciiValue);

// Output: ASCII value of A is: 65

}

Example 2: Printing ASCII Value of A to Z in Java (Uppercase)

// ascii value of a to z in java - uppercase loop

public class UppercaseASCII {

public static void main(String[] args) {

for (char c = 'A'; c <= 'Z'; c++) {

System.out.println("ASCII value of " + c + " = " + (int) c);

}

// Output (first 3 lines):

// ASCII value of A = 65

// ASCII value of B = 66

// ASCII value of C = 67 ... (continues to Z = 90)

Example 3: Complete ASCII Value of A to Z in Java (Both Cases)

// ascii value of a to z in java - both uppercase and lowercase

public class FullAlphabetASCII {

public static void main(String[] args) {

System.out.println("Uppercase:");

for (char c = 'A'; c <= 'Z'; c++)

System.out.println(c + " = " + (int) c);

System.out.println("\nLowercase:");

for (char c = 'a'; c <= 'z'; c++)

System.out.println(c + " = " + (int) c);

}

Java tip: In Java, you can also use Character.getNumericValue() for digit characters, and Character.isLetter() / Character.isUpperCase() for character classification - all of which rely on the underlying ascii value of a to z in java mappings.

How to Find ASCII Value of a Character in Python

How to find ascii value of a character in python: Python provides two built-in functions for ASCII work - ord() (character → integer) and chr() (integer → character). These are the primary tools for all ASCII manipulation in Python.

Function	Purpose	Example	Output
ord(char)	Returns the ASCII integer value of a character	ord('A')	65
chr(int)	Returns the character for a given ASCII integer	chr(65)	'A'
ord(char)	Works on lowercase too	ord('a')	97
chr(int)	Works across full ASCII range	chr(32)	' ' (space)
bin(ord(char))	Binary representation of ASCII value	bin(ord('A'))	'0b1000001'

Example 1: Complete ASCII Toolkit in Python

# how to find ascii value of a character in python

def ascii_info(char):

val = ord(char)

return {

'character': char,

'decimal': val,

'binary': bin(val),

'hex': hex(val),

'octal': oct(val)

}

for ch in ['A', 'a', ' ', '!', '0']:

info = ascii_info(ch)

print(f"{info['character']!r:5} | Dec: {info['decimal']:3} | Bin: {info['binary']:10} | Hex: {info['hex']}")

# Output:

# 'A' | Dec: 65 | Bin: 0b1000001 | Hex: 0x41

# 'a' | Dec: 97 | Bin: 0b1100001 | Hex: 0x61

# ' ' | Dec: 32 | Bin: 0b100000 | Hex: 0x20

# '!' | Dec: 33 | Bin: 0b100001 | Hex: 0x21

# '0' | Dec: 48 | Bin: 0b110000 | Hex: 0x30

Example 2: Validating Character Types Using ASCII in Python

def classify_char(char):

v = ord(char)

if 65 <= v <= 90: return f'{char} is an uppercase letter (ascii value of capital letters range)'

if 97 <= v <= 122: return f'{char} is a lowercase letter'

if 48 <= v <= 57: return f'{char} is a digit'

if v == 32: return f'{char} is a space (ascii value of space = 32)'

return f'{char} is a special character (ASCII {v})'

for ch in ['G', 'g', '5', ' ', '@']:

print(classify_char(ch))

This pattern - using ASCII ranges to classify characters - is a core technique in how to find ascii value of a character in python for competitive programming, input validation, and lexical analysis.

Practical Applications of ASCII Values

ASCII values are foundational across programming, data processing, encryption, and communication protocols. Here are the key real-world applications:

• Data Transmission and Communication: ASCII codes were the original standard for transmitting text over networks. Each character in a message was encoded as its ASCII integer, ensuring consistent interpretation across different platforms and systems.

• Encryption and Cryptography: ASCII values underpin many encryption algorithms. Caesar cipher, for example, works by shifting each character's ASCII value by a fixed amount. More complex algorithms use ASCII values as the starting point for mathematical transformations.

• Character Classification in Programming: Checking whether a character is a letter, digit, or special character is done by comparing it against ASCII ranges (65–90, 97–122, 48–57) - a technique central to input validation, parsers, and lexers.

• String Sorting: Languages like Python, Java, C, and C++ sort strings using ASCII order by default. Characters are compared by their ASCII integers - uppercase letters sort before lowercase (65–90 precede 97–122).

• Compression Techniques: Run-length encoding and other text compression methods operate on ASCII values, identifying repeated characters and encoding them efficiently to reduce file sizes.

• Password Strength Validation: Checking that a password contains uppercase, lowercase, digit, and special characters is typically implemented by validating that the password includes characters from each ASCII range.

Example: String Sorting Using ASCII Order in Python

words = ['apple', 'Banana', 'cherry', 'Date', 'ELDERBERRY']

sorted_words = sorted(words)

print(f'Sorted by ASCII order: {sorted_words}')

# Output: ['Banana', 'Date', 'ELDERBERRY', 'apple', 'cherry']

# Uppercase letters (65-90) sort BEFORE lowercase (97-122) in ASCII

Difference Between ASCII and Unicode

ASCII vs Unicode is one of the most commonly asked questions in computer science. Both are character encoding standards, but they differ fundamentally in scope, capacity, and design goals. The core difference between ASCII and Unicode is that ASCII was designed for English-language computing in the 1960s, while Unicode was created to represent every writing system in the world.

Criteria	ASCII	Unicode
Character Set Size	128 characters (7-bit)	Over 1.1 million characters (up to 32 bits)
Supported Scripts	English letters, digits, and symbols only	Virtually all scripts - Latin, Cyrillic, Arabic, Chinese, Emoji, and more
Encoding	7-bit (values 0–127)	8-bit (UTF-8), 16-bit (UTF-16), 32-bit (UTF-32)
Primary Use	Simple text encoding for early computers and communication systems	Global text representation for all modern software
Internationalisation	Limited - not suitable for non-English languages	Fully internationalised - supports all modern and ancient languages
File Size	Minimal - 1 byte per character	Variable - UTF-8 uses 1–4 bytes; efficient for Latin text
Backward Compatibility	ASCII is a subset of Unicode (UTF-8)	Unicode is fully backward-compatible with ASCII in UTF-8 encoding
Common Use Today	Legacy systems, embedded systems, C programming	All modern OSes, web browsers, databases, and APIs

The most important practical implication of the difference between ASCII and unicode: in UTF-8 (the most common Unicode encoding), every ASCII character is represented identically to its original ASCII encoding. This means ascii vs unicode is not a conflict - Unicode extends and supersedes ASCII without breaking compatibility.

Example: ASCII vs Unicode in Python

# ascii vs unicode in Python

# ord() works with both ASCII and Unicode characters

# ASCII characters (0-127) - identical in both standards

print(ord('A')) # 65 - same in ASCII and Unicode

print(ord(' ')) # 32 - ascii value of space, same in both

# Unicode-only characters (beyond ASCII range)

print(ord('é')) # 233 - accented e (not in standard ASCII)

print(ord('中')) # 20013 - Chinese character (Unicode only)

print(ord('😀')) # 128512 - Emoji (Unicode only, requires UTF-16/32)

# Encode to bytes to see the difference between ascii and unicode

print('A'.encode('ascii')) # b'A' - 1 byte

print('é'.encode('utf-8')) # b'\xc3\xa9' - 2 bytes in UTF-8

Quick Reference: ASCII Value Chart

This complete ascii value chart covers all printable characters (32–126) - the full ascii table alphabets, digits, and special characters in a single reference table.

Printable ASCII Range (32–126) - Complete Reference:

Dec	Char	Dec	Char	Dec	Char	Dec	Char
32	(SP)	33	!	34	"	35	#
36	$	37	%	38	&	39	'
40	(	41	)	42	*	43	+
44	,	45	-	46	.	47	/
48	0	49	1	50	2	51	3
52	4	53	5	54	6	55	7
56	8	57	9	58	:	59	;
60	<	61	=	62	>	63	?
64	@	65	A	66	B	67	C
68	D	69	E	70	F	71	G
72	H	73	I	74	J	75	K
76	L	77	M	78	N	79	O
80	P	81	Q	82	R	83	S
84	T	85	U	86	V	87	W
88	X	89	Y	90	Z	91	[
92	\	93	]	94	^	95	_
96	`	97	a	98	b	99	c
100	d	101	e	102	f	103	g
104	h	105	i	106	j	107	k
108	l	109	m	110	n	111	o
112	p	113	q	114	r	115	s
116	t	117	u	118	v	119	w
120	x	121	y	122	z	123	{
124	\|	125	}	126	~	-	-

Memory anchors for the ascii value chart: Space=32 | 0–9: 48–57 | A–Z: 65–90 | a–z: 97–122 | Lowercase = Uppercase + 32

Conclusion

ASCII codes have served as a foundational bridge between human-readable characters and binary computing since the 1960s. The ascii values of alphabets - from the ascii value of a at 97 (lowercase) or 65 (uppercase), through the complete A-Z range - remain essential knowledge for developers working in any programming language.

From the ascii value chart for printable characters to control codes, extended characters, and the classic ascii vs unicode comparison, this guide has covered the full spectrum. Key practical skills - including how to find ascii value of a character in python, the ascii value of a to z in java, and the ascii value of special characters - have been demonstrated with working code examples.

Despite the dominance of Unicode in modern software, ASCII remains relevant for legacy systems, embedded devices, competitive programming, and as the backbone of UTF-8 encoding. Understanding ASCII is understanding the DNA of digital text.

To deepen your programming knowledge, consider the Certificate Program in Application Development powered by Hero Vired - covering Python, Java, data structures, and much more.