一、函数

（一、基础

函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用它

函数的使用：

1. 定义函数——封装独立的功能
2. 调用函数——使用封装的功能

函数的作用：在开发过程中，函数可以优化代码的可读性、提高编写效率、将常用代码重用

（二、基本使用

1、定义函数

　　　　def 函数名（）：

　　　　　　函数封装的代码

　　　　　　......

注意：

• 函数名要做到见名知意
• 函数的名称要符合标识符的命名规则，即：由字母、数字和下划线组成；不能由数字开头；不能与关键字重名

2、函数的调用

直接通过 函数名（）调用即可

注意：

• 定义一个函数只是封装了一段实现某种功能的代码而已，如果不主动调用函数，函数是不会主动执行的
• 不能将函数调用放在函数定义上方，否则会出现名称错误
• 在给函数添加注释时，要在定义函数的下方，使用三个连续的对引号，其中编写说明文字
• pycharm中在函数调用位置使用快捷键ctrl+q可查看函数说明信息
• 应在函数体上方保证两个空行的间隔，以保证函数视觉上的独立性

3、函数的参数

位置：函数名后面的小括号内，多个参数之间使用逗号连接

作用：增加函数的通用性，在函数内部对参数进行相同的处理

分类:

• 形参：定义函数时，小括号中的参数，作为变量使用
• 实参：调用函数时，小括号中的参数，用来把数据传递到函数内部

 4、函数的返回值

作用：完成函数对数据的处理操作后，给调用者返回一个结果

关键字：return关键字，执行完之后后面的代码不会被执行

5、函数的嵌套调用

定义：在函数中又调用另外一个函数，在执行函数A时，执行到嵌套函数B之后，先执行函数完函数B，再回到函数A中，调用函数B的位置，继续执行后续代码。

 嵌套函数练习：打印5行*组成的分隔线，要求能够打印任意重复次数的分隔线：

def print_line(char, times):
    print(char * times )

def print_lines(char, times):
    row = 0
    while row<5:
        print_line(char, times)
        row += 1

6、使用模块中的函数

任何一个扩展名为py的python源代码文件都是一个模块，模块相当于一个工具包，用import导入，模块中的全局变量以及函数都可以在导入后通  模块名.变量  或  模块名.函数  进行重复使用。

模块名：同样是一个标识符，有数字、字母和下划线组成，不能以数字开头，不能与关键字重名。

7、函数的局部变量和全局变量

• 局部变量是定义函数内部定义的变量，只能在函数内部使用；
• 全局变量是在函数的外部定义的变量，所有的函数内部都可以使用这个变量

　　7.1局部变量

　　特点：

•  局部变量定义在函数的内部，只能在函数内部使用
• 函数执行结束后，局部变量会被系统回收
• 不同的函数可以定义相同的名字的局部变量，彼此之间不会产生影响

　　作用：

　　在函数内部，临时保存函数需要使用的数据

def demo1():
    num = 10
    print(num)
    num = 100
    print("修改后num=%d" % num)
demo1()
"""运行结果：10
         修改后num=100"""

局部变量的生命周期：

• 局部变量在函数执行时才会被创建
• 函数执行结束后，即被系统回收
• 只适用于存储临时使用的数据

　　7.2全局变量

　　全局变量是定义在函数外部的变量，当函数执行时会先在函数内部寻找特定名称的局部变量，如果找不到就会在函数外部找是否有该名称的全局变量，如果都没有就会报错。

　　在函数内部可以使用全局变量，但是函数内部不能对全局变量进行修改

num = 1
def demo():
   num = 10
   print(num)
demo() 
print(num)
"""输出结果：10
           1"""

位置：为了保证所有的函数都可以调用全局变量，全局变量应定义在其他函数的上方

8.函数的参数及返回值

　　　参数：当函数内部处理的数据不一定时，将外界的数据以参数的形式传递给函数

　　　返回值：当调用者需要得到函数的结果时，可以用return关键字将结果返回，调用者可以用一个变量来接受函数返回的结果

　　一个函数执行后如何返回多个结果？

　　可用元组的方式将结果返回（注：当用元组返回多个结果时，括号是可以省略的）

def message():
   name = "xiaoming"
   age = 18
   return name, age


message2 = message()
print(message2)
"""运行结果：('xiaoming', 18)"""

#可将一个元组使用赋值语句同时赋值给多个变量，注意：变量的个数要和元组中的元素个数一致
message3 = name1,age2 =message()
print(message3)
"""运行结果：('xiaoming', 18)"""

　　 8.1不可变和可变的参数

无论传递的参数是可变的还是不可变的，在函数内部针对参数适用赋值语句不会影响到外部变量的引用，它相当于只是修改了局部变量的引用

