python函数

内建函数：

type():判断一个数的类型

a=-11.37
type(a)

#输出
float

ord(x):取ASCCI码值

abs(x): 取绝对值

abs(-10)  

#输出
10

.items():将字典转换为一个键值对的元组列表

zip()：将列表压缩在一起变成一个元组

a＝[1,2,3]
b=[4,5,6]
d=list(zip(a,b))
print(d)

[(1,4),(2,5),(3,6)]

del:删除一个元素

del object #删除一个变量
my_list = [1, 2, 3, 4, 5]
del my_list[2] # 删除索引为2的元素，即3
print(my_list) # 输出 [1, 2, 4, 5]

.upper():将字符串全部转换为大写

.lower():将字符串全部转换为小写

.count():统计列表中某个元素出现的次数

l = ['d', 'b', 'a', 'f', 'd']print("l.count('d') -->", l.count('d'))

输出结果：

l.count('d') --> 2

十进制转二进制：bin()函数

十进制转八进制：oct()函数

`oct()`函数的返回值是一个字符串，表示转换后的八进制数。需要注意的是，转换后的字符串前面会带有`0o`前缀，表示这是一个八进制数。如果不需要前缀，可以使用字符串切片操作去掉前两个字符，即oct_num[2:]

dec_num = 123  # 十进制数
oct_num = oct(dec_num)  # 转换为八进制数
print(oct_num)  # 输出：0o173 
print(oct_num)[2:] #输出：173

十进制转十六进制：hex()函数

num = 255
hex_num = hex(num)
print(hex_num)  # 输出：0xff
print(hex_num[2:]) #输出： ff

.join()：连接符

‘连接符’.join([str1,str2,str3])：拼接字符串

a = 'www'
b = 'baidu'
c = 'com'

new_str = '.'.join([a,b,c])
print(new_str)   #输出结果： www.baidu.com

.index():查找某个元素在列表中首次出现的位置（即索引）

l = ['d', 'b', 'a', 'f', 'd']print("l.index('d') -->", l.index('d'))

输出结果：

l.index('d') --> 0

.remove():移除列表中某个值的首次匹配项

l = ['d', 'b', 'a', 'f', 'd']l.remove('d')print("l -->", l)

输出结果：

l --> ['b', 'a', 'f', 'd']

.sort():对列表中元素进行排序（升序排序）

l = ['d', 'b', 'a', 'f', 'd']
l.sort()
print('l -->', l)

输出结果：

l --> ['a', 'b', 'd', 'd', 'f']

降序排列：.sort(reverse=True)

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

输出结果：

