Python内置函数

Python内置函数

一、内置函数

什么是内置函数? 就是python给你提供的。 拿来直接⽤的函数， 比如print， input等等。

1. 作用域相关

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

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

2. 迭代器相关

   range() 获取数据

   next() 迭代器向下执行一次，实际上调用了内部的__next__()方法获取迭代器中的下一个数据

   iter() 获取迭代器，实际上是调用了内部的__iter__()方法获取迭代器

3. 字符串类型代码的执行

   eval() 执行字符串类型的代码，并返回结果

   print(eval("2 + 2"))	# 4
   
   def func():
   	print("哈哈")
   eval("func()")		# 哈哈
   

   exec() 执行字符串类型的代码

   exec('''
   for i in range(10):
       print(i)
   ''')
   # 1 2 3 4 5 6 7 8 9
   
   exec('''
   def func():
       print("你真好看")
   func()
   ''')
   # 你真好看
   

   comlile() 将字符串类型的代码编译， 代码对象能够通过exec语句来执⾏或者eval()进⾏求值

   '''
    参数说明:
    1. resource 要执⾏的代码, 动态代码⽚段
    2. ⽂件名, 代码存放的⽂件名, 当传⼊了第⼀个参数的时候, 这个参数给空就可以了
    3. 模式, 取值有3个,
    1. exec: ⼀般放⼀些流程语句的时候
    2. eval: resource只存放⼀个求值表达式.
    3. single: resource存放的代码有交互的时候. mode应为single
   '''
   
   code1 = "for i in range(4): print(i)"
   ret = compile(code1, "", mode="exec")
   exec(ret)
   # 0 1 2 3 
   
   code2 = "1 + 2+ 3"
   ret = compile(code2, "", mode="eval")
   print(eval(ret))
   # 6
   
   code3 = "name = input('请输入你的姓名：')"		# dogfa
   ret = compile(code3, "", mode="single")
   exec(ret)
   print(name)		# dogfa
   

4. 输入和输出

   print() 打印输出

   input() 获取用户输入的内容

5. 内存相关

   hash() 获取到可哈希对象的哈希值

   id() 获取对象的内存地址

6. 文件操作相关

   open() 用于打开一个文件，获取一个文件句柄

7. 模块相关

   __import__() 用于动态加载类和函数

8. 帮助

   help() 用于查看函数或类的用途的详细说明

9. 调用相关

   callable() 检查一个对象是否可调用，如果返回True，对象有可能调用失败，但是返回False，那么则一定调用不成功。

10. 查看内置属性

    __dir__() 查看对象的内置属性和方法

11. 数字相关

    bool() 将给定的数据转换成bool值

    int() 将给定的数据转换成int类型的值

    float() 将给定的数据类型转换成float类型的值，即转换成小数类型

12. 进制转换

    bin() 将给定的值转换成二进制类型数据

    oct() 将给定的值转换成八进制类型数据

    hex() 将给定的值转换成十六进制类型数据

13. 数学运算

    abs() 取绝对值

    divmode() 返回商和余数，得到的值是一个元祖，可以解构接收

    round() 四舍五入

    pow(a, b) 求a的b次幂，如果有第三个参数，则取幂之后对第三个值取余并返回

    max() 求最大值

    min() 求最小值

    sum() 求和

14. 列表和元祖

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

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

    reversed() 将一个序列反转，返回反转后的序列的迭代器对象

    slice() 列表的切片

15. 字符串相关

    str() 将数据转换成字符串类型

    format() 与具体数据相关，⽤于计算各种⼩数， 精度等

    # 浮点数保存两位小数
    print(format(1.23456, ".2f"))
    # 1.23
    

    bytes() 将数据转换成bytes类型

    content = "哈哈"
    ret = content.encode("utf-8")
    print(ret)
    # b'\xe5\x93\x88\xe5\x93\x88'
    
    content = "哈哈"
    bs = bytes(content, encoding = "utf-8")
    print(bs)
    # b'\xe5\x93\x88\xe5\x93\x88'
    

    repr() 返回对象的string形式

    # repr 就是原封不动的输出, 引号和转义字符都不起作⽤，但是对%s格式化输出不起作用
    print(repr("我是\t\n啊哈哈“嘿嘿”"))
    # 我是\t\n啊哈哈“嘿嘿”
    
    print(repr("我是一个%s" % "大帅比"))
    # 我是一个大帅比
    
    

