1.is 和==的区别？
is：比较的是两个对象的id值是否相等，也就是比较俩对象是否为同一个实例对象。是否指向同一个内存地址
== ： 比较的两个对象的内容/值是否相等，默认会调用对象的eq()方法
2.python中内置的数据结构有几种？
4种
列表 字典 字符串 集合 元祖
3.Python中变量的作用域？（变量查找顺序)
函数作用域的LEGB顺序
1.什么是LEGB?
L： local 函数内部作用域
E: enclosing 函数内部与内嵌函数之间
G: global 全局作用域
B： build-in 内置作用
python在函数里面的查找分为4种，称之为LEGB，也正是按照这是顺序来查找的4.python新式类和经典类的区别
在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式类”，都会获得所有“新式类”的特性；
反之，不由任意内置类型派生出的类，则称之为“经典类”。
“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
5.super函数的具体用法和场景
https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html6.一行代码实现1-100之和
print(sum(range(1,101)))7.用一行python代码写出实现四个数之和
rom functools import reduce
#使用sum内置函数求和
print(sum([1,2,3,10248]))
#使用reduce函数
print(reduce(lambda x,y : x + y, [1,2,3,10248]))
'''
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
'''8.一行代码生成指定列表
'''
用一行代码生成[1,4,9,16,25,36,49,64,81,100]
'''
print([i * i for i in range(1,11)])
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]9.全字母短语判断
'''
全字母短句 PANGRAM 是包含所有英文字母的句子，
比如：A QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
定义并实现一个方法 get_missing_letter, 传入一个字符串采纳数，
返回参数字符串变成一个 PANGRAM 中所缺失的字符。应该忽略传入字符串参数中的大小写，
返回应该都是小写字符并按字母顺序排序（请忽略所有非 ACSII 字符）
'''
def get_missing_letter(a):
s1 = set('abcdefghijklmnopqrstuvwxyz')
s2 = set(a)
ret = ''.join(sorted(s1-s2))
return ret
print(get_missing_letter('Lions, and tigers, and bears, oh my'))10.列表切片下标超限
list = ['a','b','c','d','e']
print(list[10:]) #[]
print(list[10]) #IndexError: list index out of range
'''
代码将输出[],不会产生IndexError错误，
就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。
例如，尝试获取list[10]和之后的成员，会导致IndexError。
然而，尝试获取列表的切片，开始的index超过了成员个数不会产生IndexError，而是仅仅返回一个空列表。
这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致Bug很难被追踪到。
'''11.列表合并
'''
两个有序列表，l1,l2，对这两个列表进行合并不可使用extend
'''
def loop_merge_sort(l1, l2):
tem = []
while len(l1) > 0 and len(l2) > 0:
if l1[0] < l2[0]:
tem.append(l1[0])
del l1[0]
else:
tem.append(l2[0])
del l2[0]
return tem
l1 = [1,3,5,9,8,2,68,12,35]
l2 = [5,6,8,7,2,65,12,45,36]
listed = loop_merge_sort(l1, l2)
print(listed)12.请写出一段python代码实现删除list里面的重复元素？
l1 = ['b','c','d','c','a','a']
'''
方法一使用集合去重 set
'''
l2 = list(set(l1)) #set集合元素不重复 可以去重 然后再转化为list
print(l2) #集合set是无序的 会打乱原来list列表顺序
'''
方法二 用list的sort方法 避免打乱list顺序
'''
l1 = ['b','c','d','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index) # 保存顺序和原list一致 今天才发现python的sort有个key参数,我好圡...
#key=l1.index表示按照l1列表中的数值对应的下标进行排序，也就是按照原先的顺序排序
print(l2)
'''
方法三 方法二 可以视作一个
'''
l1 = ['b','c','d','c','a','a']
l2 = sorted(set(l1), key=l1.index)
print(l2)
'''
sort 和 sorted 主要的区别在于:
list.sort()是对已经存在的列表进行操作，进而可以改变进行操作的列表。
而内建函数sorted返回的是一个新的list，而不是在原来的基础上进行的操作.
'''
'''
方法四 将一个列表的数据取出来放到另外一个列表中，之间做判断
'''
l1 = ['b','c','d','c','a','a']
l2 = []
for i in l1:
if not i in l2:
l2.append(i)
print(l2)
'''
方法五 使用字典
'''
b = {}
b = b.fromkeys(l1)
# print(b)
c = list(b.keys())
print(c)
#Python 字典 fromkeys() 函数用于创建一个新字典，
# 以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
#seq -- 字典键值列表。
#value -- 可选参数, 设置键序列（seq）的值。不指定默认值none13.阅读一下代码他们的输出结果是什么？
def multi():
return[lambda x:i*x for i in range(4)]
print([m(3) for m in multi()])
'''
正确答案是[9,9,9,9]，而不是[0,3,6,9]
产生的原因是Python的闭包的后期绑定导致的，这意味着在闭包中的变量是在内部函数被调用的时候被查找的，
因为，最后函数被调用的时候，for循环已经完成, i 的值最后是3,
因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]
'''14.列表生成式生成新的列表
'''
该列表只包含满足以下条件的值，元素为原始列表中偶数切片（下标为偶数并且值也为偶数）
'''
alist = [1,2,5,8,10,3,18,6,20]
# num = [0,1,2,3,4,5,6,7,8,9,10]
res = [i for i in alist[::2] if i % 2 == 0]
print(res)
'''
这两道题相同
该函数的输入是一个仅包含数字的list,输出一个新的list，其中每一个元素要满足以下条件：
1、该元素是偶数
2、该元素在原list中是在偶数的位置(index是偶数)
'''15.单例模式的实现方式
'''
单例模式（Singleton Pattern）是一种常用的软件设计模式，
该模式的主要目的是确保某一个类只有一个实例存在。
当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
'''
#python如何实现单例模式?请写出两种实现方式?
#方式一 使用装饰器
def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class foo(object):
pass
foo1 = foo()
foo2 = foo()
print(foo1 is foo2)
#方法二 使用基类 New 是真正创建实例对象的方法，所以重写基类的new 方法，以此保证创建对象的时候只生成一个实例
class Singleton2(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton2, cls).__new__(cls, *args, **kwargs)
return cls._instance
class foo(Singleton2):
pass
foo1 = foo()
foo2 = foo()
print (foo1 is foo2)
#方法三 类
'''
元类，元类是用于创建类对象的类，类对象创建实例对象时一定要调用call方法，
因此在调用call时候保证始终只创建一个实例即可，type是python的元类
'''
class singleton3(type):
def __call__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(singleton3, cls).__call__(*args, **kwargs)
return cls._instance
class foo(object):
__metaclass__ = singleton3
foo1 = foo()
foo2 = foo()
print(foo1 is foo2)16.将一个整数反转
'''
反转一个整数，例如-123 --> -321
'''
class solution(object):
def reverse(self, x):
if -10 < x < 10:
return x
str_x = str(x)
if str_x[0] != "-":
str_x = str_x[::-1]
x = int(str_x)
else:
str_x = str_x[1:][::-1]
x = int(str_x)
x = -x
return x if -2147483648 < x < 2147483648 else 0
if __name__ == '__main__':
s = solution()
reverse_int = s.reverse(-125)
print(reverse_int)17.将一个字符串反转
print('String'[::-1])18.python中的可变类型与不可变类型
'''
1,可变类型有list,dict.不可变类型有string，number,tuple.
2,当进行修改操作时，可变类型传递的是内存中的地址，也就是说，直接修改内存中的值，并没有开辟新的内存。
3,不可变类型被改变时，并没有改变原内存地址中的值，而是开辟一块新的内存，将原地址中的值复制过去，对这块新开辟的内存中的值进行操作。
'''19.字典推导式
d = {'a':24,'g':52,'i':12,'k':33}
dd = {key: value for key, value in d.items()}
print(dd)
'''
快速更换key和value
'''
dv = {v:k for k,v in d.items()}
print(dv)20.统计一段字符串中字符出现的次数
'''
统计一段字符串中字符出现的次数
'''
#方法一
def count_str(str2):
'''
定义一个字符出现次数的函数
:param str2:
:return:
'''
dict_str = {}
for i in str2:
dict_str[i] = dict_str.get(i, 0) + 1
return dict_str
dict_str = count_str("AAABBCCAC")
# print(dict_str)
# {'C': 3, 'B': 2, 'A': 4}
# str_count_data = ''
for k, v in dict_str.items():
# str_count_data += k + str(v)
print('%s出现的次数是%d' %(k,v))21.字符串转化为字典
'''
将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
'''
#方法一 ：函数
str1 = 'k:1|k1:2|k2:3|k3:4'
def str2dict(str1):
dict1 = {}
for i in str1.split('|'):
key,value = i.split(':')
dict1[key] = int(value)
return dict1
d = str2dict(str1)
print(d.items())
#方法二：字典推导式
d = {k:int(v) for t in str1.split('|') for k,v in (t.split(':'), )}
print(d)22.字符串转化为整数
'''
字符串 "123" 转换成 123，不使用内置api，例如 int()
'''
#方法一 利用str函数
def strtoint(s):
num = 0
for i in s:
for j in range(10):
if i == str(j):
num = num*10 + j
return num
# s = "123"
# print(strtoint(s))
#方法二 利用ord函数
'''
它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值
如：
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
ord('2')
50
'''
def strtoint2(s):
num = 0
for i in s:
num = num * 10 + ord(i) - ord('0')
return num
# s = "123"
# print(strtoint2(s))
#方法三 利用eval方法
'''
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
'''
'''
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
'''
def strtoint3(s):
num = 0
for i in s:
t = "%s * 1" % i
n = eval(t)
num = num * 10 + n
return num
# s = "123"
# print(strtoint3(s))
#方法四: 结合方法二，使用 reduce，一行解决
from functools import reduce
def strtoint4(s):
return reduce(lambda num,i:num * 10 + ord(i)-ord('0'), s, 0 )
s = "123"
print(strtoint4(s))23.对字典按value值进行排序
'''
现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
'''
d = {'a':24, 'h':43, 'c':54, 'k':66}
print(d.items()) # items() 函数以列表返回可遍历的(键, 值) 元组数组。
#[('h', 43), ('k', 66), ('a', 24), ('c', 54)]
dd = sorted(d.items(), key=lambda x:x[1])
print(dd)
'''
先将字典转换为list，这里的匿名函数里面的 x 表示一个元组，x[1]表示元组里面的第二个元素，
按照第二个元素排序
'''24.给定一个整数数组和一个目标值，找出数组中和为目标值的两个数
'''
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:给定nums = [2,7,11,15],target=9 因为 nums[0]+nums[1] = 2+7 =9,所以返回[0,1]
'''
#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，一般用在 for 循环当中。
class Solution:
def twoSum(self, list1, target):
'''
:param list: List[int]
:param target: int
:return: List[int]
'''
for i, j in enumerate(list1):#返回元素j及下标i(下标从0开始)
k = i + 1 #i的后一个元素开始计算累计出现的次数
if list1[k:].count(target - j) > 0: #count() 方法用于统计某个元素在列表中出现的次数
for n in range(list1[k:].count(target - j)):
b = list1.index(target - j, k)#k的存在可以去重 每次从k开始
print(i ,b)
k = b + 1
solution = Solution()
# list1 = [2,7,11,15]
list1 = [1, 3, 4, 6, -3, 4, 1, 3, 8, 9, 3, 0, -3, 6, 0, 2, 9]
target = 9
nums = solution.twoSum(list1, target)
# print(nums)
# print(list(enumerate(list1)))
# print(list1[0:])
# print(list1.index(3,1))
'''
List.index(obj[,start=0[,stop=len(L)]])
obj -- 查找的对象。
start -- 可选参数，开始索引，默认为0。（可单独指定）
stop -- 可选参数，结束索引，默认为列表的长度。（不能单独指定）
'''25.给定两个列表，怎么找出他们相同的元素和不同的元素？
'''
给定两个列表，怎么找出他们相同的元素和不同的元素？
'''
list1 = [1,2,3]
list2 = [3,4,5]
set1 = set(list1)
set2 = set(list2)
print(set1 & set2) #相同的
print(set1 ^ set2) #不同的26.求出列表所有奇数并构造新列表
a = [1,2,3,4,5,6,7,8,9,10]
list1 = [i for i in a if i%2 == 1]
print(list1)27.找出整数数组中的第二大
def find_second_large_num(num_list):
'''
找出数组中第二大数字
:param num_list:
:return:
'''
#方法一：直接排序 输出倒数第二个
temp_list = sorted(num_list)
print('方法一\nSecond_large_num is :',temp_list[-2])
#方法二：
#设置两个标志位,一个存储最大数,一个存储次大数
#one 存储最大值，two 存储次大值.遍历一次数组即可
# 先判断是否大于 one，若大于将 one 的值给 two 将 num_list[i] 的值给 one，
# 否则比较是否大于two，若大于直接将 num_list[i] 的值给two，否则pass
one = num_list[0]
two = num_list[0]
for i in range(1, len(num_list)):
if num_list[i] > one:
two = one
one = num_list[i]
elif num_list[i] > two:
two = num_list[i]
print('方法二\nSecond_large_num is :', two)
# 方法三
# 用 reduce 与逻辑符号 (and, or)
# 基本思路与方法二一样，但是不需要用 if 进行判断。
from functools import reduce
num = reduce(lambda ot, x: ot[1] < x and (ot[1], x) or ot[0] < x and (x, ot[1]) or ot, num_list, (0,0))[0]
print("方法三\nSecond_large_num is :", num)
if __name__== '__main__':
num_list = [34, 11, 23, 56, 78, 0, 9, 12, 3, 7, 5]
find_second_large_num(num_list)28.按照list中指定的元素排序
'''
请按alist中元素的age由大到小排序
'''
alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
def sort_by_age(list1):
return sorted(alist, key=lambda x:x['age'], reverse=True)
print(sort_by_age(alist))29.产生一个公差为11的等差数列
'''
写一个列表生成式，产生一个公差为11的等差数列
'''
print([x*11 for x in range(10)])30.输入某年某月某日，判断这一天是这一年的第几天？
'''
输入某年某月某日，判断这一天是这一年的第几天？
'''
import datetime
y = int(input('请输入4位数字的年份：'))
m = int(input('请输入月份：'))
d = int(input('请输入那一天：'))
targetDay = datetime.date(y, m, d)
dayCount = targetDay - datetime.date(targetDay.year - 1,12,31)#减的是上一年最后一天
# print(dayCount) #98 days, 0:00:00
print('%s是%s年的第%s天。'%(targetDay, y, dayCount.days))31.对列表中的字典排序
'''
给列表中的字典排序：假设有如下list对象，alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}],
将alist中的元素按照age从大到小排序
'''
alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}]
alist_sort = sorted(alist, key=lambda x:x.__getitem__('age'),reverse=True)
print(alist_sort)32.统计一个文本中单词频次最高的10个单词
#方法一 正则 + 字典
import re
file = '6_10.txt'
distone = {}#定义存放结果字典
with open(file) as f :
for line in f:
line = re.sub("\W+", " ", line)#正则
lineone = line.split( )#空格分割
for keyone in lineone:
if not distone.get(keyone):
distone[keyone] = 1
else:
distone[keyone] += 1
num_ten = sorted(distone.items(), key = lambda x:x[1], reverse=True)[:10]
num_ten = [x[0] for x in num_ten]
print(num_ten)
#方法二 使用 built-in 的 Counter 里面的 most_common
import re
from collections import Counter
with open(file) as f:
alist = list(map(lambda c:c[0], Counter(re.sub('\W+', ' ', f.read()).split( )).most_common(10)))
print(alist)33.编写函数 实现以下功能：
该函数的输入是一个仅包含数字的list,输出一个新的list，其中每一个元素同时要满足以下条件：
1、该元素是偶数
2、该元素在原list中是在偶数的位置(index是偶数)def num_list(num):
return [i for i in num if i % 2 == 0 and num.index(i) % 2 == 0]
num = [0,1,2,3,4,5,6,7,8,9,10]
result = num_list(num)
print(result)34.自定义函数，让所有奇数都在偶数前面，而且奇数升序排列，偶数降序排序
'''
给定一个任意长度数组，实现一个函数
让所有奇数都在偶数前面，而且奇数升序排列，偶数降序排序，
如字符串'1982376455',变成'1355798642'
'''
'''
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
'''
'''
isinstance(object, classinfo)
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
'''
#方法一
def func1(b):
if isinstance(b, str):
b = [int(i) for i in b]
b.sort(reverse=True)#倒序排列
for i in range(len(b)):
if b[i] % 2 > 0:
b.insert(0, b.pop((i)))#insert() 函数用于将指定对象插入列表的指定位置。
#pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
print(''.join(str(e) for e in b))
'''
将序列中的元素以指定的字符连接生成一个新的字符串。
语法
语法： ‘sep’.join(seq)
参数说明：
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
'''
str2 = '1982376455'
func1(str2)
#方法二
def func2(b):
print(''.join(sorted(b, key=lambda x:int(x) % 2 == 0 and 20 - int(x) or int(x))))
func2(str2)35.遍历列表时删除元素的正确做法
'''
Python-遍历列表时删除元素的正确做法
'''
#方法一：遍历在新在列表操作，删除时在原来的列表操作
a = [1,2,3,4,5,6,7,8]
# b = id(a)
# c = id(a[:])
'''
b=a与b=a[:]的区别
b=a将两者指向同一个对象
而b=a[:]会创建一个新的与a完全相同的对象，但是与a并不指向同一对象。
在计算机中，不同的对象即不同的内存地址。
可理解为：b=a将创建a与b两个快捷方式并指向同一文件；
而b=a[:]先将a指向的文件复制一份作为副本，然后创建一个指向该副本的快捷方式b。
二者不同表现为当两者指向同一对象时，改变其中任意一个，都会改变对象的值，也就是同时改变a，b的值。
'''
print(id(a))
print(id(a[:]))
#两个不同的地址 19126472 19126920
for i in a[:]:
# print(i)#
if i > 5:
pass
else:
a.remove(i)
print(a)
print('------------')
print(id(a))
#方法二 列表推导式
a = [1,2,3,4,5,6,7,8]
b = [i for i in a if i > 5]
print(b)
#方法三 filter
a = [1,2,3,4,5,6,7,8]
b = filter(lambda x: x > 5, a)
print(list(b))
#方法四
'''
倒序删除 因为列表总是‘向前移’，所以可以倒序遍历，即使后面的元素被修改了，还没有被遍历的元素和其坐标还是保持不变的
'''
a = [1,2,3,4,5,6,7,8]
print(id(a))
for i in range(len(a) - 1, -1, -1):
if a[i] > 5:
pass
else:
a.remove(a[i])
print(id(a))
print('-------')
print(a)36.设计实现遍历目录与子目录，抓取.pyc文件
'''
设计实现遍历目录与子目录，抓取.pyc文件
'''
#方法一
import os
def get_files(dir, suffix):
res = []
for root, dirs, files in os.walk(dir): #是一个简单易用的文件、目录遍历器 取得该文件夹下的所有文件
for filename in files:
name, suf = os.path.splitext(filename) #splitext 分离文件名与扩展名
if suf == suffix:
res.append(os.path.join(root, filename))
print(res)
get_files('D:\Software\Anaconda3\envs','.pyc')
#方法二
def pick(obj):
if obj.endswith('.pyc'):
print(obj)
def scan_path(ph):
file_list = os.listdir(ph) #os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
for obj in file_list:
if os.path.isfile(obj):
pick(obj)
elif os.path.isdir(obj):
scan_path(obj)
if __name__ == '__main__':
# path = input('请输入目录')
scan_path("D:\Software\Anaconda3\envs")
#方法三
from glob import iglob
def func(fp, postfix):
for i in iglob("f{fp}/**/*{postfix}", recursive=True):
print(i)
if __name__ == '__main__':
postfix = '.pyc'
func('D:\Software\Anaconda3\envs','.pyc')
来源：oschina
链接：https://my.oschina.net/u/4313186/blog/3533840