Python004

一、 map函数：对每个元素进行操作并返回

li = [1,2,3,4,5]        # 可迭代对象

for i in map(lambda x:x+1,li):
    print(i)            # 依次输出2,3,4,5,6

li_map = map(lambda x:x+1,li)
print(li_map)           # 直接使用map返回内存地址，迭代器
print(list(li_map))     # [2, 3, 4, 5, 6]

二、 filter函数：过滤掉不合适的元素并返回

li = [1,2,3,4,5]        　 # 可迭代对象

for i in filter(lambda x:x-1,li):   # li的每一个元素放进函数进行操作，返回True的元素输出
    print(i)            　 # 依次输出2,3,4,5

li_filter = filter(lambda x:x-1<3,li)
print(li_filter)           # 返回内存地址，迭代器
print(list(li_filter))     # [2, 3, 4, 5]

三、 reduce函数：对参数序列中元素进行累计合并操作

from functools import reduce

li = [1,2,3,4,5]        　 # 可迭代对象

li_reduce = reduce(lambda x,y:x+y,li,3) # 3是初始值
print(li_reduce)           # 15

li_reduce = reduce(lambda x,y:x*y,li)
print(li_reduce)           # 120

四、其他内置函数：

 

    - abs()             # 取绝对值
    - all(iterable)     # 取出每个元素判断布尔值，只要有一个False，返回False，如果可迭代对象为空，返回True
    - any()             # 取出每个元素判断布尔值，只要有一个True，返回True
    - bin()             # 十进制转化为二进制
    - bool()
    - bytes(arg，encoding='utf8')   # 转换为字节类型
    - chr()             # 把ASCII码转化为对应的符号
    - ord()             # 把符号转化为对应的ASCII码
    - dir()             # 返回对象里的方法
    - divmod()          # 返回一个元祖(商，余数)，地板除
    - hash()            # 转换为哈希，可哈希即可变数据类型，哈希出来的数是固定长度，且不可逆推
    - hex()             # 十进制转十六进制
    - oct()             # 十进制转八进制
    - id()              # 内存地址
    - globals()         # 返回一个字典，包含的是当前脚本文件所有的全局变量名和值，判断变量是否存在
    - locals()
    - zip()
    - max(iterable,key=func)
    - min()
    - pow(a,b,c)        # a**b%c
    - repr()            # 打印
    - ascii()　　　　　　 # 同repr()
　　　　例：
　　　　　　a = [1,2,3,4,5]
　　　　　　b = ascii(a)
　　　　　　print(b)            # [1, 2, 3, 4, 5]
　　　　　　print(type(b))      # <class 'str'>

　　　　　　c = repr(a)
　　　　　　print(c)            # [1, 2, 3, 4, 5]
　　　　　　print(type(c))      # <class 'str'>

    - reversed()
    - round(a,b)        # 保留小数的位数，a是小数，b是有效数字
    - s1 = slice(3,5,2) # 定义切片参数，l[s1]调用，s1.start，s1.stop，s1.step
    - sorted(iterable,key=func)
　　　　特别地：
　　　　　　dict1 = {'c':1,'a':3,'b':2}
　　　　　　a = sorted(dict1.items())       # 按key排序
　　　　　　print(a)            # [('a', 3), ('b', 2), ('c', 1)]

　　　　　　print(dict1.items())            # dict_items([('c', 1), ('a', 3), ('b', 2)])
　　　　　　b = sorted(dict1.items(),key=lambda x:x[1])     # 按value排序，x[1]取[('c', 1), ('a', 3), ('b', 2)]里每一个元祖里的第二个值
　　　　　　print(b)            # [('c', 1), ('b', 2), ('a', 3)]
　　　　
    - vars()            # 没参数时等同于locals()，有参数等同于object.__dict__，返回一个对象所有的属性名
    - __import__('module名')
    - bytearray() # 转化为字节b形式，可修改
    - callable()        # 判断是否可调用
    - compile()和exec() # 类似eval()
    - complex()         # 复数
    - format()
    - issubclass()      # 判断是否一个子类
    - memoryview()
    - zip()             # 把两个列表每个元素返回成一个个元祖的两个元素

 

五、 文件操作
    f = open('file_name'，encoding='utf-8')      # 文件句柄：内存对象
    f.readlines()：生成一个列表，每一行是列表的每一个元素，每一句默认带一个换行符，可用strip()去掉

    大文件循环：
    for line in f:
    print(line)

