Aprenda Python função básica programação parte pentear

Seção IX / Seção X

Operação ternária (Operação trinocular)

• Sintaxe:
  • "v = a se a> b else b" # Resumo automático: retorna a quando a condição for atendida, retorne b quando a condição não for atendida

Função

1. Fundamentos da função

1.1 Estrutura básica da função

def 函数名(参数):
    #函数内容
    pass
函数名（参数） # 执行函数 

1.2 Valor de retorno

• valor de retorno, a função retorna Nenhum por padrão

def func():
    reuturn 1,3,"abc" #这种情况会自动转换为元组返回

1.3 Parâmetros de função

• Qual é a passagem do parâmetro da função? [Endereço de memória = referência]
• Qualquer número
• Qualquer tipo
• Referência de posição

def func(name,age,gender):
    pass
func("伊万科夫",25,"人妖")

• Palavra-
  chave de passagem e palavra - chave de passagem e posição, o parâmetro de posição deve estar na frente, o parâmetro de palavra-chave está na parte de trás
• Valor padrão do parâmetro [definição]
  e se o valor padrão for do tipo variável ---》 pit

#该部分代码解释了为什么默认值慎用可变类型
def func(data,value=[]):
    value.append(data)
    return value
v1=func(1) #[1,]
v2=func(1,[11,22,33]) # [11,22,33,1]
v3=func(2) # [1,2]
print(v1) #[1,2]

def func(name,age,gender='男'):
    pass
func("伊万科夫",25,gender="人妖")
func("伊万科夫",gender="人妖",25)  # 错误方式
func("伊万科夫",25)     # gender不传的情况下使用默认值 “男”

• Parâmetros universais

  • * args recebe qualquer número de parâmetros posicionais
    e pode receber qualquer número de parâmetros e converte todos os parâmetros em uma tupla

    def func(*args): # 将所有参数打包成元组传递
        print(args)
    v1 = func((11,22,33,44,55)) #将参数元祖作为整个元组的第一个参数
    print(v1) # ((11,22,33,44,55),)
    v2 = func(*(11,22,33,44,55))# 将元组元素打散再打包成元组传递
    print(v1) # (11,22,33,44,55)
    #**********************************************************
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func(*(11,"aaa"),444,"abc",name="沙鳄鱼",age='30')
    """
    (11, 'aaa', 444, 'abc')
    {'name': '沙鳄鱼', 'age': '30'}
    """
    

  • ** kwargs recebe qualquer número de parâmetros de palavras-chave
    e recebe parâmetros de palavras-chave, e o valor da chave é convertido em um dicionário

    def func(**kwargs):
        print(kwargs)
    func(k1="v1",k2="v2")  #转换字典{"k1":"v1","k2":"v2"}
    func(**{"k1":"v1","k2":"v2"})  #直接传递字典{"k1":"v1","k2":"v2"}
    #**********************************************************
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func((11,"aaa"),444,"abc",name="沙鳄鱼",age='30')
    """
    ((11, 'aaa'), 444, 'abc')
    {'name': '沙鳄鱼', 'age': '30'}
    """
    

1.4 Escopo da função

• Escopo global
• Escopo local
• Resumo:
  • Uma função e um escopo
  • Regras para encontrar dados no escopo: agora olhe dentro do escopo próprio, não é possível encontrar na pesquisa ao longo do pai
  • O escopo filho só pode usar o valor da variável pai e não pode reatribuir o valor de sua variável pai [Reatribuir a variável é equivalente a definir uma nova variável no escopo filho]
  • Para variáveis ​​do tipo variável, o sub-escopo pode modificá-lo
  • Se você precisar atribuir um valor a uma variável global, use a palavra-chave global para encontrar a variável global

name = 'enki'
def func():
    global name # global 关键字 只找全局的变量 【global关键字只查找全局中的变量】
    name = 'alex' 

- 查找父级【上一级】的变量
# 使用关键noglobal关键字

• Convenção de nomenclatura variável
  • Variáveis ​​globais em todas as capitais
  • Variáveis ​​locais em todas as minúsculas

Seção 11 / Seção 12

1. Função sênior pequena

1.1 Designação de funções

• Atribuição de nome de função

def func():
    pass
v1 = func 
v1()

• A função pode ser listada, ditada, configurada, tupla e também pode ser usada como chave e valor do dicionário
• Nomes de funções podem ser usados ​​como nomes de variáveis
• Funções podem ser passadas como parâmetros

def func(arg):
    print(arg)
 def show():
    return 9
