# ----------------------------  排序  --------------------------------

# reversed()
# 翻转可迭代对象
print(list(reversed('abc')))
# # 返回反向迭代器序列  必须是具有 __reversed__() 方法或支持序列协议 __len__() 方法与 __getitem__() 方法的整数参数开始于 0 ）

# sorted()
# 返回排序过后的可迭代对象
# sorted(iterable, *, key=None, reverse=False)
lst = [{'address': 2, 'salary': 10000, 'age': 18, 'name': '小A'},
       {'address': 3, 'salary': 12000, 'age': 25, 'name': '小B'},
       {'address': 1, 'salary': 18000, 'age': 28, 'name': '小C'},
       {'address': 1, 'salary': 23000, 'age': 31, 'name': '小D'},
       {'address': 1, 'salary': 23000, 'age': 35, 'name': '小E', }]
print(sorted(lst, key=lambda x: x['address']))  # 以住址排序
print(sorted(lst, key=lambda x: (x['address'], -x['salary'])))  # 以住址排序,之后再以薪资排序
print(sorted(lst, key=lambda x: (x['address'], -x['salary'], -x['age'])))  # 以住址排序,之后再以薪资排序,之后再以年龄排序
lst = [(1, 3), (1, 5), (1, 2), (2, 1)]
print(sorted(lst, key=lambda x: x[0]))  # [(1, 3), (1, 5), (1, 2), (2, 1)] ## 第一个元素以正序排序
print(sorted(lst, key=lambda x: (x[0], -x[1])))  # [(1, 5), (1, 3), (1, 2), (2, 1)]  ## 第一个元素以正序排序 ,第二个元素以倒叙排序

print(sorted([36, 5, -12, 9, -21], key=abs)) # [5, 9, -12, -21, 36] ## 以绝对值排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)) # ['about', 'bob', 'Credit', 'Zoo'] ## 小写字母在前,大写在后

# ----------------------------------filter -- map -- zip --reduce --------------------------------------------
# filter(function, iterable)
# 内置过滤器
def func(x):
    if x >= 2:
        return True
    else:
        return False


filter_obj = filter(func, [1, 2, 3])
generator_obj = (i for i in [1, 2, 3] if func(i))
print([i for i in filter_obj])  # [2, 3]
print([i for i in generator_obj])  # [2, 3]
# 改写成匿名函数
filter_obj = filter(lambda x: True if x >= 2 else False, [1, 2, 3])
print([i for i in filter_obj])  # [2, 3]

# zip()
# zip(*iterables, strict=False) # strict= True 多个迭代器长度相同,则不会引发异常 3.10版本增加的
print(list(zip([1, 2, 3], range(4),
               ('a', 'b', 'c'))))  # [(1, 0, 'a'), (2, 1, 'b'), (3, 2, 'c')]## 并行迭代多个iterable，生成包含每个iterable项的元组

# map(function, iterable, )
# 多个可迭代对象同时迭代  从可迭代第一个参数作为值 知道可迭代对象迭代完成
iterator_obj = map(lambda x: x, range(1, 4))
print([i for i in iterator_obj])  # [1, 2, 3]
iterator_obj = map(lambda x, y: x + y, range(1, 4), range(1, 4))
print([i for i in iterator_obj])  # [2, 4, 6]
iterator_obj = map(lambda x, y: {str(x): str(y)}, range(1, 4), range(1, 4))
print([i for i in iterator_obj])  # [{'1': '1'}, {'2': '2'}, {'3': '3'}]
# 三个列表进行比较 选出下表位置最大的值
lst1 = [4, 1, 12]
lst2 = [5, 2, 11]
lst3 = [6, 3, 16]
iterator_obj = map(lambda x, y, z: max(x, y, z), lst1, lst2, lst3)
print([i for i in iterator_obj])  # [6, 3, 16]

 
from functools import reduce
# 累计执行，返回一个值
print(reduce(lambda x,y: x*10 + y, [3,4,5,6])) # 3456
print(reduce(lambda x,y: x + y, [3,4,5,6]))   # 18 ##  累加
print(reduce(lambda x,y: x - y, [3,4,5,6]))  # 360  ##累减
print(reduce(lambda x,y: x * y, [3,4,5,6]))  # -12  ##累乘
# 常常和map 一起使用
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

# 结果
# 123456789

