zoukankan      html  css  js  c++  java
  • python语言基础3

    一:python函数

        是组织好的,可重复使用的,用来实现单一,或相关联功能的代码块。以前使用过的一些Python提供的内建函数,如print()、max(4,18)、min(100,50)。当然我们自己创建的函数,叫做自定义函数。

        ①、代码要遵循的原则:高内聚,低耦合

            模块内部之间的联系,应该非常紧密的

            模块与模块之间的联系,应该尽量少

        ②、优点:

            函数能提高应用的模块性,和代码的重复利用率。  

        ③、定义函数的场合:

            凡是我们需要描述某个功能的时候,都将它定义为函数

        ④、函数定义规则:

            函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。  函数内容以冒号起始,并且缩进。

            return [表达式] 结束函数,选择性地返回一个值给调用方。不写return,相当于返回 None。

        ⑤、定义函数格式:

            def 函数名(参数列表):

                函数体

            函数调用:

                函数不调用就不会执行,调用函数通过函数名完成

        ⑥、建议:

            函数的第一行语句,可以选择性地使用文档字符串,用于存放函数说明,函数定义时,一个函数的功能要单一。

    1、简单定义函数

    #定义函数
    def hello() :
        print("Hello Python ...!")
    #调用函数 函数不调用,不执行
    hello()
    

     运行结果:

    Hello Python ...!
    

     2、简单实现业务

    #定义函数,实现打印5行5列的*号
    def print_tr() :
        for i in range(5):
            for j in range(5):
                print("* ",end="")
            print()
    #调用
    print_tr()
    

    运行结果:

    * * * * * 
    * * * * * 
    * * * * * 
    * * * * * 
    * * * * *
    

     3、在函数中,定义参数

        函数是否需要未知数参与,需要可以用参数定义出来。

    #计算两个数之和
    #2个数是未知数,未知数相当于python的参数
    def add(a,b):
        #print('{0}+{1}={2}'.format(a,b,a+b))
        print('%s+%s=%s'%(a,b,a+b))
    #调用
    add(7,8)
    

    运行结果: 

    7+8=15
    

    4、在函数中,指定返回值

        return [表达式] 结束函数,选择性地返回一个值给调用方,不带表达式的return相当于返回None。

    #调addCopy01()函数,返回两个数之和的值
    def addCopy01(a,b):
        return a+b
    #调用
    result = addCopy01(100,200)
    print(result)
    print('-------------------------------')
    #return 直接结束函数,'函数结束'提示,没有输出。
    def test_method():
        for i in range(10):
            print(i)
            return  # return结束函数     break结束循环
        print('函数结束')
    #调用
    test_method()
    

    运行结果:

    300
    -------------------------------
    0
    

    5、参数类型

    ①、必需参数

        必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用函数,你必须传入参数,不然会出现语法错误:

    #必须传入,2个参数
    def addCopy01(a,b):
        return a+b
    #调用
    addCopy01(100,200)
    

     ②、关键字参数

        关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致:

    #关键字参数:
    def printinfo(name, age):
        print("名字: ", name)
        print("年龄: ", age)
    #调用    
    printinfo(age=50, name="张三")
    

     运行结果:

    名字:  张三
    年龄:  50
    

    ③、默认参数

        调用函数时,如果没有传递参数,则会使用默认参数。

    #默认参数:
    def printinfo(name, age=35):
        print("名字: ", name)
        print("年龄: ", age)
    #调用   
    printinfo(name="张三",age=50)
    print("------------------------")
    printinfo(name="张三")
    

    运行结果:  

    名字:  张三
    年龄:  50
    ------------------------
    名字:  张三
    年龄:  35
    

    ④、不定长参数

        有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。

        加了星号(*)的参数名,会存放所有未命名的变量参数。如果在函数调用时,没有指定参数,它就是一个空元组。

    #查看不定长参数,传入的值
    def add2(a,*b):
        print(a,end="")
        print(b)
    #调用
    add2(1)  #1()
    add2(1,2) #1(2,)
    add2(1,2,3) #1(2, 3)
    print("------------------------")
    #求和 [不限制几个参数]
    def add3(a,*b):
        sum = 0
        for i in b:
            sum += i
        return a+sum
    #调用
    print(add3(1))
    print(add3(1,2))
    print(add3(1,2,3))
    

    运行结果:

    1()
    1(2,)
    1(2, 3)
    ------------------------
    1
    3
    6
    

    python 使用 lambda 来创建匿名函数。所谓匿名,意即不再使用 def 语句来定义一个函数。

        ①、lambda 函数的语法只包含一个语句

        ②、命名空间:python中存放变量名的空间或字典!

    注意:

        ①、lambda 只是一个表达式,函数体比 def 简单很多。

        ②、 lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

        ③、 lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。

    sum = lambda a,b:a+b
    print(sum(10,20))
    

    运行结果:

    30
    

    7、参数传递问题

     ①、对象是真实存在的数据,类型属于对象,变量是没有类型的。

    number = [1,2,3,4,5,6]
    info = "Hello"
    

    解释:[1,2,3,4,5,6] 是 List 类型,“Hello” 是 String 类型,而变量number与info是没有类型,它仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象

    ②、可更改与不可更改对象

        python 中一切都是对象,传递参数分为传不可变对象和传可变对象

        python 中,string字符串,tuple元组,和numbers整数,是不可更改的对象,而list列表,dict字典等则是可以修改的对象。

         使用函数的时候,如果传入参数是不可变的,那么参数里面对数据做的任何操作,都不会对函数外面的数据带来影响。不可变类型:如fun(a),传递的只是a 的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的新对象,不会影响 a 本身。

    # 不可变类型参数传递
    num = 1
    def change(num):
        num = 3 #没有对num操作,重新定义了一个num
        print(num)
    change(num)
    print(num)  #不会影响函数外,num本身的值
    print('----------------------')
    # 返回值例外
    num2 = 1
    def change(num2):
        print(num2)   # 1
        num2 = 3
        return num2
    num_result = change(num2)
    print(num_result)  #返回值例外 3
    print(num2)  #函数内改变,不影响函数外的不可变对象 1
    

    运行结果:

    3
    1
    ----------------------
    1
    3
    1
    

    可变对象类型:如 fun(la),则是将 la 真正的传过去,在函数内部,修改后,fun外部的la也会受影响

    list_num = [1,2]
    def change(list_num):
        list_num.append(3)
        print(list_num)  #[1, 2, 3]
    change(list_num)
    print(list_num)  #[1, 2, 3]
    

    运行结果:

    [1, 2, 3]
    [1, 2, 3]
    

    二:变量作用域

        Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

    Python的作 用域一共有4种,从小到大分别是:

        L (Local) 局部作用域

            局部作用域,即函数中定义的变量

            局部变量(只能在函数内部使用)

        E (Enclosing) 闭包函数外的函数中

            嵌套的父级函数的局部作用域,即包含此函数的上级函数的局部作用域,但不是全局的;

        G (Global) 全局作用域

            全局变量,就是模块(python文件)级别定义的变量;

            定义在函数外的变量

        B (Built-in) 内建作用域

            系统固定模块里面的变量,比如int, bytearray等。

        总结:以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找,内建中找不到程序报错

    name = str('张三') #python内置的作用域 ->内建作用域
    y = 2 #全局 ->全局作用域
    def outer():
        a = 3 #闭包 -> 闭包
        def inner():
            b=2  #局部 ->局部作用域
            print(a)
        inner()
        #print(b) #报错
    outer()
    #print(a)  #报错
    

    运行结果:

    3
    

    1、作用域一

        Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域(有作用域的限制);其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也就是说这些语句内定义的变量,外部也可以访问。

    # 实例中 msg 变量定义在 if 语句块中,但外部还是可以访问的。
    if True:
        msg = "ok"
    print(msg)
    # 实例中 msg 定义在函数中,则它就是局部变量,外部不能访问:
    def test():
        msg_inner = 'ok'
    # print(msg_inner) #报错,无法访问局部变量
    

    运行结果:

    ok
    

    2、作用域二

        ①、局部变量:定义在函数内部的变量拥有一个局部作用域,局部变量只能在其被声明的函数内部访问。

        ②、全局变量:定义在函数外的拥有全局作用域, 全局变量可以在整个程序范围内访问。

        ③、调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。

    total = 0
    def sumcopyt(arg1,arg2):
        total= arg1+arg2
        print("局部变量",total) # 结果是:3而不是0(以 L –> E –> G –>B 的先后规则查找)
        return total
    sumcopyt(1,2)
    print('全局变量',total)
    

    运行结果:

    局部变量 3
    全局变量 0
    

    3、作用域三

        一个不在局部作用域里的变量默认是只读的,如果试图为其绑定一个新的值,python认为是在当前的局部作用域里创建一个新的变量,也就是说在当前局部作 用域中,如果直接使用外部作用域的变量,那么这个变量是只读的,不能修改。

    global:通过里面的操作,改变外面的值

    name='50'
    def change_name():
        name='100'
        print('局部变量的值:',name)
    change_name()
    print('全局变量的值:',name)  #全局的变量,并没有修改
    print('--------------------------')
    name2='50'
    def change_name2():
        #想让局部的total和全局的total变为同一个total(通过里面的操作,改变外面的值)
        global name2
        name2='100'
        print('局部变量的值:',name2)
    change_name2()
    print('全局变量的值:',name2)  #全局的变量,已经修改啦
    

    运行结果:

    局部变量的值:100
    全局变量的值:50
    --------------------------
    局部变量的值:100
    全局变量的值:100
    

    4、作用域四

        如果要修改嵌套作用域即闭包函数(enclosing 作用域,外层非全局作用域)中的变量则需要nonlocal 关键字

    def method_01():
        a = 1
        def method_02():
            nonlocal a
            a=2
            print(a)
        method_02()
        print(a)
    
    method_01()
    

    运行结果:

    2
    2
    

    三:Python内置函数    

        为了提高程序员的开发效率,Python 提供了很多可以直接拿来用的函数。

        内容参考:http://www.runoob.com/python3/python3-built-in-functions.html

     

  • 相关阅读:
    wordpress ImetaWeblog
    日期替换,正则
    大文本编辑程序
    [C#]使用 Bing Sharp 來做 Bing 翻譯[转]
    uc密码产生方式。
    运行时出现 “child”不是此父级的子控件。
    太犯傻了。。。。
    mysql中使用rand函数得到随机整数
    混合模式程序集是针对“v2.0.50727”版的运行时生成的,在没有配置其他信息的情况下,无法在 4.0 运行时中加载该程序集。
    获取 httponly 的 cookie
  • 原文地址:https://www.cnblogs.com/zhuhuibiao/p/12377331.html
Copyright © 2011-2022 走看看