1、公共方法

• +

  • 加法運算適用於所有的基礎資料型別（int float bool）

  • 加法運算所有兩側要是同種資料型別

  • 加法運算再容器型別中是拼接的意思，不是相加計算值

# +法運算,都可以用於哪些資料型別之間
# int float  bool 肯定可以用於加法運算,不再贅述
print(1 + 12.3) # 13.3
​
# str 可以相加麼? 可以
str1 = 'hello'
str2 = ' python'
# 字串相加,可以快速將字串進行拼接
print(str1 + str2)
# 相加過後,str1 和str2 沒有發生變化,可以推斷+法運算產生了新的資料,源資料不變化
print(str1, str2, sep='\n')
​
# list 可以相加麼? 可以
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 列表相加可以將列表進行拼接,效果類似於extend
print(list1 + list2) # [1, 2, 3, 4, 5, 6]
# list相加後,原資料不發生變化,將產生一個新的資料
print(list1) # [1, 2, 3]
print(list2) # [4, 5, 6]
​
# tuple 可以相加麼?  可以
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2) # (1, 2, 3, 4, 5, 6)
# 由於元組內部元素不能修改,索引相加肯定沒有對源資料產生影響,而是生成了新的資料
​
# set
# set1 = {1, 2, 3}
# set2 = {4, 5, 6}
# # TypeError: unsupported operand type(s) for +: 'set' and 'set'
# # set之間不能進行加法運算
# print(set1 + set2)
​
# dict
# TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# dict 型別間不能進行加法運算
# dict1 = {'name': '小明'}
# dict2 = {'age':18}
# print(dict1 + dict2)
​
# 結論: 基礎資料型別都可以進行加法運算,容器型別間只有列表,元組,字串可以進行加法運算
​
​
# 不同容器型別間可以相加麼?
list1 = [1,2,3]
tuple1 = (1,2,3)
set1 = {1,2,3}
dict1 = {'name': 'xiaoming'}
​
# TypeError: can only concatenate list (not "tuple") to list
# print(list1 + tuple1)
# TypeError: can only concatenate list (not "set") to list
# print(list1 + set1)
# TypeError: can only concatenate tuple (not "set") to tuple
print(tuple1 + set1)
​
# 結論,資料型別布偶無法進行加法運算(特指容器型別之間)
 

• *

  • 基礎資料型別（int float bool）都可以進行乘法運算

  • 容器型別只能和int型別資料進行乘法運算

  • 容器型別進行乘法運算，就是將容器複製指定次數，並進行拼接

