python3內置函數大全

時間 2019-12-10

原文原文鏈接

因爲面試的時候有時候會問到python的幾個基本內置函數，因爲記不太清，就比較難受，因而嘔心瀝血總結了一下python3的基本內置函數html

Github源碼: https://github.com/tyutltf/Python_funspython

1.abs()函數git

'''
abs() 函數返回數字的絕對值。
絕對值：absolute
正如字面上的意思，能夠返回一個絕對值
'''
import math
print('abs(45)的值:',abs(45))
print('abs(-45)的值:',abs(-45))
print('abs(45+23)的值:',abs(45+23))
print('abs(math.pi)的值:',abs(math.pi))

print(help(abs))
'''
運行結果：
abs(45)的值: 45
abs(-45)的值: 45
abs(45+23)的值: 68
abs(math.pi)的值: 3.141592653589793
Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

None

在python2 裏還能夠輸出 print "abs(119L) : ", abs(119L)  不過python3中abs函數只能輸入int型 否則會報錯
'''

2.all()函數詳解github

'''
all() 函數用於判斷給定的可迭代參數 iterable 中的全部元素是否都爲 TRUE，若是是返回 True，不然返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
語法
如下是 all() 方法的語法:
all(iterable)
參數
iterable -- 元組或列表。
返回值
若是iterable的全部元素不爲0、''、False或者iterable爲空，all(iterable)返回True，不然返回False；
注意：空元組、空列表返回值爲True，這裏要特別注意。
'''
print(all(['a','b','c','']))   #列表存在一個爲空的元素，返回False
print(all(['a','b','c','d']))  #列表都有元素，返回True
print(all([0,1,2,3,4,5,6]))    #列表裏存在爲0的元素 返回False

print(all(('a','b','c','')))   #元組存在一個爲空的元素，返回Fasle
print(all(('a','b','c','d')))  #元組都有元素，返回True
print(all((0,1,2,3,4,5)))      #元組存在一個爲0的元素，返回Fasle

print(all([]))  #空列表返回 True
print(all(()))  #空元組返回 True

3.any()函數面試

'''
any() 函數用於判斷給定的可迭代參數 iterable 是否所有爲 False，則返回 False，若是有一個爲 True，則返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
語法
如下是 any() 方法的語法:
any(iterable)
參數
iterable -- 元組或列表。
返回值
若是都爲空、0、false，則返回false，若是不都爲空、0、false，則返回true。
'''
print(any(['a','b','c','']))   #列表存在一個爲空的元素，返回True
print(any(['a','b','c','d']))  #列表都不爲空，返回True
print(any([0,'',False]))       #列表裏的元素全爲  0,'',False  返回False

print(any(('a','b','c','')))   #元組存在一個爲空的元素，返回True
print(any(('a','b','c','d')))  #元組都有元素，返回True
print(any((0,'',False)))       #元組裏的元素全爲  0,'',False  返回False

print(any([]))  #空列表返回 False
print(any(()))  #空元組返回 False

4.ascii()函數express

'''
ascii() 函數相似 repr() 函數, 返回一個表示對象的字符串,
可是對於字符串中的非 ASCII 字符則返回經過 repr() 函數使用 \x, \u 或 \U 編碼的字符。
生成字符串相似 Python2 版本中 repr() 函數的返回值。
語法
如下是 ascii() 方法的語法:
ascii(object)

參數
object -- 對象。

返回值
返回字符串
'''
print(ascii('uiatfu'))

#報錯 SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 427-428: truncated \xXX escape
#不知道爲什麼

5.bin()函數api

'''
函數原型
bin(x)
參數解釋
x
整數型，參數不可爲空。
返回值
<class 'str'> 字符串類型，二進制整數。
函數說明
將一個整數轉化爲一個二進制整數，並以字符串的類型返回。
'''
print(bin(12))          #輸出12的二進制 0b1100
print(bin(-120))        #輸出-12的二進制 -0b1111000
print(type(bin(12)))    #輸出bin(12) 的類型 <class 'str'> 因此不能直接計算

print(int(bin(10),base=2)+int(bin(20),base=2))  #輸出 30

#base 參數不可爲空 爲空默認參數爲10進制 會報錯 ValueError: invalid literal for int() with base 10: '0b1010'

#固然了，參數不只能夠接受十進制整數，八進制、十六進制也是能夠的，只要是int型數據就合法。

print(bin(0b10010))    #輸出0b10010
print(bin(0o1357))     #輸出0b1011101111
print(bin(0x2d9))      #輸出0b1011011001

6.bool()函數數組

'''
描述
bool() 函數用於將給定參數轉換爲布爾類型，若是沒有參數，返回 False。
bool 是 int 的子類。
語法
如下是 bool() 方法的語法:
class bool([x])
參數
x -- 要進行轉換的參數。
返回值
返回 Ture 或 False。
'''
print(bool(0))         #返回False
print(bool(1))         #返回True
print(bool(True))      #返回True
print(bool(False))     #返回False
print(bool(''))        #返回False


#0,False,'',  空字符串返回Fasle

7.bytes()函數app

'''
描述
bytes 函數返回一個新的 bytes 對象，該對象是一個 0 <= x < 256 區間內的整數不可變序列。
它是 bytearray 的不可變版本。

語法
如下是 bytes 的語法:
class bytes([source[, encoding[, errors]]])
參數
若是 source 爲整數，則返回一個長度爲 source 的初始化數組；
若是 source 爲字符串，則按照指定的 encoding 將字符串轉換爲字節序列；
若是 source 爲可迭代類型，則元素必須爲[0 ,255] 中的整數；
若是 source 爲與 buffer 接口一致的對象，則此對象也能夠被用於初始化 bytearray。
若是沒有輸入任何參數，默認就是初始化數組爲0個元素。
返回值
返回一個新的 bytes 對象。

將一個字符串轉換成字節類型
'''
print(bytes('python',encoding='utf-8'))   #輸出b'python'
print(bytes('張三',encoding='utf-8'))     #輸出b'\xe5\xbc\xa0\xe4\xb8\x89'

print(bytes([1,2,3,4]))                   #輸出b'\x01\x02\x03\x04'
print(bytes('hello','ascii'))             #輸出b'hello'
print(type(bytes([1,2,3])))               #輸出<class 'bytes'>

8.challable()函數ssh

'''
challable()　　判斷對象是否能夠被調用，
能被調用的對象就是一個callables對象，
好比函數和帶有__call__()的實例
'''

print(callable(max))       #輸出True
print(callable([1,2,3]))   #輸出Fasle
print(callable(None))      #輸出Fasle
print(callable('str'))     #輸出Fasle


def fn(x):
    return x*x
print(callable(fn))        #輸出True  證實自定義的函數也能夠

9.chr()函數

'''
查看十進制數對應的ASCII碼值
描述
chr() 用一個整數做參數，返回一個對應的字符。
語法
如下是 chr() 方法的語法:
chr(i)
參數
i -- 能夠是 10 進制也能夠是 16 進制的形式的數字，數字範圍爲 0 到 1,114,111 (16 進製爲0x10FFFF)。
返回值
返回值是當前整數對應的 ASCII 字符。
'''

#print(chr(-1))   #報錯 ValueError: chr() arg not in range(0x110000) 超出範圍 不能小於0

print(chr(0x30))     #輸出 0
print(chr(97))       #輸出 a
print(chr(8364))     #輸出 €

10.classmethod()函數

'''
描述
classmethod 修飾符對應的函數不須要實例化，不須要 self 參數，
但第一個參數須要是表示自身類的 cls 參數，能夠來調用類的屬性，類的方法，實例化對象等。
語法
classmethod 語法：
classmethod
參數
無。
返回值
返回函數的類方法。
'''

class Stud:
    num=1
    def fn1(self):
        print('方法一')
    @classmethod
    def fn2(cls):
        print('方法二')   #輸出 方法二
        print(cls.num)    #調用類的實例化對象
        cls().fn1()       #調用類的方法

Stud.fn2()    #輸出 方法二 不須要實例化

print('===='*10)
object=Stud()
object.fn1()  #輸出 方法一 須要實例化

11.complex()函數

