函数(六)---内置函数

六、内置函数

截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。在「 6.1 内置函数列表 」中的顺序是按照首字母的排列顺序来的。它们就是python提供给你直接可以拿来使用的所有函数。

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

6.1 内置函数列表

你会发现都混乱的堆在一起的68个函数，它们就是python提供给你直接可以拿来使用的所有函数。

Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	import()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

在「杂乱无序」的时候，我们「分门别类」的学习，会「事半功倍」的

6.2. 作用域相关

1. globals()、locals()

'''
    # 基于字典的形式获取局部变量和全局变量
  globals()  获取全局变量的字典
  locals(）  获取执行本方法所在命名空间内的局部变量字典
'''

6.3. 迭代器、生成器

1.  range()、next()、iter()

# 实例 01. range 不是一个可迭代对象
print('__next__' in dir(range(1,10)))
# False

6.4. 其它

1. 查询方法：dir()

一个查询方法，获得一个对象所具备的方法列表，不长写在代码中，常用来获取帮助，判断

2. 帮助：help()

帮助函数，没有返回值，函数直接打印

help(str)
# 获取和 str 相关的使用方法

3. 调用相关：callable()

拿过来一个名字，判断一个函数是否能够被调用

# 只能看函数，不能看关键字

print(callable(print))    # True
a = 1
print(callable(a))        # False

4. 模块相关：import()  缺

5. 文件操作相关：open()

文件相关

6. 内存相关：id()、hash()

hash：把可 hash 的数据转换成一串数字

7. 输入输出 input()、print()

