常用的内置函数

常用的内置函数

【一】什么是内置函数

• 和数字相关
  • 数据类型
  • 进制转换
  • 数学运算
• 和数据结构相关
  • 序列
  • 数据集合
  • 相关内置函数
• 和作用域相关
• 和迭代器生成器相关
• 字符串类型代码的执行
• 输入输出
• 内存相关
• 文件操作相关
• 模块相关
• 帮 助
• 调用相关
• 查看内置属性

【二】数据类型转换

数字类型转换

• 整数

  # int(x) : x 转换为整数
  
  res = '1'
  print(res, type(res))
  # 1 <class 'str'>
  
  # 将可以转换为整数的类型转换为整数
  res_int = int(res)
  print(res_int, type(res_int))
  # 1 <class 'int'>
  

• 浮点数

  # float(x) : x 转换为浮点数
  
  start = 1
  print(start, type(start))
  # 1 <class 'int'>
  
  start_float = float(start)
  print(start_float, type(start_float))
  # 1.0 <class 'float'>
  

• 字符串布尔类型

  print(str(123)+'456')  #123456
  type:<class 'str'>
  

• 布尔类型（bool）

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

• 列表类型转换(list)

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

• 元祖类型转换(tuple)

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

• 字典类型转换(dict)

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

• 元祖类型转换(tuple)

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

• 集合类型转换(set)

  • 集合：set 创建一个集合

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

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

【三】数学进制转换

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

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

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

【四】数学运算

• abs() 返回绝对值

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

• 四舍五入(round)

  # 我们可以传递一个简单的负数浮点数。
  # 注意我们只向函数提供一个参数，我们省略了可选的第二个参数。
  # 我们可以看到，对 4.51 的值为 5
  print(round(4.51))
  # 我们可以看到，对 4.50 的值为 4
  print(round(4.50))
  # 我们可以看到，对 4.49 的值为 4
  print(round(4.49))
  

• a的b次幂(pow)

  '''
  参数介绍：
      x — 数值表达式(整数或者浮点数)；
      y — 数值表达式(整数或者浮点数)；
      z — 数值表达式(整数或者浮点数)，默认不设置z值；
  
  返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
  '''
  pow(x, y[, z])
  print(pow(2,5)) # 等价 2*2*2*2*2 = 32
  print(pow(2,3)) # 等价 2*2*2 = 8
  print(pow(2,3,5)) # 等价 2*2*2%5 = 8 % 5 = 3
  print(2*2*2%5)  # 等价 pow(2,3,5) = 3
  
  

• sum() 求和

  print(sum([1,2,3,4,5,6,7,8,9,10]))  
  

• min() 求最小值

  print(min(5,3,9,12,7,2))  
  # 2
  

• max() 求最大值

  print(max(5,3,9,12,7,2))  
  # 12
  

• 复数转换(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)
  
  

数据结构相关

• reversed() 将一个序列翻转, 返回翻转序列的迭代器

  data='你在干嘛'
  data=reversed(data)
  print(list(data))
  #['嘛', '干', '在', '你']
  

• slice()切片 列表的切片

  lst = [1, 2, 3, 4, 5, 6, 7]
  
  print(lst[1:3:1])  
  # [2,3]
  s = slice(1, 3, 1)  
  #  切片用的
  print(lst[s])  
  # [2,3]
  

• len()计算长度

• sorted() 排序

  lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]
  # 内置函数. 返回给你一个新列表  新列表是被排序的
  ll = sorted(lst)
  print(ll)
  # [1, 5, 5, 6, 7, 9, 12, 13, 18]
  # 倒序
  l2 = sorted(lst, reverse=True)
  print(l2)
  # [18, 13, 12, 9, 7, 6, 5, 5, 1]
  

• 枚举(enumerate) enumerate() 获取集合的枚举对象

  list=['hamburger','milk','egg']
  for i,j in enumerate(list,1):
      print(f'{i}:{j}')
  1:hamburger
  2:milk
  3:egg
  

• 格式化输出（format）

  • format() 与具体数据相关, 用于计算各种小数, 精算等.

    s = "hello world!"
    print(format(s, "^20"))  # 居  中
    #     hello world!
    print(format(s, "<20"))  # 左对齐
    # hello world!
    print(format(s, ">20"))  # 右对齐
    #         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
    

高阶函数

【1】map函数

• 在Python中使用map()函数对可迭代对象（如列表、元组、 ** 等）的每个元素应用一个函数，并将结果作为一个新的可迭代对象返回。 map()函数的语法如下：

map(function, iterable)

• 其中，function是要应用于每个元素的函数，iterable是要处理的可迭代对象。

• 使用map()函数将一个列表中的每个元素平方并返回一个新的列表

numbers = [1, 2, 3, 4, 5]

def square(x):
    return x ** 2
for i in numbers:
    square(i)
# 
1
4
9
16
25   
squared_numbers = list(map(square, numbers))
print(squared_numbers)
#[1, 4, 9, 16, 25]

