函数进阶练习题

### 第一模块内容

1. 请写出 “路飞学城alex” 分别用 utf-8 和 gbk 编码所占的位数（口述）
utf-8：一个中文字符占3个字节，英文字符占1个字节，则“路飞学城alex"一共16个字节，则共有16*8=128位。
gbk：一个中文占2个字节，英文字符占1个字节，则“路飞学城alex”一共12个字节，则共占12*8=96位

2. python有哪几种数据类型，分别什么？哪些数据类型是有序的。
基本类型有：数字（整数int、长整数long和浮点数float）、字符串（文本str和字节bytes）和布尔（True和False）；
数据集有：列表list、元组tuple、字典dict和集合set。
有序的：字符串、列表、元组等

3. 列表和字典的pop方法有什么区别。
列表的pop（）是删除最后一个；字典的pop（）要制定k值的删除。

### 第一套题

1. 对文件"02第二模块之三体语录"进行增删改查 （文件操作编程）
''' 该语录视频没有讲解，我传到群文件了 直接发给学员 '''
　　1. 查，使用seek(15)，和f.read(2)是什么字符，直接口述。
　　　　f = open('三体语录','r',encoding='utf-8')
　　　　f.seek(15) 打印出15,seek是找的字节；f.read(2)打印出1、，read读的是字符

　　2. 把第三行的“不要回答”替换成“绝对不能回复”

#方法一
import os
f = open('三体语录','r',encoding='utf-8')
f_new = open('三体语录.new','w',encoding='utf-8')
for line in f:
    if '不要回答' in line:
        line = line.replace('不要回答','绝对不能回复')
    f_new.write(line)
f.close()
f_new.close()
os.rename('三体语录.new','三体语录')

#方法二
f = open('三体语录','r+',encoding='utf-8')
f1 = f.readline()
f.seek(0)
for line in f1:
    if '不要回答' in line:
        line_new = line.replace('不要回答','绝对不能回复')
        f.write(line_new)
f.close()

　　3. 删掉最后一行

with open('三体语录','r',encoding='utf-8') as f:
    f1 = f.readlines()  ##readline是读一行 和readlines是读出所有行的区别
    with open('三体语录','w',encoding='utf-8')as f_w:
        for line in f1:
            if '25' in line:
                continue  #跳出本次循环
            f_w.write(line)

　　4. 解释一下替换过程发生了什么事情。
　　　　一种是在占硬盘的修改：以读的模式打开文件，再以写的模式打开一个新的文件；循环读文件，把要修改的替换掉；在新文件中写入每一行。
　　　　另外一种是在内存中修改：以读写的模式打开，先每一行的读出来，再把光标移到最开始，循环读到内存的，然后替换写入文件

　　5. 追加“给岁月以文明，而不是给文明以岁月”在第五行。（就是把其他的内容往下挤，不是覆盖第五行）

lines = []
f = open('三体语录','r',encoding='utf-8')
for line in f:
    lines.append(line)
