python 常用函数

Aube_Z

已于 2024-08-03 14:53:15 修改

阅读量626

点赞数 12

文章标签： python 开发语言

于 2024-07-27 17:44:34 首次发布

本文链接：https://blog.csdn.net/Aube_Z/article/details/140717229

版权

python

sorted()

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

sorted(list,key=lambda x:len(x),reverse=True)

import operator
tuple_list = [('A', 1,5), ('B', 3,2), ('C', 2,6)]
print(sorted(tuple_list, key=operator.itemgetter(1) ))

zip()

zip([iterable, …])

m = [1, 2, 3]
n = [4, 5, 6]
m_n = list(zip(m,n))

nums = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']]
# 参数为list数组时，是压缩数据，相当于zip()函数
iters = zip(*nums) 

m,n = zip(*m_n) # 逆过程

map()

3
map(function,iterable,…)

def a(x):
    return x*2
 
#定义列表
lis1=[1,3,5,7,9]
 
#对列表中的每个数运用函数a，返回迭代器
lis1_a=map(a,lis1)
 
#输出迭代器中的值
for num in lis1_a:

 def a(x,y):
 
    return x * y
 
# 定义列表1
lis1 = [1, 3, 5, 7, 9]
# 定义列表2
lis2 = [2, 4, 6, 8, 10]
 
# 将两个列表中的值，传入函数a，并返回可迭代器

filter()

4
filter(function,iterable)
函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#使用filter()函数和Lambda函数筛选出奇数
odd_numbers = filter(lambda x: x % 2 != 0, numbers)
#将结果转换为列表
odd_numbers_list = list(odd_numbers)

reduce()

5
reduce(function,literable, init_number)
对所有的对象进行计算

from functools import reduce
numbers = [5, 8, 2, 10, 3]

# 使用reduce()函数结合lambda函数求列表中的最大值和最小值
max_value = reduce(lambda x, y: x if x > y else y, numbers)
min_value = reduce(lambda x, y: x if x < y else y, numbers)

print("Max value:", max_value)  # 输出：Max value: 10
print("Min value:", min_value)  # 输出：Min value: 2

from functools import reduce
import operator

numbers = [1, 2, 3, 4, 5]
# 不指定初始值
result1 = reduce(operator.add, numbers)
print("Result without initial value:", result1)  # 输出：Result without initial value: 15

# 指定初始值为10
result2 = reduce(operator.add, numbers, 10)
print("Result with initial value:", result2)  # 输出：Result with initial value: 25

split()

按指定字符串拆分

s = 'i love python'
words = s.split(' ')

join()

7
Python中有.join()和os.path.join()两个函数，具体作用如下：
. join()：将序列（也就是字符串、元组、列表、字典）中的元素以指定的字符连接生成一个新的字符串。
os.path.join()：将多个路径进行拼接。或者称之为合并目录。

a=['I','love','China','!']
print(' '.join(a))
print('-'.join(a))
print('*'.join(a))

#结果：
I love China !
I-love-China-!
I*love*China*!

import os
filedir = os.path.join('/home/ubuntu/a/', 'b/c/','d')
print(filedir)
结果：
/home/ubuntu/a/b/c/d

strip()

去除两端的空格/指定符号

lstrip() : 去除左端的空格
rstrip(): 去除右端的空格

replace()

9
replace() 可以「替换」字符串中的内容
string.replace( old, new, count )

t1 = 'h h h , interesting'
t2 = t1.replace('h', 'w', 2)

# t2: 'w w h , interesting'

enumerate()

枚举
enumerate(sequence, [start=0]) start 指定开始序号

l = ['a', 'b', 'c']

for i, c in enumerate(l, start = 1):
	pass

range()

range(start ,stop, setp)

for i in range(1,7,2):
	print(i)
#1
#3
#5

all()

是否全都为真
这里所说的“真”和“假”是基于Python的布尔上下文。

在Python中，以下值被视为False：
数字0
空字符串（“”）
空列表（[]）
空元组（()）
空集合（{}）
None
False本身

# 示例1：所有元素都为真值
lst1 = [True, 1, "hello", [1, 2, 3]]
print(all(lst1))  # 输出：True

# 示例2：有一个元素为假值
lst2 = [True, 0, "hello", [1, 2, 3]]
print(all(lst2))  # 输出：False

# 示例3：空的可迭代对象
lst3 = []
print(all(lst3))  # 输出：True

# 示例4：非可迭代对象
num = 123
print(all(num))  # 报错：TypeError: 'int' object is not iterable

