Python3基础-内置函数

1、abs(n)

函数返回数字的绝对值 

参数n可以是整数,浮点数,复数

print(abs(10)) #n为正数   输出10
print(abs(-10)) #n为负数  输出10
print(abs(-10.12)) #n为浮点数  输出10.12

2、all()

函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False。

元素除了是 0、空、None、False 外都算 True。

参数--》元组或列表

#列表、字符串为例
print("列表都不为空或0",all([a,b,c,d]))
print("列表存在一个为空的元素",all([a,b,‘‘,d]))
print("列表存在一个为0的元素 ",all([0,1,23,]))
print("列表存在一个为True的元素 ",all([2,1,23,True]))
print("列表存在一个为False的元素",all([2,1,23,False]))
print("列表存在一个空格的元素",all([a,b, ,d]))
print("列表存在一个\\n的元素",all([a,b,\n,d]))
print("列表存在一个\\t的元素",all([a,b,\t,d]))
print("空列表",all([]))
"""
执行结果
列表都不为空或0 True
列表存在一个为空的元素 False
列表存在一个为0的元素  False
列表存在一个为True的元素  True
列表存在一个为False的元素 False
列表存在一个空格的元素 True
列表存在一个\n的元素 True
列表存在一个\t的元素 True
空列表 True
"""

3、any()

用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE

print("元祖都不为空或0",any((a,b,c,d)))
print("元祖存在一个为空的元素",any((a,b,‘‘,d)))
print("元祖存在一个为0的元素 ",any((0,1,23,)))
print("元祖存在一个为True的元素 ",any((2,1,23,True)))
print("元祖存在一个为False的元素",any((2,1,23,False)))
print("元祖存在一个空格的元素",any((a,b, ,d)))
print("元祖存在一个\\n的元素",any((a,b,\n,d)))
print("元祖存在一个\\t的元素",any((a,b,\t,d)))
print("空列表",any(()))
print("元祖的元素全部为空",any((‘‘,‘‘)))
print("元祖的元素全部为False",any((False,)))
print("元祖的元素全部为0",any((0,)))
print("元祖的元素全部为True",any((True,)))
print("元祖的元素全部为空、0、False",any((0,‘‘,False)))
"""
执行结果
元祖都不为空或0 True
元祖存在一个为空的元素 True
元祖存在一个为0的元素  True
元祖存在一个为True的元素  True
元祖存在一个为False的元素 True
元祖存在一个空格的元素 True
元祖存在一个\n的元素 True
元祖存在一个\t的元素 True
空列表 False
元祖的元素全部为空 False
元祖的元素全部为False False
元祖的元素全部为0 False
元祖的元素全部为True True
元祖的元素全部为空、0、False False
"""

4、bin()、hex()、oct()

 bin() 返回一个整数 int 或者长整数 long int 的二进制表示。  参数 -- int 或者 long int 数字

print(bin(20))
print(bin(30))

"""
执行结果
0b10100
0b11110
"""

hex()用于将一个指定数字转换为 16 进制数

print(hex(20))
print(hex(10))
"""
执行结果
0x14
0xa
"""

oct() 函数将一个整数转换成8进制字符串

print(oct(10))
print(oct(20))
"""
执行结果
0o12
0o24
"""

5、bool()

用于将给定参数转换为布尔类型,如果没有参数,返回 False。

#空字符串、空列表、空元祖、空字典、None、0、False的布尔值为False,其余为Frue
print(bool(‘‘))
print(bool(0))
print(bool(None))
print(bool(False))
print(bool([]))
print(bool(()))
print(bool({}))
"""
执行结果
False
False
False
False
False
False
False
"""

6、bytes ()

返回一个新的 bytes 对象,该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

print(bytes(1)) #正数,则返回一个长度为1的初始化数组  b‘\x00‘
print(bytes(2)) #正数,则返回一个长度为2的初始化数组  b‘\x00\x00‘
print(bytes(3)) #正数,则返回一个长度为3的初始化数组  b‘\x00\x00\x00‘
print(bytes(A,ascii)) #字符串  按照指定的 ascii 将字符串转换为字节序列 b‘A‘
#print(bytes(‘你好‘,‘ascii‘)) #报错,因为UnicodeEncodeError: ‘ascii‘ codec can‘t encode characters in position 0-1: ordinal not in range(128)
print(bytes(你好,encoding=utf-8)) #hello 根据utf-8进行编码 b‘\xe4\xbd\xa0\xe5\xa5\xbd‘
print(bytes(你好,encoding=utf-8).decode(utf-8)) #编码后解码 你好
print(bytes(你好,encoding=GBK))   #b‘\xc4\xe3\xba\xc3‘
print(bytes(你好,encoding=GBK).decode(GBK))  #你好
#print(bytes(‘hello‘))#没有指定encoding;则会报错TypeError: string argument without an encoding

