内置函数-68个

内置函数 共有68个
某个方法属于某个数据类型的变量，就用.调用
如果某个方法不依赖于仍和数据类型的，就直接调用 --- 内置函数和自定义函数

 

必须掌握			了解
函数名	类别	作用	函数名	类别	作用
eval()	其他内置函数	字符串代码运行，有返回值，简单计算	locals()	作用域	查看本地作用域内的所有名字
exec()	其他内置函数	字符串代码运行，无返回值，简单流程控制	globals()	作用域	查看全局作用域内的所有名字
input()	其他内置函数	用户数据输入	compile()	其他内置函数	将一个字符串编译为字节代码
print()	其他内置函数	打印输出	id()	其他内置函数	获取对象的内存地址
hash()	其他内置函数	显示哈希值	import	其他内置函数	导入模块 import OS
open()	其他内置函数	打开文件句柄	help()	其他内置函数	帮助，help(int)
dir()	其他内置函数	查看数据类型的所有方法	callable()	其他内置函数	检查对象是否可以被调用
bool()	基础数据类型	布尔值,强制转换时使用	complex()	基础数据类型	复数，无法比较大小
int()	基础数据类型	整型,强制转换时使用	bin()	基础数据类型	转为二进制0b
float()	基础数据类型	浮点型，强制转换时使用	oct()	基础数据类型	转为八进制0o
abs()	基础数据类型	绝对值	hex()	基础数据类型	转为十六进制0e
divmod()	基础数据类型	除余	slice()	基础数据类型	切片，操作函数里的参数传递
round()	基础数据类型	小数位精确	format()	基础数据类型	格式化输出
pow()	基础数据类型	求幂运算	bytearray()	基础数据类型	返回一个新字节数组
sum()	基础数据类型	求和运算	memoryview()	基础数据类型	切片，字节类型，仅查看
min()	基础数据类型	求最小值	ord()	基础数据类型	字符按Unicode转数字
max()	基础数据类型	求最大值	chr()	基础数据类型	数字按Unicode转字符
list()	基础数据类型	列表,强制转换时使用	ascii()	基础数据类型	只要是ascii码中的内容，就打印出来，不是就转换为\u
tuple()	基础数据类型	元组,强制转换时使用	all()	基础数据类型	判断iterable里有一个是False则为False
reversed()	基础数据类型	反转,不改变原列表，产生一个生成器	any()	基础数据类型	判断iterable里有一个是True则为True
str()	基础数据类型	字符串，强制转换时使用
bytes()	基础数据类型	bytes数据类型强转
repr()	基础数据类型	%r,原封不动输出变量的值
dict()	基础数据类型	字典，数据类型强转
set()	基础数据类型	集合，自带去重功能
frozenset()	基础数据类型	不可变集合
len()	基础数据类型	计算容器数据类型内有多少元素
filter()	基础数据类型	筛选   filter(函数名,iterable)
map()	基础数据类型	对可迭代对象进行函数处理map(函数名,iterable)
zip()	基础数据类型	拉链，返回一个迭代器
enumerate()	基础数据类型	组合为一索引序列
sorted()	基础数据类型	排序，不改变原数据，产生新的数据
next()	迭代器\生成器	返回迭代器的下一个yield
iter()	迭代器\生成器	转换为迭代器
range()	迭代器\生成器	返回一个整数序列的对象

 

与作用域相关的2个 locals() globals()

locals()  # 查看本地作用域内中的所有名字
globals()  # 查看全局作用域内的所有名字

迭代器\生成器相关的3个 next() iter() range()

next(迭代器)
iter(可迭代的) #生成一个迭代器
range()  # 确定是一个可迭代的，而不是迭代器 # iter(range(10)) 转换为迭代器

其他相关的内置函数12个
A 查看内置属性 1个 dir()

dir() # 查看一个变量拥有的所有方法

B 调用相关 1个 callable()

callable() # 检验一个变量名，是否为可执行的函数
print(callable(print))
a = 1
print(callable(a))
def b():
    print('hehe')
print(callable(b))

C 帮助相关 1个 help()

help() # 查看帮助文档
help(str)

D 模块相关 1个 import

import  # 导入模块
import OS

E 文件操作相关 1个 open()

open() # 打开文件，拿到文件句柄

F 内存相关 2个 id() hash()

id() # 代表了一个变量的内存地址
hash() # 判断变量类型能否为可哈希的对象，不可哈希的数据类型就会报错，可哈希数据类型为不可变数据类型
对于相同可hash的数据的hash值再一次程序的执行过程中总是不变的
print(hash(123))
print(hash([]))
#字典的查找Key对应的Value 与hash有关

