内置函数

一、
1、callable() : 可否调用

def func():
    pass
print(callable(a))       # False
print(callable(print))   # True
print(callable(func))    # True

2、三个查看方法
    Ctrl  +  左键单击 ：pycharm
    help：包含所有方法名 以及 它的使用方法 --- 不知道用法
    dir：只包含方法名 --- 想查看某方法是否在这个数据类型中
    print(dir(int))    ==   print(dir(5))    # 出来int的所有方法
3、
    想输出(黄字蓝底)：愿你们这场爱能避免麻烦
    print('\033[0;33;44m愿你们这场爱能避免麻烦\033[0m')
    PS:注意使用'；'分号分隔开的
4、函数的内置方法们

①基础数据类型相关(38)

数据结构相关(24):

序列(13):

列表和元组2：list和tuple

相关内置函数2：reversed，slice

字符串9：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr

数据集合(3):

字典1：dict

集合2：set，frozenset

相关内置函数(8)：len，sorted，enumerate，all，any，zip，filter，map

数字相关(14)：

数字—数据类型相关：**bool，**int，**float，complex

数字—进制转换相关：bin，oct，hex

数字—数学运算：**min，**max，**sum，*abs，*divmod，*round，*pow

②迭代器/生成器相关(3)
③作用域相关(2)

locals()

globals()

④其他(12)

字符串类型代码的执行(3): *evel   *exec  compile

输入输出(2)：  **input     **print    

内存相关(2)：  **hash     id

文件操作相关(1):   **open   

模块相关(1):    _import_

帮助(1):    help

调用相关(1):    callable

查看内置属性(1)：   *dir

⑤反射相关(4)：
⑥面向对象相关(9)