lines.insert(5,'给岁月以文明，而不是给文明以岁月
')
s = ''.join(lines)
with open('三体语录','w',encoding='utf-8')as f_write:
    f_write.write(s)
    f_write.close()

　　6. 最后一行替换成“给时光以生命，而不是给生命以时光”

lines = []
f = open('三体语录','r',encoding='utf-8')
for line in f:
    lines.append(line)
print(lines)
lines[24] = '25、给时光以生命，而不是给生命以时光'
s = ''.join(lines)
with open('三体语录','w',encoding='utf-8')as f_write:
    f_write.write(s)
    f_write.close()

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

import time
a = time.localtime()
def logger(func):
    def inner():
        with open('用户名和密码','r',encoding='utf-8') as f:
            lis = eval(f.read())
        usename = input('请输入用户名:')
        passworld = input('请输入密码:')
        if usename == lis['_usename'] and passworld == lis['_passworld']:
            print('认证成功')
            func()
        else:
            print("您的输入有误")
    return inner
@logger
def log1():
    print("%s-%s-%s"%(a.tm_year,a.tm_mon,a.tm_mday))
def log2():
    time.sleep(2)
    print('%s-%s-%s' % (a.tm_year, a.tm_mon, a.tm_mday))
log1()
log2()

3. 函数的参数 （口述）
- 形参和实参的区别。
　　形参变量:只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。
　　实参可以是常量、变量、表达式、函数等，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
- 位置参数，默认参数，关键参数，非固定参数的顺序。
　　位置参数、关键参数、默认参数、非固定参数
- 解释下参数的作用。
　　参数可以让函数更灵活，还可以根据调用时传参的不同来决定函数内部的执行流程。
- 什么数据类型可以做实参。
常量、变量、表达式、函数等
4. 解释一下是否会报错，原因是什么？要是不报错打印什么值？报错的可以怎么改就不报错？ （口述）

```
def test():
print(luffy)
luffy = "the king of sea."
```
不会报错，也不会打印，没有调用函数。
```
def test():
print(luffy)
luffy = 'e'
luffy = "the king of sea."
不会报错，也不会打印，因为没有调用函数。
```
```
def test():
luffy = 'e'
print(luffy)
luffy = "the king of sea."
```
不会报错不会打印，没有调用。

5. li = [1,2,3,5,5,6,7,8,9,9,8,3] 利用生成器功能，写一个所有数值乘以2的功能。（编程）

li = [1,2,3,5,5,6,7,8,9,9,8,3]
a = [i*2 for i in li]
print(a)

6. isinstance('s',str) 与 tupe('s') is str 效果是否一样？（口述）

　　效果一样

7. 序列化-json，xml，pickle （口述）
　　json和pickle的区别是什么？
　　　　json：只支持str、int、tuple、list、dict ；
　　　　pickle：支持python里的所有的数据类型；只能在python里使用。
　　　　xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单,通过<>节点来区别数据结构.
8. 描述写硬盘的编码转变（UTF-8格式，系统格式GBK） (口述)
　　系统文件先解码decode为Unicode，再编码encode为GBK的格式

9. 解释以下代码含义 （口述）
```
from functools import reduce
reduce(lambda x,y:x+y,range(10))
```

from functools import reduce
reduce(lambda x,y:x+y,range(10))
print(reduce(lambda x,y:x+y,range(10)))

　　从functools库中导入reduce模块，reduce函数会对参数序列中元素进行累积。
　　reduce()函数返回一个值而不是一个list。首先需要定义一个需要对两个参数进行算数运算的函数。
　　reduce()函数首先会对list中的第一个value和第二个value进行这个算数运算，这会得到一个result。
　　之后它会对这个result和list中的第三个value进行这个算数运算得到一个新的result，最后得到最终的结果。

10. 打印日志11/26/2017 10:44:21 PM bug 24 并写入文件example.log中 （编程）

import logging
logging.basicConfig(filename='example.log',
level=logging.INFO,format='%(asctime)s %(message)s %(lineno)d',
datefmt='%m/%d/%Y %I:%M:%S %p')
                      # filemode=0o755,
logging.warning("bug")

顺便告诉学员linux创建目录时候可以使用filemode=0o755 来指定权限

### 第二套

1. 编写带参数装饰器auth，
装饰器参数engine='file'时，模拟用户名username='luffy',密码password='city'认证
装饰器参数engine='mysql'时，模拟用户名username='alex',密码password='3714'认证
错误达到三次时退出程序

def auth(engine):
    def outer(func):
        def inner(*args,**kwargs):
            i = 0
            while i < 3:
                username = input('Please input your username:')
                password = input('Please input your password:')
                if username == 'luffy' and password == 'city':
                    print('欢迎luffy登录成功')
                    res = func(*args,**kwargs)
                    return res
                    break
                elif username == 'alex' and password == '3714':
                    print('欢迎alex登录成功！')
                    resu = func(*args,**kwargs)
                    return resu
                    break
                else:
                    print('您的输入有误，请重新输入:')
                    i += 1
        return inner
    return outer
@auth(engine='file')
def login1():
    print('Login file successfully!')
@auth(engine='mysql')
def login2():
    print('Login mysql successfully!')
login1()
login2()

2. 解释一下“w”和“wb”的区别（“r”和“rb”，“a”和“ab”） (口述)
　　f = open('三体语录', 'r' ,encoding='utf-8') mode=r表示只读模式
　　f = open('三体语录', 'rb' ) mode=rb 表示二进制模式

　　文件操作时，以 “a”或“ab” 模式打开，则只能追加，即：在原来内容的尾部追加内容
　　写入到硬盘上时，必须是某种编码的0101010，打开时需要注意：
　　ab，写入时需要直接传入以某种编码的0100101，即：字节类型；
　　a 和 encoding，写入时需要传入unicode字符串，内部会根据encoding制定的编码将unicode字符串转换为该编码的 010101010
　　f = open('三体语录', 'a' ,encoding='utf-8')
　　f = open('三体语录', 'ab' ,encoding='utf-8')

3. 描述写硬盘的编码转变（UTF-8格式，系统格式GBK） (口述)
　　系统文件先解码decode为Unicode，再编码encode为GBK的格式

4. 有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中。(编程)

with open('test1','r',encoding='utf-8') as f1:
    a = f1.read()
f1.close()
f2 = open('test2','r',encoding='utf-8')
b = f2.read()
f2.close()

f3 = open('tes3','w',encoding='utf-8')
l = list(a + b)
l.sort()
s = ''
s = s.join(l)
f3.write(s)
f3.close()

5. 装饰器的必备条件是什么？（口述）
　　装饰器本质为函数（用来装饰其他函数）添加附加功能 
　　1不能修改被装饰函数的源代码;2不能修改函数的调用方式 
　　高阶函数+嵌套函数 = 装饰器 

6. 返回值 （口述）
- 默认的返回值是什么？ None
- 返回值的个数限制？ 没有
- 返回值的类型限制？ 没有

7. 迭代器和生成器的区别, 在python中它们的原理是什么。（口述）

　　生成器:generator是指这种一边循环一边计算的机制；
　　迭代器:Iterator是指可以被next()函数调用并不断返回下一个值的对象。
　　迭代器与生成器的区别:
　　　　迭代器由Class对象创建. 生成器由包含yield表达的Function对象或者Generator Expression创建.
　　迭代器的原理:
　　　　(1)由Iterable.__iter__()返回Iterator.
　　　　(2)由Iterator.__next__()返回迭代值, 直到StopIteration.
　　　　一般迭代器同时实现__iter__()与__next__(), 在__iter__()返回self, 在__next__()返回迭代值,直到StopIteration
　　生成器原理:
　　　　(1)生成器都有next(), send(), close(), throw()
　　　　(2)调用next()/send(V)执行到下一个yield表达式,并返回yield表达式结果. 如果是send(V)将用V代替yield表达式的值往下执行, next()等价send(None)
　　　　(3)生成器不允许return任何值.
8. str，list，tuple，len 方法的作用及其它们的区别在哪里?
　　　　str（）转成字符串，list（）转成列表，tuple（）转成元组，len（）返回长度或个数

9. enumerate的作用是什么？（口述）
　　enumerate可以遍历索引又可以遍历元素;enumerate还可以接收第二个参数;用于指定索引起始值如下面例子enumerate（list1,1）；
　　可以遍历字符串、列表、字典、数组等

list1 = [4,5,6,3,9,]
for index, item in enumerate(list1):
    print(index, item)

10. 以下两次打印是否一致,一致请说明缘由，不一致请问如何修改使两次打印一致。 （口述）
```
import hashlib
m = hashlib.md5()
m.update(b'luffy')
m.update(b' city')
print(m.hexdigest())
m2 = hashlib.md5()
m2.update(b'luffycity')
print(m2.hexdigest())
``` 
　　　　重复调用update(arg)方法，是会将传入的arg参数进行拼接，而不是覆盖。
　　　　也就是说，m.update(a); m.update(b) 等价于m.update(a+b)

import hashlib
m = hashlib.md5()
m.update(b'luffy')
m.update(b' city')
print(m.hexdigest())

print(hashlib.md5(b'luffycity').hexdigest())

### 第三套

1. 字符串“Luffy”，将小写字母全部转换成大写字母，将大写字母转换成小写字幕，然后输出到一个磁盘文件"test"中保存。(编程)

s = 'Luffy'
with open('test','w',encoding='utf-8') as f:
    f.write(s.swapcase())

2. 描述写硬盘的编码转变（UTF-8格式，系统格式GBK） (口述)
　　系统文件先解码decode为Unicode，再编码encode为GBK的格式

3. 作用域 （口述）
1. 什么是函数的作用域，举个例子说明一下。
　　限定这个名字的可用性的代码范围就是这个名字的作用域。
　　在python中一个函数就是一个作用域。无论在任何地方调用这个函数，永远回到它最开始的地方从上执行，往上找。
　　python中函数就是一个作用域，局部变量放置在其作用域中；代码完成后，作用域已经生成。
　　LEGB 代表名字查找顺序: locals ->enclosing function -> globals -> __builtins__
　　　　locals 是函数内的名字空间，包括局部变量和形参
　　　　enclosing 外部嵌套函数的名字空间
　　　　globals 全局变量，函数定义所在模块的名字空间
　　　　builtins 内置模块的名字空间

a = 8
b = 10
def outer():
    a = 0
    b = 1
    def inner():
        a = 10
        b = 11
    inner()
outer()
print(a,b)

2. 以下代码最终结果是什么？

```
a = 8
b = 10
def outer():
a = 0
b = 1
def inner():
a = 10
b = 11
inner()
outer()
print(a,b)
```
打印出：8 10

```
# 考察内存空间

a = [1,2,3]
def outer():
    a.append(5)
outer()
print(a)

```
打印出：[1,2,3,5]

4. 迭代器带来的好处是什么 （口述）
　　使用迭代器不要求事先准备好整个迭代过程中的所有元素。
　　迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后元素可以不存在或者被销毁。
　　因此迭代器适合遍历一些数量巨大甚至无限的序列。


5. 写一个带参数的用户认证

def auth_argu(t):
    def auth(func):
        def wrapper(*args,**kwargs):
            user = input("请输入用户名:").strip()
            pas = input('请输入密码:').strip()
            if user == 'luffy' and pas == 'city':
                res = func(*args,**kwargs)
                return res
        return wrapper
    return auth
@auth_argu(t = '传参')
def log1():
    print('登录成功')
log1()

6. 装饰器的原理是什么, 请简要说一下一个函数加一个装饰器执行的流程.（口述）
　　装饰器decorator只是将函数作为参数的函数。通常，它的作用是返回封装好的经过修饰的函数.
　　装饰器在执行的时候，把函数test1当做参数传给了timer函数，timer函数执行结果就是返回了一个func的内存地址 
　　执行函数test1的时候相当于是在调用deco

import time
def timer(func): #timer(test1) | func=test1，把test1的内存地址传给了func；然后开始执行timer这个函数，只是声明了一个变量。
　　def deco(): ##timer（test1）函数的执行结果就只返回了一个deco的内存地址
　　　　start_time = time.time()
　　　　func() #运行test1（）
　　　　stop_time = time.time()
　　　　print('the func run time is %s'%(stop_time - start_time))
　　return deco
@timer #--->> test1 = timer(test1) test1就相当于timer（test1）
def test1():
　　time.sleep(2)
　　print('in the test1')
test1() ##test1执行相当于调用的是deco，执行的是deco这个函数

7. 利用sys模块和os模块 py/bin/start.py （口述）

```
[root@web01 py]# tree
.
├── bin
│   └── start.py
├── conf
│   └── account.ini
└── core
└── main.py
```
在start.py执行以下代码，请阐述一下代码含义。
```
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
```
　　　　BASE_DIR是绝对路径。sys.path.append(BASE_DIR) 把它加到环境变量里边
　　　　程序在哪执行，当前路径就是那个，要想导入其他模块就要找到它的路径。

8. 利用内置函数chr(),ord()以及random模块写一个简单随机4位验证码 （编程）
chr 把ascii码换成对应的符号，ord把符号换成ascii码
方法1：

import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90)) #chr把ascii码换成对应的符号
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print(checkcode)

