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.html
6.一行代碼實現1-100之和
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）的值。不指定默認值none
13.閱讀一下代碼他們的輸出結果是什么？
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.將一個字符串反轉
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')
