Python 内置方法

数学运算

• abs：求数值的绝对值

def func(x,y,f):
    return f(x)+f(y)
print(func(-1,9,abs))

#输出结果：10

• divmod：地板除（返回两个数值的商和余数）

print(divmod(5,2))

#输出结果：(2, 1)

• max：返回可迭代对象中的元素的最大值或者所有参数的最大值

print(max([2,3,4,5,6,7]))
print(max([1,2],[2,3],[3,4]))
a=[3,4,5,6,7,8,9,10,11]
print(a.index(max(a)))        #index为元素下标，输出最大值所对应的元素下标
print(max("aa","ab","ac"))    #按ASCII码中的数值大小
print(max(-1,0,key=abs))      #abs为绝对值参数
print(max(1,2,3,"4",key=int)) #转为int型进行比较


#输出结果：7
#输出结果：[3,4]
#输出结果：8
#输出结果：ac
#输出结果：-1
#输出结果：4

• min：返回可迭代对象中的元素的最小值或者所有参数的最小值

print(min([2,3,4,5,6,7]))
print(min([1,2],[2,3],[3,4]))
a=[3,4,5,6,7,8,9,10,11]
print(a.index(min(a)))        #index为元素下标，输出最小值所对应的元素下标
print(min("aa","ab","ac"))    #按ASCII码中的数值大小
print(min(-1,0,key=abs))      #abs为绝对值参数
print(min(1,2,3,"4",key=int)) #转为int型进行比较

#输出结果：2
#输出结果：[1,2]
#输出结果：0
#输出结果：aa
#输出结果：0
#输出结果：1

• pow：返回两个数值的幂运算值或者其与指定整数的余数值

print(2**3)
print(pow(3,3))     #3**3
print(pow(2,3,3))   #2**3%3

#输出结果：8
#输出结果：27
#输出结果：2

• round：对浮点数进行四舍五入求值

print(round(1.734567))    #取四舍五入的值
print(round(1.234565,3))  #四舍五入取三位

#输出结果：2
#输出结果：1.235

• sum：对元素类型是数值的可迭代对象中的每个元素求和

a = sum((1,2,3,4))
print(a)

#输出结果：10

类型转换

• bool：根据传入参数创建布尔值

print(bool([1]))
print(bool([8]))

#输出结果：True
#输出结果：True

• int：根据传入参数创建一个新的整数

a = int()
print(a)
b = int("3")
print(b)
c = int(3.2)
print(c)

#输出结果：0
#输出结果：3
#输出结果：3

• float：根据传入的参数创建一个新的浮点数

a = float()
print(a)
b = float("3")
print(b)
c = float(4)
print(c)

#输出结果：0.0
#输出结果：3.0
#输出结果：4.0

• complex：根据传入参数创建一个新的复数

a = complex()
print(a)
b = complex(1,2)
print(b)
c = complex("1+2j")
print(c)

#输出结果：0j
#输出结果：(1+2j)
#输出结果：(1+2j)

• str：返回一个对象的字符串表现形式（给用户）

print(str(12))
print(type(str(12)))

#输出结果：12       '''在cmd中以'12'输出'''
#输出结果：<class 'str'>

• bytes：根据传入参数创建一个新的不可变字节数组

a = bytes("abcdef",encoding="utf-8")
print(a)
b = bytes("栗子",encoding="utf-8")
print(b)

#输出结果：b'abcdef'
#输出结果：b'\xe6\xa0\x97\xe5\xad\x90'

• bytearray：根据传入的参数创建一个新的字节数组

b = bytearray("abcdef",encoding="utf-8")
print(b[0])
print(b)

#输出结果：97
#输出结果：bytearray(b'abcdef')

• memoryview：根据传入的参数创建一个新的内存查看对象

a = memoryview(b"abcde")
print(a)
print(a[-1])

#输出结果：<memory at 0x000001D79E53A348>
#输出结果：101

• chr：返回整数所对应的Unicode字符

print(chr(97))
print(chr(165))

#输出结果：a
#输出结果：¥

• ord：返回Unicode字符所对应的ASCII码数

