Mycpen

# Example: Floating-point data float is imprecise
>>> i = 1
>>> i = i - 0.1
>>> i
0.9
>>> i = i - 0.1
>>> i
0.8
>>> i = i - 0.1
>>> i
0.7000000000000001
>>> i = i - 0.1
>>> i
0.6000000000000001

# Example: Decimal type data is precise decimal numbers and can be passed as a Decimal integer or string parameter
>>> from decimal import getcontext, Decimal, Context
>>> mydec = Decimal.from_float(12.222)
>>> mydec
Decimal('12.2219999999999995310417943983338773250579833984375')
>>> mydec = Decimal(0.9)
>>> mydec
Decimal('0.90000000000000002220446049250313080847263336181640625')
>>> mydec = Decimal("3.14")
>>> mydec
Decimal('3.14')

# Example
>>> a = 'test'
>>> b = "test"
>>> a
'test'
>>> b
'test'
>>> a = '''
... t
... e
... s
... t'''
>>> a
'\nt\ne\ns\nt'
>>> print(a)

t
e
s
t
# print(a) prints according to the specified format
>>> c = "t1\nt2"
>>> c
't1\nt2'
>>> print(c)
t1
t2
>>> c = 't1\nt2'
>>> c
't1\nt2'
>>> print(c)
t1
t2
>>> c = r"t1\nt2"
>>> print(c)
t1\nt2

# Example
>>> a = "test"
>>> a[0]
't'
>>> a = "test"
>>> a[0:2]	# Get data from index 0 to 2. Includes 0, excludes 2
'te'		# Includes the front, excludes the back

# Example
>>> a = "hello world"
>>> a[4] = "1"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> id(a)
140585442705648

# Example
>>> info = "chen""peng"
>>> info
'chenpeng'

# Example
my_str = "This Is TEST!"
my_title = "This is My Title"
my_num = "123"
my_num2 = "一二三四"
my_str2 = "hello"
my_str3 = "hello123"

# Judgment Series
print("Is digit:", my_num.isdigit())     # Whether the string contains only digits
print("Is digit:", my_num.isnumeric())   # Whether the string contains only digits (including Chinese numbers one to nine, etc.)
print("Is digit:", my_num2.isdigit())    # Can only judge Arabic numerals
print("Is digit:", my_num2.isnumeric())  # Can judge Chinese numbers

print("Is letter:", my_str.isalpha())      # Will report an error if there are spaces/“!” # Judge letters (Chinese characters count as letters)
print("Is letter or digit:", my_str3.isalnum()) # Will report an error if there are spaces # Judge letters and digits

print("Does the string start with 'This':", my_title.startswith("This"))
print("Does the string end with 'This':", my_title.endswith("This"))

# Example
# Search and Count
my_str = "This Is TEST!"

print("Length:", len(my_str))		# Spaces and ! count as length
print("Position of 'i' first occurrence:", my_str.index("i"))	# Position of the first occurrence of the string "i"
print("Position of 'i' first occurrence:", my_str.find("i"))	# Position of the first occurrence of the string "i", returns -1 if not found
print("Number of occurrences of 'i':", my_str.count("i"))

# Example
# String Conversion
msg = "  hEllo World Chen   "

print("Uppercase:", msg.upper())
print("Lowercase:", msg.lower())
print("Title:", msg.title())

msg2 = "root:x:0:0:root:/root:/bin/bash"
print("Split:", msg2.split(":"))
msg3 = msg2.split(":")
print("Join:", "#".join(msg3))
print("Trim leading and trailing spaces:", msg.strip(), "######")
print("Trim 'root' from both ends:", msg2.strip("root"))
print("String padding:", msg.zfill(40))
print("String replacement:", msg2.replace(":", "%"))
print("Capitalize the first letter of the entire string:", msg.capitalize())
msg4 = "xxx"
print(msg4.center(50, ' '))
print(msg4.center(50, '-'))
print(msg4.ljust(50, "-"))
print(msg4.rjust(50, "-"))

