[Python] Types and objects

1. Terminology

All data stored in the program is an object. Each object has an identity, a type, and a value. An object's identity can be thought of as a pointer to its location in memory, and the variable name is the name that refers to that particular location.
The type of an object is also known as a category, which describes the internal representation of an object and the methods and operations it supports. When you create an object of a specific type, you sometimes refer to that object as an instance of that type. Once an instance is created, its identity and type cannot be changed. If the value of an object can be modified, called a mutable object, the inverse is called an immutable object. If an object contains references to other objects, it is referred to as a container or a collection.
Most objects have a large number of unique data properties and methods. The property is the value associated with the object. The method is the function that will perform certain operations on the object when called. Use point "." operator to access properties and methods.

2. Identity and type of object

The built-in function ID () returns the identity of an object, and the return value is an integer. The IS operator is used to compare the identities of two objects. The built-in function type () returns the type of an object. For example:

def compare(a, b):    if a is b:        # 同一个对象    if a == b:        # 具有相同的值    if type(a) is type(b):        # 具有相同类型

The type of the object itself is also an object, called the class of the object. All types of objects have a specified name that can be used to perform type checking, for example:

if type(s) is list:    s.append(item)if type(d) is dict:    d.update(t)

A better way to check the type is with the built-in function isinstance (object, type), for example:

if isinstance(s, list):    s.append(item)if isinstance(d, dict):    d.update(t)

Because the Isinstance () function implements inheritance, it is the preferred way to check all Python object types.

3. Reference counting and garbage collection

All objects have a reference count. Whether you assign a new name to an object or put it in a container, the object's reference count increases, for example:

a = 37 # 创建值为37的对象b = a # 增加37的引用计数c = []c.append(b) #增加37的引用计数

This example creates an object that contains a value of 37, a simply refers to the name of the newly created object, and when a is assigned to B, B becomes the new name of the same object, and the reference count of the object is incremented. Similarly, when B is placed in a list, the reference count of the object is incremented again.
When a del statement is used or a reference is out of scope (or is re-assigned), the object's reference count is reduced, for example:

del a # 减少37的引用计数b = 42 #减少37的引用计数c[0] = 2.0 #减少37的引用计数

Use the Sys.getrefcount () function to get the current reference count of an object, for example:

a = 37import sysprint(sys.getrefcount(a))

In most cases, reference counts are much larger than guesses, and for immutable data, such as numbers and strings, the interpreter proactively shares objects in different parts of the program in order to conserve memory.
When the reference count of an object is zeroed, it is disposed of by the garbage collection mechanism. In some cases, there may be a circular dependency between many objects that are no longer in use, for example:

a = {}b = {}a[‘b‘] = bb[‘a‘] = adel adel b

In the above example, the DEL statement will reduce the reference count of A and B and destroy the name used to refer to the underlying object. However, because each object contains a reference to another object, the reference count is not zeroed and the object is not destroyed, resulting in a memory leak. To solve this problem, the interpreter periodically executes a loop detector that searches for the non-accessible objects ' loops and deletes them.

4. References and replication

When the program makes an assignment such as a = B, a reference to B is created. For immutable objects such as numbers and strings, this assignment actually creates a copy of B. However, the reference behavior for mutable objects, such as lists and dictionaries, can be completely different, for example:

a = [1, 2, 3, 4]b = aprint(b is a) # Trueb[2] = -100print(a[2]) #-100

Because A and B refer to the same object, modifying either of these variables will affect the other. Therefore, you must create a copy of the object instead of a new reference. For container objects such as lists and dictionaries, you can use two kinds of copy operations: Shallow copy and deep copy. Shallow copy creates a new object, but it contains a reference to the items contained in the original object, for example:

a = [1, 2, [3, 4]]b = list(a)print(b is a) #Falseb.append(100)print(b) # [1, 2, [3, 4], 100]print(a) # [1, 2, [3, 4]]b[2][0] = -100print(b) # [1, 2, [-100, 4], 100]print(a) # [1, 2, [-100, 4]]

Deep copy creates a new object and recursively copies all of the objects it contains. You can use the Copy.deepcopy () function in the standard library to do the work, for example:

import copya = [1, 2, [3, 4]]b = copy.deepcopy(a)b[2][0] = -100print(b) # [1, 2, [-100, 4]]print(a) # [1, 2, [3, 4]]

