内置函数 共有68个
某个方法属于某个数据类型的变量，就用.调用
如果某个方法不依赖于仍和数据类型的，就直接调用 --- 内置函数和自定义函数
与作用域相关的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: 立即把内容输出到流文件，不作缓存
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()-求最大值
数学预算7个
和数据相关的共有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))
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
格式 : 函数名 = lambda 参数：返回值
关键字 lambda，而且不允许换行，切冒号后面的语句必须为一个可执行的逻辑
参数可以多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，切逻辑执行结束后的内容就是返回值
返回值和正常的函数一样可以是任意数据类型
带key的内置函数：min max filter map sorted 均可以与lambda使用
#一个自定义函数
def calc(n):
return n**n
print(calc(10))
# 转换为匿名函数
calc = lambda n:n**n
print(calc(10))
# 自定义一个简单函数
def add(x,y):
return x+y
add = lambda x,y:x+y
print(add(1,2))
#需求，在一个字典里取最大的Value，返回对应的key
#
dic = {'k1':10,'k2':100,'k3':30}
#def func(k):
# return dic[k]
#转换为匿名函数
#func = lambda k:dic[k]
#print(max(dic,key=func))
print(max(dic,key = lambda k:dic[k]))
# 解释一下代码
res = filter(lambda x: x > 10, [5, 8, 11, 9, 15])
for i in res:
print(i)
#解析：筛选列表中大于10的数字并答应
# 思路：先将filter拆解,因为会执行for循环将可迭代里的元素一个个取出来：filter(函数名，可迭代的)
# 函数名 = lambda x: x > 10 可迭代的=[5, 8, 11, 9, 15]
# 匿名函数再转换
#def func(x):
# return x >10
l = [5, 8, 11, 9, 15]
def func(x):
return x > 10
funcc = lambda x: x > 10
ress = filter(func, l)
for i in ress:
print(i)