1.函数的定义

函数是：组织好的、可重复使用的、用来实现特定功能的代码段。它的优点：将功能封装在函数内，可供随时随地重复利用，提高代码的复用性，减少重复代码，提高开发效率

Python函数的定义方式：先定义函数，后调用函数

#函数的定义
def 函数名(传入参数): 
    函数体
    return 返回值
#函数的调用
函数名(参数)

函数的传参

Python函数传参很简单，函数定义时形式参数用来接收实际参数所传过来的数据，调用时传过来的是实际参数，需要注意：参数之间使用逗号进行分隔，传入的时候，按照顺序传入数据，使用逗号分隔，要和形式参数一一对应。总体思想与C语言大同小异。

#函数定义
def add(x, y):
    sum = x + y
    return sum

#函数调用
print(f"2+3的和为{add(2, 3)}")

函数的返回值

所谓“返回值：就是程序中函数完成事情后，最后给调用者的结果。函数体在遇到return后就结束了，所以写在return后的代码不会执行。上例中return sum就是函数的返回语句，最终把sum的值返回到函数调用的语句中。

None类型

None是一个字面量，类似于C语言当中0、NULL，表示空的、无实际意义的意思，函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。如果没有使用return语句返回数据，那么函数就会返回None。它可以用在if判断上，等同于False，一般用于在函数中主动返回None，配合if判断做相关处理。定义变量的时候，如果暂时不需要变量有具体值，可以用None来代替。

def message():
    print(".....")
ret = message()
print(ret)#结果是None

函数的说明文档

函数的说明文档其实就是注释，增加阅读者的理解和观感，提升阅读的效率，但有一定的规范，这些规范让我们的代码看起来优雅！

def add(x, y):
    """
    add函数实现了两个数的加法
    :param x: x是加法当中的一个参数
    :param y: y是另一个参数
    :return: 返回的是两个数的和
    """
    return x+y
ret = add(2, 3)
print(ret)

注意：在PyCharm软件编写代码时可以通过鼠标悬停，查看调用函数的说明文档

函数的嵌套调用

函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

def B():
    print("---2---")
def A():
    print("---1---")
    B()
    print("---3---")
A()

局部遍量和全局变量 

局部变量：这里的局部变量的含义和C语言是一样的。局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量：指的是在函数体内、外都能生效的变量

那我们能不能在函数里修改全局变量的值呢？答案是肯定的，这牵扯到一个关键字的使用，global关键字，使用 global关键字可以在函数内部声明变量为全局变量

num = 100
def modify():
    num = 200
    print(num)#200
modify()
print(num)#100

num = 100
def modify():
    global num
    num = 200
    print(num)#200
modify()
print(num)#200

2.数据容器 

Python中的数据容器类似于C语言当中的数组的意思，可以一次性存放多个数据。是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。它根据是否支持重复元素、是否可以修改、是否有序等划分为5类，分别是：列表、元组、字符串、集合、字典。

list(列表) 

上面讲过数据容器类似于我们C语言当中所学到的数组的概念，列表就是其中的一个代表，现在就让我们来了解列表的定义，它的基本语法是：以[]作为标识，列表内每一个元素之间用，逗号隔开

name = ['张三', '李四', 666] 

但是这个列表又和我们C语言当中的数组有所区别，列表当中的数据可以是不同的数据类型，并且可以嵌套类似于二维数组的含义。

列表的下标索引：从前向后的方向，从0开始，依次递增。从后向前:从-1开始，依次递减

同样的道理要注意下标索引的取值范围，超出范围无法取出元素，并且会报错 

name = ['张三', '李四', 666]  
print(name[0]) #张三        
print(name[1]) #李四        
print(name[-3])#张三        

列表的常用操作（方法）：列表除了可以定义、使用下标索引获取值，也可以进行插入元素、删除元素、清空列表、修改元素、统计元素个数等等功能，这些功能称之为：列表的方法。下面就一一展开讲解：

