day4-python基礎-數據類型

今日份小技巧

a =3

b=4,

最快將a和b值替換的方法爲

a,b =b,a

今日內容

1. 字典

2. 集合

3.hash

4.基本數據類型總結

5.循環之for循環

6.range的使用

7.深淺copy

 

開始第四天的預習，

 

1.數據類型之字典

　　1.1 字典的定義以及特性

　　定義：字典是一種（key-value）型數據類型，python對key進行哈希運算，決定value的位置，因此字典是無序的，key必須可哈希而且不可變

　　特性：能夠存聽任意個值，能夠修改，能夠不惟一，查找速度快。列表是一個有序對象集合，字典是一個無序的對象集合，列表是經過偏移來查找數據，字典是經過鍵值來查找數據

　　####字典在python3.5以及3.5版本中是無序的，3.6優化了機制，字典會按照字典建立之初排序####

　　1.2 字典的經常使用方法-增　

方法一：傳統方法
dic = {'1':'abc','2':'cde'}
dic['key']= [1,2,3,4,5]
print(dic)
#結果，字典是無序的，只是這個顯示是這樣
{'1': 'abc', '2': 'cde', 'key': [1, 2, 3, 4, 5]}

方法二：setdefault
#方法就是給字典中添加鍵值對，若是隻有鍵，則值爲none，若是值在之前存在，則不對值作修改
dic = {'1':'abc','2':'cde'}

dic.setdefault('k')
print(dic)
dic.setdefault('k1','v')
print(dic)
dic.setdefault('k1','v1')
print(dic)
print(dic.setdefault('k1','v1'))

#結果。能夠看出setdefault返回值爲value
{'1': 'abc', '2': 'cde', 'k': None}
{'1': 'abc', '2': 'cde', 'k': None, 'k1': 'v'}
{'1': 'abc', '2': 'cde', 'k': None, 'k1': 'v'}
v

　　1.3 字典的經常使用方法-刪

#第一種，刪除返回值,有key返回對應的值，無key返回默認值，默認值須要設定
dic = {'1':'abc','2':'cde'}

print(dic.pop('1'))
print(dic)
#結果
abc
{'2': 'cde'}

#第二種，刪除不返回值
dic = {'1':'abc','2':'cde'}
del dic['2']
#結果
{'1': 'abc'}

#第三種，隨機刪除，在python3.6以及之後的版本中，都是刪除的最後一個
dic = {'1':'abc','2':'cde'}
print(dic.popitem())

print(dic)
#結果
('2', 'cde')
{'1': 'abc'}
#第四種，清空字典
dic = {'1':'abc','2':'cde'}
dic.clear()

print(dic)
#結果
{}
#第五種，使用通用辦法del，對字典內容進行刪除

　　1.4 字典的經常使用方法-改

#方法一：基本方法
dic = {'1':'abc','2':'cde'}
dic['1']= 'abbbbb'

#方法二：字典更新，倆個列表更新，若是有不一樣的key，則賦值，若是有相同的key，值覆蓋對應的值
dic = {'1':'abc','2':'cde'}
dic2 = {'3':'44444','2':'abbb'}
dic.update(dic2)
print(dic)

#結果
{'1': 'abc', '2': 'abbb', '3': '44444'}

#方法三：字典的更新，不過也是用的updata來作
dic = {'1':'abc','2':'cde'}
dic.updata(weight ='80KG')#謹記，採用這種辦法，括號內左邊的值至關於變量名，後面爲爲變量賦值，函數會將倆個值轉變爲一個鍵值對給字典賦值，前面變量名不可爲數字

　　1.5 字典的經常使用方法-查

#方法一，直接查找，如有返回對應的鍵值，若是沒有對應的鍵，則報錯
dic = {'1':'abc','2':'cde'}
print(dic['1'])
print(dic['3'])
#結果
Traceback (most recent call last):
abc
  File "D:/pycharm/全棧三期/day3/test.py", line 309, in <module>
    print(dic['3'])
KeyError: '3'

#方法二，查找，如有返回對應的鍵值，若是沒有則返回設定的默認值
dic = {'1':'abc','2':'cde'}
print(dic.get('1','無'))
print(dic.get('3','無'))
print(dic)
#結果
abc
無
{'1': 'abc', '2': 'cde'}

