今日主要内容

推导式
生成器表达式
lambda匿名函数
内置函数介绍

一、推导式

（一）列表推导式

先来看一段代码

建立一个空列表，向空列表中添加元素

lst = list()

for i in range(5):

	lst.append(i)

print(lst)

运行结果：

[0, 1, 2, 3, 4]

利用列表推导式，效果一样

lst = [i for i in range(5)]

print(lst)

运行结果：

[0, 1, 2, 3, 4]

循环模式：
- 格式：[元素 for 元素 in 可迭代对象]
- 执行流程：每次for循环将元素添加到列表中
```
lst = [i for i in range(5)]

print(lst)

运行结果：

[0, 1, 2, 3, 4]
```
筛选模式

筛选模式：
- 格式：[元素 for 变量 in 可迭代对象 if 条件]
- 执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到列表中
```
lst = [i for i in range(5) if i > 2]

print(lst)

运行结果：

[3, 4]
```

（二）字典推导式

同理，先来看一段代码

建立一个空字典，向字典中添加键值对

dic = dict()

for i in range(1, 5):

	dic[f"k{i}"] = i

print(dic)

运行结果：

{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

使用字典推导式，效果一样

dic = {f"k{i}": i for i in range(1, 5)}

print(dic)

运行结果：

{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

循环模式：
- 格式：{键值对 for 元素 in 可迭代对象}
- 执行流程：执行for循环利用元素组成键值对添加到字典中
```
dic = {f"k{i}": i for i in range(1, 5)}

print(dic)

运行结果：

{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
```
筛选模式：
- 格式：{键值对 for 元素 in 可迭代对象 if 条件}
- 执行流程：执行for循环并判断元素是否符合条件，利用符合条件的元素组成键值对添加到字典中
```
dic = {f"k{i}": i for i in range(1, 5) if i > 2}

print(dic)

运行结果：

{'k3': 3, 'k4': 4}
```

（三）集合推导式

与列表一样，这里就不再举例了

循环模式：
- 格式：{元素 for 元素 in 可迭代对象}
- 执行流程：每次for循环将元素添加到集合中
```
st = {i for i in range(5)}

print(st)

运行结果：

{0, 1, 2, 3, 4}
```
筛选模式：
- 格式：{元素 for 变量 in 可迭代对象 if 条件}`
- 执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到集合中
```
lst = {i for i in range(5) if i > 2}

print(st)

运行结果：

{3, 4}
```

（四）推导式应用

来看几个推导式的应用例题

求字符串s = "zxdhnbhnb"中"h"的索引

s = "zxdhnbhnb"

lst = [i for i in range(len(s)) if s[i] == "h"]

print(lst)

运行结果：

[3, 6]

将下列列表中带两个"e"的元素添加到新列表

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],

         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

lst = [name for i in names for name in i if name.count("e") == 2]

print(lst)

运行结果：

['Jefferson', 'Wesley', 'Steven', 'Jennifer']

二、生成器表达式

（一）回顾：通过函数实现生成器

回顾一下通过函数实现生成器

将函数return变成yield就变成了生成器

def func():

	yield 1

	yield 2

	yield 3

g = func()

print(next(g))

print(next(g))

print(next(g))

运行结果：

1 2 3

（二）生成器表达式

通过表达式实现生成器

将列表推导式的方括号[]变成圆括号()，就成了生成器表达式

lst = [i for i in range(5)]

print(type(lst))

g = (i for i in range(5))

print(type(g))

运行结果：

<class 'list'>

<class 'generator'>

转换成通过函数实现的生成器（二者等价）

# g = (i for i in range(5))

def func():    # 二者等价

	for i in range(5):

		yield i

g= func()

print(next(g))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

运行结果：

0 1 2 3 4

生成器表达式结构：
- 普通模式：
  - 格式：(元素 for 元素 in 可迭代对象)
  - 运行机制：惰性机制，不取值不运行，每次取值得到一个结果
```
g = (i for i in range(5))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

运行结果：

0 1 2 3 4
```
- 筛选模式：
  - 格式：(元素 for 元素 in 可迭代对象 if 条件)
  - 运行机制：惰性机制，不取值不运行，每次取值得到一个满足判断条件的结果
```
g = (i for i in range(5) if i > 2)

print(next(g))

print(next(g))

运行结果：

3 4
```

生成器的取值方式补充：

之前提到过的最正宗的next(生成器)

g = (i for i in range(5))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

运行结果：

0 1 2 3 4

通过for循环取值

g = (i for i in range(5))

for el in g:

	print(el)

运行结果：

0 1 2 3 4

通过list()、tuple()、set()取值

g = (i for i in range(5))

print(list(g))

print(tuple(g))

print(set(g))

运行结果：

[0, 1, 2, 3, 4]

(0, 1, 2, 3, 4)

{0, 1, 2, 3, 4}

真正理解生成器的惰性机制，来看一道例题：

def add(a, b):

    return a + b

def test():

    for r_i in range(4):

        yield r_i

g = test()

for n in [2, 10]:

    g = (add(n, i) for i in g)

print(list(g))

运行结果：

[20,21,22,23]

解析：生成器只有在取值的时候才会去运行，上述例题只有最后'print(list(g))'取值。

"""

g = test()

for n in [2, 10]:

    g = (add(n, i) for i in g)

"""

所以上面的for循环可以写成如下代码：

"""

n = 10

g = (add(n, i) for i in (add(n, i) for i in test()))

"""

最终代入得到的列表为：[20, 21, 22, 23]

三、lambda匿名函数

（一）匿名函数定义

python中为了解决一些简单的需求可以使用一句话定义一个函数，这就是lambda匿名函数

lambda语法结构：

函数名 = lambda 形参:返回值

# def func(x, y):

# 	 return x + y

# print(func(1, 2))

func = lambda x, y: x+y  # 两个函数等价

print(func(1, 2))

运行结果：

3

注意事项：

形参：可以接受多个所有类型参数（位置、动态位置、默认值、动态关键字）

func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs

print(func(3, 4,c=666,name='zxd'))

# 只返回kwargs

运行结果：

{'name': 'zxd'}

返回值：只能返回一个数据（任意数据类型），必须写

func = lambda x:(x[0],x[2])

print(func('zxdnb'))

运行结果：

('z', 'd')

返回值也可以是三元表达式

func = lambda x,y: x if x > y else y

print(func(3,100))

运行结果：

100

（二）结合匿名函数的列表推导式

例一：

列表推导式：

g = [lambda :i+1 for i in range(3)]

print([em() for em in g])

运行结果：

[3, 3, 3]

转换为普通代码

g = list()

for i in range(3):

	def func():

		return i + 1

	g.append(func)

new_g = list()

for em in g:

	new_g.append(em())

print(new_g)

运行结果：

[3, 3, 3]

例二：

列表推导式：

g = [lambda i:i+1 for i in range(3)]

print([em(3) for em in g])

运行结果：

[4, 4, 4]

转换为普通代码

g = list()

for i in range(3):

	def func(i):

		return i + 1

	g.append(func)

new_g = list()

for em in g:

	new_g.append(em(3))

print(new_g)

运行结果：

[4, 4, 4]

（三）结合匿名函数的生成器表达式

例一：

生成器表达式：

g = (lambda i:i+1 for i in range(3))

print([em(3) for em in g])

运行结果：

[4, 4, 4]

转换为函数实现的生成器：

def g():

    for i in range(3):

        def func(i):

            return i + 1

        yield func

new_g = list()

for em in g():

    new_g.append(em(3))

print(new_g)

运行结果：

[4, 4, 4]

例二：

生成器表达式：

g = (lambda :i+1 for i in range(3))

print([em() for em in g])

运行结果：

[1, 2, 3]

转换为函数实现的生成器：

def g():

    for i in range(3):

        def func():

            return i + 1

        yield func

new_g = list()

for em in g():

    new_g.append(em())

print(new_g)

运行结果：

[1, 2, 3]

例三：

生成器表达式

g = (lambda x:x*i for i in range(3))

for j in [2,10]:

    g1 = (em(3) for em in g)

print([e+j for e in g1])

运行结果：

[10, 13, 16]

转换为普通代码

def g():

    for i in range(3):

        def func(x):

            return x * i

        yield func

for j in [2, 10]:

    def g1():

        for em in g():

            yield em(3)

new_g = list()

for e in g1():

	new_g.append(e + j)

print(new_g)

运行结果：

[10, 13, 16]

四、内置函数

查看解释器内置常量和内置函数的方法
- dir(__builtins__)

Python3.6.8的内置函数（共72个）

abs	all	any	ascii	bin	bool
bytearray	bytes	callable	chr	classmethod	compile
complex	copyright	credits	delattr	dict	dir
divmod	enumerate	eval	exec	exit	filter
float	format	frozenset	getattr	globals	hasattr
hash	help	hex	id	input	int
isinstance	issubclass	iter	len	license	list
locals	map	max	memoryview	min	next
object	oct	open	ord	pow	print
property	quit	range	repr	reversed	round
set	setattr	slice	sorted	staticmethod	str
sum	super	tuple	type	vars	zip

（一）基础函数（了解）

all()	any()	bytes()	callable()
chr()	ord()	complex()	divmid()
eval()	exec()	frozenset()	help()
globals()	locals()	hash()	id()
iter()	next()	bin()	oct()
int()	hex()	pow()	repr()
round()	bool()

all()
- 函数定义：all(*args, **kwargs)
- 函数说明：填入参数为可迭代对象，如果可迭代对象中每一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True
```
print(all([1, 2, 3, 4, 5]))

print(all([0, 1, 2, 3, 4]))

print(all([]))

运行结果：

True

False

True
```
any()
- 函数定义：any(*args, **kwargs)
- 函数说明：填入参数为可迭代对象，如果可迭代对象中只要有一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True
```
print(any([0, "", 1, False]))

print(any([0, "", [], False]))

print(any([]))

运行结果：

True

False

False
```

bytes()

函数定义：bytes(value=b'', encoding=None, errors='strict')
函数说明：将填入对象转换为字节形式，需要指定编码方式

print("张旭东".encode("utf-8"))

print(bytes("张旭东", encoding="utf-8"))

运行结果：

b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c'

b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c'

callable()
- 函数定义：callable(i_e_, some_kind_of_function)
- 函数说明：判断对象是否可以调用（类也是可调用的，类的实例可调用__call__()方法）
```
def func():

	print("hello world")

print(callable(func))

运行结果：

True
```
chr()
- 函数定义：chr(*args, **kwargs)
- 函数说明：返回Unicode对应的字符串
```
print(chr(65))

运行结果：

A
```
ord()
- 函数定义：ord(*args, **kwargs)
- 函数说明：返回一个字符串对应的Unicode编码值
```
print(ord("A"))

运行结果：

65
```
complex()
- 函数定义：complex(real, imag=None)
- 函数说明：返回一个数的复数形式
```
print(complex(20))

运行结果：

(20+0j)
```
divmid()
- 函数定义：divmod(x, y)
- 函数说明：返回元组(x // y, x % y)
```
print(divmod(10, 3))

运行结果：

(3, 1)
```
eval()（不推荐使用）
- 函数定义：eval(*args, **kwargs)
- 函数说明：可以计算给定的参数，参数只能是简单表达式
```
print(eval("5 + 3"))

运行结果：

8
```
exec()（不推荐使用）
- 函数定义：exec(*args, **kwargs)
- 函数说明：可以计算给定的参数，参数可以是代码块
```
exec("for i in range(10):print(i)")

运行结果：

0

1

2

3

4
```
frozenset()
- 函数定义：frozenset(obj)
- 函数说明：将对象转换为不可变集合
```
print(frozenset((1,2,3)))

运行结果：

frozenset({1, 2, 3})
```

help()

函数定义：help(args)
函数说明：查看帮助

help(list.append)

运行结果：

Help on method_descriptor:

append(...)

    L.append(object) -> None -- append object to end

globals()

函数定义：globals(*args, **kwargs)
函数说明：返回包含当前作用域的全局变量的字典

a = 5

b = 10

def func():

    print("hello world")

print(globals())

运行结果：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000221ED9D69E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python_S26/day12/exercise.py', '__cached__': None, 'a': 5, 'b': 10, 'func': <function func at 0x00000221ED8D1EA0>}

locals()
- 函数定义：locals(*args, **kwargs)
- 函数说明：返回一个包含当前作用域的局部变量的字典
```
a = 5

def func():

    b = 10

    print(locals())

func()

运行结果：

{'b': 10}
```
hash()
- 函数定义：hash(*args, **kwargs)
- 函数说明：返回对象的哈希值
```
print(hash("zxd"))

运行结果：

5236597812272808709
```
id()
- 函数定义：id(*args, **kwargs)
- 函数说明：返回对象的id，在CPython中返回的是对象的内存地址
```
print(id(10))

运行结果：

1864728976
```

iter()

函数定义：iter(iterable, sentinel=None)
函数说明：传入可迭代对象，获取迭代器

lst = [1, 2, 3, 4, 5]

t = iter(lst)

print(t)

运行结果：

<list_iterator object at 0x00000181FB2CA9B0>

next()

函数定义：next(iterator, default=None)
函数说明：返回迭代器的下一项，若提供了默认值，并且迭代器已耗尽，则返回它而不是引发StopIteration

t = iter([1, 2, 3, 4, 5])

print(next(t, None))

print(next(t, None))

print(next(t, None))

print(next(t, None))

print(next(t, None))

print(next(t, None))

运行结果：

1

2

3

4

5

None

bin()
- 函数定义：bin(*args, **kwargs)
- 函数说明：返回整数的二进制形式
```
print(bin(10))

运行结果：

0b1010
```
oct()
- 函数定义：oct(*args, **kwargs)
- 函数说明：返回整数的八进制形式
```
print(oct(10))

运行结果：

0o12
```
int()
- 函数定义：int(x, base=10)
- 函数说明：返回对应进制的十进制，需填入对应进制数字符串形式，并填入进制数
```
print(int("0b1010", 2))

print(int("0o12", 8))

运行结果：

10

10
```
hex()
- 函数定义：hex(*args, **kwargs)
- 函数说明：返回整数的十六进制形式
```
print(hex(20))

运行结果：

0x14
```
pow()
- 函数定义：pow(*args, **kwargs)
- 函数说明：填入两个参数时，求x的y次幂；填入三个参数时，求x的y次幂在与z取余
```
print(pow(2, 4))

print(pow(2, 4, 3))

运行结果：

16

1
```
repr()
- 函数定义：repr(obj)
- 函数说明：返回规范字符串的表现形式
```
s = "zxd"

print(repr(s))

运行结果：

'zxd'
```
round()
- 函数定义：round(number, ndigits=None)
- 函数说明：将数字四舍五入为十进制整数
```
print(round(3.5))

运行结果：

4
```

（二）常用函数（会用）

abs() format() enumerate() open()

range() print() input() len()

list() dict() str() set()

tuple() float() reversed sum()

dir() type() zip() bool()

abs()	format()	enumerate()	open()
range()	print()	input()	len()
list()	dict()	str()	set()
tuple()	float()	reversed	sum()
dir()	type()	zip()	bool()

abs()
- 函数定义：abs(*args, **kwargs)
- 函数说明：返回参数的绝对值
```
print(abs(-1))

运行结果：

1
```

format()

函数定义：format(*args, **kwargs)
函数说明：返回格式化后的字符串

s = "你好"

print(format(s, ">20"))  # 右对齐20位，多余的部分用空格补齐

print(format(s, "<20"))  # 左对齐20位，多余的部分用空格补齐

print(format(s, "^20"))  # 居中共20位，多余的部分用空格补齐

运行结果：

                  你好

你好

         你好

s = 18

print(format(s, "08b"))  # 共八位，转换为二进制

print(format(s, "08o"))  # 共八位，转换为八进制

print(format(s, "08x"))  # 共八位，转换为十六进制

print(format(s, "08d"))  # 共八位，转换为十进制

运行结果：

00010010

00000022

00000012

00000018

enumerate()

函数定义：enumerate(iterable, start=0)
函数说明：枚举，遍历可迭代对象并给定对应遍历的数字，以元组的形式返回，第二个参数可指定遍历数字的起始值

lst = [1, 2, 3, 4, 5]

for i in enumerate(lst):

    print(i)

运行结果：

(0, 1)

(1, 2)

(2, 3)

(3, 4)

(4, 5)

lst = [1, 2, 3, 4, 5]

for i in enumerate(lst, 10):  # 指定起始值

    print(i)

运行结果：

(10, 1)

(11, 2)

(12, 3)

(13, 4)

(14, 5)

open()
- 函数定义：open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)
- 函数说明：打开一个文件，指定文件路径file 、文件打开模式mode、文件编码encoding，返回一个文件句柄用于操作文件，其余参数暂时忽略
```
f = open("text.txt", mode="r", encoding="utf-8")

f.read()

f.close()
```
range()
- 函数定义：range(start, stop[, step])
- 函数说明：返回一个对象，该对象可以从开始一个一个返回一个递增的整数序列一直到结束，如果有步长参数，则按照步长返回
```
for i in range(5):

	print(i)

运行结果：

0

1

2

3

4
```
print()
- 函数定义：print(self, *args, sep=' ', end='\n', file=None)
- 函数说明：在控制台打印参数，可填入参数sep来替代元素之间的逗号，可填入参数end来控制结尾的换行，可填入参数file将打印的内容写入文件
```
print("zxd", "znb", sep="-", end="!")

运行结果：

zxd-znb!
```
input()
- 函数定义：input(*args, **kwargs)
- 函数说明：将输入内容转换为字符串，可填出参数用来提示用户
```
name = input("请输入姓名:")

print(name)

运行结果：

zxd
```
len()
- 函数定义：len(*args, **kwargs)
- 函数说明：返回容器中的项数
```
lst = [1, 2, 3, 4, 5]

print(len(lst))

运行结果：

5
```
list()
- 函数定义：
  - list()
  - list(iterable)
- 函数说明：
  - 默认创建空列表
  - 将可迭代对象转换为列表
```
print(list())

print(list(range(5)))

运行结果：

[]

[0, 1, 2, 3, 4]
```
dict()
- 函数定义：
  - dict()
  - dict(mapping)
  - dict(iterable)
  - dict(**kwargs)
- 函数说明：
  - 默认创建空字典
  - 可填入映射创建字典
  - 可填入二元组列表创建字典
  - 可填入关键字参数常见列表
```
print(dict())

print(dict({"k1": 1, "k2": 2}))

print(dict([("k1", 1), ("k2", 2)]))

print(dict(k1=1, k2=2))

运行结果：

{}

{'k1': 1, 'k2': 2}

{'k1': 1, 'k2': 2}

{'k1': 1, 'k2': 2}
```
str()
- 函数定义：
  - str()
  - str(value='', encoding=None, errors='strict')
- 函数说明：
  - 默认创建空字符串
  - 可将参数转换为字符串类型，若填入参数为字节类型，需指定编码方式
```
print(repr(str(123)))

print(str(b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c',encoding="utf-8"))

运行结果：

张旭东

'123'
```
set()
- 函数定义：
  - set()
  - set(iterable)
- 函数说明：
  - 默认创建空集合
  - 将可迭代对象转换为集合（自动去重）
```
print(set())

print(set([1,2,3,4,5]))

运行结果：

set()

{1, 2, 3, 4, 5}
```
tuple()
- 函数定义：
  - tuple()
  - tuple(iterable)
- 函数说明：
  - 默认创建空元组
  - 将可迭代对象转换为元组
```
print(tuple())

print(tuple([1, 2, 3, 4, 5]))

运行结果：

()

(1, 2, 3, 4, 5)
```
float()
- 函数定义：float(x)
- 函数说明：将参数转换为浮点型
```
print(float(123))

运行结果：

123.0
```

reversed

函数定义：reversed(sequence)
函数说明：将传入的可迭代对象反向迭代，返回一个迭代器

lst = [1, 2, 3, 4, 5]

print(reversed(lst))

print(list(reversed(lst)))

运行结果：

<list_reverseiterator object at 0x000002043A55A9B0>

[5, 4, 3, 2, 1]

sum()
- 函数定义：sum(*args, **kwargs)
- 函数说明：将填入的参数求和，填入的参数必须是可迭代对象
```
print(sum([1, 2, 3, 4, 5]))

运行结果：

15
```

dir()

函数定义：dir([object])
函数说明：查看对象的方法

print(dir(list))

运行结果：

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

type()
- 函数定义：type(object_or_name, bases, dict)
- 函数说明：查看对象的类型（其实type()既是函数，又是元类(创造类的类)，可以通过type()创建一个类）
```
print(type(list()))

运行结果：

<class 'list'>
```
zip()
- 函数定义：zip(iter1 [,iter2 [...]])
- 函数说明：拉链函数，返回一个迭代器，将所有可迭代对象的元素按照位置打包成元组，直到耗尽项数最少的可迭代对象
```
lst1 = [1, 2, 3]

lst2 = [1, 2, 3, 4, 5]

print(zip(lst1, lst2))

print(list(zip(lst1, lst2)))

运行结果：

<zip object at 0x00000204D6E621C8>

[(1, 1), (2, 2), (3, 3)]
```
bool()
- 函数定义：bool(x)
- 函数说明：将传入的参数转换成布尔值，若不填入参数返回False
```
print(bool())

print(bool(123))

运行结果：

False

True
```

（三）高阶函数（熟练）

高阶函数全部需要结合规则函数，利用lambda匿名函数构造规则函数
filter() 筛选过滤

map() 映射

sorted() 排序

max() 求最大值

min() 求最小值

reduce() 累计算

filter()	筛选过滤
map()	映射
sorted()	排序
max()	求最大值
min()	求最小值
reduce()	累计算

filter()

筛选过滤功能
函数定义：filter(function or None, iterable)
函数说明：返回一个迭代器，该迭代器返回满足规格函数的可迭代对象中的元素，若函数为None，返回可迭代对象中为True的元素

# 规则函数为None，返回可迭代对象中True的元素

print(list(filter(None, [0, 1, 2, 3])))

运行结果：

[1, 2, 3]

# 返回满足规则函数可迭代对象中的元素

print(list(filter(lambda x: x > 1, [0, 1, 2, 3])))

运行结果：

[2, 3]

map()
- 映射功能
- 函数定义：map(func, *iterables)
- 函数说明：创建一个迭代器，它使用可迭代对象中的每个元素当作参数执行规则函数，直到最短的可迭代对象耗尽为止
```
print(list(map(lambda x: x ** 2, [1, 2, 3])))

运行结果：

[1, 4, 9]
```
sorted()
- 排序功能
- 函数定义：sorted(*args, **kwargs)
- 函数说明：返回一个列表，按照可迭代对象中的元素升序排列，还可以指定key=规则函数按照规则函数来排序，还可以指定reverse=True来降序排列
- 与列表中list.sort()的区别：
  - list.sort()改变的是原有列表
  - sorted()建立的新列表
```
lst = [4, 2, 3, 7, 1]

print(sorted(lst))

print(lst)  # 不改变原来列表

运行结果：

[1, 2, 3, 4, 7]

[4, 2, 3, 7, 1]
```
```
dic = {"k1": 3, "k2": 13, "k3": 1}

print(sorted(dic, key=lambda x: dic[x], reverse=True))

运行结果：

['k2', 'k1', 'k3']
```
max()
- 返回最大值
- 函数定义：
  - max(iterable, *[, default=obj, key=func])
  - max(arg1, arg2, *args, *[, key=func])
- 函数说明：
  - 使用单个可迭代对象，返回其中的最大值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数
```
lst1 = [1, 2, 3, 4, 5, -6]

lst2 = []

print(max(lst1))

print(max(lst1, key=abs))  # 制定规则参数，返回绝对值最大的元素

print(max(lst2, default=1)) # 当lst2为空的时候返回1

运行结果：

5

-6

1
```
  - 使用两个或更多的参数，返回其中最大的参数
```
a = 5

b = 10

print(max(a, b))

运行结果：

10
```
min()
- 返回最小值
- 函数定义：
  - min(iterable, *[, default=obj, key=func])
  - min(arg1, arg2, *args, *[, key=func])
- 函数说明：
  - 使用单个可迭代对象，返回其中的最小值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数
```
lst1 = [1, -2, 3, -4, 5, -6]

lst2 = []

print(min(lst1))

print(min(lst1, key=abs))

print(min(lst2, default=1))

运行结果：

-6

1

1
```
  - 使用两个或更多的参数，返回其中最小的参数
```
a = 5

b = 10

print(min(a, b))

运行结果：

5
```
reduce()
- 累计算
- 函数定义：reduce(function, sequence, initial=None)
- 函数说明：按照规则函数将序列从左到右累计算，若有initial参数则作为序列的第一项，并在序列为空时作为默认值
```
from functools import reduce

print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5]))

print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5], 5))