输出:

[1, 4, 9, 16, 25]

在上述示例中，square()函数接受一个参数，并返回该参数的平方值。map(square, numbers)将numbers列表中的每个元素都传递给square()函数进行处理，并将结果作为一个新的可迭代对象返回。最后，通过list()函数将该可迭代对象转换为列表并打印出来。

请注意，map()函数返回的是一个迭代器，如果想要得到列表作为结果，需要通过list()函数将其转换成列表。

【2】打包(zip)

• zip()函数

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

  list1=[1,2,3,4,5]
  list2=['a','b','c','d','e']
  list3=['中国','美国', '巴西', '日本']
  print(zip(list1, list2, list3))
  #[(1, 'a', '中国'), (2, 'b', '美国'), (3, 'c', '巴西'), (4, 'd', '日本')]
  for el in zip(list1, list2, list3):
      print(el)
     
  #(1, 'a', '中国')
  #(2, 'b', '美国')
  #(3, 'c', '巴西')
  #(4, 'd', '日本')
      
  

【3】 filter 函数

• flter(过滤的表达式，可迭代对象)

  def fun(i):
      return i % 2 ==1
  lst=[1,2,3,4,5,6,7]
  方法一：
  list=[]
  for i in lst:
      if fun(i):
          list.append(i)
  print(list)
  #[1, 3, 5, 7]
  方法二：
  res=filter(fun,lst)
  print(list(res))
  ##[1, 3, 5, 7]
  

作用域相关

• globals() : 查看全局的名称空间
• locals() : 查看局部的名称空间

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

迭代器和生成器

• 迭代器

  num_list = [1,2,3]
  # 创建一个迭代器
  num_iter = iter(num_list)
  print(num_iter) # <list_iterator object at 0x000002ADDF8D9270>
  

• 生成器的next方法

  print(next(num_iter))
  

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

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

• eval()方

  1.求解简单的数学表达式：

expression = "2 + 3 * 4"
result = eval(expression)
print(result)  # 输出：14

​ 2.计算数值的平方根：

import math

expression = "math.sqrt(25)"
result = eval(expression)
print(result)  # 输出：5.0

​ 3.使用变量进行计算：

x = 10
y = 5
expression = "x + y"
result = eval(expression)
print(result)  # 输出：15

• 输入和输出

print("hello", "world", sep="*", end="@") 
#sep:打印出的内容用什么连接
#end:以什么为结尾
#hello*world@

哈希

# 哈希值计算
s = 'name'
print(hash(s))  # -1259320317030181278Y
# {1:2,4:5,3:4}

# 哈希算法又叫摘要算法
# 唯一

文件和帮助和导入

# 打开文件语法
# f = open(file=...,mode=...,encoding=...)

# 导入模块语法
# exec('import os')
# os = __import__('os')
# print(os.listdir())

# 帮助函数
# import os
# print(help(os))

调度和查看属性

# 变量名是否可被调用 ： 能 变量名() 就能被调用
a = 10
# 变量a不能被调用

print(callable(a))


# False

def f():
    print("hello")


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


# 查看内置属性或方法 dir

print(dir(list))

调试器(breakpoint)

• breakpoint()函数 - 3.7+

【1】作用

• Python 3.7添加了breakpoint()，此函数将您放入调用站点的调试器中。
• 具体来说，它调用sys.breakpointhook()，直接传递args和kws。
• 默认情况下，sys.breakpointhook()调用pdb.set_trace()，不需要参数。
  • 在这种情况下，它纯粹是一个方便的函数，因此您不必显式地导入pdb或键入足够多的代码来进入调试器。
  • 但是，sys.breakpointhook()可以设置为其他函数，breakpoint()将自动调用该函数，允许您进入所选的调试器。

【2】语法

• breakpoint(*args, **kws)
• 参数介绍：
  • *args, **kws---不定长参数
• 返回值：
  • 下面例子展示 breakpoint()函数使用方法

【3】示例

# 以前
foo()
import pdb; pdb.set_trace()
bar()

# 现在
foo()
breakpoint()
bar()

• *args, **kws --- 不定长参数区别

def f(arg,*args,**kwargs):
    print(arg,args,kwargs)
f(1,2,4,5,a=1,b=2)

# 1 (2, 4, 5) {'a': 1, 'b': 2}

判断内存空间地址(id)

【1】作用

• 在Python中，id()函数用于返回一个对象的唯一标识符。
• 这个标识符是一个整数，代表了该对象在内存中的地址。
• 换句话说，每个对象都有一个唯一的标识符，即使它们的值相同也是如此。

【2】语法

id(object)

# 其中，object是要返回标识符的对象。

【3】示例

a = 5
b = 5
print("a的标识符为：", id(a))
print("b的标识符为：", id(b))

# a的标识符为： 140707288191088
# b的标识符为： 140707288191088

• 可以看到，即使a和b的值相同，它们的标识符也相同，这是因为它们指向的是同一个内存地址。