python函數 | 內置函數大全

• 數學運算（7）
• 類型轉換（21）
• 序列操作（8）
• 對象操作（6）
• 反射操作（7）
• 裝飾器（3）
• 變量作用域（3）
• 字符串類型代碼（4）
• 輸入輸出（2）
• 迭代器、生成器相關（2）
• 其他（4）

 

一、數學運算

abs：返回數字的絕對值

abs(-1)   　　　　　　　　　　　　　　　　　　# 1

round：保留浮點數的小數位數，默認保留整數。四舍五入。

round(1.553,1)   　　　　　　　　　　　　　　#1.6

divmod：計算除數和被除數的結果，並返回一個包含商和余數的元組。

divmod(5,2) 　　　　　　　　　　　　　　　　# (2,1)

pow：求x**y次冪（當有第三參數時，x**y的結果對z取余 ）

pow(2,5)   　　　　　　　　　　　　#32
pow(2,3,5) 　　　　　　　　　　　　# 這里為3個參數，2的3次方，結果為8。用8和5做除法，取余為3，最終輸出3

sum：對可迭代對象進行求和計算（可設置初始值）

# sum最多只有2個參數
sum([1,2,3,4,5])            #15
sum([1,2,3,4,5],100)         #115
sum(1,2,3,4,5)              #報錯

min：返回可迭代對象的最小值（可加key，key為函數名，通過函數的規則，返回最小值）。

　　I. 將iterable的每一個元素當作函數的參數傳給函數，字典中，元素是鍵

　　II. 按照函數的返回值進行比較大小

　　III. 返回的是遍歷的元素x，即傳入函數的參數

min([1,-2,3,-4,5])                        #-4
min([1,-2,3,-4,5],key=abs)                # 按照絕對值的大小，返回此序列最小值 1
min(1,2,-5,6,-3,key=lambda x:abs(x))      # 可以設置很多參數比較大小

ls=[('spring',100),('summer',18),('winter',500)]
def func(x):
    return x[1]
print(min(ls,key=func))              #('summer',18)

dic = {'a': 3, 'b': 2, 'c': 1}
def func1(x):
    return dic[x]
print(min(dic,key=func1))          #c

# x為dic的key，lambda的返回值（即dic的值進行比較）返回最小的值對應的鍵
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))

max：返回可迭代對象的最大值（可加key，key為函數名，通過函數的規則，返回最大值）。與min用法相同

 

二.類型轉換

進制轉化

bin：將十進制轉化成二進制

bin(100) 　　　　　　#0b1100100

oct：將十進制轉化成八進制

oct(100)  　　　　　　#0o144

hex：將十進制轉化成十六進制

hex(100) 　　　　　　#0x64

 

字符串和ASCll編碼轉換

ord：輸入字符，找該字符在unicode編碼的位置

 

ord('A') = 65
ord('Z') = 90

ord('a') = 97
ord('z') = 122

ord('你') = 20320

 

chr：輸入位置數字，找出相對應的字符，與ord相反

 

chr(65) = 'A'
chr(90) = 'Z'

chr(97) = 'a'
chr(122) = 'z'

chr(20320) = '你'

 

ascii：是ascii碼表中的內容返回原值，不是返回\u + 他在Unicode中的位置

ascii('q') 　　　　　　　　　#'q' ascii('你') 　　　　　　　　#'\u4f60' 轉化成十進制就是 20320

 

數據類型轉化相關

int：將字符串或數字轉化成整型，用於將其他進制數轉化成十進制。取整數，不會四舍五入

int(1.543) 　　　　　　#1
int('123') 　　　　　　#123
int('0101',base=2)   # 5

float：將字符串或整數轉化成浮點型

float(1)   　　　　　　#1.0
float('1') 　　　　　　#1.0

bool：用於將給定參數轉化為布爾類型

bool(123)  　　　　　　#True

complex：用於創建一個值為 real+image*j的復數，當第一個參數為字符串時，不要設置第二個參數。

complex(1,2)   　　#(1+2j)
complex('1')   　　#(1+0j)

str：將數據轉化成字符串

str(2.3)                         　　# 轉換為字符串2.3

bytes：用於不同編碼之間的轉化。將unicode 轉為非unicode。只能編碼，不能解碼

編碼轉換，將unicode轉換為utf-8
方法一：
s1 = '小太陽'
s2 = s1.encode('utf-8')
print(s2)                           # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

方法二：
s1 = '小太陽'
print(bytes(s1,encoding='utf-8')) # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

