"""
# 练习题 考试时间4h
# 一、简答题(30)
# 1、常用字符串格式化的方式有哪些?并说明他们的区别(4)
# 2、L = range(100) （4分）
# 1) 取第一到第三个元素_______
# 2) 取倒数第二个元素_______
# 3) 取后十个元素_______
# 4) 把L复制给L1用_______
# 3、解释python中深拷贝和浅拷贝的区别(2)
# 4、Python中定义函数时如何书写可变参数和关键字参数？(2)
# 5、装饰器是什么时候被执行的(3)
# 6、简述面向对象的三大特性分别是什么，以及主要功能(5)
# 7、利用python打印指定时间的时间戳时间，时间为"1989-12-25"（面试题）(4)
# 8、python中如何实现随机整数的取值？默认的随机数范围是多少？(2)
# 9、在类中使用classmethod装饰的方法被存储在哪块内存中,使用什么调用？参数有什么特点？(3)
# 10、说明__init__和__new__的作用(2)
# 11、简述反射是怎么回事？(3)
# 12、新式类和经典类(旧式类)的区别(4)一种一分
# 13、如何使用python删除一个文件（2）
"""
# 一、简答题(30)
# 1、常用字符串格式化的方式有哪些?并说明他们的区别(4)
"""
答:有两种,
第一种,利用%号占位符来实现,类似print("%s 是老男孩教育的%s" %(name,job))
第二种,利用.format来实现 ,类似 "{n}是老男孩教育的{n}".format(name,job)
不同之处是%号变量只能是位置变量,format可以通过在{}设置位置来传递位置.或者加关键字参数
"""
# 2、L = range(100) （4分）
# 1) 取第一到第三个元素_______ print(list(L)[:3])
# 2) 取倒数第二个元素_______ print(list(L)[-2])
# 3) 取后十个元素_______ print(list(L)[-10:])
# 4) 把L复制给L1用_______
#import copy
#L1 = copy.deepcopy(L)
# 3、解释python中深拷贝和浅拷贝的区别(2)
"""
深拷贝: 拷贝后的值全部都是新的内存空间,没有共用老的数据的内存空间,包括原有数据内的嵌套类型.
浅拷贝: 只有第一层是新的内存空间,内部嵌套数据都是共用老的内存空间.
"""
# 4、Python中定义函数时如何书写可变参数和关键字参数？(2)
"""
是通过*args,和**kwargs来接收可变位置参数,和可变关键字参数的.
*args接收到后,在函数内部把参数传为元组,**kwargs 接收后,传到函数内部为字典
"""
# 5、装饰器是什么时候被执行的(3)
"""
答:
装饰器是在函数执行前被执行,根据装饰器里面的设置,部分内容是在函数前执行,部分内容在函数后执行.
"""
# 6、简述面向对象的三大特性分别是什么，以及主要功能(5)
"""
三大特性:
1.多态
2.继承
3.封装
1.多态或者鸭子类型
是指不同的类调用相同的方法.
2.继承
是指子类继承父类的所有.
在python中分为单继承和多继承.
3.封装
封装包含给对象封装属性,和给一个类封装静态变量和方法以及私有成员
"""
# 7、利用python打印指定时间的时间戳时间，时间为"1989-12-25"（面试题）(4)
"""
import time
ft = "1989-12-25"
st = time.strptime(ft,"%Y-%m-%d")
t = time.mktime(st)
print(t)
"""
# 8、python中如何实现随机整数的取值？默认的随机数范围是多少？(2)
"""
通过random.randint方法来实现
print(random.randint(1,10)) # 1<=x<=10 整数
默认随机数
random.random() #范围是0到1之间的小数
"""
# 9、在类中使用classmethod装饰的方法被存储在哪块内存中,使用什么调用？参数有什么特点？(3)
"""
classmethod 是类方法,存储在类的内存当中.通过类名加方法调用.参数传入的是类.形参为cls
"""
# 10、说明__init__和__new__的作用(2)
"""
__init__ 这个方法是初始化对象时调用,给对象封装属性用的
__new__ 这个方法也是在初始化对象时调用,在__init__之前调用.返回一个对象空间.
"""
# 11、简述反射是怎么回事？(3)
"""
反射:通过 字符串 操作一个空间 (对象).
总共有四个方法:
1.getattr()
2.hasattr()
3.setattr()
4.delattr()
"""
# 12、新式类和经典类(旧式类)的区别(4)一种一分
"""
1.新式类默认继承object ,
2.新式类的继承时,广度优先,
3.旧式类在继承时,深度优先
4.旧式类默认不继承object类
"""
# 13、如何使用python删除一个文件（2）
"""
import os
os.remove("file.path")
"""
# 二、读程序(20)
# 1、下面程序的输出结果是：（3分）
# d = lambda p: p * 2
# t = lambda p: p * 3
# x = 2
# x = d(x)
# x = t(x)
# x = d(x)
# print x
"""
结果为24
"""
# 2、以下的代码的输出将是什么:___(3分)
#
# def extendList(val,list = []):
# list.append(val)
# return list
# list1 = extendList(10)
# list2 = extendList(123, [])
# list3 = extendList(‘a’)
# print “list1 = % s” % list1
# print “list2 = % s” % list2
# print “list3 = % s” % list3
"""
list1 = [10,'a']
list2 = [123]
list3 = [10,'a']
"""
# 3、sum的结果是多少？（3）
# Kvps = {‘1’:1,’2’:2}
# theCopy = kvps
# kvps[‘1’] = 5
# sum = kvps[‘1’] + theCopy[‘1’]
# Print sum
"""
10
"""
#4、自定义一个类，并实例化。使用反射给对象添加一个属性name，值为你的名字。使用反射查看name的值。(5分)
"""
class A:
def __init__(self,*args):
self.age = args[0]
ob1 = A(18)
setattr(ob1,"name","leon")
print(getattr(ob1,"name"))
"""
# 5、读程序，使用注释标注执行顺序，并说出下列代码的结果以及产生这样结果的原因？(4)
# class Base:
# def __init__(self): (1)
# self.func()
#
# def func(self):
# print('in base')
#
# class A(Base):
# Country = 'China' (2)
# print(Country) (3)
#
# def func(self): (4)
# print('in A')
#
# A()
"""
China
in A
上面是执行结果,在执行顺序见上面标注
"""
# 6、简述下列代码的输出以及输出的原因(2)
# class A:
# def __init__(self,name):
# self.__name = name
#
# @@property
# def name(self):
# return self.__name
# @name.setter
# def name(self,new_name):
# print(new_name)
#
# obj = A('alex')
# obj.name = 'egon'
# print(obj.name)
"""
egon
alex
# obj.name = 'egon' 这个类用到了属性封装.这句话实际执行了@name.setter下面的函数,并把值传给了new_name.
# print(obj.name) 这个执行了@property下面的函数,然后返回的.self.__name
"""
# 三、编程题(50)
# 1、用至少2种不同的方式删除一个list里面的重复元素,列表如下:(5)
# a = [1, 2, 2, 4, 34, 3, 4, 56, 65, 456, 5, 6456, 456, 54, 45, 6, 464, 564](5)
"""
a = [1, 2, 2, 4, 34, 3, 4, 56, 65, 456, 5, 6456, 456, 54, 45, 6, 464, 564]
b = set(a)
c = list(b)
print(c)
或者下面方法
lst = []
for i in a:
if i not in lst:
lst.append(i)
print(lst)
"""
# 2、使用python简单实现打印九九乘法表(5)
"""
for i in range(1,10):
for n in range(1,i+1):
print("{} * {} = {} ".format(n,i,n*i),end="")
print()
"""
# 3、写一个单例模式(5)
"""
class A:
__instance = None
def __new__(cls, *args, **kwargs):
if A.__instance is None:
A.__instance = object.__new__(cls)
return A.__instance
"""
# 4、面向对象编程(15)
"""
一：定义一个学生类。有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义2个同学测试下:
zm = Student('zhangming',20,[69,88,100])
返回结果：
zhangming
20
100
"""
"""
class Student:
def __init__(self,*args):
self.__name = args[0]
self.__age = args[1]
self.__score = args[2]
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def get_course(self):
return max(self.__score)
zm = Student("leon",20,[90,88,70])
print(getattr(zm,"get_name")())
print(getattr(zm,"get_age")())
print(getattr(zm,"get_course")())
"""
# 5、斐波那契数列1, 2, 3, 5, 8, 13, 21.....根据这样的规律，编程求出400万以内最大的斐波那契数，并求出他是第几个斐波那契数。(5)
"""
count = 0
def fun(n,m):
global count
if m > 4000000:
print(count)
print(n)
return
x = n + m
count += 1
fun(m,x)
fun(1,2)
结果如下:
31
3524578
"""
# 6、要求写一段代码，实现两个字典的相加，不同的key对应的值保留，相同的key对应的值相加后保留，如果是字符串就拼接，如上示例得到结果为：（5）
"""
dicta = {"a": 1, "b": 2, "c": 3, "d": 4, "f": "hello"}
dictb = {"b": 3, "d": 5, "e": 7, "m": 9, "k": "world"}
dictc = {}
for i in dicta:
dictc[i] = dicta[i]
for i in dictb:
if i not in dicta:
dictc[i] = dictb[i]
else:
dictc[i] = dicta[i] + dictb[i]
print(dictc)
"""
# 7、写函数完成抢"拼手气"红包函数，用户输入红包金额和个数，返回随机的红包金额，使得规定个数红包的总额达到红包金额。(5)
"""
lst = []
def fun(m,n):
global lst
if n == 1:
lst.append(m)
return lst
x = random.random() * m
lst.append(x)
y = m -x
n = n -1
fun(y,n)
fun(10,10)
print(lst)
"""
# 8、写函数完成计算文件夹大小的需求,文件夹中可能还有其他文件和文件夹(5)
"""
import os
lst_tmp = []
def fun(dirpath):
global lst_tmp
abs_path = os.path.abspath(dirpath)
lst = os.listdir(abs_path)
for i in lst:
i = os.path.join(dirpath,i)
if os.path.isfile(i):
lst_tmp.append(os.path.getsize(i))
elif os.path.isdir(i):
fun(i)
fun("dir1")
sum = 0
for i in lst_tmp:
sum = sum + i
print(sum)
"""
# 附加题（20）
# 1.有一个数据结构如下所示，请编写一个函数从该结构数据中返回由指定的字段和对应的值组成的字典。如果指定字段不存在，则跳过该字段。
# data:{"time": "2016-08-05T13:13:05",
# "some_id": "ID1234",
# "grp1": {"fld1": 1,
# "fld2": 2},
# "xxx2": {"fld3": 0,
# "fld5": 0.4},
# "fld6": 11,
# "fld7": 7,
# "fld46": 8}
# fields:由
# "|"
# 连接的以
# "fld"
# 开头的字符串, 如:fld2 | fld3 | fld7 | fld19
#
data ={"time": "2016-08-05T13:13:05",
"some_id": "ID1234",
"grp1": {"fld1": 1,
"fld2": 2},
"xxx2": {"fld3": 0,
"fld5": 0.4},
"fld6": 11,
"fld7": 7,
"fld46": 8}
fields = "fld2 | fld3 | fld7 | fld19"
def select(data, fields):
# TODO:implementation
fields = fields.replace(" ","")
ret = fields.split("|")
dic = data.copy()
dic_tmp = {}
for i in data:
if type(data[i]) == dict:
dic.update(data[i])
for i in ret:
if i in dic:
dic_tmp[i] = dic[i]
return dic_tmp
ret = select(data, fields)
print(ret)
# 2.以下代码的输出是什么？请给出答案并解释。
# def multipliers():
# return [lambda x: i * x for i in range(4)]
#
# print(m\[m(2)
# for m in multipliers()])
# 请修改multipliers的定义来产生期望的结果。
# def multipliers():
# return (lambda x:i*x for i in range(4))
# for m in multipliers():
# print(m(2))
# • 现有两元组(('a'), ('b')), (('c'), ('d')), 请使用python中匿名函数生成列表[{'a': 'c'}, {'b': 'd'}]
# tu1 = (('a'), ('b'))
# tu2 = (('c'), ('d'))
# p = map(lambda x:{tu1[x]:tu2[x]},range(2))
# print(list(p))
