什么是函数：一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能
为什么要使用函数：
代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化
函数定义：
def 函数名():
函数体[一系列的python语句，表示独立的功能]
函数的调用：
本质上就是去执行函数定义里面的代码块，在调用函数之前必须先定义

参数的分类：
必选参数、默认参数(缺省参数)、可选参数、关键字参数
参数：其实就是函数为了实现某项特定的功能，进而为了得到实现功能所需要的数据
（其实是为了得到外部数据的

# 1 必选参数(必须赋值的，就是有形参的函数)
def sum(a, b): # 形式参数：只是意义上的一种参数，在定义的时候是不占内存地址的
    sum = a + b
    print(sum)
    pass

# 2 默认参数(缺省参数) 始终存在与参数列表的尾部
def sum1(a, b = 4):
    print("默认参数的使用 = %d"%(a + b))
    pass

# 3 可选参数(用*来定义，当参数的个数不确定的时候使用比较灵活)

def getComputer(*args): # *args就是可变长的参数
    '''
    计算累加和
    :param args: 可变长的累加和
    :return:
    '''
    result = 0
    # print(args)
    for item in args:
        result += item
        pass
    print('result = %d'%result)
    pass

getComputer(1,2,3)
getComputer(1,2,3,4,5)

# 4 关键字可变参数(用**来定义)，在函数体内，参数关键字是一个字典类型。key是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    pass
# keyFunc(1,2,3) 不可以的
dictA = {"name":'Leo', "age":35}
keyFunc(**dictA)
keyFunc(name = 'Peter', age = 26)

# 5 连起来
def complexFunc(*args, **kwarg):
    '''
    可选参数必须放到关键字可变参数之前
    可选参数：接受的数据是一个元组类型
    关键字可选参数接受的数据是一个字典类型
    :param args:
    :param kwarg:
    :return:
    '''
    print(args)
    print(kwarg)
    pass
complexFunc(1,2,3,4, name = 'Leo')
complexFunc(**dictA)

# 6 函数返回值

def sum2():
    li = []
    i = 1
    while i < 10:
        li.append(i)
        i += 1
        pass
    return li
    pass
'''
这里可以返回数组、元组、字典等类型
'''

print(type(sum2()))
print(sum2())

# print(type(sum2()))
# print(sum2())
# 
# result = 6
# result = 15
# {'name': 'Leo', 'age': 35}
# {'name': 'Peter', 'age': 26}
# (1, 2, 3, 4)
# {'name': 'Leo'}
# ()
# {'name': 'Leo', 'age': 35}
# <class 'list'>
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

global函数

name = 'Leo'
hobby = 'basketball'
age = 29
def print1():
    print('-------------------IN PRINT1---------------------')
    global name
    name = 'Mr Wang'
    print(name)
    pass
def print2():
    print('-------------------IN PRINT2---------------------')
    name = 'Mr Du'
    print(name)
    pass
def defpro():
    global pro
    pro = 'teacher'
    pass
def print3():
    print('{} {} {}'.format(name, hobby, age))
    pass
def print4():
    print('{}'.format(pro))
    pass

print('--------------------IN MAIN-----------------------')
print3()
print1()
print3()
print2()
print3()
defpro()
print3()
print4()

# --------------------IN MAIN-----------------------
# Leo basketball 29
# -------------------IN PRINT1---------------------
# Mr Wang
# Mr Wang basketball 29
# -------------------IN PRINT2---------------------
# Mr Du
# Mr Wang basketball 29
# Mr Wang basketball 29
# teacher

匿名函数

# 匿名函数
# 语法：
# lambda 参数1, 参数2, 参数3:表达式
# 特点：
# 1、使用lambda来创建函数
# 2、没有名字的函数
# 3、冒号后面的表达式只有一个，注意：是表达式，不是语句
# 4、匿名函数自带return，而return后面的结果就是表达式计算后的结果
# 缺点：
# lambda只能是单个表达式，不是一个代码块，lambda的设计就是为了满足简单函数的场景，仅仅能封装有限的逻辑，复杂逻辑实现不了只能用def来处理
def computer(x,y):
    '''
    计算两个变量的和
    :param x:
    :param y:
    :return:
    '''
    return x + y
