列操作 九九乘法 pytho 重復 默認值 intersect key 需要 顯示

更多案例請關註我的博客：home.cnblogs.com/u/Python1234

歡迎大家加入千人交流資源共享群：125240963

• 表示什麽都沒有

• 如果函數沒有返回值，可以返回 None

• 用來占位

三、內置數據結構

• list

• set

• dict

• tuple

list(列表）

# 1, 創建空列表 l1 =

[]

# 2. 創建帶值的列表 l2 = [ 100

]

# 3. 創建列表，帶多個值 l3 = [ 2 , 3 , 1 , 4 , 6 , 4 , 6

]

# 4. 使用list() l4 = list()

• # 用list a創建一個list b # 下面代碼的含義是，對於所有a中的元素，逐個放入新列表b中 b = [i * 10 for i in

  a]

  # 還可以過濾原來list中的內容病放入新列表 # 比如原有列表a， 需要把所有a中的偶數生成新的列表b a = [x for x in range( 1 , 35 )] # 生成從1到34的一個列表 # 把a中所有偶數生成一個新的列表 b b = [m for m in a if m % 2 ==

  0]

  # 列表生成式可以嵌套 # 由兩個列表a，b a = [i for i in range( 1 , 4 )] # 生成list a b = [i for i in range( 100 , 400 ) if i % 100 ==

  0]

  # 列表生成是可以嵌套,此時等於兩個for循環嵌套 c = [ m + n for m in a for n in

  b]

  # 上面代碼跟下面代碼等價 for m in

  a:

  for n in

  b:

  print (m + n, end = " "

  )

  # 嵌套的列表生城市也可以用條件表達式 c = [ m + n for m in a for n in b if m + n < 250 ]

• 關於列表的常用函數

• copy: 拷貝，此函數是淺拷貝

  b = a.copy()

• count:查找列表中指定值或元素的個數

  a_len = a.count( 8 )

• extend:擴展列表，兩個列表，把一個直接拼接到後一個上

  a = [ 1 , 2 , 3 , 4 , 5

  ]

  b

  = [ 6 , 7 , 8 , 9 , 10

  ]

  a.extend(b)

• remove:在列表中刪除指定的值的元素(如果被刪除的值沒在list中，則報錯)

• clear:清空

• reverse:翻轉列表內容，原地翻轉

  a = [ 1 , 2 , 3 , 4 , 5

  ]

  a.reverse()

• del 刪除

• pop，從對位拿出一個元素，即把最後一個元素取出來

  last_ele = a.pop()

• insert: 制定位置插入

  # insert(index, data), 插入位置是index前面 a.insert( 3 , 666 )

• append 插入一個內容, 在末尾追加

  a = [ i for i in range( 1 , 5

  )]

  a.append(

  100 )

• min

• list：將其他格式的數據轉換成list

  # 把range產生的內容轉換成list print (list(range( 12 , 19 )))

• max:求列表中的最大值

  b = [ ‘ man ‘ , ‘ film ‘ , ‘ python ‘

  ]

  print (max(b))

• len:求列表長度

  a = [x for x in range( 1 , 100

  )]

  print (len(a))

tuple(元組)

# 創建空元組 t =

()

# 創建一個只有一個值的元組 t = ( 1

,)

t

= 1

,

# 創建多個值的元組 t = ( 1 , 2 , 3 , 4 , 5

)

t

= 1 , 2 , 3 , 4 , 5 # 使用其他結構創建 l = [ 1 , 2 , 3 , 4 , 5

]

t

= tuple(l)

元組的特性

• 是序列表，有序

• 元組數據值可以訪問，不能修改

• 元組數據可以是任意類型

• list所有特性，除了可修改外，元組都具有

元組的函數

• len: 獲取元組的長度

• max, min:最大最小值

• count: 計算制定數據出現的次數

• index:求制定元素在元組中的索引位置

set(集合)

# 集合的定義 s =

set()

# 此時，大括號內一定要有值，否則定義出的是一個dict s = { 1 , 2 , 3 , 4 , 5 , 6 , 7

}

# 如果只是用大括號定義，則定義的是一個dict類型 d = {}

集合的特征

• 集合內數據無序，即無法使用索引和分片

• 集合內部數據元素具有唯一性，可以用來排除重復數據

• 集合內的數據，str, int, float, tuple,冰凍集合等，即內部只能放置可哈希數據

集合序列操作

• 成員檢測(in,not in)

• 遍歷

# for 循環 s = { 4 , 5 , " i "

}

for i in

s:

print (i, end = " "

)

# 帶有元組的集合遍歷 s = {( 1 , 2 , 3 ), ( " just " , " for " , " fun " ), ( 4 , 5 , 6

)}