list：將一個可迭代對象轉化成列表（如果是字典，默認將key作為列表的元素）

l1 = list((1,2,3))　　　　　　　　　　　　　　　　# [1, 2, 3]
l2 = list({1,2,3})　　　　　　　　　　　　　　　　# [1, 2, 3]
l3 = list({'name':'xiaoming','age':13})　　  # ['name', 'age']

tuple：將一個可迭代對象轉化成元組（如果是字典，默認將key作為元組的元素）

tup1 = tuple([1,2,3])　　　　　　　　　　　　　　　　# (1, 2, 3)
tup2 = tuple({'name':'xiaoming','age':13})　　# ('name', 'age')

dict：創建一個字典

dict(a = 1,b = 2) 　　　　　　　　　　　　　　　　# {'b': 2, 'a': 1}
dict(zip(['a','b'],[1,2])) 　　　　　　　　　　# 可以傳入映射函數創建字典。{'b': 2, 'a': 1}
dict((('a',1),('b',2))) 　　　　　　　　　　　　# 可以傳入可迭代對象創建字典。{'b': 2, 'a': 1}

set：創建一個集合

a = set(range(10)) 　　　　　　　　　　　　　　　　# 傳入可迭代對象，創建集合{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

 

其他

bytearry：返回一個新字節數組。數組中元素可變，並且每個元素的值范圍: 0 <= x < 256。（很少用）

ret = bytearray('hello',encoding='utf-8')
print(ret)   #bytearray(b'hello')
print(id(ret))   #1979800230744
print(ret[0])   #104  h在ascii碼中的位置

ret[0] = 97   #將第一位改為a
print(ret)   #bytearray(b'aello')
print(id(ret))   #1979800230744  id是相同的

bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

memoryview：返回對象obj的內存查看對象。所謂內存查看對象，就是對象符合緩沖區協議的對象，為了給別的代碼使用緩沖區里的數據，而不必拷貝，就可以直接使用。（沒啥用）

ret = memoryview(bytes('你好',encoding='utf-8'))
print(ret)   #<memory at 0x000001DA89DDB408>
print(len(ret)) # 6
print(bytes(ret[0:3]).decode('utf-8'))   #你
print(bytes(ret[3:]).decode('utf-8'))   #好
 

ret = memoryview(b'abcefg')
print(ret[1])                   # 98
print(ret[-1])                  # 103

frozenset：返回一個凍集合(新的不可變集合)，凍結后的集合不能再添加或刪除任何元素

a = frozenset(range(10))
print(a)                                # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

enumerate:枚舉，返回一個枚舉對象。 (0, seq[0]), (1, seq[1]), (2, seq[2])

li = ['spring', 'summer', 'autumn', 'winter']
print(enumerate(li)) 　　　　　　　　　　　　　　　　# <enumerate object at 0x02E3D558>
print('__iter__' in dir(enumerate(li))) 　　　　　　# True
print('__next__' in dir(enumerate(li))) 　　　　　　# True

　　enumerate是一個迭代器, 返回結果為：列表元素的索引以及對應的值

li = ['spring', 'summer', 'autumn', 'winter']
for i in enumerate(li):
    print(i)

執行輸出：
(0, 'spring')
(1, 'summer')
(2, 'autumn')
(3, 'winter')

li = ['spring', 'summer', 'autumn', 'winter']

for k,v in enumerate(li):
    print(k,v)

執行輸出：

0 spring

1 summer

2 autumn

3 winter

　　enumerate的第2個參數，表示從多少開始。默認從0開始

 

li = ['spring', 'summer', 'autumn', 'winter']
print(list(enumerate(li)))                 # [(0, 'spring'), (1, 'summer'), (2, 'autumn'), (3, 'winter')]
print(list(enumerate(li, start=1)))        #指定起始值,[(1, 'spring'), (2, 'summer'), (3, 'autumn'), (4, 'winter')]

 

 

 

li = ['spring', 'summer', 'autumn', 'winter']

for k,v in enumerate(li,10):
    print(k,v)

執行輸出：
10 spring
11 summer
12 autumn
13 winter

range：根據傳入的參數創建一個新的range對象，一般用在for循環中

a = range(10)
b = range(1,10)
c = range(1,10,3)

print(a,list(a)) # range(0, 10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(b,list(b))        # range(1, 10) [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(c,list(c))        # range(1, 10, 3) [1, 4, 7]

三、序列操作

slice：構建一個切片對象，用於列表的切片