16. 数据集合

    dict() 创建一个字典

    set() 创建一个集合

    frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作

17. 其它相关

    len() 获取一个对象中元素的个数

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

    lst = ["dogfa", "djb", "oldniu"]
    for index, data in enumerate(lst, 1):
    	print(index, data)
    	
    # 1 dogfa
    # 2 djb
    # 3 oldniu
    

    all() 可迭代对象中的元素全部为True则返回True

    any() 可迭代对象中的一个元素为True则返回True

    lst = [1, "xixi", True]
    print(all(lst))		# True
    print(any(lst))		# True
    
    lst = [1, "xixi", True, False]
    print(all(lst))		# False
    print(any(lst))		# True
    

    zip() ⽤于将可迭代的对象作为参数， 将对象中对应的元素打包成⼀个个元组，然后返回由这些元组组成的迭代器对象。 如果各个可迭代对象中的元素个数不⼀致， 则返回列表⻓度与最短的对象相同。

    lst1 = [1, "dogfa", True]
    lst2 = [2, "dog", 3, [1, 2, 3]]
    lst3 = [[4, 5, 6], False, "嘻嘻", "嘿嘿", 2]
    print(zip(lst1, lst2, lst3))
    # (1, 2, [4, 5, 6])
    # ('dogfa', 'dog', False)
    # (True, 3, '嘻嘻')
    

    ord() 输入字符找带字符编码的位置
    chr() 输入位置数字找出对应的字符
    ascii() 是ascii码中的返回该值 不是就返回\u...

    # 找到对应字符的编码位置
    print(ord('a'))
    print(ord('中'))
    # 找到对应编码位置的字符
    print(chr(97))
    print(chr(20013))
    # 在ascii中就返回这个值. 如果不在就返回\u...
    print(ascii('a'))
    print(ascii('好'))
    

二、匿名函数

lambda匿名函数：为了解决一些简单的需求而设计的一句话函数

lambda匿名函数语法：函数名 = lambda 参数: 返回值

# 计算n的n次方
def func(n):
	return pow(n, n)
print(func(4))
# 256

f = lambda n:pow(n, n)
print(f(4))
# 256

注意：

1. 函数的参数可以有多个， 多个参数之间⽤逗号隔开
2. 匿名函数不管多复杂。 只能写⼀⾏， 且逻辑结束后直接返回数据
3. 返回值和正常的函数⼀样， 可以是任意数据类型

匿名函数并不是说⼀定没有名字。这⾥前⾯的变量就是⼀个函数名， 说他是匿名原因是我们通过__name__查看的时候是没有名字的。统⼀都叫lambda， 在调⽤的时候没有什么特别之处，像正常的函数调⽤即可。

三、sorted()，filter()，map()

1. sorted()：排序函数

   语法：sorted(Iterable, key=None, reverse = False)

   Iterable：可迭代对象

   key：排序规则(排序函数)，在sorted内部会将可迭代对象中的每⼀个元素传递给这个函数的参数， 根据函数运算的结果进⾏排序。

   reverse：是否翻转，排序之后翻转可以理解额为是否倒序。True倒序，False正序。

   # 根据字符串长度对列表进行排序
   lst = ["哈哈", "我很长哦", "我是最长的谁不服来比试比试最后的结果排名", "我赵日天不服", "我叶良成也不服"]
   
   def compare_length(data):
       return len(data)
   
   ret = sorted(lst, key=compare_length,reverse=True)
   print(ret)
   # ['我是最长的谁不服来比试比试最后的结果排名', '我叶良成也不服', '我赵日天不服', '我很长哦', '哈哈']
   
   
   # 接下来结合匿名函数实现
   lst = ["哈哈", "我很长哦", "我是最长的谁不服来比试比试最后的结果排名", "我赵日天不服", "我叶良成也不服"]
   
   ret = sorted(lst, key=lambda data:len(data),reverse=True)
   print(ret)
   # ['我是最长的谁不服来比试比试最后的结果排名', '我叶良成也不服', '我赵日天不服', '我很长哦', '哈哈']
   
   # 以上的结果是一样的，在某些情况下我们可以使用匿名函数来定义key的排序规则
   
   
   # 根据年龄对列表中的字典进行排序
   lst = [
       {"name":"dogfa", "age":18},
       {"name":"djb", "age":11},
       {"name":"oldniu", "age":23},
       {"name":"cdj", "age":38},
   ]
   ret = sorted(lst, key=lambda dic:dic["age"])
   print(ret)
   # [{'name': 'djb', 'age': 11}, {'name': 'dogfa', 'age': 18}, {'name': 'oldniu', 'age': 23}, {'name': 'cdj', 'age': 38}]
   

