今日面試題:

今日考題:
1.列舉字符串,列表，元組，字典每一個經常使用的五個方法

1.按索引取值（只可取不可改變）

# str索引取值
msg = 'hello nick'
#      0123456789  # 索引序號

print(f'索引爲6: {msg[6]}')
print(f'索引爲-3: {msg[-3]}')
索引爲6: n
索引爲-3: i
2.切片（顧頭不顧尾，步長）

# 索引切片
msg = 'hello nick'
#      0123456789  # 索引序號

print(f'切片3-最後: {msg[3:]}')
print(f'切片3-8: {msg[3:8]}')
print(f'切片3-8，步長爲2: {msg[3:8:2]}')
print(f'切片3-最後，步長爲2: {msg[3::2]}')

# 瞭解，步長爲正從左到右；步長爲負從右到左
print('\n**瞭解知識點**')
print(f'切片全部: {msg[:]}')
print(f'反轉全部: {msg[::-1]}')
print(f'切片-5--2: {msg[-5:-2:1]}')
print(f'切片-2--5: {msg[-2:-5:-1]}')
切片3-最後: lo nick
切片3-8: lo ni
切片3-8，步長爲2: l i
切片3-最後，步長爲2: l ik

**瞭解知識點**
切片全部: hello nick
反轉全部: kcin olleh
切片-5--2:  ni
切片-2--5: cin
3.長度len

# str長度
msg = 'hello nick'

print(len(msg))
10
4.成員運算in和not in

# str成員運算
msg = 'my name is nick, nick handsome'

print(f"'nick' in msg: {'nick' in msg}")
print(f"'jason' not in msg: {'jason' not in msg}")
print(f"not 'jason' in msg: {not 'jason' in msg}")
'nick' in msg: True
'jason' not in msg: True
not 'jason' in msg: True
5.移除空白strip()

# str移除空白strip()
name = '&&&n ick'

print(f"name.strip('&'): {name.strip('&')}")  # strip()默認爲‘ ’，而且不修改原值，新建立空間
print(f"name: {name}")

# strip()應用場景
pwd = input('password: ')  # 用戶可能會手抖輸入空格
if pwd.strip() == '123':
    print('密碼輸入成功')

print(f"'*-& nick+'.strip('*-& +'): {'*-& nick+'.strip('*-& +')}")
name.strip('&'): n ick
name: &&&n ick
password: 123   
密碼輸入成功
'*-& nick+'.strip('*-& +'): nick
6.切分split

# str切分split
info = 'nick:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':', 1)

print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')
info_list1:['nick', 'male', '19']
info_list2:['nick', 'male:19']
7.循環

msg = 'hello nick'

for i in msg:
    print(i)
h
e
l
l
o
 
n
i
c
k

1.按索引取值（正向取值+反向取值），便可存也能夠取

# list之索引取值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list[0] = 'nick handsom'
# name_list[1000] = 'tank sb'  # 報錯

print(f"name_list[0]: {name_list[0]}")
name_list[0]: nick handsom
2.切片

# list之切片
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list[0:3:2]: {name_list[0:3:2]}")
name_list[0:3:2]: ['nick', 'tank']
3.長度

# list之長度
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"len(name_list): {len(name_list)}")
len(name_list): 4
4.成員運算in和not in

# list之成員運算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"'tank sb' in name_list: {'tank sb' in name_list}")
print(f"'nick handsome' not in name_list: {'nick handsome' not in name_list}")
'tank sb' in name_list: False
'nick handsome' not in name_list: True
5.追加值

# list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank sb')

print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'tank', 'sean', 'tank sb']
6.刪除

# list之刪除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]

print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'sean']
7.循環

# list之循環
name_list = ['nick', 'jason', 'tank', 'sean']

for name in name_list:
    print(name)
nick
jason
tank
sean

1.索引取值

# tuple之索引取值
name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom'  # 報錯

print(f"name_tuple[0]: {name_tuple[0]}")
name_tuple[0]: nick
2.切片（顧頭不顧尾，步長）

# tuple之切片
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
name_tuple[1:3:2]: ('jason',)
3.長度

# tuple之長度
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"len(name_tuple): {len(name_tuple)}")
len(name_tuple): 4
4.成員運算

# tuple之成員運算
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"'nick' in name_tuple: {'nick' in name_tuple}")
'nick' in name_tuple: True
5.循環

# tuple之循環
name_tuple = ('nick', 'jason', 'tank', 'sean')

for name in name_tuple:
    print(name)
nick
jason
tank
sean
6.count()

# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
name_tuple.count('nick'): 1
7.index()

# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
name_tuple.index('nick'): 0

1.按key存取值：可存可取

