python學習之基礎

第一章 列表

1.1 定義

列表 --list --容器

有序,可變,支持索引

列表: 存儲數據,支持的數據類型不少 字符串,數字,布爾值,列表,集合,元祖,字典,

#定義一個列表
lst = ["zz",123,True,"中國"] # 用逗號分隔的是一個元素

print(lst[0])
print(id(lst[0]))
# id獲取對象的內存地址

1.2 增長

lst.append("111")  #追加(在列表的最後位置添加一個內容)

lst.insert(2,"sd")  #插入  之後儘可能不要使用(當數據量比較大的時候會影響效率)

lst.extend("可迭代的內容")  # 迭代追加 只在最後追加

1.3 刪除

lst.pop()  # 默認刪除最後一個
lst.pop(-1) #能夠根據索引刪除

lst.remove("dsb") # 移除 經過元素名字進行刪除 
print(lst) #只能刪除1個

#remove 刪除所有,使用while循環
l=[9,6,5,6,6,7,8,9,6,0]
length=len(l)
x=0
while x < length:
    if l[x] == 6:
        l.remove(l[x])
        # del l[x]
        x -= 1
        length -= 1
    x += 1
print(l)
lst[-1][1][1][0]

del lst[0]  # 經過索引刪除
del lst[0:3] # 經過切片刪除
del lst[0:3:2] # 經過步長刪除

lst.clear()  #清空

1.4 改

lst = ["zz",123,True,"中國"]

lst[1] = "123" #經過索引改

lst[1:2] = "12345" #經過切片改
print(lst)
# ['zz', '1', '2', '3', '4', '5', True, '中國']

lst[1:4] = 12,13,14,15  
print(lst)
['zz', 12, 13, 14, 15]

lst[1:4:2] = "12"
print(lst)  # 步長不爲1的必須用一一對應,多一個也不行,少一個也不行
['zz', '1', True, '2']

1.5 查

for i in lst:
    print(i)

1.6 列表嵌套

取出88

l=[1,2,3,[3,5,[77,88]]]
print(l[-1][-1][1])
# 無論什麼類型進行切片的時候獲取都到都是源數據類型

第二章 元組

1. 定義

-- tuple
tu=(1,"12",[12,11])
有序,不可變,支持索引
元組用於存儲一些比較重要的信息
元組在配置文件中會使用元組就是不可變的列表

2. 讀取

#for 循環
for i in tu:
    print(i)

第三章 range

1. 定義

# range -- 範圍
print(list(range(0,10)))  # 顧頭不顧尾  
經常使用於與for循環

python3 中的range是一個可迭代對象 寫得是怎樣的打印的時候就是怎樣
獲取成列表:list(range(0,10)) 顧頭不顧尾
python2 中的range返回的是一個列表
xrange和python3中的range是類似的

2. 用法

print(list(range(0,10,1))) #步長不寫的時候默認爲1  [0:10:1]
print(list(range(10,0,-1))) # [10:0:-1]
print(list(range(10))) #1  [:10]

3. 例題

