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