精华内容
下载资源
问答
  • python常用的内置函数

    2020-07-19 22:05:04
    python常用的内置函数 1.abs()函数 abs() 函数返回数字的绝对值。 >>>abs(-5) >>>5 >>>abs(10) >>>10 2.dict()函数 dict() 函数用于创建一个字典。 语法结构: class dict(**...

    python常用的内置函数

    1.abs()函数
    abs() 函数返回数字的绝对值。

    >>>abs(-5)
    >>>5
    >>>abs(10)
    >>>10
    

    2.dict()函数
    dict() 函数用于创建一个字典。
    语法结构:

    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)
    

    **kwargs – 关键字
    mapping – 元素的容器。
    iterable – 可迭代对象。

    >>>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}
    

    3.enumerate() 函数
    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循环:

    i = 0
    seq = ['one', 'two', 'three']
    for element in seq:
        print(i, seq[i])
        i += 1
    
    0 one
    1 two
    2 three
    

    下面使用enumerate()函数:

    seq = ['one', 'two', 'three']
    for i, element in enumerate(seq):
        print(i, element)
    
    0 one
    1 two
    2 three
    

    4.float() 函数
    float() 函数用于将整数和字符串转换成浮点数。

    >>>float(1)
    1.0
    >>> float(112)
    112.0
    >>> float(-123.6)
    -123.6
    >>> float('123')     # 字符串
    123.0
    

    5.format 格式化函数
    它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数,位置可以不按顺序。

    >>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
    'hello world'
     
    >>> "{0} {1}".format("hello", "world")  # 设置指定位置
    'hello world'
     
    >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    'world hello world'
    

    6.input() 函数
    Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。

    >>>a = input("input:")
    input:123                  # 输入整数
    >>> type(a)
    <class 'str'>              # 字符串
    >>> a = input("input:")    
    input:runoob              # 正确,字符串表达式
    >>> type(a)
    <class 'str'>             # 字符串
    

    7.int()函数
    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
    

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

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

    9.iter() 函数
    以下是 iter() 方法的语法:

    iter(object[, sentinel])
    

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

    >>>lst = [1, 2, 3]
    >>> for i in iter(lst):
    ...     print(i)
    ... 
    1
    2
    3
    

    10.len()函数
    len() 方法返回对象(字符、列表、元组等)长度或项目个数。

    >>>str = "runoob"
    >>> len(str)             # 字符串长度
    6
    >>> l = [1,2,3,4,5]
    >>> len(l)               # 列表元素个数
    5
    

    11.list()函数
    list() 方法用于将元组或字符串转换为列表。

    aTuple = (123, 'Google', 'Runoob', 'Taobao')
    list1 = list(aTuple)
    print ("列表元素 : ", list1)
    
    str="Hello World"
    list2=list(str)
    print ("列表元素 : ", list2)
    
    列表元素 :  [123, 'Google', 'Runoob', 'Taobao']
    列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
    

    12.map() 函数
    map() 会根据提供的函数对指定序列做映射。
    第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。

    >>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> map(square, [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]
    

    13.max() 函数
    max() 方法返回给定参数的最大值,参数可以为序列。

    print ("max(80, 100, 1000) : ", max(80, 100, 1000))
    print ("max(-20, 100, 400) : ", max(-20, 100, 400))
    print ("max(-80, -20, -10) : ", max(-80, -20, -10))
    print ("max(0, 100, -400) : ", max(0, 100, -400))
    

    输出的结果为:

    max(80, 100, 1000) :  1000
    max(-20, 100, 400) :  400
    max(-80, -20, -10) :  -10
    max(0, 100, -400) :  100
    

    14.min() 函数
    min() 方法返回给定参数的最小值,参数可以为序列。

    print ("min(80, 100, 1000) : ", min(80, 100, 1000))
    print ("min(-20, 100, 400) : ", min(-20, 100, 400))
    print ("min(-80, -20, -10) : ", min(-80, -20, -10))
    print ("min(0, 100, -400) : ", min(0, 100, -400))
    

    输出结果为:

    min(80, 100, 1000) :  80
    min(-20, 100, 400) :  -20
    min(-80, -20, -10) :  -80
    min(0, 100, -400) :  -400
    

    15.pow() 函数
    pow() 方法返回 xy(x的y次方) 的值。

    import math
    
    math.pow( x, y )
    
    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
    

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

    >>>x = set('runoob')
    >>> y = set('google')
    >>> x, y
    (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
    >>> x & y         # 交集
    set(['o'])
    >>> x | y         # 并集
    set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
    >>> x - y         # 差集
    set(['r', 'b', 'u', 'n'])
    >>>
    

    17.sorted() 函数
    sorted() 函数对所有可迭代的对象进行排序操作。

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

    它的语法结构:

    sorted(iterable, key=None, reverse=False)  
    

    iterable – 可迭代对象。
    key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    reverse – 排序规则,reverse = True 降序 , reverse = False 升序(默认)。

    实例如下:

    >>>sorted([5, 2, 3, 1, 4])
    [1, 2, 3, 4, 5] 
    
    >>>a=[5,2,3,1,4]
    >>> a.sort()
    >>> a
    [1,2,3,4,5]
    
    >>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
    [1, 2, 3, 4, 5]
    

    利用key进行倒序排序

    >>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
    >>> result_list = sorted(example_list, key=lambda x: x*-1)
    >>> print(result_list)
    [7, 6, 5, 4, 3, 2, 1, 0]
    >>>
    

    要进行反向排序,也通过传入第三个参数 reverse=True:

    >>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
    >>> sorted(example_list, reverse=True)
    [7, 6, 5, 4, 3, 2, 1, 0]
    

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

    >>>s = 'RUNOOB'
    >>> str(s)
    'RUNOOB'
    >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    >>> str(dict)
    "{'google': 'google.com', 'runoob': 'runoob.com'}"
    >>>
    

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

    >>>sum([0,1,2])  
    3  
    >>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
    10
    >>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
    12
    

    axis设置行和列相加

    import numpy as np
    
    a = np.array([[1,2],[3,4]])
    
    # 按行相加,并且保持其二维特性
    print(np.sum(a, axis=1, keepdims=True))
    
    # 按行相加,不保持其二维特性
    print(np.sum(a, axis=1))
    

    输出:

    array([[3], [7]])
    array([3, 7])
    

    20.tuple() 函数

    >>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
    >>> tuple1=tuple(list1)
    >>> tuple1
    ('Google', 'Taobao', 'Runoob', 'Baidu')
    

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

    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 返回一个对象
    >>> zipped
    <zip object at 0x103abc288>
    >>> list(zipped)  # list() 转换为列表
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip(a,c))              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
     
    >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
    >>> list(a1)
    [1, 2, 3]
    >>> list(a2)
    [4, 5, 6]
    >>>
    

    机器学习模型训练中,经常需要打乱数据集,用 zip() 函数可以实现如下:

    import random
    X = [1, 2, 3, 4, 5, 6]
    y = [0, 1, 0, 0, 1, 1]
    zipped_data = list(zip(X, y))  
    # 将样本和标签一 一对应组合起来,并转换成list类型方便后续打乱操作random.shuffle(zipped_data)  
    # 使用random模块中的shuffle函数打乱列表,原地操作,没有返回值
    new_zipped_data = list(map(list, zip(*zipped_data)))  
    # zip(*)反向解压,map()逐项转换类型,list()做最后转换
    new_X, new_y = new_zipped_data[0], new_zipped_data[1]  
    # 返回打乱后的新数据
    print('X:',X,'\n','y:',y)
    print('new_X:',new_X, '\n', 'new_y:',new_y)
    

    输出结果(因未设置随机种子seed,因此每次运行结果可能不一样):

    X: [1, 2, 3, 4, 5, 6] 
     y: [0, 1, 0, 0, 1, 1]
    new_X: [1, 2, 3, 4, 5, 6] 
     new_y: [0, 1, 0, 0, 1, 1]
    
    展开全文
  • Python 常用的内置函数

    2019-05-15 21:56:03
    Python 常用的内置函数 1. map()函数 map()函数可以理解为具有映射功能的函数。它会把参数序列中的每一个元素都映射到指定的函数上,返回结果是一个列表。 例如:下面打印每个元素的平方。 re = map(lambda x: ...

    Python   常用的内置函数

    1. map()函数

    map()函数可以理解为具有映射功能的函数。它会把参数序列中的每一个元素都映射到指定的函数上,返回结果是一个列表。

    例如:下面打印每个元素的平方。

    re = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
    print(list(re))
    
    # 输出结果
    [1, 4, 9, 16, 25]
    

    2. zip()函数

    zip()函数可以理解为具有合并功能的函数。可以接收N个参数,但是每个参数必须是可以迭代的对象,最后会返回一个经过合并的大序列,该序列的子元素中包含每个可迭代对象的对应位置上的元素,每个子元素都是一个元素(tuple)。

    # 第一种: len(nums)==len(s)的情况
    nums1 = [1,2,3]
    s = ['a','b','c']
    print(list(zip(nums1,s)))
    
    # 输出结果
    [(1, 'a'), (2, 'b'), (3, 'c')]
    
    
    # 第二种: len(nums)<len(s)
    nums1 = [1,2]
    s = ['a','b','c']
    print(list(zip(nums1,s)))
    
    # 输出结果
    [(1, 'a'), (2, 'b')]
    
    
    # 第三种情况 len(nums)>len(s)
    nums1 = [1,2,3]
    s = ['a','b']
    print(list(zip(nums1,s)))
    
    # 输出结果
    [(1, 'a'), (2, 'b')]
    

    可以发现,在进行组合时,总是以最短的迭代为准

    3. reduce()函数

    reduce()可以理解为具有聚合功能的函数。它会把参数序列按照指定的方式进行聚合。

    例如:求列表中的所有元素相乘之后的结果

    from functools import reduce
    nums = [1,2,3,4,5]
    re = reduce(lambda x,y: x*y, nums)
    print(re)
    
    # 输出结果
    120

    4. filter()函数

    filter()函数可以理解为具有过滤功能的函数。它会对给定的参数序列进行特定条件的删选。

    例如:获取一个列表中的偶数

    nums = [1,2,3,4,5,6,7,8,9]
    re = filter(lambda x:x%2==0, nums)
    print(list(re))
    
    # 输出结果
    [2, 4, 6, 8]
    

    5.id函数

    id()函数用于查看指定对象的内存地址,即id(对象)

    6. type()函数

    type()函数用于查看对象的类型,即type(对象)

     

    展开全文
  • python 常用的内置函数

    2019-10-30 21:41:16
    内置函数 作用 dict() 创建一个字典 help() 查看函数用途和说明 dir() 函数不带参数时,返回当前范围内变量、方法和定义类型列表;带参数时,返回参数属性、方法列表。如果参数包含方法__dir__(),...
    内置函数 作用
    dict() 创建一个字典
    help() 查看函数的用途和说明
    dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
    hex() 用于将10进制整数转换成16进制,以字符串形式表示。
    divmod() 把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。在 python 2.3 版本之前不允许处理复数。
    next() 迭代到下一个项目
    sorted() 对所有可迭代的对象进行排序操作。
    id() 用于获取对象的内存地址。
    oct() 将一个整数转化为八进制的字符串
    bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
    open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
    str() 将对象转化为适于人阅读的形式。
    sum() 对序列进行求和计算
    filter 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
    format() Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数,位置可以不按顺序。

    博客断了好长时间了,争取把博客重新拾起来,让自己的知识更上一层楼

    展开全文
  • Python常用的内置函数

    2019-09-26 09:21:57
    print函数是你学Python接触到第一个函数,它将对象输出到标准输出流,可将任意多个对象打印出来,函数的具体定义: print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) objects 是可变参数,所以...

    print()

    print函数是你学Python接触到的第一个函数,它将对象输出到标准输出流,可将任意多个对象打印出来,函数的具体定义:

    print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

    objects 是可变参数,所以你可以同时将任意多个对象打印出来

    >>> print(1,2,3)
    1 2 3

    默认使用空格分隔每个对象,通过指定sep参数可以使用逗号分隔

    >>> print(1,2,3, sep=',')
    1,2,3

    对象默认输出的是标准输出流,你也可以将内容保存到文件中

    >>> print(1,2,3, sep=',', file=open("hello.txt", "w"))

    isinstance()

    可以用 isinstance 函数判断某个对象是否属于某个类的实例,函数的定义

    isinstance(object, classinfo)

    classinfo 既可以是单个类型对象,也可以是由多个类型对象组成的元组,只要object的类型是元组中任意一个就返回True,否则返回False

    >>> isinstance(1, (int, str))
    True
    >>> isinstance("", (int, str))
    True
    >>> isinstance([], dict)
    False

    range()

    range函数是个工厂方法,用于构造一个从[start, stop) (不包含stop)之间的连续的不可变的整数序列对象,这个序列功能上和列表非常类似,函数定义:

    range([start,] stop [, step]) -> range object
    • start 可选参数,序列的起点,默认是0
    • stop 必选参数,序列的终点(不包含)
    • step 可选参数,序列的步长,默认是1,生成的元素规律是 r[i] = start + step*i

    生成0~5的列表

    >>> 
    >>> range(5)
    range(0, 5)
    >>> 
    >>> list(range(5))
    [0, 1, 2, 3, 4]
    >>>

    默认从0开始,生成0到4之间的5个整数,不包含5,step 默认是1,每次都是在前一次加1

    如果你想将某个操作重复执行n遍,就可以使用for循环配置range函数实现

    >>> for i in range(3):
    ...     print("hello python")
    ...
    hello python
    hello python
    hello python

    步长为2

    >>> range(1, 10, 2)
    range(1, 10, 2)
    >>> list(range(1, 10, 2))
    [1, 3, 5, 7, 9]

    起点从1开始,终点10,步长为2,每次都在前一个元素的基础上加2,构成1到10之间的奇数。

    enumerate()

    用于枚举可迭代对象,同时还可以得到每次元素的下表索引值,函数定义:

    enumerate(iterable, start=0)

    例如:

    >>> for index, value in enumerate("python"):
    ...     print(index, value)
    ...
    0 p
    1 y
    2 t
    3 h
    4 o
    5 n

    index 默认从0开始,如果显式指定参数start,下标索引就从start开始

    >>> for index, value in enumerate("python", start=1):
    ...     print(index, value)
    ...
    1 p
    2 y
    3 t
    4 h
    5 o
    6 n

    如果不使用enumerate函数,要获取元素的下标索引,则需要更多的代码:

    def my_enumerate(sequence, start=0):
        n = start
        for e in sequence:
            yield n, e
            n += 1
    >>> for index, value in my_enumerate("python"):
        print(index, value)
    
    0 p
    1 y
    2 t
    3 h
    4 o
    5 n

    len

    len 用于获取容器对象中的元素个数,例如判断列表是否为空可以用 len 函数

    >>> len([1,2,3])
    3
    >>> len("python")
    6
    
    >>> if len([]) == 0:
            pass

    并不是所有对象都支持len操作的,例如:

    >>> len(True)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: object of type 'bool' has no len()

    除了序列对象和集合对象,自定义类必须实现了 __len__ 方法能作用在len函数上

    reversed()

    reversed() 反转序列对象,你可以将字符串进行反转,将列表进行反转,将元组反转

    >>> list(reversed([1,2,3]))
    [3, 2, 1]

    open()

    open 函数用于构造文件对象,构建后可对其进行内容的读写操作

    open(file, mode='r', encoding=None)

    读操作

    # 从当前路径打开文件 test.txt, 默认以读的方式
    >>>f = open("test.txt")
    >>>f.read()
    ...

    有时还需要指定编码格式,否则会遇到乱码

    f = open("test.txt", encoding='utf8')

    写操作

    >>>f = open("hello.text", 'w', encoding='utf8')
    >>>f.write("hello python"))

    文件中存在内容时原来的内容将别覆盖,如果不想被覆盖,直接将新的内容追加到文件末尾,可以使用 a 模式

    f = open("hello.text", 'a', encoding='utf8')
    f.write("!!!")

    sorted()

    sroted 是对列表进行重新排序,当然其他可迭代对象都支持重新排放,返回一个新对象,原对象保持不变

    >>> sorted([1,4,2,1,0])
    [0, 1, 1, 2, 4]

    转载于:https://www.cnblogs.com/kadycui/p/10415511.html

    展开全文
  • 这篇文章整理一下python常用的内置函数, 所谓python的内置函数,就是不用import就可以直接使用, 并且用起来也非常方便, 所以在这里集中总结一下。 由于这些内置函数非常简单, 所以这里不会详细介绍原理, 依然是...
  • 常用内置函数:(不用import就可以直接使用) :help(obj) 在线帮助, obj可是任何类型callable(obj) 查看一个obj是不是可以像函数一样调用repr(obj) 得到obj表示字符串,可以利用这个字符串eval重建该对象一个拷贝...
  • 1 返回数字绝对值。参数可以是整数或浮点数。如果参数是复数,则返回其大小。23 all(可迭代)4 返回True如果所有元素迭代是真实(或者如果可迭代为空)。相当于:56 高清 全(迭代器):7 为 元素 迭代:8 如果 ...
  • 用max函数取出这个列表中年龄最大一个值#name = [#{'name':'alex1','age':18},#{'name':'alex2','age':20},#{'name':'alex3','age':21},#{'name':'alex4','age':100},#{'name':'alex5','age':1000}#]#l = []#for i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,345
精华内容 1,338
关键字:

python常用的内置函数

python 订阅