快捷搜索:
来自 计算机编程 2019-07-28 23:17 的文章
当前位置: 67677新澳门手机版 > 计算机编程 > 正文

python学习课程,内置函数

reload() 

用于重新载入之前载入的模块 没啥用啦

__author__ = "Tang"

"""
reload(module)
module -- 模块对象
"""

import sys
from imp import reload

内建函数built-in function

  1. abs(x) :返回x的绝对值absolute value
  2. all(iterable )
    参数:iterable -- 元组或列表。
    如果iterable的所有元素不为0、''、False或者iterable为空,all(iterable)返回True,否则返回False;
    注意:空元组、空列表返回值为True,这里要特别注意。
>>>all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
False
>>> all([0, 1,2, 3])          # 列表list,存在一个为0的元素
False   
>>> all(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True
>>> all(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
False
>>> all((0, 1,2, 3))          # 元组tuple,存在一个为0的元素
False 
>>> all([])             # 空列表
True
>>> all(())             # 空元组
True
  1. any(iterable)
    参数
    iterable -- 元组或列表。
    返回值
    如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true。
>>>any(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True 
>>> any(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
True 
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False 
>>> any(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True 
>>> any(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
True 
>>> any((0, '', False))        # 元组tuple,元素全为0,'',false
False  
>>> any([]) # 空列表
False 
>>> any(()) # 空元组
False
  1. bin(x):返回int或者long int的二进制形式
    类似的:hex() 函数用于将10进制整数转换成16进制整数。
    oct(),将十进制转换为八进制
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
print(oct(7))#>>>>>>0o7
  1. bool():将给定参数转换为布尔类型,如果没有参数,返回 False。
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
  1. callable(object):检查一个对象是否是可调用的。
    如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。
    对于函数, 方法, 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
  1. chr(i):返回值是当前整数(0-255)对应的ascii字符。
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
  1. ord():与chr(i)的功能正好相反。
  2. classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
class A(object):
    bar = 1
    def func1(self):  
        print 'foo'  
    @classmethod
    def func2(cls):
        print 'func2'
        print cls.bar
        cls().func1()   # 调用 foo 方法 
A.func2()               # 不需要实例化

输出结果为:
func2
1
foo

  1. compile() 函数将一个字符串编译为字节代码。
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4   5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
  1. complex() 函数用于创建一个值为 real imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数
>>>complex(1, 2)
(1   2j) 
>>> complex(1)    # 数字
(1   0j) 
>>> complex("1")  # 当做字符串处理
(1   0j) 
# 注意:这个地方在" "号两边不能有空格,也就是不能写成"1   2j",应该是"1 2j",否则会报错
>>> complex("1 2j")
(1   2j)
  1. delattr 函数用于删除属性。
    delattr(x, 'foobar') 相等于 del x.foobar。
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)
  1. dict()函数用于创建一个字典。
>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
  1. divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1 2j,1 0.5j)
((1 0j), 1.5j)
  1. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, seq[i]
... 
0 one
1 two
2 three
  1. eval() 函数用来执行一个字符串表达式,并返回表达式的值。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2   2')
4
>>> eval("n   4")
85
  1. execfile() 函数可以用来执行一个文件。
假设文件 hello.py,内容如下:
`print('runoob');`
execfile 调用该文件
>>>execfile('hello.py')
runoob
  1. filter():过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
def is_odd(n):
    return n % 2 == 1 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
  1. float() 函数用于将整数和字符串转换成浮点数。
>>> float(' 1.23')
1.23
>>> float('   -12345n')
-12345.0
>>> float('1e-003')
0.001
>>> float(' 1E6')
1000000.0
>>> float('-Infinity')
-inf
  1. frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>
  1. format():格式化输出字符串,format(value, format_spec)实质上是调用了value的format(format_spec)方法。
    print("i am {0},age{1}".format("tom",18))#>>>>>>i am tom,age18
  2. getatt() 函数用于返回一个对象属性值。
    getattr(x, 'foobar') 等价于 x.foobar.
>>>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'
  1. hasattr() 函数用于判断对象是否包含对应的属性。
    如果对象有该属性返回 True,否则返回 False。
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print(hasattr(point1, 'x'))  # true
print(hasattr(point1, 'y'))  # true
print(hasattr(point1, 'z'))  #true
print(hasattr(point1, 'no'))  # 没有该属性false
  1. hash() 用于获取取一个对象(字符串或者数值等)的哈希值。
hash(1)
1
hash('test')
2314058222102390712
  1. id() 函数用于获取对象的内存地址。
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
  1. int():将字符串或者其他进制的数字转化为整形。
>>>int()               # 不传入参数时,得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8
  1. isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。

isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

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

type() 与 isinstance()区别:

class A:
    pass 
class B(A):
    pass
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
  1. bytes()  将一个字符串转换成字节类型
s="apple"
v=bytes(s,encoding="utf-8")
print(v)#>>>>>>b'apple'
  1. str()  将字符类型/数值类型等转换为字符串类型
1 s=100
2 print(type(s))#>>>><class 'int'>
3 s=str(s)
4 print(type(s))#>>>><class 'str'>
  1. len():返回对象长度,参数可以是序列类型(字符串,元组或列表)或映射类型(如字典)
>>> a=[1, 2, 3, 4]
>>> len(a)
4
>>> type(a)
<class 'list'>
>>> a=(1, 2, 3, 4)
>>> type(a)
<class 'tuple'>
>>> a=['list', 'adwd', 'awde']
>>> type(a)
<class 'list'>
>>> len(a)
3
>>> a='sefijefs'
>>> len(a)
8
  1. list():元组转化列表
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
print ("列表元素 : ", aList)
结果:
列表元素 :  [123, 'xyz', 'zara', 'abc']
  1. tuple(): 列表转化元组。与list()类似
  2. locals() 函数会以字典类型返回当前位置的全部局部变量。
>>>def runoob(arg):    # 两个局部变量:arg、z
...     z = 1
...     print locals()
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
  1. map():根据提供的函数对指定序列做映射。
>>>def square(x) :            # 计算平方数
...     return x ** 2
>>> map(square, [1,2,3,4,5])   # 计算列表和:1 2 3 4 5
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x   y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
  1. max() 方法返回给定参数的最大值,参数可以为序列。
  2. min()同样的用法
  3. iter() 函数用来生成迭代器。
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
  1. next():返回迭代器的下一个项目。
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
  1. open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
    file 对象方法
    file.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)
    file.readline() 返回一行
    file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行
    for line in f: print line #通过迭代器访问
    f.write("hellon") #如果要写入字符串以外的数据,先将他转换为字符串.
    f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).
    f.seek(偏移量,[起始位置]) 用来移动文件指针.
    偏移量:单位:比特,可正可负
    起始位置:0-文件头,默认值;1-当前位置;2-文件尾
    f.close() 关闭文件
>>>f = open('test.txt')
>>> f.read()
'RUNOOB1nRUNOOB2n'
  1. pow() 方法返回 x的y次方 的值。
    以下是 math 模块 pow() 方法的语法:
import math
math.pow( x, y )

内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。

import math   # 导入 math 模块
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置,查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
结果:
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

pow(x,y) 等价于 x**y:
4**2 # 结果为16
4**2.5 # 结果为32.0
pow(x,y,z) 等价于 x**y%z:
4**2.5%3 # 结果为2.0

  1. range():函数可创建一个整数列表,一般用在 for 循环中。
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
  1. repr() 返回一个对象的 string 格式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>>repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
  1. reverse() 函数用于反向列表中元素。
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();
  1. round() 方法返回浮点数x的四舍五入值。round() 方法返回浮点数x的四舍五入值。
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
  1. slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
  1. sorted()  排序
    sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

a = [5,7,6,3,4,1,2] b = sorted(a) # 保留原列表 a [5, 7, 6, 3, 4, 1, 2] b [1, 2, 3, 4, 5, 6, 7] L=[('b',2),('a',1),('c',3),('d',4)] sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

  1. zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反,可理解为解压,返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

isinstance()

 函数来判断一个对象是否是一个已知的类型,类似 type()

__author__ = "Tang"

"""
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

isinstance(object, classinfo)
object 实例对象。
classinfo 可以是直接或间接类名、基本类型或者由它们组成的元组
"""

a = 10
print(isinstance(a,int)) # True


class A:
    pass

class B(A):
    pass
obj = B()
print(isinstance(obj,A)) #True
print(isinstance(obj,B)) #True

list() 

方法用于将对象转换为列表

__author__ = "Tang"

# 字符串转换
a = "tang"
print(list(a)) # ['t', 'a', 'n', 'g']

# a = 123
# print(list(a)) # 报错

a = (1,2,3,)
print(list(a)) # [1, 2, 3]

memoryview() 

函数返回给定参数的内存查看对象(Momory view)。

所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问

__author__ = "Tang"

"""
memoryview(obj)
"""

v = memoryview(bytearray("tang",'utf-8'))
print(v[1]) # 97

print(v[0]) # 116
print(chr(v[0])) # t

repr()

函数将对象转化为供解释器读取的形式

__author__ = "Tang"

s = "tanglaoer"
print(s) # tanglaoer
print(repr(s)) # 'tanglaoer'

hasattr()

函数用于判断对象是否包含对应的属性

__author__ = "Tang"

"""
hasattr(object, name)
object 对象。
name 字符串,属性名
"""
class A:
    b = '10'
a = A()
print(hasattr(a,'b')) # True
print(hasattr(a,'z')) # False

basestring() 

方法是 str 和 unicode 的超类(父类)可以用来判断一个对象是否为 str 或者 unicode 的实例,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))