G 输入输出相关 2个 input() print() 

input() # 用户输入，不输入就不再往下执行
print() # 每一次打印自动再末位添加一个换行符\n
#指定输出的结束符
print('skjfdksjflkjs\n',end='')
print('skjfdksjflkjs\n')
print('skjfdksjflkjs\n',end='')
print('skjfdksjflkjs\n')
print('skjfdksjflkjs\n',end='')
#指定输出多个值之间的分隔符
print(1,2,3,4,5,sep='|')

#打印输出位置改变，默认输出到屏幕  #感觉好像挺有用的
f = open('file','w')
print('hello',file=f)
f.close
#flush: 立即把内容输出到流文件，不作缓存

一个有趣的例子：使用print()功能打印进度条

H 字符串代码的执行 3个 eval() exec() compile()

eval() 常用于简单计算，且有返回值

test = '1+2+3'
print(eval(test))

exce()常用于简单流程控制，无返回值

test = '''
for i in range(10):
    print(i)
'''
exec(test)
# print(exec(test)) #返回None

eval()和exce()都可以执行字符串类型的代码，两者的区别在于eval()有返回值，exec()没有返回值

eval('print(123)')
exec('print(123)')
print(eval('1+2+3+4'))  # 有返回值
print(exec('1+2+3+4'))  # 没有返回值

compile() 将字符串的代码进行编译，但是最终还是需要调用eval()、exec()

# 流程控制
test = 'for i in range(0,10):print(i)'
compile1 = compile(test,'','exec')
exec(test)
# 简单计算
test1 = '1+2+3'
compile2 = compile(test1,'','eval')
print(eval(test1))
# 用户交互 必须使用single
test3 = 'name = input("请输入你的用户名:")'
compile3 = compile(test3,'','single')
exec(test3)
print(name) # name 通过编译后产生了

 基础数据类型相关38个，其中和数字相关的14个，和数据结构相关的24个

和数字相关的14个，其中数据类型4个，进制转换3个，数学运行7个

数据类型4个 bool()-布尔型 int()-整型 float()-浮点型 complex()-复数 只在数据类型强制转换的时候才用

complex --- 复数 ---复合的数
例子：5+12j 复数无法比较大小

# 浮点数，是根据科学计数法来的 
# 314.11= 3.1411*10**2=31.411*10 （小数点飘浮）

进制转换3个 bin() oct() hex()

print(bin(10))  # 二进制转换 0b开头
print(oct(10))  # 八进制转换 0o开头
print(hex(10))  # 十六进制转换 0x开头

数学运算7个 abs()-绝对值 divmod()-除余 round()-小数的精确 pow()-幂运算 sum()-求和 min()-求最小值 max()-求最大值

# abs() 绝对值
print(abs(100))
print(abs(-100))

# divmod() 除余
print(divmod(9,2)) # 分为两部分 div 先除去，然后mod取余，常用于分页

# round() 小数位精确
print(round(3.1415926,2))

# pow() 求幂运算
print(pow(2,3))

# sum() 求和运算
print(sum([1,2,3,4]))
print(sum(1,2,2)) # 错误写法，sum内参数位可迭代对象

# min() 最小值
print(min(-1,-2,3,4))
print(min(-1,-2,3,4,key=abs)) # 先执行key对应的函数-绝对值，再输出最小值

# max() 最大值
print(max(1,2,3,-4))
print(max(1,2,3,-4,key=abs)) # 先执行key对应的函数-绝对值，再输出最大值

和数据相关的共有24个，其中序列有13个，数据集合有3个，相关内置函数8个

序列里有13个，其中列表和元组2个，相关内置函数2个，字符串9个

 列表和元组2个 list() tuple()

# 仅在数据类型强制转换的时候使用
list 不可哈希
tuple 可哈希，不可修改

相关内置函数2个 reversed()-反转 slice()-切片

reversed() 反转功能，返回值是一个迭代器，可节省内存空间
#保留原来的列表，返回一个反向的迭代器
l = [1,2,3,4,5]
l2 = reversed(l)
print (l2)
l3 = []
for i in l2:
    l3.append(i)
print(l)
print(l3)

 

# slice() 切片
l = [1,2,333,444,555,666]
sli = slice(1,5,2)
print(l[sli])
print(l[1:5:2])

字符串相关的有9个 format()-格式化输出 bytes()-转换成bytes类型 bytearry() menoryview() ord() chr() ascil() repr()

