第二十六節，Python內置函數

時間 2019-11-12

原文原文鏈接

Python3.0內置函數python

abs() 取數字的絕對值,也就是不管是正數仍是負數取它的絕對值
格式：abs(目標變量)
返回：數字類型

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#abs() 取數字的絕對值,也就是不管是正數仍是負數取它的絕對值
a = 123
b = abs(a)
print(b)
#輸出 123

a1= -123
b1 = abs(a1)
print(b1)
#輸出 123

all() 接收可迭代類型，循環參數，若是每一個元素都爲真，那麼all的返回值爲真，有一個元素爲假返回的都是假app

格式：all(目標變量)less

假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（）（空元組），{} （空字典）dom

返回：布爾值函數

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#all() 接收可迭代類型，循環參數，若是每一個元素都爲真，那麼all的返回值爲真，有一個元素爲假返回的都是假
#假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（） （空元組），{} （空字典）

#列1
a = [1,"123",[123,456],(123,456),{"k1":123,"k2":456}]
f1 = all(a)
print(f1)
#輸出 True （真）

#列2
b = [0,"你好",[123,456],(123,456),{"k1":123,"k2":456}]
f2 = all(b)
print(f2)
#輸出 False （假）說明：裏面的類型中有一個或者多個爲假

any() 接收可迭代類型，循環參數，若是有一個元素都爲真，那麼all的返回值爲真，所有爲假才返回假
格式：any(目標變量)
假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（） （空元組），{} （空字典）
返回：布爾值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#any() 接收可迭代類型，循環參數，若是有一個元素都爲真，那麼all的返回值爲真，所有爲假才返回假
#假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（） （空元組），{} （空字典）

#列1
a = [0,"1",[],(),{}]    #其中有1個爲真
f1 = any(a)
print(f1)
#輸出 True （真）

#列2
b = [0,"",[],(),{}]     #所有爲假
f2 = all(b)
print(f2)
#輸出 False （假）說明：裏面的類型所有爲假

ascii() 根據對象，在對象類中找到 _repr_ 獲取其返回值，中文返回ascii()碼
格式： ascii(目標變量)
返回：對應的類型，中文返回ascii()碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#ascii() 根據對象，在對象類中找到 _repr_ 獲取其返回值，中文返回ascii()碼
a = 1234
b = ascii(a)
print(b)
#返回 1234

#若是是中文字符串轉換成ascii碼返回
a1 = "林貴秀"
b1 = ascii(a1)
print(b1) #中文字符串轉換成ascii碼返回
#返回 '\u6797\u8d35\u79c0'

bin() 二進制表示,十進制轉換二進制
格式：bin(目標變量)
返回：二進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#bin() 二進制表示
a = 12
b = bin(a)
print(b)
#返回 0b1100 （0b表示二進制的意思）

oct() 八進制表示，十進制轉換八進制 ui

格式：oct(目標變量)this

返回：八進制編碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#oct() 八進制表示
a = 123
b = oct(a)
print(b)
#返回 0173 （0表示八進制的意思）

int() 十進制表示，十進制轉換十進制
格式：int(目標變量)
返回：十進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int() 十進制表示
a = 123987
b = int(a)
print(b)
#返回 123987 （表示十進制的意思）

hex() 十六進制表示，十進制轉換十六進制
格式:hex(目標變量)
返回：十六進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#hex() 十六進制表示
a = 123987
b = hex(a)
print(b)
#返回 0x1e453 （0x表示十進制的意思）

int() 二進制轉換成十進制
格式：int(目標變量,base=2 )
返回：十進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int()  二進制轉換成十進制
a = "0b1100"
b = int(a,base=2)
print(b)
#返回 12 表示十進制的意思

int() 八進制轉換成十進制
格式：int(目標變量,base=8 )
返回：十進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int()  八進制轉換成十進制
a = "0173"
b = int(a,base=8)
print(b)
#返回 123 表示十進制的意思

int() 十進制轉換成十進制
格式：int(目標變量,base=10 )
返回：十進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int()  十進制轉換成十進制
a = "123987"
b = int(a,base=10)
print(b)
#返回 123987 表示十進制的意思

int() 十六進制轉換成十進制
格式：int(目標變量,base=16 )
返回：十進制

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int()  十六進制轉換成十進制
a = "0x1e453"
b = int(a,base=16)
print(b)
#返回 123987 表示十進制的意思

bool() 判斷真假，把一個對象轉換成布爾值
假數據有，0（數字），None（返回值），"" (空字符串)，[] (空列表)，（）（空元組），{} （空字典）
格式：bool(目標變量)
返回：假返回False 真返回Truespa

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#bool() 判斷真假，把一個對象轉換成布爾值
a1 = ""
b = bool(a1)
print(b)
#返回 False 表示a1空字符串爲假

bytes() 字符串轉換成字節
格式：bytes(目標變量,encoding="utf-8")
返回：字節碼指針

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#bytes() 字符串轉換成字節
a = "林貴秀"
b = bytes(a, encoding = "utf-8")
print(b)
#返回 b'\xe6\x9e\x97\xe8\xb4\xb5\xe7\xa7\x80'  字節

