Python中字典的内建函数用法是什么？
点击上方 "Python人工智能技术" 关注，星标或者置顶
22点24分准时推送 ， 第一时间送达
后台回复“大礼包” ， 送你特别福利
编辑：乐乐 | 来自：pypypypy
上一篇：
正文
大家好 ， 我是Pythn人工智能技术 。
内置函数就是Python给你提供的，拿来直接用的函数 ， 比如print.，input等 。
截止到python版本3.6.2 ，python一共提供了68个内置函数 ， 具体如下
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() ?lter() issubclass() pow() super()
bytes() ?oat() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！
和数字相关 1. 数据类型
bool : 布尔型(True,False)
int : 整型(整数)
float : 浮点型(小数)
complex : 复数
2. 进制转换
bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制
print(bin(10)) # 二进制:0b1010
print(hex(10)) # 十六进制:0xa
print(oct(10)) # 八进制:0o12
3. 数学运算
abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和数据结构相关 1. 序列
（1）列表和元组
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
【pythoninf函数 python infile函数】print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相关内置函数
reversed() 将一个序列翻转, 返回翻转序列的迭代器
slice() 列表的切片
lst = "你好啊"
it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 将数据转化成字符串
print(str(123) '456') #123456
format() 与具体数据相关, 用于计算各种小数, 精算等.
s = "hello world!"
print(format(s, "^20")) #剧中
print(format(s, "20")) #左对齐
print(format(s, "20")) #右对齐
# hello world!
# hello world!
# hello world!
print(format(3, 'b' )) # 二进制:11
print(format(97, 'c' )) # 转换成unicode字符:a
print(format(11, 'd' )) # ?进制:11
print(format(11, 'o' )) # 八进制:13
print(format(11, 'x' )) # 十六进制(?写字母):b
print(format(11, 'X' )) # 十六进制(大写字母):B
print(format(11, 'n' )) # 和d?样:11
print(format(11)) # 和d?样:11
print(format(123456789, 'e' )) # 科学计数法. 默认保留6位小数:1.234568e 08
print(format(123456789, '0.2e' )) # 科学计数法. 保留2位小数(小写):1.23e 08
print(format(123456789, '0.2E' )) # 科学计数法. 保留2位小数(大写):1.23E 08
print(format(1.23456789, 'f' )) # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f' )) # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e 3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890
bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A赋值给ret[0]
print(str(ret)) #bytearray(b'Alex')
ord() 输入字符找带字符编码的位置
chr() 输入位置数字找出对应的字符
ascii() 是ascii码中的返回该值 不是就返回u
print(ord('a')) # 字母a在编码表中的码位:97
print(ord('中')) # '中'字在编码表中的位置:20013
print(chr(65)) # 已知码位,求字符是什么:A
print(chr(19999)) #丢
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=" ")
print(ascii("@")) #'@'
repr() 返回一个对象的string形式
s = "今天\n吃了%s顿\t饭" % 3
print(s)#今天# 吃了3顿 饭
print(repr(s)) # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
#'今天\n吃了3顿\t饭'
2. 数据集合
字典：dict 创建一个字典
集合：set 创建一个集合
frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作 。
3. 相关内置函数
len() 返回一个对象中的元素的个数
sorted() 对可迭代对象进行排序操作 (lamda)
语法：sorted(Iterable, key=函数(排序规则), reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list里面的一个方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 内置函数. 返回给你一个新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #['one', 'two', 'six', 'four', 'five', 'three']
enumerate() 获取集合的枚举对象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代对象中全部是True, 结果才是True
any() 可迭代对象中有一个是True, 结果就是True
print(all([1,'hello',True,9])) #True
print(any([0,0,0,False,1,'good'])) #True
zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')
fiter() 过滤 (lamda)
语法：fiter(function. Iterable)
function: 用来筛选的函数. 在?lter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象
搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包 。
def func(i): # 判断奇数
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 会根据提供的函数对指定序列列做映射(lamda)
语法 : map(function, iterable)
可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相关
locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 当前作用域中的内容
print(globals()) # 全局作用域中的内容
print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# '__spec__': None, '__annotations__': {}, '__builtins__':
# (built-in), '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
# 'func': }
# 今天内容很多
和迭代器生成器相关
range() 生成数据
next() 迭代器向下执行一次, 内部实际使?用了__ next__()?方法返回迭代器的下一个项目
iter() 获取迭代器, 内部实际使用的是__ iter__()?方法来获取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()获得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串类型代码的执行
eval() 执行字符串类型的代码. 并返回最终结果
exec() 执行字符串类型的代码
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
s1 = input("请输入a b:") #输入:8 9
print(eval(s1)) # 17 可以动态的执行代码. 代码必须有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 执行代码不返回任何内容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 动态执行代码
exec("""
def func():
print(" 我是周杰伦")
""" )
func() #我是周杰伦
code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec") # compile并不会执行你的代码.只是编译
exec(com) # 执行编译的结果
# 0
# 1
# 2
code2 = "5 6 7"
com2 = compile(code2, "", mode="eval")
print(eval(com2)) # 18
code3 = "name = input('请输入你的名字:')" #输入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) #hello
输入输出
print() : 打印输出
input() : 获取用户输出的内容
print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾
#hello*world@
内存相关
hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存
s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #报错,列表是不可哈希的 id() : 获取到对象的内存地址s = 'alex'print(id(s)) #2278345368944
文件操作相关
open() : 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
模块相关
__ import__() : 用于动态加载类和函数
# 让用户输入一个要导入的模块
import os
name = input("请输入你要导入的模块:")
__import__(name) # 可以动态导入模块
帮 助
help() : 函数用于查看函数或模块用途的详细说明
print(help(str)) #查看字符串的用途
调用相关
callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功
a = 10
print(callable(a)) #False 变量a不能被调用
def f():
print("hello")
print(callable(f)) # True 函数是可以被调用的
查看内置属性
dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法
print(dir(tuple)) #查看元组的方法
你还有什么想要补充的吗？
免责声明：本文内容来源于网络 ， 文章版权归原作者所有，意在传播相关技术知识行业趋势，供大家学习交流，若涉及作品版权问题，请联系删除或授权事宜 。
技术君个人微信
添加技术君个人微信即送一份惊喜大礼包
→ 技术资料共享
→ 技术交流社群
--END--
往日热文：
Python程序员深度学习的“四大名著”：
这四本书着实很不错！我们都知道现在机器学习、深度学习的资料太多了，面对海量资源 ， 往往陷入到“无从下手”的困惑出境 。而且并非所有的书籍都是优质资源，浪费大量的时间是得不偿失的 。给大家推荐这几本好书并做简单介绍 。
获得方式：
2.后台回复关键词：名著
python中去除数组中inf在python中，可以使用numpy模块的finite()函数来去除数组中的inf值 ， 该函数可以判断每个元素的值是否为无穷大，如果是，则返回false，否则返回true 。例如：import numpy as np arr = np.array([10, inf, 20, 30]) result_arr = np.isfinite(arr) print(result_arr) 运行结果：[ True FalseTrueTrue]
Python中的eval()、filter()、float()函数有什么用？Python解释器内置了许多函数，这意味着我们无需定义，始终可以它们 。下面按照函数的字母顺序，讨论一些常用的内建函数 。
eval()
eval()函数解析传给它的表达式，并在程序中运行Python表达式(代码) 。举个例子：
x = 1
eval("x1")# 注意："x1"是字符串
2
eval("49")
True
eval("'py' * 3")
'pypypy'
eval("10 ** 2")
100
eval()函数不仅仅能运行简单表达式，还能调用函数，使用方法等等：
eval("abs(-11)")# 计算-11的绝对值
11
eval('"hello".upper()')# 把字符串'hello'全变成大写字母
'HELLO'
import os
eval('os.getcwd()')# 获取当前的工作目录
'/home/thepythonguru'
但是需要注意的是eval()仅适用于表达式，尝试传递语句会导致语法错误：
eval('a = 1')# 赋值语句
Traceback (most recent call last):
File "", line 1, in
File "", line 1
a = 1
^
SyntaxError: invalid syntax
eval('import re')# 导入语句
Traceback (most recent call last):
File "", line 1, in
File "", line 1
import re
^
SyntaxError: invalid syntax
此外 ， 使用eval()语句应该十分小心，永远不要将不受信任的源直接传递给eval() 。因为恶意用户很容易对您的系统造成破坏 。例如:
eval(input())# eval()将执行用户输入的代码
用户输入以下代码就能从系统中删除所有文件：
os.system("RM -RF /")
# 上面输入相当于执行：
eval('os.system("RM -RF /")')
filter()
"filter"的意思是“过滤”，filter()函数需要两个参数：一个函数对象和一个可迭代对象 。函数对象需要返回一个布尔值，并为可迭代的每个元素调用 。filter()函数仅返回那些通过函数对象返回值为true的元素 。解释有一些抽象，看一个例子：
a = [1, 2, 3, 4, 5, 6]
filter(lambda x : x % 2 == 0, a)# 过滤出所有偶数，结果返回一个filter对象
filter object at 0x1036dc048
list(filter(lambda x : x % 2 == 0, a))# 可以使用list()函数使fileter对象变成列表，方便查看结果
[2, 4, 6]
下面是另外一个例子：
dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
filter(lambda x : x['name'] == 'python', dict_a)# 过滤出列表中键'name'为值'python'的字典
filter object at 0x1036de128
tuple(filter(lambda x : x['name'] == 'python', dict_a))# 使用tuple()函数使结果变成字典
({'name': 'python', 'points': 10},)
float()
float()的参数是一个数字或者字符串，它返回一个浮点数 。如果参数是字符串，则字符串中应该包含一个数字，并可以在数字前加入一个 '-' 符号，代表负数 。参数也可以是表示NaN(非数字)或正无穷大的字符串 。如果没有任何参数的话，将返回0.0 。
float(' 1.23')# 1.23
1.23
float('-12345\n')# -12345
-12345.0
float('1e-003')# 0.001
0.001
float(' 1E6')# 10的6次幂
1000000.0
float('-Infinity')# 无穷小
-inf
float('-inf')100# 负无穷小加100仍等于负无穷小
-inf
float('inf')# 无穷大
inf
float('NaN')# NaN，代表非数字
nan
关于Python的基础问题可以看下这个网页的视频教程，网页链接，希望我的回答能帮到你 。
万字教你如何用 Python 实现线性规划想象一下pythoninf函数 ， 您有一个线性方程组和不等式系统 。这样的系统通常有许多可能的解决方案 。线性规划是一组数学和计算工具，可让您找到该系统的特定解，该解对应于某些其他线性函数的最大值或最小值 。
混合整数线性规划是线性规划的扩展 。它处理至少一个变量采用离散整数而不是连续值的问题 。尽管乍一看混合整数问题与连续变量问题相似，但它们在灵活性和精度方面具有显着优势 。
整数变量对于正确表示自然用整数表示的数量很重要，例如生产的飞机数量或服务的客户数量 。
一种特别重要的整数变量是二进制变量。它只能取零或一的值，在做出是或否的决定时很有用，例如是否应该建造工厂或者是否应该打开或关闭机器 。您还可以使用它们来模拟逻辑约束 。
线性规划是一种基本的优化技术 ， 已在科学和数学密集型领域使用pythoninf函数了数十年 。它精确、相对快速，适用于一系列实际应用 。
混合整数线性规划允许您克服线性规划的许多限制 。您可以使用分段线性函数近似非线性函数、使用半连续变量、模型逻辑约束等 。它是一种计算密集型工具 ， 但计算机硬件和软件的进步使其每天都更加适用 。
通常 ， 当人们试图制定和解决优化问题时，第一个问题是他们是否可以应用线性规划或混合整数线性规划 。
以下文章说明了线性规划和混合整数线性规划的一些用例：
随着计算机能力的增强、算法的改进以及更多用户友好的软件解决方案的出现，线性规划，尤其是混合整数线性规划的重要性随着时间的推移而增加 。
解决线性规划问题的基本方法称为，它有多种变体 。另一种流行的方法是 。
混合整数线性规划问题可以通过更复杂且计算量更大的方法来解决，例如，它在幕后使用线性规划 。这种方法的一些变体是，它涉及使用 切割平面，以及 。
有几种适用于线性规划和混合整数线性规划的合适且众所周知的 Python 工具 。其中一些是开源的，而另一些是专有的 。您是否需要免费或付费工具取决于问题的规模和复杂性，以及对速度和灵活性的需求 。
值得一提的是，几乎所有广泛使用的线性规划和混合整数线性规划库都是以 Fortran 或 C 或 C原生和编写的 。这是因为线性规划需要对（通常很大）矩阵进行计算密集型工作 。此类库称为求解器 。Python 工具只是求解器的包装器 。
Python 适合围绕本机库构建包装器 ， 因为它可以很好地与 C/C配合使用 。对于本教程，您不需要任何 C/C（或 Fortran），但如果您想了解有关此酷功能的更多信息，请查看以下资源：
基本上 ， 当您定义和求解模型时，您使用 Python 函数或方法调用低级库，该库执行实际优化工作并将解决方案返回给您的 Python 对象 。
几个免费的 Python 库专门用于与线性或混合整数线性规划求解器交互：
在本教程中，您将使用SciPy和PuLP来定义和解决线性规划问题 。
在本节中，您将看到线性规划问题的两个示例：
您将在下一节中使用 Python 来解决这两个问题 。
考虑以下线性规划问题：
pythoninf函数你需要找到X和?使得红色，蓝色和黄色的不平等 ， 以及不平等X0和?0，是满意的 。同时，您的解决方案必须对应于z的最大可能值 。
您需要找到的自变量（在本例中为x和y）称为决策变量。要最大化或最小化的决策变量的函数（在本例中为z）称为目标函数、成本函数或仅称为目标。您需要满足的不等式称为不等式约束。您还可以在称为等式约束的约束中使用方程 。
这是您如何可视化问题的方法：
红线代表的功能2 XY = 20 ， 和它上面的红色区域示出了红色不等式不满足 。同样，蓝线是函数 4 x5 y = 10，蓝色区域被禁止，因为它违反了蓝色不等式 。黄线是x2 y =2 ， 其下方的黄色区域是黄色不等式无效的地方 。
如果您忽略红色、蓝色和黄色区域，则仅保留灰色区域 。灰色区域的每个点都满足所有约束，是问题的潜在解决方案 。该区域称为可行域，其点为可行解。在这种情况下，有无数可行的解决方案 。
您想最大化z 。对应于最大z的可行解是最优解。如果您尝试最小化目标函数，那么最佳解决方案将对应于其可行的最小值 。
请注意，z是线性的 。你可以把它想象成一个三维空间中的平面 。这就是为什么最优解必须在可行区域的顶点或角上的原因 。在这种情况下，最佳解决方案是红线和蓝线相交的点 ， 稍后您将看到 。
有时 ， 可行区域的整个边缘，甚至整个区域，都可以对应相同的z值 。在这种情况下 ， 您有许多最佳解决方案 。
您现在已准备好使用绿色显示的附加等式约束来扩展问题：
方程式x5 y = 15，以绿色书写，是新的 。这是一个等式约束 。您可以通过向上一张图像添加相应的绿线来将其可视化：
现在的解决方案必须满足绿色等式，因此可行区域不再是整个灰色区域 。它是绿线从与蓝线的交点到与红线的交点穿过灰色区域的部分 。后一点是解决方案 。
如果插入x的所有值都必须是整数的要求，那么就会得到一个混合整数线性规划问题，可行解的集合又会发生变化：
您不再有绿线，只有沿线的x值为整数的点 。可行解是灰色背景上的绿点，此时最优解离红线最近 。
这三个例子说明了可行的线性规划问题，因为它们具有有界可行区域和有限解 。
如果没有解，线性规划问题是不可行的。当没有解决方案可以同时满足所有约束时，通常会发生这种情况 。
例如，考虑如果添加约束xy1会发生什么 。那么至少有一个决策变量（x或y）必须是负数 。这与给定的约束x0 和y0相冲突 。这样的系统没有可行的解决方案，因此称为不可行的 。
另一个示例是添加与绿线平行的第二个等式约束 。这两行没有共同点 ， 因此不会有满足这两个约束的解决方案 。
一个线性规划问题是无界的 ， 如果它的可行区域是无界，将溶液不是有限 。这意味着您的变量中至少有一个不受约束，可以达到正无穷大或负无穷大，从而使目标也无限大 。
例如 ， 假设您采用上面的初始问题并删除红色和黄色约束 。从问题中删除约束称为放松问题 。在这种情况下，x和y不会在正侧有界 。您可以将它们增加到正无穷大，从而产生无限大的z值 。
在前面的部分中，您研究了一个与任何实际应用程序无关的抽象线性规划问题 。在本小节中，您将找到与制造业资源分配相关的更具体和实用的优化问题 。
假设一家工厂生产四种不同的产品 ， 第一种产品的日产量为x ?，第二种产品的产量为x 2，依此类推 。目标是确定每种产品的利润最大化日产量，同时牢记以下条件：
数学模型可以这样定义：
目标函数（利润）在条件 1 中定义 。人力约束遵循条件 2 。对原材料 A 和 B 的约束可以从条件 3 和条件 4 中通过对每种产品的原材料需求求和得出 。
最后 ， 产品数量不能为负，因此所有决策变量必须大于或等于零 。
与前面的示例不同，您无法方便地将其可视化 ， 因为它有四个决策变量 。但是，无论问题的维度如何，原理都是相同的 。
在本教程中，您将使用两个Python 包来解决上述线性规划问题：
SciPy 设置起来很简单 。安装后，您将拥有开始所需的一切 。它的子包scipy.optimize可用于线性和非线性优化 。
PuLP 允许您选择求解器并以更自然的方式表述问题 。PuLP 使用的默认求解器是COIN-OR Branch and Cut Solver (CBC) 。它连接到用于线性松弛的COIN-OR 线性规划求解器 (CLP)和用于切割生成的COIN-OR 切割生成器库 (CGL) 。
另一个伟大的开源求解器是GNU 线性规划工具包 (GLPK) 。一些著名且非常强大的商业和专有解决方案是Gurobi、CPLEX和XPRESS 。
除了在定义问题时提供灵活性和运行各种求解器的能力外，PuLP 使用起来不如 Pyomo 或 CVXOPT 等替代方案复杂，后者需要更多的时间和精力来掌握 。
要学习本教程，您需要安装 SciPy 和 PuLP 。下面的示例使用 SciPy 1.4.1 版和 PuLP 2.1 版 。
您可以使用pip以下方法安装两者：
您可能需要运行pulptest或sudo pulptest启用 PuLP 的默认求解器，尤其是在您使用 Linux 或 Mac 时：
或者，您可以下载、安装和使用 GLPK 。它是免费和开源的，适用于 Windows、MacOS 和 Linux 。在本教程的后面部分 ， 您将看到如何将 GLPK（除了 CBC）与 PuLP 一起使用 。
在 Windows 上，您可以下载档案并运行安装文件 。
在 MacOS 上，您可以使用 Homebrew：
在 Debian 和 Ubuntu 上，使用apt来安装glpk和glpk-utils：
在Fedora，使用dnf具有glpk-utils：
您可能还会发现conda对安装 GLPK 很有用：
安装完成后 ， 可以查看GLPK的版本：
有关详细信息，请参阅 GLPK 关于使用Windows 可执行文件和Linux 软件包进行安装的教程 。
在本节中，您将学习如何使用 SciPy优化和求根库进行线性规划 。
要使用 SciPy 定义和解决优化问题，您需要导入scipy.optimize.linprog()：
现在您已经linprog()导入，您可以开始优化 。
让我们首先解决上面的线性规划问题：
linprog()仅解决最小化（而非最大化）问题 ， 并且不允许具有大于或等于符号 ( ) 的不等式约束 。要解决这些问题，您需要在开始优化之前修改您的问题：
引入这些更改后，您将获得一个新系统：
该系统与原始系统等效，并且将具有相同的解决方案 。应用这些更改的唯一原因是克服 SciPy 与问题表述相关的局限性 。
下一步是定义输入值：
您将上述系统中的值放入适当的列表、元组或NumPy 数组中：
注意：请注意行和列的顺序！
约束左侧和右侧的行顺序必须相同 。每一行代表一个约束 。
来自目标函数和约束左侧的系数的顺序必须匹配 。每列对应一个决策变量 。
下一步是以与系数相同的顺序定义每个变量的界限 。在这种情况下，它们都在零和正无穷大之间：
此语句是多余的，因为linprog()默认情况下采用这些边界（零到正无穷大） 。
注：相反的float("inf")，你可以使用math.inf，numpy.inf或scipy.inf 。
最后，是时候优化和解决您感兴趣的问题了 。你可以这样做linprog()：
参数c是指来自目标函数的系数 。A_ub和b_ub分别与不等式约束左边和右边的系数有关 。同样，A_eq并b_eq参考等式约束 。您可以使用bounds提供决策变量的下限和上限 。
您可以使用该参数method来定义要使用的线性规划方法 。有以下三种选择：
linprog() 返回具有以下属性的数据结构：
您可以分别访问这些值：
这就是您获得优化结果的方式 。您还可以以图形方式显示它们：
如前所述，线性规划问题的最优解位于可行区域的顶点 。在这种情况下，可行区域只是蓝线和红线之间的绿线部分 。最优解是代表绿线和红线交点的绿色方块 。
如果要排除相等（绿色）约束 ， 只需删除参数A_eq并b_eq从linprog()调用中删除：
解决方案与前一种情况不同 。你可以在图表上看到：
在这个例子中，最优解是红色和蓝色约束相交的可行（灰色）区域的紫色顶点 。其他顶点，如黄色顶点，具有更高的目标函数值 。
您可以使用 SciPy 来解决前面部分所述的资源分配问题：
和前面的例子一样 ， 你需要从上面的问题中提取必要的向量和矩阵，将它们作为参数传递给.linprog()，然后得到结果：
结果告诉您最大利润是1900并且对应于x ? = 5 和x ? = 45 。在给定条件下生产第二和第四个产品是没有利润的 。您可以在这里得出几个有趣的结论：
opt.statusis0和opt.successis True，说明优化问题成功求解，最优可行解 。
SciPy 的线性规划功能主要用于较小的问题 。对于更大和更复杂的问题，您可能会发现其他库更适合，原因如下：
幸运的是，Python 生态系统为线性编程提供了几种替代解决方案，这些解决方案对于更大的问题非常有用 。其中之一是 PuLP，您将在下一节中看到它的实际应用 。
PuLP 具有比 SciPy 更方便的线性编程 API 。您不必在数学上修改您的问题或使用向量和矩阵 。一切都更干净，更不容易出错 。
像往常一样，您首先导入您需要的内容：
现在您已经导入了 PuLP，您可以解决您的问题 。
您现在将使用 PuLP 解决此系统：
第一步是初始化一个实例LpProblem来表示你的模型：
您可以使用该sense参数来选择是执行最小化（LpMinimize或1，这是默认值）还是最大化（LpMaximize或-1） 。这个选择会影响你的问题的结果 。
一旦有了模型，就可以将决策变量定义为LpVariable类的实例：
您需要提供下限，lowBound=0因为默认值为负无穷大 。该参数upBound定义了上限，但您可以在此处省略它 ， 因为它默认为正无穷大 。
可选参数cat定义决策变量的类别 。如果您使用的是连续变量，则可以使用默认值"Continuous" 。
您可以使用变量x和y创建表示线性表达式和约束的其他 PuLP 对象：
当您将决策变量与标量相乘或构建多个决策变量的线性组合时，您会得到一个pulp.LpAffineExpression代表线性表达式的实例 。
注意：您可以增加或减少变量或表达式，你可以乘他们常数，因为纸浆类实现一些Python的特殊方法，即模拟数字类型一样__add__()，__sub__()和__mul__() 。这些方法用于像定制运营商的行为，-和* 。
类似地，您可以将线性表达式、变量和标量与运算符 ==、=以获取表示模型线性约束的纸浆.LpConstraint实例 。
注：也有可能与丰富的比较方法来构建的约束.__eq__()，.__le__()以及.__ge__()定义了运营商的行为==，= 。
考虑到这一点，下一步是创建约束和目标函数并将它们分配给您的模型 。您不需要创建列表或矩阵 。只需编写 Python 表达式并使用 =运算符将它们附加到模型中：
在上面的代码中，您定义了包含约束及其名称的元组 。LpProblem允许您通过将约束指定为元组来向模型添加约束 。第一个元素是一个LpConstraint实例 。第二个元素是该约束的可读名称 。
设置目标函数非常相似：
或者，您可以使用更短的符号：
现在您已经添加了目标函数并定义了模型 。
注意：您可以使用运算符将 约束或目标附加到模型中，=因为它的类LpProblem实现了特殊方法.__iadd__()，该方法用于指定 的行为 = 。
对于较大的问题，lpSum()与列表或其他序列一起使用通常比重复 运算符更方便 。例如，您可以使用以下语句将目标函数添加到模型中：
它产生与前一条语句相同的结果 。
您现在可以看到此模型的完整定义：
模型的字符串表示包含所有相关数据：变量、约束、目标及其名称 。
注意：字符串表示是通过定义特殊方法构建的.__repr__() 。有关 的更多详细信息.__repr__()，请查看Pythonic OOP 字符串转换：__repr__vs__str__ .
最后，您已准备好解决问题 。你可以通过调用.solve()你的模型对象来做到这一点 。如果要使用默认求解器 (CBC)，则不需要传递任何参数：
.solve()调用底层求解器，修改model对象，并返回解决方案的整数状态，1如果找到了最优解 。有关其余状态代码，请参阅LpStatus[] 。
你可以得到优化结果作为 的属性model 。该函数value()和相应的方法.value()返回属性的实际值：
model.objective持有目标函数model.constraints的值，包含松弛变量的值 ， 以及对象x和y具有决策变量的最优值 。model.variables()返回一个包含决策变量的列表：
如您所见，此列表包含使用 的构造函数创建的确切对象LpVariable 。
结果与您使用 SciPy 获得的结果大致相同 。
注意：注意这个方法.solve()——它会改变对象的状态，x并且y！
您可以通过调用查看使用了哪个求解器.solver：
输出通知您求解器是 CBC 。您没有指定求解器，因此 PuLP 调用了默认求解器 。
如果要运行不同的求解器，则可以将其指定为 的参数.solve() 。例如，如果您想使用 GLPK 并且已经安装了它，那么您可以solver=GLPK(msg=False)在最后一行使用 。请记住，您还需要导入它：
现在你已经导入了 GLPK ， 你可以在里面使用它.solve()：
该msg参数用于显示来自求解器的信息 。msg=False禁用显示此信息 。如果要包含信息，则只需省略msg或设置msg=True 。
您的模型已定义并求解 ， 因此您可以按照与前一种情况相同的方式检查结果：
使用 GLPK 得到的结果与使用 SciPy 和 CBC 得到的结果几乎相同 。
一起来看看这次用的是哪个求解器：
正如您在上面用突出显示的语句定义的那样model.solve(solver=GLPK(msg=False))，求解器是 GLPK 。
您还可以使用 PuLP 来解决混合整数线性规划问题 。要定义整数或二进制变量，只需传递cat="Integer"或cat="Binary"到LpVariable 。其他一切都保持不变：
在本例中，您有一个整数变量并获得与之前不同的结果：
Nowx是一个整数，如模型中所指定 。（从技术上讲，它保存一个小数点后为零的浮点值 。）这一事实改变了整个解决方案 。让我们在图表上展示这一点：
如您所见 ， 最佳解决方案是灰色背景上最右边的绿点 。这是两者的最大价值的可行的解决方案x和y，给它的最大目标函数值 。
GLPK 也能够解决此类问题 。
现在你可以使用 PuLP 来解决上面的资源分配问题：
定义和解决问题的方法与前面的示例相同：
在这种情况下，您使用字典 x来存储所有决策变量 。这种方法很方便，因为字典可以将决策变量的名称或索引存储为键，将相应的LpVariable对象存储为值 。列表或元组的LpVariable实例可以是有用的 。
上面的代码产生以下结果：
如您所见，该解决方案与使用 SciPy 获得的解决方案一致 。最有利可图的解决方案是每天生产5.0第一件产品和45.0第三件产品 。
让我们把这个问题变得更复杂和有趣 。假设由于机器问题，工厂无法同时生产第一种和第三种产品 。在这种情况下，最有利可图的解决方案是什么pythoninf函数？
现在您有另一个逻辑约束：如果x ? 为正数，则x ? 必须为零 ， 反之亦然 。这是二元决策变量非常有用的地方 。您将使用两个二元决策变量y ? 和y ?，它们将表示是否生成了第一个或第三个产品：
除了突出显示的行之外，代码与前面的示例非常相似 。以下是差异：
这是解决方案：
事实证明，最佳方法是排除第一种产品而只生产第三种产品 。
就像有许多资源可以帮助您学习线性规划和混合整数线性规划一样，还有许多具有 Python 包装器的求解器可用 。这是部分列表：
其中一些库，如 Gurobi，包括他们自己的 Python 包装器 。其他人使用外部包装器 。例如，您看到可以使用 PuLP 访问 CBC 和 GLPK 。
您现在知道什么是线性规划以及如何使用 Python 解决线性规划问题 。您还了解到 Python 线性编程库只是本机求解器的包装器 。当求解器完成其工作时，包装器返回解决方案状态、决策变量值、松弛变量、目标函数等 。
Python中range函数如何表示1到正无穷 望大神解答 谢啦??这个应该无法实现----这个函数的所有参数都必须是一个整数 ， 而且必需至少传入一个终止参数，所以既然你输入一个整数了，那肯定就不是正无穷了 。
pythoninf函数的介绍就聊到这里吧 ， 感谢你花时间阅读本站内容，更多关于python infile函数、pythoninf函数的信息别忘了在本站进行查找喔 。
推荐阅读
- 飞行任务游戏截图怎么截，飞行任务怎么过
- go语言开发培训三年会员，go语言开发gui
- 如何用新媒体推广旅游产品，旅游领域怎样用新媒体平台来创造价值?
- gis采集平板，gis数据采集软件
- 掩码vb.net 掩码怎么算出来
- 为什么路由器越贵越好用，无线路由器越贵越好吗?
- redis能够缓存多久，redis可以缓存多少数据
- 电脑飞行的游戏，电脑飞行的游戏有哪些
- java代码添加注释 java代码如何注释