目录
1 文件
1.1 文件打开和关闭
# 新建一个文件，文件名为:test.txt
f1= open('test.txt', 'w')
# 关闭这个文件
f.close()文件打开模式:
| 访问模式 | 说明 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
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.
| 函数名 | 描述 |
| os.mkdir(dirname) | 创建文件夹 |
| os.getcwd() | 获得当前工作目录 |
| os.chdir(“./”) | 改变至指定工作目录 |
| os.listdir(“./”) | 获得指定目录下文件列表 |
| os.rmdir(“./”) | 删除指定目录 |
| os.rename(oldname,newname) | 更改文件名 |
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 ret2.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)
591
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