print(bytes([1,2,3,4]))
#print(bytes([‘a‘,2,3,4]))#报错 TypeError: ‘str‘ object cannot be interpreted as an integer
#print(bytes([1,2,3,256]))#报错 ValueError: bytes must be in range(0, 256)
"""
可迭代类型,则元素必须为[0 ,255] 中的整数;
"""
print(bytes())#没有输入任何参数,默认就是初始化数组为0个元素

7、chr()、ord()

用一个整数作参数,返回值是当前整数对应的 ASCII 字符。。

参数-- 可以是 10 进制也可以是 16 进制的形式的数字,数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。

#print(chr())#TypeError: chr() takes exactly one argument (0 given)
#print(chr(‘a‘)) #TypeError: an integer is required (got type str)
print(chr(97)) #输出a
print(chr(0x30)) #输出0

ord() 函数是 chr() 函数(对于 8 位的 ASCII 字符串)的配对函数,它以一个字符串(Unicode 字符)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值

print(ord(a))
print(ord(~))
"""
执行结果
97
126
"""

8、dir()、help()

dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

print(dir())  #获取当前模块的属性列表

“”“
执行结果
[__annotations__, __builtins__, __cached__, __doc__, __file__, __loader__, __name__, __package__, __spec__]

”“”
print(dir(all))#获取all模块的属性列表
"""
执行结果
[‘__call__‘, ‘__class__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__le__‘, ‘__lt__‘, ‘__module__‘, ‘__name__‘, ‘__ne__‘, ‘__new__‘, ‘__qualname__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__self__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘__text_signature__‘]
"""

 help()查看函数或模块用途的详细说明

print(help(all))
"""
Help on built-in function all in module builtins:

all(iterable, /)
    Return True if bool(x) is True for all values x in the iterable.
    
    If the iterable is empty, return True.

None
"""

 

9、divmod()函数

divmod() 函数接收两个数字类型(非复数)参数,返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(3,8)) #参数 a 与 参数 b 都是整数;返回的结果相当于 (a // b, a % b)
print(divmod(8,3)) #
print(divmod(8.5,3)) #其中一个参数为浮点数时,函数返回的结果相当于 (q, a % b),q 通常是 math.floor(a / b),
print(divmod(8,3.5))
print(divmod(-8,3.5))#,若 b 是正数,余数为正数,若 b 为负数,余数也为负数
print(divmod(8,-3.5))
print(divmod(-8,-3.5))
"""
执行结果
(0, 3)
(2, 2)
(2.0, 2.5)
(2.0, 1.0)
(-3.0, 2.5)
(-3.0, -2.5)
(2.0, -1.0)
"""
注意: “/”和“//”的区别
1、" / "表示浮点数除法,返回浮点float结果;
2、" // "表示整数除法,返回一个不大于" / "计算结果的最大整数int,---整除 - 向下取接近除数的整数
特别注意如果其中一个操作数位负数,则结果必为负数。

10、enumerate() 函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

lists=[spring,1,2,3,4]
print(list(enumerate(lists)))
print(list(enumerate(lists,start=1))) #小标从1开始
"""
执行结果
[(0, ‘spring‘), (1, 1), (2, 2), (3, 3), (4, 4)]
[(1, ‘spring‘), (2, 1), (3, 2), (4, 3), (5, 4)]
"""

#for循环用enumerate
i = 0
seq = [one,two,3]
for i, element in enumerate(seq):
    print(i,seq[i])
"""
执行结果
0 one
1 two
2 3
"""

11、eval() 函数

用来执行一个字符串表达式,并返回表达式的值。

x=7
print(eval(x**2))
print(eval(x*7))
print(eval(x+x))
express=1+2+3+4+5+6
print(eval(express))
"""
执行结果
49
49
14
21
"""

##############
#字符串转换成列表
str="[1,2,3,4,‘a‘,‘b‘,[9,0]]"
print(type(str))
list_seq=eval(str)
print(list_seq,type(list_seq))
"""
<class ‘str‘>
[1, 2, 3, 4, ‘a‘, ‘b‘, [9, 0]] <class ‘list‘>
"""
#字符串转换成元祖
str="(1,2,3,4,‘a‘,‘b‘,[9,0])"
print(type(str))
list_seq=eval(str)
print(list_seq,type(list_seq))
"""
<class ‘str‘>
(1, 2, 3, 4, ‘a‘, ‘b‘, [9, 0]) <class ‘tuple‘>
"""
#字符串转换成字典
str="{1:‘a‘,2:‘b‘}"
print(type(str))
list_seq=eval(str)
print(list_seq,type(list_seq))
"""
<class ‘str‘>
{1: ‘a‘, 2: ‘b‘} <class ‘dict‘>
"""

12、hash()