for k,m,n in

s:

print (k, " -- " , m, " -- "

, n)

for k in

s:

print (k)

集合的內涵

# 普通集合內涵 # 以下集合在初始化後自動過濾掉重復元素 s = { 23 , 223 , 545 , 3 , 1 ,2 , 3 , 4 , 3 , 2 , 3 , 1 , 2 , 4 , 3

}

# 普通集合內涵 ss = {i for i in

s}

# 帶條件的集合內涵 sss = {i for i in s if i % 2 ==

0}

# 多循環的集合內涵 s1 = { 1 , 2 , 3 , 4

}

s2

= { " just " , " for " , " fun "

}

s

= {m * n for m in s2 for n in

s1}

s

= {m * n for m in s2 for n in s1 if n == 2 }

集合函數

• len, max, min

• set:生成一個集合

• add：向集合內添加元素

• clear

• copy

• remove:移除制定的值，直接改變原有值，如果要刪除的值不存在，報錯

• discard:移除集合中指定的值，跟 remove 一樣，但是入股要刪除的話，不報錯

• pop 隨機移除一個元素

• 函數

• intersection: 交集

• difference:差集

• union: 並集

• issubset: 檢查一個集合是否為另一個子集

• issuperset: 檢查一個集合是否為另一個超集

• # 創建 s = frozenset()

dict(字典)

• 沒有順序的組合數據，數據以鍵值對形式出現

  # 字典的創建 # 創建空字典1 d =

  {}

  # 創建空字典2 d =

  dict()

  # 創建有值的字典， 每一組數據用冒號隔開， 每一對鍵值對用逗號隔開 d = { " one " : 1 , " two " : 2 , " three " : 3

  }

  # 用dict創建有內容字典1 d = dict({ " one " : 1 , " two " : 2 , " three " : 3

  })

  # 用dict創建有內容字典2 # 利用關鍵字參數 d = dict(one = 1 , two = 2 , three = 3

  )

  # d = dict( [( " one " , 1 ), ( " two " , 2 ), ( " three " , 3 )])

字典的特征

• 字典是序列類型，但是是無序序列，所以沒有分片和索引

• 字典中的數據每個都有鍵值對組成，即kv對

• key: 必須是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行

• value: 任何值

字典常見操作

# 訪問數據 d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 註意訪問格式 # 中括號內是鍵值 print (d[ " one "

])

d[

" one " ] = " eins " # 刪除某個操作 # 使用del操作 del d[ " one "

]

# 成員檢測， in， not in # 成員檢測檢測的是key內容 d = { " one " : 1 , " two " : 2 , " three " : 3

}

if 2 in

d:

print ( " value "

)

if " two " in

d:

print ( " key "

)

if ( " two " , 2 ) in

d:

print ( " kv "

)

# 按key來使用for循環 d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 使用for循環，直接按key值訪問 for k in

d:

print

(k, d[k])

# 上述代碼可以改寫成如下 for k in

d.keys():

print

(k, d[k])

# 只訪問字典的值 for v in

d.values():

print

(v)

# 註意以下特殊用法 for k,v in

d.items():

print (k, ‘ -- ‘ ,v)

字典生成式

d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 常規字典生成式 dd = {k:v for k,v in

d.items()}

# 加限制條件的字典生成式 dd = {k:v for k,v in d.items() if v % 2 == 0}

字典相關函數

• len, max, min, dict

• str(字典): 返回字典的字符串格式

• clear: 清空字典

• items: 返回字典的鍵值對組成的元組格式

• keys:返回字典的鍵組成的一個結構

• values: 同理，一個可叠代的結構

• get: 根據制定鍵返回相應的值

  d = { " one " : 1 , " two " : 2 , " three " : 3

  }

  print (d.get( " on333 "

  ))

  # get默認值是None，可以設置 print (d.get( " one " , 100 ))

• fromkeys: 使用指定的序列作為鍵，使用一個值作為字典的所有的鍵的值

  l = [ " eins " , " zwei " , " drei "

  ]

  # 註意fromkeys兩個參數的類型 # 註意fromkeys的調用主體 d = dict.fromkeys(l, " oops " )

四、表達式

運算符

• 算數運算符

• 比較或者關系運算符

• 賦值運算符

• 邏輯運算符

• 位運算

• 成員運算

• 身份運算符

算數運算符

• 加 +

• 減 -

• 乘 *

• 除 /

• 取余 %

• 取商(地板除) //

• 冪運算 **

• :warning:Python 沒有自增自減運算符

比較運算符

• ==

• !=

• >=

• <=

• 比較的結果是布爾值（True/False）

賦值運算符

