[Notas de estudo do Python] 09 ancestral Yuan, dicionário, conjunto de operações comuns e princípios básicos do dicionário

Esta série de notas para aprender Python por conta própria, se houver erros, corrija-me

Tupla original

A lista é uma sequência variável, e os elementos da lista podem ser usados arbitrariamente desde os tempos antigos. Os elementos pertencem à sequência imutável e não podem modificar os elementos no ancestral original. Portanto, o ancestral original não tem métodos relacionados, como adicionar elementos, modificando elementos e excluindo elementos.

Yuanzu suporta as seguintes operações:

Acesso ao índice
Operação de corte
Operação de conexão
Operações de associação
Operação de comparação
Contagem: o comprimento do ancestral original len () valor máximo max () valor mínimo min () soma soma ()

Criação de Yuanzu

Crie o ancestral através de (), os parênteses podem ser omitidos

a = (10,20,30) ou a = 10,20,30

Se o ancestral tiver apenas um elemento, ele deve ser seguido por uma vírgula, pois o intérprete interpretará (1) como o inteiro 1 (1,) como o ancestral.
```
a = (1,)
type(a)
```
Criado por tuple ()

tupla (um objeto iterável)
```
a = tuple()
b = tuple("a,b,c")
c = tuple([2,3,4])
d = tuple(range(3))
```
Resumo: tuple () pode receber listas, strings, outros tipos de sequência e iteradores para gerar primitivas.

list () pode receber primitivas, strings, outros tipos de sequência, iteradores, etc. para gerar listas

Acesso ao elemento e contagem do ancestral

O elemento do ancestral não pode ser modificado

a = (10,20,30,40)
a[3] = 15 #报错 TypeError

O acesso ao elemento do ancestral é o mesmo da lista, mas o objeto retornado ainda é o objeto ancestral
```
a = (10,20,30)
a[1]
a[0:2]
```
O método de classificação da lista list.sorted () é modificar o objeto da lista original, mas o ancestral original não tem esse método. Se você quiser classificar o ancestral original, pode usar apenas a função integrada classificada (tupleObj ) e gerar um novo objeto de lista

fecho eclair

zip (List 1, List 2 ...) combina os elementos nas posições correspondentes de várias listas em um ancestral primitivo e retorna este objeto zip.

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
list(d)#[(10,40,70),(20,50,80),(30,60,90)]

Criação dedutiva do gerador

Do ponto de vista formal, a compreensão de gerador é semelhante à compreensão de lista, exceto que a compreensão de gerador usa parênteses, e a compreensão de lista gera diretamente um objeto de lista. A compreensão de gerador gera não uma lista ou um ancestral primitivo, mas um gerador objeto.

Podemos usar o objeto gerador para convertê-lo em uma lista ou ancestral primitivo, ou usar o __next__()método do objeto gerador para percorrer, ou usá-lo diretamente como um objeto iterador. Independentemente do método, após o término do acesso ao elemento, se você precisar revisitar o elemento, deverá recriar o objeto gerador do elemento.

s = (x*2 for x in range(5))#迭代器对象
s
tuple(s)
list(s) #此时为空 因为只能访问一次
s = (x*2 for x in range(5))
s.__next__() #访问下一个元素

Resumo de Yuan Zu

O núcleo de Yuanzu é uma sequência imutável
O acesso e a velocidade de processamento do ancestral original são mais rápidos do que o bloco da lista
Como inteiros e strings, o ancestral pode ser usado como a chave de um dicionário, e a lista nunca pode ser usada como a chave de um dicionário.

dicionário

Um dicionário é uma sequência de variável não ordenada de pares de valores-chave. Cada elemento no dicionário é um "par de valores-chave", incluindo: "objeto-chave" e "objeto de valor". O objeto-chave pode ser usado para obter e excluir rapidamente e atualizar o objeto de valor correspondente.

Na lista, encontramos o objeto correspondente por meio do número do subscrito e, no dicionário, encontramos o objeto de valor correspondente por meio do objeto-chave. Chaves são objetos imutáveis arbitrários, como ancestrais de string de números inteiros de ponto flutuante; mas listas, dicionários e ativações desses objetos variáveis não podem ser usados como "chaves" e "chaves" não podem ser repetidas.