l1 = [i for i in range(10)]
l2 = l1[:5:2]
print(l2)    　　　　　　　　　　#[0, 2, 4],按照普通切片方法

reversed：將一個序列反轉，並返回此反轉序列的迭代器，字典不能反轉。

l1 = [1,2,3,4]
print(reversed(l1))   　　　　# <list_reverseiterator object at 0x0000026B679FA4E0>

for i in reversed(l1):
    print(i)    # 4 3 2 1

s = 'asdf'
for i in reversed(s):
    print(i)   # f d s a

dic = {'name':'xiaoming','age':13}
for i in reversed(dic):
    print(i)   #字典不能反轉  TypeError: 'dict' object is not reversible

sorted：對可迭代對象進行排序，只能列表使用. 可加key，key為函數名，通過函數的規則進行排序。默認從小到大，加入reverse = True時按照從大到小。與 li.sort()相比，原列表不發生改變

　　sorted(iterable,key=None,reverse=False)

　　key: 排序規則(排序函數),在sorted內部會將可迭代對象中的每一個元素傳遞給這個函數的參數.根據函數運算的結果進行排序

　　reverse :是否是倒敘,True 倒敘 False 正序

默認升序
li = [1,2,7,8,5,4,3]
print(sorted(li))         # [1, 2, 3, 4, 5, 7, 8]

按照絕對值排序
li = [1,-2,-7,8,5,-4,3]
print(sorted(li,reverse=True,key=abs))        # [8, -7, 5, -4, 3, -2, 1]

原列表改變
l1 = [1,3,3,2,9]
l1.sort()
print(l1)          #[1, 2, 3, 3, 9]  

原列表不發生改變
l2 = [2,3,4,6,4,1]
print(sorted(l2))                  #[1, 2, 3, 4, 4, 6]
print(l2)                      #[2, 3, 4, 6, 4, 1]  

l3 = [(1,100),(2,18),(4,250),(3,500)]
def func1(x):
    return x[1]
print(sorted(l3,key=func1))          #[(2, 18), (1, 100), (4, 250), (3, 500)]

字典使用sorted排序, 字典排序返回的就是排序后的key
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))                 # [1,2,3]
 和函數組合使用
定義一個列表,然后根據一元素的長度排序
lst = ['天龍八部','西游記','紅樓夢','三國演義']
def func(s):
    return len(s)

print(sorted(lst,key=func))                        #  ['西游記', '紅樓夢', '天龍八部', '三國演義']


和lambda組合使用
lst = ['天龍八部','西游記','紅樓夢','三國演義']
print(sorted(lst,key=lambda s:len(s)))                #  ['西游記', '紅樓夢', '天龍八部', '三國演義']

lst = [{'id':1,'name':'alex','age':18},
    {'id':2,'name':'wusir','age':17},
    {'id':3,'name':'taibai','age':16},]
 
# 按照年齡對學生信息進行排序
print(sorted(lst,key=lambda e:e['age']))
 
結果:[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

all：可迭代對象中，全是True才是True

print(all([1,2,3,0]))   #False
print(all([1,2,3,4]))   #True

any：可迭代對象中，有一個是True就是True

print(any([1,[],{},0,()]))   #True

zip：將可迭代對象作為參數，將對象中的元素打包成一個元組，返回由這些元組組成的迭代器。

        如果可迭代對象中元素的數量不一致，則返回元組個與最短的對象相同。zip結果取決於最短的一個,返回的數據是元組。

        拉鏈方法：將多個iter縱向組成一個個的元組

l = [1,3,5]
tu = ('china','america','japan','korean')
dic = {'name':1,'age':2,'hobby':3}
for i in zip(l,tu,dic):
    print(i)      
    
輸出結果：
(1, 'china', 'name')
(3, 'america', 'age')
(5, 'japan', 'hobby')

lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
    print(i)
​
輸出結果:
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)

filter：通過函數過濾可迭代對象，函數中return的是一個條件，返回一個迭代器。相當於生成器表達式的篩選模式。類似於[i for i in range(10) if i > 3]

　　filter(function,iterable)

　　function: 用來篩選的函數,在filter中會自動的把iterable中的元素傳遞給function,然后根據function返回的True或者False來判斷是否保留此項數據

　　iterable:可迭代對象

l = [i for i in range(10)]
def func1(x):
    return x>5

for i in filter(func1,l):
    print(i)

lst = [{'id': 1, 'name': 'Joe', 'age': 18},
       {'id': 1, 'name': 'Paul', 'age': 17},
       {'id': 1, 'name': 'May', 'age': 16}, ]