# -------------------判断对象类型 -------------------------
# isinstance(object, classinfo)
# 返回结果是 True| False  判断对象的类型
print(isinstance('123', str))  # True
print(isinstance('123', list))  # False
print(isinstance(['1', '2', '3'], list))  # True
print(isinstance(['1', '2', '3'], (int, list)))  # True

# issubclass(class, classinfo)
# 返回结果是 True| False # 判断类书是否属于另一个类的子类
print(issubclass(bool, str))  # False
print(issubclass(bool, bool))  # True
print(issubclass(bool, int))  # True
print(issubclass(bool, (str, int)))  # True

# ----------------------------------枚举------------------------
# enumerate(iterable, start=0)
# 返回枚举对象
print(enumerate([1, 2, 3]))  # <enumerate object at 0x01EAABE8>
print(next(enumerate([1, 2, 3])))  # (0, 1)
print(list(enumerate([1, 2, 3])))  # [(0, 1), (1, 2), (2, 3)]
print(list(enumerate([1, 2, 3], 1)))  # [(1, 1), (2, 2), (3, 3)]

# ---------------------------装饰器 ------------------------
# 将方法转换为类方法。 接收一个cls对象参数, 被装饰函数 类可以调用,类对象也可以对用。
# 如果为派生类调用了类方法，则派生类对象将作为隐含的第一个参数传递。 (如果子类调用了父类的@classmethod方法 则cls对象是子类对象)
# @classmethod
# 将方法转换为静态方法, 不接收参数，类 和对象直接调用，Python中的静态方法与Java或C++中的方法类似。
# @staticmethod

# ------------------------------常用运算------------------
# abs()
print(abs(-12.12))  # 12.12  ## 返回数字的绝对值。参数可以是整数、浮点数或实现 __abs__() . 如果参数是复数，则返回其大小。

# divmod()
# 返回商和余数组成的元祖
print(divmod(12.6, 2))  # (6.0, 0.5999999999999996)
print(divmod(12, 5))  # (2, 2)
print(divmod(-12, -5))  # (2, -2)
print(divmod(12, -5))  # (2, -2)
print(divmod(-12, 5))  # (-3, -3)

# round()
# 返回四舍五入
print(round(12.265, 2))  # 12.27 返回 四舍五入小数点后的精度。
print(round(12.345, 2))  # 12.35

# len(s)
# 返回对象长度
print(len('122334'))  # 6

# pow()
print(pow(38, 2))  # 38 的2次方
print(pow(2, 6))  # 2的 6次方
print(pow(2, -1))  # 2的 -1次方

# -----------------all -- any -- sum -- max -- min  ---------------------
# all()
print(all([1, 2, 3]))  # True    ## 所有元素为真则返回True，否则返回假False
print(all([1, 0, 3]))  # False   ## 所有元素为真则返回True，否则返回假False

# any()
print(any([1, 0, 3]))  # True      ## 只要有一个元素为真返回True， 否则返回False
print(any([0, 0, 0]))  # False     ## 只要有一个元素为真返回True， 否则返回False
# sum()
print(sum([1, 2, 3]))  # 可迭代对象所有项的和 可迭代对象的项必须是数字

# max()
# 返回最大项  返回iterable中的最大项或两个或多个参数中的最大小项。
print(max(iter([1, 2, 3]), default='None'))  # 3
print(max(iter([]), default='null'))  # null
print(max('123', '345'))  # 345

# min()
# 返回最小项  返回iterable中的最大项或两个或多个参数中的最小项。
print(min(iter([1, 2, 3]), default='None'))  # 1
print(min(iter([]), default='null'))  # null
print(min('123', '345'))  # 123

# --------------------------- 数字类型转换 ----------------------------
# bin()
print(bin(4))  # ## 将整数转换为前缀为“0b”的二进制字符串。
print(bin(-4))  # ## 将整数转换为前缀为“0b”的二进制字符串。

# oct()
# 八进制
print(oct(10))  # 0o12  ## 将整数转换为以“0o”为前缀的八进制字符串。

# int()
# 十进制
print(int(12.7))  # 12
print(int('13'))  # 13

# hex()
# 十六进制
print(hex(12))  # 0xc   ## 将整数转换为前缀为“0x”的小写十六进制字符串
print(12.12.hex())  # 0x1.83d70a3d70a3dp+3     ## 将小数转换为前缀为“0x”的小写十六进制字符串