print(reduce(lambda x, y: x * y, [], 5))

运行结果：

120

600

5
```

（四）面向对象函数

classmethod() delattr() getattr()

hasattr() issubclass() isinstance()

object() property() setattr()

staticmethod() super()
后续补充...

classmethod()	delattr()	getattr()
hasattr()	issubclass()	isinstance()
object()	property()	setattr()
staticmethod()	super()

Python基础（十二）的更多相关文章

Python基础(十二) 类私有成员和保护成员
python中的protected和private python中用 _var :变量名前一个下划线来定义,此变量为保护成员protected,只有类及其子类可以访问.此变量不能通过from XXX ...
python 基础(十二) 图片简单处理
pillow 图片处理模块安装 pip install pillow pip是安装第三方模块的工具缩放图片实例 from PIL import Image path = r'C:\Users\x ...
python基础十二之生成器进阶
生成器表达式 (满足条件的元素或其相关的操作 for 元素 in 可迭代对象 if 条件) g = (i for i in range(10)) for i in g: print(i) egg_li ...
Bootstrap <基础十二>下拉菜单（Dropdowns）
Bootstrap 下拉菜单.下拉菜单是可切换的,是以列表格式显示链接的上下文菜单.这可以通过与下拉菜单(Dropdown) JavaScript 插件的互动来实现. 如需使用下列菜单,只需要在 ...
Python 基础语法(二)
Python 基础语法(二) --------------------------------------------接 Python 基础语法(一) ------------------------ ...
初学 Python（十二）——高阶函数
初学 Python(十二)--高阶函数初学 Python,主要整理一些学习到的知识点,这次是高阶函数. #-*- coding:utf-8 -*- ''''' 话说高阶函数: 能用函数作为参数的函数 ...
Java基础十二--多态是成员的特点
Java基础十二--多态是成员的特点一.特点 1,成员变量. 编译和运行都参考等号的左边. 覆盖只发生在函数上,和变量没关系. Fu f = new Zi();System.out.println( ...
Python进阶(十二)----re模块
Python进阶(十二)----re模块一丶re模块 re模块是python将正则表达式封装之后的一个模块.正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引擎执行. #正则表达式: ...
python基础知识(二)
python基础知识(二) 字符串格式化格式: % 类型 ---- > ' %类型 ' %(数据) %s 字符串 print(' %s is boy'%('tom')) ----> ...
Python基础学习二
Python基础学习二 1.编码 utf-8编码:自动将英文保存为1个字符,中文3个字符.ASCll编码被囊括在内. unicode:将所有字符保存为2给字符,容纳了世界上所有的编码. 2.字符串内置 ...

随机推荐

Java基础之Collection与Collections浅析
Java基础之Collection与Collections浅析一.前言: 位于Java.util包下的Collection与Collections都是Java中重要的工具类,它们都是Java集合框架 ...
iOS仿写下厨房
把之前简书的博客搬到博客园了,还是放在一个地方看着舒服. 先看一下做的效果,是不是还不错?(可以看一下早餐那块的轮播,上面盖着一个都是点点的图片,但是它不是和轮播一起滚动的,是盖在轮播上面的,需要在那 ...
PHP文件基础操作
文件的基本操作:(更多) fopen():文件打开 $file = fopen("file.txt","r+"); fopen()函数的参数是目标文件的路径和文 ...
DB2 根据id查表
SELECT * FROM SYSCAT.TABLES WHERE TBSPACEID = 2 AND TABLEID = 50 SELECT * FROM SYSCAT.COLUMNS WHERE ...
python内建Exception类型
1.Exception类型及分层结构如下: BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Excep ...
CodeForces - 445B - DZY Loves Chemistry-转化问题
传送门:http://codeforces.com/problemset/problem/445/B 参考:https://blog.csdn.net/littlewhite520/article/d ...
模板汇总——splay
#define lch(x) tr[x].son[0] #define rch(x) tr[x].son[1] ; , root; struct Node{ ], pre, sz; void init ...
Codeforces 374 C Inna and Dima (DFS)
Inna and Dima 题意:从图上的任意一个D点按着DIMADIMA的顺序走,问一共可以经过多少个DIMA,如果经过0个DIMA就输出“Pool DIma!“,如果可以有无数多个DIMA就输出” ...
MySQL连接方式小结
1. 连接方式 1.1 方式1 /usr/local/mysql5./bin/mysql -p 此方法默认采用root@localhost用户登录, 1.2 方式2 /usr/local/my ...
zabbix监控PHP脚本
scripts]# cat php_fpm_status.sh #!/bin/bash ############################################ #$name: ngi ...

Python基础（十二）