列表的查询功能：列表.index(元素)，它的返回值是所要查找元素的下标，而且是正向的下标。查找指定元素在列表的下标，如果找不到，报错ValueError

name = ['张三', '李四', 666]
temp = name.index('张三') 
print(temp)#0           

列表的修改功能：列表[下标]= 值 ，就是赋值，修改特定位置(索引)的元素值

列表的插入功能： 列表.insert(下标,元素)，在指定的下标位置，插入指定的元素

name = ['张三', '李四', 666]            
name.insert(1, '王二')                
print(name)#['张三', '王二', '李四', 666] 

列表的追加功能1： 列表.append(元素)，将指定元素，追加到列表的尾部

name = ['张三', '李四', 666]              
name1 = ['王二', '麻子']                  
name.append(name1[0])                 
print(name)#['张三', '李四', 666, '王二']
name.append(666)                        
print(name)#['张三', '李四', 666, '王二', 666]   

列表的追加功能2：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部 

name = ['张三', '李四', 666]                    
name1 = ['王二', '麻子']                        
name.extend(name1)                          
print(name)#['张三', '李四', 666, '王二', '麻子']   

列表的删除功能1： del 列表[下标]

列表的删除功能2：列表.pop(下标)

name = ['张三', '李四', 666]                
name1 = ['王二', '麻子']                    
name.extend(name1)                      
print(name)#['张三', '李四', 666, '王二', '麻子']
del name[0]                             
print(name)#['李四', 666, '王二', '麻子']     
name.pop(0)                             
print(name)#[666, '王二', '麻子']           

删除列表中的第一个匹配项：列表.remove(元素)，就是遍历整个列表删除其中第一个所要删除的元素

name = ['张三', '李四', 666]                      
name1 = ['王二', '麻子', 666]                     
name.extend(name1)                            
print(name)#['张三', '李四', 666, '王二', '麻子', 666]
name.remove(666)                              
print(name)#['张三', '李四', '王二', '麻子', 666]     

清空列表：列表.clear()

name = ['张三', '李四', 666]                      
name1 = ['王二', '麻子', 666]                     
name.extend(name1)                            
print(name)#['张三', '李四', 666, '王二', '麻子', 666]
name.clear()                                  
print(name)#[]                                

