常用函数 Python

Code PV:

常用python函数

  • 数学相关: abs / divmod / pow / round / min / max / sum
  • 序列相关: len / range / next / filter / map / sorted / slice / reversed
  • 类型转换: chr / ord / str / bool / int / float / complex / bin / oct / hex
  • 数据结构: dict / list / set / tuple
  • 其他函数: all / any / id / input / open / print / type

数学相关

  • abs 计算绝对值
    1
    2
    3
    4
    l = [-1,5,-6,11,6,-19]
    print(sorted(l,key=abs)) #按绝对值排序
    for i in l:
        print(abs(i))#逐个打印绝对值

divmod 除几余几

1
print(divmod(10,3))#返回一个元组

pow 幂运算

1
2
print(pow(2,3))#2的3次幂

round 小数精确，精确到小数点后几位，可以精确到小数点前几位，前几位用负数表示，均四舍五入

1
2
3
4
5
6
a = 8115/4
print(a.__round__(1))#变量a的内置方法
print(a.__round__(-2))
print(round(8115/4,1))#内置函数
print(round(8115/4,-2))

min 返回给定参数的最小值，参数可以为序列。可以加入一个key的索引

1
2
3
4

l = [1,2,3,4,5,-5]
print(min(l,key=abs))#绝对值最小
print(min(l))#最小

max 返回给定参数的最大值，参数可以为序列。可以加入一个key的索引

1
2
3
4
l = [1,2,3,4,5,-5]
print(max(l,key=abs))#绝对值最大
print(max(l))#最大

sum 求和 ，传入一个可迭代对象求和,可以继续传入一个起始求和的参数，默认为0

1
2
3
4
l = [1,2,3,4,5,-5]
print(sum(l))#10
print(sum(l,2))#12

序列相关

len 返回字符串、列表、字典、元组等长度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# len(str)
# str：要计算的字符串、列表、字典、元组等
# a.计算字符串的长度：
s = "hello good boy doiido"
len(s)

# b.计算列表的元素个数：
l = ['h','e','l','l','o']
len(l)

# c.计算字典的总长度(即键值对总数)
d = {'num':123,'name':"doiido"}
len(d)

# d.计算元组元素个数：
t = ('G','o','o','d')
len(t)

range 返回一系列连续增加的整数，它的工作方式类似于分片，可以生成一个列表对象。range函数大多数时常出现在for循环中，在for循环中可做为索引使用。其实它也可以出现在任何需要整数列表的环境中，在python 3.0中range函数是一个迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
# range()函数内只有一个参数，则表示会产生从0开始计数的整数列表
range(4) # [0, 1, 2, 3]

# 传入两个参数时，则将第一个参数做为起始位，第二个参数为结束位
range(0,5) # [0, 1, 2, 3, 4]

# 填入三个参数，第三个参数是步进值（步进值默认为1）
range(0,10,3)  # [0, 3, 6, 9]

# range函数的参数和结果也并非一定要是正数或是递增的
range(-4,4)    # [-4, -3, -2, -1, 0, 1, 2, 3]
range(4,-4,-1) # [4, 3, 2, 1, 0, -1, -2, -3]

next 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# next(iterable[, default])
# next() 返回迭代器的下一个项目
# next() 函数要和生成迭代器的 iter() 函数一起使用
# iterable -- 可迭代对象
# default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

enumerate 将一个可遍历的数据对象 (如列表、元组或字符串) 组合为一个索引序列，同时列出数据和数据下标

1
2
3
4
5
6
7
8
# enumerate(sequence, [start=0])
# sequence – 一个序列、迭代器或其他支持迭代对象。
# start – 下标起始位置。
# 返回 enumerate(枚举) 对象

the_str = "Python."
the_str = enumerate(the_str)
print(list(the_str)) # [(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')]

filter 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

1
2
3
4
5
6
7
8
9
10
11
# filter(function, iterable)
# function – 判断函数
# iterable – 可迭代对象
# 返回一个迭代器对象

# eg.过滤出列表中所有的奇数
lst = [i for i in range(20)]
lst = filter(lambda x:x%2==1,lst)
print(list(lst))
# [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

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

1
2
3
4
5
6
7
8
9
# map(function, iterable, ...)
# function -- 函数
# iterable -- 一个或多个序列
def square(x) :         # 计算平方数
    return x ** 2

map(square, [1,2,3,4,5])    # 计算列表各个元素的平方 # <map object at 0x100d3d550>     # 返回迭代器
list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表 # [1, 4, 9, 16, 25]
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数 # [1, 4, 9, 16, 25]

sorted 对所有可迭代的对象进行排序操作

1
2
3
4
5
6
7
8
9
10
# sorted(iterable, key=None, reverse=False)
# iterable – 可迭代对象。
# key – 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键进行排序
# reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
# 返回重新排序的列表

# eg.根据文件名中的数字进行排序
files_name = ['py1.py','py10.py','py2.py','py5.py','py14.py']
lst =sorted(files_name,key=lambda x:int(x[2:-3]))
# ['py1.py', 'py2.py', 'py5.py', 'py10.py', 'py14.py']

slice 

1
2
3
4
l3 = [1,2,3,4,5,1,2,3,4,5]
sli = slice(0,4,2)#定义一个切片规则
print(l3[sli])#[1, 3]
print(l3[0:4:2])#[1, 3]效果一样

reversed 