classmethod 

修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等

是类里面方法的语法糖,有property,staticmethod等

__author__ = "Tang"

class A(object):
    @classmethod
    def func1(self):
        print('foo')

A.func1()  # foo

hex()

函数用于将10进制整数转换成16进制,以字符串形式表示

__author__ = "Tang"

print(hex(10)) # 0xa

a = hex(17)
print(a, type(a)) # 0x11 <class 'str'>

67677新澳门手机版 ,set() 

函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

__author__ = "Tang"

"""
class set([iterable])
"""
x = set([1,2,3])
print(x) # {1, 2, 3}

x = set("tanglao") # 无重复的集合
print(x) # {'a', 'n', 't', 'g', 'o', 'l'}

float() 

函数用于将整数和字符串转换成浮点数,字符串是数字在里面才行,不然会报错

__author__ = "Tang"

a = 10
print(float(a)) # 10.0

a = -234
print(float(a)) # -234.0

a = "123"
print(float(a)) # 123.0

a = "123abc"
print(float(a)) # 报错

all()

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

如果iterable的所有元素不为0、''"、False或者iterable为空,all(iterable)返回True,否则返回False;注意 空列表 空元组 空字典 空字符串是True

__author__ = "Tang"

a = all([1,0])
print(a) # False

a = all([1,False])
print(a) # False