print(ord("b"))
print(ord("A"))

#输出结果：98
#输出结果：65

• bin：将整数转换成二进制字符串

print(bin(8978))
print(type(bin(8978)))

#输出结果：0b10001100010010
#输出结果：<class 'str'>

• oct：将整数转换成八进制字符串

print(oct(8978))
print(type(oct(8978)))

#输出结果：0o21422
#输出结果：<class 'str'>

• hex：将整数转换成十六进制字符串

print(hex(89))
print(type(hex(89)))

#输出结果：0x59
#输出结果：<class 'str'>

• tuple：根据传入的参数创建一个新的元组

a = tuple()
print(a)
b = tuple("12345")
print(b)

#输出结果：()
#输出结果：('1', '2', '3', '4', '5')

• list：根据传入的参数创建一个新的列表

a = list()
print(a)
b = list("12345")
print(b)

#输出结果：[]
#输出结果：['1', '2', '3', '4', '5']

• dict：根据传入的参数创建一个新的字典

a = dict()
print(a)
b = dict((("1",1),("2",2)))
print(b)
c = dict((["a","b"],[1,2]))
print(c)

#输出结果：{}
#输出结果：{'1': 1, '2': 2}
#输出结果：{'a': 'b', 1: 2}

• frozenset：根据传入的参数创建一个新的不可变集合

a=frozenset([2,3,4])
print(a)
# a[2]="aaa" #TypeError: 'frozenset' object does not support item assignment

#输出结果：frozenset({2, 3, 4})

• set：根据传入的参数创建一个新的集合

a = set()
print(a)
b = set(range(10))
print(b)
c = set("ab12")
print(c)

#输出结果：set()
#输出结果：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
#输出结果：{'1', '2', 'b', 'a'}

• enumerate

1. 在字典上是枚举、列举的意思；
2. 参数为可遍历|可迭代的对象（如列表、字符串）；
3. 多用于在for循环中的得到计数，利用它可以同时获得索引和值，即需要index和value值的时候可以使用enumerate；
4. 根据可迭代对象创建枚举对象，返回的是一个enumerate对象；
5. 格式：

　　enumerate（sequence，[start = 0]）

• sequence —— 一个序列，迭代器或其他支持迭代对象
• start —— 下标的起始位置

例1：

'''enumerate用法'''
l = ["you","are","a","pig"]
for index,item in enumerate(l,1):
    print(index,item)

#输出结果：
'''
1 you
2 are
3 a
4 pig
'''

例2：

color = ["red","green","yellow","bule"]
print(list(enumerate(color)))
print(list(enumerate(color,start=2)))

#输出结果：[(0, 'red'), (1, 'green'), (2, 'yellow'), (3, 'bule')]
#输出结果：[(2, 'red'), (3, 'green'), (4, 'yellow'), (5, 'bule')]

通过上述实例可知，通过enumerate可以自增一列序号，并且起始位置可以通过start指定任意所需值，避免了下标从0开始的局限性。

序列操作

• all：判断可迭代对象的每个元素是否都为True值

print(all(["jfdks",2,3,1]))
print(all([0,3,1]))       #列表中0的逻辑值为False

#输出结果：True
#输出结果：False

• any：判断可迭代对象的元素是否有为True值的元素

print(any([37,0,3]))    #有一个为True则全为True
print(any([0,0]))         #全为False时才为False

#输出结果：True
#输出结果：False

• sorted：对可迭代对象进行排序，返回一个新列表

a={1:2,3:4,9:2,8:6}
print(sorted(a.items()))       #以键的大小为排序对象
print(sorted(a.items(),key=lambda x:x[1]))    #以值的大小为排序对象

#输出结果：[(1, 2), (3, 4), (8, 6), (9, 2)]
#输出结果：[(1, 2), (9, 2), (3, 4), (8, 6)]

• filter

 

1. filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个可迭代对象，这个函数 f 的作用是对每个元素进行判断；
2. f返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素；
3. 使用指定方法过滤可迭代对象元素；

例1：输出9以内满足n>5的数

