常用的内置函数

内置函数

• 内置函数（Built-in functions）是编程语言中提供的一组在任何程序中都可以直接使用的函数。这些函数通常是语言本身提供的核心功能，不需要额外的导入或安装。

• 和数字相关

  • 数据类型
  • 进制转换
  • 数学运算

• 和数据结构相关

  • 序列
  • 数据集合
  • 相关内置函数

• 和作用域相关

• 和迭代器生成器相关

• 字符串类型代码的执行

• 输入输出

• 内存相关

• 文件操作相关

• 模块相关

• 帮 助

• 调用相关

• 查看内置属性

【一】数据类型转换

（1）数字类型转换

（1）整数类型转换（int）

• int：整型（整数）

res = '1'
print(int(res), type(int(res)))  # 1 <class 'int'>

（2）浮点数类型转换（float）

• float：浮点型（小数）

res = '1.5'
print(float(res), type(float(res)))  # 1.5 <class 'float'>

（2）字符串类型转换（str）

• str()将数据转化成字符串

print(str(123)+'456')  #123456

（3）布尔类型转换（bool）

• bool: 布尔类型(True / False)

res = 1
res_bool = bool(res)
print(res_bool, type(res_bool))
# True <class 'bool'>

res1 = 0
res_bool = bool(res1)
print(res_bool, type(res_bool))
# False <class 'bool'>

（4）列表类型转换(list)

• list() 将一个可迭代对象转换成列表

print(list((1,2,3,4,5,6)))  

# [1, 2, 3, 4, 5, 6]

（5）元祖类型转换(tuple)

• tuple() 将一个可迭代对象转换成元组

print(tuple([1,2,3,4,5,6]))  

# (1, 2, 3, 4, 5, 6)

（6）字典类型转换(dict)

• 字典：dict 创建一个字典
• 注释: dict() 函数可接受可迭代对象，用键值对初始化字典。

# 示例
dictionary = dict([(1, 'one'), (2, 'two'), (3, 'three')])
print(dictionary)
# 输出：{1: 'one', 2: 'two', 3: 'three'}

（7）集合类型转换(set)

• 集合：set 创建一个集合
• 注释: set() 函数用于创建一个集合，自动去除重复元素。

# 示例
my_set = set([1, 2, 3, 3, 4, 5])
print(my_set)
# 输出：{1, 2, 3, 4, 5}

【二】数学进制转换

（1）十进制转二进制(bin)

• bin() 将给的参数转换成二进制

number = 10

# 十进制转二进制
number_bin = bin(number)
print(number_bin)  # 0b1010

（2）十进制转八进制(oct)

• oct() 将给的参数转换成八进制

number = 10

# 十进制转八进制
number_oct = oct(number)
print(number_oct)  # 0o12

（3）十进制转十六进制(hex)

• hex() 将给的参数转换成十六进制

number = 10

# 十进制转十六进制
number_hex = hex(number)
print(number_hex)  # 0xa

【三】数学运算

（1）获取绝对值(abs)

• abs() 返回绝对值

number = -1
print(abs(number)) # 1 

（2）获取商和余数(divmod)

• divmod() 返回商和余数

number_start = 9
number_end = 4
# 获取商和余数 (被除数，除数)
result = divmod(number_start, number_end)
print(result)  # (2, 1)

# number_discuss : 商
# number_remainder : 余数
number_discuss, number_remainder = divmod(number_start, number_end)
print(number_discuss)
print(number_remainder)

（3）四舍五入(round)

• round() 四舍五入

  • 给定数字的四舍五入版本，有指定的小数位数。
  • 默认情况下，小数点的数量是0。
  • 因此，如果你调用 round() 时没有第二个参数，该函数将返回最近的整数。

  print(round(4.51)) # 5
  print(round(4.50)) # 4
  print(round(4.49)) # 4
  

  # 保留一位小数
  print(round(4.051, 1)) # 4.1
  print(round(4.050, 1)) # 4.0
  print(round(4.049, 1)) # 4.0
  

  # 保留两位小数
  print(round(4.0051, 2)) # 4.01
  print(round(4.0050, 2)) # 4.0
  print(round(4.0049, 2)) # 4.0
  

（4）求和(sum)

• sum() 求和

  print(sum([1,2,3,4,5,6,7,8,9,10]))  
  
  # 求和:55
  

