MSG

# 21. 内置函数


# 内置函数

什么是内置函数，就是Python官方提供的，可以直接拿来使用的函数

内置函数 内置函数 内置函数 内置函数 内置函数
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() poow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
complie() globals() map() reversed() import()
complex() hasattr() max() found()
delattr() hash() memoryview() set()


# 作用域相关函数


# locals()

查看当前作用域中的详细信息，如果在全局中则查看全局作用域，如果在局部中则查看局部作用域


# globals()

查看全局作用域中的详细信息，无论是在全局还是在局部都是返回全局作用域



# 迭代器相关函数


# range()

生成数据，可以生成指定从几到几范围的整数，默认会0开始


# iter()

获取迭代器，内部实际使用的是__iter__()的方法来获取迭代器


# next()

使用迭代器向下执行一次，内部实际使用了__next__()方法来返回迭代器的下一个结束



# 输入输出函数


# print()

输出函数，可以将，函数，变量，类型，自定义打印出当前界面上


# sep(seperetor)

可以让要打印的内容指定使用分隔符来分割，默认是以空格

print("你好","世界",sep="_")

执行结果：
你好_世界

# end

可以指定结尾处字符，默认是换行：end="\n"

注意：必须是在结尾使用

print("你好","世界",end="_")
print("你好","世界")

执行结果：
你好 世界_你好 世界

# input()

可以让用户输入数据，也可以赋值给变量



# 内存相关函数


# hash()

hash算法：目的是唯一性

hash算法表，是用空间换的时间，比较消耗内存

可以使用hash算法函数好运算出变量或值所在的hash算法位置

如果是运算数字，那么数字本身就是结果

so = "你好"
print(hash(so))

执行结果：
-7091664402723817543

# id()

查看内存地址



# 文件相关函数


# open()

可以通过open来读写文件



# 模块相关函数


# import()

引入模块，只能手动定义，不能通过变量等定义


# import()

引入模块，可以动态引入模块，能使用变量等定义

so = "os"
__import__(so)


# 帮助函数


# help()

可以查看全部或指定的函数信息

print(help(str))


# 查看内置函数属性


# dir()

查看指定的对象有什么内置属性

print(dir(str))


# 调用相关函数


# callable()

用于检查一个对象是否可调用的，只有函数才能被调用

  1. 返回Ture：可能会调用失败
  2. 返回Flase：绝对不会调用成功
so = 10
print(callable(so))
def so():
    print(10)
print(callable(so))

执行结果：
False
True


# 字符串类型代码的执行函数


# eval()

执行字符串类型的代码，并返回最终结果

要求：代码必须要有返回值

只能执行一些比较简单的代码运算，因为他确实要一个返回值才能执行

so = "230*400"
print(eval(so))

执行结果：
92000


# exec()

执行字符串类型的代码，不返回任何内容

可以执行比较复杂的代码

用处：可以让用户写入代码执行

so = "for i in range(11):   print(i)"
exec(so)

执行结果：
0
1
2
3
4
5
6
7
8
9
10

exec("""
def so():
    print("Python最帅")
so()
""")

执行结果：
Python最帅


# complie()

将字符串类型的代码编译，代码对象能够通过exec语句来执行 或 eval进行取值

参数：

变量 = compile(代码块变量名,"文件名",mode="模式")

1. 要执行的代码块，动态代码块赋值的变量名
2. 文件名，代码存放的文件名，当传入了第一个参数的时候，这参数就给空
3. 模式：
	1. exec：一般放一些流程语句
	2. eval：一般放一些求值表达式
	3. single：一般存放的代码有交互的时候

# 模式：exec

so = "for i in range(1,3): print(i)"
wo = compile(so,"",mode="exec")
exec(wo)

执行结果：
1
2

​ 为什么不用print()来获取结束，因为exec是没有返回值的，如果使用print()来获取，会出现None的默认返回值


# 模式：eval

so = "1000*2000+1111"
wo = compile(so,"",mode="eval")
print(eval(wo))

执行结果：
2001111

​ 使用print()来获取，因为eval默认是通过返回值来传递结果的，如果直接使用eval来获取，那结果就是为空


# 模式：single

so = "name = input('请输入您的姓名进行验证：')"
wo = compile(so,"",mode="single")
exec(wo)
print(name)

