python学习第12天----内置函数

1.内置函数

         python解释器提供的，直接可以使用的函数，如print,input等

1）作业域相关

①globals() 以字典的类型返回全部局部变量

②locals()   以字典的类型返回当前位置的全部局部变量

2）迭代器/生成器相关

①range 

②next()  内部执行的是__next__()

③iter()    获取一个迭代器，就相当于__iter__()

lst = ["九尾妖狐","阿狸","灵魂突袭"]
it = iter(lst)
print(it.__next__())
print(next(it))
输出：
九尾妖狐
阿狸

3)输入输出

①input 输入

②print 输出

def print(self, *args, sep=' ', end='
', file=None): # known special case of print

#输出是添加分隔符，默认为空格

print("九尾妖狐","阿狸","灵魂突袭",sep = "_")     #seperator  
输出：
九尾妖狐_阿狸_灵魂突袭

#结束时以什么结束，默认为回车

print("九尾妖狐","阿狸","灵魂突袭",sep = "_",end = "LOL")
输出：
九尾妖狐_阿狸_灵魂突袭LOL

4）内存相关

①hash 哈希，通过hash算法对“对象”算出一个唯一编号；当下次需要对象时，直接通过hash值对于的位置获取

print(hash(101))      #数字本身是唯一的
print(hash("阿狸"))
输出：
101
7129766306689511966

注：字典的查找效率非常高的原因就是在于字典的可hash的，hash是用空间换取时间，比较耗费内存；列表是不可hash的，元组是可hash的

②id 查看对象的内存值

5）文件操作相关

①open

6）模块相关

①__import__()  动态的导入一个模块

name = input("请输入你要导入的模块：")
__import__(name)  #可以动态导入模块,name为模块名

7）帮助

①help

print(help(str))

8)调用相关

①callable  判断一个对象，是否是可调用的

#变量是不可被调用的

a = 10
print(callable(a))
输出：
False

#函数是可以被调用的

def func():
    print("Hello World")

print(callable(func))
输出：
True

9)查看内置属性

①dir

print(dir(str))

10）字符串类型代码的执行

①eval  执行字符串类型的代码，并返回最终结果(可动态的执行一些代码)；代码必须有返回值，如果没有返回值，一般不用eval

s = input("请输入a+b:")
print(eval(s))
输入输出:
请输入a+b:10+5+8+20
43

#可通过eval进行一些简单的计算，复杂的运算无法计算

s = "100/2"
print(eval(s))
输出：
50.0

#eval无法进行复杂运算（如下代码报错）

s = "for i in range(10): print(i)"
print(eval(s))

②exec 执行字符串类型代码；和eval的区别是，exec没有返回值；但是可以进行复杂运算（让用户编码时，可用到；用于执行用户的代码）

#exec没有返回值

s = "100/2"
a = exec(s)
print(a)
输出：
None

#exec可进行复杂运算

s = "for i in range(10): print(i)"
print(exec(s))
输出：
0
1
。
9

#还可通过exec去执行一个函数

exec("""
def func():
    print("阿狸")
func()
""")
输出：
阿狸

③complie 将一个字符串编译为字节代码（程序最终实际运行的就是字节码），然后通过exec语句来执行或者eval()进行使用

#comlpe参数说明

参数说明: 
1. resource 要执⾏的代码, 动态代码⽚段 
2. ⽂件名, 代码存放的⽂件名, 当传⼊了第⼀个参数的时候, 这个参数给空就可以了 
3. 模式, 取值有3个, 
①exec: ⼀般放⼀些流程语句的时候 
②eval: resource只存放⼀个求值表达式. 
③single: resource存放的代码有交互的时候. mode应为single 

　#不需要返回值的代码，参数为exec　

code1 = "for i in range(10): print(i)"
c1 = compile(code1, "", mode="exec")  #compile并不会执行代码，只是编译代码
exec(c1)      #编译完成后，通过exec执行代码
输出：
0
1
.
9

注：当代码不想被别人看到时，可以先通过compile编译出来；编译完成之后的程序执行非常块

#需要返回值的代码，返回值为eval

code2 = "1+2+3"
c2 = compile(code2, "", mode="eval")
a = eval(c2)
print(a)

输出：

6

#对于代码中有用户交互的代码，模式使用single

code3 = "name = input('请输入名字:')"
c3 = compile(code3, "", mode="single")
exec(c3)
print(name)
输出：
请输入名字:阿狸
阿狸

11)基础数据类型相关

#数据类型

①bool 布尔

②int  整数

③float 浮点数

④complex 复数

#进制转换

①bin  把一个十进制数转换为二进制数

②hex 把一个十进制数转换为十六进制数

③oct把一个十进制数转换为八进制数

#数学运算

①abs()  求绝对值

②divmode() 返回商和余数

print(divmod(20,3))
输出：
(6, 2)

③round()  四舍五入

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

print(pow(2,3))
print(pow(2,3,3))
输出：
8
2

⑤sum()    求和

print(sum([1,2,3,4,5]))
输出：
15

⑥min() 求最小值

⑦max()   求最大值

12）和数据结构相关

#序列：列表和元组

①list  将其他数据类型转化为列表；把生成器转换为列表

②tuple…. 元组

#序列：相关内置函数

