您的位置:1010cc时时彩经典版 > 1010cc时时彩经典版 > 1010cc时时彩经典版python基础教程,学习笔记

1010cc时时彩经典版python基础教程,学习笔记

发布时间:2019-09-01 16:55编辑:1010cc时时彩经典版浏览(138)

    python基础教程(七),python基础教程

    本章介绍如何将语句组织成函数,那样,能够告知计算机怎么样工作。

     

    上面编辑一小段代码总括婓波那契数列(前五个数的和是第七个数)

    fibs = [0,1]   # 定义一个列表,初始内容是0,1
    for i in range(8):  #循环8次
      fibs.append(fibs[-2] fibs[-1])  #append在末尾追加一个数,这个是它前面两个数的和
    
    #输入
    >>> fibs
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    

    因为赋完值fibs已经有四个数了(0,1),所以循环8次之后,列表有十二个数,三个数相加等于第四个数。

    是或不是以为应该由大家输入来支配打字与印刷多少个数?只用把程序小变一下就行了。

    fibs = [0,1]
    num = input('How many fibonacci numbers do you want?')
    for i in range(num-2):
        fibs.append(fibs[-2] fibs[-1])
    print fibs
    #输入
    >>> 
    How many fibonacci numbers do you want?12
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    

     

     

    抽象

      抽象有可以节约点不清行事,它使得计算机程序能够令人读懂的机要。Computer喜欢管理标准和求实的下令,但人不一样,我们更爱好丢进来贰个东西,Computer就能够反映给大家想要的结果,并不是由大家一步一步的告知它如何是好。由此,上面包车型客车代码抽象一点,应该是如此的:

     

    num = input('How many fibonacci numbers do you want?')
    print fibs
    

     

    那电脑怎么明白要如何做?大家能够把拍卖的进度封装成函数,在大家每一遍用到时只用调用这么些函数就能够了。

     

     

    开创函数

      函数是足以调用的,它实践某种行为同不平时候再次来到一个值。内建的callable函数可以用来推断函数是或不是可调用:

    >>> import math
    >>> x = 1
    >>> y = math.sqrt
    >>> callable(x)  
    False
    >>> callable(y)
    True
    

    备注:callable 在python3.0中不再可用。

     

    那怎么样定义三个函数呢?使用def语句即可:

    >>> def hello(name):
        return 'hello.' name '!'
    #我们定义了一个hello函数,它会将输入的内容前面加“hello.”后面加“!”,并返回给用
    #户
    >>> print hello('world')
    hello.world!
    >>> print hello('zhangsan')
    hello.zhangsan!
    

     

    科学啊!再回过头去思维怎么把重临婓波那契数列定义成贰个函数。如下:

    #定义fibs函数,用于婓波那契数列
    >>> def fibs(num):
        result = [0,1]
        for i in range(num-2):
            result.append(result[-2] result[-1])
        return result
    
    #直接调用fibs函数
    >>> fibs(10)
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    >>> fibs(15)
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
    

     

     

    一部分变量

      当函数定义生命变量的时候,函数内所生命的变理只在其函数内有效,与函数外全数同等名称的任何变量未有其他涉及

    #局部变量
    def func(x):
        print 'x is',x
        x =2    # x=2只在func函数内其作用
        print 'Changed local x to',x
    
    x = 50
    func(x)   #func函数并没有返回数据过来。
    print 'x is still',x
    
    #输出
    >>> 
    x is 50
    Changed local x to 2
    x is still 50
    

     

     

    global 语句

      倘若想把三个变量声名称叫 全局的,则足以接纳global语句。

    def func():
        global x
    
        print 'x is',x
        x = 2
        print 'Changed local x to',x
    
    x =50
    func()
    print 'Value of x is ',x
    #输出
    x is 50
    Changed local x to 2
    Value of x is  2
    

    global 语句被用来生命x 是全局,由此在执行完func函数后,x的值已经发生了更换,並且职能于全部程序,因而最后的输入结果为2

     

     

    暗中认可参数

      对于部分参数,大家愿意它的片段参数是可选的,若是顾客不想要为那几个参数提供值的话,这个参数就使用私下认可值。

    def say(message,times=1):
        print message*times
    
    say('Hello')
    say('World',5)
    #输出
    >>> 
    Hello
    WorldWorldWorldWorldWorld
    

     

    概念的say函数的第八个参数正是可选的,默感到times=1;也正是将多少个参数相乘输出。

     

    瞩目:独有在形参表末尾的那多少个参数能够有暗中认可参数,如def func(a=5,b) 是低效的。

     

     

     

    重大参数

      要是某些函数有好些个参数,而作者辈只想钦点个中的一有的,那么能够选拔名字(关键字)并不是岗位来给函数内定实参。----那被称作 关键参数

    def func(a,b=5,c=10):
        print 'a is',a, 'and b is',b,'and c is',c
    
    func(3,7)
    func(24,c=32)
    func(c=23,a=14)
    
    #输出
    >>> 
    a is 3 and b is 7 and c is 10
    a is 24 and b is 5 and c is 32
    a is 14 and b is 5 and c is 23
    

    与此相类似做,笔者就不要顾虑参数的一一,使用函数变得更为简约。尽管另外函数都有暗许值,我们得以只给和煦想要的参数赋值。

     

     

    递归:

      有用的递归函数... 等等,什么是对事情没有什么帮助的递归?先来看八个函数的定义:

    def recursion()
        return recursion()
    

     

    驾驭,它怎么也干不了,程序的举行不断申请内部存储器,直接内部存款和储蓄器耗尽,程序崩溃。

    跟着,有用的递归函数包括以下多少个部分:

    • 当函数直接回到值时有基本实例(最小恐怕性难题)
    • 递归实例,包蕴三个要么五个难题不超过一半的递归调用。

     

    上边通过递归函数来总结叁个n的阶,n*(n-1)*(n-2)*....*1

    def f(n):
        if n == 1:
           return 1
        else:
            return n*f(n-1)
    

    本章介绍如何将语句协会成函数,那样,可以告诉Computer如何行事。 上面编辑一小段代码计算婓波那...

    本章介绍如何将语句组织成函数,那样,能够告知Computer怎么办事。

    本章介绍怎么着将语句组织成函数,那样,能够告诉Computer怎么样工作。

    ((Python基础教程))学习笔记 | 第06章 | 抽象

    第06章 抽象


    不拘小节即美德

    借使要总括斐波这契数列(任何三个数是前两数之和的数字种类)

    >>> fibs=[0,1]
    >>> for i in range(8):
     fibs.append(fibs[-2] fibs[-1]) #fibs[-2] fibs[-1]后两位数,append往后添加
    
    #运行后,包含10个斐波那契数列的10个数字是 
    >>> fibs
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    

    假若允许客商输入,进而退换总计的值,要如何是好啊?

    >>> fibs = [0,1]
    >>> num = input('Enter number here:')
    Enter number here:10
    >>> for i in range(num-2):
     fibs.append(fibs[-2] fibs[-1]) 
    >>> fibs
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    

    假如该程序要时常利用,就相应再抽象一些,如上边:fibs函数就能够成立

    num = input('How many numbers do you want? ') 
    print fibs(num)
    

    次第应该是十分抽象的,就好像"下载页面、计算频率,打字与印刷单词频率"同样易懂.
    事实上大家后天就会把这段描述翻译成Python

    page  = download_page()
    freqs = compute_frequencies(page)
    for word,freq in freqs:
        print word, freq
    

    成立函数

    函数能够调用,它施行某种行为并重返值。

    诚如的话,内建的callable函数能够判明函数是还是不是可调用:

    >>> import math
    >>> x = 1
    >>> y = math.sqrt
    >>> callable(x)
    False
    >>> callable(y)
    True
    

    Note:callbale()在Python3.0之中会用hasattr(func.__call__)来代替

    始建函数是团协会程序的基本点,那么哪些定义函数呢? 上边正是个最简单易行的函数

    >>> def hello(name):
     return 'Hello,'   name   '!'
    >>> hello('Jerry')
    'Hello,Jerry!'
    

    像上面的斐波这契要写成函数的话,就有益多了,能够流传任意数字

    >>> def fibs(num):
     result = [0,1]
     for i in range(num-2):
      result.append(result[-2] result[-1])
     return result
    
    >>> fibs(10)
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    

    Note:

    1. return 语句极其关键,是用来从函数中重回值的,若无的话,重返None

      def sum(x,y): result = x y print sum(1,2) None

    2. return 约等于程序中的break.譬喻说上边的:

      def test(): print 'This is 1 line.' return print 'This is 2 line' test() #输出结果

      This is 1 line.

    参数(parameter)、作用域(scope)

     

     

    有鉴于此: 第3个打字与印刷没有显得

    笔录函数

    就算想要函数被别人知道的话,能够用#讲明,另外一个向来抬高字符串

    譬喻一贯放def函数前面包车型地铁话,会作为函数的一部分,称为文书档案字符串

    >>> def square(x):
     'Calculates the square of the number x'
     return x*x
    

    能够用内置的模块__doc__来查看文书档案

    >>> square.__doc__
    'Calculates the square of the number x'
    

    最重大,也最常用的是help(),dir()来查阅函数相关新闻

    >>> dir(square)
    ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
    
    >>> help(square)
    Help on function square in module __main__:
    
    square(x)
        Calculates the square of the number x
    

    参数法力

    形参:def 前边的变量便是样式参数,简称形参

    实参:调用函数提供的值正是实在参数,简称实参,或叫参数,或叫值.

    变量定义在函数体内,为局地变量,定义在函数体内,为全局变量

    >>> def try_to_change(n):
     n = 'Mr, Gumby'
    >>> name = 'Mrs, Smith'
    >>> try_to_change(name) #将name作为实参传给try_to_change函数
    >>> name                #全局变量值不变
    'Mrs, Smith'
    

    字符串及元祖是不可变的,由此不能够被涂改,假若是可变的数据结构如列表做为参数呢?

    >>> def change(n):
     n[0] = 'Mr. Gumby'
    >>> name = ['Mrs. Smith','Mr. Jing']
    >>> change(name)
    >>> name                #值已经发生了变化
    ['Mr. Gumby', 'Mr. Jing']
    

    这是跟上面包车型地铁区分所在,那么些中的列表产生了更动:

    >>> name = ['Mrs. Smith','Mr. Jing']
    >>> n    = name         #模拟传参数
    >>> n[0] = 'Mr. Gumby'  #改变列表
    >>> name
    ['Mr. Gumby', 'Mr. Jing']
    

    假如不想被改动,就得拷贝其别本 n = name[:]

    >>> storage={}
    >>> storage['first']={}
    >>> storage['middle']={}
    >>> storage['last']={}
    >>> storage
    {'middle': {}, 'last': {}, 'first': {}}
    

    #storage这种字典的储存方式,有3个键'first','middle','last'.
    各种键又对应了三个字典,在子字典中,能够选择名字作为键,插入联系人列表为值.

    >>> storage['first']['Magus']=[me]
    >>> storage['middle']['Lei']=[me]
    >>> storage['last']['Hetland']=[me]
    >>> storage
    {
    'middle':   {'Lei': ['Magnus Lei Hetland']}, 
    'last': {'Hetland': ['Magnus Lei Hetland']}, 
    'first': {'Magus':  ['Magnus Lei Hetland']}
    }
    

    每种键上边都存储二个以姓名的列表。本例中,列表只有自个儿
    假如要收获全数注册中间名字为Lei的,能够如此:
    >>> storage['middle']['Lei']
    ['Magnus Lei Hetland']
    进度有个别单调,若是要推而广之这么些数据库,且不知道当中储存了哪些。
    比如:即便笔者小姨子的名字

    >>> my_sister='Anne Lei Hetland'
    >>> storage['first'].setdefault('Anne',[]).append(my_sister)
    >>> storage['middle'].setdefault('Lei',[]).append(my_sister)
    >>> storage['last'].setdefault('Hetland',[]).append(my_sister)
    >>> storage['first']['Anne']
    ['Anne Lei Hetland']
    >>> storage['middle']['Lei']
    ['Magnus Lei Hetland', 'Anne Lei Hetland']
    

    假设要写大程序来更新的话,更会议及展览示臃肿不堪.
    抽象的中央便是遮掩更新时的麻烦细节,这几个进度能够用函数来兑现。
    上边包车型大巴例证就是起始化数据结构的事例:

    >>> def init(data):
    ...     data['first']={}
    ...     data['middle'] = {}
    ...     data['last'] = {}
    ...
    >>> init(storage)
    >>> storage
    {'middle': {}, 'last': {}, 'first': {}}
    

    能够看来,函数包办开头化的办事,让程序更易读.
    假如果不可变值,比如说数字,又该怎么做呢

    >>> def inc(x): return x 1
    ...
    >>> i = 10
    >>> i = inc(i)
    >>> i
    11
    

    假虚构改造参数的话,有个小本事,放在列表中.

    >>> def inc(x):
    ...     x[0] = x[0]   1
    ...
    >>> foo = [10]
    >>> inc(foo)
    >>> foo
    [11]
    

    懒惰即美德

    算算斐波那契数列

    fibs = [0,1]
    for i in range(8):
        fibs.append(fibs[-2]   fibs[-1])
    

    一旦要求编写制定一大段复杂的代码,程序员会让协调的主次更抽象一部分。让计算斐波那契数列变得肤浅——只供给告诉Computer去做就好了,不用非常表明应该咋做。名称叫fibs的函数被创设,然后在急需总计斐波那契数列的地点调用就可以。

    上边编辑一小段代码总计婓波这契数列(前多个数的和是第3个数)

    下边编辑一小段代码总括婓波那契数列(前八个数的和是第多个数)

    如此那般代码只会回去新值,相比清洁。

    首要字参数和默许值
    岗位参数的定义,思量上边三个函数

    >>> def hello_1(greeting,name): 
            print "%s,%s!"%(greeting,name)
    ...
    >>> def hello_2(name,greeting): 
            print "%s,%s!"%(name,greeting)
    ...
    

    三个代码要落到实处的效能完全等同,只是参数名字反过来了。

    >>> hello_1('hello','world')
    hello,world!
    >>> hello_2('hello','world')
    hello,world!
    

    一部分时候参数顺序是很难记的,为了让工作差不离些,可以提供参数的名字.

    >>> hello_1(greeting='Hi', name='Jerry')
    Hi,Jerry!
    

    参数名和值要对应

    >>> hello_2(name='Jerry',greeting='Hi')
    Jerry,Hi!
    

    那类参数名提供的参数叫关键字参数。重要意义是刚烈每一个参数的功力,
    制止了下边那样诡异的函数调用。

    store('Mr. Smith',10,20,13,5)
    store(patient='Mr. Smith',hour=10,minutes=20,day=13,month=5)
    

    尽管多打了几个字,忧虑中有数,弄乱了参数的一一,对程序不会有别的影响。
    第一字参数最厉害的地点是能够跟函数提供默许值。

    >>> def hello_3(greeting='Hello',name='World'):
    ...     print '%s,%s!' % (greeting,name)
    ...
    >>> hello_3()           #如果不加参数的话,就用默认值
    Hello,World!
    >>> hello_3('greeting') #带参数的话,按参数顺序赋值
    greeting,World!
    >>> hello_3('greeting','universe') #按提供的顺序
    greeting,universe!
    # 如果只想提供name,而让greeting默认
    >>> hello_3(name='Sherry')
    Hello,Sherry!
    

    职位参数和要害字参数可以一并利用,将地点参数放前边.
    Note:
    唯有完全知道程序的效用和参数的意义,不然应防止将地方参数和重要字参数混合使用。一般的话,唯有强制需求的参数个数比可修改的具有默许值的参数个数少的时候,才使用方面提到的参数书写方式。

    >>> def hello_4(name,greeting='Hello',punctuation='!'):
    ...     print '%s, %s%s' % (greeting,name,punctuation)
    ...
    >>> hello_4('Jerry')
    Hello, Jerry!
    >>> hello_4('Jerry','Howdy')
    Howdy, Jerry!
    >>> hello_4('Jerry','Howdy','...')
    Howdy, Jerry...
    >>> hello_4('Jerry',punctuation='.')
    Hello, Jerry.
    >>> hello_4('Jerry',greeting='Top of the morning to ya')
    Top of the morning to ya, Jerry!
    >>> hello_4()
    Traceback (most recent call last):
      File "", line 1, in ?
    TypeError: hello_4() takes at least 1 argument (0 given)
    

    #即使最终三个name也用暗许值的话,就不会爆发上面的卓殊.


    募集参数

    部分时候提供多参数是很有须要的,那么什么样做啊? 很简短

    >>> def print_parms(*parms):
    ...     print parms
    ...
    

    #1个参数的话,会作为元祖打字与印刷出来,里面还或许有逗号

    >>> print_parms('Hello')
    ('Hello',)
    >>> print_parms(1,2,3)
    (1, 2, 3)
    

    #parms前面的*号,将具有的参数放到二个元祖里面,然后使用。
    那正是说能或不能够一齐普通参数和采访的参数呢,当然能够。

    >>> def print_parms_2(title,*parms):
    ...     print title
    ...     print parms
    ...
    >>> print_parms_2('Parms:',1,2,3)
    Parms:
    (1, 2, 3)
    

    #在这里,*造成了搜聚别的的地点参数

    >>> print_parms_2('Nothing:')
    Nothing:
    ()
    

    的确如此,特别有用,那么能否管理重要字参数呢?

    >>> print_parms_2('hmm...',someting=42)
    Traceback (most recent call last):
      File "", line 1, in ?
    TypeError: print_parms_2() got an unexpected keyword argument 'someting'
    

    能够见到,应该十二分,那么要怎么落到实处啊? 将在选拔"**"

    >>> def print_parms_3(**parms):
    ...     print parms
    ...
    >>> print_parms_3(x=1,y=2,z=3)
    {'y': 2, 'x': 1, 'z': 3}
    

    #归来的是字典并不是元祖
    如果将*,**身处一块儿利用呢?

    >>> def print_parms_4(x,y,z=3,*pospar,**keypar):
    ...     print x,y,z
    ...     print pospar
    ...     print keypar
    ...
    >>> print_parms_4(1,2,3,5,6,7,foo=1,bar=2)
    1 2 3
    (5, 6, 7)
    {'foo': 1, 'bar': 2}
    

    反转进度

    那正是说要什么运用*,**啊? 看上面一个轻易的例证:

    >>> def add(x,y): return x y
    ...
    >>> parms=(1,2)
    #下面这样会报错
    >>> add(parms)
    Traceback (most recent call last):
      File "", line 1, in ?
    TypeError: add() takes exactly 2 arguments (1 given)
    #必需这样,前面加个*号
    >>> add(*parms)
    3
    

    #字典方面包车型客车调用

    >>> def hello_3(greeting='Hello',name='World'):
    ...     print '%s,%s!' % (greeting,name)
    ...
    >>> params = {'name':'Sir Robin','greeting':'Well met'}
    >>> hello_3(**params)
    Well met,Sir Robin!
    

    #再看上边包车型地铁,看加双*和没加**

    >>> def with_star(**kwd):
    ...     print kwd['name'],'is',kwd['age'],'years old!'
    ...
    >>> def without_star(kwd):
    ...     print kwd['name'],'is',kwd['age'],'years old!'
    ...
    >>> args = {'name':'Mr. Gumby','age':35}
    >>> with_star(**args)
    Mr. Gumby is 35 years old!
    >>> without_star(args)
    Mr. Gumby is 35 years old!
    

    #能够观望两岸意况一样,所以*只在概念函数(允许不定数目标参数)

    和调用(分割字典或连串)才有用.

    Note:

    运用拼接(Splicing)操作符传递参数很有用,因为不用忧郁参数的个数

    >>> def foo(x,y,z,m=0,n=0):
    ...     print x,y,z,m,n
    ...
    >>> def call_foo(*arg,**kwds):
    ...     print 'Calling foo'
    ...     foo(*arg,**kwds)
    

    练习使用参数:

    def story(**kwds):
        return 'Once upon a time. There was a ' 
    '%(job)s called %(name)s.' % kwds
    
    
    def power(x,y,*others):
        if others:
            print 'Received redundant parameters:', others
        return pow(x,y)
    
    
    def interval(start,stop=None,step=1):
        'Imitates range() for step>0'
        if stop is None:
            start,stop = 0,start
        result = []
        i = start
        while i < stop:
            result.append(i)
            i  =step
        return result
    
    
    print story(job='king',name='Gumby')
    print story(name='Jerry',job='king')
    params = {'job':'language','name':'Python'}
    print story(**params)
    del params['job']
    print story(job='stroke of genius',**params)
    print power(2,3)
    print power(3,2)
    print power(y=3,x=2)
    params =(5,)*2
    print power(*params)
    print power(2,3,'Hello,World!')
    print interval(10)
    print interval(1,5)
    print interval(3,12,4)
    print power(*interval(3,7))
    

    输出结果:

    D:>python Python.py

    Once upon a time. There was a king called Gumby.
    Once upon a time. There was a king called Jerry.
    Once upon a time. There was a language called Python.
    Once upon a time. There was a stroke of genius called Python.
    8
    9
    8
    3125
    Received redundant parameters: ('Hello,World!',)
    8
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    [1, 2, 3, 4]
    [3, 7, 11]
    Received redundant parameters: (5, 6)
    81
    

    作用域

    >>> x = 1
    >>> scope = vars()
    >>> scope['x']
    1
    >>> scope['x']  =1
    >>> x
    2
    

    #只在函数体内有效

    >>> def foo(): x = 42
    ...
    >>> x = 1
    >>> foo()
    >>> x
    1
    >>> def output(x): print x
    ...
    >>> x = 1
    >>> y = 2
    >>> output(y)
    2
    

    #函数体内使用外界变量

    >>> def combine(param): print param external
    ...
    >>> external = 'berry'
    >>> combine('Shrub')
    Shrubberry
    

    WA中华VN:像这样引用变量是过多谬误的原因:

    假诺有个别变量跟全局变量重名该咋做吗?

    >>> def comb(param):
    ...     print param   globals()['param']
    ...
    >>> param='Sherry'
    >>> comb('Jerry->')
    Jerry->Sherry
    

    那么哪些更换全局变量呢?

    >>> x = 1
    >>> def change_global():
    ...     global x
    ...     x  =1
    ...
    >>> x
    1
    >>> change_global()
    >>> x
    2
    

    嵌套作用域: 三个函数嵌套在另贰个函数里面

    >>> def foo():
    ...     def bar():
    ...         print 'Hello,World!'
    ...     bar()
    ...
    >>> foo()
    Hello,World!
    
    >>> def multiplier(factor):
    ...     def multiplyByFactor(number):
    ...         return number*factor
    ...     return multiplyByFactor
    ...
    >>> double = multiplier(2)
    >>> double(5)
    10
    >>> triple = multiplier(3)
    >>> triple(3)
    9
    >>> multiplier(5)(4)
    20
    

    #再来看三个

    >>> def A(x):
            def B(y):
               def C(z):
                   return x y z
               return C
            return B
    >>> A(1)(2)(3)
    6
    

    递归:本人调用自个儿,下边是个最简便易行的特别递归的例证:

    >>>def A():
     return A()
    >>>A() #无限循环,等消耗掉所有内存资源后,报最大递归深度的错误,类似于while True
      File "", line 2, in A
        return A()
    RuntimeError: maximum recursion depth exceeded
    

    #break,return合併使用,幸免Infiniti循环

    #历次函数调用时,生成新的命名空间,意味着当函数调用本人,会有五个函数同临时候运行。

    七个非凡:阶乘及幂

    n*(n-1)*(n-2)...2*1,能够用普通函数来兑现

    >>> def factorial(n):
     result = n
     for i in range(1,n):
      result *=i
     return result
    
    >>> factorial(3)
    6
    

    也足以用递归完结:

    >>> def factorial(n):
     if n == 1:   #1的阶乘为1
         return 1
     else:        #大于1的阶乘是n*(n-1)!
         return n*factorial(n-1)
    

    幂怎么着兑现啊?

    >>> def power(x,n):  #一般的实现
     result = 1
     for i in range(n):
         result *=x
     return result
    >>> power(2,3)
    8
    
    >>> def power(x,n):  #阶乘实现
     if n == 0:
      return 1
     else:
      return x*power(x,n-1) 
    >>> power(2,3)
    8
    

    本章新函数

    map(func,seq[,seq,]) 对队列中的各样成分运用函数

    filter(func,seq) 重回其函数为实在成分的列表

    reduce(func,seq[,initial]) 等同于func(func(func(seq[0],seq[1],seq[2],...)))

    sum(seq) 重临seq中有所因素的和

    apply(func[,args[,kwargs]]) 调用函数,能够提供参数



    | 第06章 | 抽象 第06章 抽象 ------ 懒惰即美德 假诺要总结斐波那契数列(任何多个数是前两数之和的数字种类) >>...

    泛泛和组织

    架空能够节约不知凡几办事,实际上它的职能还要更大,它是驱动Computer程序能够令人读懂的主要性。(那也是最大旨的必要,不管是读依然写程序)。

     

     

    创办函数

    函数是能够调用的(或然富含参数,也正是身处圆括号中的值),它试行某种行为同期再次来到三个值。一般的话,内建的callable函数能够用来判别函数是不是可调用。

    >>> import math 
    >>> x = 1
    >>> y = math.sqrt
    >>> Callable(x)
    False
    >>> Callable(y)
    True
    

    callable在Python3中不再可用。
    选取def(或“函数定义”)语句创制函数。

    def hello(name):
        return 'Hello, '   name   '!'
    

    return语句是用来从函数中再次回到值的

    fibs = [0,1]   # 定义一个列表,初始内容是0,1
    for i in range(8):  #循环8次
      fibs.append(fibs[-2] fibs[-1])  #append在末尾追加一个数,这个是它前面两个数的和
    
    #输入
    >>> fibs
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    
    fibs = [0,1]   # 定义一个列表,初始内容是0,1
    for i in range(8):  #循环8次
      fibs.append(fibs[-2] fibs[-1])  #append在末尾追加一个数,这个是它前面两个数的和
    
    #输入
    >>> fibs
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    

    文书档案化函数

    假设要给函数写文书档案,让任何应用该函数的人能够领略的话,能够出席注释(以#发端)。别的一个方法就是直接写上字符串。那类字符串在另各地方恐怕会要命有用,举例在def语句前边(以及在模块大概类的开头)。倘诺在函数的开端写下字符串,它就能作为函数的一有些开展仓库储存,这名字为文档字符串
    访问文档字符串

    >>> function.__doc__
    'function document'
    

    doc是函数属性。属性名中的双下划线表示它是个突出质量。

    内建的help函数是老大管用的。在交互式解释器中央银行使它,能够获取官于函数,满含它的文书档案字符串的音信。

     

     

    毫不真正函数的函数

    数学中的函数总在企图其参数后赶回点什么,Python中的函数在未有return也许return前面不跟其它事物时候,再次回到None。

    因为赋完值fibs已经有三个数了(0,1),所以循环8次之后,列表有十三个数,七个数相加等于第三个数。

    因为赋完值fibs已经有四个数了(0,1),所以循环8次之后,列表有拾个数,多个数相加等于第二个数。

    参数法力

    是还是不是以为应该由大家输入来支配打字与印刷多少个数?只用把程序小变一下就行了。

    是或不是以为应该由我们输入来决定打字与印刷多少个数?只用把程序小变一下就行了。

    值从何地来

    编辑函数只是给程序供给的片段(也恐怕是另外程序)提供服务,能确认保证函数在被提供给可承受参数的时候正规干活就行,参数错误的话肯定会产生停业。
    写在def语句中等高校函授数名背后的变量平日称得上函数的形参,而调用函数的时候提供的值是实参,或许叫做参数

     

     

    我能更动参数吗

    参数只是变量而已,所以她们的一言一动实际上和您预想的等同。在函数内为参数赋予新的值不会变动外界任何变量的值。
    当变量n改动时候,变量name不便。同样,在函数内把参数重绑定(赋值)时候,函数外的变量不会碰到震慑。
    参数存款和储蓄在局地变量内
    字符串(以及数字和元组)是不可变的,参数赋值的时候只好用新的值覆盖。但是可变数据结构(列表)做参数时候,参数会产生变化。
    当四个变量同期引用二个列表的时候,它们确实是还要引述二个列表。假如要幸免被同偶然间修改,可以赋值四个列表的别本。当在连串中做切块的时候,重回的切块总是三个别本。因而,假使您复制了整个列表的切块,将会取得二个别本。
    函数的片段名称(饱含参数在内)——并不和外面包车型地铁函数名称争持

    fibs = [0,1]
    num = input('How many fibonacci numbers do you want?')
    for i in range(num-2):
        fibs.append(fibs[-2] fibs[-1])
    print fibs
    #输入
    >>> 
    How many fibonacci numbers do you want?12
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    
    fibs = [0,1]
    num = input('How many fibonacci numbers do you want?')
    for i in range(num-2):
        fibs.append(fibs[-2] fibs[-1])
    print fibs
    #输入
    >>> 
    How many fibonacci numbers do you want?12
    #输出
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    

    何以要修改参数

    利用函数改变数据结构(举个例子列表或字典),是一种将顺序抽象化的好法子。
    虚幻的中激情想就是潜伏更新时麻烦的内幕,这么些历程能够用函数完毕。

    def lookup(data, label, name):
        return data[label].get(name)
    
    def store(data, full_name):
        names = full_name.split()
        if len(names) == 2: names.insert(1, '')
        labels = 'first', 'middle', 'last'
        for label, name in zip(labels, names):
            people = lookup(data, label, name)
            if people:
                people.append(full_name)
            else:
                data[label][name] = [full_name]
    

     

     

    如果本人的参数不可变呢

    Python中等高校函授数只好修改参数对象自己。

     

     

    珍视字参数和默许值

    近来结束大家所使用的参数都称为位置参数
    另一类使用参数名提供的参数叫做关键字参数。它的首要效能在于可以分明每一种参数的效劳。
    驷比不上舌字参数还是能够在函数中给参数提供私下认可值
    岗位参数跟关键字参数能够联手利用。把岗位参数放到前边就能够了。

     

     

    征集参数

    在参数前增加二个星号()将全部值放置在同三个元组中——将那个值收罗起来,然后采纳。(搜聚别的的地点参数)。
    假定不提供任何参数,
    所代表的正是一个空元祖。
    在参数前增加另个星号(*)将有着入眼字参数放在同七个字典中——将这一个值连同关键字搜聚起来,然后利用。(搜集其余关键字参数)。

    抽象

    抽象

    参数搜聚的逆进度

    什么将参数搜聚为元组和字典已经实现,借使运用和,也能够拓宽相反的操作。
    分配某些元组在函数中利用,能够在调用时候使用

    分红有个别字典在函数中央银行使,能够在调用时候使用**。
    **星号只在概念函数(允许利用不定数目标参数)可能调用(分割字典也许系列)时才有用。

      抽象有能够节省数不清办事,它使得Computer程序能够令人读懂的主要性。Computer喜欢管理标准和切实的指令,但人不等,大家更爱好丢进来贰个事物,Computer就能够申报给我们想要的结果,并非由大家一步一步的告诉它怎么办。由此,下边包车型客车代码抽象一点,应该是那样的:

      抽象有能够省去数不胜数行事,它使得计算机程序可以令人读懂的重点。Computer喜欢管理典型和具体的指令,但人不等,大家更欣赏丢进来多个事物,计算机就能够申报给我们想要的结果,并非由我们一步一步的报告它怎么办。由此,上边的代码抽象一点,应该是如此的:

    练习使用参数

    def story(**kwds):
        return 'Once upon a time, there was a ' 
               '%(job)s called %(name)s.' % kwds
    
    def power(x, y, *others):
        if others:
            print 'Received redundant parameters:', others
        return pow(x, y)
    
    def interval(start, stop=None, step=1):
        'Imitates range() for step > 0'
        if stop is None:            # If the stop is not supplied...
            start, stop = 0, start   # shuffle the parameters
        result = []
        i = start                   # We start counting at the start index
        while i < stop:             # Until the index reaches the stop index...
            result.append(i)         # ...append the index to out result...
            i  = step                # ...increment the index with the step (> 0) 
        return result
    

     

     

    作用域

    这类不可知字典叫做命名空间或者作用域。除了全局意义域外,每种函数调用都会创制一个新的功能域。
    参数的行事原理类似于部分变量,所以用全局变量的名字作为参数名并不曾问题。
    运用globals函数获取全局变量值。
    重绑定全体变量——若是在函数内部将值赋予一个变量,它会自动成为部分变量——除非告知Python将其宣称为全局变量。那么怎么技巧高所Python那是三个全局变量呢?(使用global语句表明)

    >>> x = 1
    >>> def change_global():
                  global x
                  x = x  1
    >>> change_global()
    >>> x
    2
    

    函数能嵌套函数,但用的十分少,稍作掌握就可以

    num = input('How many fibonacci numbers do you want?')
    print fibs
    
    num = input('How many fibonacci numbers do you want?')
    print fibs
    

    递归

    函数调用自身
    递归——引用(或然调用)自个儿的意味。
    有效的递归包涵以下多少个部分:

    • 当函数间接回到值时有大旨实例(最小或然性难题)
    • 递归实例,满含三个照旧七个难题非常小部分的递归调用
      当函数调用‘自个儿’时,实际上运行的是八个不相同的函数(只怕说是同贰个函数具备多个不等的命名空间)

    本文由1010cc时时彩经典版发布于1010cc时时彩经典版,转载请注明出处:1010cc时时彩经典版python基础教程,学习笔记

    关键词: