Python全栈问答小技巧_2

最新推荐文章于 2024-09-14 23:11:55 发布

weixin_34293902

最新推荐文章于 2024-09-14 23:11:55 发布

阅读量328

点赞数

文章标签：操作系统运维 python

　　　　　　　　　　　　　　　　　　　　　　Python全栈测试题(二)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

声明：答案如有偏差，欢迎指正！欢迎加入高级运维工程师之路：598432640

本文答题用的Python版本是：Python 3.5.2，请知晓！

1. 计算1-300之间所有能被3和7整除的所有数之和

 1 #！/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 total = 0
 7 i = 1
 8 while i <= 300:
 9     if i % 3 == 0 or i % 7 == 0:
10         total += i
11     i += 1
12 print(total)
13 
14 
15 #测试结果如下：
16 19266

2. 定义函数统计一个字符串中大写字母, 小写字母, 数字的个数, 并返回结果

 1 #！/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 def counts_str_type(str):
 7     number = []
 8     upper = []
 9     lower = []
10     for i in str:
11         if 48 <= ord(i) <= 57:
12             number.append(i)
13         elif 65 <= ord(i) <= 90:
14             upper.append(i)
15         elif 97 <= ord(i) <= 122:
16             lower.append(i)
17     result = "数字的个数有:%s个，大写字符串有%s个，小写字符串有%s个"%(len(number),upper.__len__(),lower.__len__())  #统计列表的长度返回，len方法就是调用的__len__方法，这里2种写法都可以，看你喜欢哪种。
18     return result
19 test = "YinZhengJie123"
20 res = counts_str_type(test)
21 print(res)
22 
23 
24 
25 #代码执行结果如下：
26 
27 数字的个数有:3个，大写字符串有3个，小写字符串有8个

3. 集合练习

 1 #！/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 list_1 = [11,22,33]
 7 list_2 = [22,33,44]
 8 set_num1 = set(list_1)  #先将其中的一个列表变成集合
 9 print(set_num1.intersection(list_2)) #然后再用集合的取交集的方法将交集打印出来。
10 
11 
12 
13 #代码执行结果
14 {33, 22}

4.将字符串"尹正杰"转换成UTF-8编码的字节类型

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 str = "尹正杰"
 7 print(str.encode("utf-8"))  #由于在python中，在内存中的编码默认是unicode，所以直接进行编码即可，不用解码（解码的目的就是讲字符串转变成unicode编码）
 8 
 9 
10 
11 #代码执行结果：
12 b'\xe5\xb0\xb9\xe6\xad\xa3\xe6\x9d\xb0'

5. 如何计算数字绝对值

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 num_1 = abs(-5)  #利用内置函数"abs"进行取值。
 7 print(num_1)
 8 num_2 = abs(5)
 9 print(num_2)
10 
11 
12 #代码执行结果：
13 5
14 5

6. 简述深浅拷贝的原理

浅拷贝：
　　它是指将对象内的数据完全一致的复制，只是将指针指向内存中的对象。不占用内存空间。
深拷贝：
　　它可以将内部的数据按照需要用特殊的方法拷贝，将拷贝过来的数据单独开辟一块内存空间，并将指针指向新开辟出来的内存地址，是需要占用内存空间的哟。
两者的区别：浅拷贝不占用内存空间，深拷贝占用内存空间。
如果还不明白的小伙伴可以参考一位网友的博客：http://blog.csdn.net/u012377333/article/details/41956727

7. 列举布尔值为False的值

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 print([] is True)
 7 print({} is True)
 8 print(None is True)
 9 print(0 is  True)
10 print("" is True)
11 print(() is True)
12 
13 
14 ＃代码执行结果如下：
15 False
16 False
17 False
18 False
19 False
20 False
21 
22 
23 
24 ＃根据结果反推理论：
25 为空的数据类型或者数字是“０”的布尔值都为假（即False）