## 5
number = [1,4,5]
print(all(x>0 for x in number)) # True

eval()

13
把里面的字符串参数的引号去掉，把中间的内容当成Python的代码，eval 函数会执行这段代码并且返回执行结果

# 1. 字符串重复
result = eval("'+' * 5")
print(result)  # +++++

input_number = input("请输入一个加减乘除运算公式：")
print(eval(input_number))

不要滥用 eval() 在开发时千万不要使用eval直接转换input的结果因为如果用户直接通过os这个模块来调用system方法可以执行任何的终端命令，这样细想很恐怖，家底都给暴露出来了

open()

打开文件

f = open(path,'r')

reversed()

15
数据进行反转

#将列表进行逆序
print([x for x in reversed([1,2,3,4,5])])

#将元组进行逆序
print([x for x in reversed((1,2,3,4,5))])

#将字符串进行逆序
print([x for x in reversed("abcdefg")])

#将 range() 生成的区间列表进行逆序
print([x for x in reversed(range(10))])

len()

返回长度

dd = 'iiiiii'
print(len(dd)) # 6

type()

返回对象的类型

a = 10
print(type(a)) # int

lambda

匿名函数
lambda arguments: expression

# 1.
f = lambda: "Hello, world!"
print(f())  # 输出: Hello, world!

# 2.
x = lambda a, b, c : a + b + c
print(x(5, 6, 2)) # 13

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

# 4.使用 lambda 函数与 filter() 一起，筛选偶数：
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出：[2, 4, 6, 8]

# 5.下面是一个使用 reduce() 和 lambda 表达式演示如何计算一个序列的累积乘积：
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# 使用 reduce() 和 lambda 函数计算乘积
product = reduce(lambda x, y: x * y, numbers)
 
print(product)  # 输出：120

round()

返回四舍五入
rounded_number = round(number, ndigits) # ndigits 是舍入到小数点后的位数。

# 将浮点数 3.14159 舍入到最接近的整数
rounded_number = round(3.14159)
print(rounded_number)  # 输出: 3
 
# 将浮点数 3.14159 舍入到小数点后两位
rounded_number = round(3.14159, 2)
print(rounded_number)  # 输出: 3.14

math.floor()

向下取整

import math
# 向下舍入
rounded_number_down = math.floor(3.7)
print(rounded_number_down)  # 输出: 3

math.ceil()

向上取整

import math
# 向上舍入
rounded_number_up = math.ceil(3.2)
print(rounded_number_up)  # 输出: 4

abs()

取绝对值

a = -11.5
print(abs(a)) # 11.5

try except

捕获异常

try:
执行代码
except :
发生异常执行的代码
else:
不发生异常执行的代码
finally:
不管是否发生异常都会执行的代码

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

raise 引起一个异常

>>> try:
        raise NameError('HiThere')  # 模拟一个异常。
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

bytes()

将字符串转换为字节类型

# 使用字符串和编码构造 bytes 对象
s = "Hello, 世界"
b = bytes(s, 'utf-8')
print(b)  # 输出: b'Hello, \xe4\xb8\x96\xe7\x95\x8c'
 
# 从整数构造 bytes 对象
b = bytes(5)
print(b)  # 输出: b'\x00\x00\x00\x00\x00'
 
# 从可迭代对象构造 bytes 对象
b = bytes([65, 66, 67, 68])
print(b)  # 输出: b'ABCD'
 
# 通过缓冲区接口对象构造 bytes 对象
ba = bytearray(b'hello')
b = bytes(ba)
print(b)  # 输出: b'hello'

s = "Hello, World!"
b = s.encode('utf-8')
print(b)  # 输出：b'Hello, World!'

time 模块

time.time()

返回当前时间的时间戳
time模块

时间一共有3种表达形式：

时间戳（Timestamp）

1634864031.0

时间元组（struct_time）

(tm_year=2021, tm_mon=10, tm_mday=22, tm_hour=0, tm_min=40, tm_sec=48, tm_wday=4, tm_yday=295, tm_isdst=0)

格式化字符串（Format string）

‘Fri Oct 22 08:57:42 2021’

在这里插入图片描述

导入time包：import time
获取时间戳：tt = time.time()
时间戳->时间元组：

time.localtime(time.time())如果括号内不加参数，表示将当前时间转换为时间元组。
time.gmtime(time.time())将一个时间戳转换为UTC时区（0时区）的struct_time。

时间元组->时间戳：time.mktime(t)
时间戳->时间string：

time.ctime([sec]) 括号内不加参数，默认返回当前时间的时间字符串。time.ctime(time.time())

