#1.已知变量a=1，b=2,将俩个变量交换。

a=1

b=2

#答

a,b=b,a

print(a,b)

#2、列举布尔值为False的常见值，比如0

print("1. ", bool(0))

print("2. ", bool(-0))

print("3. ", bool(None))

print("4. ", bool())

print("5. ", bool(False))

print("6. ", bool([]))

print("7. ", bool(()))

print("8. ", bool({}))

print("9. ", bool(0j))

print("10. ", bool(0.0))

#3、使用Restful API风格设计用户管理模块（用户列表、用户详情、新增用户、修改用户、删除用户）的url

#4、如下代码，求运行结果，如果将变量v的值改为v={‘k1’:[],‘k2’:[]}执行结果又是什么？

a=[]

# v= {‘k1’:a,‘k2’:a}

v={‘k1’:[],‘k2’:[]}

v[‘k1’].append(666)

print(v)

v[‘k1’]= 777

print(v)

#答 ‘’’ {‘k1’: [666], ‘k2’: []} {‘k1’: 777, ‘k2’: []} ‘’’

#5、已知变量s=“1,2,3”,一行代码将s转行为[1,2,3]

s=“1,2,3”

#答

print([int(x) for x in s.split(’,’)])

#6、已知a=[1,2,3],b=[(1),(2),(3)],c=[(1,),(2,),(3,)],比较a和b的区别以及b和c的区别。

a = [1,2,3]

b = [(1),(2),(3) ]

c = [(1,),(2,),(3,) ]

print(f’他们的类型都是：{type(a)},{type(b)},{type©}’)

print(f’其中元素类型为：{[type(x) for x in a]},{[type(x) for x in b]},{[type(x) for x in c]}’)

#7、已知有如下表结构，按要求写出相应的查询语句。 ‘’’ 用户表： 用户ID：id 用户名：username 用户角色：user_role

订单表： 订单ID：id 订单号：order_num 订单日期：order_date 用户ID：user_id ‘’’ #a、查询所有用户的订单列表，按订单号进行升序排序，列表字段：用户名、订单号

select user_name,order_num from 用户表 inner join 订单表 on 用户表.id = 订单表.user_id order by order_num;

#b、查询所有用户的订单数量列表，按订单数量倒序排序，列表字段：用户名、用户所有订单数量

select username,count(id) as total_order from 用户表 right join 订单表 on 用户表.id = user.id group by username

order by count(id) desc;

#8、实现一个函数def test（n），要求判断从1-n 的正整数型数字中，能被3整除则输出“中”，能被5整除的输出“国”，能被7整除的输出“人”，能被多个数字整除则输出相应的文字组合，不能整除的则只输出数字本身。 #例如：数字1输出“1”，数字3输出“中”，数字5输出“国”，数字7输出‘人’，数字15输出“中国”，数字105输出“中国人”

def test(n):

for item in range(1,n):

if item%3==0:

print(“中”)

if item%5==0:

print(“国”)

if item%7==0:

print(“人”)

else:

print(“这个数字是”,item)

if name == ‘main’:

test(106)

#9、实现一个函数，将一个不确定嵌套层数的列表，转换为一维列表，比如列表[1,2,[3,[4,[5,6],7],8],9]转化为[1,2,3,4,5,6,7,8,9]，不得使用内置高阶函数。 ‘’’ a = [1,2,[3,[4,[5,6],7],8],9] b = [] # 用来储存操作数

def dd(array): flag = 0 # 标记是否存在列表,0不存在 for item in array: if type(item) == list: flag = 1 break if flag != 1: # 如果不存在列表就把元素都加到b列表里，结束程序 for thing in array: b.append(thing) return 0 else: for i in range(len(array)): if type(array[i]) != list: b.append(array[i]) # 如果array里元素不是列表就加到b列表里 else: dd(array[i]) # 是列表就对该列表进行同母列表一样的操作 dd(a) a = b print(a)

‘’’ #10、简述你对装饰器的理解，并写出如下要求的装饰器：接收正整型n,捕捉被装饰函数的异常，若有异常则进行重试，最多重试n次，第n次打印异常信息。 “”" 理解：封装别的函数添加到增加使用的函数中，减少重复冗余代码。增加函数功能 “”"

‘’’ def wrapper(func): def inner(n): while n > 1: try: func(n) except Exception: pass else: break n -= 1 if n == 1: try: func(n) except Exception as e: print(“error:”,e)

return inner

‘’’

#11、通过定义相应的class，表达你对继承和多态的理解。

“”" class Superman(object): def init(self): print("\nI am super man.")

def fly(self): print("I can fly")

class ChildSuperman(Superman): def init(self): super(ChildSuperman,self).init() print(“I am more powerful!”)

def flash(self): print("I can flash")

a = Superman() a.fly()

b = ChildSuperman() b.fly() b.flash() “”" b继承a的超人属性和内置方法,这就是继承.但又是新的个体,他可以衍生出新的技能,这个个体可以有多个,各自有各自的个性(属性)和技能(方法),这就是多态 “”"

‘’’ 继承的定义

继承是指：可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

（1）通过继承创建的新类称为“子类”或“派生类”。

（2）被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现

‘’’ ‘’’ 多态（polymorphisn）——一种接口，多种形态

（1）定义

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，

赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 ‘’’