'''
描述
complex() 函數用於建立一個值爲 real + imag * j 的複數或者轉化一個字符串或數爲複數。
若是第一個參數爲字符串，則不須要指定第二個參數。。
語法
complex 語法：
class complex([real[, imag]])
參數說明：
real -- int, long, float或字符串；
imag -- int, long, float；
返回值
返回一個複數。
'''

print(complex(1,2))          #輸出  (1+2j)
print(complex(1))            #輸出  (1+0j)
print(complex('2'))          #輸出  (2+0j)

# 注意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，不然會報錯
print(complex('2+3j'))       #輸出  (2+3j)

print(complex(1.2,3.4))      #輸出  (1.2+3.4j)

12.complie()函數

'''
complie()　　將字符串編譯成python能識別或能夠執行的代碼，也能夠將文字讀成字符串再編譯

1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 將source編譯爲代碼或者AST對象。代碼對象能過經過exec語句來執行或者eval()進行求值。
3 參數source：字符串或者AST（abstract syntax trees）對象。
4 參數filename：代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值。
5 參數model：指定編譯代碼的種類。能夠指定'exec', 'eval', 'single'。
6 參數flag和dont_inherit：這兩個參數爲可選參數。
'''

s="print('hello world')"
r=compile(s,'hello','exec')
print(r)

#輸出結果：
#<code object <module> at 0x000002EBD335CF60, file "hello", line 1>

13.delattr()函數

'''
描述：
delattr函數用於刪除屬性
delattr(x,'foobar)至關於del x.foobar
語法：
setattr(object,name)
參數：
object--對象
name--必須是對象的屬性
返回值：
無
'''

class People():
    sex='男'
    def __init__(self,name):
        self.name=name
    def peopleinfo(self):
        print('歡迎%s訪問'%self.name)

delattr(People,'sex')  #等同於 del People.sex
print(People.__dict__)

#輸出 {'__module__': '__main__', '__init__': <function People.__init__ at 0x000001CE3E2E52F0>, 'peopleinfo': <function People.peopleinfo at 0x000001CE3E2E5378>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

class Foo:
    def run(self):
        while True:
            cmd=input('cmd>>: ').strip()
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func()
    def download(self):
        print('download....')
    def upload(self):
        print('upload...')
obj=Foo()
obj.run()

14.dict()函數

'''
描述
dict() 函數用於建立一個字典。
語法
dict 語法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
參數說明：
**kwargs -- 關鍵字
mapping -- 元素的容器。
iterable -- 可迭代對象。
返回值
返回一個字典。
'''

print(dict())   #建立空字典
dict1=dict(a='a', b='b', t='t')   #傳入關鍵字 構建字典
print(dict1)    #輸出 {'a': 'a', 'b': 'b', 't': 't'}

dict2=dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函數方式來構造字典
print(dict2)    #輸出 {'one': 1, 'two': 2, 'three': 3}

dict3=dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代對象方式來構造字典
print(dict3)     #輸出 {'one': 1, 'two': 2, 'three': 3}

15.dir()函數

'''
dir() 函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。若是參數包含方法__dir__()，該方法將被調用。若是參數不包含__dir__()，該方法將最大限度地收集參數信息。
語法
dir 語法：
dir([object])
參數說明：
object -- 對象、變量、類型。
返回值
返回模塊的屬性列表。
'''

print(dir())        #得到當前模塊的屬性列表
#輸出 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print(dir([]))      #得到列表的方法
#輸出 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__
print(dir(str))     #得到字符串的方法
#輸出 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
print(dir(dict))    #得到字典的方法
#輸出 ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

def update_func(var):
    print("var 的內存地址:", id(var))
    var += [4]

lst_1 = [1, 2, 3]

print(dir())  #輸出 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'lst_1', 'update_func']

class Shape:
    def __dir__(self):
        return ['area', 'perimeter', 'location']

s = Shape()
print(dir(s))   #輸出 ['area', 'location', 'perimeter']

#參考網頁 https://www.yuzhi100.com/tutorial/python3/python3-neizhihanshu-dir

16.divmod()函數

'''
python divmod() 函數把除數和餘數運算結果結合起來，返回一個包含商和餘數的元組(a // b, a % b)。
在 python 2.3 版本以前不容許處理複數。
函數語法
divmod(a, b)
參數說明：
a: 數字
b: 數字
'''
print(divmod(20,4))   #返回  (5, 0)
print(divmod(7,2))    #返回  (3, 1)
print(divmod(8,2))    #返回  (4, 0)
#print(divmod(1+2j,1+0.5j))
#報錯 TypeError: can't take floor or mod of complex number.

17.enumerate()函數

'''
enumerate是翻譯過來是枚舉的意思，看下它的方法原型：
enumerate(sequence, start=0)，返回一個枚舉對象。
sequence必須是序列或迭代器iterator，或者支持迭代的對象。
enumerate()返回對象的每一個元素都是一個元組，
每一個元組包括兩個值，一個是計數，一個是sequence的值，
計數是從start開始的，start默認爲0。
---------------------
'''
a=["q","w","e","r"]
c=enumerate(a)
for i in c:
    print(i)

'''
輸出以下:
(0, 'q')
(1, 'w')
(2, 'e')
(3, 'r')
'''

a=["w","a","s","d"]
#這裏加了個參數2，表明的是start的值
c=enumerate(a,2)
for i in c:
    print(i)
'''
輸出以下：
(2, 'w')
(3, 'a')
(4, 's')
(5, 'd')
'''

a=["q","w","e","r"]
#建立一個空字典
b=dict()
#這裏i表示的是索引，item表示的是它的值
for i,item in enumerate(a):
    b[i]=item
print(b)   #輸出 {0: 'q', 1: 'w', 2: 'e', 3: 'r'}

for i,j in enumerate('abc'):
    print(i,j)
#輸出結果
# 0 a
# 1 b
# 2 c

18.eval()函數

'''
eval() 函數用來執行一個字符串表達式，並返回表達式的值。
語法
如下是 eval() 方法的語法:
eval(expression[, globals[, locals]])
參數
expression -- 表達式。
globals -- 變量做用域，全局命名空間，若是被提供，則必須是一個字典對象。
locals -- 變量做用域，局部命名空間，若是被提供，能夠是任何映射對象。
返回值
返回表達式計算結果。
'''
x=7
print(eval('3*x'))        #返回 21
print(eval('pow(2,2)'))   #返回 4
print(eval('3+5'))        #返回 8


#eval函數還能夠實現list、dict、tuple與str之間的轉化

#1.字符串轉換成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a))         #返回  <class 'str'>
b = eval(a)
print(type(b))         #返回  <class 'list'>
print(b)               #輸出  [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

#2.字符串轉換成字典
a = "{1: 'a', 2: 'b'}"
print(type(a))        #返回  <class 'str'>
b = eval(a)
print(type(b))        #返回  <class 'dict'>
print(b)              #輸出  {1: 'a', 2: 'b'}

#3.字符串轉換成元組
a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
print(type(a))        #返回 <class 'str'>
b=eval(a)
print(type(b))        #返回 <class 'tuple'>
print(b)              #輸出 ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))

19.exec()函數

'''
函數的做用：
動態執行python代碼。也就是說exec能夠執行復雜的python代碼，而不像eval函數那樣只能計算一個表達式的值。
exec(source, globals=None, locals=None, /)
source：必選參數，表示須要被指定的python代碼。它必須是字符串或code對象。若是source是一個字符串，該字符串會先被解析爲一組python語句，而後執行。若是source是一個code對象，那麼它只是被簡單的執行。
返回值：
exec函數的返回值永遠爲None。

eval()函數和exec()函數的區別：
eval()函數只能計算單個表達式的值，而exec()函數能夠動態運行代碼段。
eval()函數能夠有返回值，而exec()函數返回值永遠爲None。
'''

x = 10
def func():
    y = 20
    a = exec("x+y")
    print("a:",a)         #輸出  a: None
    b = exec("x+y",{"x":1,"y":2})
    print("b:",b)         #輸出  b: None
    c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4})
    print("c:",c)         #輸出  c: None
    d = exec("print(x,y)")
    print("d:",d)         #輸出  d: None
func()



x = 10
expr = """
z = 30
sum = x + y + z   #一大包代碼
print(sum)
"""
def func():
    y = 20
    exec(expr)   #10+20+30       輸出60
    exec(expr,{'x':1,'y':2}) #30+1+2         輸出 33
    exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是定義全局變量1，y是局部變量  輸出34

