1.創建一個字典{ },增強可判斷性,處理數據

list3 = [{"name": "alex", "hobby": "抽煙"},
         {"name": "alex", "hobby": "喝酒"},
         {"name": "alex", "hobby": "燙頭"},
         {"name": "alex", "hobby": "Massage"},
         {"name": "wusir", "hobby": "喊麥"},
         {"name": "wusir", "hobby": "街舞"}, ]
list4 = []
dic = {}
for i in list3:
    if i[‘name‘] not in dic:
        dic[i[‘name‘]] = {‘name‘:i[‘name‘],‘hobby_list‘:[i[‘hobby‘]]}
    else:
        dic[i[‘name‘]][‘hobby_list‘].append([i[‘hobby‘]])
list4 = list(dic.values())
print(list4)

　　字典的增:

　　　　dic = {}

　　　　dic[‘name] = ‘alex‘ (直接增加了一個鍵值對)

分別賦值:

　　1.對於元組,列表可以分別賦值

list1 = [1,2,3]
a,b,c = list1
print(a,b,c)#1 2 3
list2 = [(1,2),(‘a‘,‘b‘)]
e,f = list2
print(e,f) #(1, 2) (‘a‘, ‘b‘)
h,i = e
print(h,i) #print(h,i)

　　2.字典dict.items()

　　　　　dict.keys()

　　　　　dict.values() 可以分別賦值

dic = {‘name‘:‘alex‘,‘hobby‘:‘girl‘}
a,b = dic.keys()
list2 = list(dic.keys())
print(a,b) #name hobby 
print(list2) #[‘name‘, ‘hobby‘]
c,d = dic.values()
print(c,d) #alex girl
e,f = dic.items()
list1 = list(dic.items())
print(e,f) #(‘name‘, ‘alex‘) (‘hobby‘, ‘girl‘)
print(list1) #[(‘name‘, ‘alex‘), (‘hobby‘, ‘girl‘)]

　　文件操作:

　　　　w 模式下的write: 只能寫入字符串類型

　　　　　　 writelines,可以將列表內的內容,以字符串的形式輸出 (類表裏只能有字符串)

with open(r‘a.txt‘,mode=‘w‘,encoding=‘utf-8‘) as f:
    f.write(‘alex‘)
    f.writelines([‘1‘,‘2‘])

函數初識:

def func(): -------->函數名要有可識別性

　　pass

　　return -------->函數的返回值

func() -------------->函數的調用(執行)

　　函數的作用:

　　　　封裝一個功能

　　函數的優點:

　　　　減少代碼的重復率

　　　　增強代碼的可讀性

------在函數體中遇到return:

　　　　1.直接結束

　　　　2.調用函數時有返回值:(3種情況)

　　　　　　a. return後面為空----->返回None

def func():
    a = 1
    b = [1,2]
    return
func()
print(func()) #None

　　　　　　b.return後面跟1個值----->return後面跟的a是什麽類型,就是什麽類型

def func():
    a = 1
    b = [1,2]
    return a
func()
print(func()) #1

　　　　　　c.return 後面跟多個值----->返回一個元組

def func():
    a = 1
    b = [1,2]
    return a,b
func()
print(func()) #(1, [1, 2])
#函數中盡可能不要哦出現print()
#print(func) 打印的是id地址

形參與實參:

def func(): ------->形參

　　pass

　　return

func() -------------->實參

　　實參:

　　　　1.位置實參,需要一一對應

　　　　2.關鍵字實參,可以不按順序,但需要一一對應

　　　　3.混合實參,位置實參必須在前面

def func1(x,y):
    return x + y
name = 1 
func1(name,y=100,) #name 是位置實參 
print(func1(name,y=100,))

　　形參:

　　　　1.位置行參,必須一一對應

def func1(x,y,z):
    print(x,y,z)
func1(1,2,3)

　　　　2,默認行參,一般不變,在實參時可以重新賦值

def func1(x,y,a=666): # a=666是默認參數 一般是不可變數據類型
    print(x,y,a)
func1(1,2) # 不傳值,不報錯
func1(1,2,333) # 333可以覆蓋666

　　　　*****默認形參的數據一般是不可變類型,在是可變數據類型的情況下(如[ ],是列表的時候)id恒定

#必考的面試題:
def func1(x,l1=[]): #默認參數如果是可變的數據類型,此數據的id恒定
    l1.append(x)
    return l1
ret = func1(1)
print(ret,id(ret))
ret1 = func1(100)
print(ret1,id(ret1))

　　　　3.動態形參:*args 和 **kwargs 使函數變得可拓展

　　　　　　args 與( *args,**kwargs)

　　　　　　前者表示1位置參數

　　　　　　後者*和**表示聚合,args和kwargs,是約定俗成

　　　　　　　　*args 將實參裏的位置參數聚合到一個元組中,並將這個元組賦值給args(即args是一個元組)

　　　　　　　　**kwargs 將實參裏的關鍵字參數聚合到一個字典中,並將這個字典賦值給kwargs(即kwargs是一個字典)

萬能加法計算器:

def sum1(*args,**kwargs):
    sum2 = sum(args)
    return sum2
print(sum1(1,2,3,4,55,))

　　* 和 ** 的魔性用法:

　　　　1.在定義函數時,* 和 **起到聚合的作用

　　　　2.在調用函數時,* 和 **起到的作用. --->在實參中*和**可以將後面可叠代對象打散,然後匯集成一個元組,或一個字典

l1 = [1,2,3,4]
l2 = [5,6,7,8,9]
def func1(*args,**kwargs):
    print(args)
func1(*l1,*l2)
#(1, 2, 3, 4, 5, 6, 7, 8, 9)

l1 = {‘a‘:1,‘b‘:3}
l2 = {‘c‘:2,‘d‘:4}
def func1(*args,**kwargs):
    print(kwargs)
func1(**l1,**l2) 
#{‘a‘: 1, ‘b‘: 3, ‘c‘: 2, ‘d‘: 4}

位置參數,默認參數,動態位置參數(*args),動態默認參數(**kwargs)　在形參中的放置順序　

def func(a,b,*args,‘age‘=18,**kwargs):
　　　　pass

開始於結束:
    range(10) 從0開始顧頭不顧尾 0-->9
    index() 從0開始
    len() 從1開始
    enumerate() 從0開始,主要用於列表 (可叠代對象)

python學習第九天,構建字典處理數據, 分別賦值,輸入中文逗號.....函數初識