No.006-Python-学习之路-Day4-匿名函数|装饰器|迭代器|生成器|json|软件目录结构规范|内置函数

匿名函数

匿名函数及正常函数

# 正常函数及调用
def sayhi(n):
    print(n)
sayhi(11)
# 可以用匿名函数重写
sayhi = lambda n:print(n) # 关键字lambda
sayhi(11)

给匿名函数赋值是完全没有意义的(这里只是为了体现匿名与正常的联系而已)

匿名函数的参数规则及作用域与有名的参数一样

匿名函数的函数体通常应该是一个表达式，该表达式必须要有一个返回值

f = lambda x, n:x ** n # 函数定义及函数体
print(f(2, 10)) # 无意义的调用

lambda匿名函数具体怎么用呢?

匿名函数主要应用在这些对象中:max，min，sorted，map，reduce，filter

#max()函数中key参数使用
#min()函数中key参数同理
#max及min中的key参数，为一个函数，用函数处理iterable中的每一个元素，然后选择所有元素中最大值
info = { 
    "Bruce":{"salary": 10000,"age": 29,"job": "IT"},
    "Amadeus":{"salary": 0,"age": 2,"job": "sleep"}
}
def get_key(dict_key1): # 构建普通函数用于max()函数调用
    return info[dict_key1]["salary"]
print(max(info, key=get_key)) # 使用max取最大值
print(max(info, key=lambda key:info[key]["salary"])) # 使用匿名函数

# sorted()函数中key参数使用
list1 = [1,2,3,-1,-2,-3,-4]
print(sorted(list1, key=lambda item:abs(item), reverse=True)) # 匿名函数

# map()中func参数使用匿名函数
list1 = [1,2,3,-1,-2,-3,-4]
list11 = [11,12,13,-11]
list2 = list(map(lambda item1,item2:item1*item2, list1, list11))#map同时处理两个iterable元素，map返回值为map object可以转换为list
print(list2)

# reduce()在python2是内置函数
# reduce()在python3中移动到了functools模块
import functools
list1 = [1,2,3,4,5,6,7,8,9,10]
result = functools.reduce(lambda x,y:x+y, list1,100) # “100”是初始值
print(result)

# filter()根据func返回是True还是False来判断
list1 = [1,2,3,4,5,6,7,8,9,10]
list2 = filter(lambda x:True if x > 5 else False, list1)
list2 = filter(lambda x:x > 5, list1)
print(list(list2))

 装饰器

装饰器(Decorator)本质:

“器”是函数，本质是函数，即是有特定目的，完成特定任务的子代码块；

那么Decorator的任务即装饰，装饰谁呢？装饰其他函数，即为其他函数添加附加功能

装饰器(Decorator)的原则:

原则1:不能修改被装饰函数的源代码；

原则2:不能修改被装饰函数的调用方式；

从原则上来看，装饰器对被装饰函数来说，是完全透明的，无法感知的。

装饰器(Decorator)的实现:

知识点1:函数即‘变量’的概念，均是在内存中开辟空间存储数据，均需要使用变量名来引用，均可被赋值或者调用

知识点2:高阶函数，参数为函数，或返回值为函数

知识点3:函数的嵌套，函数中又定义函数

总结:装饰器(Decorator) = 高阶函数 + 函数的嵌套

# 高阶函数实现原则一:不修改hello代码，添加计时功能
import time
def func1(func): # 未修改hello源代码
    s_time = time.time()
    func()
    e_time = time.time()
    print("The func {} spend time is {}s.".format(func, e_time-s_time))
def hello():
    time.sleep(1)
    print("hello world!!!")
func1(hello) # 调用方式变了

# 函数的嵌套实现Decorator的原则二:调用方式不变
import time
def func1(func): # 高阶函数实现原则一:不修改hello代码，添加计时功能
    def warpper():
        s_time = time.time()
        func()
        e_time = time.time()
        print("The func {} spend time is {}s.".format(func, e_time-s_time))
    return warpper # 嵌套函数
def hello():
    time.sleep(1)
    print("hello world!!!")
hello = func1(hello) # 嵌套函数实现原则二
hello()

# 使用语法糖和可变顺序及关键字形参，实现完整的装饰器(Decorator)
import time
def timer(func):
    def deco(*args, **kwargs):  # 使用这两个参数可以接收任意的数量，任意种类的参数
        start_time = time.time()
        func(*args, **kwargs)  # 直接将接收到参数传递给func
        stop_time = time.time()
        print("Spend_time:", stop_time-start_time)
    return deco

