1.字典 -- dict

          
            字典是無序,可變的
鍵:使用不可變數(shù)據(jù)類型(可哈希),鍵是唯一的
值:可以任意
          
        

增加

          
                 dic["鍵"] = "值"  # 暴力添加
     dic.setdefault("鍵","值")  # 存在不添加
          
        

刪除

          
                 del dic["鍵"]
     dic.pop("鍵")
     dic.clear()
          
        

改

          
                 dic["鍵"] = "值"
     dic.update("要更新的字典")
          
        

查

          
                 for 循環(huán)查詢的是字典的鍵
     get("鍵")  #存在返回字典中鍵對(duì)應(yīng)的值,不存在返回None
     dic["鍵"]    # 存在返回字典中鍵對(duì)應(yīng)的值,不存在報(bào)錯(cuò)
          
        

其他操作

          
                 keys  --  獲取字典中所有的鍵      存放在一個(gè)高仿列表中
     values  --  獲取字典中所有的值    存放在一個(gè)高仿列表中
     items  --  獲取字典中所有的鍵和值 存放在一個(gè)高仿列表里的元組(元組第一個(gè)元素:鍵,第二元素:值)
          
        

解構(gòu)

          
                a = 10
    b = 20
    a,b = b,a
          
        

字典的嵌套

          
               dic = {1001:["周杰倫","林俊杰"],
           1002:{"汪峰":{"前妻1":["大燒餅"],"前妻2":["熊大","熊二"],"國(guó)際章":"肉絲"}},
           1003:{"陳冠希":["阿嬌","阿薩","張柏芝"]},
           1004:{"韋小寶":[{"教主夫人":["教主"]},
                        {"阿珂":"刺客"},
                        {"雙兒":"天地會(huì)"},
                        {"愛心覺羅建寧":"公主"},
                        {"獨(dú)臂神尼":{"韋小寶師父":{"蘭陵王":"隱身"},"花木蘭":[
                               "唧唧復(fù)唧唧","木蘭是戰(zhàn)士",{"爸爸":["花和尚"]}]
                                 }},
                        {"陳圓圓":"丈母娘"},{"穆建平":"小郡主"}]},
           1005:{"常鑫":["大黑哥","大燒餅","吃大煎餅","肉夾饃","自行車","井蓋",]}
           }
    
 print(dic)
 print(dic[1004]["韋小寶"][0]["教主夫人"][0])
 print(dic[1005]["常鑫"][-1])
 print(dic[1002]["汪峰"]["前妻2"][-1])
 print(dic[1004]["韋小寶"][4]["獨(dú)臂神尼"]["韋小寶師父"]["蘭陵王"])
 print(dic[1004]["韋小寶"][4]["獨(dú)臂神尼"]["花木蘭"][2]["爸爸"][0])
          
        

          
                # 查找的時(shí)候一層一層的通過鍵進(jìn)行查找
    # 鍵
          
        

小數(shù)據(jù)池--緩存機(jī)制(駐留機(jī)制)

== 判斷兩邊內(nèi)容是否相等

          
            a=10
b=10
print(a==b)
Ture
          
        

is 是

          
            a=10
b=10
print(a is b) # is 判斷基于內(nèi)存地址進(jìn)行判斷

#查ID
print(id(a))
print(id(b))
          
        

小數(shù)據(jù)池的數(shù)字范圍:-5~256

          
            a = -2.5 * 2
b = -2.5 * 2
print(id(a))
print(id(b))

a = "alex你好" *2
b = "alex你好" *2
print(id(a))
print(id(b))
          
        

代碼塊:一個(gè)文件,一個(gè)函數(shù),一個(gè)類,一個(gè)模塊,終端中每一個(gè)行是一個(gè)代碼塊

支持:

          
            數(shù)字:
  在同一代碼塊下 只要內(nèi)容相同就采用相同的內(nèi)存地址(-5以后就不是)
# 數(shù)字在做乘法的時(shí)候范圍 -5 ~ 256  ****
  數(shù)字在做乘法的時(shí)候不能使用浮點(diǎn)數(shù)
字符串:
  在同一代碼塊下 只要內(nèi)容相同就采用相同的內(nèi)存地址
