对于在Python中进行AND/OR？感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍在python中进行中文处理的库只有一个，并为您提供关于Python-如何在Python中进行相对导入？、使

对于在Python中进行AND / OR？感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍在python中进行中文处理的库只有一个，并为您提供关于Python-如何在Python中进行相对导入？、使用队列在python中进行线程化、利用Fn.py库在Python中进行函数式编程、在Python中对ALM进行Anova测试的有用信息。

• 在Python中进行AND / OR？（在python中进行中文处理的库只有一个）
• Python-如何在Python中进行相对导入？
• 使用队列在python中进行线程化
• 利用Fn.py库在Python中进行函数式编程
• 在Python中对ALM进行Anova测试

在Python中进行AND / OR？（在python中进行中文处理的库只有一个）

我知道andandor表达式存在于python中，但是有任何and/or表达式吗？还是通过某种方式组合它们以产生与and/or表达式相同的效果？

我的代码看起来像这样：

if input=="a":            if "a" or "á" or "à" or "ã" or "â" in someList:                    someList.remove("a") or someList.remove("á") or someList.remove("à") or someList.remove("ã") or someList.remove("â")

这样，我的意思是，如果用户输入“ a”并且任何类型的“ a”都包含在先前定义的列表中，我是否可以从给定列表中删除所有类型的“ a”？

python告诉我在以下方面存在问题：

someList.remove("a") or someList.remove("á") or someList.remove("à") or someList.remove("ã") or someList.remove("â")

他告诉我： ValueError: list.remove(x): x not in list

答案1

正如Matt Ball的回答所解释的，or 是“和/或”。但or不适in用于您上面使用它的方式。你不得不说if "a" in someList or "á" in someListor...。还是更好

if any(c in someList for c in ("a", "á", "à", "ã", "â")):    ...

这就是您所问问题的答案。

其他注意事项

但是，关于您发布的示例代码，还有更多要说的话。首先，someList.remove... or someListremove...这里的语句链是不必要的，并且可能导致意外的行为。这也很难读！最好将其分成几行：

someList.remove("a")someList.remove("á")...

但是，仅此还不够。正如您所观察到的，如果该项目不在列表中，则将引发错误。最重要的是，使用remove非常缓慢，因为每次调用它时，Python都必须查看列表中的每个项目。因此，如果要删除10个不同的字符，并且有一个包含100个字符的列表，则必须执行1000个测试。

相反，我建议一种非常不同的方法。使用过滤列表set，如下所示：

chars_to_remove = set(("a", "á", "à", "ã", "â"))someList = [c for c in someList if c not in chars_to_remove]

或者，就地更改列表而不创建副本：

someList[:] = (c for c in someList if c not in chars_to_remove)

它们都使用列表理解语法来创建新列表。他们查看中的每个字符someList，检查其中的字符chars_to_remove，如果不是，则将字符包括在新列表中。

这是此代码的最有效版本。它具有两个速度优势：

1. 它只通过someList一次。在上述情况下，它没有执行1000个测试，而是仅执行100个。
2. 它可以用一个操作测试所有的字符，因为chars_to_remove是一个set。如果它chars_to_remove是list或tuple，那么在上述情况下每个测试实际上将是10个测试-因为列表中的每个字符都需要单独检查。

Python-如何在Python中进行相对导入？

app/
   __init__.py
   sub1/
      __init__.py
      mod1.py
   sub2/
      __init__.py
      mod2.py

使用队列在python中进行线程化

我想在python中使用线程下载大量网页，并通过以下代码在网站之一中使用队列。

它放置了一个无限的while循环。是否每个线程都连续运行，直到所有线程完成才结束？我错过了什么吗？

#!/usr/bin/env pythonimport Queueimport threadingimport urllib2import timehosts = ["http://yahoo.com", "http://google.com", "http://amazon.com","http://ibm.com", "http://apple.com"]queue = Queue.Queue()class ThreadUrl(threading.Thread):  """Threaded Url Grab"""  def __init__(self, queue):    threading.Thread.__init__(self)    self.queue = queue  def run(self):    while True:      #grabs host from queue      host = self.queue.get()      #grabs urls of hosts and prints first 1024 bytes of page      url = urllib2.urlopen(host)      print url.read(1024)      #signals to queue job is done      self.queue.task_done()start = time.time()def main():  #spawn a pool of threads, and pass them queue instance   for i in range(5):    t = ThreadUrl(queue)    t.setDaemon(True)    t.start()  #populate queue with data     for host in hosts:    queue.put(host)  #wait on the queue until everything has been processed       queue.join()main()print "Elapsed Time: %s" % (time.time() - start)

