python數據類型

原創 mofei12138 2018-08-24 22:05

python六大標準數據類型

  1. Number（數字）
  2. String（字符串）
  3. List（列表）
  4. Tuple（元組）
  5. Set（集合）
  6. Dictionary（字典）

注意點：

  1. Number（數字）、String（字符串）、Tuple（元組）屬於不可變數據類型
  2. List（列表）、Dictionary（字典）、Set（集合）屬於可變數據類型
  3. 內置的 type() 函數可以用來查詢變量所指的對象類型。isinstance 和 type 的區別在於：type()不會認爲子類是一種父類類型。isinstance()會認爲子類是一種父類類型。

 

一、Number（數字）

  1. int（有符號整型）
  2. float（浮點型）
  3. bool（布爾型）
  4. complex（複數）

用法：

  1. +，-，*，/，%
  2. // 除法，得到一個整數，即地板除
  3. ** 乘方
  4. 浮點型也可以用科學計數法表示，2.5e2= 2.5 x 102 = 250
  5. 複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示，複數的實部a和虛部b都是浮點型。

注意點：

  1. 在python2.x中，當你的數值小於int範圍的時候，就是int變量，當大於int範圍的時候，就是long類型了。當變量大於int範圍的時候，python會自動幫你把數據類型轉爲long類型的。在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647,在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807
  2. 在Python 3裏，只有一種整數類型 int，表示爲長整型，沒有 python2 中的 Long。Python3 整型是沒有限制大小的
  3. 整數除法返回浮點型，不同類型的數混合運算時會將整數轉換爲浮點數
  4. 在 Python2 中是沒有布爾型的，它用數字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加。

數學函數：

  1. abs(x)，返回數字的絕對值，如abs(-10) 返回 10
  2. ceil(x)，返回數字的上入整數，如math.ceil(4.1) 返回 5
  3. cmp(x, y)，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已廢棄 。使用 使用 (x>y)-(x<y) 替換
  4. exp(x)，返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
  5. fabs(x)，返回數字的絕對值，如math.fabs(-10) 返回10.0
  6. floor(x)，返回數字的下舍整數，如math.floor(4.9)返回 4
  7. log(x)，如math.log(math.e)返回1.0,math.log(100,10)返回2.0
  8. log10(x)，返回以10爲基數的x的對數，如math.log10(100)返回 2.0
  9. max(x1, x2,...)，返回給定參數的最大值，參數可以爲序列。
  10. min(x1, x2,...)，返回給定參數的最小值，參數可以爲序列。
  11. modf(x)，返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
  12. pow(x, y)，x**y 運算後的值。
  13. round(x [,n])，返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。
  14. sqrt(x)，返回數字x的平方根

用法案例：

