Meu blog pessoal layout mais confortável: https://www.luozhiyun.com/archives/264
Listas e tuplas
- Lista é dinâmico, não um tamanho de comprimento fixo, podem opcionalmente ser adicionados, eliminados ou alterados elementos (mutável).
- A tupla é estático, o comprimento de um tamanho fixo e não pode ser alterada para aumentar ou deleção (imutáveis).
Se você quiser fazer qualquer "mudança" as tuplas existentes, ele só irá re-abrir um bloco de memória, criar uma nova tupla.
Da seguinte forma:
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 diferenças e tuplas de armazenamento
Como a lista é dinâmica, ele precisa armazenar um ponteiro, para apontar para os elementos correspondentes. Além disso, devido à lista de variáveis, assim o tamanho do comprimento requerido de armazenamento adicional foi alocado, para que ele possa até mesmo expansão.
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个元素的空间
Mas para tuplas, a situação é diferente. tamanho fixo do elemento principal, o elemento não pode ser mudado, o espaço de armazenamento está fixada.
listas de desempenho e tuplas
Tuples do que uma lista de alguns dos mais leves, de modo geral, o desempenho ligeiramente melhor do que a da lista de velocidade tupla.
Python no fundo, fazendo algum cache de recurso de cache de recursos (caching de recursos) para dados estáticos. Em geral, por causa da presença de coleta de lixo, se algumas variáveis não são usados, Python vai recuperar a memória ocupada por eles, retornado para o sistema operacional para que outras variáveis ou outras aplicações.
Mas, para algumas variáveis estáticas, tais como tuplas, se ele não estiver em uso e ocupam pouco espaço, Python irá armazenar em cache temporariamente essa memória.
Tuple inicialização velocidade pelo seguinte exemplo, cinco vezes mais rápido do que a listagem.
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
Dicionários e coleções
Dicionário e conjunto substancialmente o mesmo, a única diferença é que não existe um conjunto emparelhado chaves e os valores de uma série de combinação aleatória, única de elementos.
Como acesso, uso não dizer que a atenção para dois pontos:
- No dicionário Python e conjunto, ou se o valor de chave, pode ser de tipo misto
s = {1, 'hello', 5.0}
- chaves de índice de dicionário pode ser acessado diretamente, se não, ele vai lançar uma exceção, você também pode usar o get (, chave padrão) para o índice. Se a chave não existir, chame a função get () pode retornar um valor padrão.
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
Dicionário e uma coleção de obras
E a estrutura interna do dicionário é uma colecção de tabela hash.
- Para termos do dicionário, essa tabela armazena o valor de hash (Hash), e o valor destes três elementos-chave.
- E a coleção, a diferença não está emparelhado chaves e valores na tabela hash, apenas um único elemento.
Uma tabela da antiga versão estrutura pitão é mostrado abaixo:
--+-------------------------------+
| 哈希值 (hash) 键 (key) 值 (value)
--+-------------------------------+
0 | hash0 key0 value0
--+-------------------------------+
1 | hash1 key1 value1
--+-------------------------------+
2 | hash2 key2 value2
--+-------------------------------+
. | ...
__+_______________________________+
Com a expansão da tabela hash, ele se tornará cada vez mais escassa. Por exemplo:
{'name': 'mike', 'dob': '1999-01-01', 'gender': 'male'}
Em seguida, ele será armazenado como uma forma semelhante ao seguinte:
entries = [
['--', '--', '--']
[-230273521, 'dob', '1999-01-01'],
['--', '--', '--'],
['--', '--', '--'],
[1231236123, 'name', 'mike'],
['--', '--', '--'],
[9371539127, 'gender', 'male']
]
Esta estrutura do projeto é claramente um enorme desperdício de espaço de armazenamento.
A fim de melhorar a utilização do espaço de armazenamento, além do dicionário agora própria estrutura da tabela hash e índice vontade o valor hash, o valor da chave separadamente a partir de:
Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------
Entries
--------------------
hash0 key0 value0
---------------------
hash1 key1 value1
---------------------
hash2 key2 value2
---------------------
...
---------------------
Na forma armazenada na nova estrutura de mesa de hash, o exemplo acima é o seguinte:
indices = [None, 1, None, None, 0, None, 2]
entries = [
[1231236123, 'name', 'mike'],
[-230273521, 'dob', '1999-01-01'],
[9371539127, 'gender', 'male']
]
Inserir
Cada valor hash é inserido num dicionário ou conjunto de elementos, Python primeira chave calcula (de hash (chave)), e, em seguida, mascarar = PyDicMinSize - uma operação de fazer a calcula a posição desse elemento deve ser inserido numa tabela de índice de hash = de hash (chave) e máscara.
Se a tabela hash nesta posição está vazia, então, o elemento irá ser inserido. Se esta posição já ocupada, Python irá comparar dois valores hash e elementos-chave são iguais.
Se os dois não são iguais, há um, caso em que normalmente chamado de colisão de hash (hash de colisão), o que significa que dois elementos-chave não são iguais, mas os valores de hash são iguais. Neste caso, Python vai continuar a olhar para a posição da tabela de reposição, até encontrar a localização.
eliminação
Para a operação de apagamento, o Python temporariamente os elementos desta posição confere um valor especial, até re-ajustar o tamanho da tabela de Hash, e, em seguida, eliminar-lo.
A fim de garantir a sua eficiência, dicionários e tabelas hash dentro do conjunto, que geralmente têm um mínimo de espaço livre para garantir 1/3. Com a inserção de elementos de batente, quando o restante espaço é menos do que 1/3, Python vai recuperar mais espaço de memória, a expansão da tabela hash.
Funções escopo de variáveis
As variáveis locais
Se a variável é definida dentro de uma função, chamadas de variáveis locais válidos somente dentro da função. Uma vez que a função é terminado, a variável local será recuperado, inacessíveis.
Para funções aninhadas, as funções internas podem acessar funções externas variáveis definidas, mas não modificar, modificar, deve ser adicionado a esta palavra-chave não-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
Se você não adicionar a esta palavra-chave não-local, e função variável de funções e variáveis do mesmo nome internos e externos, em seguida, a mesma variável função interna anula a função de variáveis externas.
def outer():
x = "local"
def inner():
x = 'nonlocal' # 这里的 x 是 inner 这个函数的局部变量
print("inner:", x)
inner()
print("outer:", x)
outer()
# 输出
inner: nonlocal
outer: local
Variáveis globais
As variáveis globais são definidas a nível de todo o arquivo pode estar em qualquer lugar dentro do arquivo é acessado, mas não pode alterar o valor de uma variável global dentro da função.
Por exemplo:
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, Python intérprete será o padrão variável dentro da função como variáveis locais, mas também descobriu que as variáveis locais MIN_VALUE não declarou, e, portanto, incapaz de executar a operação.
Se temos de alterar o valor de uma variável global dentro de uma função, é necessário adicionar esta declaração mundial:
MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
global MIN_VALUE
...
MIN_VALUE += 1
...
validation_check(5)
Se você experimentar as funções internas de variáveis locais e globais com o mesmo nome, em seguida, dentro da função, variáveis locais irá substituir variáveis globais, como o presente seguinte:
MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
MIN_VALUE = 3
...
Closures
De fecho externas função retorna um de função, a função retorna normalmente designa uma variável que pode ser invocado para continuar mais tarde.
Por exemplo, queremos calcular a potência n-th de um número de encerramentos podem ser escritos com o seguinte 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
Aqui nth_power função externa () Retorna o valor de um exponent_of função valor específico (), em vez de um.
orientada para o objecto
função
função estática: nenhuma associação com a classe pode ser usado para fazer algumas tarefas simples de forma independente, teste conveniente, mas também para estrutura de código otimizar. função estática antes que a função pode ser representado em uma linha mais @staticmethod.
Funções: O primeiro argumento é geralmente CLS, mostrando uma classe a ser passada. A classe mais comum de funções é a função de diferentes Init construtor, semelhante ao construtor java. função de classe requer decorador @classmethod declarou.
função membro: é a nossa função mais normal da classe, ele não requer qualquer declaração decorativo, o primeiro argumento a favor de auto referências o objeto atual, por meio desta função, para conseguir a consulta desejada / modificar atributos como características.
Exemplos são como se segue:
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.
Herdar
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 classe abstrata chamada Entidade, como documentos e Vídeo da classe pai.
Cada classe tem um construtor, a classe derivada ao gerar o objeto não é automaticamente chamar o construtor da classe pai, então você deve ser na função init () chamar explicitamente o construtor da classe pai. Sua ordem de execução é construtor de subclasse -> construtor da classe pai.
Desde classe get_context_length pai é usado para ser reescrito, ele é gerado diretamente usando a função de entidade objeto, chamada get_context_length (), irá aumentar de erro de interrupção da execução do programa.
Inheritance vantagens: reduzir o código de duplicação, reduzir a entropia do sistema (isto é, da complexidade).
classe abstrata
Uma classe abstrata é uma classe especial que nasceu como existe uma classe pai, uma vez que o objeto do erro é relatado. Da mesma forma, a função abstrato definido na classe abstrata, subclasse deve substituir essa função pode ser usada. Correspondente função abstrata, ela é representada decorador @abstractmethod.
Uma classe abstrata é tal presença de um, é um estilo de design top-down, você só precisa de uma pequena quantidade de código descreve claramente vai fazer, interfaces bem definidas, então você pode dar diferentes desenvolvedores para desenvolver e encaixe .
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
entidade code = Entidade () diretamente de erro, só pode ser usado corretamente pelo Documento herança Entidade.