ls = filter(lambda lst: lst['age'] > 16, lst)
print(list(ls))　　　　# [{'id': 1, 'name': 'Joe', 'age': 18}, {'id': 1, 'name': 'Paul', 'age': 17}]

取列表中的偶數
def func(x):
    return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i) 

執行輸出：
<filter object at 0x0000021325A4B6D8>
2
4
6

使用列表生成式完成
li = [i for i in [1,2,3,4,5,6,7] if i % 2 == 0]
print(li) 

map：根據提供的函數對指定的序列做映射，返回一個迭代器，相當於生成器表達式中的循環模式

　　map(function,iterable) 可以對可迭代對象中的每一個元素進映射,分別執行function

計算列表各個元素的平方
def square(x):                         
    return x ** 2

ret = map(square,[1,2,3,4,5])                 
for i in ret:
    print(i) 

執行輸出：
1
4
9
16
25

改寫成lambda
lst = [1,2,3,4,5]
print(list(map(lambda s:s*s,lst)))

map也是迭代器
l = [i for i in range(3)]
def func(x):
    return x**2

for i in map(func,l):
    print(i) 

計算兩個列表中相同位置的數據的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))        # [3, 6, 9, 12, 15]

四、對象操作

hash：獲取一個對象（可哈希對象：int，str，Bool，tuple）的哈希值

print(hash('123'))          #6154395912723147770
print(hash(123))         #123，數字不變

id：獲取對象的內存地址

print(id(123))            #1785819168

dir：查看對象或者當前作用域內的屬性列表。函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。如果參數包含方法__dir__()，該方法將被調用。如果參數不包含__dir__()，該方法將最大限度地收集參數信息。

print(dir(list))         # ['__add__', '__class__', '__contains__'...]
print(dir())            # ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print(dir('hello'))        # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',             '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__',             '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__ne...........
print('__iter__' in dir(iter))    # False

help：返回對象的幫助信息，主要用於查看函數或模塊用途的詳細說明。

help(abs)
help(str)

len：返回一個對象中元素的個數

print(len('abcd'))                     # 4 字符串
print(len(bytes('abcd','utf-8')))             # 4 字節數組
print(len((1,2,3,4)))                     # 4 元組
print(len([1,2,3,4]))                     # 4 列表
print(len(range(1,5)))                 # 4 range對象
print(len({'a':1,'b':2,'c':3,'d':4}))             # 4 字典
print(len({'a','b','c','d'}))                 # 4 集合
print(len(frozenset('abcd')))             #4 不可變集合

type：返回對象的類型，或者根據傳入的參數創建一個新的類型

type(1) # <class 'int'>

五、反射操作

hasattr(obj, attr): 用於檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。

getattr(obj, attr): 返回obj中名為attr值的屬性的值

setattr(obj, attr, val): 給obj的attr屬性賦值為val。例如attr為'bar'，則相當於obj.bar = val

delattr(obj, name)該函數刪除該obj的一個由string指定的屬性。delattr(x, 'foobar')=del x.foobar

class Test:
    f = '類的靜態變量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Test('Joe',12)

#檢測是否含有某屬性
print(hasattr(obj,'name'))          # True
print(hasattr(obj,'say_hi'))        # True
 #獲取屬性
n=getattr(obj,'name')
func=getattr(obj,'say_hi')
print(n,func)               # Joe <bound method Test.say_hi of <__main__.Test object at 0x0000000009F69128>> #設置屬性
setattr(obj,'self.hobby','paiting')
setattr(obj,'show_hobby',lambda self:self.name+' like paiting')
print(obj.__dict__)         # {'name': 'Joe', 'age': 12, 'self.hobby': 'paiting', 'show_hobby': <function <lambda> at 0x00000000029947B8>}
print(obj.show_hobby(obj))  # Joe like paiting

#刪除屬性
delattr(obj,'age')
delattr(obj,'show_hobby')
print(obj.__dict__)         # {'name': 'Joe', 'self.hobby': 'paiting'}

isinstance(a,b)：判斷a是否是b類（或者b類的基類）實例化的對象

issubclass(a,b)： 判斷a類是否是b類（或者b的基類）的派生類

class A:
    pass

class B(A):
    pass

class C(B):
    pass

obj = B()
print(isinstance(obj,B))    # True
print(isinstance(obj,A))    # True


print(issubclass(B,A))    # True
print(issubclass(C,A))    # True

callable：檢測對象是否可被調用。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。callable其實就是判斷一個對象是否是函數，是就返回True，其他類型直接返回False