func(show)
def func(arg):
    arg() #执行函数
 def show():
    print("执行show函数")
func(show)	

1.2 expressão lambda

• Formulação básica
  e usada para representar funções simples, [não há código complicado dentro da função, apenas valor de retorno simples]

def func(a,b):
    return a + b
func1=lambda a,b:a+b
func2=lambda : 100
func3=lambda a: a+100
func4=lambda *args,**kwargs: len(args)
#默认会将":"后的结果作为返回

Expressões lambda não podem definir variáveis, procure por variáveis, caso contrário, procure o pai. [Expressões lambda são uma função de uma linha]

#一行实现比较两个值大小，返回大的值
func = lambda a,b: a if a > b else b
n = func(33,5)
print(n)

1.3 Funções incorporadas

• Função personalizada
• Funções incorporadas

  • Conversão obrigatória de tipos [int, str, bool, lista, tupla, ditado, conjunto]

  • Correlação numérica [max (), min (), float (), abs (): encontre o valor absoluto, sum ()]

    • divmod (): divida os dois valores para obter o quociente e o restante [Usado para paginação]
    • round (): a conversão retém várias vendas, arredondadas

  • Entrada e saída (impressão, entrada)

  • Relacionado à base

    • conversão bin bin, começando com 0b
    • out octal 0o começo
    • int decimal
    • hex hex 0x

    # 二进制转十进制
    v1 = '0b1101'
    result = int(v1,base=2)
    print(result)
    # 八进制转十进制
    v1 = '0o1101'
    result = int(v1,base=8)
    print(result)
    # 十六进制转十进制
    v1 = '0x1101'
    result = int(v1,base=16 )
    print(result)
    

  • Outro 【tipo, len, intervalo, aberto, id】

  • Codificação relacionada

    • chr () # Encontre o caractere correspondente na codificação Unicode com base no número decimal
    • ord () # encontre o dígito decimal correspondente na codificação Unicode de acordo com o caractere
    • Aplicação: Geração de código de verificação aleatória [Introduzir o módulo aleatório random.randint (10,50) para retornar números aleatoriamente]

  • Funções internas avançadas

    • map (func, v1) [dados do processo]
      & func é uma função, V1 é um tipo de dado iterável, função map () fazendo um loop de cada elemento do parâmetro V1, deixe que cada elemento execute a função func, a função func O resultado é adicionado a uma nova lista e retornado.

    v1 = [11,22,33,44]
    result = map(lambda x: x+100,v1)
    print(list(result)) # 特殊 ,result是一个object对象
    

    • filter (func, v1) [filtrar dados]
      & Faça um loop em cada elemento no parâmetro v1 e dê-o à função func para execução.Se a função func retornar True, adicione o elemento a uma nova lista.
    • reduzir (func, v1) [dados integrados]
      e fazer um loop de cada elemento do parâmetro v1 na função func para execução, retornando o resultado final da execução da função func; [função func requer dois parâmetros, o primeiro parâmetro é anterior à função Valor de retorno de uma execução]
      & python3 precisa importar funções de importação de módulos

    v1 = [1,2,3,4,5]
    result = reduce(lambda x,y: x+y,v1)
    print(result)
    

2. Função avançada

2.1 A função retorna o valor

• Encerramento
  • Crie um espaço de memória para a função manter seus próprios dados (variáveis ​​internas para seu próprio uso), para facilitar a execução posterior da função e chamar [cenário do aplicativo: decorator / código-fonte da Alquimia SQL]
  • Quem criou a função, onde a função começa a executar
  • Função de fechamento: Cada vez que a função é chamada, uma memória é aberta para esta chamada e a memória pode salvar o valor que você deseja usar no futuro
• Passando funções como parâmetros
• Tratar funções como valores de retorno
• Nota: Atribua a função
• Função executiva
  • A função não é chamada, o código interno nunca será executado
  • Quando a função é executada, uma parte da memória é criada para armazenar as informações sobre a execução da função [encerramento]
    # O nome da memória aberta pela função não é usado, não é um fechamento

2.2 Recursão

• O número máximo padrão de recursão é 1000, que pode ser ajustado pelo método no módulo sys; a eficiência é baixa

def func(a):
    if a ==5:
        return 100000
    result = func(a+1) + 10
    return result
v = func(1) # 100050

2.3 Módulo de criptografia

• módulo hashlib

