三元運算：

三元運算（三目運算），是對簡單的條件語句的縮寫。

# 書寫格式

result = 值1 if 條件 else 值2

# 如果條件成立，那麼將 “值1” 賦值給result變數，否則，將“值2”賦值給result變數

if a == 1:
    name = "walker"
else:
    name="wang"

name = "walker" if a == 1 else "wang"   #一句話相當於上面的if else的意思

lambda表示式：

def f1(a1)
    return a1 +100

f1 = lambda a1:a1+100   #相當於上面的個函式,也可以加兩個函式,但需要用逗號隔開
 

函式：

1 def關鍵字,建立函式
2 函式名
3 ()
4 函式體
5 返回值

需要注意的是：
函式體是不被執行的,但會把函式體放入記憶體.只有在呼叫的時候才執行
寫函式要先定義再呼叫
在函式中,一但執行了return,函式執行過程立即終止

函式傳遞引數的5種方式：
1 普通引數 (嚴格豔照順序,將實際引數賦值給形式引數) 需要11對應

def func(a)
    print(a)

#在呼叫的時候就要必須傳引數進入函式，否則會報錯
func("walker")
#或者
func（a="walker"）

2 預設引數 (預設引數必須放置在引數列表的最後) 設定預設值

def func(a="walker",b="wang")
    print(a,b)
#如果不傳入引數到函式的話，函式將會採用預設引數賦值給a，也可以傳入引數
func("wang","walker")
#或者
func（a="wang",b="walker"）

3 指定引數 (將實際引數副職給指定的形式引數)

4 *變數 (可以傳遞無數個引數,傳遞完的引數被存為元組的形式)

def f1 (*args):                 #args是變數
    print (args,type(args))     #args的型別是元組

如果將列表傳入的話,*列表的話,就將列表的每一個元素轉換成元組在函式裡.如果不加*就是將整個列表轉換成元組的一個元素.
帶*相當於一個for
 
迴圈,將str或者元素裡的每一個值都傳至函式裡.

5**變數 (可以傳遞無數個引數,傳遞完的引數被存為字典的形式)

傳指定引數的時候(變數=vaule),在函式接收後,會將傳入的引數轉換成dict的格式.key=變數名,vaule=vaule
a=f1(n=1,m=2)
如果加2*傳入函式(a=f1(**dic1))就會把字典的每一個元素都付給函式,函式接收引數後,會按照原字典的形式拼裝

6 萬能引數 可以自動轉換成,元組和字典.注意:在前面,*在後面

def f1=(*args,**kwargs) #一般都寫成args,kargs 規範!
    print (args)
    print (kwargs)