# 乘法的時(shí)候總長(zhǎng)度不能超過20   ****
  乘法的時(shí)候中文,特殊符號(hào)乘以1或0
布爾值:
  在同一代碼塊下 只要內(nèi)容相同就采用相同的內(nèi)存地址
          
        

小數(shù)據(jù)池

          
            # 數(shù)字:  -5 ~ 256   ****
字符串:
      在同一代碼塊下 只要內(nèi)容相同就采用相同的內(nèi)存地址
    # 乘法的時(shí)候總長(zhǎng)度不能超過20   ****
      乘法的時(shí)候中文,特殊符號(hào)乘以0
布爾值:
      在同一代碼塊下 只要內(nèi)容相同就采用相同的內(nèi)存地址
小數(shù)據(jù)池的驗(yàn)證方法,必須脫離代碼塊才能進(jìn)行驗(yàn)證
先執(zhí)行代碼塊的規(guī)則,在執(zhí)行小數(shù)據(jù)的規(guī)則 --(駐留機(jī)制)
          
        

必會(huì):

#重點(diǎn)重點(diǎn)

          
            # ==  判斷等號(hào)兩邊的值是否相等   ****
# is  判斷兩邊的內(nèi)存地址是否相等  ****
          
        

總結(jié)

          
                1.1代碼塊: 一個(gè)文件,一個(gè)函數(shù),一個(gè)類,一個(gè)模塊,終端中每一行
       1.1.1 數(shù)字: -5 ~ 256
       1.1.2 字符串: 乘法時(shí)總長(zhǎng)度不能超過20
       1.1.3 布爾值: 內(nèi)容相同內(nèi)存地址相同
    1.2 小數(shù)據(jù)池:
       1.2.1 數(shù)字: -5 ~ 256
       1.2.2 字符串: 乘法時(shí)總長(zhǎng)度不能超過20
       1.2.3 布爾值: 內(nèi)容相同內(nèi)存地址相同
    1.3 先執(zhí)行代碼塊后執(zhí)行小數(shù)據(jù)池
    1.4 == is
        1.4.1 == 判斷等號(hào)兩邊值是否相等
        1.4.2 is 判斷兩邊的值內(nèi)存地址是否相等
          
        

深淺拷貝--復(fù)制

          
            # 面試必問:賦值,淺拷貝,深拷貝

# 淺拷貝=修改第一層元素不改變,其它改變.
# 深拷貝=修改任何位置,另外一個(gè)不改變.
          
        

          
            lst = [1,2,3,[5,6,7]]
lst1 = lst
print(lst1)
print(lst)

lst[-1].append(8)
print(lst1)
print(lst)

lst1 = lst.copy()  # 新開辟一個(gè)空間給lst1

print(lst[-1])
print(lst1[-1])

print(id(lst1[-1]))
print(id(lst[-1]))
          
        

淺拷貝的時(shí)候

只會(huì)開辟一個(gè)新的容器列表,其他元素使用的都是源列表中的元素

          
            # 淺拷貝=修改第一層元素不改變,其它改變.
          
        

          
            lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()     # lst1 = lst.copy()
lst1[-1].append(8)
print(lst)
print(lst1)
          
        

深拷貝

不可變的數(shù)據(jù)類型公用,可變的數(shù)據(jù)類型重新開辟一個(gè)空間,對(duì)源數(shù)據(jù)進(jìn)行修改,深拷貝的內(nèi)容不進(jìn)行改變

          
            # 深拷貝=修改任何位置,另外一個(gè)不改變.
          
        

          
             import copy  #導(dǎo)入
 lst = [1,2,3,[5,6,7]]
 lst1 = copy.deepcopy(lst)  # 深拷貝 lst1 = copy.deepcopy(lst)
 lst[-1].append(8)
 print(lst)
 print(lst1)
          
        

總結(jié)

          
            # 淺拷貝的時(shí)候只拷貝第一層元素
# 淺拷貝在修改第一層元素(不可變數(shù)據(jù)類型)的時(shí)候,拷貝出來的新列表不進(jìn)行改變
# 淺拷貝在替換第一層元素(可變數(shù)據(jù)類型)的時(shí)候,拷貝出來的新列表不進(jìn)行改變
# 淺拷貝在修改第一層元素中的元素(第二層)的時(shí)候,拷貝出來的新列表進(jìn)行改變