name = 'summer'
print(callable(name))      #False，不可調用

def func1():
    pass
print(callable(func1))     #True,可以調用

class A:  # 定義類B
    def __call__(self):
        print('instances are callable now.')

print(callable(A))          # 類A是可調用對象,True
a = A()                     # 實例
print(a)                    # <__main__.A object at 0x02A6C490>
a()                         # 調用實例a成功,instances are callable now.

 

六、裝飾器

property：標示屬性的裝飾器。property是一個裝飾器函數，可以將一個方法偽裝成屬性，調用的時候可以不用加()

例如：BMI指數

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height

    @property
    def bmi(self):
        return self.__weight / self.__height **2

classmethod：標示方法為類方法的裝飾器。必須通過類的調用，而且此方法的意義：就是對類里面的變量或者方法進行修改添加

 

class Goods:
    __discount = 0.8                            # 折扣
    def __init__(self,name,origin_price):
        self.name = name
        self.__price = origin_price             # 原價

    @property
    def price(self):                            # 價格
        return self.__price * Goods.__discount

    @classmethod
    def change_discount(self,new_discount):     # 類方法 可以直接被類調用 不需要默認傳對象參數 只需要傳一個類參數就可以了
        Goods.__discount = new_discount

Goods.change_discount(1)    # 不依賴對象的方法 就應該定義成類方法 類方法可以任意的操作類中的靜態變量
apple = Goods('apple',5)
banana = Goods('banana',8)
print(apple.price)                              # 5
print(banana.price)                             # 8

 

 

 

staticmethod：標示方法為靜態方法的裝飾器。不依賴類以及對象。 

class Student:
def __init__(self,name):pass

    @staticmethod
    def login(a):  # login就是一個類中的靜態方法 靜態方法沒有默認參數 就當成普通的函數使用即可
        user = input('user :')
        if user == 'alex':
            print('success')

        else:
            print('faild')

Student.login(1) 

七、變量作用域相關

globals：返回一個字典，包含全部的全局變量

locals：返回一個字典，包含當前作用域的全部變量

vars：返回當前作用域內的局部變量和其值組成的字典，或者返回對象的屬性列表

class Test:
    f = '類的靜態變量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def variation(self):
        hobby = 'paiting'
        print(globals())
        print(locals())

obj = Test('Joe', 12)
obj.variation()
print(obj.__dict__)         # {'name': 'Joe', 'age': 12}
print(vars(obj))            # {'name': 'Joe', 'age': 12}

globals()的輸出：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DEC208>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/Python/test.py', '__cached__': None, 'Test': <class '__main__.Test'>, 'obj': <__main__.Test object at 0x0000000001F50A20>}

locals()的輸出：

{'hobby': 'paiting', 'self': <__main__.Test object at 0x0000000001F50A20>}

八、字符串類型代碼的執行

eval：執行字符串類型的代碼，並返回最終結果。相當於撥開字符串2邊的引號，執行里面的代碼

print(eval('3+4'))             # 7
ret = eval('{"name":"summer"}')
print(ret)                 #  {'name': 'summer'}

exec：執行字符串類型的代碼，不返回結果

print(exec('3+4'))         # None

ret1 = '''
li = [1,2,3]
for i in li:
    print(i)
'''
print(exec(ret1)) 

執行輸出：
1
2
3
None

val和exec 功能是類似的, 區別：

　　eval有返回值,exec沒有沒有值

　　exec適用於有流程控制的,比如for循環。eval只能做一些簡單的。

compile：將字符串類型的代碼編譯，代碼對象能夠通過exec語句執行或eval()求值。（了解即可）

code1 = 'for i in range(0,3): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1) 

執行輸出：
0
1
2

repr:返回一個對象的string形式（原形畢露）。

#%r  原封不動的寫出來
name = 'Joe'
print('我叫%r' % name)        # 我叫'Joe'

print(repr('{"name":"Joe"}'))    # '{"name":"Joe"}'
print('{"name":"Joe"}')        # {"name":"Joe"}

 

九、輸入輸出相關

input：函數接收一個標准輸入數據，返回str類型

print(self,*args,sep=' ',end='\n',file=None, flush=False)

　　sep：打印多個內容的分隔符，默認是空格

　　end：默認是換行符

　　file：默認是None，默認輸出到屏幕，設置文件句柄可輸出到文件

　　flush: 立即把內容輸出到流文件，不作緩存

sep默認是用空格拼接
print(11, 22, 33)             # 11 22 33

