面试题.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1\n",
    "strs = \" I like python \"\n",
    "one = strs.strip()\n",
    "print(one)\n",
    "\n",
    "two = strs.rstrip()\n",
    "print(two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2 在Python3中，下列程序能否运行成功\n",
    "dicts={}\n",
    "dicts[([1,2])]=\"abc\"\n",
    "print(dicts) # 字典不能做键，键内包含元组也不行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3\n",
    "class Base(object):\n",
    "    count = 0\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "b1 = Base()\n",
    "b2 = Base()\n",
    "b1.count = b1.count + 1\n",
    "\n",
    "print(b1.count,end=\" \")\n",
    "print(Base.count,end=\" \")\n",
    "print(b2.count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4\n",
    "strs = 'abbacabb'\n",
    "print(strs.strip('ab'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5\n",
    "python变量的查找顺序为:\n",
    "变量的查找顺序遵循LEGB原则：Local 局部变量->Enclosing 外部嵌套作用域->Global 全局作用域->Built-in 内置模块作用域"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6\n",
    "nl = [1,2,5,3,5]\n",
    "\n",
    "nl.append(4)\n",
    "nl.insert(0,7)\n",
    "nl.sort()\n",
    "\n",
    "print(nl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7\n",
    "import copy\n",
    "a = [1, 2, 3, 4, ['a', 'b']]\n",
    "b = a\n",
    "c = copy.copy(a)\n",
    "d = copy.deepcopy(a)\n",
    "a.append(5)\n",
    "a[4].append('c')\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 8\n",
    "lists = [1, 2, 3, 4, 5, 6]\n",
    "print(lists[6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 9\n",
    "a = [1,2,3]\n",
    "b=[1,2,4]\n",
    "# 下方的结果是True还是False\n",
    "id(a[1]) == id(b[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10\n",
    "\n",
    "1.在x64下函数调用的前4个参数总是放在寄存器中传递，剩余的参数则压入堆栈中。而x86上则是全部压入堆栈中(除了fastcall方式)。这4个用于存放参数的寄存器分别是：存放整数参数的RCX，RDX，R8，R9；存放浮点数参数的XMM0，XMM1，XMM2，XMM3。\n",
    "\n",
    "2.Intel中规定，栈是从高地址向低地址生长的；堆是由低地址向高地址增长的。ARM就没有规定的很死，可以选择栈是升序还是降序。\n",
    "\n",
    "3.计算机里的浮点类型只是一种用离散方式近似表达实数区间的方法，Python 里的 float 是不可能涵盖 [0,1] 区间内的所有实数的。即，只是---近似---表示，不是真正的能表达实数区间。\n",
    "\n",
    "4.在32位机器上，整数的位数为32位，int取值范围为-231～231-1，即-2147483648～2147483647\n",
    "  在64位系统上，整数的位数为64位，int取值范围为-263～263-1，即-9223372036854775808～9223372036854775807"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 11\n",
    "a = '123'\n",
    "b = '123'\n",
    "a is b\n",
    "a != b\n",
    "a == 123\n",
    "a + b = 246"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 12\n",
    "# 执行以下程序，当用户输入0时\n",
    "dividend = 1\n",
    "divide = int(input())\n",
    "\n",
    "try:\n",
    "    result = dividend / divide\n",
    "    print(1,end=\" \")\n",
    "except ZeroDivisionError:\n",
    "    print(2,end=\" \")\n",
    "except Exception:\n",
    "    print(3,end=\" \")\n",
    "else:\n",
    "    print(4) \n",
    "\"\"\"\n",
    "在try...except...else结构中，当执行try程序块的语句时，若出现异常的语句，则不会继续执行try还未执行的代码，而是直接跳到except程序块，\n",
    "由于0不能作为分母，其抛出的异常对象属于异常类ZeroDivisionError，\n",
    "结果输出2，当异常被处理完时，会直接跳出except程序块，\n",
    "当try程序块没有出现异常时，不会执行except而执行else语句，出现异常时则执行except而不执行else，所以最终输出结果是2。\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 13\n",
    "dicts = {'a':1,'b':2,'c':3}\n",
    "print(dicts.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 14\n",
    "list = ['1', '2', '3', '4', '5']\n",
    "print(list[10:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 15\n",
    "foo = [1,2]\n",
    "foo1 = foo\n",
    "foo.append(3)\n",
    "\n",
    "print(foo1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 16\n",
    "counter = 1 \n",
    "def doLotsOfStuff(): \n",
    "    global counter\n",
    "    for i in (1, 2, 3): \n",
    "        counter += 1 \n",
    "doLotsOfStuff()\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 17\n",
    "lists = [1, 2, 3, 4]\n",
    "tmp = 0\n",
    "for i,j in enumerate(lists):\n",
    "    tmp += i * j\n",
    "print(tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18\n",
    "a = [1, 2, 3, 4, 5]\n",
    "sums = sum(map(lambda x: x + 3, a[1::3]))\n",
    "print(sums)\n",
    "# 补充：\n",
    "data = sum(map(lambda x: x**2, [1, 2, 3, 4, 5]))\n",
    "print(data) #[1, 4, 9, 16, 25]相加"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 19\n",
    "a = [['1','2'] for i in range(2)]\n",
    "b = [['1','2']]*2\n",
    "a[0][1] = '3'\n",
    "b[0][0] = '4'\n",
    "print(a,b) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "20\n",
    "函数可以赋值给一个变量\n",
    "函数可以作为元素添加到集合对象中\n",
    "函数可以作为参数值传递给其它函数\n",
    "函数可以当做函数的返回值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 21\n",
    "strs = \"I like python and java\"\n",
    "print(strs.replace(\"I\",\"Your\"))\n",
    "print(strs.replace('a','*',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 22\n",
    "import math\n",
    "# 求素数（质数）个数\n",
    "def sieve(size):\n",
    "    sieve = [True] * size\n",
    "    sieve[0] = False\n",
    "    sieve[1] = False\n",
    "    for i in range(2, int(math.sqrt(size)) + 1):\n",
    "        # k不是素数\n",
    "        k = i * 2 \n",
    "        while k < size:\n",
    "            sieve[k] = False\n",
    "            k += i\n",
    "    # 返回true的个数，true代表素数\n",
    "    return sum(1 for x in sieve if x)\n",
    "# 求200内有多少个素数\n",
    "print(sieve(200))\n",
    "for i in range(2, int(math.sqrt(100)) + 1):\n",
    "    k = i * 2\n",
    "    print(k)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 23\n",
    "a = (1,2,3)\n",
    "print(a[1:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 24当一个嵌套函数在其外部区域引用了一个值时，该嵌套函数就是一个闭包，以下代码输出值为:\n",
    "def adder(x):\n",
    "    def wrapper(y):\n",
    "        return x + y\n",
    "    return wrapper\n",
    "adder5 = adder(5)\n",
    "print(adder5(adder5(6))) # addr(5)(addr(5)(6)) 5+6+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 25在Python中关于列表的运算结果为:\n",
    "lists = [1, 2, 2, 3, 3, 3]\n",
    "print(lists.count(3))\n",
    "print(lists.pop())\n",
    "lists.pop()\n",
    "print(lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 26 filter(function, iterable) 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。\n",
    "# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。\n",
    "# 关于filter()方法, python3和python2有一点不同\n",
    "# Python2.x 中返回的是过滤后的列表, 而 Python3 中返回到是一个 filter 类。\n",
    "# filter 类实现了 __iter__ 和 __next__ 方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。\n",
    "func = lambda x:x%2\n",
    "result = filter(func, [1, 2, 3, 4, 5])\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 27 \n",
    "for i in range(10, 1, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 28\n",
    "numbers = [1, 2, 3, 4]\n",
    "numbers.append([5,6,7,8])\n",
    "print(len(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 29\n",
    "dicts = {}\n",
    "dicts[(1, 2)] = ({3, (4, 5)})\n",
    "print(dicts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 30\n",
    "dicts = {'one': 1, 'two': 2, 'three': 3}\n",
    "tmp = dicts.copy()\n",
    "tmp['one'] = 'abc'\n",
    "print(dicts)\n",
    "print(tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "# 31  声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入\n",
    "\n",
    "def f(a,b,*,c,d,e):\n",
    "    return a+b+c+d+e\n",
    "\n",
    "def fun(a,*,b): \n",
    "    print(a,b)\n",
    "\n",
    "\n",
    "print(f(1,2,c=3,d=4,e=5))\n",
    "\n",
    "fun(1,b=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 32 注意：字典数据类型的copy函数，当简单的值替换的时候，原始字典和复制过来的字典之间互不影响，但是当添加，删除等修改操作的时候，两者之间会相互影响。\n",
    "#    所以新字典的值的替换对原字典没有影响\n",
    "dicts = {'one': 1, 'two': 2, 'three': 3}\n",
    "tmp = dicts.copy()\n",
    "tmp['one'] = 'abc'\n",
    "print(dicts)\n",
    "print(tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "33 下列关于python socket操作叙述正确的是:\n",
    "-   使用connect()初始化TCP服务器连接\n",
    "-   服务端使用listen()开始TCP监听\n",
    "-   sk.recv(bufsize[,flag]):接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。\n",
    "-   sk.recvfrom(bufsize[.flag]):与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。\n",
    "-   sk.getsockname():返回套接字自己的地址。通常是一个元组(ipaddr,port)\n",
    "-   sk.connect(address):连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。\n",
    "-   sk.listen(backlog):开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 34\n",
    "strs = ['a', 'ab', 'abc', 'python']\n",
    "y = filter(lambda s: len(s) > 2, strs)\n",
    "tmp = list(map(lambda s: s.upper(), y))  \n",
    "print(tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 35\n",
    "a,*b,c = range(5)\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def w1():\n",
    "    print('正在装饰')\n",
    "\n",
    "    def inner():\n",
    "        print('正在验证权限')\n",
    "        \n",
    "    return inner()\n",
    "\n",
    "w1()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ba6232237b01526c995775294cb002291ffc32d79377b5955f4365d8c6667f34"
  },
  "kernelspec": {
   "display_name": "Python 3.9.6 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}