Python高级之常见的内置函数

常见的内置函数

内置函数官方文档

  • 截止到python版本3.6.2 ，一共提供了68个内置函数，具体如下
Built-in Functions
Aabs()aiter()all()any()anext()ascii()
Bbin()bool()breakpoint()bytearray()bytes()
Ccallable()chr()classmethod()compile()complex()
Ddelattr()dict()dir()divmod()
Eenumerate()eval()exec()
Ffilter()float()format()frozenset()
Ggetattr()globals()
Hhasattr()hash()help()hex()
Iid()input()int()isinstance()issubclass()iter()
Llen()list()locals()
Mmap()max()memoryview()min()
Nnext()
Oobject()oct()open()ord()
Ppow()print()property()
Rrange()repr()reversed()round()
Sset()setattr()slice()sorted()staticmethod()str()sum()super()
Ttuple()type()
Vvars()
Zzip()
__import__()

str / int / float / list / dict / set / bool / tuple : 类型强转

'''当数据符合强转的类型是就可以强转'''
# 如果数据不符合将会报错
# ValueError: invalid literal for int() with base 10: 'str'
str()
int()
float()
list()
dict()
set()
bool()
tuple()

input / print : 输入输出

user = input("用户可以输入内容，并由变量接收")
print(user) #输出

id / type : 变量的三大特征

txt = 'hello world'
print(id(txt))  # 2145145789424
print(type(txt))  # <class 'str'>

abs : 求绝对值

# 求绝对值
num = -1.5
print(abs(num))
# 1.5

bin / oct /hex : 进制转换

num = 520
print(bin(num))  # 0b1000001000
print(oct(num))  # 0o1010
print(hex(num))  # 0x208

divmod : 获取商和余数

num1 = 9
num2 = 2
print(divmod(num1, num2))
# (4, 1)
# 9 / 2 = 商4余1

'''如果整除余数就为0'''
num1 = 9
num2 = 3
print(divmod(num1, num2))
# (3, 0)
  • 在做页面分页时，可以使用
gross = 1234  # 总共的信息数
every_page = 50  # 每一页上50条内容
quotients, remainders = divmod(gross, every_page)  # 取出商和余数
if remainders != 0:  # 如果余数不为0，商加1
    quotients += 1
print(f"总共 {gross} 条信息 共需要 {quotients} 页")

round : 四舍五入、保留小数位数

使用方法：round(number,digits)

digits>0，四舍五入到指定的小数位
digits=0, 四舍五入到最接近的整数
digits<0 ，在小数点左侧进行四舍五入
如果round()函数只有number这个参数，等同于digits=0
四舍五入规则：

要求保留位数的后一位<=4，则舍去，如5.214保留小数点后两位，结果是5.21
要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如5.215，结果为5.21
要求保留位数的最后一位“=5”，且该位数后面有数字，则进位，如5.2151，结果为5.22
要求保留位数的最后一位“>=6”，则进位。如5.216，结果为5.22

'''不填参数默认是0模式，也就是四舍五入到最接近的整数'''
print(round(4.5))  # 4
# 要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位
print(round(4.51))  # 5
# 要求保留位数的最后一位“=5”，且该位数后面有数字，则进位
print(round(4.516, 2))  # 4.52
# 要求保留位数的最后一位“>=6”，则进位
print(round(54.12, -1))  # 50.0
# 在小数点左侧进行四舍五入

pow : 数字的幂次方

'''
参数介绍：
    x — 数值表达式(整数或者浮点数)；
    y — 数值表达式(整数或者浮点数)；
    z — 数值表达式(整数或者浮点数)，默认不设置z值；

返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
'''

pow(x, y[, z])

'''等价于 x ** y '''
print(pow(2, 10))  # 1024
print(pow(2.3, 3))  # 12.166999999999998
print(pow(2.3, 3.3))  # 15.620749173070115
print(2.3 ** 3.3)  # 15.620749173070115

'''当有3个参数时 等价于 x ** y % '''
print(pow(2, 3, 3))  # 2   # 相当于 2**3 = 8  8%3 =2
print(8 % 3)   # 2

sum : 求和

