python基础—内置函数

 1、数学运算类

(1)、abs(x)

求绝对值，参数x可以是整形，也可也是复数，如果是复数，则返回复数的模

abs(-1)    >> 1

(2)、divmod(x,y)

 返回两个数值的商和余数

divmod(5,2)  >>(2,1)

divmod(4.5,3)  >>(1.0, 1.5) 

(3)、max(iterable[, args...][key]) 

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

max(1,2,3)    #传入三个参数，取三个中最大的一个
>> 3
max('1234')   # 传入一个可迭代对象，取最大值
>> "4"
max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
>> -1

(4)、min(iterable[, args...][key]) 

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

min(1,2,3)    #传入三个参数，取三个中最小的一个
>> 1
min('1234')   # 传入一个可迭代对象，取最小值
>> "1"
min(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取最下者
>> 0

(5)、pow(x,y,z)   

返回两个数值的幂运算值或其与指定整数的模值

如果只有两个参数，计算为x**y，如果三个参数，计算为x**y%z

pow(2,3)  # 2**3
>> 8
pow(2,3,4)   # 2**3%4
>>0

(6)、round(x[, n]) 

对浮点数进行四舍五入求值,可以指定小数点后的位数，默认为0

round(1.3455664)  # 没有指定小数点后的位置，默认为0
>> 1round(1.3455664,2)  # 保留两位小数
>> 1.35

(7)、sum(iterable[, start]) 

sum((1,2,3,4))   # 传入可迭代对象，元素必须是数值
>> 10

sum((1,2,3,4), -10)   # 先计算元祖，在计算-10
>> 0

2、类型转换

(1)、bool()

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

bool()  # 为传入任何参数
>> False
bool(None) # None，空字符串，0都为False
>> False
bool(1)
>> True

(2)、int()

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

int()   # 不传入任何参数，默认返回为0
>> 0
int("3")   # 传入一个数字型的字符串
>> 3
int(3.5)   # 传入一个浮点数
>> 3

(3)、float()

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

float()  # 不传入任何参数，返回0.0
>> 0.0
float('3.5')  # 传入浮点型的字符串
>> 3.5
float(3)   # 传入整数
>> 3.0

(4)、complex()

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

complex()   
>> 0j
complex("1+2j")
>>  (1+2j)
complex(1,2)
>>  (1+2j)

(5)、str()

返回一个对象的字符串表现形式

str()
>> ''
str(123)
>>'123'
str(None)
>> 'None'

(6)、bytes()

把字符串转换为字节形式

name = "你好"
a = bytes(name,encoding="utf-8")  # 指定编码方式
a
>> b'xe4xbdxa0xe5xa5xbd'

　a.decode('utf-8')  # 用什么方式编码，就用什么方式解码
　>> '你好'

(7)、ord()

返回ascii字符对应的整数

ord('a')
>> 97

(8)、chr()

返回整数所对应的ascii字符

chr(97)
>>a

(9)、bin()

将整数转换为二进制字符串

bin(3)
>>'0b11'

(10)、oct()

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

oct(10)
>> '0o12'

(11)、hex()

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

hex(12)
>> '0xc'

(12)、frozenset()

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

a = frozenset(range(10))

a>> frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

(13)、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')]

(14)、iter(object[, sentinel])

object -- 支持迭代的集合对象。

sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

一般常用的是传入object。

for i in iter(range(2)):
    print(i)
>>   
     0
     1   

可以利用iter()实现一个for死循环

for i in iter(int, 1):   # int永远是0
    pass

(15)、siice(start, stop[, step])

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

a = slice(5)
a
>>slice(None, 5, None)

range(10)[a]
>>range(0, 5)

3、序列操作

(1)、all()

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

all([1,2,3])   # 列表中每个元素逻辑值都为真，则返回True
>> True
all([0,1,2])
>> False
all([])   # 空列表
>> True
all(())   # 空元祖
>> True
all({})   # 空字典
>> True

(2)、any()

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

any([0,1,2])   # 列表元素逻辑值有为True的，则返回True
>> True
any([0,False])  # 列表中的逻辑值全为False,则返回False
>> False
any([])   # 空列表
>> False
any(())  # 空元祖
>> True
any({})  # 空字典
>> True

(3)、next()

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

a = iter('abc')
next(a)
>> 'a'
next(a)
>> 'b'
next(a)
>> 'c'
next(a)   # 越界会抛出异常
>> ---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-9-15841f3f11d4> in <module>
----> 1 next(a)

StopIteration:

传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常

a = iter("abc")
next(a, 'd')
>> 'a'
next(a, 'd')
>> 'b'
next(a, 'd')
>> 'c'
next(a, 'd')
>> 'd'

(4)、reversed()

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

a = reversed(range(10)) # 传入range对象
a 
>> <range_iterator at 0x5c0b770>  #
list(a)
>> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

(5)、sorted()

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

注意：不同类型之间不可以比较大小

实例1：

a = ['a','b','d','c','B','A']
sorted(a)
>>  ['A', 'B', 'a', 'b', 'c', 'd']  # 默认使用ascii排序,返回新的列表

# 可以使用sort()方法实现同样的效果，但是不会产生新的列表，在原列表的基础上排序
a.sort()
a
>>   ['A', 'B', 'a', 'b', 'c', 'd']

sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
>>  ['A', 'a', 'B', 'b', 'c', 'd']
a.sort(key=str.lower)
a
>> ['A', 'a', 'B', 'b', 'c', 'd']

实例2：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

# 按照年龄降序排序
sorted(students, key=lambda s:s[2], reverse=True)

>> [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

(6)、zip()

拉链函数，将对象一一配对（不管是左边还是右边多出，不会报错）

list(zip(('a','n','c'),(1,2,3)))
>> [('a', 1), ('b', 2), ('c', 3)]

利用zip()函数将字段的key与value进行对调

dic = {'name': 'Alex',
       'age':18,
       'genter':None}
list((zip(dic.values(),dic)))

>>  [('Alex', 'name'), (18, 'age'), (None, 'genter')]

4、对象操作

(1)、help()

返回对象的帮助信息

(2)、dir()

显示函数内部的属性和方法，以列表的形式返回

['__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__']

(3)、id()

返回对象的唯一标识符

(4)、hash() 

可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型

hash的作用：去网上下载软件，判断是否被人修改，通过比对hash值，就知道

hash('good good study')
>>  -6498340610423324471

(5)、vars()

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

def test():
    msg='多想和你一样臭不要脸'
    print(locals())    #打印出上一层的值，如果上一层没有，再往上找
    print(vars())      #如果没有参数，跟locals一样，如果有参数，查看某一个方法，显示成字典的方式
test()

>>{'msg': '多想和你一样臭不要脸'}

  {'msg': '多想和你一样臭不要脸'}

返回对象属性列表

vars(int)

5、反射操作

(1)、isinstance(object, classinfo)

　　用来判断一个对象是否为一个已知的类型，类似type()

　　object -- 实例对象。

　　classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

　　如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

注意：

　　type() 不会认为子类是一种父类类型，不考虑继承关系。　　

　　isinstance() 会认为子类是一种父类类型，考虑继承关系。

　　如果要判断两个类型是否相同推荐使用 isinstance()。

a = 2
isinstance (a,int)
>>True
isinstance (a,str)
>>False
isinstance (a,(str,int,list))    # 是元组中的一个返回 True
>> True

 (2)、issubclass(class, classinfo) 

用于判断参数 class 是否是类型参数 classinfo 的子类。

　　class -- 类。

　　classinfo -- 类

如果 class 是 classinfo 的子类返回 True，否则返回 False

class A:
    pass
class B(A):
    pass
    
issubclass(B,A)    # 返回 True

(3)、hasattr(object, name)

　　object -- 对象。

　　name -- 字符串，属性名。

如果对象有该属性返回 True，否则返回 False

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
hasattr(point1, 'x')  >> True
hasattr(point1, 'y') >> True
hasattr(point1, 'z') >> True
hasattr(point1, 'no') >> False  # 没有该属性

(4)、getattr(object, name[, default])

用于返回一个对象的属性值。

　　object -- 对象。

　　name -- 字符串，对象属性。

　　default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

class A(object):
    bar = 1
 
a = A()
getattr(a, 'bar')        # 获取属性 bar 值
>> 1
getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
>>Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'

getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
>> 3

(5)、setattr(object, name, value)

函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

　　object -- 对象。

　　name -- 字符串，对象属性。

　　value -- 属性值。

①、对已存在的属性进行赋值

class A(object):
    bar = 1

a = A()
getattr(a, 'bar')
>> 1
setattr(a, 'bar', 2)
a.bar
>> 2

②、如果属性不存在会创建一个新的对象属性，并对属性赋值 

class A(object):
    name = 'Negan'


a = A()
setattr(a, 'age', 20)
a.age
>> 20

 (6)、delattr(object, name)

　　用于删除属性，delattr(x, 'foobar') 相等于 del x.foobar。

　　object -- 对象。

　　name -- 必须是对象的属性。

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)

(7)、callable(object)

用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

callable(0)
>>False
callable("runoob")
>>False
 
def add(a, b):
    return a + b

callable(add)       # 函数返回 True
>>True

class A:         # 类
    def method(self):
        return 0

callable(A)               # 类返回 True
>> True
a = A()
callable(a)      # 没有实现 __call__, 返回 False
>> False

class B:
    def __call__(self):
        return 0

callable(B)
>>True
b = B()
callable(b)  # 实现 __call__, 返回 True
>>True

(8)、eval(expression[, globals[, locals]])

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

　　expression -- 表达式。

　　globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

　　locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

x = 7
eval( '3 * x' )
>>21
eval('pow(2,2)')
>>4
eval('2 + 2')
>>4
n=81
eval("n + 4")
>>85

(9)、exec()

执行动态语句块

exec('a=1+2') #执行语句
a
>>3

(10)、repr(object)

将对象转化为供解释器读取的形式，返回对象的string格式

dict = {'runoob': 'runoob.com', 'google': 'google.com'};
repr(dict)
>>"{'google': 'google.com', 'baidu': 'baidu.com'}"

---