8. 内置函数all和any的区别

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 all(iterable)
 8 如果迭代器里面的任何元素都非零,返回True;否则返回False.
 9 '''
10 print(all([-100,'       ',200]))
11 print(all([11,22,0]))
12 '''
13 any(iterable)
14 如果迭代器里面的任意元素非零,返回True;否则返回False.
15 '''
16 print(any([-100,'       ',200]))
17 print(any([11,22,0]))
18 
19 
20 ＃执行代码如下：
21 
22 True
23 False
24 True
25 True

9. 利用内置函数将十几只数字12 分别转换成二进制, 八进制, 十六进制表示的字符串

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 binary_1 = bin(12)   #表示将括号里的数字转换成二进制
 7 binary_2 = bin(int("12",10))  #bin函数括号中的int函数中的第一个数字，需要用引号括起来，后面的那个数字表示前面引起来的数字是几进制的！
 8 print(binary_1)
 9 print(binary_2)
10 octonary_1 = oct(12) #表示将括号里的数字转换成八进制
11 octonary_2 = oct(int("12",10))
12 print(octonary_1)
13 print(octonary_2)
14 hexadecimal_1 = hex(12)  #表示将括号里的数字转换成十六进制
15 hexadecimal_2 = hex(int("12",10))
16 print(hexadecimal_1)
17 print(hexadecimal_2)
18 
19 
20 
21 #代码执行结果如下：
22 
23 0b1100
24 0b1100
25 0o14
26 0o14
27 0xc
28 0xc

10. 简述内建函数dir, help, id, type的作用

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 import sys,os
 7 '''
 8     help函数：查看模块、函数、变量的详细说明：
 9 '''
10 #用法展示：
11 #help(os) #在这里我就注释掉这一行了，因为现实的信息是在太多了
12 
13 '''
14      dir函数：查看变量可用的函数或方法
15 '''
16 #用法展示：
17 print(dir(sys))
18 '''
19      type函数：查看变量的类型
20 '''
21 #用法展示
22 num_1 = 123
23 num_2 = "123"
24 list_1 = ["yinzhengjie","alex"]
25 print(type(list_1))
26 print(type(num_1))
27 print(type(num_2))
28 '''
29     id函数:返回指定对象的内存id值。每个对象(在python中一切皆对象)拥有唯一的内存id。
30 '''
31 #用法展示
32 print(id(num_1))
33 print(id(num_2))
34 print(id(list_1))
35 
36 
37 #代码执行结果如下：
38 
39 ['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']
40 <class 'list'>
41 <class 'int'>
42 <class 'str'>
43 1774018736
44 25023520
45 25021256

11. 简述内建函数globals, locals作用

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 import sys
 7 '''
 8 首先，是关于名字空间的一个名词解释。是枯燥，但是很重要，所以要耐心些。Python使用叫做名字空间的东西来记录变量的轨迹。名字空间只是一个 字典，它的键字就是变量名，字典的值就是那些变量的值。实际上，名字空间可以象Python的字典一样进行访问，一会我们就会看到。
 9 
10 在一个Python程序中的任何一个地方，都存在几个可用的名字空间。每个函数都有着自已的名字空间，叫做局部名字空间，它记录了函数的变量，包括 函数的参数和局部定义的变量。每个模块拥有它自已的名字空间，叫做全局名字空间，它记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常 量。还有就是内置名字空间，任何模块均可访问它，它存放着内置的函数和异常。
11 
12 当一行代码要使用变量 x 的值时，Python会到所有可用的名字空间去查找变量，按照如下顺序：
13     1>.局部名字空间 - 特指当前函数或类的方法。如果函数定义了一个局部变量 x，Python将使用这个变量，然后停止搜索。
14     2>.全局名字空间 - 特指当前的模块。如果模块定义了一个名为 x 的变量，函数或类，Python将使用这个变量然后停止搜索。
15     3>.内置名字空间 - 对每个模块都是全局的。作为最后的尝试，Python将假设 x 是内置函数或变量。
16 如果Python在这些名字空间找不到 x，它将放弃查找并引发一个 NameError 的异常，同时传 递 There is no variable named 'x' 这样一条信息
17 
18 像Python中的许多事情一样，名字空间在运行时直接可以访问。特别地，局部名字空间可以通过内置的 locals 函数来访问。全局（模块级别）名字空间可以通过 globals 函数来访问
19 '''
20 def foo(arg):
21     z = 100
22     print(locals())
23 foo("yinzhengjie")
24 
25 print(globals())  #globals 函数返回一个全局变量的字典，包括所有导入的变量。
26 
27 '''
28 扩展：
29     LGB就是在python中有一个变量，python怎么判断这个变量是哪一个，顺序是局部-全局-内置（local--global--built-in）
30 '''
31 
32 
33 
34 #代码执行结果如下：
35 {'arg': 'yinzhengjie', 'z': 100}
36 {'__file__': 'D:/python/daima/DAY4/test.py', '__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__package__': None, '__name__': '__main__', '__doc__': None, '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00F35A90>, 'sys': <module 'sys' (built-in)>, 'foo': <function foo at 0x00F06660>}

12. 简述三元运算的书写格式

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 python中三元运算的格式为：
 8     为真时的结果 if 判定条件 else 为假时的结果
 9 '''
10 #用法展示
11 username = input("Please enter the username for this host:>>>")
12 print("欢迎回来，我的主人%s" % username) if username == "yinzhengjie" else print("哼！休想骗我！你不是我的主人！")
13 
14 
15 
16 #代码运行结果如下：
17 
18 #登陆成功结果：
19 Please enter the username for this host:>>>yinzhengjie
20 欢迎回来，我的主人yinzhengjie
21 
22 #登陆失败结果：
23 Please enter the username for this host:>>>alex
24 哼！休想骗我！你不是我的主人！

