0517Python基础-内置函数

Posted dzh0394

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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)

自己试

 

 

相关内置函数(2)

*** reversed:将一个序列翻转,并返回此翻转序列的迭代器。

l1 = [11, 22, 33, 44, 77, 66]

l_obj = reversed(l1)

# print(l_obj)

for i in l_obj:

    print(i)

 

 

slice:构造一个切片对象,用于列表的切片。

l1 = [11, 22, 33, 44, 77, 66]

l2 = [111, 222, 333, 444, 777, 666]

# print(l1[1::2])

rule = slice(1, len(l2), 2)

print(l2[rule])

 

字符串相关(9)

 

str:将数据转化成字符串。

 

format:与具体数据相关,用于计算各种小数,精算等。

print(format(‘test‘, ‘<20‘))  # 左对齐

print(format(‘test‘, ‘>20‘))  # 右对齐

print(format(‘test‘, ‘^20‘))  # 居中

 

*** bytes:str---> bytes

s1 = ‘alex‘

# b1 = s1.encode(‘utf-8‘)

b2 = bytes(s1,encoding=‘utf-8‘)

# print(b1)

print(b2)

 

bytearray

ret = bytearray(‘alex‘, encoding=‘utf-8‘)  # 类比:[97,103,....]

print(id(ret))

print(ret)  # bytearray(b‘alex‘)

print(ret[0])

ret[0] = 65

print(ret)

print(id(ret))

 

分字节去转换成str

b1 = bytes(‘你好‘,encoding=‘utf-8‘)

print(b1)

ret = memoryview(b1)

# print(len(ret))

# print(ret)

print(bytes(ret[:3]).decode(‘utf-8‘))

print(bytes(ret[3:]).decode(‘utf-8‘))

 

ord:输入字符找该字符编码的位置

print(ord(‘a‘))

print(ord(‘中‘))  # unicode

chr:输入位置数字找出其对应的字符

print(chr(65))

print(chr(20013)) # unicode

ascii:是ascii码中的返回该值,不是就返回/u...

print(ascii(‘a‘))

print(ascii(1))

print(ascii(‘中‘))

 

*** repr:返回一个对象的string形式(原形毕露)。

 

msg = ‘小数%f‘ %(1.234)

print(msg)

msg = ‘姓名:%r‘ % ( ‘alex‘)

print(msg)

 

print(repr(‘{"name":"alex"}‘))

print(‘{"name":"alex"}‘)

数据集合(3)

dict:创建一个字典。

set:创建一个集合。

frozenset:返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

 

dic = dict({‘name‘: ‘alex‘})

print(dic)

set1 = set((‘alex‘,‘wusir‘))

print(set1)

相关内置函数(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

以上是关于0517Python基础-内置函数的主要内容,如果未能解决你的问题,请参考以下文章

python基础---内置函数

python基础之内置函数与匿名函数

Python 3基础教程28-内置函数

python基础-内置函数

Python之路--Python基础4--内置函数

第六篇:python基础_6 内置函数与常用模块