2.python的基本語法元素_組合數據類型

#-*- coding: utf-8 -*-

#組合數字類型 列表 元組 字典 集合
print("============列表============")
#2.1 列表  序列類型  數據有位置順序 能夠通過位置序號訪問其中元素
#列表是一個可以使用多種類型元素，支持元素都增，刪，改，查操作都序列類型
a = ["Python",1989,True,{"version":3.7}]
print (a)
print (a[3])
#列表的另一種產生方式：list(可迭代對象)
#可迭代對象包括：字符串、元組、集合、range()
#字符串轉列表
print(list("abcdefg"))
#元組轉列表
print (list(("we","are","one","family")))
#集合轉列表
print (list({"lilei","hanmeimei","jim","Green"}))
#特殊的range()
for i in  [0,1,2,3,4,5]:
    print (i)

for i in range(6):
    print (i)

#range(起始數字，中止數字，數字間隔)
#如果起始數字缺省，默認爲0，不包含中止數字，數字間隔缺省，默認爲1
for i in range(1,11,2):
    print(i)

#range轉列表
print(list(range(1,11,2)))
#列表的性質
#列表的長度  len(列表)
ls = [1,2,3,4,5]
print (len(ls))
#列表的索引，與同爲序列類型的字符串完全相同
#變量名[位置編號]，正向索引從0開始，方向索引從-1開始
cars = ["BYD","BMW","AUDI","TOYOTA"]
print(cars[0])
print (cars[-1])
#列表的切片
#變量名[開始位置：結束位置：切片間隔]
#正向切片
print (cars[:3])
print (cars[1:4:2])
print (cars[:])
print (cars[-4:-2])
#反向切片
print(cars[:-4:-1]) #開始位置缺省，默認爲-1
print(cars[::-1]) #獲得反向列表
#列表的操作符
#用list1+list2 的形式實現列表的拼接
a = [1,2]
b = [3,4]
print (a+b)
#用n*list或者list*n的方式實現列表的成倍複製
#列表初始化的一種方式
print ([0]*10)
#列表的操作方法
#增加元素  在末尾增加元素  列表.append(待增加元素)
languages = ["Pyhton","C++","R"]
languages.append("Java")
print (languages)
#在任意位置插入元素  列表.insert(位置編號，待增元素)，在位置編號相應元素前插入待增元素
languages.insert(1,"C")
print (languages)

#在末尾整體插入另一列表
# 列表1.extend(列表2)，extend將列表2的元素逐個添加到列表1中
languages = ['Pyhton','C','C++','R','Java']
languages.extend(['Ruby','PHP'])
print (languages)
# append將列表2整體作爲一個元素添加到列表1中
languages.append(['Ruby','PHP'])
print (languages)
#刪除元素 刪除列表i位置的元素 列表.pop(位置)
languages =  ["Python","C++","C","R","Java"]
languages.pop(1)
print (languages)
#不寫位置信息，默認刪除最後一個元素
languages.pop()
print (languages)
#刪除列表中的第一次出現的待刪除元素， 列表.remove(待刪元素)
languages = ['Python','C','R','Java']
languages.remove('C')
print (languages)
#查找元素  列表中第一次出現待查找元素待位置  列表.index(待查元素)
languages = ['Python','C','R','Java']
idx = languages.index("Python")
print (idx)
#修改元素  通過"先索引後賦值"的方式，對元素進行修改 列表名[位置]=新值
languages = ['Python','C','R','Java']
languages[1] = "C++"
print (languages)
#列表複製
#方法1： 列表.copy()
languages = ['Python','C','R','Java']
# languages_2 = languages.copy()
# languages.pop()
# print (languages)
# print (languages_2)

#方法2：列表[:]
languages = ['Python','C','R','Java']
languages_3 = languages[:]
languages.pop()
print (languages)
print (languages_3)

#列表的排序
#使用 列表.sort()對列表進行永久排序 直接在列表上進行操作，無返回值
ls = [2,5,2,8,19,3,7]
ls.sort()
print (ls)
#遞減排序
ls1 = [2,5,2,8,19,3,7]
ls1.sort(reverse=True)
print (ls1)
#使用sorted(列表）對列表進行臨時排序，原列表保持不變，返回排序後的列表
ls2 = [2,5,2,8,19,3,7]
ls_2 = sorted(ls2)
print(ls_2)
#列表的翻轉 使用 列表.reverse() 對列表進行永久翻轉 直接在列表上進行操作，無返回值
ls3 = [1,2,3,4,5]
ls3.reverse()
print (ls3)
#使用for循環對列表進行遍歷
ls4 = [1,2,3,4,5]
for i in ls4:
    print (i)

