函数—函数进阶—作业需求

                                    函数—函数进阶—作业需求

 1 '''
 2 1、编码问题
 3   请说明python2 与python3中的默认编码是什么？
 4       python2：ASCII
 5       python3：UTF—8
 6   为什么会出现中文乱码？你能列举出现乱码的情况有哪几种？
 7       存到硬盘上时是以何种编码存的，再从硬盘上读出来时，就必须以何种编码读，不然就会出现中文乱码。
 8       终端为UTF-8，locale为zh_CN.GBK
 9       终端为UTF-8，locale为zh_CN.UTF-8
10       终端为GBK，locale为zh_CN.GBK
11       终端为GBK，locale为zh_CN.UTF-8
12   如何进行编码转换？
13       UTF-8 --> decode 解码 --> Unicode
14       Unicode --> encode 编码 --> GBK / UTF-8
15   #-*-coding:utf-8-*- 的作用是什么？
16        声明编码为：utf_8
17   解释py2 bytes vs py3 bytes的区别
18        python2   str == bytes
19        python3 中需要通过 unicode
20            string -> encode  -> bytes
21            bytes -> decode  -> string
22 
23 2、文件处理
24    r和rb的区别是什么？
25         r 为 读模式
26         rb 为 二进制读模式
27    解释一下以下三个参数的分别作用，open(f_name,'r',encoding="utf-8")
28         f_name   文件名
29         r      模式
30         encoding  编码方式
31 '''

3、函数基础

• 写函数，计算传入数字参数的和。（动态传参）

  1 def sum(x,y):
  2      sum = x + y
  3      print(sum)
  4 sum(2,3)
  5 
  6 lambda x,y : x+y

• 写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作。

   1 def func():
   2      name = input("要修改的文件名：")
   3      content = input("要修改的内容：")
   4      content1 = input("修改后的内容：")
   5      new_name = name+'.new'
   6 
   7      import os         #加载模块
   8      f = open(name,mode = 'r')       #打开要修改的文件
   9      f_new = open(new_name,mode = 'w')      #打开修改后写入的文件
  10 
  11      for i in f:                    #循环文件中每一行的的数据
  12           if content in i:
  13                new_i = i.replace(content,content1)       #将要修改的内容字符串用replace替换
  14           else:
  15                new_i = i
  16           f_new.write(new_i)
  17      f.close()       #关闭要修改的文件
  18      f_new.close()   #关闭修改后写入的文件
  19      os.rename(new_name,name)      #将写入修改后内容的文件改名为修改的文件名，这样就相当于修改了原来的文件
  20 func()

• 写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

  1 def func(*file):
  2      n = 0
  3      for i in file:
  4           if i == ' ':
  5                n += 1
  6      print("含有%s个空行"%n)
  7 func(*[1,' ',2])

• 写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

  dic = {"k1": "v1v1", "k2": [11,22,33,44]}
  PS:字典中的value只能是字符串或列表

  1 dic = {"k1": "v1v1", "k2": [11,22,33,44]}
  2 def func(dic):
  3      for i in dic:
  4           if len(dic[i]) > 2:
  5                dic[i] = dic[i][:2]
  6      return dic
  7 f = func(dic)
  8 print(f)

• 解释闭包的概念。

   1 闭包：即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。
   2 这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。
   3 当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。
   4 也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。
   5 这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响
   6 
   7 例：
   8 def func():
   9     n = 10
  10 
  11     def func2():
  12         print("func2:",n)
  13     return func2    #返回func2的内存地址
  14 
  15 f = func()
  16 print(f)         #结果为：<function func.<locals>.func2 at 0x000002F1B9F59730>
  17 f()              #结果为：func2: 10
  18 
  19 #按常理来讲，执行完func()函数后，func2()已经释放了，但是它返回了   func2: 10
  20 #在外部拿到了内部的函数，并且还可以使用内部函数的作用域里面的值
  21 
  22 #闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

4、函数进阶

• 写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组，例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃A’)]

   1 def func():
   2      num = []
   3      for i in range(2,11):
   4           num.append(i)
   5      num.extend(['J','Q','K','A'])
   6      data = ['红心','草花','方块','黑桃']
   7      num1 = []
   8      for i in num:
   9           for j in data:
  10                num1.append((j,i))
  11      return num1
  12 f = func()
  13 print(f)

• 写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}。例如:min_max(2,5,7,8,4)，返回:{‘max’:8,’min’:2}

   1 def min_max(*args):
   2      max = args[0]
   3      min = args[0]
   4      for i in args:
   5           if i > max:
   6                max = i
   7           elif i < min:
   8                min = i
   9      return {'max': max , 'min': min}
  10 print(min_max(3,2,6,8,15,17,-9,38,5))