a = all(["",1])
print(a) # False

a = all([])
print(a) # True

a = all(())
print(a) # True

a = all({})
print(a) # True

a = ""
print(all(a)) # True

next() 

返回迭代器的下一个项目

__author__ = "Tang"

"""
next(iterator[, default])
iterator 可迭代对象
default 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常
"""
li = [1,2,3,4]
# print(next(li)) # TypeError: 'list' object is not an iterator

# 先转换为可迭代对象
li = iter(li)
print(next(li)) #  1
print(next(li)) #  2
print(next(li)) #  3
print(next(li,80)) #  4
print(next(li,90)) #  90 不然就报错

hash()

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

__author__ = "Tang"

"""
hash(object)
"""
print(hash("tang")) # 278126952
print(hash(23)) # 23
print(hash(str([1,2,3]))) # 716557122
# print(hash([1,2,3])) # 报错

any() 

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

如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true

__author__ = "Tang"

a = any([1,0])
print(a) # True

a = any([1,False])
print(a) # True

a = any(["",1])
print(a) # True

a = any([])
print(a) # False

a = any(())
print(a) # False

a = any({})
print(a) # False

a=""
print(any("")) # False

setattr()

函数对应函数 getatt(),用于设置属性值,该属性必须存在

__author__ = "Tang"