13. 简述lambda表达式的书写格式

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 def sum(num_1,num_2=5):  #定义了一个形式参数num_1，定义了一个默认参数num_2
 7     sum_tatol = num_1 +num_2  #定义过程
 8     return sum_tatol  #返回结果
 9 res = sum(10)
10 print(res)
11 sum = lambda num_1,num_2=5:num_1+num_2  #在“：”之前的是形式参数和默认参数，“：”后面的是返回结果
12 print(sum(10))
13 '''
14 扩展:
15 func_1 = lambda  x,y,z: x + y + z
16 res = func_1(100,200,300)
17 print(res)
18 func_2 = [(lambda n,i=i:i + n )for  i in range(10)] #其中有四个i，第一个i是形参；第二个i是参数的默认值，值就是最后一个i；然后，是第三个i，根据LGB原则，这个i应该是对应着参数i（第一个i）；最后一个i应该最简单，就是一个普通的变量，在循环过程中的值不断变化，其实这就是一个列表生成式，
19 print(func_2[3](2))
20 func_3 = [(lambda n,:i + n )for  i in range(10)]
21 print(func_3[3](4))
22 test = [i for i in range(10)]  #列表生成式
23 print(test)
24 '''
25 
26 #代码执行结果
27 15
28 15

14. 利用内建函数zip, 实现功能

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 l1 = ["alex",22,33,44,55]
 8 l2 = ["is",22,33,44,55]
 9 l3 = ["good",22,33,44,55]
10 l4 = ["guy",22,33,44,55]
11 请获取字符串s = "alex_is_good_guy"
12 '''
13 list_1 = ["alex",22,33,44,55]
14 list_2 = ["is",22,33,44,55]
15 list_3 = ["good",22,33,44,55]
16 list_4 = ["guy",22,33,44,55]
17 ziped = zip(list_1,list_2,list_3,list_4)
18 str = "_".join(list(ziped)[0])
19 print(str)
20 
21 #测试结果如下：
22 alex_is_good_guy

15. 简述文件打开模式'r'和'rb'的区别和影响

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 一、Python文件读写的几种模式：
 8 r,rb,w,wb 那么在读写文件时，有无b标识的的主要区别在哪里呢？
 9 1、文件使用方式标识
10 'r':默认值，表示从文件读取数据。
11 'w':表示要向文件写入数据，并截断以前的内容
12 'a':表示要向文件写入数据，添加到当前内容尾部
13 'r+':表示对文件进行可读写操作（删除以前的所有数据）
14 'r+a'：表示对文件可进行读写操作（添加到当前文件尾部）
15 'b':表示要读写二进制数据
16 2、读文件 进行读文件操作时，直到读到文档结束符（EOF）才算读取到文件最后，Python会认为字节\x1A(26)转换成的字符为文档结束符（EOF），
17       故使用'r'进行读取二进制文件时，可能会出现文档读取不全的现象。
18 示例：
19      二进制文件中存在如下从低位向高位排列的数据：7F 32 1A 2F 3D 2C 12 2E 76
20      如果使用'r'进行读取，则读到第三个字节，即认为文件结束。
21      如果使用'rb'按照二进制位进行读取的，不会将读取的字节转换成字符，从而避免了上面的错误。
22 解决方案：
23      二进制文件就用二进制方法读取'rb'
24   总结：
25      使用'r'的时候，如果碰到'0x1A'，就视为文件结束，就是EOF。使用'rb'则不存在这个问题，
26 即：如果你用二进制写入再用文件读出的话，如果其中存在'0x1A'，就只会读出文件的一部分，
27 使用'rb'会一直读取文件末尾。
28 3、写文件 对于字符串x='abc\ndef',我们可用len(x)得到它的长度为7，\n我们称之为换行符，实际上是0x0A。当我们用'w'即文本方式写的时候，在windows平台上会自动将'0x0A'变成两个字符'0x0D','0x0A'，即文件长度实际上变成8。当用'r'文本方式读取时，又自动的转换成原来的换行符。 如果换成'wb'二进制方式来写的话，则会保持一个字符不变，读取的时候也是原样读取。 所以如果用文本方式写入，用二进制方式读取的话，就要考虑这多出的一个字节了。'0x0D'也称回车符。 Linux下不会变，因为linux只使用'0X0A'来表示换行。
29 '''

16. 文件操作时with的作用

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 文件操作时with的作用：
 8     1>.可以以任意模式打开文件，且不用担心文件关闭的操作，一旦执行with语句完毕会自动释放内存；
 9     2>.在一个程序文件中，我们可以同事打开多个文件哟！