@timer # 语法糖 等于 tell_name1 = timer(tell_name1)
def tell_name1(name):
    time.sleep(0.1)
    print(name.title())

 装饰器的高阶版

可以将正常的装饰器看作一个整体，而在装饰器上再加一层函数，可以实现更加丰富的装饰

高阶装饰器本质：返回代入参数以后的可调用的实际二层装饰器方法

import time
def timer(choice):
    if choice == "time":
        def father_wrapper(func):
            def wrapper(*args, **kwargs):
                start_time = time.time()
                func(*args, **kwargs)
                stop_time = time.time()
                print("Spend time is {}".format(stop_time - start_time))
            return wrapper
        return father_wrapper
    else:
        def father_wrapper(func):
            def wrapper(*args, **kwargs):
                start_time = time.time()
                func(*args, **kwargs)
                stop_time = time.time()
                print("Spend11 time is {}".format(stop_time - start_time))
            return wrapper
        return father_wrapper
@timer(choice="time") # 语法糖后的"()"为最外层函数传递参数并调用，返回的是根据一定规则生成的装饰器
def func(name):
    time.sleep(1)
    print("func.%s" % name)
func(name="Amadeus")

 多层装饰器

两种多层的区别在于，方式一是装饰装饰器，方式二本质仍然装饰一个函数，而非装饰器；

# decorator的本质是重写函数，将原函数在新函数你调用，并将新函数的内存地址返回给原函数头
def deco_deco_deco(func_deco_deco): # 调用被重写，即装饰的deco_deco装饰器
    def grade_wrapper(func_deco): # 该函数即为deco_deco的重写
        def father_wrapper(func_say):
            def wrapper(*args, **kwargs):
                value = func_deco_deco(func_deco)(func_say)(*args, **kwargs)
                # 上句话的含义是:被deco_deco装饰过的deco装饰器装饰过的say函数的返回值
                new_value = value + "--->From deco_deco_deco"
                return new_value
            return wrapper
        return father_wrapper
    return grade_wrapper # 返回重写，即装饰后的deco_deco装饰器
@deco_deco_deco
def deco_deco(func_deco):
    def father_wrapper(func_say):
        def wrapper(*args, **kwargs):
            value = func_deco(func_say)(*args, **kwargs)
            new_value = value + "-->From deco_deco"
            return new_value
        return wrapper
    return father_wrapper
@deco_deco # deco_say = deco_deco(deco_say)
def deco_say(func_say):
    def warpper(*args, **kwargs):
        value = func_say(*args, **kwargs)
        newvalue = value + "-->From deco_say"
        return newvalue
    return warpper
@deco_say
def say(str):
    return str
print(say("Hello "))

# decorator多层调用时，从最靠近函数位置依次向上
def C(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)+"-->From C"
    return wrapper
def B(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)+"-->From B"
    return wrapper
def A(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)+"-->From A"
    return wrapper
@C # 用C装饰B装饰过的A装饰过的say
@B # 用B装饰A装饰过的say
@A # 用A装饰say
def say(str):
    return str
print(say("Hello"))

 迭代器

可迭代(iterable)

凡是直接作用于for循环的对象，被称之为可迭代对象(iterable),集合数据类型如list，truple，dict，str，都是Itrable不是Iterator，但可以通过iter()函数获得一个Iterator对象；

因为和迭代器相比有一个很大的不同，list/truple/map/dict这些数据的大小是确定的，也就是说有多少事可知的；

So Iterable的优点:可直观查看内部数据；

For 循环的本质:将可迭代对象转换成迭代器，然后利用next进行取值，最后利用异常处理处理StopIteration抛出的异常。

So Iterable的缺点:占用内存，不可迭代取值，仅可以使用index，key来取值；

迭代器可以看作一个有序的，却不知长度的序列，只有通过next()方法调用数据时,Iterator才会计算(惰性计算)，So Iterator的长度可以是无穷大的，比如全体自然数；

list1 = [1,2,3,4,5]
for i in list1:print(i) # 正常for循环

list1 = iter(list1) # 先转换iterable为iterator否则没有next()方法
while True: # 用while模拟的for循环
    try:i = list1.__next__()
    except StopIteration:break 
    else:print(i)

迭代器(iterator)

迭代器是这样的对象：实现了无参数的__next__方法，返回序列中的下一个元素，如果没有元素了，那么抛出StopIteration异常.python中的迭代器还实现了__iter__方法，因此迭代器也可以迭代。