# 深拷貝開辟一個(gè)容器空間(列表),不可變數(shù)據(jù)公用,可變數(shù)據(jù)數(shù)據(jù)類型(再次開辟一個(gè)新的空間)
# ,空間里的值是不可變的數(shù)據(jù)進(jìn)行共用的,可變的數(shù)據(jù)類型再次開辟空間
          
        

測(cè)試代碼

          
            #淺拷貝
        s = [1, 2, 3, [4, 5, 6]]
        s1 = s.copy()
        s[-1] = 11111
        print(s)
        print(s1)
#深拷貝
        s=[1,2,3,[4,5,6]]
        import copy
        s1=copy.deepcopy(s)
        s[-1][1]=11111
        print(s)
        print(s1)
          
        

集合--set

沒有值的字典 無序--不支持索引

**** 天然去重

定義集合

          
             s = {1,"alex",False,(1,2,3),12,1,12,4,6,32,2,4}
 print(s)
          
        

面試題:

          
            lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))
          
        

s = {1,2,3,4}

          
            增:
s.add("67")  #只能添加一個(gè)
print(s)
s.update("今天")  # 迭代添加
print(s)
          
        

          
            刪:
print(s.pop())  # pop有返回值
print(s)
s.remove(3)     # 指定元素刪除
print(s)
s.clear()         # 清空   -- set() 空集合
print(s)
          
        

          
            改:
先刪在加
          
        

          
             查:
 for i in {1,2,3}:
     print(i)
          
        

其他操作:

          
            s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
print(s1 & s2)  # 交集
print(s1 | s2)  # 并集
print(s1 - s2)  # 差集
print(s1 ^ s2)  # 反交集
print(s1 > s2)  # 父集(超集)
print(s1 < s2)  # 子集
          
        

          
             print(frozenset(s1))  # 凍結(jié)集合 更不常用
 dic = {frozenset(s1):1}
 print(dic)
          
        

基礎(chǔ)類型補(bǔ)充

str:不可變

1.首字母大寫

          
            name = "alex"
name1 = name.capitalize()
print(name1)
          
        

2.每個(gè)單詞首字母大寫

          
            name = "alex wusir"
print(name.title())
          
        

3.大小寫反轉(zhuǎn)

          
             name = "Alex"
 print(name.swapcase())
          
        

4.居中--填充

          
             name = "alex"
 print(name.center(20,"-"))
          
        

5.查找 從左向右 只查找一個(gè)

          
             name = "alelx"
 print(name.find("b"))  #find查找不存在的返回-1
 print(name.index("b"))   #index查找不存在的就報(bào)錯(cuò)
          
        

6.拼接

          
             name = "al3x"
# print("_".join(name))  ***
          
        

7.格式化

          
             1.%s
 2.f
 3.name.format()
 name = "alex{},{},{}"
 print(name.format(1,2,3)) # 按照順序位置進(jìn)行填充
 name = "alex{2},{0},{1}"
 print(name.format("a","b","c")) # 按照索引值進(jìn)行填充
 name = "alex{a},{b},{c}"
 print(name.format(a=1,c=11,b=67)) # 按照關(guān)鍵字進(jìn)行填充
          
        

8.+ * 開辟新的空間

          
            name = "alex"
name1 = "wusir"
print(id(name))
print(id(name1))
print(id(name + name1))
          
        

list:

定義方法

          
            list("123")
          
        

其他方法

          
            lst = [1,2,23,234,435,36,23,213421,421,4231,534,65]
lst.sort()  # 排序 (升序)
print(lst)

lst = ["你好","我好"]
lst.sort()  # 排序 (默認(rèn)升序)
print(lst)

lst.sort(reverse=True) # 降序
print(lst)

lst = [1,2,3,4453,5,6,7]
print(lst[::-1])
lst.reverse()  # 反轉(zhuǎn)
print(lst)

lst = [1,2,3,4,5123,21345,231123,4,1235,234,123]
lst.sort()
lst.reverse()
print(lst)
          
        