func()

#參考原博客 https://www.cnblogs.com/yangmingxianshen/p/7810496.html

20.filter()函數

'''
filter() 函數是一個對於可迭代對象的過濾器，過濾掉不符合條件的元素，
返回的是一個迭代器，若是要轉換爲列表，可使用 list() 來轉換。
該函數接收兩個參數，第一個爲函數的引用或者None，第二個爲可迭代對象，
可迭代對象中的每一個元素做爲參數傳遞給函數進行判，而後返回 True 或 False，最後將返回 True 的元素放到迭代器中
下面看下fiter()的用法：
'''

my_list=[1,2,'',3,4,'6',' ']
new_list=list(filter(None,my_list))
print(new_list)
#None 函數 過濾掉'' 而不是過濾掉空字符串

def is_oushu(x):
    return x%2==0
new_list=list(filter(is_oushu,list(range(1,11))))
print(new_list)
#過濾掉不是偶數的數

a=[1,2,3,4,5,6,2,2,2,]
print(list(filter(lambda x:x!=2,a)))
#篩選出列表裏全部的不是 2  的元素

21.float()函數

'''
描述
float() 函數用於將整數和字符串轉換成浮點數。
語法
float()方法語法：
class float([x])
參數
x -- 整數或字符串
返回值
返回浮點數。
'''
print(float(1))            #輸出  1.0
print(float(112.0))        #輸出  112.0
print(float('123'))        #輸出  123.0
print(float(True))         #輸出  1.0
print(float(False))        #輸出  0.0

#print(float('a'))
#報錯 ValueError: could not convert string to float: 'a'

#能夠參考博客 https://blog.csdn.net/TCatTime/article/details/82932818

22.format()函數

'''
自python2.6開始，新增了一種格式化字符串的函數str.format()，此函數能夠快速處理各類字符串。
語法
它經過{}和:來代替%。
請看下面的示例，基本上總結了format函數在python的中全部用法
'''
#經過位置
print ('{0},{1}'.format('chuhao',20))
#chuhao,20
print ('{},{}'.format('chuhao',20))
#chuhao,20
print ('{1},{0},{1}'.format('chuhao',20))
#20,chuhao,20
#經過關鍵字參數
print ('{name},{age}'.format(age=18,name='chuhao'))
#chuhao,18
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return 'This guy is {self.name},is {self.age} old'.format(self=self)

print (str(Person('chuhao',18)))       #This guy is chuhao,is 18 old

#經過映射 list
a_list = ['chuhao',20,'china']
print ('my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list))
#my name is chuhao,from china,age is 20

#經過映射 dict
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print ('my name is {name}, age is {age},from {province}'.format(**b_dict))
#my name is chuhao, age is 20,from shanxi

#填充與對齊
print ('{:>8}'.format('189'))
#     189
print ('{:0>8}'.format('189'))
#00000189
print ('{:a>8}'.format('189'))
#aaaaa189

#精度與類型f
#保留兩位小數
print ('{:.2f}'.format(321.33345))
#321.33

#用來作金額的千位分隔符
print ('{:,}'.format(1234567890))
#1,234,567,890

#其餘類型 主要就是進制了，b、d、o、x分別是二進制、十進制、八進制、十六進制。

print ('{:b}'.format(18)) #二進制 10010
print ('{:d}'.format(18)) #十進制 18
print ('{:o}'.format(18)) #八進制 22
print ('{:x}'.format(18)) #十六進制12



#參考博客 https://www.cnblogs.com/gide/p/6955895.html

23.frozenset()函數

'''
描述
frozenset() 返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。
語法
frozenset() 函數語法：
class frozenset([iterable])
參數
iterable -- 可迭代的對象，好比列表、字典、元組等等。
返回值
返回新的 frozenset 對象，若是不提供任何參數，默認會生成空集合。
'''

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

b=frozenset('ltftyut1234')
print(b)
#輸出  frozenset({'2', '4', 't', 'f', '1', '3', 'l', 'y', 'u'})

# 1 frozenset([iterable])
# 2 set和frozenset最本質的區別是前者是可變的，後者是不可變的。當集合對象會被改變時（例如刪除，添加元素），只能使用set，
# 3 通常來講使用fronzet的地方均可以使用set。
# 4 參數iterable：可迭代對象。

24.getattr()函數

'''
描述：
getattr()函數用於返回一個對象屬性值
語法：
getattr(object,name,default)
參數：
object--對象
name--字符串，對象屬性
default--默認返回值，若是不提供該參數，在沒有對應屬性時，將觸發AttributeError。
返回值：
返回對象屬性值
'''

class People():
    sex='男'
    def __init__(self,name):
        self.name=name
    def peopleinfo(self):
        print('歡迎%s訪問'%self.name)

obj=getattr(People,'sex')
print(obj)       #返回值  男

#obj=getattr(People,'sexage')
#print(obj)
'''
報錯。。。
Traceback (most recent call last):
  File "G:/pythonAI/Python_funs/getattr函數詳解.py", line 24, in <module>
    obj=getattr(People,'sexage')
AttributeError: type object 'People' has no attribute 'sexage'
'''

obj=getattr(People,'sexage',None)
print(obj)    #返回值 None

25.globals() 函數

'''
描述
globals() 函數會以字典類型返回當前位置的所有全局變量。
語法
globals() 函數語法：
globals()
參數
無
返回值
返回全局變量的字典
'''
a='ltftyut1234'
print(globals()) # globals 函數返回一個全局變量的字典，包括全部導入的變量。
#  {'__name__': '__main__', '__doc__': '\n描述\nglobals() 函數會以字典類型返回當前位置的所有全局變量。\n語法\nglobals() 函數語法：\nglobals()\n參數\n無\n返回值\n返回全局變量的字典\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C5A50FB4E0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'G:/pythonAI/Python_funs/globals函數詳解.py', '__cached__': None, 'a': 'ltftyut1234'}



def zero_promo():
    return 0

def one_promo():
    return 1

def two_promo():
    return 2

def hello():
    print("Hello")

if __name__ == '__main__':
    promos = [name for name in globals()if name.endswith("_promo")]
    print(promos)   #輸出 ['zero_promo', 'one_promo', 'two_promo']

    promos = [globals()[name] for name in globals() if name.endswith("_promo")]
    print(promos[0]())    #輸出 0  調用了第一個函數

#參考博客  https://www.jianshu.com/p/a9f583d8cbaa

26.hasattr()函數

'''
hasattr()函數用於判斷是否包含對應的屬性
語法：
hasattr(object,name)
參數：
object--對象
name--字符串，屬性名
返回值：
若是對象有該屬性返回True，不然返回False
'''

class People():
    sex='男'
    def __init__(self,name):
        self.name=name
    def peopleinfo(self):
        print('歡迎%s訪問'%self.name)

obj=People('zhangsan')
print(hasattr(People,'sex'))    #輸出 True
print('sex'in People.__dict__)  #輸出 True

print(hasattr(obj,'peopleinfo'))  #輸出 True
print(People.__dict__)
#輸出 {'__module__': '__main__', 'sex': '男', '__init__': <function People.__init__ at 0x0000019931C452F0>, 'peopleinfo': <function People.peopleinfo at 0x0000019931C45378>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

27.hash()函數

'''
描述
hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。
語法
hash 語法：
hash(object)
參數說明：
object -- 對象；
返回值
返回對象的哈希值。
'''

print(hash('test'))      #輸出 -2950866779904704330   會改變的
print(hash(1))              #數字  輸出 1
print(hash(str([1,2,3])))      # 集合   輸出 -6217131644886971364
print(hash(str(sorted({'1':1})))) # 字典   輸出 -6233802074491902648

'''
hash() 函數能夠應用於數字、字符串和對象，不能直接應用於 list、set、dictionary。
在 hash() 對對象使用時，所得的結果不只和對象的內容有關，還和對象的 id()，也就是內存地址有關。
'''
class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))

'''
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
'''

