内置函数
作用域相关
基于字典的形式获取局部和全局变量
locals
locals()——获取执行本方法所在的命名空间内的局部变量的字典
def func():
a = 1
print(locals())
{'a': 1}print(locals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x017746D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/work.py', '__cached__': None, 'func': <function func at 0x03562588>}
globals
globals()——获取全局变量的字典
print(globals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x017746D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/work.py', '__cached__': None, 'func': <function func at 0x03562588>}
其他
字符串类型代码的执行
eval
exec
compile
# exec('print(123)')
# eval('print(123)')
# print(eval('1+2+3+4')) # 有返回值
# print(exec('1+2+3+4')) #没有返回值
# exec和eval都可以执行 字符串类型的代码
# eval有返回值 —— 有结果的简单计算
# exec没有返回值 —— 简单流程控制
# eval只能用在你明确知道你要执行的代码是什么
# code = '''for i in range(10):
# print(i*'*')
# '''
# exec(code)
# code1 = 'for i in range(0,10): print (i)'
# compile1 = compile(code1,'','exec')
# exec(compile1)
# code2 = '1 + 2 + 3 + 4'
# compile2 = compile(code2,'','eval')
# print(eval(compile2))
# code3 = 'name = input("please input your name:")'
# compile3 = compile(code3,'','single')
# exec(compile3) #执行时显示交互命令，提示输入
# print(name)
# name #执行后name变量有值
# "'pythoner'"输入输出
input
user = input('输入内容<<<')
input 中的内容会显示到 控制台 等待用户输入def print(self, *args, sep=' ', end='\n', file=None):end
指定输出的结束符
>>>print('hello',end='')
>>>print('Night')
helloNightsep
指定输出多个值之间的分隔符
>>>print(1,2,3,4,sep='|')
1|2|3|4file
将字符直接写入文件中。
f = open('file', 'w')
print('123asd',file=f)
f.close()在python中print其实一直是在写入文件中，只不过对于pycharm而言，默认是写入到控制台这个文件中
练习
模拟进度条
import time
def toos_bar():
for i in range(0,101,2):
time.sleep(0.1)
nub = i // 2
str = '\r {}% : {}\n'.format(i,'*' * nub) if i == 100 else '\r {}% : {}'.format(i,'*' * nub)
print(str,flush = True,end='')
toos_bar()
内存相关
hash
获取可哈希数据的哈希值
每次运行程序的hash值都是不同的
不可哈希的数据类型会直接报错
>>>print(hash('asd'))
681678499id
得到变量的内存地址
>>>print(id('asd'))
16271104文件操作
open
open得到一个文件句柄。 可以进行文件操作
模块相关
_ import _
导入模块
time = __import__('time')
等同于
import(time)帮助
help
通过help查询解释器自带的帮助文档例如：
help(str)调用相关
callable
def func():pass
print(callable(func)) #参数是函数名，可调用，返回True
print(callable(123)) #参数是数字，不可调用，返回False查看内置属性
dir
默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法
print(dir(int)) #查看整数的内置方法数字相关
数据类型
bool
布尔类型
int
数字类型
float
浮点数类型
（有限循环小数，无限循环小数） != 小数 ：有限循环小数，无限循环小数，无限不循环小数
complex
复数类型
复数的实部 虚部 都是浮点数类型float
复数 —— complex
# 实数 ： 有理数
# 无理数
# 虚数 ：虚无缥缈的数
# 5 + 12j === 复合的数 === 复数
# 6 + 15j进制转换
bin 二进制转换
print(bin(10))
0b1010oct 八进制转换
print(oct(10))
0o12hex 十六进制转换
print(hex(10))
0xa数学运算
abs绝对值
>>>print(abs(-5))
>>>print(abs(5))
5
5divmod
>>>print(divmod(7,2)) # div除法 mod取余
>>>print(divmod(9,5)) # 除余
min求最小
print(min([1,2,3,4]))
print(min(1,2,3,4))
print(min(1,2,3,-4))
print(min(1,2,3,-4,key = abs))max求最大
print(max([1,2,3,4]))
print(max(1,2,3,4))
print(max(1,2,3,-4))
print(max(1,2,3,-4,key = abs))sum求和
ret = sum([1,2,3,4,5,6])
print(ret)round
获取精度(四舍五入)
print(round(3.14159,3))
3.142
pow幂运算
print(pow(2,3)) #pow幂运算 == 2**3
print(pow(3,2))
print(pow(2,3,3)) #幂运算之后再取余
print(pow(3,2,1))数据结构相关
序表
列表和元祖
list
list 可以把可迭代对象强转成列表
>>>list('asd')
['a', 's', 'd']
>>> list({'a':1,'b':2})
['a', 'b']
>>> list((1,2,3))
[1, 2, 3]tuple
tuple 可以把可迭代对象强转成元祖
>>> tuple('asd')
('a', 's', 'd')
>>> tuple({'a':1,'b':2})
('a', 'b')
>>> tuple([1,2])
(1, 2)相关内置函数
reversed
反转
和list的reverse的区别就是在于：reverse不会创建新的列表，而是在原列表的基础上直接反转。
而reversed会创建一个新的迭代器进行存储反转后的结果而原列表不会更改
l=[1,2,3,4,5]
l.reverse()
print(l)
[5, 4, 3, 2, 1]
l=[1,2,3,4,5]
l2 = reversed(l)
print(l)
print(list(l2))
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]slice
切片作用一样
l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)
print(l[sli])
(2, 213)字符串
str
强转成str类型
>>>str(123)
'123'format
- 函数功能将一个数值进行格式化显示。
- 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。
>>> format(3.1415936)
'3.1415936'
>>> str(3.1415926)
'3.1415926'- 对于不同的类型，参数format_spec可提供的值都不一样
#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))
#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'
#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母
'INF'
#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'bytes
强转成二进制
>>> bytes('asd',encoding='gbk')
b'asd'bytearray
byte类型的数组
ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))
44430400
97
bytearray(b'Alex')
44430400memoryview
函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))
6
你
好ord
ord()函数主要用来返回对应字符的ascii码
print(ord('a'))
97chr
，chr()主要用来表示ascii码对应的字符他的输入时数字，可以用十进制，也可以用十六进制。
print(chr(97))
'a'ascii
返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x，\u或\U等字符来表示。与python2版本里的repr()是等效的函数。
>>> ascii(1)
'1'
>>> ascii('&')
"'&'"
>>> ascii(9000000)
'9000000'
>>> ascii('中文') #非ascii字符
"'\\u4e2d\\u6587'"repr
尽管str(),repr()和运算在特性和功能方面都非常相似，事实上repr()和做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象。
尽管str(),repr()和运算在特性和功能方面都非常相似，事实上repr()和做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象。
但str()则有所不同，str()致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值，但很适合用于print语句输出。需要再次提醒的是，并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象。 也就是说 repr() 输出对 Python比较友好，而str()的输出对用户比较友好。
尽管str(),repr()和运算在特性和功能方面都非常相似，事实上repr()和做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象。
但str()则有所不同，str()致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值，但很适合用于print语句输出。需要再次提醒的是，并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象。 也就是说 repr() 输出对 Python比较友好，而str()的输出对用户比较友好。
虽然如此，很多情况下这三者的输出仍然都是完全一样的。 大家可以看下下面的代码，来进行对比
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.10000000000000001'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"数据集合
dict
强转成字典
set
强转成集合
frozenset
#改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})
扫一扫
536
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