　　1.6 字典的經常使用方法-循環

dic = {'1':'abc','2':'cde'}
for i in dic:
    print(i)

for i in dic.items():
    print(i)

for k,v in dic.items():
    print(k,v)

#結果
1
2
('1', 'abc')
('2', 'cde')
1 abc
2 cde

　　1.7 字典的經常使用方法-其餘方法

# item = dic.items()
# print(item,type(item))  # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 這個類型就是dict_items類型，可迭代的

# keys = dic.keys()
# print(keys,type(keys))  # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>

# values = dic.values()
# print(values,type(values))  # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上

　　1.8字典的相關函數

#.fromkeys函數，快速生成大量數
dic = dict.fromkeys([1,2,3],['alex'])
print(dic)

dic [1].append('sb')
#坑#這個函數用法是前面一個可迭代對象，後面爲一個隨意值，不事後面的值爲可變對象，就會發現全部生成的字典對象都會變動

print(dic)

#結果
{1: ['alex'], 2: ['alex'], 3: ['alex']}
{1: ['alex', 'sb'], 2: ['alex', 'sb'], 3: ['alex', 'sb']}

2.數據類型之集合

　　2.1 集合的定義以及特性

　　定義：集合是一個無序的，不重複的數據組合，s ={1,2,3,4}則直接建立

　　特性：自動去重，將列表轉換爲集合則會自動去重，主要做用爲關係測試  l = [1,2,3,4]  s =set(l)則直接轉換爲集合

　　2.2 集合的增刪改查

　　s.add() #增長，一次只能增長一個

　　s.pop() #刪除，隨機刪除一個值

　　s.remove() #指定刪除一個值

　　s.discard() #丟棄，刪除一個值，不存在則不報錯，存在則刪除！

　　s.update() #把一個集合和另一個集合合併，update能夠一次性添加多個值

　　2.3 集合的關係運算

　　關係運算算是集合經典使用方法了，下面就來看一下集合的關係運算，舉個例子，有些人只買iphone7有些人只買iponeX

　　2.3.1 交集

iphone6sp ={'alex','jack','tom','tony','happy','sugimoto','mizutani'}
iphoneX ={'happy','yuki','sugimoto'}

#交集
print(iphone6sp.intersection(iphoneX))
print(iphone6sp&iphoneX)

#結果
{'sugimoto', 'happy'}
{'sugimoto', 'happy'}

　　2.3.2 差集

#差集,有前後順序，是前一個差後面
print(iphone6sp.difference(iphoneX))
print(iphone6sp-iphoneX)

#結果
{'mizutani', 'jack', 'tom', 'tony', 'alex'}
{'mizutani', 'jack', 'tom', 'tony', 'alex'}

　　2.3.3 並集

#並集
print(iphone6sp.union(iphoneX))
print(iphone6sp|iphoneX)

#結果
{'yuki', 'tony', 'mizutani', 'jack', 'sugimoto', 'tom', 'happy', 'alex'}
{'yuki', 'tony', 'mizutani', 'jack', 'sugimoto', 'tom', 'happy', 'alex'}

　　2.3.4 對稱差集

#對稱差集
print('只買蘋果6sp和蘋果X的人')
print(iphone6sp.symmetric_difference(iphoneX))
print(iphone6sp^iphoneX)

#結果
只買蘋果6sp和蘋果X的人
{'yuki', 'mizutani', 'jack', 'tom', 'tony', 'alex'}
{'yuki', 'mizutani', 'jack', 'tom', 'tony', 'alex'}

　　2.3.5 超集子集

#超集子集
s1 ={1,2,3,4,5,'jack'}
s2 = {1,2,3}
#判斷子集
print(s2.issubset(s1))
print(s1 > s2)         #都是判斷s2是否是s1的子集

#判斷超集
print(s2.issuperset(s1))
print(s1< s2)          #都是判斷s2是否是s1的超集



#結果
True
True
False
False

　　2.4 集合的其餘用法

　　.isdijoint(s2)#判斷倆個集合可交集

　　.difference_update() #把倆個集合的差集賦值給後者

　　.intersection_updata() #把倆個集合的交集賦值給後者

3.數據類型之hash

　　3.1 hash的定義以及特性

　　hash通常稱之爲「散列」，將任意長度的消息壓縮到某一固定長度的消息摘要

