一：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

　

最新文章

  1. Datazen地图Chart介绍
  2. LoadRunner 函数之 web_add_cookie
  3. UITableViewCell的highlighted 和selected 属性1
  4. js JS 浮点计算BUG
  5. Python模拟用户登录
  6. observer观察者模式
  7. ZENCART 打开/关闭日志文件
  8. linux 学习之九、Linux 磁盘与文件系统管理（3）
  9. Struts2 开发环境搭建
  10. js两种生成对象模式（公有成员和成员私有）
  11. js检测对象中是否存在某个属性
  12. 建立、配置和使用Activity——Activity
  13. An impassioned circulation of affection
  14. charAt()的功能
  15. 《Metasploit魔鬼训练营》虚拟环境搭建中网络配置的一些问题
  16. iOS 让图片变模糊
  17. bzoj 2763 [JLOI2011]飞行路线 Dijikstra 分层
  18. 将 notepad++ 添加到鼠标右键菜单 带图标
  19. Python 执行 mysql 存储过程
  20. JavaWeb - Servlet教程

热门文章

  1. JS将扁平化的数据处理成Tree结构
  2. 封装好通用的reset.css base.css 样式重置css文件
  3. mysql删除索引
  4. SQL中的real、float、decimal、numeric数据类型区别
  5. 记录zabbix4.0升级4.2
  6. springboot打成jar包并携带第三方jar
  7. visual studio2010编译过程中出现COFF文件损坏的原因和方法总结
  8. 【pycharm基本操作】项目创建、切换、运行、字体颜色设置，常见包的安装步骤
  9. [USACO19OPEN]Valleys P
  10. 止损+TS