<input id="ohw05"></input>
  • <table id="ohw05"><menu id="ohw05"></menu></table>
  • <var id="ohw05"></var>
  • <code id="ohw05"><cite id="ohw05"></cite></code>
    <label id="ohw05"></label>
    <var id="ohw05"></var>
  • 【python基礎】第11回 數據類型內置方法 02

    本章內容概要

    列表內置方法

    字典內置方法

    元組內置方法

    集合內置方法

    可變類型與不可變類型

    本章內容詳細

    1.列表內置方法 list

    列表在調用內置方法之后不會產生新的值

    1.1 統計列表中的數據值的個數

    l1 = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
    l2 = [77, 22, 55, 33, 44, 99]
    # 統計列表中數據的個數
    print(len(l1))  # 5
    print(len(l2))  # 6

    2.增

    2.1 尾部追加數據值append() 括號內無論寫什么數據類型 都是當成一個數據值增加

    # 2.1尾部追加數據值append() 括號內無論寫什么數據類型 都是當成一個數據值追加
    res = l1.append('owen')
    print(res)  # None 空
    print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry', 'owen']

    s1 = '$hello$'
    res1 = s1.split('$')
    print(res1)  # ['', 'hello', '']
    print(s1)  # $hello$
    l1.append([1, 2, 3, 4, 5])
    print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry', [1, 2, 3, 4, 5]]

     2.2 任意位置插入數據值insert 括號內i而什么數據類型 都是當成一數據子方恒

    # 意位置插入數據值insert() 括號內無論寫什么數據類型 都是當成一個數據值插入
    l1.insert(0, [1, 2, 3])
    print(l1)  # [[1, 2, 3], 'jason', 'kevin', 'oscar', 'tony', 'jerry']
    l2.insert(0, '插隊')  # ['插隊', [1, 2, 3], 'jason', 'kevin', 'oscar', 'tony', 'jerry']
    print(l2)

     2.3 擴展列表

    方式1

    # 2.3 擴展列表
    new_1 = [11, 22, 33, 44, 55]
    new_2 = [1, 2, 3]
    # 方式1
    for i in new_1:
        new_2.append(i)
    print(new_2)  # [1, 2, 3, 11, 22, 33, 44, 55

     方式2

    # 方式2
    print(new_1 + new_2)  # [11, 22, 33, 44, 55, 1, 2, 3]

     方式3(推薦使用)  extend

    # 方式3(推薦使用)
    new_1.extend(new_2) # 括號里面必須是支持for循環的數據類型  for循環+append()
    print(new_1)  # [11, 22, 33, 44, 55, 1, 2, 3]

     3.查詢數據與修改數據

    # 3.查詢數據與修改數據
    print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry']
    print(l1[0])  # jason
    print(l1[1:4])  # ['kevin', 'oscar', 'tony']
    l1[0] = 'jasonNM'
    print(l1)  # ['jasonNM', 'kevin', 'oscar', 'tony', 'jerry']

    4.刪除數據

    4.1通用數據策略

    # 4.1通用數據策略
    del l1[0]  # 通過索引即可
    print(l1)  # ['kevin', 'oscar', 'tony', 'jerry']

     4.2指名道姓的刪除 remove

    # 4.2 指名道姓刪除
    res = l1.remove('jason')  # 括號內必須填寫明確的數據值
    print(l1, res)  # ['kevin', 'oscar', 'tony', 'jerry'] None

     4.3 先取出數值 在刪除  pop

    # 4.3 先取出數據值 然后再刪
    res = l1.pop()  # 默認取出列表尾部數據值 然后再刪
    print(l1, res)  # ['jason', 'kevin', 'oscar', 'tony'] jerry
    res = l1.pop(0)
    print(res, l1)  # jason ['kevin', 'oscar', 'tony']

     5.查看索引值 index

    # 5.查看數據值對于的索引值
    print(l1.index('jason'))

     6.統計某個數據值出現的數據 append

    # 6.統計某個數據值出現的次數
    l1.append('jason')
    print(l1.count('jason'))  # 2

     7.排序 sort 升序  sort(reverse=True)  降序    b.sort(key=a.index)  去重b按a的列表排序

    l2.sort()  # 升序  [22, 33, 44, 55, 77, 99]
    print(l2)
    l2.sort(reverse=True)  # 降序
    print(l2)  # [99, 77, 55, 44, 33, 22]

    8.翻轉 reverse

    l1.reverse()  # 前后跌倒
    print(l1)  # ['jerry', 'tony', 'oscar', 'kevin', 'jason']

     9.比較運算

    new_1 = [99, 22]
    new_2 = [11, 22, 33, 44]
    print(new_1 > new_2)  # True 是按照位置順序一一比較

    new_1 = ['a', 11]
    new_2 = [11, 22, 33, 44]
    print(new_1 > new_2)  # 不同數據類型之間默認無法直接做操作

    new_1 = ['a', 11]           # a 97
    new_2 = ['A', 22, 33, 44]   # A 65
    print(new_1 > new_2)  # True
    new_1 = ['', 11]           # a 97
    new_2 = ['', 22, 33, 44]   # A 65  
    print(new_1 > new_2)  # False

    2.字典內置方法 dict

    字典很少涉及到類型轉換 都是直接定義使用

    # 類型轉換(了解即可) 字典很少涉及到類型轉換 都是直接定義使用
    print(dict([('name', 'jason'), ('pwd', 123)]))  # {'name': 'jason', 'pwd': 123}
    print(dict(name='jason', pwd=123))  # {'name': 'jason', 'pwd': 123}

    1.字典內k:v鍵值對是無序的

    2.取值

    # 2.取值操作
    print(info['username'])  # 不推薦使用 鍵不存在會直接報錯
    print(info['xxx'])  # 不推薦使用 鍵不存在會直接報錯
    print(info.get('username'))  # jason
    print(info.get('xxx'))  # None
    print(info.get('username', '鍵不存在返回的值 默認返回None'))  # jason
    print(info.get('xxx', '鍵不存在返回的值 默認返回None'))  # 鍵不存在返回的值 默認返回None
    print(info.get('xxx', 123))  # 123
    print(info.get('xxx'))  # None

    3.統計字典中鍵值對的個數  len

    print(len(info))  # 3

     4.修改數據

    info['username'] = 'jasonNB'  # 鍵存在則是修改
    print(info) # {'username': 'jasonNB', 'pwd': 123, 'hobby': ['read', 'run']}

     5.新增數據 

    # 5.新增數據
    info['salary'] = 6  # 鍵不存在則是新增
    print(info)  # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6}

     6.刪除數據 

    方式1

    # 方式1
    del info['username']
    print(info)  # {'pwd': 123, 'hobby': ['read', 'run']}

     方式2

    res = info.pop('username')
    print(info, res)  # {'pwd': 123, 'hobby': ['read', 'run']} jason

     方式3

    # 方式3
    info.popitem()  # 隨機刪除
    print(info)  # {'username': 'jason', 'pwd': 123}

     7.快速獲取鍵 值 鍵值對數據

    print(info.keys())  # 獲取字典所有的k值 結果當成是列表即可dict_keys(['username', 'pwd', 'hobby'])
    print(info.values())  # 獲取字典所有的v值 結果當成是列表即可dict_values(['jason', 123, ['read', 'run']])
    print(info.items())  # 獲取字典kv鍵值對數據 組織成列表套元組dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])

     8.修改字典數據 鍵存在則是修改 鍵不存在則是新增

    # 8.修改字典數據   鍵存在則是修改  鍵不存在則是新增
    info.update({'username':'jason123'})
    print(info)  # {'username': 'jason123', 'pwd': 123, 'hobby': ['read', 'run']}
    info.update({'xxx':'jason123'})
    print(info)  # {'username': 'jason123', 'pwd': 123, 'hobby': ['read', 'run'], 'xxx': 'jason123'}

     9.快速構造字典 給的值默認情況下所有的鍵都用一個

    # 9.快速構造字典  給的值默認情況下所有的鍵都用一個
    res = dict.fromkeys([1, 2, 3], None)
    print(res)  # {1: None, 2: None, 3: None}
    new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}
    new_dict['name'] = []
    new_dict['name'].append(123)
    new_dict['pwd'].append(123)
    new_dict['hobby'].append('read')
    print(new_dict)  # {'name': [123], 'pwd': [123, 'read'], 'hobby': [123, 'read']}

    res = dict.fromkeys([1, 2, 3], 234234234234234234234)
    print(id(res[1]))  # 2340954113104
    print(id(res[2]))  # 2340954113104
    print(id(res[3]))  # 2340954113104

     10.鍵存在則獲取鍵對應的值 鍵不存在則設置 并返回設置的新值

    3.元組內置方法 tuple

    # 關鍵字 tuple
    # 類型轉換  支持for循環的數據類型都可以轉元組
    print(tuple(123))  # 不可以
    print(tuple(123.11))  # 不可以
    print(tuple('zhang'))  # 可以
    t1 = ()  # tuple
    print(type(t1))
    t2 = (1)  # int
    print(type(t2))
    t3 = (11.11)  # float
    print(type(t3))
    t4 = ('jason')  # str
    print(type(t4))

    當元組內只有一個數據值的時候 逗號不能省略,如果省略了 那么括號里面是什么數據類型就是什么數據類型
    建議:編寫元組 逗號加上 哪怕只有一個數據(111, ) ('jason', )ps:以后遇到可以存儲多個數據值的數據類型 如果里面只有一個數據 逗號也趁機加上

    t2 = (1,)  # tuple
    print(type(t2))
    t3 = (11.11,)  # tuple
    print(type(t3))
    t4 = ('jason',)  # tuple
    print(type(t4))

     1.統計元組內個數

    t1 = (11, 22, 33, 44, 55, 66)
    # 1.統計元組內數據值的個數
    print(len(t1))  # 6

     2.查與改

    # 2.查與改
    print(t1[0])  # 可以查  11
    t1[0] = 222  # 不可以改
    """元組的索引不能改變綁定的地址"""

    t1 = (11, 22, 33, [11, 22])
    t1[-1].append(33)
    print(t1)  # (11, 22, 33, [11, 22, 33])

    4.集合內置方法 set

    set() 類型轉換 支持for循環的 并且數據必須是不可變類型

    1.定義空集合需要使用關鍵字才可以
    2.集合內數據必須是不可變類型(整型 浮點型 字符串 元組 布爾值)

    3.去重

    # 去重
    s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
    print(s1)  # {1, 2, 3, 4, 5, 12}
    l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
    s2 = set(l1)
    l1 = list(s2)
    print(l1)  # ['jason', 'tony', 'oscar']

    4.模擬兩個人的好友集合

    1.求f1和f2的共同好友

    f1 = {'jason', 'tony', 'oscar', 'jerry'}
    f2 = {'kevin', 'jerry', 'jason', 'lili'}
    # 1.求f1和f2的共同好友
    print(f1 & f2)  # {'jason', 'jerry'}

    2.求f1/f2獨有好友

    print(f1 - f2)  # {'oscar', 'tony'}
    print(f2 - f1)  # {'lili', 'kevin'}

     3.求f1和f2所有的好友

    print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}

     4.求f1和f2各自獨有的好友(排除共同好友)

    print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'}

     5.父集 子集

    # 5.父集 子集
    s1 = {1, 2, 3, 4, 5, 6, 7}
    s2 = {3, 2, 1}
    print(s1 > s2)  # s1是否是s2的父集  s2是不是s1的子集
    print(s1 < s2)

    5.可變類型與不可變類型

    為什么字符串調用內置方法是產生新的值 列表調用內置方法是改變自身

    1.可變類型  list  值改變(內置方法) 內存地址可以不變

    # 為什么字符串調用內置方法是產生新的值  列表調用內置方法是改變自身
    # 1.可變類型 list 值改變(內置方法) 內存地址可以不變
    l1 = [11, 22, 33]
    print(id(l1))  # 1359453669056
    l1.append(44)  # [11, 22, 33, 44]
    print(id(l1))  # 1359453669056

     2.不可變類型 str int float 值改變(內置方法),內存地址肯定變

    # 2.不可變類型 str int float 值改變(內置方法),內存地址肯定變
    s1 = '$hello$'
    print(id(s1))  # 2807369626992#
    s1 = s1.strip('$')
    print(id(s1))  # 2807369039344
    ccc = 666
    print(id(ccc))  # 2807369267664
    ccc = 990
    print(id(ccc))  # 2807374985904

     作業

    # 1.
    # 利用列表編寫一個員工姓名管理系統
    # 輸入1執行添加用戶名功能
    # 輸入2執行查看所有用戶名功能
    # 輸入3執行刪除指定用戶名功能
    # ps: 思考如何讓程序循環起來并且可以根據不同指令執行不同操作
    # 提示: 循環結構 + 分支結構
    # 拔高: 是否可以換成字典或者數據的嵌套使用完成更加完善的員工管理而不是簡簡單單的一個用戶名(能寫就寫不會沒有關系)

     

    # 5.定義列表模擬數據庫存儲用戶名
    name_list = []
    # 3.添加循環
    while True:
        # 4.添加功能顯示
        print("""
            1.添加用戶名功能
            2.查看所有用戶名功能
            3.執行刪除指定用戶名功能
        """)
        # 1.獲取用戶輸入的指令
        choice = input('please input your command>>:').strip()
        # 2.判斷用戶輸出的指令 利用print模擬功能
        if choice == '1':
            # 6.獲取用戶輸入的用戶名
            username = input('請輸入你的名字:')
            # 7.判斷當前用戶名是否已存在
            if username in name_list:
                print('用戶名已存在')
            else:
                name_list.append(username)  # 列表增加
                print(f'用戶:{username}添加成功')
        elif choice == '2':
            # 8.查看所有用戶 本質就是打印列表 但是我們 可以稍微美好一下
            for name in name_list:
                print(f"""
                ---------------info--------------
                username:{name}
                ---------------------------------
                """)
        elif choice == '3':
            # 9.獲取相要刪除的用戶名
            target_name = input('請輸入你要需刪除的名字:').strip()
            if target_name not in name_list:
                print('沒有這個人')
                continue
            # 10.直接刪除
            name_list.remove(target_name)
            print(f'用戶名{target_name}刪除成功')
        else:
            print('please input right command')

    # 2.去重下列列表并保留數據值原來的順序
    # eg: [1, 2, 3, 2, 1]
    # 去重之后[1, 2, 3]

    1.

    l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
    l2 = list(set(l1))  # 把列表裝換為集合去重之后在裝換為列表
    l2.sort(key=l1.index)  # 對去重后的列表按原始列表排序
    print(l2)

    2.

    l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
    # 1.定義一個空列表
    l2 = []
    # 2.循環含有重復數據值的列表
    for i in l1:
        if i not in l2:  # 3.判斷當前數據值是否存在于新列表中
            l2.append(i)  # 4.如果不在則追加到新列表
    print(l2)

    3.有如下兩個集合,pythons是報名python課程的學員名字集合,linuxs是報名linux課程的學員名字集合
    pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
    linuxs = {'kermit', 'tony', 'gangdan'}

    1.求出即報名python又報名linux課程的學員名字集合

    print(pythons & linuxs)

     2.求出所有報名的學生名字集合

    print(pythons | linuxs)  # {'kevin', 'gangdan', 'jason', 'biubiu', 'kermit', 'tony', 'ricky', 'oscar'}

    3.求出只報名python課程的學員名字

    print(pythons - linuxs)  # {'kevin', 'oscar', 'ricky', 'jason', 'biubiu'}

    4.求出沒有同時這兩門課程的學員名字集合

    print(pythons ^ linuxs)  # {'biubiu', 'tony', 'kermit', 'jason', 'ricky', 'oscar', 'kevin'}

     

    posted @ 2022-06-27 22:53  菜鳥一直飛  閱讀(119)  評論(0編輯  收藏  舉報
    国产美女a做受大片观看