'''
hash() 函數的用途
hash() 函數的對象字符無論有多長，返回的 hash 值都是固定長度的，
也用於校驗程序在傳輸過程當中是否被第三方（木馬）修改，
若是程序（字符）在傳輸過程當中被修改hash值即發生變化，
若是沒有被修改，則 hash 值和原始的 hash 值吻合，
只要驗證 hash 值是否匹配便可驗證程序是否帶木馬（病毒）。
'''

name1='正常程序代碼'
name2='正常程序代碼帶病毒'
print(hash(name1)) # 2403189487915500087
print(hash(name2)) # -8751655075885266653

28.hex() 函數

'''
描述
hex() 函數將一個整數轉換成十六進制字符串。
語法
hex 語法：
hex(x)
參數說明：
x -- 整數。
返回值
返回十六進制字符串。
'''
print(hex(12))          #輸出12的八進制 0xc
print(hex(-120))        #輸出-12的二進制 -0x78
print(type(hex(12)))    #輸出oct(12) 的類型 <class 'str'> 因此不能直接計算

print(int(hex(10),base=16)+int(hex(15),base=16))  #輸出 25

#base 參數不可爲空 爲空默認參數爲10進制 會報錯 ValueError: invalid literal for int() with base 10: '0b1010'

#固然了，參數不只能夠接受十進制整數，八進制、十六進制也是能夠的，只要是int型數據就合法。

print(hex(0b10010))    #輸出0x12
print(hex(0o1357))     #輸出0x2ef
print(hex(0x2d9))      #輸出0x2d9

29id() 函數

'''
id() 函數用於獲取對象的內存地址。
語法
id 語法：
id([object])
參數說明：
object -- 對象。
返回值
返回對象的內存地址。
'''
str='zhangsan'
print(id(str))  #輸出 1556579882544  動態分配 id  每一次會改變

b=1
print(id(b))    #輸出 1597205568

'''
id方法的返回值就是對象的內存地址。

python2中會爲每一個出現的對象分配內存，哪怕他們的值徹底相等（注意是相等不是相同）。
如執行a=2.0，b=2.0這兩個語句時會前後爲2.0這個Float類型對象分配內存，
而後將a與b分別指向這兩個對象。因此a與b指向的不是同一對象

python3中 值相等的變量 內存同樣 以下圖所示
'''

a=10.21
b=10.21
print(id(a))       #輸出2036826247912
print(id(b))       #輸出2036826247912
print(a is b)      #輸出  True
print(a == b)      #輸出  True

'''
id 函數 涉及到 淺拷貝和深拷貝的相關知識

深copy和淺copy
深copy新建一個對象從新分配內存地址，複製對象內容。

淺copy不從新分配內存地址，內容指向以前的內存地址。
淺copy若是對象中有引用其餘的對象，若是對這個子對象進行修改，子對象的內容就會發生更改。
'''

import copy

#這裏有子對象
numbers=['1','2','3',['4','5']]
#淺copy
num1=copy.copy(numbers)
#深copy
num2=copy.deepcopy(numbers)

#直接對對象內容進行修改
num1.append('6')

#這裏能夠看到內容地址發生了偏移，增長了偏移‘6’的地址
print('numbers:',numbers)
print('numbers memory address:',id(numbers))
print('numbers[3] memory address',id(numbers[3]))
print('num1:',num1)
print('num1 memory address:',id(num1))
print('num1[3] memory address',id(num1[3]))


num1[3].append('6')

print('numbers:',numbers)
print('num1:',num1)
print('num2',num2)
'''

輸出：
numbers: ['1', '2', '3', ['4', '5']]
numbers memory address: 1556526434888
numbers memory address 1556526434952
num1: ['1', '2', '3', ['4', '5'], '6']
num1 memory address: 1556526454728
num1[3] memory address 1556526434952
numbers: ['1', '2', '3', ['4', '5', '6']]
num1: ['1', '2', '3', ['4', '5', '6'], '6']
num2 ['1', '2', '3', ['4', '5']]
'''

#參考博客 https://www.cnblogs.com/dplearning/p/5998112.html
#參考博客 https://www.cnblogs.com/JackFu/p/8014762.html

30.input() 函數

'''
Python3.x 中 input() 函數接受一個標準輸入數據，返回爲 string 類型。
注意：在 Python3.x 中 raw_input() 和 input() 進行了整合，
去除了 raw_input( )，僅保留了input( )函數，其接收任意任性輸入，
將全部輸入默認爲字符串處理，並返回字符串類型。
函數語法
input([prompt])
參數說明：
prompt: 提示信息
'''

a=input('請輸入一個數:')  #輸入 10
print(a)                 #輸出 10
print(type(a))           #輸出 <class 'str'>
#b=a+10           #報錯 TypeError: must be str, not int
b=int(a)+10       #轉換成整型
print(b)          #輸出 20

a=input('請輸入一個字符串:')      #輸入  ltf1234
print(a)                         #輸出  字符串ltf1234  可使用字符串對應的方法
print(a.split('1'))              #輸出   ['ltf', '234']  split 切割字符串 直接輸出列表

31.int()函數

'''
int([x[,radix]])
若是參數是字符串，那麼它可能包含符號和小數點。參數radix表示轉換的基數（默認是10進制）。
它能夠是[2,36]範圍內的值，或者0。若是是0，系統將根據字符串內容來解析。
若是提供了參數radix，但參數x並非一個字符串，將拋出TypeError異常；
不然，參數x必須是數值（普通整數，長整數，浮點數）。經過捨去小數點來轉換浮點數。
若是超出了普通整數的表示範圍，一個長整數被返回。
若是沒有提供參數，函數返回0。

int(x, [base])
做用：
將一個數字或base類型的字符串轉換成整數。
int(x=0)
int(x, base=10)，base缺省值爲10，也就是說不指定base的值時，函數將x按十進制處理。
注：
1. x 能夠是數字或字符串，可是base被賦值後 x 只能是字符串
2. x 做爲字符串時必須是 base 類型，也就是說 x 變成數字時必須能用 base 進製表示
'''

#1.x是數字
print(int(2.1))     #輸出 2
print(int(2e3))     #輸出 2000
#print(int(1000,2))       #出錯，base 被賦值後函數只接收字符串
#報錯 TypeError: int() can't convert non-string with explicit base

#2.x是字符串
print(int('abc12',16))    #輸出  703506
#print(int('tuifyg',16))   #出錯  tuifyg  超過0-9 abcdef 超出16進制
#報錯 ValueError: invalid literal for int() with base 16: 'tuifyg'

#3. base 可取值範圍是 2~36，囊括了全部的英文字母(不區分大小寫)，
# 十六進制中F表示15，那麼G將在二十進制中表示16，依此類推....Z在三十六進制中表示35
#print(int('FZ',16))     # 出錯，FZ不能用十六進制表示
#報錯 ValueError: invalid literal for int() with base 16: 'FZ'
print(int('FZ',36))     #  575

#4.字符串 0x 能夠出如今十六進制中，視做十六進制的符號，
# 同理 0b 能夠出如今二進制中，除此以外視做數字 0 和字母 x
print(int('0x10', 16))  # 16，0x是十六進制的符號
#print(int('0x10', 17)) # 出錯，'0x10'中的 x 被視做英文字母 x
print(int('0x10', 36))  # 42804，36進制包含字母 x


#參考博客  https://www.cnblogs.com/guyuyuan/p/6827987.html

32isinstance() 函數

'''
isinstance() 函數來判斷一個對象是不是一個已知的類型，相似 type()。
isinstance() 與 type() 區別：
type() 不會認爲子類是一種父類類型，不考慮繼承關係。
isinstance() 會認爲子類是一種父類類型，考慮繼承關係。
若是要判斷兩個類型是否相同推薦使用 isinstance()。

語法
如下是 isinstance() 方法的語法:
isinstance(object, classinfo)
參數
object -- 實例對象。
classinfo -- 能夠是直接或間接類名、基本類型或者有它們組成的元組。
返回值
若是對象的類型與參數二的類型（classinfo）相同則返回 True，不然返回 False。。
'''

a=2
print(isinstance(a,int))               #返回 True
print(isinstance(a,str))               #返回 Fasle
print(isinstance(a,(str,int,list)))    #返回 True  是元組中的一個類型 就行


class A:
    pass

class B(A):
    pass

print(isinstance(A(), A) )      # returns True
print(type(A()) == A )          # returns True
print(isinstance(B(), A))       # returns True
print(type(B()) == A)           # returns False

