我在官方网站上找不到关于cookie修改的任何文件,即没有api doc for requests.cookies.RequestsCookieJar.
例如,
session = requests.Session()
a = session.head('http://www.google.co.uk')
session.cookies
<[曲奇(版本= 0,名称= 'NID',值= '67 = CXdvwjj9sjd-13Y0VyRQyUs8PxXaxyMhiGrrozXP7RWSjf-5alV4D17ORcfnZNYLAmlHXSVlHuS5LcuE4-v6vnzRQS-Gt72hgbGye0apoBoW5KJeVXA2o2E0gE-8jIeY '端口=无,port_specified =假,域='.使用google.co.uk" ,domain_specified = True,domain_initial_dot = True,path ='/',path_specified = True,secure = False,expires = 1424443599,discard = False,comment = None,comment_url = None,rest = {'HttpOnly':None},rfc2109 = False),Cookie(版本= 0,名称='PREF',值='ID = 41c5d5cac7d22262:FF = 0:TM = 1408632399:LM = 1408632399:S = wTfY_LkkZnSsBxoL',port =无,port_specified = False,domain = '.google.co.uk',domain_specified = True,domain_initial_dot = True,path ='/',path_specified = True,secure = False,expires = 1471704399,discard = False,comment = None,comment_url = None,rest = { },rfc2109 = …
我正在做其他实验,直到这种奇怪的行为引起了我的注意.
代码在x64版本中编译.
如果键入1,则第3次运行List方法的成本比前2个多40%.输出是
List costs 9312
List costs 9289
Array costs 12730
List costs 11950
如果键入2,则第三次运行Array方法的时间比前两次多30%.输出是
Array costs 8082
Array costs 8086
List costs 11937
Array costs 12698
你可以看到模式,完整的代码附在下面(只是编译和运行):{提供的代码是最小的运行测试.用于获得可靠结果的实际代码更复杂,我将方法包装好并在适当的预热后测试了100多次}
class ListArrayLoop
{
readonly int[] myArray;
readonly List<int> myList;
readonly int totalSessions;
public ListArrayLoop(int loopRange, int totalSessions)
{
myArray = new int[loopRange];
for (int i = 0; i < myArray.Length; i++)
{
myArray[i] = i;
}
myList = myArray.ToList();
this.totalSessions = totalSessions;
}
public void ArraySum()
{ …免责声明:这是微观基准,如果您对该主题感到不满,请不要评论诸如"过早优化是邪恶的"等引用.
示例是针对x64,.Net4.5 Visual Studio 2012 F#3.0的发布,并在Windows 7 x64中运行
在分析之后,我缩小了我的一个应用程序的瓶颈,所以我想提出这个问题:
如果内部没有回路for in循环或Seq.iter,那么很显然,他们都是相似的速度.(update2 vs update4)
如果循环内部有一个循环,for in或者Seq.iter它似乎Seq.iter快2倍for in.(update vs update3)奇怪吗？(如果在fsi中运行它们会相似)
如果它针对anycpu并在x64中运行,则没有时间差异.所以问题就变成了:如果目标是x64,Seq.iter(update3)会提升2倍的速度
update: 00:00:11.4250483 // 2x as much as update3, why?
updatae2: 00:00:01.4447233
updatae3: 00:00:06.0863791
updatae4: 00:00:01.4939535
open System.Diagnostics
open System
[<EntryPoint>]
let main argv =
let pool = seq {1 .. 1000000}
let ret = Array.zeroCreate 100
let update pool =
for x in pool do …在scipy.special.expit,物流功能实现如下:
if x < 0
a = exp(x)
a / (1 + a)
else
1 / (1 + exp(-x))
但是,我已经看到了其他语言/框架中的实现
1 / (1 + exp(-x))
我想知道scipy版本实际带来了多少好处.
对于非常小的x,结果接近0.它即使exp(-x)溢出也有效Inf.
在c#中,可以在方法中使用默认参数值,例如:
public void SomeMethod(String someString = "string value")
{
Debug.WriteLine(someString);
}
但现在我想使用数组作为方法中的参数,并为其设置默认值.
我以为它应该看起来像这样:
public void SomeMethod(String[] arrayString = {"value 1", "value 2", "value 3"})
{
foreach(someString in arrayString)
{
Debug.WriteLine(someString);
}
}
但这不起作用.
有没有正确的方法来做到这一点,如果这甚至可能的话？
这些是2个功能,fun1需要1个参数,fun2需要4个额外的无用参数.当我针对x64时,fun1需要4秒但fun2不到1 秒.如果我针对anycpu,那么两者都不到1秒.
我问这里有一个类似的问题 ,如果目标是x64,为什么Seq.iter比循环快2倍？
它是在.Net 4.5 Visual Studio 2012,F#3.0中编译,在Windows 7 x64中运行
open System
open System.Diagnostics
type Position =
{
a: int
b: int
}
[<EntryPoint>]
let main argv =
let fun1 (pos: Position[]) = //<<<<<<<< here
let functionB x y z = 4
Array.fold2 (fun acc x y -> acc + int64 (functionB x x y)) 0L pos pos
let fun2 (pos: Position[]) u v w x = //<<<<<<<< here
let functionB …对于一个简单的数组长度为5的问题(实际上数组长度可能是20 ..)
我有一个预定义的一套模式,如AAAAB,AAABA,BAABC,BCAAA,....每个模式与输入数组的长度相同.我需要一个函数,它接受任何整数数组作为输入,并返回它匹配的所有模式.(一个数组可能匹配几个模式)尽可能快.
" A "表示在该模式中,A位置的所有数字都相等.例如,AAAAA仅表示所有数字相等,{ 1,1,1,1,1 }与AAAAA匹配.
" B "表示位置B处的数字不等于A位置处的数字.(即,不是A的数字的通配符)B表示的数字不必相等.例如,ABBAA表示第1,第4,第5个数字等于,例如x,第2个,第3个不等于x. { 2,3,4,2,2 }与ABBAA相匹配.
" C "表示该位置可以是任何数字(即数字的通配符).{ 1,2,3,5,1 }匹配ACBBA, { 1,1,3,5,1 }也匹配ACBBA
我正在寻找一种有效的(在比较数字方面)算法.它不一定是最优的,但不应该是最佳的.我觉得它有点像决策树......
尝试将每个模式与输入匹配.说AABCA反对{a,b,c,d,e}.它检查是否(a=b=e && a!=c).
如果模式的数量是n,模式/数组的长度是m,则复杂度约为O(n*m)
请随意为这个问题提出更好的措辞,因为我不知道如何在没有混淆的情况下简单地理解问题.
理想的算法需要某种准备,比如将模式集转换为决策树.因此,对于某些特殊模式集,预处理后的复杂性可以实现为O(log n*log m).(只是猜测) …
我知道预分配矢量或矩阵很有用,因为它们总是存储在一个连续的内存块中.
但是,就列表而言,它可以包含差异长度和模式的元素.所以我的第一个猜测是列表可能只包含指向其元素的真实地址的指针.我对么？这里有一个相关的问题列表的内部实现是什么？它说列表本质上是一个数组,但它不包括元素如何存储在列表中,而每个元素的大小可能会改变.
示例1:如果列表包含a,b,c,d,e,何时myList$a<-1:1000000,是否已修改列表(仅a表示更新)或整个列表是否已复制和更新？
例2
> system.time( { myList <- list()
+ myList$a <- 1:10000000
+ myList$b <- 1:10000100
+ myList$c <- 1:10000200
+ myList$d <- 1:10000300})
user system elapsed
0.01 0.02 0.03
> system.time({ myList2<-list(a=1:10000000,b=1:10000100,c=1:10000200,d=1:10000300) })
user system elapsed
0.00 0.03 0.03
由于没有预先分配,myList效率会非常低myList2吗？或者没有明显的性能差异,无论有多大a,b,c,d,因为第一个只复制指针几倍？
这是预分配.列表看起来如何？它是否仅为指针预分配内存？如果是这种情况,我没有看到任何用途,因为无论如何都没有太多数据复制指针.
> system.time( { myList <- vector("list", 4)
+ myList[[1]] <- 1:10000000
+ myList[[2]] <- 1:10000100
+ myList[[3]] <- 1:10000200
+ …我有2张桌子,A,B
A: id is primary key and indexed
id, type_id, status
------------------
1, 1, True
2, 1, False
3, 2, False
...
B: (Type) type_id is primary key and indexed
type_id, param
----------
1, 23
2, 35
3, 24
我想选择的所有行B这已经至少1相关条目A与status True
select distinct B.id, B.param
from B
join A on A.type_id = B.type_id
where A.status = true
这是一个好方法吗？