【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格式化形式

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:8888print('{name},{sex},{age}'.format(age=32,sex='male',name='zhangk'))    #zhangk,male,32

元素访问

print("{0[0]}.{0[1]}".format(('baidu','com')))  #baidu.com　

填充对齐

1. ^、<、>分别是居中、左对齐、右对齐

精度设置

    # 填充与对齐
    # 填充常跟对齐一起使用
    # ^、<、>分别是居中、左对齐、右对齐，后面带宽度
    # :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
    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 threeprint('{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 threeclass AssignValue(object):    def __init__(self, value):        self.value = valuemy_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()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

abs()    #绝对值all()    #如果全是真或者假，返回true，否则返回false     0,"",false 为假，其他为真any()    #一真为真，全假为假ascii()  #返回对应的ascii， 类似于repr()  和chr差不多，和ord相反，\64会变成4bin()    #oct()  hex()  接受一个10进制数字，不可以是字符串，转为相对应的进制bool     #返回相对应的bool值，None，0，“”，{}，【】，（）为falsebytes()  #把字符串转为相对应的字节，第一个是要转化的字符串，第一个参数是按什么编码，是不可变序列，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和上一篇的formatfrozenset()  #转换为不可变的集合globals()  # 返回一个字典，包括所有的全局变量与它的值所组成的键值对locals()  # 返回一个字典，包括所有的局部变量与它的值所组成的键值对vars() #返回当前模块中的所有变量hash()    # 传入一个对象，返回相对应的hash值id()    #返回内存地址，可用于查看两个变量是否指向相同一块内存地址input()   #提示用户输入，接受字符串类型isinstance()   issubclass()   #如名字iter()    #转为迭代器next()    #迭代器的下一个项目，和iter互用map()    #详见本文的mapmemoryview()  #查看内存对象,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://www.cnblogs.com/zhouguanglu/p/10118953.html