1.列表(list)

容器型數據類型(序列),可變(增刪改)、有序(支持下表操作)

2.元素

任何類型的數據都可以作為列表元素

3.元素的增刪改查

"""
1.查
查單個元素:列表[下標]
查部分元素:列表[開始下標:結束下標:步長]
遍歷:直接遍歷、遍歷下標

2.增

列表.append(元素0)、列表.insert(下標,元素)

list1 = (1, 2, 3, 4, 5, 6, 7)

3.刪
del 列表[下標]
列表.remove(元素) #多個重復元素刪除第一個
列表.pop() 列表.pop(下標) #將列表最后一個元素取出來

4.改
列表[下標] = 新值
"""

4. +， *， ==，!=，in/not in(判斷一個元素是在列表里面存在),len(),list()序列才能轉換成列表,序列中的元素單獨拿出來作為元素

5.列表常用方法

1) count

"""
列表.count(元素) -- 統計列表中指定元素的個數
"""
nums = [1, 34, 6, 8, 1]
print(nums.count(1))

2.)extend

"""
列表.extend(序列) -- 將序列中元素全部添加到列表中
"""
nums.extend('abc')
print(nums)
nums.extend([100, 'abc', 'name'])
print(nums)
nums.extend({'age': 18})
print(nums)

3.)index

"""
列表.index(元素) -- 獲取指定元素對應的下標(如果元素有多個只取第一個)
注意:如果元素不存在會報錯
"""
nums = [100, 60, 34, 100]
print(nums.index(34))

4)reverse

"""
列表.reverse() -- 反向列表(直接修改原列表)

reversed(序列) -- 反向序列,不修改原序列而是產生新的序列(迭代器)
"""
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)), str1[::-1])

字符串.join(序列)

5)sort

"""
列表.sort() -- 將列表中的元素升序排序(從小到大)
列表.sort(reverse = True) -- 將列表中的元素降序排序(從大到小排序)

sorted(序列) -- 排序的時候不修改原序列，產生新的序列
注意:能夠進行排序的列表總要求列表中的元素類型一致并且支持比較運算
"""
nums = [100, 60, 34, 100]

nums1.sort()

nums.sort(reverse=True)
print(nums)

sorted

nums = [100, 60, 34, 101]
new_nums = sorted(nums) # 從小到大排序
print(nums) # [100, 60, 34, 101]
print(new_nums) # [100, 60, 34, 101]

new_nums = sorted(nums, reverse=True) # 從大到小排序
print(new_nums) # [101, 100, 60, 34]
str2 = 'helloworld'
new_str = sorted(str2)
print(new_str) # ['d', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str)) # adehllloorw

6) clear

"""
列表.clear() -- 刪除列表中所有的元素(清空列表)
"""
nums = [101, 100, 60, 34]
print(id(nums))
nums = []
print(id(nums))

nums.clear()

print(nums)

7.copy

"""
列表.copy() -- 相當于列表[:],將列表中的元素拷貝一份產生一個新的列表(淺拷貝)
"""
nums = [101, 100, 60, 34]
new_nums = nums.copy()
print(id(nums), id(new_nums))

new_nums2 = nums # 一個變量給另一個變量賦值，賦的是地址
new_nums2.insert(0, 1000)
print(new_nums2, nums)

1.什么是元祖(tuple)

元祖是python提供的容器型數據類型(序列),不可變(特色)，有序

元祖就是不可變的列表,一般保存一些不讓修改的數據

(元素1， 元素2， 元素3...)

2.元素

空的元祖

tuple1 = ()
print(type(tuple1), tuple1)

1) 元素個數是1的元祖: 如果一個元祖中只有一個元素，這個元素后面必須加逗號！

tuple2 = (10,)
print(tuple2, type(tuple2))

2)元祖數據中小括號可以省略。(多個數據直接用逗號隔開，實質表示的是一個元祖)

tuple3 = 10, 23, 89, 10, '小米'
print(tuple3, type(tuple3))

3.獲取元素: 和列表一樣

tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2[1])
print(tuple2[2:])
for item in tuple2:
print(item, end= " ")

1.讓變量的個數和元祖中元素的個數保持一致,來一一獲取元祖中每個元素的值

point = (100, 50)
x, y = point
print('x:', x, 'y', y)

a, b, c = 10, 20, 30 # a, b, c = (10, 20, 30)

2) 讓多個變量同時獲取元祖中的元素的時候，可以在一個變量前加*號

將這個變量變成一個列表，來獲取不帶號的變量獲取后剩下的數據。(注意:帶號的半兩只能有一個)

student = ('小米', 18, 89, 68, 89, 90)
name, age, *scores =student
print(name, age, scores)

name, *scores, age = student
print(name, age, scores)

*items, a, b = student
print(item, a, b)

tuple4 = (10, 20)
print(*tuple4) # print(10, 20)

new_tuple4 = tuple4
print(new_tuple4)

1.什么是字典(dict)

字典(哈希)是python提供的容器型數據類型(序列),可變,無序

2.字典中的元素

{鍵值對1， 鍵值對2， 鍵值對3,....} - 字典的元素就是鍵值對

鍵值對 - '鍵：值'的形式成對出現，

鍵(key) - 要求不可變,唯一 (建議用字符串作為key，用來對值進行說明和區分的)

值(value) - 任何類型的數據都可以作為值

dict1 = {10: 100, 'name': 100, (1, 2): 100, 'a': 'abc', 'b': True, 'c': [1, 2], 'd': {'a': 2}}
print(dict1)

