''' abs() 函數(shù)返回?cái)?shù)字的絕對值。d'd'd'd 絕對值：absolutedddd 正如字面上的意思，可以返回一個絕對值 ''' 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)) ''' 運(yùn)行結(jié)果： 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函數(shù)只能輸入int型 不然會報(bào)錯 '''
''' all() 函數(shù)用于判斷給定的可迭代參數(shù) iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。 元素除了是 0、空、FALSE 外都算 TRUE。 語法 以下是 all() 方法的語法: all(iterable) 參數(shù) 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
''' any() 函數(shù)用于判斷給定的可迭代參數(shù) iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True。 元素除了是 0、空、FALSE 外都算 TRUE。 語法 以下是 any() 方法的語法: any(iterable) 參數(shù) 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
''' ascii() 函數(shù)類似 repr() 函數(shù), 返回一個表示對象的字符串, 但是對于字符串中的非 ASCII 字符則返回通過 repr() 函數(shù)使用 \x, \u 或 \U 編碼的字符。 生成字符串類似 Python2 版本中 repr() 函數(shù)的返回值。 語法 以下是 ascii() 方法的語法: ascii(object) 參數(shù) object -- 對象。 返回值 返回字符串 ''' print(ascii('uiatfu')) #報(bào)錯 SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 427-428: truncated \xXX escape #不知道為何
''' 函數(shù)原型 bin(x) 參數(shù)解釋 x 整數(shù)型，參數(shù)不可為空。 返回值 <class 'str'> 字符串類型，二進(jìn)制整數(shù)。 函數(shù)說明 將一個整數(shù)轉(zhuǎn)化為一個二進(jìn)制整數(shù)，并以字符串的類型返回。 ''' print(bin(12)) #輸出12的二進(jìn)制 0b1100 print(bin(-120)) #輸出-12的二進(jìn)制 -0b1111000 print(type(bin(12))) #輸出bin(12) 的類型 <class 'str'> 所以不能直接計(jì)算 print(int(bin(10),base=2)+int(bin(20),base=2)) #輸出 30 #base 參數(shù)不可為空 為空默認(rèn)參數(shù)為10進(jìn)制 會報(bào)錯 ValueError: invalid literal for int() with base 10: '0b1010' #當(dāng)然了，參數(shù)不僅可以接受十進(jìn)制整數(shù)，八進(jìn)制、十六進(jìn)制也是可以的，只要是int型數(shù)據(jù)就合法。 print(bin(0b10010)) #輸出0b10010 print(bin(0o1357)) #輸出0b1011101111 print(bin(0x2d9)) #輸出0b1011011001
''' 描述 bool() 函數(shù)用于將給定參數(shù)轉(zhuǎn)換為布爾類型，如果沒有參數(shù)，返回 False。 bool 是 int 的子類。 語法 以下是 bool() 方法的語法: class bool([x]) 參數(shù) x -- 要進(jìn)行轉(zhuǎn)換的參數(shù)。 返回值 返回 Ture 或 False。 ''' print(bool(0)) #返回False print(bool(1)) #返回True print(bool(True)) #返回True print(bool(False)) #返回False print(bool('')) #返回False #0,False,'', 空字符串返回Fasle
''' 描述 bytes 函數(shù)返回一個新的 bytes 對象，該對象是一個 0 <= x < 256 區(qū)間內(nèi)的整數(shù)不可變序列。 它是 bytearray 的不可變版本。 語法 以下是 bytes 的語法: class bytes([source[, encoding[, errors]]]) 參數(shù) 如果 source 為整數(shù)，則返回一個長度為 source 的初始化數(shù)組； 如果 source 為字符串，則按照指定的 encoding 將字符串轉(zhuǎn)換為字節(jié)序列； 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數(shù)； 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用于初始化 bytearray。 如果沒有輸入任何參數(shù)，默認(rèn)就是初始化數(shù)組為0個元素。 返回值 返回一個新的 bytes 對象。 將一個字符串轉(zhuǎn)換成字節(jié)類型 ''' 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'>
''' challable() 判斷對象是否可以被調(diào)用， 能被調(diào)用的對象就是一個callables對象， 比如函數(shù)和帶有__call__()的實(shí)例 ''' 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 證明自定義的函數(shù)也可以
''' 查看十進(jìn)制數(shù)對應(yīng)的ASCII碼值 描述 chr() 用一個整數(shù)作參數(shù)，返回一個對應(yīng)的字符。 語法 以下是 chr() 方法的語法: chr(i) 參數(shù) i -- 可以是 10 進(jìn)制也可以是 16 進(jìn)制的形式的數(shù)字，數(shù)字范圍為 0 到 1,114,111 (16 進(jìn)制為0x10FFFF)。 返回值 返回值是當(dāng)前整數(shù)對應(yīng)的 ASCII 字符。 ''' #print(chr(-1)) #報(bào)錯 ValueError: chr() arg not in range(0x110000) 超出范圍 不能小于0 print(chr(0x30)) #輸出 0 print(chr(97)) #輸出 a print(chr(8364)) #輸出 €
''' 描述 classmethod 修飾符對應(yīng)的函數(shù)不需要實(shí)例化，不需要 self 參數(shù)， 但第一個參數(shù)需要是表示自身類的 cls 參數(shù)，可以來調(diào)用類的屬性，類的方法，實(shí)例化對象等。 語法 classmethod 語法： classmethod 參數(shù) 無。 返回值 返回函數(shù)的類方法。 ''' class Stud: num=1 def fn1(self): print('方法一') @classmethod def fn2(cls): print('方法二') #輸出 方法二 print(cls.num) #調(diào)用類的實(shí)例化對象 cls().fn1() #調(diào)用類的方法 Stud.fn2() #輸出 方法二 不需要實(shí)例化 print('===='*10) object=Stud() object.fn1() #輸出 方法一 需要實(shí)例化
''' 描述 complex() 函數(shù)用于創(chuàng)建一個值為 real + imag * j 的復(fù)數(shù)或者轉(zhuǎn)化一個字符串或數(shù)為復(fù)數(shù)。 如果第一個參數(shù)為字符串，則不需要指定第二個參數(shù)。。 語法 complex 語法： class complex([real[, imag]]) 參數(shù)說明： real -- int, long, float或字符串； imag -- int, long, float； 返回值 返回一個復(fù)數(shù)。 ''' print(complex(1,2)) #輸出 (1+2j) print(complex(1)) #輸出 (1+0j) print(complex('2')) #輸出 (2+0j) # 注意：這個地方在'+'號兩邊不能有空格，也就是不能寫成'1 + 2j'，應(yīng)該是'1+2j'，否則會報(bào)錯 print(complex('2+3j')) #輸出 (2+3j) print(complex(1.2,3.4)) #輸出 (1.2+3.4j)
''' complie() 將字符串編譯成python能識別或可以執(zhí)行的代碼，也可以將文字讀成字符串再編譯 1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 2 將source編譯為代碼或者AST對象。代碼對象能過通過exec語句來執(zhí)行或者eval()進(jìn)行求值。 3 參數(shù)source：字符串或者AST（abstract syntax trees）對象。 4 參數(shù)filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認(rèn)的值。 5 參數(shù)model：指定編譯代碼的種類。可以指定'exec', 'eval', 'single'。 6 參數(shù)flag和dont_inherit：這兩個參數(shù)為可選參數(shù)。 ''' s='print('hello world')' r=compile(s,'hello','exec') print(r) #輸出結(jié)果： #<code object <module> at 0x000002EBD335CF60, file 'hello', line 1>
''' 描述： delattr函數(shù)用于刪除屬性 delattr(x,'foobar)相當(dāng)于del x.foobar 語法： setattr(object,name) 參數(shù)： 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()
''' 描述 dict() 函數(shù)用于創(chuàng)建一個字典。 語法 dict 語法： class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg) 參數(shù)說明： **kwargs -- 關(guān)鍵字 mapping -- 元素的容器。 iterable -- 可迭代對象。 返回值 返回一個字典。 ''' print(dict()) #創(chuàng)建空字典 dict1=dict(a='a', b='b', t='t') #傳入關(guān)鍵字 構(gòu)建字典 print(dict1) #輸出 {'a': 'a', 'b': 'b', 't': 't'} dict2=dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函數(shù)方式來構(gòu)造字典 print(dict2) #輸出 {'one': 1, 'two': 2, 'three': 3} dict3=dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代對象方式來構(gòu)造字典 print(dict3) #輸出 {'one': 1, 'two': 2, 'three': 3}
''' dir() 函數(shù)不帶參數(shù)時，返回當(dāng)前范圍內(nèi)的變量、方法和定義的類型列表；帶參數(shù)時，返回參數(shù)的屬性、方法列表。如果參數(shù)包含方法__dir__()，該方法將被調(diào)用。如果參數(shù)不包含__dir__()，該方法將最大限度地收集參數(shù)信息。 語法 dir 語法： dir([object]) 參數(shù)說明： object -- 對象、變量、類型。 返回值 返回模塊的屬性列表。 ''' print(dir()) #獲得當(dāng)前模塊的屬性列表 #輸出 ['__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 的內(nèi)存地址:', 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']
''' python divmod() 函數(shù)把除數(shù)和余數(shù)運(yùn)算結(jié)果結(jié)合起來，返回一個包含商和余數(shù)的元組(a // b, a % b)。 在 python 2.3 版本之前不允許處理復(fù)數(shù)。 函數(shù)語法 divmod(a, b) 參數(shù)說明： a: 數(shù)字 b: 數(shù)字 ''' 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)) #報(bào)錯 TypeError: can't take floor or mod of complex number.
''' enumerate是翻譯過來是枚舉的意思，看下它的方法原型： enumerate(sequence, start=0)，返回一個枚舉對象。 sequence必須是序列或迭代器iterator，或者支持迭代的對象。 enumerate()返回對象的每個元素都是一個元組， 每個元組包括兩個值，一個是計(jì)數(shù)，一個是sequence的值， 計(jì)數(shù)是從start開始的，start默認(rèn)為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'] #這里加了個參數(shù)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'] #創(chuàng)建一個空字典 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) #輸出結(jié)果 # 0 a # 1 b # 2 c
''' eval() 函數(shù)用來執(zhí)行一個字符串表達(dá)式，并返回表達(dá)式的值。 語法 以下是 eval() 方法的語法: eval(expression[, globals[, locals]]) 參數(shù) expression -- 表達(dá)式。 globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。 locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。 返回值 返回表達(dá)式計(jì)算結(jié)果。 ''' x=7 print(eval('3*x')) #返回 21 print(eval('pow(2,2)')) #返回 4 print(eval('3+5')) #返回 8 #eval函數(shù)還可以實(shí)現(xiàn)list、dict、tuple與str之間的轉(zhuǎn)化 #1.字符串轉(zhuǎn)換成列表 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.字符串轉(zhuǎn)換成字典 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.字符串轉(zhuǎn)換成元組 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))
''' 函數(shù)的作用： 動態(tài)執(zhí)行python代碼。也就是說exec可以執(zhí)行復(fù)雜的python代碼，而不像eval函數(shù)那樣只能計(jì)算一個表達(dá)式的值。 exec(source, globals=None, locals=None, /) source：必選參數(shù)，表示需要被指定的python代碼。它必須是字符串或code對象。如果source是一個字符串，該字符串會先被解析為一組python語句，然后執(zhí)行。如果source是一個code對象，那么它只是被簡單的執(zhí)行。 返回值： exec函數(shù)的返回值永遠(yuǎn)為None。 eval()函數(shù)和exec()函數(shù)的區(qū)別： eval()函數(shù)只能計(jì)算單個表達(dá)式的值，而exec()函數(shù)可以動態(tài)運(yùn)行代碼段。 eval()函數(shù)可以有返回值，而exec()函數(shù)返回值永遠(yuǎn)為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()
''' filter() 函數(shù)是一個對于可迭代對象的過濾器，過濾掉不符合條件的元素， 返回的是一個迭代器，如果要轉(zhuǎn)換為列表，可以使用 list() 來轉(zhuǎn)換。 該函數(shù)接收兩個參數(shù)，第一個為函數(shù)的引用或者None，第二個為可迭代對象， 可迭代對象中的每個元素作為參數(shù)傳遞給函數(shù)進(jìn)行判，然后返回 True 或 False，最后將返回 True 的元素放到迭代器中 下面看下fiter()的用法： ''' my_list=[1,2,'',3,4,'6',' '] new_list=list(filter(None,my_list)) print(new_list) #None 函數(shù) 過濾掉'' 而不是過濾掉空字符串 def is_oushu(x): return x%2==0 new_list=list(filter(is_oushu,list(range(1,11)))) print(new_list) #過濾掉不是偶數(shù)的數(shù) a=[1,2,3,4,5,6,2,2,2,] print(list(filter(lambda x:x!=2,a))) #篩選出列表里所有的不是 2 的元素
''' 描述 float() 函數(shù)用于將整數(shù)和字符串轉(zhuǎn)換成浮點(diǎn)數(shù)。 語法 float()方法語法： class float([x]) 參數(shù) x -- 整數(shù)或字符串 返回值 返回浮點(diǎn)數(shù)。 ''' 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')) #報(bào)錯 ValueError: could not convert string to float: 'a'
''' 自python2.6開始，新增了一種格式化字符串的函數(shù)str.format()，此函數(shù)可以快速處理各種字符串。 語法 它通過{}和:來代替%。 請看下面的示例，基本上總結(jié)了format函數(shù)在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 #通過關(guān)鍵字參數(shù) 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 #保留兩位小數(shù) print ('{:.2f}'.format(321.33345)) #321.33 #用來做金額的千位分隔符 print ('{:,}'.format(1234567890)) #1,234,567,890 #其他類型 主要就是進(jìn)制了，b、d、o、x分別是二進(jìn)制、十進(jìn)制、八進(jìn)制、十六進(jìn)制。 print ('{:b}'.format(18)) #二進(jìn)制 10010 print ('{:d}'.format(18)) #十進(jìn)制 18 print ('{:o}'.format(18)) #八進(jìn)制 22 print ('{:x}'.format(18)) #十六進(jìn)制12
''' 描述 frozenset() 返回一個凍結(jié)的集合，凍結(jié)后集合不能再添加或刪除任何元素。 語法 frozenset() 函數(shù)語法： class frozenset([iterable]) 參數(shù) iterable -- 可迭代的對象，比如列表、字典、元組等等。 返回值 返回新的 frozenset 對象，如果不提供任何參數(shù)，默認(rèn)會生成空集合。 ''' 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最本質(zhì)的區(qū)別是前者是可變的，后者是不可變的。當(dāng)集合對象會被改變時（例如刪除，添加元素），只能使用set， # 3 一般來說使用fronzet的地方都可以使用set。 # 4 參數(shù)iterable：可迭代對象。
''' 描述： getattr()函數(shù)用于返回一個對象屬性值 語法： getattr(object,name,default) 參數(shù)： object--對象 name--字符串，對象屬性 default--默認(rèn)返回值，如果不提供該參數(shù)，在沒有對應(yīng)屬性時，將觸發(fā)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) ''' 報(bào)錯。。。 Traceback (most recent call last): File 'G:/pythonAI/Python_funs/getattr函數(shù)詳解.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
''' 描述 globals() 函數(shù)會以字典類型返回當(dāng)前位置的全部全局變量。 語法 globals() 函數(shù)語法： globals() 參數(shù) 無 返回值 返回全局變量的字典 ''' a='ltftyut1234' print(globals()) # globals 函數(shù)返回一個全局變量的字典，包括所有導(dǎo)入的變量。 # {'__name__': '__main__', '__doc__': '\n描述\nglobals() 函數(shù)會以字典類型返回當(dāng)前位置的全部全局變量。\n語法\nglobals() 函數(shù)語法：\nglobals()\n參數(shù)\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函數(shù)詳解.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 調(diào)用了第一個函數(shù)
''' hasattr()函數(shù)用于判斷是否包含對應(yīng)的屬性 語法： hasattr(object,name) 參數(shù)： 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}
''' 描述 hash() 用于獲取取一個對象（字符串或者數(shù)值等）的哈希值。 語法 hash 語法： hash(object) 參數(shù)說明： object -- 對象； 返回值 返回對象的哈希值。 ''' print(hash('test')) #輸出 -2950866779904704330 會改變的 print(hash(1)) #數(shù)字 輸出 1 print(hash(str([1,2,3]))) # 集合 輸出 -6217131644886971364 print(hash(str(sorted({'1':1})))) # 字典 輸出 -6233802074491902648 ''' hash() 函數(shù)可以應(yīng)用于數(shù)字、字符串和對象，不能直接應(yīng)用于 list、set、dictionary。 在 hash() 對對象使用時，所得的結(jié)果不僅和對象的內(nèi)容有關(guān)，還和對象的 id()，也就是內(nèi)存地址有關(guān)。 ''' 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() 函數(shù)的用途 hash() 函數(shù)的對象字符不管有多長，返回的 hash 值都是固定長度的， 也用于校驗(yàn)程序在傳輸過程中是否被第三方（木馬）修改， 如果程序（字符）在傳輸過程中被修改hash值即發(fā)生變化， 如果沒有被修改，則 hash 值和原始的 hash 值吻合， 只要驗(yàn)證 hash 值是否匹配即可驗(yàn)證程序是否帶木馬（病毒）。 ''' name1='正常程序代碼' name2='正常程序代碼帶病毒' print(hash(name1)) # 2403189487915500087 print(hash(name2)) # -8751655075885266653
''' 描述 hex() 函數(shù)將一個整數(shù)轉(zhuǎn)換成十六進(jìn)制字符串。 語法 hex 語法： hex(x) 參數(shù)說明： x -- 整數(shù)。 返回值 返回十六進(jìn)制字符串。 ''' print(hex(12)) #輸出12的八進(jìn)制 0xc print(hex(-120)) #輸出-12的二進(jìn)制 -0x78 print(type(hex(12))) #輸出oct(12) 的類型 <class 'str'> 所以不能直接計(jì)算 print(int(hex(10),base=16)+int(hex(15),base=16)) #輸出 25 #base 參數(shù)不可為空 為空默認(rèn)參數(shù)為10進(jìn)制 會報(bào)錯 ValueError: invalid literal for int() with base 10: '0b1010' #當(dāng)然了，參數(shù)不僅可以接受十進(jìn)制整數(shù)，八進(jìn)制、十六進(jìn)制也是可以的，只要是int型數(shù)據(jù)就合法。 print(hex(0b10010)) #輸出0x12 print(hex(0o1357)) #輸出0x2ef print(hex(0x2d9)) #輸出0x2d9
''' id() 函數(shù)用于獲取對象的內(nèi)存地址。 語法 id 語法： id([object]) 參數(shù)說明： object -- 對象。 返回值 返回對象的內(nèi)存地址。 ''' str='zhangsan' print(id(str)) #輸出 1556579882544 動態(tài)分配 id 每一次會改變 b=1 print(id(b)) #輸出 1597205568 ''' id方法的返回值就是對象的內(nèi)存地址。 python2中會為每個出現(xiàn)的對象分配內(nèi)存，哪怕他們的值完全相等（注意是相等不是相同）。 如執(zhí)行a=2.0，b=2.0這兩個語句時會先后為2.0這個Float類型對象分配內(nèi)存， 然后將a與b分別指向這兩個對象。所以a與b指向的不是同一對象 python3中 值相等的變量 內(nèi)存一樣 如下圖所示 ''' a=10.21 b=10.21 print(id(a)) #輸出2036826247912 print(id(b)) #輸出2036826247912 print(a is b) #輸出 True print(a == b) #輸出 True ''' id 函數(shù) 涉及到 淺拷貝和深拷貝的相關(guān)知識 深copy和淺copy 深copy新建一個對象重新分配內(nèi)存地址，復(fù)制對象內(nèi)容。 淺copy不重新分配內(nèi)存地址，內(nèi)容指向之前的內(nèi)存地址。 淺copy如果對象中有引用其他的對象，如果對這個子對象進(jìn)行修改，子對象的內(nèi)容就會發(fā)生更改。 ''' import copy #這里有子對象 numbers=['1','2','3',['4','5']] #淺copy num1=copy.copy(numbers) #深copy num2=copy.deepcopy(numbers) #直接對對象內(nèi)容進(jìn)行修改 num1.append('6') #這里可以看到內(nèi)容地址發(fā)生了偏移，增加了偏移'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']] '''
''' Python3.x 中 input() 函數(shù)接受一個標(biāo)準(zhǔn)輸入數(shù)據(jù)，返回為 string 類型。 注意：在 Python3.x 中 raw_input() 和 input() 進(jìn)行了整合， 去除了 raw_input( )，僅保留了input( )函數(shù)，其接收任意任性輸入， 將所有輸入默認(rèn)為字符串處理，并返回字符串類型。 函數(shù)語法 input([prompt]) 參數(shù)說明： prompt: 提示信息 ''' a=input('請輸入一個數(shù):') #輸入 10 print(a) #輸出 10 print(type(a)) #輸出 <class 'str'> #b=a+10 #報(bào)錯 TypeError: must be str, not int b=int(a)+10 #轉(zhuǎn)換成整型 print(b) #輸出 20 a=input('請輸入一個字符串:') #輸入 ltf1234 print(a) #輸出 字符串ltf1234 可以使用字符串對應(yīng)的方法 print(a.split('1')) #輸出 ['ltf', '234'] split 切割字符串 直接輸出列表
''' int([x[,radix]]) 如果參數(shù)是字符串，那么它可能包含符號和小數(shù)點(diǎn)。參數(shù)radix表示轉(zhuǎn)換的基數(shù)（默認(rèn)是10進(jìn)制）。 它可以是[2,36]范圍內(nèi)的值，或者0。如果是0，系統(tǒng)將根據(jù)字符串內(nèi)容來解析。 如果提供了參數(shù)radix，但參數(shù)x并不是一個字符串，將拋出TypeError異常； 否則，參數(shù)x必須是數(shù)值（普通整數(shù)，長整數(shù)，浮點(diǎn)數(shù)）。通過舍去小數(shù)點(diǎn)來轉(zhuǎn)換浮點(diǎn)數(shù)。 如果超出了普通整數(shù)的表示范圍，一個長整數(shù)被返回。 如果沒有提供參數(shù)，函數(shù)返回0。 int(x, [base]) 作用： 將一個數(shù)字或base類型的字符串轉(zhuǎn)換成整數(shù)。 int(x=0) int(x, base=10)，base缺省值為10，也就是說不指定base的值時，函數(shù)將x按十進(jìn)制處理。 注： 1. x 可以是數(shù)字或字符串，但是base被賦值后 x 只能是字符串 2. x 作為字符串時必須是 base 類型，也就是說 x 變成數(shù)字時必須能用 base 進(jìn)制表示 ''' #1.x是數(shù)字 print(int(2.1)) #輸出 2 print(int(2e3)) #輸出 2000 #print(int(1000,2)) #出錯，base 被賦值后函數(shù)只接收字符串 #報(bào)錯 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進(jìn)制 #報(bào)錯 ValueError: invalid literal for int() with base 16: 'tuifyg' #3. base 可取值范圍是 2~36，囊括了所有的英文字母(不區(qū)分大小寫)， # 十六進(jìn)制中F表示15，那么G將在二十進(jìn)制中表示16，依此類推....Z在三十六進(jìn)制中表示35 #print(int('FZ',16)) # 出錯，F(xiàn)Z不能用十六進(jìn)制表示 #報(bào)錯 ValueError: invalid literal for int() with base 16: 'FZ' print(int('FZ',36)) # 575 #4.字符串 0x 可以出現(xiàn)在十六進(jìn)制中，視作十六進(jìn)制的符號， # 同理 0b 可以出現(xiàn)在二進(jìn)制中，除此之外視作數(shù)字 0 和字母 x print(int('0x10', 16)) # 16，0x是十六進(jìn)制的符號 #print(int('0x10', 17)) # 出錯，'0x10'中的 x 被視作英文字母 x print(int('0x10', 36)) # 42804，36進(jìn)制包含字母 x
''' isinstance() 函數(shù)來判斷一個對象是否是一個已知的類型，類似 type()。 isinstance() 與 type() 區(qū)別： type() 不會認(rèn)為子類是一種父類類型，不考慮繼承關(guān)系。 isinstance() 會認(rèn)為子類是一種父類類型，考慮繼承關(guān)系。 如果要判斷兩個類型是否相同推薦使用 isinstance()。 語法 以下是 isinstance() 方法的語法: isinstance(object, classinfo) 參數(shù) object -- 實(shí)例對象。 classinfo -- 可以是直接或間接類名、基本類型或者有它們組成的元組。 返回值 如果對象的類型與參數(shù)二的類型（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
''' 描述 issubclass() 方法用于判斷參數(shù) class 是否是類型參數(shù) classinfo 的子類。 語法 以下是 issubclass() 方法的語法: issubclass(class, classinfo) 參數(shù) 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參數(shù)是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))) #報(bào)錯 TypeError: issubclass() arg 2 must be a class or tuple of classes
''' 描述 iter() 函數(shù)用來生成迭代器。 語法 以下是 iter() 方法的語法: iter(object[, sentinel]) 參數(shù) object -- 支持迭代的集合對象。 sentinel -- 如果傳遞了第二個參數(shù)，則參數(shù) object 必須是一個可調(diào)用的對象（如，函數(shù)），此時，iter 創(chuàng)建了一個迭代器對象，每次調(diào)用這個迭代器對象的__next__()方法時，都會調(diào)用 object。 打開模式 返回值 迭代器對象。 1 iter(o[, sentinel]) 2 返回一個iterator對象。該函數(shù)對于第一個參數(shù)的解析依賴于第二個參數(shù)。 3 如果沒有提供第二個參數(shù)，參數(shù)o必須是一個集合對象，支持遍歷功能（__iter__()方法）或支持序列功能（__getitem__()方法）， 4 參數(shù)為整數(shù)，從零開始。如果不支持這兩種功能，將處罰TypeError異常。 5 如果提供了第二個參數(shù)，參數(shù)o必須是一個可調(diào)用對象。在這種情況下創(chuàng)建一個iterator對象，每次調(diào)用iterator的next()方法來無 6 參數(shù)的調(diào)用o，如果返回值等于參數(shù)sentinel，觸發(fā)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
''' 匿名函數(shù)lambda：是指一類無需定義標(biāo)識符（函數(shù)名）的函數(shù)或子程序。 lambda 函數(shù)可以接收任意多個參數(shù) (包括可選參數(shù)) 并且返回單個表達(dá)式的值。 要點(diǎn)： 1，lambda 函數(shù)不能包含命令， 2，包含的表達(dá)式不能超過一個。 說明：一定非要使用lambda函數(shù)；任何能夠使用它們的地方，都可以定義一個單獨(dú)的普通函數(shù)來進(jìn)行替換。 我將它們用在需要封裝特殊的、非重用代碼上，避免令我的代碼充斥著大量單行函數(shù)。 lambda匿名函數(shù)的格式：冒號前是參數(shù)，可以有多個，用逗號隔開，冒號右邊的為表達(dá)式。 其實(shí)lambda返回值是一個函數(shù)的地址，也就是函數(shù)對象。 ''' 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)) #傳入一個參數(shù)的lambda函數(shù) 返回x*x b=lambda x,y,z:x+y*z print(b(1,2,3)) #返回x+y*z 即1+2*3=7 #2.方法結(jié)合使用 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)) #返回每個元素相加的和
''' 描述 Python len() 方法返回對象（字符、列表、元組等）長度或項(xiàng)目個數(shù)。 語法 len()方法語法： len( s ) 參數(shù) 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
''' list() 列表構(gòu)造函數(shù) 1 list([iterable]) 2 list的構(gòu)造函數(shù)。參數(shù)iterable是可選的，它可以是序列，支持編譯的容器對象，或iterator對象。 3 該函數(shù)創(chuàng)建一個元素值，順序與參數(shù)iterable一致的列表。如果參數(shù)iterable是一個列表，將創(chuàng)建 4 列表的一個拷貝并返回，就像語句iterables[:]。 ''' list=[1,2,3,4,5,6,7,8,9] #構(gòu)建列表 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 的數(shù)量 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() #列表反轉(zhuǎn) 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)) #報(bào)錯 >' not supported between instances of 'str' and 'int' #print(min(list3)) #報(bào)錯 >' not supported between instances of 'str' and 'int'
''' locals() 函數(shù)會以字典類型返回當(dāng)前位置的全部局部變量。 對于函數(shù), 方法, lambda 函式, 類, 以及實(shí)現(xiàn)了 __call__ 方法的類實(shí)例, 它都返回 True。 語法 locals() 函數(shù)語法： locals() 參數(shù) 無 返回值 返回字典類型的局部變量 1 不要修改locals()返回的字典中的內(nèi)容；改變可能不會影響解析器對局部變量的使用。 2 在函數(shù)體內(nèi)調(diào)用locals()，返回的是自由變量。修改自由變量不會影響解析器對變量的使用。 3 不能在類區(qū)域內(nèi)返回自由變量。 ''' 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}
''' map()函數(shù) map()是 Python 內(nèi)置的高階函數(shù)，它接收一個函數(shù) f 和一個 list， 并通過把函數(shù) f 依次作用在 list 的每個元素上，得到一個新的 list 并返回。 例如，對于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每個元素都作平方，就可以用map()函數(shù)： 因此，我們只需要傳入函數(shù)f(x)=x*x，就可以利用map()函數(shù)完成這個計(jì)算： ''' 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()函數(shù)不改變原有的 list，而是返回一個新的 list。 利用map()函數(shù)，可以把一個 list 轉(zhuǎn)換為另一個 list，只需要傳入轉(zhuǎn)換函數(shù)。 由于list包含的元素可以是任何類型，因此，map() 不僅僅可以處理只包含數(shù)值的 list， 事實(shí)上它可以處理包含任意類型的 list，只要傳入的函數(shù)f可以處理這種數(shù)據(jù)類型。 任務(wù) 假設(shè)用戶輸入的英文名字不規(guī)范，沒有按照首字母大寫，后續(xù)字母小寫的規(guī)則， 請利用map()函數(shù)，把一個list（包含若干不規(guī)范的英文名字）變成一個包含規(guī)范英文名字的 ''' 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 得這樣寫才可以
''' 描述 max() 方法返回給定參數(shù)的最大值，參數(shù)可以為序列。 語法 以下是 max() 方法的語法: max( x, y, z, .... ) 參數(shù) x -- 數(shù)值表達(dá)式。 y -- 數(shù)值表達(dá)式。 z -- 數(shù)值表達(dá)式。 返回值 返回給定參數(shù)的最大值。 ''' 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)) ''' 輸出結(jié)果： max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100 ''' #1.傳入的多個參數(shù)的最大值 print(max(1,2,3,4)) #輸出 4 #2.傳入可迭代對象時，取其元素最大值 s='12345' print(max(s)) #輸出 5 #3.傳入命名參數(shù)key，其為一個函數(shù)，用來指定取最大值的方法 s = [ {'name': 'sumcet', 'age': 18}, {'name': 'bbu', 'age': 11} ] a = max(s, key=lambda x: x['age']) print(a) #輸出 {'name': 'sumcet', 'age': 18}
''' 描述 min() 方法返回給定參數(shù)的最小值，參數(shù)可以為序列。 語法 以下是 min() 方法的語法: min( x, y, z, .... ) 參數(shù) x -- 數(shù)值表達(dá)式。 y -- 數(shù)值表達(dá)式。 z -- 數(shù)值表達(dá)式。 返回值 返回給定參數(shù)的最小值。 ''' 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)) ''' 輸出結(jié)果 min(80, 100, 1000) : 80 min(-20, 100, 400) : -20 min(-80, -20, -10) : -80 min(0, 100, -400) : -400 ''' #1.傳入的多個參數(shù)的最小值 print(min(1,2,3,4)) #輸出 1 #2.傳入可迭代對象時，取其元素最小值 s='12345' print(min(s)) #輸出 1 #3.傳入命名參數(shù)key，其為一個函數(shù)，用來指定取最小值的方法 s = [ {'name': 'sumcet', 'age': 18}, {'name': 'bbu', 'age': 11} ] a = min(s, key=lambda x: x['age']) print(a) #輸出 {'name': 'bbu', 'age': 11}
''' 描述 next() 返回迭代器的下一個項(xiàng)目。 語法 next 語法： next(iterator[, default]) 參數(shù)說明： iterator -- 可迭代對象 default -- 可選，用于設(shè)置在沒有下一個元素時返回該默認(rèn)值，如果不設(shè)置，又沒有下一個元素則會觸發(fā) StopIteration 異常。 返回值 返回對象幫助信息。 ''' # 首先獲得Iterator對象: it = iter([1, 2, 3, 4, 5]) # 循環(huán): while True: try: # 獲得下一個值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循環(huán) 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)) #報(bào)錯 StopIteration #函數(shù)可以接收一個可選的default參數(shù)，傳入default參數(shù)后， # 如果可迭代對象還有元素沒有返回，則依次返回其元素值，如果所有元素已經(jīng)返回， # 則返回default指定的默認(rèn)值而不拋出StopIteration 異常。 print(next(a,'e')) #這次不報(bào)錯了 返回 e 即default參數(shù)
''' 描述 oct() 函數(shù)將一個整數(shù)轉(zhuǎn)換成八進(jìn)制字符串。 語法 oct 語法： oct(x) 參數(shù)說明： x -- 整數(shù)。 返回值 返回八進(jìn)制字符串。 ''' print(oct(12)) #輸出12的八進(jìn)制 0o14 print(oct(-120)) #輸出-12的二進(jìn)制 -0o170 print(type(oct(12))) #輸出oct(12) 的類型 <class 'str'> 所以不能直接計(jì)算 print(int(oct(10),base=8)+int(oct(15),base=8)) #輸出 25 #base 參數(shù)不可為空 為空默認(rèn)參數(shù)為10進(jìn)制 會報(bào)錯 ValueError: invalid literal for int() with base 10: '0b1010' #當(dāng)然了，參數(shù)不僅可以接受十進(jìn)制整數(shù)，八進(jìn)制、十六進(jìn)制也是可以的，只要是int型數(shù)據(jù)就合法。 print(oct(0b10010)) #輸出0o22 print(oct(0o1357)) #輸出0o1357 print(oct(0x2d9)) #輸出0o1331
''' python open() 函數(shù)用于打開一個文件，創(chuàng)建一個 file 對象，相關(guān)的方法才可以調(diào)用它進(jìn)行讀寫。 更多文件操作可參考：Python 文件I/O。 函數(shù)語法 open(name[, mode[, buffering]]) 參數(shù)說明： name : 一個包含了你要訪問的文件名稱的字符串值。 mode : mode 決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數(shù)是非強(qiáng)制的，默認(rèn)文件訪問模式為只讀(r)。 buffering : 如果 buffering 的值被設(shè)為 0，就不會有寄存。如果 buffering 的值取 1，訪問文件時會寄存行。如果將 buffering 的值設(shè)為大于 1 的整數(shù)，表明了這就是的寄存區(qū)的緩沖大小。如果取負(fù)值，寄存區(qū)的緩沖大小則為系統(tǒng)默認(rèn)。 不同模式打開文件的完全列表： 模式 描述 r 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認(rèn)模式。 rb 以二進(jìn)制格式打開一個文件用于只讀。文件指針將會放在文件的開頭。這是默認(rèn)模式。 r+ 打開一個文件用于讀寫。文件指針將會放在文件的開頭。 rb+ 以二進(jìn)制格式打開一個文件用于讀寫。文件指針將會放在文件的開頭。 w 打開一個文件只用于寫入。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。 wb 以二進(jìn)制格式打開一個文件只用于寫入。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。 w+ 打開一個文件用于讀寫。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。 wb+ 以二進(jìn)制格式打開一個文件用于讀寫。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。 a 打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結(jié)尾。也就是說，新的內(nèi)容將會被寫入到已有內(nèi)容之后。如果該文件不存在，創(chuàng)建新文件進(jìn)行寫入。 ab 以二進(jìn)制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結(jié)尾。也就是說，新的內(nèi)容將會被寫入到已有內(nèi)容之后。如果該文件不存在，創(chuàng)建新文件進(jìn)行寫入。 a+ 打開一個文件用于讀寫。如果該文件已存在，文件指針將會放在文件的結(jié)尾。文件打開時會是追加模式。如果該文件不存在，創(chuàng)建新文件用于讀寫。 ab+ 以二進(jìn)制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結(jié)尾。如果該文件不存在，創(chuàng)建新文件用于讀寫。 file 對象方法 file.read([size])：size 未指定則返回整個文件，如果文件大小 >2 倍內(nèi)存則有問題，f.read()讀到文件尾時返回''(空字串)。 file.readline()：返回一行。 file.readlines([size]) ：返回包含size行的列表, size 未指定則返回全部行。 for line in f: print line ：通過迭代器訪問。 f.write('hello\n')：如果要寫入字符串以外的數(shù)據(jù),先將他轉(zhuǎn)換為字符串。 f.tell()：返回一個整數(shù),表示當(dāng)前文件指針的位置(就是到文件頭的比特?cái)?shù))。 f.seek(偏移量,[起始位置])：用來移動文件指針。 偏移量: 單位為比特，可正可負(fù) 起始位置: 0 - 文件頭, 默認(rèn)值; 1 - 當(dāng)前位置; 2 - 文件尾 f.close() 關(guān)閉文件 open(filename [, mode [, bufsize]]) 打開一個文件，返回一個file對象。 如果文件無法打開，將處罰IOError異常。 應(yīng)該使用open()來代替直接使用file類型的構(gòu)造函數(shù)打開文件。 參數(shù)filename表示將要被打開的文件的路徑字符串； 參數(shù)mode表示打開的模式，最常用的模式有：'r'表示讀文本，'w'表示寫文本文件，'a'表示在文件中追加。 Mode的默認(rèn)值是'r'。 當(dāng)操作的是二進(jìn)制文件時，只要在模式值上添加'b'。這樣提高了程序的可移植性。 可選參數(shù)bufsize定義了文件緩沖區(qū)的大小。0表示不緩沖；1表示行緩沖；任何其他正數(shù)表示使用該大小的緩沖區(qū)； 負(fù)數(shù)表示使用系統(tǒng)默認(rèn)緩沖區(qū)大小，對于tty設(shè)備它往往是行緩沖，而對于其他文件往往完全緩沖。如果參數(shù)值被省卻。 使用系統(tǒng)默認(rèn)值。 ''' f=open('1.txt','r',encoding='utf-8') print(f.read()) ''' 輸出... ltf zhongguo shanxi yuncheng 男 20 '''
''' 描述 ord() 函數(shù)是 chr() 函數(shù)（對于8位的ASCII字符串）或 unichr() 函數(shù)（對于Unicode對象）的配對函數(shù)，它以一個字符（長度為1的字符串）作為參數(shù)，返回對應(yīng)的 ASCII 數(shù)值，或者 Unicode 數(shù)值，如果所給的 Unicode 字符超出了你的 Python 定義范圍，則會引發(fā)一個 TypeError 的異常。 語法 以下是 ord() 方法的語法: ord(c) 參數(shù) c -- 字符。 返回值 返回值是對應(yīng)的十進(jìn)制整數(shù)。 ''' print(ord('a')) #輸出97 print(ord('b')) #輸出98 print(ord('c')) #輸出99 print(ord(']')) #輸出93 print(ord('8')) #輸出56
''' 描述 pow() 方法返回 xy（x的y次方） 的值。 語法 以下是 math 模塊 pow() 方法的語法: import math math.pow( x, y ) 內(nèi)置的 pow() 方法 pow(x, y[, z]) 函數(shù)是計(jì)算x的y次方，如果z在存在，則再對結(jié)果進(jìn)行取模，其結(jié)果等效于pow(x,y) %z 注意：pow() 通過內(nèi)置的方法直接調(diào)用，內(nèi)置方法會把參數(shù)作為整型，而 math 模塊則會把參數(shù)轉(zhuǎn)換為 float。 參數(shù) x -- 數(shù)值表達(dá)式。 y -- 數(shù)值表達(dá)式。 z -- 數(shù)值表達(dá)式。 返回值 返回 xy（x的y次方） 的值。 ''' import math # 導(dǎo)入 math 模塊 print('math.pow(100, 2) : ', math.pow(100, 2)) # 使用內(nèi)置，查看輸出結(jié)果區(qū)別 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)) ''' 輸出結(jié)果... 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 '''
''' 描述 property() 函數(shù)的作用是在新式類中返回屬性值。 語法 以下是 property() 方法的語法: class property([fget[, fset[, fdel[, doc]]]]) 參數(shù) fget -- 獲取屬性值的函數(shù) fset -- 設(shè)置屬性值的函數(shù) fdel -- 刪除屬性值函數(shù) 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
''' python range() 函數(shù)可創(chuàng)建一個整數(shù)列表，一般用在 for 循環(huán)中。 函數(shù)語法 range(start, stop[, step]) 參數(shù)說明： start: 計(jì)數(shù)從 start 開始。默認(rèn)是從 0 開始。例如range（5）等價(jià)于range（0， 5）; stop: 計(jì)數(shù)到 stop 結(jié)束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5 step：步長，默認(rèn)為1。例如：range（0， 5） 等價(jià)于 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) #依次輸出字符
''' 在python3中如果使用reduce需要先導(dǎo)入 from functools import reduce reduce函數(shù)，reduce函數(shù)會對參數(shù)序列中元素進(jìn)行累積。 reduce函數(shù)的定義： reduce(function, sequence [, initial] ) -> value function參數(shù)是一個有兩個參數(shù)的函數(shù)，reduce依次從sequence中取一個元素， 和上一次調(diào)用function的結(jié)果做參數(shù)再次調(diào)用function。 第一次調(diào)用function時，如果提供initial參數(shù)， 會以sequence中的第一個元素和initial作為參數(shù)調(diào)用function， 否則會以序列sequence中的前兩個元素做參數(shù)調(diào)用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)) # 運(yùn)行過程為1*2*3*4*5*6=720 #來個稍微復(fù)雜的 print(reduce(lambda x,y:x*y+1,lst)) ''' 運(yùn)算步驟：1*2+1=3 3*3+1=10 10*4+1=41 41*5+1=206 206*6+1=1237 ''' #再說說有初始化值的情況, 這個時候就不是取列表的前兩項(xiàng), 而是取初始值為第一個, # 序列的第一個元素為第二個元素,開始進(jìn)行l(wèi)ambda函數(shù)的應(yīng)用計(jì)算. print(reduce(lambda x,y:x+y,lst,5)) ''' 計(jì)算步驟：5+1=6 6+2=8 8+3=11 11+4=15 15+5=20 20+6=26 '''
''' 描述 repr() 函數(shù)將對象轉(zhuǎn)化為供解釋器讀取的形式。 語法 以下是 repr() 方法的語法: repr(object) 參數(shù) 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
''' 描述 reversed 函數(shù)返回一個反轉(zhuǎn)的迭代器。 語法 以下是 reversed 的語法: reversed(seq) 參數(shù) seq -- 要轉(zhuǎn)換的序列，可以是 tuple, string, list 或 range。 返回值 返回一個反轉(zhuǎn)的迭代器。 1 reversed(seq) 2 返回一個逆序的iterator對象。參數(shù)seq必須是一個包含__reversed__()方法的對象或支持序列操作(__len__()和__getitem__()) 3 該函數(shù)是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（）返回的是一個迭代器對象，只能進(jìn)行一次循環(huán)遍歷。顯示一次所包含的值！
''' 描述 round() 方法返回浮點(diǎn)數(shù)x的四舍五入值。 語法 以下是 round() 方法的語法: round( x [, n] ) 參數(shù) x -- 數(shù)字表達(dá)式。 n -- 表示從小數(shù)點(diǎn)位數(shù)，其中 x 需要四舍五入，默認(rèn)值為 0。 返回值 返回浮點(diǎn)數(shù)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)) ''' 輸出結(jié)果... 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 '''
''' 描述： setattr函數(shù)，用于設(shè)置屬性值，該屬性必須存在 語法： setattr(object,name,value) 參數(shù)： 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}
''' 描述 set() 函數(shù)創(chuàng)建一個無序不重復(fù)元素集，可進(jìn)行關(guān)系測試，刪除重復(fù)數(shù)據(jù)，還可以計(jì)算交集、差集、并集等。 語法 set 語法： class set([iterable]) 參數(shù)說明： iterable -- 可迭代對象對象； 返回值 返回新的集合對象。 ''' a=set('www.baidu.com') b=set('www.gogle.com') #重復(fù)的元素被刪除 元素唯一 可以用來去重 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) # 移除不存的元素不會報(bào)錯 print(se) se = {11, 22, 33} se.remove(11) #se.remove(44) # 移除不存的元素會報(bào)錯 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) # 合并不同項(xiàng)，并賦新值 print(temp1) #{33, 11} print(se) #{33, 11, 22} temp2 = se.symmetric_difference_update(be) # 合并不同項(xiàng)，并更新自己 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]) # 可增加迭代項(xiàng) print(se) #8.集合的轉(zhuǎn)換 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'>
''' 描述 slice() 函數(shù)實(shí)現(xiàn)切片對象，主要用在切片操作函數(shù)里的參數(shù)傳遞。 語法 slice 語法： class slice(stop) class slice(start, stop[, step]) 參數(shù)說明： start -- 起始位置 stop -- 結(jié)束位置 step -- 間距 返回值 返回一個切片對象。 實(shí)例 ''' myslice=slice(5) #設(shè)置一個 截取五個元素的切片 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]
''' 描述 sorted() 函數(shù)對所有可迭代的對象進(jìn)行排序操作。 sort 與 sorted 區(qū)別： sort 是應(yīng)用在 list 上的方法，sorted 可以對所有可迭代的對象進(jìn)行排序操作。 list 的 sort 方法返回的是對已經(jīng)存在的列表進(jìn)行操作，而內(nèi)建函數(shù) sorted 方法返回的是一個新的 list，而不是在原來的基礎(chǔ)上進(jìn)行的操作。 語法 sorted 語法： sorted(iterable, key=None, reverse=False) 參數(shù)說明： iterable -- 可迭代對象。 key -- 主要是用來進(jìn)行比較的元素，只有一個參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對象中，指定可迭代對象中的一個元素來進(jìn)行排序。 reverse -- 排序規(guī)則，reverse = True 降序 ， reverse = False 升序（默認(rèn)）。 返回值 返回重新排序的列表。 ''' print(sorted([2,3,4,1,5,6])) #輸出 [1, 2, 3, 4, 5, 6] #另一個區(qū)別在于list.sort() 方法只為 list 定義。而 sorted() 函數(shù)可以接收任何的 iterable。 print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})) #輸出 [1, 2, 3, 4, 5] #利用key進(jìn)行倒序排序 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] #要進(jìn)行反向排序，也通過傳入第三個參數(shù) 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 的應(yīng)用，也可以通過 key 的值來進(jìn)行數(shù)組/字典的排序，比如 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'}]
''' python staticmethod 返回函數(shù)的靜態(tài)方法。 該方法不強(qiáng)制要求傳遞參數(shù)，如下聲明一個靜態(tài)方法： class C(object): @staticmethod def f(arg1, arg2, ...): ... 以上實(shí)例聲明了靜態(tài)方法 f，類可以不用實(shí)例化就可以調(diào)用該方法 C.f()，當(dāng)然也可以實(shí)例化后調(diào)用 C().f()。 函數(shù)語法 staticmethod(function) 參數(shù)說明： 無 ''' class C(object): @staticmethod def f(): print('hello world') C.f() # 靜態(tài)方法無需實(shí)例化 cobj = C() cobj.f() # 也可以實(shí)例化后調(diào)用 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>
''' 描述 str() 函數(shù)將對象轉(zhuǎn)化為適于人閱讀的形式。 語法 以下是 str() 方法的語法: class str(object='') 參數(shù) 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'>
''' 描述 sum() 方法對系列進(jìn)行求和計(jì)算。 語法 以下是 sum() 方法的語法: sum(iterable[, start]) 參數(shù) iterable -- 可迭代對象，如：列表、元組、集合。 start -- 指定相加的參數(shù)，如果沒有設(shè)置這個值，默認(rèn)為0。 返回值 返回計(jì)算結(jié)果 ''' print(sum([0,1,2])) # 列表總和 3 print(sum((2,3,4),1)) # 元組計(jì)算總和后再加 1 print(sum([2,3,4,5,6],8)) # 列表計(jì)算總和后再加 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
''' 描述 vars() 函數(shù)返回對象object的屬性和屬性值的字典對象。 語法 vars() 函數(shù)語法： vars([object]) 參數(shù) object -- 對象 返回值 返回對象object的屬性和屬性值的字典對象，如果沒有參數(shù)，就打印當(dāng)前調(diào)用位置的屬性和屬性值 類似 locals()。 ''' print(vars()) #輸出 {'__name__': '__main__', '__doc__': '\n描述\nvars() 函數(shù)返回對象object的屬性和屬性值的字典對象。\n語法\nvars() 函數(shù)語法：\nvars([object])\n參數(shù)\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
#zip函數(shù)接受任意多個可迭代對象作為參數(shù),將對象中對應(yīng)的元素打包成一個tuple,然后返回一個可迭代的zip對象. #這個可迭代對象可以使用循環(huán)的方式列出其元素 #若多個可迭代對象的長度不一致,則所返回的列表與長度最短的可迭代對象相同. #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)
聯(lián)系客服