"""
setattr(object, name, value)
object -- 对象。
name -- 字符串,对象属性。
value -- 属性值
"""

class A:
    b = 1

a = A()
print(getattr(a,'b'))

setattr(a,'c',5)
print(a.c) # 5

 eval()

函数用来执行一个字符串表达式,并返回表达式的值,可以说是一个计算器

__author__ = "Tang"

"""
eval(expression[, globals[, locals]])
expression 表达式
globals - 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象
"""

x = 2
print(eval('3 * x')) # 6

print(eval('2 2')) # 4

print(eval('2**10')) # 1024

sum()

 方法对系列进行求和计算

__author__ = "Tang"

"""
sum(iterable[, start])
iterable -- 可迭代对象,如:列表、元组、集合。
start -- 指定相加的参数,如果没有设置这个值,默认为0
"""
a = [1,2,3,4]
print(sum(a)) # 10

print(sum(a,10)) # 20

# 面试题 用一句话打印出1~100的和
print(sum(range(101))) # 5050

reduce() 

函数会对参数序列中元素进行累积。

函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果

__author__ = "Tang"

"""
reduce(function, iterable[, initializer])
function -- 函数,有两个参数
iterable -- 可迭代对象
initializer -- 可选,初始参数
"""
from functools import reduce

def test(a,b):
    return  a  b
b = [1,2,3,4,5,6,7]
a = reduce(test,b)
print(a) # 28

# 配合lambda
a = reduce(lambda x,y:x y,b)
print(a) # 28

"""
顺便问一道题:用一句话打印1~100的和?
"""
print(sum(range(101))) # 5050

id()

函数用于获取对象的内存地址

__author__ = "Tang"

"""
在这里提一下,两个变量指向一个相同的不可变数据类型的数值时,它们的id是相同的,
但是元组不一样,它们id是改变的,与列表一样
"""
# int
a  = 10
print(id(a)) # 1368449952
b  = 10
print(id(b)) # 1368449952

# str 字符串是不可变数据类型
a = "tang"
print(id(a)) # 17810368

b = "tang"
print(id(b)) # 17810368

# 列表
a = [1,2,3,4]
print(id(a)) # 50262384

b = [1,2,3,4]
print(id(b)) # 50262344


a = (1,2,3,4,)
print(id(a)) # 6564096

b = (1,2,3,4,)
print(id(b)) # 6631664

super() 

函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表

__author__ = "Tang"

"""
super(type[, object-or-type])
type -- 类。
object-or-type -- 类,一般是 self
"""

class A():
    def tt(self):
        print("我是父类的tt")
        return
class B(A):
    def tt(self):
        super().tt() # 调用父类函数
        print("我是子类的tt")

b = B()
b.tt()
"""
我是父类的tt
我是子类的tt
"""

iter() 

函数用来生成迭代器

__author__ = "Tang"

"""
iter(object[, sentinel])
object 支持迭代的集合对象。
sentinel 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),
此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object
"""

li = [1,2,3]
for i in iter(li):
    print(i,end=" ") # 1 2 3

l = ['a','b','c','d']
def test():
    return l.pop()
it = iter(test,'z') # 无穷执行test() 直到test结果等于'z'
print(it.__next__()) # d
print(it.__next__()) # c
print(it.__next__()) # b
print(it.__next__()) # a
print(it.__next__()) # IndexError: pop from empty list

