day03.2-内置函数的使用

1. 取绝对值函数，abs()

1 res = abs(-1)
2 print(res)
3 
4 """
5 运行结果：1
6 结果分析：计算-1的绝对值
7 """

2. 判断序列中所有元素是否都为真，all()

 1 res1 = all(())
 2 res2 = all([1,2,"3"])
 3 res3 = all([0,None,"kill"])
 4 
 5 print(res1)
 6 print(res2)
 7 print(res3)
 8 
 9 """
10 运行结果：
11     True
12     True
13     False
14 结果分析：
15     当序列中所有元素都为True或该序列为空时，运算结果为True；
16     当序列中存在元素为假（0、None、False、空字符串等）时，运算结果为False。
17 """

3. 判断序列中是否存在元素为真，any()

 1 res1 = any([0,None,"kill"])
 2 res2 = any(())
 3 res3 = any([0,None,"",False])
 4 
 5 print(res1)
 6 print(res2)
 7 print(res3)
 8 
 9 """
10 运行结果：
11     True
12     False
13     False
14 结果分析：
15     当序列中存在元素为True时，运算结果为True；
16     当序列中所有元素都为假或该序列为空时，运算结果为False。
17 """

4. 十进制数据转换为二进制，bin()

1 res = bin(11)
2 print(res)
3 
4 """
5 运行结果：0b1011
6 结果分析：计算十进制数据11的二进制表达方式
7 """

5. 判断元素的布尔值，bool()

 1 print(bool(1))
 2 print(bool())
 3 print(bool(""))
 4 
 5 """
 6 运行结果：
 7     True
 8     False
 9     False
10 结果分析：计算元素对应的布尔值
11 """

6. 查看字符串的字节编码（python3默认编码方式为utf-8，ascill码不能编码含有中文元素的字符串）

1 res = bytes("你好",encoding="utf-8")
2 print(res)
3 
4 """
5 运行结果：b'\xe4\xbd\xa0\xe5\xa5\xbd'
6 结果分析：输出目标字符串的utf-8编码内容
7 """

   查看已编码字符串的解码内容（解码方式必须与编码方式相同）

1 res = bytes(b'\xe4\xbd\xa0\xe5\xa5\xbd').decode("utf-8")
2 print(res)
3 
4 """
5 运行结果：你好
6 结果分析：输出目标字符串的解码内容
7 """

7.  查看ASCII码表对应位置字符

1 res = chr(45)
2 print(res)
3 
4 """
5 运行结果：-
6 结果分析：在ASCII码表中，编码位置为45的字符是“-”
7 """

  查看字符对应的ASCII码表编码位置

1 res = ord('a')
2 print(res)
3 
4 """
5 运行结果：97
6 结果分析：在ASCII码表中，字符"a"的编码位置为97
7 """

8. 查看对象下属的内置方法

1 print(dir("a"))
2 
3 """
4 运行结果：输出字符串对应的所有内置方法
5 """

9. 获取除法运算结果，包括商与余数

1 res = divmod(10,3)
2 print(res)
3 
4 """
5 运行结果：(3, 1)
6 结果分析：以元组形式返回10/3的运算结果，元组第1个元素为运算结果的商，第2个元素为运算结果的余
7 """

10. 提取字符串中的数据结构

1 test = str({"name":"alex"})
2 res = eval(test)
3 print(res["name"])
4 
5 """
6 运行结果：alex
7 结果分析：提取出字符串test中的字典，赋值给res
8 """

    提取字符串型表达式的运算结果

1 test = "1+2*(3/3-1)-2"
2 res = eval(test)
3 print(res)
4 
5 """
6 运行结果：-1.0
7 结果分析：计算字符串表达式test的运算结果
8 """

11. 整型数字转换为浮点型

1 a = 11
2 res = float(a)
3 print(res)
4 
5 """
6 运行结果：11.0
7 结果分析：将整型数字转换为浮点型
8 """

12. 哈希运算

1 res = hash("abcd123456efg")
2 print(res)
3 
4 """
5 运行结果：7896290500402745242
6 结果分析：计算输入信息对应的哈希值
7 """

    注：可以进行哈希运算的数据类型即为不可变数据类型；

        不可进行哈希运算的数据类型为可变数据类型。

13. 查看帮助信息

1 help(str)
2 
3 """
4 结果分析：查看字符串对应帮助信息
5 """

14. 十进制转换为十六进制

1 res = hex(11)
2 print(res)
3 
4 """
5 运行结果：0xb
6 结果分析：查看输入十进制数字对应的十六进制形式
7 """

15. 十进制转换为八进制

1 res = oct(11)
2 print(res)
3 
4 """
5 运行结果：0o13
6 结果分析：查看输入十进制数字对应的八进制形式
7 """

16. 打印变量的内存地址

1 test = "you"
2 res = id(test)
3 print(res)
4 
5 """
6 运行结果：2347033856520
7 结果分析：查看变量的内存地址
8 """

 17. 判断变量是否是属于某一对象的实例

1 test = "you"
2 print(isinstance(test,str))
3 
4 """
5 运行结果：True
6 结果分析：当变量test的类型是字符串时，返回True；否则返回False
7 """

