python3知识点汇总_35个高级Python知识点总结
No.1 一切皆對(duì)象
眾所周知，Java中強(qiáng)調(diào)“一切皆對(duì)象”，但是Python中的面向?qū)ο蟊菾ava更加徹底，因?yàn)镻ython中的類(class)也是對(duì)象，函數(shù)（function）也是對(duì)象，而且Python的代碼和模塊也都是對(duì)象。
Python中函數(shù)和類可以賦值給一個(gè)變量
Python中函數(shù)和類可以存放到集合對(duì)象中
Python中函數(shù)和類可以作為一個(gè)函數(shù)的參數(shù)傳遞給函數(shù)
Python中函數(shù)和類可以作為返回值
Step.1
# 首先創(chuàng)建一個(gè)函數(shù)和一個(gè)Python3.x的新式類
class Demo(object):
def __init__(self):
print("Demo Class")
# 定義一個(gè)函數(shù)
def function():
print("function")
# 在Python無論是函數(shù)，還是類，都是對(duì)象，他們可以賦值給一個(gè)變量
class_value = Demo
func_value = function
# 并且可以通過變量調(diào)用
class_value() # Demo Class
func_value() # function
Step.2
# 將函數(shù)和類添加到集合中
obj_list = []
obj_list.append(Demo)
obj_list.append(function)
# 遍歷列表
for i in obj_list:
print(i)
#
#
Step.3
# 定義一個(gè)具體函數(shù)
def test_func(class_name, func_name):
class_name()
func_name()
# 將類名和函數(shù)名傳入形參列表
test_func(Demo, function)
# Demo Class
# function
Step.4
# 定義函數(shù)實(shí)現(xiàn)返回類和函數(shù)
def test_func2():
return Demo
def test_func3():
return function
# 執(zhí)行函數(shù)
test_func2()() # Demo Class
test_func3()() # function
No.2 關(guān)鍵字type、object、class之間的關(guān)系
在Python中，object的實(shí)例是type，object是頂層類，沒有基類；type的實(shí)例是type，type的基類是object。Python中的內(nèi)置類型的基類是object，但是他們都是由type實(shí)例化而來，具體的值由內(nèi)置類型實(shí)例化而來。在Python2.x的語法中用戶自定義的類沒有明確指定基類就默認(rèn)是沒有基類，在Python3.x的語法中，指定基類為object。
# object是誰實(shí)例化的？
print(type(object)) #
# object繼承自哪個(gè)類？
print(object.__bases__) # ()
# type是誰實(shí)例化的？
print(type(type)) #
# type繼承自哪個(gè)類？
print(type.__bases__) # (,)
# 定義一個(gè)變量
value = 100
# 100由誰實(shí)例化？
print(type(value)) #
# int由誰實(shí)例化？
print(type(int)) #
# int繼承自哪個(gè)類？
print(int.__bases__) # (,)
# Python 2.x的舊式類
class OldClass():
pass
# Python 3.x的新式類
class NewClass(object):
pass
No.3 Python的內(nèi)置類型
在Python中，對(duì)象有3個(gè)特征屬性：
在內(nèi)存中的地址，使用id()函數(shù)進(jìn)行查看
對(duì)象的類型
對(duì)象的默認(rèn)值
Step.1 None類型
在Python解釋器啟動(dòng)時(shí)，會(huì)創(chuàng)建一個(gè)None類型的None對(duì)象，并且None對(duì)象全局只有一個(gè)。
Step.2 數(shù)值類型
ini類型
float類型
complex類型
bool類型
Step.3 迭代類型
在Python中，迭代類型可以使用循環(huán)來進(jìn)行遍歷。
Step.4 序列類型
list
tuple
str
array
range
bytes, bytearray, memoryvie（二進(jìn)制序列）
Step.5 映射類型
dict
Step.6 集合類型
set
frozenset
Step.7 上下文管理類型
with語句
Step.8 其他類型
模塊
class
實(shí)例
函數(shù)
方法
代碼
object對(duì)象
type對(duì)象
ellipsis（省略號(hào)）
notimplemented
NO.4 魔法函數(shù)
Python中的魔法函數(shù)使用雙下劃線開始，以雙下劃線結(jié)尾。關(guān)于詳細(xì)介紹請(qǐng)看我的文章——《全面總結(jié)Python中的魔法函數(shù)》。
No.5 鴨子類型與白鵝類型
鴨子類型是程序設(shè)計(jì)中的推斷風(fēng)格，在鴨子類型中關(guān)注對(duì)象如何使用而不是類型本身。鴨子類型像多態(tài)一樣工作但是沒有繼承。鴨子類型的概念來自于：“當(dāng)看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子。”
# 定義狗類
class Dog(object):
def eat(self):
print("dog is eatting...")
# 定義貓類
class Cat(object):
def eat(self):
print("cat is eatting...")
# 定義鴨子類
class Duck(object):
def eat(self):
print("duck is eatting...")
# 以上Python中多態(tài)的體現(xiàn)
# 定義動(dòng)物列表
an_li = []
# 將動(dòng)物添加到列表
an_li.append(Dog)
an_li.append(Cat)
an_li.append(Duck)
# 依次調(diào)用每個(gè)動(dòng)物的eat()方法
for i in an_li:
i().eat()
# dog is eatting...
# cat is eatting...
# duck is eatting...
白鵝類型是指只要 cls 是抽象基類，即 cls 的元類是 abc.ABCMeta ，就可以使用 isinstance(obj, cls)。
No.6 協(xié)議、 抽象基類、abc模塊和序列之間的繼承關(guān)系
協(xié)議：Python中的非正式接口，是允許Python實(shí)現(xiàn)多態(tài)的方式，協(xié)議是非正式的，不具備強(qiáng)制性，由約定和文檔定義。
接口：泛指實(shí)體把自己提供給外界的一種抽象化物（可以為另一實(shí)體），用以由內(nèi)部操作分離出外部溝通方法，使其能被內(nèi)部修改而不影響外界其他實(shí)體與其交互的方式。
我們可以使用猴子補(bǔ)丁來實(shí)現(xiàn)協(xié)議，那么什么是猴子補(bǔ)丁呢？
猴子補(bǔ)丁就是在運(yùn)行時(shí)修改模塊或類，不去修改源代碼，從而實(shí)現(xiàn)目標(biāo)協(xié)議接口操作，這就是所謂的打猴子補(bǔ)丁。
Tips：猴子補(bǔ)丁的叫法起源于Zope框架，開發(fā)人員在修改Zope的Bug時(shí)，經(jīng)常在程序后面追加更新的部分，這些雜牌軍補(bǔ)丁的英文名字叫做guerilla patch，后來寫成gorllia，接著就變成了monkey。
猴子補(bǔ)丁的主要作用是：
在運(yùn)行時(shí)替換方法、屬性
在不修改源代碼的情況下對(duì)程序本身添加之前沒有的功能
在運(yùn)行時(shí)對(duì)象中添加補(bǔ)丁，而不是在磁盤中的源代碼上
應(yīng)用案例：假設(shè)寫了一個(gè)很大的項(xiàng)目，處處使用了json模塊來解析json文件，但是后來發(fā)現(xiàn)ujson比json性能更高，修改源代碼是要修改很多處的，所以只需要在程序入口加入：
import json
# pip install ujson
import ujson
def monkey_patch_json():
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
monkey_patch_json()
Python 的抽象基類有一個(gè)重要實(shí)用優(yōu)勢(shì)：可以使用 register 類方法在終端用戶的代碼中把某個(gè)類 “聲明” 為一個(gè)抽象基類的 “虛擬” 子 類（為此，被注冊(cè)的類必腨滿足抽象其類對(duì)方法名稱和簽名的要求，最重要的是要滿足底 層語義契約；但是，開發(fā)那個(gè)類時(shí)不用了解抽象基類，更不用繼承抽象基類 。有時(shí)，為了讓抽象類識(shí)別子類，甚至不用注冊(cè)。要抑制住創(chuàng)建抽象基類的沖動(dòng)。濫用抽象基類會(huì)造成災(zāi)難性后果，表明語言太注重表面形式 。
抽象基類不能被實(shí)例化(不能創(chuàng)建對(duì)象)，通常是作為基類供子類繼承，子類中重寫虛函數(shù)，實(shí)現(xiàn)具體的接口。
判定某個(gè)對(duì)象的類型
強(qiáng)制子類必須實(shí)現(xiàn)某些方法
抽象基類的定義與使用
import abc
# 定義緩存類
class Cache(metaclass=abc.ABCMeta):
@abc.abstractmethod
def get(self, key):
pass
@abc.abstractmethod
def set(self, key, value):
pass
# 定義redis緩存類實(shí)現(xiàn)Cache類中的get()和set()方法
class RedisCache(Cache):
def set(self, key):
pass
def get(self, key, value):
pass
值得注意的是：Python 3.0-Python3.3之間，繼承抽象基類的語法是class ClassName(metaclass=adc.ABCMeta)，其他版本是：class ClassName(abc.ABC)。
collections.abc模塊中各個(gè)抽象基類的UML類圖
No.7 isinstence和type的區(qū)別
class A(object):
pass
class B(A):
pass
b = B()
print(isinstance(b, B))
print(isinstance(b, A))
print(type(b) is B)
print(type(b) is A)
# True
# True
# True
# False
No.8 類變量和實(shí)例變量
實(shí)例變量只能通過類的實(shí)例進(jìn)行調(diào)用
修改模板對(duì)象創(chuàng)建的對(duì)象的屬性，模板對(duì)象的屬性不會(huì)改變
修改模板對(duì)象的屬性，由模板對(duì)象創(chuàng)建的對(duì)象的屬性會(huì)改變
# 此處的類也是模板對(duì)象，Python中一切皆對(duì)象
class A(object):
#類變量
number = 12
def __init__(self):
# 實(shí)例變量
self.number_2 = 13
# 實(shí)例變量只能通過類的實(shí)例進(jìn)行調(diào)用
print(A.number) # 12
print(A().number) # 12
print(A().number_2) # 13
# 修改模板對(duì)象創(chuàng)建的對(duì)象的屬性，模板對(duì)象的屬性不會(huì)改變
a = A()
a.number = 18
print(a.number) # 18
print(A().number) # 12
print(A.number) # 12
# 修改模板對(duì)象的屬性，由模板對(duì)象創(chuàng)建的對(duì)象的屬性會(huì)改變
A.number = 19
print(A.number) # 19
print(A().number) # 19
No.9 類和實(shí)例屬性以及方法的查找順序
在Python 2.2之前只有經(jīng)典類，到Python2.7還會(huì)兼容經(jīng)典類，Python3.x以后只使用新式類，Python之前版本也會(huì)兼容新式類
Python 2.2 及其之前類沒有基類，Python新式類需要顯式繼承自object，即使不顯式繼承也會(huì)默認(rèn)繼承自object
經(jīng)典類在類多重繼承的時(shí)候是采用從左到右深度優(yōu)先原則匹配方法的.而新式類是采用C3算法
經(jīng)典類沒有MRO和instance.mro()調(diào)用的
假定存在以下繼承關(guān)系：
class D(object):
def say_hello(self):
pass
class E(object):
pass
class B(D):
pass
class C(E):
pass
class A(B, C):
pass
采用DFS（深度優(yōu)先搜索算法）當(dāng)調(diào)用了A的say_hello()方法的時(shí)候，系統(tǒng)會(huì)去B中查找如果B中也沒有找到，那么去D中查找，很顯然D中存在這個(gè)方法，但是DFS對(duì)于以下繼承關(guān)系就會(huì)有缺陷：
class D(object):
pass
class B(D):
pass
class C(D):
def say_hello(self):
pass
class A(B, C):
pass
在A的實(shí)例對(duì)象中調(diào)用say_hello方法時(shí)，系統(tǒng)會(huì)先去B中查找，由于B類中沒有該方法的定義，所以會(huì)去D中查找，D類中也沒有，系統(tǒng)就會(huì)認(rèn)為該方法沒有定義，其實(shí)該方法在C中定義了。所以考慮使用BFS（廣度優(yōu)先搜索算法），那么問題回到第一個(gè)繼承關(guān)系，假定C和D具備重名方法，在調(diào)用A的實(shí)例的方法時(shí)，應(yīng)該先在B中查找，理應(yīng)調(diào)用D中的方法，但是使用BFS的時(shí)候，C類中的方法會(huì)覆蓋D類中的方法。在Python 2.3以后的版本中，使用C3算法：
# 獲取解析順序的方法
類名.mro()
類名.__mro__
inspect.getmro(類名)
使用C3算法后的第二種繼承順序：
class D(object):
pass
class B(D):
pass
class C(D):
def say_hello(self):
pass
class A(B, C):
pass
print(A.mro()) # [, , , , ]
使用C3算法后的第一種繼承順序：
class D(object):
pass
class E(object):
pass
class B(D):
pass
class C(E):
pass
class A(B, C):
pass
print(A.mro())
# [, , , , , ]
在這里僅介紹了算法的作用和演變歷史，關(guān)于深入詳細(xì)解析，請(qǐng)看我的其他文章——《從Python繼承談起，到C3算法落筆》。
No.10 類方法、實(shí)例方法和靜態(tài)方法
class Demo(object):
# 類方法
@classmethod
def class_method(cls, number):
pass
# 靜態(tài)方法
@staticmethod
def static_method(number):
pass
# 對(duì)象方法/實(shí)例方法
def object_method(self, number):
pass
實(shí)例方法只能通過類的實(shí)例來調(diào)用；靜態(tài)方法是一個(gè)獨(dú)立的、無狀態(tài)的函數(shù)，緊緊依托于所在類的命名空間上；類方法在為了獲取類中維護(hù)的數(shù)據(jù)，比如：
class Home(object):
# 房間中人數(shù)
__number = 0
@classmethod
def add_person_number(cls):
cls.__number += 1
@classmethod
def get_person_number(cls):
return cls.__number
def __new__(self):
Home.add_person_number()
# 重寫__new__方法，調(diào)用object的__new__
return super().__new__(self)
class Person(Home):
def __init__(self):
# 房間人員姓名
self.name = 'name'
# 創(chuàng)建人員對(duì)象時(shí)調(diào)用Home的__new__()方法
tom = Person()
print(type(tom)) #
alice = Person()
bob = Person()
test = Person()
print(Home.get_person_number())
No.11 數(shù)據(jù)封裝和私有屬性
Python中使用雙下劃線+屬性名稱實(shí)現(xiàn)類似于靜態(tài)語言中的private修飾來實(shí)現(xiàn)數(shù)據(jù)封裝。
class User(object):
def __init__(self, number):
self.__number = number
self.__number_2 = 0
def set_number(self, number):
self.__number = number
def get_number(self):
return self.__number
def set_number_2(self, number2):
self.__number_2 = number2
# self.__number2 = number2
def get_number_2(self):
return self.__number_2
# return self.__number2
u = User(25)
print(u.get_number()) # 25
# 真的類似于Java的反射機(jī)制嗎？
print(u._User__number) # 25
# 下面又是啥情況。。。想不明白了T_T
u.set_number_2(18)
print(u.get_number_2()) # 18
print(u._User__number_2)
# Anaconda 3.6.3 第一次是：u._User__number_2 第二次是：18
# Anaconda 3.6.5 結(jié)果都是 0
# 代碼我改成了正確答案，感謝我大哥給我指正錯(cuò)誤，我保留了錯(cuò)誤痕跡
# 變量名稱寫錯(cuò)了，算是個(gè)寫博客突發(fā)事故，這問題我找了一天，萬分感謝我大哥，我太傻B了，犯了低級(jí)錯(cuò)誤
# 留給和我一樣的童鞋參考我的錯(cuò)我之處吧！
# 正確結(jié)果：
# 25 25 18 18
No.12 Python的自省機(jī)制
自省（introspection）是一種自我檢查行為。在計(jì)算機(jī)編程中，自省是指這種能力：檢查某些事物以確定它是什么、它知道什么以及它能做什么。自省向程序員提供了極大的靈活性和控制力。
dir([obj])：返回傳遞給它的任何對(duì)象的屬性名稱經(jīng)過排序的列表（會(huì)有一些特殊的屬性不包含在內(nèi)）
getattr(obj, attr)：返回任意對(duì)象的任何屬性 ，調(diào)用這個(gè)方法將返回obj中名為attr值的屬性的值
... ...
No.13 super函數(shù)
Python3.x 和 Python2.x 的一個(gè)區(qū)別是: Python 3 可以使用直接使用 super().xxx 代替 super(type[, object-or-type]).xxx 。
super()函數(shù)用來調(diào)用MRO（類方法解析順序表）的下一個(gè)類的方法。
No.14 Mixin繼承
在設(shè)計(jì)上將Mixin類作為功能混入繼承自Mixin的類。使用Mixin類實(shí)現(xiàn)多重繼承應(yīng)該注意：
Mixin類必須表示某種功能
職責(zé)單一，如果要有多個(gè)功能，就要設(shè)計(jì)多個(gè)Mixin類
不依賴子類實(shí)現(xiàn)，Mixin類的存在僅僅是增加了子類的功能特性
即使子類沒有繼承這個(gè)Mixin類也可以工作
class Cat(object):
def eat(self):
print("I can eat.")
def drink(self):
print("I can drink.")
class CatFlyMixin(object):
def fly(self):
print("I can fly.")
class CatJumpMixin(object):
def jump(self):
print("I can jump.")
class TomCat(Cat, CatFlyMixin):
pass
class PersianCat(Cat, CatFlyMixin, CatJumpMixin):
pass
if __name__ == '__main__':
# 湯姆貓沒有跳躍功能
tom = TomCat()
tom.fly()
tom.eat()
tom.drink()
# 波斯貓混入了跳躍功能
persian = PersianCat()
persian.drink()
persian.eat()
persian.fly()
persian.jump()
No.25 上下文管理器with語句與contextlib簡(jiǎn)化
普通的異常捕獲機(jī)制：
try:
pass
except Exception as err:
pass
else:
pass
finally:
pass
with簡(jiǎn)化了異常捕獲寫法：
class Demo(object):
def __enter__(self):
print("enter...")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("exit...")
def echo_hello(self):
print("Hello, Hello...")
with Demo() as d:
d.echo_hello()
# enter...
# Hello, Hello...
# exit...
import contextlib
# 使用裝飾器
@contextlib.contextmanager
def file_open(file_name):
# 此處寫__enter___函數(shù)中定義的代碼
print("enter function code...")
yield {}
# 此處寫__exit__函數(shù)中定義的代碼
print("exit function code...")
with file_open("json.json") as f:
pass
# enter function code...
# exit function code...
No.26 序列類型的分類
容器序列：list tuple deque
扁平序列：str bytes bytearray array.array
可變序列：list deque bytearray array
不可變序列：str tuple bytes
No.27 +、+=、extend()之間的區(qū)別于應(yīng)用場(chǎng)景
首先看測(cè)試用例：
# 創(chuàng)建一個(gè)序列類型的對(duì)象
my_list = [1, 2, 3]
# 將現(xiàn)有的序列合并到my_list
extend_my_list = my_list + [4, 5]
print(extend_my_list) # [1, 2, 3, 4, 5]
# 將一個(gè)元組合并到這個(gè)序列
extend_my_list = my_list + (6, 7)
# 拋出異常 TypeError: can only concatenate list (not "tuple") to list
print(extend_my_list)
# 使用另一種方式合并
extend_my_list += (6, 7)
print(extend_my_list) # [1, 2, 3, 4, 5, 6, 7]
# 使用extend()函數(shù)進(jìn)行合并
extend_my_list.extend((7, 8))
print(extend_my_list) # [1, 2, 3, 4, 5, 6, 7, 7, 8]
由源代碼片段可知：
class MutableSequence(Sequence):
__slots__ = ()
"""All the operations on a read-write sequence.
Concrete subclasses must provide __new__ or __init__,
__getitem__, __setitem__, __delitem__, __len__, and insert().
"""
# extend()方法內(nèi)部使用for循環(huán)來append()元素，它接收一個(gè)可迭代序列
def extend(self, values):
'S.extend(iterable) -- extend sequence by appending elements from the iterable'
for v in values:
self.append(v)
# 調(diào)用 += 運(yùn)算的時(shí)候就是調(diào)用該函數(shù)，這個(gè)函數(shù)內(nèi)部調(diào)用extend()方法
def __iadd__(self, values):
self.extend(values)
return self
No.28 使用bisect維護(hù)一個(gè)已排序的序列
import bisect
my_list = []
bisect.insort(my_list, 2)
bisect.insort(my_list, 9)
bisect.insort(my_list, 5)
bisect.insort(my_list, 5)
bisect.insort(my_list, 1)
# insort()函數(shù)返回接收的元素應(yīng)該插入到指定序列的索引位置
print(my_list) # [1, 2, 5, 5, 9]
No.29 deque類詳解
deque是Python中一個(gè)雙端隊(duì)列，能在隊(duì)列兩端以$O(1)$的效率插入數(shù)據(jù)，位于collections模塊中。
from collections import deque
# 定義一個(gè)雙端隊(duì)列，長度為3
d = deque(maxlen=3)
deque類的源碼：
class deque(object):
"""
deque([iterable[, maxlen]]) --> deque object
一個(gè)類似列表的序列，用于對(duì)其端點(diǎn)附近的數(shù)據(jù)訪問進(jìn)行優(yōu)化。
"""
def append(self, *args, **kwargs):
""" 在隊(duì)列右端添加數(shù)據(jù) """
pass
def appendleft(self, *args, **kwargs):
""" 在隊(duì)列左端添加數(shù)據(jù) """
pass
def clear(self, *args, **kwargs):
""" 清空所有元素 """
pass
def copy(self, *args, **kwargs):
""" 淺拷貝一個(gè)雙端隊(duì)列 """
pass
def count(self, value):
""" 統(tǒng)計(jì)指定value值的出現(xiàn)次數(shù) """
return 0
def extend(self, *args, **kwargs):
""" 使用迭代的方式擴(kuò)展deque的右端 """
pass
def extendleft(self, *args, **kwargs):
""" 使用迭代的方式擴(kuò)展deque的左端 """
pass
def index(self, value, start=None, stop=None): __doc__
"""
返回第一個(gè)符合條件的索引的值
"""
return 0
def insert(self, index, p_object):
""" 在指定索引之前插入 """
pass
def pop(self, *args, **kwargs): # real signature unknown
""" 刪除并返回右端的一個(gè)元素 """
pass
def popleft(self, *args, **kwargs): # real signature unknown
""" 刪除并返回左端的一個(gè)元素 """
pass
def remove(self, value): # real signature unknown; restored from __doc__
""" 刪除第一個(gè)與value相同的值 """
pass
def reverse(self): # real signature unknown; restored from __doc__
""" 翻轉(zhuǎn)隊(duì)列 """
pass
def rotate(self, *args, **kwargs): # real signature unknown
""" 向右旋轉(zhuǎn)deque N步， 如果N是個(gè)負(fù)數(shù)，那么向左旋轉(zhuǎn)N的絕對(duì)值步 """
pass
def __add__(self, *args, **kwargs): # real signature unknown
""" Return self+value. """
pass
def __bool__(self, *args, **kwargs): # real signature unknown
""" self != 0 """
pass
def __contains__(self, *args, **kwargs): # real signature unknown
""" Return key in self. """
pass
def __copy__(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a deque. """
pass
def __delitem__(self, *args, **kwargs): # real signature unknown
""" Delete self[key]. """
pass
def __eq__(self, *args, **kwargs): # real signature unknown
""" Return self==value. """
pass
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass
def __getitem__(self, *args, **kwargs): # real signature unknown
""" Return self[key]. """
pass
def __ge__(self, *args, **kwargs): # real signature unknown
""" Return self>=value. """
pass
def __gt__(self, *args, **kwargs): # real signature unknown
""" Return self>value. """
pass
def __iadd__(self, *args, **kwargs): # real signature unknown
""" Implement self+=value. """
pass
def __imul__(self, *args, **kwargs): # real signature unknown
""" Implement self*=value. """
pass
def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
"""
deque([iterable[, maxlen]]) --> deque object
A list-like sequence optimized for data accesses near its endpoints.
# (copied from class doc)
"""
pass
def __iter__(self, *args, **kwargs): # real signature unknown
""" Implement iter(self). """
pass
def __len__(self, *args, **kwargs): # real signature unknown
""" Return len(self). """
pass
def __le__(self, *args, **kwargs): # real signature unknown
""" Return self<=value. """
pass
def __lt__(self, *args, **kwargs): # real signature unknown
""" Return self
pass
def __mul__(self, *args, **kwargs): # real signature unknown
""" Return self*value.n """
pass
@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass
def __ne__(self, *args, **kwargs): # real signature unknown
""" Return self!=value. """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
總結(jié)
以上是生活随笔為你收集整理的python3知识点汇总_35个高级Python知识点总结的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python为什么是蟒蛇_Python
- 下一篇： python能做哪些客户端_发布一个Ht