执行结果：
请输入您的姓名进行验证：人
人

为什么要使用exec来执行 ，还有为什么print()中执行的变量是在字符串代码块中的变量

  1. 因为single只是一个模式，并不是一个内置函数无法执行，需要按执行的代码来选择 exec 或 eval 来执行
  2. 执行过程，会先进行编译在赋值给变量wo，但exec来执行这个变量wo的时候，就相当赋值的代码块执行一次，这样子直接exec执行是没有结果的，因为代码在执行一行，有数据的变量就只有name这个变量，所有print()打印这个变量name


# 基础数据类型相关的


# 数字相关类型


# 数据类型相关函数


# bool()

bool类型，因 0：Flase 1：True

可以把其他类型按一定的运算转成布尔类型


# int ()

整数类型，可以把其他类型按一定的运算规转成整数类型


# fioat()

浮点数类型


# complex()

复数类型，分为实数跟虚数



# 进制转换函数


# bin()

转换成二进制

print(bin(22))

执行结果：
0b10110

# hex()

转换成十六进制

print(hex(22))

执行结果：
0x16

# oct()

转换成八进制

print(oct(22))

执行结果：
0o26


# 数学运算相关函数


# abs()

获取绝对值

print(abs(-1))
print(abs(1))

执行结果：
1
1

# divmod()

获取商和余数

结果是以元组类型来表示

print(divmod(100,20))

执行结果：
(5, 0)

# round()

将一个浮点数进入四舍五入操作

print(round(4.2))

执行结果：
4

# pow()

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

print(pow(90,12))

执行结果：
282429536481000000000000

print(pow(90,12,2))

执行结果：
0

# sum()

求和

print(sum([11,22,33,44,55]))

执行结果：
165

print(sum([11,22,33,44,55],sum([111,22,333])))

执行结果：
631

# min()

求最小值

print(min(10,20,1,20))

执行结果：
1

# max()

求最大值

print(max(10,20,1,20))

执行结果：
20


# 数据结构相关函数


# 跟序列相关函数


# 列表和元组

# list()

列表，可以把其他类型转换成列表类型

注意：如果是可迭代对象，就会迭代生成列表，如果是不可迭代的，就会拿取所有数据生成列表，放在列表的第一个值上


# tuple()

元组，可以把其他类型转换成元组类型



# 序列相关的内置函数

# reversed()

将一个序列进行翻转，返回翻转序列的迭代器，简单说就是把序列进行反向排序返回

不会修改原序列

so = "今天天气都好"
wo = ["江","小","大","凡"]
so = reversed(so)
wo = reversed(wo)
print(list(so))
print(list(wo))

执行结果：
['好', '都', '气', '天', '天', '今']
['凡', '大', '小', '江']

# slice()

切片

so = [1,2,3,4,5,6,7,8]
print(so[1:8:1])
wo = slice(1,8,1)
print(so[wo])

执行结果：
[2, 3, 4, 5, 6, 7, 8]
[2, 3, 4, 5, 6, 7, 8]

so = "今天天气真不错"
wo = slice(1,4,2)
print(so[wo])

执行结果：
天气


# 字符串序列相关函数

# str()

字符串，可以把其他类型转换成字符串类型


# format()

与具体的数据相关，用于计算各种小数，精算等


字符串的format操作


居中

so = "你好呀"
print(format(so,"^20"))

执行结果：
        你好呀

​ 居中操作，指定数量为20，如果字符数量不够以空格填充


居左

so = "你好呀"
print(format(so,"<20"))

执行结果：
你好呀

​ 居左操作，指定数量为20，如果字符数量不够以空格填充


居右

so = "你好呀"
print(format(so,">20"))

执行结果：
                 你好呀

​ 居右操作，指定数量为20，如果字符数量不够以空格填充


数值的format操作


二进制

print(format(3, 'b'))

执行结果：
11

八进制

print(format(11, 'o'))

执行结果：
13

十进制

print(format(11, 'd'))

执行结果：
11

十六进制-小写字母

print(format(11, 'x'))

执行结果：
b

十六进制-大写字母

print(format(11, 'X'))

执行结果：
B

转换成unicode字符

print(format(97, 'c'))

执行结果：
a

十进制

print(format(11, 'n'))

执行结果：
11

