目录

1 文件

1.1 文件打开和关闭

1.2 文件读操作

1.3 文件写操作

1.4 文件定位读写

1.5 目录操作

2 函数

2.1 函数的作用

2.2 函数的定义和调用

2.2.1 普通函数

2.2.2 带参数函数

2.2.3 带返回值函数

2.2.4 带参数和返回值函数

2.2.5 多个返回值函数

2.2.6 带默认参数的函数

2.2.7 不定长参数的函数

2.2.8 函数概念总结

2.3 局部变量和全局变量

2.4 函数嵌套使用

2.5 递归函数和匿名函数

2.5.1 递归函数

2.5.2 匿名函数

---

1 文件

1.1 文件打开和关闭

# 新建一个文件，文件名为:test.txt
f1= open('test.txt', 'w')
 
# 关闭这个文件
f.close()

文件打开模式:

python中，打开文件，操作完成后必须close()关闭文件，也可以另一种打开文件方式（推荐）：

with open('test.txt', 'w') as f:
    f.read()

1.2 文件读操作

读文件，可以使用read()、readline()、或者readlines()。

• read()可以一次性读取文件中所有的内容，也可以设置read(100)，也就是一次读取100字节内容。读到文件结尾之后，再次调用read()会返回空(’’)字符串
• readline()一次可以读取一行数据。当文件读取结束后，同样也会返回空字符串。我们if not line:判断也会返回False
• readlines()调用的时候读取所有行，并返回单行字符串的列表

# 打开文件
f = open("./index.cpp","r")
 
# 1. 读取文件中所有数据
contents = f.read()
print("文件数据如下:")
 
# 使用strip函数,删除内容中的空行
print(contents.strip())
 
# 2. 指定读取5个字节
contents = f.read(5)
print(contents)
 
# 读取剩下内容
contents = f.read()
print(contents)
 
# 3. 读取一行数据
line = f.readline()
print(line,end="")
line = f.readline()
print(line,end="")
 
# 4. 读取所有行
lines = f.readlines()
for line in lines:
   # 判断当前行是否为空行
   if line.isspace():
       continue
   print(line,end="")
 
# 关闭文件
f.close()

1.3 文件写操作

# 打开文件
f = open("./index.cpp","w")
 
# 1. 写入数据
contents = "hello world!"
f.write(contents)
 
# 关闭文件
f.close()

1.4 文件定位读写

# 打开文件
f = open("./test.txt","rb")
 
# 输出文件当前位置
print(f.tell())
 
# 当我读了两字节之后
f.read(2)
 
# 输出结果为2
print(f.tell())
 
# 将文件位置设置到第5个位置
f.seek(5,0)
print(f.read())
 
# 将文件位置设置到文件倒数三个字符位置
# 在py3中,如果不是以b模式打开文件，只允许从开始位置设置位置
# 不允许从末尾偏移　0-文件头,默认值;1-当前位置;2-文件尾
f.seek(-3,2)
contents = f.read()
print(chr(contents[0]))
print(contents)
 
# 关闭文件
f.close()

1.5 目录操作

通过程序去修改文件的名字、删除文件或文件夹、获得路径下的文件列表等等操作,需要导入模块os.

import os
# 创建文件夹
os.mkdir("myfile")
 
# 删除文件夹
os.rmdir("myfile")
 
# 切换工作目录
os.chdir("/")
 
# 显示目录下所有的文件
print(os.listdir())

2 函数

2.1 函数的作用

函数的作用，就是把常用的功能封装成一个实体，用的时候，直接调用就可以，不需要写重复代码，维护非常容易。

1. 代码块重复，这时候必须考虑用到函数，降低程序的冗余度；

2. 代码块复杂，这时候可以考虑用到函数，提高程序的可读性；

2.2 函数的定义和调用

函数的定义包含三个基本元素：函数名 函数参数 返回值。

函数名是函数的标识；函数参数是函数调用时传递给函数的数据；函数返回值是函数运算完成返回给调用者的数据。

注意：函数中的程序代码不会自动执行，必须手动调用才可以执行.

定义函数的格式如下：

def 函数名():
    要执行的代码

2.2.1 普通函数

# 普通函数
def my_function():
    print("hello python!")
 
# 调用函数
my_function()

2.2.2 带参数函数

# 带参数函数
# a和b为函数参数
def my_function(a, b):
    ret = a + b
    print("ret = %d" % ret)
 
# 1. 从左向右顺序传递参数
my_function(10, 20)
# 2. 指定参数值方式
my_function(a=10, b=20)
# 或者
my_function(b=20, a=10)

2.2.3 带返回值函数

# 带返回值函数
def my_function():
    ret = 10 + 20
    return ret
 
# 调用带返回值函数
ret = my_function()
print("ret = %d" % ret)