#format() 格式化输出
print(format('test','<20'))  # 开20个空间 向左对齐
print(format('test','>20'))  # 开20个空间 向右对齐
print(format('test','^20'))  # 开20个空间 居中对齐

# bytes() 转换bytes类型
# 所有数据读到内存里，都是Unicode
# 需求：我拿到的是GBK编码，想转换成UTF-8
# 思路：先解码decode成Unicode，在bytes成想要的编码类型
print(bytes('你好',encoding='GBK')) # Unicode转为GBK
print(bytes('你好',encoding='UTF-8'))  # Unicod 转为UTF-8
print(bytes('你好',encoding='GBK').decode('GBK')) # Unicode转为GBK,然后解码成GBK
# 用途
# 网络编程 只能传二进制
# 文件存储
# 照片和视频也是以二进制存储
# html网页爬取到的数据也是bytes编码

#bytearry() 
# 可以通过切片修改对应的字节，修改的时候可以节省内存，仅可以通过字符编码来修改
b_array = bytearray('你好',encoding='UTF-8')
print(b_array) 
print(b_array[0])

# menoryview() 
# 切片 -->字节类型，不占内存，仅切给你看，而且切出来的是字节类型，如果转为其他编码又占空间了

# ord()  
#字符按照Unicode转数字 
print(ord('a'))
print(ord('你好'))

# chr()
# 数字按照Unicode转字符 
print(chr(99))

# ascii()
# 只要是ascii码中的内容，就打印出来，不是就转换为\u
print(ascii('你好'))
print(ascii('123‘’))

 

# repr()
# 会让变量原封不动的输出出来，也用于格式化输出%r
name = 'egg'
print('Hello %s'%name)
print('Hellor %r'%name)

print(repr(1))  # int
print(repr('1'))  # str

数据集合有3个，其中字典1个，集合2个

字典1个 dict()

# dict() 字典

集合2个 set() frozenset()

# set() 集合

# frozenset() 不可变集合  可以作为字典的key

内置函数里的最重要的几个内置函数---相关内置函数8个

len() enumerate() all() any() zip() filter() map() sorted()

# all(可迭代的)
# 可迭代对象里，有任何一个是是False就整体是False
print(all(['a','',123]))
print(all(['a',123]))
print(all([0,1123]))

#any(可迭代的)
# 可迭代对象里，有任何一个是True就整体是True
print(any(['a','',123]))
print(any(['a',123]))
print(any([0,1123]))

#zip()  
# 返回一个迭代器
# 拉链，以最小单位为基准
l = [1,2,3,4]
l2 = ['a','b','c']
l3 = ('111',222,[3333])
l4 = {'k1':1,'k2':2}
for i in zip(l,l2,l3,l4):
    print(i)

 注意：

filter() 执行了filter之后的结果集合   <=  执行之前的个数
　　filter只管筛选，不会改变原来的值
map() 执行过后元素个数不变
       值可能发生改变

# filter(函数名,可迭代的)  # 注意是函数名不是函数调用
# 是过滤函数 筛选
# 函数体 返回的值是True的时候 才会进行输出
# 例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数
def is_odd(x):
    return  x % 2 ==1

ret = filter(is_odd,[1, 4, 6, 7, 9, 12, 17])
# filter()方法会进行一个循环和调用函数的动作
# for i in [1, 4, 6, 7, 9, 12, 17]:
#     if is_odd(i):
#         print(i)
print(ret)  # 返回一个迭代器
for i in ret:
    print(i)

#利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串或者空列表，空字典等等：
# 思路，主要是看你函数怎么判读

# map()
#Python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，
# map函数则会把每一个参数都以相应的处理函数进行迭代处理。
# map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
ret = map(abs,[1,-2,-3,4])
# 等同于[abs(i) for i in [1,-2,-3,4]]
print(ret)
for i in ret:
    print(i)

# sorted() 排序方法
#会产生一个新的列表，适用于数据量小的列表，对于数据量大时慎用，因为会占用内存空间
# 特点是不改变原列表，产生一个新的列表，缺点是占用内存
l = [1,2,-1,3,-5,6]
l.sort(key=abs) #在原列表的基础上进行排序
print(l)
print(sorted(l,key=abs, reverse=True)) # 生成了一个新的列表
print(l)

# 需求：列表按照每个元素的len排序
l = ['hello',[1,23,4],(1,2,3,4,5,6),{'k1':1}]
print(sorted(l,key=len))