10 '''
11 with open("test.txt","r",encoding="utf-8") as f_1:
12     for i in f_1.readlines():
13         print(i)
14 with open("new.txt","r",encoding="utf-8") as  f_2:
15     for j in f_2.readlines():
16         print(j)
17 
18 
19 #代码执行结果：
20 yinzhengjie's test.txt file        88888888
21 yinzhengjie's new.txt file!     6666666
22 
23 #test.txt文件内容：
24 yinzhengjie's test.txt file        88888888
25 #new.txt文件内容：
26 yinzhengjie's new.txt file!     6666666

17. 利用with实现同时打开两个文件(一读, 一写)

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 with open("test.txt","r",encoding="utf-8") as f_1:
 7     for i in f_1.readlines():
 8         print(i)
 9 with open("new.txt","r+",encoding="utf-8") as  f_2:
10     for j in f_2.readlines():
11         print(j)
12     f_2.write("\n")
13     f_2.write("我爱北京天安门")
14 
15 #执行代码之前查看文件内容：
16 #new.txt文件内容：
17 yinzhengjie's new.txt file!     6666666
18 
19 #test.txt文件内容：
20 yinzhengjie's test.txt file        88888888
21 
22 #执行代码之后结果如下：
23 
24 #显示屏输出结果如下：
25 yinzhengjie's test.txt file        88888888
26 yinzhengjie's new.txt file!     6666666
27 写入成功
28 
29 #查看执行代码之后查看文件内容：
30 
31 #new.txt文件内容：
32 yinzhengjie's new.txt file!     6666666
33 我爱北京天安门
34 
35 #test.txt文件内容：
36 yinzhengjie's test.txt file        88888888

18. 函数的默认返回值是什么

　　如果一个函数没有return（返回值）的话，默认返回None.

19. 简述函数的普通参数, 指定参数, 默认参数, 动态参数的特点和注意事项

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 #1.普通参数就是像下面这段函数传入的参数一样，传入函数，没有默认值
 7 def common_parameter(a):
 8     a = a + 1
 9     return a
10 res = common_parameter(100)
11 print(res)
12 #2.指定参数
13 def specified_parameter(a,b,c):
14     print(a,b,c)
15 specified_parameter(c="alex",a="尹正杰",b="廖雪峰")  #如果像这样指定a,b,c的值，那么它们就是指定参数，可以不按照它们原来的顺序传入
16 #3、默认参数
17 def mount(a,b="/root/yinzhengjie"): ##像这样在括号里指定b的初始值,那么b就成为默认参数,如果用户不指定的话就会使用提前设置好的参数打印。
18     print("您要做的操作是\033[32;1m%s:\033[0m，需要\033[32;1m%s:\033[0m的路径是\033[32;1m%s:\033[0m"% (a,a,b))
19 mount("挂载")
20 mount("挂载","/yinzhengjie")
21 #4.动态参数
22 def dynamic_tuple(*args):  # #动态参数 *args  是指当我们需要传入多个参数时，可以用*args代表多个参数，不用分别在括号里指定多个参数
23     print(args,type(args))
24 dynamic_tuple("yinzhengjie","alex","廖雪峰","python")
25 def dynamic_dict(**kwargs):  #动态参数 **kwargs, 当我们需要传入键值对类型的参数时就可以用**kwargs
26     print(kwargs, type(kwargs))
27 dynamic_dict(yinzhengjie = 25,)
28 def install_program(action,*args,install_path=r"C:\Users\yzj\share",**kwargs):  #动态参数之参数的万能模式,这样我们无论怎么传参数几乎都不会报错,这里我模拟一下安装程序的函数传参。
29     print("您要做的操作是\033[32;1m%s:\033[0m，您选择的安装模式是\033[32;1m%s:\033[0m,安装成功后的默认账号密码是\033[32;1m%s:\033[0m，需要安装的路径是\033[32;1m%s:\033[0m"%(action,args,kwargs,install_path))
30 install_program("安装","自动安装",yinzhengjie=123)
31 
32 #执行以上代码结果如下：
33 101
34 尹正杰 廖雪峰 alex
35 您要做的操作是挂载:，需要挂载:的路径是/root/yinzhengjie:
36 您要做的操作是挂载:，需要挂载:的路径是/yinzhengjie:
37 ('yinzhengjie', 'alex', '廖雪峰', 'python') <class 'tuple'>
38 {'yinzhengjie': 25} <class 'dict'>
39 您要做的操作是安装:，您选择的安装模式是('自动安装',):,安装成功后的默认账号密码是{'yinzhengjie': 123}:，需要安装的路径是C:\Users\yzj\share:

20. Python有几种导入模块的方式

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 #方法一：
 7 '''
 8     import modname
 9     提示：这种导入方法适合用在导入内置模块（如:os,sys.time等等）或者导入第三方库时使用！
