Python基础学习第十一节 内置函数详解

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python基础学习第十一节 内置函数详解相关的知识,希望对你有一定的参考价值。

Python基础学习之内置函数

Python3.5版本中的68个内置函数,按顺序逐个进行了自认为详细的解析,现在是时候进行个总结了。为了方便记忆,将这些内置函数进行了如下分类:

1. 数学运算(7个)

1.1 abs(),求绝对值

求数值的绝对值

abs(-10)   # 输出:10

1.2 divmod(),求商和余数

求两个数值的商和余数

# divmod
divmod(10 , 3)  # 输出:(3, 1)
divmod(10.1,3)  # 输出:(3.0, 1.0999999999999996)
divmod(-10,4)   # 输出:(-3, 2)

1.3 max(),求最大值

求最大值

max(1,2,3)     # 传入3个参数 取3个中较大者;输出:3
max(1234)    # 传入1个可迭代对象,取其最大元素值;输出:4
max(-1,0)     # 数值默认去数值较大者;输出:0
max(-1,0,key = abs)  # 传入了求绝对值函数,则参数都会进行求绝对值后再取较大者;输出:-1

1.4 min(),求最小值

求最小值

min(1, 2, 3)    # 传入3个参数 取3个中较小的;输出:1
min(1234)     # 传入1个可迭代对象,取其最小元素值;输出:1
min(-1,-2)      # 数值默认去数值较小者;输出:-2
min(-1,-2,key = abs)  # 传入了求绝对值函数,则参数都会进行求绝对值后再取较小者;输出:-1

1.5 pow(),求幂运算

求两个数的幂运算

pow(2, 3)    # 2^3 = 8

1.6 round(),四舍五入

对数值进行四舍五入

round(1.131415926,1)  # 输出:1.1
round(1.131415926,5)  # 输出:1.13142

1.7 sum(),求和

求数值的和

# 传入可迭代对象
sum((1,2,3,4))    # 输出:10
# 元素类型必须是数值型
sum((1.5,2.5,3.5,4.5))    # 输出:12.0
sum((1,2,3,4),-10)    # 输出:0 

2. 类型转换(24个)

2.1 bool(),布尔转换

根据传入的参数的逻辑值创建一个新的布尔值

bool() # 未传入参数;输出:False
bool(0) # 数值0、空序列等值为False;输出:False
bool(1)  # 输出:True

2.2 int(),整型转换

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

int() #不传入参数时,得到结果0;输出:0
int(3) # 输出:3
int(3.6) # 输出:3

2.3 float(),浮点型转换

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

float() # 不提供参数的时候,返回:0.0
float(3)   # 返回:3.0
float(3)    # 返回:3.0

2.4 complex(),复数

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

complex() # 当两个参数都不提供时,返回复数 0j。
complex(1+2j) # 传入字符串创建复数,输出:(1+2j)
complex(1,2) # 传入数值创建复数,输出:(1+2j)

2.5 str(),字符串转换

返回一个对象的字符串表现形式(给用户)

str()  # 返回:
str(None)  # 输出:None
str(abc)    # 输出:abc
str(123)    # 输出:123

2.6 bytearray(),字节数组

根据传入的参数创建一个新的字节数组,不怎么用;

bytearray(中文,utf-8)    # bytearray(b\\xe4\\xb8\\xad\\xe6\\x96\\x87)

2.7 bytes(),不可变字节数组

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

bytes(中文,utf-8)    # b\\xe4\\xb8\\xad\\xe6\\x96\\x87

2.8 memoryview(),内存查看

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

v = memoryview(babcefg)
v[1]    # 输出:98
v[-1]   # 输出:103

2.9 ord(),字符 --> ASC

返回Unicode字符对应的整数

ord(a)    # 输出:97

2.10 chr() ,ASC --> 字符

返回整数所对应的Unicode字符

chr(97)    # 输出:a

2.11 bin(),转换成二进制

将整数转换成2进制字符串

bin(3)  # 输出:0b11

2.12 oct(),转换成八进制

将整数转化成8进制数字符串

oct(10)   # 输出:0o12

2.13 hex(),转换成十六进制

将整数转换成16进制字符串

hex(15)  # 输出:0xf

2.14 tuple(),创建元组

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

tuple()    # 不传入参数,创建空元组; 输出:()
tuple(121)  # 传入可迭代对象。使用其元素创建新的元组;输出: (1, 2, 1)