面試題

          
            lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)

lst = [1,[]]
new_lst = lst * 5
new_lst[0] = 10
print(new_lst)

lst = [1,[]]
new_lst = lst * 5
new_lst[1] = 10
print(new_lst)

方式一:
lst.extend(lst1)
print(lst)
方式二:
print(lst+lst1)
new_lst = lst * 5
print(id(new_lst[0]), id(new_lst[0]))

lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)
          
        

tuple

          
             tu = ("12")  # 數(shù)據(jù)類型是()中數(shù)據(jù)本身
 print(type(tu))

 tu = (1,)   # (1,)是元組
 print(type(tu))

 元組 + * 不可變共用,可變也共用
          
        

dict

定義一個(gè)字典

          
            print(dict(k=1,k1=2))
          
        

隨機(jī)刪除:popitem

          
            dic = {"key":1,"key2":2,"key3":56}
print(dic.popitem())  # 返回的是被刪除的鍵值對(duì)(鍵,值)
print(dic)
python36 默認(rèn)刪除最后一個(gè)
          
        

          
            dic = {}
dic.fromkeys("123",[23]) # 批量添加鍵值對(duì){"1":[23],"2":[23],"3":[23]}
print(dic)

dic = dict.fromkeys("123456789",1) # 批量添加鍵值對(duì)"鍵是可迭代對(duì)象",值 -- 會(huì)被共用
dic["1"] = 18
print(dic)
          
        

set

          
                # set() -- 空集合
    # {} -- 空字典
    # 定義集合:
    # set("alex")  # 迭代添加的
          
        

          
            bool: False
數(shù)字: 0
字符串: ""
列表:[]
元組:()
字典:{}
集合: set()
其他: None
          
        

數(shù)據(jù)類型之間轉(zhuǎn)換

          
            list  tuple
tuple list
str list
name = "alex"  print(name.split())
list str
lst = ["1","2","3"] # print(''.join(lst))

dict -- str
dic = {"1":2}
print(str(dic),type(str(dic)))
print(dict("{1:1}"))

set - list
list - set
          
        

          
            # python數(shù)據(jù)類型:
# 可變:
# list ,dict ,set
# 不可變:
# int bool str tuple
# 有序:
# list,tuple,str,int,bool
# 無序:
# dict,set
# 取值方式:
# 索引: str list tuple
# 直接: set ,int ,bool
#   鍵: dict
          
        

二次編碼

密碼本

          
             ascii  -- 沒有中文
 gbk    -- 英文 8b(位) 1B(字節(jié)) 中文 16b 2B
 unicode -- 英文16b 2B  中文32b 4B
 utf-8 --   英文8b 1B  歐洲16b 2B  亞洲24b 3B
          
        

          
             name = "你好啊"
 s1 = name.encode("utf-8") # 編碼  9
 s2 = name.encode("gbk") # 編碼  6
 s2 = s1.decode("utf-8") # 解碼
 print(s2.encode("gbk"))
# 以什么編碼集(密碼本)進(jìn)行編碼就要用什么編碼集(密碼本)解碼
          
        

以后會(huì)遇見的坑坑坑

循環(huán)

          
            lst = [1,2]
for i in lst:
    lst.append(3)
print(lst)  # 死循環(huán)
          
        

刪除列表的坑

          
            lst = [1,2,3,4]
for i in lst:
    lst.pop()
print(lst)
          
        

          
            lst = [1,2,3,4]
for i in lst:
    lst.pop(0)
print(lst)
          
        

          
            lst = [1,2,3,4]
for i in lst:
    lst.remove(i)
print(lst)
          
        

成功刪除的方式

          
            lst = [1,2,3,4,6]
for i in range(len(lst)):
    lst.pop()
print(lst)
          
        

          
            lst = [1,2,3,4,6]
for i in range(len(lst)-1,-1,-1):
    del lst[i]
print(lst)
          
        

          
            lst = [1,2,3,4,6]
for i in range(len(lst)):
    del lst[-1]
print(lst)
          
        

          
            lst = [1,2,3,4,5,6]
lst1 = lst.copy()
for i in lst1:
    lst.remove(i)
print(lst)
          
        