f1(11,22,33,44,k1="v1,k2="v2")  可以自動識別元組型別或者是key,value型別

7 補充

a. def f1
   def f1 會用後面的引數
b.傳遞引數的時候是一個引用
c.全域性變數和區域性變數

內建函式：

abs() #取絕對值

bool() #取布林值 False的有(除了False))0,None,”“,[],{},()

all() #給all傳引數,如果所有元素都為真就是真,有一個假久為假

n=all([1,2,3,4])    #print(n)的時候為Ture
    n=all([1,2,3,0])    #print(n)的時候為False

any() #給any傳引數,任意一個為真就為真(具體參考all函式)

ascii() #自動執行物件的repr方法

bin() #接收10進位制,轉換成2進位制 (0b表示2進位制的意思)

oct() #接收10進位制,轉換層8進位制 (0o表示8進位制的意思)

hex() #接收10進位制,轉換層16進位制 (0x表示16進位制的意思)

int() #將字串數字，轉換成10進位制

bytes() #把字串可以轉換成位元組型別,想把一個字串轉換成一個位元組。

bytes(s,encoding="utf-8")

bytearray() #把btye的那種位元組轉換成列表

str() #把位元組轉換成字串

str(字串,encoding="utf-8")

callable() #檢測是否可以被執行 用處不大

chr() #ascii碼對應關係

print(chr(65))

ord() #跟chr相反,將字元轉換成ascii碼

print(chr(“A”))

compile() #把字串編譯成程式碼

s="print(123)"
    r=compile(s,"<string>","exec")      #"<string>"可以被"檔名"替換

exec() #執行compile()編譯完的程式碼 比eval更牛逼，但是exec沒有返回值

exec(r)

eval() #eval函式可以計算Python表示式，並返回結果（exec不返回結果，

print(eval("…"))#列印None
#正確如下：
ret=eval("7+8+9")
print(ret)

dir() #快速獲取模組、類獲取哪些功能

print(dir(dict))

help() #相當於man文件,相當於按住ctrl滑鼠左鍵顯示的原始碼

help(dict)

divmod() #取餘數

r=divmod(97,10)
print r #r[0]是商 r[1]是餘數
n1,n2=divmod(97,10)     #可以將商和餘數分別賦值給n1，n2

enumerate() #用於遍歷序列中的元素以及它們的下標 字典、列表、元組都可以

for i,j in enumerate(('a','b','c')):
    print i,j
#以下為顯示：
    0 a
    1 b
    2 c

isinstance() #判斷物件是誰的例項

s="alex"
isinstance(s,str)

filter() #(函式,可迭代的物件)

li=[11,22,33,44,55]
def f2(a):          #f2=lambda a:a>22
    if a>22:
    return True
ret=filter(f2,li)   

#ret=filter(lambda a:a>22,li)   用lamba表示式       
#filter內部會迴圈第二個引數,在每一次迴圈的內部再執行第一個引數(把第二個引數傳入第一個函式變數中)

print(list(li))

map()#(函式,可迭代的物件），將第二個引數傳入第一個函式，函式進行計算

result=map(lambda a:a+100,li)
print (list(result))

frozenset() #不可變集合

globals() #可以打印出所有的全域性變數

locals() #可以打印出所有的區域性變數

hash() #生成雜湊值

iter() #建立迭代器

len() #檢視長度 python3裡按照字元，python2按照位元組

#如果要看位元組長度   需要用bytes()

max() #列出最大

min() #列出最小

sum() #列出求和

memoryview() #檢視記憶體地址的

object() #所有類的父類

pow() #pow(2,10) 相當於2**10

range() #範圍

reverse() #反轉 reverse(li) == li.reverse()

round() #四捨五入

set() #集合

slice() #切片

sorted() #排序 sorted(li) == li.sorted()

vars() #當前模組都有哪些變數

zip() #負責將多個元素的相同角標內的內容，整理到一個元祖中。

join() #負責將同元組或者列表內的元素拼接起來 (“”.join(元祖或列表))

#注意，join拼接的只能是字串，如果是int會報錯
a=["walker","wang"]
print （"".join(a)）

更詳細的官方資料：猛戳這裡

open函式：open()

開啟檔案：

f=open("db","a")    #如果open開啟檔案亂碼了就增加encoding引數傳入到open函式
    r:只讀
    w:只寫,每次都會把檔案清空
    x:如果當這個檔案存在的時候就報錯,不存在的話就建立並寫內容
    a:追加
    rb:開啟方式如果加了b(rb,wb,xb,ab) python不處理轉換，讀取的時候是位元組型別,寫入也是以位元組型別寫入 （常用於誇平臺操作）
    r+:+號可以即可讀又可寫(日後推薦使用) (可以+b) 如果開啟模式無b 則read是按照字元讀取。受影響的read(1)

操作檔案：
f.seek() #調整指標的位置 按照位元組
f.tell() #獲取當前指標的位置 按照位元組 推薦使用時：f.seek(f.tell())
f.read() #預設無引數讀全部,如果有引數按照開啟方式(有b按照位元組，無b按照字元)
f.write() #寫入檔案
f.close() #關閉檔案
f.fileno() #檔案描述符，檔案的數字形式
f.flush() #將f.write()後但沒有close()的緩衝區內容寫入到檔案
f.deadable()#檢視檔案是否可讀 返回True 和 False
f.readline()#只讀取一行
f.truncate()#截斷檔案,根據指標位置

for line in f:  #迴圈每一行
    print line

關閉檔案：
f.close()

replace函式()
user.replace(“old”,”new”,[max])
old – 將被替換的子字串。
new – 新字串，用於替換old子字串。
max – 可選字串, 替換不超過 max 次

#舉例：
str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);

字串格式化：
字串格式化分為：百分號方式、format方式

百分號方式：%[(name)][flags][width].[precision]typecode
(name) 可選，用於選擇指定的key

flags 可選，可供選擇的值有:
+ 右對齊；正數前加正好，負數前加負號；
- 左對齊；正數前無符號，負數前加負號；
空格 右對齊；正數前加空格，負數前加負號；
0 右對齊；正數前無符號，負數前加負號；用0填充空白處

