python基础

# 第一阶段考试题（答案）

1. 简述解释型语言和编译型语言的区别。

   ```

   编译器和解释器的作用是将各编程语言的代码进行翻译，从而使得计算机能够识别并执行。

   编译器，全文翻译，将代码编译成`临时文件`，再执行临时文件。

   解释器，实时翻译，对代码实行边解释边执行。

   ```

2. 罗列你听说过的编程语言。

   ```

   Java、C、C++、PHP、JavaScript、C#、Golang

   ```

3. 简述位和字节的关系？

   ```

   1字节等于8位

   ```

4. 简述你理解的 ascii、unicode、utf-8、gbk 编码。

   ```

   ascii编码、unicode字符集、utf-8编码、gbk编码本质上都是字符与二进制的关系。

   - ascii，只有256种对照关系，只包含英文、符号等。

   - unicode，万国码，包含了全球所有文字和二进制之间的一个对应关系。（ucs2或ucs4）

   - utf-8，对unicode字符集的码位进行压缩处理，间接也维护了字符和二进制的对照表。

   - gbk，包含中国、日本韩国等亚洲国家的文字和二进制的对照表。

   ```

5. py2和py3默认解释器编码分别是什么？如何在代码中修改解释器的编码？

   ```

   py2:ascii

   py3:utf-8

    

   在文件的顶部通过设置： # -*- coding:编码 -*- 实现修改。

   ```

6. pass的作用？

   ```

   pass相当于空行，程序啥都不做。 用于保持语法的完整性。

   ```

7. is和==的区别？

   ```

   is，比较内存地址是否一致。

   ==，比较值是否相等。

   ```

8. 列举你了解的Python2和Python3的区别。

   ```python

   - 默认解释器编码

   - 整型和长整形

   - 地板除取整、取小数

   - 字典的keys()/values()/items() 获取的值不同。

   - py2，字典无序；py3.6+ 字典有序。

   ```

9. 变量名的命名规范有哪些？

   ```

   三条规范（必须遵循，否则定义变量会报错）

     - 变量名只能由 字母、数字、下划线 组成。

     - 变量名不能以数字开头。

     - 变量名不能是Python内置关键字

   二条建议（遵循可以显得更加专业，不遵循也可以正常运行不报错）

    - 下划线命名法，多个单词表示的变量名用下划线连接（均小写）

    - 见名知意，通过阅读变量名就能知道此变量的含义。

   ```

10. 都有那些值转换为布尔值时为False？

    ```

    0

    ""

    [] or list()

    () or tuple()

    set()

    None

    {} or dict()

    ```

11. 简述如下三个变量的区别。

    ```python

    v1 = (1)    # 整型 1

    v2 = (1,)   # 元组

    v3 = 1      # 整型 1

    ```

12. 你所学的数据类型中哪些是可变的类型？

    ```

    list

    set

    dict

    ```

13. 你所学的数据类型中哪些是可哈希的类型？

    ```

    int

    bool

    float

    str

    tuple

    ```

14. 你所学的数据类型（容器）中哪些是有序的？

    ```

    list

    tuple

    dict（py3.6之后）

    ```

15. 列举你能记得的如下数据类型的方法（独有功能）。

    - str

      ```

      strip

      split

      join

      startswith

      endswith

      upper

      lower

      ...

      ```

    - list

      ```

      append

      insert

      remove

      extend

      sort

      reverse

      ...

      ```

    - dict

      ```

      get

      keys

      values

      items

      setdefault

      update

      ...

      ```

16. 请将字符 `name = "wupeiqi"` 翻转。

    ```

    data = name[::-1]

    print(data)

    ```

17. 进制之间如何进行转换？

    ```python

    - 十进制转其他：bin、oct、hex

    - 其他进制转十进制：int("其他进制",base=2或8或16)

    ```