答案1

将线程设置为daemon线程会使线程在主线程完成后退出。但是，是的，您是正确的，只要线程中的某些queue内容将阻塞，线程将连续运行。

该文档解释了此详细信息Queue docs

python Threading文档也对此daemon部分进行了说明。

当没有活动的非守护线程时，整个Python程序将退出。

因此，当队列为空并且queue.join解释器退出时恢复运行时，线程将死亡。

编辑：的默认行为的更正 Queue

利用Fn.py库在Python中进行函数式编程

尽管python事实上并不是一门纯函数式编程语言，但它本身是一门多范型语言，并给了你足够的自由利用函数式编程的便利。函数式风格有着各种理论与实际上的好处（你可以在python的文档中找到这个列表）：

•     形式上可证
•     模块性
•     组合性
•     易于调试及测试

虽然这份列表已经描述得够清楚了，但我还是很喜欢Michael O.Church在他的文章“函数式程序极少腐坏（Functional programs rarely rot）”中对函数式编程的优点所作的描述。我在PyCon UA 2012期间的讲座“Functional Programming with Python”中谈论了在Python中使用函数式方式的内容。我也提到，在你尝试在Python中编写可读同时又可维护的函数式代码时，你会很快发现诸多问题。

fn.py类库就是为了应对这些问题而诞生的。尽管它不可能解决所有问题，但对于希望从函数式编程方式中获取最大价值的开发者而言，它是一块“电池”，即使是在命令式方式占主导地位的程序中，也能够发挥作用。那么，它里面都有些什么呢？
Scala风格的Lambda定义

在Python中创建Lambda函数的语法非常冗长，来比较一下：

Python

map(lambda x: x*2, [1,2,3])

Scala

立即学习“Python免费学习笔记（深入）”；

点击下载“修复打印机驱动工具”；

代码如下:

from fn import _

assert (_ + _)(10, 5) = 15
assert list(map(_ * 2, range(5))) == [0,2,4,6,8]
assert list(filter(_ < 10, [9,10,11])) == [9]

from fn import _ 

print (_ + 2) # "(x1) => (x1 + 2)" 
print (_ + _ * _) # "(x1, x2, x3) => (x1 + (x2 * x3))"

from fn import Stream 
from fn.iters import take, drop, map
from operator import add

f = Stream()
fib = f << [0, 1] << map(add, f, drop(1, f))

assert list(take(10, fib)) == [0,1,1,2,3,5,8,13,21,34]
assert fib[20] == 6765
assert list(fib[30:35]) == [832040,1346269,2178309,3524578,5702887]

def fact(n):
   if n == 0: return 1
   return n * fact(n-1)

>>> import sys
>>> fact(sys.getrecursionlimit() * 2)
... many many lines of stacktrace ...
RuntimeError: maximum recursion depth exceeded

def fact(n, acc=1):
   if n == 0: return acc
   return fact(n-1, acc*n)

from fn import recur

@recur.tco 
def fact(n, acc=1):
   if n == 0: return False, acc
   return True, (n-1, acc*n)

class Request(dict):
   def parameter(self, name):
     return self.get(name, None)

r = Request(testing="Fixed", empty=" ")
param = r.parameter("testing")
if param is None:
   fixed = ""
else:   
   param = param.strip()
   if len(param) == 0:
     fixed = ""
   else:
    fixed = param.upper() 

from operator import methodcaller
from fn.monad import optionable

class Request(dict):
   @optionable
   def parameter(self, name):
     return self.get(name, None)

r = Request(testing="Fixed", empty=" ")
fixed = r.parameter("testing") 
     .map(methodcaller("strip")) 
     .filter(len) 
     .map(methodcaller("upper")) 
     .get_or("")

from fn.monad import Option 

request = dict(url="face.png", mimetype="PNG") 
tp = Option \ 
     .from_value(request.get("type", None)) \ # check "type" key first 
     .or_call(from_mimetype, request) \ # or.. check "mimetype" key 
     .or_call(from_extension, request) \ # or... get "url" and check extension 
     .get_or("application/undefined")

formula = ''PropNo_Pred ~ Geography + log10BMI + Cat_OpCavity + CatLes_neles + CatRural_urban + \        CatPred_Control + CatNative_Intro + Midpoint_of_study''mod1 = smf.glm(formula=formula, data=A2, family=sm.families.Binomial()).fit()mod1.summary()

table1 = anova_lm(mod3)print table1