【2022-06-27】Python數據類型的內置方法（二）

Python數據類型的內置方法（二）

數據類型之列表內置方法

列表關鍵字：list
# 列表的類型描述：用中括號括起來，內部存放多個元素或者數據值，數據值與數據值之間用逗號隔開，數據值可以是任意數據類型 表達關鍵字為list
# 1.先定義一個列表，便於理解
# l1 = ['劉備', '曹操', '孫權', '關羽', '張飛']
# l2 = [11, 22, 33, 44, 55, 66]
# 1.統計列表中數據值的個數len
# print(len(l1))
# 2.列表的增
# 2.1 尾部追加元素append() 括號內無論寫什麼數據類型，都是當成單個數據值追加
# l1.append('黃忠')
# print(l1) # 需要注意的是，列表在調用內置方法之後不會產生新的數據值，而是修改它自身 ['劉備', '曹操', '孫權', '關羽', '張飛', '黃忠']
# l1.append([1, 2, 3, 4, 5])
# print(l1) # ['劉備', '曹操', '孫權', '關羽', '張飛', '黃忠', [1, 2, 3, 4, 5]]
# 2.2 任意位置插入數據值insert() 括號內無論寫什麼數據類型，都是當成單個數據值插入
# l1.insert(2, '馬超') # ['劉備', '曹操', '馬超', '孫權', '關羽', '張飛']
# print(l1)
# 2.3 擴展列表
# new_l1 = [77, 88, 99, 100]
# new_l2 = [1, 2, 3]
# 方式一
# for i in new_l1:
# new_l2.append(i)
# print(new_l2) # [1, 2, 3, 77, 88, 99, 100]
# 方式二
# print(new_l1 + new_l2) # [77, 88, 99, 100, 1, 2, 3]
# 方式三(推薦使用)
# new_l1.extend(new_l2)
# print(new_l1) # [77, 88, 99, 100, 1, 2, 3]
# 3.查詢數據與修改數據
# 查詢數據
# print(l1) # ['劉備', '曹操', '孫權', '關羽', '張飛']
# print(l1[3]) # 關羽
# print(l1[1:5]) # ['曹操', '孫權', '關羽', '張飛']
# 修改數據
# l1[2] = '趙雲'
# print(l1) # ['劉備', '曹操', '趙雲', '關羽', '張飛']
# 4，刪除數據
# 4.1 通用刪除策略
# del l1[1] # 把索引1所指定的數據進行刪除
# print(l1) # ['劉備', '孫權', '關羽', '張飛']
# 4.2 指定數據值進行刪除 括號內必須填寫明確的數據值
# l1.remove('張飛')
# print(l1) # ['劉備', '曹操', '孫權', '關羽']
# 4.3 先取出數據值，之後進行刪除
# res = l1.pop() # 將列表裡的最後一個數據值先取出來，然後進行刪除
# print(l1, res) # ['劉備', '曹操', '孫權', '關羽'] 張飛
# res = l1.pop(1)
# print(res, l1) # 曹操 ['劉備', '孫權', '關羽', '張飛']
# 5.查看數據值對應的索引值
# print(l1.index('張飛')) # 4
# 6.統計某個數據值出現的次數
# l1.append('劉備')
# print(l1.count('劉備'))
# 7.排序
# l2.sort()
# print(l2) # [11, 22, 33, 44, 55, 66] 升序
# l2.sort(reverse=True)
# print(l2) # [66, 55, 44, 33, 22, 11] 降序
# 8.反轉
# l1.reverse()
# print(l1) # ['張飛', '關羽', '孫權', '曹操', '劉備'] 前後順序顛倒
# 9.比較運算
# new_1 = [88, 66]
# new_2 = [33, 44, 55, 66]
# print(new_1 > new_2) # True 列表在比較大小的時候是按照位置順序一一比較的
# new_1 = ['a', 66]
# new_2 = [33, 44, 55, 66]
# print(new_1 > new_2) # 不同數據類型之間默認無法直接做操作
# new_1 = ['a', 66]
# new_2 = ['A', 44, 55, 66]
# print(new_1 > new_2) # True

數據類型之字典內置方法