2.15 list(),创建列表

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

list() # 不传入参数,创建空列表;输出:[] 
list(abcd) # 传入可迭代对象,使用其元素创建新的列表;输出:[a, b, c, d]

2.16 dict(),创建字典

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

dict() # 不传入任何参数时,返回空字典。返回:
dict(a = 1,b = 2) #  可以传入键值对创建字典。返回:b: 2, a: 1
dict(zip([a,b],[1,2])) # 可以传入映射函数创建字典。返回:b: 2, a: 1
dict(((a,1),(b,2))) # 可以传入可迭代对象创建字典。返回:b: 2, a: 1

2.17 set(),创建集合

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

set() # 不传入参数,创建空集合;输出:set()
set(range(10)) # 传入可迭代对象,创建集合;输出:0, 1, 2, 3, 4, 5, 6, 7, 8, 9

2.18 frozenset(),创建不可变集合

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

a = frozenset(range(10))   # 输出:frozenset(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

2.19 enumerate(),创建枚举对象

根据可迭代对象创建枚举对象

seasons = [Spring, Summer, Fall, Winter]   
list(enumerate(seasons))    # 输出:[(0, Spring), (1, Summer), (2, Fall), (3, Winter)]

list(enumerate(seasons, start=1)) # 指定起始值,输出:[(1, Spring), (2, Summer), (3, Fall), (4, Winter)]

2.20 range(),创建range对象

根据传入的参数创建一个新的range对象

a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c # 分别输出a,b,c,输出:(range(0, 10), range(1, 10), range(1, 10, 3))
list(a),list(b),list(c) # 分别输出a,b,c的元素;输出:([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

2.21 iter(),创建可迭代对象

根据传入的参数创建一个新的可迭代对象

a = iter(abcd) #字符串序列
print(a)    # 输出:<str_iterator object at 0x03FB4FB0>
next(a)    # 输出:a
next(a)    # 输出:b
next(a)    # 输出:c
next(a)    # 输出:d
next(a)    # 由于后面没有元素了,所以会报错;报错内容如下:
# Traceback (most recent call last):
#   File "<pyshell#29>", line 1, in <module>
#     next(a)
# StopIteration

2.22 slice(),创建切片对象

根据传入的参数创建一个新的切片对象

slice(5)    # 输出:slice(None, 5, None)
slice(2,5)    # 输出:slice(2, 5, None)
slice(1,10,3)   # 输出:slice(1, 10, 3)

2.23 super(),继承

根据传入的参数创建一个新的子类和父类关系的代理对象

#定义父类A
class A(object):
    def __init__(self):
        print(A.__init__)

#定义子类B,继承A
class B(A):
    def __init__(self):
        print(B.__init__)
        super().__init__()

#super调用父类方法
b = B()

print(b)    # 输出:
# B.__init__
# A.__init__
# <__main__.B object at 0x0000025B3398C160>

2.24 object(),创建对象

创建一个新的object对象

a = object()

3. 序列操作(8个)

3.1 all(),all运算

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

all([1,2]) # 列表中每个元素逻辑值均为True,返回True; 输出:True
all([0,1,2]) #列表中0的逻辑值为False,返回False;
all(()) # 空元组,输出:True
all() # 空字典,输出:True

3.2 any(),any运算

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

any([0,1,2]) # 列表元素有一个为True,则返回True
any([0,0]) # 列表元素全部为False,则返回False
any([]) # 空列表,输出: False
any() # 空字典,输出: False

3.3 filter(),过滤可迭代对象

使用指定方法过滤可迭代对象的元素

a = list(range(1,10)) #定义序列, 输出 a 为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
def if_odd(x): # 定义奇数判断函数
    return x % 2 == 1

list(filter(if_odd , a)) # 筛选序列中的奇数,输出:[1, 3, 5, 7, 9]

3.4 map(),对可迭代对象中每个元素运算

使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象

a = map(ord,abcd)    # 此时,a为:<map object at 0x03994E50>
list(a)    # 对字符串abcd 分别计算ord(), 输出为:[97, 98, 99, 100]

3.5 next(),迭代对象中的下一个

返回可迭代对象中的下一个元素值