decode()將二進制字節類型解碼成字符串

格式：字節碼變量.decode("utf-8")

#!/usr/bin/env python
# -*- coding:utf8 -*-
#bytes() 字符串轉換成字節
a = "林貴秀"
b = bytes(a, encoding = "utf-8")
print(b)
#返回 b'\xe6\x9e\x97\xe8\xb4\xb5\xe7\xa7\x80'  字節
f = b.decode("utf-8")
print(f)
#輸出
# b'\xe6\x9e\x97\xe8\xb4\xb5\xe7\xa7\x80'
# 林貴秀

str() 將字節轉換成字符串
格式：str(目標變量,encoding="utf-8")
返回：字符串

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""str() 將字節轉換成字符串"""
#bytes() 字符串轉換成字節
a = "林貴秀"
b = bytes(a, encoding = "utf-8")
print(b)
#返回 b'\xe6\x9e\x97\xe8\xb4\xb5\xe7\xa7\x80'  字節

#str() 將字節轉換成字符串
c = str(b, encoding = "utf-8")
print(c)
#返回 林貴秀 字符串

bytearray() 將字符串轉換成字節列表
格式：bytearray(目標變量,encoding="utf-8")
返回：字節列表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#bytearray() 字節列表
a = "林貴秀"
b = bytearray(a, encoding="utf-8")
print(b)
#返回 bytearray(b'\xe6\x9e\x97\xe8\xb4\xb5\xe7\xa7\x80') 字節列表

#字節列表也能夠用str()轉換成字符串
c = str(b, encoding="utf-8")
print(c)
#返回 林貴秀 字符串

chr() 將十進制ascii碼轉換成對應的（英文，字符，數字）
格式：chr(目標變量)
返回：對應的（英文，字符，數字）

詳情見：ascii碼對照表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#chr() 將十進制ascii碼轉換成對應的（英文，字符，數字）
a = 77
b = chr(a)
print(b)
#返回 M  ascii碼對應的（英文，字符，數字）

ord() 將（英文，字符，數字）轉換成十進制對應的ascii碼
格式：ord(目標變量)
返回：十進制對應的ascii碼

詳情見：ascii碼對照表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#ord() 將（英文，字符，數字）轉換成十進制對應的ascii碼
a = "M"
b = ord(a)
print(b)
#返回 77  十進制對應的ascii碼

random 隨機數模塊
格式：
　　import random 引入隨機模塊文件
　　random.randrange(65,91) 調用隨機函數random.randrange(隨機數開始範圍,隨機數結束範圍)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""實現隨機數"""
import random   #引入隨機模塊文件
f1 = random.randrange(65,91)    #調用隨機函數random.randrange(隨機數開始範圍,隨機數結束範圍)
print(f1)   #返回一個65至91之間的隨機數