• += （-=， ×=， /=, //=, %=, **=）

邏輯運算符

• and 邏輯與

• or 邏輯或

• not 邏輯非

• 結果如果是0則為False， 否則為True

• 短路

• Python 中沒有異或運算

成員運算符號

• 用來檢測某一個變量是否是另一個變量的成員

• in

• not in

身份運算

• is: 用來檢測兩個變量是否是同一個變量

• is not: 兩個變量不是同一個變量

運算符的優先級

• 括號具有最高優先級

  ** 指數 (最高優先級)

  ~ + - 按位翻轉

  ,

  一元加號和減號 (最後兩個的方法名為 +@ 和 -@)

  * / % // 乘，除，取模和取整除

  + - 加法減法

  \>> << 右移，左移運算符

  & 位 ‘AND‘

  ^ | 位運算符

  <

  = < > > =

  比較運算符

  <>

  == ! =

  等於運算符

  = % = / = // = - = + = * = ** =

  賦值運算符

  is is not 身份運算符

  in not in 成員運算符

  not or and 邏輯運算符

五、程序結構

順序

分支

• 基本語法

  # 表達式後面的冒號不能少 # 用縮進來表示同一個代碼塊 if

  條件表達式：

  語句1

  語句2

  語句3

  

  ..

• 雙向分支

  # if 和 else 一個層級，其余語句一個層級 if

  條件表達式:

  語句1

  語句2

  

  else

  :

  語句1

  語句2

  

• 多路分支

  if

  條件表達式：

  語句1

  

  .

  elif

  條件表達式：

  語句1

  

  elif

  條件表達式：

  語句1

  

  

  ..

  else

  :

  語句1

  

  .

• Python 沒有 switch-case 語句

循環

for 循環

for 變量 in

序列：

語句1

語句2

range

• 生成一個數字序列

• 範圍:[m,n)

  # 打印 1～10 for i in range( 1 , 11

  ):

  print (i)

for-else

• 當for循環結束的時候，會執行else語句

• else語句可選

while 循環

while

條件表達式：

語句塊

# 另外一種表達方法 while

條件表達式：

語句塊1

else

：

語句塊2

循環之break,continue,pass

• break： 無條件結束整個循環，簡稱循環猝死

• continue：無條件結束本次循環，從新進入下一輪循環

• pass：表示略過，通常用於站位，沒有跳過功能

六、函數

• def關鍵字

• 代碼縮進

  # 定義 def

  func():

  print ( " 這是一個函數 "

  )

  # 調用 func()

函數的參數和返回值

• 參數： 負責給函數傳遞一些必要的數據或者信息

• 形參（形式參數）： 在函數定義的時候用到的參數沒有具體值，只是一個占位的符號，成為形參

• 實參（實際參數）： 在調用函數的時候輸入的值

• 返回值： 函數的執行結果

• 使用 return 關鍵字

• 如果沒有 return ，默認返回一個 None

• 函數一旦執行 return 語句，則無條件返回，即結束函數的執行

  # return語句的基本使用 # 函數打完招呼後返回一句話 def

  hello(person):

  print ( " {0}, 你腫麽咧 "

  .format(person))

  print ( " Sir, 你不理額額就走咧 "

  )

  return " 我已經跟{0}打招呼了，{1}不理我 "

  .format(person, person)

  p

  = " 明月 " rst =

  hello(p)

  print (rst)

# 定義一個函數，打印一行九九乘法表 def

printLine(row):

for col in range( 1 , row + 1

):

# print函數默認任務打印完畢後換行 print ( row * col, end = " "

)

print ( ""

)

# 九九乘法表 # version 2.0 for row in range( 1 , 10

):

printLine(row)

參數詳解

• 參數分類

• 普通參數

• 默認參數

• 關鍵字參數

• 收集參數

• 普通參數

• 參見上例

• 定義的時候直接定義變量名

• 調用的時候直接把變量或者值放入指定位置

  def 函數名（參數1， 參數2，

  

  .):

  函數體

  # 調用 函數名（value1, value2,

  

  

  .)

• 默認參數

• 形參帶有默認值

• 調用的時候，如果沒有對相應形參賦值，則使用默認值

  def func_name(p1 = v1, p2 = v2

  

  

  

  .):

  func_block

  # 調用1

  func_name()

  # 調用2 value1 = 100 value2 = 200 func_name(value1,value2)

• 關鍵字參數

  def func(p1 = v1, p2 = v2

  

  ..):

  func_body

  # 調用函數： func(p1 = value1, p2 = value2

  

  

  .)

• 收集參數

