[python2] python basis

python的官方网站文档:https://docs.python.org/2/library/functions.html

1.python 的环境变量:
(1)对于Python3
#!/usr/bin/env python3
(2)对于python2

#!/usr/bin/env python

注释可以让这个文件直接在Unix/Linux/Mac上运行,


2.python2.7中为了输出中文需要加:

 

#-*-  coding:utf-8 -*-

 

注释表示.py文件本身使用标准UTF-8编码;


3.对于单个字符的编码:
ord() 获取字符的整数表示。
chr() 将编码转化成对应的字符

4.常量
10/3=3.3333333333333335
10//3=3
10%3=1

5.
append() 方法向列表的尾部添加一个新的元素。只接受一个参数
extend()方法只接受一个列表作为参数,并将该参数的每个元素都添加到原有的列表中
>>> list
[1, 2, 0, 'abc']
>>> list.append(3)
>>> list
[1, 2, 0, 'abc', 3]
>>> list.extend([22,'cd'])
>>> list
[1, 2, 0, 'abc', 3, 22, 'cd']

6.range()语法:
range(start,stop,step )
start:计数从start开始。默认是从0开始。 range(5) 等价于range(0,5)
srop:计数到stop结束,range(0,5) 是[0,1,2,3,4]  没有5
step:步长 默认是1, range(0,5) 等价于range(0,5,1)

7.
abs() 取绝对值
cmp(x,y) 比较函数,需要两个参数。如果x<y 返回 -1, 如果x=y,返回0,如果x>y 返回1
int() 数据类型转换,int()函数可以讲其他的数据类型转换为整数

例如:
print int('12')
print int(12.2)
print float('12.34')
print str(1.23)
print bool(1)
print bool('')

输出:
12
12
12.34
1.23
True
False


8.函数名其实就是指向一个函数对象的引用,完全可以将函数名赋予给一个变量。
相当于给这个函数起了一个别名
a = abs      #变量名a 指向abs函数
print a(-1)  #所以可以通过a调用abs函数

9.定义一个函数需要使用def语句,依次是函数名,括号,括号中的参数和冒号:
然后在缩进块中编写函数体,函数的返回值用return语句。
函数体内部的语句在执行的时候,一旦执行到return是,函数就执行完毕,并将结果返回。
如果没有return 语句,函数执行完毕后也会返回结果,只是结果为None.
return none 可以简写为return

如:实现自定义的abs函数
def my_code(x):
    if x >= 0:
        return x
    else:
        return -x

print my_code(5)

10.Pass是占位符,
TypeError  调用函数时,参数个数不对,python解释器会自动检查出来并抛出TypeError
数据类型检查可以使用内置函数isinstance实现

tupple是元组,在语法上返回一个tuple可以省略括号,而多个变量可以同事接收一个tuple.
按位置赋给对应的值,所以python的函数返回值其实就是返回一个tuple.

11.默认参数设定
(1)必选参数在前,默认参数在后。
(2)当函数有多个参数的时候,把变化大的参数放在前面,变化小的参数放在后面。
变化小的参数可以做为默认参数。  ---最大的好处是降低调用函数的难度
def power3(x,n=2):
    s = 1
    while n >0:
        n = n -1
        s = s * x
    return s

print power3(5)
print power3(5,2)
print power3(5,3)


12.定义默认参数要牢记:默认参数必须指向不变的对象。
python函数在定义的时候,默认参数L的值被计算出来了,即[],因为默认参数L也是一个变量
她指向对象[],每次调用该函数的时候,如果改变了L的内容,则下次调用时,默认参数就变了。
不再时函数定义时的[]

def add_end(L=[]):
    L.append('END')
    return L

print add_end([1,2])
print add_end()
print add_end()
输出:
[1, 2, 'END']
['END']
['END', 'END']

如果需要修改可以使用None
不变对象一旦创建,对象内部的数据就不能修改,这样就减少了由于修改数据导致的错误。
此外,由于对象不变,多任务环境下同时读取对象不需要加锁,同时读一点问题都没有

def add_end2(L=None):
    if L is None:
        L=[]
    L.append('END')
    return L
print add_end2([1,2])
print add_end2()
print add_end2()

输出:
[1, 2, 'END']
['END']
['END']

13.定义可变参数和定义list或者tuple参数相比,仅仅在参数前面加一个*号。
可变参数允许传入0个或者任意个参数,这些可变参数在函数调用时自动组装为一个tuple.
def calc2(*numbers):
    sum2 = 0
    for n in numbers:
        sum2 = sum2 + n * n
    return sum2
print calc2(1,2,3)
print calc2(1,3,5,7)

14.关键字参数
允许传入0个参数或者任意参数名的参数,这些关键字参数在函数内部自动组装为一个dict.

15.参数组合
python定义函数,可以用必选参数,默认参数,可变参数和关键字参数。
这四种参数可以一起使用。或者只用其中的部分。
但参数定义的顺序必须是:
必选参数、默认参数、可变参数和关键字参数。
<1>
def func(a,b,c=0,*args,**kw):
    print 'a=',a,'b=',b,'c=',c,'args=',args, 'kw=',kw