是Python最强大的功能之一，是访问集合元素的一种方式，是可以记住遍历位置的对象；

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退；

迭代器有两个基本的方法：iter()和 next();

迭代器有生成器(generator)、生成器函数(generator function)及其他用__iter__()及__next__()构建的类；

class My_iterator():
    def __init__(self, max_num):
        self.max_num = max_num
    # __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
    def __iter__(self):
        self.num = 0
        return self
    # __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
    def __next__(self):
        if self.num < self.max_num:
            self.num += 1
            return self.num
        else:
            raise StopIteration

from _collections_abc import Iterator, Iterable
My_iter = My_iterator(20)
print(isinstance(My_iter, Iterable)) # 有iter()方法，iterable
print(isinstance(My_iter, Iterator)) # 有iter()方法，有next()方法，iterator

for i in My_iter:
    print(i)

可迭代(iterable)与迭代器(iterator)的判断

from _collections_abc import  Iterator, Iterable
lis = [1,2,3] 
gen = (x**2 for x in range(10) if x >= 3)
print(isinstance(lis, Iterable)) # list可迭代
print(isinstance(lis, Iterator)) # list不是迭代器
print(dir(lis)) # iterable 无next方法，有iter方法
print(dir(iter(lis))) # iterator 有next方法，有iter方法
print(isinstance(iter(lis), Iterator)) # list可以是用iter(）变为迭代器
print(isinstance(gen, Iterable)) # generator可迭代
print(isinstance(gen, Iterator)) # generator 迭代器

生成器

前奏-列表生成式

当我要按照一定的规则(规则不能过于复杂，可以包含for及三元运算)生成一个新列表的时候，可以使用一般的for循环新建，也可以使用列表生成式生成，比如:

# 原列表为[1,2,3,4,5]
# 新列表为原列表每个不小于3的元素的平方
list1 = [1,2,3,4,5]
list2 = [x**2 for x in list1 if x >= 3] # 此为列表生成式
print(list2)

生成器(genrator)定义

由列表生成器可以直接生成一个列表，但是这个列表并不可以是无限大的；

但是，这个“列表”是有一定规律的，我们可以在循环取元素的同时根据规律实时算出这个值，而这种一边循环一边计算的机制，即生成器(genrator)

在 Python 中，使用了 yield 的函数被称为生成器（generator）；

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 或send()时从当前位置继续运行。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器；

from _collections_abc import Generator
# 列表生成式稍作修改
gen = (x**2 for x in range(5) if x > 2)
print(isinstance(gen, Generator))
# 更复杂的用函数构造(斐波那契数列)
def fibo(max_num):
    a, b, d = 0, 1, 1
    while True:
        yield b
        a, b = b, a+b # 相当于 a, b = (b, a+b)
        d += 1
        if d > max_num:
            break
for i in fibo(5):
    print(i)

生成器作用-单线程下实现并发

 单线程下并行效果->异步IO的雏形->协程(单线程下更小的线程单位)
__next__()方法，唤醒生成器，即回到yield
send(args)方法，唤醒生成器，即回到yield，同时将args赋值给yield
nexus的实现设置类似与该种的方法，当然更加复杂了；

import time,random
def consumer(someone):
    print("{}来到包子店吃包子.".format(someone))
    while True:
        baozi = yield  # yield 保存当前状态，并返回
        time.sleep(2)
        print("{}吃了{}个刚刚做好的[{}]包子。".format(someone, baozi[1], baozi[0]))
menu = ["大葱馅", "韭菜馅", "白菜粉丝", "猪肉馅", "牛肉馅", "梅干菜肉", "豆沙馅"]
def producer():
    c1 = consumer("Bruce")  # 使用函数生成C1
    c2 = consumer("Amadeus")  # 使用函数生成C2
    c1.__next__()  # 初始运行generator
    c2.__next__()  # 初始运行generator
    for thing in menu:
        time.sleep(1)
        print("包子店做了一笼{}的包子。".format(thing))
        c1_num = random.randint(1, 7)
        c2_num = 8 - c1_num
        c1_eat = [thing, c1_num]
        c2_eat = [thing, c2_num]
        c1.send(c1_eat) # 将C1吃的包子及数量返回给yield
        c2.send(c2_eat) # 将C2吃的包子及数量返回给yield
producer()

json(JavaScript Object Notation)

什么是json

JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation），是存储和交换文本信息的语法，类似 XML，比 XML 更小、更快，更易解析；

