*arg和**kwarg作用

比如現在我有一個最簡單的加法（Jiafa）函式：

def Jiafa(x, y):
    z = x + y
    return z
print(Jiafa(1,2))
這個很簡單，一看就知道輸出等於3。

那下一個問題是，如果我要算不固定個數的數字相加，那怎麼來計算呢？

這時，就使用args和*kwarg，就可以幫助我們解決這種問題。

*args：可以理解為只有一列的表格，長度不固定。

**kwargs：可以理解為字典，長度也不固定。

首先，args和kwarg不是必須成對出現，也不是必須叫這個名字，也可以叫x和**y。寫成這樣，只是一種約定俗成，比如給別人講故事：從前有個張三和李四……大家一聽就知道你要說什麼了，而不能說從前有個馬七狗八，大家雖然也能聽懂，但總是不太好理解。

先說args的作用，還是開篇的案例，我們要算不定長的加法，就可以用args來定義了，當然也可以叫x，y。

def Jiafa(*args):
    sum = 0
    for i in args:
        sum = sum + i
        print(sum)

Jiafa(1, 3, 5)
Jiafa(2, 4, 6, 8, )
輸出結果，9和20。這個案例很簡單，用*args定義就可以引入，相當於定義了不定長度的函式，然後在程式中就可以多次使用。

**kwargs的字典呢？先看一下普通的字典，用一對大括號{}就可以建立字典，比如下面3行程式，就可以編一個字典的程式：

dict = {"system": "系統", "China": "中國", "link": "聯接"}

x = input("請輸入一個英文單詞：")
print(dict.get(x, "本字典裡沒找到!"))
如果輸入正確，會得到答案，否則會顯示沒找到。

在這個程式裡，dict = {"system": "系統", "China": "中國", "link": "聯接"}建立了三對“鍵和值”（key和value），比如“system”是key，“系統”是key對應的值，也叫鍵值。

還可以寫一個測試單詞的小軟體。

dict = {"system": "系統", "China": "中國", "link": "聯接"}

通過Key找value的語句：
y = input("請輸入China的中文意思：")
if dict['China'] == y:
    print("恭喜你，答對了！")

通過value找Key的語句：
z = input("請輸入“系統”的英文單詞：")
if list(dict.keys())[list(dict.values()).index("系統")] == z:
    print("恭喜你，答對了！")
現在問題來了，如果開始不知道字典裡都有哪些內容，需要在程式運程中才知道怎麼辦？這個時候就可以用kwargs來定義了。我們先用kwargs來定義一個函式，函式內容先都不用寫，再看看下面的小程式：

def dict(**kwargs):
    return kwargs

mydict = dict(system="系統", China="中國", link="聯接")
x = input("請輸入單詞：")
if x in mydict.keys():
    print("中文意思：", mydict[x])
else:
    print("抱歉，沒找到。")
用字典也可以達成這樣的功能，使用in……keys(),就是判斷這個key是不是存在，如果存在就返回它的值。 同樣，用**kwargs傳遞資料的功能，還可以設計一個使用者登入的程式：

def dict(**kwargs):
    return kwargs

userdict = dict(user1="1234", user2="5678")

x = input("請輸入使用者名稱：")
if x in userdict.keys():
    y = input("請輸入密碼：")
if userdict[x] == y:
    print("完全正確")
else:
    print("密碼錯誤！")
else:
    print("使用者不存在！")
以上的功能，都是能表達出args和*kwarg的功能的最精減程式碼，大家運動一下會更有助於理解。希望大家學會初步的功能，共同進步，加油！
 

is和==的區別

>>> a = 'cheesezh'
>>> b = 'cheesezh'
>>> a == b
True


>>> x = y = [4,5,6]
>>> z = [4,5,6]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False
>>>
>>> print id(x)
3075326572
>>> print id(y)
3075326572
>>> print id(z)
3075328140

看例子就能看懂
 

簡述Python的深淺拷貝以及應用場景

匯入模組：import copy

淺拷貝：copy.copy

深拷貝：copy.deepcopy

字面理解：淺拷貝指僅僅拷貝資料集合的第一層資料，深拷貝指拷貝資料集合的所有層。所以對於只有一層的資料集合來說深淺拷貝的意義是一樣的，比如字串，數字，還有僅僅一層的字典、列表、元祖等.