• 写函数，专门计算图形的面积

   1 # 其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
   2 # 调用函数area(‘圆形’,圆半径) 返回圆的面积
   3 # 调用函数area(‘正方形’,边长) 返回正方形的面积
   4 # 调用函数area(‘长方形’,长，宽) 返回长方形的面积
   5 # def area():
   6 #    def 计算长方形面积():
   7 #          pass
   8 #
   9 #    def 计算正方形面积():
  10 #          pass
  11 #
  12 #    def 计算圆形面积():
  13 #         pass
  14 def area():
  15      def rectangle(x,y):
  16           print(x*y)
  17      def square(s):
  18           print(s*s)
  19      def circle(r):
  20           print(3.14*r*r)
  21 
  22      name = input('请输入图形名称：')
  23      if name == '长方形':
  24           x = int(input('请输入长方形的长：'))
  25           y = int(input('请输入长方形的宽：'))
  26           rectangle(x,y)
  27      elif name == '正方形':
  28           s = int(input('请输入正方形的边长：'))
  29           square(s)
  30      elif name == '圆形':
  31           r = int(input('请输入圆的半径：'))
  32           circle(r)
  33 print(area())

• 写函数，传入一个参数n，返回n的阶乘。

  1 def func2(n):
  2      res = 1
  3      for i in range(n,0,-1):
  4           res = res * i
  5      return  res
  6 print(func2(5))

•  编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码。

   1 user_status = False  # 用户登录了，就把这个改成True
   2 def login(auth_type):
   3      def iner():
   4           global user_status
   5           if user_status == False:
   6                username = input("user:")
   7                password = input("password:")
   8 
   9                f = open('data.txt','r')
  10                da = eval(f.read())
  11                if username in da:
  12                     if password == da[username]:
  13                          user_status = True
  14           if user_status == True:
  15                auth_type()
  16      return iner
  17 
  18 @login
  19 def func():
  20     print('---func---')
  21 @login
  22 def func1():
  23     print('----func1----')
  24 @login
  25 def func2():
  26     print('-----func2----')
  27 
  28 @login
  29 def func3():
  30      print('-----func3----')
  31 
  32 func()
  33 func3()

5、生成器和迭代器

• 生成器和迭代器的区别？

  1     对于list、string、tuple、dict等这些容器对象,使用for循环遍历是很方便的。在后台for语句对容器对象调用iter()函数。iter()是python内置函数。 
  2     iter()函数会返回一个定义了next()方法的迭代器对象，它在容器中逐个访问容器内的元素。next()也是python内置函数。在没有后续元素时，next()会抛出一个StopIteration异常，通知for语句循环结束。
  3     迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的_next_方法（Python3中是对象的_next_方法，    Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的_next_方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现_iter_方法，而_iter_方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的_iter_方法返回自身self即可。
  4 
  5 
  6    生成器是一种特殊的迭代器，生成器自动实现了“迭代器协议”（即__iter__和next方法），不需要再手动实现两方法。
  7    生成器在迭代的过程中可以改变当前迭代值，而修改普通迭代器的当前迭代值往往会发生异常，影响程序的执行。

• 生成器有几种方式获取value？

  1 三种方式获取：
  2    while        会报错
  3    for  循环
  4    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]是指自日志方法第几次调用，每调用一次输出一条日志

 1 def logger(filename,channel='file'):
 2 """
 3 日志方法
 4 :param filename: log filename
 5 :param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both)
 6 :return:
 7 """
 8 ...your code...
 9 
10 #调用
11 log_obj = logger(filename="web.log",channel='both')
12 log_obj.__next__()
13 log_obj.send('user alex login success')

6、内置函数

• 用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb

   1 #map  它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。map()函数在不改变原有的lisy，而是返回一个新的list
   2 print(map(lambda x: x*x , [1,2,3,4,5]))         #结果为：<map object at 0x0000022DB38384A8>
   3 print(list(map(lambda x: x*x , [1,2,3,4,5])))   #结果为：[1, 4, 9, 16, 25]
   4 
   5 #解答：
   6 name=['alex','wupeiqi','yuanhao','nezha']
   7 def func(x):
   8     return x + '_sb'
   9 res = map(func,name)
  10 print(list(res))

• 用filter函数处理数字列表，将列表中所有的偶数筛选出来

   1 #filter
   2 print(filter(lambda x: x>3 , [1,2,3,4,5]))         #结果为：<filter object at 0x000002B9B1CC84E0>
   3 print(list(filter(lambda x: x>3 , [1,2,3,4,5])))   #结果为：[4, 5]
   4 
   5 #解答
   6 num = [1,3,5,6,7,8]
   7 def func(x):
   8     if x%2 == 0:
   9         return x
  10 res = filter(func,num)
  11 print(list(res))

• 如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格

  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}
  ]

  1 #计算购买每支股票的总价
  2 for i in portfolio:
  3     print(i['name'],i['shares']*i['price'])
  4 #或者
  5 print([(item['name'],item['shares']*item['price']) for item in portfolio])

   1 #用filter过滤出，单价大于100的股票有哪些
   2 portfolio = [
   3     {'name': 'IBM', 'shares': 100, 'price': 91.1},
   4     {'name': 'AAPL', 'shares': 50, 'price': 543.22},
   5     {'name': 'FB', 'shares': 200, 'price': 21.09},
   6     {'name': 'HPQ', 'shares': 35, 'price': 31.75},
   7     {'name': 'YHOO', 'shares': 45, 'price': 16.35},
   8     {'name': 'ACME', 'shares': 75, 'price': 115.65}
   9 ]
  10 print(list(filter(lambda i:i['price'] >100,portfolio)))