a = iter(abcd) #字符串序列
print(a)    # 输出:<str_iterator object at 0x03FB4FB0>
next(a)    # 输出:a
next(a)    # 输出:b
next(a)    # 输出:c
next(a)    # 输出:d
next(a)    # 由于后面没有元素了,所以会报错;报错内容如下:
# Traceback (most recent call last):
#   File "<pyshell#29>", line 1, in <module>
#     next(a)
# StopIteration

3.6 reversed(),返序

反转序列生成新的可迭代对象

a = reversed(range(10)) # 传入range对象
list(a) # 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3.7 sorted(),排列

对可迭代对象进行排序,返回一个新的列表

a = [a,b,d,c,B,A]
sorted(a)  # 默认按字符ascii码排序,输出:[A, B, a, b, c, d]
sorted(a,key = str.lower) # 转换成小写后再排序,a和A值一样,b和B值一样;输出:[a, A, b, B, c, d]

3.8 zip(),列表 --> 字典

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

x = [1,2,3] #长度3
y = [4,5,6,7,8] #长度5
list(zip(x,y)) # 取最小长度3,输出: [(1, 4), (2, 5), (3, 6)]

4. 对象操作(9个)

4.1 help(),帮助文件

返回对象的帮助信息

help(list)
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterables items
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |

4.2 dir(),属性列表

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

dir(list)
[__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]

4.3 id(),唯一标识符

返回对象的唯一标识符

a = kai
id(a)   # 输出:2332201834456

4.4 hash(),哈希值

获取对象的哈希值

hash(good good study)  # 输出:6003936519601954108

4.5 type(),对象类型

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

type(10)    # 输出:<class int>
type(10)     # 输出:<class str>

4.6 len(),对象长度

返回对象的长度

len(abcd) # 字符串,返回:4
len(bytes(abcd,utf-8)) # 字节数组,返回:4
len((1,2,3,4)) # 元组,返回:4
len([1,2,3,4]) # 列表,返回:4
len(range(1,5)) # range对象,返回:4
len(a:1,b:2,c:3,d:4) # 字典,,返回:4
len(a,b,c,d) # 集合,,返回:4
len(frozenset(abcd)) #不可变集合,,返回:4

4.7 ascii(),可打印字符串

返回对象的可打印表字符串表现方式

ascii(1)     # 输出:1
ascii(&)    # 输出:"&"
ascii(9000000)    # 输出:9000000
ascii(中文) #非ascii字符    # 输出:"\\\\u4e2d\\\\u6587"

4.8 format(),格式化显示

格式化显示值

# 整形数值可以提供的参数有 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

4.9 vars(),局部变量和值

返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表

class A(object):
    pass
a = A()

print(a.__dict__)    # 输出:
print(vars(a))    # 输出:
a.name = Kim
print(a.__dict__)    # 输出:name: Kim
print(vars(a))    # 输出:name: Kim

5. 反射操作(8个)

5.1 import(),动态导入模块

动态导入模块

index = __import__(index)
index.sayHello()

5.2 isinstance(),判断实例

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

isinstance(1,int)   # 输出:True
isinstance(1,str)    # 输出:False
isinstance(1,(int,str))    # 输出:True

5.3 issubclass(),判断子类

判断类是否是另外一个类或者类型元组中任意类元素的子类

issubclass(bool,int)    # 输出:True
issubclass(bool,str)      # 输出:False
issubclass(bool,(str,int))     # 输出:True

5.4 hasattr(),判断属性

检查对象是否含有属性

class Student:
    def __init__(self, name):
        self.name = name

s = Student(Aim)
hasattr(s, name)  # a含有name属性,True
hasattr(s, age)   # a不含有age属性,False

5.5 getattr(),获取属性

获取对象的属性值

class Student:
    def __init__(self, name):
        self.name = name

s = Student(Aim)
hasattr(s, name)  # a含有name属性,True
hasattr(s, age)   # a不含有age属性,False

getattr(s, name)   # 存在属性name,返回: Aim
getattr(s,age,0)   # 不存在属性age,但提供了默认值,返回默认值0;
getattr(s,age)     # 不存在属性age,没有默认值,则会报错;AttributeError: Stduent object has no attribute age

5.6 setattr() ,设置属性

设置对象的属性值

class Student:
    def __init__(self,name):
        self.name = name

a = Student(Kim)
a.name    # 输出:Kim
setattr(a,name,Bob)    # 修改name
a.name   # 输出:Bob

5.7 delattr(),删除属性

