Mi blog personal diseño más cómodo: https://www.luozhiyun.com/archives/264
Las listas y tuplas
- Lista es dinámica, no un tamaño de longitud fija, opcionalmente se puede añadir, suprimir o cambiar elementos (mutable).
- La tupla es estática, la longitud de un tamaño fijo, no se puede cambiar para aumentar o deleción (inmutable).
Si desea hacer cualquier "cambio" las tuplas existentes, un viaje de solo re-abrir un bloque de memoria, crear una nueva tupla.
De la siguiente manera:
tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组new_tup，并依次填充原元组的值 new _tup (1, 2, 3, 4, 5)
l = [1, 2, 3, 4]
l.append(5) # 添加元素5到原列表的末尾 l [1, 2, 3, 4, 5]
listas de las diferencias y las tuplas de almacenamiento
Dado que la lista es dinámica, se necesita almacenar un puntero, apuntando a los elementos correspondientes. Además, debido a la lista de variables, por lo que el tamaño de la longitud necesaria de almacenamiento adicional se ha asignado, de modo que puede incluso expansión.
l = []
l.__sizeof__() // 空列表的存储空间为40字节
40
l.append(1) l.__sizeof__()
72 // 加⼊了元素1之后，列表为其分配了可以存储4个元素的空间 (72 - 40)/8 = 4
l.append(2)
l.__sizeof__()
72 // 由于之前分配了空间，所以加⼊元素2，列表空间不变
l.append(3)
l.__sizeof__()
72 // 同上
l.append(4)
l.__sizeof__()
72 // 同上
l.append(5)
l.__sizeof__()
104 // 加⼊元素5之后，列表的空间不⾜，所以⼜额外分配了可以存储4个元素的空间
Pero para tuplas, la situación es diferente. Tamaño fijo del elemento de cabeza, el elemento no se puede cambiar, el espacio de almacenamiento es fijo.
listas de rendimiento y las tuplas
Tuplas que una lista de algunos de los más ligeros, por lo general, el rendimiento ligeramente mejor que la de la lista de velocidad tupla.
Python en el fondo, haciendo un poco de caché de recursos de recursos de caché (caché de recursos) para los datos estáticos. En general, debido a la presencia de la recolección de basura, si no se utilizan algunas variables, Python reclamar la memoria ocupada por ellos, vuelto al sistema operativo para que otras variables u otras aplicaciones.
Sin embargo, para algunas variables estáticas, como tuplas, si no está en uso y ocupan poco espacio, Python caché temporalmente esta memoria.
Tupla de inicialización de velocidad mediante el siguiente ejemplo, cinco veces más rápido que el anuncio.
python3 -m timeit 'x=(1,2,3,4,5,6)'
20000000 loops, best of 5: 9.97 nsec per loop
python3 -m timeit 'x=[1,2,3,4,5,6]'
5000000 loops, best of 5: 50.1 nsec per loop
Diccionarios y colecciones
Diccionario y conjunto sustancialmente de la misma, la única diferencia es que no hay ninguna tecla conjunto emparejado y valores de una serie de azar combinación, única de elementos.
Cómo acceso, uso no dice que la atención sobre dos puntos:
- En el diccionario Python y conjunto, o si el valor de clave, puede ser de tipo mixto
s = {1, 'hello', 5.0}
- claves de índice del diccionario se puede acceder directamente, si no, va a lanzar una excepción, también se puede utilizar la función get (clave, valor predeterminado) para indexar. Si no existe la clave, llame a la función get () puede devolver un valor predeterminado.
d = {'name': 'jason', 'age': 20}
d['name']
'jason'
d['location']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'location'
d = {'name': 'jason', 'age': 20}
d.get('name')
'jason'
d.get('location', 'null')
'null
Diccionario y una colección de obras
Y la estructura interna del diccionario es una colección de tabla hash.
- Para conocer los términos del diccionario, esta tabla almacena el valor hash (hash), y el valor de estos tres elementos clave.
- Y la colección, la diferencia no está emparejado claves y valores en la tabla hash, un solo elemento.
Una tabla hash de la estructura antigua versión de Python se muestra a continuación:
--+-------------------------------+
| 哈希值 (hash) 键 (key) 值 (value)
--+-------------------------------+
0 | hash0 key0 value0
--+-------------------------------+
1 | hash1 key1 value1
--+-------------------------------+
2 | hash2 key2 value2
--+-------------------------------+
. | ...
__+_______________________________+
Con la expansión de la tabla hash, que será cada vez más escasa. Por ejemplo:
{'name': 'mike', 'dob': '1999-01-01', 'gender': 'male'}
Entonces se almacena como una forma similar a la siguiente:
entries = [
['--', '--', '--']
[-230273521, 'dob', '1999-01-01'],
['--', '--', '--'],
['--', '--', '--'],
[1231236123, 'name', 'mike'],
['--', '--', '--'],
[9371539127, 'gender', 'male']
]
Esta estructura de diseño es claramente un enorme desperdicio de espacio de almacenamiento.
Con el fin de mejorar la utilización del espacio de almacenamiento, además de la estructura de diccionario ahora tabla hash en sí, y el índice del valor hash voluntad, el valor de la clave por separado a partir de:
Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------
Entries
--------------------
hash0 key0 value0
---------------------
hash1 key1 value1
---------------------
hash2 key2 value2
---------------------
...
---------------------
En la forma almacenada en la nueva estructura de la tabla de hash, el ejemplo anterior es la siguiente:
indices = [None, 1, None, None, 0, None, 2]
entries = [
[1231236123, 'name', 'mike'],
[-230273521, 'dob', '1999-01-01'],
[9371539127, 'gender', 'male']
]
Insertar
Cada valor hash se inserta en un diccionario o conjunto de elementos, Python primera clave calcula (hash de (tecla)), y luego la máscara = PyDicMinSize - 1 hacer la operación calcula la posición de este elemento debe ser insertado en una mesa de índice hash = almohadilla (clave) y la máscara.
Si la tabla hash en esta posición está vacío, entonces se insertará el elemento. Si esta posición ya está ocupada, Python comparar dos valores hash y los elementos clave son iguales.
Si los dos no son iguales, hay una, en cuyo caso generalmente llamados colisión de hash (hash de colisión), lo que significa que dos elementos claves no son iguales, pero los valores hash son iguales. En este caso, Python va a seguir investigando para la posición de mesa libre, hasta que encuentre la ubicación.
supresión
Para la operación de eliminación, Python temporalmente los elementos de esta posición confiere un valor especial, hasta que vuelva a ajustar el tamaño de la tabla hash, y luego eliminarlo.
Con el fin de garantizar su eficiencia, diccionarios y tablas hash dentro del conjunto, que suelen tener un mínimo de espacio libre para garantizar 1/3. Con la inserción de elementos de tope, cuando el espacio restante es inferior a 1/3, Python va a recuperar más espacio de memoria, la expansión de la tabla hash.
Funciones Alcance Variable
Las variables locales
Si la variable se define dentro de una función, llamada variables locales válidos sólo dentro de la función. Una vez terminada la función, se recuperará la variable local, inaccesible.
Para las funciones anidadas, las funciones internas pueden acceder a las funciones externas variables definidas, pero no modificar, de modificar, se debe agregar a esta palabra clave no local:
def outer():
x = "local"
def inner():
nonlocal x # nonlocal 关键字表示这里的 x 就是外部函数 outer 定义的变量 x
x = 'nonlocal'
print("inner:", x)
inner()
print("outer:", x)
outer()
# 输出
inner: nonlocal
outer: nonlocal
Si no se agrega a esta palabra clave no local, y la función de la variable de funciones y variables del mismo nombre internos y externos, a continuación, la misma variable función interna anula la función variable externa.
def outer():
x = "local"
def inner():
x = 'nonlocal' # 这里的 x 是 inner 这个函数的局部变量
print("inner:", x)
inner()
print("outer:", x)
outer()
# 输出
inner: nonlocal
outer: local
Las variables globales
Las variables globales se definen a nivel de todo el archivo puede estar en cualquier lugar dentro se accede al archivo, pero no puede cambiar el valor de una variable global dentro de la función.
Por ejemplo:
MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
...
MIN_VALUE += 1
...
validation_check(5)
#输出
UnboundLocalError: local variable 'MIN_VALUE' referenced before assignment
Porque, intérprete de Python por defecto variable dentro de la función que las variables locales, pero también encontró que las variables locales MIN_VALUE no declaró, y por lo tanto no puede realizar la operación.
Si tenemos que cambiar el valor de una variable global dentro de una función, es necesario añadir esta declaración mundial:
MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
global MIN_VALUE
...
MIN_VALUE += 1
...
validation_check(5)
Si experimenta las funciones internas de las variables locales y globales del mismo nombre, a continuación, dentro de la función, las variables locales se sobreponen a las variables globales, tales como las siguientes esto:
MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
MIN_VALUE = 3
...
cierres
De cierre vuelve a funciones externas de una función, la función devuelve normalmente asigna una variable que se puede invocar para seguir adelante.
Por ejemplo, queremos calcular la potencia enésima de un número de cierres se pueden escribir con el siguiente código:
def nth_power(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
square
# 输出
<function __main__.nth_power.<locals>.exponent(base)>
cube
# 输出
<function __main__.nth_power.<locals>.exponent(base)>
print(square(2)) # 计算 2 的平方
print(cube(2)) # 计算 2 的立方
# 输出
4 # 2^2
8 # 2^3
Aquí nth_power función externa () Devuelve el valor de una función exponent_of valor específico (), en lugar de uno.
Orientado a Objetos
función
función estática: no hay asociación con la clase se puede utilizar para hacer algunas tareas sencillas de forma independiente, prueba conveniente, sino también para optimizar la estructura de código. función estática antes de la función se puede representar en una fila más @staticmethod.
Funciones: El primer argumento es generalmente CLS, que muestra una clase que se ha pasado. La clase más común de las funciones es la función de diferente init constructor, similar al constructor java. función de clase requiere @classmethod decorador declaró.
función miembro: es nuestra función más normal de la clase, que no requiere ninguna declaración decorativa, el primer argumento a favor de referencias auto el objeto actual, a través de esta función, para lograr la consulta deseada / modificar atributos como características.
Ejemplos son los siguientes:
class Document():
WELCOME_STR = 'Welcome! The context for this book is {}.'
def __init__(self, title, author, context):
print('init function called')
self.title = title
self.author = author
self.__context = context
# 类函数
@classmethod
def create_empty_book(cls, title, author):
return cls(title=title, author=author, context='nothing')
# 成员函数
def get_context_length(self):
return len(self.__context)
# 静态函数
@staticmethod
def get_welcome(context):
return Document.WELCOME_STR.format(context)
empty_book = Document.create_empty_book('What Every Man Thinks About Apart from Sex', 'Professor Sheridan Simove')
print(empty_book.get_context_length())
print(empty_book.get_welcome('indeed nothing'))
########## 输出 ##########
init function called
7
Welcome! The context for this book is indeed nothing.
Heredar
class Entity():
def __init__(self, object_type):
print('parent class init called')
self.object_type = object_type
def get_context_length(self):
raise Exception('get_context_length not implemented')
def print_title(self):
print(self.title)
class Document(Entity):
def __init__(self, title, author, context):
print('Document class init called')
Entity.__init__(self, 'document')
self.title = title
self.author = author
self.__context = context
def get_context_length(self):
return len(self.__context)
class Video(Entity):
def __init__(self, title, author, video_length):
print('Video class init called')
Entity.__init__(self, 'video')
self.title = title
self.author = author
self.__video_length = video_length
def get_context_length(self):
return self.__video_length
harry_potter_book = Document('Harry Potter(Book)', 'J. K. Rowling', '... Forever Do not believe any thing is capable of thinking independently ...')
harry_potter_movie = Video('Harry Potter(Movie)', 'J. K. Rowling', 120)
print(harry_potter_book.object_type)
print(harry_potter_movie.object_type)
harry_potter_book.print_title()
harry_potter_movie.print_title()
print(harry_potter_book.get_context_length())
print(harry_potter_movie.get_context_length())
########## 输出 ##########
Document class init called
parent class init called
Video class init called
parent class init called
document
video
Harry Potter(Book)
Harry Potter(Movie)
77
120
Podemos aprender clase abstracta llamada Entidad, como documentos y video de la clase padre.
Cada clase tiene un constructor, la clase derivada al generar el objeto no se llama automáticamente al constructor de la clase padre, por lo que debe estar en la función init () llamar explícitamente al constructor de la clase padre. Su orden de ejecución es constructor de la subclase -> constructor de la clase padre.
Puesto que se utiliza la clase get_context_length padres que ser reescrito, se genera directamente a través de la función del objeto de entidad, llamada get_context_length (), que elevará Error de interrupción de la ejecución del programa.
ventajas de herencia: reducir la duplicación de código, reducir la entropía del sistema (es decir, complejidad).
clase abstracta
Una clase abstracta es una clase especial que nació como existe una clase padre, una vez que se informó el objeto del error. Del mismo modo, la función resumen se define en la clase abstracta, subclase deben anular esta función se puede utilizar. Correspondiente función abstracta, se representa decorador @abstractmethod.
Una clase abstracta es una dicha presencia, es un estilo de diseño de arriba hacia abajo, sólo se necesita una pequeña cantidad de código describe claramente va a hacer, interfaces bien definidas, a continuación, le puede dar diferentes desarrolladores para desarrollar y atraque .
from abc import ABCMeta, abstractmethod
class Entity(metaclass=ABCMeta):
@abstractmethod
def get_title(self):
pass
@abstractmethod
def set_title(self, title):
pass
class Document(Entity):
def get_title(self):
return self.title
def set_title(self, title):
self.title = title
document = Document()
document.set_title('Harry Potter')
print(document.get_title())
entity = Entity()
########## 输出 ##########
Harry Potter
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-7-266b2aa47bad> in <module>()
21 print(document.get_title())
22
---> 23 entity = Entity()
24 entity.set_title('Test')
TypeError: Can't instantiate abstract class Entity with abstract methods get_title, set_title
Código entidad Entidad = () directamente de error, sólo se puede utilizar adecuadamente por herencia documento Entidad.