AI学习 Day06 内置函数

本文章最初发布在 XJHui’s Blog，未经允许，任何人禁止转载！

注意：最新修改版本已发布在 这里，点击前往查看！

基础

1. 是什么？

   为便于我们使用，python自带的一些函数（print …）

2. 有什么？

   

   具体内容的可以点击 这里 查看！

数学运算

1. 绝对值函数（abs）

   print(abs(-10), abs(10))
   

   运行结果：

   

2. 取近似值（round）

   • 无位数限定：

     print(round(3.5))
     

     运行结果：

     

     注意：无位数限定时默认取整。

   • 位数限定：

     print(round(3.555, 2))
     

     运行结果：

     

3. 求次幂（pow）

   print(pow(2, 3)) #方法一
   print(2 ** 3) #放法二
   

   运行结果：

   

4. 求最大、小值（max、min）

   print(max([10, 2, 3, 5, 2, 4, 5])) #从单个列表中选出最大值
   print(max(10, 2, 3, 5, 2, 4, 5)) #从多个数中选出最大值
   

   运行结果：

   

   如果是多个列表怎么比较？

   print(max([10, 2, 3, 5, 2, 4, 5], [10, 3, 3, 5, 2, 4, 5])) #min同理
   

   运行结果：

   

   说明：多个列表如何比较？

   

5. 求和（sum）

   • 多值、可迭代对象：

     print(sum(range(4)))
     

     运行结果：

     

   • 设置参数：

     print(sum(range(4), 4)) #先求和再与参数相加
     

     运行结果：

     

6. eval函数

   不做讲解，点击 这里 查看详细说明

类型转换

1. int()、float()、str()

   strA = '10'  # 定义字符型的变量
   print(type(strA))  # 打印变量类型
   intA = int(strA)  # 使用类型转换函数 int()
   print(intA, type(intA))  # 输出转换后的变量值与类型
   

   运行结果：

   

   注意：其余类型转换函数使用方法相似，不再赘述。

2. bin()、hex()

   分别获取对应值的二、十六进制

   print(bin(10)) # 二进制为例，十六进制同理
   

   运行结果：

   

   验证正确性：

   

   注意：十六进制以0x开头

3. list()、tuple()

   元组与列表互相转换

   tupleA = (1, 2, 3)  # 定义一个元组
   print(tupleA, type(tupleA))  # 打印元组及其类型
   listA = list(tupleA)  # 使用list()将元组转换为列表类型
   print(listA, type(listA))  # 打印转换后的变量值和类型
   

   运行结果：

   

   注意：tuple()的使用方法类似，不在赘述。

4. dict()

   生成字典（有特定的生成规则）

   • 创建一个空字典

     dictA = dict()
     print(type(dictA))
     dictA['name'] = '小明'
     dictA['age'] = 18
     print(dictA)
     

     运行结果：

     

   • 创建一个带有键值对的字典：

     dictA = dict(name='小明', age=18)
     print(dictA, type(dictA))
     

     运行结果：

     

5. bytes()

   转换为字节数组

   print(bytes('你好呀！', encoding='utf-8'))
   

   运行结果：

   

序列操作

对字符串、元组、列表的操作

1. all()

   当元组、列表中仅包含True值时返回True，否则返回False（包含0、空、False），类似逻辑运算符中的 and

   print(all([]), all(()))  # 判断空列表、元组
   print(all([1, 2, 3, True]), all((1, 2, 3, True)))  # 不包含0、空、False
   print(all([1, 2, 0]), all([1, 2, 3, False]))  # 列表中包含0、空、False
   print(all((1, 2, 0)), all((1, 2, 3, False)))  # 元组中包含0、空、False
   

   运行结果：

   

   注意：当元组、列表为空时使用all()返回值均为True。

2. any()

   当元组、列表中包含任一True值时返回True，否则返回False（包含0、空、False），类似逻辑运算符中的 or

   具体内容与all()的使用类似，不在赘述

3. sorted()

   对所有可迭代对象排序

   • 区别sort()：

     • sort仅适用与列表，sorted使用与所有可迭代对象
     • sort是在原列表基础上进行的排序，sorted会新建一个
     • sorted无论排序哪种类型的变量，返回值均为list

   • 使用：

     • sort()：

       listA = [4, 2, 1, 14, 324, 3]
       listA.sort()  # 默认升序排列，使用reverse=True可实现降序排列
       print(listA)
       

       运行结果：

       

       注意：可以看出sort()是在原列表的基础上实现的

     • sorted()：

       listA = [4, 2, 1, 14, 324, 3]
       listB = sorted(listA, reverse=True)  # reverse默认等于False（升序），使用reverse=True可实现降序排列
       print(listB)
       

       运行结果：

       

       注意：可以看出sorted()是在新列表上实现的，元组类型的数据使用方法类似，不在赘述

