内置函数

内置函数

内置:python自带

作用域相关

locals    获取执行本方法所在命名空间内的局部变量的字典
globals  获取全局变量的字典

迭代器，生成器相关

range(100)  # [0,100)
range(5,100)  # [5,100)
range(1,100,2)
# 可迭代对象，可以for循环，惰性计算
iter
iterator = iter(range(100))  # 拿到一个迭代器
next
next(iterator)

其它

# dir 查看内置属性
print(dir([]))
print(dir(5))

# callable 调用相关
callable()  # 可以调用
a = 1
print(callable(a))  # False
print(callable(print))  # True

# help 帮助
help()  # 进去python的帮助页面
help(list)  # 查看list的帮助信息
# ctrl + 左键单击:pycharm的方法
# dir:只包含方法名 —— 想查看某方法是否在这个数据类型中
# help:包含所有方法名以及他的使用方法 —— 不知道用法

# __import__ 模块相关
import time  # 时间
import os  # 操作系统

# open 文件操作相关
open('文件名','w',encoding='utf-8')
# 打开模式:
# r、w、a、ab、rb、wb
# 编码 utf-8/gbk

# 内存相关
# hash 算法，结果为一串数字
# hash 判断一个数据类型是否可以hash
# 在一个程序执行的过程中，对同一个值hash的结果总是不变
# 多次执行，对同一个值的hash结果可能改变
# 数据的存储和查找
# 字典查找数据快，有了key是一次寻址就查到的，将key通过算法转换为数字，代表一个内存地址，然后将值存在这个内存地址内，这种
# 方法叫索引的寻址
# 模块:hashlib
print(hash(123))
print(hash('abs'))

# id 指向的内存地址
print(id(1))  # 1对应的内存地址
print(id(2))  # 2对应的内存地址

# 输入输出
# input，print
s = input('提示:')  # 接收到的都是字符串
print(s)

print(1,2,3,4,5,sep='*')  # 1*2*3*4*5 sep是指定多个要打印的内容之间的分隔符
print(1,end=',')  # end指定结尾的符号
print(2)  # 1,2

f = open('a','w')
print('abc',file=f)  # file将内容打印到指定的文件中

# 打印进度条
import time
for i in range(0,101,2):
     time.sleep(0.2)
     char_num = i//2      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)  # \r把光标移到该行的最开始
     print(per_str,end='', flush=True)  # flush=True 不要缓存，直接打印

字符串类型代码的执行

exec("print('12345')")
eval("print('12345')")
print(exec('1+2+3-4'))  # None
print(eval('1+2+3-4'))  # 2
# exec和eval可以以python代码的形式执行一个字符串，但是exec没有返回值，eval有返回值
# eval用于值计算的时候
# exec用于流程性代码的执行

# compile 编译
# 1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　
# 2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，
# filename参数传入空字符即可。　　
# 3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，
# model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，
# model应指定为'single'
#流程语句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)
#简单求值表达式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
eval(compile2)
#交互语句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
#执行前name变量不存在
exec(compile3) #执行时显示交互命令，提示输入
# please input your name:'pythoner'
# "'pythoner'"

和数字相关

# 数据类型相关
# bool int float complex
# 进制转换
# bin二进制
# oct八进制
# hex十六进制
# 数学运算
# abs 绝对值
print(abs(-5))  # 5
# divmod 取商和余数，商余函数，分页的时候用到
ret = divmod(10,2)
print(ret)  # (5,0)
# round 保留几位小数
print(round(3.1415926,2))  # 3.14
# pow 幂运算
print(pow(2,3))  # 8
print(pow(3,2))  # 9
print(pow(2,3,2))  # 2的3次方取余2  x**y%z
# sum 接收可迭代对象
print(sum([1,2,3,4,5,6]))
print(sum(range(100)))
print(sum([1,2,3,4,5,6],5))  # 26  5为起始值
# min 取最小值
print(min([1,3,0,9,7]))  # 0
print(min([],default=0))  # 没有值会报错，但是default可以设置一个默认值
print(min([-9,1,23,5],key=abs))  # 迭代可迭代对象里的每一个值，传给key后面的函数，并接收返回值
# max 去最大值
print(max((-25,1,3,6,8)))  # 8
print(max((-25,1,3,6,8),key=abs))  # -25 取绝对值最大的
print(max((),default=100))  # 内容为空的不报错，返回默认值100

 和数据结构相关