sep 指定分隔符 |
print(11, 22, 33, sep = '|')         # 11|22|33

end結尾符
print(1,end=' ')
print(222)               # 1 222


print(333,end='')
print(666,)                #333666

print(333,end='**')
print(666,)　            # 333**666

file寫入文件

with open('log.txt',encoding='utf-8',mode='w') as f1:
    print('5555',file=f1)             # 執行程序，查看log.txt文件內容為: 555

f = open('t1',encoding='utf-8',mode='w')
print(111,'222',file=f)                # 執行程序，查看t1文件內容為: 111 222

f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

打印進度條

import time
for i in range(0,101,2):  
     time.sleep(0.1)
     char_num = i//2                      #打印多少個'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)

 

十、迭代器、生成器相關

iter：函數用來生成迭代器（將一個可迭代對象，生成迭代器）

from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable))  # 判斷是否可迭代 True
print(isinstance(l,Iterator))  # 判斷是否為迭代器 False

from collections import Iterable
from collections import Iterator
l = [1,2,3]

l1 = iter(l)             #生成迭代器
print(isinstance(l1,Iterable))      # True
print(isinstance(l1,Iterator))      # True
print(l1)                           # <list_iterator object at 0x031D3690>
print(next(l1))                     # 1
print(next(l1))                     # 2
print(next(l1))                     # 3
print(next(l1))                     # 報錯 StopIteration

next：內部實際使用了__next__方法，返回迭代器的下一個項目。

# 首先獲得Iterator對象:
it = iter([1, 2, 3, 4, 5])
while True:
    try:
        # 獲得下一個值:
        x = next(it) #next內部封裝了__next__方法,都是求下一個值
        print(x)

    except StopIteration:
        # 遇到StopIteration就退出循環
        break 

執行輸出：
1
2
3
4
5

十一、其他

文件操作相關

open()  ：打開一個文件，返回一個文件操作符(文件句柄), 可以用encoding指定編碼。操作文件的模式有r,w,a,r+,w+,a+ 共6種，每一種方式都可以用二進制的形式操作(rb,wb,ab,rb+,wb+,ab+)

 

format：1、提供參數，指定對其方式，<是左對齊，>是右對齊，^是居中

　　　　2、將整數轉化成二進制’b‘、’n‘、unicode ’c‘、八進制’o‘、十六進制’x’、’X‘等

　　　　3、將浮點數用科學計數法或小數點計數法表示

print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20')) 

執行輸出：
test                
                test
        test         

super：根據傳入的參數創建一個新的子類和父類關系的代理對象

class A(object):
    def __init__(self):
        print('A.__init__')

class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()

#super調用父類方法
b = B()

結果輸出：
B.__init__
A.__init__

__import__：動態導入模塊

index = __import__('index')
index.sayHello()

 

 

特例：reduce()

在 Python3 中，reduce() 函數已經被從全局名字空間里移除了，它現在被放置在 functools 模塊里，如果想要使用它，則需要通過引入 functools 模塊來調用 reduce() 函數：

from functools import reduce

 

 

語法

reduce(function, iterable[, initializer])

• function -- 函數，有兩個參數
• iterable -- 可迭代對象
• initializer -- 可選，初始參數

 

reduce() 函數會對參數序列中元素進行累積。

 

　　reduce()函數有2個參數：第一個參數是有兩個變量的函數（f（x，y）),第二個是迭代對象 i (元組，列表或字符串）。reduce(f,i)將前兩個迭代元素（i[0], i[1]）傳至函數f，計算f返回的值，然后將該值作為f的第一個參數，迭代器的第三個元素（i[2]）作為第二個參數，以此類推。

 

 

實例

（1）數字加和

from functools import reduce

def add(x,y):
    return x + y

print (reduce(add, range(1, 101)))  # 5050

（2）統計某字符串重復次數:

from functools import reduce

sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. '] 

word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
print(word_count)   # 2

（3）字符串反序

import functools

str1="hello"
print(functools.reduce(lambda x,y:y+x,str1))
# 輸出 olleh

（4）找多個集合中共有元素

from functools import reduce

a = set((1, 2, 3, 4, 5))
b = set((2, 4, 6, 7, 1))
c = set((1, 4, 5, 9))

triple_set = [a, b, c]
common = reduce(set.intersection, triple_set)

print(common)

'''
{1, 4}
'''

 

  

 參考鏈接：

        https://www.cnblogs.com/sesshoumaru/p/6140987.html

        https://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html

        https://www.cnblogs.com/pyyu/p/6702896.html