O valor pode ser qualquer dado e pode ser repetido.

Criação de dicionário

Podemos criar um objeto de dicionário por {} dict ()

a = {
      
      'name':'slp','age':18,'job':'teacher'}
b = dict(name='slp',age=18,job='teacher')
a = dict([("name","18"),("age",18)])
c = {
      
      } #空字典对象
d = dict() #空字典对象

Crie um objeto de dicionário por meio de zip ()

k = ['name','age','job']
v = ['slp',18,'teacher']
d = dict(zip(k,v))

Criado por fromkeysO valor está vazioDicionário 's
```
a = dict.fromkeys(['name','age','job'])
```

Acesso aos elementos do dicionário

Obtenha o valor por meio da chave, se a chave não existir, lance uma exceção

a = {
      
      'name':'slp','age':18}
a['name'] #slp
a['job'] #KeyError

Obtenha o valor através do método get (), é recomendado usar, o ponto é: a chave especificada não existe, retorne None, você também pode definir o objeto de retorno padrão quando a chave especificada não existir
```
a = {
      
      'name':'slp','age':18}
a.get('name')
```
Listar vários pares de valores-chave
```
a.items()
```
Liste todas as chaves, liste todos os valores
```
a.keys()
a.values()
```
len () o número de pares de valores-chave
Verifique se a chave está no dicionário
```
'name' in a
```

Adição, modificação, exclusão de elemento de dicionário

Adicione "pares de valores-chave" ao dicionário. Se a "chave" já existe, sobrescreve o valor antigo, se não existe, adicione um novo par de valor-chave
```
a = {
      
      'name','slp'}
a['address']='sx'
```
Use update () para adicionar todos os pares de valores-chave do novo dicionário ao dicionário antigo. Se a chave for repetida, ela será substituída diretamente
```
a = {
      
      'name':'slp','age':18}
b = {
      
      'name':'hp','address':'sx'}
a.update(b)
```
Para excluir elementos do dicionário, você pode usar o método del () ou clear () para excluir todos os pares de valor-chave; pop () exclui o par de valor-chave especificado e retorna o "objeto de valor" correspondente
```
a={
      
      'name':'slp',
 	'age':18}
del(a['name'])
```
popitem (): exclui aleatoriamente e retorna o par de valores-chave. O dicionário é uma sequência de variáveis não ordenadas, então não há conceito do primeiro elemento e o último elemento. popitem () exibe itens aleatórios, porque o dicionário não tem o último elemento ou outros conceitos de pedido, se você quiser excluir um por um, isso é muito eficaz
```
a = {
      
      'name':'slp','age':18}
a.popitem()
```

Descompactação da sequência

A descompactação de sequência pode ser usada para ancestrais, listas e dicionários. O desempacotamento da sequência nos permite atribuir facilmente valores a várias variáveis,

x,y,z = (20,30,10)
x #20
(a,b,c)=(9,8,10)
a #9
[a,b,c]=[10,20,30]
c #30

Quando o desempacotamento da sequência é usado em um dicionário, o padrão é operar em chaves; se você precisa operar em valores de chave, você precisa usar itens (), se você precisa operar em valores, você precisa usar valores ()

s = {
    
    'name':'slp','age':18}
name,age = s
name #'name'
name,age=s.items()
name#{'name','slp'}

exemplo

Os dados da tabela são armazenados em dicionários e listas e acessados

Nome	era	Salário	cidade
Gao Xiaoyi	18	30000	Pequim
Gao Xiaoer	19	20.000	Xangai
Gao Xiaowu	20	10.000	Shenzhen

# -*- coding: utf-8 -*-
"""
Created on Fri Jan 15 14:06:22 2021

@author: sangliping
"""

r1 = {
    
    'name':'高小一','age':18,'salary':30000,'city':'北京'}
r2 = {
    
    'name':'高小二','age':19,'salary':10000,'city':'上海'}
r3 = {
    
    'name':'高小五','age':20,'salary':10000,'city':'深圳'}
tb = [r1,r2,r3]
print(tb)
# 获得第二行人的薪资
print(tb[1].get('salary'))
#打印表中所有的薪资
for i in range(len(tb)):
    print(tb[i].get('salary'))
    
# 打印表的所有数据
for i in range(len(tb)):    
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