import hashlib
def get_md5(data):
    obj = hashlib.md5("一套随机字符串",encode='utf-8')
    obj.update(data.encode('utf-8')) #python3需要加编码指定
    result = obj.hexdigest()
	return result

• A senha não é exibida, módulo getpass

import getpass
pwd = getpass.getpass('请输入密码：') #密码隐藏不显示
#在终端输入运行（pycharm无法运行不行）
 # getpass 在pycharm终端无法直接运行，如果需要请在命令行或者下方terminal窗口输入py文件运行

Seção XIII / Seção XIV

1. Decorador

• Função: Com base em não alterar o código original da função original, execute automaticamente uma função antes e depois da execução da função
• Escreva um decorador:
  • A função de @x:
    & 1. Execute a função x e passe a seguinte função func1 como parâmetro da função x.
    & 2. Atribua o valor de retorno da execução da função x ao seguinte nome da função func1

#装饰器的编写
def x(func):
    def y():
        ret = func()
        return ret
    return y

#装饰器的应用
@x
def func1():
    pass
@x 
def func2():
    pass

• Cenário de aplicativo: É usado para expansão de função pública para uma função ou funções.
• Formato do decorador:

def 外层函数(参数)：
	def 内层函数(*args,**kwargs):#注意万能参数传递
        return 参数（*args,**kwargs）#注意万能参数传递
    return 内层函数

@外层函数
def index():
    pass
index()

2. Derivação

• Compreensão da lista
  • Formato básico: variável = [variável de loop for; para loop um objeto iterável]

vals = [ i for i in 'alex' ]
v1 = [i+100 for i in range(10)]
v2 = [100 for i in range(10)]
v3 = [99 if i >5 else 66 for i in range(10)]
i = [lambda:100+i for i in range(10)]
v4[0]() #109
v = [i for i in range(10) if i > 5]
# 条件成立才append进去

• Definir derivação
  & v1 = {i para i em 'alex'} # A diferença é definida com deduplicação
• Derivação do dicionário
  & v1 = {'k' + str (i): i para i no intervalo (10)}

3. Decorador com parâmetros

# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次。把每次结果添加到列表中返回
 import random
def x(num):
    def wrapper(func):
        def inner(*args,**kwargs):
            results = []
            for i in range(num):
                value = func(*args,**kwargs)
                if value > num:
                    results.append(value)
            return results
        return inner
    return wrapper

@x(5)
def index():
    return random.randint(0,10)

r = index()
print(r)

4. Módulo

Módulo sys 4.1 [dados relacionados ao interpretador python]

• \ n Wrap
• tabulação
• \ r Voltar ao início da linha atual

##进度条
for i in range(1,101):
    msg = "%s%%\r" %i
    print(msg,end='')

• Escape
  • Adicione a letra r na frente da string para remover os caracteres especiais no conteúdo da string, como \ n não tem mais o significado de nova linha.

s = r""D:\code\s21day14\n1.mp4" 

• sys.argv é comumente usado; [Obter os parâmetros passados ​​quando o usuário executa o script]
  & Obter os parâmetros do script executado são armazenados em uma lista, o 0º parâmetro padrão é o nome do caminho completo do script executado

print(arg)
path = sys.argv[1]
print("删除",path)

• sys.exit (0); encerra o programa

4.2 módulo shutil [Excluir diretório / arquivo]

import shutil
# 删除目录
ret = shutil.rmtree("")
# 重命名
shutil.move("原文件名","新文件名")
#压缩文件
shutil.make_archive("压缩后的文件名称","压缩成什么格式","需要压缩的目录")
#解压文件
shutil.unpack_archive("需要解压的文件名",extract_dir="解压到哪个目录",format="解压格式")

4.3 módulo OS [dados relacionados ao sistema operacional]

• os.path.exists (path) # Retorno True se o caminho existir
• os.path.abspath () # Obter o caminho absoluto do arquivo
• os.path.dirname (arquivo) # Obter o diretório superior do arquivo
• os.path.join (caminho, arquivo) # caminho de emenda
• os.stas (file) .st_size # Obtenha o tamanho do arquivo
• os.listdir (caminho) # Lista todos os arquivos em um diretório [excluindo subdiretórios, primeiro nível]
• os.walk () #Lista todos os arquivos em um diretório (incluindo) subdiretórios [recursivamente]

#查看一个目录下所有的文件
import os
listdir = os.listdir("D:\wuhailuo\python_projects\code\python_jichu\模块作业")
# print(listdir)

