函数
三元运算
简单条件语句
val = 1 if 条件成立 else 2
文件处理
文件操作分为读,写,修改:
f = open(file="name.txt", mode="r", encoding='utf-8')
data = f.read()
print(data)
二进制模式,不支持编码,当不知道文件编码类型时,可以使用chardet模块检测编码类型:
f = open(file="name.txt", mode = 'rb')
data = f.read()
f.close()
import chardet
chardet.detect(data)
print(result)
data.decode("GB2313")
写文件,mode w, 写同一文件时,文件会被清空
f = open(file = "test.txt", mode = "w", encoding = "gbk")
f. write("呵呵")
f.close()
f = open(file = "test.txt", mode = "wb")
f. write("呵呵".encode("utf-8"))
f.close()
追加模式
f = open(file = "test.txt", mode = "a", encoding = "gbk")
f. write("呵呵")
f.close()
读写和写读模式的区别
文件常用操作
fileno()
flush()
readable()
readline()
seek()
seekable()
tell()
truncate()
文件修改
write()修改时会覆盖后面的内容
为避免文件过大,一次性读取文件导致内存溢出,可以readline()逐行修改,写入到新的文件中,再os.rename()覆盖源文件
函数
函数是将一组语句的集合通过一个名字(函数名)封装起来,要执行这个函数,只需调用其函数名即可.
def sayhi():
print("Hello World")
# 可以带参数
def calc(x, y):
res = x ** y
return res
print(calc(3,5))
特性
- 减少重复代码
- 是程序变得可扩展
- 易维护
函数参数
- 形参
- 实参
默认参数
def stu_register(name,age, course,country= "CN"):
pass
stu_register("Alex", 22, 'python')
关键参数
指定了参数名就叫关键参数
def stu_register(name,age, course,country= "CN"):
pass
stu_register("alex", course = "python", age= 2)
非固定参数
# 形参出现*号, 传递参数会被打包成元祖
def send_alert(msg, *user): pass
send_alert(msg, "zhangsan", "lisi")
send_alert(msg, *["zhangsan", "lisi"])
# 形参出现**, 传递参数会被打包成未定义的关键参数
def func(name, *args, **kwargs):
print(name, args, kwargs)
func("Alex", 22, "tesla", "500w", addr = "山东", num = 12312412)
返回值
函数外部的代码要获取函数的执行结果,就可以在函数里用return语句返回
局部变量
定义在函数里面的的变量,定义在函数外的叫全局变量
name = "哈士奇"
def change_name():
name = "哈哈明"
print("inner", name)
print("outer", name)
在函数里修改全局变量
name = "哈士奇"
def change_name():
global name
name = "哈哈明"
print("inner", name)
print("outer", name)
嵌套函数
def func1():
print("alex")
def func2():
print('eric')
func1() # func2不会执行,没有调用
python中一个函数就是一个作用域
代码定义完成后,作用域已经生成
匿名函数
使用lambda定义匿名函数,支持三元运算,不支持复杂的逻辑运算
def calc(x, y):
return x*y
func = lambda x,y:x*y
print(func(3,8))
func = lambda x,y: x**y if x<y else x/y
map(lambda x: x**x, list(range(10))
高阶函数
变量可以指向一个函数, 函数的参数能够接受变量,那么一个函数可以接收另外一个函数作为参数,这种函数就称之为高阶函数.
return 返回任意一个函数
def func(x, y):
return x + y
def calc(x):
print(x)
n = func
calc(n)
递归
python默认递归1000层
def calc(n):
n = int(n/2)
print(n)
if n > 0:
calc(n)
print(n)
递归返回值:
def calc(n, count):
if count < 5:
return calc(n/2, count + 1)
else:
return n
练习题:
# 递归练习题
menus = [{
'text': '北京',
'children': [
{'text': '朝阳', 'children': []},
{'text': '昌平', 'children': [
{'text': '沙河', 'children':[]},
{'text': '回龙观', 'children': []}
]}
]
},
{
'text': '上海',
'children': [
{'text': '宝山', 'children': []},
{'text': '金山', 'children': []},
]
}]
# 1. 打印所有节点
# 2. 输入一个节点名字, 沙河, 你要便利,找到了就打印它,并返回true
def print_dic(dic):
for i in dic:
if len(i['children']) != 0:
print_dic(i['children'])
print("%s --> %s" % (i['text'], i['children']))
print_dic(menus)
print("*" * 80)
search = input(">>: ")
def re_true(dic):
for i in dic:
if len(i['children']) != 0:
re_true(i['children'])
if i['text'] == search:
print("%s --> %s" % (i['text'], i['children']))
return True
re_true(menus)
内置函数
abs()
dict()
help()
min()
max()
setattr()
all()
any()
dir()
hex()
next()
slice()
divmod()
id()
object()
sorted()
ascii()
enumerate()
eval()
exec()
input()
int()
open()
str()
isinstance()
ord()
sum()
bytearray()
filter()
issubclass()
pow()
super()
bytes()
float()
iter()
print()
tuple()
callable()
format()
len()
property()
type()
chr()
frozenset()
list()
range()
vars()
classmethod()
getattr()
locals()
repr()
zip()
complie()
globals()
map()
reversed()
__import__()
complex()
hasattr()
max()
round()
delattr()
hash()
memoryview()
set()
bool()
练习
"""
# 修改个人信息程序
文件里存多个人的个人信息, 如以下:
username password age position department
alex abc123 24 Engineer IT
rain df2@432 25 Teacher Teching
1. 输入用户名密码, 正确登录系统,打印
- 修改个人信息
- 打印个人信息
- 修改密码
2. 每个选项写一个方法
3. 登录时, 输错3次退出程序
"""
with open("file.txt", "r") as f:
data = []
for line in f.readlines():
data.append(line.strip().split(" "))
print(data)
def modify(name):
age = input("Age: ")
position = input("Position: ")
department = input("department: ")
for i in data:
if i[0] == name:
i[2] = age
i[3] = position
i[4] = department
def info(name):
user_info = """
用户名: {}
年龄: {}
职位: {}
部门: {}
"""
for i in data:
if i[0] == name:
account = [x for x in i]
del account[1]
print(user_info.format(*account))
def change_password(name):
password = input("Password: ")
for i in data:
if i[0] == name:
i[1] = password
print(data)
def main():
count = 0
while count < 3:
name = input("name:>> ")
password = input("Password:>> ")
if [name, password] in [i[0:2] for i in data]:
print("login")
while True:
login_info = "1. 修改个人信息\n2. 打印个人信息\n3. 修改密码"
print(login_info)
choice = input("Select action:>> ").strip()
if choice.isdigit():
choice = int(choice)
if choice == 1:
modify(name)
elif choice == 2:
info(name)
elif choice == 3:
change_password(name)
else:
print("action not exist")
elif choice == "q":
with open("file.txt", "w") as f:
for line in data:
f.write(" ".join(line) + "\n")
break
else:
print("You must input a number!")
break
count += 1
if __name__ == "__main__":
main()
函数进阶
名称空间
名称空间又交name space,若变量x=1,名称空间正是存放名字x与1绑定关系的地方.
名称空间共三种:
- locals: 是函数内的名称空间,包括局部变量和形参
- globals: 全局变量,函数定义所在魔板的名字空间
- bubuiltins: 内置模板的名字空间
不同的变量的作用域不同就是由这个变量所在的命名空间决定的
作用域即范围:
- 全局范围: 全局存活,全局有效;
- 局部范围: 临时存活, 局部有效;
查看作用域方法globals(),locals()
闭包
关于闭包,即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数).这些内部函数可以访问它们所在的外部函数中声明的所有局部变量,参数.放其中一个这样的内部函数在包含它们外部函数之外被调用时会形成闭包.
def outer():
name = "alex"
def inner():
print("在inner里打印外层函数的变量", name)
return inner
f = outer()
f()
返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,这个函数无论在何处调用,优先使用自己外层包裹的作用域
装饰器
https://www.jianshu.com/p/600db039cd91
装饰器练习题
- 编写3个函数，每个函数执行的时间是不一样的，
提示：可以使用time.sleep(2)，让程序sleep 2s或更多，
- 编写装饰器，为每个函数加上统计运行时间的功能
提示：在函数开始执行时加上start=time.time()就可纪录当前执行的时间戳，函数执行结束后在time.time() - start就可以拿到执行所用时间
- 编写装饰器，为函数加上认证的功能，即要求认证成功后才能执行函数
- 编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
提示：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-3 下午9:41
# @File : 装饰器练习.py
import time
def count_time(func):
def inner(*args, **kwargs):
start_time = time.time()
func()
end_time = time.time()
print("%s wait for %s" % (func, end_time - start_time))
return inner
def login(func):
_name = "fbo"
_password = "123"
def inner(*args, **kwargs):
name = input("Name >>").strip()
password = input("Password >>").strip()
if (name, password) == (_name, _password):
print("auth!!!")
func()
else:
print("Go awaly!")
return inner
login_status = False
def global_login(func):
with open("password", "r") as f:
data = f.read()
auth = eval(data)
def inner(*args, **kwargs):
global login_status
if not login_status:
name = input("Name >>").strip()
password = input("Password >>").strip()
if name == auth["name"] and password == auth["password"]:
login_status = True
if login_status:
func(*args, **kwargs)
return inner
@login
@count_time
def func1():
time.sleep(1)
@global_login
def func2(name):
time.sleep(2)
print(name, "is foolish man!")
@global_login
def func3():
time.sleep(3)
func1()
func2("alex")
print(login_status)
func3()
生成式&迭代器
列表生成式
[i + 1 if i < 5 else i *i for i in range(10)]
生成器
通过列表生成式, 我们可以直接创建一个列表.但是,收到内存的限制,列表容量肯定是有限的.而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们只访问前面几个元素,那后面绝大多数元素占用的空间都浪费了.
在python中,这种一边循环一边计算的机制,称之为generator;
要创建一个generator很简单,第一种方法,只需要将列表生成式的[]改成();
如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值,计算出最后一个元素,没有更多元素时会抛出StopIteration的错误;
generator是可迭代对象,可以使用for循环;
# 斐波拉契数列
def fib(max):
a, b, n = 0, 1, 0
while n < max:
print(b)
a, b = b, a+b
n += 1
fib(10)
# 生成器版
def fib(max):
a, b, n = 0, 1, 0
while n < max:
yield b
a, b = b, a+b
n += 1
f10 = fib(10)
print(f10)
print(next(f10))
print(next(f10))
print(next(f10))
print(next(f10))
print(next(f10))
print(next(f10))
print(next(f10))
print(next(f10))
for i in f10:
print(i)
在变成gennerator函数,没吃调用next()的时候执行,遇到yield语句返回,再次被next()调用时从上次返回的yield语句处继续执行
用for循环调用generator时,无法拿到generator的return语句的返回值. 如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-4 下午5:10
# @File : generator_return.py
def fib(max):
a, b, n = 0, 1, 0
while n < max:
yield b
a, b = b, a + b
n += 1
return "done"
g = fib(6)
while True:
try:
x = next(g)
print(x)
except StopIteration as e:
print("The return value is", e.value)
break
可以通过yield实现单线程的情况下实现并发运算的效果
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-4 下午5:17
# @File : producer_consumer.py
import time
def consumer(name):
print("%s 来吃包子了", name)
while True:
baozi = yield
print("包子%s来了,被%s吃了" % (baozi, name))
def producer(name):
c1 = consumer("A")
c2 = consumer("B")
c1.__next__()
c2.__next__()
print(name, "准备做包子了．．．")
for i in range(10):
time.sleep(1)
print("做了两个包子")
c1.send(i)
c2.send(i)
producer("fbo")
迭代器
- 可以直接作用
for循环的对象统称为可迭代对象'Iterable', 使用isinstance()判断一个对象是否是Iterable; - 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
- 凡是可作用于for循环的对象都是Iterable类型；
- 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
- 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
练习题
文件处理相关
- 编码问题
请说明python2 与python3中的默认编码是什么？
python2中默认使用ASCII编码,python3中默认编码是utf8
为什么会出现中文乱码？你能列举出现乱码的情况有哪几种？
sys.stdout.encoding, 默认就是locale编码,print会使用sys.stdout.encoding去encode()成字节流,交给terminal显示.所以locale需要terminal一致,才能正确的print打印中文; sys.setdefaultencoding('utf8'),用于指定str.encode() str.decode()的默认编码,默认是ascii;
如何进行编码转换？
字符串在python内部默认是采用unicode编码方式,所以其他语言先decode转换成unicode编码,再encode转换成utf8编码
解释py2 bytes vs py3 bytes的区别
python2 将strings处理为原生的byte类型,而不是unicode;
python3 中所有的strings都是unicode类型
- 文件处理
r和rb的区别是什么?
r 读模式, rb 二进制读模式
解释一下以下三个参数的分别作用?
open(f_name,'r',encoding="utf-8")
f_name 文件路径
'r' 模式
encoding='utf-8' 编码方式
函数基础
写函数, 计算传入数字的和.(动态传参)
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-4 下午10:10
# @File : sum_number.py
def sum_number(a, b):
return a + b
print(sum_number(1, 11))
写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-4 下午10:14
# @File : func_2.py
def mod_file(file_name, old, new):
f = open(file_name, "r")
data = f.read()
data = data.replace(old, new)
f.close()
f = open(file_name, "w")
f.write(data)
f.close()
mod_file("password", "123", "456")
写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-4 下午10:21
# @File : func_3.py
def func3(object):
if not all(object):
print(object,"含有空元素")
func3(["", 1, 2, 3])
func3({"":"dfas",})
写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def check_dic(dic):
for k, v in dic.items():
if len(v) > 2:
dic[k] = v[0:2]
check_dic(dic)
print(dic)
解释闭包的概念
闭包(closeuer)是函数式编程重要的语法结构. 函数式编程是一种范式;
在面向过程中,我们见过函数(function);在面向过程中,我们见过(object).函数和对象根本目的是以某种逻辑方式组织代码,并提高代码的可重复使用性(reusability);
闭包也是一种组织代码的结构,它提高了代码的可重复使用性.
函数进阶
写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组;例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃A’)]
def poker():
poker_list = []
for i in ["红桃", "黑桃", "梅花", "方块"]:
for j in [2, 3, 4, 5, 7, 8, 9, 10, "J", "Q", "K", "A"]:
poker_list.append((i, j))
return poker_list
写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
def max_min(*args):
rt = {}
rt["min"] = min(args)
rt["max"] = max(args)
return rt
print(max_min(1, 2, 3, 4))
写函数，专门计算图形的面积
- 其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
- 调用函数area(‘圆形’,圆半径) 返回圆的面积
- 调用函数area(‘正方形’,边长) 返回正方形的面积
- 调用函数area(‘长方形’,长，宽) 返回长方形的面积
def area(*args):
def rectangle(*args):
print(args)
rt = args[0] * args[1]
return rt
def square(*args):
return args[0] ** 2
def circle(*args):
import math
rt = math.pi * (args[0] ** 2)
return rt
if args[0] == "长方形":
inner_args = list(args[1:])
print(rectangle(*inner_args))
elif args[0] == "正方形":
print(square(*list(args[1:])))
elif args[0] == "圆形":
print(circle(*list(args[1:])))
else:
print("Something not right!")
area("长方形", 10, 2)
area("正方形", 10)
area("圆形", 10)
写函数，传入一个参数n，返回n的阶乘
def calc(n):
rt = 1
while n > 0:
rt *= n
n -= 1
return rt
print(calc(4))
def calc1(n):
if n > 1:
rt = n * calc1(n - 1)
return rt
else:
return 1
print(calc1(100))
编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-5 上午10:44
# @File : func_advance5.py
login_status = False
def login(func):
def inner(*args, **kwargs):
global login_status
with open("user_list", "r") as f:
user_list = [i.strip().split(",") for i in f.readlines()]
# print(user_list)
if not login_status:
while True:
user = input("Name>>> ").strip()
password = input("password>>>").strip()
if [user, password] in user_list:
login_status = True
break
else:
print("Retry!!!")
if login_status:
return func(*args, **kwargs)
return inner
@login
def func1():
print("func1")
@login
def func2():
print("func2")
func1()
func2()
生成器和迭代器
- 生成器和迭代器的区别？
对于list、string、tuple、dict等这些容器对象,使用for循环遍历是很方便的。
在后台for语句对容器对象调用iter()函数。iter()是python内置函数。
iter()函数会返回一个定义了 next()方法的迭代器对象，它在容器中逐个访问容器内的
元素。next()也是python内置函数。在没有后续元素时，next()会抛出
一个StopIteration异常，通知for语句循环结束。
迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的
时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数
的时候，调用的就是迭代器对象的next方法（Python3中是对象的next方法，
Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，
就要实现它的next方法。但这还不够，python要求迭代器本身也是可迭代的，
所以我们还要为迭代器实现iter方法，而iter方法要返回一个迭代器，
迭代器自身正是一个迭代器，所以迭代器的iter方法返回自身self即可。
- 生成器有几种方式获取value？
两种方式获取：
for 循环
next 获取
- 通过生成器写一个日志调用方法， 支持以下功能
- 根据指令向屏幕输出日志
- 根据指令向文件输出日志
- 根据指令同时向文件&屏幕输出日志
- 以上日志格式如下
2017-10-19 22:07:38 [1] test log db backup 3 2017-10-19 22:07:40 [2] user alex login success #注意：其中[1],[2]是指自日志方法第几次调用，每调用一次输出一条日志 - 代码结构如下
def logger(filename,channel='file'): """ 日志方法 :param filename: log filename :param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both) :return: """ ...your code... #调用 log_obj = logger(filename="web.log",channel='both') log_obj.__next__() log_obj.send('user alex login success')
答案:
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-5 上午11:26
# @File : generator1.py
import datetime
def logger(filename, channel='file'):
"""
日志方法
:param filename: log filename
:param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both)
:return:
"""
count = 1
while True:
s = yield
s = "%s [%s] %s" % (str(datetime.datetime.today()), str(count), s)
if channel == "terminal" or channel == "both":
print(s)
if channel == "file" or channel == "both":
with open(filename, "a") as f:
f.write(s + "\n")
count += 1
# 调用
log_obj = logger(filename="web.log", channel='both')
log_obj.__next__()
log_obj.send('user alex login success')
log_obj.send('user fbo login success')
内置函数
- 用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao','nezha']
new_name = list(map(lambda x: x + "_sb", name))
print(new_name)
- 用filter函数处理数字列表，将列表中所有的偶数筛选出来
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-5 上午11:57
# @File : builtin2.py
num = [1,3,5,6,7,8]
def check(x):
if x % 2 == 0:
return True
else:
return False
for i in filter(check, num):
print(i)
- 如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
- 计算购买每支股票的总价
- 用filter过滤出，单价大于100的股票有哪些
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
def total(l):
sum_list = list()
temp = dict()
for i in portfolio:
temp["name"] = i["name"]
temp["sum"] = i["shares"] * i["price"]
sum_list.append(temp)
print(sum_list)
total(portfolio)
rt = filter(lambda x: x["price"] >= 100, portfolio)
print(list(rt))
| 模式 | 含义 |
|---|---|
| r | 文本只读模式 |
| rb | 二进制模式,这种方法是用来传输或存储,不给别人看的 |
| r+ | 读写模式,只要有r, name文件必须存在 |
| rb+ | 二进制读写模式 |
| w | 只写模式, 不能读, 用w模式打开一个已经存在的文件,如果有内容会重写 |
| wb | 以二进制方式打开,只能写文件,如果不存在,则创建 |
| w+ | 读写模式,先读后写,只要有w,就会清空原来的文件内容 |
| wb+ | 二进制读写模式 |
| a | 追加模式,也能写,在文件的末尾添加内容 |
| ab | 二进制追加模式 |
| a+ | 追加模式,如果文件不存在,则创建文件,如果存在,在末尾追加 |
| ab+ | 追读二进制模式,从文件顶部读取,从文件底部追加内容,不存在则创建 |
请分别介绍文件操作中不同的打开方式之间的区别：
| 模式 | 含义 |
|---|---|
| r | 文本只读模式 |
| rb | 二进制模式,这种方法是用来传输或存储,不给别人看的 |
| r+ | 读写模式,只要有r, name文件必须存在 |
| rb+ | 二进制读写模式 |
| w | 只写模式, 不能读, 用w模式打开一个已经存在的文件,如果有内容会重写 |
| wb | 以二进制方式打开,只能写文件,如果不存在,则创建 |
| w+ | 读写模式,先读后写,只要有w,就会清空原来的文件内容 |
| wb+ | 二进制读写模式 |
| a | 追加模式,也能写,在文件的末尾添加内容 |
| ab | 二进制追加模式 |
| a+ | 追加模式,如果文件不存在,则创建文件,如果存在,在末尾追加 |
| ab+ | 追读二进制模式,从文件顶部读取,从文件底部追加内容,不存在则创建 |
-
有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 请将以字母“a”开头的元素的首字母改为大写字母；
[i.title() if i.startswith("a") else i for i in li] -
有如下程序, 请给出两次调用show_num函数的执行结果，并说明为什么：
num = 20
def show_num(x=num):
print(x)
show_num() # 20
num = 30
show_num() # 30
- 有名为poetry.txt的文件，其内容如下，请删除第三行；
昔人已乘黄鹤去，此地空余黄鹤楼。
黄鹤一去不复返，白云千载空悠悠。
晴川历历汉阳树，芳草萋萋鹦鹉洲。
日暮乡关何处是？烟波江上使人愁。
with open("poetry.txt", "r") as f:
data = f.read()
data = data.split("\n")
del data[2]
with open("poetry.txt", "w") as f:
for i in data:
if data.index(i) == len(data) - 1:
f.write(i)
else:
f.write(i + "\n")
- 有名为username.txt的文件，其内容格式如下，写一个程序，判断该文件中是否存在"alex", 如果没有，则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在；
pizza
alex
egon
with open("username.txt", "r+") as f:
data = f.read()
if not "alex" in data:
f.write("\nalex")
- 有名为user_info.txt的文件，其内容格式如下，写一个程序，删除id为100003的行；
pizza,100001
alex,100002
egon,100003
with open("user_info.txt") as f:
data = [i.strip().split(",") for i in f.readlines()]
with open("user_info.txt", "w") as f:
for i in data:
if i[1] != "100002":
f.write(",".join(i) + "\n")
- 有名为user_info.txt的文件，其内容格式如下，写一个程序，将id为100002的用户名修改为alex li；
with open("user_info.txt") as f:
data = [i.strip().split(",") for i in f.readlines()]
with open("user_info.txt", "w") as f:
for i in data:
if i[1] == "100002":
i[0] = "alex li"
f.write(",".join(i) + "\n")
- 写一个计算每个程序执行时间的装饰器；
import time
def count_time(func):
def warpper(*args, **kwargs):
start_time = time.time()
func(*args, **kwargs)
end_time = time.time()
print("waste", end_time - start_time)
return warpper
@count_time
def func1(name):
time.sleep(3)
print("haha -> ", name)
func1("fbo")
- lambada是什么?在什么场景下使用lambada?
lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数
好处：
1.lambda函数比较轻便，即用即扔，适合完成只在一处使用的简单功能
2.匿名函数，一般用来给filter，map这样的函数式编程服务
3.作为回调函数，传递给某些应用，比如消息处理
- 题目：写一个摇骰子游戏，要求用户压大小，赔率一赔一。
- 要求：三个骰子，摇大小，每次打印摇骰子数。
import random
count = 0
while count < 3:
choice = input("请选择大小＞＞＞").strip()
rt = [random.randint(1, 6) for i in range(3)]
if sum(rt) > 9:
check = "大"
else:
check = "小"
if choice == check:
print("You got it!")
else:
print("Loser!!!")
count += 1
作业
现要求你写一个简单的员工信息增删改查程序，需求如下：
staff.png
当然此表你在文件存储时可以这样表示:
1,Alex Li,22,13651054608,IT,2013-04-01
2,Jack Wang,28,13451024608,HR,2015-01-07
3,Rain Wang,21,13451054608,IT,2017-04-01
4,Mack Qiao,44,15653354208,Sales,2016-02-01
5,Rachel Chen,23,13351024606,IT,2013-03-16
6,Eric Liu,19,18531054602,Marketing,2012-12-01
7,Chao Zhang,21,13235324334,Administration,2011-08-08
8,Kevin Chen,22,13151054603,Sales,2013-04-01
9,Shit Wen,20,13351024602,IT,2017-07-03
10,Shanshan Du,26,13698424612,Operation,2017-07-02
- 可进行模糊查询，语法至少支持下面3种查询语法:
find name,age from staff_table where age > 22
find * from staff_table where dept = "IT"
find * from staff_table where enroll_date like "2013"
- 可创建新员工纪录，以phone做唯一键(即不允许表里有手机号重复的情况)，staff_id需自增
语法: add staff_table Alex Li,25,134435344,IT,2015-10-29
- 可删除指定员工信息纪录，输入员工id，即可删除
语法: del from staff where id=3
- 可修改员工信息，语法如下:
UPDATE staff_table SET dept="Market" WHERE dept = "IT" 把所有dept=IT的纪录的dept改成Market
UPDATE staff_table SET age=25 WHERE name = "Alex Li" 把name=Alex Li的纪录的年龄改成25
- 以上每条语名执行完毕后，要显示这条语句影响了多少条纪录。 比如查询语句 就显示 查询出了多少条、修改语句就显示修改了多少条等。
注意：以上需求，要充分使用函数，请尽你的最大限度来减少重复代码！
网友评论