列表和元组
list，tuple数据类型强制转换

 

reversed 参数:序列 返回值:反序的迭代器

l = [3,4,2,6,7,1,5]
ret = reversed(l)
print(ret)  # <list_reverseiterator object at 0x000000000112AB70>
print(list(ret))  # [5, 1, 7, 6, 2, 4, 3]
l.reverse()
print(l)  # [5, 1, 7, 6, 2, 4, 3]
# reversed:返回迭代器，不改变原来的列表，生成一个新的序列迭代器
# reverse:返回None，是在原本的列表的基础上修改的

 

slice 实现了切片的函数

l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)
print(l[sli])  # (2, 213)

 

str 数据类型抢转为字符串

 

format 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐

print(format('test', '<20'))  # test
print(format('test', '>20'))  #                 test
print(format('test', '^20'))  #         test

 

bytes 网络变成的时候:能在网络上传输的只能是字节

ret = bytes('你好，哈哈哈，再见',encoding='utf-8')
print(ret)
# 中间是网络传输的过程
print(ret.decode(encoding='utf-8'))

bytearray 对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearray的内存地址

ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))

 

memoryview

ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))

 

ord chr

print(ord('a'))  # 97 字符按照unicode转数字
print(chr(97))  # a 数字按照unicode转换字符

 

ascii 只要是ascii码中的内容，就打印出来，不是就转换成\u

print(ascii('a'))  # 'a'
print(ascii('你好'))  # '\u4f60\u597d'
print(ascii('a你好'))  # 'a\u4f60\u597d'

 

repr 打印出内容并且能看出数据类型

print(repr(1))  # 1
print(repr('1'))  # '1'
print('name:%r'%('金老板'))  # name:'金老板' %r格式化输出

 

dict 字典
set 集合
frozenset 不可变集合

 

len 计算长度

 

enumerate 枚举

l = ['笔记本','phone','apple','banana']
for i in enumerate(l,1):
    print(i)

 

all 接收一个可迭代对象，里面的元素只要有一个是False，整体就是False

print(all([1,2,3,4,0]))  # False
print(all([1,2,3,4]))  # True

any 接收一个可迭代对象，里面的元素只要有一个是True，整体就是True

print(any([True,None,False]))  # True
print(any([False,None,False]))  # False

 

zip 拉链函数

print(zip([1,2,3,4],[5,6,7,8]))  # <zip object at 0x00000000006F5C08>
print(list(zip([1,2,3,4],[5,6,7,8])))  # [(1, 5), (2, 6), (3, 7), (4, 8)]
print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))  # [(0, 5, 'a'), (1, 6, 'b')]

 

filter 过滤函数，有一个可迭代对象，想要一个新的内容集，是从原可迭代对象中筛选出来的新内容少于等于原内容的时候，才能用到filter

def is_odd(x):
    if x > 10:
        return True
ret = filter(is_odd,[1,4,6,7,9,12,17])  # 过滤列表中所有大于10的数
print(list(ret))  # [12, 17]

ret = filter(lambda x:x%2==0,[1,4,6,7,9,12,17])  # 过滤所有能被2整除的数
print(list(ret))

def func(x):
    return x and x.strip()
l = ['test', None, '', 'str', '  ', 'END']
ret = filter(func,l)  # 过滤None和空内容
print(list(ret))  # ['test', 'str', 'END']

# 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是:
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
print(filter(is_sqr, range(1, 101)))

map 新内容的个数等于原内容的个数

ret = map(abs,[-1,-5,6,-7])
print(list(ret))

# 有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理
L = [1,2,3,4,5,6,7,8]
ret = map(lambda x:x**2,L)
print(list(ret))

filter和map
参数很相近:都是一个函数名+可迭代对象
返回值也很相近:都是返回可迭代对象
区别
filter是做筛选的，结果还是原来就在就在可迭代对象中的项
map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项

 

sorted 是生成一个新列表，不改变原来的列表
sort 是直接修改原列表的顺序，节省内存

print(sorted([-5,3,-4,2,-1]))  # [-5, -4, -1, 2, 3]
print(sorted([-5,3,-4,2,-1],reverse=True))  # [3, 2, -1, -4, -5]
print(sorted([-5,3,-4,2,-1],key=abs))  # [-1, 2, 3, -4, -5] 按照绝对值排序，但是输出的还是原来的元素