# 对应的匿名函数
M = lambda x, y:x+y
# 通过变量调用匿名函数
print(M(29,4))
print(computer(29,4))

MAX = lambda x, y:x if x > y else y
print(MAX(656,5))
# x**y表示x的y次方
# 33
# 33
# 656

序列操作

str 元组、 list

all()

result:bool 对象中的元素除了是 0、空、FALSE 外都算 TRUE,所有的元素都为True,结果就为True

any()

result:bool 类似于逻辑运算符 or的判断，只要有一个元素为True 结果就为True

print(all(('',4,56,[43]))) # False
print(any(('',4,56,[43]))) # True

sort 和sorted

li=[2,45,1,67,23,10] # 原始对象
# li.sort() #list的排序方法 直接修改的原始对象
li = [1,345,65,76,2,8,3,4,7]
print('-----------------排序之前--------------{}'.format(li))
li1 = li2 = li
li1.sort()
print('----------------li1排序之后------------{}'.format(li1))
lis = sorted(li2,reverse = True) # reverse代表倒序，故True为倒
print('----------------li2进行倒序排序之后-----{}'.format(lis))

# -----------------排序之前--------------[1, 345, 65, 76, 2, 8, 3, 4, 7]
# ----------------li1排序之后------------[1, 2, 3, 4, 7, 8, 65, 76, 345]
# ----------------li2进行倒序排序之后-----[345, 76, 65, 8, 7, 4, 3, 2, 1]

zip()

就是用来打包的，会把序列中对应的索引位置的元素存储为一个元组
函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表
zip函数 https://blog.csdn.net/zbrj12345/article/details/80372954

s1=['a','b','c']
s2=['你','我','c他','peter']
s3=['你','我','c他','哈哈','呵呵']
print(list(zip(s1))) # 压缩一个数据
zipList=zip(s2,s3) # 两个参数
print(list(zipList))
print(zip(s1, s2, s3))
print(*zip(s1, s2, s3))
# [('a',), ('b',), ('c',)]
# [('你', '你'), ('我', '我'), ('c他', 'c他'), ('peter', '哈哈')]
# <zip object at 0x000001DFEBA31A00>
# ('a', '你', '你') ('b', '我', '我') ('c', 'c他', 'c他')

def printBookInfo():
    '''
    zip 函数的使用
    :return:
    '''
    books=[] #存储所有的图书信息
    id=input('请输入编号: 每个项以空格分隔')  #str
    bookName = input('请输入书名: 每个项以空格分隔') #str
    bookPos = input('请输入位置: 每个项以空格分隔')
    idList=id.split(' ')
    nameList = id.split(' ')
    posList = id.split(' ')

    bookInfo=zip(idList,nameList,posList) #打包处理
    for bookItem in bookInfo:
        '''
        遍历图书信息进行存储
        '''
        dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
        books.append(dictInfo) #将字典对象添加到list容器中
        pass
    for item in books:
        print(item)

printBookInfo()

# 请输入编号: 每个项以空格分隔1 2 3
# 请输入书名: 每个项以空格分隔harrypotter dargenraja thesummer
# 请输入位置: 每个项以空格分隔A1 B2 C3
# {'编号': '1', '书名': '1', '位置': '1'}
# {'编号': '2', '书名': '2', '位置': '2'}
# {'编号': '3', '书名': '3', '位置': '3'}

enumerate 函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，般用在 for循环当中

listObj = ['a','b','c']
for index, item in enumerate(listObj, 5): # 5表示索引开头数字
    print(index, item)
    pass

dicObj = {}
dicObj['name'] = '李易峰'
dicObj['hobby'] = '唱歌'
dicObj['pro'] = '艺术设计'

for item in enumerate(dicObj):
    print(item)

# 5 a
# 6 b
# 7 c
# (0, 'name')
# (1, 'hobby')
# (2, 'pro')

python函数