格式化輸出
print(f'{d}')
會把d代表的意義轉化掉，和format差不多
%格式化形式
#這里只說明字典使用 dict1 = {"what": "this year", "year": 2016} print("%(what)s is %(year)d" % {"what": "this year", "year": 2016}) # 輸出this year is 2016 print("%(what)s is %(year)d， %d" % (dict1,22) ) # 輸出this year is 2016
format格式化形式
位置映射
#后面的元素可以多 print("{}:{}".format('192.168.0.100', 8888, 222)) #輸出如下192.168.0.100:8888
關鍵字映射
print("{server}{1}:{0}".format(8888,'192.168.1.100',server='Web Server Info :')) #Web Server Info :192.168.1.100:8888
print('{name},{sex},{age}'.format(age=32,sex='male',name='zhangk')) #zhangk,male,32
元素訪問
print("{0[0]}.{0[1]}".format(('baidu','com'))) #baidu.com
填充對齊
- ^、<、>分別是居中、左對齊、右對齊
精度設置
# 填充與對齊 # 填充常跟對齊一起使用 # ^、<、>分別是居中、左對齊、右對齊，后面帶寬度 # :號后面帶填充的字符，只能是一個字符，不指定的話默認是用空格填充 print('{:>8}'.format('zhang')) print('{:0>8}'.format('zhang')) print('{:a<8}'.format('zhang')) print('{:p^10}'.format('zhang')) # 精度與類型f # 精度常跟類型f一起使用 print('{:.2f}'.format(31.31412)) # 其他類型 # 主要就是進制了，b、d、o、x分別是二進制、十進制、八進制、十六進制 print('{:b}'.format(15)) print('{:d}'.format(15)) print('{:o}'.format(15)) print('{:x}'.format(15)) # 用逗號還能用來做金額的千位分隔符 print('{:,}'.format(123456789)) #輸出如下： zhang 000zhang zhangaaa ppzhangppp 31.31 1111 15 17 f 123,456,789
進制及其他顯示
b : 二進制
d ：十進制
o ：八進制
x ：十六進制
!s ：將對象格式化轉換成字符串
!a ：將對象格式化轉換成ASCII
!r ：將對象格式化轉換成repr
其他情況
dict1 = {"one": 1, "two": 2, "three": 3}
list1 = ["one","two", "three"]
print("{}".format(dict1)) # 是字典
print("{0} {1} {2}".format(*dict1)) # 返回的是one two three
print('{one},{two},{three}'.format(**dict1)) # 返回的是元組對，
print('{one},{two},{three}'.format(one=1, two=2, three=3)) # 返回的是元組對，
print("{}".format(list1)) # 是序列
print("{0} {1} {2}".format(*list1)) # 返回的是one two three
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 為: {0.value}'.format(my_value)) # "0" 是可選的,傳入的是對象
#輸出如下：
{'one': 1, 'two': 2, 'three': 3}
one two three
1,2,3
1,2,3
['one', 'two', 'three']
one two three
value 為: 6
函數
函數即變量，如果先使用fun(),然后在定義fun(),就會報錯
函數基本形式
def 函數名（參數列表）: 函數體
#直接調用 def hello(): print("hello,world") return hello() #返回函數 def hello1(x): def hello2(x): print(x, x) return hello2 a = hello1("1") a(1) #輸出如下： hello,world 1 1
關鍵字參數，可變長參數
func1(m,n) #位置參數 func2(m=1) #默認參數，必須在位置參數后面，最好是不可變對象 func3(*args) #可變參數 func4(**kwargs) #關鍵字參數 func5(*args,a=1,b) #命名關鍵字參數
- 調用時候，位置參數一定在默認參數前面，否則報錯function(one = 1,two = 2,3)，也不可以調換順序 錯誤例子
- **接受的是字典，*接受的元組，調用時候如果有元組，列表，字典調用*，則添加*解包，調用**參數，字典用**解包
- 參數定義的順序必須是：必選參數–>默認參數–>可變參數–>命名關鍵字參數–>關鍵字參數
- 命名關鍵字參數必須是a=2,這樣指定
參數后面的冒號和->
def f(ham: str, eggs: str = 'eggs') -> str :
print("Annotations:", f.__annotations__)
print("Arguments:", ham, eggs)
return ham + ' and ' + eggs
f.__annotations__(顯示參數注釋和返回值注釋) {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
其實只是提醒，並沒有指定參數類型
內置函數
abs() #絕對值
all() #如果全是真或者假，返回true，否則返回false 0,"",false 為假，其他為真
any() #一真為真，全假為假
ascii() #返回對應的ascii， 類似於repr() 和chr差不多，和ord相反，\64會變成4
bin() #oct() hex() 接受一個10進制數字，不可以是字符串，轉為相對應的進制
bool #返回相對應的bool值，None，0，“”，{}，【】，（）為false
bytes() #把字符串轉為相對應的字節，第一個是要轉化的字符串，第一個參數是按什么編碼，是不可變序列，
bytearray() #可以如果bytes，但是是可變序列，也可以直接添加參數bytearray(str.encode())
classmethod() staticmethod() #函數修飾符 和普通函數區別詳見 普通函數是實例的， classmethod是對象的 staticmethod是不綁定參數的
callable：函數用於檢查一個對象是否是可調用的。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。
complie() #講.py或者str變成可執行的語句，詳見
float() int() complex() #轉為相對應的類型
getattr() hasattr() setattr() delattr() #詳見 對應獲取屬性， 查詢屬性 設置 刪除
dict() len() list() str() set() max() min() pow() print()#比較簡單不說了
dir() #接收對象作為參數，返回該對象的所有屬性和方法 和__dict__區別，__dict__是字典，dir()是列表，__dict__是dir()的子集 __annotation__是函數注釋
help() #以樹狀形式返回所有的屬性和方法，還有注釋，這個不錯哦
divmod(100,3) #返回一個(33,1)元組，第一個是商，第二個是余數
enumerate() #枚舉可迭代對象，用於獲取他的索引和值，for index,value in enumerate(list1):
eval() 和exec() #變成可執行代碼， eval支持一行，有返回，exec支持多行，無返回
filter,format #參見本文的filter和上一篇的format
frozenset() #轉換為不可變的集合
globals() # 返回一個字典，包括所有的全局變量與它的值所組成的鍵值對
locals() # 返回一個字典，包括所有的局部變量與它的值所組成的鍵值對
vars() #返回當前模塊中的所有變量
hash() # 傳入一個對象，返回相對應的hash值
id() #返回內存地址，可用於查看兩個變量是否指向相同一塊內存地址
input() #提示用戶輸入，接受字符串類型
isinstance() issubclass() #如名字
iter() #轉為迭代器
next() #迭代器的下一個項目，和iter互用
map() #詳見本文的map
memoryview() #查看內存對象,
open： #函數用於打開一個文件，創建一個 file 對象，相關的方法才可以調用它進行讀寫。
propetry() #把某個方法變成屬性，詳見
range() #創建一個range()對象，可以迭代，可以轉為列表
repr() #原形畢露
reversed() #將序列翻轉，返回迭代器
round() #返回數字整數部分
slice(start,stop,stride) #相當於做一個切片模板，別人用就這么切
sorted() #詳見本文
super() #調用父類的方法，順序按照__mro__
type() #返回對象類型
zip() #打包成元組，zip(x1,x2,x3,x4) 把x1，x2,x3,x4中對應的元素打包成元組，哪個沒有就停止
__import__：函數用於動態加載類和函數 。
高級函數
高階函數：就是把函數當成參數傳遞的一種函數；例如
def add(x:int, y, f): return f(x) + f(y) print(add(1.1, 2, abs)) #輸出3.1
包含函數：
name = "1" def outer(func): name="2" func() #這里相當於調用，而不是內部函數 def show(): print(name) outer(show) #輸出如下： 1
map，filter，reduce，sorted
map,filter在python3中返回的是迭代對象，reduce在functools中，sorted沒有了cmp
map()函數
python內置的一個高階函數，它接收一個函數f和一個list,並且把list的元素以此傳遞給函數f，然后返回一個函數f處理完所有list元素的列表，如下：
a = [1,2,3,4,5] def f(x): return abs(x-3) print(map(f, a)) #<map object at 0x00CABDF0> 返回的是迭代對象，所以可以用for循環，循環完就里面就沒有東西了 print(list(map(f,a))) #[2, 1, 0, 1, 2]
reduce()函數
reduce()函數也是python的內置高階函數，reduce()函數接收的的參數和map()類似，一個函數f，一個list，但行為和map()不同，reduce()傳入的參數f必須接受2個參數，
第一次調用是把list的前兩個元素傳遞給f,第二次調用時，就是把前兩個list元素的計算結果當成第一個參數，list的第三個元素當成第二個參數，傳入f進行操作，以此類推，並最終返回結果；
from functools import reduce #在python3里面不是內置，需要導 def f(x,y): return x+y print(reduce(f,[1,2,3,4,5])) #15
注解：
1，計算a=f(1,2)的值為3
2，計算b=f(a,3)的值為6
3，計算c=f(b,4)的值為10
4，計算d=f(c,5)的值為15
filter()函數
filter()函數是python內置的另一個有用的高階函數，filter()函數接收一個函數f和一個list,這個函數f的作用是對每個元素進行判斷，返回true或false,filter()根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件的元素組成的list;例
a = [1,2,3,4,5] def f(x): return x % 2 == 1 print(filter(f, a)) #<filter object at 0x00C6BD70> print(list(filter(f, a))) #[1,3,5]
返回的是迭代對象，需要用list轉換成列表
注解：
1.llist元素以此傳入到函數f
2.f判斷每個元素是否符合條件，把符合條件的留下，不符合條件的舍棄
3.把最終符合條件的元素組成一個新的列表
sorted（）函數
sorted() 函數對所有可迭代的對象進行排序操作。
sort 與 sorted 區別：
sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。
list 的 sort 方法返回的是對已經存在的列表進行操作，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。
sorted 語法：
sorted(iterable, key=None, reverse=False)
參數說明：
- iterable -- 可迭代對象。
- key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。 可以是變量，可以是函數或者lambda
- reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。
- 多級排序，使用operator.itemgetter例如：sorted(list1, key=itemgetter(0,1)) 先用第0個，再用第一個排序
返回重新排序的列表。
以下實例展示了 sorted 的使用方法：
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a) # 保留原列表
>>> a [5, 7, 6, 3, 4, 1, 2]
>>> b [1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函數
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
匿名函數
忘了哪里說的盡量少用
ython 使用 lambda 來創建匿名函數。
- lambda只是一個表達式，函數體比def簡單很多。
- lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
- lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。
- 雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。
語法
lambda函數的語法只包含一個語句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下實例：
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可寫函數說明 sum = lambda arg1, arg2: arg1 + arg2; # 調用sum函數 print "相加后的值為 : ", sum( 10, 20 ) print "相加后的值為 : ", sum( 20, 20 )
以上實例輸出結果：
相加后的值為 : 30 相加后的值為 : 40
lambda多重調用：和偏函數對比
x = lambda x:(lambda y : x/y) print(x(1)(1)) #1.0 print(x(2)(1)) #2.0
函數面試題
1、默認參數
默認參數在程序開始時候，裝載完畢，如果是可變參數，內部引用的時候會不再開辟新的空間，用的是func.__deflaut__的值，，但如果不是可變參數，每次變化都是新的空間，如None
def f(arg, li =[]): li.append(arg) return li v1 = f(1) #用的是默認參數【】的空間 print(v1) v2 = f(2,[]) #這是【】是新的空間 print(v2) v3= f(3) print(v3) #用的是默認參數【】的空間，盡量默認參數不要用可變列表 print(v1) #參數變化 [1] [2] [1, 3] [1, 3]