时间元组->时间string：

time.asctime([tuple]) 如果括号内不给参数，则默认返回当前时间的字符串，相当于time.asctime(time.localtime())。
time.strftime(format [，tuple]) 指定形式

字符串->时间元组：time.strptime(str，format)
time.sleep(sec)可以让程序等待sec的秒数，括号内可以是int或者float的数。

re 模块

24
24-2
24-3

正则表达式

在这里插入图片描述

re.match()

# 导入
import re
# 1.1
 m = re.match(pattern,string)
# 1.2
p = re.compile(pattern)
m = p.match(string)

# 2.
m.group() # 0 和空值代表从第一位开始匹配的值，

>>>import re
>>> pattern = re.compile(r'\d+')   
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

re.search()

re.search 扫描整个字符串并返回第一个成功的匹配，如果没有匹配，就返回一个 None。

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配

import re
ret = re.search(r"\d+", "阅读次数为9999")
print(ret.group())
# 9999

re.sub()

re.sub(pattern, repl, string, count=0, flags=0)

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import re
 
phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print "电话号码是: ", num
 
# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print "电话号码是 : ", num

电话号码是:  2004-959-559 
电话号码是 :  2004959559

re.findall()

findall(string[, pos[, endpos]])
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。

# -*- coding:UTF8 -*-
 
import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)

['123', '456']
['88', '12']

isinstance()

判断对象是否为指定类型

my_list = [3,5,7]
my_int = 10
if isinstance(my_list, list): 
	print('is list')
	# is list

os 模块

os.mkdir()

os.mkdir(path) 创建目录

json 模块

json.loads()

导入json数据

import json

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = json.loads(jsonData)
print(text)

# {u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

json.dumps()

用于将 Python 对象编码成 JSON 字符串。

import json

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]
data2 = json.dumps(data)

data2 = json.dumps({'a': 'Runoob', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': '))
print(data2)

{
    "a": "Runoob",
    "b": 7
}

requests

import requests

requests.get(url)

requests.post()

requests.put()

requests.delete()

requests.patch()

requests.Session()

session = requests.Session()

hash()

31
31-2

返回对象的哈希值：哈希值是一个固定长度的整数，用于表示一个对象的状态或标识，通常用于构建字典、集合等数据结构，以及进行数据加密等方面。

所有的不可变类型都具有可哈希性，包括数字、字符串、元组等，而可变类型如列表、字典、集合等则没有可哈希性。

常见的hash算法：
1、除法哈希算法
2、乘法哈希算法
3、平方取中法
3、随机数哈希算法

hash_value = hash('hello world')
index = hash_value % 10

哈希值在字典、集合等数据结构中非常有用，用于快速查找和比较对象。
自定义对象的哈希值需要实现 hash() 方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __hash__(self):
        # 自定义哈希值计算逻辑
        return hash((self.name, self.age))
 
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
 
# 计算自定义对象的哈希值
print(f"Person1 hash: {hash(person1)}")
print(f"Person2 hash: {hash(person2)}")

哈希表的存储与查找

# 创建哈希表
hash_table = {}
 
# 插入元素
hash_table[hash("apple")] = 42
hash_table[hash("banana")] = 17
hash_table[hash("orange")] = 33
 
# 查找元素
print(hash_table[hash("apple")])  # 42

安全哈希算法

import hashlib
 
password = "password123"
hashed_password = hashlib.sha256(password.encode()).hexdigest()
print(hashed_password)

globals()

globals() 返回的是一个字典，其中包含了全局作用域中的所有变量。
获取全局变量表，前边为内置方法，后边为自定义的变量与方法。

注意不要修改这个字典，以免影响程序的正常运行。

a=123
b='hello'
c=True
def d():
    e=456
    f='world'
print(globals())

在这里插入图片描述

setattr()和getattr()

设置对象的属性值
setattr(object, attribute, value)

获取一个对象的属性值或方法
getattr(object, name[, default])

class Test(object):
    test = 1
 
print(Test.test) # 1
print(Test().test) # 1
 
obj = Test()
ret = getattr(obj, 'test')  # 获取属性 test 值
print(ret) # 1
 
setattr(obj, 'test', 5)  # 设置属性 test 值
print(obj.test) # 5

frozenset()

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。

str.format()

字符格式化