filter() 

函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表

__author__ = "Tang"

"""
该函数接收两个参数,第一个为函数,第二个为序列,
序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中
filter(function, iterable)
"""

def test(n):
    return n%2
li = filter(test,[i for i in range(10)])
print(li) # <filter object at 0x00B132F0>
print(list(li)) # [1, 3, 5, 7, 9]

# 配合匿名函数
li = filter(lambda x:x%2,[i for i in range(10)])
print(li) # <filter object at 0x036232F0>
print(list(li)) # [1, 3, 5, 7, 9]

enumerate()

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

__author__ = "Tang"

"""
enumerate(sequence, [start=0]) 可以自定义start 开始下标
返回两个参数,第一个为下标,第二个为值
"""

a = ['tang','lao','er']
for key,value in enumerate(a,10):
    print(key,value)
"""
10 tang
11 lao
12 er
"""

bin()  返回一个整数 int 的二进制表示

__author__ = "Tang"

a = 10
print(bin(a)) # 0b1010

a = 500
print(bin(a)) # 0b111110100

bool() 

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

__author__ = "Tang"

# 为False的情况 七兄弟
# () [] {} 0 False "" 空
print(bool(())) # False
print(bool([])) # False
print(bool({}))# False
print(bool(0))# False
print(bool(False))# False
print(bool(""))# False
print(bool())# False

print(bool(10)) # 其他情况都为True

67677新澳门手机版 1

print()

 方法用于打印输出,最常见的一个函数

__author__ = "Tang"

"""
print(*objects, sep=' ', end='n', file=sys.stdout)
objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
sep -- 用来间隔多个对象,默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 n,我们可以换成其他字符串。
file -- 要写入的文件对象。
"""

a = "tanglaoer"
b = "chenlaosan"
print(a,b) # tanglaoer chenlaosan
print(a,b,sep='*') #tanglaoer*chenlaosan

a = [1,2,3,4]
for i in a:
    print(i)
"""
1
2
3
4
"""
for i in a:
    print(i,end=" ") #1 2 3 4 

dir() 

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

__author__ = "Tang"

"""此方法在学习过程中非常有用,可用于查看类的方法"""

print(dir())
"""
['__annotations__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
"""

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']
"""

locals()

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

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

__author__ = "Tang"

def test():
    a = 1
    print(locals()) # {'a': 1}
    print(globals())
    """
    {
    '__name__': '__main__', 
    '__doc__': None, 
    '__package__': None, 
    '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00E3C350>, 
    '__spec__': None, 
    '__annotations__': {}, 
    '__builtins__': <module 'builtins' (built-in)>, 
    '__file__': 'F:/python_django/基础/内置函数.py', 
    '__cached__': None, 
    '__author__': 'Tang', 
    'test': <function test at 0x002BB618>}
    """
test()

type()

函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象

__author__ = "Tang"

"""
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

type(name, bases, dict)
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典,类内定义的命名空间变量。
返回值
一个参数就返回对象类型, 
如果是三个参数,那么就返回新的类型对象
"""

print(type(1)) # <class 'int'>

print(type([1,2,3])) # <class 'list'>

# 创建一个类
x = type('X',(object,),dict(a=1))

print(x) # <class '__main__.X'>
obj = x()
print(obj.a) # 1

delattr(object,name) 

函数用于删除属性

__author__ = "Tang"

class A:
    x = 20

print(A.x) # 20
delattr(A,"x")
print(A.x) #报错

input()

 函数接受一个标准输入数据,返回为 string 类型

 

__author__ = "Tang"

a = input('请输入:')
print(a,type(a))

67677新澳门手机版 2

 

chr()

用一个范围在 range(256)内的(就是0~255)整数作参数,返回一个对应ascii字符

__author__ = "Tang"

print(chr(97)) # a

file()

python3 中没有该函数

 

本文由67677新澳门手机版发布于计算机编程,转载请注明出处:python学习课程,内置函数

关键词: