内置函数:python自带的函数
作用域相关
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
def func():
a = 1
b = 2
print(locals())
print(globals()) #始终不变
func(){‘b‘: 2, ‘a‘: 1}
{‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x00 000 226639E59E8>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__ ‘_ _cac hed__‘: No ne, ‘func‘: <function func at 0x0000022663AB89D8>}
其他
eval() 将字符串类型的代码执行并返回结果
print(eval(‘1+2+3+4‘)) #10
exec()将自字符串类型的代码执行
print(exec("1+2+3+4")) #没有返回值，结果None
exec("print(‘hello,world‘)") #hello,world
compile 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
参数说明：
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("print(‘12345‘)") #12345
eval("print(‘12345‘)") #12345
print(exec(‘1+2+3-4‘)) #None
print(eval(‘1+2+3-4‘)) #2
code1 = ‘for i in range(0,10): print (i)‘ compile1 = compile(code1,‘‘,‘exec‘) exec(compile1) #0 1 2 3 4 5 6 7 8 9
#简单求值表达式用eval code2 = ‘1 + 2 + 3 + 4‘ compile2 = compile(code2,‘‘,‘eval‘) print(eval(compile2))
code3 = ‘name = input("please input your name:")‘
compile3 = compile(code3,‘‘,‘single‘)
# # name #执行前name变量不存在
exec(compile3)
print(name) #name在pycharm里飘红，但是可以执行please input your name:
range#可迭代对象，可以for循环，惰性运算
# range(100) #[0,100)
# range(5,100) #[5,100)
# range(1,100,2)
#可迭代对象，可以for循环，惰性运算
# def iter(): #定义迭代器
# return range(100).__iter__()
iterator = iter(range(100)) #拿到一个迭代器
print(iterator.__next__()) #0
print(next(iterator)) #1
for i in range(100):
print(i) #for循环迭代每一个元素
dir查看参数所属类型的所有内置方法
dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法 print(dir(int)) #查看整数的内置方法
callable
和调用相关
callable(o)，o是参数，看这个变量是不是可调用。
如果o是一个函数名，就会返回True
a = 1 def func():pass print(callable(a)) #不可以调用 print(callable(print)) #可以调用 print(callable(func)) #可以调用
查看关键字用法
ctrl + 左键单击 ：pycharm
help：包含所有方法名以及他的使用方法 —— 不知道用法的情况下
在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入quit退出
或者直接执行help(o)，o是参数，查看和变量o有关的操作
dir：只包含方法名 —— 想查看某方法是否在这个数据类型中
import 引用模块
import time #时间
import os #操作系统
open() 打开一个文件，返回一个文件操作符
操作文件的模式有r,w,a,rb,wb,ab
可以用encoding指定编码.utf-8，gbk
f = open(‘文件名‘,‘w‘,encoding=‘utf-8‘)
input输入，输入内容是字符串
s = input("请输入内容 ： ")
print(s)
print输出打印
print(self, *args, sep=‘ ‘, end=‘\n‘, file=None):
"""
print(value, ..., sep=‘ ‘, end=‘\n‘, file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
"""
f = open(‘tmp_file‘,‘w‘) print(123,456,sep=‘,‘,file = f,flush=True)
##打印进度条
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) print(per_str,end=‘‘, flush=True) #\r 可以把光标移动到行首但不换行
type(o)返回变量o的数据类型
id(o)返回变量o的内存地址
hash(o)返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错
数字相关
数字——数据类型相关：bool(布尔型)，int(整型)，float(浮点型)，complex(复数)，一般用于强转类型
进制转换相关：bin(二进制)，oct八进制()，hex(十六进制)，一般用于强转类型
数学运算：abs(绝对值)，divmod(取商和余)，min(最小值)，max(最大值)，sum(求和)，round(取几位小数)，pow(幂运算)
abs 取绝对值
print(abs(-5)) #5
divmod 取商余
ret = divmod(10,2) print(ret) #(5, 0)
ret = divmod(3,2)
print(ret) #(1, 1)
ret = divmod(7,2)
print(ret) #(3,1)
round 取几位小数
print(round(3.14159,2)) #取小数位数，后面的2表示去几位小数，结果为3.14
pow 幂运算
print(pow(2,3.5)) #可以是小数，结果11.313708498984761 print(pow(3,2)) #9print(pow(2,3,3)) #x**y%z结果2
sum 求和，接收一个可迭代对象
print(sum([1,2,3,4,5,6],-2)) #后面的-2同样和前面的相加，结果为19 print(sum(range(100))) #4950
min 最小值
print(min([1,-4,0,9,6])) #-4
print(min([],default=0)) #取默认值0
print(min([-9,1,23,5],key=abs)) #匿名函数，序列里先经过后面的函数运算再比较，结果为1
print(min({‘z‘:1,‘a‘:2})) #比较字典键的大小，结果为a
max 最大值
t = (-25,1,3,6,8) print(max(t)) #8 print(max(t,key = abs)) #-25 print(max((),default=100)) #100
数据结构相关
序列：list，tuple，str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr
ret = bytearray(‘alex‘,encoding=‘utf-8‘) #对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearry的内存地址 print(id(ret)) #2235695791048 print(ret[0]) #97，a的asii码 ret[0] = 65 print(ret) #bytearray(b‘Alex‘)，小写a变大写A print(id(ret)) #2235695791048，内存不变
ret = memoryview(bytes(‘你好‘,encoding=‘utf-8‘)) print(len(ret)) #6 print(bytes(ret[:3]).decode(‘utf-8‘)) #你 print(bytes(ret[3:]).decode(‘utf-8‘)) #好
reversed反转
l = [3,4,2,5,7,1,5] ret = reversed(l) print(ret) # <list_reverseiterator object at 0x000001EFDFF27BA8> print(list(ret)) #[5, 1, 7, 5, 2, 4, 3] l.reverse() print(l) #[5, 1, 7, 5, 2, 4, 3]
slice 实现了切片的函数
l = (1,2,23,213,5612,342,43) sli = slice(1,5,2) #实现了切片的函数 print(l[sli]) #(2, 213) #l[1:5:2] 语法糖
format
print(format(‘test‘, ‘<20‘))#20个字符，test左对齐 print(format(‘test‘, ‘>20‘))#20个字符，test右对齐 print(format(‘test‘, ‘^20‘))#20个字符，test居中
结果：
test
test
test
bytes
#网络编程的时候：能在网络上传递的必须是字节 ret = bytes(‘你好，哈哈哈，再见‘,encoding=‘utf-8‘) #中间是网络传输的过程 print(ret.decode(encoding=‘utf-8‘)) #你好，哈哈哈，再见
ord
print(ord(‘a‘)) #97
chr
print(chr(97)) #a
ascii
print(ascii(97)) #97 print(ascii(‘a‘) #‘a‘,原内容输出字符，a带引号
repr
print(repr(1)) #1 print(repr(‘1‘)) #‘1‘ print(repr(‘name : %r‘%(‘金老板‘))) #‘name : ‘金老板‘‘,整体带引号
enumerate枚举
l = [‘笔记本‘,‘phone‘,‘apple‘,‘banana‘]
for i,j in enumerate(l,1):
print(i,j)
输出
1 笔记本
2 phone
3 apple
4 banana
all只要有一个布尔值为False的内容，结果就为False，否则为True
any只要有一个布尔值为True的内容，结果就为True,否则为False
print(all([1,2,3,4,0])) #F print(all([1,2,3,4])) #T print(all([1,2,3,None])) #F print(all([1,2,3,‘‘])) #F print(any([1,None,False])) #T print(any([False,None,False])) #F
zip 拉链函数
print(list(zip([0,1,2,3,4],[5,6,7,8],[‘a‘,‘b‘])))
结果[(0, 5, ‘a‘), (1, 6, ‘b‘)]
filter过滤函数
def is_odd(x):
if x>10:
return True
ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
print(list(ret)) #[12, 17]
#filter就是有一个可迭代对象，想要一个新的内容集，是从原可迭代对象中筛选出来的
def func(x):
#return x.strip() #‘ ’.strip() ==> ‘‘ ==> return False
# ‘test‘.strip() ==> ‘test‘
return x and x.strip() #None False and
#去掉所有的空内容和字符串中的空格
l = [‘test‘, None, ‘‘, ‘str‘, ‘ ‘, ‘END‘]
ret = filter(func,l)
print(list(ret))
#新内容少于等于原内容的时候，才能用到filter
map
ret = map(abs,[-1,-5,6,-7]) #abs(-1) = 1 abs(-5) = 5 print(list(ret)) #[1, 5, 6, 7]
filter和map
参数很相近：都是一个函数名+可迭代对象
且返回值很相近：都是返回可迭代对象
区别：
filter是做筛选的，结果还是原来就在可迭代对象中的项
map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项
有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理
def func(x):
return x*x
ret = map(func,[1,2,3,4,5,6,7,8])
print(list(ret)) #[1, 4, 9, 16, 25, 36, 49, 64]
sorted排序
对List、Dict进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序，直接修改原列表顺序，节省内存
方法2.用内置函数sorted进行排序，生成新列表，原列表不变
print(sorted([-5,3,-4,2,-1],reverse=True)) #[3, 2, -1, -4, -5]，reverse=True默认从大打小排序 print(sorted([-5,3,-4,2,-1],key=abs)) #[-1, 2, 3, -4, -5]，按绝对值大小排序(原列表元素不变) l2 = [‘ajkhs‘,(1,2),‘a‘,[1,2,3,4]] print(sorted(l2,key=len,reverse=True)) #[‘ajkhs‘, [1, 2, 3, 4], (1, 2), ‘a‘]，按元素长度排序
匿名函数
lambda表达式
def calc(n):
return n**n
print(calc(10))
#换成匿名函数
calc = lambda n:n**n
print(calc(10))
dic={‘k1‘:10,‘k2‘:100,‘k3‘:30}
print(max(dic.values())) #找出字典中最大的值
print(max(dic)) #找出字典中最大的键
print(max(dic,key=lambda k:dic[k])) #找出字典中值最大的键
结果：
100
k3
k2
#找出序列中大于10的数
ret = filter(lambda num:num>10,[1,4,6,823,67,23]) print(list(ret))
#也可以下面这样写 ret = filter(lambda num:True if num>10 else False,[1,4,6,823,67,23]) print(list(ret))
一、数学运算类
1，abs(x)求绝对值参数可以是整型，也可以是复数
2，divmod(a, b)分别取商和余数,整型、浮点型都可以
3，pow(x, y)x的y次幂
4，round(x, n)小数四舍五入
5，sum(iterable)求和
6，int转为int类型
7，bool转为bool类型
8，float转为float类型
二、序列操作
1，enumerate返回一个可枚举的对象,该对象的next()方法将返回一个tuple
2，max(iterable[args][key])返回最大值
3，min(iterable[args][key])返回最小值
4，sorted(iterable,key,reverse)对序列排序
5，reversed反转
三，判断类
1，all集合中的元素都为真的时候为真
2，any集合中的元素有一个为真的时候为真
3，callable检查对象是否可调用
4，dir返回方法或者参数的属性
四，字符串类
1，bytes
2，eval将字符串类型的代码执行并返回结果
3，exec将自字符串类型的代码执行
4，compile将字符串类型的代码编译
5，len返回集合长度
五，函数类
1，filter过滤函数
2，map遍历每个元素，执行function操作
3，zip拉链函数
4，repr用于%r格式化输出
5，range(start, stop, step]) 产生一个可跌代对象，默认从0开始
六，其他
1，input输入
2，print输出
3，hash返回一个可哈希值
4，open打开文件
5，import引用模块
带key值的函数,key=func
min()
max()
sorted()