dict2 = {10: 100, 'name': 100, [1, 2]: 100} #TypeError: unhashable type: 'list'

dict1 = {10: 100, 'name': 100, {'a': 1}: 100} #TypeError: unhashable type: 'dict'

3.元素的操作

1)查 - 獲取值

"""
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

"""
3.遍歷字典
直接通過for循環遍歷字典的時候，獲取到的是所有的key
"""

1.直接遍歷(只用這個)

print('-----------------')
for item in dog:
print(item, dog[key])

2.間接遍歷

print('------------')
for value in dog.values():
print(value)

print('--------------')
for key, value in dog.items():
print(key, value)

2)增/改

"""
字典[key] = value - 如果key存在,修改key對應的值;如果key不存在，添加鍵值對
"""
class1 = {'name': 'py1902', 'address': '19樓5教室'}
print(class1)

增

class1['number'] = 50
print(class1) # {'name': 'py1902', 'address': '19樓5教室', 'number': 50}

改

class1['name'] = 'python1902'
print(class1)

3) 刪

"""
1.del 字典[key] - 刪除字典中指定key對應的鍵值對。如果key不存在會報錯
2.字典.pop(key) - 取出字典中key對應的值。如果key不存在會報錯
"""
class2 = {'name': 'python1902', 'address': '19樓5教室', 'num': 50}
del class2['num']
print(class2) # {'name': 'python1902', 'address': '19樓5教室'}

class2.pop('name')
print(class2)

4.字典相關操作

1)運算符:不支持數學運算,比較運算符只支持比較相等,不支持比較大小

print({'a': 100, 'b': 10} == {'b': 100, 'a': 10}) # 支持比較運算符

2) in / not in

key in/ not in 字典 - 判斷字典中是否存在指定的key

print('-----------')
class2 = {'name': 'python1902', 'address': '19樓5教室', 'num': 50}

print('name' in class1) - True

print(50 not in class1) - True

3) len

print(len(class2))

4) dict

"""
能轉換成字典的數據要求:數據本身是序列，序列中的每個元素也是長度2的序列，并且小序列中第一個元素是不可變的
"""
data = [(1, 2), ['a', 23]]
print(dict(data))

dict2 = {'a': 10, 'b': 20}
print(list(dict2)) # ['a', 'b']

5.相關方法

1)clear

"""
字典.clear() - 清空字典
"""
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)

2)copy

"""
字典.copy() - 拷貝字典中的鍵值對產生一個新的字典
"""
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}

dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}

3)formkeys

"""
dict.fromkeys(序列，值) - 創建一個新的字典,字典的key是序列的元素,key對應的value是值
"""
new_dict = dict.fromkeys('hello', 100)
print(new_dict)

4)keys, values, items

"""
字典.key() - 獲取字典中所有的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())

5)setdefault

"""
字典.setdefault(key, value) - 添加鍵值對
"""
students.setdefault('tel', '18803091680')
print(students)

6)update

"""
字典1.update(字典2) - 使用字典2中的鍵值對去更新字典1(不存在添加、存在修改)
"""
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2) # 結果: {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}
print(dict1)

1.什么是集合(set)

容器型數據類型(序列),可變、無序

2.集合中的元素

{元素1, 元素2. 元素3,....}

元素: 不可變、唯一(自帶去重功能)

注意: {}不能表示空的集合,set() - 空集合

set1 = set()
set2 = {1, 'abc', (1, 3), False, 1, 1, 1}

set2 = {1, 'abc', (1, 3), False, [1, 2]}

print(set2) # TypeError: unhashable type: 'list'

print(set2) # {(1, 3), 1, 'abc', False}

str1 = 'ssadjkasdkajkjkjsa'
print(''.join(set(str1)))

list1 = [1, 34, 43, 2, 2]
print(list(set(list1)))

3.元素相關的操作

1)查

集合不能單獨獲取指定的某一個元素，只支持遍歷

print("-----------")
set3 = (1, 2, 3, 44, 5, 21)
for x in set3:
print(x)

2)增

"""
集合.add(元素) - 往集合中農添加一個元素
集合.upade(序列) - 將系列中的元素添加到集合中(自帶去重)
"""

set1 = {1}
print(set1)
set1.add(100)
print(set1)
print('---------')
set1.update({'name': '張三', 'age':20})
print(set1) # {'age', 1, 'name', 100}

3)刪

"""
集合.remove(元素) - 刪除元素中指定的元素
"""

set4 = {'age', 1, 'name',100}
set4.remove(100)
print(set4)

(*)4.數學集合運算

set1 = {1, 2, 3, 4, 5, 6}
set2 = {2, 3, 4, 5, 6, 7}

兩門課:class1, class2

1)并集: |

"""
集合1 | 集合2 - 將兩個集合中的元素合并產生新的集合
"""
print(set1 | set2)

2）交集: & - 求兩個集合公共的部分

print(set1 & set2)

3)差集: 集合1 - 集合2 --- 獲取集合1中除了集合2以外的部分

print(set1 - set2) # {1}
print(set2 - set1) # {7}

4)補集:集合1^集合2 --- 兩個集合除了公共部分以外的部分

print(set1 ^ set2)

5)包含關系

"""
集合1 >= 集合2 - 集合1中是否包含集合2
集合1 <= 集合2 - 集合2中是否包含集合1
"""
print({5, 6, 7, 8, 9} >= {1,2, 3}) # False
print({5, 6, 7, 8, 9} >= {5, 9}) # True