第二模块复习题

## 第二模块

3-5分钟总结第二模块学习内容+作业流程（作业可以看代码）
考核前，先考核第一模块内容

### 第一模块内容

1. 请写出 “路飞学城alex” 分别用 utf-8 和 gbk 编码所占的位数（口述）
　　uft-8：编码中文占3个字节，字母占1个字节，“路飞学城alex” 共占16个字节，共有16*8=128位
　　gbk：编码中文占2个字节，字幕占1个字节，“路飞学城alex” 共占12个字节，共有12*8=96位
2. python有哪几种数据类型，分别什么？哪些数据类型是有序的。
　　基本数据类型：数字（整数int，浮点float，长整型long），字符串（str和bytes），布尔bool
　　数据集：字典dict，元祖tuple，列表list，集合set
　　有序的：列表，字符串，元祖
3. 列表和字典的pop方法有什么区别。
　　列表的pop方法是删除最后一个值，字典的pop方法是删除指定的k值

### 第一套题

1. 对文件"02第二模块之三体语录"进行增删改查（文件操作编程）
　　''' 该语录视频没有讲解，我传到群文件了直接发给学员 '''
1. 查，使用seek(15)，和f.read(2)是什么字符，直接口述。
　　seek(15)打印的是15，read（2）打印的是前两个字符‘文明’
2. 把第三行的“不要回答”替换成“绝对不能回复”

# -*- coding:utf-8 -*-

import os


f = open('02第二模块之三体语录',encoding='utf-8')
f_new = open('02第二模块之三体语录.new','w',encoding='utf-8')
fl = f.read()
if '不要回答' in fl:
    f2 = fl.replace('不要回答', '绝对不能回复')
f_new.write(f2)
f.close()
f_new.close()
os.replace('02第二模块之三体语录.new','02第二模块之三体语录1')

View Code

3. 删掉最后一行

# -*- coding:utf-8 -*-

import os


f = open('02第二模块之三体语录',encoding='utf-8')
f_new = open('02第二模块之三体语录.new','w',encoding='utf-8')
fl = f.readlines()
for line in fl:
    if '25' in line:
        continue
    f_new.write(line)
f.close()
f_new.close()
os.replace('02第二模块之三体语录.new','02第二模块之三体语录1')

View Code

4. 解释一下替换过程发生了什么事情。

　　占硬盘的修改：以读的模式打开文件，再以写的模式打开一个新的文件；循环读文件，把要修改的替换掉；在新文件中写入每一行。

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

line_list = []
f = open('02第二模块之三体语录', encoding='utf-8')
f_new = open('02第二模块之三体语录', 'w', encoding='utf-8')
for line in f:
    line_list.append(line)
line_list.insert(5,'给岁月以文明，而不是给文明以岁月\n')
line_list_new = ''.join(line_list)
f_new.write(line_list_new)
f.close()
f_new.close()

View Code

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

line_list = []
f = open('02第二模块之三体语录', encoding='utf-8')
f_new = open('02第二模块之三体语录', 'w', encoding='utf-8')
for line in f:
    line_list.append(line)
line_list[-1] = '25、给时光以生命，而不是给生命以时光'
line_list_new = ''.join(line_list)
f_new.write(line_list_new)
f.close()
f_new.close()

View Code

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

def login(func):
    def inner(*args, **kwargs):
        username = input('username:').strip()
        password = input('password:').strip()
        with open('account', encoding='utf-8') as f:
            line = eval(f.read())
            if username == line['username'] and password == line['password']:
                print('认证成功！')
                ret = func(*args, **kwargs)
                return ret
            else:
                print('登录失败！')
        return inner

@login
def login1():
    print('login1')

@login
def login2():
    print('login2')

login1()
login2()

View Code

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 = [x*2 for x in li]
print(a)

View Code

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

　　效果一样

7. json和pickle的区别是什么？

　　json：只支持str、int、tuple、list、dict ；
　　pickle：支持python里的所有的数据类型；只能在python里使用。

9. 解释以下代码含义（口述）

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

　　从functools库中导入reduce模块，reduce函数会对参数序列中元素进行累积。

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

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

View Code

### 第二套

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

def login(engine):
    def outer(func):
        def inner(*args, **kwargs):
            i = 0
            while i < 3:
                username = input('username:').strip()
                password = input('password:').strip()
                if username == 'luffy' and password == 'city':
                    print('luffy登陆成功')
                    res = func(*args, **kwargs)
                    return res
                    break
                elif username == 'alex' and password == '3714':
                    print('alex登陆成功')
                    res = func(*args, **kwargs)
                    return res
                    break
                else:
                    print('登录失败')
                    i+=1
        return inner
    return outer

@login(engine='file')
def login1():
    print('Login file successfully!')
@login(engine='mysql')
def login2():
    print('Login mysql successfully!')
login1()
login2()

View Code

2. 解释一下“w”和“wb”的区别（“r”和“rb”，“a”和“ab”） (口述)
　　1. 让学员用代码形式边口述，边自行写

　　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' )

3. 描述写硬盘的编码转变（UTF-8格式，系统格式GBK） (口述)

