1、内置函数

内置函数：
1.2其他相关

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

      eval：执行字符串类型的代码，并返回最终结果。

            print(eval('4+4'))  #8

            n = 90
            print(eval('n + 9'))  #99

            eval('print(666)')   #666

      exec：执行字符串内部的代码。

print(exec('4 + 4'))
ret = '''
name = input('请输入您的姓名：').strip()
if name == 'gelong':
    print(666)
'''
exec(ret)

 

1.2.2 输入输出相关 input，print

name = input('请%s输入名字：' % 'gelong')
print(name)

print(1,2,3, sep='#')
print(1,2,3, end=' ')
print(4,5,6)

f1 = open('aaa', encoding='utf-8', mode='a')
print('666', file = f1, end = '')
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(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 func():
    print(666)
age = 16
print(callable('name'))
print(callable(age))
print(callable(func))
False
False
True

1.2.7查看内置属性

** dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

print(dir(str))
print(dir(int))

 

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))

结果：
<list_iterator object at 0x00000297348C9358>
1
2

 

1.4.1数字相关（14）

　　

　　数据类型（4）：

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

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

print(int('123')) #123
print(int(1.234)) # 1
print(int(1.768)) # 1

 

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

complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。

i = 3.1415
print(float(i),type(i))   #3.1415 <class 'float'>
s = '1.234'
print(float(s))   #1.234
print(int(1.234))    #1
print(float(100))   #100.0

 

bin：将十进制转换成二进制并返回。
print(bin(100))
oct：将十进制转化成八进制字符串并返回。
print(oct(10))
hex：将十进制转化成十六进制字符串并返回。
print(hex(13))
print(hex(18))


数学运算（7）：

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

print(abs(-5))    #5
print(abs(-3.14))  #3.14

 

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

print(divmod(9,4))    #(2, 1)
print(divmod(6,3))     # (2, 0)
print(divmod(3,6))      #(0, 3)
print(divmod(5,0))      #error

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

print(round(1.234, 2))  #1.23
print(round(1.234))   # 1

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

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

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

print(sum((1,2,3,5)))    #11
print(sum([1,2,3,5], 100))   #111

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

print(min([1, 5, -7, 6, 0, -20]))     #-20
print(min([1, 5, -7, 6, 0, -20],key = abs))    #0

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

print(max([1,5,7,8,-3]))  #8
print(max([1,5,7,8,-3,-10], key=abs))    #-10

1.4.2和数据结构相关（24）

　　列表和元祖（2）

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

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

tu = (1,2,3)
print(list(tu))   #[1, 2, 3]
print(list({'name':'gelong','sex':'man'}))   #['name', 'sex']

l = [1,2,3]
print(tuple(l))  #(1, 2, 3)
print(tuple({'name':'gelong', 'sex':'man'}))   #('name', 'sex')

相关内置函数（2）

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

l1 = [11, 22, 33, 44, 77, 66]
l_obj = reversed(l1)   #迭代器
for i in l_obj:
    print(i,end=' ')   #66 77 44 33 22 11

slice：构造一个切片对象，用于列表的切片。

l1 = [11, 22, 33, 44, 77, 66]
l2 = [111, 222, 333, 444, 777, 666]
rule = slice(1, len(l2), 2)
print(l2[rule])

字符串相关（9）

str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。

print(format('gelong','<20'))    # 左对齐
print(format('gelong','>20'))     #右对齐
print(format('gelong','^20'))     #居中
gelong
              gelong
       gelong

*** bytes：str---> bytes

s1 = 'alex'
b1 = bytes(s1, encoding='utf-8')    #b'alex'
b2 = s1.encode('utf-8')             #b'alex'
print(b2)

bytearray

ret = bytearray('alex', encoding='utf-8')  # 类比：[97,103,....]
print(id(ret))    # 1818346099520
print(ret)        # bytearray(b'alex')
print(ret[0])     # 97
ret[0] = 65
print(ret)        # bytearray(b'Alex')
print(id(ret))    # 1818346099520

分字节去转换成str

b1 = bytes('你好',encoding='utf-8')
print(b1)                       ## b'\xe4\xbd\xa0\xe5\xa5\xbd'
ret = memoryview(b1)
print(len(ret))                 ## 6
print(ret)              # <memory at 0x00000169AD2B5F48>
print(bytes(ret[:3]).decode('utf-8'))       # 你
print(bytes(ret[3:]).decode('utf-8'))       # 好

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

print(ord('a'))   #97
print(ord('中'))  #20017   # unicode

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

print(chr(65))   #　A
print(chr(20013)) # 中   # unicode

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

print(ascii('a'))   #'a'
print(ascii(1))　　　　#1
print(ascii('中'))　　#'\u4e2d'

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

msg = '小数%f' %(1.234)
print(msg)
msg = '姓名：%r' % ( 'alex')
print(msg)
print("{'name':'gelong'}")          #{'name':'gelong'}
print(repr("{'name':'gelong'}"))    #"{'name':'gelong'}"

 

数据集合（3）

　　　　dict：创建一个字典。

　　　　set：创建一个集合。

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

dic = dict({'name':'gelong'})
print(dic)
set1 = set(('alex','wusir'))
print(set1)

　相关内置函数（8）

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

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

print(sorted([1,6,9,4,5,-10]))   #[-10, 1, 4, 5, 6, 9]
print(sorted([1,6,9,4,5,-10],reverse = True))   #[9, 6, 5, 4, 1, -10]
print(sorted([1,6,9,4,5,-10],key = abs))  #[1, 4, 5, 6, 9, -10]

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

def func1(x):
    return x[1]
L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]
print(sorted(L, key=func1))   #[('a', 1), ('c', 2), ('b', 3), ('d', 4)]

 

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

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

 

***zip 拉链方法 返回的是一个迭代器，按照最短的留取,

l = [1,2,3]
tu = ('name','sex','age')
l2 = ['gelong','man',18]
obj = zip(l,tu,l2)   #迭代器
for i in obj:
    print(i,type(i))
结果：
(1, 'name', 'gelong')   元祖
(2, 'sex', 'man')
(3, 'age', 18)

 

***map: 循环模式

def func2(x):
    return x**2
obj = map(func2,[1,2,3,4])    #迭代器
for i in obj:
    print(i)
结果：
1
4
9
16
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)
结果：
3
5
7
9

 

***filter  筛选模式

def func3(x):
    return x % 2 == 0
ret = filter(func3, [1,2,3,4,5,6,7,8])
for i in ret:
    print(i)
结果：
2
4
6
8
print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))

 

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

def func(x,y):
    return x + y
ret = lambda x,y:x+y
print(ret(2,3))

ret = filter(lambda x:x %2 ==0, [1,2,3,4,5,6,7])
for i in ret:
    print(i)
结果：
2
4
6

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

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
l = sorted(students,key=lambda x:x[2])
print(l)    #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 1