可hash的数据类型是不可变数据类型,不可hash的数据类型即可变数据类型

获取取一个对象(字符串或者数值等)的哈希值

hash() 函数可以应用于数字、字符串和对象,不能直接应用于 list、set、dictionary

print(hash(123))
print(hash(123dddddddddddddd))
print(hash(str([1,2,3])))
name = 初九
print("哈哈哈哈",hash(name))
name = "初十"
print("hehhh",hash(name))

13、globals()、locals()、vars()

globals() 函数会以字典类型返回当前位置的全部全局变量

locals() 函数会以字典类型返回当前位置的全部局部变量

name = spring

def test(myname): # # 两个局部变量:myname、age
    age = sususuusussssssssssssssssss
    print(locals())  # # 返回一个名字/值对的字典
    print(globals()) #globals 函数返回一个全局变量的字典,包括所有导入的变量。

test(winner)

"""
执行结果
{‘myname‘: ‘winner‘, ‘age‘: ‘sususuusussssssssssssssssss‘}
{‘__name__‘: ‘__main__‘, ‘__doc__‘: ‘\[email protected]    : Day.py\[email protected]    : 2019/10/15 17:43\[email protected]  : XXX\[email protected]   : [email protected]\[email protected]: PyCharm\n‘, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x00C5C230>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/pyAuto/pythonDay/pythonbase/Day.py‘, ‘__cached__‘: None, ‘name‘: ‘spring‘, ‘test‘: <function test at 0x00C7F7C8>}

"""

vars() 函数返回对象object的属性和属性值的字典对象

name= sss
def test():
    localname=testing
    print(locals())
    print(vars()) #没有参数,作用相当于locals()
test()
print(vars())
"""
执行结果
"""

14、__file__

print(__file__)#获取当前文件的路径
#D:/pyAuto/pythonDay/pythonbase/Day.py

 15、zip()

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

 

seq=[spring,sunner,winner]
seq1=[1,2,3]
seq2=[4,5,6,7,8]
print(zip(seq,seq1))  #返回一个对象
print(list(zip(seq,seq1)))  #list()转换为列表
print(list(zip(seq,seq2)))  #元素个数与最短的列表一致

a1, a2 = zip(*zip(seq,seq1))   #与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
print(a1,a2)
"""
执行结果
<zip object at 0x0124F990>
[(‘spring‘, 1), (‘sunner‘, 2), (‘winner‘, 3)]
[(‘spring‘, 4), (‘sunner‘, 5), (‘winner‘, 6)]
(‘spring‘, ‘sunner‘, ‘winner‘) (1, 2, 3)
"""

print(list(zip("name","my"))) #字符串[(‘n‘, ‘m‘), (‘a‘, ‘y‘)]
print(list(zip((n,1,2,3),[1,2,3]))) #[(‘n‘, 1), (1, 2), (2, 3)]
print(list(zip("name",(1,2)))) #[(‘n‘, 1), (‘a‘, 2)]
print(list(zip({1,2,3},(1,2)))) #[(1, 1), (2, 2)]

seq={name:my,age:29}
print(list(zip(seq.values(),seq.keys())))  #[(‘my‘, ‘name‘), (29, ‘age‘)]

16、max()  min()

max() 方法返回给定参数的最大值,参数可以为序列

min() 方法返回给定参数的最小值,参数可以为序列。

#max函数、min函数处理的可迭代对象,相当于一个for循环去除每个元素进行比较,注意,不同类型之间不能进行比较
print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
#注意点:每个元素间进行比较,是从每个元素的第一个位置一次比较,如果一个位置分出大写,后面的都不需要比较了,之间得出大小
age_dic={age:19,age1:19,age2:29,age3:39}
print(max(age_dic))  #默认比较字典的key
age_dic={age:190,age1:19,age2:29,age3:39}
print(max(age_dic)) # 比较到第四位的时候,3大于其他元素的值,所以仍然输出的是age3

age_dic={age:19,age1:19,wge2:29,age3:39}
print(max(age_dic.values())) #字典key值最大 ,但是不知道对应的key

for item in zip(age_dic.values(),age_dic.keys()):
    print("---------",item)

print(max(zip(age_dic.values(),age_dic.keys())))#结合zip函数找出字典中值最大的

seq=[(5,a),(4,b),(3,e)]
print(max(seq)) #输出的是(5, ‘a‘)
seq=[(5,a),(5,b),(5,e)]
print(max(seq)) #输出的是(5, ‘e‘)

seq1=[12a,10a,20c]
print(max(seq1))

#seq1=[‘12a‘,‘10a‘,‘20c‘,50] #不同类型之间不能进行比较
#print(max(seq1)) ##TypeError: ‘>‘ not supported between instances of ‘int‘ and ‘str‘
"""
注意点
key关键字的作用是,对每个素先使用key指定的function来处理,然后再比较、返回预期的元素。
key参数的值也可以使用自定义函数
"""
测试1-找出列表中age最大的值