33.issubclass()函數

'''
描述
issubclass() 方法用於判斷參數 class 是不是類型參數 classinfo 的子類。
語法
如下是 issubclass() 方法的語法:
issubclass(class, classinfo)
參數
class -- 類。
classinfo -- 類。
返回值
若是 class 是 classinfo 的子類返回 True，不然返回 False。
'''


class A:
    pass

class B(A):
    pass

class C(A):
    pass

print(issubclass(B, A))  # 返回 True
print(issubclass(C, A))  # 返回 True
print(issubclass(C, B))  # 返回 False

#2.class參數是classinfo的子類，而且classinfo是元組
print(issubclass(C, (A, object)))                #返回  True
print(issubclass(C, (A, int, object)))           #返回  True
print(issubclass(C, (int, str)))                 #返回 False
print(issubclass(C, (int, str, type)))           #返回 False

#print(issubclass(C, (1, A)))
#報錯 TypeError: issubclass() arg 2 must be a class or tuple of classes

#參考簡書 https://www.jianshu.com/p/4c425bbdd773

34.iter() 函數

'''
描述
iter() 函數用來生成迭代器。
語法
如下是 iter() 方法的語法:
iter(object[, sentinel])
參數
object -- 支持迭代的集合對象。
sentinel -- 若是傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），此時，iter 建立了一個迭代器對象，每次調用這個迭代器對象的__next__()方法時，都會調用 object。
打開模式
返回值
迭代器對象。

1 iter(o[, sentinel])
2 返回一個iterator對象。該函數對於第一個參數的解析依賴於第二個參數。
3 若是沒有提供第二個參數，參數o必須是一個集合對象，支持遍歷功能（__iter__()方法）或支持序列功能（__getitem__()方法），
4 參數爲整數，從零開始。若是不支持這兩種功能，將處罰TypeError異常。
5 若是提供了第二個參數，參數o必須是一個可調用對象。在這種狀況下建立一個iterator對象，每次調用iterator的next()方法來無
6 參數的調用o，若是返回值等於參數sentinel，觸發StopIteration異常，不然將返回該值。
'''

lst = [1,2,3,4,5,6,7]
for i in iter(lst):
    print(i)      #輸出1,2,3,4,5,6,7


class counter:
    def __init__(self, _start, _end):
        self.start = _start
        self.end = _end
    def get_next(self):
        s = self.start
        if(self.start < self.end):
            self.start += 1
        else:
            raise StopIteration
        return s

c = counter(1, 5)
iterator = iter(c.get_next, 3)
print(type(iterator))       #返回 <class 'callable_iterator'>
for i in iterator:
    print(i)                #輸出 1  2


#參考博客 https://www.cnblogs.com/yitouniu/p/5243136.html

35.lambda()函數

'''
匿名函數lambda：是指一類無需定義標識符（函數名）的函數或子程序。
lambda 函數能夠接收任意多個參數 (包括可選參數) 而且返回單個表達式的值。

要點：
1，lambda 函數不能包含命令，

2，包含的表達式不能超過一個。

說明：必定非要使用lambda函數；任何可以使用它們的地方，均可以定義一個單獨的普通函數來進行替換。
我將它們用在須要封裝特殊的、非重用代碼上，避免令個人代碼充斥着大量單行函數。

lambda匿名函數的格式：冒號前是參數，能夠有多個，用逗號隔開，冒號右邊的爲表達式。
其實lambda返回值是一個函數的地址，也就是函數對象。
'''
def sum(x,y):
    return x+y
print(sum(4,6))

f=lambda x,y:x+y
print(f(4,6))
#這倆個例子的效果是同樣的，都是返回x+y

a=lambda x:x*x
print(a(4))  #傳入一個參數的lambda函數 返回x*x

b=lambda x,y,z:x+y*z
print(b(1,2,3))  #返回x+y*z  即1+2*3=7

#2.方法結合使用
from functools import reduce
foo=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print(list(filter(lambda x:x%3==0,foo))) #篩選x%3==0 的元素
print(list(map(lambda x:x*2+10,foo)))    #遍歷foo 每一個元素乘2+10 再輸出
print(reduce(lambda x,y:x+y,foo))        #返回每一個元素相加的和

36.len()函數

'''
描述
Python len() 方法返回對象（字符、列表、元組等）長度或項目個數。
語法
len()方法語法：
len( s )
參數
s -- 對象。
返回值
返回對象長度。
'''
str1='ltf1234'
print(len(str1))    #輸出 7

list1=[1,2,3,4,5,6,7,8]
print(len(list1))   #輸出 8

for i in range(len(list1)):
    print(i)        #依次輸出1-8

dict = {'num':777,'name':"anne"}
print(len(dict))    #輸出 2

#參考博客 https://www.cnblogs.com/101718qiong/p/7542193.html

37.list()函數

'''
list()　　列表構造函數

1 list([iterable])
2 list的構造函數。參數iterable是可選的，它能夠是序列，支持編譯的容器對象，或iterator對象。
3 該函數建立一個元素值，順序與參數iterable一致的列表。若是參數iterable是一個列表，將建立
4 列表的一個拷貝並返回，就像語句iterables[:]。
'''

list=[1,2,3,4,5,6,7,8,9]    #構建列表
print(list)                 #輸出 [1,2,3,4,5,6,7,8,9]

list.append(10)             #列表追加 10
print(list)                 #輸出 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list.insert(2,18)           #在列表索引爲2 的位置 插入 18 其他的後移
print(list)                 #輸出 [1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10]

print(list.count(1))        #輸出 列表裏1 的數量

list2=[-1,-2,-3]
list.extend(list2)          #列表追加列表
print(list)                 #輸出 [1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3]

list.remove(1)              #刪除列表裏的第一個1
print(list)                 #輸出 [2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3]

list.sort()                 #列表排序
print(list)                 #輸出 [-3, -2, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18]

list.reverse()              #列表反轉
print(list)                 #輸出 [18, 10, 9, 8, 7, 6, 5, 4, 3, 2, -1, -2, -3]

print(max(list))            #輸出列表最大值 18
print(min(list))            #輸出列表最小值 -3

list3=[1,2,3,'q','a','s']
#print(max(list3))           #報錯 >' not supported between instances of 'str' and 'int'
#print(min(list3))           #報錯 >' not supported between instances of 'str' and 'int'

38.locals() 函數

'''
locals() 函數會以字典類型返回當前位置的所有局部變量。
對於函數, 方法, lambda 函式, 類, 以及實現了 __call__ 方法的類實例, 它都返回 True。
語法
locals() 函數語法：
locals()
參數
無
返回值
返回字典類型的局部變量

1 不要修改locals()返回的字典中的內容；改變可能不會影響解析器對局部變量的使用。
2 在函數體內調用locals()，返回的是自由變量。修改自由變量不會影響解析器對變量的使用。
3 不能在類區域內返回自由變量。
'''

def test_py(arg):
    z=1
    print(locals())
test_py(6)   #輸出 {'z': 1, 'arg': 6}


def foo(arg, a):
    x = 100
    y = 'hello python!'
    for i in range(10):
        j = 1
        k = i
    print(locals())
foo(1, 2)   #輸出 {'k': 9, 'j': 1, 'i': 9, 'y': 'hello python!', 'x': 100, 'a': 2, 'arg': 1}

#參考博客 https://blog.csdn.net/sxingming/article/details/52061630

39.map()函數

'''
map()函數
map()是 Python 內置的高階函數，它接收一個函數 f 和一個 list，
並經過把函數 f 依次做用在 list 的每一個元素上，獲得一個新的 list 並返回。

例如，對於list [1, 2, 3, 4, 5, 6, 7, 8, 9]
若是但願把list的每一個元素都做平方，就能夠用map()函數：

所以，咱們只須要傳入函數f(x)=x*x，就能夠利用map()函數完成這個計算：
'''
list=[1,2,3,4,5,6,7,8,9]
def f(x):
    return x*x
list1=map(f,list)
print(list1)
for i in list1:
    print(i)

