When in if perhaps while Statement, or as the operand of the following Boolean operation, an object will be checked to determine whether a value is true

By default, an object, if its class defines an object that returns False __bool__() Function, or a function that returns 0 __len__() Function, then it will be judged as false. In other cases, it is true.

- None and False are False
- Zeros of any number type are false: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
- Empty sequences and sets are false: '', (), [], {}, set(), range(0)

Boolean operation:

operation | result |
---|---|

x or y | Returns y if x is false, otherwise returns X |

x and y | If x is false, X is returned, otherwise y is returned |

not x | Returns True if x is False, False otherwise |

Or, and, and not are three Boolean operators with higher priority. Not has the highest priority. The evaluation order of a and b or not c is (a and b) or (not c). Not C is evaluated first, then (a and b), and then the whole.

Both x and y and x or y have the function of short circuit, that is, if the result can be obtained from x, y will not be evaluated.

For example, if the value of x and y is false, x and y must be false. The result can be obtained without evaluating y. x is returned directly, and the operand y will not be executed.

X or Y, if x is true, then x or y must be true. You can get the result without evaluating y, directly return x, and the expression y will not be executed.

x = [] def y(): print('y') return 1 a = x and y() b = bool(x and y()) print(a, b) # [] False Copy code

## 2, Compare

There are 8 comparison operations in total. The priority of these 8 comparison operations is the same, but the priority of comparison operation is higher than that of Boolean operation.

operation | significance |
---|---|

< | less than |

<= | Less than or equal to |

> | greater than |

>= | Greater than or equal to |

== | be equal to |

!= | Not equal to |

is | Yes (object ID) |

is not | No (negative object ID) |

Except for different number types, all other different types are considered unequal. TypeError is thrown when comparing inappropriate types.

from datetime import datetime, timedelta now = datetime.now() yesterday = now + timedelta(days=-1) print(now > yesterday) # True print(2 <= 1.5) # False print(2 <= now) # TypeError: '<=' not supported between instances of 'int' and 'datetime.datetime' Copy code

Can pass __lt__(), __le__(), __gt__(), __ge__() , __eq__() And other functions to customize the comparison behavior of objects.

x == y is considered equal as long as the values represented by X and y are the same, but is requires that x is the same object. For class objects = = and is are the same.

e = [1, 2] f = [1, 2] print(e == f) # True print(e is f) # False print(id(e), id(f)) # 4479741616 4478061536 Copy code

Tuples are immutable types. In the following example, the results of c == d and c is d are True, and the memory addresses of c and d are the same, indicating that Python has made some optimization behind it. The values of d and c are the same. Therefore, when defining d, the created values of c are directly reused, and c and d point to the same object.

c = (1, 2) d = (1, 2) print(c == d) # True print(c is d) # True print(id(c), id(d)) # 4470112416 4470112416 Copy code

also in and not in , x in s is evaluated as True if x is a member of s, otherwise it is False. not in is the opposite.

print(1 in [1, 2, 3]) # True print(1 not in (1, 2, 3)) # False Copy code

For more details, you can view: compare.

## 3, Determine the type of a value

- use isinstance

isinstance(object, classinfo). If the object parameter is an instance of the classinfo parameter or an instance of a subclass of the classinfo parameter, isinstance(object, classinfo) returns True.

Python has these built-in constructors:

bool(),int(),float(),str(),list(),dict(),object(),range(),set(),slice(),tuple(),bytearray(),bytes(),complex() , frozenset(), etc.

g = 'g' h = 1 i = [1, 2] j = { 'j': 1 } print(isinstance(g, str)) # True print(isinstance(h, int)) # True print(isinstance(i, list)) # True print(isinstance(j, dict)) # True Copy code

- use type

type() returns the type of the object. isinstance is recommended when determining the object type because it takes subclasses into account.

print(type('g') == str) # True print(type(1) == int) # True Copy code

## 4, Calculate

operation | result |
---|---|

x + y | Sum of x and y |

x - y | Difference between x and y |

x * y | Product of x and y |

x / y | Quotient of x and y |

x // y | Quotient of x and y |

x % y | Remainder of x / y |

-x | x inversion |

+x | x invariant |

abs(x) | The absolute value or size of x |

int(x) | Convert x to integer |

float(x) | Convert x to floating point number |

pow(x, y) | y power of x |

x ** y | y power of x |

The result of x / y is always a floating point number. x // y is the quotient of x / y rounded down.

k = 2 / 1 print(k) # 2.0 l = 1 / 2 m = 1 // 2 print(l, m) # 0.5 0 n = 3.5 % 2 print(n) # 1.5 Copy code

operation | result |
---|---|

math.trunc(x) | Truncate x to an integer |

round(x[, n]) | Round x to N decimal places, and half of the value will be rounded to an even number. If n is omitted, it defaults to 0 |

math.floor(x) | Integral < = x, rounded down |

math.ceil(x) | Integral >=X, rounded up |

o = math.trunc(1.2) p = round(1.2265, 2) q = round(2.5) r = math.floor(1.2) s = math.ceil(1.2) print(o, p, q, r, s) # 1 1.23 2 1 2 Copy code

## 5, json and string conversion

- json to string dumps()
- String to json loads()

