Python基础题
2021-04-30 16:27
标签：int 表达 映射 单引号 可迭代对象 跨行 用户 abc oba 1、简述列举了解的编程语言及语言间的区别？ 2、列举Python2和Python3的区别？ 3、看代码写结果 and:真真取后真，假假取前假，真假取假 4、比较以下值有什么不同？ 5、用一行代码实现数值交换。 6、Python中单引号、双引号、三引号的区别？ 7、is和==的区别？ 8、python里如何实现tuple和list的转化？ 9、如何实现字符串 name=‘老男孩’的反转？ 10、两个set如何获取交集、并集、差集？ 11、那些情况下, y != x - (x-y)会成立? 12、Python中如何拷贝一个对象？ 13、简述 赋值、浅拷贝、深拷贝的区别？ 14、pass的作用？ 15、阅读代码写结果。 16、用Python实现9 * 9 乘法表。 17、用Python显示一个斐波那契数列0，1，1，2，3，5，8，13……。 18、如何删除列表中重复的值？ 19、一个大小为100G的文件etl_log.txt, 要读取文件中的内容, 写出具体过程代码？ 20、a = dict(zip((“a”,“b”,“c”,“d”,“e”),(1,2,3,4,5))) 请问a是什么？ 21、lambda关键字的作用？ 22、*arg和**kwarg作用? 23、如何在函数中设置一个全局变量 ? 24、filter、map、reduce的作用？ 25、什么是匿名函数？匿名函数有什么作用？ 26、Python递归的最大层数？ 27、什么是迭代器？什么是可迭代对象？ 28、什么是生成器？ 29、什么是装饰器及应用场景？ 30、什么是反射及应用场景？ 31、写一个普通的装饰器。 32、写一个带参数的装饰器。 ? 33、求结果 34、def(a, b=[])这种写法有什么陷阱？ 35、看代码写结果 36、看代码写结果 37、请编写一个函数实现将IP地址转换成一个整数。 再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？ 38、请查找一个目录下的所有文件（可能存在文件嵌套）。 39、求结果 40、是否使用过functools中的函数？其作用是什么？ 41、re的match和search区别？ 42、用Python匹配HTML tag的时候,<.>和<.>有什么区别? 43、如何生成一个随机数？ 44、super的作用？ 45、双下划线和单下划线的区别？ 46、@staticmethod和@classmethod的区别？ 47、实现一个单例模式（加锁）。 48、栈和队列的区别？ 49、以下代码输出是什么? 请给出答案并解释。 50、参考下面代码片段 Python基础题 标签：int 表达 映射 单引号 可迭代对象 跨行 用户 abc oba 原文地址：https://www.cnblogs.com/remixnameless/p/13227995.html编译型: 一次性全部编译成二进制码,然后运行
解释型:编译一行,运行一行
1.python 解释型,间接高效,容易上手,各个方向百花齐放
2.java 混合型(JVM,JIT编译器),开发周期慢,web方向
3.c 编译型 属于底层开发,只有面向过程,没有面向对象
4.c++ 编译型 属于底层开发,既有面向过程,还有面向对象
5.go 编译型 应用在区块链,高并发高可用,游戏方向
Python2中print是语句不需要括号即可输出，Python3print是函数需要
Python2默认ASCII，Python3默认Unicode
Python2中存在经典类和新式类，Python3中统一采用新式类
Python2有long，Python3没有long
Python2中数值比较大时，出现long类型，Python3中所有整数都是int类型，不存在long类型
Python2除法取整数，Python3除法获取的是浮点数
Python2可带可不带引号，Python3必须带引号
Python2中raw_input获取的内容都是字符串，input获取的是int,float，Python3去除了raw_input，保留了input函数，任意输入都是返回的是字符串
Python2打印range获取的是列表，Python3打印range获取的就是range本身
or:真真取前真，假假取后假，真假取真v1 = 1 or 2 #1
v2 = 3 and 7 or 9 and 0 #7
v1 = [1,2,3]
v2 = [(1),(2),(3)]
v3 = [(1,),(2,),(3,)]
#v1，v2列表中的元素类型是数字，v3中的元素类型是元组
a = 1
b = 2
a,b=b,a
单引号和双引号中间是字符串，三引号中间是注释
单双引号没有区别,三引号可以支持跨行在互相嵌套时需注意:里外不能使用相同的引号
is 判断两边内存地址是否相同
== 判断两边值是否相等
a= (1,2)
list(a)
tuple(a)
name[::-1]
a ={1,2,3,4}
b = {2,3,5,6}
print(a&b) #交集a.intersection(b)
print(a|b) #并集a.union(b)
print(a-b) #差集a.difference(b)
#非空集合且不为子父关系的两个集合
y != x-(x-y)
x = {“a”,“b”,“c”}
y = {“b”,“d”}
if y != x-(x-y):
print(“ok”)
1.copy.copy
2.lst.copy
3.切片[:]或[::]
#赋值 : 将变量和值在内存中形成映射指向关系
#浅拷贝 : 只拷贝第一级里所有的元素 copy.copy
#深拷贝 : 为所有层级的元素都单独开辟新空间 copy.deepcopy() (地址:原不可变数据只是暂时的指向,可变的数据独立开辟新空间)
"""
可变数据: list set dict
不可变数据: int float bool complex str tuple
"""
占位
import copy
a = [1,2,4,5,[‘b‘,‘c‘]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(5)
a[4].append(‘d‘)
print(b) #[1,2,4,5,[‘b‘,‘c‘,‘d‘],5]
print(c) #[1,2,4,5,[‘b‘,‘c‘,‘d‘]]
print(a) #[1,2,4,5,[‘b‘,‘c‘,‘d‘],5]
#1
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d" % (i,j,i*j),end=" ")
print(‘\n‘)
# 2
i = 1
while i# 方法一
lst = [1,1]
for i in range(10):
lst.append(lst[-1] + lst[-2])
print(lst)
# 方法二
a,b = 0,1
for i in range(10):
print(b)
a,b = b,a+b
# 方法三
#示范：
def fib(n):
if n a = [1,1,2,3,4,4]
a = list(set(a))
# 第一种
with open("文件",mode = "r",encoding="utf-8") as fp:
# 一次最多读取100个字符
res = fp.read(100)
while res:
print(res)
res = fp.read(100)
# 第二种
f = open(文件,mode="r",encoding="utf-8")
for line in f:
# f是迭代器,遍历时,默认按照一行一行进行读取
print(line)
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4, ‘e‘: 5}
匿名函数
#*arg 普通收集参数 : 收集多余的没人要的普通实参
#**kwarg 关键字收集参数: 收集多余的没人要的关键字实参
global
filter 过滤元素，返回一个迭代器对象
map 映射
reduce 会对元素进行累计算
使用lambda表示匿名函数
不需要显示的定义函数，方便
官方说法1000 , 实际测试 994 ~ 1000
import sys
sys.setrecursionlimit(100000)
def foo(n):
print(n)
n += 1
foo(n)
if __name__ == ‘__main__‘:
foo(1)
# 修改递归的最大深度,得到的值在3925-3929之间浮动，这个是和计算机有关系的，不然也不会是一个浮动的数字了（数学逻辑讲求严谨）
实现了iter和next()方法的对象都是迭代器
实现了iter方法的对象叫做可迭代对象
生成器的本质就是迭代器,可以自定义迭代的逻辑
创建方式两种:
(1)生成器表达式 (推导式) (i for i in range(3))
(2)生成器函数 (含有yield关键字)
装饰器的本质就是闭包
在不修改原有代码的前提下,额外增加新功能就是装饰器
应用:登录认证,property类,框架(django,flask,@app.route("/",methdos=[“GET”,“POST”]))
通过字符串去操作类对象 或者 模块中的属性方法
hasattr getattr setattr delattr
应用: 可以配合用户的操作或者输入,调用其中的成员,api接口中
def warpper(f):
def inner():
f()
return inner
@warpper
def func():
print("被装饰的函数")
def outer(n):
def wrapper(func):
def inner1(*args,**kwargs):
res = func(*args,**kwargs)
print("我是大王")
return res
def inner2(*args,**kwargs):
res = func(*args,**kwargs)
print("大王叫我来巡山")
return res
if n == "alex":
return inner1
else:
return inner2
return wrapper
@outer("alex123") # outer("alex123") => wrapper =>@wrapper
def func():
print("i am fine 3q")
func()def warpper(func):
def inner(*args,**kwargs):
func(*args,**kwargs)
return inner
@warpper
def foo():
print("被装饰的函数")
def num():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in num()])
[6,6,6,6]
"""
刚开始定义的时候,没有去执行函数内部的内容,不存在i变量的赋值.
只有在调用的时候,才会去获取此时的i值
而调用时,此时的i值是3,由于遍历已经结束,而i的值处在闭包中,延长该变量的生命周期,可以获取到
return i * x => return 3 * 2 => 6
由于是4个函数,所以是4个6;
"""
b身上的默认值是列表,如果使用原来默认的参数,调用func函数
会把几次调用的值都存放在同一个默认列表里
默认参数:
如果调用时,用户给实参了,那么使用用户的
如果调用时,用户没给实参,那么使用默认的(早已存在内存中的这个列表)
默认值会提前在内存中驻留,在使用时,才能调取,在定义函数的时候就提前开辟了空间
def func(a,b=[]):
b.append(a)
return b
v1 = func(1)
v2 = func(2,[10,20])
v3 = func(3)
print(v1,v2,v3)
# [1, 3] [10, 20, 2] [1, 3]
def func(a,b=[]):
b.append(a)
return b
v1 = func(1)
print(v1)
v2 = func(2,[10,20])
print(v2)
v3 = func(3)
print(v3)
[1]
[10, 20, 2]
[1, 3]
如 10.3.9.12 转换规则为：
10 00001010
3 00000011
9 00001001
12 00001100#ljust 原字符串居左,填充符号
#rjust 原字符串居右,填充符号
#方法一
ip = "10.3.9.12"
strvar = ""
for i in ip.split("."):
bin_str = str(bin(int(i)))[2:]
#总长度是8 原字符串居右
strvar += bin_str.rjust(8,"0")
#把二进制字符串转换成十进制,默认转换时,是十进制
print(int(strvar,2))
#方法二
ip = "10.3.9.12"
strvar = ""
for i in ip.split("."):
#format 将整型转化成二进制,不够8位的拿0补位
strvar += format(int(i) , "08b")
print(int(strvar,2))
# 方法一 (递归写法)
import os
def getallsize(pathvar):
size = 0
lst = os.listdir(pathvar)
print(lst)
for i in lst:
pathvar2 = os.path.join(pathvar,i)
print(pathvar2)
# 判断是否是文件
if os.path.isfile(pathvar2):
size += os.path.getsize(pathvar2)
# 判断是否是文件夹
elif os.path.isdir(pathvar2):
size += getallsize(pathvar2)
print(size)
return size
"E:\chuan\test\a.txt"
pathvar = r"E:\chuan\test"
res = getallsize(pathvar)
print(res)
#方法二
import os
os.walk() => 生成器
pathvar = r"E:\chuan\test"
gen = os.walk(pathvar)
for root,dirs,files in gen:
for name in files:
pathvar = os.path.join(root,name)
print(pathvar)
import math
print(math.floor(5.5))
print(math.ceil(5.1))
# floor 地板 向下取整
# ceil 天花板 向上取整
from functools import reduce
#在装饰器中使用,如果想要保留原来函数的属性,加上wraps
# 在装饰器中使用,保留原函数的属性,避免暴露装饰器的名字;
from functools import wraps
def wrapper(func):
@wraps(func)
def inner(*args,**kwargs):
res = func(*args,**kwargs)
print("雷霆嘎巴,无情哈拉少")
return res
return inner
@wrapper
def func():
print(1111)
return 123
match : 必须从字符串的开头进行匹配
search: 从任意位置开始匹配,匹配到就返回只匹配一个
<.> 除了\n的任意字符 , 个数必须是一个
<.> 除了\n的任意字符 , 个数必须是一个 或者 0个
. 除了\n的任意字符
* ? + {3,10} 都是量词
.? 除了\n的任意字符 匹配到0个或者1个
.* 贪婪匹配 默认向更多次匹配
.*? 非贪婪匹配 默认向更少次匹配
.?? 非贪婪匹配 默认向更少次匹配
import randomrandom.random 随机获取 0用来解决多继承之间复杂的调用关系使用super
类.mro() => 调用顺序列表(继承关系)
super调用父类相关成员时,参照mro列表中的继承顺序依次调用
class MyClass():
__abc = 90
_ppp = 100
"""
封装: 公有public 私有private 受保护的protected
私有:__ 2个下划线来表达 __sex
受保护:在python 中有约定俗成的写法,在成员的前面加上一个下划线
(可以在继承时使用该成员,无法在类外使用;) _sex
魔术方法/属性: __doc__ __init__ ...
"""
@staticmethod 静态方法
无论是类还是对象,都可以调用,不会默认传递任何参数
@classmethod 类方法
无论是类还是对象,都可以调用,默认传递类这个参数
"""
目的: 节省内存空间,提高运行效率,应用在多人使用同一个操作类的场景
没生成一个对象,都在内存中占用空间,尤其在执行mysql操作类时
因为多人的使用,创建出多个对象,而对象本身不会额外增加新成员,只做单纯的成员调用
那么就可以使用单态模式;
"""
from threading import Lock
class SingleTon():
# 防止类外直接调用__obj成员,对他进行保护,所以用私有
__obj = None
lock = Lock()
# 控制对象的创建
def __new__(cls,*args,**kwargs):
with cls.lock:
if not cls.__obj:
cls.__obj = object.__new__(cls)
return cls.__obj
obj1 = SingleTon()
obj2 = SingleTon()
obj3 = SingleTon()
print( id(obj1) , id(obj2) , id(obj3) )
栈: 先进后出 或 后进先出
队列: 先进先出 或 后进后出
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x) # 1 1 1
Child1.x = 2
print(Parent.x, Child1.x, Child2.x) # 1 2 1
Parent.x = 3
print(Parent.x, Child1.x, Child2.x) # 3 2 3
""" 面向对象的上下文管理, with语法的具体实现 """
class Context:
# 在使用with语法时,自动触发,功能返回对象
def __enter__(self):
return self
# 在执行完with语法之后,自动触发,用来做收尾操作
def __exit__(self, exc_type, exc_val, exc_tb):
print("关闭文件 f.close() ")
def do_something(self):
print("我是做点什么~")
with Context() as ctx:
ctx.do_something()