方法2：:

import random,string
source =  string.digits + string.ascii_lowercase
print("".join(random.sample(source,4)))

9. 写一个map函数 （编程）

a=map(lambda x:x+1 if x > 5 else x**2 ,[1,2,3,6,7,8])
for i in a:
    print(i)

10. 解释一下包和模块的含义。 （口述）

　　一个文件夹管理多个模块文件，这个文件夹就被称为包。 __init__ 把目录初始化成一个包。
　　在Python中，一个.py文件就称之为一个模块（Module）

### 第四套
1. 描述写硬盘的编码转变（UTF-8格式，系统格式GBK） (口述)
　　系统文件先解码decode为Unicode，再编码encode为GBK的格式

2. 编写sed功能，使用下面执行命令之后，“修改前的内容” 会被修改成 “修改后的内容”，该内容使用re模块进行匹配，不允许使用replace。 （编程）

```python
python3 sed.py 's#修改前的内容#修改后的内容#g' 修改文件名。
```

import sys,re
msg = sys.argv[1]  #sys.argv 命令行参数List，第一个元素是程序本身路径
filename = sys.argv[2]
    # msg = '  's#修改前的内容#修改后的内容#g'
old = re.search("'s#[^#]+#", msg).group()[3:-1]
new = re.search("#[^#]+#g", msg).group()[1:-2]
with open(filename,'r',encoding='utf-8')as f_read:
    with open(filename+".new","w",encoding='utf-8') as f_write:
        date_read = f_read.read()
        date_write = re.sub(old,new,date_read)
        f_write.write(date_write)

