Python-基础问题（二）

前言

接着上次的Python基础面试题

题目：

Python3和Python2中 int 和 long的区别？
4G 内存怎么读取一个 5G 的数据?
read、readline 和 readlines 的区别?
文件操作时：xreadlines和readlines的区别？
列举布尔值为False的常见值？
字符串、列表、元组、字典每个常用的5个方法？
lambda表达式格式以及应用场景? 用lambda函数的好处?
pass的作用？continue的作用? break的作用?
*arg和**kwarg作用
is和==的区别
简述Python的深浅拷贝以及应用场景？
拷贝的注意点?
Python垃圾回收机制？
Python的可变类型和不可变类型？
列举常见的内置函数？

Python3和Python2中 int 和 long的区别？

python2 中分int型和 long型，long型为长整型比int型的取值范围要大

Python3 取消long型将int型的取值范围扩大到long型的范围

4G 内存怎么读取一个 5G 的数据?

分段读取，每次读取固定的内容，与网络传输的分段传输差不多。
def get_lines(): # 生成器
with open(‘123.py’, ‘r’) as f:
while True:
data = f.readlines(100)
if data:
yield data
else:
break

f = get_lines()  # 迭代器对象
print(next(f))

read、readline 和 readlines 的区别?

read() 方法用来直接读取字节到字符串中, 最多读取给定数目个字节. 如果没有给定 size 参数(默认值为 -1)或者 size 值为负, 文件将被读取直至末尾. 未来的某个版本可能会删除此方法.
readline() 方法读取打开文件的一行(读取下个行结束符之前的所有字节). 然后整行，包括行结束符，作为字符串返回. 和 read() 相同, 它也有一个可选的 size 参数, 默认为 -1, 代表读至行结束符. 如果提供了该参数, 那么在超过 size 个字节后会返回不完整的行.
readlines() 方法并不像其它两个输入方法一样返回一个字符串. 它会读取所有(剩余的)行然后把它们作为一个字符串列表返回. 它的可选参数 sizhint 代表返回的最大字节大小. 如果它大于 0 , 那么返回的所有行应该大约有 sizhint 字节(可能稍微大于这个数字, 因为需要凑齐缓冲区大小).

文件操作时：xreadlines和readlines的区别？

readlines 返回一个列表

xreadlines 返回一个生成器

列举布尔值为False的常见值？

False None ‘’ 0 [] {} () set() 不成立的表达式

字符串、列表、元组、字典每个常用的5个方法？

字符串：

find通过元素找索引，可切片，找不到返回-1
index，找不到报错。
split 由字符串分割成列表，默认按空格。
captalize 首字母大写，其他字母小写。
upper 全大写。
lower 全小写。
title，每个单词的首字母大写。
startswith 判断以什么为开头，可以切片，整体概念。
endswith 判断以什么为结尾，可以切片，整体概念。
format格式化输出
strip 默认去掉两侧空格，有条件， 12，lstrip,rstrip 14,center 居中，默认空格。
count查找元素的个数，可以切片，若没有返回0
expandtabs 将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，
replace（old，new,次数）
isdigit 字符串由字母或数字组成 isalpha, 字符串只由字母组成 isalnum 字符串只由数字组成
swapcase 大小写翻转
for i in 可迭代对象。

###字典：

key：输出所有的键
clear：清空
dic：删除的键如果没有则报错
pop：键值对删，有返回，没有原来的键会报错（自行设置返回键就不会报错）
popitem：随机删键值对
del：删除的键如果没有则报错

列表：

append：在后面添加。
Insert按照索引添加，
expend：迭代着添加。
list.extend(seq) - 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
pop 删除 (pop 有返回值)
remove 可以按照元素去删
clear 清空列表
del 1、可以按照索引去删除 2、切片 3、步长（隔着删）
list.count(obj) - 统计某个元素在列表中出现的次数
list.index(obj) - 从列表中找出某个值第一个匹配项的索引位置
list.reverse() - 反向列表中元素
list.sort([func]) - 对原列表进行排序

###元组：

cmp(tuple1, tuple2)：比较两个元组元素。
len(tuple)：计算元组元素个数。
max(tuple)：返回元组中元素最大值。
min(tuple)：返回元组中元素最小值。
tuple(seq)：将列表转换为元组。

lambda表达式格式以及应用场景? 用lambda函数的好处?

匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
函数名 = lambda 参数：返回值

参数可以有多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

返回值和正常的函数一样可以是任意数据类型

#lambda 表达式

temp = lambda x,y:x+y

print(temp(4,10))   

#可替代：
def foo(x,y):
    return x+y
print(foo(4,10))

pass的作用？continue的作用? break的作用?

###pass
pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

###continue
退出本次循环，执行下一次循环

###break
结束循环

*arg和**kwarg作用

*args代表位置参数，它会接收任意多个参数并把这些参数作为元祖传递给函数。

**kwargs代表的关键字参数，返回的是字典，位置参数一定要放在关键字前面

is和==的区别

is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。

== 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。默认会调用对象的 eq()方法。

a = 'lishi'
str1 = "li"
str2 = "shi"
str3 = str1 + str2
print("a == str3",a == str3)
print("a is str3",a is str3)
print("id(a)",id(a))
print("id(str3)",id(str3))
# a == str3 True    ==  ---> 只需要内容相等
# a is str3 False   is  ---> 只需要内存地址相等
# id(a) 38565848
# id(str3) 39110280

简述Python的深浅拷贝以及应用场景？

浅拷贝只是增加了一个指针指向一个存在的地址，

而深拷贝是增加一个指针并且开辟了新的内存，这个增加的指针指向这个新的内存，
采用浅拷贝的情况，释放内存，会释放同一内存，深拷贝就不会出现释放同一内存的错误

一层的情况：

import copy

 #浅拷贝
li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

# 深拷贝
li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

多层的情况：

import copy

# 浅拷贝 指向共有的地址
li1 = [1, 2, 3,[4,5],6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]

# 深拷贝 重指向
li1 = [1, 2, 3,[4,5],6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]

拷贝的注意点?

区分深拷贝与浅拷贝

Python垃圾回收机制？

引用计数

标记清除

分代回收

python垃圾回收机制详解

Python的可变类型和不可变类型？

可变类型：

列表
字典（索引不可变）
可变集合

不可变类型：

字符串
数字
元祖
不可变集合

列举常见的内置函数？

①map():对可迭代对象中的每个元素都进行相同的处理，最后返回一个新的可迭代对象，python2中直接返回列表形式

②filter():对可迭代对象中的每个元素进行筛选，最后将符合条件的元素装进一个新的可迭代对象里，python2中直接返回列表形式

③reduce():对可迭代对象中的元素进行一个操作（如所有的值加起来），最后返回新数值

#===========input========输入
s = input("请输入内容 ： ")  #输入的内容赋值给s变量
print(s)  #输入什么打印什么。数据类型是str
# ==========abs==========绝对值
print(abs(-1))  # 1

# ==========all==========可迭代对象的每个元素的布尔操作都是True时返回True，若传入的可迭代对象是空则返回True
print(all(['', 1, 's']))  # False

# ==========any==========可迭代对象的每个元素的布尔操作中有一个是True时就返回True，若传入的可迭代对象是空则返回True
print(any(['', 5, '0']))  # Ture

# ==========bin==========将十进制数转成二进制数
print(bin(3))  # 0b11

# ==========hex==========将十进制数转成十六进制数
print(hex(10))  # 0xa

# ==========oct==========将十进制数转成八进制数
print(oct(8))  # 0o10

# ==========bool==========布尔值操作: 空 0 None 布尔操作为False
print(bool([]))  # False

# ==========bytes==========编码 将传入的字符串用某种编码方式转换成二进制
print(bytes('陈', encoding='utf-8'))  # b'\xe9\x99\x88'
print(bytes('陈', encoding='utf-8').decode('utf-8'))  # 陈  # 译码 译码与编码应采用一样的

# ==========chr==========将ASCII码转成对应字符
print(chr(97))  # a

# ==========ord=========将字符转成对应的ASCII码值
print(ord('a'))  # 97

# ==========dir==========打印某种对象里面的所有属性
print(dir(all))

# ==========divmod==========参数1除以参数2 返回一个元组（商，余数）
print(divmod(10, 3))  # (3, 1)

# ==========eval==========
dic = {'name': 'chen'}
dic_str = str(dic)
# ===================================功能1：提取成传入的字符串中的数据类型
print(dic_str)  # '{'name': 'chen'}'
print(type(dic_str))  # <class 'str'>
print(eval(dic_str))  # {'name': 'chen'}
print(type(eval(dic_str)))  # <class 'dict'>
# ===================================功能2：计算字符串中的数学运算
s = '1 + 2 * 1'
print(eval(s))  # 3

