1.寫函數，接收兩個數字參數，返回最大值

def res_max(number1,number2):
           l1 = []
           l1.append(number1)
           l1.append(number2)
           return max(l1)

2.寫函數，獲取傳入列表的所有奇數位索引對應的元素，并將其作為新列表返回。

def getnewlist(mylist):
      list1=[];
      for i in range(0,len(mylist)):
              if i%2!=0:
              list1.append(mylist[i])
      return list1

3.寫函數，檢查傳入的字符串是否含有空字符串，返回結果，包含空字符串返回True，不包含返回False

def str_spack(string):
         if string.find(' '):
                 return True
         else:
                 return False

4.定義一個函數,實現兩個數四則運算,要注意有3個參數,分別是運算符和兩個運算的數字.

def arithmetic(number1, number2, symbol):

           if symbol == '+':
           				s = number1 + number2
           elif symbol == '-':
          					 s = number1 - number2
           elif symbol == '*':
           						s = number1 * number2
           elif symbol == '/':
         						  s = number1 / number2
 return s
方法二：
def getresult(num1,fh,num2):
 str1=str(num1)+fh+str(num2)
 return eval(str1)
print(getresult(10,'*',20))

5.filter、map、reduce 的作用?

1. filter—過濾條件用的

2. map–將內容里的元素 逐個處理

3. reduce–用于做累計算的

6.請實現一個裝飾器,通過一次調用使函數重復執行5次。

import time
def wrapper(func):
               def inner(*args,**kwargs):
                         for i in range(5):
                         							time.sleep(0.5)
               												func(*args,**kwargs)
               return inner
@wrapper
def func():
           print('a')
func()

7.如何判斷一個值是函數還是方法?

用type()來判斷，如果是method為方法，如果是function則是函數。括號中寫入變量名,,不要有括號什么別的符號之類的

8.可更改(mutable)與不可更改(immutable)對象

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。

不可變類型：變量賦值 a=5 后再賦值 a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當于新生成了a。

可變類型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。

python 函數的參數傳遞：

不可變類型：類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。

可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會受影響

python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象

9.匿名函數

python 使用 lambda 來創建匿名函數。

lambda只是一個表達式，函數體比def簡單很多。

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。

雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。

10.變量作用域

一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。

變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：

全局變量

局部變量

11.模塊與包

模塊首先是一個含有源代碼的文件在Python里以.py結尾，文件里可以有函數的定義、變量的定義或者對象(類的實例化)的定義等等內容。如果一個項目的代碼量較大，函數較多，最好把一個文件分為多個文件來管理，這樣總程序脈絡清晰易于維護和團隊分工協作，這就是Python里存在模塊的意義所在。模塊名就是文件名(不含.py)，例如假設有一個模塊：

xopowo.py那么模塊名為xopowo。

但當一個項目的模塊文件不斷的增多，為了更好地管理項目，通常將功能相近相關的模塊放在同一個目錄下，這就是包，故包從物理結構上看對應于一個目錄，一個特殊要求，包目錄下必有一個空的init.py文件，這是包區分普通目錄的標簽或者說是標志。包下可以又有包稱為子包，子包也是一個目錄，子包的目錄下也得有一個空的init.py文件。這樣就構成了分級或者說分層的項目管理體系。

12.模塊的使用

模塊，可是Python自帶的、而外安裝的或者開發者自己寫的，在一個文件里使用模塊很簡單用import即可，import有點像C語言的include。

以Python2的內建模塊datetime為例，講解一下模塊的基本使用。

在新程序里使用datetime模塊可以有兩種方式：方式一是把模塊引入，而模塊里的函數的使用需要用點運算的方式來來使用。

import datetime

birthday = datetime.date(2011,7,23)

print birthday

而文件引用模塊里某函數還有另外一種方式就是用from import來直接引入某模塊里的某函數，即方式二。

from datetime import date,time

birthday = date(2011,7,23)

print birthday

使用方式二文件只能用import后列出的函數，而模塊datetime里的其他函數無法在本文件里使用，所以一種特殊的寫法如下：

from datetime import *

也就是說datetime里的所有函數在本程序里均可使用。

13.包的使用

包，實際是更大規模的以目錄形式存在的模塊集合，包可以含子包，包區別于目錄是包的目錄下有一個空的init.py文件。包和模塊一樣有Python自帶的包，也可以通過工具安裝一些包，例如numpy就是數據科學領域比較常用的一個包，需額外安裝，當然也可以自己開發一些包。

