# Number type

## Basic type

1. Integer type: can be positive or negative. There is no limit on the value range. There are four forms: decimal, binary (0b/0B), octal (0o/0O) and hexadecimal (0x/0X).

2. Floating point number type: numbers with decimals and decimals. There is a range in the value range. There is an uncertain mantissa in the operation between floating-point types because binary means that the decimal is infinitely close to the decimal rather than equal to the decimal.

```0.1+0.2 == 0.3
#Output False
round(0.1+0.2,1)==0.3
#Output True
round(x,d)#Round x, d is the number of decimal places
```

3. Complex type: a+bj, a is the real part and b is the imaginary part. Commonly used in spatial transformation.

```z = 1.23+96j
a=z.real()
b=z.imag()
```

## Digital operation

1. Numeric operator
The result of different data types is the "widest" type: integer < floating point < complex number

Operatordescribe
x-ySubtraction
x/yDivision, quotient 10 / 3 = 3.33335
x//yInteger division, 10 / / 3 = 3
x%yRemainder, modular operation, 10% 3 = 1
x**yPower operation, x^y, y is the square when y is a decimal
Enhanced operationx+=y x-=y x*=y x/=y x//=y x%=y x**=y

2. Digital operation function

functiondescribe
abs(x)Find the absolute value of x
divmod(x,y)At the same time, the quotient and remainder of x/y are obtained
pow(x,y[,z])Power remainder operation, z optional. Set z to find the y power of x divided by the remainder of z
round(x[,d])Round x, d optional, rounded by default
max(x1,x2)Find the maximum value
mim(x1,x2)Find the minimum value
int(x)Change x to an integer and round off the decimal part
float(x)Change x to floating point number and increase the decimal part
complex(x)Change x into a complex number and increase the imaginary part

## Example

```#One thousandth of progress every day, how much progress a year?
#One thousandth of every day, how much is left in a year?
dayup=pow(1.001,365)
daydown=pow(0.999,365)
print("dayup:{:.2f}, daydown:{:.2f}".format(dayup,daydown))
#The results are: dayup:1.44, daydown:0.69

#If it's five thousandths, one percent?
dayfactor=0.005 #Modifiable
dayup=pow(1+dayfactor, 365)
daydown=pow(1-dayfactor, 365)

#If it's a 1% increase on weekdays and a 1% decrease on rest days?
dayup = 1.0
dayfactor = 0.01
for i in range(365):
if 1%7 in [6,0]:
dayup = dayup*(1-dayfactor)
else:
dayup = dayup*(1+dayfactor)

#How hard should you work on a weekday to be the same as working 1% every day
def dayUP(df):
dayuo = 1
for i in range(365):
if 1%7 in [6,0]:
dayup = dayup*(1-0.01)
else:
dayup = dayup*(1+df)
return dayup
dayfactor = 0.01
while dayUP(dayfactor) ＜ pow(1.01, 365)
dayfactor += 0.001
```

# String type

## String type representation

An ordered sequence of 0 or more characters, in which the characters can be indexed.

1. Means:

• Single or double quotation marks: single line string
• Three quotation marks: multiline string

If you want the string itself to have single quotation marks / double quotation marks, you should use double quotation marks / single quotation marks on both sides to represent the string.

2. Intercept

• Positive increment sequence number: from left to right, starting from 0
• Reverse decrement sequence number: from right to left, starting from - 1

Index: < string > [M]
Slice: < string > [M: n: k]: m indicates the start position. If it is missing, it defaults to the beginning; If n indicates the end position is missing, it defaults to the end, but n is not included; K represents the step size.

3. Escape character
Used to express the original meaning of a character.

charactersignificance
\bBack off
\nLine feed (cursor movement with downward header)
\rEnter (cursor moves to the beginning of the line)

## String processing operation

1. Operator

Operatordescribe
x+yConnect two strings
xn nxN is an integer, indicating that the string x is copied n times
x in sReturns True if x is a substring of s, False otherwise

2. String handler