# ==========hash==========hash运算
print(hash('chen'))  # -1076846465005340399
print(hash('chenyuanyuan'))  # -8978753568388561982  #hash()---->hash运算

# ==========help==========函数功能解释
print(help(all))

# ==========isinstance==========判断某个对象是否是某种数据类型的实例对象
print(isinstance('2', str))  # True

# ==========globals、locals==========全局变量、局部变量
name = 'chen'


def test():
    age = 18
    print(globals())  # 打印所有的全局变量，包括name
    print(locals())  # {'age': 18} #打印所有的局部变量


test()

# ==========min、max==========最小值、最大值
dic = {'chen': 100, 'wang': 200, 'li': 500, 'do': 600}
# ============一个可迭代参数
print(min(['a01', 'b10', 'c1']))  # a01 遍历出每个元素，比较它们的的第一位的ASCII码值，找到最小后就停止比较
# print(min(['a01', 'b10', 'c1', 30])) #报错 不同数据类型无法比较
print(min(dic))  # chen
print(max(dic))  # wang
print(min(dic.values()))  # 100
print(max(dic.values()))  # 600
print(max(zip(dic.values(), dic.keys())))  # (600, 'do') #max与zip结合找出value值最大的那一组
# ============两个参数
print(min(dic, key=lambda k: dic[k]))  # chen
print(max(dic, key=lambda k: dic[k]))  # do

# ==========zip==========拉链操作，将多个可迭代对象(列表，元组，字符串)对应元素组成一个元组，多余元素自动去掉，返回可迭代对象
print(list(zip('abc', 'def', 'ghihhhhh')))  # [('a', 'd', 'g'), ('b', 'e', 'h'), ('c', 'f', 'i')]
print(list(zip(dic.keys(), dic.values())))  # [('chen', 100), ('wang', 200), ('li', 500), ('do', 600)]

# ==========pow==========参数1的参数2次方，结果对参数3进行取余操作
print(pow(2, 3))  # 8
print(pow(2, 3, 1))  # 0

# ==========reversed==========反转可迭代对象中元素的排列顺序，返回迭代器
a = [1, 2, 3]
print(list(reversed(a)))  # [3, 2, 1]

# ==========round==========四舍五入取整
print(round(2.66))  # 3

# ==========set==========将其他数据类型转换成集合
print(set('hello'))  # {'h', 'o', 'e', 'l'}

# ==========slice==========切片：参数1-->起始索引，参数2-->结束索引，参数3-->步长
a = 'ehllovihgh'
s1 = slice(2, 6, 2)
print(s1.start)  # 2
print(s1.stop)  # 6
print(s1.step)  # 2
print(a[s1])  # lo

# ==========sorted==========排序
a = [1, 25, 2, 3]
print(sorted(a)) #[1, 2, 3, 25]  #不同数据类型任然无法进行排序比较
lists = [{'name': 'chen', 'age': 18}, {'name': 'wang', 'age': 25}, {'name': 'li', 'age': 9}]
print(sorted(lists, key = lambda dic:dic['age']))
#[{'name': 'li', 'age': 9}, {'name': 'chen', 'age': 18}, {'name': 'wang', 'age': 25}]
info = {'liu': 100, 'li': 12200, 'chen': 100000}
print(sorted(info.keys()))  #['chen', 'li', 'liu']  #比较key值
print(sorted(info.values())) #[100, 12200, 100000]  #比较value值
print(sorted(info, key = lambda key: info[key]))   #['liu', 'li', 'chen'] #比较value值，返回key值
print(sorted(zip(info.values(), info.keys())))   #[(100, 'liu'), (12200, 'li'), (100000, 'chen')]

# ==========type==========查看数据类型
print(type('ll'))  # <class 'str'>

# ==========sum==========求和
print(sum([5, 2, 3])) #10

# ==========range==========范围
for item in range(5):
    print(item)
# 0
# 1
# 2
# 3
# 4
for item in range(5, 7):
    print(item)
# 5
# 6

# ==========__import__==========引入字符串类型的模块名
m = __import__('...')
m.函数名()

常用内置函数列举