# str()
# 常用字符串强转
# str(object='')
# str(object=b'', encoding='utf-8', errors='strict')


# tuple()
# 强制转换元组
# tuple([iterable])
# tuple(list)


# float()
# 强转浮点
print(float('+1.23'))  # 1.23
print(float('   -12345\n'))  # -12345.0
print(float('1e-003'))  # 0.001
print(float('+1E6'))  # 1000000.0
print(float('-Infinity'))  # -inf

# type()
# type(name, bases, dict)## 使用三个参数，返回一个新的类型对象。
type(object)  ## 使用一个参数，返回 object . 返回值是一个类型对象，通常与返回的对象相同 object.__class__ .

# help()
# 获取对象帮助文档
print(help(str))  # 显示对象的帮助文档

# vars()
print(vars(int))  # 返回 __dict__ 模块、类、实例或具有 __dict__ 属性
print(int.__dict__)  #

# callable()
# 类是可调用的
# 类 派生出的对象可不可以调用 取决于类是否有 __call__(self, *args, **kwargs) 方法。
print(callable(int))  # True  ## 返回对象是否可以调用
print(callable('a'))  # False  ## 返回对象是否可以调用

# dir() 返回对象的属性
now = '当前'
_new = '_类内部属性,可以被继承'
__new = '__ 仅限当前类内部使用'  # 不会被dir捕获
print(dir(), '当前文件对象属性！')

# 返回模块属性
import datetime

print(dir(datetime))


# 内核方法
class Shape:
    def __dir__(self):
        return ['area', 'perimeter', 'location']


print(Shape())  # ['area', 'perimeter', 'location']

# dir([object])
# 1)参数为空值时 返回当前文件的可用属性名称列表
# 2)参数为 是一个类型或类对象 则列表包含其属性的名称，以及其基的属性的递归名称
# 3)参数为 是对象 该列表包含对象的属性名称、类属性的名称以及类的基类的递归属性。
# 4) 当参数是类时，元类属性不在结果列表中。

# --------------------------------------生成对象--------------------------------
# 复数对象
# complex([real[, imag]])

# 生成字典对象
# dict(**kwarg)

# object()
# object()  #返回一个新的无特征对象。 object 是所有类的基础。它具有所有Python类实例通用的方法。

# frozenset([iterable])
# 返回一个新的 frozenset 对象
print(frozenset([1, 2, 3]))  # frozenset({1, 2, 3})  不可变集合
print(set([1, 2, 3]))  # {1, 2, 3} # 可变集合

# iter(object[, sentinel])
# 返回一个iterator 对象
iterable_obj = iter([1, 2, 3])
print(next(iterable_obj))  # 1
print(next(iterable_obj))  # 2
print(next(iterable_obj))  # 3
lst = [1, 2, 3]
# print(next(lst)) # 注意列表是可迭代对象，但是列表不是迭代器对象 这个语句会报错！

# --------------------------------------字节操作--------------------------------
# bytearray()
# 返回新的字节数组。这个 bytearray 类是范围0<=x<256的可变整数序列。它具有大多数常用的可变序列方法，如 可变序列类型 以及大多数方法 bytes 类型已见 字节和字节数组操作 .
print(bytearray('你好世界'.encode('utf-8')))  # 如果是 string ，您还必须 encoding
print([i for i in bytearray('你好世界'.encode('utf-8'))])
print(bytearray(12))  # 如果是 整数 ，数组将具有该大小，并将用空字节初始化
print([i for i in bytearray(12)])
print(bytearray())  # 如果没有参数，将创建大小为0的数组。
print([i for i in bytearray()])
# 如果它是符合 buffer interface 对象的只读缓冲区将用于初始化字节数组
# 如果是 可迭代的 ，它必须是范围内整数的可Itable 0 <= x < 256 ，用作数组的初始内容。


# bytes()
# 返回一个新的“bytes”对象，该对象是范围内不可变的整数序列 0 <= x < 256 . bytes 是的不可变版本 bytearray --它具有相同的非变异方法和相同的索引和切片行为。
# print(bytes('你好世界'.encode()))
# print([i for i in bytes('你好世界'.encode())])
# print(bytes('你好世界'.encode())[0:2])
# print([i for i in bytes('你好世界'.encode()[0:2])])