（5）最小值(min)

• min() 求最小值

  print(min(5,3,9,12,7,2))  
  
  # 求最小值:2
  

（6）最大值(max)

• max() 求最大值

  print(max(7,3,15,9,4,13))  
  
  # 求最大值:15
  

（7）复数转换(complex)

• 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)

【四】序列化相关相关

（1）翻转（reversed）

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

new_num_list = reversed(num_list)
print(list(new_num_list)) # [7, 6, 5, 4, 3, 8, 2, 1]

（2）切片（slice）

name = 'heart|god'
# slice(start,stop,step)
new_name = name[1:5:2]
print(new_name)  # er
new_name = name[slice(1, 5, 2)]
print(new_name)  # er

（3）计算长度（len）

print(len('heart'))  # 5

（4）排序（sorted）

num_list = [1, 2, 5, 4, 97, 9, 4, 89, 3, 4, 85, 55]
new_list = sorted(num_list, reverse=True)
print(new_list)  # [97, 89, 85, 55, 9, 5, 4, 4, 4, 3, 2, 1]

（5）枚举（enumerate）

num_list = ['heart', 'god', 3, 4, 5, 6, 7]

# 以前的用法：遍历列表的长度获取到索引
for i in range(len(num_list)):
    print(i)

print(enumerate(num_list,1)) # <enumerate object at 0x000002A725973240>

# 现在 ： 用 enumerate 直接解压出索引和元素
for index, item in enumerate(num_list,1):
    print(index)
    print(item)

【五】字符串相关

（1）format

• 格式化输出format

s = "hello world!" # 12 个长度
print(format(s, "^20"))  # 居  中
#    hello world!
print(format(s, "<20"))  # 左对齐 ljust
# hello world!
print(format(s, ">20"))  # 右对齐 rjust
#         hello world!

print(format(3, 'b'))  # 二进制:11
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(11, 'd'))  # ⼗进制:11
print(format(11, 'o'))  # 八进制:13
print(format(11, 'x'))  # 十六进制(⼩写字母):b
print(format(11, 'X'))  # 十六进制(大写字母):B
print(format(11, 'n'))  # 和d⼀样:11
print(format(11))  # 和d⼀样:11

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

（2）字符串转bytes

# encode('utf8')
print(bytes('name', encoding='utf8'))  # b'name'

（3）获取字节数组

res = bytearray('小明', encoding='utf8')
# 一个英文占一个字节，一个中文占三个字节
print(list(res))

（4）返回对象的字符串格式

word = "今天\n吃了%s顿\t饭" % 3
print(word)
# 今天
# 吃了3顿  饭

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(word))
# '今天\n吃了3顿\t饭'

（5）根据字符去找他的ASCII码 ord

print(ord('Z'))  # 90

（6）根据数字去找他的字符 chr

print(chr(97))  # a

（7）数字找ASCII码

for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

print(ascii("11"))  #'@'

【六】数据集合

num_set = {1, 2, 3}
num_set.add(9)
print(num_set)  # {1, 2, 3, 9}
num_set = {1, 2, 3, 4, 5}
frozen_set = frozenset(num_set)
print(frozen_set)  # frozenset({1, 2, 3, 4, 5})
num_set.add(9)
print(num_set)  # {1, 2, 3, 4, 5, 9}

【七】判断条件

# all : 参数是可迭代类型， 参数里面所有为真才为真
if 1 and 'hello' and []:
    print(True)
else:
    print(False)
print(all([1, 'hello', []])) 
# any : 参数是可迭代类型 ， 参数里面任一为真就为真
print(any([1, '', []]))

【八】高级函数之zip函数

# zipper : 拉链函数
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国']

# 如果一个列表中的元素相较于另一个列表中的元素少，那就会按照元素少的列表进行打包
print(list(zip(lst1, lst2)))  # [(1, '醉乡民谣'), (2, '驴得水'), (3, '放牛班的春天'), (4, '美丽人生'), (5, '辩护人'), (6, '被嫌弃的松子的一生')]

【九】高阶函数之filter函数

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


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

l1 = []
for i in lst:
    if func(i):
        l1.append(i)
print(l1)  # [1, 3, 5, 7, 9]

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

【十】高阶函数值map函数