'''
注意：map()函數不改變原有的 list，而是返回一個新的 list。

利用map()函數，能夠把一個 list 轉換爲另外一個 list，只須要傳入轉換函數。

因爲list包含的元素能夠是任何類型，所以，map() 不只僅能夠處理只包含數值的 list，
事實上它能夠處理包含任意類型的 list，只要傳入的函數f能夠處理這種數據類型。

任務
假設用戶輸入的英文名字不規範，沒有按照首字母大寫，後續字母小寫的規則，
請利用map()函數，把一個list（包含若干不規範的英文名字）變成一個包含規範英文名字的
'''
def format_name(s):
    s1=s[0:1].upper()+s[1:].lower()
    return s1
names=['adam', 'LISA', 'barT']
print (map(format_name, names))  #python2 這樣寫能夠直接輸出列表
for i in map(format_name,names):
    print(i)                      #python3 得這樣寫才能夠

40.max()函數

'''
描述
max() 方法返回給定參數的最大值，參數能夠爲序列。

語法
如下是 max() 方法的語法:
max( x, y, z, .... )

參數
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。

返回值
返回給定參數的最大值。
'''

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))

'''
輸出結果：
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100
'''

#1.傳入的多個參數的最大值
print(max(1,2,3,4))  #輸出 4

#2.傳入可迭代對象時，取其元素最大值
s='12345'
print(max(s))        #輸出 5

#3.傳入命名參數key，其爲一個函數，用來指定取最大值的方法

s = [
    {'name': 'sumcet', 'age': 18},
    {'name': 'bbu', 'age': 11}
]
a = max(s, key=lambda x: x['age'])
print(a)        #輸出 {'name': 'sumcet', 'age': 18}

41.min()函數

'''
描述
min() 方法返回給定參數的最小值，參數能夠爲序列。

語法
如下是 min() 方法的語法:
min( x, y, z, .... )

參數
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。

返回值
返回給定參數的最小值。
'''

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))

'''
輸出結果
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400
'''

#1.傳入的多個參數的最小值
print(min(1,2,3,4))  #輸出 1

#2.傳入可迭代對象時，取其元素最小值
s='12345'
print(min(s))        #輸出 1

#3.傳入命名參數key，其爲一個函數，用來指定取最小值的方法

s = [
    {'name': 'sumcet', 'age': 18},
    {'name': 'bbu', 'age': 11}
]
a = min(s, key=lambda x: x['age'])
print(a)        #輸出 {'name': 'bbu', 'age': 11}

42.next()函數

'''
描述
next() 返回迭代器的下一個項目。
語法
next 語法：
next(iterator[, default])
參數說明：
iterator -- 可迭代對象
default -- 可選，用於設置在沒有下一個元素時返回該默認值，若是不設置，又沒有下一個元素則會觸發 StopIteration 異常。
返回值
返回對象幫助信息。
'''

# 首先得到Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 得到下一個值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break

a=iter('abcde')
print(next(a))    #輸出 a
print(next(a))    #輸出 b
print(next(a))    #輸出 c
print(next(a))    #輸出 d
print(next(a))    #輸出 e
#print(next(a))    #報錯 StopIteration

#函數能夠接收一個可選的default參數，傳入default參數後，
# 若是可迭代對象還有元素沒有返回，則依次返回其元素值，若是全部元素已經返回，
# 則返回default指定的默認值而不拋出StopIteration 異常。

print(next(a,'e'))   #此次不報錯了 返回 e 即default參數

#參考博客  http://www.cnblogs.com/sesshoumaru/p/6037922.html

43.oct() 函數

'''
描述
oct() 函數將一個整數轉換成八進制字符串。
語法
oct 語法：
oct(x)
參數說明：
x -- 整數。
返回值
返回八進制字符串。
'''

print(oct(12))          #輸出12的八進制 0o14
print(oct(-120))        #輸出-12的二進制 -0o170
print(type(oct(12)))    #輸出oct(12) 的類型 <class 'str'> 因此不能直接計算

print(int(oct(10),base=8)+int(oct(15),base=8))  #輸出 25

#base 參數不可爲空 爲空默認參數爲10進制 會報錯 ValueError: invalid literal for int() with base 10: '0b1010'

#固然了，參數不只能夠接受十進制整數，八進制、十六進制也是能夠的，只要是int型數據就合法。

print(oct(0b10010))    #輸出0o22
print(oct(0o1357))     #輸出0o1357
print(oct(0x2d9))      #輸出0o1331

44.open() 函數

'''
python open() 函數用於打開一個文件，建立一個 file 對象，相關的方法才能夠調用它進行讀寫。
更多文件操做可參考：Python 文件I/O。
函數語法
open(name[, mode[, buffering]])
參數說明：
name : 一個包含了你要訪問的文件名稱的字符串值。
mode : mode 決定了打開文件的模式：只讀，寫入，追加等。全部可取值見以下的徹底列表。這個參數是非強制的，默認文件訪問模式爲只讀(r)。
buffering : 若是 buffering 的值被設爲 0，就不會有寄存。若是 buffering 的值取 1，訪問文件時會寄存行。若是將 buffering 的值設爲大於 1 的整數，代表了這就是的寄存區的緩衝大小。若是取負值，寄存區的緩衝大小則爲系統默認。
不一樣模式打開文件的徹底列表：
模式
描述
r
以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
rb
以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。
r+
打開一個文件用於讀寫。文件指針將會放在文件的開頭。
rb+
以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。
w
打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。
wb
以二進制格式打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。
w+
打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。
wb+
以二進制格式打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。
a
打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
ab
以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
a+
打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。
ab+
以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。
file 對象方法
file.read([size])：size 未指定則返回整個文件，若是文件大小 >2 倍內存則有問題，f.read()讀到文件尾時返回""(空字串)。
file.readline()：返回一行。
file.readlines([size]) ：返回包含size行的列表, size 未指定則返回所有行。
for line in f: print line ：經過迭代器訪問。
f.write("hello\n")：若是要寫入字符串之外的數據,先將他轉換爲字符串。
f.tell()：返回一個整數,表示當前文件指針的位置(就是到文件頭的比特數)。
f.seek(偏移量,[起始位置])：用來移動文件指針。
偏移量: 單位爲比特，可正可負
起始位置: 0 - 文件頭, 默認值; 1 - 當前位置; 2 - 文件尾
f.close() 關閉文件


open(filename [, mode [, bufsize]])
打開一個文件，返回一個file對象。 若是文件沒法打開，將處罰IOError異常。
應該使用open()來代替直接使用file類型的構造函數打開文件。
參數filename表示將要被打開的文件的路徑字符串；
參數mode表示打開的模式，最經常使用的模式有：'r'表示讀文本，'w'表示寫文本文件，'a'表示在文件中追加。
Mode的默認值是'r'。
當操做的是二進制文件時，只要在模式值上添加'b'。這樣提升了程序的可移植性。
可選參數bufsize定義了文件緩衝區的大小。0表示不緩衝；1表示行緩衝；任何其餘正數表示使用該大小的緩衝區；
負數表示使用系統默認緩衝區大小，對於tty設備它每每是行緩衝，而對於其餘文件每每徹底緩衝。若是參數值被省卻。
使用系統默認值。
'''

f=open('1.txt','r',encoding='utf-8')
print(f.read())
'''
輸出...
ltf
zhongguo
shanxi
yuncheng
男
20
'''

#參考博客 https://www.cnblogs.com/Devilf/p/8006663.html

45.ord() 函數

'''
描述
ord() 函數是 chr() 函數（對於8位的ASCII字符串）或 unichr() 函數（對於Unicode對象）的配對函數，它以一個字符（長度爲1的字符串）做爲參數，返回對應的 ASCII 數值，或者 Unicode 數值，若是所給的 Unicode 字符超出了你的 Python 定義範圍，則會引起一個 TypeError 的異常。
語法
如下是 ord() 方法的語法:
ord(c)
參數
c -- 字符。
返回值
返回值是對應的十進制整數。
'''

print(ord('a'))    #輸出97
print(ord('b'))    #輸出98
print(ord('c'))    #輸出99

print(ord(']'))    #輸出93
print(ord('8'))    #輸出56

#其實要是有一張表就行了 哈哈哈哈

46.pow()函數

