一 列表

1.列表（list）

容器型數(shù)據(jù)類型（序列），有序、可變

2.元素

任何類型的數(shù)據(jù)都可以作為列表元素

3.元素的增刪改查（*******）

1.查
查單個元素：列表[下標(biāo)]
查部分元素(切片)：列表[開始下標(biāo)：結(jié)束下標(biāo)：步長]，列表[：]，列表[::-1]
遍歷：直接遍歷，遍歷下標(biāo)

2.增
列表.append（元素），    列表.insert（下標(biāo)，元素）

3,.刪
del 列表[下標(biāo)]
列表.remove（元素）
列表.pop（）        列表.pop（下標(biāo)） 

4.改
列表[下標(biāo)]=新值

4 . + * == != in /not in len（） list（）

5. 列表常用方法

1） count

列表.count(元素) -------統(tǒng)計列表中指定元素的個數(shù)，返回一個整數(shù)

nums = [1,2,3,4,1]
print(nums.count(1))

2)extend

列表.extend（序列） ----將序列中的元素全部添加到列表中

nums.extend('abc')
print(nums)     #  [1, 2, 3, 4, 1, 'a', 'b', 'c']

nums.extend([12,432,345])
print(nums)     #[1, 2, 3, 4, 1, 'a', 'b', 'c', 12, 432, 345]

3)index

列表.index（元素） ----獲取指定元素的下標(biāo)（如果元素有多個只取第一個）

注意：如果元素不存在會報錯?。。。?！

4)reverse

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

reversed（序列） -----反向序列，不修改原序列而是產(chǎn)生新的序列

nums = [1,2,3,4,1]
print(nums.reverse())
print(reversed(nums))

5）sort

列表.sort ---將列表中的元素從小到大排列
列表.sort(reverse=True) --將列表中的元素從大到小排序
sorted（序列） ---排序的時候不修改原序列，產(chǎn)生新的序列
注意：能夠進行排序的列表要求列表中的元素一致，并支持比較運算

nums = [1,2,3,4,1,4,3,1]
nums.sort()
print(nums)
nums.sort(reverse=True)
print(nums)
print(sorted(nums))    #小 ---->  大
print(sorted(nums,reverse=True))  #  大  --- 小 

6）clear

列表.clear（） -----刪除列表中的所有數(shù)據(jù)

nums = [1,2,3,4,1,4,3,1]
nums.clear()
print(nums)

7.copy

列表.copy（） -----相當(dāng)于[:]，將列表中的元素拷貝一份產(chǎn)生一個新的列表

nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))

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

二 元祖（tuple）

1.什么是元祖（tuple）

元祖是Python提供的容器型數(shù)據(jù)類型(序列)，不可變（特色），有序

元祖就是不可變的列表，一般保存一些不讓修改的數(shù)據(jù)

（元素1，元素2，元素3，.....）

2.元素

tuple1=() # 無意義

1)元素個數(shù)是1的元祖 : 如果一個元祖中只有一個元素，這個元素后面一定要加逗號

tuple2 = (10)
print(tuple2,type(tuple2))   # 10 <class 'int'>
tuple2 = (10,)
print(tuple2,type(tuple2))   #(10,) <class 'tuple'>

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

tuple5 = 10,20,31
print(tuple5[0])

3.獲取元素和列表一樣

1)讓變量的個數(shù)和元祖中的個數(shù)保持一致，來一一獲取

point = (100,90)
x, y = point
print(x, y)

2)讓多個變量同時獲取元祖中的元素的時候，可以在一個變量前加星號將這個變量變成一個列表來獲取不帶的變量獲取后剩下的數(shù)據(jù)。

（注意：帶*的變量只有一個）

student = ('小明', 18, 89, 68, 89, 90, 'abc')
name, age, *scores = student
print(name, age, scores)   # 小明 18 [89, 68, 89, 90, 100]

name, *scores, age, a = student
print(name, age, scores, a)   # 小明 90 [18, 89, 68, 89] 100

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

注意：如果在一個列表或者元祖前加星號，則是將這個列表或者元祖分開打印出來