# 查询显示指定目录下的所有文件，包括子目录下的所有文件
list_file = os.walk("D:\wuhailuo\python_projects\code\python_jichu\模块作业") #得到一个生成器对象，只有当对其循环是给出结果

for a,b,c in list_file: # a：正在查看的目录，b：此目录下的文件夹,c:此目录下的文件
    for filename in c:
        print(os.path.join(a,filename))

15 aulas / 16 aulas: conhecimento do módulo

Suplemento de conhecimento

• função range: python2 / 3 diferença:
  • python2:
    • range (10): Crie valores de sequência imediatamente na memória
    • xrang (10): não será criado imediatamente na memória; somente quando estiver em loop, será criado enquanto estiver em loop.
  • python3:
    • intervalo (10) = xrang em p2 (10)

1. Conhecimento básico de módulos

1.1 Módulo personalizado

1.1.1 Definir módulo

• O módulo de definição pode considerar um arquivo py ou uma pasta (pacote) como um módulo, para facilitar a chamada posterior de outros arquivos py.
• Para a definição do pacote: [a diferença entre python2 / 3]

py2: 文件夹中必须有 __init__.py
py3:不需要 __init__.py 【推荐写代码时，加上此文件】

1.1.2 Chamada de módulo

• módulo de importação module. function ()
• função de importação de módulo de formulário ()
• função de importação do módulo de formulário como alias alias ()

Sumário

• Quando o módulo e o arquivo a ser executado estão no mesmo diretório e são necessárias muitas funções no módulo, é recomendável usar import para importar o módulo
• Outras recomendações: from module import module module.
• Outras recomendações: from module Função de importação de módulo ()

1.1.3 Suplemento

• importar

  • módulo de importação 1 módulo 1. function ()
  • módulo de importação 1. módulo 2. módulo 3 módulo 1. módulo 2. módulo 3. function ()
  • Especial: init .py é carregado dentro da pasta de importação

• de xxx import xxx

  • Especial: do src import xxx [__init__.py que carrega internamente a pasta src]

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# 导入模块，加载此模块中所有的值到内存
import os
# 导入模块中某个函数功能
from lizhongwei import func,show
from lizhongwei import * #导入这个模块的所有功能
from lizhongwei import func as f # 避免函数重复覆盖，取别名

1.2 Módulo embutido

1.2.1 os module import os

• os.mkdir ("") cria um diretório no diretório em que o script está sendo executado no momento (apenas um nível pode ser gerado)
• os.makedirs (r "dd \ xx \ aa") cria diretórios recursivamente
• renomear os.rename ("")

1.2.2 sys module import sys

• sys.path Por padrão, quando o Python importa módulos, ele pesquisará de acordo com esse caminho de valor.Quando o arquivo python for executado, o caminho do arquivo atual será carregado no sys.path

import sys
### 给Python添加查找模块的路径
sys.path.append('D:\\ ')    

1.2.3 módulo json [comumente usado]

• json é uma string especial. [Lista longa de imagens, sequência, dicionário, números]
  • A sequência contida em json deve estar entre aspas duplas
• A camada mais externa da string json deve ser um contêiner [lista / dicionário]
  • As tuplas são serializadas em listas e as coleções não podem ser serializadas
• Serialização / desserialização de dados no formato json
  • Serialização: Converta valores python em strings de formato json json.dumps ()
  • Desserialização: Converta a sequência de formato json no tipo de dados Python json.loads ()
  • Há chinês no dicionário ou na lista, a serialização deve manter a exibição em chinês [sure_ascii = False]

# 保留中文显示
val = json.dumps(v,ensure_ascii=False)

v = [12,3,4,{'k1':'v1'},True,'asdf']
import json
# 序列化，将python的值转换为json格式的字符串
v1 = json.dumps(v)
s = '["alex",123]'
#反序列化，将json格式的字符串转换为python的数据类型
s1 = json.loads(s)

• json suporta tipos de dados python

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

1.2.4 pickle module [semelhante ao módulo json]

• json Prós: comum a todos os idiomas; Desvantagens: só pode serializar tipos de dados básicos (strings, listas, dicionários, números)
• vantagem de pickle: tudo em python pode ser serializado por ele (objeto de soquete); desvantagem: o conteúdo da serialização só pode ser reconhecido por python.
• A impressão direta serializada de pickle.dumps (v) é um conteúdo binário, que pode ser exibido normalmente pelo processamento de pickle.loads (val). [Código de exemplo abaixo]
• O pickle do tipo de byte é um tipo de byte como b'xxxx 'após a serialização [código de exemplo abaixo]