JSON 是轻量级的文本数据交换格式，具有自我描述性，更易理解，只支持简单的数据类型(列表，字典，集合，元祖之类的)；

JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言；

json的序列化与反序列化

关键方法json.dumps(args),json.dump(args, file),json.loads(file_text),json.load(file)

注意dump一次，load一次，千万不要dump多次，如果需要多次dump的，建多个文件;

import json
dict1 = {
    "Bruce":{"age":29, "job": "it"},
    "Amadeus":{"age":2, "job": "sleep"}
}

#json.dump序列化
with open("json.txt", "w", encoding="utf-8") as f:
    json.dump(dict1, f) # 相同->f.write(json.dumps(dict1))

#json.load反序列化
with open("json.txt", "r", encoding="utf-8") as f:
    dict2 = json.load(f)  # 相同->dict2 = json.loads(f.read())

print(dict2, type(dict2))

pickle的序列化与反序列化

 关键方法pickle.dumps(args),pickle.dump(args, file),pickle.loads(file_text),pickle.load(file)

# pickle序列化，因包含byte数据，所以需要使用wb
import pickle
def sayhi():
    print("Ni Hao!")
dict1["fun"] = sayhi
with open("No.014-pickle", "wb") as f:
    pickle.dump(dict1, f)# 相同->f.write(pickle.dumps(dict1))

# pickle可以用来保存更复杂的状态
# pickle只能在python内部使用
# pickle的序列化及反序列化同json
import pickle
def sayhi(name):
    print("Hi {}".format(name))
with open("No.014-pickle", 'rb') as f:
    data1 = pickle.load(f)
print(data1)
data1["fun"]("Amadeus")

 软件目录结构规范

为什么要设计好目录结构?

可读性:不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪，配置文件在哪等等，从而非常快速的了解这个项目；

可维护性高:定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放在什么目录下；这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好；

简单的示例-项目名称Foo:

 

bin/: 存放项目的一些可执行文件，比如foo(调用foo/main.py)，当然你可以起名script/之类的也行；

conf/:存放项目配置文件；

foo/: 存放项目的所有源代码；#源代码中的所有模块、包都应该放在此目录，不要置于顶层目录；#其子目录tests/存放单元测试代码；#程序的主入口命名为main.py；

docs/: 存放一些文档；

setup.py: 安装、部署、打包的脚本，python中有setup-tool来打包成pip能够安装的软件；

requirements.txt: 存放软件依赖的外部Python包列表；

README: 项目说明文件；

如LICENSE.txt,ChangeLog.txt文件，也可包含，但大部分是在开源软件；

实际项目的编写可以参考这个例子:点这里

# 需要动态生成path，好方便移植安装
print(__file__) # __file__返回当前文件的相对路径，看起来返回值像绝对路径的原因是，pycharm调用时从根目录开始调用的，所以看到的是绝对路径

import os,sys
abs_path = os.path.abspath(__file__)
print(abs_path) # 通过相对路径返回绝对路径
file_dir = os.path.dirname(abs_path) # 获取文件的目录

father_file_dir = os.path.dirname(file_dir) # 获取文件(最下层目录)的目录
print(file_dir)
print(father_file_dir)
sys.path.append(father_file_dir) # 添加到PATH中
from core import main
main.say()

 

模块

逻辑上来说模块就是一组功能的组合；实质上一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀；

import加载的模块分为四个通用类别：使用python编写的代码(.py文件)，已被编译为共享库或DLL的C或C++扩展；包好一组模块的包；使用C编写并链接到python解释器的内置模块；

模块的详细讲解:点这里

包(Package)

python package就是一个目录，其中包括一组模块和一个__init__.py文件；

在import包时，实际调用了__init__.py文件；

# __init__.py
# 可以使用from package import * -->导入所有的模块，同时访问时不需要加包名
__all__ = ['accounts', 'auth', 'db_handler', 'logger', 'main', 'transaction']

# main.py
from core import *
auth.auth()# 未写包名字

 __init__.py
# 通过__init__中的import可以指定在导入包的同时默认导入的模块
import core.accounts # 父文件->执行import时，当前目录是不会变的（就算是执行子目录的文件），还是需要完整的包名；

# main.py
import core # 调用package->调用->__init__.py->执行import core.accounts->调用了core.accounts模块
core.auth.auth() #通过包(core)调用模块(auth)调用模块中的函数(auth)

目录(Directory)

Dictionary在pycharm中就是一个文件夹，放置资源文件，或者说在进行物体识别时，用来存储背景图像的文件夹。该文件夹其中并不包含__init__.py文件；