print(sum([1, 2, 3]))   # 6
# 只可以求数字的和
print(sum(['1', '2', '3']))
# TypeError: unsupported operand type(s) for +: 'int' and 'str'

'''可以设置底数'''
print(sum([1, 2, 3], start=10))   # 16

max / min : 求最大值和最小值

print(max([1, 2, 3]))   # 3
print(min([1, 2, 3]))   # 1

'''比较文字长度'''
strings = ['apple', 'banana', 'kiwi', 'orange']
print(max(strings, key=len))
# 可以通过设置key来比较指定内容

'''比较pow的余数值'''
# key 可以自定义
print(max([1, 2, 3], key=lambda x: pow(x, x + 1, 3)))   # 2
print(1 ** 2 % 3)  # 1
print(2 ** 3 % 3)  # 2
print(3 ** 4 % 3)  # 0

print(min([1, 2, 3], key=lambda x: pow(x, x + 1, 3)))  # 3

# 比较字典的值
def dict_max(x):
    return dict1[x]
dict1 = {'1': 3, '2': 2, '3': 1}
print(f"直接max判断，字典中的最大键是{max(dict1)} ,数据类型是{type(max(dict1))},对应的值是{dict1[max(dict1)]} ")
print(f"指定key判断，字典中的最大键是{max(dict1, key=dict_max)} ,数据类型是{type(max(dict1, key=dict_max))},对应的值是{dict1[max(dict1, key=dict_max)]} ")

# 直接max判断，字典中的最大键是3 ,数据类型是<class 'str'>,对应的值是1 
# 指定key判断，字典中的最大键是1 ,数据类型是<class 'str'>,对应的值是3

complex : 复数

# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。

start = complex(3, 4)
print(start)  # (3+4j)

second = complex(5, 9)
print(second)  # (5+9j)

res = start + second
print(res) # (8+13j)

all / any : 条件判断

print(all([1, 1, 1, 0]))   # False
print(any([0, 0, 0, 1]))   # True
  • 在对密码验证时可以使用
input_string = input("请输入密码:")
if any(char.islower() for char in input_string):
    print("密码中含有一个小写字母，密码验证通过！")
else:
    print("密码中必须包含一个小写字母，请重新输入！")

reversed : 翻转

  • 接受一个序列作为参数，并返回一个反向迭代器
list1 = [1, 2, 3]
print(type(reversed(list1)))  # <class 'list_reverseiterator'>
print(tuple(reversed(list1)))  # (3, 2, 1)
print(list(reversed(list1)))  # [3, 2, 1]
print(set(reversed(list1)))  # {1, 2, 3}
'''set 类型，因为某些特性，数字是会按照顺序排序'''
tuple1 = ('a', 'b', 'c')
print(set(reversed(tuple1)))  # {'c', 'b', 'a'}

slice : 切片

list1 = [1, 2, 3, 4, 5, 6]
print(slice(1, 5, 2))  # slice(1, 5, 2)
print(type(slice(1, 5, 2)))  # <class 'slice'>
print(list1[slice(1, 5, 2)])  # [2, 4]
'''等价于'''
print(list1[1:5:2])   # [2, 4]
  • 使用 slice 函数可以将切片的参数提前定义，然后在多个地方重复使用，提高代码的可读性和重用性。

sorted : 排序

  • sorted(iterable,key,reverse)

    • Iterable: 可迭代对象

    • key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

    • reverse: 是否是倒叙. True: 倒叙, False: 正序

list1 = [6, 5, 4, 3, 2, 1]
print(sorted(list1))  # [1, 2, 3, 4, 5, 6]   # 默认不填reverse参数为False,按照正序排序
print(sorted(list1, reverse=True))  # [6, 5, 4, 3, 2, 1]   # reverse参数为True,按照倒叙排序


'''可以自定义排序规则'''
print(sorted(list1, reverse=False, key=lambda x: x ** 2 % 2))
# 可以设置自定义排序,此处为数值的平方除以2的余数
# 6: 36 / 2 商18 余 0 
# 4: 8 / 2  商4 余 0 
# 5: 25 /2 商12 余1
# 3: 9 /2 商 4 余1 
# 1: 1 /2 商0 余1