'''
描述
pow() 方法返回 xy（x的y次方） 的值。

語法
如下是 math 模塊 pow() 方法的語法:
import math

math.pow( x, y )
內置的 pow() 方法
pow(x, y[, z])
函數是計算x的y次方，若是z在存在，則再對結果進行取模，其結果等效於pow(x,y) %z
注意：pow() 經過內置的方法直接調用，內置方法會把參數做爲整型，而 math 模塊則會把參數轉換爲 float。

參數
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。

返回值
返回 xy（x的y次方） 的值。
'''

import math  # 導入 math 模塊

print("math.pow(100, 2) : ", math.pow(100, 2))
# 使用內置，查看輸出結果區別
print("pow(100, 2) : ", pow(100, 2))

print("math.pow(100, -2) : ", math.pow(100, -2))
print("math.pow(2, 4) : ", math.pow(2, 4))
print("math.pow(3, 0) : ", math.pow(3, 0))

'''
輸出結果...
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
'''

47.property() 函數

'''
描述
property() 函數的做用是在新式類中返回屬性值。
語法
如下是 property() 方法的語法:
class property([fget[, fset[, fdel[, doc]]]])
參數
fget -- 獲取屬性值的函數
fset -- 設置屬性值的函數
fdel -- 刪除屬性值函數
doc -- 屬性描述信息
返回值
返回新式類屬性
'''


class C(object):
    def __init__(self):
        self._x = None
    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")


class Parrot(object):
    def __init__(self):
        self._voltage = 100000
    #裝飾器寫法
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage


class D(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

48.range() 函數

'''
python range() 函數可建立一個整數列表，通常用在 for 循環中。
函數語法
range(start, stop[, step])
參數說明：
start: 計數從 start 開始。默認是從 0 開始。例如range（5）等價於range（0， 5）;
stop: 計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
step：步長，默認爲1。例如：range（0， 5） 等價於 range(0, 5, 1)

'''

for i in range(10):
    print(i)  #輸出 從0-9

for i in range(0,11,2):
    print(i)  #輸出 0,2,4,6,8,10

for i in range(0,-10,-3):
    print(i)  #輸出 0,-3,-6,-9

list=[]
for i in range(5,-5,-1):
    list.append(i)
print(list)   #輸出 [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

for i in 'ahfgohiauf':
    print(i)   #依次輸出字符

#參考博客 https://www.cnblogs.com/101718qiong/p/7542193.html

49.reduece()函數

'''
在python3中若是使用reduce須要先導入

from functools import reduce

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

reduce函數的定義：
reduce(function, sequence [, initial] ) -> value
function參數是一個有兩個參數的函數，reduce依次從sequence中取一個元素，
和上一次調用function的結果作參數再次調用function。
第一次調用function時，若是提供initial參數，
會以sequence中的第一個元素和initial做爲參數調用function，
不然會以序列sequence中的前兩個元素作參數調用function。
'''

from functools import reduce
lst=[1,2,3,4,5,6]
def f(x,y):
    return x+y
print(reduce(f,lst))

'''
過程1+2+3+4+5+6=21
'''

print(reduce(lambda x,y:x*y,lst))
# 運行過程爲1*2*3*4*5*6=720

#來個稍微複雜的
print(reduce(lambda x,y:x*y+1,lst))

'''
運算步驟：1*2+1=3
         3*3+1=10
         10*4+1=41
         41*5+1=206
         206*6+1=1237
'''

#再說說有初始化值的狀況, 這個時候就不是取列表的前兩項, 而是取初始值爲第一個,
# 序列的第一個元素爲第二個元素,開始進行lambda函數的應用計算.
print(reduce(lambda x,y:x+y,lst,5))

'''
計算步驟：5+1=6
         6+2=8
         8+3=11
         11+4=15
         15+5=20
         20+6=26
'''

50.repr()函數

'''
描述
repr() 函數將對象轉化爲供解釋器讀取的形式。
語法
如下是 repr() 方法的語法:
repr(object)
參數
object -- 對象。
返回值
返回一個對象的 string 格式。
'''

s='qwerasdf'
print(s)            #輸出  qwerasdf
print(repr(s))      #輸出  'qwerasdf'

dict={'a':1,'b':2}
print(dict)         #輸出 {'a': 1, 'b': 2}
print(repr(dict))   #輸出 {'a': 1, 'b': 2}  沒改變麼

print(repr([0,1,2,3,4]))         #輸出 [0, 1, 2, 3, 4]
print(repr('hello'))             #輸出 'hello'

print(str(1.0/7.0))              #輸出 0.14285714285714285
print(repr(1.0/7.0))             #輸出 0.14285714285714285

51.reversed() 函數

'''
描述
reversed 函數返回一個反轉的迭代器。

語法
如下是 reversed 的語法:
reversed(seq)
參數
seq -- 要轉換的序列，能夠是 tuple, string, list 或 range。
返回值
返回一個反轉的迭代器。

1 reversed(seq)
2 返回一個逆序的iterator對象。參數seq必須是一個包含__reversed__()方法的對象或支持序列操做(__len__()和__getitem__())
3 該函數是2.4中新增的
'''

str='wasdqwer'
print(list(reversed(str)))      #輸出 ['r', 'e', 'w', 'q', 'd', 's', 'a', 'w']

tuple=('r', 'e', 'w', 'q', 'd', 's', 'a', 'w')
print(list(reversed(tuple)))    #輸出 ['w', 'a', 's', 'd', 'q', 'w', 'e', 'r']

seqRange = range(5, 9)
print(list(reversed(seqRange)))  #輸出 [8, 7, 6, 5]

seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))   #輸出 [5, 3, 4, 2, 1]

a=[1,2,3,4,5,6]
b=reversed(a)
print(b)                #輸出  <list_reverseiterator object at 0x0000023E2A448748>  顯示爲一個迭代器
print(list(b))          #輸出  [6, 5, 4, 3, 2, 1]
print(list(b))          #輸出  []

#由此可知：reversed（）返回的是一個迭代器對象，只能進行一次循環遍歷。顯示一次所包含的值！

52.round()函數

'''
描述
round() 方法返回浮點數x的四捨五入值。

語法
如下是 round() 方法的語法:
round( x [, n]  )

參數
x -- 數字表達式。
n -- 表示從小數點位數，其中 x 須要四捨五入，默認值爲 0。

返回值
返回浮點數x的四捨五入值。
'''

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

'''
輸出結果...
round(70.23456) :  70
round(56.659,1) :  56.7
round(80.264, 2) :  80.26
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
'''

53.setattr()函數

'''
描述：
setattr函數，用於設置屬性值，該屬性必須存在
語法：
setattr(object,name,value)
參數：
object--對象
name--字符串，對象屬性
value--屬性值
返回值：
無
'''

class People():
    sex='男'
    def __init__(self,name):
        self.name=name
    def peopleinfo(self):
        print('歡迎%s訪問'%self.name)

obj=People('zhangsan')
setattr(People,'x',123)
print(People.x)  #等同於 Peopel.x=123

setattr(obj,'age',18)
print(obj.__dict__)   #輸出 {'name': 'zhangsan', 'age': 18}

print(People.__dict__)
#輸出
#{'__module__': '__main__', 'sex': '男', '__init__': <function People.__init__ at 0x00000259A92752F0>, 'peopleinfo': <function People.peopleinfo at 0x00000259A9275378>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, 'x': 123}

54.set() 函數

'''
描述
set() 函數建立一個無序不重複元素集，可進行關係測試，刪除重複數據，還能夠計算交集、差集、並集等。
語法
set 語法：
class set([iterable])
參數說明：
iterable -- 可迭代對象對象；
返回值
返回新的集合對象。
'''

a=set('www.baidu.com')
b=set('www.gogle.com')      #重複的元素被刪除 元素惟一 能夠用來去重
print(a)                    #輸出   {'u', '.', 'm', 'c', 'w', 'd', 'i', 'a', 'o', 'b'}
print(b)                    #輸出   {'.', 'm', 'e', 'c', 'w', 'o', 'l', 'g'}

print(a&b)                  #交集 {'m', 'c', 'w', '.', 'o'}
print(a|b)                  #並集 {'m', 'c', 'i', 'w', 'b', 'd', 'u', 'g', 'e', 'a', '.', 'o', 'l'}
print(a-b)                  #差集 {'i', 'b', 'd', 'u', 'a'}


#1.比較
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值
print(temp1)        #{33, 11}
print(se)        #{33, 11, 22}

temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆蓋掉se
print(temp2)        #None
print(se)           #{33, 11},


#2.刪除
se = {11, 22, 33}
se.discard(11)
se.discard(44)  # 移除不存的元素不會報錯
print(se)

se = {11, 22, 33}
se.remove(11)
#se.remove(44)  # 移除不存的元素會報錯
print(se)

se = {11, 22, 33}  # 移除末尾元素並把移除的元素賦給新值
temp = se.pop()
print(temp)  # 33
print(se) # {11, 22}


#3.取交集
se = {11, 22, 33}
be = {22, 55}

temp1 = se.intersection(be)             #取交集，賦給新值
print(temp1)  # 22
print(se)  # {11, 22, 33}

temp2 = se.intersection_update(be)      #取交集並更新本身
print(temp2)  # None
print(se)  # 22


#4.判斷
se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判斷是否不存在交集（有交集False，無交集True）
print(se.issubset(be))          #False，判斷se是不是be的子集合
print(se.issuperset(be))        #True，判斷se是不是be的父集合


#5.合併
se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合併不一樣項，並賦新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合併不一樣項，並更新本身
print(temp2)    #None
print(se)             #{33, 11}

#6.取並集

se = {11, 22, 33}
be = {22,44,55}

temp=se.union(be)   #取並集，並賦新值
print(se)       #{33, 11, 22}
print(temp)     #{33, 22, 55, 11, 44}


#7.更新
se = {11, 22, 33}
be = {22,44,55}

se.update(be)  # 把se和be合併，得出的值覆蓋se
print(se)
se.update([66, 77])  # 可增長迭代項
print(se)


#8.集合的轉換
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))        #輸出 [0, 1, 2, 3] <class 'list'>
print(tu,type(tu))        #輸出 [0, 1, 2, 3] <class 'tuple'>
print(st,type(st))        #輸出 [0, 1, 2, 3] <class 'str'>


#參考博客  https://www.cnblogs.com/whatisfantasy/p/5956775.html

55.slice() 函數

'''
描述
slice() 函數實現切片對象，主要用在切片操做函數裏的參數傳遞。
語法
slice 語法：
class slice(stop)
class slice(start, stop[, step])
參數說明：
start -- 起始位置
stop -- 結束位置
step -- 間距
返回值
返回一個切片對象。
實例
'''

myslice=slice(5)      #設置一個 截取五個元素的切片
print(myslice)        #輸出 slice(None, 5, None)

arr=list(range(10))
print(arr)            #輸出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(arr[myslice])   #輸出 [0, 1, 2, 3, 4]

print(arr[3:6])       #輸出 [3, 4, 5]

56.sorted() 函數

'''
描述
sorted() 函數對全部可迭代的對象進行排序操做。
sort 與 sorted 區別：
sort 是應用在 list 上的方法，sorted 能夠對全部可迭代的對象進行排序操做。
list 的 sort 方法返回的是對已經存在的列表進行操做，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操做。
語法
sorted 語法：
sorted(iterable, key=None, reverse=False)
參數說明：
iterable -- 可迭代對象。
key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。
返回值
返回從新排序的列表。
'''

print(sorted([2,3,4,1,5,6]))          #輸出 [1, 2, 3, 4, 5, 6]

#另外一個區別在於list.sort() 方法只爲 list 定義。而 sorted() 函數能夠接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))      #輸出  [1, 2, 3, 4, 5]

#利用key進行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)                   #輸出  [7, 6, 5, 4, 3, 2, 1, 0]

#要進行反向排序，也經過傳入第三個參數 reverse=True：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list=sorted(example_list, reverse=True)
print(result_list)                   #輸出 [7, 6, 5, 4, 3, 2, 1, 0]

#sorted 的應用，也能夠經過 key 的值來進行數組/字典的排序，好比
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)                         #輸出 [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

57.staticmethod()函數

'''
python staticmethod 返回函數的靜態方法。
該方法不強制要求傳遞參數，以下聲明一個靜態方法：
class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
        ...
以上實例聲明瞭靜態方法 f，類能夠不用實例化就能夠調用該方法 C.f()，固然也能夠實例化後調用 C().f()。
函數語法
staticmethod(function)
參數說明：
無
'''

class C(object):
    @staticmethod
    def f():
        print('hello world')
C.f()               # 靜態方法無需實例化
cobj = C()
cobj.f()            # 也能夠實例化後調用



class A(object):
    def foo(self, x):
        print("executing foo(%s,%s)" % (self, x))
        print('self:', self)
    @classmethod
    def class_foo(cls, x):
        print("executing class_foo(%s,%s)" % (cls, x))
        print('cls:', cls)
    @staticmethod
    def static_foo(x):
        print("executing static_foo(%s)" % x)
a = A()
print(a.foo)               #輸出 <bound method A.foo of <__main__.A object at 0x000001B5B2A51D30>>
print(a.class_foo)         #輸出 <bound method A.class_foo of <class '__main__.A'>>
print(a.static_foo)        #輸出 <function A.static_foo at 0x000001B5B2A55598>

#參考博客 https://www.cnblogs.com/elie/p/5876210.html

58.str() 函數

'''
描述
str() 函數將對象轉化爲適於人閱讀的形式。
語法
如下是 str() 方法的語法:
class str(object='')
參數
object -- 對象。
返回值
返回一個對象的string格式。
'''

print(str(1))             #輸出  字符串1
print(type(str(1)))       #輸出  <class 'str'>
print(str(b'\xe5\xbc\xa0\xe4\xb8\x89',encoding='utf-8'))  #輸出張三

dict={'zhangsan':'zhang1234','lisi':'li1234'}
print(type(dict))         #輸出  <class 'dict'>
a=str(dict)
print(str(dict))          #輸出  字符串 {'zhangsan': 'zhang1234', 'lisi': 'li1234'}
print(type(a))            #輸出  <class 'str'>

59.sum()函數

'''
描述
sum() 方法對系列進行求和計算。
語法
如下是 sum() 方法的語法:
sum(iterable[, start])
參數
iterable -- 可迭代對象，如：列表、元組、集合。
start -- 指定相加的參數，若是沒有設置這個值，默認爲0。
返回值
返回計算結果
'''

print(sum([0,1,2]))              # 列表總和 3
print(sum((2,3,4),1))            # 元組計算總和後再加 1
print(sum([2,3,4,5,6],8))        # 列表計算總和後再加 2

a = list(range(1,11))
b = list(range(1,10))
c = sum([item for item in a if item in b])
print(c)                         #輸出 45

60.vars() 函數

'''
描述
vars() 函數返回對象object的屬性和屬性值的字典對象。
語法
vars() 函數語法：
vars([object])
參數
object -- 對象
返回值
返回對象object的屬性和屬性值的字典對象，若是沒有參數，就打印當前調用位置的屬性和屬性值 相似 locals()。
'''

print(vars())
#輸出 {'__name__': '__main__', '__doc__': '\n描述\nvars() 函數返回對象object的屬性和屬性值的字典對象。\n語法\nvars() 函數語法：\nvars([object])\n參數\nob

class A:
    a=1
    __dict__ = 'ltf'
print(vars(A))
#輸出 {'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

a=A()
print(vars(a))
#輸出 ltf

print(a.__dict__)
#輸出 ltf

61.zip()函數

#zip函數接受任意多個可迭代對象做爲參數,將對象中對應的元素打包成一個tuple,而後返回一個可迭代的zip對象.
#這個可迭代對象可使用循環的方式列出其元素
#若多個可迭代對象的長度不一致,則所返回的列表與長度最短的可迭代對象相同.

#1.用列表生成zip對象
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
h=['a','b','c','d']
zip1=zip(x,y,z)
print(zip1)
for i in zip1:
    print(i)

zip2=zip(x,y,h)
for i in zip2:
    print(i)

zip3=zip(h)
for i in zip3:
    print(i)

zip4=zip(*h*3)
for i in zip4:
    print(i) #這是幹啥喲。。

print('==*=='*10)
#2.二維矩陣變換
l1=[[1,2,3],[4,5,6],[7,8,9]]
print(l1)
print([[j[i] for j in l1] for i in range(len(l1[0])) ])
zip5=zip(*l1)
for i in zip5:
    print(i)