width 可選，佔有寬度

.precision 可選，小數點後保留的位數

typecode 型別模式，此項為必選 例如（%s %d）

%s， 獲取傳入物件的__str__方法的返回值，並將其格式化到指定位置
%r， 獲取傳入物件的__repr__方法的返回值，並將其格式化到指定位置
%c， 整數：將數字轉換成其unicode對應的值，10進位制範圍為 0 <= i <= 1114111（py27則只支援0-255）；字元：將字元新增到指定位置
%o， 將整數轉換成 八  進製表示，並將其格式化到指定位置
%x， 將整數轉換成十六進位制表示，並將其格式化到指定位置
%d， 將整數、浮點數轉換成 十 進製表示，並將其格式化到指定位置
%e， 將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（小寫e）
%E， 將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（大寫E）
%f， 將整數、浮點數轉換成浮點數表示，並將其格式化到指定位置（預設保留小數點後6位）
%F， 同上
%g， 自動調整將整數、浮點數轉換成 浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是e；）
%G， 自動調整將整數、浮點數轉換成 浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是E；）
%%， 當字串中存在格式化標誌時，需要用 %%表示一個百分號

注：Python中百分號格式化是不存在自動將整數轉換成二進位制表示的方式

常用格式化(%s)：

tpl = "i am %s" % "walker"
tpl = "i am %s age %d" % ("walker", 18)
tpl = "i am %(name)s age %(age)d" % {"name": "walker", "age": 18}
tpl = "percent %.2f" % 99.97623
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
tpl = "i am %.2f %%" % {"pp": 123.425556, }

format方式: [[fill]align][sign][#][0][width][,][.precision][type]

:               【可選】格式化選項   

fill            【可選】空白處填充的字元

align           【可選】對齊方式（需配合width使用）
        <，      內容左對齊
        >，      內容右對齊(預設)
        ＝，  內容右對齊，將符號放置在填充字元的左側，且只對數字型別有效。 即使：符號+填充物+數字
        ^，      內容居中

sign            【可選】有無符號數字
#               【可選】對於二進位制、八進位制、十六進位制，如果加上#，會顯示 0b/0o/0x，否則不顯示

，               【可選】為數字新增分隔符，如：1,000,000

width            【可選】格式化位所佔寬度

.precision       【可選】小數位保留精度

type             【可選】格式化型別  (用冒號)
    傳入” 字串型別 “的引數
        s，格式化字串型別資料
        空白，未指定型別，則預設是None，同s
    傳入“ 整數型別 ”的引數
        b，將10進位制整數自動轉換成2進製表示然後格式化
        c，將10進位制整數自動轉換為其對應的unicode字元
        d，十進位制整數
        o，將10進位制整數自動轉換成8進製表示然後格式化；
        x，將10進位制整數自動轉換成16進製表示然後格式化（小寫x）
        X，將10進位制整數自動轉換成16進製表示然後格式化（大寫X）
    傳入“ 浮點型或小數型別 ”的引數
        e， 轉換為科學計數法（小寫e）表示，然後格式化；
        E， 轉換為科學計數法（大寫E）表示，然後格式化;
        f ， 轉換為浮點型（預設小數點後保留6位）表示，然後格式化；
        F， 轉換為浮點型（預設小數點後保留6位）表示，然後格式化；
        g， 自動在e和f中切換
        G， 自動在E和F中切換
        %，顯示百分比（預設顯示小數點後6位）

常用格式化(format)：

#最基本的
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex') 

#用*將列表傳進來，如果傳字典用**      
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])  

tpl = "i am {0}, age {1}, really {0}".format("seven", 18)       
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

生成6位隨機碼：(驗證碼)：

import random
li=[]
for i in range(6):
    r=random.random.randrange(0,5)  # 取0到4隨機數
    if r==2 or r==4:
        tmp= random.randrange(0,9)
        li.append(chr(tmp))
    else:
        tmp= random.randrange(65,91)
        c=chr(tmp)
        li.append(c)
result="".join(li)
print(result)

裝飾器：

裝飾器: @ + 函式名 例如(@outer)
1.會自動執行outer函式,並且將其下面的函式名f1當作引數傳遞

2.將outer函式的返回值,重新賦值給函式(原有的函式的記憶體地址會被覆蓋)
下面的例子說明 f1 函式被inder取代

