记录自己答题带思路Python简单？先来40道基础面试题测试下

1.深浅拷贝

2.迭代器生成器

3.列表元祖字典字符串集合

4.正则

5.动态获取设置类属性

6.内存管理机制

7.面向对象

8.python2 python3

9.小数据

池

希望大家批评指正感谢

1.python2中有range和xrange，这两个有什么区别？
答：range 创建列表，for i in range() 用的多循环
str = ‘lxp666’
for i in range(len(str)):
print(str[i])
换行打印字符串

2.print(int(‘111’, 2)) 的结果是？
答：是2的零次方+ 2的一次方 + 2的平方
print(int(‘111’, 5)) 那就是 5的零次方+…

疑问print(int(‘222’, 2)) 这种没见过还是要翻阅一下int函数语法！！

3.在python当中如何获取命令行参数？
sys 不太懂希望大家百度

4.python中id、is、=、== 分别是比较什么的？
id 是来内存地址的 is引用相同 = 赋值 = = 两个值是否相等

5.python的小数据池是什么？
在牛客网刷题遇到过
原题： a=[1,2,3] b=[1,2,4] id(a[1]) == id(b[1]) 结果是true
范围在[-5,256]
暴力记忆占用内存很小，小数据池的范围是-5~256 ，如果多个变量都是指向同一个（在这个范围内的）数字，他们在内存中指向的都是一个内存地址。

6.test = [{‘name’:‘tom’, ‘salary’:20000}, {‘name’:‘jack’, ‘salary’:15000}, {‘name’:‘liming’, ‘salary’:10000},]，根据salary由大到小进行排序

test = [{'name': 'tom', 'salary': 20000}, {'name': 'jack', 'salary': 25000}, {'name': 'liming', 'salary': 10000}, ]
list1 = []
for one in test:list1.append(one['salary'])
list1.sort(reverse=True)
list2 = []
for j in range(0, len(list1)):for one in test:if list1[j] == one['salary']:list2.append(one)print(list1)
print(list2)

思路：先将字典循环遍历将字典中的key=slary 薪资添加到一个列表中，然后sort(reverse=true) 进行反转排序先从小到大在反转列表。
然后再次循环遍历， list1的值 == salary时将小字典加入新的列表list2

10、流程控制当中：pass、continue、break、exit分别是什么作用？
先答这一题
pass是相当于空着写会报错，加上不会
continue 跳出本次循环
break 终止循环
exit 不用
例: 循环遍历小于10 ifa==5 continue print(a) 跳过5 其他都打印
break 截止到5
11、python当中的赋值、浅拷贝、深拷贝有什么区别？

list1=[1,2,3,4]
①list2=list1
②list2 =list1.copy()id(list1)    id(list2)

①：改变list1中的值 list2的值也会改变 id 内存地址相同
② ：拷贝后地址不同 list1 值改变后 list2 不变。
目录

深浅拷贝 1
2.迭代器生成器 2
3小知识点列表元组字典字符串 4

1.深浅拷贝

1、b = a: 赋值引用，a 和 b 都指向同一个对象。
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

2.迭代器生成器

只要一个对象有__iter__方法和__next__方法，那么这个对象就可以叫做迭代器。
#对一个可迭代对象调用它的__iter__方法，得到的就是迭代器对象。
#迭代器的特点
#优点：不依赖索引惰性计算，节省内存
缺点：不如按索引取值方便一次性，只能往后取，不能往回退
#或者说，你想喝水，杯子有游泳池那么大；
#①把杯子装满再喝
#②一遍往杯子装水，一边喝杯子里已经装好的水（生成器）

print(iter(list1))
print(isinstance(list1, Iterable))
print(isinstance(list1, Iterator))
print(list1)
list1 = iter(list1)
print(type(list1))
print(list1)
print(list1.__next__())
print(list1.__next__())def next():yield 1yield 2yield 3
print(type(next()))
foo1 = next()
print(foo1.__next__())
#for i in list5():
#print(i)
list6 =(i for i in range(4))
print(list6.__next__())
print(list6.__next__())
print(list6.__next__())
print(foo1.__next__())
print(list6.__next__())

3小知识点列表元组字典字符串

1.创建列表：list=[] list = list(data) 例子： list(range(5))
2.创建字典：
Dict={}
Dict = dict()
Dict = dict(zip(list1,list2))
Dict = dict(key1=value1,key2=value2)
Dict = dict.fromkeys(list1)
Dict = {tuple1:list1} 注意此种方法列表不能做keys 因为列表可变序列
①列表
索引；切片

l = [0,1,2,3,4]
print(l[0],l[1])  #0 1
print(l[:2])      #[0, 1]
print(l[-1])      #4
print(l[::-1])    #[4, 3, 2, 1, 0]
print(l[1:])      #[1, 2, 3, 4]
print(l[9:])      #[]
print(l[1::2])    #[1, 3]
print(l[7])       #IndexError: list index out of range   （会报错超出索引下标）

排序：

dict={'a':24,'w':52,'g':12,'c':33}
print(dict.items())            #dict_items([('a', 24), ('w', 52), ('g', 12), ('c', 33)])
l1 = list(dict.items())
print(sorted(l1, key=lambda x: x[1]))  #[('g', 12), ('a', 24), ('c', 33), ('w', 52)]
l2 = [1,56,2,56,87,9,56,12]
# l2.sort()
print(sorted(l2))      # [1, 2, 9, 12, 56, 56, 56, 87]
print(l2)              #[1, 56, 2, 56, 87, 9, 56, 12]

4.正则表达式：

import  re
str = r'\b\d+lxp'
str1 = '1154326487324lxp'
str3 = re.match(str,str1)    #查找   <re.Match object; span=(0, 16), match='1154326487324lxp'>
print(str3)
str4 = r'[2]'
str2 =re.sub(str4,'33',str1)  #替换115433364873334lxp
print(str2)

.	匹配出换行符以外的任意字符·
\w	匹配字母或者数字或者下划线或者汉字
\s	匹配任意空白符
\d	匹配任意数字
\b	匹配单词的开始或者结束
^	匹配单词的开始
$	匹配单词的结束
?	匹配零次或者一次
+	匹配一次或者多次
*	匹配零次或者多次

5.动态获取和设置类属性

1. if hasattr(Parent，'x'):
2.  print(getattr(Parent，'x'))
3.  setattr(Parent，'x'，29)
4.  print(getattr(Parent，'x'))

6.Python的内存管理机制

内存管理机制：引用计数、垃圾回收、内存池。引用计数：1. 引用计数是一种非常高效的内存管理手段， 当一个 Python 对象被引用时其引用计数增加1， 当其不再被一个变量引用时则计数减 1. 当引用计数等于0时对象被删除。.
引用计数也是一种垃圾收集机制，而且也是一种最直观，最简单的垃圾收集技术。当 Python 的某
个对象的引用计数降为 0 时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为 1。如果引用被删除，对象的引用计数为 0，
那么该对象就可以被垃圾回收。不过如果出现循环引用的话，引用计数机制就不再起有效的作用了垃圾回收

7.面向对象三大特性：

封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同代码不用重复编写
多态：不同的对象调用相同方法产生不同的执行结果

明天继续。