7、请分别介绍文件操作中不同的打开方式之间的区别：

 1 模式       含义
 2 r          文本只读模式
 3 rb         二进制模式，这种方法是用来传输或存储，不给人看的
 4 r+         读写模式，只要有r，那么文件必须存在
 5 rb+        二进制读写模式
 6 w          只写模式，不能读，用w模式打开一个已经存在的文件，如果有内容会清空，重新写
 7 wb         以二进制方式打开，只能写文件，如果不存在，则创建
 8 w+         读写模式，先读后写，只要有w，会清空原来的文件内容
 9 wb+        二进制读写模式
10 a          追加模式，也能写，在文件的末尾添加内容
11 ab         二进制追加模式
12 a+         追加模式，如果文件不存在，则创建文件，如果存在，则在末尾追加
13 ab+        追读写二进制模式，从文件顶部读取文件，从文件底部添加内容，不存在则创建

8、有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 请将以字母“a”开头的元素的首字母改为大写字母

 1 # startswith      a.startsWith(b)       判断字符串a 是不是以字符串b开头.
 2 # append       在被选元素的结尾（仍然在内部）插入指定内容.
 3 # capitalize      返回一个字符串，首字母为大写，其他字母为小写
 4 li = ['alex', 'egon', 'smih', 'pizza', 'alen']
 5 #方法一：
 6 new_li = []
 7 for i in li:
 8     if i.startswith('a'):
 9         new_li.append(i.capitalize())
10     else:
11         new_li.append(i)
12 print(new_li)
13 
14 #方法二：
15 for i in range(len(li)):
16     if li[i][0] == 'a':
17         li[i] = li[i].capitalize()
18     else:
19         continue
20 print(li)
21 
22 #方法三：
23 print([item.capitalize() if item.startswith('a') else item for item in li])

9、有如下程序, 请给出两次调用show_num函数的执行结果，并说明为什么：

 1 num = 20
 2 def show_num(x=num):
 3     print(x)
 4 
 5 show_num()      #结果为：20
 6 
 7 num = 30
 8 show_num()      #结果为：20
 9 
10 # 如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象，相当于通过“传值’来传递对象
11 #如果想改变这些变量的值，可以将这些变量申明为全局变量

10、有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 请以列表中每个元素的第二个字母倒序排序

#sorted((1,4,8,9,3,6), reverse=True)     #结果为: [9, 8, 6, 4, 3, 1]
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
print(sorted(li,key=lambda x : x[1],reverse = True))

11、有名为poetry.txt的文件，其内容如下，请删除第三行

 1 '''
 2    昔人已乘黄鹤去，此地空余黄鹤楼。
 3 
 4    黄鹤一去不复返，白云千载空悠悠。
 5 
 6    晴川历历汉阳树，芳草萋萋鹦鹉洲。
 7 
 8    日暮乡关何处是？烟波江上使人愁。
 9 '''
10 import os
11 f1=open('poetry.txt', 'r',encoding='utf-8')
12 
13 str='晴川历历汉阳树，芳草萋萋鹦鹉洲。'
14 with open('poetry1.txt', 'w', encoding='utf-8') as f2:
15       ff1='poetry.txt'
16       ff2='poetry1.txt'
17       for line in f1:
18           if str in line:
19               line=''
20               f2.write(line)
21 
22           else:
23               f2.write(line)
24 f1.close()
25 f2.close()
26 os.replace(ff2,ff1)

12、有名为username.txt的文件，其内容格式如下，写一个程序，判断该文件中是否存在"alex", 如果没有，则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在。

  pizza
  alex
  egon

1 with open('username.txt','r+',encoding='utf-8')as f:
2     s = 'alex'
3     i = f.read()
4     print(i)
5     if s in i:
6         print('该用户已存在')
7     else:
8         f.write('\nalex')

13、有名为user_info.txt的文件，其内容格式如下，写一个程序，删除id为100003的行

 1 f_name = r'user_info.txt'
 2 f_new_name = '%s.new'%f_name
 3 del_id = '100001'
 4 f_new = open(f_new_name, 'w', encoding='utf-8')
 5 with open(f_name, 'r', encoding='utf-8') as f:
 6     for line in f:
 7         if del_id in line:
 8             pass
 9         else:
10             f_new.write(line)
11 f_new.close()
12 os.replace(f_new_name,f_name)

14、有名为user_info.txt的文件，其内容格式如下，写一个程序，将id为100002的用户名修改为alex li

 1 f_name = r'user_info.txt'
 2 f_new_name = '%s.new'%f_name
 3 update_id = '100002'
 4 update_name = 'alex li'
 5 f_new = open(f_new_name, 'w', encoding='utf-8')
 6 with open(f_name, 'r', encoding='utf-8') as f:
 7     for line in f:
 8         if update_id in line:
 9             line = ','.join([update_name, update_id])
10             f_new.write(line+'\n')
11         else:
12             f_new.write(line)
13 f_new.close()
14 os.replace(f_new_name,f_name)