10 '''
11 #用法展示
12 import sys
13 #方法2
14 '''
15     from modname import funcname   & from modname import *
16     提示：这种用适合用在包文件的导入，相对导入，绝对导入就是用他实现的！不建议使用from modname import *   这种方法导入！
17 '''
18 #用法展示：
19 from os import chown,chmod
20 #方法3
21 '''
22     mymodule = __import__ (’module_name’)
23 '''
24 #友情提示
25 '''
26     不主张从一个包或模块中用import * 导入所有模块，因为这样的通常会导致可读性很差。
27     from Package import specific_submodule的用法并没有错，实际上这还是推荐的用法，除非导入的模块需要使用其它包中的同名子模块(the importing module needs to use submodules with the same name from different packages). 
28          综上所述，一般情况应该使用import , 但有几个例外 
29         1>.module文档告诉你要用from-import的 
30         2>.导入一个包组件。需要一个包里面的某个子模块，一般用from A.b import c比import A.b.c 更方便 且不会冒混淆的危险.
31 '''

21.判断以下字符串格式化是否正确, 如果不正确请改正

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 判断以下字符串格式化是否正确, 如果不正确请改正
 8 tpl1 = "i am {name}, age {age}, really {name}".format(name="seven",age=18)
 9 tpl2 = "i am {0}, age {1}".format(["seven",18])
10 '''
11 #tpl1的写法是正确的！可以直接打印：
12 tpl1 = "i am {name}, age {age}, really {name}".format(name="seven",age=18)
13 print(tpl1)
14 #tpl2的写法是错误的！正解如下：
15 #改法一：通过下表传参数，
16 tpl2 = "i am {0[0]}, age {0[1]}".format(["seven",18])   #如果是按照一个列表传参的话，是需要通过下表传参的！
17 print(tpl2)
18 #通过位置传参：
19 tpl3 = "i am {0}, age {1}".format("seven",18)  #传入的参数是按照位置来的，不能传列表！
20 print(tpl3)
21 
22 #扩展：
23 #取近似值：
24 print('{:.2f}'.format(321.33645))  #来确定精度，采取四舍五入，其中.2表示长度为2的精度，f表示float类型。
25 #进制的转换
26 print('{:b}'.format(12))   #二进制表示方法
27 print('{:d}'.format(12))   #十进制
28 print( '{:o}'.format(12))  #八进制
29 print( '{:x}'.format(12))  #十六进制
30 #用，号还能用来做金额的千位分隔符。
31 print('{:,}'.format(1234567890))
32 #填充与对齐，填充常跟对齐一起使用，“^，<，>”分别是居中、左对齐、右对齐，后面带宽度
33 print('{:^10}'.format('189'))
34 print('{:0>8}'.format('189'))
35 print('{:a<8}'.format('189'))
36 
37 
38 #以上代码执行结果如下：
39 i am seven, age 18, really seven
40 i am seven, age 18
41 i am seven, age 18
42 321.34
43 1100
44 12
45 14
46 c
47 1,234,567,890
48    189    
49 00000189
50 189aaaaa

22.通过字符串格式化将7.88123输出时仅保留小数点后两位, 例如: "bala 7.88 bala"

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 #定义2个相似的数字，在需要保留小数的后一位稍作修改如下：
 7 num_1 = 7.88123  
 8 num_2 = 7.88911
 9 str_2 = '{:.2f}'.format(num_2)   # #来确定精度，采取四舍五入，其中.2表示长度为2的精度，f表示float类型。
10 str_1 ='{:.2f}'.format(num_1)
11 test_1 = "bala \033[32;1m%s:\033[0m bala" % str_1
12 test_2 = "我是用来对比的上面的数字哟：\033[31;1m%s:\033[0m" % str_2
13 print(test_1)
14 print(test_2)
15 
16 
17 #以上代码测试结果如下：
18 bala 7.88: bala
19 我是用来对比的上面的数字哟：7.89:

23. 分页如果有192个商品, 每页显示10个商品, 问共需要几页

　　20页，没毛病！哈哈~

24. 函数传递参数时, 是引用还是复制值

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 #先看这段代码：
 7 # def test(c):
 8 #     print("test before ")
 9 #     print(id(c))
