from collections.abc import Iterable, Generator, Iterator
'''
abs()
求绝对值
'''
print(abs(-1)) # 1
'''
dict()
创建字典
'''
print(dict(a=1, b=2, c=3)) # {'a': 1, 'b': 2, 'c': 3}
print(dict(zip([1, 2, 3], [4, 5, 6]))) # {1: 4, 2: 5, 3: 6}
'''
help()
查看函数或模块用途的详细说明
'''
help(abs)
'''
min(*args, key=None)
求最小值，可以传入一个key作为比较的标准
'''
lst = [1, 2, 3, 4, 1, 2, 3]
print(min(lst, key=lambda x: lst.count(x))) # 4
'''
setattr(object, name, value)
object---对象
name---属性名
value---属性值
注意：无论调用属性还是方法,都是先强制调用 __getattribute__ 方法,然后再传回属性的值或者是 函数(方法)的引用.
'''
class Person(object):
def __getattribute__(self, item):
return super().__getattribute__(item)
def __setattr__(self, key, value):
super().__setattr__(key, value)
def __getattr__(self, item):
print('没有找到元素')
def __delattr__(self, item):
super().__delattr__(item)
p = Person()
print(p.__dict__)
print(Person.__dict__)
setattr(p, 'age', 18)
print(p.age)
class B(object):
version = 2.0
def __init__(self, x):
self.x = x
self.y = 200
def __getattribute__(self, obj):
if obj == 'x':
return 'xxx'
else:
raise AttributeError
def __getattr__(self, obj):
return 'defaultValue'
def say(self):
print('this is B')
b = B(100)
print(b.x) # 'xxx'
print(b.y) # 'defaultValue
'''
对于属性的获取来说，不管是获取对象的方法还是对象的属性，优先级最高的就是__getattribute__
属性查找优先级：优先级__getattribute__ > 实例的__dict__ > 父类的__dict__ > __getattr__
'''
'''
all(iterable)
iterable里面的所有元素全为真，返回True,否则返回False
'''
print(all([1, 2, 3, None])) # False
'''
dir(obj)
调用对象的__dir__方法，查看对象的所有属性
'''
print(dir(int))
'''
hex()
将其他进制的数转化为16进制
'''
print(hex(1))
'''
next()
调用对象的__next__()方法
'''
class MyData(object):
def __next__(self):
return '1'
m = MyData()
print(next(m)) # 1
'''
slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
slice(stop)从下标0开始
slice(start, stop[, step]) 可以设置开始下标，结束下标和步长
'''
t = slice(5, 10)
my_list = list(range(10))
print(my_list[t]) # [5, 6, 7, 8, 9]
'''
any(iterable)
只要iterable的元素中有任意一个为真，就返回True,否则返回False
'''
print(any([1, 0, None, []])) # True
'''
divmod()
返回商和余数
'''
print(divmod(10, 3)) # (3, 1)
'''
id()
返回对象的内存地址
'''
a = 1
print(id(a)) # 140727303958784
'''
object()
object没有定义__dict__，所以不能对object类实例对象尝试设置属性。
'''
a = object()
a.name = 1 # AttributeError: 'object' object has no attribute 'name'
print(dir(object))
print(dir(a))
class A(object):
pass
a = A()
print(dir(a))
print(dir(A))
'''
sorted(iterable, key=None)
对iterable以key中定义的函数进行排序
'''
a = [1, 2, 3, 1]
print(sorted(a, key=lambda x: a.count(x))) # [2, 3, 1, 1]
'''
ascii(obj)
调用对象的__repr__方法
'''
class Person(object):
def __repr__(self):
return 'hh'
p = Person()
print(ascii(p)) # hh
'''
enumerate(iterable, start=0)
对iterable进行枚举，将每个元素的下标和值一起返回, 可以设定start参数，表示以哪个数字作为开始
'''
for i, v in enumerate([1, 2, 3], start=1):
print(i, v)
# 1 1
# 2 2
# 3 3
'''
input()
获取标准输入，会阻塞, 返回结果为字符串
'''
a = input('请输入：')
print(a)
'''
oct()
将其他进制转化为八进制
'''
print(oct(0b10101)) # 0o25
'''
staticmethod()
返回函数的静态方法，参数是callable
'''
class TestOut(object):
@staticmethod
class TestInner(object):
def __init__(self, value):
self.value = value
t = TestOut.TestInner(1)
print(t.value)
'''
bin()
将其他进制转化为二进制
'''
print(bin(0x123)) # 0b100100011
'''
eval()
将字符串当做可执行的代码并执行,返回结果
'''
test_str = '1 + 2'
print(eval(test_str))
'''
int()
将其他对象转化为整数
'''
print(int('123')) # 123
'''
open()
打开文件
'''
'''
str()
将其他对象转化为字符串
'''
print(str({"a": 1, "b": 2})) # {'a': 1, 'b': 2}
'''
bool()
返回对象的布尔值
'''
'''
exec()
将字符串当做可执行的代码并执行,不返回结果
eval和exec的区别在于exec可以执行多行代码
'''
multi_line = '''
for i in range(10):
print(i)
'''
exec(multi_line)
'''
isinstance(obj, A_tuple)
判断对象是否属于某种类型
'''
print(isinstance(1, (int, float, str))) # True
'''
ord()
获取一个字符的Unicode码点
'''
print(ord('张')) # 24352
'''
sum(iterable, start=0)
求和,可以传入起始值
'''
print(sum([1, 2, 3], 10)) # 16
'''
bytearray(source=None, encoding=None, errors='strict')
返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
'''
print(bytearray(3))
'''
filter(function_or_None, iterable)
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，
最后将返回 True 的元素放到新列表中。
'''
print(list(filter(None, [1, 0, 2, None]))) # [1,2]
def filter_condition(x):
return x >= 5
print(list(filter(filter_condition, [1, 2, 6, 8]))) # [6, 8]
'''
issubclass()
issubclass() 方法用于判断参数class是否是类型参数classinfo 的子类,就是判断继承关系
'''
print(issubclass(int, object)) # True
print(issubclass(int, type)) # False
'''
pow()
幂运算
'''
print(pow(2, 3)) # 8
'''
super()
super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，
'''
class Animal(object):
def color(self):
pass
class Dog(Animal):
def color(self):
super(Dog, self).color()
'''
bytes()
bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本
'''
print(bytes(3)) # b'\x00\x00\x00'
print(bytes([1, 2, 3])) # b'\x01\x02\x03'
'''
float()
将对象转化成浮点数
'''
print(float(4)) # 4.0
'''
iter()
将可迭代对象转化成迭代器对象
'''
print(iter('123')) #
'''
print()
输出函数
'''
'''
tuple()
将对象转化为元组
'''
print(tuple([1, 2, 3])) # (1, 2, 3)
'''
callable()
callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，
调用对象 object 绝对不会成功.对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True
'''
print(callable(1)) # False
print(callable(int)) # True
'''
format()
格式化
'''
print('{}{}'.format('你', '好')) # 你好
print('{2}{1}{0}'.format('吗', '好', '你')) # 你好吗
'''
len()
返回可迭代对象的长度
'''
print(len('123')) # 3
'''
property()
'''
class Person(object):
def __init__(self, age):
self.__age = age
def get_age(self):
print('get_age')
return self.__age
def set_age(self, value):
print('set_age')
self.__age = value
def del_age(self):
print('del_age')
del self.__age
age = property(get_age, set_age, del_age) # 相当于注册了三个方法，获取属性，设置属性，删除属性
p = Person(10)
print(p.age)
p.age = 20
del p.age
class Person(object):
def __init__(self, age):
self.__age = age
@property # 将方法转化成对象的属性
def age(self):
return self.__age
@age.setter
def age(self, value):
self.__age = value
@age.deleter
def age(self):
del self.__age
p = Person(10)
print(p.age)
p.age = 20
del p.age
'''
type(what, bases=None, dict=None)
如果只传入what,将是返回what的类型
如果传入了bases和dict,那么将创建一个类
'''
print(type(1)) #
tt = type('my_int', (object,), {})
a = tt()
print(a) # <__main__.my_int object at 0x000001A6184C4048>
'''
chr()
将Unicode码点转化为字符
'''
print(chr(12345)) # 〹
'''
frozenset(seq=())
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
'''
print(frozenset([1, 2, 3])) # frozenset({1, 2, 3})
print(frozenset('python')) # frozenset({'y', 'h', 'n', 't', 'o', 'p'})
'''
list()
将可迭代对象转化为列表
'''
'''
range(stop)
生成一个可迭代的数字序列
'''
print(isinstance(range(5), Iterable)) # True
print(isinstance(range(5), Iterator)) # False
print(isinstance(range(5), Generator)) # False
'''
vars()
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()
'''
class Person(object):
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
p = Person('张三', 18, 1.8)
print(vars(p)) # {'name': '张三', 'age': 18, 'height': 1.8}
print(vars())
'''
classmethod()
指定方法为类方法
'''
class Person(object):
@classmethod
class P(object):
def __init__(self, value):
print('self', self)
print('value', value)
self.value = value
p = Person.P()
print(p.value)
'''
getattr(object, name, default=None)
获取对象的属性，如果没有，则返回default的值,如果没有给定default的值，则报错
'''
# print(getattr(1, 'name', 2)) # 2
'''
locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。如果不在函数里面，则返回当前模块的全局变量
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True
'''
def test(args):
a = 1
print(locals())
test(4) # {'args': 4, 'a': 1}
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
p = Person('张三', 18)
print(locals())
'''
repr()
调用对象的__repr__方法,将对象转化为供解释器读取的形式
print()一个对象，首先寻找对象的__str__方法，如果没有再寻找__repr__方法。
'''
print(repr(1))
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f'{self.name} {self.age}'
def __repr__(self):
return 'hh'
p = Person('张三', 18)
print(p) # 张三 18
class MyInt(int):
def __str__(self):
return 'tt'
m = MyInt()
print(m) # tt
'''
zip(iter1, iter2=None)
将可迭代对象组合成元组，以最短的为主,
'''
for i in zip([1, 2, 3]):
print(i)
for i in zip([1, 2, 3], [4, 5, 6]):
print(i)
'''
compile(source, filename, mode[, flags[, dont_inherit]])
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
'''
test_str = '''
for i in range(5):
print(i)
'''
c = compile(test_str, '', 'exec')
exec(c)
'''
globals()
将全局变量组合成一个字典
'''
print(locals())
print(globals())
'''
map(func, *iterables)
将可迭代类型的元素全部作用于func,返回结果
'''
print(list(map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])))
'''
reversed(seq)
返回一个反转的迭代器
'''
print(list(reversed([1, 2, 3]))) # [3, 2, 1]
'''
__import__
动态的加载模块和函数
'''
# __import__('a') # 加载a模块
'''
complex()
生成复数
'''
print(complex(1, 2)) # (1+2j)
'''
hasattr()
判断某个对象是否有某个属性
'''
print(hasattr(int, '__init__')) # True
'''
max(*args, key=None)
求最大值,可以通过key传入自定义的比较方式
'''
a = [1, 2, 3, 1]
print(max(a, key=lambda x: a.count(x))) # 1
'''
round()
四舍五入，可以指定位数
'''
print(round(3.1415926535, 3)) # 3.142
'''
delattr()
删除对象的某个属性
'''
'''
hash()
调用对象的__hash__方法，计算对象的hash值
'''
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __hash__(self):
return 1
p = Person('张三', 18)
print(hash(p)) # 1
'''
set()
将对象转化为集合
'''
if __name__ == '__main__':
pass