十进制

print(format(11))

执行结果：
11

浮点数的format操作


科学计数法-默认保留6位小数

print(format(123456789, 'e'))

执行结果：
1.234568e+08

**科学计数法-保留2位小数-小写 **

print(format(123456789, '0.2e'))

执行结果：
1.23e+08

**科学计数法-保留2位小数-大写 **

print(format(123456789, '0.2E'))

执行结果：
1.23E+08

小数点计数法-保留6位小数

print(format(1.23456789, 'f'))

执行结果：
1.234568

小数点计数法-保留2位小数

print(format(1.23456789, '0.2f'))

执行结果：
1.23

小数点计数法保留10位小数

print(format(1.23456789, '0.10f'))

执行结果：
1.2345678900

小数点计数法

print(format(1.23456789e+10000, 'F'))

执行结果：
INF

# bytes()

可以把字符串转化成bytes类型

wo = "天气真不错"
so = bytes("今天",encoding="utf-8")
wo = bytes(wo,encoding="utf-8")
print(so)
print(wo)

执行结果：
b'\xe4\xbb\x8a\xe5\xa4\xa9'
b'\xe5\xa4\xa9\xe6\xb0\x94\xe7\x9c\x9f\xe4\xb8\x8d\xe9\x94\x99'

# bytearray()

字节数组，返回一个新字节数组，数字里的元素是可变的，并且每个元素的值的范围是(0,256)

返回结果： 是编码中的位置数字

如果使用中文，那么有点故障！！！

so = bytearray("abcd",encoding="utf+8")
print(so[0])

执行结果：
97

# memoryview()

查看bytes在内存中的情况地址

so = memoryview("你好".encode("utf-8"))
print(so)

执行结果：
<memory at 0x000002ED67236048>

# ord()

返回指定字符的编码位置

print(ord("人"))

执行结果：
20154

# chr()

输入编码位置数字找出对应的字符

print(chr(20154))

执行结果：
人

# 实验：查看所有编码
for i in range(65536):
    print(chr(i),end=" ")

​ 友谊提醒，如果配置比较低的机，不建议执行


# ascii()

判断指定的字符是否在ascii码中，如果是那就返回本身字符

print(ascii("a"))
print(ascii("中"))

执行结果：
'a'
'\u4e2d'

# repr()

返回一个对象的string形式，就是原样输出

注意：repr会过滤掉转义字符，\n \t \r 等，但是不会过滤 % 百分号字符

so = "今天\n天气真不错%s对" % ",是吗，"
print(so)
print(repr(so))

执行结果：
今天
天气真不错,是吗，对
'今天\n天气真不错,是吗，对'


# 数据集合相关函数


# 字典相关函数

# dict()

字典，可以将其他类型按一定的运算规则转换成字典类型



# 集合相关函数

# set()

集合，可以将其他类型按一定的运算规则转换成集合类型


# frozenset()

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



# 其他相关函数


# len()

返回一个对象中的元素的个数


# enumerate()

获取集合或列表的索引跟值

so = [1,2,3,4,5,6,7,8,9]
for i in enumerate(so):
    print(i)
    
执行结果：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)

so = [1,2,3,4,5,6,7,8,9]
for i,n in enumerate(so):
    print(i,n)
    
执行结果：
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9

so = [1,2,3,4,5,6,7,8,9]
for i,n in enumerate(so,1):
    print(i,n)
    
执行结果：
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

以上二个实例没什么好说的，最后一个，可以在后面指定索引以什么数开始算


# all()

在可迭代对象中全部是Tuer，结果才是True

so = ["你好","a",1]
print(all(so))

执行结果：
True

# any()

在可迭代对象中有一个是Tuer，结果就是True

so = [0,"你好","a",1]
print(any(so))

执行结果：
True

# zip()

函数用于可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的开了表，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

so1 = [1,2,3,4,5]
so2 = ["技术部","业务部","财务部","人力行政部"]
so3 = [12,8,2,2]
for  i in zip(so1,so2,so3):
    print(i)
    
执行结果：
(1, '技术部', 12)
(2, '业务部', 8)
(3, '财务部', 2)
(4, '人力行政部', 2)

​ zip会对变量对象进行对比，只会显示完全匹配得上的，结果以元组表示



← 22. 内置函数进阶 →