1
2
3
4
5
6
7
8
9
10
11
# 列表中reverse() 起到反转列表的作用，替换原有的列表
l = [1,2,3,4,5]
l.reverse()
print(l)#[5, 4, 3, 2, 1]

# reversed 则是不替换原有序列，返回一个迭代器，更节省内存
l1 = [11,22,33,44,55]
l2 = reversed(l1)
print(l1)#[11, 22, 33, 44, 55]原列表不变
print(l2)#返回一个迭代器
print(list(l2))#强转为列表打印出来[55, 44, 33, 22, 11]

类型转换

chr 将整数转化成对应的字符

1
2
3
4
5
6
chr(65) # 'A'
chr(32) # ' '
chr(16) # '\x10'
chr(20) # '\x14'
chr(26) # '\x1a'
chr(35) # '#'

ord 将字符转换成整数

1
2
3
4
5
ord('#')   # 35
ord('\x01')   # 1
ord('A')   # 65
ord('a')   # 97
ord(' ')   # 32

str 把数、字符、列表、元组、字典转换成字符串

1
2
3
4
5
str(5)          #'5'
str('c')        #'c'
str([1,2,3])    #'[1, 2, 3]'
str((1,2))      #'(1, 2)'
str({'1':2})    #"{'1': 2}"

bool 将一个值转化为布尔值，如果该值为假或省略返回False，否则返回True

1
2
3
4
5
6
a = [0, 0.0, False, None, '', (), [], {}]
for i in a:
	print(bool(i), end = ' ') # False False False False False False False False 
b = [1, -1, 1.0, '#', (2, 3), ['a'], {'a': 1}, 'b']
for i in b:
	print(bool(i), end = ' ') # True True True True True True True True

int 把一个数、字符转换成整形。如果未空，返回0,；如果是数，返回x.int();如果是浮点数，取整数部分
int(x, base = 10)
如果给出base, 依据base返回对应值

1
2
3
4
5
6
7
8
int()       # 0
int(0.9)    # 0
int(-1)     # -1
int('123')  # 123
int ('123', base = 10)  # 123
int('123', base = 16)   # 291
int('0xEE', base = 16)  # 238
int('0b11111111', base = 2)  # 255

float 把字符串或者一个数转换成浮点数

1
2
3
4
float(1)          #1.0
float('1.123')    #1.123
float ('   1.1')  #1.1
float(' -123')    #-123.0

complex 

1
2
3
4
5
6
# class complex([real[, imag]])
# real -- int, long, float或字符串；
# imag -- int, long, float；
# 返回一个复数
complex(1, 2)  # (1 + 2j)
complex(1)     # 数字 (1 + 0j)

bin 

1
bin(0xa)   # '0b1010'

oct 二进制转八进制

1
oct(0b1010) # '0o12'

hex 十进制转十六进制：

1
hex(10)     # '0xa'

数据结构

dict
list
set
tuple

其他函数

all all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 函数等价于：
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

# all(iterable)
# iterable -- 元组或列表
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
```````
any any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
```python
# 函数等价于：
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

# any(iterable)
# iterable -- 元组或列表。
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

id 返回对象的唯一标识符，标识符是一个整数。
CPython 中 id() 函数用于获取对象的内存地址。

1
2
3
4
a = 'runoob'
id(a)  #4531887632
b = 1
id(b)  #140588731085608

input Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。

1
2
3
4
5
a = input("input:")     # input:123                  # 输入整数
type(a)                 # <type 'int'>               # 整型
a = input("input:")     # input:"runoob"           # 正确，字符串表达式
type(a)                 # <type 'str'>             # 字符串
a = input("input:")

open 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# open(name[, mode[, buffering]])
# name : 一个包含了你要访问的文件名称的字符串值。
# mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
# buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
# 模式	描述
# t	    文本模式 (默认)。
# x	    写模式，新建一个文件，如果该文件已存在则会报错。
# b	    二进制模式。
# +	    打开一个文件进行更新(可读可写)。
# U	    通用换行模式（不推荐）。
# r	    以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
# r+	打开一个文件用于读写。文件指针将会放在文件的开头。
# rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
# w	    打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
# wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
# wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# a	    打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
# ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
  • file 对象方法
  • file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回””(空字串)。
  • file.readline()：返回一行。
  • file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
  • for line in f: print line ：通过迭代器访问。
  • f.write(“hello\n”)：如果要写入字符串以外的数据,先将他转换为字符串。
  • f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的字节数)。
  • f.seek(偏移量,[起始位置])：用来移动文件指针
  • 偏移量: 单位为字节，可正可负
  • 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
  • f.close() 关闭文件

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

1
2
3
4
5
6
# print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
# objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
# sep -- 用来间隔多个对象，默认值是一个空格。
# end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
# file -- 要写入的文件对象。
# flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

type

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# type(object)
# type(name, bases, dict)
# name -- 类的名称。
# bases -- 基类的元组。
# dict -- 字典，类内定义的命名空间变量
# 一个参数实例
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'>

参考链接：
https://blog.csdn.net/qq_36078992/article/details/105174536
https://www.cnblogs.com/aizhinong/p/11407695.html
https://blog.csdn.net/qq_36357820/article/details/77850841

Powered by Hexo and Hexo-theme-hiker

Copyright © 2013 - 2024 HELLO WORLD All Rights Reserved.

UV : | PV :