So 目录(Directory)即没有包(Package)的初始化的一些功能，直接import目录(Directory)是没有意义的；

 内置函数

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

 abs(x)

返回一个数的绝对值，参数为整数或浮点数；

all(iterable)

iterable中所有元素为真或iterable为空，返回Truce，否则False;

any(iterable)

iterable中任意元素为真，则返回Truce，否则False，iterable为空，返回False;

ascii(object)

类似于函数repr()，返回一个对象为可打印的字符串，区别在于ascii()返回的字符串中非 ASCII 编码的字符，会使用 x、u 和 U 来转义，repr()会正常显示；

list1 = [1, 2, 3, "我"]
print(ascii(list1))
print(repr(list1))
# 结果
[1, 2, 3, 'u6211']
[1, 2, 3, '我']

bin(int)

将一个整数转变为一个前缀为“ob”的二进制字符串；可以使用format()将前缀去掉；

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

bool([x])

将某个值转换为bool值，当无参数或者参数为假时返回False，否则返回True；

breakpoint(*args, **kwargs)

3.7的新功能，没有研究明白，待基础学完后研究下；

bytearray([source[, encoding[, errors]]])

返回一个新的bytes数组，这个数据是可变的序列，可以调用list的方法；

# 类型为bytearray，整体实际为后面的二进制，每个代表元素的分割，每个元素最大255，可以调用list的一些方法
bytearray(b'xcexd2xcaxc7xb8xf6xbaxc3xc8xcb')

bytes([source[, encoding[, errors]]])

返回一个新的bytes数组，这个数据是不可变的序列，调用的方法类似于字符串；

bytes("我是个好人", encoding="gbk")
# 类型即为普通的bytes类型数据
b'xcexd2xcaxc7xb8xf6xbaxc3xc8xcb'

callable(object)

如果参数 object 是可调用的就返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功;

# 判断是否可被调用，()即调用 # 列表明显无法加"()"即无法调用
def func():pass
list1 = []
print(callable(func),callable(list1)

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数;

@classmethod

类方法，在面向对象后补充

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行；

参数-source:可以是常规的字符串、字节字符串，或者 AST 对象;

参数-filename:ilename 实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 '<string>'）;

参数-mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'；

code = "for i in range(10):print(i)" # 定义一个字符串，内部包含代码
code_com = compile(code, "", 'exec') # 将code预编译成.pyc的对象
exec(code) # 可以直接执行，代码
exec(code_com) # 可以执行，预编译的对象

code_1 = "1+2*311"
code_1_com = compile(code_1, "", 'eval')
print(eval(code_1)) # 可以直接执行，代码
print(eval(code_1_com)) # 可以执行，预编译的对象 # 作用，可用于从其他位置导入代码并运行 # 不可再有语句的时候使用，需进一步了解。

complex([real[, imag]])

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数；

delattr(object, name)

类方法，在面向对象后补充

dict(**kwarg)  dict(mapping, **kwarg) dict(iterable, **kwarg)

创建一个新的字典。dict 对象是一个字典类；

dir([object])

如果没有实参，则返回当前本地作用域中的名称列表，如果有实参，它会尝试返回该对象的有效属性列表；

divmod(a, b)

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。

print(divmod(10, 3), divmod(11.1, 3))
# 返回值
(3, 1) (3.0, 2.0999999999999996)

 enumerate(iterable, start=0)

返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象； enumerate（） 返回的迭代器的 __next__()方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

eval(expression[, globals[, locals]])

expression 参数会作为一个 Python 表达式（从技术上说是一个条件列表）被解析并求值，并使用 globals和 locals 字典作为全局和局部命名空间；

实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象；

exec(object[, globals[, locals]])

这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）；

 filter(function, iterable)

用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。

filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for itemin iterable if item)

float([x])

返回从数字或字符串 x 生成的浮点数。

format(value[, format_spec])

将 value 转换为 format_spec 控制的“格式化”表示，遵循格式规格迷你语言；

frozenset([iterable])

返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素；即返回一个不可变集合；

getattr(object, name[, default])

类方法，面向对象后添加

global()

以一个字典的格式，返回这个程序中所有的变量名:value， 从内存中取出，可以取出变量名哦，可以用来判断变量存不存在之类的;

hasattr(object, name)

 该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。

hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。