刪除字典的坑

          
            dic = dict.fromkeys("12345",1)  # 字典的迭代的時(shí)候改變了原來的大小(不能加不能刪)
for i in dic:
    dic[i] = "123"
print(dic)
          
        

          
            dic = dict.fromkeys("12345",1)
dic1 = dic.copy()
for i in dic1:
    dic.pop(i)
print(dic)

# 集合和字典都是迭代的時(shí)候不能改變?cè)瓉淼拇笮?
          
        

文件操作

理論性知識(shí)

          
            "蘿莉小姐姐電話號(hào).txt"
open()  # 打開
file  # 文件的位置(路徑)
mode  # 操作文件的模式
encoding # 文件編碼方式
f  # 文件句柄

f = open("蘿莉小姐姐電話號(hào)",mode="r",encoding="utf-8")
print(f.read())
f.close()

操作文件:
    1. 打開文件
    2. 操作文件
    3. 關(guān)閉文件

文件操作的模式:
r,w,a (重要)
rb,wb,ab (次要)
r+,w+,a+ (沒啥用)

f = open("文件的路徑(文件放的位置)",mode="操作文件的模式",encoding="文件的編碼") # 內(nèi)置函數(shù)
f(文件句柄)
          
        

重要知識(shí):r讀,w寫,a加 (重要) 內(nèi)容

R操作 讀

          
            f = open("蘿莉小姐姐電話號(hào)",mode="r",encoding="utf-8")
print(f.read())    #全部讀取
print(f.read(5))   #按照字符進(jìn)行讀取
print(f.read())

print(f.readline())  # 讀取一行內(nèi)容,自動(dòng)換行
print(f.readline())  # "常鑫你就是大帥比\n"
print(f.readline().strip()) #去除換行符

print(f.readlines())  # 一行一行的讀取,存放在列表中

解決大文件:
for i in f:
    print(i)  # 本質(zhì)就是一行一行進(jìn)行讀取

print(f.readline())
print(f.readline())
print(f.readline())
          
        

W操作 寫

          
            w分為兩步:
    1.先清空文件
    2.寫入文件

f = open("蘿莉小姐姐電話號(hào)","w",encoding="utf-8")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")
          
        

路徑

          
            1.絕對(duì)路徑 -- C:\user\meet\python24\蘿莉小姐姐電話號(hào)
2.相對(duì)路徑
          
        

          
            絕對(duì)路徑方式打開文件
f = open("F:\s24\day08\蘿莉小姐姐電話號(hào)","r",encoding="utf-8")
print(f.read())

相對(duì)路徑方式打開文件
f = open("../day03/蘿莉小姐姐電話號(hào)","r",encoding="utf-8")
print(f.read())
../ 返回上一層

f = open(r"C:\user\net\s24\day03\蘿莉小姐姐電話號(hào)","r",encoding="utf-8")
          
        

          
            路徑轉(zhuǎn)義:
    1."\\"
    2.r"C:\user\net"
推薦使用相對(duì)路徑 (*****)

s = "[1,'2',3,4]"
print(s)
print(repr(s))  # repr -- 顯示數(shù)據(jù)原生態(tài)
          
        

A操作:追加寫 加

          
            在源文件的基礎(chǔ)上進(jìn)行添加
f = open("../day03/蘿莉小姐姐電話號(hào)","a",encoding="utf-8")
f.write("138383848\n")
f.write("138383850\n")
          
        

次要知識(shí):rb,wb,ab (次要) 字節(jié)

rb 讀 字節(jié)

          
            f1 = open("1.jpg","rb")
print(f1.read())   # 全部讀取
print(f1.read(3))  # 按照字節(jié)讀取
          
        

wb 寫 字節(jié)

          
            f = open("3.jpg","wb")
f.write(f1.read())

          
        

ab 加 字節(jié)

          
            f = open("2.jpg","ab")
f.write("你好啊".encode("utf-8"))

f = open("2.jpg","rb")
print(f.read())

          
        

不重要: +操作

R+ 讀寫-先讀后寫

          
            錯(cuò)誤的操作 (坑)
f = open("蘿莉小姐姐電話號(hào)","r+",encoding="utf-8")
f.write("常鑫你太美")
print(f.read())