5. A built-in type that represents data

There are about 12 data types that you can use to represent most of the data used in your program. As shown in the following table:

/tr>

type category	type name	description
none	Type (none)	null object none
number	int	integer
number	float	floating point
number	complex	plural
number	bool	boolean value
sequence	str	string
sequence	list	list
sequence	tuple	tuple
sequence	range	created integer range
map	range	integer range created
collection	set	mutable set
collection	frozense T	Immutable collection

The

None type represents an object that has no value and is represented as none in the program. If a function does not display a return value, the object is returned. None is often used for the default value of an optional parameter, so that the function detects whether the caller actually passed a value for the parameter.
Python uses 4 numeric types: Boolean, Integer, floating-point, and complex. All numeric objects are signed except for Boolean values. All numeric types are immutable. Numeric types have a number of properties and methods that simplify operations involving mixed arithmetic. To be compatible with rational numbers, integers use attributes X.numerator and x.denominator. In order to be compatible with complex numbers, integers or floating-point numbers y have properties y.real and Y.imag, as well as Method Y.conjugate (). Use Y.as_interger_ratio () to convert a floating-point number y to a pair of integers in fractional form. Method Y.is_interger () is used to test whether the floating-point number y represents an integer value. Floating-point numbers can be used in low-level binary form by means of Y.hex () and Y.fromhex (). The
sequence represents a collection of ordered objects that are indexed as non-negative integers, including strings, lists, and tuples. The following tables are supported for all sequences:

Project	Description
S[i]	Returns the element of a sequence I
S[I:J]	Returns a slice
S[i:j:stride]	Returns an extended slice
Lens (s)	Number of elements in s
Min (s)	The minimum value in s
Max (s)	The maximum value in s
Sum (s [, initial])	The and of the items in S
All (s)	Check if all items in s are true
Any (s)	Check if any of the items in S are true

The following table applies to variable sequences:

Project	Description
S[i] = V	Project Assignment Value
S[I:J] = t	Slice Assignment
S[i:j:stride] = t	Extended Slice Assignment
Del S[i]	Item deletion
Del S[i:j]	Slice Delete
Del S[i:j:stride]	Extended Slice Deletion

The list supports the following table:

Method	Description
List (s)	Convert S to a list
S.append (x)	Appends a new element x to the end of S
S.extend (x)	Append a new list to the end of S
S.count (x)	Calculates the number of occurrences of x in S
S.index (x [, start [, stop]])	Find the location where X first appears
S.insert (i, X)	Insert X at index i
S.pop ([i])	Returns the element I and removes it from the list, omitting I returns the last element in the list
S.remove (x)	Search for x and remove it from S
S.reverse ()	Reverses the order of all elements in S
S.sort ([key [, reverse]])	Sorts all the elements in S. Key is a key function. Reverse indicates that the list is sorted in reverse order

List (s) can convert any of the iteration types to a list. If S is already a list, then the new list constructed by the function is a shallow copy of S.
The following table is the supported methods for strings:

