Python常用内置函数（一）

---

了解更多的Python相关知识可以访问我的网站

↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
点击此处跳转我的网站

abs() absolute-全称

返回一个数的绝对值
使用方法：

1. abs(x)
2. x.abs()

---

all()

如果 iterable（可迭代对象） 的所有元素均为真值（或可迭代对象为空）则返回 True 。

# all()等价于
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

常见可迭代对象：

• 如list、tuple、dict、set、str等

看下栗子：

x = [1, 3, 5, 6, 0]

print(all(x))

# 结果False，因为迭代到0时，0非真值

y = "You are so cool 0 "  # str类型

for i in y:
    print(type(i), end="")

# 循环结果也是str类型

print(all(y))  # 返回结果为True

if "0":
    print("yes")  # 返回yes

# 说明字符串类型的0是真值，int类型的0为假值

---

any()

与all()相反，只要一个为真就返回True，全为假时返回False

等价于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

---

ascii()

作用：
将内容转化为ascii编码
非 ASCII 字符会用 \x、\u 和 \U 进行转义。

x = "oh my god ! 我的天~ 911"

print(ascii(x))

# result：
#'oh my god ! \u6211\u7684\u5929~ 911'
# 可见英文数字是原样，中文会被转义，后续见到\u开头的可想到是否被ascii编码

---

bin()

作用：进制转换，常将十进制数转成二进制数

print(bin(14))
# 0b1110 0b开头在python中表示二进制数

# 控制是否显示0b开头，提供两种方法:

print(format(14, '#b'), format(14, 'b'))

print(f'{14:#b}', f'{14:b}')

# 0b1110 1110
# 0b1110 1110

---

bool()

作用：返回被测字段是否为真，为真返回True，反之False

print(bool(1))
print(bool(0))
print(bool(False))
print(bool([]))
print(bool({}))
print(bool(()))
print(bool(""))

# True
# False
# False
# False
# False
# False
# False

# 由此可见 0 为假 ，空的列表，元祖，字符串等均为假

---

bytes()

返回一个新的“bytes”对象，这是一个不可变序列

print(bytes([1, 2, 3]))
print(bytes("我的天", "utf-8"))
print("我的天".encode("utf-8"))
print("我的天".encode("gbk"))

#1
b'\x01\x02\x03'
#2
b'\xe6\x88\x91\xe7\x9a\x84\xe5\xa4\xa9'
#3
b'\xe6\x88\x91\xe7\x9a\x84\xe5\xa4\xa9'
#4
b'\xce\xd2\xb5\xc4\xcc\xec'

由1可以看出，bytes可以把list中的所有转成bytes类型，此处仅支持 0 <= x < 256 的整数
2,3不同写法结果一样，看习惯使用

---

callable(object)

如果参数 object 是可调用的就返回 True，否则返回 False。

如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。

请注意类是可调用的（调用类将返回一个新的实例）；

如果实例所属的类有 call() 则它就是可调用的。

class Test:
    def system_out(self):
        pass

def result():
    raise ValueError("Test")

t = Test()

print(callable(t))  # False ,因为没有实现__call__方法

print(callable(Test))  # True ,因为Test可以被实例化,不需要实现__call__

print(callable(result))  # True,即使函数内raise,但它依然是一个可以被调用的方法

print(callable("sss"))  # False,字符串无法被调用


class Test:
    def __call__(self, *args, **kwargs):
        pass

t = Test()

Test类中含有call方法那么他的实例t也是可调用的
print(callable(t)) # True

一个可callable的对象是指可以被调用执行的对象，并且可以传入参数， 用另一个简单的描述方式，只要可以在一个对象的后面使用小括号来执行代码，那么这个对象就是callable对象

---

classmethod

官方解释：

把一个方法封装成类方法。

类方法隐含的第一个参数就是类，就像实例方法接收实例作为参数一样。要声明一个类方法，按惯例请使用以下方案：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。

其所属类以外的类实例会被忽略。

如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

@classmethod 出现

• Python面向对象编程，由于Python不支持多个的參数重载构造函数，比方在C++里，构造函数能够依据參数个数不一样。能够写多个构造函数。Python为了解决问题，采用classmethod修饰符的方式，这样定义出来的函数就能够在类对象实例化之前调用这些函数，就相当于多个构造函数，解决多个构造函数的代码写在类外面的问题。

• 类最基本的作用是实例化出一个对象，但是有的时候再实例化之前，就需要先和类做一定的交互，这种交互可能会影响实际实例化的过程，所以必须放在调用构造函数之前。

• 直接一点来说，我们知道对于一个普通的类，我们要使用其中的函数的话，需要对类进行实例化，而一个类中，某个函数前面加上了staticmethod或者classmethod的话，那么这个函数就可以不通过实例化直接调用，可以通过类名进行调用的

• @classmethod 定义的类方法是可选构造函数中，我们定义了一个类方法，类方法的第一个参数(cls)指代的就是类本身。类方法会用这个类来创建并返回最终的实例。使用类方法的另一个好处就是在继承的时候，保证了子类使用可选构造函数构造出来的类是子类的实例而不是父类的实例。

@classmethod 使用：

简单实例：

class Data_test(object):
    day=0
    month=0
    year=0
    def __init__(self,year=0,month=0,day=0):
        self.day=day
        self.month=month
        self.year=year
    def out_date(self):
        print("year :",self.year)
        print("month :",self.month)
        print("day :",self.day)
t=Data_test(2020,1,1)
t.out_date()

输出：
year :2020
month :1
day :1

如果用户输入的是 “2016-8-1” 这样的字符格式，那么就需要调用Date_test 类前做一下处理

string_date='2020-1-1'
 
year,month,day=map(int,string_date.split('-'))
 
s=Data_test(year,month,day)

先把‘2020-1-1’ 分解成 year，month，day 三个变量，然后转成int，再调用Date_test(year,month,day)函数。 也很符合期望。

那我可不可以把这个字符串处理的函数放到 Date_test 类当中呢？那么@classmethod 就开始出场了：

class Data_test2(object):
    day=0
    month=0
    year=0
    def __init__(self,year=0,month=0,day=0):
        self.day=day
        self.month=month
        self.year=year
    @classmethod
    def get_date(cls,data_as_string):
 
        #这里第一个参数是cls， 表示调用当前的类名
 
        year,month,day=map(int,data_as_string.split('-'))
        date1=cls(year,month,day)     #返回的是一个初始化后的类
        return date1
 
    def out_date(self):
        print("year :",self.year)
        print("month :",self.month)
        print("day :",self.day)

在Date_test类里面创建一个成员函数， 前面用了@classmethod装饰。 它的作用就是有点像静态类，比静态类不一样的就是它可以传进来一个当前类作为第一个参数。那么如何调用呢？

r=Data_test2.get_date("2020-1-1")
 
r.out_date()

输出：

year :2020
 
month :1
 
day :1

这样子等于先调用get_date（）对字符串进行出来，然后才使用Data_test的构造函数初始化。

这样的好处就是你以后重构类的时候不必要修改构造函数，只需要额外添加你要处理的函数，然后使用装饰符 @classmethod 就可以了。

classmethod 和 staticmethod 的区别后续会专门出一章进行具体分析

参考链接： https://blog.csdn.net/qq_23981335/article/details/103798741