1. 程式人生 > 其它 >python 資料型別的內建方法

python 資料型別的內建方法

內容概要

  • 例題講解
  • 列表內建方法補充
  • 字典內建方法
  • 元祖內建方法
  • 元祖相關例題
  • 集合內建方法

內容詳細

例題詳解

1.佇列:先進先出

2.堆疊:先進後出

列表其他方法

            l1 = [44, 22, 11, 33, 99, 77, 88, 66]

            l1.sort()  # 預設是升序
            l1.sort(reverse=True)  # 引數指定 降序
            l1.reverse()  # 順序顛倒
            print(l1[::-1])  # 冒號左右兩邊不寫數字預設全都要
            print(l1[:5])  # [44,22,11,33,99]  左邊不寫預設從頭開始
            print(l1[1:])  # [22,11,33,99,77,88,66] 左邊不寫預設到尾部
            l1 = [999,111]
            l2 = [111,222,333,444,555,666,777,888]
            print(l1 > l2)  # True 列表比較運算採用相同索引元素比較 只要有一個比出了結果就直接得出結論
            s1 = 'holle world'
            s2 = 'abc'
            print(s1 > s2)  # 字串比較大小也是按照索引位置內部轉成ASCII對應的數字比較

字典內建方法

            dic = {
                'name': 'jason',
                'age': 18,
                'hobbies': ['play game', 'basketball']
            }

            # 按K取值K不存在會直接報錯
            print(dic['name'])
            print(dic['pwd'])


            # 按K修改值 新增鍵值對(使用頻率最高)
            dic['name'] = 'zhnag'  # 鍵存在為修改值
            print(dic)
            dic['hobbies'].append('resd')
            print(dic)
            dic['pwd'] = 123  # 鍵不存在為新增鍵值對
            print(dic)


            # 統計字典內部鍵值對的個數
            print(len(dic))  # 3


            # 成員運算  預設只暴露K
            print('jason' in dic)
            print('name' in dic)


            # 刪除元素
            # 方式一:
            del dic['name']
            print(dic)
            # 方式二:指定K彈出鍵值對  給出V
            print(dic.pop('age'))
            print(dic)
            # 方式三: 彈出鍵對值 組織成元祖的形式  第一個元素是K第二個元素是V(瞭解一下)
            print(dic.popitem())
            print(dic)


            # 獲取v值
            print(dic['name'])  # jason  鍵不存在直接報錯  按k取值不太推薦使用該方式
            print(dic['xxx'])  #  鍵不存在直接報錯  按k取值不太推薦使用該方式
            print(dic.get('name'))  # jason
            print(dic.get('xxx'))  # None  鍵不存在 不會報錯返回None
            print(dic.get('name', '哈哈哈'))  # 第二個引數 可以在k不存在的時候自定義返回資訊
            print(dic.get('xxx', '哈哈哈'))  # 第二個引數 可以在k不存在的時候自定義返回資訊


            # keys() values()  items()  在python2中是列表 在python3中是迭代器(老母豬)
            print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  獲取字典所有的鍵 看成列表即可
            print(dic.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  獲取字典所有的值 看成列表即可
            print(dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
            # 獲取字典裡面所有的鍵值對 組織成列表套元組的形式 元組內有兩個元素 第一個是k第二個是v


字典需要了解的方法


            # 更新字典  鍵存在則修改 不存在則建立
            dic.update({'name': 'jasonNB', 'pwd': 123})
            print(dic)

            # 初始化字典
            print(dict.fromkeys(['k1', 'k2', 'k3'], []))

            '''例題'''
            res = dict.fromkeys(['k1', 'k2', 'k3'], [])
            res['k1'].append(111)
            res['k2'].append(222)
            res['k3'].append(333)
            res['k1'] = [111,222,333]
            res['k1'].append(444)
            print(res)

            # 當鍵存在的情況下 不修改而是獲取該鍵對應的值
            print(dic.setdefault('name', 'jasonNB'))
            print(dic)
            # 當鍵不存在的情況下 新增一組鍵值對 並且該方法的結果是新增的值
            print(dic.setdefault('pwd', '123'))
            print(dic)


元組內建方法

            """
            小括號括起來 內部存放多個元素 元素與元素逗號隔開
            元素可以是任意資料 但是元組內元素不支援‘修改’(索引指向的元素的記憶體地址不能改變)
                也可以簡單的認為它是一個不可變的列表
            """
            # 型別轉換  能夠支援for迴圈的資料都可以轉換成元組
            print(tuple(111))
            print(tuple(11.11))
            print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
            print(tuple([11,22,33]))  # (11, 22, 33)
            print(tuple({'name':'jason','pwd':123}))  # ('name', 'pwd')

            # 元組第一道筆試題
            t1 = (111)  # 整型
            t2 = (11.11)  # 浮點型
            t3 = ('hello')  # 字串
            '''元組哪怕內部只有一個元素 也需要加上逗號'''
            print(type((111,)))
            '''容器型別:內部可以存放多個值的資料型別都可以稱之為容器型別
                建議:所有的容器型別在儲存資料的時候 如果內部只有一個元素 
                    那麼也推薦你加上逗號
            '''

            t = (111, 222, 333, 444, 555)
            # 索引取值
            print(t[2])
            print(t[-1])
            # 切片操作
            print(t[1:5])
            print(t[1:])
            print(t[:])
            # 步長
            print(t[1:5:2])
            # 統計元組內元素的個數
            print(len(t))  # 5
            # for迴圈
            for i in t:
                print(i)
            # count計數
            print(t.count(111))  # 1
            '''例題'''
            t1 = (111, 222, [11, 22, 33])
            t1[2].append(44)
            print(t1)


集合去重操作

            # 定義空集合需要使用關鍵字set
            s1 = set()
            # 型別轉換  能夠支援for迴圈的資料型別都可以轉成集合(元素要是不可變型別)
            '''集合內元素是無序的'''
            # 去重
            s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
            print(s1)  # {1, 2, 3, 4}
            name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
            # 先將列表轉換成集合
            s1 = set(name_list)
            # 再將去重之後的集合轉換成列表
            l1 = list(s1)
            print(l1)

            """例題"""

            ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
            # 基本要求:去重即可
            s1 = set(ll)
            ll1 = list(s1)
            print(ll1)

            # 拔高要求:去重並保留原來的順序
            # 先定義一個新列表
            new_list = []
            # for迴圈ll列表
            for i in ll:
                # 判斷當前元素是否在新列表中
                if i not in new_list:
                    # 如果不在 則新增到新列表
                    new_list.append(i)
                # 如果在 則不管
            print(new_list)

集合關係運算

            # 關係運算
            """兩個群體之間做差異比較    共同好友 共同關注..."""

            friends1 = {"zero", "kevin", "jason", "eg"}  # 使用者1的好友們
            friends2 = {"Jy", "ricky", "jason", "eg"}  # 使用者2的好友們

            # 求兩個使用者的共同好友
            print(friends1 & friends2)  # {'jason', 'eg'}

            # 求兩個使用者所有的好友
            print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}

            # 求使用者1獨有的好友
            print(friends1 - friends2)  # {'zero', 'kevin'}

            # 求使用者2獨有的好友
            print(friends2 - friends1)  # {'ricky', 'Jy'}

            # 求使用者1和使用者2各自的好友
            print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}

            # 父集與子集
            s1 = {11, 22, 33, 44}
            s2 = {11, 33}
            print(s1 > s2)  # 判斷s1是否是s2的父集   True
            print(s2 < s1)  # 判斷s2是否是s1的子集   True