Method	Description
S.captitalize ()	Capitalize the first character
S.center (width [, pad])	Centers the string inside a field with a width of length. Pad is a fill character
S.count (Sub [, Start [, end]])	Calculates occurrences of a sub of a specified substring
S.decode ([encoding [, errors]])	Decodes a string and returns a Unicode string
S.encdoe ([encoding [, errors]])	Returns the encoded version of a string
S.endswith (suffix [, start [, end]])	Checks if the string ends with suffix
S.expandtabs ([tabsize])	Replace tabs with spaces
S.find (Sub [, Start [, end]])	Finds the position of the first occurrence of the specified substring sub, otherwise returns-1
S.format (args, *Kwargs)	Formatting s
S.index (Sub [, Start [, end]])	Refers to the position of the first occurrence of the specified substring sub, or an error
S.isalnum ()	Checks if all characters are letters or numbers
S.isalpha ()	Checks if all characters are alphabetic
S.isdigit ()	Checks if all characters are numeric
S.islower ()	Checks if all characters are lowercase
S.isspace ()	Checks if all characters are blank
S.istitle ()	Check if the string is a header string (capitalize each word)
S.isupper ()	Checks if all characters are uppercase
S.join (t)	Use S as a delimiter to concatenate strings in a sequence T
S.ljust (width [, fill])	Left-aligned within a string of length width
S.lower ()	Convert to lowercase
S.lstrip ([chrs])	Delete the blanks or characters in front of chrs
S.partition (Sep)	Use the delimiter string Sep to divide a string. Returns a tuple (head, Sep, tail)
S.replace (old, new [, Maxreplace])	Replace a substring
S.rfind (Sub [, Start [, end]])	Find where a substring last occurred
S.rindex (Sub [, Start [, end]])	Find the last occurrence of a substring, or an error
S.rjust (width [, fill])	Right-aligned within a string of length width
S.rpartition (Sep)	Use the delimiter Sep to divide the string, but start the search at the end of the string
S.rsplit ([Sep [, Maxsplit]])	Use Sep as a delimiter to divide a string from back to forward. Maxsplit is the maximum number of partitions
S.rstrip ([chrs])	Delete chrs trailing blanks or characters
S.split ([Sep [, Maxsplit]])	Use Sep as a delimiter to divide a string. Maxsplit is the maximum number of partitions
S.splitlines ([keepends])	Divides a string into a list of rows and columns. If Keepends is 1, the last line break of each row is preserved
S.startswith (prefix [, start [, end]])	Checks whether a string starts with prefix
S.strip ([chrs])	Remove whitespace or characters from the beginning and end of chrs
S.swapcase ()	Convert uppercase to lowercase, or vice versa
S.title ()	Convert a string to a header format
S.translate (table [, Deletechars])	Use a character conversion table to convert a string to remove characters from Deletechars
S.upper ()	Converts a string to uppercase
S.zfill (width)	Padding 0 to the left of the string until it is width wide

Many string methods accept the optional start and end parameters, whose value is an integer that specifies the index of the start and end positions in S. In most cases, these values can be negative, indicating that the index starts at the end of the string.
A map type represents a collection of arbitrary objects and can be indexed by another collection that is almost any key value. Unlike sequences, mapping objects are unordered and can be indexed by numbers, strings, and other objects. The mappings are mutable.
A dictionary is the only built-in mapping type, and any immutable object can be used as a dictionary key value, such as a string, a number, a tuple, and so on. The following table is the dictionary method:

Project	Description
Len (M)	Returns the number of items in M
M[K]	Returns the key of the M medium key K
M[K] = X	Set the value of M[k] to X
Del M[k]	Remove M[k from M]
K in M	Returns True if K is a key in M
M.clear ()	Delete all items in M
M.copy ()	Returns a copy of M
M.fromkeys (s [, value])	Creates a new dictionary and takes all of the elements in the sequence s as keys to the new dictionary, with values of these keys as value
M.get (k [, V])	Return m[k], if M[K] is not found, then return V
M.items ()	Returns a sequence consisting of (key, value) pairs
M.keys ()	Returns a sequence that consists of a key value
M.pop (k [, default])	If M[K] is found, return m[k] and remove from M, otherwise return the value of default
M.popitem ()	Removes a random (key, value) pair from M and returns it as a tuple
M.setdefault (k [, V])	If M[K] is found, return m[k], do not return V, and set the value of m[k] to V
M.update (b)	Add all objects in B to M
M.values ()	Returns a sequence of all values in M

A collection is the only unordered set. Unlike sequences, collections do not provide an index or slice operation. They also differ from dictionaries in that the object does not have a related key value. The items that are put into the collection must be immutable. A collection is divided into two types, set is a mutable collection, and Frozenset is an immutable collection, both of which are created with a pair of built-in functions, such as:

s = set([1, 5, 10, 15])f = frozenset([‘a‘, 37, ‘hello‘])

The following tables are supported for all collections:

Project	Description
Len (s)	Returns the number of items in s
S.copy ()	Make a copy of S
S.difference (t)	Differential set. Returns all items that are in the s but not in t
S.intersection (t)	To find the intersection. Return all items in both S and T
S.isdisjoint (t)	Returns true if S and t do not have the same item
S.issubset (t)	Returns true if S is a subset of T
S.issuperset (t)	Returns true if S is a superset of T
S.symmetric_difference (t)	To find the symmetric difference set. Returns all items in S or T, but not both in both collections
S.union (t)	The set of the request. Returns all items in S or T

The Mutable collection also provides some additional methods, such as the following table:

