python内置函数：
https://www.runoob.com/python/python-built-in-functions.html
a
b
c
clear()--》删除
删除字典内所有的元素
dic = {‘a’:123,‘b’:456,‘c’:789,‘d’:567}
dic.clear()
print(dic)
{}
commands
getstatusoutput()
在Python 2中，经常使用commands模块来执行shell的命令，尤其是常用getstatusoutput()函数。但是在Python 3中，突然发现这个函数没有了。为什么呢？
getstatusoutput()这个函数有一个很大的缺陷，就是它的返回值中无法区分stderr和stdout.
那么在Python 3中如果要调用一个命令，如何做呢？有2种方法。其实它们在Python 2中也适用。
方法1. 使用subprocess.check_output()函数
如果命令调用失败，check_output()会抛出一个CalledProcessError的异常。
如果要看到stderr的内容，即合并stdout和stderr，可以把 stderr=subprocess.STDOUT 作为check_output的一个参数。
方法2. 自己定制一个get_status_output()函数，内容如下：
def get_status_output(*args, **kwargs):
p = subprocess.Popen(*args, **kwargs)
stdout, stderr = p.communicate()
return p.returncode, stdout, stderr
Python 3中的commands.getstatusoutput()的替代方案，即 subprocess.getstatusoutput().
https://blog.csdn.net/weixin_42310670/article/details/113479369
copy()--》拷贝
拷贝一个字典
dic = {‘a’:123,‘b’:456,‘c’:789,‘d’:567}
dic_two = dic.copy()
print(dic)
{‘a’: 123, ‘b’: 456, ‘c’: 789, ‘d’: 567}
print(dic_two)
{‘a’: 123, ‘b’: 456, ‘c’: 789, ‘d’: 567}
d
datetime.date.today().strftime('%y%m%d')
获取当前日期
import datetime
today=datetime.date.today().strftime('%Y-%m-%d')
print(today)
#打印结果：2020-04-02
e
f
fromkeys(seq[,value])
创建一个新字典,seq作为键，value为字典所有键的初始值(默认为None)
dic = dict.fromkeys(‘abcd’)
print(dic)
{‘a’: None, ‘b’: None, ‘c’: None, ‘d’: None}
dic = dict.fromkeys(‘abc’,1)
print(dic)
{‘a’: 1, ‘b’: 1, ‘c’: 1}
g
get(key,default = None)
返回指定的键的值，如果键不存在，则返会 default 的值
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
print(dic.get(‘b’))
2
print(dic.get(‘e’,5))
5
h
i
int(time.time())
获取当前时间戳
import time
int(time.time())
#打印结果：1658978376
int(time.time()*1000)
#打印结果：1658978400276
items()
返回键值对的可迭代对象，使用 list 可转换为 [(键,值)] 形式
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
print(dic.items())
dict_items([(‘a’, 1), (‘b’, 2), (‘c’, 3), (‘d’, 4)])
print(list(dic.items()))
[(‘a’, 1), (‘b’, 2), (‘c’, 3), (‘d’, 4)]
j
json
- JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
- JSON 是轻量级的文本数据交换格式
- JSON 独立于语言
- JSON 具有自我描述性，更易理解
引用模块
import json
编码：把一个Python对象编码转换成Json字符串 json.dumps()
解码：把Json格式字符串解码转换成Python对象 json.loads()
load和dump处理的主要是文件
loads和dumps处理的是字符串
python和Json数据类型的映射
| JSON | Python |
|---|---|
| object | dict |
| array | list |
| string | str |
| number | int |
| true | True |
| false | False |
| null | None |
json.load()/json.loads() json.dump()/json.dumps()
- json.load()从json文件中读取数据
- json.loads()将str类型的数据转换为dict类型
- json.dumps()将dict类型的数据转成str
- json.dump()将数据以json的数据类型写入文件中
1、json.dumps()和json.loads()是以json格式处理函数（可以这么理解，json是字符串）
(1)json.dumps()函数是将一个Python数据类型列表进行json格式的编码（可以这么理解，json.dumps()函数是将字典转化为字符串）
(2)json.loads()函数是将json格式数据转换为字典（可以这么理解，json.loads()函数是将字符串转化为字典）
2、json.dump()和json.load()主要用来读写json文件函数
总结
res=json.loads(var) var为变量
res=json.load(file) file为文件路径
res都为字典类型
json.dumps()
import json
def demo():
data = {"name": "张三", "age": "18", "sex": "男"}
result = json.dumps(data, indet=5, ensure_ascii=False)
print(result)
print(type(result))
demo()
输出结果：
{
"name": "张三",
"age": "18",
"sex": "男"
}
<class 'str'>
json.loads()
data = """{
"name": "张三",
"age": "18",
"sex": "男"
}"""
# 一般此时data为request.text返回值
print(data, type(data))
data = json.loads(data)
print(data, type(data))
输出结果：
{
"name": "张三",
"age": "18",
"sex": "男"
}<class 'str'>
{'name': '张三', 'age': '18', 'sex': '男'}<class 'dict'>
注：json内部要使用双引号。
k
keys()
返回一个迭代器，可以使用 list() 来转换为列表
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
print(dic.keys())
dict_keys([‘a’, ‘b’, ‘c’, ‘d’])
print(list(dic.keys()))
[‘a’, ‘b’, ‘c’, ‘d’]
l
len()--》个数
返回键的个数，即字典的长度。返回对象（字符、列表、元组等）长度或项目个数。
dic = {‘a’:123,‘b’:456,‘c’:789,‘d’:567}
print(len(dic))
4
line
line.startswith
搜索一列，直到找到str Linear，找到该位置的索引，将其添加1，然后通过切片提取数据帧。
获取行号
def find_index_of(lines, predicate):
for index, line in enumerate(lines):
if predicate(line):
return index
index = find_index_of(sheetname, lambda x: x.startswith("Linear"))
line.split()
通常用于将字符串切片并转换为列表。
拆分字符串。通过制定分隔符将字符串进行切片，并返回分割后的字符串列表[list]
语法:
str.split(str="",num=string.count(str))[n]
参数：str：分隔符，默认为空格，但不能为空("")
num: 表示分割次数。如果指定num，则分割成n+1个子字符串，并可将每个字符串赋给新的变量
示例：
u = "www.google.com"
print(u.split('.')) --> ['www','google','com']
print(u.split('.')[0])-->www
补充：
line.strip().split(',')
strip()表示删除掉数据中的换行符，split（'，'）则是数据中遇到',' 就隔开。
list
list.append(obj)
用于在列表末尾添加新的对象
list.read()
把一个文档当成一个字符串（结尾有空字符串）返回。也就是一个文档存储在一个字符串对象中，如果文件很大，就很耗内存。
注：read()和原来的文档相比，输出的时候结尾多了一个'\n'（换行），其余没区别
如果想要输出和原文档一模一样，需要在结果加rstrip()，也就是去掉末尾空格
cat pi_digits.txt
3.14345345345
23426534534
45345123656
file_name = 'pi_digits.txt'
with open(file_name) as f:
contents = f.read()
print(contents)
print(contents.rstrip())
3.14345345345
23426534534
45345123656
3.14345345345
23426534534
45345123656
显然第一个末尾多一个空行，第二次和原文档一样。
list.readline()
readline()，类似于readlines()，不过它每次只读取文档的一行。以后需要逐步循环（一般用whicl循环）,最后遍历整个文件。
注意：输出情况同readlines()
list.readlines()
readlines()，是把一个文档的每一行（包含行前的空格，行末加一个\n），作为列表的一个元素，存储在一个list中。每一个行作为list的一个元素。
注意：readlines()和原文档相比，每行之后都多出一个空行，因为原来每行末尾都加了'\n'，要想和原文档输出一样，那么每个行末尾加上rstrip()即可消除右边空格，左边空格不变。
二维矩阵行列转换
print('二维矩阵行列转换')
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list(map(list, zip(*a)))) # [[1, 4, 7], [2, 5, 8], [3, 6, 9]], map()函数把zip(*a)后的每一个元素转化为list
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
m
n
o
open()
open()会把原来的文档对象保存到一个变量中。且在原来的每行末尾加一个看不见的'\n'，我们姑且当成是直接打包一个文件（每行多加一个'\n'）。逐行读取的时候和readlines（）是一样的。但是readlines()会把一个文件以行为单位放在一个list中，但是open()结果是把一个文档整体打包。但是open()返回对象和readlines()还有一个区别，readlines()返回的对象可以在with代码块之外使用，但是open（）返回的对象只能在with代码块内使用。
不同模式打开文件的完全列表：
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
file_name = 'pi_digits.txt'
f1 = open(file_name)
#这里f1在原来的每行末尾都放置了一个'\n'，print本身也会加一个'\n'，所以每行输出后多两个'\n'，
#两次换行的结果是行和行之间夹着一个空行
for line in f1:
print(line)
3.14345345345
23426534534
45345123656
file_name = 'pi_digits.txt'
with open(file_name) as f1:
#下面的for代码块使用了f1,必须有缩进，因为使用f1只能在with代码块内使用
for line in f1:
print(line)
with open(file_name) as f2:
lines = f2.readlines()
#下面的for语句可以有缩进也可以没有缩进，有缩进就意味着在with代码块内，没有缩进意味着在with代码块外
#使用，这两种都是可以的，所以相对而言，readlines（）返回对象有更大的自由度
for line in lines:
print(line.rstrip())
os
os.path.getctime()
获取系统指定路径的ctime
os.listdir()
返回指定的文件夹包含的文件或文件夹的名字的列表
os.remove()
os.remove() 方法用于删除指定路径的文件。如果指定的路径是一个目录，将抛出 OSError。
os.stat()
os.stat() 函数会给出一个文件或文件描述符(file descriptor)的各种状态信息，如权限，大小，所属用户和组，修改时间等。
>>> import os
>>> statinfo = os.stat('somefile.txt')
>>> statinfo
os.stat_result(st_mode=33188, st_ino=7876932, st_dev=234881026,
st_nlink=1, st_uid=501, st_gid=501, st_size=264, st_atime=1297230295,
st_mtime=1297230027, st_ctime=1297230027)
>>> statinfo.st_size
264
popen()
os.popen() 方法用于从一个命令打开一个管道。
在Unix，Windows中有效
os.popen(command[, mode[, bufsize]])
command -- 使用的命令。
mode -- 模式权限可以是 'r'(默认) 或 'w'。
bufsize -- 指明了文件需要的缓冲大小：0意味着无缓冲；1意味着行缓冲；其它正值表示使用参数大小的缓冲（大概值，以字节为单位）。负的bufsize意味着使用系统的默认值，一般来说，对于tty设备，它是行缓冲；对于其它文件，它是全缓冲。如果没有改参数，使用系统的默认值。
p
pop(key[,default])--》删除
删除字典中 key 的值，返回被删除的值。key 值如果不给出，则返回default的值
>>> dic = {'a':1,'b':2,'c':3,'d':4}
>>> print(dic.pop('a',6))
1 //返回删除的值
>>> print(dic)
{'b': 2, 'c': 3, 'd': 4}
>>> print(dic.pop('e','字典中没有该值'))
字典中没有该值 //如果字典中不存在该键，则返回 default 的值
>>> print(dic)
{'b': 2, 'c': 3, 'd': 4}
popitem()
随机返回一个键值对(通常为最后一个)，并删除最后一个键值对
>>> dic = {'a':1,'b':2,'c':3,'d':4}
>>> print(dic.popitem())
('d', 4)
>>> print(dic)
{'a': 1, 'b': 2, 'c': 3}
>>> print(dic.popitem())
('c', 3)
>>> print(dic)
{'a': 1, 'b': 2}
q
r
range()
python2.x range() 函数可创建一个整数列表，一般用在 for 循环中。
Python3 range() 返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表，具体可查阅 Python3 range() 用法说明。
range(stop)
range(start, stop[, step])
- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
- stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
>>>range(10) # 从 0 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11) # 从 1 开始到 10
[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)
[]
以下是 range 在 for 中的使用，循环出runoob 的每个字母:
>>>x = 'runoob'
>>> for i in range(len(x)) :
... print(x[i])
...
r
u
n
o
o
b
>>>
s
setdefault(key,default = None)
如果键存在于字典中，则不修改键的值
如果键不存在于字典中，则设置为 default 值
# 如果键存在，则不修改键的值
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
dic.setdefault(‘a’,8)
print(dic)
{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
# 如果键不存在于字典中，则设置为 default 值
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
dic.setdefault(‘e’,5)
print(dic)
{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5}
split()
拆分字符串。通过制定分隔符将字符串进行切片，并返回分割后的字符串列表[list]
str()--》字符串
将字段转换为字符串
t
type()--》类型
查看字典的类型
dic = {‘a’:123,‘b’:456,‘c’:789,‘d’:567}
print(type(dic))
<class ‘dict’>
time
time.localtime()
类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。 DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时。
#!/usr/bin/python
import time
print "time.localtime() : %s" % time.localtime()
输出结果为：
time.localtime() : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=27, tm_hour=10, tm_min=26, tm_sec=5, tm_wday=6, tm_yday=332, tm_isdst=0)
#!/usr/bin/python
import time
now = int(time.time())
time_stamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(now))
print(time_stamp)
输出结果：
2022-09-13 17:28:46
u
update(字典对象)
将字典对象更新到字典中
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
dic_two = {‘f’:6}
dic.update(dic_two)
print(dic)
{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘f’: 6}
v
values()
返回一个可迭代对象，使用 list 转换为字典中 值 的列表
dic = {‘a’:1,‘b’:2,‘c’:3,‘d’:4}
print(list(dic.values()))
[1, 2, 3, 4]
w
x
y
z
zip()
zip() 接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个 tuple，然后返回由这些 tuple 组成的 list。
若传入参数的长度不等，则返回 list 的长度和参数中长度最短的对象相同。
利用 * 号操作符，可以将 list 解压。
Python3.0开始，zip()函数已经不返回 list 了，而是返回 iterable(可迭代对象)。这个可迭代对象需要特别注意，只能进行一次迭代遍历，第二次遍历就是空了。这个坑了我一个多小时。
简单示例
a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9, 10, 11]
ab = zip(a, b)
print(list(ab)) # [(1, 4), (2, 5), (3, 6)]
# zip()之后的结果只能“使用一次”
# zip()实际上是一个生成器对象，故使用list()获取zip()结果时，已经相当于是完成一次迭代遍历
# 第二次再次使用list()时迭代已经结束，所以返回[]
print(list(ab)) # []
ac = zip(a, c)
# print(list(ac)) # [(1, 4), (2, 5), (3, 6)]，以短的为准
_ac = zip(*ac) # 与 zip 相反，可理解为解压，返回二维矩阵式
print(list(_ac)) # [(1, 2, 3), (7, 8, 9)]，如果没把上面的 print(list(ac)) 注掉，这里的显示结果就是[]了
zip与for的结合
print('zip与for的结合')
name = ('jack', 'alex', 'sony', 'joey')
age = (25, 28, 21, 30)
for a, n in zip(name, age):
print(a, n)
jack 25
alex 28
sony 21
joey 30