3. 简述内置函数globals() locals()的作用 （口述）

　　globals()获取当前代码里的所有全局变量；locals()获取当前代码里的所有局部变量

a = 12
b = 456
c = 789
d = globals()
print(d)

def f1():
    a = 123
    b = 456
    c = 789
    print(locals())
f1()

4. 利用内置函数 filter 和自定义函数获取l1大于33的所有元素 l1 = [11, 22, 33, 44, 55] （编程）

l1 = [11, 22, 33, 44, 55]
for i in filter(lambda x:x>33,l1):
    print(i)

5. 编写3个函数，每个函数执行的时间是不一样的，
提示：可以使用time.sleep(2)，让程序sleep 2s或更多。

import time
def timer(func):  #timer(test1)  func=test1
    def deco():
        start_time = time.time()
        func()  #运行test1（）
        stop_time = time.time()
        print('the func run time is %s'%(stop_time - start_time))
    return deco
@timer
def test1():
    time.sleep(2)
    print('in the test1')
@timer
def test2():
    time.sleep(3)
    print('in the test2')
@timer
def test3():
    time.sleep(4)
    print('in the test3')
#test1 = timer(test1)
test1()
#test2 = timer(test2)
test2()
test3()

6. 执行f.write()之后，会立刻写入磁盘吗？不会的话，有几种方式能让其写入磁盘中？ （口述）

