函数初识

一. 文件操作知识回顾

文件操作的流程：
1. 打开文件，创建文件句柄
2. 对文件句柄进行操作
3. 关闭文件句柄

读
r r+ rb r+b
读取方法：
read()  全部读取
read(n) 读取一部分
    r 模式：n代表n个字符
    b 模式：n代表n个字节
readline()  按行读取
readlines()  返回列表，列表中的每个元素是文件的每一行
for 循环

写
w w+ wb w+b
如果没有文件，创建文件写入内容
如果有文件，清空内容，写入新内容

追加
a a+ ab a+b
如果没有文件，创建文件写入内容
如果有文件，在文件的最后追加新内容

带 b 的模式：
操作的非文本类的文件

其他操作方法：
    readable()
    writable()
    seek()
    tell()
    flush()
    truncate()

文件操作的改：
    都是以新旧文件的操作来改文件
    1. 以读模式打开原文件，产生文件句柄f1
    2. 以写模式打开新文件，产生文件句柄f2
    3. 读取原文件内容，修改成新内容后写入新文件
    4. 删除原文件
    5. 将新文件重命名为原文件名

二. 函数

# 面向过程编程：
# 1. 代码重复性多
# 2. 代码的可读性差

l = [1, 2, 3, 4]
count = 0
for i in l:
    count += 1
print(count)

# 函数式编程

# 函数：
# 一个函数封装一个功能

def my_len():
    count = 0
    for i in l1:
        count += 1
    print(count)

my_len()

# 探探

print("打开探探")
print("附件的人")
print("左滑一下")
print("右滑一下")
print("锁定目标，联系")
print("相约...")

# 上面重复代码较多，可以整合到一个函数中

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")


date()  # 调用函数，只有这步才能执行上面的函数

# 要调用几次，就写几个 date()

# return 用法

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return
    print("锁定目标，联系")
    print("相约...")


date()
print(666)

# 1. 函数中遇到 return 直接结束
# 2. 给函数的执行者(调用者,即 date())返回值
# 单独的return返回None

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return

date()


# return 单个值就返回单个值
def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return "前凸后翘的美女"


ret = date()
print(ret)   # 前凸后翘的美女

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return [1, 2, 3]


ret = date()
print(ret)  # [1, 2, 3]

# return 多个值，返回一个元组

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return "金刚芭比", "洛天依", "天海翼"


ret = date()
print(ret)  # ('金刚芭比', '洛天依', '天海翼')

def date():
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")
    return "金刚芭比", "洛天依", "天海翼"


wangzi, yongge, wang = date()
print(wangzi)  # 金刚芭比
print(yongge)  # 洛天依
print(wang)    # 天海翼

# 函数的参数

def date(a, b): # 函数的定义：形参
    print(a, b)
    print("打开探探")
    print("附件的人")
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")


x = 2
y = 3
date(x, y)  # 函数的执行者：实参

# 实参
# 位置参数:必须与形参角度的位置从左到右一一对应，否则会报错