# Example
# String concatenation (+)
>>> a = 'I' + 'Love' + 'Python'
>>> print(a)
ILovePython

# String concatenation (join)
>>> a = ['I', 'Love', 'Python']
>>> print(''.join(a))
ILovePython

+ and join efficiency issue
    Generally, + concatenation is less efficient than join concatenation.
    With + concatenation, a new space is allocated in memory each time it appears, so it is less efficient and takes more time.
    join concatenates into one large string at once.

String formatting (%)
Basic format
	%[(name)][flags][width].[precision]typecode
	-(name): naming
	-flags: +, -, '' or 0. + indicates right alignment; - indicates left alignment; '' is a space, indicating filling a space on the left side of positive numbers to align with negative numbers, 0 indicates filling with 0.
	-width indicates display width.
	-precision indicates precision after the decimal point.

# Example
# % formatting 
name = "wen"
age = 18
print("Name: %s, Age: %s" % (name, age))
print("Name: %s, Age: %s" % (age, "wen2"))

String formatting (format)
	{variable:[filling character][alignment <^>][width][format]}

# Example
# format formatting
name = "wen"
age = 18
print("format01 --> Name: {}, Age: {}".format(name, age))
print("format01 --> Name: {}, Age: {}".format(age, name))
print("format02 --> Name: {1}, Age: {0}".format(name, age))
print("format02 --> Name: {1}, Age: {0}".format(age, name))
print("format03 --> Name: {name1}, Age: {age1}".format(name1=name, age1=age))
print("format01 --> {0:*>10}".format(10, 20))  # Note: 0 is the first variable
print("format01 --> {1:*>10}".format(10, 20))  # Note: 1 is the second variable
print("format01 --> {1:*<10}".format(10, 20))  # Note: : execution; * is the filling character
print("format01 --> {1:*^10}".format(10, 20))  # Note: ^ is centered; 10 is the filling width of 10 characters
print("format02 --> {0:.2f}".format(1/3, 5.333))
print("format02 --> {1:06.2f}".format(1/3, 5.333))
# Binary
print("format02 --> {0:b}".format(10))
# Octal				Note: Hexadecimal is "{0:x}".format(10)
print("format02 --> {0:o}".format(10))
# Thousands separator formatting
print("format02 --> {0:,}".format(123456789))

String formatting - f

# Example
# f identifier formatting
a = "I"
b = "Love"
c = "Python"
print(f"{a}{b}{c}")
# Result ILovePython
print("{a}{b}{c}".format(a=a, b=b, c=c))		# Note: Effect is the same
# Result ILovePython
print(f"{a}{b}{c:a^10}")	# Note: Operation on string c: fill width 10 with “a”, centered
# Result ILoveaaPythonaa
print("{a}{b}{c:a^10}".format(a=a, b=b, c=c)) # Note: Effect is the same
# Result ILoveaaPythonaa

Boolean values (Booleans) are logical values.
The range of values is only True and False (true and false).
False boolean values:
	'', 0, 0.0, (), [], {}, None, False
	None is a special constant representing a special data type (NoneType).
True boolean values:
	All values except false are true.

# Example
# Boolean values can be added and subtracted
>>> a = 1
>>> b = 2
>>> print(a == b)
False
>>> c = (a == b) + (a == d)		# Note: c = 0 + 1
>>> c
1
# Boolean sorting
>>> lst = [(a == d), (a == b)]  # Note: (a == d) is true, (a == b) is false
>>> sorted(lst)
[False, True]  # Note: Because by default 0 is false, 1 is true

○ Constants
	A constant is a fixed value that cannot be changed once initialized.
	Note: In Python, a constant is usually represented in uppercase (by convention, not mandatory), such as: PI=3.1415926.
○ NoneType
	None represents the absence of value.