實現隨機驗證碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""實現隨機驗證碼"""

"""實現隨機數"""
import random   #引入隨機模塊文件
f1 = random.randrange(65,91)    #調用隨機函數random.randrange(隨機數開始範圍,隨機數結束範圍)
print(f1)   #返回一個65至91之間的隨機數

"""實現8位數字隨機數"""
suij = ""   #統計隨機數
for i in range(4):  #循環4次
    rad = random.randrange(65,91)   #每一次循環隨機一個65至91之間的一個數賦值rad變量
    c = str(rad)    #將每次獲得的隨機數轉換成字符串類型
    suij = suij + c     #將轉換成字符串類型的隨機數賦值給，統計隨機數
print(suij)     #打印出統計隨機數

"""實現4位字母隨機數130"""
suij2 = ""      #統計隨機數
for i in range(4):      #循環4次
    rad = random.randrange(65,91)       #每一次循環隨機一個65至91之間的一個數賦值rad變量
    c = chr(rad)        #將每次獲得的隨機數以十進制的ascii碼轉換成對應字母（ascii碼字母範圍是65-91）
    suij2 += c      #將轉換的字母賦值給，統計隨機數
print(suij2)        #打印出統計隨機數

"""實現隨機數字字母的組合"""
suij3 = ""      #統計隨機數
for i in range(4):      #循環4次
    rad1 = random.randrange(0,6)        #每一次循環隨機一個0至6之間的一個數
    if rad1 == 1 or rad1 == 3:          #判斷若是rad1變量隨機數等於1或者等於3
        rad2 = random.randrange(65,91)      #每一次循環隨機一個65至91之間的一個數
        c1 = str(rad2)      #將隨機數轉換成字符串
        suij3 = suij3 + c1      #將轉換的字符串賦值給，統計隨機數
    else:       #若是rad1變量隨機數不等於1或者3
        rad3 = random.randrange(65,91)      #每一次循環隨機一個65至91之間的一個數
        c2 = chr(rad3)      #將隨機到的數以十進制的ascii碼轉換成對應字母
        suij3 = suij3 + c2      #將轉換的字母賦值給，統計隨機數
print(suij3)        #打印出統計隨機數

callable() 一個對象是否能夠被執行，也就是判斷一個對象是否能夠執行一個功能，如判斷函數
格式：callable(目標變量)
返回：布爾值，能夠執行返回True,不能夠執行返回False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#callable() 一個對象是否能夠被執行，也就是判斷一個對象是否能夠執行一個功能，如判斷函數
def f1(a,b):
    c = a + b
    return c
f1(5,5)
r = callable(f1)
print(r)
#返回 True 表示可執行對象

dict() 字典，建立字典
格式：dict(目標變量)
返回：字典

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#dict() 字典，建立字典
#建立字典
a = dict({"k1":123,"k2":456,"k3":789})
print(a)
#返回 {'k3': 789, 'k1': 123, 'k2': 456}

dir() 查看一個對象的類庫全部功能
格式：dir(目標變量)
返回：對象的類庫詳情

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#dir() 查看一個對象的類庫全部功能
a = []
b = dir(a)
print(b)
#返回：對象的類庫詳情

help() 查看一個類的類庫功能詳情
格式：help(類名稱)
返回：一個類的類庫功能詳情

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#help() 查看一個類的類庫功能詳情
a = help(str)
print(a)
#返回 一個類的類庫功能詳情

divmod() 除數，判斷除數結果，若是結果是整數返回整數加餘數0，若是結果有小數返回整數加餘數1
格式：divmod(除數,被除數)
返回：整數加餘數1 ，整數加餘數0

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#divmod() 除數，判斷除數結果，若是結果是整數返回整數加餘數0，若是結果有小數返回整數加餘數1
#除數結果是整數列
a = divmod(10,5)
print(a)
#返回 (2, 0)

#除數結果有小數列
b = divmod(10,3)
print(b)
#返回 (3, 1)

enumerate() 自定義有序類型的起始索引，如：列表，元組等
格式：(目標變量,起始索引位置數)
返回：對應類型的索引自定義位置開始

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#enumerate() 自定義有序類型的起始索引，如：列表，元組等
#列1
a = [123,456,789]
for k,v in enumerate(a,1):
    print(k,v)
#返回
#1 123
#2 456
#3 789

#列2
b = [987,654,321]
c = enumerate(b,1)
for k,v in c:
    print(k,v)
#返回
#1 987
#2 654
#3 321

eval() 計算字符串類型的算數
格式：eval(目標變量,賦值字典)
返回：計算結果

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#eval() 計算字符串類型的算數
#列1
a = "3 + 2 - 5 + 1"     #字符串類的表達式
b = eval(a)     #計算字符串類的表達式
print(b)    #返回結果
#返回 1

#列2
b1 = eval("f + 5",{"f":8})      #f+5,至關於f是一個變量+5，後面能夠傳一個字典，就至關於賦值f變量等於8
print(b1)       #返回結果
#返回 13

exec() 執行字符串類型的代碼
格式：exec(目標變量)
返回：無返回值，只執行字符串類型的代碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#exec() 執行字符串類型的代碼
#列1
a1 = "for i in range(8): print(i)"      #字符串類型的一個8次循環
b1 = exec(a1)   #執行字符串代碼

#列2
a = "for i in range(x): print(i)"   #字符串類型的一個8次循環
b = exec(a,{"x":8})     #後面能夠傳一個字典，就至關於賦值x變量等於8

filter() 帥選一個可迭代對象，循序一個可迭代對象，將每次循環到的元素傳入一個判斷函數，判斷函數返回True就將此元素保留，返回False的元素不保留
格式：filter(函數,可迭代對象)
返回：函數返回True的元素

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#filter() 循序一個可迭代對象，將每次循環到的元素傳入一個判斷函數，判斷函數返回True就將此元素保留，返回False的元素不保留
#列1
def f1(x):
    if x > 5:   #判斷函數傳入的參數是否大於5
        return True     #若是大於5返回True
    else:
        return False    #若是不大於5返回False
a = filter(f1,[1,2,3,4,5,6,7,8,9])      #循環可迭代對象每次循環到的元素傳入f1函數，每次傳入函數返回True的元素保留給a變量，返回False 的元素不保留
for i in a:     #循環出保留的元素
    print(i)    #打印出保留的元素
#打印出
# 6
# 7
# 8
# 9

#列2
#用lambda的表達式建立函數
a1 = filter(lambda x: x > 5 ,[1,2,3,4,5,6,7,8,9])   #循環可迭代對象每次循環到的元素傳入f1函數，每次傳入函數返回True的元素保留給a變量，返回False 的元素不保留
for i in a1:    #循環出保留的元素
    print(i)    #打印出保留的元素
#打印出
# 6
# 7
# 8
# 9

map() 對一個可迭代對象的每一個元素作一種操做，返回以處理後的元素
格式：map(函數，可迭代對象)
返回：返回以處理後的元素

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#map() 對一個可迭代對象的每一個元素作一種操做，返回以處理後的元素
#列1
def f1(x):
    return x + 100  #將函數接收到的參數加100返回
a = map(f1,[1,2,3,4,5])     #循環列表將每次循環的元素傳入函數，將每次函數返回結果賦值給a變量
for i in a:     #循環出結果賦值的變量
    print(i)    #打印結果
#輸出
# 101
# 102
# 103
# 104
# 105

#列2
#用lambda表達式建立函數
a1 = map(lambda x: x + 100, [1,2,3,4,5])
for i in a1:
    print(i)
#輸出
# 101
# 102
# 103
# 104
# 105

globals() 獲取當前代碼裏的全部全局變量
格式：print(globals())
返回：當前代碼裏的全部全局變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#globals() 獲取當前代碼裏的全部全局變量
a = 123
b = 456
c = 789
print(globals())
#返回：當前代碼裏的全部全局變量

locals() 獲取當前代碼裏的全部局部變量
格式：print(locals())
返回：當前代碼裏的全部局部變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#locals() 獲取當前代碼裏的全部局部變量
def f1():
    a = 123
    b = 456
    c = 789
    print(locals())     #獲取當前代碼裏的全部局部變量
f1()

hash() 計算一個字符串的哈希值
格式：hash(目標變量)
返回：哈希值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#hash() 計算一個字符串的哈希值
a = "ihdaho;uybvy8h9adghoda"
b = hash(a)
print(b)
#返回 2278432038003157021 哈希值

help() 查看類的幫助信息
格式：help(type(a))
返回：幫助信息

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#help() 查看類的幫助信息
a = "ihvfijwj"
b = help(type(a))
print(b)
#返回：幫助信息

id() 獲取對象的內存地址
格式：id(目標變量)
返回：對象內存地址

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#id() 獲取對象的內存地址
a = "ewjwehnig"
b = id(a)
print(b)
#返回：對象內存地址

input() 等待用戶輸入
格式：變量 = input()
返回：用戶輸入信息

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#input() 等待用戶輸入
a = input()
print(a)
#返回：用戶輸入信息

int() 建立或者轉換整數類型
格式：int(目標變量)
返回：整數

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#int() 建立或者轉換整數類型
#建立整數
a = int(1234)
print(a)

#轉換整數
b = "1234"
c = int(b)
print(c)
#返回：整數

isinstance() 判斷一個對象是不是某個類型
格式：isinstance(目標對象,類型)
返回：若是是對應的類型True，不是對應的類型False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#isinstance() 判斷一個對象是不是某個類型
a = "林貴秀"
b = isinstance(a,str)
print(b)
#返回 True

iter() 建立可迭代的對象，結合next()取出裏面的每一個元素
格式：iter(目標變量)
返回：可迭代類型
可結合next()取出裏面的每一個元素

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#iter() 建立可迭代的對象
a = "rghrthrhkjhtr"
b = iter(a) #建立可迭代的對象
print(b)
c1 = next(b) #取出裏面一個元素
print(c1)
c2 = next(b) #取出裏面一個元素
print(c2)
c3 = next(b) #取出裏面一個元素
print(c3)
# 返回：可迭代類型
# 可結合next()取出裏面的每一個元素

next()取出可迭代類型裏面的每一個元素，結合iter()使用
格式：next(目標對象)
返回：可迭代類型的一個元素

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#iter() 建立可迭代的對象
a = "rghrthrhkjhtr"
b = iter(a) #建立可迭代的對象
print(b)
c1 = next(b) #取出裏面一個元素
print(c1)
c2 = next(b) #取出裏面一個元素
print(c2)
c3 = next(b) #取出裏面一個元素
print(c3)
# 返回：可迭代類型
# 可結合next()取出裏面的每一個元素

len() 判斷一個可迭代對象裏面有多少個元素
格式：len(目標對象)
返回：可迭代對象裏面元素的數量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#len() 判斷一個可迭代對象裏面有多少個元素
a = "12345"
b = len(a)
print(b)
# 返回：可迭代對象裏面元素的數量

max() 取一個可迭代對象的最大值
格式：max(目標變量)
返回：最大值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#max() 取一個可迭代對象的最大值
a = "128345"
b = max(a)
print(b)
# 返回：最大值

min() 取一個可迭代對象的最小值
格式：min(目標變量)
返回：最小值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#min() 取一個可迭代對象的最小值
a = "128345"
b = min(a)
print(b)
# 返回：最小值

pow() 求一個數的對少次方
格式：pow(要求的數,多少次方)
返回：一個數的次方

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#pow() 求一個數的對少次方
a = pow(2,10) #2的10次方
print(a)
#返回 1024

property() 打印結果
格式：property(目標變量)
返回：結果

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#property() 打印結果
a = 12345
print(a)
#返回 12345 結果

range() 自動建立一個數字列表，py3.0以上版本須要for循環後才建立
格式：range(開始數字，結束數字)
返回：須要for循環後返回建立的元素

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#range() 自動建立一個列表
a = range(1,10) #若是傳一個參數，默認從0開始
for i in a:
    print(i)
#返回 須要for循環後返回建立的元素

repr() 在對象類中找到 _repr_ 獲取其返回值，返回對應的類型
格式：repr（目標變量）
返回：對應的類型

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#repr（）在對象類中找到 _repr_ 獲取其返回值，返回對應的類型
a = 1234
b = repr(a)
print(b)
#返回 1234


a1 = "林貴秀"
b1 = repr(a1)
print(b1)
#返回 '林貴秀'

reversed() 對可迭代類型的元素排序進行反轉，須要for循環後返回
格式：reversed(目標變量)
返回：須要for循環後返回，將元素進行反轉排序後返回

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#reversed() 對可迭代類型的元素排序進行反轉，須要for循環後返回
a = "1234"
b = reversed(a)
for i in b:
    print(i)
# 返回
# 4
# 3
# 2
# 1

round() 四捨五入
格式：round(目標變量)
返回：四捨五入

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#round() 四捨五入
#四舍
a = 3.4
b = round(a)
print(b)
#返回 3

#五入
a1 = 5.5
b1 = round(a1)
print(b1)
#返回 6

set() 建立或轉換無序集合
格式：set(目標變量)
返回：無序集合

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#set() 建立或轉換無序集合
#建立結合
a1 = set({1,2,3})
print(a1)
#返回 {1, 2, 3}

#轉換集合
a = [1,2,3,4,5]
b = set(a)
print(b)
#返回 {1, 2, 3, 4, 5}

sum() 將一個可迭代對象的數字元素求和
格式：sum(目標變量)
返回：求和

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#sum() 將一個可迭代對象的數字元素求和
a = [11,22,33,44]
b = sum(a)
print(b)
#返回 110 求和

tuple() 建立或轉換元組
格式：tuple(目標變量)
返回：元組

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#tuple() 建立或轉換元組
#建立元組
a = tuple((11,22,33,44))
print(a)
#返回 (11, 22, 33, 44)

#轉換元組
a1 = [11,22,33,44]
b1 = tuple(a1)
print(b1)
#返回 (11, 22, 33, 44)

type() 查看一個對象的類型
格式：type(目標變量)
返回：類型

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#type() 查看一個對象的類型
a = "你好"
b = type(a)
print(b)
#返回類型 <class 'str'>

zip() 將兩個列表的元素，組合成兩個元素爲一對元組，須要for循環後返回
格式：zip(列表，列表)
返回：須要for循環後返回，兩個元素爲一對元組

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#zip() 將兩個列表的元素，組合成兩個元素爲一對元組，須要for循環後返回
a = [1,2,3,4,5]
b = ["a","b","c","d","e"]
c = zip(a,b)
print(c)    #<zip object at 0x0000012584DA0F88>
for i in c:
    print(i)
#返回
# (1, 'a')
# (2, 'b')
# (3, 'c')
# (4, 'd')
# (5, 'e')

sorted() 對可迭代對象排序，注意可迭代對象元素必定要是同一類型，不然不能排序
格式：sorted(目標變量)
返回：排序後的對應對象

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#sorted() 對可迭代對象排序，注意可迭代對象元素必定要是同一類型，不然不能排序
#數字排序，數字從小到大排序
a = [6,3,8,2,9,7,5]
b = sorted(a)
print(b)
#返回 [2, 3, 5, 6, 7, 8, 9]

#字母排序，字母按照順序排序
a1 = ["d","f","s","e","a","u","g","l"]
b1 =sorted(a1)
print(b1)
#返回 ['a', 'd', 'e', 'f', 'g', 'l', 's', 'u']

#字符串排序，是按照字符串的字節碼數字和字母的ascii碼排序的
a2 = "自貢玉秀文化傳播有限公司"
b2 = sorted(a2)
print(b2)
#返回 ['傳', '公', '化', '司', '播', '文', '有', '玉', '秀', '自', '貢', '限']

for i in b2:
    print(bytes(i,encoding="utf-8"))    #查看字符串的字節碼

文件操做
文件操做的步驟
1.打開文件： open()打開文件
2.操做文件： read()讀出文件，write()寫入文件
3.關閉文件： close()關閉文件

open() 打開一個文件
格式：句柄變量 = open(要打開的文件名或文件路徑，打開模式，編碼)
注意：默認是隻讀模式
注意：編碼只有在普通模式的時候用（3.0版本默認是utf-8編碼），字節碼模式不須要編碼由於基層就是字節碼保存的
返回：文件句柄

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#open() 打開一個文件
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r模式（只讀）打開，以utf-8編碼
print(f)    #打印文件句柄，<_io.TextIOWrapper name='h.log' mode='r' encoding='utf-8'>
f1 = f.read()   #read()讀出文件內容
f.close()   #關閉文件
print(f1)   #讀出文件內容，tjhutrjtr

read() 讀出文件內容
格式：句柄變量.read(位數從指針位置開始向後讀多少位) 默認所有讀出
返回：文件裏的內容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#read() 讀出文件內容
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r模式（只讀）打開，以utf-8編碼
print(f)    #打印文件句柄，<_io.TextIOWrapper name='h.log' mode='r' encoding='utf-8'>
f1 = f.read()   #read()讀出文件內容
f.close()   #關閉文件
print(f1)   #讀出文件內容，tjhutrjtr

write() 寫入文件
格式：句柄變量.write(要寫入的內容)
返回：無返回，將內容寫入文件

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#write() 寫入文件
f = open("h.log", "w", encoding="utf-8")    #打開h.log文件，以r模式（只讀）打開，以utf-8編碼
f1 = f.write("林貴秀")   #write()寫入文件內容
f.close()   #關閉文件

close() 關閉文件
格式：句柄變量.close()
返回：無，關閉打開的文件

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#read() 讀出文件內容
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r模式（只讀）打開，以utf-8編碼
print(f)    #打印文件句柄，<_io.TextIOWrapper name='h.log' mode='r' encoding='utf-8'>
f1 = f.read()   #read()讀出文件內容
f.close()   #關閉文件
print(f1)   #讀出文件內容，tjhutrjtr

打開文件的模式有：

r ，只讀模式【默認】

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#r ，只讀模式【默認】
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r模式（只讀）打開，以utf-8編碼
f2 = f.read()   #read()讀出文件
print(f2)
f.close()   #關閉文件
# 只能讀，不能寫入

下面相同原理

w，只寫模式【不可讀；不存在則建立；存在則清空內容；】
x，只寫模式【不可讀；不存在則建立，存在則報錯】
a，追加模式【不可讀；不存在則建立；存在則只追加內容；】

"+" 表示能夠同時讀寫某個文件

r+，讀寫【可讀，可寫】

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#r ，只讀模式【默認】
f = open("h.log", "r+", encoding="utf-8")    #打開h.log文件，以r+模式（讀寫）打開，以utf-8編碼
f2 = f.read()   #read()讀出文件
print(f2)
f.write("9444") #寫入文件
f.close()   #關閉文件
# 可讀，可寫

　　下面相同原理

w+，寫讀【可讀，可寫，不存在則建立；存在則清空內容；】
x+ ，寫讀【可讀，可寫，不存在則建立，存在則報錯】
a+，寫讀【可讀，可寫，不存在則建立；存在則只追加內容；】

"b"表示以字節的方式操做，以b方式打開時，讀取到的內容是字節類型，寫入時也須要提供字節類型

　　 注：以b方式打開時，讀取到的內容是字節類型（不須要編碼），寫入時也須要提供字節類型（須要用bytes()轉換成字節寫入）

rb 或 r+b 【原有基礎上增長字節碼模式】

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#r+b 讀寫字節方式
f = open("h.log", "r+b")    #打開h.log文件，以r+b模式（讀寫字節方式）
f2 = f.read()   #read()讀出文件內容字節
f3 = str(f2, encoding="utf-8")  #將字節轉換成字符串
print(f3)   #打印出字符串

a = "你好"
b = bytes(a,encoding="utf-8")   #注意：字節模式寫入前必定要轉換成字節
f.write(b)  #寫入文件
f.close()   #關閉文件
# 可讀，可寫

　　下面相同原理

wb 或 w+b 【原有基礎上增長字節碼模式】　　
xb 或 w+b 【原有基礎上增長字節碼模式】
ab 或 a+b 【原有基礎上增長字節碼模式】

文件指針
操做文件，寫入內容或者讀出內容都是從指針位置開始向後操做的。
指針位置在開始位置後面的內容就能夠讀出，指針位置在結束的位置後面是空的此時讀出就是空白

寫入內容後指針就停留在寫入內容的結束位置，追加模式寫入內容是先將指針調到結束位置寫入，寫入後停留在寫入結束位置
根據打開文件的模式不一樣指針位置不一樣，

tell() 查看文件指針位置
格式：句柄變量.tell()
返回：指針位置

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#tell() 查看文件指針位置
#如：h.log裏有一串字符串"自貢玉秀文化傳播有限公司"
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r只讀模式，以utf-8編碼
f1 = f.tell()   #tell()獲取文件指針位置，注意：中文字符一個漢字算3個指針
print(f1)   #打印出指針位置

f.seek(9)   #自定義文件指針位置
f2 = f.tell()   #tell()獲取文件指針位置，注意：中文字符一個漢字算3個指針
print(f2)   #打印出指針位置

f3 = f.read()   #讀取文件內容
print(f3)   #打印出文件內容
f.close()   #關閉文件

seek() 自定義文件指針位置
格式：句柄變量.seek(自定義指針位置) 默認指針位置0
返回：無，自定義文件指針位置

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#tell() 查看文件指針位置
#如：h.log裏有一串字符串"自貢玉秀文化傳播有限公司"
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r只讀模式，以utf-8編碼
f1 = f.tell()   #tell()獲取文件指針位置，注意：中文字符一個漢字算3個指針
print(f1)   #打印出指針位置

f.seek(9)   #自定義文件指針位置
f2 = f.tell()   #tell()獲取文件指針位置，注意：中文字符一個漢字算3個指針
print(f2)   #打印出指針位置

f3 = f.read()   #讀取文件內容
print(f3)   #打印出文件內容
f.close()   #關閉文件

flush() 刷新文件內部緩衝區（將內容刷到硬盤文件裏）
格式：句柄變量.flush()
返回：無，將內容刷到硬盤文件裏

下面是將內容刷到硬盤文件裏，與不將內容刷到硬盤文件裏的區別

1不將內容刷到硬盤文件裏

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#flush() 刷新文件內部緩衝區（將內容刷到硬盤文件裏）
#不將內容刷到硬盤文件裏
f = open("h.log", "w", encoding="utf-8")    #打開h.log文件，以w只寫，以utf-8編碼
f.write("林貴秀")  #寫入內容
input()     #等待用戶輸入，進程沒結束
f.close()   #關閉文件
#如上列說明，等待用戶輸入，只要用戶沒有輸入信息確認進程就沒結束，上面的內容就不會寫入文件

2將內容刷到硬盤文件裏

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#flush() 刷新文件內部緩衝區（將內容刷到硬盤文件裏）
f = open("h.log", "w", encoding="utf-8")    #打開h.log文件，以w只寫，以utf-8編碼
f.write("林貴秀")  #寫入內容
f.flush()   #將內容刷到硬盤文件裏
input()     #等待用戶輸入，進程沒結束
f.close()   #關閉文件
#如上列說明，等待用戶輸入，只要用戶沒有輸入信息確認進程就沒結束，上面的內容也會寫入文件

readline() 僅讀取一行數據，後面行的數據不讀取
格式：句柄變量.readline()
返回：僅返回文件裏一行數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#readline() 僅讀取一行數據
f = open("h.log", "r", encoding="utf-8")    #打開h.log文件，以r只讀模式，以utf-8編碼
f1 = f.readline()   #readline() 僅讀取一行數據,後面行的數據不讀取
print(f1)
f.close()   #關閉文件

truncate() 截斷數據，僅保留指針以前數據，指針以後的數據刪除
格式：句柄變量.truncate()
返回：僅保留指針以前數據，指針以後的數據刪除

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#truncate()  截斷數據，僅保留指針以前數據
#如文件裏有:123456789
f = open("h.log", "r+", encoding="utf-8")    #打開h.log文件，以r+讀寫模式，以utf-8編碼
print(f.tell())     #查看文件指針
f.seek(5)   #將文件指針定位到第5個位置
print(f.tell())     #查看文件指針
f.truncate()   #truncate()  截斷數據，僅保留指針以前數據，指針以後的數據刪除
f.close()   #關閉文件
#最後文件裏是 12345 後面的被刪除了

for 循環文件裏的內容，文件句柄是能夠被循環的，適合大文件讀取好處是節省內存，至關於一行一行的讀的，（推薦）
格式：句柄變量 = 打開文件
for 循環
返回：文件裏的內容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#for 文件句柄是能夠被循環的，循環文件裏的內容，適合大文件讀取好處是節省內存，至關於一行一行的讀的，
f = open("h.log", "r+", encoding="utf-8")    #打開h.log文件，以r+讀寫模式，以utf-8編碼
for i in f:
    print(i)
f.close()   #關閉文件

with 自動打開文件，對文件操做後，自動關閉文件,不用寫關閉文件函數，並且支持同時打開兩個文件（推薦）
格式：with open("文件路徑","打開模式") as 句柄變量:
返回：句柄變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# with 自動打開文件，對文件操做後，自動關閉文件（推薦）
# 格式：with open("文件路徑","打開模式") as 句柄變量:
# 返回：句柄變量
with open("h.log", "r+", encoding="utf-8") as f:    #自動打開文件，對文件操做後，自動關閉文件
    a = f.read()    #讀出文件內容
    print(a)    #打印出文件內容

列2 同時打開兩個文件，將一個文件的內容寫入另一個文件
假如原始文件很大，因此經過循環文件句柄，讀一行寫一行到新文件，減小內存使用率

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 列2 同時打開兩個文件，將一個文件的內容寫入另一個文件
# 假如原始文件很大，因此經過循環文件句柄，讀一行寫一行到新文件，減小內存使用率
with open("1.log", "r", encoding="utf-8") as  a, open("2.log", "w", encoding="utf-8") as b:    #自動打開文件，對文件操做後，自動關閉文件
    for i in a:     #循環出原始文件的數據
        b.write(i)  #每循環出一行原始文件數據，寫入新文件裏

文件操做2.x源碼

class file(object)
    def close(self): # real signature unknown; restored from __doc__
        關閉文件
        """
        close() -> None or (perhaps) an integer.  Close the file.
         
        Sets data attribute .closed to True.  A closed file cannot be used for
        further I/O operations.  close() may be called more than once without
        error.  Some kinds of file objects (for example, opened by popen())
        may return an exit status upon closing.
        """
 
    def fileno(self): # real signature unknown; restored from __doc__
        文件描述符  
         """
        fileno() -> integer "file descriptor".
         
        This is needed for lower-level file interfaces, such os.read().
        """
        return 0    
 
    def flush(self): # real signature unknown; restored from __doc__
        刷新文件內部緩衝區
        """ flush() -> None.  Flush the internal I/O buffer. """
        pass
 
 
    def isatty(self): # real signature unknown; restored from __doc__
        判斷文件是不是贊成tty設備
        """ isatty() -> true or false.  True if the file is connected to a tty device. """
        return False
 
 
    def next(self): # real signature unknown; restored from __doc__
        獲取下一行數據，不存在，則報錯
        """ x.next() -> the next value, or raise StopIteration """
        pass
 
    def read(self, size=None): # real signature unknown; restored from __doc__
        讀取指定字節數據
        """
        read([size]) -> read at most size bytes, returned as a string.
         
        If the size argument is negative or omitted, read until EOF is reached.
        Notice that when in non-blocking mode, less data than what was requested
        may be returned, even if no size parameter was given.
        """
        pass
 
    def readinto(self): # real signature unknown; restored from __doc__
        讀取到緩衝區，不要用，將被遺棄
        """ readinto() -> Undocumented.  Don't use this; it may go away. """
        pass
 
    def readline(self, size=None): # real signature unknown; restored from __doc__
        僅讀取一行數據
        """
        readline([size]) -> next line from the file, as a string.
         
        Retain newline.  A non-negative size argument limits the maximum
        number of bytes to return (an incomplete line may be returned then).
        Return an empty string at EOF.
        """
        pass
 
    def readlines(self, size=None): # real signature unknown; restored from __doc__
        讀取全部數據，並根據換行保存值列表
        """
        readlines([size]) -> list of strings, each a line from the file.
         
        Call readline() repeatedly and return a list of the lines so read.
        The optional size argument, if given, is an approximate bound on the
        total number of bytes in the lines returned.
        """
        return []
 
    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
        指定文件中指針位置
        """
        seek(offset[, whence]) -> None.  Move to new file position.
         
        Argument offset is a byte count.  Optional argument whence defaults to
(offset from start of file, offset should be >= 0); other values are 1
        (move relative to current position, positive or negative), and 2 (move
        relative to end of file, usually negative, although many platforms allow
        seeking beyond the end of a file).  If the file is opened in text mode,
        only offsets returned by tell() are legal.  Use of other offsets causes
        undefined behavior.
        Note that not all file objects are seekable.
        """
        pass
 
    def tell(self): # real signature unknown; restored from __doc__
        獲取當前指針位置
        """ tell() -> current file position, an integer (may be a long integer). """
        pass
 
    def truncate(self, size=None): # real signature unknown; restored from __doc__
        截斷數據，僅保留指定以前數據
        """
        truncate([size]) -> None.  Truncate the file to at most size bytes.
         
        Size defaults to the current file position, as returned by tell().
        """
        pass
 
    def write(self, p_str): # real signature unknown; restored from __doc__
        寫內容
        """
        write(str) -> None.  Write string str to file.
         
        Note that due to buffering, flush() or close() may be needed before
        the file on disk reflects the data written.
        """
        pass
 
    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
        將一個字符串列表寫入文件
        """
        writelines(sequence_of_strings) -> None.  Write the strings to the file.
         
        Note that newlines are not added.  The sequence can be any iterable object
        producing strings. This is equivalent to calling write() for each string.
        """
        pass
 
    def xreadlines(self): # real signature unknown; restored from __doc__
        可用於逐行讀取文件，非所有
        """
        xreadlines() -> returns self.
         
        For backward compatibility. File objects now include the performance
        optimizations previously implemented in the xreadlines module.
        """
        pass

文件操做3.x源碼

class TextIOWrapper(_TextIOBase):
    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '\n', '\r', and '\r\n'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.
    """
    def close(self, *args, **kwargs): # real signature unknown
        關閉文件
        pass

    def fileno(self, *args, **kwargs): # real signature unknown
        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown
        刷新文件內部緩衝區
        pass

    def isatty(self, *args, **kwargs): # real signature unknown
        判斷文件是不是贊成tty設備
        pass

    def read(self, *args, **kwargs): # real signature unknown
        讀取指定字節數據
        pass

    def readable(self, *args, **kwargs): # real signature unknown
        是否可讀
        pass

    def readline(self, *args, **kwargs): # real signature unknown
        僅讀取一行數據
        pass

    def seek(self, *args, **kwargs): # real signature unknown
        指定文件中指針位置
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        指針是否可操做
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        獲取指針位置
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        截斷數據，僅保留指定以前數據
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        是否可寫
        pass

    def write(self, *args, **kwargs): # real signature unknown
        寫內容
        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default