2.2.4 带参数和返回值函数

# 带参数和返回值函数
def my_function(a, b):
    ret = a + b
    return ret
 
# 1. 从左向右传递参数方式
ret = my_function(10, 20)
print("ret = %d" % ret)
 
# 2. 指定参数值方式
ret = my_function(a=10, b=20)
# 或者
ret = my_function(b=20, a=10)

2.2.5 多个返回值函数

在python中，我们可以返回多个值。

# 返回多个值函数
def my_function(a, b):
    my_a = a + 10
    my_b = b + 20
    return my_a, my_b
 
# 1. 从左向右传递参数方式
# 保存函数返回的两个结果
aa, bb = my_function(10, 20)
print("a = %d, b = %d" % (aa, bb))
# 2. 指定参数值方式
aa, bb = my_function(a=10, b=20)
# 或者
aa, bb = my_function(b=20, a=10)

2.2.6 带默认参数的函数

我们在定义函数的时候，函数的默认值类型可以是python任意合法类型。

# 返回多个值函数
def my_function(num1=0, num2=0):
    ret = num1 + num2
    return ret
 
# 1. 当不传递参数，使用默认值
result = my_function()
print("result = %d" % result)
 
# 2. 当传递参数,使用传递参数
result = my_function(10)
print("result = %d" % result)
 
result = my_function(10, 20)
print("result = %d" % result)
 
# 3. 也可只指定某个参数
result = my_function(num2=100)
print("result = %d" % result)
 
result = my_function(num1=100, num2=200)
print("result = %d" % result)
 
 
# 注意：错误定义方式
# 某个位置设置了默认值，那么此位置之后的所有参数都必须设置默认值
# def my_function_error(num1=0, num2):
#     ret = num1 + num2
#     return ret

2.2.7 不定长参数的函数

以上在定义带参数函数时,参数的个数都是固定的，例如，函数如果接受2个参数的话，当我们传递多于两个参数，那么就会报错。如何让函数支持不固定个数的参数呢？

我们每一个参数的位置，只可以传递一个值，如果每个位置我们可以传递多个值，就可以实现不定个数的参数传递了。python规定，只要我们给参数名前面加上*，该位置就可存储多个值，示例代码如下：

# 定义不定长参数函数
def my_function(*num):
    my_sum = 0
    for value in num:
        my_sum += value
    return my_sum
 
# 1. 传递0个参数
result = my_function()
print("result = %d" % result)
 
# 2. 传递1个参数
result = my_function(10)
print("result = %d" % result)
 
# 3. 传递2个参数
result = my_function(10, 20)
print("result = %d" % result)
 
# 4. 传递3个参数
result = my_function(10, 20, 30)
print("result = %d" % result)

如果我们想传递键值对的话，上面那种方式就行不通了，例如：

# 定义不定长参数函数
def my_function(*num):
    my_sum = 0
    for value in num:
        my_sum += value
    return my_sum

如果传递的参数是key=value形式

result = my_function(a=10, b=20)

print("result = %d" % result)

报错信息如下：

Traceback (most recent call last):

File "test.py", line 9, in

result = my_function(a=10, b=20)

TypeError: my_function() got an unexpected keyword argument 'a'

如何实现传递键值对的形式呢？我们只需要让参数名前面加上**即可，示例如下:

# 定义不定长参数函数
def my_function(**num):
    for key, value in num.items():
       print("%s = %d" %(key, value))
 
# 如果传递的参数是key=value形式
my_function(a=10, b=20, c=30)

普通参数和不定参数一起使用:

# 函数参数和不定长参数一起使用
def my_function(param1, *param2, **param3):
    print("param1 = %d" %param1)
    print("param2 = ", end="")
    for value in param2:
        print(value, end=" ")
    print("\nparam3 = ", end="")
    for key, value in param3.items():
        print("%s:%s" % (key, value), end=" ")
 
# 调用函数
my_function(10, 20, 30, c=40, d=50, e=60)

普通参数和不定长参数在一起使用要注意：不定长参数须在普通参数 之后，*param参数须在**param之前。

2.2.8 函数概念总结

函数参数:

• 函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据.
• 在函数内部，把参数当做变量使用，进行需要的数据处理.函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递.

形参和实参:

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

形参作用域:

• 形参的作用域(起作用的范围) 只在定义函数的代码块 中，一旦超出该范围再使用该形参名，则使用的是同名的自定义变量.
• 编程中应该尽量避免 函数的形参 和 同文件的变量名同名.

返回值:

• 在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理.返回值是函数完成工作后，最后给调用者的一个结果.
• 在函数中使用 return 关键字可以返回结果.
• 调用函数一方，可以使用变量来接收函数的返回结果.
• 在python中函数可以返回多个结果.

2.3 局部变量和全局变量