使用for循環和range 打印 100 ~ 1
for i in range(100,0,-1):
    print(i

輸入三次姓名退出
lst = []
flage = True
while flage:
    name = input("請輸姓名:")
    lst.append(name)
    if len(lst) == 3:
        flage = False

print(lst)
#------------------------------------------
lst = []
for i in range(3):
    lst.append(input("請輸入姓名:"))
print(lst)

4. 小題

lst = [1,2]
for i in lst:
    lst.append("alex")
    print(lst) # 循環打印lst中的內容 -- 此循環是死循環

lst = [1,2]
for i in lst:
    lst.append("alex")
print(lst)  # 死循環 -- 不會打印內容

lst = []
for i in range(5):
    lst.append([])
print(lst)  # [[],[],[],[],[]]

lst = [1,2]
lst[0] = lst
print(lst)  # [[...],2]

第四章 字典

1. 定義

字典 -- dist

字典:無序的,可變的數據類型

字典:用於存儲數據,存儲大量數據 字典要比列表快 將數據和數據之間進行關聯

dic = {1:"zbb",2:True,3:"追夢NAN",4:"人生苦短",5:"我用python"}

字典的鍵(key):

​ 可哈希的(不可變得數據類型) -- 避免哈希衝突使用了 開放尋址法

​ 要求惟一 -- 若是有重複的後邊值的將前面的值覆蓋

字典的值(value):

​ 能夠任意

2. 增長

dic["zz"] = 89  # 暴力添加

dic.setdefault("www",100) #去字典查詢key,若是不存在執行添加,若是存在就不添加了

3. 刪除

del dic["www"]    # 經過字典的鍵刪除鍵值對

dic.pop("zz")  #經過字典的鍵進行刪除鍵值對  返回值:返回的是被刪除的值

dic.clear()   #清空

4. 改

dic["aaa"] = "djj" #有則改,無則加

dic.update(dic1)  #  update括號中的字典級別高於update前面的字典

5.查

for i in dic1:   # 循環獲取的是字典中每一個鍵值對的鍵
    print(i)

print(dic.get("cx"))  # 經過鍵獲取值,若是將不存在字典中返回None

print(dic["cx"])      # 經過鍵獲取值,若是將不存在字典中報錯

6.其餘操做

print(dic1.keys())  # 高仿列表 -- dict_keys(['1', '5', '2']) 支持for循環 不支持索引

for i in dic1.keys():       # 獲取字典中全部的鍵
    print(i)

print(list(dic1.values()))   # 獲取字典中全部的值

#獲取字典中全部的鍵和值 存放在一個高仿列表裏的元組(元組第一個元素:鍵,第二元素:值)
print(dic.items())
for i in dic.items():
    print(i[0],i[1])
    
#dict_items([(1, 'zbb'), (2, True), (3, '追夢NAN'), (4, '人生苦短'), (5, '我用python')])
# 1 zbb
# 2 True
# 3 追夢NAN
# 4 人生苦短

7.解構

a,b=10,12

print(a) #10
print(b) #12

a,b = [1,2]  #a=1,b=2
a,b = (3,4)  #a=3,b=4
a,_,b = (3,4,5)
print(a,b)   # 等號後邊的值和前面的變量名要一一對應 3,5

a = 10,12 #本質就是一個元組

a,b = "23"
print(a,b)  # 2 3

a,b = {"1":"a","2":"b"}
print(a,b)  #1, 2 顯示的是key

for i in dic.items():
    print(i)  #每一個字邊變成了元組
#(123, '123')
#(1, '122')

for k,v in dic.items():
    print(k,v)    # 獲取每一個元素的鍵和值

8.嵌套

dic = {1001:["倫","傑"],
       1002:{"峯":{"妻":["餅"],"前":["熊大","熊二"],"章":"肉絲"}},
       1003:{"陳":["嬌","薩","芝"]}}
print(dic[1002]["峯"]["妻"][0])

第五章 小數據池

緩存機制(駐留機制)

節省資源

== 判斷兩邊內容是否相等

is判斷基於內存地址進行判斷

a = 0
b = 0
print(a==b)
print(a is b)
print(id(a))
print(id(b))

1.代碼塊

可以提升一些字符串，整數處理人物在時間和空間上的性能；須要值相同的字符串，整數的時候，直接從‘字典’中取出複用，避免頻繁的建立和銷燬，提高效率，節約內存。

一個文件,一個函數,一個類,一個模塊,終端中每個行是一個代碼塊

知足代碼塊緩存機制

適用對象: int (float) ,str , bool

數字:
在同一代碼塊下 只要內容相同就採用相同的內存地址(-5之後就不是)
數字在作乘法的時候範圍 -5 ~ 256 ****
數字在作乘法的時候不能使用浮點數
字符串:
在同一代碼塊下 只要內容相同就採用相同的內存地址
乘法的時候總長度不能超過python3.7 4096 ****
乘法的時候中文,特殊符號乘以1或0
布爾值:
在同一代碼塊下 只要內容相同就採用相同的內存地址

2.小數據池

可以提升一些字符串，整數處理人物在時間和空間上的性能；須要值相同的字符串，整數的時候，直接從‘池’裏拿來用，避免頻繁的建立和銷燬，提高效率，節約內存

數字: -5 ~ 256 ****
字符串:
在同一代碼塊下 只要內容相同就採用相同的內存地址
乘法的時候總長度不能超過3.7 4096 ****
乘法的時候中文,特殊符號乘以0
布爾值:
在同一代碼塊下 只要內容相同就採用相同的內存地址
小數據池的驗證方法,必須脫離代碼塊才能進行驗證
先執行代碼塊的規則,在執行小數據的規則 --(駐留機制)

第六章 深淺拷貝

1.淺拷貝

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

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()  # 新開闢一個空間給lst1
lst[-1].append(7)

print(lst1)
print(lst)
# 淺拷貝的時候,只會開闢一個新的容器列表,其餘元素使用的都是源列表中的元素

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

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

dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"][0] = "56"
print(dic)
print(dic1)
#####直接就是第二層

2.深拷貝

用法

import copy  #導入
空間裏的值是不可變的數據進行共用的,可變的數據類型再次開闢空間
lst = [1,2,3,[5,6,7]]
lst1 = copy.deepcopy(lst)  # 深拷貝
lst[-1][-2]=1
print(lst)
print(lst1)

怎麼改都不變

第七章 集合

集合 --set

至關於沒有值得字典 無序 --不支持索引

-- set() 空集合

做用:

​ 自然去重

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

定義:

s = {1,2,3,4,5}

1. 增

s.add("67")  #只能添加一個
s.update("今天")  # 迭代添加

2. 刪除

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

3. 查

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

4. 其餘操做

# 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))  # 凍結集合 更不經常使用
# dic = {frozenset(s1):1}
# print(dic)