python的一些非常基础的但不影响使用的事

python的一些入门的基本知识。

python模块管理：

有init就叫包没有init就叫文件夹。

from file import demo,file是文件夹，demo.py 报错！

如果在文件夹中加入一个init.py 即使空白也可以用import语句，否则不行。

if __name__=='__main__'

主文件，从文件。python index.py 那么index.py就是主文件。

如果是运行某份主文件，那么就是输出print __name__
单独运行主从文件那么输出的都是_main__
如果在从文件输出__name__，但是运行主文件，那么运行的主文件输出的是
main，那么被导入的不是main而是包+文件名。

所以if __name__=='__main__'
如果是主文件，就执行。
黑客来了，不能执行我们这个个文件即使它们能import
它执行不了这个主函数。

函数式编程：

可变参数：

foo(name,action='haha')默认参数，默认参数放最后

def show(arg):
 for item in arg:
 print item

show(['dfd'.'dfd'])

def show(**args):
传字典，把字典传进去要加两个**

如果

show(name=aaa,age=dfdfd)这个就是传字典！

def show(*arg):
那么python会自动把你的所有的参数包装成列表。
这不是可变参数,而是列表！！！

def foo():
 yield 1

re=foo()
print re

什么是range,xrange

xrange()得到是一个对象， 但是可以遍历。
只有遍历的时候才一个一个创建，没有遍历的时候，什么都不是，只是一个生成器，
延迟创建？怎么办到的！
yield
def foo():
 yield 1
 yield 2
 yield 3

re=foo()
for item in re:
 print item

只是暂时保存执行的位置，当循环到1时候就执行第一个，然后执行第二个yield2
然后出去了，然后保持这个位置，就执行第三个。

def AlexReadlines():
seek=0;
while True:
 with open as f:
  f.seek(seek)  #从某个字节开始读，默认0
  data=f.readline()
  if data:
    seek=f.tell()#到了行末，tell是位置。到了行末的位置。
    yield data
  else :
 return

for item in AlexReadlines():
    print item

yield可以用来创建线程池

with语法：自动close
with open() as f:
当跳出这一级自动close

一般调用函数中间状态不能被外部获知。
函数走到中间停住，程序可以动态，也是通过yield。

三元运算：和lamba表示
result = 'gt ' if 1>3 else 'lt'
lamba是一个关键字！
a= lambda x,y:x+y
print temp(4,10)

tmp=lambda x :x*x
tmp(2)

[x*2 for x in range(10)]
map(lambda x:x*2, range(10 ))

内置函数！！！
help()
dir()
vars()
type()
import
list()
dict()
tuple()
id()

当你两次import python只会import一次，
如果用reload(demo)重新导入

t=123
t2=888
id(t)
返回内存地址

all([1,2,3,4])
遍历之 所有都是真则会真，若有一个为0 则为假

any([0,1,2,3])
如果所有的都是0才返回假
可以快速判断列表是否有空的字符串。

chr(66)
chr(67)ASIX码

ord('A')码转数字。
通过这个可以随机生成字母

li=['shoubiao','dfdf','dsfsdfdfd']

生成序号或者key

for item in enumerate(li):
print item

自动加从0开始的序列，

如果规定起始值，enumereate(li,10)
从10开始

，可以加

s='i am {0},{1}'
print s.format('zhang','helo')

跟%s一样

apply 执行函数！！

def Funciotn(arg):
 pring sfsd

apply(Function,参数)

map(函数,序列)
遍历数组的每一个元素

def foo(ar):
 return arg+100

map(foo,[1,2,3])
相当于append自动加到list

t=map(lambda arg:arg+100,[1,2,4]) map 是映射！一对一
def foo(arg):
 if arg<22:
  return true
 else reutrn false
t=filter(foo,[11,22,33])

reduce(lambda x,y:x+y,[1,2,3])

就是q中的over，先传两个值，返回值当做x，把第三个值带入
如果列表只有一个元素。直接返回 lambda必须至少两个

zip()

x=[1,2,3]
y=[2,4,5]
z=[1,1,1]
q=[1,2,3]
print zip(x,y,z q)

如果四个不整齐，有多的有少的，只取整齐的，其他的放弃。

'8*8'

eval(a)
直接返回64

把字符串当做表达式

 反射：
通过字符串'os'

temp='os'
导入os.

但是不能import

model= __import__(temp)

函数式编程，把函数当参数调用的。
python比较有限：