4. reverse()

   对列表中的数据进行反转操作

   listA = [4, 2, 1, 14, 324, 3]
   listA.reverse()
   print(listA)
   

   运行结果：

   

5. range()

   创建一个整数列表，一般用在for循环中

   参数：

   • start：起点值
   • stop：终点值（不包含）
   • step：步长，默认为1

   案例：

   for i in range(1, 10, 2): #range(start,stop,step)
       print(i, end=' ')
   

   运行结果：

   

6. zip()

   压缩多个可迭代对象

   listA = [1, 2, 3]  # 定义两初始数组
   listB = ['小明', '男', 19]
   zipA = zip(listA, listB)  # 使用zip压缩，列表个数任意
   print(zipA)  # 直接打印压缩后生成的可迭代对象
   for i in zipA:  # 使用for循环输出可迭代对象的值
       print(i, end=' ')
   

   运行结果：

   

   注意：

   • 原始列表压缩后生成一个可迭代对象

   • 该对象包含多个元组，每个元组均由原始列表中的值构造而成

   • 构造方法为如下图：

     

   • 假设两个列表中元素数目分别为num1、num2，则压缩后的元组数目为min(num1,num2)，多个列表时类似

   案例：创建函数实现书本信息（编号、书名、位置）的录入

   def addInfo():
       '''
       录入书本信息（id、name、pos）
       :return:
       '''
       id = input('id：')  # 书本编号
       name = input('name：')  # 书本名称
       pos = input('pos：')  # 书本存放位置
   
       idList = id.split(' ')  # 通过split函数将数据拆分后存入列表便于zip压缩
       nameList = name.split(' ')
       posList = pos.split(' ')
   
       bookZip = zip(idList, nameList, posList)  # 多个列表数据纵向合并用到zip
   
       bookList = []  # 存放书本信息
   
       for bookItem in bookZip:  # 遍历压缩后的数据
           bookDict = {'id': bookItem[0], 'name': bookItem[1], 'pos': bookItem[2]}  # 初始化字典并将获取的信息存入（初始化字典时key要使用引号）
           bookList.append(bookDict)  # 每个字典都是一本书的信息，将这些信息全部存入bookList中
       for i in bookList:  # 打印所有书本信息
           print(i)
           
   
   addInfo()
   

   运行结果：

   

   知识点：

   • 列表数据纵向合并用到zip
   • 字典创建时可赋值，赋值时key要加引号
   • 列表嵌套字典，展示数据更清晰

7. enumerate()

   添加下标（列表、字典等），可自定义起始值

   listA = ['a', 'b', 'c']
   print(list(enumerate(listA, 6)))
   

   运行结果：

   

Set集合

概念

1. 是什么？无序且不重复的元素集合
2. 特点：
   • 无序、互异
   • 不支持切片、索引
   • 类似于字典但仅有key无value

使用

1. 创建集合

   • 方法1：

     setA = {1, 2, 3}
     print(type(setA))
     

     运行结果：

     

   • 方法2：

     listA = [1, 2, 3]
     setA = set(listA)
     print(setA, type(setA))
     

     运行结果：

     

     注意：可以通过对list进行强制转换来创建一个集合。

2. 添加操作：

   setA = {1, 2, 3}
   setA.add('hello')
   print(setA)
   

   运行结果：

   

3. 清空操作：

   setA = {1, 2, 3}
   setA.clear()
   print(setA)
   

   运行结果：

   

4. 差、并、交集

   概念：

   

   案例：

   setA = {1, 2, 3}
   setB = {2, 3, 4}
   print(setA - setB, setA.difference(setB))  # 差集
   print(setA & setB, setA.intersection(setB))  # 交集
   print(setA | setB, setA.union(setB))  # 并集
   

   运行结果：

   

5. 移除指定元素：

   setA = {4, 2, 3, 1}
   setA.discard(4)
   print(setA)
   

   运行结果：

   

6. 合并集合：

   setA = {4, 2, 3, 1}
   setB = {1, 6}
   setA.update(setB)
   print(setA)
   

   运行结果：

   

   注意：集合合并会自动去重

思路补充

做题时遇到的好的想法和思路

1. 函数很方便

2. 函数返回元组或其它类型的数据

   return (sum,1+sum) #再根据下标使用
   

3. 列表移除指定元素：.remove()

4. 判断是否在列表中 in / not in

---

不足之处，欢迎留言，会及时回复，及时更正！

创作不易，感谢支持！