补充:

permission_menu_dict = {
 1: {
     'menu_title': '信息管理',
     'menu_icon': 'fa fa-address-book-o',
     'weight': 1,
     'children': [{
         'menu_id': 1,
         'permission_title': '客户列表',
         'permission_url': '/customer/list/'
     }]
 },
 2: {
     'menu_title': '财务管理',
     'menu_icon': 'fa fa-money',
     'weight': 2,
     'children': [{
         'menu_id': 2,
         'permission_title': '缴费记录',
         'permission_url': '/payment/list/'
     }]
 }
}

for i in sorted(permission_menu_dict, key=lambda key:permission_menu_dict[key]['weight'], reverse=True):
 print(permission_menu_dict[i])

# 字典默认将key传入, 返回值也是key

2. filter()：筛选函数，返回的值是一个迭代器

   语法：filter(function, Iterable)

   function: ⽤来筛选的函数，在filter中会⾃动的把iterable中的元素传递给function，然后根据function返回的True或者False来判断是否保留此项数据

   Iterable: 可迭代对象

   # 筛选lst中的奇数
   lst = [i for i in range(100)]
   print(list(filter(lambda data:data % 2 == 1, lst)))
   
   # 筛选年龄大于20的数据
   lst = [
   	{"name":"dogfa", "age":18},
       {"name":"djb", "age":11},
       {"name":"oldniu", "age":23},
       {"name":"cdj", "age":38},
   ]
   print(list(filter(lambda dic:dic["age"] > 20, lst)))
   # [{'name': 'oldniu', 'age': 23}, {'name': 'cdj', 'age': 38}]
   

3. map()：映射函数，返回的值是一个迭代器

   语法：map(function, Iterable)

   可以对可迭代对象中的每⼀个元素进⾏映射，分别取执⾏function

   # 对列表中的每个元素取平方，重新返回列表
   lst = [i for i in range(6)]
   print(list(map(lambda data:pow(data, 2), lst)))
   # [0, 1, 4, 9, 16, 25]
   
   # 计算两个列表相同位置的数据的和
   lst = [1, 2, 3, 4, 5]
   lst2 = [10, 11, 12, 13, 14, 15, 16, 17, 18]
   print(list(map(lambda data1, data2: data1 + data2, lst, lst2)))
   # [11, 13, 15, 17, 19]
   

四、递归

递归：在函数中调用函数本身，就是递归。

# 递归
def func():
	print("666")
	func()
	
func()

# 在Python中递归的最深度为998
def func(depth):
	print(depth)
	func(depth+1)
	
func(1)
# RecursionError: maximum recursion depth exceeded while calling a Python object
# 到达递归的最大层时会报错

递归的应用：可以使用递归来遍历各种树形结构，比如文件目录。

# 使用递归遍历文件夹中的所有文件
import os

def read_file(file_path, depth):
    files = os.listdir(file_path)  # 获取当前文件夹中的所有文件和子文件夹
    for file in files:
        new_file_path = os.path.join(file_path, file)  # 获取文件夹中的文件和杂文件夹的路径
        if os.path.isdir(new_file_path):  # 如果子文件是文件夹
            print("\t" * depth, file)
            read_file(new_file_path, depth + 1)
        else:
            print("\t" * depth, file)

print(read_file("C:\\Users\Administrator\Desktop", 0))

# 还可以使用递归进行二分查找
lst = [1, 45, 98, 100, 125, 135, 146, 198, 199, 500, 988, 1000, 1546, 2000]

def binary_search(left, right, n):
    middle = (left + right) // 2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle

    return binary_search(left, right, n)

index = binary_search(0, len(lst) - 1, 988)
print("查找的数据:{0},索引:{1}".format(lst[index], index))
# 查找的数据:988,索引:10