python基础,函数,面向对象,模块练习

---恢复内容开始---

python基础,函数,面向对象,模块练习

1,简述python中基本数据类型中表示False的数据有哪些?

#　 [] {} () None 0

2,位和字节的关系?

#　1 字节=8位

3,字符串和列表如何相互转换?
#　字符串转列表： list('fku3ksjf'

#　列表转字符串： "".join(['xx','x1','x2'])　　# 内部需要是字符串

4,写代码实现字符串反转，如：v = ‘oldboy’
#　　v[::-1]
#　　注：其他方式也可以

5,.python 递归的最大层数？

#　　998 或 10

6, 列举 Python2 和 Python3 的区别？

#　　py2：unicode、bytes(str)
#　　py3: str 、bytes
#　　等

7, 用一行代码实现数值交换：
#　　a = 1
#　　b = 2
#　　a,b = b,a

8,请给出代码运次的结果

print(type(1))
print(type("1"))
print(type(1,))

#　　<class 'int'>
#　　<class 'str'>
#　　<class 'int'>

9,求结果:

v = [lambda:x for x in range(10)]print(v[0]())

# 9

.10, re 的 match 和 search 区别？
#　　match()函数只检测 RE 是不是在 string 的开始位置匹配，在 0 位置匹配成功的话才有返回不是
#　　的话返回 NONE
#　　search()会扫描整个 string 查找匹配

11,请编写一个闭包程序

#　　def funx():

　　　　 x=5

　　　　def funy():

　　　　　　nonlocal x

　　　　　　 x+=1

　　　　　　return x

　　　　 return funy

12,简述面向对象的三大特性并用代码说明？
#　　封装：数据封装到对象；方法封装到类
#　　继承：多个类中都有的方法提取到父类中
#　　多态：函数的参数可以是多重形态，如：def func(arg):arg.send()

13,列举面向对象所有成员并用代码表示。

#　　变量：实例变量、类变量（字段：字段、静态字段也可以）
#　　方法：实例方法、静态方法、类方法
#　　属性：属性

14,看代码写结果

class StarkConfig(object):
    def __init__(self,num):
        self.num = num
    def run(self):
        self()
    def __call__(self,*args,**kwargs):
        print(self.num)

class RoleConfig(StarkConfig):
    def __call__(self,*args,**kwargs):
        print(345)

    def __getitem__(self,item):
        return self.num[item]

v1 = RoleConfig("alex")
v2 = StarkConfig("wupeiqi")
print(v1[1])
print(v2[2])

#  1
#　报错

15,看代码写结果

class F3(object):
    def f1(self):
        ret = super().f1()
        print(ret)
        return 123
class F2(object):
    def f1(self):
        print("123")
class F1(F3,F2):
    pass

obj = F1()
obj.f1()

#　　123
#　　None

16,看代码写结果

class UserInfo(object):
    pass
class Department(object):
    pass
class StarkConfig(object):
    def __init__(self,num):
        self.num = num
    def changelist(self,request):
        print(self.num,request)
    def run(self):
        self.changelist(999)

class RoleConfig(StarkConfig):
    def changelist(self,request):
        print(666,self.num)

class AdminSite(object):
    def __init__(self):
        self._registry = {}
    def register(self,k,v):
        self._registry[k] = v(k)

site = AdminSite()
site.register(UserInfo,StarkConfig)
site.register(Department,RoleConfig)
for k,row in site._registry.items():
    row.run()

#　　<class '__main__.UserInfo'> 999
#　　666 <class '__main__.Department'>

17,msg = '123.33sdhf3424.34fdg323.324',计算字符串中所有数字的和（2 分）
　　本题结果应为：123.33+3424.34+323.32

#通过正则获取到所有数字，然后数字

18,python特殊方法
#　　__init__初始化实例对象的属性/__call__/__dict__/__enter__/__exit__/ getitem__/__setitem__/__delitem__/__add__/__new__

19,函数和方法如何区分

#　　与类和实例无绑定关系的function都属于函数（function）；

#　　与类和实例有绑定关系的function都属于方法（method）。

20,简述：isinstance、issubclass、callable、type 的作用
#　　isinstance, 判断对象是否是某个类以及其派生类的对象
#　　issubclass,判断某各类是否是指定类的派生类。
#　　callable，判断某个对象是否可以被执行，即：加括号。
#　　type, 获取对象所属于的类

21,看代码写结果:

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display

class RoleConfig(StarkConfig):
    list_display = [11,22]

s1 = StarkConfig()
s2 = RoleConfig()

result1 = s1.get_list_display()
print(result1)
result2 = s2.get_list_display()
print(result2)

# [30]
# [30,11,22]

22,简述反射的作用并列举反射相关的所有方法。
#　　反射，用于根据字符串的形式去指定对象中获取其成员。
#　　getattr/setattr/delattr/hasattr

23,看代码写结果:

class Foo(object):
    def __init__(self):
        self.name = "周杰伦"
        self.age = 100
        self.email = "jay@hehe.com"

obj = Foo()
setattr(Foo,"email","jay@hehe.com")

v1 = getattr(obj,"email")
v2 = getattr(Foo,"email")
print(v1,v2)

# jay@hehe.com jay@hehe.com

24,如何自定义异常

#　　写一个类且需要继承 Exception
#　　主动触发异常使用 raise XXException()
#　　捕捉异常使用： try … except XXException as e:

25,python 中应该如何约束派生类中指定的方法并编写示例代码？

#　　用异常，如：
#　　class Base:
#　　　　def send(self):
#　　　　raise NotImplementedError()
#　　class Message(Base):
#　　　　def send(self):
#　　　　　　pass