v = {1,2,3,4,"abc"}
val = pickle.dumps(v) 
print(val)   # b'\x80\x03cbuiltins\nset\nq\x00]q\x01(K\x01K\x02K\x03K\x04X\x03\x00\x00\x00abcq\x02e\x85q\x03Rq\x04.'
******************************
file_obj = open("x.txt",mode='wb')
data = "abc".encode("utf-8")
print(data,type(data))   # b'abc' <class 'bytes'>
file_obj.write(data)
file_obj.close()

1.2.5 módulo de hora e data e hora

• UTC / GMT: Horário mundial
• Hora local: hora no fuso horário local
• módulo de hora 【Obter carimbo de data e hora】
  • time.time (): timestamp: 1970-1-1 00:00 [valor aleatório pode ser usado]
  • time.sleep (10) Tempo de sono / espera em segundos
  • fuso horário time.timezone
• módulo datetime

from datetime import datetime,timezone,timedelta
vl = datetime.now() #当前本地时间
v2 = datetime.utcnow() # 当前UTC时间
tz = timezone(timedelta(hours=7)) # 当前东7区时间
v3 = datetime.now(tz)

• conversão de formato de data e hora

from datetime import datetime,timezone,timedelta
v1 = datetime.now()
# datetime时间格式转换字符串
v1.strftime('%Y-%m-%d %H-%M-%S')
#
v2 = datetime.strptime('2020-03-22','%Y-%m-%d')

• O relacionamento entre data e hora e carimbo de data / hora

ctime =time.time()
v1 = datetime.fromtimestamp(ctime) # 时间戳转datetime
v2 = datetime.now()
v2.timestamp() #datetime转时间戳

1.3 Módulos de terceiros [baixar / instalar / usar]

1.3.1 Pré-requisito para instalar a ferramenta de gerenciamento de pacotes pip, instale o módulo de terceiros através do pip

• Primeiro, é necessário instalar o pip e, em seguida, faça o download e instale o módulo de terceiros necessário através do pip https://pypi.org
  • O padrão está no diretório de instalação do python \ Lib \ site-packages

# pip.exe所在目录添加到环境变量中
pip install 需要安装的模块名称

• Módulos de terceiros comumente usados ​​[solicitações, xlrd]

1.3.2 Instalar módulos de terceiros a partir do código fonte

• Baixar arquivos de origem: arquivos compactados
• Descompacte o arquivo e digite este diretório via comando
• Executar python3 setup.py (nome do arquivo de instalação do módulo) build [Compile check]
• Executar python3 setup.py (nome do arquivo de instalação do módulo) install [install]

1.4 Módulo personalizado

1.4.1 Procedimento

• Criar arquivo xxx.py

def func1():
    pass
def func2():
    pass

• Importar módulos personalizados e chamar funções

import xxx
xxx.func1()
xxx.func2()

2. Tratamento de exceção

• Gramática básica

try:
    程序处理
except exception as e:
    print("异常处理")

• O código contido no try reportará um erro e capturará diretamente a exceção.O código no bloco try não continuará sendo executado. Portanto, tente e tente envolver o loop dentro do loop, o resultado da execução é diferente.

17 aulas / 18 aulas

1. Iterador

• Iterador: Obtenha os elementos no objeto iterável, um por um, e existe o método __next__.
• Objeto iterável: pode ser usado em um loop for ou ter um método __iter__ dentro e retornar um iterador.

# 列表转换成迭代器的两种方式：
v = [1,2,3,4]
#方式一
v1 = iter(v)
#方式二
v2 = v.__iter__()
# 迭代器逐一获取元素,反复调用__next__（）方法
val = v1.__next__()

2. Gerador

2.1 Gerador

• Generator: A
  palavra-chave yield dentro da função & é a função de gerador
  e a função de gerador não é chamada quando a função é chamada.A função de chamada retorna um gerador. Somente quando o gerador é executado em loop, o código dentro da função de gerador é executado ,
  Cada laço for obterá o valor retornado pelo rendimento

def func():
    yield 1
    print("f1")
    yield 2
    print("f2")
    yield 3
    print("f3")
v = func()
# item只拿函数中yield的值
for item in v:
    print(item)
#输出结果：
# 1
# f1
# 2
# f2
# 3
# f3