18. 循环过程中 break和continue的作用是什么？

    ```python

    break,终止所有循环。

    continue，停止当前循环开始下次循环。

    ```

19. 看代码写结果

    ```python

    v1 = 1 or 9 and 88 or [11,22] and (1,2,3)

     

    v2 = 1>5 or "alex" and {"K1":"v1"} or 888

     

    print(v1,v2) # 1    {'K1': 'v1'}

    ```

20. 看代码写结果

    ```python

     info = [

         {'k1':(1),'k2':{'k9':'luffy','k10':'武沛齐'}},

         (11,22,33,44),

         {199,2,3,4,5},

         True,

         ['李杰','alex', { 'extra': ("alex",[18,20],'eric') } ]

    ]

    ```

    - 利用索引获取 "luffy"

      ```python

      info[0]["k2"]["k9"]

      ```

    - 利用索引获取 44

      ```python

      info[1][-1]

      ```

    - 删除k10对应的键值对

      ```python

      del info[0]['k2']['k10']

      ```

    - 在 `{ 'extra': ("alex",[18,20],'eric') }` 字典中添加一个键值对 `"name":"武沛齐"`

      ```python

      info[-1][2]["name"] = "武沛齐"

      ```

    - 在集合` {199,2,3,4,5} `中添加一个 "北京"

      ```python

      info[2].add("北京")

      ```

    - 将列表中的True修改为 "真"

      ```python

      info[3] = "真"

      ```

    - 在列表 `[18,20]`的第0个索引位置插入 666

      ```python

      info[-1][-1]["extra"][1].insert(0,666)

      ```

       

21. 判断下面的代码是否正确？正确的话则写出结果，否则标明错误。

    ```python

    v1 = (11,22,33)                                 # 正确 (11,22,33)

    v2 = (11)                                       # 正确 11

    v3 = {11,2,33}                                  # 正确 {11,2,33}

    v4 = {11,2,("alex","eric"),33}                  # 正确 {11,2,("alex","eric"),33}

    v5 = {11,2,("alex",{"北京","上海"},"eric"),33}   # 错误

    ```

22. 看代码写结果

    ```python

    v1 = [11,22,33]

    v2 = [11,22,33]

    v1.append(666)

     

    print(v1)  # [11,22,33,666]

    print(v2)  # [11,22,33]

    ```

23. 看代码写结果

    ```python

    v1 = [11,22,33]

    v2 = v1

    v1.append(666)

     

    print(v1) # [11,22,33,666]

    print(v2) # [11,22,33,666]

    ```

24. 看代码写结果

    ```python

    v1 = [1,2,3,4,5]

    v2 = [v1,v1,v1]

     

    v2[1][0] = 111

    v2[2][1] = 222

     

    print(v1) # [111,222,3,4,5]

    print(v2) # [[111,222,3,4,5],[111,222,3,4,5],[111,222,3,4,5]]

    ```

25. 写代码实现，循环提示用户输入内容（Q或q终止），并将内容用 "_" 连接起来。

    ```python

    data_list = []

    while True:

        text = input("请输入（Q/q退出）：")

        if text.upper() == "Q":

            break

        data_list.append(text)

     

    result = "_".join(data_list)

    print(result)

    ```

26. 写代码实现，将IP转换为整数。

    > 如 10.3.9.12 转换规则为：

    >         10            00001010

    >          3             00000011

    >          9             00001001

    >         12            00001100

    > 再将以上二进制拼接起来，然后再进行一次翻转。

    >

    > 最终将翻转之后的二进制转换为整型。

    ```python

    ip = "10.3.9.12"

     

    data_list = []

    num_list = ip.split(".")

    for num in num_list:

        item = bin(int(num))[2:].zfill(8)

        data_list.append(item)

     

    reverse_data = "".join(data_list)[::-1]

    result = int(reverse_data, base=2)

    print(result)

    ```

