码迷,mamicode.com
首页 > 编程语言 > 详细

Python的基本用法

时间:2018-12-23 18:01:30      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:engine   数列   func   很多   pre   数据   指定   大小写   about   

---恢复内容开始---

一、函数

1.1 默认参数

想要计算一个数x的n次方,可以定义如下的函数。但是有时候我们仅仅只需要计算x^2,所以只想使用一个参数即power(x),这时如果仍用如下代码会报错

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
def power(x,n=2)

可以改成上面的形式,不传入参数,即默认n=2。同时,当有多个默认参数时,我们可以指定为哪个默认参数赋值如下

def fun(a,b=2,c=3):
    pass

fun(4,c=6)

有一点需要注意:默认参数必须是不变对象,不能是list这样的可变对象

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

>>> add_end()
[END]
>>> add_end()
[END, END]
>>> add_end()
[END, END, END]

函数定义后,默认参数的值就被计算出来了。如果默认参数是可变的,那么每次调用函数后,默认参数的值就会发生改变。

1.2 可变参数

如果参数的个数是不确定的,可以使用list或者tuple进行封装,也可以使用可变参数,方法如下:

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

""" 使用list作为可变参数时,可以使用下面的简单方法
>>> nums = [1, 2, 3]
>>> calc(*nums)
14

1.3 关键字参数

可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):
    print(name:, name, age:, age, other:, kw)

""" 函数除了接收两个必填参数name和age外,还可以接收若干个关键字参数kw

>>> person(‘Michael‘, 30)
name: Michael age: 30 other: {}
>>> person(‘Bob‘, 35, city=‘Beijing‘)
name: Bob age: 35 other: {‘city‘: ‘Beijing‘}
>>> person(‘Adam‘, 45, gender=‘M‘, job=‘Engineer‘)
name: Adam age: 45 other: {‘gender‘: ‘M‘, ‘job‘: ‘Engineer‘}

1.4 命名关键字参数

如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收cityjob作为关键字参数。这种方式定义的函数如下:

def person(name, age, *, city, job):
    print(name, age, city, job)

如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了:

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

二  List和Tuple

2.1 List和Tuple相当于一个数组,但是数组里可以存放的内容是不受限制的,也不需要全部相同,同时一个List里可以有一个List。List是可变的对象,而Tuple是不可变的对象

对于List和Tuple的访问,可以使用切片技术:

>>> L = [Michael, Sarah, Tracy, Bob, Jack]

>>> L[1:3]
[Sarah, Tracy]

""" L[i:j]表示从索引i开始,取到索引j-1的内容

2.2 遍历元素时,C或其他语言是按照下标进行的,而Python的遍历可以不需要下边,只要变量是可以迭代的即可,如dict就可以迭代

>>> d = {a: 1, b: 2, c: 3}
>>> for key in d:
...     print(key)
...
a
c
b

""" 遍历key和value

>>> for k,v in d.items():
...     print(k,v)
...
a 1
b 2
c 3

如何判断一个对象是可迭代对象呢?方法是通过collections模块的Iterable类型判断:

>>> from collections import Iterable
>>> isinstance(abc, Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

最后一个小问题,如果要对list实现类似Java那样的下标循环怎么办?Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身:

>>> for i, value in enumerate([A, B, C]):
...     print(i, value)
...
0 A
1 B
2 C

2.3 列表生成式:

如果要创建一个列表,可以使用for循环,同时也可以有更简单的方法进行创建

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

""" for循环后可以增加if条件
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

""" 可以使用两层循环
>>> [m + n for m in ‘ABC‘ for n in ‘XYZ‘]
[‘AX‘, ‘AY‘, ‘AZ‘, ‘BX‘, ‘BY‘, ‘BZ‘, ‘CX‘, ‘CY‘, ‘CZ‘]
 

2.4  列表生成器

通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。

所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。

要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

""" 如果要访问生成器g的元素,可以使用for循环,也可以使用next(g)一个个访问
>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

生成器类似于函数,保存的是算法,所以可以在打印输出时通过算法进行计算。

定义一个计算斐波拉契数列的函数

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return done


>>> fib(6)
1
1
2
3
5
8
‘done‘
 

此时,只要把print(b)写成yield b就可以把函数fib改成一个generator了

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return done

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

2.5 迭代器

可用next函数不断访问下一个元素的对象是迭代器,如generator就是一个迭代器

凡是可作用于for循环的对象都是Iterable类型;

凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;

集合数据类型如listdictstr等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

三、 函数式编程

3.1 高阶函数

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

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

 filter()函数接收一个函数和一个序列,filter()函数将函数作用于序列上,根据作用的结果是True or False来决定保留还是舍弃。

注意到filter()函数返回的是一个Iterator,也就是一个惰性序列,所以要强迫filter()完成计算结果,需要用list()函数获得所有结果并返回list。

Python实现素数的筛选:

"""定义一个生成器,生成一个3开始的无限奇数序列  
def _odd_iter(): n = 1 while True: n = n + 2 yield n

定义一个筛选函数
def _not_divisible(n):
    return lambda x: x % n > 0
定义一个生成器,不断返回下一个元素
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

打印输出前1000的素数
for n in primes():
    if n < 1000:
        print(n)
    else:
        break
 

排序函数可以使用sorted()这个函数

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

可以自定义一个函数进行排序,传入函数到key
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

对字符串进行排序,默认是按照ASCII进行排序
>>> sorted([bob, about, Zoo, Credit])
[Credit, Zoo, about, bob]

忽略大小写:
>>> sorted([bob, about, Zoo, Credit], key=str.lower)
[about, bob, Credit, Zoo]

默认是从小到大,如果是从大到小
>>> sorted([bob, about, Zoo, Credit], key=str.lower, reverse=True)
[Zoo, Credit, bob, about]

3.2 函数作为返回值

Python中不仅函数可以作为参数传入,同时,函数也可以作为结果输出

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>


>>> f()
25

注意到返回的函数在其定义内部引用了局部变量args,所以,当一个函数返回了一个函数后,其内部的局部变量还被新函数引用,所以,闭包用起来简单,实现起来可不容易。

另一个需要注意的问题是,返回的函数并没有立刻执行,而是直到调用了f()才执行。我们来看一个例子

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

f1(),f2(),f3()的结果全为9,原因是f1(),f2(),f3()是一起执行的。

返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量。

 匿名函数lambda是对函数的一种简化

def f(x):
    return x * x
可以写成
>>> f = lambda x: x * x

函数模块中的作用域问题:

在一个模块中,我们可能会定义很多函数和变量,但有的函数和变量我们希望给别人使用,有的函数和变量我们希望仅仅在模块内部使用。在Python中,是通过_前缀来实现的。

正常的函数和变量名是公开的(public),可以被直接引用,比如:abcx123PI等;

类似__xxx__这样的变量是特殊变量,可以被直接引用,但是有特殊用途,比如上面的__author____name__就是特殊变量,hello模块定义的文档注释也可以用特殊变量__doc__访问,我们自己的变量一般不要用这种变量名;

类似_xxx__xxx这样的函数或变量就是非公开的(private),不应该被直接引用,比如_abc__abc等;

之所以我们说,private函数和变量“不应该”被直接引用,而不是“不能”被直接引用,是因为Python并没有一种方法可以完全限制访问private函数或变量,但是,从编程习惯上不应该引用private函数或变量。

 

Python的基本用法

标签:engine   数列   func   很多   pre   数据   指定   大小写   about   

原文地址:https://www.cnblogs.com/flightless/p/10164721.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!