python学习
1.高阶函数
1.map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
def fun(x)
return x*x
a=[1,2,3,4]
r=map(fun,a) # 返回[1,4,9,16]
2.reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def fn(x,y)
return x*10+y
reduce(fn,[1,3,5]) #返回135，实现了序列到整数的转化
3.和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。 filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
def is_odd(n)
return n%2==1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
2.字符串有关
string.upper #小写变大写
string.lower #大写变小写
string.join #字符串拼接
string.split #字符串分割
str.split(str="", num=string.count(str)). #str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等;
#num -- 分割次数。默认为 -1, 即分隔所有
3.其他函数
1.sorted()
sorted([36, 5, -12, 9, -21])
sorted([36, 5, -12, 9, -21], key=abs)
4.闭包
在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
5.装饰器
前言：当你把一对小括号放在后面，这个函数就会执行；然而如果你不放括号在它后面，那它可以被到处传递，并且可以赋值给别的变量而不去执行它。 在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
python输出
print(1) #数值类型可以直接输出
'''
运行结果如下
1
'''
print("Hello World") #字符串类型可以直接输出
'''
运行结果如下：
Hello World
'''
a=1
b="Hello World"
print(a, b) #可以一次输出多个对象，对象之间用逗号分隔
'''
运行结果如下：
1 Hello World
'''
#如果直接输出字符串，而不是用对象表示的话，可以不使用逗号
print("Duan""Yixuan")
print("Duan","Yixuan")
'''
运行结果如下：
DuanYixuan
Duan Yixuan
可知，不添加逗号分隔符，字符串之间没有间隔
'''
print("www", "snh48", "com", sep=".") # 设置间隔符
'''
运行结果如下：
www.snh48.com
'''
变量的输出 无论什么类型的数据，包括但不局限于：数值型，布尔型，列表变量，字典变量...都可以直接输出。
#例如：
num = 19
print(num) #19 输出数值型变量
str = 'Duan Yixuan'
print(str) #Duan Yixuan 输出字符串变量
list = [1,2,'a']
print(list) #[1, 2, 'a'] 输出列表变量
tuple = (1,2,'a')
print(tuple) #(1, 2, 'a') 输出元组变量
dict = {'a':1, 'b':2}
print(dict) # {'a': 1, 'b': 2} 输出字典变量
格式化输出
s='Duan Yixuan'
x=len(s)
print('The length of %s is %d' %(s,x))
'''
'The length of %s is %d' 这部分叫做：格式控制符
(s,x) 这部分叫做：转换说明符
% 字符，表示标记转换说明符的开始
输出如下：
The length of Duan Yixuan is 11
'''
PI = 3.141592653
print('%10.3f'%PI) #字段宽10，精度3
# 3.142
#精度为3，所以只显示142，指定宽度为10，所以在左边需要补充5个空格，以达到10位的宽度
PI=3.1415926
print("PI=%.*f"%(3,PI))
#用*从后面的元组中读取字段宽度或精度,可以读取出来精度是3位
#PI=3.142
#没有指定宽度，所以不需要缩进
print("PI=%*.3f"%(10,PI)) #精度为3，总长为10.
# PI= 3.142
#* 所处的位置不同，读取的内容也不同
转换标志：-表示左对齐；+表示在数值前要加上正负号；" "(空白字符)表示正数之前保留空格()；0表示转换值若位数不够则用0填充。
PI=3.1415926
print('%-10.3f' %PI) #左对齐，还是10个字符，但空格显示在右边。
#3.142
PI=3.1415926
print('%+f' % PI) #显示正负号 #+3.141593
# 类型f的默认精度为6位小数。
PI=3.1415926
print('%010.3f'%PI) #字段宽度为10，精度为3，不足处用0填充空白
#000003.142 0表示转换值若位数不够则用0填充
换行
for x in range(0, 5):
print(x, end=' ')
#0 1 2 3 4
for x in range(0, 5):
print(x, end=',')
#0,1,2,3,4,
print(x, end=' ')
print('\n')
for x in range(0, 5):
print(x, end=',')
'''
0 1 2 3 4 #出现上面这种情况，是因为print()本身就是默认换行的，再加上换行符，相当于换行两次。
0,1,2,3,4,
'''
相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’
（1）不带编号，即“{}”
（2）带数字编号，可调换顺序，即“{1}”、“{2}”
（3）带关键字，即“{a}”、“{tom}”
print('{} {}'.format('hello','world')) # 不带字段
hello world
print('{0} {1}'.format('hello','world')) # 带数字编号
hello world
print('{0} {1} {0}'.format('hello','world')) # 打乱顺序
hello world hello
print('{1} {1} {0}'.format('hello','world'))
world world hello
print('{a} {tom} {a}'.format(tom='hello',a='world')) # 带关键字
world hello world
'{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
'{}, {}, {}'.format('a', 'b', 'c') # 3.1+版本支持
'a, b, c'
'{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
'{2}, {1}, {0}'.format(*'abc') # 可打乱顺序
'c, b, a'
'{0}{1}{0}'.format('abra', 'cad') # 可重复
'abracadabra'
通过位置匹配
# 格式转换
print('{0:b}'.format(3))
11
print('{:c}'.format(20))
print('{:d}'.format(20))
20
print('{:o}'.format(20))
24
print('{:x}'.format(20))
14
print('{:e}'.format(20))
2.000000e+01
print('{:g}'.format(20.1))
20.1
print('{:f}'.format(20))
20.000000
print('{:n}'.format(20))
20
print('{:%}'.format(20))
2000.000000%
# 时间转换等等
import datetime
d = datetime.datetime(2010, 7, 4, 12, 15, 58)
'{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'
6.字符串函数
1.split()函数
str1 = "Hello world, My name is 王怕怕升职'"
str2 = str1.split() # 以空格为分隔符，全部分隔
str3 = str1.split(" ", 3) # 以空格为分隔符，分为4份
print(str2)
print(str3)
print("---------------------------------")
# 利用re模块分割含有多种分割符的字符串：
import re
a='Beautiful, is; better + than - ugly'
x= re.split(',|; | \+ | - ',a)
print(x)
print("---------------------------------")
# 分隔后的字符串赋予变量
user, emall = ('123@qq.com').split('@')
print('user是：%s, emall是：%s' % (user, emall))
print("---------------------------------")
# 网页地址解析：
str="http://www.runoob.com/python/att-string-split.html"
print("0:%s"%str.split("/")[-1]) # 分割后的最后1条数据
print("1:%s"%str.split("/")[-2]) # 分割后的倒数第2条数据
print("2:%s"%str.split("/")[-3]) # 分割后的倒数第3条数据
print("5:%s"%str.split("/",-1)) # 默认-1，即分割所有
print("6:%s"%str.split("/",0)) # 分隔1条，即不分割
print("7:%s"%str.split("/",1)) # 分隔2条
python将列表元素转化为字符串
``colors = ['red', 'blue', 'yellow'] str1 = ",".join(colors) str1
'red,blue,yellow'`
#join 只接受 str 类型参数 colors = ['red', 'blue', 'yellow', 12, 3.14] str1 = ",".join(colors)
Traceback (most recent call last): File "", line 1, in TypeError: sequence item 3: expected str instance, int found
字符串转列表
str1 = "hi hello world"
print(str1.split(" "))
['hi', 'hello', 'world']
#### 7.程序异常处理
[try...except](https://blog.csdn.net/m0_37822685/article/details/80259402?spm=1001.2101.3001.6650.7&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-7.pc_relevant_aa&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-7.pc_relevant_aa&utm_relevant_index=11)
深信服公司福利 399人发布
腾讯一面1770人在聊
查看8道真题和解析