　　执行write方法之后，会写在内存当中，想写入磁盘有三种方案 （写入缓冲区，解决程序写入硬盘慢的问题）
　　　　1. f.flush()，打印实时日志使用
　　　　2. f.close()
　　　　3. 关闭程序

7. 函数闭包 （口述） 
创建一个闭包函数需要满足哪几点：
　　　　必须有一个内嵌函数
　　　　内嵌函数必须引用外部函数中的变量
　　　　外部函数的返回值必须是内嵌函数

8. 写一个简单的加减乘除的函数。 (编程)

def calc(x,y):
    print(x+y)
    print(x-y)
    print(x*y)
    print(x//y)
calc(9,3)

9. 利用hashlib模块和open函数写一个三次验证代码，要求如下：（编程）
　　1. 密码是加密的。
　　2. 三次登陆失败锁定账号在文件当中。
　　3. 登陆成功：使用一个全局变量进行记录

文件：正确用户信息 {'alex':'e99a18c428cb38d5f260853678922e03','kris':'202cb962ac59075b964b07152d234b70'}
锁定信息 []

i = 0
import hashlib
file = open("正确用户信息",'r',encoding='utf-8')
file_wrong = open("锁定信息",'r+',encoding='utf-8')
line = eval(file.readline())
line_wrong = eval(file_wrong.readline())

name = input("请输入用户名:")
passworld = input("请输入密码:")
m = hashlib.md5()
m.update(passworld.encode())
if name in line and name not in line_wrong:
    while i <= 3:
        if m.hexdigest() == line[name]:
            print('登录成功')
            break
        else:
            i +=1
            print('
您已经第%d次输错密码,输错3次账户将会被锁定'%(i))
            if i < 3:
                passworld = input("请重新输入密码:")
            elif i == 3:
                print("已经输错3次,账户已被锁定")
                line_wrong.append(name)
                file_wrong.seek(0)
                file_wrong.write(str(line_wrong))
                #file_wrong.tell()
                break
elif name in line_wrong:
    print("该用户名已被锁定")
else:
    print("该用户名不存在")
    exit()

10. time、datetime 
将时间打印出成一个2017/10/01 18:08:15的格式
将 "2017-11-18" 17:43:43" 转换为 datetime的结构化时间 
import time
print(time.strftime('%Y/%m/%d %H:%M:%S'))

import datetime
d = datetime.datetime.now()
print(d)
print(d.day)
print(datetime.datetime(2017,11,18,17,43,43))

### 未整理
1. 编写装饰器，为每个函数加上统计运行时间的功能
提示：在函数开始执行时加上start=time.time()就可纪录当前执行的时间戳，函数执行结束后在time.time() - start就可以拿到执行所用时间

见上

2. 编写装饰器，为函数加上认证的功能，即要求认证成功后才能执行函数

import time
a = time.localtime()
def logger(func):
    def inner():
        _usename = 'kris'
        _passworld = 'abc123'
        usename = input('请输入用户名:')
        passworld = input('请输入密码:')
        if usename == _usename and passworld == _passworld:
            print('认证成功')
            func()
        else:
            print("您的输入有误")
    return inner
def log1():
    print("%s-%s-%s"%(a.tm_year,a.tm_mon,a.tm_mday))#13
@logger
def log2():
    time.sleep(2)
    print('%s-%s-%s' % (a.tm_year, a.tm_mon, a.tm_mday))
@logger
def log3():
    time.sleep(4)
    print('%s-%s-%s' % (a.tm_year, a.tm_mon, a.tm_mday))
log1()
log2()
log3() 

3. read,readline,readlines的区别 （口述）
　　

　　read([size])从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止。它的返回是字符串对象。
　　readline每次读取一行内容，所以读取时占用内存小，比较适合大文件。readline返回一个字符串对象。
　　readlines读取文件的所有行，保存在一个列表(list)变量中。每1个文件行作为一个list元素，但读取大文件会比较占内存。


4. 模拟登陆 （编程)
```
用户输入帐号密码进行登陆
用户信息保存在文件内
用户密码输入错误三次后锁定用户，下次再登录，检测到是这个用户也登录不了
```

见上

5. 从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。 （编程）

filename = input('输入文件名:')
f = open(filename , "w+")
ch = ''
while '#' not in ch:
    f.write(ch)
    ch = input('输入字符串:
')
f.close()

6. 函数的作用（特性/好处）.（口述）
　　函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
　　特性:减少重复代码；使程序变的可扩展；使程序变得易维护。

7. 递归函数 （编程）
实现递归函数的条件有那些？
递归实现阶乘1*2*3*4*5*6*7 （获取最终阶乘的答案）
　　必须有一个明确的结束条件；每次进入更深一层递归时，问题规模相比上次递归都应有所减少

def calc(n):
    if n < 2:
        return 1
    else:
        return n *calc(n-1)
print(calc(7))

1. 快速找到26，不使用index等内置方法。二分法使用（编程）
[1,4,6,8,9,11,26,34,56,58,72,88]

data = [1,4,6,8,9,11,26,34,56,58,72,88]
if len(data) >1:
    mid = int(len(data)/2)
    if data[mid] == 26:  #find it
        print("找到数字",data[mid])
    elif data[mid] > 26:
        print('我找的数在左边')
###########################
data = [1,4,6,8,9,11,26,34,56,58,72,88]
def binary_search(dataset,find_num):
    print(dataset)
    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("33[31;1m找的数在mid[%s]左面33[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("33[32;1m找的数在mid[%s]右面33[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)
binary_search(data,26)

8. 匿名函数
```
def func(x, y):
return x+y
```
使用lamda表达上面函数。 （编程）

　　ad = lambda x,y : x+y

9. 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。 （编程）
　　当n > 2时，跳上n级台阶最后一步无外乎两种情况，从第n-1级跳一级跳上来，或是从第n-2级跳2级跳上来，
　　因此很容易得到如下递归公式。
　　F（0）= 0
　　F（1）= 1
　　F（2）= 2
　　F（n）= F（n-1）+ F（n-2）（n > 2）

def jump_floor(n):
    if n <= 2:
        return n
    pre , cur = 1 ,2
    for i in range(3,n+1):
        pre ,cur = cur ,pre+cur
    return cur

10. 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。(编程）
相比上一个跳台阶，这次可以从任意台阶跳上第n级台阶，也可以直接跳上第n级。
因此其递归公式为各个台阶之和再加上直接跳上去的一种情况。
F（0）= 0
F（1）= 1
F（2）= 2
F（n）= F（n-1）+ F（n-2）+ … + F（2）+ F（1）+ 1 = 2 **（n-1）

def jump_floor(n):
    if n == 0:
        return 0
    return 2**(n-1)

11. int, long, float, complex 方法的作用及其它们的区别在哪里
　　int（X）转换X到一个普通整数。
　　long（X）转换X到一个长整数。
　　float（X）转换X到浮点数字。
　　complex（x）的转换与真正的第X部和虚部为零的x到一个复杂的数量。 
　　类型复杂（X,Y）转换x和y的第X部和虚部Ÿ复数。x和y是数值表达式内置数功能

12. eval （口述）
- eval的作用的是什么, 它有什么弊端 
　　eval（）把字符串转换成代码;只能处理单行代码

13. enumerate的作用是什么？（口述）
　　enumerate可以遍历索引又可以遍历元素;enumerate还可以接收第二个参数;用于指定索引起始值如下面例子enumerate（list1,1）；
　　可以遍历字符串、列表、字典、数组等

list1 = [4,5,6,3,9,]
for index, item in enumerate(list1):
    print (index, item)

14. iter和next的作用是什么？（口述）
　　通过next()函数获得生成器generator的下一个返回值；
　　可以通过iter()函数获得一个迭代器Iterator对象。

15. format （编程）
- format的格式化方式有那些, 它和python的 %s 格式化参数有什么区别
- 请用format + 列表生成式 + 字符串的某个方法实现 python 一句话生成 99乘法口诀表
　　format基本语法是通过 {} 和 : 
　　　　format 函数可以接受不限个参数，位置可以不按顺序。
　　　　"{} {}".format("hello", "world") #不设置指定位置，按默认顺序
　　　　"{0} {1}".format("hello", "world") #设置指定位置 
　　　　print('my name is {name},age is {age}'.format(name='hoho',age=18)) ##使用关键字参数
　　　　%s只表示字符串 print("my name is %s and I am %d years old" %("xiaoming",18))

print("
".join([" ".join(["{}*{}={}".format(i, j, j*i) for j in range(1, i+1)]) for i in range(1, 10)]))

16. 利用subprocess打印出当前目录（输入两条命令，一条是正确的，windows：dir linux：ls 一条是错误的。）

import subprocess
cmd_obj = subprocess.Popen('dir %s' %self.user_current_dir,
                               shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
stdout  = cmd_obj.stdout.read().strip()
stderr = cmd_obj.stderr.read().strip()
cmd_result = stdout+stderr
print(cmd_result)

18. 自定义模块"three_func":该模块里有三个函数,并给该模块取个别名"func_3" （编程）
1. 打印当前时间。
2. 一个计时装饰器
3. 写一个函数：说明一下作用域问题

import time
def timer(func):  #timer(test1)  func=test1
    def deco():
        start_time = time.time()
        func()  #运行test1（）
        stop_time = time.time()
        print('the func run time is %s'%(stop_time - start_time))
    return deco
@timer
def test1():
    time.sleep(2)
    print(time.asctime())
@timer
def test2():
    time.sleep(3)
    print(time.asctime())
@timer
def test3():
    time.sleep(4)
    print(time.asctime())
test1()  ## 实际上运行执行的是deco    #既没有改变调用方式也没有改变原代码
test2()
test3()

19. 导入模块：使用绝对路径和相对路径进行导入(使用os和sys模块进行绝对路径导入) （口述）

import sys,os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(_file_))) #这是绝对路径
print(BASE_DIR)
sys.path.append(BASE_DIR)

相对路径直接 from Xx import models


20. os （）
请用os模块判断某个目录是否存在(例如: /user/lib/), 如果有不创建该目录, 反之则创建此目录
请用os模块获取一个文件的大小, 创建时间
　　判断path是否是一个目录：os.path.isdir(path)；
　　创建多级目录：os.makedirs（r“c：python est”）
　　创建单个目录：os.mkdir（“test”）
　　修改文件权限与时间戳：os.chmod（file）
　　获取文件大小：os.path.getsize（filename）



21. shelve （口述）
shelve作用是什么？
　　shelve模块是对pickle进行封装，是一种k v的格式。
　　简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式 
22. logging （口述）
1. logging模块写日志时如何指定写入文件编码？

import logging
logging.FileHandler("access.log",encoding='utf-8')

23. re （编程）
利用re模块

```
124.127.244.4 - - [07/Nov/2017:10:15:02 +0800] "GET /api/v1/interested_tag/ HTTP/1.0" 200 188 "http://www.luffycity.com/" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
124.127.244.4 - - [07/Nov/2017:10:15:02 +0800] "GET /api/v1/industry/ HTTP/1.0" 200 456 "http://www.luffycity.com/" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
124.127.244.4 - - [07/Nov/2017:10:15:02 +0800] "GET /api/v1/ip_info/ HTTP/1.0" 200 111 "http://www.luffycity.com/" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
124.127.244.4 - - [07/Nov/2017:10:15:02 +0800] "GET /api/v1/province/ HTTP/1.0" 200 423 "http://www.luffycity.com/" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
124.127.244.4 - - [07/Nov/2017:10:15:02 +0800] "GET /api/v1/captcha_check/?t=1510020901753 HTTP/1.0" 200 122 "http://www.luffycity.com/" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
```
把IP地址过滤出来。 

import re
f = open('过滤IP地址','r',encoding='utf-8')
data = f.read()
reip = re.compile(r'(?<![.d])(?:d{1,3}.){3}d{1,3}(?![.d])')
for ip in reip.findall(data):
    print( "ip>>>", ip)    

24. 用python函数实现一个斐波那契数列 （编程）

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

25. 用python函数实现计算某个数的最大公约数 （编程）

def hcf(x, y):
   # 获取最小值
   if x > y:
       smaller = y
   else:
       smaller = x
   for i in range(1,smaller + 1):
       if((x % i == 0) and (y % i == 0)):
           hcf = i
   return hcf
# 用户输入两个数字
num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))
print( num1,"和", num2,"的最大公约数为", hcf(num1, num2))

26. 利用map和自定义函数将所有是奇数的元素的和 l1 = [1, 2, 3, 5, 11, 12, 14, 19] （编程）

li = [1,2,3,5,11,12,14,19]
t = sum(map(lambda x:x if x % 2 == 0 else 0,li))
print(t)

27. 写装饰器（编程）

如下有俩个函数, 请书写一个装饰器实现在不改变函数调用者代码的基础上, 实现在函数执行前后分别打印 "before" 和 "after"

```
def func1(arg):
return arg + 1
def func2(arg1, arg2):
return arg1 + arg2
```

def print_msg(func):
    def wapper(*args,**kwargs):
        print("before")
        back = func(*args,**kwargs)
        print("after")
        return back
    return wapper
@print_msg
def func1(arg):
    return arg + 1
@print_msg
def func2(arg1,arg2):
    return arg1 + arg2
print(func1(1))
#print(func2(2,3))

28. 文件操作: （编程）

文件 demo.txt 如下:

```
global 
log 127.0.0.1 local2 
daemon 
maxconn 256

backend www.luffycity.com
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.luffycity.com 
server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000 
```
a. 用户input输入 www.luffycity.com 则将其以下内容添加到列表返回给用户(终端)
既:

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

web = input("请输入网址:")
if web == 'www.luffycity.com':
    with open('demo.txt','r',encoding='utf-8')as f:
        f1 = f.readlines()
        l1 = f1[5:8]
        print(l1)
    

b. 设置内容, 用户通过输入 input输入

```
{"backend": "www.luffycity.com","record":{"server": "100.1.7.6","weight": 20,"maxconn": 30}} 
```
则在文件的 backend www.luffycity.com 下新加入一条记录

``` 
backend www.luffycity.com 
server 100.1.7.6 100.1.7.6 weight 20 maxconn 3000 
```

s = input("请输入要添加的内容:")
f_read = open('demo.txt','r',encoding='utf-8')
f_write = open('demo_new.txt','w',encoding='utf-8')
f1 = f_read.readlines()
print(f1)
site = 'backend www.luffycity.com
'
for line in f1:
    if site in line:
        f1.insert((f1.index(site))+1,s)
    f_write.write(str(f1))

注: 由于文件直接修改时会覆盖原有内容, 所以可利用同时打开俩个文件, 边读边写到达指定位置时, 插入此数据。