26,列举你了解的 5 个模块并简述其作用。
#　　logging,日志
#　　hashlib,加密
#　　re, 正则
#　　time,时间处理
#　　json,序列化

27,yield和return有什么区别?

#　　yield是用于生成器。什么是生成器，你可以通俗的认为，在一个函数中，使用了yield来代替return的位置的函数，就是生成器。它不同于函数的使用方法是：函数使用return来进行返回值，每调##用一次，返回一个新加工好的数据返回给你；yield不同，它会在调用生成器的时候，把数据生成object，然后当你需要用的时候，要用next()方法来取，同时不可逆。你可以通俗的叫它"轮转容器"，#可用现实的一种实物来理解：水车，先yield来装入数据、产出generator object、使用next()来释放；好比水车转动后，车轮上的水槽装入水，随着轮子转动，被转到下面的水槽就能将水送入水道中流#入田里。

#　　return
#这个大家都知道了，一句话，return既可以终止函数的执行，也可以返回函数加工处理好的数据，只是这个数据需要一个载体来进行保存，通常是变量。非条件判断的时候，只要遇见return，函数就结#束执行。

28,简述super和self的作用
　　1. super并不是一个函数，是一个类名，形如super(B, self)事实上调用了super类的初始化函数，
       产生了一个super对象；
　　2. super类的初始化函数并没有做什么特殊的操作，只是简单记录了类类型和具体实例；
　　3. super(B, self).func的调用并不是用于调用当前类的父类的func函数；
　　4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用，而且保证每个父类函数
       只调用一次（如果每个类都使用super）；
　　5. 混用super类和非绑定的函数是一个危险行为，这可能导致应该调用的父类函数没有调用或者一
       个父类函数被调用多次。

29,简述global和nonlocal的作用

　　global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字

　　 nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量

30,编写代码,删除列表中所有姓张的人

　　lst = ["张无忌","胡辣汤","张三丰","赵铁柱","牛栏山"]

lst = ['张无忌', '胡辣汤', '张三丰', '赵铁柱', '牛栏山']

lst1 = []

for name in lst:

    if name.startswith('张'):

        lst1.append(name)

for el in lst1:

    lst.remove(el)

print(lst)

31,编写一个函数,给函数传递一个参数n.判断n是否是一个质数

# def handlerNum(num):

#     if num > 1:

#         for i in range(2,num//2+1):

#             if (num % i) == 0:

#                 print(num,"不是质数")

#                 break

#         else:

#             print(num."是质数")

#     else:

#         print(num,"不是质数")

# if __name__ == "__main__":

#     num = int(input("请输入一个数字:"))

#     handlerNum(num)

32,有以下文件,将文件中每一行的内容封装到一个python文件中,并将对象统一装在一个列表中

[
{'id': '1', 'name': 'alex', 'age': '28', 'hobbies': ['上窜', '瞎跳', '真能浪']}, {'id': '2', 'name': 'wusir', 'age': '23', 'hobbies': ['忽悠', '吹牛']}, {'id': '3', 'name': '宋仲基', 'age': '99', 'hobbies': ['撩妹', '思密达', '怕不怕']}
]

# import json

# class Person:

#     def __init__(self, id, name, age, hobbies):

#         self.id = id

#         self.name = name

#         self.age = age

#         self.hobbies = hobbies

#

# # lst = [{'id': '1', 'name': 'alex', 'age': '28', 'hobbies': ['上窜', '瞎跳', '真能浪']}, {'id': '2', 'name': 'wusir', 'age': '23', 'hobbies': ['忽悠', '吹牛']}, {'id': '3', 'name': '宋仲基', 'age': '99', 'hobbies': ['撩妹', '思密达', '怕不怕']}]

# with open('data.json', 'r', encoding='utf-8') as f:

# #     data = json.dumps(lst, ensure_ascii=False)

# #     f.write(data)

#     data = json.load(f)

# print(data)

#     # print(type(data))

# lst = []

# for dic in data:

#     p1 = Person(dic['id'], dic['name'], dic['age'], dic['hobbies'])

#     lst.append(p1)

#

# print(lst

33,模拟 cs 游戏（10 分）
1. 人物角色分为警察和匪徒两种，定义成两个类
　　• 所有的警察的角色都是 police
　每个警察都有自己独有名字，生命值，武器，性别
　每个都可以开枪攻击敌人，切攻击目标不能是 police
　所有的匪徒的角色都是 terrorist

　每个匪徒都有自己独有名字，生命值，武器，性别
　每个都可以开枪攻击敌人，切攻击目标不能是 terrorist
　实例化一个警察，一个匪徒，警察攻击匪徒，匪徒掉血
3. 提取警察类和匪徒类相似之处定义成一个父类，使用继承的方式减少代码重复

lass Common(object):

    def __init__(self,name,HP,weason,gender):

        self.name = name

        self.HP = HP

        self.weason = weason

        self.gender = gender

class Police(Common):

    def introduction(self):

        print("我是警察,我的名字叫%s" % (self.name))

    def combat(self,other):

        if isinstance(other,Police):

            print("警察都是自己人,不能打")

            return

        print("警察%s 要打匪徒%s" % (self.name,other.name,))

        self.HP -= 0

        other.HP -= 100

class Terrorist(Common):

    def introduction(self):

        print("我是匪徒,我的名字叫%s" % (self.name))

    def combat(self,other):

        if isinstance(other,Terrorist):

            print("自己人")

            return

        print("匪徒%s 要打警察%s" % (self.name,other.name))

        # self.HP -= 100

        # other.HP -= 200

p = Police("大辉哥",1000,"原子弹","男")

t = Terrorist("蔡仁哲",1000,"牙签","男")

t.combat(t)