• Objetos iteráveis: para loops e esses objetos, todos têm métodos de iter e retornam um iterador (também pode ser um gerador)
• Generator: pode ser para loop e possui o método __iter__, mas também o método __next__ (), portanto, o gerador também pode ser chamado de iterador especial ou objeto iterável especial
• Você pode visualizar os métodos pertencentes ao objeto de função através de div (objeto de função)
• Exemplo clássico do gerador, [simulando redis para ler dados em lotes]

#通过生成器读取大数据文件 	[模拟redis数据读取]
import time
"""生成所需数据
with open("data.txt",mode='a+',encoding='utf-8') as fileobject:
    for i in range(1,100):
        fileobject.write("你领取到的号牌是："+str(i)+"\n")
"""
"""生成器函数"""
"""分批去读取文件中的内容，将文件的内容返回给调用者"""
def func():
    index=0
    while True:
        time.sleep(2)
        with open("data.txt",mode='r',encoding='utf-8') as fileobject: #连接上redis
           li = []
           fileobject.seek(index)
           for i in  range(10):
                line = fileobject.readline().strip()
                if not  line:
                    break
                li.append(line)
           index=fileobject.tell()
        # fileobject.close()
        for i in li:
            yield i

v=func()
for l in v:
    print(l)

2.2 Derivação do gerador

• A diferença entre compreensão de lista e compreensão de gerador

#列表推导式
v1 = [i for i in range(10)]
#生成器推导式
v2 = (i for i in range(10))

• A compreensão da lista é executada imediatamente, retornando uma lista de 0 a 9 no loop for.
• O v2 retornado pela derivação do gerador é um gerador.O loop for interno não é executado imediatamente. Somente quando existe um loop for que chama v2 para executar o loop, o loop for interno será executado e retornará de 0 a 9 elementos.

v1 = [lambda : i for i in range(10)] # 列表推导式
v1 = (lambda : i for i in range(10))  # 生成器推导式
# 两者区别
# 列表推导式
def func():
    result = []
    for i in range(10):
        def f():
            return i        
        result.append(f)
    return result
v = func()
for item in v:
    print(item()) # 9*9
#上面函数与下面推导式相等
v1 = [lambda : i for i in range(10)]
for item in v1:
    print(item())

#########################################
# 生成器推导式,
def func():
    for i in range(10):
        def f():
            return i
    yield f     
v = func()
for item in v:
    print(item()) # 0~9
   
# 上面函数与下面推导式相等
v2 = (lambda : i for i in range(10))
for item in v2:
    print(item)

2,3 rendimento de

• O valor após o rendimento da necessidade de retornar um gerador, [por exemplo, o valor de retorno na função test () abaixo não pode ser retornado]
• Consulte o código para obter detalhes

def test():
    yield 1
    yield 2
    yield 3

def func():
    yield "alex"
    yield "enki"
    yield from test()
v = func()
for item in v:
    print(item)
# 执行结果
"alex"
"enki"
1
2
3

3. Suplemento de conhecimentos anteriores

A diferença entre py2 / py3 e suplemento

• tipo de string str e codificação relacionada
  • No py3, tipo de string str [geralmente usado para operações de dados na memória, a codificação de armazenamento é unicode]
  • Em py3, tipo de byte de bytes [geralmente usado para transmissão de rede e armazenamento de dados, a codificação específica é determinada pelo tipo de codificação do cabeçalho do arquivo que executa o arquivo py]
  • O tipo unicode em py2 ---> é o tipo str em py3
  • O tipo str em py2 ----> é o tipo de bytes em py3
• Diferenças nos valores de retorno no dicionário
  • Itens
    • Lista retornada por py2
    • iterador py3 [não pode receber valor pelo índice]
  • valores
    • Lista retornada por py2
    • iterador py3 [não pode receber valor pelo índice]
  • chaves
    • Lista retornada por py2
    • iterador py3 [não pode receber valor pelo índice]
  • O mesmo vale para mapa / filtro

Conhecimento adicional

• Módulo de importação
  • módulo de importação
  • do módulo module module module
  • do módulo módulo de módulo módulo de importação
  • Importação relativa [O módulo deve ter um diretório pai, esta operação não pode ser executada no diretório raiz]
    • a partir de .. módulo de importação
    • do módulo de importação
  • Nota: A nomeação de arquivos e pastas não pode ser igual ao nome do módulo importado, caso contrário, ela será pesquisada diretamente no diretório atual.
• Arquivo principal [função principal] (executando o arquivo py)
  • Distinguir pelo nome do atributo , o valor do atributo __name__ __main__significa arquivo principal

#判断是否为主文件，如果是主文件则执行
if __name__ == '__main__':
    run() #执行入口