# memoryview()
# memoryview()  # 返回内存视图 目前不知道用法
# 从中检索下一项 迭代器 通过调用它的 __next__() 方法 返回迭代器的下一项
# print(next(iter([1,2,3]))) # 1

# ----------------------------------执行字符串python代码 -----------------------
# 可执行对象
# compile(source, filename, mode)  # 生成此对象交由 exec() 或 eval()执行
# source 可以是普通字符串、字节字符串或AST对象。
# filename 这个 filename 代码的文件地址；如果不是从文件中读取代码，则传递一些可识别的值 'string'。
# 这个 mode 参数指定必须编译的代码类型 三种: 分别是 exec ，eval，single
# 参数 optimize 指定编译器的优化级别 optimize 指定编译器的优化级别；默认值为 -1 选择解释器的优化级别，如 -O 选项。显式级别是 0 （无优化； __debug__ 是真的） 1 （断言被删除， __debug__ 是假的） 2 （文档字符串也被删除）。
# 此函数引发 SyntaxError 如果编译的源无效，并且 ValueError 如果源包含空字节。
# 注解 编译包含多行代码的字符串时 'single' 或 'eval' 模式，输入必须至少以一个换行符终止。这有助于检测 code 模块。
# 警告 由于python的ast编译器中的堆栈深度限制，在编译到ast对象时，可能会使用足够大/复杂的字符串使python解释器崩溃。

# 执行 字符类型的python代码
# eval(expression[, globals[, locals]])
# exec(object[, globals[, locals]])

# ----------------------------------格式化字符串----------------------------------
# format(value[, format_spec])
# 1)默认值 format_spec 是一个空字符串，通常产生与调用相同的效果 str(value) .

print(format(14, '#b'), format(14, 'b'))  # 0b1110 1110
print("二进制: {0:#b}  格式化二进制: {0:b}".format(14))  # 二进制: 0b1110  格式化二进制: 1110 去掉二进制的Ob
print(f'二进制: {14:#b}', f' 格式化二进制: {14:b}')  # 二进制: 0b1110  格式化二进制: 1110 去掉二进制的Ob

print(format(5, 'b'))  # '101'
print(format(5, '#b'))  # '0b101'
print(format(5, '12b'))  # '         101'
print(format(5, '#12b'))  # '       0b101'
print(format(5, '012b'))  # '000000000101'
print(format(5, '#012b'))  # '0b0000000101'

print(format(1003.1415926, '.2f'))  # 1003.14
print(format(1003.1415926, '.2%'))  # 100314.16%
print(format(1003.1415926, ',.2f'))  # 1,003.14
print(format(1003.1415926, ',.2%'))  # 100,314.16%
print(format(1003.1415926, ',.12'))  # 1,003.1415926
print(format(1003.1415926, '_.2%'))  # 100_314.16%

# -----------------------------------------反射 -----------------------------
# delattr(object, name)
# 删除对象属性
# 这是一个亲戚 setattr() . 参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。
# 如果对象允许，函数将删除命名属性。例如， delattr(x, 'foobar') 等于 del x.foobar .

# getattr(object, name[, default])
# 返回对象的属性
print(dir(str))
print(getattr(str, 'as', 'null'))  # 返回对象属性的值 如果属性不存在则返回默认值 没有设置默认值则抛出异常！

# hasattr(object, name)
# 判断对象是否有属性方法
print(hasattr(str, 'as'))  # False ## 参数是一个对象和一个字符串。结果是 True 如果字符串是对象属性之一的名称， False 如果没有
print(hasattr(str, 'count'))  # True ##

# setattr()
# 设置对象属性
# setattr(object, name, value)  # 这是 getattr() .参数是一个对象、一个字符串和一个任意值。# 该字符串可以命名现有属性或新属性。只要对象允许，函数就为属性赋值。例如， setattr(x, 'foobar', 123) 等于 x.foobar = 123 .

# ------------------------------------------- 其他 --------------------------------------------
# __import__()
date = __import__('datetime')  # 延迟导入 # 日常python代码编写不需要用到
print(dir(date))  #

# 内置功能 globals() 和 locals() 分别返回当前的全局和局部字典
print(globals())  # 返回表示当前全局属性的字典。这始终是当前模块的字典（在函数或方法中，这是定义它的模块，而不是从中调用它的模块）
print(locals())  # 更新并返回表示当前本地属性的字典。 当它在函数块中调用时，而不是在类块中调用。注意，在模块级， locals() 和 globals() 是同一本字典。

