Python之路：（八）内置函数

一、内置函数

python内置了很多简单实用的内置函数，日常工作中会很常用到这些函数，通过这些内置函数能够提高代码得简洁性，节省工作量。

 

内置函数abs()取绝对值

print(abs(-10))

10

 

all()所有为真,结果才为真

print(all([1, 2, 3, None]))

False

 

any()只要有真,结果就为真

print(any([[], 0, "", 1]))

True 

 

bool() 求布尔值

print(bool(1))
print(bool(None))

True
False

 

进制转换

# bin() 转换2进制  0b
print(bin(10))

# oct() 转换8进制  0o
print(oct(10))

# hex() 转换16进制 0x
print(hex(10))

0b1010
0o12
0xa

 

bytes()字符转换成字节

s = "梁"
n = bytes(s, encoding="utf-8")
print(n)

b'\xe6\xa2\x81'

 

str()字节转换字符串

s = "梁"
n = bytes(s, encoding="utf-8")
print(n)
new_str = str(n, encoding="utf-8")
print(new_str)

b'\xe6\xa2\x81'
梁

 

ascii 转换

r = chr(65)  # 输入数字返回ascii中对应的的字符
print(r)

s = ord('A')  # 输入字符返回ascii中对应位置
print(s)

A
65

 

random()生成随机码

import random
li = []
for i in range(11):
    r = random.randrange(0, 5)
    if r == 2 or r == 4:
        item = random.randrange(0, 10)
        li.append(str(item))
    else:
        item = random.randrange(65, 91)
        c = chr(item)
        li.append(c)

result = "".join(li)
print(result)

B3LJAY3ZXR3

 

compile() 编译, single,eval,exec，将字符串编译成python代码执行,可以是string or file，

# compile() # 编译, single,eval,exec
# 将字符串编译成python代码,可以接受string or file
s = "print(123)"
r = compile(s, "<string>", "exec")
#执行代码,接收代码和字符串都能执行,没有返回值
print(r)
ret = exec(r)  # exec() 执行python的代码

<code object <module> at 0x104e45930, file "<string>", line 1>
123

 

eval()执行表达式,并返回结果

# eval()执行表达式,并返回结果
s = "8*8"
ret = eval(s)
print(ret)

64

 

dir()快速查看类为对象提供了哪些功能

print(dir(list))

 

help()看源码帮助信息

help(list)

 

 divmod()求商和余数

# divmod()求商和余数
r = divmod(97, 10)
print(r)

(9, 7)

 

isinstance()判断对象,对象是否是某个类的实例

# isinstance()判断对象,对象是否是某个类的实例
s = [1,2,3,22]
r = isinstance(s, list)
print(r)

True

 

 

filter()对于序列中的元素进行筛选，最终获取符合条件的序列

# filter() 过滤条件
# filter # 函数返回True,将元素添加到结果中
# filter(函数,可迭代的对象)
# filter内部迭代第二个参数
# result = []
# for item in 第二个参数:
#     r = 第一个参数(item)
#     if r :
#         result.append(item)
# return result
# filter ,循环第二个参数,让每个循环元素执行函数,如果函数返回True,表示元素合法
def f2(num):
    if num > 22:
        return True

li = [11, 22, 33, 44, 55, ]

ret = filter(f2, li)
print(list(ret))

# 简写
li = [11, 22, 33, 44, 55]
result = filter(lambda num: num > 33, li)
print(list(result))

[33, 44, 55]
[44, 55]

 

 

map()遍历序列，对序列中每个元素进行操作，最终获取新的序列。

# map()  迭代操作
# map()  # 将函数retrun,放到结果中
li = [11, 22, 33, 44, 55]

# map(函数,可迭代的对象(可以for循环的东西))
def f2(a):
    return a + 100

result = map(f2, li)
print(list(result))

# 简写
# result = map(lambda a: a + 100, li)

[111, 122, 133, 144, 155]

 