def demo(num ,list):
   num = 10
   list=[1,2,3]
   print(num)
   print(list)
num = 1
list =[0,9,8]
demo(num,list)
print(num)
print(list)
"""运行结果：10
           [1, 2, 3]
           1
           [0, 9, 8]"""

但是在函数中调用方法对可变参数进行修改，是会改变影响外部数据的

def demo(list):
   list.append(6)
   print(list)
list =[0,9,8]
demo(list)
print(list)
"""运行结果：
           [0, 9, 8, 6]
        
           [0, 9, 8, 6]"""

 "+=”

在python中列表调用 =+ 本质上是在执行extend方法，所以外部数据是会改变的

def demo(num ,list):
   num += 10
   list += list
   print(num)
   print(list)
num = 1
list =[0,9,8]
demo(num,list)
print(num)
print(list)
"""运行结果：11
           [0, 9, 8, 0, 9, 8]
           1
           [0, 9, 8, 0, 9, 8]"""

但是不可变类型的参数是会改变的 

　　8.2 缺省参数

　　定义函数时可以给某一参数一个默认值，即缺省参数，当调用者调用函数时没有传递缺省参数的值，就会传递默认参数，所以将常见的值传递给缺省参数会简化函数的调用。

在参数后面直接使用赋值语句就可以指定缺省参数

注意：

• 当有多个参数时，缺省参数必须要在参数列表的末尾
• 在调用函数时，有多个缺省参数的话，必须指定参数名