map函数用于对可迭代对象中的每个元素应用一个函数。在你的情况下，如果要将切片应用到字符串中的每个字符，你可以使用map函数来达到这个目的。

def func(i):
    return i ** 2


num_list = [1, 2, 3, 4, 5, 6]
print(list(map(func, num_list)))  # [1, 4, 9, 16, 25, 36]
print(list(map(lambda x: x ** 2, (1, 2, 3, 4, 5, 6))))  # [1, 4, 9, 16, 25, 36]

【十一】作用域相关

name = "heart"
def func():
    a = 10
    # 当前作用域中的内容
    print(f"这是当前作用域中的内容 :>>>> {locals()}")
    # 全局作用域中的内容
    print(f"这是全局作用域中的内容 :>>>> {globals()}")
    print("我是函数func内部")
func()
# 这是当前作用域中的内容 :>>>> {'a': 10}

# 这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002C717E65540>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\2023propygo\\test.py', '__cached__': None, 'name': 'dream', 'func': <function func at 0x000002C717993EB0>}

# 我是函数func内部

【十二】迭代器和生成器

# （1）range 函数
for i in range(100):
    print(i)

# （2）迭代器的时候讲了一个 iter
num_list = [1, 2, 3]
# 创建一个迭代器
num_iter = iter(num_list)
print(num_iter)  # <list_iterator object at 0x000002F5BB5F3E80>

# （3）生成器讲了一个 next 方法
num_iter = iter([1, 2, 3])
print(num_iter)  # <list_iterator object at 0x000002F5BB5F3E50>
print(next(num_iter))  # 1

【十三】动态执行字符串代码

（1）exec

• 在Python中，可以使用exec函数来动态执行字符串中的代码。执行指令但是不返回结果。以下是一个简单的例子：

code_to_execute = """
for i in range(5):
    print(f"Current value: {i}")
"""

exec(code_to_execute)

• 在这个例子中，code_to_execute包含一个简单的for循环，然后使用exec执行这个字符串中的代码。当你运行这个程序时，它将打印从0到4的值。

（2）eval

• eval 函数是Python中的一个内置函数，用于执行以字符串形式提供的Python表达式，并返回表达式的结果。下面是一个简单的示例：

expression = "2 + 3"
result = eval(expression)
print(result) # 5

（3）compile

code1 = "for i in range(3): print(i)"
# compile并不会执行你的代码.只是编译
com = compile(code1, "", mode="exec")
# 执行编译的结果 : 可以让 eval 执行，也可以让 exec 执行
eval(com)
exec(com)
# 0
# 1
# 2

code3 = "name = input('请输入你的名字:')"
# 输入:heart

com3 = compile(code3, "", mode="single")
exec(com3)
print(name)  # heart

【十四】检查对象类型(isinstance)

• 在 Python 中，可以使用 isinstance() 函数来检查对象的类型。isinstance() 函数接受两个参数：要检查的对象和类型。
• 语法：

isinstance(object, classinfo)

• object: 要检查类型的对象。
• classinfo: 类型，可以是单个类型或一个包含多个类型的元组。

a = 123
print(isinstance(a, int))  # True
print(isinstance(a, str))  # False
print(isinstance(a, (str, int, list)))  # True
# 只要满足元组类型中的其中一个即可，答案是满足，所以为True

class Dog:
    pass

class Cat:
    pass

dog = Dog()
cat = Cat()

print(isinstance(dog, Dog))  # 输出: True
print(isinstance(dog, Cat))  # 输出: False

print(isinstance(cat, Dog))  # 输出: False
print(isinstance(cat, Cat))  # 输出: True

【十五】检查类类型(issubclass)

• 在 Python 中，可以使用 issubclass() 函数来检查一个类是否是另一个类的子类。issubclass() 函数接受两个参数：要检查的类和要比较的可能的父类。
• 语法：

issubclass(class, classinfo)

• class: 要检查是否为子类的类。
• classinfo: 父类，可以是单个类或一个包含多个类的元组。

class Animal:
    pass


class Dog(Animal):
    pass


class Cat(Animal):
    pass


print(issubclass(Dog, Animal))  # 输出: True
print(issubclass(Cat, Animal))  # 输出: True
print(issubclass(Dog, Cat))  # 输出: False