locals()   # 代表所有局部变量
globals()  # 代表所有全局变量

 

len()取字符串和子节长度,在python3中len()取的是字符的长度

# len()取字符串和子节长度,在python3中len()取的是字符的长度
s = "阿飞"
print(len(s))

b = bytes(s, encoding='utf-8')
print(len(b))

2
6

 

max() min() sum() 分别求最大,最小,求和.

# max() min() sum() 分别求最大,最小,求和.
print(max([11,22,33]))
print(min([11,22,33]))
print(sum([11,22,33]))

33
11
66

 

pow() 幂运算

# pow() 幂运算
print(2**10)
print(pow(2, 10))  

1024
1024

 

reversed()方法反转序列

# reversed()方法反转序列
l = [11, 22, 33, 44]
print(list(reversed(l)))  # 反转,和list的reverse方法一样
print(list(reversed("liang")))
l.reverse()
print(l)

[44, 33, 22, 11]
['g', 'n', 'a', 'i', 'l']
[44, 33, 22, 11]

 

zip() 拉链,交叉,不相等长不互补,多余的丢弃

# zip() # 拉链,交叉,不相等长不互补,多余的丢弃
l = [11, 22, 33, ]
l1 = ['aa', 'bb', 'cc', 'dd', 'ee', ]
print(list(zip(l, l1)))

[(11, 'aa'), (22, 'bb'), (33, 'cc')]

 

sorted() 排序

# sorted() 排序
l = [3,2,1,4,5,6,9,]
l1 = sorted(l)
print(l1)

[1, 2, 3, 4, 5, 6, 9]

 

round() 四舍五入

# round() 四舍五入
print(round(1.8))

2

 

format() 高级字符串格式化

Python的字符串格式化有两种方式: 百分号方式、format方式

百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。[PEP-3101]

This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing '%' string formatting operator.

[[fill]:align][sign][#][0][width][,][.precision][type]

• fill           【可选】空白处填充的字符
• align        【可选】对齐方式（需配合width使用）
• <，内容左对齐
• >，内容右对齐(默认)
• ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
• ^，内容居中
• sign         【可选】有无符号数字
  • +，正号加正，负号加负；
  •  -，正号不变，负号加负；
  • 空格 ，正号空格，负号加负；
• #            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• ，            【可选】为数字添加分隔符，如：1,000,000
• width       【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type         【可选】格式化类型
• 传入” 字符串类型 “的参数
  • s，格式化字符串类型数据
  • 空白，未指定类型，则默认是None，同s
• 传入“ 整数类型 ”的参数
  
  • b，将10进制整数自动转换成2进制表示然后格式化
  • c，将10进制整数自动转换为其对应的unicode字符
  • d，十进制整数
  • o，将10进制整数自动转换成8进制表示然后格式化；
  • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
  • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
• 传入“ 浮点型或小数类型 ”的参数
• e， 转换为科学计数法（小写e）表示，然后格式化；
• E， 转换为科学计数法（大写E）表示，然后格式化;
• f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
• F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
• g， 自动在e和f中切换
• G， 自动在E和F中切换
• %，显示百分比（默认显示小数点后6位）

更多格式化操作：https://docs.python.org/3/library/string.html

 

常用例子：

# 没有指定格式化规则,默认按照参数顺序填充
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')

# format方法采用动态参数,接受序列参数*[]遍历序列传递
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])  

# 指定格式化参数位置
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)   
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])

# 指定格式化名称,参数以key-value形式传递,对应指定名称传递参数
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)  

# format方法采用动态参数,接受序列参数**{}遍历序列传递
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})  

# 参数序列索引传递
tpl = "i am {0[0]}, age {0[1]}, really {1[2]}".format([1, 2, 3], [11, 22, 33])   

# 指定格式化类型
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)                  
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})

# 格式化类型
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)  
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

# 宽度30字符居中,用"-"填充
tpl = "{:-^30}".format("居中")