三 字典（dict）

1.什么是字典(dict)

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

2.字典中的元素

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

鍵值對 -------- 以'鍵:值'的形式成對出現(xiàn)

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

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

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'

dict1 = {10: 100, 'name': 100, (1, 2): 100, 10: 200}
print(dict1)   # {10: 200, 'name': 100, (1, 2): 100}

3.元素的操作

1) 查 - 獲取值

1. 字典[key] --------- 獲取字典中key對應(yīng)的value。（如果key不存在會報錯！）
2. 字典.get(key) ------- 獲取字典中key對應(yīng)的value。（如果key不存在不報錯，結(jié)果是None）
3.字典.get(key, 默認(rèn)值) ------ 獲取字典中key對應(yīng)的value。（如果key不存在不報錯，結(jié)果是默認(rèn)值）

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', '公狗'))   # 公狗

4.遍歷字典

直接通過for循環(huán)遍歷字典的時候，獲取到的是所有的key

# 1.直接遍歷(只用這個)
for key in dog:
    print(key, dog[key])

# 2.間接遍歷
print('===================')
print(dog.values())
for value in dog.values():
    print(value)

print('====================')
print(dog.items())
for key, value in dog.items():
    print(key,  value)
# 只做了解

2) 增/改

字典[key] = value - 如果key存在, 修改key對應(yīng)的值; 如果key不存在，添加鍵值對

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

增

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

改

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

3) 刪

1. del 字典[key] - 刪除字典中指定key對應(yīng)的鍵值對。如果key不存在會報錯
2. 字典.pop(key) - 取出字典中key對應(yīng)的值。如果key不存在會報錯

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

name = class2.pop('name')
print(class2, name)      # {'name': 'python1902', 'address': '19樓5教室'}  python1902

4. 字典相關(guān)操作

1) 運算符：不支持?jǐn)?shù)學(xué)運算，比較運算符只支持比較相等不支持比較大小

print({'a': 100, 'b': 10} == {'b': 10, 'a': 100})    # True

2) in / not in

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

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

3) len

print(len(class2))

4) dict

能轉(zhuǎn)換成字典的數(shù)據(jù)要求： 數(shù)據(jù)本身是序列，序列中的每個元素也是長度是2的序列，并且小序列中第一個元素是不可變的

data = [(1, 2), ['a', 23]]
print(dict(data))

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

5.相關(guān)方法

1) clear

字典.clear() - 清空字典

dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)

2)copy

字典.copy() - 拷貝字典中的鍵值對產(chǎn)生一個新的字典

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

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

3)fromkeys

dict.fromkeys(序列, 值) - 創(chuàng)建一個新的字典，字典的key是序列的元素， key對應(yīng)的value是值

new_dict = dict.fromkeys('hello', 100)
print(new_dict)

4)keys, values, items

字典.keys() - 獲取字典中所有的key, 結(jié)果是一個序列
字典.values() - 獲取字典中所有的value, 結(jié)果是一個序列
字典.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', '15300022783')
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)
print(dict1)   # {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}

四 集合

1.什么是集合(set)

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

2.集合中的元素

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

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

注意: {}不是能表示空的集合,他表示字典的空集合，set() - 空集合

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

集合可以去重

str1 = 'hekskfahhheuwjseaaa'
print(''.join(set(str1)))      # hfkaweujs

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

3.元素相關(guān)操作

1) 查

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

set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
    print(x)

2) 增

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

set1 = {1}
print(set1)
set1.add(100)
print(set1)

set1.update('abc')
print(set1)

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

3) 刪

集合.remove(元素) - 刪除集合中指定的元素。（元素不存在會報錯!）

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

(*)4.數(shù)學(xué)集合運算

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

1) 并集: |

集合1 | 集合2 - 將兩個集合中的元素合并產(chǎn)生新的集合

print(set1 | set2)

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

print(set1 & set2)  # {4, 5, 6}

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

print(set1 - set2)  # {1, 2, 3}
print(set2 - set1)  # {7, 8}

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

print(set1 ^ set2)

5) 包含關(guān)系

集合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