1.python一些基础理念,基础知识
a.python底层是使用C语言实现的,又由于C语言的可移植性,所以python能运行在任何带有ANSI C编译器的编译平台中。
b.python的内存管理是由python解释器负责的,开发人员就可以从内存管理中释放出来
c.python一些外来引入包的安装可以使用pip或者easy_install
2.python一些基础知识
a.支持连续运算符,比如:3 < 4 < 5会返回True
b.变量名大小写敏感
c.不支持自增、自减运算,比如会将--n解释为-(-n)也即n,++n解释为+(+n)也即n
d.通常使用#作为单行注释,三引号作为多行注释
e.列表使用[]包裹,访问也使用[],例如:
aList = [1,2,3,4]
aList[0]结果为1
f.元组使用()包裹,访问使用[],元组的值不能修改,例如:
aTuple=('robot',1,2)
aTuple[0]结果为'robot'
d.python中字典使用{}包裹,访问使用[],例如:
aDict={"host":"earth"}
aDist["host"]返回"earth"
e.列表解析可以用于生成一个列表,例如:
squared=[x ** 2 for x in range(4)]返回[0,1,4,9]
f.异常使用
try:
except IOError,e:
print "error"
g.当一个类实例被创建时,__init__()方法会自动执行,在实例创建完毕后执行,类似构造器。但他并不创建实例,只是执行对象的一些初始化操作。
h.模块中可以包含可执行代码、类和函数,当创建了一个python文件的时候,模块的名字就是不带.py的文件名,可以在另外一个模块中通过import导入这个模块来使用
i.在一行代码的末尾添加\表示两行代码是同一行代码,分号;将两个语句放在同一行
j.对象采用引用传递,基础类型数据(int,float等)传值
k.多元赋值方式可以使用无需中间变量交换变量的值,例如:
x,y=1,2
x,y=y,x //执行后x值为2,y的值为1
l.类中的变量默认都是公有变量,python定义私有变量的方式是前缀使用两个下划线:__,在python中需要直接访问私有变量则使用: 对象名._类名__私有属性名 访问,例子:
class testPrivate:
def __init__(self):
self.__data=[]
def add(self,item):
self.__data.append(item)
def printData(self):
print self.__data
t = testPrivate()
t.add("hello")
t.printData()
print t._testPrivate__data //在类外直接访问私有变量__data
m.不支持函数重载
n.字符串本身是不可变的
o.在操作文件的时候,不管使用什么操作系统,只要导入了os模块,换行符会被替换成该平台的换行符,不需要特殊处理,当然你也可以自己设置,print在输出内容尾部会加上换行符,可以通过在语句后加上逗号避免这种行为
p.可以通过引入sys模块并通过sys.argv得到参数内容
q.python中的模块可以看作是一个独立的文件,模块的文件名就是模块的名字加上扩展名py,包是用来组织模块的,一个模块只被加载一次,无论被导入多少次,加载只在第一次导入的时候发生
r.在每个包里面会有__init__.py文件,它用来初始化模块,from * import *在导入子包时会用到它,它们可以是空文件
s.可以在模块的头部加入一个额外的编码指示说明就可以让导入者使用相应的编码解析你的模块,例如希望使用utf-8解析:# -*- coding: UTF-8 -*-
t.所有类可以继承一个或者多个类,继承方式
class MyClass(bases):
class_suit
其中bases是一个或者多个可以被继承的父类
u.在类的实例方法声明中都存在self参数,这个参数代表实例对象本身,例如:
class MyClass(object):
def printFoo(self):
print "run in foo"
v.父类的__init__初始化函数不会在子类中隐式调用,需要显示在子类中调用,并且把子类的self传递过去例如:
class AddrBookEntity(object):
def __init__(self,name,phone):
self.name = name
self.phone = phone
class EmplAddrBookEntity(AddrBookEntity):
def __init__(self,name,phone,id,email):
AddrBookEntity.__init__(self,name,phone)//调用父类的初始化函数
self.id = id
self.email = email
w.python中方法的声明和定义是一体的,不支持纯虚函数或者抽象方法
3.python一些高级操作
a.可以使用切片方法创建切片对象,切片语法为:[起始索引:结束索引:步进值],可以使用负数表示索引,结束索引可以使用-1表示,倒数第二个使用-2等等,例子:
a1:倒序
foostr="abcde"
foostr[::-1]结果为"edcba"
a2:反向截取
foostr1="abcde"
foostr1[::-2]结果为"eca"
b.函数参数
b1.调用函数时可以不按照函数声明中的参数顺序输入参数,但要输入相应的参数名,例如:
net_conn(port=8080,host="china")
b2.传递函数作为参数
def foo():
print "run in foo()"
def bar(argfunc):
argfunc()
bar(foo)//传递函数参数
b3.函数默认参数:对于默认参数如果在函数调用时没有为参数提供值则使用预先定义的默认值,所有的必需参数都要在默认参数之前,例如:
def taxMe(rate=0.1,cost)://错误
return rate * cost
正确方式:
def taxMe(cost,rate=0.1):
return rate * cost
b4.可变长参数必须在必需参数和默认参数之后,作为元组传递给函数,格式:
def function_name(formal_args, *vargs):
function_body_suite
例子:
def tupleVarArgs(args1,args2="defaultB",*theRest):
print "formal args1:",args1
print "formal args2:",args2
for eachArg in theRest:
print "another arg:",eachArg
tupleVarArgs("abc",123,"xyz","efg")将输出:
formal args1:abc
formal args2:123
another arg:xyz
another arg:efg
b5.关键字变量参数,当我们有不确定数目的参数的时候,参数放入一个字典中,字典的键值是参数名,值是参数值,格式:
def function_name(formal_args,*vargs,**vargsd):
function_body_suite
例子:
def dictVarArgs(arg1,arg2="defaultB",**theRest):
print "formal args1:",args1
print "formal args2:",args2
for eachArg in theRest.keys():
print "another arg:%s:%s" % \
(eachArg,str(theRest[eachArg]))
tupleVarArgs("abc",123,a="xyz",b="efg")将输出:
formal args1:abc
formal args2:123
another arg:a:xyz
another arg:b:efg
b6.综合可变长参数和关键字参数
例子:
def allVarArgs(args1,args2="defaultB",*theRest, **theRest1):
print "formal args1:",args1
print "formal args2:",args2
for eachArg in theRest:
print "another arg:",eachArg
for eachArg in theRest1.keys():
print "another arg:%s:%s" % \
(eachArg,str(theRest1[eachArg]))
aTuple=(6,7,8)
aDict={"z":9}
newfoo("abc","efg",*aTuple,**aDict)
b7.匿名函数使用lambda定义
a = lambda x,y=2: x+y
调用方式:a(3)
c.内建函数filter(bool_func,seq)
给定一个对象的序列和一个过滤函数,每个序列元素都通过这个过滤器进行筛选,保留函数返回为真的对象
filter(bool_func,seq):第一个参数是一个返回bool值的函数;第二个参数是一个序列,例子:
def odd(n)
return n%2
allNums = []
for eachNumber in range(9):
allNums.append(randint(1,99))
print filter(odd,allNums)
d.内建函数map(func,seq)
d1.将函数调用映射到每个序列的元素上,并返回一个含有所有返回值的列表,例子:
map((lambda x: x+2),[0,1,2,3,4,5])
d2.形式更一般的map()能以多个序列作为其输入。如果是这种情况,那么map会并行地迭代每个序列。在第一次调用时,map()会将每个序列的第一个元素捆绑到元组中,例子:
map(lambda x,y:x+y,[1,3,5],[2,4,6]) 返回[3,7,11]
map(None,[1,3,5],[2,4,6])返回[(1,2),(3,4),(5,6)]
map的上面那个例子和zip函数很像,zip函数:zip([1,3,5],[2,4,6])返回[(1,2),(3,4),(5,6)]
e.内建函数reduce(func,seq)
reduce使用了一个二元函数将seq中的序列进行折叠(seq的第一个元素和第二个元素作为func的输入,然后func的输出结果与seq的第三个元素作为下一次输入,以此类推),例子:
求0到4的数字之和:reduce((lambda x,y:x+y),range(5))
f.全局变量,在函数的局部作用域中,全局变量会被局部变量覆盖掉,如果想在函数局部中指定使用全局变量,可以使用global关键字,例如:
is_this_global="xyz"
def foo():
global is_this_global
is_this_global = "def"
foo()
print is_this_global //def
g.闭包:由于python的静态嵌套域,我们可以使用闭包的功能:如果在一个内部函数里,对在外部作用域(但不是全局作用域)的变量进行引用,那么内部函数被认为是闭包。定义在外部函数内的但由内部函数引用或者使用的变量被称为自由变量。例子:
def counter(start=0):
count=[start]
def incr():
count[0]+=1
return count[0]
return incr//外部函数返回内部函数
调用:
count=counter(5)//count是incr函数
print count() //调用incr(),返回6
print count()//调用incr(),返回7
h.装饰器:装饰器是在调用函数之上的装饰,这些装饰器是当声明一个函数的时候才会应有的额外调用,装饰器的名字以@开头,接着是装饰器的名字和可选的参数
h1例如:静态函数可以使用装饰器
原本的静态函数实现方法:
class MyClass(object):
def staticFoo():
functionbody
staticFoo=staticmethod(staticFoo)//通过内建函数staticmethod进行转换
加了装饰器之后的定义
class MyClass(object):
def staticFoo():
functionbody
h2.装饰器的语义:
def foo():
functionbody
与foo=g(f(foo))相同,意思是f函数以foo作为参数返回一个值作为g函数的输入,最后g函数返回一个函数。例子:
def tsfunc(func):
def wrappedFunc():
print "[%s] %s() called" % (ctime(),func.__name__)
return func()//调用func函数
return wrappedFunc//返回wrappedFunc
@tsfunc
def func():
pass
h3.带参数的装饰器,语义:
@d1(args)
def func():
function body
上面的注解等价于d1(args)(func),d1以args作为参数返回一个函数A,A的参数是func函数,A还会返回一个函数B例子:
def tsfunc(condition)://以condition作为参数返回一个函数A
def preFunc(func)://被tsfunc(condition)返回的A函数的参数是func
def wrappedFunc(*args,**hargs):
print "args is",args //打印("hello",)
print "[%s] %s() called" % (ctime(),func.__name__)
return func(*args,**hargs)
return wrappedFunc//A函数返回B函数
if condition == "pre":
return preFunc
return wrappedFunc
@tsfunc("pre")
def foo(info):
print "info is",info
pass
if __name__ == "__main__":
foo("hello")
i.生成器:是一个带yield语句的函数,一个函数或者子函数只返回一次,一个生成器能暂停执行并返回一个中间的结果,那就是yield语句的功能,返回一个值给调用者并暂停执行。当生成器的next()方法被调用的时候,它会准确从离开的地方继续。
例子,随机输出list中的结果,进行遍历:
def randGen(aList):
while len(aList) > 0:
yield aList.pop(randint(0,len(aList)))
for item in randGen(["rock","paper","scissors"]):
print item
j.类属性,在类中声明,类似于静态成员变量,但是一定要用类.属性修改他,如果用实例.属性修改他,实际上引入了一个实例属性,例子:
class testPrivate:
staticA = 1
def __init__(self):
self.__data=[]
def add(self,item):
self.__data.append(item)
def printData(self):
print self.__data
t1 = testPrivate()
t2 = testPrivate()
t1.staticA = 100 //实际上在实例t1中引入了一个新的实例属性staticA,类属性值没有改变
print t1.staticA //返回实例属性值100
print t2.staticA //返回引用的类属性1
print testPrivate.staticA //返回类属性1
扫一扫
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