對於數字和字串的深淺拷貝都只是將變數的索引指向了原來的記憶體地址，無論修改任意其中一個變數，只是將其指向了另一個記憶體地址，其他兩個變數不會變，字元串同理。因此，對於 數字 和 字串 而言，賦值、淺拷貝和深拷貝無意義，因為其永遠指向同一個記憶體地址。

 深拷貝的時候python將字典的所有資料在記憶體中新建了一份，所以如果你修改新的模版的時候老模版不會變。相反，在淺copy 的時候，python僅僅將最外層的內容在記憶體中新建了一份出來，字典第二層的列表並沒有在記憶體中新建，所以你修改了新模版，預設模版也被修改了。
 

列舉常見的內建函式

一、數學相關

1、絕對值：abs(-1)
2、最大最小值：max([1,2,3])、min([1,2,3])
3、序列長度：len('abc')、len([1,2,3])、len((1,2,3))
4、取模：divmod(5,2)//(2,1)
5、乘方：pow(2,3,4)//2**3/4
6、浮點數：round(1)//1.0

二、功能相關

1、函式是否可呼叫：callable(funcname)，注意，funcname變數要定義過
2、型別判斷：isinstance(x,list/int)
3、比較：cmp('hello','hello')
4、快速生成序列：(x)range([start,] stop[, step])

三、型別轉換

1、int(x)
2、long(x)
3、float(x)
4、complex(x) //複數
5、str(x)
6、list(x)
7、tuple(x) //元組
8、hex(x)
9、oct(x)
10、chr(x)//返回x對應的字元，如chr(65)返回‘A'
11、ord(x)//返回字元對應的ASC碼數字編號，如ord('A')返回65

四、字串處理

1、首字母大寫：str.capitalize
複製程式碼 程式碼如下:

>>> 'hello'.capitalize()

'Hello'
2、字串替換：str.replace
複製程式碼 程式碼如下:

>>> 'hello'.replace('l','2')
'he22o'

可以傳三個引數，第三個引數為替換次數
3、字串切割：str.split
複製程式碼 程式碼如下:

>>> 'hello'.split('l')
['he', '', 'o']

可以傳二個引數，第二個引數為切割次數
以上三個方法都可以引入String模組，然後用string.xxx的方式進行呼叫。

五、序列處理函式

1、len：序列長度
2、max：序列中最大值
3、min：最小值
4、filter：過濾序列
複製程式碼 程式碼如下:

>>> filter(lambda x:x%2==0, [1,2,3,4,5,6])
[2, 4, 6]
5、zip：並行遍歷
複製程式碼 程式碼如下:

>>> name=['jim','tom','lili']
>>> age=[20,30,40]
>>> tel=['133','156','189']
>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '156'), ('lili', 40, '189')]

注意，如果序列長度不同時，會是下面這樣的結果：
複製程式碼 程式碼如下:

>>> name=['jim','tom','lili']
>>> age=[20,30,40]
>>> tel=['133','170']
>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '170')]

6、map：並行遍歷，可接受一個function型別的引數
複製程式碼 程式碼如下:

>>> a=[1,3,5]
>>> b=[2,4,6]
>>> map(None,a,b)
[(1, 2), (3, 4), (5, 6)]
>>> map(lambda x,y:x*y,a,b)
[2, 12, 30]

7、reduce：歸併
複製程式碼 程式碼如下:

>>> l=range(1,101)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> reduce(lambda x,y:x+y,l)
5050

至少列舉8個常用模組都有那些

     pip、pygame、pyMysql、sys、math、time、os

re的match和search區別？

match（）函式只檢測RE是不是在string的開始位置匹配，

 search()會掃描整個string查詢匹配；

也就是說match（）只有在0位置匹配成功的話才有返回，

如果不是開始位置匹配成功的話，match()就返回none。


例如：
print(re.match(‘super’, ‘superstition’).span())   會返回(0, 5)

而print(re.match(‘super’, ‘insuperable’))   則返回None

search()會掃描整個字串並返回第一個成功的匹配
例如：print(re.search(‘super’, ‘superstition’).span())返回(0, 5)

print(re.search(‘super’, ‘insuperable’).span())返回(2, 7)

什麼是正則的貪婪匹配

1.什麼是正則表示式的貪婪與非貪婪匹配

　　如：String str="abcaxc";

　　　　Patter p="ab.*c";

　　貪婪匹配:正則表示式一般趨向於最大長度匹配，也就是所謂的貪婪匹配。如上面使用模式p匹配字串str，結果就是匹配到：abcaxc(ab.*c)。

　　非貪婪匹配：就是匹配到結果就好，就少的匹配字元。如上面使用模式p匹配字串str，結果就是匹配到：abc(ab.*c)。