# dic之按key存取值
dic = {'a': 1, 'b': 2}

print(f"first dic['a']: {dic['a']}")

dic['a'] = 3

print(f"second dic['a']: {dic['a']}")
first dic['a']: 1
second dic['a']: 3
2.長度len

# dic之長度len
dic = {'a': 1, 'b': 2}

print(f"len(dic): {len(dic)}")
len(dic): 2
3.成員運算in和not in

# dic之成員運算in和not in
dic = {'a': 1, 'b': 2}

print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")
'a' in dic: True
1 in dic: False
4.刪除

# dic之刪除del
dic = {'a': 1, 'b': 2}
del dic['a']

print(f"dic.get('a'): {dic.get('a')}")
dic.get('a'): None
# dic之刪除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a')  # 指定元素刪除

print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
dic.pop('b'): 2
dic.get('a'): None
# dic之刪除popitem()
dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)。
dic.popitem(): ('b', 2)
5.鍵keys()、值values()、鍵值對items()

# dic之鍵keys()、值values()、鍵值對items()，python2中取出的是列表（雞蛋）；python3中取出的是元組（雞）
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")
dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])
6.循環

# dic之循環
# dic是無序的，可是python3採用了底層優化算法，因此看起來是有序的，可是python2中的字典是無序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items能夠換成keys()、values()
    print(k, v)
a 1
b 2
c 3
d 4

2.描述下列常見內置函數的做用可用代碼說明map,zip,filter,sorted,reduce

# map  --> 映射
def function1(item):
    return item + 2
res = map(function1, [1, 2, 3, ])
print(res)
print(list(res))



#zip --> 將兩個個序列中的元素進行一對一的組合成元組
res = zip(["1", "2", "3"], [5, 6,7, 8])
print(res)
'''
{'1': 5, '2': 6, '3': 7}
多餘的將會被丟棄
'''
#將字典中的kv顛倒
res = zip(dict0.values(), dict0.keys())
dict1 = dict(res)
print(dict1)
 

    
# fileter ---> 篩選
def function(item):  # 1/2/3/4
    if item < 5:
        return True
    else:
        return False
res = filter(lambda item: item > 2, [1, 2, 3, 4])
print(res)  
print(list(res))

# sorted --> 排序
def function2(item):
    return salary_dict[item]
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}
res = sorted(salary_dict, key=function2, reverse=True)
print(list(res))





#reduce --> 把一個函數做用在一個序列[x1, x2, x3, ...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素作累積計算
'''
把序列[5, 4, 3, 2, 1]變成整數54321
'''
import functools
res = functools.reduce(lambda x,y:x * 10 +y,[5, 4, 3, 2, 1])
print(res) #54321

3.列舉你所知道的面相對象中的__開頭__結尾的方法及做用，越多越好

__init__: 在調用類時觸發。
    __str__: 會在打印對象時觸發。
    __del__: 對象被銷燬前執行該方法,該方法會在最後執行。
    __getattr__: 會在對象.屬性時，「屬性沒有」的狀況下才會觸發。
    __setattr__: 會在 「對象.屬性 = 屬性值」 時觸發。
    __call__: 會在對象被調用時觸發。
    __new__: 會在__init__執行前觸發。

4.寫出form表單中全部的知識點

action  控制數據的提交路徑           
method  控住數據提交的方式  默認是get請求         
enctype  控制前端朝後端提交數據的編碼格式       
註冊頁面
下拉框 select標籤
textarea 大段文本

5.列舉你所知道的全部css選擇器

基本選擇器
            
            id選擇器       #id值
            
            類選擇器        .class值
            
            通用選擇器      *
        
後代選擇器
屬性選擇器
僞類選擇器
僞元素選擇器

6.簡述解釋性語言和編譯性的區別

編譯型
優勢（解釋型）：執行效率高
缺點（解釋型）：開發效率低
解釋型
優勢（編譯型）：開發效率高
缺點（編譯型）：執行效率低

7.列舉你所知道的python2與python3之間的區別

print
1/2的結果
編碼
在使用super()的不一樣

8.什麼是匿名函數。匿名函數通常結合什麼一塊兒使用

沒有名字的函數
通常和 max/min/filter/map/sorted聯用

9.三次握手四次揮手

10.什麼是GIL全局解釋器鎖

1.GIL本質上是一個互斥鎖.
2.GIL的爲了阻止同一個進程內多個線程同時執行(並行)
3.這把鎖主要是由於CPython的內存管理不是 "線程安全" 的.
GIL的存在就是爲了保證線程安全的.

11.什麼是python的垃圾回收機制

當一個變量值的引用計數爲0的時候，會觸發垃圾回收機制，改變量值會被回收