print()语法

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """

实操

每一次 print 自动换行

'''
    # 指定结尾符号
    print('print 01',end='\n\n')

    # 指定输出多个值之间的分隔符
    print(1,2,3,4,5,sep='_%_')

    # 指定打印内容到文件句柄
    f = open('aa.txt','w')
    print('print 03',file=f)
'''

提高：打印进度条

import time
for i in range(0,101,2):  
     time.sleep(0.1)
     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 可以把光标移动到行首但不换行
# progress Bar 模块

8. 字符串类型代码的执行：eval()、exec()、single、compile

# 相同之处
exec("print(123,'by exec')")
eval("print(123,'by eval')")
# 123 by exec
# 123 by eval

# 不同之处
print(eval('1+2+3+4'))   #  10 , 返回结果
print(exec('1+2+3+4'))   #  None , 没有返回值

'''
    exec 和 eval 都可以执行字符串类型的代码
    适用场景：
    eval：
        - 只能用在你明确知道你要执行的代码是什么
      - 有结果的简单计算
    exec:
        - 没有返回结果
      - 简单流程控制
'''

 实例：exec()

# 实例 01
code = '''
for i in range(10):
    print(i*'*')
'''
exec(code)

9. compile

将字符串类型的代码编译。diamante 对象能够通过 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 ，流程
code1 = 'for i in range(0,3):print(i)'
comple1 = compile(code1,'','exec')
exec(comple1)

# eval ，计算
code1 = '1+2+3+4'
comple1 = compile(code1,'','eval')

print(eval(comple1))

# single ，交互
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')

exec(compile3)
print(name)

6.5. 基础数据类型——数字相关（14）

'''
  数据类型相关：bool,int,float,complex
    - 只在数据类型强制转换时使用
  
    进制转换相关：bin，oct，hex
    - 
 
    数学运行：abs，divmod，min，max，sum，round，pow
'''

1. divmod() 除余

网站内容分页
print(divmod(7,2))
(3, 1)   # 结果

2. round() 小数精确

3. pow() 幂运算

4. sum() 和

5. min() 最小值

# 根据特定条件，查找值
print(min(1,2,3,-4,key=abs))

6. max() 最大值

print(max(1,2,3,-4,key=abs))

6.6. 基础数据类型——和数据结构相关

1. 序列相关 list、tuple

2. reversed() 反转

'''
    list:
  tuple:
'''
# reversed()  获得一个逆序列表迭代器,不修改原列表
l = [1,2,3,4,5]
print(type(reversed(l)))    # <class 'list_reverseiterator'>
print(list(reversed(l)))    # [5, 4, 3, 2, 1]

l.reverse()   # 直接修改原列表，可以用这个方法

3. slice() 生成切片规则

l = (1,2,3,23,213,24,54,98)
sli = slice(1,5,2)
# 调用定义的切片规则
print(l[sli])

# 直接切片
print(l[1:5:2])

5.2 字符串相关

str	format	bytes
bytearray	memoryview	ord
chr	ascii	repr

1. format() 

'''
    1. 将一个数值进行格式化显示。
  2. 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。
  3. 对于不同的类型，参数format_spec可提供的值都不一样
'''

# 1,2
print(type(format(1)))

'''
    格式化输出
'''

#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
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'

2. bytes()

'''
    应用场景：
        1. 网络编程
    2. 文件存储
    3. 照片和视频也是二进制存储的
    4. html 网页爬取到的也是
'''

# 2. unicode 转换
print(bytes('你好',encoding='GBK'))
print(bytes('你好',encoding='utf-8'))

print(bytes('你好',encoding='GBK').decode('GBK'))
print(bytes('你好',encoding='utf-8').decode('utf-8'))

# 1：把gbk 编码的你好，重新编译成 utf-8
a = bytes('你好',encoding='GBK')
b = a.decode('GBK')
c = bytes(b,encoding='utf-8')
d = c.decode('utf-8')
print(a,b,c,d)

3. bytearray()

'''
    byte 类型的一个数组
    - 修改的时候，可以修改字节，比较麻烦
    - 在修改字符串的时候，转换成字节的形式，可以节省内存
'''

b_array = bytearray('你好',encoding='utf-8')
print(b_array)
print(b_array[0])

4. memoryview()

编码转换

'''
    ord：字符按照 unicode 转数字
  chr：数字按照 unicode 转字符
  ascii：是 ascii 码的输出原始内容，不是的输出一个byte串
'''

print(ascii('你'))
print(ascii('a'))

5. repr()  暂缺

把准备输出的内容，原封不动的打印出来，和字符串格式和输出中的%r等价

5.3 数据集合 dict()、set()、forzenset()

5.3 相关内置函数

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

1. all()、any()

判断可迭代对象，是否存在 bool 值为 False 
**

# all  有一个是假，--> False
print(all(['a','',123]))
print(all(['a',123]))
print(all([0,123]))

# any  有一个为真， --> True
print(any(['a','',123]))
print(any(['a',123]))
print(any([0,123]))

2. zip() 拉链函数

l = [1,2,3]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':2,'k2':3}

for i in zip(l,l2,l3,d):
    print(i)

输出结果：
''' 
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')
'''

# 结论：
    1. 以最小单元为基准，一次聚合成一列表，每一项是一个元组
  2. 字典以 key 聚合

3. filter() 、map()

过滤函数，根据函数条件来判断可迭代对象是否满足，返回 bool 值，为真时新增至一个迭代器

'''
    filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
    filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
'''
def is_odd(x):
    return x %2 == 1

l = filter(is_odd,[1,3,4,6,7,9,12,17])
print(list(l))
# 把可迭代的每一个值，当做参数，传入到函数中，根据返回的结果(bool)确认是不是在删选的范围之内
# 循环可迭代内容，做判断，True 组成一个新的可迭代器

# 等价于 如下列表推导式
# [i for i in [1,3,4,6,7,9,12,17] if i %2 == 1]


# 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
    return s and len(s.strip()) > 0
print(list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])))

# map 函数
ret = map(abs,[-1,4,-5,8])
print(ret)
for i in ret:
    print(i)
# 把可迭代的值，一次通过 abs 来执行，返回一个迭代器地址

'''
小结：
    filter
    - 执行了 fileter 之后的结果 <= 执行之前的个数，
    - filter 只管筛选，不会改变原来的值，截取一部分
  map()
    - 执行前后元素个数不变
    - 值可能发生改变
'''

4. sorted()

排序方法，保留原列表

# 生成一个新的列表，开辟新的内存空间
l = [1,-3,5,6,-9]
print(sorted(l),l,sorted(l,reverse=True))  
# [-9, -3, 1, 5, 6] [1, -3, 5, 6, -9][6, 5, 1, -3, -9]

print(sorted(l,key=abs,reverse=True))  # 根据绝对值，从大到小排列，key = 排序规则
# [-9, 6, 5, -3, 1]

'''
练习题 01：根据裂变元素的长度排序
    # l = ['sdf',{'ssdf':123,'a':3}]
    # print(sorted(l,key=len))   # 有问题，数字不能进行排序

    l = [1,112,'sd3f',{'ssdf':123,'a':3},(1,2,3,4)]
    def func(x):
       if type(x) == int or type(x)==bool or type(x) == float or type(x) ==complex:
           return len(str(x))
       else:
          return len(x)
    print(sorted(l,key=func,reverse=True))
'''

# 在元列表的基础上进行排序，列表的排序方法
l = [1,-3,5,6,-9]
l.sort()  
print(l)
l.sort(key=abs)
print(l)

转载于:https://www.cnblogs.com/liudianer/p/10495605.html