前言回顧
1. 列表(list)
容器型數(shù)據(jù)類型(序列),可變恃慧、有序
2. 元素
任何python類型的數(shù)據(jù)都可以作為列表元素
3. 元素的增刪改查
1. 查
查單個元素：列表[下標]
查部分元素(切片)：列表[開始下標:結束下標:步長]康谆，列表[:]，列表[::-1]
遍歷：直接遍歷则剃、遍歷下標
2. 增
列表.append(元素)、列表.insert(下標舔痕、元素)
3. 刪
del 列表[下標]
列表.remove(元素) 不能刪除不存在的元素湃交；多個元素相同扫倡，只會刪除第一個
列表.pop() 列表.pop(下標)
4. 改
列表[下標] = 新值
4. +, *, ==, !=, in/not in, len(), list(序列), max/min
+ : 列表拼接
* : 列表重復多次
== :列表相等谦秧，元素和順序都相同
!= :列表不等
in/not in : 判斷某個[元素]是否在列表中
5. 列表常用方法
- count
列表.count(元素) - 統(tǒng)計列表中指定元素的個數(shù)，返回一個整數(shù)
nums = [1, 34, 1, 6, 8, 1]
print(nums.count(1))
- extend
列表.extend(序列) - 將序列的元素全部添加到列表中
nums.extend('abc')
print(nums)
nums.extend([100, 'abc', 'name'])
print(nums)
- index
列表.index(元素) - 獲取指定元素在列表中出現(xiàn)的[第一個]下標
注意：元素不存在會報錯撵溃！
nums = [100, 60, 34, 100]
print(nums.index(100))
4. reverse
列表.reverse() - 反向列表 (對原列表進行修改油够，不會產(chǎn)生新的列表)
reversed(序列) - 反向序列 (不修改原序列，而是產(chǎn)生新的序列(迭代器)征懈，即有返回值)
序列(seq) -- 要轉換的序列，可以是 tuple, string, list 或 range
nums = [100, 60, 34, 100]
nums.reverse()
print(nums)
nums = [100, 60, 34, 100]
new_nums = reversed(nums)
print(nums, list(new_nums))
str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.join(list(new_str)))
# 字符串.join(序列) 將序列用前面的字符串拼接起來揩悄，并返回拼接了的字符串
- sort
列表.sort() - 將列表中的元素升序排序(從小到大)
列表.sort(reverse=True) - 將列表中的元素降序排序(從大到小)
sorted(序列) - 排序的時候不修改原序列卖哎，產(chǎn)生新的序列
注意：能夠進行排序的列表要求列表中的元素類型一致，并且支持比較運算Ｉ拘浴亏娜！
nums = [100, 60, 34, 101]
# nums.sort()
nums.sort(reverse=True)
print(nums)
nums = [100, 60, 34, 101]
new_nums = sorted(nums) # 從小到大排序
print(nums) # [100, 60, 34, 101]
print(new_nums) # [34, 60, 100, 101]
str2 = 'helloworld'
new_str = sorted(str2)
print(new_str) # ['d', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str)) # dehllloorw
- clear
列表.clear() - 刪除列表中所有的元素(清空列表)
nums = [100, 60, 34, 101]
nums.clear()
# nums = []
print(nums, id(nums)) # id 獲取對象的內存空間地址
# 區(qū)別：clear是清空容器；[]是銷毀原空間蹬挺，再開辟一個新的空間
- copy
列表.copy() - 相當于列表[:],將列表中的元素拷貝一份產(chǎn)生一個新的列表 (淺拷貝)
產(chǎn)生一個新的列表维贺，兩個列表空間地址不同，對某一個列表進行元素操作不會相互影響
nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))
作業(yè)
選講前一天的作業(yè)巴帮，括號里面為前一天的標題序號
1(5).已知一個數(shù)字列表溯泣，將所有元素乘二。
例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]
nums = [1, 2, 3, 4]
for index in range(len(nums)):
nums[index] *= 2
print(nums)
2(6).有一個長度是10的列表榕茧，數(shù)組內有10個人名垃沦，要求去掉重復的
例如:names = ['張三', '李四', '大黃', '張三'] -> names = ['張三', '李四', '大黃']
方法一：
names = ['張三', '李四', '大黃', '張三', '二狗', '將軍', '爵爺', '花生', '警長', '二狗']
new_names = []
for name in names:
if name not in new_names:
new_names.append(name)
print(new_names)
方法二：
names = ['張三', '李四', '大黃', '張三', '二狗', '將軍', '爵爺', '花生', '警長', '二狗']
for name in names[:]:
if names.count(name) > 1:
names.remove(name)
print(names)
3(8).用一個列表來保存一個節(jié)目的所有分數(shù)，求平均分數(shù)(去掉一個最高分用押，去掉一個最低分肢簿，求最后得分)
list1 = [9.2, 9.0, 7.8, 8.8, 7.6, 9.4]
avge = (sum(list1) - max(list1) - min(list1))/(len(list1) - 2)
print(avge)
4(9).有兩個列表A和B，使用列表C來獲取兩個列表中公共的元素
例如: A = [1, 'a', 4, 90] B = ['a', 8, 'j', 1] --> C = [1, 'a']
A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for i in A:
for j in B:
if i == j:
C.append(i)
print(C)
5(10).有一個數(shù)字列表，獲取這個列表中的最大值.(注意: 不能使用max函數(shù))
例如: nums = [19, 89, 90, 600, 1] —> 600
nums = [19, 89, 90, 600, 1]
max1 = nums[0]
for item in nums[1:]:
if max1 < item:
max1 = item
print(max1)
6(11).獲取列表中出現(xiàn)次數(shù)最多的元素
例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3
nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
max_count = 0 # 保存最大個數(shù)
num = None # 最大個數(shù)對應的元素池充，None - 空值
for item in nums:
count = nums.count(item)
if count > max_count:
max_count = count
num = item
print('出現(xiàn)次數(shù)最多的元素:%d, 次數(shù)是:%d' % (num, max_count))
元組
1.什么是元組(tuple)
元組是python提供的容器型數(shù)據(jù)類型(序列)桩引，不可變(特色)，有序
元組就是不可變的列表收夸，一般保存一些不讓修改的數(shù)據(jù)
(元素1, 元素2, 元素3...)
除了不可變(即增刪改)以外坑匠，其他和list列表差不多
2.元素
空的元組(沒有意義)
tuple1 = ()
print(tuple1, type(tuple1))
- 元素個數(shù)是1的元組：如果一個元組中只有一個元素，這個元素后面必須加逗號咱圆！
tuple2 = (10,) # 若不加逗號笛辟，tuple2 = (10)， 輸出 type(tuple2) -> <class 'int'>
print(tuple2, type(tuple2))
- 元組數(shù)據(jù)中小括號可以省略 (多個數(shù)據(jù)直接用逗號隔開序苏，表示的是一個元組)
tuple3 = 10, 23, 89, 12, '小明'
print(tuple3, type(tuple3))
3.獲取元素：和列表一樣
tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2)
print(tuple2[1])
print(tuple2[2:])
for item in tuple2:
print(item)
- 讓變量的個數(shù)和元組中元素的個數(shù)保持一致(必須一致)手幢，來一一獲取元組中每個元素的值
point = (100, 50)
x, y = point
print('x:', x, 'y:', y)
a, b, c = 10, 20, 30 # 實質就是：a, b, c = (10, 20, 30)
- 讓多個變量同時獲取元組中的元素的時候，可以在一個變量前加*將這個變量變成一個列表忱详，來獲取不帶*的變量獲取后剩下的數(shù)據(jù)围来。(注意，帶*的變量只能有一個)
和不定長參數(shù)不一樣,帶*的變量可以放在中間
student = ('小明', 18, 89, 68, 89, 90) # 帶*的只能有一個
name, age, *scores = student
print(name, age, scores)
name, *scores, age, a = student
print(name, age, scores, a)
*items, a, b = student
print(items, a, b)
# 容器前面加*匈睁，表示獲取這個容器中的全部元素
tuple4 = (10, 20)
print(*tuple4) # print(10, 20)
容器前面加*监透，表示獲取這個容器中的全部元素
字典
用一個變量保存一個學生的信息
student = {'name': '小明', 'age': 18, 'gender': '男', 'score': 59}
print(student['name'])
print(*student)
1.什么是字典(dict)
字典是python提供的容器型數(shù)據(jù)類型(序列)，可變航唆，無序
2.字典中的元素
{key1: value1, key2: value2...} - 字典的元素就是鍵值對
key-value(鍵值對) - 以'鍵：值'的形式成對出現(xiàn)
鍵(key) - 要求不可變胀蛮，唯一(建議用字符串作為key，用來對值進行說明和區(qū)分的)
值(value) - 任何類型的數(shù)據(jù)都可以作為值(python支持的)
dict1 = {10: 100, 'name': 98, (1, 2): 99, 'a': 'abc', 'b': True, 'c': [1, 2],'d': {'a': 2}} # int糯钙、str粪狼、tuple均是不可變的
print(dict1)
# dict2 = {10: 100, 'name': 98, [1, 2]: 99} # list可變，不能作為key值 TypeError: unhashable type: 'list'
# dict2 = {10: 100, 'name': 98, {'a': 1}: 99} # dict也不能作為key值 TypeError: unhashable type: 'dict'
dict1 = {10: 100, 'name': 100, (1, 2): 100, 10: 200}
print(dict1) # {10: 200, 'name': 100, (1, 2): 100}
3.元素的操作
- 查 - 獲取值
1. 字典[key] - 獲取字典中key對應的value (如果key不存在會報錯任岸！)
2. 字典.get(key) - 獲取字典中key對應的value (如果key不存在不報錯再榄，結果是None)
字典.get(key, 默認值) - 獲取字典中key對應的value (如果key不存在不報錯，結果是默認值)
dog = {'name': '旺財' , 'color': '黃色', 'age': 3, 'type': '土狗'}
print(dog['type'])
# print(dog['gender']) # KeyError: 'gender'
print(dog.get('name'))
print(dog.get('gender')) # None
print(dog.get('age', 100))
print(dog.get('gender', '公狗')) # 公狗
key = 'age'
print(dog.get(key))
print(dog[key])
3. 遍歷字典
直接通過for循環(huán)遍歷字典的時候享潜，獲取到的是所有的key
1.直接遍歷(只用這個困鸥，時間復雜度最低！剑按！)
print('===1===')
for key in dog:
print(key, dog[key])
2.間接遍歷
print('===2===')
print(dog.values())
for value in dog.values():
print(value)
print('===3===')
print(dog.items())
for key, value in dog.items():
print(key, value)
- 增/改
字典[key] = value - 如果key存在疾就，修改key對應的值；如果key不存在艺蝴，添加鍵值對
class1 = {'name': 'py1902', 'address': '19樓5教室'}
print(class1)
# 增
class1['num'] = 50
print(class1)
# 改
class1['name'] = 'python1902'
print(class1)
- 刪
1. del 字典[key] - 刪除字典中指定key對應的鍵值對 如果key不存在會報錯
2. 字典.pop(key) - 取出字典中key對應的值 如果key不存在會報錯
"""
class2 = {'name': 'py1902', 'address': '19樓5教室', 'num': 50}
del class2['num']
print(class2) # {'name': 'py1902', 'address': '19樓5教室'}
name = class2.pop('name')
print(class2, name)
4. 字典相關操作
- 運算符：不支持數(shù)學運算,比較運算符只支持比較相等不支持比較大小(因為字典無序)
print({'a': 100, 'b': 10} == {'b': 10, 'a': 100}) # True 因為無序
- in /not in
key in 字典 - 判斷字典中是否存在指定的key
class2 = {'name': 'py1902', 'address': '19樓5教室', 'num': 50}
print('name' in class2) # True
print(50 not in class2) # True
- len - 鍵值對的個數(shù)
print(len(class2))
- dict
能轉換成字典的數(shù)據(jù)要求：數(shù)據(jù)本身是序列虐译，序列中的每個元素長度是2的序列，
并且小序列中的第一個元素是不可變的
data = [(1, 2), ['a', 23]]
print(dict(data))
dict2 = {'a': 10, 'b': 20}
print(list(dict2)) # ['a', 'b']
5.相關方法
- clear
字典.clear() - 清空字典
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2) # {}
- copy
字典.copy() - 拷貝字典中的鍵值對產(chǎn)生一個新的字典
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 20, 'b': 20} 直接賦值會有影響 (共享空間地址)
dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}
- fromkeys
dict.fromkeys(序列吴趴， 值) - 創(chuàng)建一個新的字典漆诽，字典的key是序列的元素侮攀， key對應的value是值
new_dict = dict.fromkeys('hello', 100)
print(new_dict)
- keys, values, items
字典.keys() - 獲取字典中所有的key，結果是一個序列
字典.values() - 獲取字典中所有的value厢拭，結果是一個序列
字典.items() - 獲取字典中的key和value兰英，key和value以元祖的形式返回
students = {'name': '張三', 'age': 18, 'stu_id': 'stu001', 'gender': '女'}
print(students.keys())
print(students.values())
print(students.items())
- setdefault
字典.setdefault(key, value) - 添加鍵值對(不能修改)
students.setdefault('tel', '15300022233')
print(students)
- update
字典1.update(字典2) - 使用字典2中的鍵值對去更新字典1(不存在就添加、存在就修改)
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2)
print(dict1) # {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}
集合
1.什么是集合(set)
容器型數(shù)據(jù)類型(序列)供鸠，可變畦贸、無序
2.集合中的元素
{元素1, 元素2, 元素3...}
元素：不可變，唯一(自帶去重功能)
＠阄妗薄坏！注意：{}不能表示空的集合，set() - 空集合
set1 = set() # set 空集合表示方法
set2 = {1, 'abc', (1, 3), False} # {False, 1, (1, 3), 'abc'}
# True 顯示不出來, 因為python中寨闹，1 == True胶坠；0 == False
# 若是集合中同時存在1 和 True，會輸出在前面的那一個繁堡；0 和 False同理
print(set2) # {False, (1, 3), 1, 'abc'}
# 集合可以去重
str1 = 'sdfsadfadssw'
print(set(str1))
print(''.join(set(str1)))
list1 = [1, 34, 34, 2, 2]
print(list(set(list1))) # [1, 34, 2]
3.元素相關操作
- 查
集合不能單獨獲取指定的一個元素沈善，只支持遍歷
set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
print(x)
- 增
集合.add() - 往集合中添加一個元素
集合.update(序列) - 將序列中的元素添加到集合中(自帶去重)
set1 = {1}
print(set1)
set1.add(100)
print(set1)
set1.update('abc')
print(set1)
set1.update({'name': '張三', 'age': 20})
print(set1)
- 刪
集合.remove(元素) - 刪除集合中指定的元素
set4 = {1, 100, 'name', 'a', 'age', 'b', 'c'}
set4.remove(100)
print(set4)
(*)4.數(shù)學集合運算
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
- 并集： |
集合1 | 集合2 -- 將兩個集合中的元素合并產(chǎn)生新的集合
print(set1 | set2)
- 交集：& -- 求兩個集合公共的部分
print(set1 & set2)
- 差集：集合1 - 集合2 -- 獲取集合1中除了集合2以外的部分
print(set1 - set2)
- 對稱差集(補集)：集合1 ^ 集合2 -- 獲取除了兩個集合公共部分以外的部分
print(set1 ^ set2)
- 包含關系
集合1 >= 集合2 - 集合1中是否包含集合2
集合1 <= 集合2 - 集合1是否在集合2中
print({5, 6, 7, 8, 9} >= {1, 2, 3}) # False
print({5, 6, 7, 8, 9} >= {5, 9}) # True