　　系统文件先解码decode为Unicode，再编码encode为GBK的格式

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

f = open('A', encoding='utf-8')
f = f.read()
f1 = open('B', encoding='utf-8')
f1 = f1.read()
s = ''.join(sorted(f + f1))
f2 = open('C', 'w', encoding='utf-8')
f2.write(s)

View Code

5. 装饰器的必备条件是什么？（口述）

　　1不能修改被装饰函数的源代码;2不能修改函数的调用方式

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

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

1）可迭代对象包含迭代器。
2）如果一个对象拥有__iter__方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。
3）定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。

　　生成器: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）；
　　可以遍历字符串、列表、字典、数组等

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())
```

　　不一致，去掉空格就一致了

### 第三套

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

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

View Code

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

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

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. 写一个带参数的用户认证

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这个函数

View Code

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码

　　方法一

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)

View Code

　　方法二

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

View Code

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)

View Code

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)

View Code

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

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

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)

View Code

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

# -*- coding:utf-8 -*-

import time

def login(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        print('welcome')
        func()
        end_time = time.time()
        print('%s'% (end_time - start_time))
    return inner
@login
def login1():
    time.sleep(0.1)
    print('login1')


@login
def login2():
    time.sleep(1)
    print('login2')


@login
def login3():
    time.sleep(0.5)
    print('login3')


login1()
login2()
login3()

View Code

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)

View Code

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

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

# -*- coding:utf-8 -*-

import hashlib


i = 0
with open('account', encoding='utf-8') as f:
    line = eval(f.readline())
    username = input('username:').strip()
    password = input('password:').strip()
    pwd_md5 = hashlib.md5()
    pwd_md5.update(password.encode())
    if username in line['username'] and line['status'] == 0:
        while i < 3:
            if pwd_md5.hexdigest() == str(line['password']):
                print('登陆成功！')
                break
            else:
                print('登陆失败！还有%s次机会重试'% i)
                i += 1
                if i < 3:
                    password = input('password:').strip()
                else:
                    print('账户已被锁定')
                    line['status'] = 1
                    with open('account', 'w', encoding='utf-8') as f1:
                        f1.write(str(line))
                    break
    elif line['status'] == 1:
        print('账户已被锁定')
    else:
        print('账户不存在')

View Code

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'))

View Code

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

View Code

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

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

import time


def login(func):
    def inner(*args, **kwargs):
        username = input('username:').strip()
        password = input('password:').strip()
        if username == 'abc' and password == '123':
            start_time = time.time()
            print('登陆成功')
            func()
            end_time = time.time()
            print('耗时%s'%(end_time - start_time))
        else:
            print('登录失败')
    return inner

@login
def login1():
    time.sleep(1)
    print('login1')

@login
def login2():
    time.sleep(2)
    print('login2')

login1()
login2()

View Code

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('输入字符串:\n')
f.close()

View Code

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))

View Code

8. 匿名函数

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

ad = lambda x,y : x+y

View Code

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

View Code

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)

View Code

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）；
　　可以遍历字符串、列表、字典、数组等

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("\n".join([" ".join(["{}*{}={}".format(i, j, j*i) for j in range(1, i+1)]) for i in range(1, 10)]))

View Code

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)

View Code

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

# -*- coding:utf-8 -*-

import time
def timer(func):  #timer(test1)  func=test1
    def inner(*args, **kwargs):
        start_time = time.time()
        func()  #运行test1（）
        stop_time = time.time()
        print('the func run time is %s'%(stop_time - start_time))
    return inner
@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()  ## 实际上运行执行的是inner   #既没有改变调用方式也没有改变原代码
test2()
test3()

View Code

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)

View Code

　　相对路径直接 from Xx import models

20. os （）
请用os模块判断某个目录是否存在(例如: /user/lib/), 如果有不创建该目录, 反之则创建此目录
请用os模块获取一个文件的大小, 创建时间
　　判断path是否是一个目录：os.path.isdir(path)；
　　创建多级目录：os.makedirs（r“c：\python\test”）
　　创建单个目录：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')

View Code

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

def fib(n):
    if n < 2:
        return n
    else:
        return (fib(n - 1) + fib(n - 2))

print(fib(10))

View Code

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

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

View Code

27. 写装饰器（编程）

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

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

# -*- coding:utf-8 -*-

def login(func):
    def inner(*args, **kwargs):
        print('before')
        ret = func(*args, **kwargs)
        print('after')
        return ret
    return inner

@login
def func1(arg):
    return arg + 1

@login
def func2(arg1, arg2):
    return arg1 + arg2

print(func1(2))
print(func2(5, 6))

View Code

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('>>>').strip()
with open('demo.txt', encoding='utf-8') as f:
    line = f.readlines()
    if web == 'www.luffycity.com':
        line_new = line[6:9]
        print(line_new)

View Code

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\n'
for line in f1:
    if site in line:
        f1.insert((f1.index(site))+1,s)
    f_write.write(str(f1))

View Code

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

### 第一模块内容

### 第一套题

### 第二套

### 第三套

### 第四套

猜你喜欢