• 把沒有位置，不能和定義時的參數位置相對應的參數，放入一個特定的數據結構中

  def func( *

  args):

  func_body

  # 按照list使用方式訪問args得到傳入的參數 # 調用： func(p1, p2, p3,

  

  ..)

收集參數混合調用的順序問題

• 收集參數，關鍵字參數，普通參數可以混合使用

• 使用規則就是，普通參數和關鍵字參數優先

• 定義的時候一般找普通參數，關鍵字參數，收集參數 tuple，收集參數 dict

返回值

• 函數和過程的區別

• 有無返回值

• 需要用return顯示返回內容，

• 如果沒有返回，則默認返回None

遞歸函數

• python對遞歸深度有限制，超過限制報錯

  # 斐波那契額數列 # 一列數字，第一個值是1， 第二個也是1， 從第三個開始，每一個數字的值等於前兩個數字出現的值的和 # 數學公式為： f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2) # 例如： 1,1，2，3,5,8,13.。。。。。。。。 # n表示求第n個數子的斐波那契數列的值 def

  fib(n):

  if n == 1

  :

  return 1 if n == 2

  :

  return 1 return fib(n - 1 ) + fib(n - 2

  )

  print (fib( 3

  ))

  print (fib( 10 ))

• 漢諾塔問題

• 規則：

• 方法：

1. n=1： 直接把A上的一個盤子移動到C上， A->C

2. n=2:

3. n=3:

4. n = n：

1. 把小盤子從A放到B上， A->B

2. 把大盤子從A放到C上， A->C

3. 把小盤子從B放到C上， B->C

1. 把A上的兩個盤子，通過C移動到B上去， 調用遞歸實現

2. 把A上剩下的一個最大盤子移動到C上， A->C

3. 把B上兩個盤子，借助於A，挪到C上去， 調用遞歸

1. 把A上的n-1個盤子，借助於C，移動到B上去，調用遞歸

2. 把A上的最大盤子，也是唯一一個，移動到C上，A->C

3. 把B上n-1個盤子，借助於A，移動到C上， 調用遞歸

1. 每次移動一個盤子

2. 任何時候大盤子在下面，小盤子在上面

def

hano(n, a, b, c):

‘‘‘

漢諾塔的遞歸實現

n：代表幾個盤子

a：代表第一個塔，開始的塔

b：代表第二個塔，中間過渡的塔

c：代表第三個塔, 目標塔

‘‘‘ if n == 1

:

print (a, " --> "

, c)

return

None

‘‘‘

if n == 2:

print(a, "-->", b)

print(a, "-->", c)

print(b, "-->", c)

return None

‘‘‘ # 把n-1個盤子，從a塔借助於c塔，挪到b塔上去 hano(n - 1

, a, c, b)

print (a, " --> "

, c)

# 把n-1個盤子，從b塔，借助於a塔，挪到c塔上去 hano(n - 1 ,b, a, c)

a = " A " b = " B " c = " C " n = 1

hano(n, a, b, c)

n

= 2

hano(n, a, b, c)

n

= 3 hano(n, a, b, c)

查找函數幫助文檔

• 用 help 函數

  help( print )

• 使用__doc__

  def

  stu(name, age):

  ‘‘‘

  這是文檔的文字內容

  :param name: 表示學生的姓名

  :param age: 表示學生的年齡

  :return: 此函數沒有返回值

  ‘‘‘ pass print

  (help(stu))

  print ( " * " * 20

  )

  print (stu. __doc__ )

七、變量作用域

• 分類：按照作用域分類

• 全局(global): 在函數外部定義

• 局部（local)：在函數內部定義

• LEGB原則

• L（Local）局部作用域

• E（Enclosing function locale）外部嵌套函數作用域

• G（Global module）函數定義所在模塊作用域

• B（Buildin）： python內置魔抗的作用域

提升局部變量為全局變量(使用global)

def

fun():

global

b1

b1

= 100 print

(b1)

print ( " I am in fun "

)

# b2的作用範圍是fun b2 = 99 print

(b2)

fun()

print (b1)

globals, locals函數

• 可以通過globals和locals顯示出局部變量和全局變量

  # globals 和 locals # globals 和 locals 叫做內建函數 a = 1 b = 2 def

  fun(c,d):

  e

  = 111 print ( " Locals={0} "

  .format(locals()))

  print ( " Globals={0} "

  .format(globals()))

  fun(

  100 , 200 )

eval()函數

• 把一個字符串當成一個表達式來執行， 返回表達式執行後的結果

  eval(string_code, globals = None, locals = None)

exec()函數

跟eval功能類似， 但是，不返回結果

exec (string_code, globals = None, locals = None)

此篇文章獻給還處於Python零基礎的小白們！保證你能入門不是問題