以Python2自帶的包multiprocessing為例，其下還有子包dummy。

liao@liao:/usr/lib/python2.7/multiprocessing$ ls
connection.py        forking.py     heap.pyc    managers.py     pool.pyc   queues.py   reduction.pyc   synchronize.py   connection.pyc   forking.pyc    __init__.py     managers.pyc   process.py  queues.pyc   sharedctypes.py    synchronize.pyc 
dummy heap.py    __init__.pyc   pool.py   process.pyc  reduction.py   sharedctypes.pyc    util.py
liao@liao:/usr/lib/python2.7/multiprocessing$ ls dummy/
connection.py connection.pyc __init__.py __init__.pyc
liao@liao:/usr/lib/python2.7/multiprocessing$

multiprocess包下有很多的模塊，例如process模塊，那么可以在一個示例程序里使用包multiprocess里的process模塊

#coding:utf-8
from multiprocessing import Process
import os 
def test(name):
 print "Process ID： %s" % (os.getpid()) 
 print "Parent Process ID： %s" % (os.getppid()) 
if __name__ == "__main__":
 proc = Process(target=test, args=('nmask',)) 
 proc.start() 
 proc.join()

需要解釋的是from multiprocessing import Process是從包multiprocess里引入Process， 但Process類定義在process.py文件里，包含Process類的process.py文件是在multiprocessing目錄下的，故是multiprocessing包里的一個模塊。通過Python交互環境可以查明這一點。

>>> from multiprocessing import Process
>>> help(Process)
Help on class Process in module multiprocessing.process:
class Process(__builtin__.object)

代碼from multiprocessing import Process也可以這樣去寫from multiprocessing.process import Process這樣寫既寫了包名又寫了模塊名即包.模塊，其實在Python里一般還是直接用包名(偷懶)，而少有既寫包又寫模塊的。

14.File（文件)方法 python3

open() 方法

Python open() 方法用于打開一個文件，并返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。

注意：使用 open() 方法一定要保證關閉文件對象，即調用 close() 方法。

open() 函數常用形式是接收兩個參數：文件名(file)和模式(mode)。

open(file, mode=’r’)

完整的語法格式為：open(file, mode=’r’, buffering=-1, encoding=None, errors=None,newline=None, closefd=True, opener=None)

參數說明:

file: 必需，文件路徑（相對或者絕對路徑）。

mode: 可選，文件打開模式

buffering: 設置緩沖

encoding: 一般使用utf8

errors: 報錯級別

newline: 區分換行符

closefd: 傳入的file參數類型

opener: 設置自定義開啟器，開啟器的返回值必須是一個打開的文件描述符。

15.異常處理的定義

python解釋器檢測到錯誤，觸發異常（也允許程序員自己觸發異常）

程序員編寫特定的代碼，專門用來捕捉這個異常（這段代碼與程序邏輯無關，與異常處理有關）

如果捕捉成功則進入另外一個處理分支，執行你為其定制的邏輯，使程序不會崩潰，這就是異常處理

16.異常處理的意義

python解析器去執行程序，檢測到了一個錯誤時，觸發異常，異常觸發后且沒被處理的情況下，程序就在當前異常處終止，后面的代碼不會運行，所以你必須提供一種異常處理機制來增強你程序的健壯性與容錯性

17.常見的異常

AttributeError 試圖訪問一個對象沒有的屬性，比如foo.x，但是foo沒有屬性x

IOError 輸入/輸出異常；基本上是無法打開文件

ImportError 無法引入模塊或包；基本上是路徑問題或名稱錯誤

IndentationError 語法錯誤（的子類） ；代碼沒有正確對齊

IndexError 下標索引超出序列邊界，比如當x只有三個元素，卻試圖訪問x[5]

KeyError 試圖訪問字典里不存在的鍵

KeyboardInterrupt Ctrl+C被按下

NameError 嘗試訪問一個沒有申明的變量