10 #     c+=2
11 #     print("test after +")
12 #     print(id(c))  # id函数可以获得对象的内存地址.很明显从上面例子可以看出，将a变量作为参数传递给了test函数，传递了a的一个引用，把a的地址传递过去了，所以在函数内获取的变量C的地址跟变量a的地址是一样的，但是在函数内，对C进行赋值运算，C的值从2变成了4，实际上2和4所占的内存空间都还是存在的，赋值运算后，C指向4所在的内存。而a仍然指向2所在的内存，所以后面打印a，其值还是2.
13 #     return c
14 # if __name__=="__main__":
15 #     a=2
16 #     print("main before invoke test")
17 #     print(id(a))
18 #     n=test(a)
19 #     print("main afterf invoke test")
20 #     print(a)
21 #     print(id(a))
22 
23 #将上面的注释掉之后再看下面的这段代码：
24 def test(list2):
25     print("test before ")
26     print(id(list2))
27     list2[1]=30
28     print("test after +")
29     print(id(list2))  #实际上是因为python中的序列：列表是一个可变的对象，就基于list1=[1,2] list1[0]=[0]这样前后的查看list1的内存地址，是一样的。
30     return list2
31 
32 if __name__=="__main__":
33     list1=["yinzhengjie",25,'boy']
34     print("main before invoke test")
35     print(id(list1))
36     list3=test(list1)
37     print("main afterf invoke test")
38     print(list1)
39     print(id(list1))
40 
41 '''
42 结论：
43         python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值－－相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象－－相当于通过“传值'来传递对象。
44 '''

25. Python3中的range函数和Python2.7中的range函数有什么区别

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 #先看python3
 7 '''
 8 [root@yinzhengjie ~]# python3
 9 Python 3.5.0 (default, Jan  2 2017, 22:54:19)
10 [GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux
11 Type "help", "copyright", "credits" or "license" for more information.
12 >>> range(1,10)
13 range(1, 10)
14 >>> a = range(1,10)
15 >>> type(a)
16 <class 'range'>
17 >>> list(a)  #要想打印出列表，需要加list
18 [1, 2, 3, 4, 5, 6, 7, 8, 9]
19 >>>
20 '''
21 #再看python2
22 '''
23 [root@yinzhengjie ~]# python
24 Python 2.6.6 (r266:84292, Feb 22 2013, 00:00:18)
25 [GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux2
26 Type "help", "copyright", "credits" or "license" for more information.
27 >>> range(1,10)   #打印出1-10的数字，python默认从0开始
28 [1, 2, 3, 4, 5, 6, 7, 8, 9]
29 >>> a = range(1,10)
30 >>> type(a)
31 <type 'list'>
32 >>>
33 '''
34 
35 #结论：
36 两者的区别：
37     在于返回值的不同，python3中的range返回的是一个迭代值；python2中的range返回的是一个列表。

26. Python中导入模块时, 如何搜索其路径

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 
 7 '''
 8     运行Python应用或引用Python模块，Python解释器要有一个查找的过程。可以通过设置一个环境变量PYTHONPATH为Python增加一个搜索路径，以方便查找到相关Python模块（不同的操作系统环境变量的设置稍有不同，默认以下都是WIndows环境），这与众多应用程序需要设置一个系统环境变量的道理是一样的。在命令行中可以通过以下命令设置：
 9 C:\Users\Administrator>set PYTHONPATH=E:/Project/Python/ModuleAndPackage/
10 '''
11 
12 #那么如何添加系统环境变量呢？
13 # 在linux环境中
14 '''
15 [root@yinzhengjie ~]# python3
16 Python 3.5.0 (default, Jan  2 2017, 22:54:19)
17 [GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux
18 Type "help", "copyright", "credits" or "license" for more information.
19 >>> import sys
20 >>> sys.path
21 ['', '/usr/local/lib/python35.zip', '/usr/local/lib/python3.5', '/usr/local/lib/python3.5/plat-linux', '/usr/local/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages']
22 >>> sys.path.append("/yinzhengjie/tools") #可以通过sys模块的append方法在Python环境中增加搜索路径
23 >>> sys.path
24 ['', '/usr/local/lib/python35.zip', '/usr/local/lib/python3.5', '/usr/local/lib/python3.5/plat-linux', '/usr/local/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages', '/yinzhengjie/tools']
25 >>>
26 '''
27 # 在windows环境中
28 '''
29 C:\Users\yzj>python
30 Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)] on win32
31 Type "help", "copyright", "credits" or "license" for more information.
32 >>> import sys
33 >>> sys.path
34 ['', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\python35.zip', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\DLLs', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib\\site-packages']
35 >>> sys.path.append(r"C:\Users\yzj\Documents\Tencent Files")  #可以通过sys模块的append方法在Python环境中增加搜索路径,前面的"r"参数是自动转义的意思。
36 >>> sys.path
37 ['', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\python35.zip', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\DLLs', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib\\site-packages', 'C:\\Users\\yzj\\Documents\\Tencent Files']
38 >>>
39 '''