字典關鍵字dict
# 字典的類型描述：用大括號括起來，內部可以存放多個數據值，數據值與數據值之間用逗號隔開，組織形式為K:V鍵值對
# 類型轉換
# print(dict([('name', 'zh'), ('pwd', 123)])) # {'name': 'zh', 'pwd': 123}
# print(dict(name='huawei', pwd=666)) # {'name': 'huawei', 'pwd': 666}
"""字典很少涉及到的類型轉換 都是直接定義使用"""
info = {
'username': 'lisa',
'password': 666,
'hobby': ['read', 'run']
}
"""
k是對v的描述性性質的信息，一般是字符串，也可以是不可變類型，如整型、浮點型、字符串、元組
"""
# 1.字典內K:V鍵值對是無序的，無法用索引取值
# 2.取值操作
# print(info['username']) # 不推薦使用，如果鍵不存在，則會打印報錯
# print(info.get('username')) # lisa
# print(info.get('name')) # None
# print(info.get('username', '鍵不存在返回的值，默認是None')) # lisa
# print(info.get('xxx', '鍵不存在返回的值，默認是None')) # 鍵不存在返回的值，默認是None
# 3.統計字典中鍵值對的個數
# print(len(info)) # 3
# 4.修改數據
# info['username'] = 'name' 鍵存在則是修改
# print(info) # {'username': 'name', 'password': 666, 'hobby': ['read', 'run']}
# 5.新增數據
# info['salary'] = 600 鍵不存在就是新增
# print(info) # {'username': 'lisa', 'password': 666, 'hobby': ['read', 'run'], 'salary': 600}
# 6.刪除數據
# 方式一
# del info['username']
# print(info) # {'password': 666, 'hobby': ['read', 'run']}
# 方式二
# res = info.pop('username')
# print(info, res) # {'password': 666, 'hobby': ['read', 'run']} lisa
# 方式三
# info.popitem() # 隨機刪除
# print(info)
# 7.快速獲取鍵、值、鍵值對數據
# print(info.keys()) # dict_keys(['username', 'password', 'hobby']) 獲取字典所有的K值，結果當成列表即可
# print(info.values()) # dict_values(['lisa', 666, ['read', 'run']]) 獲取字典所有的V值，結果當成列表即可
# print(info.items()) # dict_items([('username', 'lisa'), ('password', 666), ('hobby', ['read', 'run'])]) 取字典KV鍵值對數據，組織成列表套元組
# 8.快速構造字典 給的值默認情況下，所有的鍵都用一個
# res = dict.fromkeys([1, 2, 3, 4, 5], {})
# print(res) # {1: {}, 2: {}, 3: {}, 4: {}, 5: {}}

數據類型之元組內置方法

元組關鍵字tuple
# 元組的類型描述：小括號括起來，內部存放多個數據值，數據值與數據值之間用逗號隔開，數據值可以是任意數據類型，也稱為不可變的列表
# 類型轉換 支持for循環的數據類型都可以進行轉換
# print(tuple(123))
# print(tuple(1.2))
# print(tuple('huawei')) # ('h', 'u', 'a', 'w', 'e', 'i')
# print(tuple([1, 2, 3, 4, 5])) # (1, 2, 3, 4, 5)
# print(tuple({'name': 'lib', 'age': 18})) # ('name', 'age')
# 先定義一個元組
# t1 = ()
# print(type(t1)) # <class 'tuple'>
# t2 = (1)
# print(type(t2)) # <class 'int'>
# t3 = (22.22)
# print(type(t3)) # <class 'float'>
# t4 = 'name'
# print(type(t4)) # <class 'str'>
# 當元組內只有一個數據值的時候，逗號不能省略，如果省略了，括號裡邊是什麼數據類型就是什麼數據類型
# 編寫元組的時候，把逗號加上，哪怕只有一個數據
# t1 = ()
# print(type(t1)) # <class 'tuple'>
# t2 = (1,)
# print(type(t2)) # <class 'tuple'>
# t3 = (22.22,)
# print(type(t3)) # <class 'tuple'>
# t4 = ('name',)
# print(type(t4)) # <class 'tuple'>
# 以後遇到可以存儲多個數據值的數據類型，如果裡面只有一個數據值，那麼趁機把逗號也加上，可以更加規范
# t1 = (11, 22, 33, 44, 55, 66, 77, 88)
# 1.索引相關操作
# 2.統計元組內數據值的個數
# print(len(t1)) # 8
# 3.查與改
# print(t1[0]) # 可以查找
# t1[0] = 333 # 不可以修改
# 注意：元組的索引不能改變綁定地址
# t2 = (11, 22, 33, 44, [1, 2])
# t2[-1].append(3)
# print(t2) # (11, 22, 33, 44, [1, 2, 3])

數據類型之集合內置方法