正確的操作:
f = open("蘿莉小姐姐電話號(hào)","r+",encoding="utf-8")
print(f.read())
f.write("常鑫你太美")

          
        

w+ 清空寫 讀

          
            f = open("蘿莉小姐姐電話號(hào)","w+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell())
f.seek(15)         
print(f.tell())
print(f.read())

          
        

a+ 追加寫 讀

          
            f = open("蘿莉小姐姐電話號(hào)","a+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell())   # 字節(jié)數(shù)
print(f.seek(0,0))  # 0將光標(biāo)移動(dòng)到文件的頭部
print(f.read())

          
        

其他操作:

          
            tell 查看光標(biāo)    --- 返回的是字節(jié)數(shù)
seek 移動(dòng)光標(biāo)
    1.seek(0,0)  -- 移動(dòng)到文件的頭部
    2.seek(0,1)  -- 當(dāng)前位置
    3.seek(0,2)  -- 移動(dòng)到文件的末尾
    4.seek(3)    -- 按照字節(jié)進(jìn)行移動(dòng)(按照編碼集,自己進(jìn)行計(jì)算)

          
        

          
            f = open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")
print(f.read(3)) # 字符

f = open("蘿莉小姐姐電話號(hào)","rb")
print(f.read(3))   # 字節(jié)

f = open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")
print(f.read(3))     # 字符

          
        

錯(cuò)誤操作

          
            f = open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")
f.seek(-1)
print(f.read())

          
        

文件修改

          
            f = open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")
s = f.read()
s1 = s.replace("你太美","吃煎餅")

f1 = open("蘿莉小姐姐電話號(hào)","w",encoding="gbk")
f1.write(s1)

with 關(guān)鍵字 open("蘿莉小姐姐電話號(hào)","r",encoding="gbk") as f:
  文件操作的具體內(nèi)容

          
        

w,a 檢測(cè)有文件就操作,沒文件就創(chuàng)建

          
            with open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")as f,\
        open("蘿莉小姐姐電話號(hào).txt","w",encoding="gbk")as f1:
    for i in f:
        s1 = i.replace("大燒餅","井蓋")
        f1.write(s1)

import os
os.rename("蘿莉小姐姐電話號(hào)","蘿莉小姐姐電話號(hào).bak")
os.rename("蘿莉小姐姐電話號(hào).txt","蘿莉小姐姐電話號(hào)")

with open("蘿莉小姐姐電話號(hào)","r",encoding="gbk")as f:
    pass # 縮進(jìn)里操作文件
print(f.read())  # 文件及已經(jīng)關(guān)閉了

          
        

---

總結(jié)

1.字典 -- dict

          
            字典是無序,可變的
鍵:使用不可變數(shù)據(jù)類型(可哈希),鍵是唯一的
值:可以任意
          
        

增加

          
                 dic["鍵"] = "值"  # 暴力添加
     dic.setdefault("鍵","值")  # 存在不添加
          
        

刪除

          
                 del dic["鍵"]
     dic.pop("鍵")
     dic.clear()
          
        

改

          
                 dic["鍵"] = "值"
     dic.update("要更新的字典")
          
        

查

          
                 for 循環(huán)查詢的是字典的鍵
     get("鍵")  #存在返回字典中鍵對(duì)應(yīng)的值,不存在返回None
     dic["鍵"]    # 存在返回字典中鍵對(duì)應(yīng)的值,不存在報(bào)錯(cuò)
          
        

其他操作

          
                 keys  --  獲取字典中所有的鍵      存放在一個(gè)高仿列表中
     values  --  獲取字典中所有的值    存放在一個(gè)高仿列表中
     items  --  獲取字典中所有的鍵和值 存放在一個(gè)高仿列表里的元組(元組第一個(gè)元素:鍵,第二元素:值)
          
        

解構(gòu)

          
                a = 10
    b = 20
    a,b = b,a
          
        

字典的嵌套

          
               dic = {1001:["周杰倫","林俊杰"],
           1002:{"汪峰":{"前妻1":["大燒餅"],"前妻2":["熊大","熊二"],"國(guó)際章":"肉絲"}},
           1003:{"陳冠希":["阿嬌","阿薩","張柏芝"]},
           1004:{"韋小寶":[{"教主夫人":["教主"]},
                        {"阿珂":"刺客"},
                        {"雙兒":"天地會(huì)"},
                        {"愛心覺羅建寧":"公主"},
                        {"獨(dú)臂神尼":{"韋小寶師父":{"蘭陵王":"隱身"},"花木蘭":[
                               "唧唧復(fù)唧唧","木蘭是戰(zhàn)士",{"爸爸":["花和尚"]}]
                                 }},
                        {"陳圓圓":"丈母娘"},{"穆建平":"小郡主"}]},
           1005:{"常鑫":["大黑哥","大燒餅","吃大煎餅","肉夾饃","自行車","井蓋",]}
           }
    
 print(dic)
 print(dic[1004]["韋小寶"][0]["教主夫人"][0])
 print(dic[1005]["常鑫"][-1])
 print(dic[1002]["汪峰"]["前妻2"][-1])
 print(dic[1004]["韋小寶"][4]["獨(dú)臂神尼"]["韋小寶師父"]["蘭陵王"])
 print(dic[1004]["韋小寶"][4]["獨(dú)臂神尼"]["花木蘭"][2]["爸爸"][0])
          
        

          
                # 查找的時(shí)候一層一層的通過鍵進(jìn)行查找
    # 鍵
          
        

1.小數(shù)據(jù)池

          
                1.1代碼塊: 一個(gè)文件,一個(gè)函數(shù),一個(gè)類,一個(gè)模塊,終端中每一行
       1.1.1 數(shù)字: -5 ~ 256
       1.1.2 字符串: 乘法時(shí)總長(zhǎng)度不能超過20
       1.1.3 布爾值: 內(nèi)容相同內(nèi)存地址相同
    1.2 小數(shù)據(jù)池:
       1.2.1 數(shù)字: -5 ~ 256
       1.2.2 字符串: 乘法時(shí)總長(zhǎng)度不能超過20
       1.2.3 布爾值: 內(nèi)容相同內(nèi)存地址相同
    1.3 先執(zhí)行代碼塊后執(zhí)行小數(shù)據(jù)池
    1.4 == is
        1.4.1 == 判斷等號(hào)兩邊值是否相等
        1.4.2 is 判斷兩邊的值內(nèi)存地址是否相等
          
        

2.深淺拷貝

          
                2.1 賦值:
        多個(gè)變量名指向同一個(gè)內(nèi)存地址
        一個(gè)變量對(duì)其進(jìn)行操作,其他變量查看時(shí)都變動(dòng)
    2.2 淺拷貝:
        lst[1:10] -- 是淺拷貝
        淺拷貝只拷貝第一層元素
        修改第一層元素時(shí),新開辟的不進(jìn)行改變
    2.3 深拷貝:
        不可變的數(shù)據(jù)類型共用,可變的數(shù)據(jù)類型重新開辟一個(gè)空間
        對(duì)源數(shù)據(jù)進(jìn)行修改,深拷貝的內(nèi)容不進(jìn)行改變
        
# 淺拷貝=修改第一層元素不改變,其它改變.
# 深拷貝=修改任何位置,另外一個(gè)不改變.
          
        

3.集合

          
            3. 集合
    3.1 集合是沒用值得字典
    3.2 集合是無序,可變的
    3.3 集合天然去重
    3.4
        增:add ,update
        刪:pop remove clear
        改:先刪后加
        查: for循環(huán)
    3.5 其他操作:
        & 交集
        | 并集
        - 差集
        ^ 反交集
        > 超集
        < 子集
        frozenset()  凍結(jié)集合
    3.6 面試題:
        list(set(要去去重的數(shù)據(jù)))
          
        

1.編碼解碼

          
            # 編碼:將文字轉(zhuǎn)換成字節(jié)形式  encode
# 解碼:將字節(jié)轉(zhuǎn)換成文字形式  decode
          
        

2.基礎(chǔ)數(shù)據(jù)類型

          
            str:
    首字母大寫
    每個(gè)單詞首字母大寫
    大小寫反轉(zhuǎn)
    居中 -- 填充
    查找:find index
    拼接
    格式化: name.format
          
        

          
            list:
    排序(默認(rèn)是升序) 降序sort(reverse=True)
    反轉(zhuǎn)
    查找 index
    統(tǒng)計(jì) count
    + * 元素都是共用的
          
        

          
                面試題:

tuple:
    (1,)# 元組
    (1) # 括號(hào)里數(shù)據(jù)本身
    + *

dict:
    popitem
    fromkeys("可迭代的鍵",共用的值)   -- 坑
    dict(key = 1,key2 =2)

set:
    set() -- 空集合
    set("alex") # 迭代添加
          
        

3.坑

          
                列表刪除  -- 從后向前刪除
    創(chuàng)建一個(gè)新的列表,刪除舊的列表

    字典刪除  -- 循環(huán)的時(shí)候不能改變?cè)磾?shù)據(jù)的大小 (可以改變值)
    創(chuàng)建一個(gè)新的字典,刪除舊的字典

    集合刪除  -- 循環(huán)的時(shí)候不能改變?cè)磾?shù)據(jù)的大小
          
        