#filter,将满足情况的项输出
ve=filter(lambda n:n>5,range(10))
for i in ve:
    print(i)

#输出结果：6
#输出结果：7
#输出结果：8
#输出结果：9

• map

 

1. map()是 Python内置的高阶函数，它接收一个函数f和列表或元组对象,并通过把函数f依次作用在列表或元组的每个元素上。
2. 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象。
3. 返回值

• Python 2.x 返回列表
• Python 3.x 返回迭代器

例1：将原有列表通过map的方法，使其元素输出平方值。

 

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# def f(x):
#     return x**2
#a = map(f,l)
a = map(lambda i:i**2,l) #等价于def
print(a)
#输出结果：
'''
<map object at 0x000001B1539144A8>
迭代器的形式，并非真值
'''

for i in a:
    print(i)
#利用for循环可以打印出所需的值
#输出结果：
'''
1
4
9
16
25
36
49
64
81
'''

 

例2：将下列中不规范的姓名，规范化，即首字母大写。

def format(s):
    s1=s.title()
    return s1

a = map(format, ['LIZI', 'yin', 'bob'])
for i in a:
    print(i)
    
#输出结果：
'''
Lizi
Yin
Bob
'''

例3：判断True或False

#map，将判断结果输出
re=map(lambda n:n>5,range(3))
for i in re:
    print(i)

#输出结果：False
#输出结果：False
#输出结果：False

PS：lambda函数是一种快速定义单行的最小函数，是从 Lisp 借用来的，可以用在任何需要函数的地方 。lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。  lambda 函数不能包含命令，包含的表达式不能超过一个。使用lambda函数来定义更加精简灵活，还可以直接把函数赋值给一个变量，用变量名来表示函数名。

• zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

a=[1,2,3,4]
b=[5,6,7,8]
for i in zip(a,b):
    print(i)

#输出结果：(1, 5)
#输出结果：(2, 6)
#输出结果：(3, 7)
#输出结果：(4, 8)

a=[1,2,3]
b=[5,6,7,8]
for i in zip(a,b):
    print(i)

#输出结果：(1, 5)
#输出结果：(2, 6)
#输出结果：(3, 7)

c=[[1,2,3],[4,5,6],[7,8,9]]
for i in zip(*c):
    print(i)

#输出结果：(1, 4, 7)
#输出结果：(2, 5, 8)
#输出结果：(3, 6, 9)

对象操作

• dir：返回对象或者当前作用域内的属性列表

print(dir([]))

#输出结果：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

• id：返回对象的唯一标识符

a = "lizi"
print(id(a))

#输出结果：2269288752104

• hash：获取对象的哈希值

print(hash("a"))

#输出结果：4677843747549717534

• type：返回对象的类型，或者根据传入的参数创建一个新的类型

print(type(1))

#输出结果：<class 'int'>

• ascii：返回对象的可打印表以字符串形式输出

a = ascii(12)
print(a)
print(type(a))

#输出结果：12
#输出结果：<class 'str'>

反射操作

• isinstance：判断对象是否是类或者类型元组中任意类元素的实例

a=1
print(isinstance(a,int))
print(type(1))

#输出结果：True
#输出结果：<class 'int'>

type和isinstance的区别：

1. type不认为子类是一种父类类型，不考虑继承
2. isinstance会认为子类是一种父类类型，考虑继承
3. 如果需要判断两种类型的关系，建议使用isinstance

• callable：检测对象是否可被调用

def func(x,y,f):
    return f(x)+f(y)
print(callable(func))

#输出结果：True

变量操作

• locals：返回当前作用域内的局部变量和其值组成的字典

def A():
    varse=234
    print(locals())   #打印局部变量
print(A())

#输出结果：{'varse': 234}
#输出结果：None

• globals：返回当前作用域内的全局变量和其值组成的字典

def A():
    varse=2347
    print(globals())  # 返回本模块中所有的全局变量
print(A())

#输出结果：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F73AA56080>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/lenovo/Documents/WeChat Files/qian414414/Files/内置方法(1).py', '__cached__': None, 'A': <function A at 0x000001F738EEC1E0>}

#输出结果：None