memoria
-
El papel de la computadora
- Almacenamiento y computaciónLos datos binarios.
-
Cómo Computer 1 + 1 =? operativo
- 1 se carga en la memoria del ordenador, el ordenador de baseAdición de registroEspecifica los datos almacenados en la memoria de añadido.
- Sin registro resta, + (- 1) es -1.
-
El concepto de variables
- La naturaleza habla, la variable se refiere a un pedazo de espacio de memoria en su ordenador.
- Hay dos propiedades inherentes de espacio de memoria
- Dirección: Representación número hexadecimal
- Papel: cpu conveniente abordar. Número de casa.
- Tamaño: bits, bytes, KB, MB, GB, TB
- Determina el rango de valores almacenados en el bloque de memoria
- Dirección: Representación número hexadecimal
-
A = apreciará que la (punto de referencia) de memoria 10
- Cita: es variableEn términos generales, la pantalla / de almacenamiento variable es un pedazo de espacio de direcciones de memoria del espacio de memoria.
- punto:Si un bloque de almacenamiento de referencia variable / memoria representa un espacio de direcciones, o las referencias al bloque de memoria de variables.
- por ejemplo: Stu = Student (), Stu puntos a espacio de memoria estudiantes correspondiente al objeto
- siguiente = Nodo (), next.item, next.next
-
Para el espacio abierto tamaño de la memoria inherente mismo tipo de datos
- Conformación de datos: 4byte
- Float: 4,8byte
- Carácter: 1 byte
comprensión personal
-
paraalmacenamiento persistentePorque, de acuerdo a las tiendas de la tabla de codificación:
ascii: 1word -> 1 bytegbk1word: -> 2 bytesutf-8: 1word -> 1-4 bytes (o un byte ASCII prima contenida en dos bytes en Europa, Asia, 3 bytes)
-
paraespacio de memoria pitónpara:
-
El tipo de datos de cada asignación de variable es diferente para las diferentes variables espacio reservado,tipo de datos determina el tamaño del espacio de memoria reservado para sólo los datos, mientras que el tamaño de los datos en sí no afectará el tamaño del espacio reservado
-
Memoria se puede ampliar después de más de espacio reservado,Aunque aproximadamente el tamaño de dicho espacio de memoria reservado a medida es un poco un desperdicio de recursos, PeroGuardar la CPU recursos informáticos a reservar espacio para cada elemento en diferentes tamañosY si se calcula de acuerdo con el tamaño del espacio de memoria de datos, siempre y cuando los puntos variables han cambiado, pero el espacio de reserva también recalculado, que está muy ocupada eficiencia de la CPU
-
pitón espacio de reserva:
-
Shaping: 4 bytes;
-
1byte = 8bits,1 bit puede almacenar un número binario, Entonces un byte puede almacenar números binarios de 8 bits, es decir, puede ser almacenado2**8(256) un número decimal (0-255) -
De manera similar, 4 bytes pueden ser almacenados
2**32número decimal semillanp.iinfo('int8') # int，相较于无符号，需要浪费第一位用来储存+-号，2**7=128，所以范围就是 -127~127iinfo(min=-128, max=127, dtype=int8)En [6]:
np.iinfo('uint8') # 无符号int，2**8=256，范围就是0-255iinfo(min=0, max=255, dtype=uint8)
-
-
Flotador: 4/8 bytes (precisión simple / doble precisión);
-
str: 1 1 caracteres de un byte, pero todas las cadenas tienen una final
-0, tendrá un byte de una extra (por ejemplo, 'hola' -> 6 bytes)
-
-
tabla de orden
clasificación
-
elementos de estructura de datos se almacenan en secuencial, estructura de la tabla de secuencia se puede dividir en dos formas:
- Tipo simple de datos (matriz) y múltiples tipos de datos (lista).
-
en pythonLas listas y tuplas pertenecen a varios tipos de datos de mesa fin
-
tipo de datos individual (array) de la figura memoria de tabla de secuencia (RAM continua abierto)
- tipos de datos de matrices están unificados, por lo que el desplazamiento se fija
- Esto puede explicar el origen del índice
-
Múltiples tipos de datos Figura memoria de tabla de secuencia (RAM discontinua abierta)
- lista se puede almacenar en diferentes tipos de datos, de modo que offset diferente, podemos lograr una lista de índice (el mismo offset) almacenado por la dirección de memoria
Figura en la comprensión personal:
-
tabla de orden Categoría:
- estructura de almacenamiento de datos único, múltiples estructuras de almacenamiento de datos
-
Matriz: estructura de almacenamiento de datos único
- Se almacena en los elementos de matriz mismos
- Dentro del tipo de datos de matriz debe ser unificada:Con el fin de facilitar la cantidad de desplazamiento de cálculo
-
Lista: estructura de almacenamiento de datos múltiples
- La lista se almacena en la dirección de memoria! ! !
- Una lista de los elementos no se almacenan directamente en la lista, se almacenan en la memoria en forma de almacenamiento no contiguo, y es sólo una lista de puntos Almacenar la dirección de memoria de cada elemento contenedor ordenada, también por esta razón, la lista puede ser almacenada en diferentes tipos de datos, pero el índice se mantiene sin cambios
-
tabla Order desventaja: insertar los datos, un índice de todos los elementos para ser cambiado después de la posición de inserción, hora de complejidad
-
Lista Contras: hay que encontrar un una baja eficiencia consulta
inconvenientes:
- Estructura necesita conocer de antemano el tamaño de la tabla de datos con el fin de aplicar el espacio de almacenamiento continuo
- ¿Cuál es el espacio de almacenamiento contiguo?
- Es decir, cuando la memoria interna, no uno por uno en el orden de uso, pero a ver quién es, donde no es libre, esto conducirá a un nido de avispas ese caso, utilizar una gran cantidad de espacio se fragmenta, por lo que quiero encontrar unaespacio de memoria continuo, y suficientemente grandePodría retrasar la eficiencia
- ¿Cuál es el espacio de almacenamiento contiguo?
- Y está el espacio tiempo y la memoria para expandir las necesidades de datos a ser reubicados, sino también para encontrar el espacio para satisfacer las condiciones
lista
- Lista (Lista de enlaces) corresponde a estructuras básicas comunes de datos, una tabla lineal, como tabla de secuencias, pero no almacena los datos de forma continua, peroCada nodo (datos medios de almacenamiento) almacenado en la información del siguiente nodo (es decir, dirección)
ventajas:
- tabla Order, cada lista de nodos vinculados puede ser discontinua con respecto, se puede tomar ventaja de espacio de memoria del ordenador, proporcionada por la dirección de memoria del siguiente nodo almacenado en cada nodo que puede lograrse en la búsqueda de la cadena, no hay necesidad de almacenado de forma continua. Esto permite la gestión dinámica de memoria flexibles
- No hay datos de movimiento cuando la dirección de memoria expandida puede ser almacenada en el nodo nuevo, siempre y cuando el último nodo
Debemos poner en práctica los métodos de la lista:
- .is_empty (): la lista está vacía
- .length (): longitud de la cadena
- .travel (): atravesar toda la lista
- .add (elemento): Adición de la cabeza de los elementos de la lista
- .Append (artículo): la cola de la lista para añadir elementos
- .Insert (pos, artículo): Elements Añadir lugar especificado
- .Remove (punto): el nodo Eliminar
- .search (artículo): existe Look para el nodo
nodo
# 节点的封装
class Node(object):
def __init__(self,item):
self.item = item
self.next = None
lista
class Link(object):
"""可以发现链表的各种方法中如果涉及第一个节点都要额外定义，因为第一个节点连接的是self._head"""
def __init__(self):
self._head = None
def is_empty(self):
return self._head == None
def add(self,item):
"""三步走，实例化节点，新节点连上一个节点，self._head连新节点"""
node = Node(item)
node.next = self._head
self._head = node # 将_head指向当前节点
def append(self,item):
node = Node(item)
# 如果链表为空
if not self._head:
self._head = node
return
cur = self._head
pre = None # 用来存储cur的上一个节点，因为while循环最后会找到None为止，到时候再找上一个对象就麻烦了，所以我们手动存储
while cur:
pre = cur
cur = cur.next
pre.next = node # 当while循环结束的时候，pre就指向了链表中最后一个节点，而不是None
def travel(self):
# cur指向了第一个节点
# _head要永远指向第一个节点，轻易不要修改_head的指向，不然可能会导致数据丢失，
# 因为你每个节点就只存储了下一个点的内存地址，一个点断了，后面的数据就都找不到了
cur = self._head
while cur:
print(cur.item)
cur = cur.next
def length(self):
count = 0
cur = self._head
while cur:
count += 1
cur = cur.next
return count
def search(self,item):
"""查找item对应的节点是否存在，返回Bool"""
cur = self._head
while cur:
if cur.item == item:
return True
cur = cur.next
return False
def insert(self,pos,item):
"""
插入操作核心在于pre跟cur代表两个连续的节点，根据索引进行循环得到pre跟cur后，
pre.next连接node，node.next连接cur
"""
node = Node(item)
if pos == 0: # 插入首位需要调整self._head值
node.next = self._head
self._head = node
return
# 在非首位插入元素
cur = self._head
pre = None
for i in range(pos):
pre = cur
cur = cur.next
pre.next = node
node.next = cur
def remove(self,item):
"""删除核心在于，并没有进行删除操作，只是将要删除节点的前后节点直接进行连接，跳过该节点"""
if self._head.item == item:
self._head = self._head.next
pre = None
cur = self._head
while cur.next: # 这里为了避免循环内cur.next得到的是None，下面的cur.item会报错，'NoneType' object has no attribute 'item'
pre = cur
cur = cur.next
if cur.item == item:
pre.next = cur.next
return
uso:
link = Link()
#link.add(1)
#link.add(3)
#link.add(2) # 2,3,1
link.append(4)
link.append(6)
link.append(5) # 2,3,1,4,6,5
link.travel()
print(link.search(1))
4
6
5
False
insertar
link = Link()
link.append(4)
link.append(5)
link.append(6)
link.insert(0,7) # 插哪个位置都可以
link.travel()
7
4
5
6
eliminar
link = Link()
link.append(4)
link.append(5)
link.append(6)
link.remove(5) # 插哪个位置都可以
link.travel()
4
6
preguntas de la entrevista:
- Voltear lograr su propia lista
- 1,2,3,4,5
- Provisión flip: 5,4,3,2,1
- Requisitos: Punto de modificar el nodo para lograr una salida invertida de la lista!
código:
# 节点的封装
class Node(object):
def __init__(self,item):
self.item = item
self.next = None
class Link(object):
def __init__(self):
self._head = None
def is_empty(self):
return self._head == None
def add(self,item):
"""三步走，实例化节点，新节点连上一个节点，self._head连新节点"""
node = Node(item)
node.next = self._head
self._head = node # 将_head指向当前节点
def append(self,item):
node = Node(item)
# 如果链表为空
if not self._head:
self._head = node
return
cur = self._head
pre = None # 用来存储cur的上一个节点，因为while循环最后会找到None为止，到时候再找上一个对象就麻烦了，所以我们手动存储
while cur:
pre = cur
cur = cur.next
pre.next = node # 当while循环结束的时候，pre就指向了链表中最后一个节点，而不是None
def travel(self):
# cur指向了第一个节点
# _head要永远指向第一个节点，轻易不要修改_head的指向，不然可能会导致数据丢失，
# 因为你每个节点就只存储了下一个点的内存地址，一个点断了，后面的数据就都找不到了
cur = self._head
while cur:
print(cur.item)
cur = cur.next
def length(self):
count = 0
cur = self._head
while cur:
count += 1
cur = cur.next
return count
def search(self,item):
"""查找item对应的节点是否存在，返回Bool"""
cur = self._head
while cur:
if cur.item == item:
return True
cur = cur.next
return False
def insert(self,pos,item):
"""
插入操作核心在于pre跟cur代表两个连续的节点，根据索引进行循环得到pre跟cur后，
pre.next连接node，node.next连接cur
"""
node = Node(item)
if pos == 0: # 插入首位需要调整self._head值
node.next = self._head
self._head = node
return
# 在非首位插入元素
cur = self._head
pre = None
for i in range(pos):
pre = cur
cur = cur.next
pre.next = node
node.next = cur
def remove(self,item):
"""删除核心在于，并没有进行删除操作，只是将要删除节点的前后节点直接进行连接，跳过该节点"""
if self._head.item == item:
self._head = self._head.next
pre = None
cur = self._head
while cur.next: # 这里为了避免循环内cur.next得到的是None，下面的cur.item会报错，'NoneType' object has no attribute 'item'
pre = cur
cur = cur.next
if cur.item == item:
pre.next = cur.next
return
def reverse(self):
"""实现链表的反转"""
cur = self._head
pre = None
while cur:
storage = cur.next # 先把下一个节点存起来，不然数据周转不开
cur.next = pre # 下一个节点的next指向上一个节点
pre = cur # 老操作了
cur = storage # cur往前推进
self._head = pre
uso:
li = Link()
items = [1,2,3,4,5]
for item in items:
li.append(item)
li.travel()
li.reverse()
print('-')
li.travel()
resultados:
1
2
3
4
5
-
5
4
3
2
1