可变类型与不可变类型：
1）可变：列表、字典
2）不可变：字符串、数字、元组
访问顺序：
1）直接访问：数字
2）顺序访问：字符串、列表、元组
3）映射：字典
存放元素种类的类型：
1）容器类型：列表、元组、字典
2）原子类型：数字、字符串
集合：1）不同元素组成；2）无序；3）集合中元素必须是不可变类型（#集合是可变类型）
例：{1,2,3,4,780}#大括号，中间以逗号隔开
格式化赋值常用的两种方法：
1）百分号方式：
%[(name)][flags][width].[precision]typecode
- (name) 可选，用于选择指定的key
- flags 可选，可供选择的值有：
- + 右对齐，正数前加正号，负数前加负号
- - 左对齐，正数前无符号，负数前加负号
- 空格 右对齐，正数前加空格，负数前加负号
- 0 右对齐 ，正数前无符号，负数前加负号；用0填充空白处
- width 可选，占有长度
- .precision 可选，小数点后保留的位数
- typecode 必选，最常见的是s
2）format形式
注意：传字典要加2个*号；传列表加1个*
函数：（过程：就是没有返回值的函数）
python中函数定义方法：
- def test(x):
- "the function defination"
- x += 1
- return x
def:定义函数的关键字
test:函数名
（）：内可定义形参
“”：文档描述（非必须，但是强烈建议为你的函数添加描述信息）
x+=1:泛指代码块或程序处理逻辑
return：定义返回值，即函数处理后要输出的值
函数的好处：1）代码重用；2）保持一致性，易于维护；3）可扩展性
#代码执行由上往下，当前面存在两个函数，执行时只执行靠后的一个
返回值总结：1）返回值=1，返回None；2）返回值=1，返回object；3）返回值>1，返回tuple
函数参数：1）形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
2）实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值、输入等办法使参数获得确定值。
3）位置参数（实参与形参一一对应，缺多都不行）与关键字参数（不用一一对应）
4）默认参数：不设置时为默认，输入时即变为输入的内容
5）参数组：将输入的多余参数放进参数组，分元组形式和字典形式。
------------恢复内容开始------------
可变类型与不可变类型：
1）可变：列表、字典
2）不可变：字符串、数字、元组
访问顺序：
1）直接访问：数字
2）顺序访问：字符串、列表、元组
3）映射：字典
存放元素种类的类型：
1）容器类型：列表、元组、字典
2）原子类型：数字、字符串
集合：1）不同元素组成；2）无序；3）集合中元素必须是不可变类型（#集合是可变类型）
例：{1,2,3,4,780}#大括号，中间以逗号隔开
格式化赋值常用的两种方法：
1）百分号方式：
%[(name)][flags][width].[precision]typecode
- (name) 可选，用于选择指定的key
- flags 可选，可供选择的值有：
- + 右对齐，正数前加正号，负数前加负号
- - 左对齐，正数前无符号，负数前加负号
- 空格 右对齐，正数前加空格，负数前加负号
- 0 右对齐 ，正数前无符号，负数前加负号；用0填充空白处
- width 可选，占有长度
- .precision 可选，小数点后保留的位数
- typecode 必选，最常见的是s
2）format形式
注意：传字典要加2个*号；传列表加1个*
函数：（过程：就是没有返回值的函数）
python中函数定义方法：
- def test(x):
- "the function defination"
- x += 1
- return x
def:定义函数的关键字
test:函数名
（）：内可定义形参
“”：文档描述（非必须，但是强烈建议为你的函数添加描述信息）
x+=1:泛指代码块或程序处理逻辑
return：定义返回值，即函数处理后要输出的值
函数的好处：1）代码重用；2）保持一致性，易于维护；3）可扩展性
#代码执行由上往下，当前面存在两个函数，执行时只执行靠后的一个
返回值总结：1）返回值=1，返回None；2）返回值=1，返回object；3）返回值>1，返回tuple
函数参数：1）形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
2）实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值、输入等办法使参数获得确定值。
3）位置参数（实参与形参一一对应，缺多都不行）与关键字参数（不用一一对应）
4）默认参数：不设置时为默认，输入时即变为输入的内容
5）参数组：将输入的多余参数放进参数组，分元组形式和字典形式。
全局变量与局部变量：
在子程序中定义的变量称为局部变量（不从顶格写），在程序一开始定义的变量称为全局变量（从顶格开始写）；局部变量作用域是定义该变量的子程序，全局变量作用域是整个程序
当全局变量与局部变量同名时，在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。
如果函数内部无global关键字，优先读取局部变量，无局部变量读取全局变量，只能读取全局变量，无法对全局变量重新赋值；但是对于可变类型，，可以对内部元素进行操作，并且全局生效。
如果函数内部有global关键字，变量本质就是全局那个变量，可读取可赋值。
#########规则：全局变量全部大写，局部变量全部小写
前向引用：函数运行前必须已经定义，即定义在前，运行即引用，运行在后，才可以执行
递归：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身 ，这个函数就是递归函数。（一层一层往里走，得到结果后一层一层返回到最初试处）
递归特点：1）必须有一个明确的结束条件；2）每次进入更深一层递归时，问题规模相比上一次都应有所减少；3）递归效率不高，递归层次过多会导致栈溢出（计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈桢，每当函数返回，栈就会减少一层栈桢，由于栈的大小不是无限地，所以，递归调用的次数过多，会导致栈溢出）
作用域：作用域在嵌套函数时就已经固定了，不会随着调用位置的改变而改变
匿名函数：不需要显示的指定函数，不单独执行；只能执行简单的逻辑，不能进行if while for等复杂运算；可以设置多个形参
编程方法论（3种流派）：
一.面向过程：（基于函数，没有返回值的函数即过程）找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程（例如解决结婚：1.找到匹配的目标范围；2.表白，成功则进入3，失败返回；3.恋爱，成功则进入4，失败返回；4.见家长，成功则进入5，失败返回；5.结婚）
二.函数式：函数式=编程语言定义的函数+数学意义的函数；通俗来讲，函数式就是用编程语言去实现数学函数的，这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数，没有for和while循环，所有的循环都由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变
1.特征：1）不可变数据：（不可变：不用变量保存状态，不修改变量）
#非函数式 a = 1 def incr_test1(): global a a += 1 return a incr_test1() print(a) #输出的是返回值 #函数式 n=1 def incr_test2(): return n+1 incr_test2() print(n) #输出的不是返回值，而是全局变量
2）第一类对象：函数即“变量”：函数名可以当做参数传递；返回值可以是函数名（二者满足其一就是高阶函数）
3）尾调用优化（尾递归：在函数的最后一步去调用另外一个函数，最后一行不一定是函数的最后一步）：尾调用的关键就在于是函数最后一步去调用其他函数的，那么最后一步调用，有何好处。根据函数即“变量”的定义，定义a函数，a内调用b函数，b内调用c函数，在内存会形成一个调用记录，又称为调用帧（call frame），用于保存调用位置和内存变量信息，即a->b->c，直到c返还结果给b，c的调用记录才会消失，b返还给a，b的调用记录才会消失，a返回结果，a的调用记录消失，所有的调用记录，都是先进后出，形成了一个“调用栈”（call stack）。尾调用由于是函数的最后一步操作，所以不需要保留额外函数的调用记录，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用记录，取代外层函数的调用记录就可以了。
2.map函数：map(lambda x:x**2,[23,45,6,8]) 意思是对后面的对象统一进行前面的运算，输出每一个对象的处理结果，元素个数及位置不变，print(map(lambda x:x**2,[23,45,6,8]))打印出的是一个内存对象地址，经过list可以打印出列表。（放入对象一般是序列，是可迭代的）
3.reduce函数：reduce(lambda x,y:x+y,[1,5,8,19]) 意思是将后面对象之间进行处理并压缩，最终得出一个运算结果，注意只有一个结论。print(reduce(lambda x,y:x+y,[1,5,8,19]))打印出结果（放入对象一般是序列，是可迭代的）
4.filter函数：filter(lambda n:n.startswith('sb'),["asd",'sbfg','sbrtyu']) 意思是对后面的对象进行前面的布尔判断，True的筛选保留出来，长度会改变，print(filter(lambda n:n.startswith('sb'),["asd",'sbfg','sbrtyu'])))打印出的是一个内存对象地址，经过list可以打印出列表。（放入对象一般是序列，是可迭代的）
5.内置函数：abs()取绝对值；
all()判断元素布尔值是否全为真，全为真输出True（可迭代对象中所有值的布尔判断都为真，返回True；如果可迭代对象为空，返回True）；
any()可迭代对象中只要有一个值的布尔判断为真，返回True；
bin()十进制转为2进制；
boll()判断布尔值；
bytes()保存时所用的编码形式，要指定编码形式；
chr()按照ASCII表规定的顺序给出字符；
dir()查看某一个对象的内置方法；
divmod()得出商和余数，用来分页；
eval()可以把字符串中的表达式进行运算，还可以把字符串中的数据类型结构提取出来；
hash()做hash运算，可以用来鉴别两个名字相同的文件是否经过了修改（hash值是固定长度的，不因输入的长短变化而变化；相同内容hash值相同，但不能根据hash值反推内容），（可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型）；help()查看某一个对象的内置方法的注释；
hex()十进制 转16进制；oct()10进制转8进制；
isinstance()某某是不是某某的实例；
global()全局变量；locals()局部（上级）变量；
zip()一一对应，一次对应组成一个元组，不成对的不对应（只要是序列就可以对应，序列包括：列表元组字符串）；
max()取最大值，注意两点，其一，max函数处理的是可迭代对象，相当于for循环取出每一个元素进行比较，不同元素类型之间不可比较，其二，每个元素之间的比较，是从每一个元素的第一个位置依次比较，如果这一个位置分出大小，后来的都不需要比较，直接得出结果；min()取最小值，用法和max相同；
ord()符号在ASCII码中对应的位置，与chr()相对应；
pow()某某的某某次方；还有一个功能取余；
reversed()反转；
round()四舍五入；
slice()切片功能；
sorted()由小到大排序，用法与max相似，相同类型才能排序；
str()转换成字符串，任何类型都可以转换成字符串；
type()查看数据类型；
sum()求和；
vars()作用与local()一样；
import 文件名：调用其他写好的py文件，直接用文件里写好的程序，不能导入字符串，不加.py
__import__()调用其他写好的py文件，能导入字符串
三.面向对象
文件处理：
一.文件处理流程：1.打开文件，得到文件句柄并赋值给一个变量； #用open()操作
2.通过句柄对文件进行操作；
3.关闭文件
打开文件的模式：读r，写w（不存在则创建，存在则清空），追加a，写x（不存在则创建，存在则报错 ） #带+都表示可读可写，具体的操作规则有所不同
以rb方式：以二进制的方式读取文件 （字符串——>encode——>bytes）（bytes——>decode——>字符串）
文件相关的操作：见pycharm
迭代器与生成器：
递归：函数调用自身并等待自身运行后返回结果；
迭代：每次循环的结果都是根据上次的循环得到的；
迭代器协议：是指，对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个Stopiteration异常，以终止迭代（只能往后走不能往前退）
可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个_iter_()方法）
协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max，函数等）使用迭代器访问对象
python中强大的for循环机制：
for循环的本质：循环所有对象，全都是使用迭代器协议
（字符串、列表、元组、字典、集合、文件对象）这些都不是可迭代对象，只不过在for循环时，调用了他们内部的_iter_()方法，把它们变成了可迭代对象；然后for循环调用可迭代对象的_next_方法去取值，而且for循环会捕捉Stopiteration异常，以终止迭代。
for循环可以实现可以遍历（遍历：查看内部所有的内容）所有对象，包括序列型的字符串列表元组，还包括非序列型的字典集合文件对象。
for循环将得到的内容全部放入内存，而_iter_()方法只形成一个迭代器对象(地址)，使用next方法时才将值一行一行的放入内存。
生成器：可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要自己调用内置的_iter_()方法），所以生成器就是可迭代对象。
生成器分类及在python中的表现形式（python有两种不同的方式提供生成器）：1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下一次重它离开的地方继续执行；2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表。
三元表达式及列表解析：见pycharm
列表解析会将得到的结果全部放进内存，类似于for循环；
总结：1.把列表解析的[]变成()就是生成器表达式；2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存；3.python不但使用迭代器协议，让for循环更加通用，大部分内置函数也是通过迭代器协议访问对象的。如sum()。
生产者消费者模型：
如果返回值是yield的就是生成器类型，test()表示生成生成器，并不会执行，next才会使之运行；如果返回值是return的就是函数，test()表示运行函数。
# bool([]) # for i in range(1,9):#注意，9>range>=1，即取不到右边范围的数 # print(i) # 输出一个乘法口诀表 # for i in range(1,10): # string = "" # for v in range(1,i+1): # string += str(v) + "*" + str(i) + "=" + str(i*v) + "\t" # print(string) # print('1',end="SB")#end表示以什么结尾，默认为换行 # print('1','2','3',sep="and")#sep表示将所有打印的内容以特定值连接 # 练习 # for x in range(1,100//5): # for y in range(1,100//3): # for z in range(1,100): # if x + y + z == 100 and 5*x + 3*y + z/3 == 100:# =为赋值，==为等于 # print(x,y,z) # tu = ("alex","123",[345],) # for a,b in enumerate(tu,10):#enumerate指定输出元组元素，并按照指定序号往后排 # print(a,b) # for v in range(len("qwe")):#可用来找索引 # print(v) # li = [12,23,45,67] # del li[1:4]#索引大于等于1小于4 # print(li) # name = "lilei" # print(id(name))#不可变类型，即只要内容改变id也会变 # name = 'leili' # print(id(name)) # li = [12,23,45] # print(id(li))#可变类型，即内容改变id也不会变 # li[0] = 56 # print(id(li)) # s = {123,"qwe",(345),123}#无序，不可重复 # print(s) # s = set("hello")#定义集合的方法 # print(s) # s = set([123,"qwe","牛逼"])#定义方式，并且可去重 # print(s) # s = set([123,"qwe","牛逼"]) # # s.clear()#清除 # s.add(3)#添加 # s.copy()#拷贝 # s.remove(3)#指定参数删，删除不存在的会报错 # s.pop()#随机删 # s.discard('ppp')#指定参数删，删除不存在的不会报错 # print(s) # p_and_l_name = [] # python_l = ['a','s','d'] # linux_l = ['a','s'] # for name_p in python_l: # if name_p in linux_l: # p_and_l_name.append(name_p) # print(p_and_l_name) python_l = ['a','s','d','f','a'] linux_l = ['a','s','q'] p_s = set(python_l) l_s = set(linux_l) # print(p_s,l_s) # print(p_s.intersection(l_s))#求交集 # print(p_s&l_s)#求交集，功能一样 # print(p_s.union(l_s))#求并集 # print(p_s|l_s)#也是求并集 # print(p_s.difference(l_s))#求差集 # print(p_s-l_s)#也是求差集 # print(p_s.symmetric_difference(l_s))#交叉补集：先求并集再减去交集 # print(p_s^l_s)#也是交叉补集 # p_s.difference_update(l_s)#求差集并将结果返回给原集合 # print(p_s) # print(p_s.isdisjoint(l_s))#判断是否有交集，有交集输出False # print(p_s.issubset(l_s))#判断p_s是否为l_s的子集，是就输出True # print(p_s<=l_s)#同上 # print(p_s.issuperset(l_s))#判断p_s是否为l_s的父集，是就输出True # print(p_s>=l_s)#同上 # p_s.add(1)#更新一个值 # print(p_s) # p_s.update((2,3,4),(5,6,7))#可更新多个值 # print(p_s) # s = frozenset('hello')#创建不可变集合，普通集合是可变的 # print(s) # msg = 'i am %.2s,my hobby is %s' %('lyt',['music',123])#%s表示格式化加入值，值可以是各种类型的(.2表示保留两个字符，可去掉） # print(msg) # msg = 'i am %d years old' %8 #%d格式化加入数字 # print(msg) # t = '%.4f%%' % 98.95687654 #按照规定的小数位数打印浮点数，%%打印出来就是% # print(t) # msg = 'i am %(name)s age %(age)d' %{'name':'lyt','age':18} #字典形式格式化赋值 # print(msg) # msg = 'i am \033[45;1m%(name)-30.2s\033[0m age %(age)d' %{'name':'lyt','age':18} #\033[45;1m \033[0m表示给夹中间的加颜色 # print(msg) # print('root','x','0','0',sep=':') #sep以什么符号拼接字符 # t = "i am {}, age{}, hobby is {}".format("a",18,'b','c') #format方式，只能一一对应，给的值可以多，不能少 # print(t) # # t = "i am {2}, age{1}, hobby is {2}".format("a",18,'b','c') #format方式，按索引方式改变填充顺序，不用一一对应 # print(t) # t = "i am {name}, age{age}, hobby is {hobby}".format(name="a",age=18,hobby='b') # t = "i am {name}, age{age}, hobby is {hobby}".format(**{"name":"a","age":18,"hobby":'b'}) #传字典要加两个* # print(t) # t = "i am {:s}, age{:d}, hobby is {:.2f}".format("a",18,34.2) #规定format填入的类型 # print(t) # t = 'numbers:{:b},{:o},{:d},{:x},{:X},{:%}'.format(15,15,15,15,15,15,15) #b 二进制；o 8进制；d 十进制；x（X） 十六进制；%显示为百分数 # print(t) # def test(x): #定义函数 # "求值" # y = 2*x + 1 # return y #return x就输出了x当前的值 # a = test(3) # print(a) # def test(): #调试运行函数，不加形参 # "求值" # x = 4 # y = 2*x + 1 # return y # a = test() # print(a) # def test(x,y,z): # print(x) # print(y) # print(z) # test(1,2,3)#位置参数 # test(x=1,z=2,y=3)#关键字参数 # test(2,4,z=3)#可以混用，位置参数放左边，但是要按照顺序 # def handle(x,type='qwe'): #type为默认参数 # print(x) # print(type) # handle(123) # handle(123,'asd') # def test(x,*args):#参数组（*args将多余位置参数组成元组） # print(x) # print(args) # test(1,2,3,4) # test(1,[2,3,4])#当做整体 # test(1,*[2,3,4])#加*结果为列表和元组的元素 # def test(x,**kwargs):#参数组（**kwargs将关键字参数组成字典） # print(x) # print(kwargs) # test(1,y=2,z=4) # name = 'lyt'#全局变量 # def change_name(): # name = 'niubi'#局部变量 # print('change_name',name) # change_name() # print(name) # name = 'lyt' # def change_name(): # global name #局部变量变为全局变量，添加 global name;即创建了一个路径指向全局变量，下一步改的是全局变量，局部变量失效 # print('change_name', name)#全局变量 # name = 'niubi'#改了全局变量 # print('change_name',name) # change_name() # print(name) # name = ['lyt',123] # def a(): # name.append(456) # print('hello',name)#对全局可变类型变量，可进行内部操作，且全局生效 # a() # print('hello',name) # NAME = 1 #函数内部可以嵌套，注意代码执行的顺序 # def a(): # name = 2 # print(name) # def b(): # name = 3 # print(name) # def c(): # name = 4 # print(name) # c() # b() # a() # name = 'a' #函数内嵌套的子函数更改了全局变量，不影响原函数的局部变量 # def A(): # name = 'b' # def B(): # global name # name = 'c' # B() # print(name) # print(name) # A() # print(name) # name = 'a' #函数内嵌套的子函数更改了上级变量，即改变了原函数的局部变量，全局变量不变 # def A(): # name = 'b' # def B(): # nonlocal name#指向上级变量 # name = 'c' # B() # print(name) # print(name) # A() # print(name) # def bar(): #可运行 # print('from bar') # def foo(): # print('from foo') # bar() # foo() # def foo(): #可运行 # print('from foo') # bar() # def bar(): # print('from bar') # foo() # def foo(): #不可运行，只能前向引用，bar函数在执行前没有被定义 # print('from foo') # bar() # foo() # def bar(): # print('from bar') # def calc(n): #递归（这里是死循环） # print(n) # calc(n) # calc(10) # def calc(n): #先在内部再一次调用原函数，再将得到的值返回给上一次的函数 # print(n) # if int(n / 2) == 0: # return n # res=calc(int(n / 2)) # return res # res = calc(10) # print(res) # import time # person_list=['alex','wupeiqi','yuanhao','linhuanfeng','zsc'] # def ask_way(): # print('-'*60) # if len(person_list) == 0: # return '没人知道' # person = person_list.pop(0) # if person == 'linhuanfeng': # return '%s说：我知道，在XXX' %person # print('Hi,美男[%s],敢问路在何方' %person) # print('%s回答道：“我不知道，但念你慧眼识珠，你等我，我帮你去问%s...' %(person,person_list)) # time.sleep(2) #执行下一行代码休眠的时间 # res = ask_way() # return res # res = ask_way() # print(res) # def test1(): # print('in the test1') #没有设立返回值，结果会输出None # def test(): # print('in the test') # return test1 # res = test() # print(res()) # def test1(): # print('in the test1') # def test(): # print('in the test') # return test1 # res = test() # print(res) #打印的是test()的内存位置 # name = 'alex' # def foo(): # name = 'lyt' # def bar(): # name = 'ppp' # print(name) # return bar # res = foo() # print(res) # res() #作用域在嵌套函数时就已经固定了，不会随着调用位置的改变而改变，即使顶格运行子函数（有局部变量与全局变量的前提下）起作用的仍是局部变量 # name = 'alex' # def foo(): # name = 'lyt' # def bar(): # name = 'ppp' # print(name) # return bar # res = foo()() #与上面的效果一样 # def calc(x,y): # return x+1,y+2 #多个形参将自动以元组形式输出 # res = calc(10,10) # print(res) # func = lambda x,y:(x+1,y+2) #匿名函数，与上一个函数的效果完全相同（不独立使用，使用时直接写 lambda x:x + 1） # print(func(10,10)) #匿名函数多个形参要在定义时加括号，手动组成元组的形式 # n=2 # def incr_test2(): #函数式 # return n+1 # incr_test2() # print(n) # print(n+1) # def foo(n): # print(n) # def bar(name): # print('my name is %s' %name) # foo(bar) # foo(bar('alex')) #函数有括号的，由括号内往外执行 # def test(): # print('qwe') # test() # print('asd') #非尾调用，如果去掉这一行就是尾调用 # test() # number_l = [1,5,10,45,7] #循环版本 # res = [] # for i in number_l: # res.append(i**2) # print(res) # def map_test(array): #一个函数只解决一个功能的版本 # res = [] # for i in array: # res.append(i**2) # return res # a = map_test(lambda x:x+1,[23,45,6,8]) # print(a) # def map_test(func,array): #一个函数解决多个功能的版本 # res = [] # for i in array: # k = func(i) # res.append(k**2) # return res # a = map_test(lambda x:x+1,[23,45,6,8]) # print(a) # def map_test(func,array): #一个函数解决一个功能的版本，但可以改写为map # res = [] # for i in array: # k = func(i) # res.append(k) # return res # a = map_test(lambda x:x**2,[23,45,6,8]) # print(a) # print(list(map(lambda x:x**2,[23,45,6,8]))) #一句话解决上述函数，注：不一定使用lambda，可以自定义 # print(map(lambda x:x**2,[23,45,6,8])) # def filter_test(array): #初级版本 # ret = [] # for p in array: # if p.startswith('sb'): # ret.append(p) # return ret # print(filter_test(["asd",'sbfg','sbrtyu'])) # def filter_test(func,array): #终极版本，相当于filter # ret = [] # for p in array: # if func(p): # ret.append(p) # return ret # print(filter_test(lambda n:n.startswith('sb'),["asd",'sbfg','sbrtyu'])) # print(list(filter(lambda n:n.startswith('sb'),["asd",'sbfg','sbrtyu']))) #得到布尔值，如果是True就保留，否则不保留 # print(filter(lambda n:n.startswith('sb'),["asd",'sbfg','sbrtyu'])) # print(list(filter(lambda n:not n.startswith('sb'),["asd",'sbfg','sbrtyu']))) # from functools import reduce #调用reduce函数 # def reduce_test(array): #初级版本 # res = 0 # for num in array: # res += num # return res # print(reduce_test([1,5,8,19])) # def reduce_test(func,array): #终级版本,相当于reduce # res = array.pop(0) # for num in array: # res = func(res,num) # return res # print(reduce_test(lambda x,y:x+y,[1,5,8,19])) # from functools import reduce # print(reduce(lambda x,y:x+y,[1,5,8,19])) #使用前要先调用 # print(reduce(lambda x,y:x+y,[1,5,8,19],100)) #最后一个100为首位值，不写默认首位为序列的第一个值 # print(all([1,2,'q',0])) #可迭代对象中所有值的布尔判断都为真，返回True；如果可迭代对象为空，返回True # print(any([1,2,'q',0])) #可迭代对象中所有值的布尔判断只要有一个为真，返回True # print(bin(3)) # print(bool(0)) # print(bytes('您好',encoding='utf-8')) #utf-8中每个字符用3个字节 # print(bytes('您好',encoding='gbk')) #gbk中每个字符用2个字节 # print(bytes('您好',encoding='utf-8').decode('utf-8')) #用什么编码就用什么解码 # print(chr(107)) # print(dir(all)) # print(divmod(20,6)) #20总条数，每页6条，分4页 # express = '1+2*(6/3-1)-2' # print(eval(express)) #把字符串中的表达式进行运算 # s ="{'name':'lyt'}" # print(eval(s)) #把字符串中的数据结构提取出来 # name = 'lyt' # print(hash(name)) # print(hash(name)) # print(hash('123')) # name = 'lty' # print(hash(name)) # print(help(all)) # print(isinstance('qwe',str)) #判断是不是实例，str，list，dict，int，set # print(list(zip(('q','w','e'),(1,2,3)))) # print(list(zip(('q','w','e'),(1,2,3,4)))) # print(list(zip(('q','w','e','r'),(1,2,3)))) #一一对应，一次对应组成一个元组，不成对的不对应 # p = {'name':'lyt','age':18,'gender':'male'} # print(list(zip(p.keys(),p.values()))) #将字典的key与value对应 # print(p.keys()) #取key、value值的方法 # age_dic = {'age1':18,'age2':20,'age4':30,'age3':100} # print(max(age_dic.values())) #max比较是经过for循环后得到的结果 # for i in age_dic: #字典for循环默认得到的是key值 # print(i) # age_dic = {'age123344':18,'age2':20,'age4':30,'age3':100} # print(max(age_dic)) #默认比较的是字典的key，前三位相同，第四位4在ascii码中做大，所以age4最大，后面位数就不比较了 # age_dic = {'age123':18,'age2':20,'age4':30,'age3':100} # print(list(max(zip(age_dic.values(),age_dic.keys())))) #max比较从起始处开始，zip的目的是调换起始处，把value调到前面，key调到后面，并组成元组 # li = ['z1','w34',12] #max比较的元素必须是可迭代对象，且相同类型（for循环得到的是字典则不可比较） # print(max(li)) # age_dic = ({'name':'age123344','age':18},{'name':'age2','age':20},{'name':'age4','age':30}) # print(max(age_dic,key=lambda dic:dic['age'])) #max加两个参数的用法，等同于可以利用lambda先处理数据再比较 # print(ord('a')) #与chr对应 # print(pow(3,3)) #3**3 # print(pow(3,3,4)) ##3**3/4的余数 # l = [1,2,3,4] # print(list(reversed(l))) #反转 # print(round(3,45)) #四舍五入，只保留整数 # print(set('qwer')) #创建集合 # l = 'qwertyu' # s1 = slice(1,5) # s2 = slice(1,5,3) #与切片功能相同，有起始结束步长3个参数 # print(l[s1]) # print(l[s2]) # age_dic = ({'name':'age123344','age':28},{'name':'age2','age':20},{'name':'age4','age':30}) #sorted用法与max相似 # print(sorted(age_dic,key=lambda dic:dic['age'])) # age_dic = {'asd':10000,'azd':2000,'qwe':3000} # print(sorted(age_dic,key=lambda key:age_dic[key])) #三种输出方法，排序的依据也不同 # print(sorted(age_dic)) # print(sorted(zip(age_dic.keys(),age_dic.values()))) # print(type({12,3})) #查看数据类型 # print(sum(range(5))) #range5表示1,2,3,4相加，不包括5 # msg = '123' 用于判断类型 # if type(msg) is str: # msg = int(msg) # print(msg+1) # def test(): # msg = '去玩儿体育界和股份董事长形成' # print(locals()) # print(vars()) #没有参数时与locals()功能相同 # test() # print(vars(int)) #有参数时显示参数的作用 # import test1 #不能导入字符串 # test1.say_hi() # w = 'test1' # m = __import__(w) #能导入字符串 实际上：import-->找到操作系统-->调用__import__ # m.say_hi() # f = open('文本',encoding='utf8') #相对引用 # data = f.read() #文档写的时候是utf8，操作系统是gbk，要进行转换；如果写的时候是gbk就不用转换 # print(data) # f.close() # f = open('文本',encoding='utf8') #赋予的句柄有只读权限 # data = f.read() #read()表示全部读出来，read(4)表示读4个字符，而非字节 # print(data) # print(f.readable()) #判断是否可读 # f.close() #关闭句柄 # f = open('文本',encoding='utf8') # print(f.readline(),end='') #依次读取一行，默认结尾空一行，可以设置 # print(f.readline(),end='') # print(f.readline(),end='') # f = open('文本',encoding='utf8') # print(f.readlines()) #全部读出来，放入一个列表 # f = open('文本1','w',encoding='utf8') #'w'功能，如果文件存在，清空原文件后等待写入，文件不存在时新建一个文件等待写入。 # f.write('111111111\n') # f.write('222222222\n') # f.write('111\n222\n333\n') # print(f.writable()) # f.writelines(['55\n','66\n']) #注意，只能写入文件规定的格式，这里只能写字符串，writelines写时要用列表 # f.close() # f = open('文本1','a',encoding='utf8') # f.write('谢谢') #‘a'追加写在最后，原来的不变 # f.close() # f = open('文本1','r+',encoding='utf8')#可读且可写，从文件的最初开始写入，后面有内容的覆盖原来的内容 # print(f.writable()) # f.write('lyt牛逼啊') # f.write('lyt牛逼啊') # f.write('\nlyt牛逼啊') # f.close() # with open('文本','r',encoding='utf8') as f: #另一种打开方式，用完后不用关闭 # print(f.writable()) # with open('文本','r',encoding='utf8') as src_f,\ # open('文本_new','w',encoding='utf8') as dst_f: #将一个文件的内容原封不动写入另一个文件，内容可以是多行 # data=src_f.read() # dst_f.write(data) # f = open('文本','rb') #以(r)b方式读的时候不能指定编码 # data=f.read() # print(data) # print(data.decode()) # f = open('文本2','wb') # data=f.write(bytes('你好\n',encoding='utf-8')) #先找出字符串的字节（二进制）编码，再以字节方式写入，要规定编码方式 # f.write('牛逼'.encode('utf-8')) #功能相同(encoding表示open以什么编码方式打开，不是存文件的编码方式） # f.flush() #刷新，会将内存里的修改保存到硬盘里，否则不会保存进硬盘 # f.close() # print(f.closed) #判断文件是否关闭 # f = open('文本2','r',encoding='utf-8',newline='') #newline读取文件中真正的换行符号 # print(f.tell()) # print(f.readlines()) # print(f.tell()) #当前光标的位置，后续写入将在光标之后 # f.close() # f = open('文本2','r+',encoding='utf-8',newline='') # print(f.tell()) # print(f.readlines()) # print(f.tell()) # f.seek(3) #seek()按字节数移动光标，tell和seek中的数字都是表示字节数，而非字符数，与read(3)相区别（实际上除了read其余都是字节数） # print(f.tell()) # f.close() # f = open('文本3','r+',encoding='utf-8',newline='') # f.truncate(6) #截取文件前几位字节数留下，其他的删掉 # f.close() # f=open('seek','r',encoding='utf-8') # print(f.tell()) # f.seek(10,0) #seek默认模式为0，可不写，表示每次从文件最开始处移动光标 # print(f.tell()) # f.seek(3,o) # print(f.tell()) # f=open('seek','rb') # print(f.readlines()) # print(f.tell()) # f.seek(10,1) #seek其他模式要用r打开，1模式表示从文件光标现有位置处移动光标，负数表示倒着移动，正数正向移动 # print(f.tell()) # f.seek(-3,1) # print(f.tell()) # f=open('seek','rb') # print(f.tell()) # f.seek(-1,2) # print(f.tell()) # f.seek(3,2) #seek其他模式要用r打开，2模式表示从文末尾处处移动光标，负数表示倒着移动，正数正向移动 # print(f.tell()) # f=open('seek','rb') # print(f.readline()) # f.seek(-1,2) # print(f.readline()) #读取行的时候会读出光标后的一行的所有内容 # f.close() # # #取最后一行的办法 # f=open('seek','rb') # for i in f: #这里for循环是一行一行全部取出来的，在这里可以不用写 # #print(i.decode('utf-8')) # offs=-10 # while True: # f.seek(offs,2) # data = f.readlines() # if len(data)>1: # print('文件最后一行是%s' %(data[-1].decode('utf-8'))) # break # offs*2 # s = 'qwe' # f = s.__iter__() #实现迭代器协议，将字符串变为可迭代对象（for循环的功能之一） # print(f.__next__()) # print(f.__next__()) # print(f.__next__()) # print(f.__next__()) #for循环的功能之二，识别StopIteration并终止循环 # li = [1,2,3] # index = 0 # while index<len(li): #序列型可以通过index遍历 # print(li[index]) # index+=1 # #for循环实现过程 # li = [1,2,3] # diedai_l = li.__iter__() # while True: # try: # print(diedai_l.__next__()) # except StopIteration: # #print("迭代完了") # break # li = [1,2,3] # lw =li.__iter__() # print(next(lw)) #next()——>相同功能：-next-() # def test(): # yield 1 # print(5) # yield 2 # yield 3 # f = test() # print(f) # print(f.__next__()) #yield可以返回多个值，并且下一个next从上一个yield停下的地方开始往下执行 # print(f.__next__()) # #三元表达式： # name = 'lyt' # res ='SB' if name == 'ppp' else 'shuai' #条件成立输出条件前面的，否则输出后面的 # print(res) # #列表解析 # egg_list=[] # for i in range(10): # egg_list.append("鸡蛋%s" %i) # print(egg_list) # # l = ['鸡蛋%i' %i for i in range(10)] #与上述功能一样 # print(l) # # l = ['鸡蛋%i' %i for i in range(10) if i<6]#只有三元或者两元，不能四元 # print(l) # l = ('鸡蛋%i' %i for i in range(10)) #列表解析的中括号变成括号就能实现生成器 # print(l) # print(l.__next__()) # print(sum(x ** 2 for x in range(1000000))) #内置函数sum通过迭代器协议实现求和功能 # def preduct_baozi(): # ret=[] # for i in range(100): # ret.append('包子%s' %i) # return ret #全部完成后才进行下一步，缺点：占空间大，效率低 # baozi_list=preduct_baozi() # print(baozi_list) # def preduct_baozi(): # for i in range(100): # print('开始生产包子') # yield '包子%s' %i #得到生成器，有需求才进行下一步，效率高 # print('开始卖包子') # baozi_list=preduct_baozi() # print(baozi_list) # print(baozi_list.__next__()) # #加其他基于此次结果的代码 # print(baozi_list.__next__()) # with open('人口普查','r',encoding='utf-8') as f: #查询总人口，取出来的是文本，要用eval函数还原数据原本的类型 # print(sum(eval(i)['人口'] for i in f )) #注意：一个next只能使用一次 # def test(): # print('开始啦') # x = yield 1 # print('第一次',x) #x表示yield传的值 # yield 2 # print('第二次') # t=test() # res1=t.__next__() # print(res1) # res2=t.__next__() # print(res2) # def test(): # print('开始啦') # x = yield 1 # print('第一次',x) #x表示yield传的值，即下面send里面的值（注意，如果yield不设置返回值，打印时会输出None) # yield 2 #即yield有两个功能，一个是返回值，另一个功能是传递send发过来的值 # print('第二次') # t=test() # res1=t.__next__() # print(res1) # res2=t.send(5) #send()相当于一次next的功能，但它会给yield传一个值，这个值不影响yield的返回值 # print(res2) # #消费者生产者理论： # #单独运行 # import time # def preducer(): # ret=[] # for i in range(100): # time.sleep(0.1) # ret.append('做好的包子%s' %i) # return ret # def consumer(res): # for index,bz in enumerate(res): # time.sleep(0.1) # print("第%s个人来吃完了%s" %(index,bz)) # res=preducer() # consumer(res) # #并发运行 # import time # def consumer(name): # print('我是%s，我要吃包子' %name) # while True: # baozi=yield # time.sleep(1) # print('%s开心地把%s吃掉了' %(name,baozi)) # def preducer(): # c1=consumer('lyt') # c1.__next__() # for i in range(10): # time.sleep(0.1) # print('做好了包子%s' %i) # c1.send('包子%s' %i) # res=preducer() # #练习：找出字符串中所有大小写和数字的个数 # def test(x): # a = 0 # b = 0 # c = 0 # for i in x: # if ord(i) in range(65,91): # a += 1 # elif ord(i) in range(97,123): # b += 1 # elif ord(i) in range(48,58): # c += 1 # return {'大写个数':a,'小写个数':b,'数字个数':c} # res = test('dfhjuvbgdSDFGH123445') # print(res) # #练习：如何加百分号 # a = '1班前100名占%d%%' %20 # print(a) # #练习：求n的阶乘： # #法1 # from functools import reduce # print(reduce(lambda x,y:x*y,[x for x in range(1,7)])) # #法2 # def j(n): # if n==1: # return 1 # return n*j(n-1) # res = j(6) # print(res) # #练习读取拷贝文件内容： # with open('人口普查','r') as x,open('人口普查_new','w') as y: # y.write(x.read()) # #匿名函数也要传值进去，9天时间，下一天是（上一天+1）*2，共有多少 # s = 1 # func=lambda s:(s+1)*2 # for i in range (9): # s=func(s) # print(s) # # func=lambda x:x**2 # print(func(3))
浙公网安备 33010602011771号