類型轉(zhuǎn)換

          
                 list -- str  join
     str -- list  split
          
        

文件操作

          
            open  -- 打開文件
file  -- 文件路徑
mode  -- 操作文件的模式
encoding -- 文件的編碼集

打開文件
操作文件
關(guān)閉文件
          
        

r,w,a (******)

          
                 r: 讀文本
        read()  全部讀取
        read(3) 看文件的操作方式 r/w/a 字符
        readline 讀取一行(自帶換行符)
        readlines() 一行一行讀取存放在列表中

     w:清空,寫
        open("xxx","w",encoding="utf-8")  # 進(jìn)行清空
        write()  只能寫字符串

     a:追加
        在文本的末尾進(jìn)行寫入
        write()
          
        

rb,wb,ab(****)

          
                rb:讀字節(jié)
        read()  全部讀取
        read(3) 看文件的操作方式  rb/wb/ab 字節(jié)
        readline 讀取一行(自帶換行符)
        readlines() 一行一行讀取存放在列表中

    wb:清空,寫
        open("xxx","wb")  # 進(jìn)行清空
            write()  只能寫字節(jié)

    ab:追加
        open("xxx","ab")
            write()  只能寫字節(jié)
          
        

r+,w+,a+ (r+)

          
                r+:讀寫
        錯(cuò)誤的方式是寫讀
        先讀后寫

    w+:清空寫,讀
        1.清空文件
        2.讀取內(nèi)容(默認(rèn)讀取的是空)
        3.移動(dòng)光標(biāo)

    a+:追加寫,讀
        1.先寫后讀
        2.讀取內(nèi)容(默認(rèn)讀取的是空)
        3.移動(dòng)光標(biāo)