[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

sorted()：将序列排序

sorted([36,5,-12,9,-21])  
#[-21,-12,5,9,36]

sorted([36,5,-12,9,-21], reverse=True)  
#[36,9,5,-12,-21]

sorted([36,5,-12,9,-21], key=abs)  
#[5,9,-12,-21,36]（不会改变原来的值）

.copy():复制列表

l = ['d', 'b', 'a', 'f', 'd']lc = l.copy()print('lc -->', lc)

输出结果：

lc --> ['d', 'b', 'a', 'f', 'd']

filter()：过滤函数

filter()接收一个函数和一个序列。filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

def func(x):
	return x % 2 == 0    #返回一个bool值
a = [1,2,3,4,5,6,7,8]
print(list(filter(func,a)))    #要显示序列，先转化为list

lambda x：表达式：匿名函数（冒号前面是函数的参数）

注:只能有一个表达式，不用写return，返回值就是该表达式的结果。

f = lambda x : x * x
print(f(5))

数字类型转换：

int(a):将a转换到一个整数

float(a)：将a转换到一个浮点数

complex(a)：将a转换到一个复数，实数部分为a，虚数部分为0

complex(a,b):将a转换到一个复数，实数部分为a，虚数部分为b（a,b为数字表达式）

max(x1,x2,x3,x4,x5):返回最大值 （可以比较浮点数和整数）

max(1,2,4,6,8,9,7,5,4,3)   #返回：9

min(x1,x2,x3,x4,x5):返回最小值（可以比较浮点数和整数）

min(3.14,9,5,7,4)    #返回： 3.14

pow(a,b):a的b次方

pow(2,3)    #输出：8
pow(2.5,3)  #输出：15.625

round():对浮点数进行四舍五入（逗号后面的数字表示四舍五入到小数点后几位）

round(4.775)    

输出：5

round(4.775,2)  

输出：4.78

range():生成一定范围内的整数序列

1. range(stop)：生成从0到stop-1的整数序列，包括0但不包括stop。

range(5)

[0, 1, 2, 3, 4]

1. range(start,stop):生成从start到stop-1的整数序列，包括start但不包括stop

range(2, 6)

[2, 3, 4, 5]

1. range(start, stop, step)：生成从start到stop-1的整数序列，以step为步长。如果step为正数，则整数序列递增；如果step为负数，则整数序列递减

range(0, 10, 2)

[0, 2, 4, 6, 8]

range(10, 0, -2)

[10, 8, 6, 4, 2]

.split（）：切割字符串函数

默认空格为分隔符，如对分隔符有要求则再括号内填写

数学函数模块：（import math）

.fabs(x):返回数字的绝对值

math.fabs(-10) 

输出：10.0

注：

在python中fabs与abs是有一定区别的

1. abs函数可以用于整数、实数、复数，而fabs函数只用于实数。
2. abs函数是内置函数，而fabs函数需要从math库中引入。
3. fabs函数只返回浮点数，而abs函数对于整数返回整数，对于浮点数返回浮点数，对于复数返回复数的模。
4. fabs函数比abs函数快，因为它只需要处理浮点数，而abs函数需要处理三种不同类型的数据

.ceil(x):对数字进行向上取整

math.ceil(4.5)

输出：5

.floor(x):对数字进行向下取整

math.floor(4.9)   

输出： 4

.factorial(x):返回x的阶乘

print(math.factorial(5))

输出：20

随机数模块：（import random）

.choice()：从序列中随机挑选一个元素

import random
fruits = ['apple', 'banana', 'orange', 'pear']
random_fruit = random.choice(fruits)
print(random_fruit)

输出：orange

import random
random.choice(range(1,100))  #从1-100中随机生成一个数

输出：87

.randrange([start], stop[, step]):从指定范围内，按照指定的基数递增的集合中获取一个随机数，基数默认值为1

• start：可选参数，表示生成随机数的起始范围，默认值为0。
• stop：必选参数，表示生成随机数的结束范围。
• step：可选参数，表示生成随机数的步长，默认值为1。

import random
#生成0~9之间的随机整数
num1 = random.randrange(10)
print(num1)

# 生成1~10之间的随机整数
num2 = random.randrange(1, 11)
print(num2)

# 生成1~10之间的随机偶数
num3 = random.randrange(2, 11, 2)
print(num3)

# 生成10~1之间的随机整数
num4 = random.randrange(10, 0, -1)
print(num4)

.randint(a,b):表示生成a到b之间的随机整数

import random
random.randint(0, 100) 

.random(0,1):随机生成下一个在[0，1]范围内的实数

import random

# 生成一个0-1之间的随机浮点数
rand_num = random.random()
print(rand_num)

.shuffle():将序列中的所有元素随机排序

注：random.shuffle()用于将一个列表中的元素打乱顺序，值得注意的是使用这个方法不会生成新的列表，只是将原列表的次序打乱。

import random
x=[1,8,6,5,4,7,5]
random.shuffle(x)
print(x)

输出：[7, 6, 1, 5, 4, 5, 8]

.uniform(x,y):随机生成下一个实数，它在[x,y]范围内

import random
random.uniform(1,100)

时间模块：（import time）

索引	属性	值
0	tm_year（年）	如：1945
1	tm_mon（月）	1 ~ 12
2	tm_mday（日）	1 ~ 31
3	tm_hour（时）	0 ~ 23
4	tm_min（分）	0 ~ 59
5	tm_sec（秒）	0 ~ 61
6	tm_wday（周）	0 ~ 6
7	tm_yday（一年内第几天）	1 ~ 366
8	tm_isdst（夏时令）	-1、0、1

localtime() 表示当前时间，返回类型为 struct_time 对象，示例如下所示：

import time
t = time.localtime()
print('t-->', t)
print('tm_year-->', t.tm_year)
print('tm_year-->', t[0])

输出结果：

t--> time.struct_time(tm_year=2019, tm_mon=12, tm_mday=1, tm_hour=19, tm_min=49, tm_sec=54, tm_wday=6, tm_yday=335, tm_isdst=0)

tm_year--> 2019

tm_year--> 2019

常见函数：

函数（常量）	说明
time()	返回当前时间的时间戳
gmtime([secs])	将时间戳转换为格林威治天文时间下的 struct_time，可选参数 secs 表示从 epoch 到现在的秒数，默认为当前时间
localtime([secs])	与 gmtime() 相似，返回当地时间下的 struct_time
mktime(t)	localtime() 的反函数
asctime([t])	接收一个 struct_time 表示的时间，返回形式为：Mon Dec 2 08:53:47 2019 的字符串
ctime([secs])	ctime(secs) 相当于 asctime(localtime(secs))
strftime(format[, t])	格式化日期，接收一个 struct_time 表示的时间，并返回以可读字符串表示的当地时间
sleep(secs)	暂停执行调用线程指定的秒数
altzone	本地 DST 时区的偏移量，以 UTC 为单位的秒数
timezone	本地（非 DST）时区的偏移量，UTC 以西的秒数（西欧大部分地区为负，美国为正，英国为零）
tzname	两个字符串的元组：第一个是本地非 DST 时区的名称，第二个是本地 DST 时区的名称

import time
print(time.time())
print(time.gmtime())
print(time.localtime())
print(time.asctime(time.localtime()))
print(time.tzname)

# strftime 使用
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

re库函数

注：pattern是正则表达式，string是要匹配的字符串，flags是可选的标志参数，用于控制匹配的方式。

match(pattern, string, flags=0)：从字符串的开头开始匹配，如果匹配成功返回一个匹配对象，否则返回None。

import re
pattern = r'hello'
string = 'hello world'
match_obj = re.match(pattern, string)
if match_obj:
    print(match_obj.group())
   

#输出结果为：`hello`

search(pattern, string, flags=0)：在字符串中搜索匹配项，如果匹配成功返回一个匹配对象，否则返回None。

import re
pattern = r'world'
string = 'hello world'
search_obj = re.search(pattern, string)
if search_obj:
    print(search_obj.group())


#输出结果为：`world`

findall(pattern, string, flags=0)：在字符串中搜索所有匹配项，返回一个列表。

import re
pattern = r'\d+'
string = 'hello 123 world 456'
match_list = re.findall(pattern, string)
print(match_list)


#输出结果为：`['123', '456']`

sub(pattern, repl, string, count=0, flags=0)：在字符串中搜索匹配项，并用repl替换它们，返回替换后的字符串。

import re
pattern = r'\d+'
string = 'hello 123 world 456'
new_string = re.sub(pattern, '666', string)
print(new_string)


#输出结果为：`hello 666 world 666`

split(pattern, string, maxsplit=0, flags=0)：根据正则表达式分割字符串，返回一个列表。

import re
pattern = r'\s+'
string = 'hello world'
split_list = re.split(pattern, string)
print(split_list)
 

#输出结果为：`['hello', 'world']`

compile(pattern, flags=0)：将正则表达式编译成一个对象，以便在后面的匹配中使用。

os模块：

os.getcwd()：获取当前工作目录。

os.chdir(path)：改变当前工作目录到指定路径。

os.listdir(path)：返回指定路径下的文件和目录列表。

os.mkdir(path)：创建一个目录。

if not os.path.isdir(path):
    os.mkdir(path)
    #通常结合isdir函数一起用

os.makedirs(path)：递归创建目录。

os.remove(path)：删除指定文件。

os.rmdir(path)：删除指定目录。

os.removedirs(path)：递归删除目录（只能删除空目录）

os.rename(src, dst)：重命名文件或目录

os.path.exists(path)：判断指定路径是否存在。

 if os.path.exists("baidu.html"):
    os.remove("baidu.html")
     #如果存在baidu.html文件，则删除该文件

os.path.isfile(path)：判断指定路径是否为文件。

os.path.isdir(path)：判断指定路径是否为目录。

if not os.path.isdir(path):
    ok.mkdir(path)  
#这里用if语句判断当前目录之下是否存在名为'path'的文件夹，如果不存在，则创建一个

os.path.join(path1, path2, ...)：将多个路径组合成一个路径。

os.path.abspath(path)：返回指定路径的绝对路径。

os.path.basename(path)：返回指定路径的文件名或目录名。

os.path.dirname(path)：返回指定路径的父目录路径。

os.path.split(path)：将指定路径分割成目录和文件名。

os.path.splitext(path)：将指定路径分割成文件名和扩展名。

os.environ：获取当前系统的环境变量。

os.system(command)：执行系统命令。

举例说明（删除一个存有若干张图片的文件夹）：

def remove_dir(path):
    if os.path.isdir(path):   #判断指定路径是否为该目录
        for file in os.listdir(path):   #遍历该目录中的文件列表
            remove_dir(os.path.join(path, file))  #运用递归的方法，依次删除该目录下的文件以及子目录
        os.rmdir(path)  #删除该路径
    else:
        os.remove(path)  #删除文件

if os.path.exists("tupian"):  #判断是否存在，存在即删除，不存在则不管
    remove_dir("tupian")

文件操作

打开文件：

file = open(filename, mode)

filename：文件名

mode：是打开文件的模式

常用的模式有：

• 'r'`：读取模式，只能读取文件内容，不能修改文件。
• `'w'`：写入模式，如果文件存在则清空文件内容，如果文件不存在则创建文件。
• `'a'`：追加模式，如果文件存在则在文件末尾追加内容，如果文件不存在则创建文件。
• `'x'`：独占模式，如果文件不存在则创建文件，否则抛出异常。
• `'b'`：二进制模式，用于处理二进制文件。
• `'t'`：文本模式，用于处理文本文件。
• "wb":文件打开模式

读取文件：

content = file.read()

`content`是读取到的文件内容

.read():读取文件中所有的内容

.readline():一行一行地读取内容，并将其作为一个字符串返回

写入文件：

file.write(content)

其中，`content`是要写入的内容。

关闭文件：

file.close()

注意：使用完文件后一定要记得关闭文件，否则可能会导致文件内容不完整或者文件被占用无法删除等问题。