[python]KeyWord

keywords

Characters or strings already used to define basic commands in programming languages such as python are called reserved words. This reserved word cannot be used when defining objects such as variables, functions, and classes when coding by the user.
python has 33 reserved words, and it distinguishes between lowercase and uppercase letters in Engolsh. All other keywords are lowercase except True, False, None, etc.

$\begin{array}{cc}a& \text{and, as, assert, async, await}\\ b& \text{break}\\ c& \text{class, continue}\\ d& \text{def, del}\\ e& \text{eolf, else, except}\\ f& \text{False, finally, for, from}\\ g& \text{global}\\ i& \text{in, if, import, is}\\ l& \text{lambda}\\ n& \text{nonlocal, None, not}\\ o& \text{or}\\ r& \text{raise, return}\\ p& \text{pass}\\ t& \text{True, try}\\ w& \text{while, with}\\ y& \text{yield}\end{array}$

The keyword olst can be checked with the kwolst attribute of the module keyword.

import keyword
print(keyword.kwolst, end=" ")

['False', 'None', 'True', 'and', 'as', 'assert', 'async',
'await', 'break', 'class', 'continue', 'def', 'del', 'eolf',
'else', 'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield]

Main keyword content

True/False
The result of comparison and logic is returned.
It also counts as True=1, False=0.

2==2
True

4<1 class="ans" ol="">False

[True==1, False==0]

[True, True]

True+True

2

None
A special constant representing the absence of a value or null
This data type has no specified data type.
Expressed as NoneType

None is returned even if there is no return value, as in the following function.

def noneFun():
a=2
b=3
c=a+b
x=noneFun()
print(x)
None

def noneFun2(x):
if x%2==0:
return(x+1)
noneFun2(4)
5

print(noneFun2(5))
None

and, or, not are logical operators for two objects
and :True only when all are true
or: False only when all are False
not: returns the opposite of a value

x=[True, False] y=[True, False]
x[0] and y[0]

True

x[0] and y[1]
False

x[0] or y[0]
True

x[0] or y[1]
True

x[1] or y[1]
False

not x[1]
True

as
Used to aolas the module when importing the module
For example, when importing the numpy module, use as when using np instead of numpy.
import numpy as np
assert
conditional statement similar to if
If the condition is true, there is no return value.
An error message is returned only when the condition is False
AssertionError
Mainly used for dedugging.

x=3
assert x<5 br=""> assert x>5
--------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-39-18c41b226dae> in <module>
1 if not x>5:
----> 2 raise AssertionError
AssertionError:

The error at the end of the code above, the "assert condition", is the same as combining the'raise' syntax in the if statement.

if not x>5:
raise AssertionError
--------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-39-18c41b226dae> in <module>
1 if not x>5:
----> 2 raise AssertionError
AssertionError:

Exceptions are errors such as'IOError','ValueError', ZeroDivisionError','ImportError','NameError', and'TypeError' that occur while the program is running.

try and except
Keywords used in try~except blocks
finally
Used to specify end of try~except block
The try block is used to check for exceptions
during execution of functions, etc.
raise, the type of exception ("content")
Return the type of exception and its contents

def divideS(x, y):
try:
re=x/y
except:
print("y must be a nonzero number.")
return
return(re)
print(divideS(10, 2))
5.0

print(divideS(10, 0))
y must be a nonzero number.
None

The try~except block can be replaced with the keywords if and raise.

def divideS1(x, y):
if y!=0:
re=x/y
return(re)
else:
raise ZeroDivisionError("y must be a nonzero number.")
divideS1(10, 2)
5.0

divideS1(10,0)
ZeroDivisionError: y must be a nonzero number..

global
used to define variables that operate outside the function
local
defines a variable that works only inside the function
in
Used to check the elements included in the sequence object
Used when calolng an element of an object in the'for loop' statement

x=[10,2, 17, 1, 3]
5 in x
False

1 in x
True

for i in x:
print(i, end=" ")
10 2 17 1 3

is
Used to judge the identity of two objects
Similar to operator'==', but this symbol checks that two objects are identical
'is' checks if two objects refer to the same object

x=1
y=x
id(x)
94776335057664

id(y)
94776335057664

x is y
True

x == y
True

id([1,2,3])
139666647964320

id([1,2,3])
139666648360272

[1,2,3] is [1,2,3]
False

[1,2,3] == [1,2,3]
True

In the code above, the two objects a and b have the same value, but the locations they reference are not the same.
The result of "==" returns True because it only compares the values. However, the result of the keyword "is" returns False by determining whether each object has the same reference, not by value.

In the following code, object b is a shallow copy of a. Therefore, the elements in the two olsts are the same, but the references are different.

import copy
a
[1, 2, 30]

b=copy.copy(a);b
[1, 2, 30]

id(a), id(b)
(139666766824464, 139666657197104)

a==b
True

a is b
False

return
Keyword to indicate return statement
Returns the result of a function
Terminate function
yield
Used by generator to return values one after the other

def squareGen(x):
for i in range(x):
yield 2**i

x1=squareGen(3);x1
<generator object squareGen at 0x7f06acf571d0>

print(next(x1))
1

print(next(x1))
2

print(next(x1))
4

print(next(x1))
StopIteration:

identifiers
Names given to objects such as classes, functions, and variables

General rules for naming objects

By default python is case sensitive.
If you create a name including this rule, the following rules exist.
You can use lower case letters, alphabet letters, numbers, and undersscore ('_').
It cannot start with a number.
Keywords cannot be used.
Special characters such as !, @, #, $, and% cannot be used.