def demo(name,title="",gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("[%s]%s 是 %s" % (title,name,gender_text))
demo("xiaoming",gender=True)
    """运行结果：(1, 2, 3)
               {'name': 'xiaoming', 'age': 18}"""

　　 8.3多值参数

python中有两种多值参数：

• 参数名前有一个* ，可以接收元组
• 参数名前有两个*，可以接收字典

一般在给多值函数命名时《习惯使用以下两个名字

• *args——存放元组参数
• **kwargs——存放列表参数

def demo(*args,**kwargs):
    print(args)
    print(kwargs)
demo(1,2,3,name="xiaoming",age=18)
"""运行结果为：(1, 2, 3)
            {'name': 'xiaoming', 'age': 18}"""

9、函数的递归

在一个函数内部调用自己本身的函数叫递归函数

特点：

• 函数的代码是相同的，只是针对参数不同，处理的结果不同
• 当参数满足一个条件时，函数不再执行，即函数的递归出口，必须有否则会出现死循环 

def sum_num(num):
    if num ==1:
        return 1
    temp = sum_num(num-1)
    return temp+num

print(sum_num(6))
#运行结果21

二、高级变量

python中变量可以分为数字型和非数值型两种

数字型：

• 整数（int）
• 浮点型（float）
• 布尔型（bool）真：True（非零即真）；假：False 0 
• 复数型（complex）

非数字型：

• 元组
• 列表
• 字典
• 字符串

python中所有非数字变量都有以下特点：

1. 都是一个序列，相当于一个容器
2. 都可以进行切片操作
3. 都可以重复 *  和链接 +
4. 都可以计算长度、最大值、最小值、比较、删除
5. 取值[ ]
6. 遍历for in

（一、列表

• 列表list用来储存一串信息，在python中时使用最频繁的数据类型；
• 用[ ]定义，数据之间用 ， 隔开
• 列表的索引（即位置编号）从0开始（在列表中取数时不能超过索引范围，否则会报错）

1、列表的常用操作

在python3中定义一个列表，输入 列表名. 再按TAB键盘，会提示列表能够使用的方法

序号	分类	关键字/函数/方法	说明
1	增加	列表.insert(索引，数据)	在指定位置插入数据
		列表.append(数据)	在末尾追加数据
		列表.extend（另一列表）	将另一列表的数据追加至此列表
2	修改	列表[索引] = 数据	修改指定索引的数据
3、	删除	列表.pop	删除末尾数据
		列表.pop[数据]	删除指定索引数据
		列表.remove[数据]	删除第一个出现的指定数据
		列表.clear	清空列表
		del列表[索引]	删除指定索引的数据
4、	统计	len（列表）	列表的长度
		列表.count（数据）	数据在列表中出现的次数
5、	排序	列表.sort(）	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse（）	逆序、反转

　　1.1 循环遍历

遍历就是从头到尾依次从列表中获取数据，可以再循环内部针对每一个元素做同样的操作在python中提供迭代遍历，利用for就可以实现迭代遍历

num_list=[1,2,3]
for num in num_list:
    print(num)
"""运行结果为：1
             2
             3
"""

（二、元组

1、元组（tuple）的定义和列表类似不同之处在于元素不能修改

• 元组用（）定义
• 元组的索引从0开始

注意：元组中只包含一个元素时需要在元素后面加一个，eg：info_tuple = (1,)

2、元组中的元素不能改变，所以元组可调用的函数只有

　　元组名.count(数据)：用来查看数据在元组中出现的次数

　　元组名.index（数据）：用来查看数据第一次出现的索引

3、循环遍历，和列表的循环遍历相同，使用for

4、应用场景

• 函数的多值参数和返回值
• 格式化字符串
• 让列表不可以被修改

5、元组和列表的转变

• 使用list函数可以将元组转变为列表  list(元组)
• 使用tuple函数可以将列表转变为元组 tuple（列表）

（三、字典

1、字典用{ }定义，使用键值对存储数据，键值对之间用 ，隔开，用来描述一个物体的相关信息

• 字典的键key是索引
• 值value是数据
• 键和值之间用 ： 链接
• 键必须是唯一的
• 值可以使用任何数据类型，但是键只能使用字符串、数字和元组

2、和列表的区别：列表是有序的对象集合，字典是无序的对象集合

xiaoming = {"name":"xiaoming","age":18,"height":175}
print(xiaoming)
"""运行结果：{'name': 'xiaoming', 'age': 18, 'height': 175}"""

3、循环遍历

for 循环内部使用的“key”的变量，in字典

（四、字符串

1、字符串就是一串字符，是编程语言中表示文本的数据类型

注意：

• 在python中可以使用一对双引号或者一对单引号，来定义字符串
• 如果在字符串内部需要使用 " ，可以使用 ' 定义字符串
• 如果在字符串内部需要使用 ' ,可以使用 " 定义字符串
• 也可以使用索引，获取一个字符串内部指定位置的字符
• 也可以使用for循环遍历字符串中的每个字符

2、字符串的常用操作：

 

3、字符串的切片

切片适用于字符串、列表及元组

切片使用索引值来限定范围，可以从一个大的字符串里切出一个小的字符串

列表和元组是一个有序的集合，直接使用索引就可以切出想要的内容，但是字典是无序的集合，不提供对字典的切片

切片操作：字符串[开始索引：结束索引：步长]

注意：

• 索引的指定区间是左闭右开型
• 从头开始，索引可以省略但是冒号不能省略 eg：字符串[ : 6] 即为截取从开始到5位置的字符串
• 到末尾的索引，结束索引数字也可以省略，但是冒号也不能省略
• 步长默认为1，如果是连续的进行切片的话，步长也是可以省略的

字符串的切片不知可以顺序也可以逆序，逆序时将步长设为-1 eg：字符串的逆序：字符串名[ : : -1]

（五：公共方法

1、python内置函数

函数	描述	备注
len(item)	计算容器中元素的个数
del（item）	删除容器中的元素	del的特殊用法
max(item)	返回容器中元素的最大值	如果是字典，只针对key比较
min(item)	返回容器中的最小值	如果是字典，只针对key比较

注意：del删除的是引用而不是数据本身，由于python都是引用，而python有GC机制，所以，del语句作用在变量上，而不是数据对象上。

1. if __name__=='__main__':  
       a=1       # 对象 1 被 变量a引用，对象1的引用计数器为1  
       b=a       # 对象1 被变量b引用，对象1的引用计数器加1  
       c=a       #1对象1 被变量c引用，对象1的引用计数器加1  
       del a     #删除变量a，解除a对1的引用  
       del b     #删除变量b，解除b对1的引用  
       print(c)  #最终变量c仍然引用1  

del删除的是变量，而不是数据。

if __name__=='__main__':  
    li=[1,2,3,4,5]  #列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4]   
    first=li[0]     #拷贝列表，也不会有数据对象的复制，而是创建新的变量引用  
    del li[0]  
    print(li)      #输出[2, 3, 4, 5]  
    print(first)   #输出 1  

2、切片

描述	python中的表达式	结果	支持的数据类型
切片	“1234568”[ :  : -2]	"8531"	列表、元组、字符串

3、运算符

运算符	python表达式	结果	描述	支持的数据类型
+	[1,2]+4,3]	[1,2,3,4]	合并	元组、列表、字符串
*	["h"]*3	["h","h","h"]	重复	元组、列表、字符串
in	3 in （1，2，3）	True	元素是否存在	元组、列表、字符串、字典（字典只能针对key判断）
not in	4 not in（1，2，3，4）	True	元素是否不存在	元组、列表、字符串、字典（字典只能针对key判断）
> >= < <= ==	（1，2，3）<（2，2，3）	True	元素比较	字符串，元组，列表

注意：

• in和not in被称为成员运算符
• 在用in 和not in对字典进行运算时，实质上是在针对key进行判断