[python2] python basis

最新推荐文章于 2022-09-07 21:56:37 发布

flynna

最新推荐文章于 2022-09-07 21:56:37 发布

阅读量359

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/flynna/article/details/80804742

版权

python 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

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.模块
任何模块代码的第一个字符串都被视为模块的文档注释；