# Python3 整型是沒有限制大小的
a = 922337203685477580811
print(type(a))
# // 得到的並不一定是整數類型的數
print(7 / 2)  # 3.5
print(7 // 2)  # 3
print(7.0 / 2)  # 3.5
print(7.0 // 2)  # 3.0
"""數學函數"""
# abs,ceil,cmp,exp,fabs,floor,log,log10,max,min,modf,pow,round,sqrt
# 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
print(math.modf(10.3))
"""隨機數"""
# choice,randrange,random,seed,shuffle,uniform,randint
for i in range(20):
    # 從序列的元素中隨機挑選一個元素
    print(random.choice(range(10)), end='')
print()  # 33430436396496623185
for i in range(20):
    # 從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數缺省值爲1
    print(random.randrange(2, 10, 2), end='')
print()  # 28626622688248468282
# 隨機生成下一個實數,它在[0,1)範圍內。
print(random.random())  # 0.6905597758450086
# 使用相同的隨機數種子，相同的次序生成的隨機數是相同的
random.seed(1)
print(random.random())
# 將序列的所有元素隨機排序
a = [1, 2, 3, 4, 5]
random.shuffle(a)
print(a)  # [5, 2, 3, 4, 1]
# 隨機生成下一個實數，它在[x, y]範圍內。
for i in range(4):
    print(random.uniform(1, 9), end=' ')
print()  # 7.643509634313039 1.817455568060705 8.719267117297669 6.719165339718973
# 隨機生成[x, y]的整數
for i in range(20):
    print(random.randint(0, 3), end='')
print()  # 30330321020000313013
"""三角函數"""
# acos,asin,atan,atan2,cos,hypot,sin,tan,degress,radians
# 返回歐幾里德範數 sqrt(x*x + y*y)。
print(math.hypot(3, 4))  # 5.0
# 將弧度轉換爲角度
print(math.degrees(math.pi / 2))  # 90.0
# 將角度轉換爲弧度
print(math.radians(180))  # 3.141592653589793
"""數學常量"""
print(math.pi)  # 3.141592653589793
print(math.e)  # 2.718281828459045

 

二、String（字符串）

用法：

  1. 字符串可以使用+和*操作
  2. 字符串可以進行切片操作
  3. in操作 可以判斷一個字符串在不在另一個字符串中 'a' in 'abbc'
  4. 字符串拼接方式
    1. 'a' + 'b'
    2. '%sxxx%sx' % ('a', 'b') 字符串格式化
    3. ''.join(['a', 'b']
    4. 字符串用+拼接會多開闢內存空間， 最好使用%格式化字符串，或者.format
    5. join方式在大量數據拼接時快於+方式， 參考該文章http://www.sohu.com/a/162334410_776230，結論是如果連接的字符串很少，只有幾個或者十幾個，完全可以通過「+」來連接，畢竟這種方式更直白，而超過一定個數之後，則應該採用「join」方法，只有在操作大數據的時候，兩者的對比才明顯。

注意點：

  1. 字符串前面加r是代表這個string是raw string，讓反斜槓不發生轉義
  2. 字符串不能被改變
  3. 反斜槓(\)可以作爲續行符，表示下一行是上一行的延續。也可以使用 """...""" 或者 '''...''' 跨越多行。

用法案例：

# 反斜槓(\)可以作爲續行符，表示下一行是上一行的延續。
# 也可以使用 """...""" 或者 '''...''' 跨越多行。
a = '111' \
    '222'
b = '''33\
444\
555'''
print(a)  # 111222
print(b)  # 33444555
print(a[3])  # 2
print(a[0:3])  # 111
"""字符串內建函數"""
st = 'hello world'
print(st.count('l'))  # 統計元素個數        3
print(st.capitalize())  # 首字母大寫         Hello world
print(st.center(50, '-'))  # 居中                -------------------hello world--------------------
print(st.encode('utf-8'))
print(st.endswith('ld'))  # 是否以某個字符串結尾
print(st.startswith('he'))  # 是否以某個字符串開頭
print('he\tllo world'.expandtabs(20))  # tab替換成n個空格       he                  llo world
print(st.find('e'))  # 查找到第一個匹配的元素，並返回索引值        1
print('hello {1} world {0} {name}'.format('and', 'hi', name='xxx'))  # 格式化字符串       hello hi world and xxx
print('hello {{world}} {name}'.format_map({'name': 'xxx'}))  # 格式化字符串       hello {world} xxx
print(st.index('l'))  # 找不到會報錯，find找不到返回-1        2
print('abc123'.isalnum())  # 只包含數字字母
print('11'.isdecimal())  # 是否爲十進制數
print('222'.isdigit())  # 是否爲數字
print('222'.isnumeric())  #
print('b222'.isidentifier())  # 是否合法變量名
print('asdad'.islower())  # 字符串裏的字母是否全部小寫
print('ADSD'.isupper())  # 字符串裏的字母是否全部大寫
print(' \t\r\n'.isspace())  # 是否爲空白符(空格，製表，回車)
print('Adsadsd Bs'.istitle())  # 每個單詞首字母大些
print('AvdsVSDF'.lower())  # avdsvsdf
print('AvdsVSDF'.upper())  # AVDSVSDF
print('AvdsVSDF'.swapcase())  # aVDSvsdf
print(st.ljust(50, '-'))  # 靠左        hello world---------------------------------------
print(st.rjust(50, '-'))  # 靠右        ---------------------------------------hello world
print('\t 1 354z\n'.strip())  # 去掉兩邊的空白符號(空格，製表，回車)
print('\t 1 354z\n'.lstrip())  # 去左
print('\t 1 354z\n'.rstrip())  # 去右
print('123a11sd'.replace('1', 'aa', 1))  # 替換一次      aa23a11sd
print('123a11sd'.rfind("1"))  # 同find 從右往左找   5
print('123,213,321'.split(','))  # 分割成列表，list.join的逆過程 ['123', '213', '321']
print('123,213,321'.rsplit(',', 1))  # 從右往左 分割一次 ['123,213', '321']
print('s\na\n'.splitlines())  # 根據換行符分割
print('123 asd aqsz'.title())  # 單詞首字母變成大寫
print('qq ww ee'.translate(str.maketrans('qwe', '123')))  # 11 22 33
print(max('abc'))  # c
print(min('abc'))  # a
print('1'.zfill(2))  # 前面補0  01

 

三、List（列表）

用法：

  1. 查：
    1. 索引(下標)，是從0開始的
    2. 切片操作
    3. .count()查某個元素的出現次數
    4. .index()根據內容找其所在的位置
    5. 'xx' in a 根據內容查看是否在列表中
  2. 增：
    1. .append('xx')追加
    2. .insert(index, "xx") 在index位置前插入元素
    3. .extend() 擴展
    4. + × 兩個列表相加，乘一個整數
  3. 改：
    1. a[index] = "xx"
    2. a[start: end] = ['aa', 'bb']
  4. 刪除：
    1. a.remove('xx')
    2. a.pop(index) 不指定index刪除最後一個
    3. del a, del a[1]
    4. a.clear() 清空列表
  5. 排序
    1. a.sort()
    2. a.reverse()
  6. 身份判斷
    1. type(a) is list 用==結果相同

enumerate用法：

  1. 一個列表既要遍歷索引又要遍歷元素時用enumerate，如for index, item in enumerate(list1)
  2. enumerate還可以接收第二個參數，用於指定索引起始值,默認爲0
  3. enumerate()返回的對象其實是由一個個元組組成的，可以賦給一個變量，也可以賦給兩個變量
  4. python可以直接交換兩個變量的位置，其他語言基本不可以

用法案例：

"""list的增刪改查和其他常用方法"""
# 查
a = ['aa', 'bb', 'cc', 'dd', 'ee']
print(a[1:])  # ['bb', 'cc', 'dd', 'ee']
print(a[1:-1])  # ['bb', 'cc', 'dd']
print(a[1::2])  # ['bb', 'dd']
print(a[3::-2])  # ['dd', 'bb']
print(a[3::-1])  # ['dd', 'cc', 'bb', 'aa']
print(a.count('aa'))  # 1
print(a.index('aa'))  # 0
print('aa' in a)  # True
# 查找第二個aa的位置
b = ['aa', 'bb', 'aa', 'cc', 'dd', 'ee']
print(b.index('aa', b.index('aa') + 1))  # 2
# 增
a.append('ff')
a.insert(1, 'ss')
print(a)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff']
print(a + ['gg'])  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg']
print(a * 2)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff']
# b的元素加到a列表中
b = ['hh', 'jj']
a.extend(b)
print(a)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
print(b)  # ['hh', 'jj']
# 改
a[1] = 'hh'
print(a)  # ['aa', 'hh', 'bb', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
a[1:3] = ['q', 'w']
print(a)  # ['aa', 'q', 'w', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
# 刪
a.remove('q')
print(a)  # ['aa', 'w', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
print(a.pop(1))  # w
print(a)  # ['aa', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
del a[1:3]
print(a)  # ['aa', 'ee', 'ff', 'hh', 'jj']
del a
# print(a) # name 'a' is not defined
a = ['aa', 'ee', 'ff', 'hh', 'jj']
a.clear()
print(a)
# 反轉列表
a = ['aa', 'ee', 'ff', 'hh', 'jj']
a.reverse()
print(a)  # ['jj', 'hh', 'ff', 'ee', 'aa']
# 按升序排序, 字符串會按照ascii大小
x = [4, 6, 2, 1, 7, 9]
x.sort()
print(x)  # [1, 2, 4, 6, 7, 9]
# 按降序排序
x.sort(reverse=True)
print(x)  # [9, 7, 6, 4, 2, 1]
# 身份判斷
print(type(x) is list)  # True

 

四、Tuple（元組）

用法：

  1. 查操作，+ ×操作，身份判斷都和列表用法相同

注意點：

  1. 不可變對象，tuple的元素不可改變，但它可以包含可變的對象，比如list列表。
  2. 構造包含 0 個或 1 個元素的元組比較特殊，有一些額外的語法規則：
    1. tup1 = () # 空元組
    2. tup2 = (20,) # 一個元素，需要在元素後添加逗號
  3. 可以把字符串看作一種特殊的元組。

用法案例：

"""元組 查,+*,身份判斷"""
# 查
a = ('aa', 'bb', 'cc', 'dd', 'ee')
print(a[1:2])  # ('bb',)
print(a.count('aa'))  # 1
print(a.index('aa'))  # 0
print('aa' in a)  # True
# +*操作
print(a + ('ff',))  # ('aa', 'bb', 'cc', 'dd', 'ee', 'ff')
print(a * 2)  # ('aa', 'bb', 'cc', 'dd', 'ee', 'aa', 'bb', 'cc', 'dd', 'ee')
# 身份判斷
print(type(a) is tuple)  # True
# 創建方式，創建1個與元素的元組
a = ('aa',)
print(a)  # ('aa',)

 

五、Set（集合）

注意點：

  1. 集合（set）是一個無序不重複元素的序列。可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
  2. frozenset是不可變的集合，創建後不可更改

用法：

  1. 創建方式：
    1. a= {'a', 'b', 'r', 'a', 'c', 'a'}
    2. a = set('abracadabra')
  2. 增：
    1. a.add('q')
    2. a.update([5, 'c']) # 添加多個元素
    3. a.update('1234') # 添加4個元素
  3. 刪：
    1. a.remove(2) # 刪除2這個元素
    2. a.pop() # 不確定刪除哪個
    3. a.clear()
  4. 運算：
    1. ==，判斷是否相等
    2. <和>，a<b判斷a是否爲b的真子集
    3. 並集：
      1. a | b
      2. a.union(b)
    4. 交集：
      1. a & b
      2. a.intersection(b)
    5. 差集：
      1. a - b
      2. a.difference(b)
    6. 對稱差集（不同時存在的元素）：
      1. a ^ b
      2. a.symmetric_difference(b)
    7. 父集：
      1. a.issuperset(b)
    8. 子集：
      1. a.issubset(b)

用法案例：

"""set增刪，運算"""
# 創建方式
a = {1, 2, 3}
print(a)  # {1, 2, 3}
print(type(a))  # <class 'set'>
f = frozenset({1, 2})
print(f)  # frozenset({1, 2})
print(type(f))  # <class 'frozenset'>
# 增
a.add('q')
print(a)  # {1, 2, 3, 'q'}
a.update([5, 'c'])  # 添加多個元素
print(a)  # {1, 2, 3, 5, 'c', 'q'}
a.update('1234')
print(a)  # {1, 2, 3, '4', 5, '1', '2', 'c', 'q', '3'}
# 刪
a.remove(2)
print(a)  # {1, 3, '4', 5, '1', '2', 'c', 'q', '3'}
a.pop()  # 不確定刪除哪個
print(a)  # {3, '4', 5, '1', '2', 'c', 'q', '3'}
a.clear()
print(a)  # set()
# 運算
print(set('aa1') == set('a111'))  # True
print(set('aa1') < set('a1112'))  # True 前者是後者的真子集
print(set('aa1') | set('bb21'))  # 並集
print(set('aa1').union(set('bb21')))  # {'1', '2', 'a', 'b'}
print(set('aa21') & set('bb21'))  # 交集
print(set('aa21').intersection(set('bb21')))  # {'1', '2'}
print(set('aa1') - set('a2'))  # 差集
print(set('aa1').difference(set('a2')))  # {'1'}
print(set('aa1') ^ set('a2'))  # 對稱差集
print(set('aa1').symmetric_difference(set('a2')))  # {'1', '2'}
print(set('aa1').issuperset(set('a')))  # True 父集
print(set('a').issubset(set('a1')))  # True 子集

六、Dictionary（字典）

注意點：

  1. key只能用不可變類型
  2. key是唯一的
  3. 鍵值對是無序存儲的

用法：

  1. 創建方式：
    1. d = dict.fromkeys(['q', 'w', 'e'], 'test')
    2. a = {"name": "xx"}
  2. 查：
    1. d['xx']
    2. d.get('xxx')
    3. d.setfault('xx', 10)
    4. list(a.keys()),list(a.values()),list(a.items()
  3. 增：
    1. d["xxx"] = 21
    2. d.update(d2) 把d2字典的內容加到d字典中去
  4. 改：
    1. d["xxx"] = 21
  5. 刪除：
    1. del d['xx']
    2. del d
    3. d.clear()
    4. a.pop('hobby')
    5. a.popitem() 刪除內容不可預測
  6. 排序
    1. sorted(a)，sorted(a.keys())，sorted(a.values())
  7. 遍歷
    1. for k, v in d.items()，for k in d

用法案例：

"""dict增刪改查，排序，遍歷"""
# 創建方式
a = dict.fromkeys(['q', 'w', 'e'], 'test')
print(a)  # {'q': 'test', 'w': 'test', 'e': 'test'}
a = {'name': 'xx', 'age': 21}
print(a)  # {'name': 'xx', 'age': 21}
# 查
print(a['name'])  # xx
print(a.get('name'))  # xx
# setdefault()若鍵存在返回相應的值，不存在則添加鍵值對並返回值
print(a.setdefault('age', 34))  # 21
print(a.setdefault('hobby', 'game'))  # game
print(a)  # {'name': 'xx', 'age': 21, 'hobby': 'game'}
# 取所有鍵，所有值，所有鍵值對
print(list(a.keys()))  # ['hobby', 'age', 'name']
print(list(a.values()))  # ['game', 21, 'xx']
print(list(a.items()))  # [('hobby', 'game'), ('age', 21), ('name', 'xx')]
# 增
# 添加鍵值對 或 修改值
a['age'] = 30
print(a)  # {'name': 'xx', 'age': 30, 'hobby': 'game'}
# update 將a字典的元素逐個放到b裏，鍵相同的則覆蓋
b = {'name': 'aa', 'qq': 1}
b.update(a)
print(b)  # {'name': 'xx', 'qq': 1, 'age': 30, 'hobby': 'game'}
# 刪除
del a['name']
print(a)  # {'age': 30, 'hobby': 'game'}
# del a
# print(a)  # name 'a' is not defined
a.clear()
print(a)  # {}
a = {'age': 21, 'hobby': 'game', 'name': 'xx'}
print(a.pop('hobby'))  # game
print(a)  # {'age': 21, 'name': 'xx'}
print(a.popitem())  # ('name', 'xx') 刪除內容不可預測
# 其他操作
a = {'age': '21', 'hobby': 'game', 'name': 'xx'}
print(sorted(a))  # ['age', 'hobby', 'name']
print(sorted(a.keys()))  # ['age', 'hobby', 'name']
print(sorted(a.values()))  # ['21', 'game', 'xx']
# 遍歷
for k in a:
    print(k, a[k], sep=':', end=',')  # age:21,name:xx,hobby:game,
print()
for k, v in a.items():
    print(k, v, sep=':', end=',')  # age:21,name:xx,hobby:game, 效率比上面那種低

七、數據類型的轉換

  1. int(x [,base])，將x轉換爲一個整數
  2. float(x)，將x轉換到一個浮點數
  3. complex(real [,imag])，創建一個複數
  4. str(x)，將對象 x 轉換爲字符串
  5. repr(x)，將對象 x 轉換爲表達式字符串
  6. eval(str)，用來計算在字符串中的有效Python表達式,並返回一個對象
  7. tuple(s)，將序列 s 轉換爲一個元組
  8. list(s)，將序列 s 轉換爲一個列表
  9. set(s)，轉換爲可變集合
  10. dict(d)，創建一個字典。d 必須是一個序列 (key,value)元組。
  11. frozenset(s)，轉換爲不可變集合
  12. chr(x)，將一個整數轉換爲一個字符
  13. ord(x)，將一個字符轉換爲它的整數值
  14. hex(x)，將一個整數轉換爲一個十六進制字符串
  15. oct(x)，將一個整數轉換爲一個八進制字符串

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

亂序拼圖驗證的識別並還原 puzzle-captcha（開源）

一、前言 亂序拼圖驗證是一種較少見的驗證碼防禦，市面上更多的是拖動滑塊，被完美攻克的有不少，都在行爲軌跡上下足了功夫，本文不討論軌跡模擬範疇，就只針對拼圖還原進行研究。 找一個市面比較普及的頂像亂序拼圖進行驗證，它號稱的防禦能力4星，

S.F. 2021-12-01 00:53:28

【轉載】Python處理csv文件

Python處理csv文件 CSV(Comma-Separated Values)即逗號分隔值，可以用Excel打開查看。由於是純文本，任何編輯器也都可打開。與Excel文件不同，CSV文件中： 值沒有類型，所有值都是字符串 不能指定字

zqh 2020-07-18 14:25:30

Error:field larger than field limit(131072)解決方法

從csv文件讀取某一列的數據時，報錯顯示：Error:field larger than field limit(131072) 通過判斷髮現是因爲文件的行數超過csv限制的行數，所以導致結果既無法在控制檯打印，試着轉到df,存成csv文

hammring 2020-07-08 12:39:29

啓動Jupyter時, 遇到 sudo: jupyterhub: command not found 問題的解決方案

最近在學習Jupyter, 但是我發現啓動不了多用戶的JupyterHub 官網的教程: sudo jupyterhub 直接輸入就會導致這樣子的結果 後面我各種谷歌百度,都好複雜,然後我突然想到,這是沒有Jupyterhub

钢琴线与小刀 2020-07-08 12:39:19

Python小記 —— 文件讀寫操作裏read()方法的深究

** 語法 ** 格式：read(size) 在read()方法裏，size表示要從文件中讀取的數據長度，如果沒有指定size或者指定爲“None”就表示讀取文件裏的全部數據。 特別需要注意點： read()的讀取機制因訪問文件

柘月十七 2020-07-08 12:33:27

python使用pip指令安裝並引用第三方模塊及注意事項

python裏有內置模塊、自定義模塊還有第三方模塊。 內置模塊就是python自帶的模塊了，我們直接引用就可以了，如：import sys。自定義模塊就是按照我們編程者的需求以方便編寫程序和維護代碼的一些“.py文件”，簡單地說，

柘月十七 2020-07-08 12:33:27

python小記 —— sys.argv

sys.argv到底是什麼? sys.argv是運行在黑屏終端運行python文件獲取的參數。即返回一個包含輸入參數的列表。 話不多說了看下面，反手就是一堆代碼： import sys print("list長度：",len(sy

柘月十七 2020-07-08 12:33:16

Django Signals 信號

文章目錄Django Signals 信號入門connect Django Signals 信號 入門 # receiver 接收者 def my_callback(sender, **kwargs): print sen

冯斯特罗 2020-07-08 12:31:35

sorted 在python2和3中的區別

文章目錄sorted 在python2和3中的區別 sorted 在python2和3中的區別 python3中取消了cmp參數 python3中的使用方法如下: from functools import cmp_to_key

冯斯特罗 2020-07-08 12:31:35

python3 排序 sort sorted

排序穩定性和排序複雜度 排序保證是 穩定 的。 這意味着當多個記錄具有相同的鍵值時，將保留其原始順序。 >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >

冯斯特罗 2020-07-08 12:31:35

python3 super 用法2

class MetaCls(type): def __new__(cls, *args, **kwargs): print("in MetaCls") # return super(Meta

冯斯特罗 2020-07-08 12:31:35

meta class 和 類裝飾器的執行順序

meta class 和類裝飾器的執行順序 先執行decorator,後執行metaclass 程序是從上到下執行,先遇到decorator,後遇到class,創建class 調用metaclass. 同理,裝飾器也是先執行上面的

冯斯特罗 2020-07-08 12:31:35

弱引用 weakref

弱引用 weakref 對對象的弱引用不能保證對象存活：當對像的引用只剩弱引用時， garbage collection 可以銷燬引用並將其內存重用於其他內容。但是，在實際銷燬對象之前，即使沒有強引用，弱引用也一直能返回該對象。

冯斯特罗 2020-07-08 12:31:35

python神級數據結構namedtuple

python神級數據結構namedtuple from collections import namedtuple 以前就知道有這個東西,也知道如何使用,但是沒覺得有什麼實際用處. 上次看框架源碼,無意間看到這個,發現非常好用.

冯斯特罗 2020-07-08 12:31:35

python3 super 用法

python3 super 用法 標題黨了. 其實我也不確定這是不是python3的用法. 但是,今天工作的時候遇到了不一樣的寫法,試了一下,運行成功. 剛剛在官網找到了一個例子.以後用的更有底氣了. class C(B):

冯斯特罗 2020-07-08 12:31:35