SyntaxError Python代碼非法，代碼不能編譯(個人認為這是語法錯誤，寫錯了）

TypeError 傳入對象類型與要求的不符合

UnboundLocalError 試圖訪問一個還未被設置的局部變量，基本上是由于另有一個同名的全局變量，導致你以為正在訪問它

ValueError 傳入一個調用者不期望的值，即使值的類型是正確的

18.如何進行異常處理

使用if判斷式

num1=input('>>: ') #輸入一個字符串試試
if num1.isdigit():
			 int(num1) #我們的正統程序放到了這里,其余的都屬于異常處理范疇
elif num1.isspace():
 				print('輸入的是空格,就執行我這里的邏輯')
elif len(num1) == 0:
 			print('輸入的是空,就執行我這里的邏輯')
else:
				 print('其他情情況,執行我這里的邏輯')
#第二段代碼
# num2=input('>>: ') #輸入一個字符串試試
# int(num2)
#第三段代碼
# num3=input('>>: ') #輸入一個字符串試試
# int(num3)

問題一：

使用if的方式我們只為第一段代碼加上了異常處理，針對第二段代碼，你得重新寫一堆if，elif等

而這些if，跟你的代碼邏輯并無關系,可讀性差

問題二：

第一段代碼和第二段代碼實際上是同一種異常，都是ValueError,相同的錯誤按理說只處理一次就可以了，而用if，由于這二者if的條件不同，這只能逼著你重新寫一個新的if來處理第二段代碼的異常

第三段也一樣

try…except

語法：

try:
<語句> #運行別的代碼
except <異常類型>： <語句> #如果在try部份引發了'name'異常
except <異常類型> as <數據>:
<語句> #如果引發了'name'異常，獲得附加的數據
else:
<語句> #如果沒有異常發生

注：

python2 和 3 處理 except 子句的語法有點不同，需要注意；

Python2

try:
 print (1/0)
except ZeroDivisionError, err: # , 加原因參數名稱
 print ('Exception: ', err)

Python3

try:
 print (1/0)
except ZeroDivisionError as err: # as 加原因參數名稱
 print ('Exception: ', err)

例

try:
 fh = open("testfile", "w")
 fh.write("這是一個測試文件，用于測試異常!!")
except IOError:
 print("Error: 沒有找到文件或讀取文件失敗")
else:
 print("內容寫入文件成功")
 fh.close()

輸出

內容寫入文件成功

注：

異常類只能用來處理指定的異常情況，如果非指定異常則無法處理。（異常是由程序的錯誤引起的，語法上的錯誤跟異常處理無關，必須在程序運行前就修正）

# 未捕獲到異常，程序直接報錯
s1 = 'hello'
try:
 int(s1)
except IndexError as e:
 print e

輸出
File "/Users/hexin/PycharmProjects/py3/day9/1.py", line 11
 print e
 ^
SyntaxError: Missing parentheses in call to 'print'

多分支

try:
 msg=input('>>:')
 int(msg) #ValueError
 #
 # print(x) #NameError
 # #
 # # l=[1,2]
 # # l[10] #IndexError
 #
 # 1+'asdfsadfasdf' #TypeError
 except ValueError as e:
 print(e)
except NameError:
 print('NameError')
except KeyError as e:
 print(e)
>>:gg
invalid literal for int() with base 10: 'gg'

萬能異常

在python的異常中，有一個萬能異常：Exception，他可以捕獲任意異常

s1 = 'hello'
try:
 int(s1)
except Exception as e:
 '丟棄或者執行其他邏輯'
 print(e)

輸出

invalid literal for int() with base 10: 'hello'

try-finally 語句

try-finally 語句無論是否發生異常都將執行最后的代碼。

s1 = 'hello'
try:
 int(s1)
except IndexError as e:
 print(e)
except KeyError as e:
 print(e)
except ValueError as e:
 print(e)
#except Exception as e:
# print(e)
else:
print('try內代碼塊沒有異常則執行我')
finally:
 print('無論異常與否,都會執行該模塊,通常是進行清理工作')

輸出

invalid literal for int() with base 10: ‘hello’

無論異常與否,都會執行該模塊,通常是進行清理工作

raise主動觸發異常

我們可以使用raise語句自己觸發異常

raise語法格式如下：

raise [Exception [, args [, traceback]]]

語句中Exception是異常的類型（例如，NameError）參數是一個異常參數值。該參數是可選的，如果不提供，異常的參數是”None”。

最后一個參數是可選的（在實踐中很少使用），如果存在，是跟蹤異常對象。

try:
 raise TypeError('類型錯誤')
except Exception as e:
 print(e)

輸出

類型錯誤

自定義異常

class hexinException(BaseException):
 def __init__(self,msg):
 self.msg=msg
 def __str__(self):
 return self.msg
try:
 raise hexinException('類型錯誤')
except hexinException as e:
 print(e)

輸出

類型錯誤