• 局部变量，就是在函数内部定义的变量。
• 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响。
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储。
• 函数内部变量定义并且赋值，该变量为局部变量;
• 在函数外部定义的变量，为全局变量；
• 函数内部使用变量名，局部变量名和全局变量名同名，优先使用局部变量;
• 在函数内部如果想要使用全局变量，使用global关键字声明;
• 全局变量在函数内部未声明的情况下，只能使用，不可修改值.

2.4 函数嵌套使用

import random
 
# 玩家姓名
player_name = "John"
# 玩家金钱
player_money = 1000
 
# 显示玩家信息
def show_player():
    print("玩家姓名:%s 玩家余额:%d" % (player_name, player_money))
 
# 输入竞猜数字
def input_guessing_number():
    # 输入的竞猜数字必须(1-5)
    while True:
        guessing_number = input("请输入竞猜数字(1-5):")
        if 1 <= int(guessing_number) <= 5:
            return int(guessing_number)
        else:
            print("您输入有误!")
 
 
# 输入竞猜金额
def input_guessing_money():
    # 输入竞猜金额，必须小于等于账户余额
    while True:
        print("请输入竞猜金额(1-%d):" % player_money, end="")
        guessing_money = input()
        if 0 < int(guessing_money) <= player_money:
            return int(guessing_money)
        else:
            print("账户余额不足以支持本次押注，请重新输入!")
 
 
# 赌博函数
def gamble_start(number, money):
    # 1. 随机产生竞猜数字(1-5)
    random_number = random.randint(1, 5)
    # 2. 判断是否获胜
    print("本轮竞猜数字为:%d, 您押注数字为:%d." % (random_number, number))
    # 声明全局变量
    global player_money
    if int(number) == random_number:
        print("恭喜您，本轮您猜中,获得金钱:%d元!" % money)
        player_money = player_money + money
    else:
        print("很抱歉，本轮您未猜中,损失金钱:%d元!" % money )
        player_money = player_money - money * 2
 
 
# 开始赌博游戏
def my_game():
    # 游戏回合数
    game_round = 1
    # 开始游戏循环
    while player_money > 0:
        # 0. 显示当前回合数
        print("您已经在拉斯维加大战%d回合!" % game_round)
        # 1. 显示玩家信息
        show_player()
        # 2. 输入竞猜数字
        guessing_number = input_guessing_number()
        # 3. 输入竞猜金额
        guessing_money = input_guessing_money()
        # 4. 开始赌博
        gamble_start(guessing_number, guessing_money)
        # 回合数增加1
        game_round += 1
        print("-----------------------")
 
    if player_money < 0:
        print("小子，别走，你还欠我%d元!" % abs(player_money))
    else:
        print("输的裤衩都没了,555555!")
 
# 启动游戏
my_game()

2.5 递归函数和匿名函数

2.5.1 递归函数

如果函数调用的不是其他函数，而是调用自身函数，这个函数就叫做递归函数。

递归函数的调用和普通的函数调用流程一致，唯一不同之处在于递归函数调用的仍然函数本身。

# 编写函数输出1-5的数字
def print_number(val):
    # 退出条件
    if val == 0:
        return
 
    print_number(val - 1)
    print(val)
 
print_number(3)

 练习：

def print_number(val):
    # 退出条件
    if val == 0:
        return 0
 
    ret = val + print_number(val - 1)
    return ret
 
result = print_number(5)
print("result = %d" % result)

2.5.2 匿名函数

Python中函数分为两种，一种是通过def定义的函数，一种是lambda定义的匿名函数。

lambda匿名函数适合定义一些单行语句的函数，可使代码更加简洁优美。但lambda函数局限性很大，通常我们只能定义一条单独的表达式，这个表达式的结果就是返回值。我们在匿名函数中无法使用多行语句、条件分支、异常处理。

我们不适用lambda函数也可以编写python函数完成我们的功能。但lambda有起到函数速写的作用，在仅需要一小段代码程序执行的情况下，可以带来优美简洁的代码结构。

# 匿名函数如何定义
# lambda 参数,参数... : 函数体
 
 
def my_add_function(a, b):
    return a + b
 
# 对于一些短小函数，以上定义稍显复杂
# 是否有更简洁的定义函数方式呢？
my_add_lambda = lambda a, b: a + b
 
# 调用结果
ret1 = my_add_function(10, 20)
ret2 = my_add_lambda(10, 20)
print("ret1 = %d" % ret1)
print("ret2 = %d" % ret2)

匿名函数练习:

students = [["John", 1001], ["Smith", 1006], ["Edward", 1004], ["Obama", 1002]]
print(students)
# 指定key排序
students.sort(key=lambda student: student[1])
print(students)
# 指定key排序
new_students = sorted(students, key=lambda student: student[1])
print(new_students)