①reversed() 将一个序列翻转，返回翻转序列的迭代器；不会改变原列表，而是返回一个迭代器

lst = ["九尾妖狐","阿狸","灵魂突袭"]
lst_new = reversed(lst)
print(lst_new)
print(list(lst_new))
输出：
<list_reverseiterator object at 0x000001E1856C5EB8>
['灵魂突袭', '阿狸', '九尾妖狐']

②slice  列表的切片

lst = [1,2,3,4,5,6,7]
print(lst[1:3:1])
s = slice(1,3,1)
print(lst[s])
输出：
[2, 3]
[2, 3]

#字符串

①str

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

# 字符串
print(format('test', '<20')) # 左对⻬
print(format('test', '>20')) # 右对⻬
print(format('test', '^20')) # 居中
# 数值
print(format(3, 'b')) # ⼆进制
print(format(97, 'c')) # 转换成unicode字符
print(format(11, 'd')) # ⼗进制
print(format(11, 'o')) # ⼋进制
print(format(11, 'x')) # ⼗六进制(⼩写字⺟)
print(format(11, 'X')) # ⼗六进制(⼤写字⺟)
print(format(11, 'n')) # 和d⼀样
print(format(11)) # 和d⼀样
# 浮点数
print(format(123456789, 'e')) # 科学计数法. 默认保留6位⼩数
print(format(123456789, '0.2e')) # 科学计数法. 保留2位⼩数(⼩写)
print(format(123456789, '0.2E')) # 科学计数法. 保留2位⼩数(⼤写)
print(format(1.23456789, 'f')) # ⼩数点计数法. 保留6位⼩数
print(format(1.23456789, '0.2f')) # ⼩数点计数法. 保留2位⼩数
print(format(1.23456789, '0.10f')) # ⼩数点计数法. 保留10位⼩数
print(format(1.23456789e+10000, 'F')) # ⼩数点计数法.,无穷大显示INF
输出：
test                
                test
        test        
11
a
11
13
b
B
11
11
1.234568e+08
1.23e+08
1.23E+08
1.234568
1.23
1.2345678900
INF

③bytes    把字符串直接转化为bytes类型

#字符编码的转化

s = "史迪仔很可爱"
a = s.encode("utf-8")
print(a)
print(a.decode("utf-8"))
输出：
b'xe5x8fxb2xe8xbfxaaxe4xbbx94xe5xbex88xe5x8fxafxe7x88xb1'
史迪仔很可爱

#bytes可直接完成转化，结果是一样的

bs = bytes("史迪仔很可爱",encoding="utf-8")   #把字符串编码成utf-8
print(bs)
输出：
b'xe5x8fxb2xe8xbfxaaxe4xbbx94xe5xbex88xe5x8fxafxe7x88xb1'

④bytearry       返回一个字节数组，并且这个数字中的元素是可变的，并且每个元素的值的范围是[0,256)

ret = bytearray("Lop",encoding="utf-8")
print(ret[0])
print(ret)
输出：
76
bytearray(b'Lop')

⑤memoryview  查看内存

⑥ord        返回字符在编码表中的位置（只能是单个字符）

print(ord("a"))
print(ord("中"))  #中字在编码表中的位置
输出：
97
20013

⑦chr        通过字符编码，返回是哪个字符

print(chr(65))
print(chr(20013))  
输出：
A
中

⑧ascii      可字符是否在ascii表中，若在表中，直接返回本身

print(ascii("a"))
print(ascii("中"))
输出：
'a'
'u4e2d'

⑨repr 原因输出，过滤掉转义字符（ ）,但是不管%

name = "%s就是
LOL " % "英雄联盟"
print(name)
print(repr(name))
输出：
英雄联盟就是
LOL 
'英雄联盟就是
LOL '

#数据集合：字典

①dict 

#数据集合：集合

①set        set集合

②frozenset  不可变的集合

#相关内置函数

①len

②sorted

③enumerate  把列表中 的索引和元素一起获取

lst = ["英雄联盟","地下城","CF","QQ飞车"]
for index,values in enumerate(lst):
    print(index,values)
输出：
0 英雄联盟
1 地下城
2 CF
3 QQ飞车

#索引默认是从0开始，可以进行修改

lst = ["英雄联盟","地下城","CF","QQ飞车"]
for index,values in enumerate(lst,1):
    print(index,values)
输出：
1 英雄联盟
2 地下城
3 CF
4 QQ飞车

④all  可迭代对象中全部都是True，则返回True(相当于and)

print(all([1,2,True,0]))
print(any([1,'',0]))
输出：
False
True

⑤any  可迭代对象中有一个是True，则返回True(相当于or)

⑥zip

hero = ["九尾妖狐","远古巫灵","惩戒之箭","无双剑姬"]
name = ["阿狸","泽拉斯","维鲁斯","菲奥娜"]
skill = ["灵魂突袭","奥数仪式","腐败锁链"]  #该列表少一个，所以最终输出也少一个
for i in zip(hero,name,skill):
    print(i)
输出：
('九尾妖狐', '阿狸', '灵魂突袭')
('远古巫灵', '泽拉斯', '奥数仪式')
('惩戒之箭', '维鲁斯', '腐败锁链')

⑦fiter  过滤

⑧map  会根据提供的函数对指定序列做映射(lamda)