import json t = [ 'a', 1, { 'b': [1, 2, 3] } ] t_str = json.dumps(t) t_json = json.loads(t_str) print(t_str, t_json[2]['b'][0]) # '["a", 1, {"b": [1, 2, 3]}]' 1 Copy code

## 6, list related methods

operation | result |
---|---|

x in s | If one item in s is equal to x, the result is True, otherwise the result is False. |

x not in s | If one item in s is equal to x, the result is False, otherwise the result is True |

s + t | Splice s and t |

s * n or n * s | Equivalent to splicing n s |

s[i] | Item i of s, i starts from 0. |

s[i:j] | Slice of s from i to j |

s[i:j:k] | s slices from i to j, each index interval k |

len(s) | Length of s |

min(s) | The smallest item of s |

max(s) | The largest item of s |

s.index(x[, i[, j]]) | Index position of the first x appearing in s (at index i or greater than i and less than index j) |

s.count(x) | Total number of occurrences of x in s |

u = [1, 2] v = [3, 4, 5, 6, 7, 8] print(1 in u) # True print(3 not in u) # True print(u + v) # [1, 2, 3, 4, 5, 6, 7, 8] print([None] * 2) # [None, None] print(u[0]) # 1 print(v[1: 3]) # [4, 5] print(v[0: 5: 1]) # [3, 4, 5, 6, 7] print(len(u)) # 2 print(min(v)) # 3 print(max(v)) # 8 print(v.index(6)) # 3 print(v.count(1)) # 0 Copy code

list related , list method:

- list.append(x)

Add an item to the end of the list. Equivalent to a[len(a):] = [x].

- list.extend(iterable)

Add all items in the iteratable object iterable to the list. Equivalent to a[len(a):] = [x].

- list.insert(i, x)

Inserts an item into a given location. Insert x before the item with index i.

- list.remove(x)

Removes the first item in the list with a value of x. If there is no item with a value of x, it is thrown ValueError .

- list.pop([i])

Removes an item at a given location in the list and returns it. If the index i is not declared, the last item in the list is removed and returned.

- list.clear()

Remove all items from the list. Equivalent to del a [:].

d = [1, 2] d.append(3) print(d) # [1, 2, 3] d.extend((3, 4, 5)) print(d) # [1, 2, 3, 3, 4, 5] d.insert(0, 10) print(d) # [10, 1, 2, 3, 3, 4, 5] d.remove(3) # [10, 1, 2, 3, 4, 5] print(d) d.pop() # [10, 1, 2, 3, 4] print(d) d.clear() # [] print(d) Copy code

## 7, Related methods of str

- str.find(sub[, start[, end]])

Returns the first lowest index position of the substring sub that appears in the string slice s[start:end]. If the substring sub is not found, - 1 is returned.

w = 'abc'.find('a') print(w) # 0 Copy code

- str.format(args, kwargs)

Perform a format string operation. str can contain text literal and {}, where {} is the index of location parameter or the name of keyword parameter.

x = 'Just write something {0}. {a}'.format('sentence', a='ha-ha') print(x) # Write some sentences casually ha-ha Copy code

- str.join(iterable)

Returns a character consisting of values in an iteratable object. str is the interval between elements.

y = ['base', 'gold', 'Crazy', 'fall', '，Tut', '〠_〠'] print(''.join(y)) # The fund fell sharply, tut 〠 Copy code

- str.split(sep=None, maxsplit=-1)

Returns a list of words in a string, using sep as the separator. Maxplit sets the number of separators. If maxplit is not declared or the value of maxplit is declared as - 1, there is no limit on the number of separators.

b = 'a, b, c, d, e' print(b.split(',')) # ['a', ' b', ' c', ' d', ' e'] print(b.split(',', 2)) # ['a', ' b', ' c, d, e'] Copy code

This can be used corresponding to str.join(iterable).

- str.lower()

Returns a string that converts characters to lowercase characters.

z = 'Xyz' print(z.lower()) # xyz Copy code

- str.upper()

Returns a string that converts characters to uppercase characters.

c = 'xyz' print(c.upper()) # XYZ Copy code

- str.replace(old, new[, count])

Replace all old strings in the string with the new string new. If there is a count, only the first count strings will be replaced.

a = 'this a character string a Inside no a There are English letters a' print(a.replace('a', '')) #There are no English letters in this string Copy code

## 8, Loop through objects that support iteration

- Simple traversal, using for in:

for e in ('a', 'b', 'c'): print(e) Copy code

2. When traversing the sequence, use enumerate , return an iteratable object, through which you can get the index and the value of the corresponding position at the same time. This method is equivalent to:

def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1 Copy code

example:

for i, f in enumerate(['a', 'b', 'c']): print(i, e) # 0 c # 1 c # 2 c Copy code

3. When traversing the dictionary, use items() to get the keys and values of the dictionary at the same time.

g = { 'a': 10, 'b': 20, 'c': 30, } for k, v in g.items(): print(k, v) # a 10 # b 20 # c 30 Copy code

4. Traverse two or more objects, using zip()

h_arr = [1, 2, 3] i_arr = [4, 5] for h, i in zip(h_arr, i_arr): print(h, i) # 1 4 # 2 5

### Those who like little fat people hurry up for three times, otherwise they can't find little fat people~

reference