18. 查看全局变量与局部变量

 1 v1 = "stephen"
 2 v2 = "klay"
 3 def warriors():
 4     v3 = "durant"
 5     v4 = "green"
 6     print(globals())
 7     print(locals())
 8 warriors()
 9 
10 """
11 结果分析：分别输出所有全局变量和局部变量，包括变量名及其对应的值
12 """

19. 查看序列元素的最大值

1 test = [1,3,100,-1,2]
2 res = max(test)
3 print(res)
4 
5 """
6 运行结果：100
7 结果分析：输出test列表中的最大元素值
8 """

1 age_dic = {"age1":18,"age4":20,"age2":100,"age3":30}
2 res = max(age_dic)
3 print(res)
4 
5 """
6 运行结果：age4
7 结果分析：输出字典元素中最大的key值
8 """

1 age_dic = {"age1":18,"age4":20,"age2":100,"age3":30}
2 res = max(age_dic.values())
3 print(res)
4 
5 """
6 运行结果：100
7 结果分析：输出字典元素中最大的value值
8 """

1 age_dic = {"age1":18,"age4":20,"age2":100,"age3":30}
2 res = max(age_dic,key=lambda key:age_dic[key])
3 print(res)
4 
5 """
6 运行结果：age2
7 结果分析：输出字典元素中最大value值对应的key值
8 """

1 age_dic = {"age1":18,"age4":20,"age2":100,"age3":30}
2 m = zip(age_dic.values(),age_dic.keys())
3 res = max(m)
4 print(res)
5 
6 """
7 运行结果：(100, 'age2')
8 结果分析：输出字典元素中最大value值对应的key-vaule对
9 """

 1 people = [
 2           {'name':'stephen','age':31},
 3           {'name':'klay','age':29},
 4           {'name':'durant','age':32},
 5           {'name':'green','age':29}
 6 ]
 7 res = max(people,key = lambda dic:dic['age'])
 8 print(res)
 9 
10 """
11 运行结果：{'name': 'durant', 'age': 32}
12 结果分析：输出序列元素中最大'age'值对应的字典
13 """

    注：max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较。注意，不同数据类型之间不能进行比较。

        每个元素间进行比较，是从每一个元素的第一个位置依次比较。如果某一位置分出大小，则无需再比较后面的位置，以该位置的比较结果     作为元素的比较结果。

20. 查看序列元素的最小值

1 test = [1,3,100,-1,2]
2 res = min(test)
3 print(res)
4 
5 """
6 运行结果：-1
7 结果分析：输出test列表中的最小元素值
8 """

    注：同max函数。

21. 拉链函数。两个序列中元素一一对应，组合生成元组序列

 1 res = zip(('a','b','c','d'),(1,2,3,4))
 2 for item in res:
 3     print(item)
 4 
 5 """
 6 运行结果：
 7     ('a', 1)
 8     ('b', 2)
 9     ('c', 3)
10     ('d', 4)
11 结果分析：两序列中的元素进行一一对应组合
12 """

22. 幂运算

 1 v1 = pow(2,4)      #相当于v1 = 2**4
 2 v2 = pow(2,4,5)    #相当于v2 = 2**4%5
 3 print(v1)
 4 print(v2)
 5 
 6 """
 7 运行结果：
 8     16
 9     1
10 """

23. 反转互换序列中元素的位置

1 test = [1,2,3,4]
2 res = reversed(test)
3 print(list(res))
4 
5 """
6 运行结果：[4, 3, 2, 1]
7 结果分析：将原序列中元素的位置进行反转互换
8 """

24. 对浮点数进行四舍五入运算

1 res = round(3.1415)
2 print(res)
3 
4 """
5 运行结果：3
6 结果分析：完成给定浮点数的四舍五入运算
7 """

25. 切片操作

 1 test = 'hello'
 2 
 3 s1 = slice(3,5)
 4 s2 = slice(1,4,2)
 5 
 6 print(test[s1])       #相当于test[3:5]
 7 print(test[s2])       #以步长为2，取出test中索引位置位于[1,4)之间的元素
 8 
 9 print(s2.start)       #查看切片s2的初始位置
10 print(s2.stop)        #查看切片s2的终止位置
11 print(s2.step)        #查看切片s2的步长
12 
13 """
14 运行结果：
15     lo
16     el
17     1
18     4
19     2
20 """

26. 对序列中元素进行排序（序列元素的数据类型必须相同，且序列为可迭代对象）

1 test = [1,3,100,-1,2]
2 res = sorted(test)
3 print(res)
4 
5 """
6 运行结果：[-1, 1, 2, 3, 100]
7 结果分析：将原列表中的所有元素按照递增的顺序重新排列
8 """

27. 序列中元素求和

1 test = [1,3,100,-1,2]
2 res = sum(test)
3 print(res)
4 
5 """
6 运行结果：105
7 结果分析：求取原列表中所有元素之和
8 """

28. 查看元素的数据类型

1 test = [1,3,100,-1,2]
2 print(type(test))
3 
4 """
5 运行结果：<class 'list'>
6 结果分析：输入数据类型为列表
7 """

 

转载于:https://www.cnblogs.com/zizaijiapu/p/10492817.html