【Python3 第三日】%和format格式化输出 函数
格式化输出
print(f'{d}')
会把d代表的意义转化掉,和format差不多
%格式化形式
#这里只说明字典使用 dict1 = {"what": "this year", "year": 2016} print("%(what)s is %(year)d" % {"what": "this year", "year": 2016}) # 输出this year is 2016 print("%(what)s is %(year)d, %d" % (dict1,22) ) # 输出this year is 2016
format格式化形式
位置映射
#后面的元素可以多 print("{}:{}".format('192.168.0.100', 8888, 222)) #输出如下192.168.0.100:8888
关键字映射
print
(
"{server}{1}:{0}"
.
format
(
8888
,
'192.168.1.100'
,server
=
'Web Server Info :'
)) #Web Server Info :192.168.1.100:8888
print
(
'{name},{sex},{age}'
.
format
(age
=
32
,sex
=
'male'
,name
=
'zhangk'
)) #zhangk,male,32
元素访问
print("{0[0]}.{0[1]}".format(('baidu','com'))) #baidu.com
填充对齐
- ^、<、>分别是居中、左对齐、右对齐
精度设置
# 填充与对齐 # 填充常跟对齐一起使用 # ^、<、>分别是居中、左对齐、右对齐,后面带宽度 # :号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充 print('{:>8}'.format('zhang')) print('{:0>8}'.format('zhang')) print('{:a<8}'.format('zhang')) print('{:p^10}'.format('zhang')) # 精度与类型f # 精度常跟类型f一起使用 print('{:.2f}'.format(31.31412)) # 其他类型 # 主要就是进制了,b、d、o、x分别是二进制、十进制、八进制、十六进制 print('{:b}'.format(15)) print('{:d}'.format(15)) print('{:o}'.format(15)) print('{:x}'.format(15)) # 用逗号还能用来做金额的千位分隔符 print('{:,}'.format(123456789)) #输出如下: zhang 000zhang zhangaaa ppzhangppp 31.31 1111 15 17 f 123,456,789
进制及其他显示
b : 二进制
d :十进制
o :八进制
x :十六进制
!s :将对象格式化转换成字符串
!a :将对象格式化转换成ASCII
!r :将对象格式化转换成repr
其他情况
dict1 = {"one": 1, "two": 2, "three": 3}
list1 = ["one","two", "three"]
print("{}".format(dict1)) # 是字典
print("{0} {1} {2}".format(*dict1)) # 返回的是one two three
print('{one},{two},{three}'.format(**dict1)) # 返回的是元组对,
print('{one},{two},{three}'.format(one=1, two=2, three=3)) # 返回的是元组对,
print("{}".format(list1)) # 是序列
print("{0} {1} {2}".format(*list1)) # 返回的是one two three
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的,传入的是对象
#输出如下:
{'one': 1, 'two': 2, 'three': 3}
one two three
1,2,3
1,2,3
['one', 'two', 'three']
one two three
value 为: 6
函数
函数即变量,如果先使用fun(),然后在定义fun(),就会报错
函数基本形式
def 函数名(参数列表):
函数体
#直接调用 def hello(): print("hello,world") return hello() #返回函数 def hello1(x): def hello2(x): print(x, x) return hello2 a = hello1("1") a(1) #输出如下: hello,world 1 1
关键字参数,可变长参数
func1(m,n) #位置参数 func2(m=1) #默认参数,必须在位置参数后面,最好是不可变对象 func3(*args) #可变参数 func4(**kwargs) #关键字参数 func5(*args,a=1,b) #命名关键字参数
- 调用时候,位置参数一定在默认参数前面,否则报错function(one = 1,two = 2,3),也不可以调换顺序 错误例子
- **接受的是字典,*接受的元组,调用时候如果有元组,列表,字典调用*,则添加*解包,调用**参数,字典用**解包
- 参数定义的顺序必须是:必选参数–>默认参数–>可变参数–>命名关键字参数–>关键字参数
- 命名关键字参数必须是a=2,这样指定
参数后面的冒号和->
def f(ham: str, eggs: str = 'eggs') -> str :
print("Annotations:", f.__annotations__) print("Arguments:", ham, eggs) return ham + ' and ' + eggs
f.__annotations__(显示参数注释和返回值注释) {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
其实只是提醒,并没有指定参数类型
内置函数
abs() #绝对值
all() #如果全是真或者假,返回true,否则返回false 0,"",false 为假,其他为真
any() #一真为真,全假为假
ascii() #返回对应的ascii, 类似于repr() 和chr差不多,和ord相反,\64会变成4
bin() #oct() hex() 接受一个10进制数字,不可以是字符串,转为相对应的进制
bool #返回相对应的bool值,None,0,“”,{},【】,()为false
bytes() #把字符串转为相对应的字节,第一个是要转化的字符串,第一个参数是按什么编码,是不可变序列,
bytearray() #可以如果bytes,但是是可变序列,也可以直接添加参数bytearray(str.encode())
classmethod() staticmethod() #函数修饰符 和普通函数区别详见 普通函数是实例的, classmethod是对象的 staticmethod是不绑定参数的
callable:函数用于检查一个对象是否是可调用的。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。
complie() #讲.py或者str变成可执行的语句,详见
float() int() complex() #转为相对应的类型
getattr() hasattr() setattr() delattr() #详见 对应获取属性, 查询属性 设置 删除
dict() len() list() str() set() max() min() pow() print()#比较简单不说了
dir() #接收对象作为参数,返回该对象的所有属性和方法 和__dict__区别,__dict__是字典,dir()是列表,__dict__是dir()的子集 __annotation__是函数注释
help() #以树状形式返回所有的属性和方法,还有注释,这个不错哦
divmod(100,3) #返回一个(33,1)元组,第一个是商,第二个是余数
enumerate() #枚举可迭代对象,用于获取他的索引和值,for index,value in enumerate(list1):
eval() 和exec() #变成可执行代码, eval支持一行,有返回,exec支持多行,无返回
filter,format #参见本文的filter和上一篇的format
frozenset() #转换为不可变的集合
globals() # 返回一个字典,包括所有的全局变量与它的值所组成的键值对
locals() # 返回一个字典,包括所有的局部变量与它的值所组成的键值对
vars() #返回当前模块中的所有变量
hash() # 传入一个对象,返回相对应的hash值
id() #返回内存地址,可用于查看两个变量是否指向相同一块内存地址
input() #提示用户输入,接受字符串类型
isinstance() issubclass() #如名字
iter() #转为迭代器
next() #迭代器的下一个项目,和iter互用
map() #详见本文的map
memoryview() #查看内存对象,
open: #函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
propetry() #把某个方法变成属性,详见
range() #创建一个range()对象,可以迭代,可以转为列表
repr() #原形毕露
reversed() #将序列翻转,返回迭代器
round() #返回数字整数部分
slice(start,stop,stride) #相当于做一个切片模板,别人用就这么切
sorted() #详见本文
super() #调用父类的方法,顺序按照__mro__
type() #返回对象类型
zip() #打包成元组,zip(x1,x2,x3,x4) 把x1,x2,x3,x4中对应的元素打包成元组,哪个没有就停止
__import__:函数用于动态加载类和函数 。
高级函数
高阶函数:就是把函数当成参数传递的一种函数;例如
def add(x:int, y, f): return f(x) + f(y) print(add(1.1, 2, abs)) #输出3.1
包含函数:
name = "1" def outer(func): name="2" func() #这里相当于调用,而不是内部函数 def show(): print(name) outer(show) #输出如下: 1
map,filter,reduce,sorted
map,filter在python3中返回的是迭代对象,reduce在functools中,sorted没有了cmp
map()函数
python内置的一个高阶函数,它接收一个函数f和一个list,并且把list的元素以此传递给函数f,然后返回一个函数f处理完所有list元素的列表,如下:
a = [1,2,3,4,5] def f(x): return abs(x-3) print(map(f, a)) #<map object at 0x00CABDF0> 返回的是迭代对象,所以可以用for循环,循环完就里面就没有东西了 print(list(map(f,a))) #[2, 1, 0, 1, 2]
reduce()函数
reduce()函数也是python的内置高阶函数,reduce()函数接收的的参数和map()类似,一个函数f,一个list,但行为和map()不同,reduce()传入的参数f必须接受2个参数,
第一次调用是把list的前两个元素传递给f,第二次调用时,就是把前两个list元素的计算结果当成第一个参数,list的第三个元素当成第二个参数,传入f进行操作,以此类推,并最终返回结果;
from functools import reduce #在python3里面不是内置,需要导 def f(x,y): return x+y print(reduce(f,[1,2,3,4,5])) #15
注解:
1,计算a=f(1,2)的值为3
2,计算b=f(a,3)的值为6
3,计算c=f(b,4)的值为10
4,计算d=f(c,5)的值为15
filter()函数
filter()函数是python内置的另一个有用的高阶函数,filter()函数接收一个函数f和一个list,这个函数f的作用是对每个元素进行判断,返回true或false,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件的元素组成的list;例
a = [1,2,3,4,5] def f(x): return x % 2 == 1 print(filter(f, a)) #<filter object at 0x00C6BD70> print(list(filter(f, a))) #[1,3,5]
返回的是迭代对象,需要用list转换成列表
注解:
1.llist元素以此传入到函数f
2.f判断每个元素是否符合条件,把符合条件的留下,不符合条件的舍弃
3.把最终符合条件的元素组成一个新的列表
sorted()函数
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
sorted 语法:
sorted(iterable, key=None, reverse=False)
参数说明:
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。 可以是变量,可以是函数或者lambda
- reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
- 多级排序,使用operator.itemgetter例如:sorted(list1, key=itemgetter(0,1)) 先用第0个,再用第一个排序
返回重新排序的列表。
以下实例展示了 sorted 的使用方法:
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a) # 保留原列表
>>> a [5, 7, 6, 3, 4, 1, 2]
>>> b [1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
匿名函数
忘了哪里说的尽量少用
ython 使用 lambda 来创建匿名函数。
- lambda只是一个表达式,函数体比def简单很多。
- lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
以上实例输出结果:
相加后的值为 : 30 相加后的值为 : 40
lambda多重调用:和偏函数对比
x = lambda x:(lambda y : x/y) print(x(1)(1)) #1.0 print(x(2)(1)) #2.0
函数面试题
1、默认参数
默认参数在程序开始时候,装载完毕,如果是可变参数,内部引用的时候会不再开辟新的空间,用的是func.__deflaut__的值,,但如果不是可变参数,每次变化都是新的空间,如None
def f(arg, li =[]): li.append(arg) return li v1 = f(1) #用的是默认参数【】的空间 print(v1) v2 = f(2,[]) #这是【】是新的空间 print(v2) v3= f(3) print(v3) #用的是默认参数【】的空间,尽量默认参数不要用可变列表 print(v1) #参数变化 [1] [2] [1, 3] [1, 3]
![](https://images.cnblogs.com/cnblogs_com/zhouguanglu/1345279/o_zhifubaoshouqian.png)
支付宝
您的资助是我最大的动力!
金额随意,欢迎来赏!
微信
![](https://images.cnblogs.com/cnblogs_com/zhouguanglu/1345279/o_weixinshouqian.png)
![](https://images.cnblogs.com/cnblogs_com/zhouguanglu/1345279/o_jiahaoyou.jpg)