enumerate ： 枚举

'''枚举就是 (索引值 + 值) 的一个元组'''
list1 = [6, 5, 4, 3, 2, 1]
# start 默认为0 ，也可以指定索引值的起始
print(enumerate(iterable=list1, start=0))  # <enumerate object at 0x000001C21C621C00>

# 可以通过强转得到值
print(list(enumerate(list1)))  # [(0, 6), (1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]
print(tuple(enumerate(list1)))  # ((0, 6), (1, 5), (2, 4), (3, 3), (4, 2), (5, 1))
print(dict(enumerate(list1)))  # {0: 6, 1: 5, 2: 4, 3: 3, 4: 2, 5: 1}

# 可以通过for循环，解压赋值得到 索引值 和 值
for index, value in enumerate(list1):
    print(index, value)

'''指定索引值起始值'''
list1 = [6, 5, 4, 3, 2, 1]
# 起始为1
print(dict(enumerate(iterable=list1, start=1)))
# {1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
# 起始为5
print(dict(enumerate(iterable=list1, start=5)))
# {5: 6, 6: 5, 7: 4, 8: 3, 9: 2, 10: 1}

format ：格式化输出

'''对齐'''
s = "hello world!"
print(format(s, "^20"))  # ^ # 居  中
#     hello world!
print(format(s, "<20"))  # < # 左对齐
# hello world!
print(format(s, ">20"))  # > # 右对齐
#         hello world!

'''进制转换'''
print(format(99, 'b'))  # 二进制:1100011
print(format(99, 'c'))  # 转换成unicode字符:c
print(format(99, 'd'))  # ⼗进制:99
print(format(99, 'o'))  # 八进制:143
print(format(15, 'x'))  # 十六进制(⼩写字母):f
print(format(15, 'X'))  # 十六进制(大写字母):F
print(format(99, 'n'))  # 和d⼀样:99
print(format(99))  # 和d⼀样:99

