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
Operator | describe |
---|---|
x+y | Add, sum |
x-y | Subtraction |
x*y | Multiplication, quadrature |
x/y | Division, quotient 10 / 3 = 3.33335 |
x//y | Integer division, 10 / / 3 = 3 |
x%y | Remainder, modular operation, 10% 3 = 1 |
x**y | Power operation, x^y, y is the square when y is a decimal |
Enhanced operation | x+=y x-=y x*=y x/=y x//=y x%=y x**=y |
2. Digital operation function
function | describe |
---|---|
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.
character | significance |
---|---|
\b | Back off |
\n | Line feed (cursor movement with downward header) |
\r | Enter (cursor moves to the beginning of the line) |
String processing operation
1. Operator
Operator | describe |
---|---|
x+y | Connect two strings |
xn nx | N is an integer, indicating that the string x is copied n times |
x in s | Returns True if x is a substring of s, False otherwise |
2. String handler
function | describe |
---|---|
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 use | describe |
---|---|
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.
Symbol | significance |
---|---|
%Y | particular year |
%m | Month (number) |
%B,%b | Month (English, English abbreviation) |
%d | Date (number) |
%A,%a | Week (English, English abbreviation) |
%H,%h | Hour (24, 12) |
%p | Morning or afternoon identifier |
%M | minute |
%S | second |
- 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.