name = 'alice'
age = 18
print('i am {}, i am {}'.format(name, age))
# i am alice, i am 18
print('i am {}, i am {}'.format('bob', 20))
# i am bob, i am 20
print('i am {0},i am {2};i am {1},i am {2}'.format('alice','bob',18))
# i am alice,i am 18;i am bob,i am 18
print(i am {name1},i am {age};i am {name2},i am {age}'.format(name1='alice',name2='bob',age=18))

people = {
	name: 'alice',
	age: 18
}
print('i am {}, i am {}'.format(**people)) # 可以传入多个
# i am alice, i am 18

class Dog:
    def __init__(self, name):
        self.name = name

class Mouse:
    def __init__(self, name):
        self.name = name


tom = Dog("Tom")
jerry = Mouse("Jerry")

str_1 = "{0.name} want to eat {1.name}".format(tom, jerry)
print(str_1)

传入list

list_1 = ["ZhangSan","https://blog.csdn.net/KaiSarH"]
list_2 = ["KaiSarH", "http:www.baidu.com"]
str_3 = "博主：{1[0]}, 博客地址：{0[1]}".format(list_1, list_2)

数字格式化

38-2

super()

调用父类的方法

调用父类的初始化方法：
super().init(self, attr)

class A:
    def hi(self):
        print("A hi")

class B(A):
    def hello(self):
        print("B hello")
        
b = B()
b.hi()       # B里没有写hi(),这里调用的是继承自A的hi()

------------------------------------------------------------------
class A:
    def hi(self):
        print("A hi")

class B(A):
    def hi(self):
        print("B hi")
        
b = B()
b.hi()    # 这里调用的就是B自己的hi()
------------------------------------------------------------------
class A:
    def hi(self):
        print("A hi")

class B(A):
    def hi(self):
        super().hi()        
         # 通过super调用父类A的hi()
         # A.hi()
        print("B hi")
        
b = B()
b.hi()    # 这里调用的就是B里面的hi()

divmod()

同时执行除法和取模

result = divmod(10,3)
print(result)
# (3,1)

list()

将可迭代对象转为列表

ord()

用于返回字符的Unicode码

chr(97) #返回字母a
chr(20320) #返回汉字 “你”

ord("a")  #返回字母a对应的ASCII码：97
ord("aa")  #报错，参数不能是字符串，只能是字符

sum()

对可迭代对象求和

slice()

创建一个切片对象

s = slice(1, 5, 2)
seq = [0, 1, 2, 3, 4, 5, 6]
start, stop, step = s.indices(len(seq))
result = []
for i in range(start, stop, step):
    result.append(seq[i])
print(result)   # [1, 3]

import

动态导入模块

encode

转换为字节字符串

str.encode([encoding=“utf-8”][,errors=“strict”])

#定义str
str = '我爱我的强大的国家——中国'
 
#①默认编码类型utf-8和报错方式为strict
a = str.encode()
a
 
#②编码类型为‘gbk’和默认报错方式为strict
b = str.encode(encoding='gbk')
b
 
#④编码类型为‘gb18030’和默认报错方式为strict
c = str.encode(encoding='gb18030')
c
 
#⑤编码类型为‘gbk’和默认报错方式为ignore
e = str.encode(encoding='gb2312',errors ='ignore')
e

decode

将目标二进制数据bytes转为目标字符串str类型

bytes.decode([encoding=“utf-8”][,errors=“strict”)

#解码decode
#定义str
str = '我爱我的强大的国家——中国'
 
#解码utf-8类型
#定义bs
bs=str.encode() #默认utf-8类型的bytes
a = bs.decode()
a
 
#解码gb18030类型
#①解码为gb18030
bs=str.encode(encoding='gb18030') #默认utf-8类型的bytes
b = bs.decode(encoding='gb18030')
b
 
#②解码为gbk
c = bs.decode(encoding='gbk')
c
 
#③解码为gb2312
d = bs.decode(encoding='gb2312')
d

count()

统计在可迭代对象中某个元素出现的次数

fruits = ['apple', 'banana', 'orange', 'apple', 'grape', 'apple']
count = fruits.count('apple')
print(count) # 3

index()

进行索引位置

fruits = ['apple', 'banana', 'orange', 'apple', 'grape', 'apple']
f = fruits.index('orange')
# f 2

a = fruits.index('apple',3,5,2) # 从下标3 开始查找，到下标5 ，第2次出现的位置
# a 5

find()

用于查找子字符串在字符串中的位置
str.find(sub,start[, end]])

str = 'hello world'
index = str.find('wo')
# index 6

update()

dict.update(dict2)

#!/usr/bin/python

tinydict = {'Name': 'Zara', 'Age': 7}
tinydict2 = {'Sex': 'female' }

tinydict.update(tinydict2)
print ("Value : %s" %  tinydict)
# Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}