　文件操作方法：
        f.read(50)：读出50个字符
        f.tell()：返回当前指针坐标
        f.seek(0)：返回最前方
        f.encoding：编码格式
        f.fileno()：返回内存地址编号
        f.name：文件名字
        f.flush()：强制刷新
        f.closed：判断文件是否关闭
        f.truncate(10)：不带参数是清空，带参数时保留参数前面的内容

f = open('aa.txt','r+')    # 一定要用r+模式
f.truncate(10)
f.close()

    w：生成一个新的空文件，往里写内容
    a:   在文件后追加
    r+：从头开始覆盖字符数

f = open('a.txt','w')
data = f.write('1234\n5678\n9011\n1213')
f.close()

g = open('a.txt','r+')      # 以r+的方式写入
data2 = g.write('abcdefg')  # 在光标后面写入，默认在文件头部写入，覆盖原文相同字符数
g.close()

    rb： 读取二进制，文本内容可以以二进制编码读取，内容是字节
    wb：写入二进制。f.write(string.encode())

f = open('aa.txt','wb')     　# 以二进制方式写入
data_f = f.write(bytes('1234\n5678\n9011\n1213\nhello\n你好',encoding='utf8'))  # 需要规定以什么编码格式写入，默认utf8
f.close()

g = open('aa.txt','rb')     　# 以二进制方式读取
data_g = g.read()
print(data_g)     # b'1234\n5678\n9011\n1213\nhello\n\xe4\xbd\xa0\xe5\xa5\xbd'
print('---------------')
print(data_g.decode('utf8'))  # 按utf8格式解码二进制内容，正常输出
g.close()

 

六、 文件修改

　　没有直接修改文件的方式

 

with open('文件1',encoding='utf-8') as f,\
        open('文件2','w',encoding='utf-8') as d:
    for line in f:
        if '挟带' in line:
            line = line.replace('挟带','携带')
        d.write(line)

 

 

 

七、 字符编码与转码

    Python3默认是utf-8编码，字符串是Unicode编码格式

import sys,chardet

print(sys.getdefaultencoding())     # 系统默认编码utf8

s = '你好'
s_to_GBK = s.encode('gbk')          # 以gbk格式编码成字节类型，2个字节代表一个汉字，输出：b'\xc4\xe3\xba\xc3'
s_to_UTF8 = s.encode('utf-8')       # 以utf8格式编码成字节类型，3个字节代表一个汉字，输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'
s_to_nothing = s.encode()           # 默认是utf8

print(s_to_GBK)
print(s_to_UTF8)
print(s_to_nothing)
print(chardet.detect(s_to_GBK))     # 查看字符串的编码格式
print(chardet.detect(s_to_UTF8))

八、 函数与函数式编程
    面向对象——类——class
    面向过程——过程——def：没有return
    函数式编程——函数——def：有return

    代码重用，保持一致性，可扩展性

    多个返回值是一个元祖
    形参，实参，位置参数，关键字参数，默认参数    参数组*args传值方式：接收N个位置参数，转换成元祖形式
        1. test（1,2,3,4,5）
        2. test(*list)
    
    参数组**kwargs传值方式：接收N个关键字参数，转换成字典形式
        1. test(name='alex'，age=8，sex='F')
        2. test(**{'name':'alex'，'age'：8}

九、 局部变量
    字符串，整数等不可改变的数据类型不能改，列表，字典，集合，类等可以改

十、 递归
    1. 必须有明确的结束条件
    2. 每次进入更深一层递归时，问题规模相比上一层应有所减少
    3. 递归效率不高，层次过多会导致栈溢出（stack）

十一、 高阶函数
    一个函数可以接收另一个函数作为参数



十二、 进度条

import sys,time

# 低级版
for i in range(50):
    sys.stdout.write('#')   # 标准输出，默认不换行
    sys.stdout.flush()      # 强制刷新，如果不加这行，会等结束才返回结果
    time.sleep(0.2)

# 高级版
for i in range(101):
    sys.stdout.write('\r')      # 覆盖已打印的上一条
    sys.stdout.write("%s%% |%s" % (int(i % 101), int(i % 101) * '#'))
    sys.stdout.flush()
    time.sleep(0.1)