def date(sex, position):
    print("打开探探")
    print("%s附件的%s" %(position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")

date("女性", "深圳")

# 打开探探
# 深圳附件的女性
# 左滑一下
# 右滑一下
# 锁定目标，联系
# 相约...

# 写一个函数，完成一个功能：给函数传入两个数字对象，将大的数字返回给函数的调用者

def larger_number(a, b):
    if a > b:
        return a
    else:
        return b

s = larger_number(100, 102)
print(s)  # 102

if a > b:
    return a
else:
    return b

# 这种简单的搭配可以用三元运算符

ret = 666 if 3 > 2 else 777
print(ret)

# 所以上面的条件判断可以写成

ret = a if a > b else b

def larger_number(a, b):
    if a > b:
        return a
    else:
        return b

s = larger_number(100, 102)
print(s)

# 上面可以简写成：

def larger_number(a, b):
    ret = a if a > b else b
    return ret


larger_number(100, 101)

# 还可以简写成

def larger_number(a, b): return a if a > b else b


ret = larger_number(100, 102)
print(ret)

# 关键字参数
# 必须一一对应，可以不按顺序

def date(sex, position, soft):
    print("打开手机")
    print("打开%s软件，搜索%s附件的%s" %(soft, position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")

date(soft="微信", sex="girl", position="深圳南山区")

# 打开手机
# 打开微信软件，搜索深圳南山区附件的girl
# 左滑一下
# 右滑一下
# 锁定目标，联系
# 相约...

# 混合参数——既有位置参数，又有关键字参数

def date(meet_place, sex, position, soft):
    print("打开手机")
    print("打开%s软件，搜索%s附件的%s" % (soft, position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约%s" % meet_place)

# 位置参数必须在关键字参数前面
date("酒吧", soft="微信", sex="girl", position="深圳南山区")

# 打开手机
# 打开微信软件，搜索深圳南山区附件的girl
# 左滑一下
# 右滑一下
# 锁定目标，联系
# 相约酒吧

实参角度：
1. 位置参数——从左到右一一对应
2. 关键字参数——一一对应，可以不按顺序
3. 混合参数——位置参数一定要在关键字参数前面

# 形参角度：
# 1. 位置参数——与实参角度的位置参数一样，要从左到右一一对应

def date(sex, position):
    print("打开探探")
    print("%s附件的%s" %(position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约...")


date("女性", "深圳")

# 2. 默认参数——给形参设置默认值，通常是常用的数值，可改可不改
# 注意：默认参数一定要在位置参数后面

# 示例一
def date(meet_place, position, soft, sex="girl"):
    print("打开手机")
    print("打开%s软件，搜索%s附件的%s" % (soft, position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约%s" % meet_place)


date("酒吧", soft="微信", position="深圳南山区")

# 示例二
def date(meet_place, position, soft, sex="girl"):
    print("打开手机")
    print("打开%s软件，搜索%s附件的%s" % (soft, position, sex))
    print("左滑一下")
    print("右滑一下")
    print("锁定目标，联系")
    print("相约%s" % meet_place)


date("酒吧", soft="微信", position="深圳南山区", sex="lady_boy")  # 注意这里默认参数可以改变

# 打开手机
# 打开微信软件，搜索深圳南山区附件的lady_boy
# 左滑一下
# 右滑一下
# 锁定目标，联系
# 相约酒吧

# 默认参数的陷阱
# 默认参数指向的是一个容器型数据类型，那么这个数据永远是同一个(内存地址)

def func1(a, l1=[]):
     l1.append(a)
     return l1

print(func1(666))  # [666]
print(func1(22))   # [666, 22]
print(func1(33, []))  # [33]
# 第三次主动传入了一个空列表

def extendList(val, list=[]):
    list.append(val)
    return list

list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')

print('list1=%s' % list1)
print('list2=%s' % list2)
print('list3=%s' % list3)

# list1=[10, 'a']
# list2=[123]
# list3=[10, 'a']
# 这里注意先是全部执行了 print 前面的内容再打印结果的，注意与下面的区别

def extendList(val, list=[]):
    list.append(val)
    return list

list1 = extendList(10)
print('list1=%s' % list1)
list2 = extendList(123, [])
print('list2=%s' % list2)
list3 = extendList('a')
print('list3=%s' % list3)

# list1=[10]       # 有了print阻断了三者都运行的顺序，这里只添加了10
# list2=[123]      # 说明新传进一个空列表在内存中指向另一个地址
# list3=[10, 'a']  # 说明10和"a"指向内存中同一个地址

# 万能参数
# 两个形参参数，接收所有的位置参数和关键字参数
# 又称动态参数、不定长传参，就是你需要传给函数的参数很多，不定个数时，就用*args，**kwargs接收
# args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

def date(*args, **kwargs):
    print(args)
    print(kwargs)

date("深圳南山区", "18-30", "23", 13, position="深圳南山区", sex="lady_boy")

# ('深圳南山区', '18-30', '23', 13)
# {'position': '深圳南山区', 'sex': 'lady_boy'}

形参角度：
# 1. 位置参数——从左到右，一一对应
# 2. 默认参数，放在位置参数后面
# 3. 万能参数：接受实参角度所有的位置参数，关键字参数。