print ("===============元組類型=================")
#元組 序列順序 但是不支持修改，增加，減少 即不可變帶列表
#其他操作與列表操作完全一致
b = (1,2,3,4,5)
print (b[2])

#打包與解包
def f1(x):
    return x**2,x**3  #實現打包返回，即將結果作爲一個元組返回
print (f1(3))
print (type(f1(3)))
#解包處理
a,b = f1(3)
print (a)
print (b)
#解包例子2
numbers = [201901,201902,201903]
name = ["xiaoming","xiaohong","xiaoqiang"]
#將列表numbers和name用zip進行打包之後，就將各自相同位置的元素變成一個元組
print(list(zip(numbers,name)))
#每次取到一個元素，立即進行解包賦值
for number,name in zip(numbers,name):
    print(number,name)

print ("================字典類型=================")
#字典 映射類型，通過鍵-值帶映射實現數據的存儲和查找，內部是無序的，字典的鍵不能重複
student = {201901:"小明",201902:"小紅",201903:"小強"}
#字典的索引 通過 字典[鍵]的形式來獲取對應的值
print (student[201901])
student = {}
#字典的鍵必須是不可變類型，如果鍵變了，就找不到對應的存儲的值了
#不可變類型： 數字、字符串、元組。一旦確定，它就是它自己，變了就不是它了，這些可以作爲字典的鍵
#可變類型：列表、字典、集合。 一旦確定，還可以隨意增刪改

#字典的長度--鍵值對的個數
student1 = {201901:"小明",201902:"小紅",201903:"小強"}
print (len(student1))
#字典的操作方法
#增加鍵值對 通過變量名[新鍵] = 新值
student2 = {201901:"小明",201902:"小紅",201903:"小強"}
student2[201904] = "小雪"
print (student2)
#刪除鍵值對
#通過del 變量名[待刪除鍵] 刪除鍵值對
student3 = {201901:"小明",201902:"小紅",201903:"小強"}
del student3[201903]
print (student3)
#通過變量名.pop(待刪除鍵) 刪除，同時獲得待刪除鍵值對對值
student4 = {201901:"小明",201902:"小紅",201903:"小強"}
value = student4.pop(201903)
print (value)
print (student4)
#變量名.popitem()隨機刪除一個鍵值對，並以元組返回刪除對鍵值對
student5 = {201901:"小明",201902:"小紅",201903:"小強"}
key,value = student5.popitem()
print(key,value)
print (student5)
#修改鍵值對對值 通過先索引後賦值對方法對相應對值進行修改
student6 = {201901:"小明",201902:"小紅",201903:"小強"}
student6[201902] = "小雪"
print (student6[201902])
#d.get()方法 　d.get(key,default) 從字典d中獲取鍵key對應對值，如果沒有這個值，則返回default
#統計 "牛奶奶找劉奶奶買牛奶"中字符出現對頻率
s = "牛奶奶找劉奶奶買牛奶"
d = {}
for i in s:
    d[i] = d.get(i,0) + 1
print (d)
#d.keys() 取字典裏所有的鍵
#d.values()  取字典裏所有的值
student6 = {201901:"xiaoming",201902:"xiaohong",201903:"xiaoqiang"}
print (list(student6.keys()))
print (list(student6.values()))
#d.items()方法及字典的遍歷
print(list(student6.items()))
for k,v in student6.items():
    print (k,v)

print("=================集合=================")
#集合 一系列互不相等元素的集合，無序且互斥
#集合元素必須是不可變類型：數字，字符串或元組，可視作字典的鍵
#集合可以看作是沒有值，或者值爲None的字典
s = {"xiaoming","xiaohong","xiaoqiang","xiaoming"} #可用於去重
print (s)
#集合的運算
#例子 通過集合進行交集並集的運算
Chinese_A = {"liu","zhang","manyu","zhong","gu","lin"}
print (Chinese_A)
Math_B = {"lin","guo","wang","liu","manyu","li"}
print (Math_B)
#交集運算，返回一個新集合，包括同時在A和B中的元素
print  (Chinese_A&Math_B)
#並集運算，返回一個包含A和B所有元素的新集合
print (Chinese_A|Math_B)
#返回包含A和B非共同元素的新集合
print (Chinese_A^Math_B)
#返回一個包含在集合A中但不在集合B中的元素的集合
print (Chinese_A - Math_B)
#集合的操作方法
#增加元素
stars = {"liu","zhang","manyu"}
stars.add("wang")
print (stars)
#移除元素
stars.remove("wang")
#計算集合的長度
print (len(stars))
#集合的遍歷
for star in stars:
    print(star)