删除对象的属性

#定义类A
class A:
    def __init__(self,name):
        self.name = name
    def sayHello(self):
        print(hello,self.name)

#测试属性和方法
a.name    # 输出:小麦
a.sayHello()    # 输出: hello 小麦

#删除属性
delattr(a,name)
a.name    # 报错:A object has no attribute name

5.8 callable(),对象是否可调用

检测对象是否可被调用

class B:  # 定义类B
    def __call__(self):
        print(instances are callable now.)

callable(B)  # 类B是可调用对象,输出:True
b = B()  # 调用类B
callable(b)  # 实例b是可调用对象,输出:True
b()  # 调用实例b成功,输出:instances are callable now.

6. 作用域变量操作(2个)

6.1 globals(),全局变量 & 值

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

globals()  # 直接可以调用,查看当前的全局变量和其值组成的字典;

6.2 locals(),局部变量 & 值

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

locals()  # 直接可以调用,查看当前的局部变量和其值组成的字典;

7. 交互操作(2个)

7.1 print(),打印输出

向标准输出对象打印输出

print(1,2,3)    # 输出:1 2 3
print(1,2,3,sep = +)    # 输出:1+2+3
print(1,2,3,sep = +,end = =?)    # 输出:1+2+3=?

7.2 input(),用户输入

读取用户输入值

s = input(please input your name:)  # 代码运行到此,就需要用户进行输入;

8. 文件操作(1个)

8.1 open(),打开文件

使用指定的模式和编码打开文件,返回文件读写对象

# t为文本读写,b为二进制读写
a = open(test.txt,rt)
a.read()    # 输出:some text
a.close()

9. 编译执行(4个)

9.1 compile(),编译代码

将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值

#流程语句使用exec
code1 = for i in range(0,10): print (i)
compile1 = compile(code1,,exec)
exec (compile1)

9.2 eval(),执行动态表达式

执行动态表达式求值

eval(1+2+3+4)     # 输出:10

9.3 exec(),执行动态语句

执行动态语句块

exec(a=1+2)  # 执行语句,

9.4 repr(),字符串表现形式

返回一个对象的字符串表现形式(给解释器)

a = some text
str(a)    # 输出:some text
repr(a)    # 输出:"some text"

10. 装饰器(3个)

10.1 property(),属性装饰器

标示属性的装饰器

class C:
    def __init__(self):
        self._name = 

    @property
    def name(self):
        """im the name property."""
        return self._name

    @name.setter
    def name(self, value):
        if value is None:
            raise RuntimeError(name can not be None)
        else:
            self._name = value

c = C()

print(c.name)    # 访问属性,输出为

c.name = Kim  # 设置属性
print(c.name)  # 访问属性,输出为:Kim

c.name = None  # 设置属性时进行验证
# 弹出错误: RuntimeError: name can not be None

del c.name  # 删除属性,不提供deleter则不能删除

10.2 classmethod(),类装饰器

标示方法为类方法的装饰器

class C:
    @classmethod
    def f(cls, arg1):
        print(cls)
        print(arg1)

C.f(类对象调用类方法)
# 输出如下:
# <class __main__.C>
# 类对象调用类方法

c = C()
c.f(类实例对象调用类方法)
# 输出如下:
# <class __main__.C>
# 类实例对象调用类方法

10.3 staticmethod(),静态方法装饰器

标示方法为静态方法的装饰器

# 使用装饰器定义静态方法
class Student(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def sayHello(lang):
        print(lang)
        if lang == en:
            print(Welcome!)
        else:
            print(你好!)

Student.sayHello(en)  # 类调用,en传给了lang参数
# 输出如下:
# en
# Welcome!

b = Student(Kim)
b.sayHello(zh)  # 类实例对象调用,zh传给了lang参数
# 输出如下:
# zh
# 你好

本文参考地址:https://blog.csdn.net/oaa608868/article/details/53506188?utm_medium=distribute.pc_relevant.none-task-blog-title-9&spm=1001.2101.3001.4242

以上是关于Python基础学习第十一节 内置函数详解的主要内容,如果未能解决你的问题,请参考以下文章

python学习笔记第十一节(迭代和其他)

第十一节:Thymeleaf内置对象

零基础入门学习java第十一节:Java中的类和对象

python学习第三十一节

第十一章 Python常用内建函数

第十一节 JS事件基础