统计某元素在列表内的数量： 列表.count(元素）

name = ['张三', '李四', 666]                      
name1 = ['王二', '麻子', 666]                     
name.extend(name1)                            
print(name)#['张三', '李四', 666, '王二', '麻子', 666]
count = name.count(666)                       
print(count)#2                                

 统计列表内有多少元素：len(列表)

name = ['张三', '李四', 666]                      
name1 = ['王二', '麻子', 666]                     
name.extend(name1)                            
print(name)#['张三', '李四', 666, '王二', '麻子', 666]
count = len(name)                             
print(count)#6                                

汇总表格：

列表元素的遍历：在C语言当中，我们常常会使用for循环去遍历一个数组，那在Python中，我们能不能这样做呢？答案是肯定的，Python中for循环和while循环都可以实现遍历列表，while循环的条件，防止死循环，for循环用起来会更加方便，它的语法就是从数据容器中逐个取出元素赋值到临时变量上。

name = ['张三', '李四', 666, '王二', '麻子', 666]
index = 0                                
#while循环遍历列表                             
# while index < len(name):               
#     print(f"列表的元素：{name[index]}")      
#     index += 1                         
#for循环遍历列表                               
for index in name:                       
    print(f"列表的元素：{index}")              

tuple(元组) 

元组和列表的功能是差不多的，主要的区别就是元组里的内容不可以修改，定义的方式是使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。需要格外注意的是：元组只有一个数据，这个数据后面要添加逗号。还有一点是虽然元组不可以修改，但当元组里面的内容包括列表时那么元组里面的列表内容是可以修改的，但是列表不能换成其它数据类型。

由于不能修改，它的相关操作也少了许多

name = ('张三', '李四', 666, '王二', '麻子', 666, [1, 2, 3])
print(len(name))#7                                  
print(name[0])#张三                                   
name[6][0] = 0                                      
print(name[6][0]) #0                                
index = 0                                           
while index < len(name):                            
    print(f"元组的元素：{name[index]}")                   
    index += 1                                      
# 元组的元素：张三                                          
# 元组的元素：李四                                          
# 元组的元素：666                                         
# 元组的元素：王二                                          
# 元组的元素：麻子                                          
# 元组的元素：666                                         
# 元组的元素：[0, 2, 3]                                   

str(字符串)

我们前面已经接触到了字符串，其实字符串也是一个数据容器，它不仅可以通过下标进行访问而且也可以进行相应的操作。同元组一样，字符串是一个无法修改的数据容器，而且它只能存储字符。

• 下标访问时，和列表元组的方式是相同的从前向后，下标从0开始，从后向前，下标从-1开始
• 查找特定字符串的下标索引值：字符串.index(字符串)，返回的是所查字符串的起始下标
• 字符串的替换：字符串.replace(字符串1，字符串2)，将字符串内的全部字符串1，替换为字符串2。不是修改字符串本身，而是得到了一个新字符串。
• 字符串的分割：字符串.split(分隔符字符串)，按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。字符串本身不变，而是得到了一个列表对象。
• 字符串的规整操作：字符串.strip()，不带入参数是去前后空格，带入参数是去前后指定字符串
• 统计字符申中某宇符申的出现次数：和列表元组一样使用count方法
• 统计字符串的长度：和列表元组一样使用len()方法

汇总表格：

 

name = "zhangsan lisi wanger"                 
print(name[1])#h                              
n = name.index('an')                          
print(n)#2                                    
new_name = name.replace('zhangsan', 'mazi')   
print(new_name)#mazi lisi wanger              
new_list = name.split(' ')                    
print(new_list)#['zhangsan', 'lisi', 'wanger']
name = "\n  zhangsan lisi wanger  \n"         
new_name = name.strip()                       
print(new_name)#zhangsan lisi wanger          
name = "zhangsan lisi wanger"                 
new_name = name.strip('zr')                   
print(new_name)#hangsan lisi wange            
name = "zhangsan lisi wanger"                 
print(name.count('a'))#3                      
print(len(name))#20                           

序列 

序列是指：内容连续、有序，可使用下标索引的一类数据容器。前面所介绍的列表、元组、字符串，都可以视为序列，序列是支持切片操作的，切片就是从一个序列中，取出一个子序列。语法是：序列[起始下标:结束下标:步长]，表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。需要注意此操作不会影响序列本身，而是会得到一个新的序列。

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔，可以省略，省略步长默认为1，也可以为负数表示倒序执行

name = "zhangsan lisi wanger"    
name1 = name[9:13]               
print(name1)#lisi                
name2 = name[:]                  
print(name2)#zhangsan lisi wanger
list = [1, 2, 3, 4, 5]           
list1 = list[1:3:2]              
print(list1)#[2]                 

set(集合) 

前面所讲述的列表、元组、字符串它们都支持重复元素且是有序的，局限就在于都支持重复元素，那有没有不支持的呢？即有去重作用这样的数据容器呢？答案是肯定的，这就是集合。集合的定义与它们几乎相同，无非是用{}来表示。因为是无序的，所以不支持下标访问，它具有以下的操作：

• 添加新元素：集合.add(元素)，集合本身被修改，添加了新元素
• 移除元素：集合.remove(元素)，集合本身被修改，移除了元素
• 从集合中随机取出元素：集合.pop()，会得到一个元素的结果。同时集合本身被修改，元素被移除
• 清空集合：集合.clear()，集合本身被清空
• 取出2个集合的差集：集合1.difference(集合2)，取出集合1和集合2的差集(集合1有而集合2没有的)，得到一个新集合，集合1和集合2不变
• 消除2个集合的差集：集合1.difference_update(集合2)，在集合1内，删除和集合2相同的元素，集合1被修改，集合2不变
• 2个集合合并：集合1.union(集合2)，将集合1和集合2组合成新集合，得到新集合，集合1和集合2不变

汇总如下：

 

#定义集合                                                                
name = {"zhangsan", "lisi", "wanger", "zhangsan", "wanger", "mazi"}  
print(name)#{'wanger', 'mazi', 'lisi', 'zhangsan'}                   
#添加新元素                                                               
name.add(666)                                                        
print(name)#{'lisi', 'wanger', 'mazi', 'zhangsan', 666}              
name.add("zhangsan")                                                 
print(name)#{'lisi', 'wanger', 'mazi', 'zhangsan', 666}              
#移除元素                                                                
name.remove(666)                                                     
print(name)#{'wanger', 'lisi', 'mazi', 'zhangsan'}                   
name.remove("zhangsan")                                              
print(name)#{'wanger', 'lisi', 'mazi'}                               
#从集合中随机取出元素                                                          
temp = name.pop()                                                    
print(temp)#mazi                                                     
#清空集合                                                                
name.clear()                                                         
print(name)#set()                                                    
#取出2个集合的差集                                                           
name1 = {"zhangsan", "lisi", "wanger", "mazi"}                       
name2 = {"zhangsan", "lisi", "wanger", "zhangsan", "wanger"}         
tp = name1.difference(name2)                                         
print(tp)#{'mazi'}                                                   
print(name1)#{'zhangsan', 'lisi', 'mazi', 'wanger'}                  
print(name2)#{'zhangsan', 'lisi', 'wanger'}                          
#消除2个集合的差集                                                           
name1 = {"zhangsan", "lisi", "wanger", "mazi"}                       
name2 = {"zhangsan", "lisi", "wanger", "zhangsan", "wanger"}         
name1.difference_update(name2)                                       
print(name1)#{'mazi'}                                                
print(name2)#{'zhangsan', 'lisi', 'wanger'}                          
#2个集合合并                                                              
name1 = {"zhangsan", "lisi", "wanger", "mazi"}                       
name2 = {"zhangsan", "lisi", "wanger", "zhangsan", "wanger"}         
name3 = name1.union(name2)                                           
print(name3)#{'lisi', 'zhangsan', 'mazi', 'wanger'}                  
print(name1)#{'mazi', 'lisi', 'wanger', 'zhangsan'}                  
print(name2)#{'lisi', 'wanger', 'zhangsan'}                          
#集合的遍历                                                               
set = {1, 2, 3, 4}                                                   
for element in set:                                                  
    print(element)                                                   

dict(字典) 

字典类似于我们日常生活中所使用的汉语字典通过字查找字的含义的功能一样，它可以通过key取出value的操作，字典的定义，同样使用{}，不过存储的元素是一个个的：键值对。

• 字典同集合一样，不可以使用下标索引，但是字典可以通过Key值来取得对应的Value
• 字典内Key也不允许重复，重复添加等同于覆盖了原有的数据
• 键值对的Key和Value可以是任意类型(Key)不可为字典，也就是说它可以嵌套，只能在value中进行嵌套

它的一些操作如下：

• 新增元素： 字典[Key]= Value，字典被修改，新增了元素，更新元素也是如此，如果字典里有key就更新，没有就新增
• 删除元素：字典.pop(Key)，获得指定Key的Value，同时字典被修改，指定Key的数据被删除
• 清空字典：字典.clear()
• 获取全部的key：字典.keys()，得到字典中的全部Key，可用于遍历字典

汇总如下：

 

#知道key获取value                                              
dict = {"张三": 99, "李四": 77, "王二": 66,}                     
print(dict["张三"])#99                                       
#添加或更新                                                     
dict["张三"] = 66                                            
print(dict)#{'张三': 66, '李四': 77, '王二': 66}                 
dict["麻子"] = 55                                            
print(dict)#{'张三': 66, '李四': 77, '王二': 66, '麻子': 55}       
#删除                                                        
temp = dict.pop("李四")                                      
print(dict)#{'张三': 66, '王二': 66, '麻子': 55}                 
print(temp)#77                                             
#获取全部的key                                                  
tp = dict.keys()                                           
print(tp)#dict_keys(['张三', '王二', '麻子'])                    
#遍历字典                                                      
for name in dict:                                          
    print(f"{name}的分数是：{dict[name]}")                      
# 张三的分数是：66                                                
# 王二的分数是：66                                                
# 麻子的分数是：55                                                

数据容器的通用操作

前面我们介绍了len(容器)，包括for循环进行遍历都是数据容器的通用操作，其实还有以下的通用操作：

• max(容器)：统计容器的最大元素
• min(容器)：统计容器的最小元素
• list(容器)：将给定容器转换为列表
• str(容器)：将给定容器转换为字符串
• tuple(容器)：将给定容器转换为元组
• set(容器)：将给定容器转换为集合
• sorted(容器， [reverse = True])：将给定容器进行排序，注意reverse默认为files，如果需要倒序，需要将reverse = True

汇总如下：

list1 = [1, 2, 3, 4, 5]                                                 
tuple1 = (1, 2, 3, 4, 5)                                                
str1 = "abcdef"                                                         
set1 = {"zhangsan", "lisi", "wanger", "mazi"}                           
dict1 = {'张三': 66, '王二': 66, '麻子': 55}                                  
print(list(list1))#[1, 2, 3, 4, 5]                                      
print(list(tuple1))#[1, 2, 3, 4, 5]                                     
print(list(str1))#['a', 'b', 'c', 'd', 'e', 'f']                        
print(list(set1))#['zhangsan', 'lisi', 'mazi', 'wanger']                
print(list(dict1))#['张三', '王二', '麻子'],把value值舍去                         
list1 = [1, 2, 3, 4, 5]                                                 
tuple1 = (1, 2, 3, 4, 5)                                                
str1 = "abcdef"                                                         
set1 = {"zhangsan", "lisi", "wanger", "mazi"}                           
dict1 = {'张三': 66, '王二': 66, '麻子': 55}                                  
print(tuple(list1))#(1, 2, 3, 4, 5)                                     
print(tuple(tuple1))#(1, 2, 3, 4, 5)                                    
print(tuple(str1))#('a', 'b', 'c', 'd', 'e', 'f')                       
print(tuple(set1))#('mazi', 'zhangsan', 'wanger', 'lisi')               
print(tuple(dict1))#('张三', '王二', '麻子'),把value值舍去                        
list1 = [1, 2, 3, 4, 5]                                                 
tuple1 = (1, 2, 3, 4, 5)                                                
str1 = "abcdef"                                                         
set1 = {"zhangsan", "lisi", "wanger", "mazi"}                           
dict1 = {'张三': 66, '王二': 66, '麻子': 55}                                  
print(str(list1))#[1, 2, 3, 4, 5]                                       
print(str(tuple1))#(1, 2, 3, 4, 5)                                      
print(str(str1))#abcdef                                                 
print(str(set1))#{'zhangsan', 'mazi', 'lisi', 'wanger'}                 
print(str(dict1))#{'张三': 66, '王二': 66, '麻子': 55}                        
list1 = [1, 2, 3, 4, 5]                                                 
tuple1 = (1, 2, 3, 4, 5)                                                
str1 = "abcdef"                                                         
set1 = {"zhangsan", "lisi", "wanger", "mazi"}                           
dict1 = {'张三': 66, '王二': 66, '麻子': 55}                                  
print(set(list1))#{1, 2, 3, 4, 5}                                       
print(set(tuple1))#{1, 2, 3, 4, 5}                                      
print(set(str1))#{'c', 'b', 'a', 'd', 'e', 'f'}                         
print(set(set1))#{'zhangsan', 'lisi', 'mazi', 'wanger'}                 
print(set(dict1))#{'王二', '麻子', '张三'} 把value值舍去 
list1 = [2, 5, 1, 4, 5]                            
print(sorted(list1)) #[1, 2, 4, 5, 5]              
list1 = [2, 5, 1, 4, 5]                            
print(sorted(list1, reverse=True))#[5, 5, 4, 2, 1]