# 注意點(diǎn): (a,ab,a+)將光標(biāo)移動(dòng)到某個(gè)位置進(jìn)行,寫入的時(shí)候還是在文件的末尾
          
        

其他操作:

          
                tell()  查看光標(biāo)返回的是字節(jié)
    seek() 移動(dòng)光標(biāo)
        seek(0,0) 移動(dòng)文件頭部
        seek(0,1) 當(dāng)前位置
        seek(0,2) 移動(dòng)文件末尾

        seek(3)  # 按照字節(jié)進(jìn)行計(jì)算 (計(jì)算方式根據(jù)編碼計(jì)算)

    with open("文件路徑","操作模式",編碼")as f:
        操作文件

    with open的好處:
        1.可以同時(shí)打開多個(gè)文件
        2.能夠自動(dòng)關(guān)閉文件
          
        

          
                修改文件內(nèi)容:
        1.創(chuàng)建一個(gè)新的文件
        2.將文件中的內(nèi)容進(jìn)行替換
        3.替換后的內(nèi)容寫入新文件中
        4.改變文件名
          
        

重點(diǎn)

          
                路徑:
        絕對(duì)路徑: 從磁盤根部進(jìn)行查找
        相對(duì)路徑: ../返回上一級(jí)  --推薦使用
        轉(zhuǎn)義:
            1."C:\\user\\ner"
            2. r"C:\user\ner"  -- 推薦使用