　　3.2 hash的用法

　　hash值固定，不可更改,只有不可變類型才能被hash

　　3.3 hash的使用環境

　　通常用途爲文件簽名，md5加密，密碼驗證

　　用法就是.hash()

4.數據類型的總結

　　4.1 按照存儲空間來分，從小到大　　

數字
字符串
集合：無序，即無序存索引相關信息
元組：有序，須要存索引相關信息，不可變
列表：有序，須要存索引相關信息，可變，須要處理數據的增刪改
字典：無序，須要存key與value映射的相關信息，可變，須要處理數據的增刪改

　　4.2 按照存值個數區分

標量／原子類型	數字，字符串
容器類型	列表，元組，字典

 

 

 

　　4.3 按照可變不可變區分（hash）

可變	列表，字典
不可變	數字，字符串，元組，布爾值

 

 

 

　　4.4 按照訪問順序區分

直接訪問	數字
順序訪問（序列類型）	字符串，列表，元組
key值訪問（映射類型）	字典

  

 

 

 

　　4.5 數據類型之間的轉換

　　現有的數據類型有

　　int（整型）

　　str（字符串）

　　bool  布爾值）

　　list（列表）

　　dict（字典）

　　tuple（元祖）

　　set（集合）

　　主要的數據類型轉換

　　int <------>str (要轉換就在前面加類型)，str(),int() 

　　int <------>bool,非零爲真，零爲假;布爾值轉爲數字，真爲1，假爲0

　　str  ------>bool,非空爲真，空爲假;,bool值轉爲字符串無心義

　　str <------>list  str轉list用splite,list轉str用join  ****

　　空列表，空字典，空元祖，空集合，對應的都是bool值得假

　　list <------>set (要轉換就在前面加類型),list轉換爲set自動去重

　　list <------>tuple(要轉換就在前面加類型)

　　dict ------->list 打印字典的key值

　　dict ------->tuple 打印字典的key值

　　4.6 數據類型的補充

# 元組中只有一個元素而且沒有逗號，則他不是元組與元素數據類型相同。
# tu1 = (1)
# tu2 = ('alex')
# tu3 = ([1,2,3])
# print(tu1, tu2, tu3)
#結果
1 alex [1, 2, 3]
#不過加了逗號就都變成集合了
(1,) ('alex',) ([1, 2, 3],)

 　　4.7 列表與字典的一些特殊處理方法

　　題目一：# li = [11, 22, 33, 'alex', 55]  將列表中索引爲奇數位的元素刪除。

　　錯誤解法：

li = [11, 22, 33, 'alex', 55]
for i in range(len(li)):
    if i %2 ==1:
        li.pop(i)
print(li)

#錯誤結果
[11, 33, 'alex']
#結果發現並無咱們預期的55

　　正確解法

del li[1::2]
print(li)
#或者是倒序取值，倒着切
#結果
[11, 33, 55]

　　題目二：dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}，將字典中鍵含有k元素的鍵值對刪除

　　錯誤解法

dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}
for key in dic:
    if 'k' in key:
        dic.pop(key)
#結果
RuntimeError: dictionary changed size during iteration
翻譯過來就是說字典的長度在迭代中修改了

　　正確解法

dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}
l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
for k1 in l1:
    dic.pop(k1)
print(dic)
#結果
{'name': '太白'}

　　總結：在循環一個列表時，最好不要改變列表的大小，這樣會影響你的最終結果。在循環一個字典時，不能更改字典的大小，不然會報錯！

5.循環之for循環

　　5.1 for循環也是在python中常常用到的內容，用戶按照順序循環迭代可迭代對象

　　      字符串，列表，元祖，字典均可以迭代

　　5.2 與for循環相關的就是enumerate,就是枚舉 

　　　   對於於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它能夠同時得到索引和值。

list = [1,2,3,4,5,6]
for i in enumerate(list):
    print(i)

for i ,j in enumerate(list):
    print(i,j)

#結果
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
0 1
1 2
2 3
3 4
4 5
5 6

6.range的使用

指定範圍生成指定數字以及內容，可迭代對象

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步長
    print(i)

for i in range(10,1,-2): # 反向步長
    print(i)

7.查漏補缺之深淺copy

深淺copy放在單獨的一個去書寫