import os
name='alex'
def foo():
name='lihaig'
def bar():
print(name)
return bar
foo()
匿名函數
lambda x:x+1
def calc(x)
return x+1
res=calc(10)
print(res)
匿名函數不能使用較爲複雜的邏輯
匿名函數返回值需要作爲整體的返回
十：函數式編程
11高階函數
滿足兩個特性任意一個即爲高階函數
1.函數的接收參數是一個函數名
2.函數的返回值是一個函數名
編程的方法論
面向過程
面向函數式
面向對象
1.搜索目標
2.表白，表白成功進入3，否則2
3.戀愛，戀愛成功進入，4，否則1
4.見家長，家長同意進入5，否則1
函數式編程
函數式：編程語言定義的函數+數學意義的函數
函數即變量
#把函數的返回值傳遞給另外一個函數
def foo(n):
print(n)
def bar(name):
print('jajg',name)
#foo(bar)
foo(bar(1))
僞遞歸調用優化，在函數的最後一部調用
map 函數
num_1=[1,2,3,4,5,6,7,8,77]
# def map_test():
# ret=[]
# for i in num_1:
# ret.append(1**2)
# return ret
# ret=map_test(num_1)
# rett=map_test(num_1)
# print(num_1)
# print(rett)
#lambda x:x-1
def reduce_one(x):
return x-1
def map_test(func,args):
ret=[]
for i in args:
res=func(i)
#ret.append(i+1)
ret.append(res)
return ret
print(map_test(reduce_one,num_1))
print(map_test(lambda x:x-1,num_1))
print('內置函數map,處理結果',map(lambda x:x-1,num_1))
a=map(lambda x:x-1,num_1)
print(list(a))
msg='lajgagag'
print(list(map(lambda x:x.upper(),msg)))
filter 函數
#filter 函數
#filter()
movie_people = ['sjg_sb', 'aghadg', 'sb_ag', 'sb_ag']
#filter(lambda n:n.endswith('sb'),movie_people)
ls=filter(lambda n:n.endswith('sb'),movie_people)
print(list(ls))
#第一個是函數，第二個是一個可以迭代的對象
#reduce函數
import os
# movie_people = ['sjg', 'aghadg', 'sb_ag', 'sb_ag']
# def sb_show(n):
# return n.endswith('sb')
# def filter_test(arrg):
# ret = []
# for a in movie_people:
# if not a.startwith('sb_'):
# ret.append(a)
# print(ret)
# return ret
# res=filter_test(movie_people)
# #filter 函數
#movie_people = ['sjg', 'aghadg', 'sb_ag', 'sb_ag']
# def filter_tesq(func,args):
# fet=[]
# for p in args:
# if not func(p):
# fet.append(p)
# return fet
# res=filter_tesq(lambda n:n.endswith('sb'),movie_people)
# print(res)
#filter 函數
#filter()
movie_people = ['sjg_sb', 'aghadg', 'sb_ag', 'sb_ag']
#filter(lambda n:n.endswith('sb'),movie_people)
ls=filter(lambda n:n.endswith('sb'),movie_people)
print(list(ls))
from functools import reduce
--------------------reduce 函數--------------
# num_l=[1,3,4,5,4,64,6]
# res=0
# for num in num_l:
# res+=num
#
# print(res)
#
# num_l=[1,3,5]
#
# def multi(x,y):
# return x*y
# def reduce_test(func,array):
# res=num_l[0]
# for num in array:
# res=func(res,num)
# return res
# print(reduce_test(multi,num_l))
# def reduce_test(func,arry,init=None):
# if init is None:
# res = arry.pop(0)
# else:
# res = init
# for num in arry:
# res=func(res,num)
# return res
# print(reduce_test(lambda x,y:x*y,num_l,))
#reduce 函數 數據合併
#filter 函數 對裏面的值進行篩選
#map 函數 依次處理每個值
num_l1=[1,3,5]
print(reduce(lambda x,y:x*y,num_l1,5))
===================map函數==============
num_1=[1,2,3,4,5,6,7,8,77]
# def map_test():
# ret=[]
# for i in num_1:
# ret.append(1**2)
# return ret
# ret=map_test(num_1)
# rett=map_test(num_1)
# print(num_1)
# print(rett)
#lambda x:x-1
def reduce_one(x):
return x-1
def map_test(func,args):
ret=[]
for i in args:
res=func(i)
#ret.append(i+1)
ret.append(res)
return ret
print(map_test(reduce_one,num_1))
print(map_test(lambda x:x-1,num_1))
print('內置函數map,處理結果',map(lambda x:x-1,num_1))
a=map(lambda x:x-1,num_1)
print(list(a))
msg='lajgagag'
print(list(map(lambda x:x.upper(),msg)))
----------------------內置函數-----------------------
#第一個是函數，第二個是一個可以迭代的對象
#絕對值
# print(abs(-1))
#all全部,進行布爾運算，只要有一個爲假，就是假
# print(all([1,2,3,'dhgag']))
# print(all([1,2,3,'dhgag','']))
#any只要有一個爲真就是真的
# print(any('1'))
#空，None,0 的布爾值爲False，其餘都是True
# print(bool(''))
# print(bool(None))
# print(bool(0))
#bytes
# name='歐陽'
# print(bytes(name,encoding='utf-8'))
# print(bytes(name,encoding='utf-8').decode('utf-8'))#python3 默認的解碼格式爲 utf-8
#print(bytes(name,encoding='ascii'))#ascii 不嫩編碼中文
#chr ascii 表的轉換
# print(chr(97))
# #dir() 打印某一個對象下面有哪些方法
# print(dir(dict))
#eval函數
#取字典裏面的字符串的結構截取下來
#hash 可以hash 的數據類型是不可變類型，不可hash 類型就是可變類型
# print(hash('hgahg'))
# #help 打印解釋
# print(help(dir(all)))
#進制轉換
# print(bin(10))#10進制 2進制
# print(hex(12))#10進制- 16進制
# print(oct(12))#10進制換 8進制
# #判斷類型，並且進行布爾運算
# print(isinstance(1,int))
# print(isinstance([],list))
# print(isinstance({},dict))
# print(isinstance({1,2},set))
======================format字符串處理=============================
#常用的格式
#1
#rt='i am {}, age {},{}'.format('sle',18,'睡覺') 自動的添加
#rt='i am {2}, age {1},{}'.format('sle',18,'睡覺') 按照自定義的順序進行排序
# rt='i am {name}, age {age},stu {sj}'.format(**{'name':'hahg','age':'hahg','sj':'hahg'}) #字典的數據類型，必須要加上一個**
# print(rt)
# rt1='number:{:b},{:c}.{:d}'.format(15,20,25)#b是二進制
# print(rt1)
# def test(a,*args):
# print(a)
# print(args)
# print(args[0][2])
# test(1,[1,23,43,53])
#test(1,{1,2,4,6})
# def tesq(a,*args,**kwargs):#字典類型
# print(a)
# print(args)
# print(kwargs)
#
# tesq(1,t=2,y=4)
# #位置參數必須一一對應
# #一個參數不能傳遞2遍值，會報錯
# #*args,**kwargs
# #順序只能這樣
# tesq(1,*[1,2,3],**{'y':2,})
=====================字符串格式輸出==============================
#把字符串進行拼接輸出
a='oulen'
b='hh'
print('i am %s my hobby is %s'%(a,b))
c='ja'
msg='i am %s my hobby is %d'%('ks',1)
print(msg)
#打印浮點數
tpu1='percent %.2f %%' %99.55457 #加上%
tpu='percent %.2f' %99.55457#進行
print(tpu1)
tpu2='i am %(name)-60s my hobby is alex' %{'name':'lej'}#鍵值對添加
print(tpu2)
#%s 字符串等任意類型 %d 是int 類型
=========================字典=======================
dic={
'植物':
{"草本植物":
['牽牛花','刮花距','葫蘆'],
'水生植物':
['喬木','杉']
},
'動物':
{'兩棲動物':
['山鬼']
}
}
# li = []
# go = True
#
# for v in enumerate(dic,1):
# print(v)
# #li.append(v)
# print(li)
# while go:
# for i,v in enumerate(dir,1):
# print(i,v)
# li.append()
# v_c=str(input('>>>'))
# if v_c.isdigit():
# pass
# elif v_c.isalpha():
# v_c=v_c.lower()
# if v_c==i:
# lx=input('類型：')
# if dic.get(lx,1)==1:
# dic[lx]={}
#
# zl= input('種類:')
# if dic.get(lx[zl],1)==1:
# dic[lx][zl]=[]
# mc=input('名稱：')
db={
'北京':
{
'昌平':
{
'沙河':{},
'回龍觀':{},
},
'西郊':{},
'朝陽':{}
},
'上海':
{
}
}
# q=input(">>>")
# db[q]={}
# print(db)
path=[]
while True:
temp = db
for item in path:
temp=temp[item]
print("當前可選的所有節點",list(temp.keys()))
choice=input('1.添加節點；2.查看節點（Q/B）；\n>>>')
if choice == '1':
name=input("輸入要添加的節點名稱")
temp[name]={}
elif choice == '2':
name=input("輸入你想要查看的節點名稱：")
path.append(name)
elif choice.lower() == 'b':
path.pop()
elif choice.lower() == 'q':
break
else:
print("輸入錯誤，重新輸入")
# while True:
# chose=input('1.添加節點；2.查看節點（Q/B）；\n>>>')
# if chose=='1':
# pass
# elif chose==2:
# pass
# elif chose.lower()==b:
# pass
# elif
#
# print('全部的節點',db.keys())
========================匿名函數=====================
import os
# lambda x:x+1
# def calc(x):
# return x+1
#
# res=calc(10)
# print(res)
# print(calc)
# print(lambda x:x+1)
# func=lambda x:x+1
# print(func(10))
#
# name='jjfj'
# def chang_name(x):
# return name+'_sb'
# re=chang_name(name)
# print(re)
# f=lambda x:name+'_sb'
# f(name)
#
#把函數的返回值傳遞給另外一個函數
# def foo(n):
# print(n)
# def bar(name):
# print('jajg',name)
# #foo(bar)
# foo(bar(1))
#返回值包含函數
def bar():
print('from bar')
def foo():
print('from foo')
return bar
n=foo()
n()
#返回值可以是任意函數
num_1=[1,2,3,4,5,6,6]
ret=[]
for i in num_1:
ret.append(i**2)
print(ret)
=====================小結============================
from functools import reduce
#處理序列中的每個元素，得到的結果是一個列表，該列表是元素個數和位置與原來一樣
#map()
#filter 遍歷序列中每個元素，判斷每個元素得到的布爾值，如果是True則保留下來
people=[
{'name':'alex','age':1000},
{'name':'wupeiuae','age':10000},
{'name':'yuanhao','age':100000},
{'name':'lianghaife','age':18},
]
print(list(filter(lambda p:p['age']<=18,people))) #filter()函數是留下需要保留的結果
#reduce 處理一個序列，然後把序列進行合併操作
#計算1到100的值
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))
===========================列表=================
import os
li = [1,2,3,'jghg',[23,34,'gf'],'nin']
li[1:3] = [45,54]
print(li)
#########索引刪除
li = [1,2,3,'jghg',[23,34,'gf'],'nin']
v = 1 in li
#del li[3:4]
print(v)
a = li[4][0]
print(a)
li = [1,2,3,'jghg',[23,34,'gf'],'nin']
s =''
for i in li:
s=s+str(i)
print(s)
#直接使用字符串，可以使用join進行轉換
#########切片刪除
li.count('5')
li.clear()
c=li.count('l')#計算可以元素出現次數
print(c)
li.append([98,985])#整體的添加
li.extend([98,585])#擴展原來的列表
li.pop()#默認刪除最後一個
li.remove('22')#刪除列表中的值
li.reverse()#將當前列表進行反轉
li.sort()#進行排序，默認從小到大
tu = (111,'alex',(11,22),[(33,44)],True,33,44,)
tu[3][0]=11
print(tu)
ac=tu.count('alex')
ac1=tu.index('alex')
print(ac,ac1)
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
# v = info['k1']
# print(v)
# v = info[2]
# print(v)
v = info['k3'][5]['kk3'][0]
print(v)
day12列表
Python主要有三種數據類型：字典、列表、元組。其分別由花括號，中括號，小括號表示。
如：
字典：dic = {'a': 12, 'b': 34}
列表：list = [1, 2, 3, 4]
元組：tup = (1, 2, 3, 4)
v = "李傑"
for item in v:
print(item)
###################################################################################################
str
name = "alex"
list # 類，列表
li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True] # 通過list類創建的對象，li
list
類
list類的一個對象
######################################灰魔法: list類中提供的方法 #######################################
li = [11, 22, 33, 22, 44]
參數
1.
原來值最後追加
對象.方法(..) # li對象調用append方法
li.append(5)
li.append("alex")
li.append([1234, 2323])
print(li)
2
清空列表
li.clear()
print(li)
3
拷貝，淺拷貝
v = li.copy()
print(v)
4.
計算元素出現的次數
v = li.count(22)
print(v)
5.
擴展原列表，參數：可迭代對象
li = [11, 22, 33, 22, 44]
li.append([9898, "不得了"])
[11, 22, 33, 22, 44, [9898, '不得了']]
li.extend([9898, "不得了"])
for i in [9898, "不得了"]:
li.append(i)
[11, 22, 33, 22, 44, 9898, '不得了']
li.extend("不得了")
print(li)
6.
根據值獲取當前值索引位置（左邊優先）
li = [11, 22, 33, 22, 44]
v = li.index(22)
print(v)
7.
在指定索引位置插入元素
li = [11, 22, 33, 22, 44]
li.insert(0, 99)
print(li)
8、 刪除某個值(1.
指定索引；2.
默認最後一個)，並獲取刪除的值
li = [11, 22, 33, 22, 44]
v = li.pop()
print(li)
print(v)
li = [11, 22, 33, 22, 44]
v = li.pop(1)
print(li)
print(v)
9.
刪除列表中的指定值，左邊優先
li = [11, 22, 33, 22, 44]
li.remove(22)
print(li)
PS: pop
remove
del li[0]
del li[7:9]
clear
10
將當前列表進行翻轉
li = [11, 22, 33, 22, 44]
li.reverse()
print(li)
11
列表的排序
li = [11, 44, 22, 33, 22]
li.sort()
li.sort(reverse=True)
print(li)
## 欠
cmp
key
sorted
# 元組，元素不可以修改，不能被增加或者刪除
# 元組的一級元素不可以修改，刪除，增加
# tuple
tu = (111, 'alex', (11, 22), [(33, 44)], True, 33, 44,) # 元組最後面加上一個逗號
v = tu[0]
v1 = [0:2]
元組可以進行for
循環
for item in tu:
print(item)
列表的extend方法
元組是有序的
####################################### 深灰魔法 #######################################
1.
列表格式
2.
列表中可以嵌套任何類型
中括號括起來
，分割每個元素
列表中的元素可以是
數字，字符串, 列表，布爾值..所有的都能放進去
“集合”，內部放置任何東西
3.
索引取值
print(li[3])
4
切片，切片結果也是列表
print(li[3:-1])
5
for循環
while循環
for item in li:
print(item)
列表元素，可以被修改
li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True]
6
索引
修改
li[1] = 120
print(li)
li[1] = [11, 22, 33, 44]
print(li)
刪除, 第一種方式
del li[1]
print(li)
############# 7 切片
修改
li[1:3] = [120, 90]
print(li)
刪除
del li[2:6]
print(li)
8 in 操作
li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True]
v1 = "石振文" in li
print(v1)
v2 = "age" in li
print(v2)
列表中的元素，
9
操作
li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True]
li[4][1][0]
[1]
li = [1, 12, 9, "age", ["石振文", ["19", 10], "龐麥郎"], "alex", True]
s = "pouaskdfauspdfiajsdkfj"
s = 123
a = "123"
int(a)
a = 123
str(a)
10
轉換
字符串轉換列表
li = list("asdfasdfasdf"), 內部使用for循環
s = "pouaskdfauspdfiajsdkfj"
new_li = list(s)
print(new_li)
列表轉換成字符串，
需要自己寫for循環一個一個處理： 既有數字又有字符串
li = [11, 22, 33, "123", "alex"]
# r = str(li) # '[11,22,33,"123","alex"]'
# print(r)
s = ""
for i in li:
s = s + str(i)
print(s)
直接使用字符串join方法：列表中的元素只有字符串
li = ["123", "alex"]
v = "".join(li)
print(v)
補充：字符串創建後，不可修改
v = "alex"
v = v.replace('l', 'el')
print(v)
li = [11, 22, 33, 44]
li[0]
li[0] = 999
s = "alex"
li[0]
s[0] = "E"
li = [11, 22, 33, 44]
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
列表，有序；元素可以被修改
列表
list
li = [111, 22, 33, 44]
####################################################################################################
元組
元組，元素不可被修改，不能被增加或者刪除
tuple
tu = (11, 22, 33, 44)
tu.count(22), 獲取指定元素在元組中出現的次數
tu.index(22)
####################################### 深灰魔法 #######################################
1.
書寫格式
tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
一般寫元組的時候，推薦在最後加入,
元素不可被修改，不能被增加或者刪除
2.
索引
v = tu[0]
print(v)
3.
切片
v = tu[0:2]
print(v)
4.
可以被for循環，可迭代對象
for item in tu:
print(item)
5.
轉換
s = "asdfasdf0"
li = ["asdf", "asdfasdf"]
tu = ("asdf", "asdf")
v = tuple(s)
print(v)
v = tuple(li)
print(v)
v = list(tu)
print(v)
v = "_".join(tu)
print(v)
li = ["asdf", "asdfasdf"]
li.extend((11, 22, 33,))
print(li)
6.
元組的一級元素不可修改 / 刪除 / 增加
tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
元組，有序。
v = tu[3][0][0]
print(v)
v = tu[3]
print(v)
tu[3][0] = 567
print(tu)
####################################################################################################
字典
1.
字典的形式
info = {
'k1': 'v1'
'k2':'v2'
}
2.
布爾值，列表，字典不能作爲key
3.
字典無序的
4.
value
可以是任何值，
5.
索引方式找到指定元素
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11, 22),
}
],
"k4": (11, 22, 33, 44)
}
v = info['k1']
print(v)
v = info[2]
print(v)
v = info['k3'][5]['kk3'][0]
print(v)
dic = {
'l1': '1',
'l2': '2',
'k3': 'k3',
'k4': "4",
}
1.
根據序列，創建字典，並且根據對應的創建key
v = dict.formkeys(['k1', 'j3', 'yh'], 123)
print(v)
2.
獲取key的值
v = dir['j3']
print(v)
v = dic.get('l1', 222)
3.
指定key
刪除列表中的指定值
dic = {
'l1': '1',
'l2': '2',
'k3': 'k3',
'k4': "4",
}
v = dic.pop('k3', 90)
print(v)
k, v = dic.popitem()
print(dir, k, v)
4.
設置值，如果已經存在，則獲取到當前key
對應的值，如果不存在，則獲取到新的值
v = dic, setdefault('k3', '123')
5.
更新值
dic.update({'k1': 'jg', 'hg': 'kjg'})
dic.update(k1=123, k2='rer', k5='hdhg')
6.
重點，keys()
values()
items()
dr = {
name = {id1: 'ou', id2 = 'jd'}
}
###########################
整理
1、數字
int(..)
2、字符串
replace, find, join, strip, startswith, endswith, split, upper, lower, formate
3、列表
append, extend, insert, remove, pop
索引，切片，循環
4、元組
索引，切片，循環
一級元素不可以修改
5、字典
get, update, keys, values, items
# for 索引
dic = {
k1 = 123, k3 = 345, k5 = "asdf"
}
v = 'k1' in dic
v = 'k1' in dir.values()
6、布爾值
0, 1
bool
None
''()[]
{}
0 -> > False