表達關鍵字set
# 定義空集合需要使用關鍵字才可以
# 類型轉換：能夠被for循環的數據類型都可以轉換為集合，但轉換完的數據值只能是不可變的數據類型
# 集合內數據類型必須是不可變的數據類型(整型、浮點型、字符串、元組、布爾值)
# 集合自帶去重特性
# l1 = ['red', 'blue', 'black', 'green', 'red', 'red', 'red'] # 自動去除列表裡重復的元素
# s1 = set(l1)
# print(s1) # {'red', 'black', 'blue', 'green'}
# l1 =list(s1)
# print(l1) # ['red', 'black', 'blue', 'green']
# 關系運算
# 模擬兩個人的好友集合
# a1 = {'宋江', '吳用', '盧俊義', '晁蓋', '武松', '李逵'}
# a2 = {'劉備', '關羽', '李逵', '曹操', '周瑜', '馬超'}
# 1.求a1和a2的共同好友
# print(a1 & a2) # {'李逵'}
# 2.求a1和a2獨有的好友
# print(a1 - a2) # {'盧俊義', '晁蓋', '宋江', '吳用', '武松'}
# print(a2 - a1) # {'劉備', '馬超', '關羽', '周瑜', '曹操'}
# 3.求a1和a2所有的好友
# print(a1 | a2) # {'吳用', '宋江', '馬超', '李逵', '曹操', '盧俊義', '劉備', '晁蓋', '武松', '關羽', '周瑜'}
# 4.求a1和a2各自獨有的好友，排除共同好友
# print(a1 ^ a2) # {'武松', '宋江', '盧俊義', '吳用', '關羽', '周瑜', '晁蓋', '劉備', '曹操', '馬超'}
# 5.父集、子集
# s1 = {1, 2, 3, 4, 5, 6, 7}
# s2 = {3, 2, 1}
# print(s1 > s2) # True 判斷s1是不是s2的父集，s2是不是s1的子集

可變類型與不可變類型

"""
為什麼字符串調用內置方法是產生新的值 列表調用內置方法是改變自身
"""
1.可變類型 list
值改變(通過內置方法) 內存地址可以不變
l1 = [11, 22, 33]
print(id(l1)) # 1931283911552
l1.append(44) # [11, 22, 33, 44]
print(id(l1)) # 1931283911552
2.不可變類型 str int float
值改變(通過內置方法) 內存地址肯定變
s1 = '$hello$'
print(id(s1))
s1 = s1.strip('$')
print(id(s1))

課題演練

# 1.利用列表編寫一個員工姓名管理系統
# 輸入1執行添加用戶名功能
# 輸入2執行查看所有用戶名功能
# 輸入3執行刪除指定用戶名功能
# ps: 思考如何讓程序循環起來並且可以根據不同指令執行不同操作
# 提示: 循環結構 + 分支結構
# 拔高: 是否可以換成字典或者數據的嵌套使用完成更加完善的員工管理而不是簡簡單單的一個用戶名(能寫就寫
# 不會沒有關系)
"""
主體功能：[添加用戶、查看用戶、刪除用戶]
"""
# 1.先定義一個存儲用戶名數據的列表
user_data_list = []
# 2.循環打印管理系統功能，並提供功能編號
while True:
print("""
1.添加用戶名
2.查看所有用戶名
3.刪除指定用戶名
""")
# 3.獲取用戶需要執行的功能編號
select = input('請您輸入需要執行的功能編號>>>:').strip()
# 4.判斷用戶想要執行的功能
if select == '1':
# 5.獲取用戶的用戶名
username = input('請輸入您要添加的用戶名>>>:').strip()
# 6.判斷用戶名是否已經存在，如果存在則提示用戶已存在並結束判斷
if username in user_data_list:
print('對不起，此用戶名已存在，無法添加')
break
# 7.創建一個臨時列表用於存放用戶名
user_list = f'{username}'
# 8.添加到數據列表中
user_data_list.append(user_list)
# 9.提示用戶添加成功
print(f'{username}添加成功')
elif select == '2':
print(user_data_list)
elif select == '3':
# 10.獲取想要刪除的用戶名
delete_user = input('請輸入您想要刪除的用戶名>>>:')
# 11.判斷當前用戶名是否還存在
if delete_user not in user_data_list:
print('此用戶名不存在，無法刪除')
continue # 如果存在，則結束本次循環
# 12.使用列表內置方法進行數據刪除
res = user_data_list.pop(1).strip()
print('此用戶名已刪除完畢')
else:
print('請輸入正確的功能編號')
# 2.去重下列列表並保留數據值原來的順序
# eg: [1, 2, 3, 2, 1]去重之後[1, 2, 3]
# l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
# l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
# l2 = set(l1)
# l1 = list(l2)
# print(l1) # [1, 2, 3, 4, 5, 6]
# 3.有如下兩個集合，pythons是報名python課程的學員名字集合，linuxs是報名linux課程的學員名字集合
# pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
# linuxs = {'kermit', 'tony', 'gangdan'}
# 1.求出即報名python又報名linux課程的學員名字集合
# 2.求出所有報名的學生名字集合
# 3.求出只報名python課程的學員名字
# 4.求出沒有同時這兩門課程的學員名字集合
# pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
# linuxs = {'kermit', 'tony', 'gangdan'}
#
# print(pythons & linuxs) # {'gangdan'}
# print(pythons | linuxs) # {'tony', 'biubiu', 'gangdan', 'oscar', 'kevin', 'kermit', 'ricky', 'jason'}
# print(pythons - linuxs) # {'jason', 'ricky', 'biubiu', 'oscar', 'kevin'}
# print(pythons ^ linuxs) # {'jason', 'kermit', 'oscar', 'kevin', 'ricky', 'biubiu', 'tony'}

​