# property()
# 需要详细解释 内置模块经常使用
# property(fget=None, fset=None, fdel=None, doc=None) # 返回属性属性 # fget 是用于获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。和 doc 为属性创建docstring


# id()
# 返回对象id数值
print(id(1))  # 1515545744 # 返回对象的“标识”。这是一个整数，它保证在这个对象的生存期内是唯一的和不变的。生命周期不重叠的两个对象可能具有相同的 id

# hash()
# 返回对象hash数值
print(hash(str))  # -2052770554  # 返回对象的hash值（如果有）。hash值是整数。
print(hash('123'))  # 字符串每次hash的值都不一样
print(hash(123))  # 123
print(hash(123.12))  # 1889806704

# repr()
# 返回包含对象的可打印表示形式的字符串，通常返回对象的名称和地址
print(repr(object))  # <class 'object'>
print(repr(object))  # <class 'object'> ## 返回包含对象的可打印表示形式的字符串。

# ascii()
# 返回对象的ascii编码格式
print(ascii('你好世界'))  # '\u4f60\u597d \u4e16\u754c' #  返回对象的ascii编码格式
print(ascii([1, 2, 3]))  # [1, 2, 3] #  返回对象的ascii编码格式
print(ascii(['你好', '世界']))  # ['\u4f60\u597d', '\u4e16\u754c'] #  返回对象的ascii编码格式

# bool()
# 返回对象的布尔值
print(bool('1'))  # True
print(bool('0'))  # True
print(bool(''))  # False
# breakpoint()  # 使得控制台进入pdb模式, （目前没有使用过，之后学习使用）

# chr()
# 返回表示其Unicode码位为整数的字符的字符串 i . 参数的有效范围是从0到1114111
print(chr(97))  # a
print(chr(98))  # b
print(chr(114))  # r

# ord()
# 返回单字符字符串的Unicode码位。 chr()对应
print(ord('a'))
print(ord('b'))
print(ord('r'))
print(ord('a'))  # 97 ## 给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode码位的整数。

# range()
# print(range(3))  # range(0, 3) ## range 实际上是不可变的序列类型 并不是一个函数

# super()
# super([type[, object-or-type]]) 继承方法需要 研究下

# open()
# open()  # 打开文件并返回文件对象  ##正常开放 file 并返回相应的 file object . 如果无法打开文件

# print()的特殊用法
wf = open('./text.txt', 'w', encoding='utf-8')
print('你好这是测试输出', '测试分隔', sep='$', end='\t', file=wf, flush=True)
print('你好这是测试输出', '测试分隔', sep='$', end='\t', file=wf, flush=True)
# wf.close()
result = input('标准输入:')  # result 类型为str

class A:
    name = 'A'
    ...

    def __init__(self):
        self.age = 18

    @classmethod
    def get_name(cls, name):
        print(cls.__base__)
        return name

    def __repr__(self):
        return '这是A对象'

    def __index__(self):
        return 4

    def __bool__(self):
        return False

    def __call__(self, *args, **kwargs):
        return '调用结果a!'

    # def __dir__(self):
    #     return ['A']


class B:
    ...


a = A()
b = B()

print(vars(a))  # {'age': 18}  返回对象的self属性
print(vars(b))  # {'age': 18}

print(dir(a))  # ['A']
print(dir(b))  # 其对象, 对象所属类， 所属类父类的所有属性名称。

# # 如果为派生类调用了类方法，则派生类对象将作为隐含的第一个参数传递。 (如果子类调用了父类的@classmethod方法 则cls对象是子类对象)
print(A.get_name('A'))  # A  ## 类可直接调用
print(a.get_name('a'))  # a  ## 对象可直接调用

print(callable(A))  # True
print(callable(a))  # True
print(callable(b))  # False   b 对象是不可调用的

print(a())  # 调用结果a!
print(a.__call__())  # 调用结果a!

print(repr(a))  # 这是A对象
print(a.__repr__())  # 这是A对象

print(bin(a))  # 0b100
print(a.__index__())  # 4

print(bool(a))  # False
print(a.__bool__())  # False

print(hash(a))
print(hash(b))