# * 效果是設麼?
# * 什麼容器型別可以使用*
​
# 基礎資料型別  int  float  bool都可以使用*法運算
print(12.1 * 2)
​
# 容器型別的乘法運算
# 格式: 容器型別 * int型別資料
# 乘法運算的 效果,就是講容器型別複製指定次數,並拼接到一起
​
# list 可以使用*法運算麼?  可以
list1 = [1, 2, 3]
# 將list1 複製3次並進行拼接
print(list1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# 使用list 型別乘以float型別可以實現麼?
# TypeError: can't multiply sequence by non-int of type 'float'
# 乘法運算不能讓容器與非int型別相乘
# print(list1 * 1.3)
# list 能乘以負數麼?  可以相乘,但是結果為空列表
print(list1 * -3) # []
# 可以與0 相乘,結果為空列表
print(list1 * 0) # []
​
# tuple 可以使用*法運算麼? 可以
tuple1 = (1, 2, 3, 4)
print(tuple1 * 2) # (1, 2, 3, 4, 1, 2, 3, 4)
# tuple 只能與int型別相乘
​
​
# set可以使用 * 法運算麼?  不可以
set1 = {1, 2, 3}
# TypeError: unsupported operand type(s) for *: 'set' and 'int'
# 集合型別資料不能做乘法運算
# print(set1 * 3)
​
# dict 能夠使用 * 法運算麼?  不可以
dict1 = {'name': 'jack'}
# TypeError: unsupported operand type(s) for *: 'dict' and 'int'
# 字典不能做乘法運算
# print(dict1 * 3)
​
# 乘號左右兩側的資料可以互換位置麼?  可以
print(3 * list1) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
 

• in和not in

  • 判斷元素是否在資料序列當中

  • 字串，列表，元組，集合 ，字典都可以使用

# in 判斷元素是否存在於容器當中
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
​
print(3 in list1) # True
print(3 in tuple1) # True
print(3 in set1) # True
# 如果要判斷是否在set當中,要注意被判斷的元素必須可以儲存在set當中,如果是列表,字典,集合,則不能判斷
# print([1, 2] in list1)  # False  可以判斷,引為[1,2] 可以儲存在list1當中
# print([1, 2] in set1)  # TypeError: unhashable type: 'list' 不能判斷,因為[1,2]不能儲存到set1當中
​
​
# str型別可以使用in麼? 可以
str1 = '123'
# TypeError: 'in <string>' requires string as left operand, not int
# 字串判斷時,左側的元素只能是字串型別,否則報錯
# print(1 in str1)
print('1' in str1) # True
​
# dict 是否可以使用in???
dict1 = {'name': 123}
# dict使用in判斷的是當前元素是否是dict中存在的鍵
print(123 in dict1) # False
print('name' in dict1) # True
​
# 如果使用此方法則不能判斷字典  列表 集合
# TypeError: unhashable type: 'list'
# print([1,2] in dict1)
​
# not in  : 所有用法和in相同,只是取反而已
​
# 結論:
# 1.使用in 和not in  被判斷的元素在關鍵字左側, 資料序列在關鍵字右側
# 2.如果想要判斷該元素是否在容器內,該元素必須能儲存到容器內,比如集合不能儲存列表,字典,集合 所以就不能判斷其型別的元素是否在集合內
# 3.字典判斷的是元素是否在keys內,也就是是否是其中的鍵
 

• 切片

  • 通過切片按照規則獲取資料序列中的一部分元素

  • tuple list str 可以使用切片

  • dict set 不可以使用切片

# 切片:通過切片方法可以按照一定規則擷取容器的一部分資料
​
# str切片
str1 = 'abcde'
# 格式:[起始位置:終止位置:步長]
# 不會修改原有字串,而是產生了一個新的字串
print(str1[2:]) # cde
​
# list可以切片麼?
list1 = [1, 2, 3, 4]
# list切片方式方法和str完全相同
# list切片後不會在原有資料上進行修改,而是產生了一個新的列表
print(list1[1:3:1]) # [2, 3]
print(list1)
​
# tuple 可以切片麼?
tuple1 = (1, 2, 3, 4)
# tuple1切片方式方法和str完全相同
# 切片後不會在原有資料上進行修改,而是產生了一個新的列表
print(tuple1[1:3:1]) # (2, 3)
print(tuple1)
​
# dict可以切片麼?  肯定不行,因為不能使用索引獲取資料
# set 可以切片麼?  肯定不行,因為不能使用索引獲取資料
​
# 結論:
# 1.list str tuple 可以使用切片,格式是:[起始位置:終止位置:步長],三者使用方式完全一致
# 2.所有的切片都不會在原有的資料上進行修改,而是產生一個新的資料序列
# 3.集合和字典無法切片,因為不能使用索引獲取資料元素

2、公共函式

• len ：獲取容器內元素個數

• del：刪除容器內元素

• max ：獲取容器內資料的最大值

• min ： 獲取容器內元素的最小值

• enumerate ： 獲取容器內元素時可以攜帶序號

• range：根據一定規則獲取整數序列

# len  獲取容器型別的元素個數,  或者說獲取容器的長度
str1 = '123'
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
dict1 = {'name': 123, 'age': 18}
# 使用len可以獲取list  str  tuple set中的元素個數
print(len(str1))
print(len(list1))
print(len(tuple1))
print(len(set1))
# 使用len可以獲取dict中的鍵值對的個數
print(len(dict1))
​
# len() 可以寫成  容器.__len__()
print(list1.__len__())
​
# del
# 刪除容器內指定的元素
# list
# del list1[0]
# print(list1)
​
# tuple
# del tuple1[0]
# TypeError: 'tuple' object doesn't support item deletion
# 元組內元素不能被刪除
# print(tuple1)
​
# set
# for i in set1:
#   del i
​
# dict
# del dict1['name']
# del 在dict中刪除的是鍵值對
print(dict1)
​
# str
# TypeError: 'str' object doesn't support item deletion
# str 不能夠使用del 刪除內部元素
# 注意 :str內部的元素也是不可修改的,類似於元組
# del str1[0]
# print(str1)
​
# 結論:
# 1.列表,字典可以使用del刪除內部元素,但是,列表中是刪除元素,字典中是刪除鍵值對
# 2.使用del 沒法迴圈遍歷刪除set中的元素,因為引用機制問題
# 3.str  tuple內部的元素都不可更改所以不能使用del刪除元素
​
​
# max  min
# list tuple set str可以使用max  min獲取容器內的最大最小值
print(max(list1))
print(max(tuple1))
print(max(set1))
print(max(str1))
# dict是使用max和min獲取鍵的最大最小值
print(max(dict1))
​
# enumerate  列舉函式:獲取容器內資料時新增序號(預設序號從0開始可以作為索引使用)
​
list2 = [1, 2, 3, 4, 5, 6, 7, 8]
​
for i in list2:
  print(i)
​
# 可不可以同時獲取元素的值和元素的索引?  可以 使用enumerate
​
# for i in enumerate(list2):
#   # 直接列印,獲取的是以(索引,值)組成的元組
#   print(i)
​
# list
for index, value in enumerate(list2):
  print(index, value, sep=' : ')
​
# tuple
for index, value in enumerate(tuple1):
  print(index, value, sep=' : ')
​
# set
for index, value in enumerate(set1):
  print(index, value, sep=' : ')
​
# str
for index, value in enumerate(str1):
  print(index, value, sep=' : ')
​
# dict 
for index, value in enumerate(dict1):
  print(index, value, sep=' : ')
  
# 結論:所有的容器和課迭代型別都可以使用enumerate,並且產生序號,這個序號並不是索引值,而是在生成序號時預設從0開始,碰巧可以在list,str,tuple中當做索引使用