# hash是什么? 中文名称叫散列，作用是为无关联的数据建立已经的关系方便查找与修改，且在一个程序中值永远是固定的，详细了解下
print(hash("李大鹏"))
print(hash("李大鹏"))
print(hash("amadeus"))
print(hash("Amadeus"))

help([object])

启动内置的帮助系统（此函数主要在交互式中使用)

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。

id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。

input([prompt])

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。

int([x])

将某个值转换为整数

isinstance(object, classinfo)

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True;

import _collections_abc
print(isinstance(range(10),_collections_abc.Iterable))

issubclass(class, classinfo)

如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True;

iter(object[, sentinel])

返回一个 iterator 对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 __iter__() 方法）的集合对象，或必须支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）;

len(s)

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）;

list([iterable])

虽然被称为函数，list 实际上是一种可变序列类型

locals()

返回locals()所在代码块的局部变量

def loc():
    arc1 = "Happly new year!!!"
    loc_arc = locals() # 返回局部变量
    return loc_arc

arc = "HeHe"
gol_arc = globals() # 返回全局变量，任何位置返回的都是全局变量
print(loc())
print(gol_arc)

map(function, iterable, ...)

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。 如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。

list1 = [1,2,3,4]
list2 = [5,6,7,8,9]
list3 = [10,11,12,13,14,15]
list4 = map(lambda x, y, z: x+y+z, list1, list2, list3 )
print(list(list4))
# 结果
[16, 19, 22, 25]

max(iterable, *[, key, default])

max(arg1, arg2, *args[, key])

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的；

max(1,2,3,4) 
max([1,2,3,4]

min(iterable, *[, key, default])

min(arg1, arg2, *args[, key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的；

memoryview(obj)

返回由给定实参创建的“内存视图”对象。

a = "10"
print(memoryview(a.encode()))
# 结果
<memory at 0x0328C3E8>

next(iterator[, default])

通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

object

类方法，面向对象后补充

oct(x)

将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。

# 如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打开 file 并返回对应的 file objec，如果该文件不能打开，则触发 OSError；

 ord(c)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数，这是 chr() 的逆函数；

pow(base, exp[, mod])

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp；

>>> pow(38, 1, mod=20)
18

print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False)

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出；

file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象；

输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新；

with open("practice.txt", 'w', encoding="utf-8") as f:
    print("Hello", file=f)

property(fget=None, fset=None, fdel=None, doc=None)

类方法，面向对象后添加；

range(start, stop[, step])

虽然被称为函数，但 range 实际上是一个不可变的序列类型；

repr(object)

def func():print("ss")
print(repr(func))
# 结果
<function func at 0x01625610>

reversed(seq)

返回一个反向的 iterator;

round(number[, ndigits])

保存小数点的精度(ndigits)

print(round(10.12, 1))
#结果
10.1

set([iterable])

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。

setattr(object, name, value)

类方法，面向对象后补充

slice(start, stop[, step])

没明白，貌似用于对列表的切片

sorted(iterable, *, key=None, reverse=False)

根据 iterable 中的项返回一个新的已排序列表。

dict1 = {1:9, 2:8, -1:-9, -2:-8, 124:888, 10:666}
print(dict1)
print(sorted(dict1))
print(sorted(dict1.items()))
print(sorted(dict1.items(), key=lambda x:x[1])) # 用value来排序，lambda的作用有待挖掘呀，sort的参数能加哪些呢？有待了解

@staticmethod

类方法，面向对象后补充

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

 返回一个 str 版本的 object

sum(iterable, /, start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

super([type[, object-or-type]])

类方法，面向对象后补充

tuple([iterable])

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

type(name, bases, dict)

传入一个参数时，返回 object 的类型。

vars([object])

函数返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals();

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器;

list1 = [1, 2, 3, 4]
list2 = ["a", "b", "c", "d", "e"]
sum = zip(list1, list2) # zip 拉链的意思，根据建立一一对应的元祖，如果多了删除，生成的对象是迭代器
for i in sum: print(i)  # zip 如果数量不一致时，按照最少的来，# 相应的有个map的语法，可以了解下

__import__(name, globals=None, locals=None, fromlist=(), level=0)

__import__("sys")  # 可以用字符串来表示模块名，并导入 # 很有用....但是无法言传

 内置函数-->https://docs.python.org/zh-cn/3/library/functions.html

 迭代器相关-->https://www.cnblogs.com/luckinlee/p/11620133.html   https://www.runoob.com/python3/python3-iterator-generator.html

 多层装饰器-->https://blog.csdn.net/u010185894/article/details/71191811

end