Python学习之内置函数

1.abs()取绝对值
print(abs(-1))            1
print(abs(1))             1
2.布尔运算，all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

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

print(all([1,2,'1']))            True
print(all([1,2,'1','']))         False
print(all(''))                     True #如果可迭代对象为空，返回True
3.any（）有一个为真即为真
print(any([0,'']))                False
print(any([0,'',1]))              True
4.bool()判断布尔值：空，None，0的布尔值为False，其余都为True
print(bool(''))                     False           
print(bool(None))                   False
print(bool(0))                      False
5.bytes（）返回一个新的bytes对象
name='你好'
print(bytes(name,encoding='utf-8'))           ==》b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(name,encoding='utf-8').decode('utf-8'))          ==》你好 #用什么编码就用什么解码（utf-8）

print(bytes(name,encoding='gbk'))               ==》b'\xc4\xe3\xba\xc3'
print(bytes(name,encoding='gbk').decode('gbk'))             你好#用什么编码就用什么解码（gbk）
print(bytes(name,encoding='ascii'))#ascii不能编码中文
6.chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
print(chr(46))               ==》.
7.dir（）打印某个对象下面都有哪些方法
print(dir(dict))
8.divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(10,3))      ==》(3, 1)        #10除以3取商和余数
9.hash() 用于获取一个对象（字符串或者数值等）的哈希值。可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))            -3770611814330439003
print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))                                          7627853189009815345

name='alex'
print(hash(name))                     -3756719071540909345
print(hash(name))                     -3756719071540909345

print('--->before',hash(name))         --->before -3756719071540909345
name='sb'
print('=-=>after',hash(name))          =-=>after 5833407911109000262

10.help() 函数用于查看函数或模块用途的详细说明。
print(help(all))
11.进制转换
print(bin(10)) #10进制->2进制　　　0b1010
print(hex(12)) #10进制->16进制　　　0xc
print(oct(12)) #10进制->8进制　　　　0o14
12.isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
print(isinstance(1,int))                     True
print(isinstance('abc',str))                 True
print(isinstance([],list))                   True
print(isinstance({},dict))                   True
print(isinstance({1,2},set))                 True
13.globals() 函数会以字典类型返回当前位置的全部全局变量。
name='哈哈哈哈'
print(globals())       {'__name__': '__main__', '__doc__': None, '...}
print(__file__)        #打印文件名C:/Users/jy/Desktop/python全栈s3  day16课上所有/内置函数.py
14.locals() 函数会以字典类型返回当前位置的全部局部变量
def test():
    age='1111111'
    print(locals())
test()               {'age': '1111111'}
15.max，min返回最大最小值
l=[1,3,100,-1,2]
print(max(l))       100
print(min(l))       -1

补充max，min高级用法：

 

#比较多种元素类型时：
dic={'age1':18,'age2':10}
print(max(dic))                    #比较的是key  ==》age2
print(max(dic.values()))       #比较的是value  ==》18
print(max(zip(dic.values(),dic.keys())))  ==>(18, 'age1')#结合zip使用

 

　

 

 

16.eval() 函数用来执行一个字符串表达式，并返回表达式的值。

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

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

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

 

print(list(zip(('a', 'b', 'c'), (1, 2, 3))))          ==》  [('a', 1), ('b', 2), ('c', 3)]
# print(list(zip(('a', 'b', 'c','d'), (1, 2, 3))))  ==》  [('a', 1), ('b', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))     ==》    [('name', 'alex'), ('age', 18), ('gender', 'none')]
print(list(zip(p.keys())))       ==》      [('name',), ('age',), ('gender',)]
print(list(zip(p.values())))    ==》      [('alex',), (18,), ('none',)]

18.ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

print(chr(97)) -->a
print(ord('a')) -->97

19.pow() 方法返回 x^y（x的y次方） 的值。

print(pow(3,3))           #两个参数相当于3**3          --》       27
print(pow(3,3,2))        #三个参数相当于3**3%2     --》        1

20.reversed()返回一个反转的迭代器
l=[1,2,3,4]
print(list(reversed(l))) ==>[4, 3, 2, 1]
21.round() 方法返回浮点数x的四舍五入值
print(round(3.5)) ==>4
22.set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
print(set('hello')) ==>{'h', 'o', 'l', 'e'}

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

l='hello'
s1=slice(3,5)
s2=slice(1,4,2)
print(l[s1])        ==》lo
print(l[s2])        ==》el

print(s2.start)           1 #起始位置
print(s2.stop)            4 #结束位置
print(s2.step)            2 #间距

24.sorted() 函数对所有可迭代的对象进行排序操作
l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l)) ==》[1, 2, 3, 5, 7]
print(sorted(l1)) #报错，排序的本质就是在比较大小，不同类型之间不可以比较

name_dic={
    'abyuanhao': 11900,
    'alex':1200,
    'wupei':300,
}
print(sorted(name_dic))

print(sorted(name_dic,key=lambda key:name_dic[key]))

print(sorted(zip(name_dic.values(),name_dic.keys())))

输出结果：
['abyuanhao', 'alex', 'wupei']
['wupei', 'alex', 'abyuanhao']
[(300, 'wupei'), (1200, 'alex'), (11900, 'abyuanhao')]

25.str() 函数将对象转化为适于人阅读的形式

print(str('1'))
print(str({'a':1}))
dic_str=str({'a':1})
print(eval(dic_str))


输出结果：
1
{'a': 1}
{'a': 1}

26.sum() 方法对系列进行求和计算。

l=[1,2,3,4]
print(sum(l))                  10
print(sum(range(5)))       10

27.type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1          
>>> type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
>>> X
<class '__main__.X'>
***********************************************
msg='123'
if type(msg) is str:
    msg=int(msg)
    res=msg+1
    print(res)
def test():
    msg='哈哈'
    print(locals())
    print(vars())
test()
print(vars(int))
输出结果：
124
{'msg': '哈哈'}
{'msg': '哈哈'}
{'__repr__': <slot wrapper '__repr__' of 'int' objects>, '__hash__':。。。}

28.

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

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

a.py 文件代码：
import os  
 
print ('在 a.py 文件中 %s' % id(os))


test.py 文件代码：
import sys  
__import__('a')        # 导入 a.py 模块


执行 test.py 文件，输出结果为：
在 a.py 文件中 4394716136

29.isinstance(obj,cls)和issubclass(sub,super)

#isinstance(obj,cls)检查是否obj是否是类 cls 的对象
class Foo(object):

     pass
obj = Foo()
print(isinstance(obj, Foo))  -->True

#issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object):
    pass
class Bar(Foo):
    pass
print(issubclass(Bar, Foo))  -->True
print(issubclass(Foo,Bar ))  -->Flase