Os princípios básicos do dicionário

O núcleo do objeto de dicionário é a tabela hash. A tabela hash é uma matriz esparsa. Cada unidade da matriz é chamada de intervalo. Cada intervalo tem duas partes: uma é uma referência para um objeto-chave e a outra é uma referência para um objeto de valor.

Como todos os intervalos têm a mesma estrutura e tamanho, podemos ler o intervalo especificado por deslocamento
Insira a descrição da imagem aqui

Coloque um par de valores-chave no processo subjacente do dicionário

a = {
    
    }
a['name']='slp'

Suponha que, após o dicionário, um objeto ser criado, o comprimento do array seja 8:
Insira a descrição da imagem aqui

Precisamos colocar o par de valores-chave'name '=' slp 'no objeto de dicionário a. A primeira etapa é calcular o valor hash da chave, que pode ser calculado por hash () em python bin(hash('name'))

Como o comprimento da matriz é 8, podemos usar os 3 dígitos mais à direita do valor hash calculado como o deslocamento, ou seja, 101, o decimal é 5. Verificamos se o balde correspondente ao deslocamento 5 está vazio, se estiver vazio , Coloque o par de valores-chave. Se não estiver vazio, pegue os 3 dígitos corretos por sua vez como o deslocamento, que é 100. Verifique se o balde com deslocamento 4 está vazio, até encontrar um balde vazio e colocar a chave -par par de valores Entre.
Insira a descrição da imagem aqui

O processo subjacente de encontrar "pares de valores-chave" com base em chaves

Quando chamamos a.get ('nome'), encontramos o par de valores-chave de acordo com o nome e encontramos o objeto. A primeira etapa ainda é calcular o valor do hash.

Consistente com o algoritmo de armazenamento do processo subjacente, os números em diferentes posições do valor de hash também são obtidos sequencialmente. Supondo que o comprimento da matriz seja 8, podemos pegar os 3 dígitos mais à direita do valor hash calculado como o deslocamento e verificar se o intervalo correspondente à posição decimal está vazio. Se estiver vazio, retorne Nenhum. Se estiver não vazio, então compare Se eles forem iguais, eles serão retornados como valores.Se eles não forem iguais, eles serão comparados com outros bits por sua vez. Se ainda não for encontrado no final, retorna Nenhum.
Insira a descrição da imagem aqui

Resumindo:

A chave deve ser hashble
- Os ancestrais da string numérica são todos hashable
- Os objetos personalizados precisam oferecer suporte aos três pontos a seguir
  - Suporte a função hash ()
  - __eq__()Métodos de suporte para detectar igualdade
  - Se a==bverdadeiro, então hash(a)==hash(b)também verdadeiro
O dicionário tem uma grande sobrecarga de memória, um espaço típico de tempo
A consulta da chave é rápida
Adicionar uma nova chave ao dicionário pode causar expansão e alterar a ordem das chaves na tabela hash. Portanto, não é necessário modificar o dicionário durante a navegação pelo dicionário.

conjunto

A coleção é desordenada e variável e os elementos não podem ser repetidos. Na verdade, a camada inferior da coleção é implementada por um dicionário. Todos os elementos da coleção são objetos-chave no dicionário, portanto, não podem ser repetidos e únicos.

Criação e exclusão de coleção

Use {} para criar um objeto de coleção e use o método add () para adicionar elementos
```
a = {
      
      3,5,7}
a.add(9)
```
Use set () para converter objetos iteráveis como listas e tuplas em vários. Se houver valores duplicados nos dados, apenas um será mantido.
```
a = ['a','b']
b = set(a)
```
remove () apaga o elemento especificado, clear () apaga toda a coleção

Operações relacionadas à coleção

Como os conceitos da matemática, o python também fornece operações como união, interseção e diferença para conjuntos

a = {
    
    1,2}
b={
    
    's','l'}
a|b #并集
a&b #交集
a-b #差集
a.union(b) #并集
a.intersection(b) #交集
a.difference(b) #差集

Pesquise [Zixin] no WeChat ou digitalize o código QR abaixo para fazer amigos e progredir juntos. O artigo é atualizado continuamente. No momento, estou organizando as notas de estudo das centenas de batalhas do Python e espero mais atualizações no futuro.