Project	Description
S.add (item)	Add item to S. If item is already in S, it has no effect
S.clear ()	Delete all items in S
S.difference_update (t)	Remove all items from S that are also in t
S.discard (item)	Remove item from S, if item does not have a member of S, then no effect
S.intersection_update (t)	Computes the intersection of S with T and puts the result in s
S.pop ()	Returns an arbitrary collection element and removes it from S
S.remove (item)	Remove item from S if item is not a member of S, throws an exception
S.symmetric_difference_update (t)	Calculates the symmetric difference between s and T, and puts the result in s
S.update (t)	Add all items in T to S

All of these operations can modify the collection s directly.

6. A built-in type that represents a program structure

In Python, functions, classes, and modules are objects that can be manipulated as data, such as the following table:

Type Classification	type name	Description
Can call	Types. Builtinfunctiontype	Built-in functions or methods
Can call	Type	Types of built-in types and classes
Can call	Object	Ancestors of all types and classes
Can call	Types. Functiontype	User-defined Functions
Can call	Types. Methodtype	Class method
Module	Types. Moduletype	Module
Class	Object	Ancestors of all types and classes
Type	Type	Types of built-in types and classes

A callable type represents an object that supports the operation of a function call. Objects with this property are: User-defined functions, methods, built-in functions and methods, callable classes and instances.
A user-defined function is a callable object created at the module level with a DEF statement or lambda operator, which has the following properties:

Properties	Description
F._doc_	Document string
F._name_	Function name
F._dict_	A dictionary containing function properties
F._Code_	Code for byte compilation
F._Defaults_	Tuples that contain default parameters
F._Globals_	Define a dictionary of global namespaces
F._closure_	Tuples containing data related to nested scopes

A method is a function that is defined in a class definition. There are 3 common methods: instance methods, class methods, and static methods. An instance method is a method that operates an instance of a specified class, which is passed to the method as the first argument, which is generally called self, according to the Convention. The class method operates on the class itself as an object, passing the class object to the class in the first argument. A static method is a function packaged in a class that cannot use an instance or Class object as the first parameter. For example:

f = Foo()meth = f.instance_methodmeth(30)

In the above example, meth is called a binding method. A binding method is a callable object that encapsulates a function and a related instance. When a binding method is called, the instance is passed to the method as the first argument (self). Method lookups can also occur on the class itself, for example:

umeth = Foo.instance_methodumeth(f, 30)

In the following example, Umeth is called a non-binding method. A non-binding method is a callable object that encapsulates a method function, but it needs to pass an instance of the correct type as the first argument. If the passed object type is wrong, an TypeError exception is thrown.
The following table defines the properties for the method object:

Properties	Description
M._doc_	Document string
M._name_	Method name
M._Class_	The class that defines the method
M._func_	The function object that implements the method
M._self_	Method-related instance (none if non-binding method)

class objects and instances can also be manipulated as callable objects. The class object is created using the class statement and is called as a function to create a new instance. In this case, the parameters of the function are passed to the class's _init_() method to initialize the newly created instance. If the instance defines a special method _Call_(), it can simulate the behavior of the function. If the method is defined for an instance x, using the X (args) statement is equivalent to calling the method x._Call_(args).
When defining a class, a class definition typically generates an object of type object, and the common properties of a type objects T are the following table:

Properties	Description
T._doc_	Document string
T._name_	Class name
T._Bases_	Tuple of base class
T._dict_	To save a Dictionary of class methods and variables
T._Module_	Define the module name of the class
T._Abstractmethods_	Collection of abstract method names

When you create an object instance, the type of the instance is the class that defines it, for example:

f = Foo()print(type(f)) # <class ‘__main__.Foo‘>

The following table shows the special properties that the instance has:

Properties	Description
T._Class_	class to which the instance belongs
T._dict_	Dictionary of Saving instance data

The module type is a container that holds objects that are loaded with the import statement. The module defines a namespace that is implemented using a dictionary, for example, m.x=y equivalent to m._dic_["X"]=y. The available properties of the module are as follows:

Properties	Description
M._dict_	Dictionary associated with a module
M._doc_	Module Document String
M._name_	Module name
M._File_	The file used to load the module
M._Path_	Fully qualify the package name, defined only when the module object references the package

[Python] Types and objects