func(1,2,3,'a','b')
func(1,2,3,'a','b',x=20)

输出:
a= 1 b= 2 c= 3 args= ('a', 'b') kw= {}
a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 20}

<2>
def func(a,b,c=0,*args,**kw):
    print 'a=',a,'b=',b,'c=',c,'args=',args, 'kw=',kw

args = (1,2,3,4)  #tuple
kw = {'x':99}     #dict

func(*args,**kw)

输出:
a= 1 b= 2 c= 3 args= (4,) kw= {'x': 99}

*args是可变参数,args接收的是一个tuple;
**kw是关键字参数,kw接收的是一个dict。


16.list 和 tuple
list:
list是一个可变的有序表,list里面的元素的数据类型也可以不同,
list元素也可以是另一个list
如果一个list中一个元素也没有,就是一个空的list,它的长度为0:
L= ['Michael','Sarah','Tracy','Bob','jack']

list长度:print len(L)
最后一个元素的位置:print len(L)-1
如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素

print L[0],L[1],L[2],L[3]
#输出:Michael Sarah Tracy Bob

print L[-1],L[-2],L[-3],L[-4],L[-5]
#输出:jack Bob Tracy Sarah Michael

print L[-1],L[-2],L[-3],L[-4],L[-5],L[-6]
报错:
Traceback (most recent call last):
jack Bob Tracy Sarah Michael
  File "C:/zsy/mycode/jichu.py", line 6, in <module>
    print L[-1],L[-2],L[-3],L[-4],L[-5],L[-6]
IndexError: list index out of range

可以往list中追加元素到末尾:
>>> classmates.append('Adam')
也可以把元素插入到指定的位置,比如索引号为1的位置:(即 新插入的元素的索引会为1,之前索引为1的元素需要向后排)
>>> classmates.insert(1, 'Jack')
要删除list末尾的元素,用pop()方法
>>> classmates.pop()
要删除指定位置的元素,用pop(i)方法,其中i是索引位置:
>>> classmates.pop(1)
要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
>>> classmates[1] = 'Sarah'





tuple
另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改
M = ('Michael','Sarah','Tracy','Bob','jack')
它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,但不能赋值成另外的元素。

tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来
>>> t = (1, 2)
如果要定义一个空的tuple,可以写成():
>>> t = ()
所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:
>>> t = (1,)

注意:
>>> t = (1)
定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。




17.切片
对于这种经常取制定索引范围的操作,用循环十分繁琐,因此python提供了切片(Slice)操作符,能大大简化操作。
L= ['Michael','Sarah','Tracy','Bob','jack']
print L[0:3]

L[0:3]表示,从索引0开始取,直到索引3为止,即0,1,2 正好3个元素。也就是说 “前闭后开”区间
如果第一个索引是0,可以省略: L[:3]

前10个数,每两个取一个:
L=range(100)
print L[:10:2]
输出:[0, 2, 4, 6, 8]

所有数,每5个取一个
>>> L[::5]

甚至什么都不写,只写[:]就可以原样复制一个list:
L = [2,4,6,8,10]
M = L[:]
print M

18.迭代
如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)。
所以字符串,list 都是可以迭代,整数是不能迭代的。
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False


19 生成器
如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。
在Python中,这种一边循环一边计算的机制,称为生成器(Generator)。
(1)要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator
L = [x * x for x in range(10)]
g = (x * x for x in range(10))
print g
输出:<generator object <genexpr> at 0x0000000004BBD318>
创建L和g的区别仅在于最外层的[]和(),L是一个list,而g是一个generator。

generator保存的是算法,每次调用next(),就计算出下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。
(2)这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator:
这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。
而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
print fib(6)
输出:<generator object fib at 0x00000000051DD318>

20.高阶函数
map/reduce
map()函数接收两个参数,一个是函数,一个是序列
map将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回。

reduce()接收两个参数。把一个函数作用在一个序列上。

21 Python中转变大小写的直接函数有以下方法:
upper()——所有字母大写
lower()——所有字母小写
capitalize()——首字母大写,其他字母小写
title()——所有单词首字母大写,其他小写

22.filter()函数用于过滤序列
filter()也接收一个函数和一个序列。filter()吧传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。

23.闭包

24.关键字lambda 表示匿名函数,
匿名函数lambda x: x * x实际上就是:
def f(x):
    return x * x

冒号前边的参数表示函数参数。
匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果


25.装饰器Decorator
在函数调用前后自动打印日志,但又不希望修改函数的定义,这种diamagnetic运行期间动态增加功能的方式,称之为装饰器

26.偏函数 functools.partial
把一个函数的默写参数给固定主(也就是设置默认值),返回一个新的函数,调用这个新函数会更简单。
需要导入模块:
import functools
小结:当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新的函数,
这个函数可以固定原函数的部分参数,从而在调用时更简单。

27.模块
任何模块代码的第一个字符串都被视为模块的文档注释;

 

.

 

.

.

.

.

 

 

 

 

 

廖雪峰python2.7:

https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000

没有更多推荐了,返回首页