12.你所知道的可以實現單例模式的方式有哪些，嘗試着手寫幾個

# 單例模式1
    __instance = None   
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance
# 單例模式2
    __instance = None 
    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance = cls()
        return cls.__instance

13.列舉python中經常使用模塊及主要功能，越多越好！

# time模塊：提供了三種不一樣類型的時間（時間戳）,三種不一樣類型的時間能夠相互轉換
# datetime模塊：時間的加減
# random模塊：隨機數
# hashlib模塊：對字符加密
# hmac模塊：對字符加密，而且加上密鑰
# typing模塊：與函數聯用，控制函數參數的數據類型,提供了基礎數據類型以外的數據類型
# requests模塊：爬蟲--》爬數據，模擬瀏覽器對url發送請求，拿到數據
# re模塊： 去字符串找 符合某種特色的字符串
# numpy模塊：用來作數據分析，對numpy數組（既有行又有列）--矩陣進行科學運算

14.什麼是浮動，浮動的效果是什麼，有沒有壞處，如何解決

在 CSS 中，任何元素均可以浮動。
浮動的元素 是脫離正常文檔流的(原來的位置會讓出來),瀏覽器會優先展現文本內容
浮動帶來的影響,會形成父標籤塌陷(口袋癟了)  
如何解決父標籤塌陷問題？？？
clear  清除浮動帶來的影響,哪一個父標籤塌陷了 就給誰加clearfix這個類屬性值

15.你所知道的定位有哪些，每一個定位各有什麼特色，並列舉哪些是不脫離文檔流的哪些是脫離文檔流的

相對定位   relative
            相對於標籤原來的位置 移動
絕對定位  absolute
            相對於已經定位過(只要不是static均可以 relative)的父標籤 再作定位(******)
固定定位  fixed
            相對於瀏覽器窗口  固定在某個位置不動
1.不脫離文檔流:相對定位;
2.脫離文檔流:浮動的元素,絕對定位,固定定位

16.二進制轉換成十進制：v = 「0b1111011」
十進制轉換成二進制：v = 18
八進制轉換成十進制：v = 「011」
十進制轉換成八進制：v = 30
十六進制轉換成十進制：v = 「0x12」
十進制轉換成十六進制：v = 87

print(int(v,2)
print(bin(v))
print(int(v,8))
print(oct(v))
print(int(v,16))
print(hex(v))

17.簡述可迭代對象，迭代器對象，生成器對象及應用場景

含有.__iter__方法的數據類型就叫作可迭代對象,除了數字類型，全部數據類型都是可迭代對象
含有__iter__和__next__方法的對象就是迭代器對象
含有yield關鍵字的函數叫作生成器
爲何要有迭代器對象：提供了不依賴索引取值的手段
可迭代對象不必定是迭代器對象; 迭代器對象必定是可迭代對象
yield的特性:
1. 暫停函數
2. 經過next取值

18.什麼是元類?元類的應用場景有哪些，能具體說說嗎？

元類就是類的類，類的類是type，type是全部類的類，type就是一個元類。
元類能夠幫咱們控制類的建立。

19.你用的MySQL是哪一個引擎，各個引擎之間有什麼區別

主要MyISAM與InnoDB兩個引擎，其主要區別以下：
1、InnoDB支持事務，MyISAM不支持，這一點是很是之重要。事務是一種高級的處理方式，如在一些列增刪改中只要哪一個出錯還能夠回滾還原，而MyISAM就不能夠了;
2、MyISAM適合查詢以及插入爲主的應用，InnoDB適合頻繁修改以及涉及到安全性較高的應用;
3、InnoDB支持外鍵，MyISAM不支持;
4、MyISAM是默認引擎，InnoDB須要指定;
5、InnoDB不支持FULLTEXT類型的索引;
6、InnoDB中不保存表的行數，如selectcount(*)fromtable時，InnoDB;須要掃描一遍整個表來計算有多少行，可是MyISAM只要簡單的讀出保存好的行數便可。注意的是，當count(*)語句包含where條件時MyISAM也須要掃描整個表;
7、對於自增加的字段，InnoDB中必須包含只有該字段的索引，可是在MyISAM表中能夠和其餘字段一塊兒創建聯合索引;
8、清空整個表時，InnoDB是一行一行的刪除，效率很是慢。MyISAM則會重建表;
9、InnoDB支持行鎖(某些狀況下仍是鎖整表，如updatetableseta=1whereuserlike‘%lee%’

20.什麼是Js，Js的數據類型有哪些,Js序列化反序列化用的是什麼方法

js是前端的一門編程語言
js中的數據類型
數值類型 Number,字符類型 string,對象  object,布爾值  Boolean