27. 写代码实现，车牌的区域划分。

    ```python

    car_list = ['鲁A32444', '沪B12333', '京B8989M', '京C49678', '黑C46555', '晋B25041', '沪C34567']

     

    # 根据以上代码获取各省车牌数量，例如：info = {"沪":2,"京":2 ...}

    ```

    ```python

    car_list = ['鲁A32444', '沪B12333', '京B8989M', '京C49678', '黑C46555', '晋B25041', '沪C34567']

     

    info = {}

     

    for item in car_list:

        city = item[0]

        if city in info:

            info[city] = info[city] + 1

        else:

            info[city] = 1

     

    print(info)

    ```

    ```python

    car_list = ['鲁A32444', '鲁B12333', '京B8989M', '京C49678', '黑C46555', '晋B25041', '沪C34567']

     

    info = {}

    for item in car_list:

        city = item[0]

        num = info.get(city, 0)

        info[city] = num + 1

    print(info)

    ```

     

28. 写代码实现，数据格式化处理。

    ```python

    text = """id,name,age,phone,job

    1,alex,22,13651054608,IT

    2,wusir,23,13304320533,Tearcher

    3,老男孩,18,1333235322,IT"""

     

    # 将上述数据处理为如下格式的结果：

    #    info = [  {'id':'1','name':'alex','age':'22','phone':'13651054608','job':'IT'},.... ..  ]

     

    # 提示：text的内容是根据 \n 分割（\n表示回车换行）。

    ```

    ```python

    text = """id,name,age,phone,job

    1,alex,22,13651054608,IT

    2,wusir,23,13304320533,Tearcher

    3,老男孩,18,1333235322,IT"""

     

    data_list = text.split("\n") # ["id,name,age,phone,job","1,alex,22,13651054608,IT"... ]

    header_list = data_list[0].split(",") # ["id","name","age"... ]

    info = []

    for index in range(1, len(data_list)):

        item = {}

        row = data_list[index] # 1,alex,22,13651054608,IT

        row_item_list = row.split(",") # ["1","alex","22",...]

        for i in range(len(row_item_list)):

            item[header_list[i]] = row_item_list[i]

        info.append(item)

    print(info)

    ```

29. 写代码实现 累乘计算器。

    ```python

    content = input("请输入内容:") # 用户可能输入 5*9*99.... 或 5* 9 * 10 * 99 或 5 * 9 * 99... （不用考虑非数字的情况）

     

    # 补充代码实现

    result = 1

    num_list = content.split("*") # ["5","9","99"]

    for num in num_list:

        # result *= int(num)

        result = result * int(num)

     

    print(result)

    ```

30. 使用for循环实现输出 9*9 乘法表

    ```

    1*1

    2*1 2*2

    3*1 3*2 3*3

    4*1 4*2 4*3 4*4

    5*1 5*2 5*3 5*4 5*5

    6*1 6*2 6*3 6*4 6*5 6*6

    7*1 7*2 7*3 7*4 7*5 7*6 7*7

    8*1 8*2 8*3 8*4 8*5 8*6 8*7 8*8

    9*1 9*2 9*3 9*4 9*5 9*6 9*7 9*8 9*9

     

     

    1*1

    1*2 2*2

    1*3 2*3 3*3

    1*4 2*4 3*4 4*4

    1*5 2*5 3*5 4*5 5*5

    1*6 2*6 3*6 4*6 5*6 6*6

    1*7 2*7 3*7 4*7 5*7 6*7 7*7

    1*8 2*8 3*8 4*8 5*8 6*8 7*8 8*8

    1*9 2*9 3*9 4*9 5*9 6*9 7*9 8*9 9*9

    ```

    ```python

    print("666",end=" ")

    print("999",end=" ")

    666 999

    ```

    ```python

    for i in range(10):

        # 0,1,2,3,4,5,6,7,8

        for j in range(i): # []  [0] [0,1] [0,1,2]

            # 0,1

    ```

    ```python

    for i in range(1, 10):

        # 1 2 3 4 5 6 7 8 9

        for j in range(1, i + 1): # [1]  [1,2]  [1,2,3]  [1,2,3,4] [1,2,3,4,5] ... [1,2,3,4...9 ]

            # j * i

            # 1 * 1

            # 1 * 2  2 * 2

            # 1 * 3 2 * 2

            text = "{}*{}".format(j, i)

            print(text, end=" ")

        print("")

    ```