27. sys.argv的作用

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7     sys.argv: 实现从程序外部向程序传递参数
 8 '''
 9 import sys
10 print("Your name is %s，and your age is %s" % (sys.argv[1],sys.argv[2]))
11 
12 '''
13 扩展：
14 sys.argv: 实现从程序外部向程序传递参数。
15 sys.exit([arg]): 程序中间的退出，arg=0为正常退出。
16 sys.getdefaultencoding(): 获取系统当前编码，一般默认为ascii。
17 sys.setdefaultencoding(): 设置系统默认编码，执行dir（sys）时不会看到这个方法，在解释器中执行不通过，可以先执行reload(sys)，在执行 setdefaultencoding('utf8')，此时将系统默认编码设置为utf8。（见设置系统默认编码 ）
18 sys.getfilesystemencoding(): 获取文件系统使用编码方式，Windows下返回'mbcs'，mac下返回'utf-8'.
19 sys.path: 获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到。
20 sys.platform: 获取当前系统平台。
21 sys.stdin,sys.stdout,sys.stderr: stdin , stdout , 以及stderr 变量包含与标准I/O 流对应的流对象. 如果需要更好地控制输出,而print 不能满足你的要求, 它们就是你所需要的. 你也可以替换它们, 这时候你就可以重定向输出和输入到其它设备( device ), 或者以非标准的方式处理它们
22 '''
23 
24 
25 #在window的cmd窗口下运行结果如下：
26 D:\python\daima\DAY4>python test.py "尹正杰" "25"
27 Your name is 尹正杰，and your age is 25
28 
29 D:\python\daima\DAY4>

28. 如何获取一个路径的上级目录的路径

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 import os
 7 print(os.path.dirname(os.path.abspath(__file__)) )  #获取当前文件所在文件的绝对路径的方法一
 8 print(os.getcwd())                                  #获取当前文件所在文件的绝对路径的方法二
 9 print(os.path.abspath(os.path.dirname(os.path.dirname(__file__)))) #获得当前所在的路径的上级路径的方法一
10 print(os.path.dirname(os.getcwd()))  #获得当前所在的路径的上级路径的方法二
11 
12 
13 
14 #代码的执行结果如下：
15 D:\python\daima\DAY4
16 D:\python\daima\DAY4
17 D:\python\daima
18 D:\python\daima

29. 请将以下三个路径按照a,b,c的顺序拼接起来

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 a = "/root"
 7 b = "/yinzhengjie"
 8 c = "bin"
 9 list_1 = [a,b,c]
10 print("___________".join(list_1))
11 
12 
13 
14 #以上代码执行结果如下：
15 /root___________/yinzhengjie___________bin

30. 简述一个随机字母的思路

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 import random  #导入random模块 用于生产随机数功能
 7 ababdon = random.randint(97,122)  #利用random.randint()函数生成一个随机整数
 8 string = chr(ababdon)  #对应从“a”到“z”的ASCII码
 9 print(string)
10 
11 
12 #代码执行结果如下：
13 f
14 
15 #实现思路:
16     1>.导入随机生成模块，便于生成一个数字；
17     2>.找到我们想要生成的字母在ASSIC表中所对应的数字；
18     3>.利用内置函数chr()来将随机生成的数字转换成ASSIC表中所对应的字母！


31.简述计算1*2+3*4+5*6+7*8...+99*100的实现思路

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7     简述计算1*2+3*4+5*6+7*8...+99*100的实现思路
 8 '''
 9 total = 0
10 i = 1
11 while i <= 100:
12     total += i*(i+1) #把2个连续的数字相乘并将结果相加
13     i += 2 #每次自增的打小应该是2。
14 print(total)
15 
16 
17 #以上代码运行结果如下：
18 169150

32.函数练习

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 list_1 = [11,22,33,44,55]
 7 #1.利用filter, 自定义函数 获取l1中元素大于33的所有元素
 8 print(list(filter(lambda x: x > 33,list_1)))
 9 #2.利用filter, lambda表达式 获取l1中元素小于33的所有元素
