0517Python基础-内置函数

1、昨日内容回顾

可迭代对象：内部含有__iter__方法的

迭代器：内部含有__iter__方法并且还含有__next__方法的

可迭代对象.__iter__()

判断可迭代对象，迭代器。

'__iter__' in dir(可迭代对象)

'__next__' in dir(可迭代对象)

isinstance(obj, Iterator)

isinstance(obj, Iterable)

迭代器：

节省内存。

惰性机制。

单向不可逆。

生成器：

生成器本质是迭代器，他是用python代码写的。

生成器函数。 yield

__next__ send()

生成器推导式。

[变量(加工后的变量) for 变量 in 可迭代对象] 遍历模式。

[变量(加工后的变量) for 变量 in 可迭代对象 if 条件] 筛选模式。

() 生成器推导式

2、内置函数

重点记忆

用域相关

**globals() 已字典的形式返回全局变量

**locals() 已字典的形式返回当前位置的局部变量

q = 666

def wrapper(argv):

a = 3

print(locals()) # 1 {a:3,argv:2}

def inner(argv1):

b = 4

c = 5

print(locals()) # 2 {b:4 c:5,argv1:6}

inner(6)

wrapper(2)

print(globals()) # 3

其他相关

1.2.1 字符串类型代码的执行 eval，exec，complie

***eval 去除字符串的引号，返回对应内部的值

s = '{"a":1,"b":3}'

dic = eval(s)

print(dic,type(dic))

print(eval('2 + 2'))

print(eval('print(666)'))

*** exec 执行字符串内部的代码

print(exec('1 + 1'))

ret = '''

name = input('请输入名字：').strip()

if name == 'alex':

print(666)

'''

exec(ret)

compile: pass

1.2.2 输入输出相关 input，print

name = input('请%s输入名字:' % 'alex')

print(name)

print(1, 2, 3,sep='*') # 设定打印元素的连接方式

print('alex', end='') # end控制的是换行

print('老男孩')

***f1 = open('log', encoding='utf-8', mode='w')

print('666', file=f1) # file 操作文件句柄，写入文件。

f1.close()

1.2.3内存相关 hash id

*hash 将不可变的数据通过hash算法转化成hash值

print(hash('name'))

print(hash('age'))

print(hash((1, 2, 3,)))

print(hash(1))

print(hash(100))

*print(id('name'))

1.2.3文件操作相关

open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

1.2.4模块相关__import__　

　　__import__：函数用于动态加载类和函数。

1.2.5帮助

*help：函数用于查看函数或模块用途的详细说明。

print(help(str))

1.2.6调用相关

*** callable：函数用于检查一个对象是否是可调用的。

如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

def func1():

print(666)

age = 16

print(callable('name'))

print(callable(age))

print(callable(func1))

1.2.7查看内置属性

** dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；

带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。

如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

print(dir(str))

1.3 迭代器生成器相关

*** range iter() next()

print(len(range(100)))

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

l_obj = l.__iter__()

l_obj = iter(l)

print(l_obj)

print(l_obj.__next__())

print(next(l_obj))

1.4.1数字相关（14）

　　数据类型（4）：

　　bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。

　　int：函数用于将一个字符串或数字转换为整型。

print(int('123'))

print(int(1.234))

print(int(1.768))

float：函数用于将整数和字符串转换成浮点数。

　　　complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。

如果第一个参数为字符串，则不需要指定第二个参数。。

i = 3.1415

print(i, type(i))

s = '1.234'

print(int(1.234))

print(float(s))

print(float(100))

bin：将十进制转换成二进制并返回。

print(bin(100))

oct：将十进制转化成八进制字符串并返回。

print(oct(10))

hex：将十进制转化成十六进制字符串并返回。

print(hex(13))

print(hex(18))

数学运算（7）：

**abs：函数返回数字的绝对值。

print(abs(-5))

***divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(7, 3))

**round：保留浮点数的小数位数，默认保留整数。

print(round(1.234,2))

*pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(pow(2, 3)) # 2的三次幂

print(pow(2, 3, 3)) # 2的三次幂对3取余数

***sum：对可迭代对象进行求和计算（可设置初始值）。

print(sum([1, 2, 3, 4]))

print(sum([1, 2, 3, 4], 100))

*** min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。

print(min([1, 3, 5, 7, -4]))

print(min([1, 3, 5, 7, -4], key=abs))

*** max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(max([1, 3, 5, 7, -4]))

print(max([1, 3, 5, 7, -9], key=abs))

1.4.2和数据结构相关（24）

列表和元祖（2）

list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。

tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

tu = (1, 2, 3)

print(list(tu))

l1 = list((1, 2, 3))

l1 = list({'name':'alex','age':1000})

print(l1)

自己试

相关内置函数（8）

*** len:返回一个对象中元素的个数。

*** sorted：对所有可迭代的对象进行排序操作。返回的是列表

print(sorted([1, 2, 3, 4, 5, -6]))

print(sorted([1, 2, 3, 4, 5, -6], key=abs))

L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]

print(sorted(L))

def func1(x):

return x[1]

L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]

print(sorted(L, key=func1))

*all：可迭代对象中，全都是True才是True

*any：可迭代对象中，有一个True 就是True

print(all([1, 'alex', True, (1,2,3)]))

print(all([0, 'alex', True, (1,2,3)]))

print(any([0, '', False, (1,2,3)]))

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

***zip 拉链方法返回的是一个迭代器

l1 = [1, 2, 3, 4]

tu1 = ('老男孩', 'alex', 'wusir')

l2 = ['*', '**', '***', "****"]

obj = zip(l1,tu1,l2)

for i in obj:

print(i)

***map: 循环模式

def func2(x):

return x**2

obj = map(func2, [1, 2, 3, 4])

for i in obj:

print(i)

print((i**2 for i in [1, 2, 3, 4]))

def func2(x, y):

return x + y

obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5))

for i in obj1:

print(i)

***filter 筛选模式

def func(x):

return x % 2 == 0

ret = filter(func,[1, 2, 3, 4, 5, 6, 7])

print(ret)

for i in ret:

print(i)

print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))

***lambda 匿名函数一句话函数

def func(x): return x % 2 == 0

def func1(x, y):

return x + y

ret = lambda x, y: x+y

print(ret(2,3))

def func1(x, y):

return x if x > y else y

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

print(ret(2,3))

def func(x):

return x % 2 == 0

ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7])

print(ret)

for i in ret:

print(i)

[1, 2, 3, 4, 5, 6, 7] [1,4,9,16...] map lambda

ret2 = map(lambda x:x**2,[1, 2, 3, 4, 5, 6, 7])

for i in ret2:

print(i)

def func1(x):

return x[1]

L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]

print(sorted(L, key=func1))

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

l = sorted(students, key= lambda x: x[2],reverse=True)

print(l)

sorted max min map filter

posted on 2018-05-17 20:50 kindle86 阅读(115) 评论(0) 编辑收藏举报

刷新页面返回顶部

kindle86

0517Python基础-内置函数

导航

公告