31. 补充代码实现《棋牌游戏11点》

    需求：

    - 生成一副扑克牌（自己设计扑克牌的结构，小王和大王可以分别用14、15表示 ）

    - 3个玩家

      ```python

      user_list = ["alex","武沛齐","李路飞"]

      ```

    - 发牌规则

      - 默认先给用户发一张牌，其中 J、Q、K、小王、大王代表的值为0.5，其他就是则就是当前的牌面值。

      - 用户根据自己的情况判断是否继续要牌。

        - 要，则再给他发一张。

        - 不要，则开始给下个玩家发牌。

      - 如果用户手中的所有牌相加大于11，则表示爆了，此人的分数为0，并且自动开始给下个人发牌。

    - 最终计算并获得每个玩家的分值，例如：

      ```python

      result = {

          "alex":8,

          "武沛齐":9,

          "李路飞":0

      }

      ```

    必备技术点：随机抽排

    ```python

    import random

     

    total_poke_list = [("红桃", 1), ("黑桃", 2), ("大王", 15), ("小王", 14)]

     

    # 随机生成一个数，当做索引。

    index = random.randint(0, len(total_poke_list) - 1)

    # 获取牌

    print("抽到的牌为：", total_poke_list[index])

    # 踢除这张牌

    data = total_poke_list.pop(index) # ("红桃", 1)

     

    print("抽完之后，剩下的牌为：", total_poke_list)

    ```

     

    代码示例：（请补充实现）

    ```python

    import random

     

    result = {}

     

    user_list = ["alex", "武沛齐", "李路飞"]

     

    # 1. 生成一副扑克牌

    total_poke_list = [ ("小王",14),("大王",15) ]

color_list = ["红桃", "黑桃", "方片", "梅花"]

    num_list = []

for num in range(1, 14):

        num_list.append(num)

    for color in color_list:

        for num in num_list:

            item = (color, num,)

            total_poke_list.append(item)

     

    # 2. 发牌 -> ["alex", "武沛齐", "李路飞"]

    for user in user_list:

        # 给用户发第一张牌

        score = 0

        index = random.randint(0, len(total_poke_list) - 1)

        poke = total_poke_list.pop(index) # ("花色",值)

        # JQK表示 0.5 点

        value = poke[1]

        if poke[1] > 10:

            value = 0.5

        score += value

        print("给{}发的牌：{}{}，此刻所有牌面值总和:{}".format(user, poke[0], poke[1], score))

         

        # 用户选择是否继续要

        while True:

            choice = input("是否继续要牌(Y/N)？")

            choice = choice.upper()

     

            # 用户输入的不是Y/N/y/n

            if choice not in {"Y", "N"}:

                print("输入错误，请重新输入。")

                continue

     

            # 用户输入N，不继续要牌了

            if choice == "N":

                print("{}不要拍了".format(user))

                break

     

            # 继续要拍（再随机抽取一张）

            index = random.randint(0, len(total_poke_list) - 1)

            poke = total_poke_list.pop(index)

            value = poke[1]

            if poke[1] > 10:

                value = 0.5

            score += value

             

            print("给{}发的牌：{}{}，此刻所有牌面值总和:{}".format(user, poke[0], poke[1], score))

     

            # 大于11点，则用户爆了且分值变为0

            if score > 11:

                print("用户{}爆了".format(user))

                score = 0

                break

     

        result[user] = score

     

    print(result)

    ```