10 print(list(filter(lambda x: x < 33,list_1)))
11 #3.利用map, 自定义函数将所有是奇数的元素加100
12 print(list(map(lambda x: x + 100 , [x for x in list_1 if(x%2)==1])))
13 #4.利用map, lambda表达式 将所有是偶数的元素加100
14 print(list(map(lambda x: x + 100 , [x for x in list_1 if(x%2)==0])))
15 #5.使用for循环实现打印99乘法表
16 print ('\n'.join([' '.join(['%s*%s=%s' % (j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)]))
17 #6.递归实现乘阶 1*2...*7
18 def fact(n):
19     if n == 1:
20         return 1
21     return n * fact(n - 1)
22 print(fact(7)) #可以开启Debug模式看这个函数是怎么运行的
23 
24 #以上代码运行结果如下：
25 
26 [44, 55]
27 [11, 22]
28 [111, 133, 155]
29 [122, 144]
30 1*1=1
31 1*2=2 2*2=4
32 1*3=3 2*3=6 3*3=9
33 1*4=4 2*4=8 3*4=12 4*4=16
34 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
35 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
37 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
38 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
39 5040

33.列表+函数练习

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7 如有以下两个列表
 8 list_1 = [...]
 9 list_2 = []
10 第一个列表中的数字无序不重复排列, 第二个列表为空列表
11 需求:
12     取出第一个列表的最小值 放到第二个列表的首个位置,
13     取出第一个列表的最小值(仅大于上一次的最小值) 放到第二个列表的首个位置)
14     ..
15     以此类推, 从而获得一个有序的列表list_2, 并将其返回给函数调用者
16     不能改变list_1列表, 不能对之进行排序, 也不可以倒到别的列表中.
17 '''
18 def func(list_1, list_2):
19     for i in range(len(list_1)):
20         list_2.insert(0, min(set(list_1).difference(list_2)))
21     return list_2
22 list_1 = [2,4,3,1,5,6,7,9]
23 list_2 = []
24 res = func(list_1,list_2)
25 print(res)
26 
27 
28 #以上代码执行结果如下：
29 
30 [9, 7, 6, 5, 4, 3, 2, 1]

34.装饰器练习：

 1 #！/usr/bin/env python3
 2 #_*_coding:utf-8_*_
 3 #@author :yinzhengjie
 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
 5 #EMAIL:y1053419035@qq.com
 6 '''
 7     如有以下两个函数, 请书写一个装饰器实现在不改变函数调用者的代码基础上, 实现在函数执行前后分别打印"before"和"after"
 8     def f1(arg):
 9     return arg + 1
10     def f2(arg1, arg2):
11     return arg1 + arg2
12 '''
13 def display(func):
14     def wrapper(*args,**kwargs):
15         print('before')
16         print(func(*args,**kwargs))
17         print('after')
18     return wrapper
19 @display
20 def f1(arg):
21     return arg + 1
22 @display
23 def f2(arg1, arg2):
24     return arg1 + arg2
25 
26 f1(10)
27 print("*"*50,"我是分割线","*"*50)
28 f2(11, 22)
29 
30 
31 #以上代码执行结果如下：
32 before
33 11
34 after
35 ************************************************** 我是分割线 **************************************************
36 before
37 33
38 after

35.文件操作练习：

文件内容如下:
global
    log 127.0.0.1 local2
    daemon
    maxconn 256
    log 127.0.0.1 local2 info
defaults
    log global
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms
    option dontlognull
listen stats :8888
    stats enable
    stats uri       /admin
    stats auth      admin:1234
frontend oldboy.org
    bind 0.0.0.0:80
    option httplog
    option httpclose
    option   forwardfor
    log global
    acl www hdr_reg(host) -i www.oldboy.org
    use_backend www.oldboy.org if www
backend www.oldboy.org
    server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
    server 100.1.7.8 100.1.7.8 weight 20 maxconn 3000
    server 100.1.7.7 100.1.7.6 weight 20 maxconn 3000
backend buy.oldboy.org
    server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000

需求:
1. 获取内容
    当用户通过input输入 www.oldboy.org 则将其下面内容添加到列表中返回给用户
    即: li = [
        "server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000",
        "server 100.1.7.8 100.1.7.8 weight 20 maxconn 3000",
        "server 100.1.7.7 100.1.7.6 weight 20 maxconn 3000"
        ]
2. 设置内容
    当用户通过input输入
    {"backend":"www.oldboy.org", "record":{"server":"100.1.7.6","weight":20,"maxconn":30}}
    则在文件的backend www.oldboy.org 下新插入一条记录:
    serverstattask100.1.7.6 100.1.7.6 weight 20 maxconn 3000
# 注: 由于文件直接修改时会覆盖原有内容, 所以, 可利用同时打开两个文件, 边读边写, 当达到指定内容时, 将新内容插入.

36.附加题

1. 公鸡5文钱一只, 母鸡3文钱一只, 小鸡三只1文钱, 用100文钱买100只鸡, 其中公鸡, 母鸡, 小鸡都必须有, 问公鸡, 母鸡, 小鸡要买多少只刚好凑足100文钱

2. 猴子第一天摘下若干个桃子, 当即吃了一半, 还不过瘾就多吃了一个, 第二天早上又将剩下的桃子吃了一半, 还是不过瘾有多吃了一个, 以后每天都吃前一天剩下的一半再加一个. 到第10天刚好剩一个, 问猴子第一天摘了多少个桃子.