5、round:   print(round(3.14159,2))     # 3.14
6、pow:     print(pow(2,3,2))    2的3次方 取余 2    # 0
7、sum:     print(sum([1,2,3,4,5,6),-2)      # 前面加起来  减 2
  print(sum(range(101)))         # sum接收可迭代对象     5050
8、min:      print(min([],default = 0))    若没有 default 则报错     # 0
  print(min([-9,2,23,59],key = abs))  # 输出绝对值最小的数    # 2
9、max:        和min类似
10、divmid:   print(divmod(17,10))    #  (1,7)   商1,余 7
11、input 和 print
①s = input('提示:')
②

print(1,2,sep=',')           # print('%s,%s'%(1,2))
print(1,2,3,4,5,sep='*')  # sep是指定多个要打印的内容之间的分隔符 ，默认空格

f = open('文件','w',encoding='utf-8')
print('abc\n',file=f)
print(2)

二、进度条：

import time
for i in range(2,101,2):      # 源代码是从0 开始(加入颜色了之后不知道怎么0%的时候颜色会覆盖一下)
    time.sleep(0.3)              #  睡眠0.3，不然直接显示，看不到效果
    i2 = i // 2                        # 打印多少个'*'    8/2 = 4
    if i == 100:                    # 等于100打印完成，回车换行
        p_str = '\r%s%% : \033[0;31;41m%s\033[0m\n'% (i,'*'*i2)
    else:                             # 不等于100直接在后面打印*
        p_str = '\r%s%% : \033[0;31;41m%s\033[0m'%(i,'*'*i2)
    print(p_str,end='',flush=True)           # 没颜色的话是逐步打印 *

# print(self, *args, sep=' ', end='\n',flush=False)    # 源码中end 默认换行;flush缓存，为True的话拿到一条打印一条

三、不懂也不想懂的：难受

print(id(1))                                      # 1777295584
print(id(2))                                      # 1777295616
print(hash('sajghfj;eyrwodnvjnz,.jifupwk'))  #算法  # 1058870219305678952
print(hash(125342))                                      # 125342
print(hash((1,2,3,4)))                                      # 485696759010151909

数据的存储和查找
模块：hashlib
{'k':'v'}
[1,2,3,4,5,6,]

hash([1,2,3,4,5,6,])
hash 判断一个数据类型是否可以hash
在一个程序执行的过程中，对同一个值hash的结果总是不变
多次执行，对同一个值的hash结果可能改变

四、
1、迭代器强转换的三种方法：

print(list(ret))

next

for循环

2、

li = [3,4,2,5,7,1,5]

ret = reversed(li)      这两个的区别：

print(ret)                    返回值不同：

print(list(ret))                    reversed:返回迭代器

                                        不改变原来的列表，生成一个新的序列迭代器

li.reverse()                         reverse：返回None

print(li)                               是在原本的列表的基础上修改的

3、

ret  =  bytes('花不再香'，encoding='utf-8')        ：将中文转换成bytes

print(ret.decode(encoding='utf-8'))                    ：将十六进制转换成中文  

修改的次数多，且字符串长的时候：

ret = bytearray('alex',encoding='utf-8')

print(id(ret))                    # ## 43715808

print(ret[0])                     # ## 97

ret[0] = 65

print(ret)                         # ## bytearrary(b'ALex')

print(id(ret))                    # ## 43715808 

ps: 对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearry的

4、print(ord('a'))       # ## 97   显示其ASCII码
       print(chr(97))       # ## a     显示ASCII码对应的字符
5、print(repr(1))        # ## 1     
       print(repr('1'))       # ## 1        
6、print('name: %r' %('金老板'))   # ## name: '金老板'
      print('name: %s' %('金老板'))   # ## name: 金老板
7、enumerate：

li = ['笔记本','phone','Apple']

for i in enumerate(li):               # ##(0,'笔记本')

print(i)                                # ##(1,'phone')         

                                                # ##(2,'Apple')   

for i,j in enumerate(li,1):           # ## 1  '笔记本'

print(i,j)                                # ## 2  'phone'         

                                                  # ## 3  'Apple '   
8、all   与  any  (注意括号们)

print(all([1,2,3,0]))           # ## False

print(all([1,None,2]))        # ## False

print(all([1,2,'']))                # ## False

print(all([1,2,3,4,5]))           # ## True

print(any([True,None,False]))   # ## True

print(any((False,None)))           # ## False

9、filter:(过滤)     就是一个可迭代对象，想要一个子女的内容集，是从可迭代对象中筛选出来的

①
def is_odd(x):
if x % 2 == 0:
return True
ret = filter(is_odd,[1,4,6,7,9,12,17)
print(list(ret))             # ## [4,6,12]

② 去掉所有空内容和字符串中的空格

def func(x):
return x and x.strip()
li = ['test',None,'','str','    ','end']
ret = filter(func,li)
print(list(ret))          # ## ['test', 'str', 'end']

10、map(映射):

ret = map(abs,[-1,-5,6,-9])

print(list(ret))       # ## [1,5,6,9]

9/10:filter 和 map

参数很相近：一个函数名 + 可迭代对象

返回值相近：返回可迭代对象

区别：

filter 做筛选，结果还是原来就在可迭代对象中的项

map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项

①有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理

def func(x):
    return x*x
ret = map(func,[1,2,3,4,5,6,7,8])
print(list(ret))                   # [1, 4, 9, 16, 25, 36, 49, 64]

11、sort 和 sorted

sort 是直接修改原列表的顺序，节省内存

sorted 是生成一个新列表，不改变原列表

key 的用法 666

print(sorted([-5,3,-4,2,-1],reverse=True))   # ##[3, 2, -1, -4, -5]

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

按长度排序：

list2 = ['sunv',(1,2),'a',[1,2,3]]

print(sorted(list2,key=len,reverse=True))   # ## ['sunv', [1, 2, 3], (1, 2), 'a']

12、拉链函数

print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))    # ##  [(0, 5, 'a'), (1, 6, 'b')]

五、lambda

1、要输出值最大键：

dic = {'k1':10,'k2':100,'k3':30}

# print(max(dic.values()))           # 100

# print(max(dic))                    # k3         # 不用 lambda 做不到

print(max(dic,key=lambda k:dic[k]))   # k2 

2、map、lambda

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

print(list(ret))

3、filter、lambda（找三位数）

ret = filter(lambda num:99<num<1000,[1,4,859,67,34])

print(list(ret))

4、面试一：

现有两个元组（('a')('b')）,（('c')('d')）

使用匿名函数生成列表[{'a':'c'},{'b':'d'}]

t1 = (('a'),('b'))

t2 = (('c'),('d'))

# print(dict(zip(t1,t2)))   # 自己想的(错的，没有用匿名函数)

①：

print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2)))) # [{'a':'c'}, {'b':'d'}]

②：

test = lambda t1,t2 : [{i,j} for i,j in zip(t1,t2)]

print(test(t1,t2))

③：print([{i,j} for i,j in zip(t1,t2)])

5、面试2，将列表推导式换成了，生成器表达式

def multipliers():
          return (lambda x:i*x for i in range(4))
print([m(2) for m in multipliers()])  # ## [0,2,4,6]