functiondescribe
len(x)Returns the length of the string x
str(x)Converts any type of variable x to the corresponding string form
hex(x) oct(x)Form the hexadecimal or octal lowercase of integer x into a string
chr(u)Returns Unicode encoding to its corresponding string form
ord(x)Returns the string x to its Unicode encoding

3. Treatment method

Method usedescribe
str.lower() str.upper()Returns all lowercase / uppercase of a string
str.split(sep=None)Returns a list divided by str according to sep
str.count(sub)Returns the number of occurrences of sub in str
str.replace(old,new)Replace old in the string with new
str.center(wedth[,fillchar])The string is centered according to the width, fillchar is optional
str.strip(chars)Remove the characters in chars on the left and right sides of the string
str.join(iter)Add a str after every element of the iter variable except the last element

## String type formatting

< template string >. Format (< comma separated parameter >), note that when setting the width, if the length of the string exceeds the width, it will be output according to the length of the string itself.

```print("{}:computer{}of CPU The occupancy rate is{}%".format("2021.5.11","A",10))
print("{1}:computer{0}of CPU The occupancy rate is{2}%".format("A","2021.5.11",10))

#Control format:
"{:<>}"#fill
"{:<}"#Align left
"{:>}"#Right align
"{:^}"#Center alignment
"{:<d>}"#width

"{0:=^20}".format("python")
#The width of the output string is 20, centered in python, and the rest is filled with =

"{:<,>}"#thousands separator
"{:.d}"#Maximum length of precision or string output
"{:<leixing>}"#Integer: bcdoxX floating point number: eEf%

"{0:,.2f}".format(12345.6789)
#Output 12345.68
```

## Example

```#Text progress bar:
#Use string mode to print text progress bar that can change dynamically
#The progress bar needs to be able to change gradually in one line

#Simple framework
import time
scale = 10 #Approximate width and progress proportion of the text progress bar
print("------Execution start------")
for i in range(scale+1):
a = '*'*i
b = '.'*(scale-i)
c = (i/scale)*100
print("{:^3.0f}%[{}->{}]".format(c,a,b))
time.sleep(0.1) #Running program
print("------end of execution------")

#Single line dynamic refresh (characters printed after overwrite characters before) \ r
import time
for i in range(101)
print("\r{:3}%".format(i), end="")
#\r controls the cursor to return to the beginning of the current line, and end = "" controls the output of the print() function without line wrapping. End = add information at the end after output.
time.sleep(0.1)

#Full effect text progress bar
import time
scale = 50
print("Execution start".center(scale//2, "-"))
start = time.perf_counter()
for i in range(scale+1):
a = '*'*i
b = '.'*(scale-i)
c = (i/scale)*100
dur = time.perf_counter() - start
print("\r{:3^.0f}%[{}->{}]{:.2f}".format(c,a,b,dur), end="")
print("\n"+"end of execution".center(scale//2, '-'))
```

# Attached - Time library

The standard library of processing time, expressing the computer time, extracting the system time and timing accurately.

1. Get time

• time(): get the internal time value of the computer (floating point number)
• ctime(): get the readable current time (string)
• gmtime(): get the current time. The computer can read the format of the operation

2. Time format:

• strftime(tpl, ts): tpl is the format template string and defines the output effect; ts is a computer internal time type variable.
Symbolsignificance
%Yparticular year
%mMonth (number)
%B,%bMonth (English, English abbreviation)
%dDate (number)
%A,%aWeek (English, English abbreviation)
%H,%hHour (24, 12)
%pMorning or afternoon identifier
%Mminute
%Ssecond
• strptime(str,tpl): change the string into time, the time in the form of str string, and tpl format the template string.

3. Program timing:

• sleep(s): s is the sleep time in seconds. It can be a floating point number.
• perf_counter(): measure time and return a CUP level accurate time, in seconds. It is meaningful only when the difference is called continuously.

Posted on Tue, 05 Oct 2021 20:32:10 -0400 by cshaw