• 精心整理 170 道 Python 面试题


    精心整理的 Python 相关的基础知识,用于面试,或者平时复习,都是很好的!废话不多说,直接开搞

    • 基础篇

      • 1. 为什么学习 Python

      • 2. 解释型和编译型语言的区别

      • 3. 简述下 Python 中的字符串、列表、元组和字典

      • 4. 简述上述数据类型的常用方法

      • 5. 简述 Python 中的字符串编码

      • 6.一行代码实现数值交换

      • 7. is 和 == 的区别

      • 8.Python 函数中的参数类型

      • 9.`*arg` 和 `**kwarg` 作用

      • 10.一行代码实现1-100之和

      • 11.获取当前时间

      • 12.PEP8 规范

      • 13.Python 的深浅拷贝

      • 14.查看下面代码的输出

      • 15.可变类型与不可变类型

      • 16.打印九九乘法表

      • 17.filter、map、reduce 的作用

      • 18.re 的 match 和 search 区别

      • 19.面向对象中`__new__` 和 `__init__` 区别

      • 20.三元运算规则

      • 21.生成随机数

      • 22.zip 函数用法

      • 23.range 和 xrange 的区别

      • 24.with 方法打开文件的作用

      • 25.什么是正则的贪婪匹配

      • 26.为什么不建议函数的默认参数传入可变对象

      • 27.字符串转列表

      • 28.字符串转整数

      • 29.删除列表中的重复值

      • 30.字符串单词统计

      • 31.列表推导,求奇偶数

      • 32.一行代码展开列表

      • 33.实现二分法查找函数

      • 34.字典和 json 转换

      • 35.列表推导式、字典推导式和生成器

      • 36.简述 read、readline、readlines 的区别

      • 37.打乱一个列表

      • 38.反转字符串

      • 39.单下划线和双下划线的作用

      • 40.新式类和旧式类

      • 41.Python 面向对象中的继承有什么特点

      • 42.super 函数的作用

      • 43.类中的各种函数

      • 44.如何判断是函数还是方法

      • 45.isinstance 的作用以及与 type()的区别

      • 46.单例模式与工厂模式

      • 47.查看目录下的所有文件

      • 48.计算1到5组成的互不重复的三位数

      • 49.去除字符串首尾空格

      • 50.去除字符串中间的空格

      • 51. 字符串格式化方式

      • 52. 将"hello world"转换为首字母大写"Hello World"(不使用 title 函数)

      • 53. 一行代码转换列表中的整数为字符串

      • 54. 合并两个元组到字典

      • 55. 给出如下代码的输入,并简单解释

      • 56. Python 中的反射

      • 57. 实现一个简单的 API

      • 58. metaclass 元类

      • 59. sort 和 sorted 的区别

      • 60. Python 中的 GIL

      • 61. 产生8位随机密码

      • 62. 输出原始字符

      • 63. 列表内,字典按照 value 大小排序

      • 64. 简述 any() 和 all() 方法

      • 65. 反转整数

      • 66. 函数式编程

      • 67. 简述闭包

      • 68. 简述装饰器

      • 69. 协程的优点

      • 70. 实现一个斐波那契数列

      • 71. 正则切分字符串

      • 72. yield 用法

      • 73. 冒泡排序

      • 74. 快速排序

      • 75. requests 简介

      • 76. 比较两个 json 数据是否相等

      • 77. 读取键盘输入

      • 78. enumerate

      • 79. pass 语句

      • 80. 正则匹配邮箱

      • 81. 统计字符串中大写字母的数量

      • 82. json 序列化时保留中文

      • 83. 简述继承

      • 84. 什么是猴子补丁

      • 85. help() 函数和 dir() 函数

      • 86. 解释 Python 中的`//`,`%`和`**`运算符

      • 87. 主动抛出异常

      • 88. tuple 和 list 转换

      • 89. 简述断言

      • 90. 什么是异步非阻塞

      • 91. 什么是负索引

      • 92. 退出 Python 后,内存是否全部释放

      • 93. Flask 和 Django 的异同

      • 94. 创建删除操作系统上的文件

      • 95. 简述 logging 模块

      • 96. 统计字符串中单词出现次数

      • 97. 正则 re.complie 的作用

      • 98. try except else finally 的意义

      • 99.反转列表

      • 100. 字符串中数字替换

    • 综合篇:网络编程

      • 101. 简述 OSI 七层协议

      • 102. 三次握手、四次挥手的流程

      • 103. 什么是 C/S 和 B/S 架构

      • 104. TCP 和 UDP 的区别

      • 105. 局域网和广域网

      • 106. arp 协议

      • 107. 什么是 socket?简述基于 TCP 协议的套接字通信流程

      • 108. 简述 进程、线程、协程的区别以及应用场景

      • 109. 如何使用线程池和进程池

      • 110. 进程之间如何进行通信

      • 111. 进程锁和线程锁

      • 112. 什么是并发和并行

      • 113. threading.local 的作用

      • 114. 什么是域名解析

      • 115. LVS 是什么及作用

      • 116. Nginx 的作用

      • 117. keepalived 及 HAProxy

      • 118. 什么是 rpc

      • 119. 从浏览器输入一个网址到展示网址页面的过程

      • 120. 什么是cdn

    • 综合篇:数据库和框架

      • 121. 列举常见的数据库

      • 122. 数据库设计三大范式

      • 123. 什么是数据库事务

      • 124. MySQL 索引种类

      • 125. 数据库设计中一对多和多对多的应用场景

      • 126. 简述触发器、函数、视图、存储过程

      • 127. 常用 SQL 语句

      • 128. 主键和外键的区别

      • 129. 如何开启 MySQL 慢日志查询

      • 130. MySQL 数据库备份命令

      • 131. char 和 varchar 的区别

      • 132. 最左前缀原则

      • 133. 无法命中索引的情况

      • 134. 数据库读写分离

      • 135. 数据库分库分表

      • 136. redis 和 memcached 比较

      • 137. redis中数据库默认是多少个 db 及作用

      • 138. redis 有哪几种持久化策略

      • 139. redis 支持的过期策略

      • 140. 如何保证 redis 中的数据都是热点数据

      • 141. Python 操作 redis

      • 142. 基于 redis 实现发布和订阅

      • 143. 如何高效的找到 redis 中的某个 KEY

      • 144. 基于 redis 实现先进先出、后进先出及优先级队列

      • 145. redis 如何实现主从复制

      • 146. 循环获取 redis 中某个非常大的列表数据

      • 147. redis 中的 watch 的命令的作用

      • 148. redis 分布式锁

      • 149. http 协议

      • 150. uwsgi,uWSGI 和 WSGI 的区别

      • 151. HTTP 状态码

      • 152. HTTP常见请求方式

      • 153. 响应式布局

      • 154. 实现一个简单的 AJAX 请求

      • 155. 同源策略

      • 156. 什么是 CORS

      • 157. 什么是 CSRF

      • 158. 前端实现轮询、长轮询

      • 159. 简述 MVC 和 MTV

      • 160. 接口的幂等性

      • 161. Flask 框架的优势

      • 162. 什么是 ORM

      • 163. PV、UV 的含义

      • 164. supervisor 的作用

      • 165. 使用 ORM 和原生 SQL 的优缺点

      • 166. 列举一些 django 的内置组件

      • 167. 列举 Django 中执行原生 sql 的方法

      • 168. cookie 和 session 的区别

      • 169. beautifulsoup 模块的作用

      • 170. Selenium 模块简述

    基础篇

    1. 为什么学习 Python

    Python 语言简单易懂,上手容易,随着 AI 风潮,越来越火

    2. 解释型和编译型语言的区别

    编译型语言:把做好的源程序全部编译成二进制的可运行程序。然后,可直接运行这个程序。如:C,C++ 解释型语言:把做好的源程序翻译一句,然后执行一句,直至结束!如:Python, (Java 有些特殊,java程序也需要编译,但是没有直接编译称为机器语言,而是编译称为字节码,然后用解释方式执行字节码。)

    3. 简述下 Python 中的字符串、列表、元组和字典

    字符串(str):字符串是用引号括起来的任意文本,是编程语言中最常用的数据类型。列表(list):列表是有序的集合,可以向其中添加或删除元素。元组(tuple):元组也是有序集合,但是是无法修改的。即元组是不可变的。字典(dict):字典是无序的集合,是由 key-value 组成的。集合(set):是一组 key 的集合,每个元素都是唯一,不重复且无序的。

    4. 简述上述数据类型的常用方法

    字符串:

    1. 切片 mystr='luobodazahui' mystr[1:3] output 'uo'

    2. format mystr2 = "welcome to luobodazahui, dear {name}" mystr2.format(name="baby") output 'welcome to luobodazahui, dear baby'

    3. join 可以用来连接字符串,将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串。mylist = ['luo', 'bo', 'da', 'za', 'hui'] mystr3 = '-'.join(mylist) print(mystr3) outout 'luo-bo-da-za-hui'

    4. replace String.replace(old,new,count) 将字符串中的 old 字符替换为 New 字符,count 为替换的个数 mystr4 = 'luobodazahui-haha' print(mystr4.replace('haha', 'good'))

    output luobodazahui-good

    1. split 切割字符串,得到一个列表

    1. mystr5 = 'luobo,dazahui good'
    2. # 以空格分割
    3. print(mystr5.split())
    4. # 以h分割
    5. print(mystr5.split('h'))
    6. # 以逗号分割
    7. print(mystr5.split(','))

    output

    1. ['luobo,dazahui', 'good']
    2. ['luobo,daza', 'ui good']
    3. ['luobo', 'dazahui good']

    列表:

    1. 切片 同字符串

    2. append 和 extend 向列表中国添加元素

    1. mylist1 = [12]
    2. mylist2 = [34]
    3. mylist3 = [12]
    4. mylist1.append(mylist2)
    5. print(mylist1)
    6. mylist3.extend(mylist2)
    7. print(mylist3)

    outout

    1. [1, 2, [3, 4]]
    2. [1, 2, 3, 4]
    1. 删除元素 del:根据下标进行删除 pop:删除最后一个元素 remove:根据元素的值进行删除

    1. mylist4 = ['a''b''c''d']
    2. del mylist4[0]
    3. print(mylist4)
    4. mylist4.pop()
    5. print(mylist4)
    6. mylist4.remove('c')
    7. print(mylist4)

    output

    1. ['b', 'c', 'd']
    2. ['b', 'c']
    3. ['b']
    1. 元素排序 sort:是将list按特定顺序重新排列,默认为由小到大,参数 reverse=True 可改为倒序,由大到小。reverse:是将list逆置

    1. mylist5 = [15234]
    2. mylist5.sort()
    3. print(mylist5)
    4. mylist5.reverse()
    5. print(mylist5)

    output

    1. [1, 2, 3, 4, 5]
    2. [5, 4, 3, 2, 1]

    字典:

    1. 清空字典 dict.clear()

    1. dict1 = {'key1':1'key2':2}
    2. dict1.clear()
    3. print(dict1)

    output

    {}
    
    1. 指定删除 使用 pop 方法来指定删除字典中的某一项

    1. dict1 = {'key1':1'key2':2}
    2. d1 = dict1.pop('key1')
    3. print(d1)
    4. print(dict1)

    output

    1. 1
    2. {'key2': 2}
    1. 遍历字典

    1. dict2 = {'key1':1, 'key2':2}
    2. mykey = [key for key in dict2]
    3. print(mykey)
    4. myvalue = [value for value in dict2.values()]
    5. print(myvalue)
    6. key_value = [(k, v) for kv in dict2.items() ]
    7. print(key_value)

    output

    1. ['key1', 'key2']
    2. [1, 2]
    3. [('key1', 1), ('key2', 2)]
    1. fromkeys 用于创建一个新字典,以序列中元素做字典的键,value 为字典所有键对应的初始值

    1. keys = ['zhangfei''guanyu''liubei''zhaoyun']
    2. dict.fromkeys(keys0)

    output

    {'zhangfei': 0, 'guanyu': 0, 'liubei': 0, 'zhaoyun': 0}
    

    5. 简述 Python 中的字符串编码

    计算机在最初的设计中,采用了8个比特(bit)作为一个字节(byte)的方式。一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。最早,计算机只有 ASCII 编码,即只包含大小写英文字母、数字和一些符号,这些对于其他语言,如中文,日文显然是不够用的。后来又发明了Unicode,Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。UTF-8 是隶属于 Unicode 的可变长的编码方式。在 Python 中,以 Unicode 方式编码的字符串,可以使用 encode() 方法来编码成指定的 bytes,也可以通过 decode() 方法来把 bytes 编码成字符串。encode

    "中文".encode('utf-8')
    

    output

    b'\xe4\xb8\xad\xe6\x96\x87'
    

    decode

    b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    

    output

    '中文'
    

    6.一行代码实现数值交换

    1. 1a = 1
    2. 2b = 2
    3. 3a, b = b, a
    4. 4print(a, b)

    output

    12 1
    

    7. is 和 == 的区别

    先来看个例子

    1. c = d = [1,2]
    2. e = [1,2]
    3. print(c is d)
    4. print(c == d)
    5. print(c is e)
    6. print(c == e)

    output

    1. True
    2. True
    3. False
    4. True

    == 是比较操作符,只是判断对象的值(value)是否一致,而 is 则判断的是对象之间的身份(内存地址)是否一致。对象的身份,可以通过 id() 方法来查看

    1. id(c)
    2. id(d)
    3. id(e)

    output

    1. 88748080
    2. 88748080
    3. 88558288

    可以看出,只有 id 一致时,is 比较才会返回 True,而当 value 一致时,== 比较就会返回 True

    8.Python 函数中的参数类型

    位置参数,默认参数,可变参数,关键字参数

    9.*arg 和 **kwarg 作用

    允许我们在调用函数的时候传入多个实参

    1. def test(*arg, **kwarg):
    2.     if arg:
    3.         print("arg:"arg)
    4.     if kwarg:
    5.         print("kearg:", kwarg)
    6. test('ni''hao', key='world')

    output

    1. arg: ('ni', 'hao')
    2. kearg: {'key': 'world'}

    可以看出,*arg 会把位置参数转化为 tuple**kwarg 会把关键字参数转化为 dict

    10.一行代码实现1-100之和

    sum(range(1, 101))
    

    11.获取当前时间

    1. import time
    2. import datetime
    3. print(datetime.datetime.now())
    4. print(time.strftime('%Y-%m-%d %H:%M:%S'))

    output

    1. 2019-06-07 18:12:11.165330
    2. 2019-06-07 18:12:11

    12.PEP8 规范

    简单列举10条:尽量以免单独使用小写字母'l',大写字母'O',以及大写字母'I'等容易混淆的字母。函数命名使用全部小写的方式,可以使用下划线。常量命名使用全部大写的方式,可以使用下划线。使用 has 或 is 前缀命名布尔元素,如: is_connect = True; has_member = False 不要在行尾加分号, 也不要用分号将两条命令放在同一行。不要使用反斜杠连接行。顶级定义之间空2行, 方法定义之间空1行,顶级定义之间空两行。如果一个类不继承自其它类, 就显式的从object继承。内部使用的类、方法或变量前,需加前缀_表明此为内部使用的。要用断言来实现静态类型检测。

    13.Python 的深浅拷贝

    浅拷贝

    1. import copy
    2. list1 = [123, [12]]
    3. list2 = copy.copy(list1)
    4. list2.append('a')
    5. list2[3].append('a')
    6. print(list1, list2)

    output

    [1, 2, 3, [1, 2, 'a']] [1, 2, 3, [1, 2, 'a'], 'a']
    

    能够看出,浅拷贝只成功”独立“拷贝了列表的外层,而列表的内层列表,还是共享的

    深拷贝

    1. import copy
    2. list1 = [123, [12]]
    3. list3 = copy.deepcopy(list1)
    4. list3.append('a')
    5. list3[3].append('a')
    6. print(list1, list3)

    output

    [1, 2, 3, [1, 2]] [1, 2, 3, [1, 2, 'a'], 'a']
    

    深拷贝使得两个列表完全独立开来,每一个列表的操作,都不会影响到另一个

    14.查看下面代码的输出

    1. def num():
    2.     return [lambda x:i*x for i in range(4)]
    3. print([m(1for m in num()])

    output

    [3, 3, 3, 3]
    

    通过运行结果,可以看出 i 的取值为3,很神奇

    15.可变类型与不可变类型

    可变数据类型:list、dict、set

    不可变数据类型:int/float、str、tuple

    16.打印九九乘法表

    1. for i in range(110):
    2.     for j in range(1, i+1):
    3.         print("%s*%s=%s " %(i, j, i*j), end="")
    4.     print()

    output

    1. 1*1=1
    2. 2*1=2 2*2=4
    3. 3*1=3 3*2=6 3*3=9
    4. 4*1=4 4*2=8 4*3=12 4*4=16
    5. 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
    6. 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
    7. 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
    8. 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
    9. 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

    print 函数,默认是会换行的,其有一个默认参数 end,如果像例子中,我们把 end 参数显示的置为"",那么 print 函数执行完后,就不会换行了,这样就达到了九九乘法表的效果了

    17.filter、map、reduce 的作用

    filter 函数用于过滤序列,它接收一个函数和一个序列,把函数作用在序列的每个元素上,然后根据返回值是True还是False决定保留还是丢弃该元素

    1. mylist = [123456789]
    2. list(filter(lambda x: x%2 == 1, mylist))

    output

    [1, 3, 5, 7, 9]
    

    保留奇数列表

    map 函数传入一个函数和一个序列,并把函数作用到序列的每个元素上,返回一个可迭代对象

    1. mylist = [123456789]
    2. list(map(lambda x: x*2, mylist))

    output

    [2, 4, 6, 8, 10, 12, 14, 16, 18]
    

    reduce 函数用于递归计算,同样需要传入一个函数和一个序列,并把函数和序列元素的计算结果与下一个元素进行计算

    1. from functools import reduce
    2. reduce(lambda x, y: x+y, range(101))

    output

    5050
    

    可以看出,上面的三个函数与匿名函数相结合使用,可以写出强大简洁的代码

    18.re 的 match 和 search 区别

    match()函数只检测要匹配的字符是不是在 string 的开始位置匹配,search()会扫描整个 string 查找匹配

    19.面向对象中__new__ 和 __init__ 区别

    __new__是在实例创建之前被调用的,因为它的任务就是创建实例然后返回该实例对象,是个静态方法。__init__是当实例对象创建完成后被调用的,然后设置对象属性的一些初始值,通常用在初始化一个类实例的时候,是一个实例方法

    1、__new__至少要有一个参数 cls,代表当前类,此参数在实例化时由 Python 解释器自动识别。2、__new__必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时要特别注意,可以 return 父类(通过 super(当前类名, cls))__new__出来的实例,或者直接是 object 的__new__出来的实例。3、__init__有一个参数 self,就是这个__new__返回的实例,__init____new__的基础上可以完成一些其它初始化的动作,__init__不需要返回值。4、如果__new__创建的是当前类的实例,会自动调用__init__函数,通过 return 语句里面调用的__new__函数的第一个参数是 cls 来保证是当前类实例,如果是其他类的类名,;那么实际创建返回的就是其他类的实例,其实就不会调用当前类的__init__函数,也不会调用其他类的__init__函数

    20.三元运算规则

    1. a, b = 1, 2
    2. # 若果 a>b 成立  就输出  a-b  否则 a+b
    3. = a-if a>else a+b

    output

    3
    

    21.生成随机数

    1. print(random.random())
    2. print(random.randint(1100))
    3. print(random.uniform(1,5))

    output

    1. 0.03765019937131564
    2. 18
    3. 1.8458555362279228

    22.zip 函数用法

    zip() 函数将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表

    1. list1 = ['zhangfei''guanyu''liubei''zhaoyun']
    2. list2 = [0324]
    3. list(zip(list1, list2))

    output

    [('zhangfei', 0), ('guanyu', 3), ('liubei', 2), ('zhaoyun', 4)]
    

    23.range 和 xrange 的区别

    range([start,] stop[, step]),根据start与stop指定的范围以及step设定的步长,生成一个序列。而 xrange 生成一个生成器,可以很大的节约内存

    24.with 方法打开文件的作用

    开文件在进行读写的时候可能会出现一些异常状况,如果按照常规的 f.open 写法,我们需要 try,except,finally,做异常判断,并且文件最终不管遇到什么情况,都要执行 finally f.close() 关闭文件,with 方法帮我们实现了 finally 中 f.close

    25.什么是正则的贪婪匹配

    Python 中默认是贪婪匹配模式

    贪婪模式:正则表达式一般趋向于最大长度匹配

    非贪婪模式:在整个表达式匹配成功的前提下,尽可能少的匹配

    26.为什么不建议函数的默认参数传入可变对象

    例如:

    1. def test(L=[]):
    2.     L.append('test')
    3.     print(L)

    output

    1. test() # ['test']
    2. test() # ['test', 'test']

    默认参数是一个列表,是可变对象[],Python 在函数定义的时候,默认参数 L 的值就被计算出来了,是[],每次调用函数,如果 L 的值变了,那么下次调用时,默认参数的值就已经不再是[]了

    27.字符串转列表

    1. mystr = '1,2,3'
    2. mystr.split(',')

    output

    ['1', '2', '3']
    

    28.字符串转整数

    1. mylist = ['1''2''3']
    2. list(map(lambda x: int(x), mylist))

    output

    [1, 2, 3]
    

    29.删除列表中的重复值

    1. mylist = [123455]
    2. list(set(mylist))

    30.字符串单词统计

    1. from collections import Counter
    2. mystr = 'sdfsfsfsdfsd,were,hrhrgege.sdfwe!sfsdfs'
    3. Counter(mystr)
    4. output
    5.  Counter({'s'9,
    6.           'd'5,
    7.           'f'7,
    8.           ','2,
    9.           'w'2,
    10.           'e'5,
    11.           'r'3,
    12.           'h'2,
    13.           'g'2,
    14.          '.'1,
    15.          '!'1})

    31.列表推导,求奇偶数

    [for x in range(10) if x%2 == 1]
    

    output

    [1, 3, 5, 7, 9]
    

    32.一行代码展开列表

    1. list1 = [[1,2],[3,4],[5,6]]
    2. [j for i in list1 for j in i]

    output

    [1, 2, 3, 4, 5, 6]
    

    33.实现二分法查找函数

    二分查找算法也称折半查找,基本思想就是折半,对比大小后再折半查找,必须是有序序列才可以使用二分查找

    递归算法

    1.  def binary_search(data, item):
    2.      # 递归
    3.      n = len(data)
    4.      if n > 0:
    5.          mid = n // 2
    6.          if data[mid] == item:
    7.              return True
    8.          elif data[mid] > item:
    9.              return binary_search(data[:mid], item)
    10.         else:
    11.             return binary_search(data[mid+1:], item)
    12.     return False
    13. list1 = [1,4,5,66,78,99,100,101,233,250,444,890]
    14. binary_search(list1, 999)

    非递归算法

    1.  def binary_search(data, item):
    2.      # 非递归
    3.      n = len(data)
    4.      first = 0
    5.      last = n - 1
    6.      while first <= last:
    7.          mid = (first + last)//2
    8.          if data[mid] == item:
    9.              return True
    10.         elif data[mid] > item:
    11.             last = mid - 1
    12.         else:
    13.             first = mid + 1
    14.     return False
    15. list1 = [1,4,5,66,78,99,100,101,233,250,444,890]
    16. binary_search(list1, 99)

    34.字典和 json 转换

    字典转 json

    1. import json
    2. dict1 = {'zhangfei':1"liubei":2"guanyu"4"zhaoyun":3}
    3. myjson = json.dumps(dict1)
    4. myjson
    5. output
    6. '{"zhangfei"1"liubei"2"guanyu"4"zhaoyun"3}'
    7. json 转字典
    8. mydict = json.loads(myjson)
    9. mydict

    output

    {'zhangfei': 1, 'liubei': 2, 'guanyu': 4, 'zhaoyun': 3}
    

    35.列表推导式、字典推导式和生成器

    1. import random
    2. td_list=[i for i in range(10)]
    3. print("列表推导式", td_list, type(td_list))
    4. ge_list = (i for i in range(10))
    5. print("生成器", ge_list)
    6. dic = {k:random.randint(49)for k in ["a""b""c""d"]}
    7. print("字典推导式",dic,type(dic))

    output

    1. 列表推导式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
    2. 生成器 object at 0x0139F070>
    3. 字典推导式 {'a': 6, 'b': 5, 'c': 8, 'd': 9} <class 'dict'>

    36.简述 read、readline、readlines 的区别

    read 读取整个文件

    readline 读取下一行,使用生成器方法

    readlines 读取整个文件到一个迭代器以供我们遍历

    37.打乱一个列表

    1. list2 = [123456]
    2. random.shuffle(list2)
    3. print(list2)

    output

    [4, 6, 5, 1, 2, 3]
    

    38.反转字符串

    1. str1 = 'luobodazahui'
    2. str1[::-1]

    output

    'iuhazadoboul'
    

    39.单下划线和双下划线的作用

    __foo__:一种约定,Python 内部的名字,用来区别其他用户自定义的命名,以防冲突,就是例如__init__(),__del__(),__call__()些特殊方法

    _foo:一种约定,用来指定变量私有。不能用 from module import * 导入,其他方面和公有变量一样访问

    __foo:这个有真正的意义:解析器用_classname__foo 来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx 这样的方式可以访问

    40.新式类和旧式类

    a. 在 python 里凡是继承了 object 的类,都是新式类

    b. Python3 里只有新式类

    c. Python2 里面继承 object 的是新式类,没有写父类的是经典类

    d. 经典类目前在 Python 里基本没有应用

    41.Python 面向对象中的继承有什么特点

    a. 同时支持单继承与多继承,当只有一个父类时为单继承,当存在多个父类时为多继承

    b. 子类会继承父类所有的属性和方法,子类也可以覆盖父类同名的变量和方法

    c. 在继承中基类的构造(__init__())方法不会被自动调用,它需要在其派生类的构造中专门调用

    d. 在调用基类的方法时,需要加上基类的类名前缀,且需要带上 self 参数变量。区别于在类中调用普通函数时并不需要带上 self 参数

    42.super 函数的作用

    super() 函数是用于调用父类(超类)的一个方法

    1.  class A():
    2.      def funcA(self):
    3.          print("this is func A")
    4.  class B(A):
    5.      def funcA_in_B(self):
    6.          super(B, self).funcA()
    7.  
    8.      def funcC(self):
    9.          print("this is func C")
    10. ins = B()
    11. ins.funcA_in_B()
    12. ins.funcC()

    output

    1. this is func A
    2. this is func C

    43.类中的各种函数

    主要分为实例方法、类方法和静态方法

    实例方法

    定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法)

    调用:只能由实例对象调用

    类方法

    定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法)

    调用:实例对象和类对象都可以调用

    静态方法

    定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法

    调用:实例对象和类对象都可以调用

    静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,主要是一些逻辑属于类,但是和类本身没有交互。即在静态方法中,不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名称空间中

    类方法是将类本身作为对象进行操作的方法。他和静态方法的区别在于:不管这个方式是从实例调用还是从类调用,它都用第一个参数把类传递过来

    44.如何判断是函数还是方法

    与类和实例无绑定关系的 function 都属于函数(function)

    与类和实例有绑定关系的 function 都属于方法(method)

    普通函数:

    1. def func1():
    2.     pass
    3. print(func1)
    4. output
    5. 0x01379348>
    6. 类中的函数:
    7.  class People(object):
    8.      def func2(self):
    9.          pass
    10.      @staticmethod
    11.      def func3():
    12.          pass
    13.      @classmethod
    14.      def func4(cls):
    15.          pass
    16. people = People()
    17. print(people.func2)
    18. print(people.func3)
    19. print(people.func4)

    output

    1. <bound method People.func2 of <__main__.People object at 0x013B8C90>>
    2. <function People.func3 at 0x01379390>
    3. <bound method People.func4 of <class '__main__.People'>>

    45.isinstance 的作用以及与 type()的区别

    isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()

    区别:

    type() 不会认为子类是一种父类类型,不考虑继承关系

    isinstance() 会认为子类是一种父类类型,考虑继承关系

    1.  class A(object):
    2.      pass
    3.  class B(A):
    4.      pass
    5.  a = A()
    6.  b = B()
    7.  print(isinstance(a, A))
    8.  print(isinstance(b, A))
    9.  print(type(a) == A)
    10. print(type(b) == A)

    output

    1. True
    2. True
    3. True
    4. False

    46.单例模式与工厂模式

    单例模式:主要目的是确保某一个类只有一个实例存在

    工厂模式:包涵一个超类,这个超类提供一个抽象化的接口来创建一个特定类型的对象,而不是决定哪个对象可以被创建

    47.查看目录下的所有文件

    1. import os
    2. print(os.listdir('.'))

    48.计算1到5组成的互不重复的三位数

    1.  # 1到5组成的互不重复的三位数
    2.  k = 0
    3.  for i in range(16):
    4.      for j in range(16):
    5.          for z in range(16):
    6.              if (i != j) and (i != z) and (j != z):
    7.                  k += 1
    8.                  if k%6:
    9.                      print("%s%s%s" %(i, j, z), end="|")
    10.                 else:
    11.                     print("%s%s%s" %(i, j, z))

    output

    1. 123|124|125|132|134|135
    2. 142|143|145|152|153|154
    3. 213|214|215|231|234|235
    4. 241|243|245|251|253|254
    5. 312|314|315|321|324|325
    6. 341|342|345|351|352|354
    7. 412|413|415|421|423|425
    8. 431|432|435|451|452|453
    9. 512|513|514|521|523|524
    10. 531|532|534|541|542|543

    49.去除字符串首尾空格

    1. str1 = "   hello nihao    "
    2. str1.strip()

    output

    'hello nihao'
    

    50.去除字符串中间的空格

    1. str2 = "hello you are good"
    2. print(str2.replace(" """))
    3. "".join(str2.split(" "))

    output

    1. helloyouaregood
    2. 'helloyouaregood'


    ....博主太懒了字数太多了,不想写了....文章已经做成PDF,有需要的朋友可以私信我免费获取!

     

  • 相关阅读:
    C语言学习记录(三)之操作符
    车牌识别定位 matlab基本方法和操作
    js的call()和apply()
    算法通过村第九关-二分(中序遍历)黄金笔记|二叉搜索树
    微服务系列二:微服务架构面临的挑战
    【计算机网络】HTTP 重定向的应用场景
    JAVA 单例模式
    产品运营常用的ChatGPT通用提示词模板
    机器学习或者机器视觉代码讲解视频教程
    gorm 中的事务运用
  • 原文地址:https://blog.csdn.net/m0_72444380/article/details/125894103