#方法一
people=[
    {name:spring,age:100},
    {name:summer,age:1000},
    {name:winner,age:9999}
]

list_age=[]
for item in people:
    for key,value in item.items():
        if key == age:
            list_age.append(value)

print("方法一",max(list_age))
#方法二
list_age=[]
for item in people:
    list_age.append(item[age])

print("方法二",max(list_age))
#print(max(people)) #报错TypeError: ‘>‘ not supported between instances of ‘dict‘ and ‘dict‘

#方法三
print(max(people,key=lambda dic:dic[age]))
#测试2-找出列表中绝对值最大的值
testlist=[9.12,100,-999,20.11]
print(max(testlist,key=abs))
print(max(testlist,key=lambda x:abs(x)))

#自定义方法
def func(n):
    return abs(n)

testlist=[9.12,100,-999,20.11]
print(max(testlist,key=func))

17、pow()

pow() 方法返回 xy(x的y次方) 的值。

print(pow(2,1),pow(2,2),pow(2,3),pow(2,4),pow(2,5))
"""
执行结果
2 4 8 16 32
"""

18、reversed()

reversed 函数返回一个反转的迭代器。参数-- 要转换的序列,可以是 tuple, string, list 或 range

#字符串
seqstr=spring
print(reversed(seqstr)) #<reversed object at 0x00AA0A10>
print(list(reversed(seqstr)))

#列表
seqlist=[1,2,3,4,a,b]
print(reversed(seqlist))
print(list(reversed(seqlist)))

#元祖
seqtup=(1,2,3,4,a,b)
print(reversed(seqtup))
print(list(reversed(seqtup)))

seqrange=range(1,10)
print(reversed(seqrange))
print(list(reversed(seqrange)))

#字典
seqdict={name:susu,age:25,level:}
#print(reversed(seqdict))  #TypeError: ‘dict‘ object is not reversible

#集合
seqset={1,2,3,4,a,b,a}
#print(reversed(seqset)) #TypeError: ‘set‘ object is not reversible
"""
执行结果
<reversed object at 0x00D00A10>
[‘g‘, ‘n‘, ‘i‘, ‘r‘, ‘p‘, ‘s‘]
<list_reverseiterator object at 0x00D009D0>
[‘b‘, ‘a‘, 4, 3, 2, 1]
<reversed object at 0x00D00A30>
[‘b‘, ‘a‘, 4, 3, 2, 1]
<range_iterator object at 0x00CAED40>
[9, 8, 7, 6, 5, 4, 3, 2, 1]
"""

19、 slice() 

slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。

myslice=slice(5) #设置截取5个元素
arr=range(10)
print(arr[myslice]) #输出的是range(0, 5)

seqstr = spring
myslice=slice(2,5) #输出 rin
myslice=slice(8,10) #超出范围,输出为空
print((seqstr[myslice]))

20、sorted()

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:

1、sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
2、list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
分享图片
#测试 sort 与 sorted
seq = [5,4,3,2,1]
print(sorted(seq))  #默认升序
print("查看sorted后的顺序",seq)

print(seq.sort()) #返回为空
print("查看sort后的顺序",seq)

seq={4,3,2,1}
#seq.sort() #会报错 AttributeError: ‘set‘ object has no attribute ‘sort‘
print(sorted(seq)) # sorted() 函数可以接收任何的 iterable
sort和sorted
people=[
    {name:spring,age:100},
    {name:summer,age:1000},
    {name:winner,age:9999}
]

print(根据age从小到大进行排序,sorted(people,key=lambda dict:dict[age]))

seqdict={1: D, 4: E, 3: B, 2: B, 5: A}
print("key排序",sorted(seqdict)) #默认key排序
print("对key的值进行排序",sorted(seqdict.values())) #对key的值进行排序
print("反向进行排序",sorted(seqdict,reverse=True))
"""
执行结果
根据age从小到大进行排序 [{‘name‘: ‘spring‘, ‘age‘: 100}, {‘name‘: ‘summer‘, ‘age‘: 1000}, {‘name‘: ‘winner‘, ‘age‘: 9999}]
key排序 [1, 2, 3, 4, 5]
对key的值进行排序 [‘A‘, ‘B‘, ‘B‘, ‘D‘, ‘E‘]
反向进行排序 [5, 4, 3, 2, 1]
"""

21、__import__()

__import__() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入

test.py文件代码

# -*- encoding: utf-8 -*-

print("哈哈哈哈。我是在test.py中输出")

相同目录下Day.py文件代码

import  os
__import__(test)

执行Day.py文件,输出结果为

哈哈哈哈。我是在test.pyz中输出
相关文章
相关标签/搜索