print('e:', format(123456789, 'e'))  # 科学计数法. 默认保留6位小数:1.234568e+08
print('0.2e:', format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写):1.23e+08
print('0.2E:', format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写):1.23E+08
print('f:', format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数:1.234568
print('0.2f:', format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数:1.23
print('0.10f:', format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print('F:', format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出INF:1234.567890

bytes : 将字符转为二进制数据

str1 = 'hello world'
'''utf-8 中 英文1个字母1个字节 二进制数据'''
print(bytes(str1, encoding='utf8'))  # b'hello world'
str2 = '你好'
'''utf-8 中 中文1个中文3个字节 二进制数据'''
print(bytes(str2, encoding='utf8'))  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

'''英文可以直接通过【b+''】得到二进制数据，而中文不可以直接使用【b+''】'''
print(b'hello world')
print(b'你好')  # SyntaxError: bytes can only contain ASCII literal characters

bytearray ：字节数组

str1 = 'hello world'
'''utf-8 中 英文1个字母1个字节 二进制数据'''
res = bytearray(str1, encoding='utf8')
print(res)  # bytearray(b'hello world')
print(type(res))  # <class 'bytearray'>
# 通过list 可以查看到每一个字母的编码值
print(list(res))  # [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
# 可以对字符编码进行修改
res[0] = 97
print(str(res))   # bytearray(b'aello world')

str2 = '你好'
'''utf-8 中 中文1个中文3个字节 二进制数据'''
res = bytearray(str2, encoding='utf8')
print(res)  # bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(type(res))  # <class 'bytearray'>
# 通过list 可以查看到每一个字母的编码值
print(list(res))  # [228, 189, 160, 229, 165, 189]
# 可以对字符编码进行修改
res[0] = 229
res[1] = 165
res[2] = 189
print(str(res))  # bytearray(b'\xe5\xa5\xbd\xe5\xa5\xbd')
txt = res.decode(encoding='utf8')
print(txt)   # 好好

str2 = '你好'
'''utf-8 中 中文1个中文3个字节 二进制数据'''
res = bytearray(str2, encoding='utf8')
print(res)  # bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(type(res))  # <class 'bytearray'>
# 通过list 可以查看到每一个字节的编码值
print(list(res))  # [228, 189, 160, 229, 165, 189]
# 可以对字节编码进行修改
res[0] = 97
'''
如果只修改了一个字节编码，且这个编码与中文不一致，将会报错
例如此处，在编码中97 是英文字母a，
而这样，只有5个字节编码了，不满足中文3个字节的条件，utf8编码中将找不到对用的内容
'''
print(str(res))  # bytearray(b'a\xbd\xa0\xe5\xa5\xbd')
txt = res.decode(encoding='utf8')
print(txt)   # UnicodeDecodeError: 'utf-8' codec can't decode byte 0xbd in position 1: invalid start byte

chr / ord : 字符转换

  • ord 函数用于查找字符的 Unicode 码点（code point）
  • chr 函数将 Unicode 码点转换为字符
res = ord("中")
print(res)  # 20013
print(chr(res))  # 中

ascii ：在ASCII编码中查找值

print(ascii('a'))  # 'a'
print(ascii('中'))  # '\u4e2d'   # ascii 中并没有中文 ，返回的值是unicode编码表中的值
print(ascii('国'))  # '\u56fd'   # ascii 中并没有中文 ，返回的值是unicode编码表中的值

# 将上述输出的unicode码点进行chr就可以看到是中
print(chr(ord('\u4e2d')))  # 中

repr ：返回对象的字符串格式

txt = "这是换行符：\n这是制表符：\t制表符以后"
print(txt)  # 转义符将会执行转义
'''
这是换行符：
这是制表符：	制表符以后
'''
print(repr(txt))  # repr不执行转义
# '这是换行符：\n这是制表符：\t制表符以后'
'''可以简写成【r''】引导'''
print(r"这是换行符：\n这是制表符：\t制表符以后")

zip : 拉链

  • zip() 函数

    • 用于将可迭代的对象作为参数
    • 将对象中对应的元素打包成一个元组
    • 然后返回由这些元组组成的列表.

  • 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3))  # <zip object at 0x00000256CA6C7A88>

# 将三组列表打包成 一对一 的元祖
# 如果少则按最少算
for el in zip(lst1, lst2, lst3):
    print(el)

# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')

filter : 过滤

  • 语法：fiter(function. Iterable)

    • function: 用来筛选的函数.

      • 在filter中会自动的把iterable中的元素传递给function.

      • 然后根据function返回的True或者False来判断是否保留留此项数据

    • Iterable: 可迭代对象

  • filter() 过滤 (lamda)

def func(i):  # 判断奇数
    return i % 2 == 1


lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# l1是迭代器
l1 = filter(func, lst)
print(l1)  # <filter object at 0x000001CE3CA98AC8>
print(list(l1))
# [1, 3, 5, 7, 9]

map : 映射

  • 语法 : map(function, iterable)

    • 可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

  • map() 会根据提供的函数对指定序列列做映射(lamda)

def f(i):
    return i


lst = [1, 2, 3, 4, 5, 6, 7, ]
# 把可迭代对象中的每一个元素传递给前面的函数进行处理.
# 处理的结果会返回成迭代器print(list(it))

it = map(f, lst)
print(it)  # <map object at 0x000001EEDDE997B0>

# 如果要查看 map 的结果需要用 list 强转
print(list(it))
# [1, 2, 3, 4, 5, 6, 7]

globals / locals : 名称空间

  • locals() 返回当前作用域中的名字

  • globals() 返回全局作用域中的名字

name = 'user'
age = 18


def outer():
    name_func = 'lenvo'
    age_func = 20
    print(f"locals当前作用域:{locals()}")
    print(f"globals全局作用域:{globals()}")


outer()
'''
locals当前作用域:{'name_func': 'lenvo', 'age_func': 20}

globals全局作用域:{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000258050E4880>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\Files\\Python\\pythonProject1\\python.py', '__cached__': None, 'name': 'user', 'age': 18, 'outer': <function outer at 0x0000025804CD3EB0>}
'''

eval / exec : 执行字符串类型的代码

  • eval() 执行字符串类型的代码. 并返回最终结果
txt = 'input("请输入内容:")'
input_txt = eval(txt)  # 请输入内容:111
print(input_txt)  # 111
exec_input = exec(txt)  # 请输入内容:222
print(exec_input)  # None

'''对于带有运算逻辑的eval就无法执行了，就需要exec'''
txt1 = """
def index():
    print("执行成功")
    return "函数的返回值"
"""
eval(txt1)   # SyntaxError: invalid syntax
  • exec() 执行字符串类型的代码,不返回结果
txt1 = """
def index():
    print("执行成功")
    return "函数的返回值"
"""
res = exec(txt1)
print(res)  # None
res_index = index()  # 执行成功
print(res_index)  # 函数的返回值

image-20240103205459096

isinstance : 判断数据类型

print(isinstance('str', str))   # True
print(isinstance([1, 2, 3], str))  # False
'''也可以是一个元组'''
print(isinstance([1, 2, 3], (str, list)))  # True

range ：循环生成数据

print(range(1, 10))
# range(1, 10)
print(type(range(1, 10)))  # 在python3以后，当range不调用时，就不会生成
# <class 'range'>

print([i for i in range(1, 10)])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

iter / next : 迭代器

  • iter()
    • 创建迭代器, 内部实际使用的是__ iter__()方法来获取迭代器
list1 = [1, 2, 3, 4]
iter_list = iter(list1)
print(iter_list)  # <list_iterator object at 0x0000025B2D68A6B0>
print(type(iter_list))  # <class 'list_iterator'>
  • next()
    • 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目
list1 = [1, 2, 3, 4]
iter_list = iter(list1)

print(next(iter_list))  # 1
print(next(iter_list))  # 2
print(next(iter_list))  # 3

callable :

  • callable() : 用于检查一个对象是否是可调用的

    • 如果返回True, object有可能调用失败

    • 但如果返回False. 那调用绝对不会成功

a = 10
# 变量a不能被调用

print(callable(a))
# False  

def f():
    print("hello")

# 函数是可以被调用的
print(callable(f))
# True

frozenset：冻结集合

set = {1, 2, 3, 4}
frozen_set = frozenset(set)   # 可以转成冻结集合的并不止集合，列表等也可以转为冻结集合
# 查看冻结集合的hash值
print(hash(frozen_set))
# hash值，只有不可变数据类型有哈希值，而set是可变数据类型
print(hash(set))  # TypeError: unhashable type: 'set'

特点：

  1. 不可变性： 一旦创建，frozenset 对象的内容不可更改。不能添加、删除或更新元素。
  2. 可哈希性： 由于 frozenset 是不可变的，它是可哈希的，可以作为字典的键或放入另一个集合中。

应用场景：

  1. 字典的键： 当你需要在字典中使用集合类型作为键时，由于 set 是不可哈希的，你可以使用 frozenset 作为键。
  2. 集合的元素： 如果你希望将集合作为另一个集合的元素，但不希望集合可变，可以使用 frozenset。
  3. 不可变性要求： 在需要不可变性的场景下，你可以选择使用 frozenset。
set = {1, 2, 3, 4}
frozen_set = frozenset(set)  # 可以转成冻结集合的并不止集合，列表等也可以转为冻结集合
'''普通的集合因为其可变性，所有没有哈希值，而冻结集合有哈希值，所以可以作为字典的键使用'''
dict1 = {frozen_set: "字符串"}

print(dict1[frozen_set])

help : 查看函数或模块用途的详细说明

  • help() : 函数用于查看函数或模块用途的详细说明
def index(name,age):
    '''
    可以读取到函数内部,也就是这里的注释内容
    :param name: 解释形参
    :param age: 解释形参
    :return: 解释返回值
    '''
print(help(index))
'''
index(name, age)
    可以读取到函数内部,也就是这里的注释内容
    :param name: 解释形参
    :param age: 解释形参
    :return: 解释返回值

'''

# 也可以读取内建函数或模块用途的详细说明
print(help(str))

dir：查看内置属性

  • dir() :

    • 查看对象的内置属性

    • 访问的是对象中的 __dir__() 方法

# 查看元组的方法
print(dir(tuple))
posted @ 2024-01-03 21:08  Lea4ning  阅读(19)  评论(0)  编辑  收藏  举报