def outer(func)
    def inter(*args,**kwargs):  #先輸出新函式,再輸出原函式,在原函式不變的基礎上再執行新函式
    pass    
        r=func(*args,**kwargs)          #func() 其實是執行老的f1函式
        return r            #可以將原函式的返回值返回
    return inder    #不能加括號,加括號相當於返回 inder函式的返回值也就是None

@outer
def f1()
    pass

雙層裝飾器

    @xx2
    @xx1
    def xx0 #編譯是從下到上，但執行是從上到下。! 其實記住從上到下執行就行了。

生成器：
函式裡面有yield 呼叫時候通過for迴圈取

def func()
    print(111)  #第一次執行的時候會print 111 然後yield 1
    yield 1
    print(222)  #第二次執行的時候會print 111 然後yield 1
    yield 2
    print(333)  #第三次執行的時候會print 111 然後yield 1
    yiele 3
ret = func()
r=ret._next_() #進入函式找到yield 獲取yield後面的資料 , 每一個yield相當於一個停頓
print(r)

迭代器：
相當於for迴圈在python中. for迴圈封裝了迭代器. 迭代器相當於用next功能去取,用for迴圈取到最後一個不會報錯.

遞迴:
一個函式呼叫另外一個函式

def func(n)
    n+=1
    if n >=4:
        return "end"
    return func(n)

遞迴階乘

def func(num)
    if num == 1:
        return 1
    return num * func(num)
x=fun(7)    #實際上就是1*2*3*4*5*6*7的值

補充上一篇文章忘了提的–集合：
集合 set 無序、不重複的序列
建立集合:
s=set()

s1={123,456}
s2=set() 建立一個空集合
s3=set([11,22,33,4])

s.add 增加元素

s.clear 清除所有內容

s3=s1.difference(s2) #s1的差集 並賦值給s3
s1.symmetric_update(s2) #S1的差集並覆蓋掉s1
s3=s1.symmetric_difference(s2)      #s1和s2對稱差集,並賦值給s3
s1.symmetric_difference_update(s2)  #s1和s2對稱差集,並覆蓋掉s1

s1.discard 移除集合中的元素,不存在不報錯

s1.remove 移除集合中的元素,不存在會報錯

s1.pop() 隨機移除集合中的某個元素 不推薦.(pop裡無引數)

ret = s1.pop()  #ret接收pop移除的元素

s3=s1.intersection(s2) s1和s2的交集 並賦值給s3
    s1.intersection_update(s2)  s1和s2的交集 並覆蓋掉s1

s3=s1.union(s2) s1和s2的並集 並賦值給s3

s1.update(列表\元組\字串) 可以被迭代的物件,可以被FOR迴圈的物件
    可以將列表內新增的值迴圈加入set內
        但如果是字串將會被拆分

issubset    子序列
issuperset  父序列
    例如: s1={11,22,33}
            s2={22,33}
    那麼s2的{22,33}就是s1的子序列,同理反之父序列

補充一下集合的概念：

集合:A{1234} B{2345}
交集:A和B共有的部分     {2345}
並集:屬於A或者屬於B的    {12345}
差集:只屬於A但不屬於B,叫做A的差集{5}
全集:AB的所有元素集合    {12342345}
對稱差集:只屬於A但不屬於B,只屬於B但不屬於A {15}
補集:術語全集AB但不屬於A的叫做A的補集{5}

雙下劃線的預設方法(python自動呼叫)

li=[11,22,33]   #list_init_
li()            #list_call_
li[0]           #list_getitem_
li[0]=123       #list_setitem_
def li [1]      #list_delitem_

try/finally
舉例：

try:
    <語句>
finally:
    <語句> #退出try時總會執行

try語句子句形式表

except: 捕獲所有異常
except name: 只捕獲特定的異常
except name,value: 捕獲異常和它的附加資料（將異常的資訊儲存到value，）
except (name1,name2): 捕獲任何列出的異常
else: 如果沒有異常
finally: 總是執行

在shell中給print語句加顏色 31是紅色字型,32是綠色字型 41是背景紅色
\033[31;1m”文字”]\033[0m
1表示加深，
3開頭表示字型顏色，
4開頭表示背景顏色。兩種顏色都設定，用分號隔開

print (\033[1;32;41m"文字"\033[0m)
1  加深
5  閃爍
31 紅色
32 綠色
33 黃色
34 深藍色
35 紫色
36 藍色
37 灰色