Python面试100讲的基础知识

约定不等于承诺〃 2023-07-03 10:49 51阅读 0赞

### 文章目录 ###

*  1 导入Python模块,指定别名 from,import,as
 *  2 设置搜索路径export,.pth,sys.path.append()
 *  3 字符串连接 有5种方式+,"""",',',format,join
 *  4 字符串与非字符串相连+,%,重定向
 *  5 类显示字符串\_\_str\_\_(self):
 *  6 进制表示和转换 bin,int,hex,oct
 *  7 字符串首字母大小写capitalize,upper,lower
 *  8 检测字符串是否为数字isdigit,isalnum,isspace
 *  9 字符串转化为整数,安全的
 *  10 字符串翻转 s1\[::-1\]
 *  11 格式化整数format(1234,'\*>10d')左对齐补\*
 *  12 字符串同时输出单双引号
 *  13 转义符失效保持
 *  14 print函数 sep="\*",end="\*"
 *  15 列表,元组,集合区别
 *  16 列表如何去重
 *  17 集合的api add,remove,\_\_contains\_\_
 *  18 集合中的运算 | ^ & union,intersection,difference
 *  19 列表连接 +,extend
 *  20 列表顺序随机打乱, random.shuffle(a)
 *  21 \*运算符 可变参数,以元组形式导入, \*\*字典
 *  22 合并列表和字典,\* \*\*
 *  23 快速调换字典中的key和value, set.items()
 *  24 0-100的列表
 *  25 两个列表或元组合并一个字典 dict(zip(a,b))
 *  26 元组 字典 列表 集合差异
 *  27 列表方法 排序sort(reverse=),sorted()
 *  28 列表对象如何排序 \_\_str\_\_(self): \_\_lt\_\_(self, other):
 *  29 删除,增加列表 pop del append
 *  30 使用lambda进行列表排序sorted(d, key = lambda x:x\['age'\])
 *  31 字典key的类型
 *  32 切片获取列表的部分元素gen = iter(range(10)) \# 产生器
 *  33 列表变成产生器
 *  34 字典与字符串中间的转换 json.dumps和loads
 *  35 字符串格式化方法:from string import Template
 *  36 fstring格式化 f"string"中f起到的作用
 *  37 字符串相关操作 len,max,\[::\]
 *  38 format 使用\{\}指定需要替换的数据
 *  39 字符串居中显示 '<\{:\#^30\}>'.format(s1)
 *  40 字符串列表连接 " \# ".join(a)
 *  41 正则表达式 match, search
 *  42 搜索手机号 限定11位re.search
 *  43 搜索区号 分机号 电话号
 *  44 查找所有的email re.findall(prefix + 'com' + prefix + 'net', s, re.I)
 *  45 浮点数浮点数正则表达
 *  46 提取url搜索re.findall
 *  47 去读xml数据,字典
 *  48 字典转换为xml
 *  49 json文件映射为对象product = json.loads(json\_str, object\_hook=Product)
 *  50 SQlite 数据库表
 *  51 read, readline,readlines
 *  52 json 序列化日期类型
 *  53 读文件,统计字符,得到最多
 *  54 装饰器的作用
 *  55 判断调用的是函数还是方法MethodType, FunctionType
 *  56 声明静态方法 @staticmethod@classmethod
 *  57 元类
 *  58 对象属性处理hasattr, getattr, setattr
 *  59 lambda表达式
 *  60 复制深层对象 copy与deepcopy的区别
 *  61 生成器,二维列表变成一维列表
 *  62 递归生成器,多维转1维
 *  63 当前时间确定调用time.localtime(time.time())
 *  64 保留字
 *  65 数字类型
 *  66 空行
 *  67 map()内置函数 用于映射
 *  68 内置函数reduce()问题
 *  69 zip()函数的使用
 *  70 matplotlib画图

# 1 导入Python模块,指定别名 from,import,as #

import math
    from math import * # 导入所有成员
    import numpy as np # 指定别名为np

# 2 设置搜索路径export,.pth,sys.path.append() #

方式:  
1 设置Pythonpath环境变量  
临时环境变量 export,.pth,sys.path.append() PYTHONPATH=添加的路径  
win下 set PYTHONPATH=添加的路径

2 添加.pth文件
    在Python安装目录,随便新建文件,后缀.pth, 在里面写入绝对路径,然后就可以直接调用路径下的所有文件
    
    
    3 通过sys.path设置路径
    import sys
    sys.path.append(r"E:\admin\diskpart\201921050\12_python_lib\myfunction")
    
    4 使用pycharm,可以设置搜索路径

# import working 
    # # 这就是文件为working.py的函数, 
    # # 该文件路径保存在abc.pth中
    # print(working.hello())
    
    # import sys
    # sys.path.append(r"E:\admin\diskpart\201921050\12_python_lib\myfunction")
    # import myfunction 
    # # 该文件保存在"E:\admin\diskpart\201921050\12_python_lib\myfunction\myfunction.py")
    # myfunction.hello_world("按个")
    # print("hehh")

# 3 字符串连接 有5种方式+,"""",’,’,format,join #

''' 1 str1+str2 2 直接连接 str1str2 s="hello""world" 3 逗号连接 print("hello", "world") 4 格式化 s = '<%s><%s>'%(s1,s2) 5 join s = ' '.join([s1,s2]) # 连接列表里面的两个字符串,中间用' '连接 '''

'\n1 str1+str2\n2 直接连接 str1str2 s="hello""world"\n3 逗号连接 print("hello", "world") \n4 格式化\ns = \'<%s><%s>\'%(s1,s2)\n\n5 join\ns = \' \'.join([s1,s2]) # 连接列表里面的两个字符串,中间用\' \'连接\n'

# 4 字符串与非字符串相连+,%,重定向 #

n=23
    b = True
    v = 12.44
    s1 = "hello"
    s = s1 + str(n) + str(v) + str(b)
    print(s)
    
    # 格式化
    s = "<%s><%d><%.2f><%d>"%(s1,b,v,n)
    print(s)
    
    # 重定向
    from io import StringIO
    import sys
    old_stdout = sys.stdout
    result = StringIO()
    sys.stdout = result
    print(s1,True,n,v,sep="*")
    sys.stdout = old_stdout
    result_str = result.getvalue()
    print(result_str)

hello2312.44True
    <hello><1><12.44><23>
    hello*True*23*12.44

# 5 类显示字符串\_\_str\_\_(self): #

class HelloWorld:
        def __str__(self):
            return "this is a balla"
    h = HelloWorld()
    print(h)

this is a balla

# 6 进制表示和转换 bin,int,hex,oct #

# 不同表示
    n1 = 1234 # 十进制
    n2 = 0b1010 # 二进制
    n3 = 0o123 # 八进制
    n4 = 0xfa # 16进制
    print(n1,n2,n3, n4)
    
    # 转换
    print(bin(10)) # 十进制转2进制
    print(int(0b101), 2) # 各种进制转10进制,, 这里是2进制
    print(hex(23)) # 转16进制
    print(oct(23)) # 转八进制

1234 10 83 250
    0b1010
    5 2
    0x17
    0o27

# 7 字符串首字母大小写capitalize,upper,lower #

s1 = "hello world"
    print(s1.capitalize()) # 首字母大写
    
    s2 = s1[0:1]+s1[1:3].upper()+s1[3:] # 字符串小写变大写
    print(s2)
    
    s1 = "Hello"
    s3 = s1[0].lower() + s1[1:] # 变小写
    print(s3)
    
    # 每一个首字母都变大写
    s4 = "this is a beauitful cat !"
    new_str =' '.join([i.capitalize() for i in s4.split(" ")])
    print(new_str)

Hello world
    hELlo world
    hello
    This Is A Beauitful Cat !

# 8 检测字符串是否为数字isdigit,isalnum,isspace #

s1 = '12345'
    print("isdigit检测数字:",s1.isdigit())
    s2 = '12345a'
    print("12345a".isalnum()) #数字字母混合
    print(' '.isspace()) # 是否空白

isdigit检测数字: True
    True
    True

# 9 字符串转化为整数,安全的 #

try:
        print(int("123a"))
    except Exception as e:
        print(e)

invalid literal for int() with base 10: '123a'

# 10 字符串翻转 s1\[::-1\] #

# 考察分片问题
    
    # 1循环
    s1 = "abcde"
    for c in s1:
        s2 = c+s2
    print(s2)
    
    print(s1[0::2])  # 从0开始 步长为2
    print(s1[::1]) # 字符串本身
    print(s1[::-1]) # 字符串翻转

edcba12345a
    ace
    abcde
    edcba

# 11 格式化整数format(1234,’*>10d’)左对齐补* #

n = 1234
    print(format(1234,'0>10d')) # 左侧补0
    print(format(n,'0<10d'))  # 右侧补0
    
    # 格式化浮点数,保留后两位小数点
    f = 41.2569
    print(format(f, '0.2f')) # 不足补0
    
    # format函数
    # 设置格式化规则
    x2 = 12.1
    print(format(x2, "*>15.4f")) # 右对齐,补* 小数点后4位
    print(format(x2, "*<15.4f"))
    print(format(x2, "#^15.4f")) # 中对齐
    print(format(123456789, ',')) # 千位号分割
    print(format(123214.1242, ',.2f'))
    print(format(x2, "E"))
    print(format(x2, "0.2E"))

0000001234
    1234000000
    41.26
    ********12.1000
    12.1000********
    ####12.1000####
    123,456,789
    123,214.12
    1.210000E+01
    1.21E+01

# 12 字符串同时输出单双引号 #

print("'hk\' ahskg \asg")
    print('"hello" \'world\' ')

'hk' ahskg sg
    "hello"    'world'

# 13 转义符失效保持 #

print(r"let\'s go")  # r表示保留转义字符\
    print(r'hello\nworld')
    
    print("let\'s go'")
    print(repr("let\'s go'"))  # repr跟r是一样的
    
    print("保持多行 原格式输出")
    print(
    """-- hello world """)

let\'s go
    hello\nworld
    let's go'
    "let's go'"
    保持多行 原格式输出
    --
        hello
            world

# 14 print函数 sep="*",end="*" #

print("aaa","bbbb", sep="**") # 增加中间的分隔符
    
    # 不换行,首位相接
    print("hello", end="*")
    print("world")
    
    # 格式化
    print("长度是:%d,%s"%(256,"萨嘎"))

aaa**bbbb
    hello*world
    长度是:256,萨嘎

# 15 列表,元组,集合区别 #

# 去掉列表重复数据
    # 列表和结合转换
    # 集合和列表的区别
    
    #列表 list
    a = [1,2,3]
    print(type(a), a)
    
    #元组 tuple
    b = (1,2,3,4,5)
    print(type(b),b)
    
    # 集合 set
    c = { 1,2,3,4,5}
    print(type(c),c)
    d = { 1,2,2,3,4,2,5}
    print(c==d)
    ''' 区别: 集合没有重复的元素 集合中的元素与顺序无关 '''

<class 'list'> [1, 2, 3]
    <class 'tuple'> (1, 2, 3, 4, 5)
    <class 'set'> {1, 2, 3, 4, 5}
    True
    
    
    
    
    
    '\n区别:\n集合没有重复的元素\n集合中的元素与顺序无关\n'

# 16 列表如何去重 #

a = [1,2,2,3,5,3]
    a_res = list(set(a)) # 先转集合再转列表
    print(a_res)

[1, 2, 3, 5]

# 17 集合的api add,remove,**contains** #

a = { 3,2,1}
    
    # 添加
    a.add(123)
    print(a)
    a.add("asg")
    print(a)
    
    # 删除
    if a.__contains__("asg"):
        a.remove("asg")
        print("删除后:",a)
    else:
        print("不存在")

{123, 1, 2, 3}
    {1, 2, 3, 'asg', 123}
    删除后: {1, 2, 3, 123}

# 18 集合中的运算 | ^ & union,intersection,difference #

x1 = { 1,2,3}
    x2 = { 2,3,4,5}
    print(x1|x2) # 合并
    print(x1.union(x2))
    
    print(x1&x2) # 交集
    print(x1.intersection(x2))
    
    # x1中存在,x2不存在
    print(x1.difference(x2))
    
    # 排除x1, x2 
    print(x1^x2)

{1, 2, 3, 4, 5}
    {1, 2, 3, 4, 5}
    {2, 3}
    {2, 3}
    {1}
    {1, 4, 5}

# 19 列表连接 +,extend #

a = [1,2,3]
    b = [3,4,5]
    print(a+b)
    a.extend(b)
    print(a)
    
    ''' 差异 +不改变列表值, 但是extend改变a列表 + 必须两次同类型 extend 列表可以增加元组 list.extend(tuple) '''

[1, 2, 3, 3, 4, 5]
    [1, 2, 3, 3, 4, 5]
    
    
    
    
    
    '\n差异 +不改变列表值, 但是extend改变a列表\n+ 必须两次同类型\nextend 列表可以增加元组\nlist.extend(tuple)\n'

# 20 列表顺序随机打乱, random.shuffle(a) #

a = [1,2,3,4,5,6,7,9,10]
    import random
    from typing import*
    def random_list(a:List):
        for i in range(0,100):
            index1 = random.randint(0,len(a)-1)
            index2 = random.randint(0,len(a)-1)
            a[index1],a[index2] = a[index2],a[index1]
    random_list(a)
    print(a)
    
    # 直接调用API
    a = [1,2,3,4,5,6,7,9,10]
    random.shuffle(a)
    print(a)

[7, 6, 4, 1, 3, 10, 5, 9, 2]
    [10, 6, 4, 5, 2, 7, 3, 9, 1]

# 21 \*运算符 可变参数,以元组形式导入, \*\*字典 #

''' 作用 * 元组形式 '''
    def fun1(para1, *para2,x): # para2是可变参数, *号参数只能有一个,以元组形式导入
        print(para1,)
        print(para2) # 这是四个元组
        print(x)
        
    fun1(1,2,3,4,5, x=2)
    
    def fun2(para1, **para2): # para2是可变参数, ** 以字典形式导入
        print(para1,)
        print(para2) 
    fun2(1,a=2,b=3,c=4, x=2)

1
    (2, 3, 4, 5)
    2
    1
    {'a': 2, 'b': 3, 'c': 4, 'x': 2}

# 22 合并列表和字典,\* \*\* #

# 列表 
    a = [1,2,3]
    b = [4,5,6]
    print([*a, *b])
    
    c = { "a":1, "b":2}
    d = { "c":23, "d":90}
    print({ **c,**d})

[1, 2, 3, 4, 5, 6]
    {'a': 1, 'b': 2, 'c': 23, 'd': 90}

# 23 快速调换字典中的key和value, set.items() #

a = { "a":1, "b":2}
    b = { v:k for k,v in a.items()}
    print(b)
    print(b[1])

{1: 'a', 2: 'b'}
    a

# 24 0-100的列表 #

print([i for i in range(101)])

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

# 25 两个列表或元组合并一个字典 dict(zip(a,b)) #

# zip dict 
    a = ["a","b"]
    b = [1,2]
    #合并为字典
    print(dict(zip(a,b))) #先压缩,在字典
    
    fields = ('id', 'ame', 'age')
    records = [['01','bill',20], ['02','jia',23]]
    res = []
    for record in records:
        res.append(dict(zip(fields,record)))
    print(res)

{'a': 1, 'b': 2}
    [{'id': '01', 'ame': 'bill', 'age': 20}, {'id': '02', 'ame': 'jia', 'age': 23}]

# 26 元组 字典 列表 集合差异 #

# 1 语法差异 () {} [] {,}
    # 元组是只读的, 
    # 列表是可写的
    # 列表和元组的大小不同,列表分配内存块小, 
    # 但是元组使用大的内存块,占用内存小, 大量元素时建议使用元组

# 27 列表方法 排序sort(reverse=),sorted() #

a = [1,2,32,5,3]
    a.sort(reverse=True)  # 从小到大, 自身排序
    print(a)
    a = [1,2,32,5,3]
    b = sorted(a,reverse=False) # 新建排序, 默认是正序,False
    print(b)
    
    ''' 区别sort 属于列表方法 sorted属于独立函数 sort改变列表本身 sorted返回 '''

[32, 5, 3, 2, 1]
    [1, 2, 3, 5, 32]
    
    
    
    
    
    '\n区别sort 属于列表方法\nsorted属于独立函数\n\nsort改变列表本身\nsorted返回\n'

# 28 列表对象如何排序 **str**(self): **lt**(self, other): #

class Myclass:
        def __init__(self):
            self.value = 0
        def __str__(self):
            return "Myclass"
        def __lt__(self, other): #用于判断大小的特征
            return self.value < other.value
        
    my1 = Myclass()
    my1.value = 20
    
    my2 = Myclass()
    my2.value = 10
    
    my3 = Myclass()
    my3.value = 30
    
    print(my1)  # 测试def __str__(self):
    
    a = [my1, my2, my3]
    print(a)
    
    a.sort(reverse = False)
    print(a[0].value)

Myclass
    [<__main__.Myclass object at 0x000002F63C39A240>, <__main__.Myclass object at 0x000002F63C39A2E8>, <__main__.Myclass object at 0x000002F63C39A2B0>]
    10

# 列表对象如何排序
    class Myclass:
        def __init__(self):
            self.value = 0  
    my1 = Myclass()
    my1.value = 20
    
    my2 = Myclass()
    my2.value = 10
    
    my3 = Myclass()
    my3.value = 30
    
    
    a = [my1, my2, my3]
    print(a)
    
    import operator 
    
    a.sort(reverse = False, key=operator.attrgetter('value'))
    print(a[0].value)
    print(a[1].value)
    print(a[2].value)

[<__main__.Myclass object at 0x000002F63C39A208>, <__main__.Myclass object at 0x000002F63C39A438>, <__main__.Myclass object at 0x000002F63C39A400>]
    10
    20
    30

# 29 删除,增加列表 pop del append #

a = [4,2,5,6]
    print(a)
    del a[2]
    print(a)
    
    print(a.pop(1))
    print(a)

[4, 2, 5, 6]
    [4, 2, 6]
    2
    [4, 6]

# 30 使用lambda进行列表排序sorted(d, key = lambda x:x\[‘age’\]) #

d = [
        { 'nama':'zq', "age":23},
        { 'nama':'ji', "age":26},
        { 'nama':'zw', "age":18},
    ]
    print(d)
    print(sorted(d, key = lambda x:x['age'])) #lambda传入的参数是

[{'nama': 'zq', 'age': 23}, {'nama': 'ji', 'age': 26}, {'nama': 'zw', 'age': 18}]
    [{'nama': 'zw', 'age': 18}, {'nama': 'zq', 'age': 23}, {'nama': 'ji', 'age': 26}]

# 31 字典key的类型 #

# 列表和字典本身
    d = { }
    d['name'] = 'Biill'
    d[True] = False
    d[12.3] = 322
    d[(1,2,3)] = [3,4,5]
    
    class Person:
        pass
    p1 = Person()
    p2 = Person()
    
    d[p1] = "p1"
    d[p2] = 'p2'
    
    print(d)
    
    # 下面是错误的,因为key是不能变的,但是列表和字典是可变的
    # d[[1,2,3]] =3
    # d[{'a':3}] =4

{'name': 'Biill', True: False, 12.3: 322, (1, 2, 3): [3, 4, 5], <__main__.Person object at 0x000002F63C383588>: 'p1', <__main__.Person object at 0x000002F63C383198>: 'p2'}

# 32 切片获取列表的部分元素gen = iter(range(10)) \# 产生器 #

gen = iter(range(10)) # 产生器
    print("怀孕已经完成")
    print(type(gen))
    for i in gen:
        print(i)
    print("iteration孩子已经生产完毕,无法继续生产")    
    for i in gen:
        print(i)
    print("求放过,孩子已经生完了")
    # 切片获取列表的部分元素
    from itertools import islice
    gen = iter(range(10))
    print(type(gen))
    for i in islice(gen,2,6): # 方法islicc切割
        print(i)
    print("孩子已经通过大夫islice生产了2,3,4,5了, 而0,1被其杀死了,为了生产2,3,4,5")
    for i in gen:
        print(i)
    print("好了现在都生出来了,死了俩")

怀孕已经完成
    <class 'range_iterator'>
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    iteration孩子已经生产完毕,无法继续生产
    求放过,孩子已经生完了
    <class 'range_iterator'>
    2
    3
    4
    5
    孩子已经通过大夫islice生产了2,3,4,5了, 而0,1被其杀死了,为了生产2,3,4,5
    6
    7
    8
    9
    好了现在都生出来了,死了俩

# 33 列表变成产生器 #

a = [i for i in range(10)]
    print(a)
    for i in a:
        print(i)
        
    # 新建产生器
    # 将列表的形式变成元组的形式就能够变成了一个产生器,产生器只是怀孕还未生产
    b = (i for i in range(10)) # 有for 所以是一个产生器,但是没有for就是一个元组
    print(b)
    for i in b:
        print(i)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    <generator object <genexpr> at 0x000002F63C37F410>
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

# 34 字典与字符串中间的转换 json.dumps和loads #

# json
    import json
    d = { 'a':23,'b':33,'c':89}
    json_str = json.dumps(d) #带s的dump将字典转化为str形式
    print(json_str)
    print(type(json_str))
    
    # 将str的字典格式转化为dict
    d1 = json.loads(json_str)
    print(d1)
    print(type(d1))

{"a": 23, "b": 33, "c": 89}
    <class 'str'>
    {'a': 23, 'b': 33, 'c': 89}
    <class 'dict'>

# 35 字符串格式化方法:from string import Template #

# 多少种
    ''' %格式化 魔板字符串 字符串format方法 fstring 通过template对象封装, $ 放置一些占位符 通过substitute方法用实际值替换占位符 '''
    from string import Template
    template1 = Template("$d is a beautiful code, $s is easy function, 功能强大")
    print(template1.substitute(d = "python", s="zjq"))
    data = { }
    data['d'] = "zjjj"
    data["s"] = "askksk"
    print(template1.substitute(data))
    
    template2 = Template("$hello world")
    print(template2.substitute(hello = "abc"))
    template3 = Template("${h}ello world $$ ")
    print(template3.substitute(h = "abc"))

python is a beautiful code, zjq is easy function, 功能强大
    zjjj is a beautiful code, askksk is easy function, 功能强大
    abc world
    abcello world $

# 36 fstring格式化 f"string"中f起到的作用 #

# 直接使用变量
    name = "zjq"
    age = 20
    def hello():
        print("hello")
    s = f"my name is {name}, 我今年{age}岁, {hello()}"  # f表示有变量,或者函数
    print(s)

hello
    my name is zjq, 我今年20岁, None

# 37 字符串相关操作 len,max,\[::\] #

str1 = "hello world, my name is zjq!"
    print(str1[0:6])
    print(str1[::-1]) # 全部翻转
    print(str1[::2])
    print(2*str1) # 打印两遍
    
    print('b' in str1)
    print('w' not in str1)
    
    print(len(str1))
    print(max(str1))
    print("小",min(str1))

hello 
    !qjz si eman ym ,dlrow olleh
    hlowrd ynm szq
    hello world, my name is zjq!hello world, my name is zjq!
    False
    False
    28
    z
    小

# 38 format 使用\{\}指定需要替换的数据 #

s1 = "Today is {}, the temperature is {},"
    print(s1.format("saturday", 24))
    
    s1 = "Today is {day}, the temperature is {degree},"
    print(s1.format(day = "saturday",degree = 30))
    
    class Person:
        def __init__(self):
            self.age = 20
        def get_name():
            return "bill"
    s2 = "name is {name.age}"
    print(s2.format(name = Person()))

Today is saturday, the temperature is 24,
    Today is saturday, the temperature is 30,
    name is 20

# 39 字符串居中显示 ‘<\{:\#^30\}>’.format(s1) #

s1 = "saga"
    print("<"+s1.center(30) + ">")
    print("<"+s1.center(30,'#') + ">")
    
    print('<{:^30}>'.format(s1))
    print('<{:#^30}>'.format(s1))

<             saga             >
    <#############saga#############>
    <             saga             >
    <#############saga#############>

# 40 字符串列表连接 " \# ".join(a) #

s1 = "hello"
    s2 = "world"
    a  =  [s1,s2]
    print(" # ".join(a))

hello # world

# 41 正则表达式 match, search #

import re # 正则表达式
    print(re.match('hello', 'hello'))
    s1 = "Today is 2019-12-12"
    m = re.match(".*\d{4}-\d{2}-\d{2}",s1)
    if m is not None:
        print(m.group())

<_sre.SRE_Match object; span=(0, 5), match='hello'>
    Today is 2019-12-12

# match 用于匹配
    # search: 搜索
    import re
    m = re.match('.*python', 'i love python')
    print(m)
    m2 = re.search("python", "i love python")
    print(m2)

<_sre.SRE_Match object; span=(0, 13), match='i love python'>
    <_sre.SRE_Match object; span=(7, 13), match='python'>

# 42 搜索手机号 限定11位re.search #

m = re.search('1\d{10}', 'wode shouj is 13096908985')
    if m is not None:
        print(m.group())
        print(m.start())
        print(m.end())

13096908985
    14
    25

# 43 搜索区号 分机号 电话号 #

# 搜索区号 分机号 电话号
    # 区号 3位 电话号至少7位 分机号至少3位 024-2356897-231
    # 正则表达式的分组
    import re
    m = re.search('\d{3}-\d{7,}-\d{3,}',"我的公司座机号码是: 024-123456789-259")
    if m is not None:
        print(m.group())
        print(m.groups())
    # print(m.groups()[0])
    # print(m.groups()[1])
    # print(m.groups()[2])

024-123456789-259
    ()

# 44 查找所有的email re.findall(prefix + ‘com’ + prefix + ‘net’, s, re.I) #

import re
    s = 'wode emal地址是1234@qq.com,你的是3241@122.net'
    prefix = '[0-9a-zA-Z]+@[0-9a-zA-Z]+\.'
    res = re.findall(prefix + 'com' + prefix + 'net', s, re.I)# re.I表示忽略大小写
    print(res)

[]

# 45 浮点数浮点数正则表达 #

# 浮点数浮点数正则表达式 -?\d+(\.\d+)? 完整浮点数 # \d+任意多数字
    import re
    # 使用##替换浮点数
    res = re.subn("-?\d+(\.\d+)?", '##', 'PI is 3.141592654, e is 2.71828 -0.2+1.3=1.1')
    print(res) # ('PI is ##, e is ## ##+##=##', 5)
    print(res[0])
    
    # 动态替换
    def fun(matched):
        return "<" + matched.group() + ">"
    res = re.subn("-?\d+(\.\d+)?", fun, 'PI is 3.141592654, e is 2.71828 -0.2+1.3=1.1')
    print(res) # ('PI is <3.141592654>, e is <2.71828> <-0.2>+<1.3>=<1.1>', 5)
    print(res[0])
    
    print("动态替换")
    # 动态替换
    def fun(matched):
        return format(float(matched.group()),"0.2f")
    res = re.subn("-?\d+(\.\d+)?", fun, 'PI is 3.141592654, e is 2.71828 -0.2+1.3=1.1')
    print(res) # ('PI is 3.14, e is 2.72 -0.20+1.30=1.10', 5)
    print(res[0])

('PI is ##, e is ## ##+##=##', 5)
    PI is ##, e is ## ##+##=##
    ('PI is <3.141592654>, e is <2.71828> <-0.2>+<1.3>=<1.1>', 5)
    PI is <3.141592654>, e is <2.71828> <-0.2>+<1.3>=<1.1>
    动态替换
    ('PI is 3.14, e is 2.72 -0.20+1.30=1.10', 5)
    PI is 3.14, e is 2.72 -0.20+1.30=1.10

# 46 提取url搜索re.findall #

import re
    s = '<a href="https://baidu.com">饥渴</a> <a href="https://wr.com">计科</a> '
    
    res = re.findall('<a[^>]*href="([^>]*)">',s,re.I) #[^>]* 除了> ()表示group
    print(res)

['https://baidu.com', 'https://wr.com']

# 47 去读xml数据,字典 #

''' xml格式 '''
    # 去读xml文件,属性
    from xml.etree.ElementTree import parse
    doc = parse('files/products.xml')
    print(type(doc))
    for item in doc.iterfind('products/product'): # 过滤所有products 里面的
        id = item.findtext('id')
        name = item.findtext('name')
        price = item.findtext('price')
        uuid = item.get('uuid') # 当前节点的属性
        
        print('uuid','=',uuid)
        print('id','=',id)
        print('name','=',name)
        print('price','=',price)
        print('---------')

<class 'xml.etree.ElementTree.ElementTree'>
    uuid = 1234
    id = 10000
    name = iPhone9
    price = 9999
    ---------
    uuid = 4321
    id = 20000
    name = 特斯拉
    price = 800000
    ---------
    uuid = 5678
    id = 30000
    name = Mac Pro
    price = 40000
    ---------

# 48 字典转换为xml #

import dicttoxml
    import os
    from xml.dom.minidom import parseString
    d = [20,"names",
         { 'name':'ball','age':20, 'salary':2000},
         { 'name':'zjq', 'age':56, 'salary':1253},]
    bxml = dicttoxml.dicttoxml(d, custom_root='persons') # 后面的参数是xml根节点
    xml = bxml.decode('utf-8')
    print(xml)
     
    dom = parseString(xml)
    pretty_xml = dom.toprettyxml(indent=' ')
    print(pretty_xml)
    with open("my_file/person1.xml", 'w', encoding='utf-8') as fd:
        fd.write(pretty_xml)

<?xml version="1.0" encoding="UTF-8" ?><persons><item type="int">20</item><item type="str">names</item><item type="dict"><name type="str">ball</name><age type="int">20</age><salary type="int">2000</salary></item><item type="dict"><name type="str">zjq</name><age type="int">56</age><salary type="int">1253</salary></item></persons>
    <?xml version="1.0" ?>
    <persons>
      <item type="int">20</item>
      <item type="str">names</item>
      <item type="dict">
        <name type="str">ball</name>
        <age type="int">20</age>
        <salary type="int">2000</salary>
      </item>
      <item type="dict">
        <name type="str">zjq</name>
        <age type="int">56</age>
        <salary type="int">1253</salary>
      </item>
    </persons>

import xmltodict
    import dicttoxml
    import os
    from xml.dom.minidom import parseString
    import pprint
    with open("my_file/person1.xml", 'r', encoding='utf-8') as fd:
        xml = fd.read()
        d = xmltodict.parse(xml)
        print(d)
        pp = pprint.PrettyPrinter(indent= 4)
        pp.pprint(d)
        print(type(d))

OrderedDict([('persons', OrderedDict([('item', [OrderedDict([('@type', 'int'), ('#text', '20')]), OrderedDict([('@type', 'str'), ('#text', 'names')]), OrderedDict([('@type', 'dict'), ('name', OrderedDict([('@type', 'str'), ('#text', 'ball')])), ('age', OrderedDict([('@type', 'int'), ('#text', '20')])), ('salary', OrderedDict([('@type', 'int'), ('#text', '2000')]))]), OrderedDict([('@type', 'dict'), ('name', OrderedDict([('@type', 'str'), ('#text', 'zjq')])), ('age', OrderedDict([('@type', 'int'), ('#text', '56')])), ('salary', OrderedDict([('@type', 'int'), ('#text', '1253')]))])])]))])
    OrderedDict([   (   'persons',
                        OrderedDict([   (   'item',
                                            [   OrderedDict([   ('@type', 'int'),
                                                                ('#text', '20')]),
                                                OrderedDict([   ('@type', 'str'),
                                                                (   '#text',
                                                                    'names')]),
                                                OrderedDict([   ('@type', 'dict'),
                                                                (   'name',
                                                                    OrderedDict([   (   '@type',
                                                                                        'str'),
                                                                                    (   '#text',
                                                                                        'ball')])),
                                                                (   'age',
                                                                    OrderedDict([   (   '@type',
                                                                                        'int'),
                                                                                    (   '#text',
                                                                                        '20')])),
                                                                (   'salary',
                                                                    OrderedDict([   (   '@type',
                                                                                        'int'),
                                                                                    (   '#text',
                                                                                        '2000')]))]),
                                                OrderedDict([   ('@type', 'dict'),
                                                                (   'name',
                                                                    OrderedDict([   (   '@type',
                                                                                        'str'),
                                                                                    (   '#text',
                                                                                        'zjq')])),
                                                                (   'age',
                                                                    OrderedDict([   (   '@type',
                                                                                        'int'),
                                                                                    (   '#text',
                                                                                        '56')])),
                                                                (   'salary',
                                                                    OrderedDict([   (   '@type',
                                                                                        'int'),
                                                                                    (   '#text',
                                                                                        '1253')]))])])]))])
    <class 'collections.OrderedDict'>

# 49 json文件映射为对象product = json.loads(json\_str, object\_hook=Product) #

# 读取, 转化为Python对象
    # self.__dict__ 的重要意义
    class Product:
        def __init__(self, d):
            self.__dict__ = d
    
    import json
    with open(r"files/product.json", 'r') as fd:
        json_str = fd.read()
        print(json_str)
        product = json.loads(json_str, object_hook=Product) 
        # 这样就将json里面的dict转到类
        print(product.name)
        print(product.price)
        print(product.count)
        
        print("using def")
        def json2product(d):
            return Product(d)
        product1 = json.loads(json_str,object_hook=json2product)
        print(product1.name)
        print(product1.price)

{"name":"iPhone9",
    "price":9999,
    "count":3000}
    iPhone9
    9999
    3000
    using def
    iPhone9
    9999

# dumps用法
    # python对象转json字符串
    class Product:
        def __init__(self, name, price, count):
            self.name = name
            self.price = price
            self.count = count
    product = Product("zjq", 10000,23) # 创建对象,保存到json文件中
    def product2dict(obj):
        return { 
            'name':obj.name,
            'price':obj.price,
            'count':obj.count
        }
    json_str = json.dumps(product,default=product2dict,ensure_ascii=False)
    print(json_str)

{"name": "zjq", "price": 10000, "count": 23}

# json dumps 多个对象
    with open(r"files/products.json", 'r',encoding='utf-8') as fd:
        json_str = fd.read()
        print(json_str)
        
        # 加载为对象
        class Product:
            def __init__(self, d):
                self.__dict__ = d
        products = json.loads(json_str, object_hook=Product)
        print(products)
        for product in products:
            print(product.name)
            
        # 转化为json文件
        json_str = json.dumps(products, default=product2dict, ensure_ascii=False)
        print(type(json_str))

[
        {
        "name":"iPhone9",
        "price":9999,
        "count":3000},
        
    	{"name":"特斯拉",
    	"price":800000,
    	"count":122}
    ]
    [<__main__.Product object at 0x000002F63C439780>, <__main__.Product object at 0x000002F63C439B70>]
    iPhone9
    特斯拉
    <class 'str'>

# 50 SQlite 数据库表 #

# 创建SQlite 数据库表 sqlite3是Python自带的数据库
    import sqlite3
    import os
    path_db = 'data.sqlite'
    if not os.path.exists(path_db):
        conn = sqlite3.connect(path_db) # 不存在就创建
        c = conn.cursor()
        c.execute('''create table persons (id int primary key not null, name text not null, age int not null, address char(100), salary real );''')
        conn.commit()
        conn.close()
        print("创建从数据库成功")
        
    # 插入数据
    with sqlite3.connect(path_db) as conn:
        c = conn.cursor()
        c.execute('delete from persons') # 删除table中person
        c.execute('''insert into persons(id,name,age,address,salary) values(1,'ball',32, 'caifornia',20000)''')
        c.execute('''insert into persons(id,name,age,address,salary) values(2,'zjq',30, 'caifornia',25000)''')
        c.execute('''insert into persons(id,name,age,address,salary) values(3,'rqx',18, 'beauuif',90000)''')
        conn.commit() # 必须含有这个才真正插入了,不然是调入缓存了
        print("insert success")
        
        pass
    
    # 查询
    with sqlite3.connect(path_db) as conn:
        c = conn.cursor()
        persons = c.execute('select name,age,address,salary from persons order by age')
        print(type(persons))
        res = []
        for person in persons:
            value= { }
            value["name"] = person[0]
            value["age"] = person[1]
            value["address"] = person[2]
            value["salary"] = person[3]
            res.append(value)
        print(res)

insert success
    <class 'sqlite3.Cursor'>
    [{'name': 'rqx', 'age': 18, 'address': 'beauuif', 'salary': 90000.0}, {'name': 'zjq', 'age': 30, 'address': 'caifornia', 'salary': 25000.0}, {'name': 'ball', 'age': 32, 'address': 'caifornia', 'salary': 20000.0}]

# ORM框架
    ''' 常用框架和区别 SQLALchemy: 偏向于SQL 灵活提交SQL语句 SQLobject: 面向对象更加,无法free 原生的SQL语句 '''

'\n常用框架和区别\nSQLALchemy: 偏向于SQL  灵活提交SQL语句\nSQLobject:  面向对象更加,无法free 原生的SQL语句\n\n'

# 51 read, readline,readlines #

# 综合知识
    # read readline readlines
    with open(r"files/readme.txt",'r+',encoding="utf-8") as fd:
        # print(fd.read()) #读取全部
        # print(fd.read(3)) #读取前3个字符
        fd.seek(6) # 将文件指针向后6位,
        print(fd.read(3))# 从后六位之后读取三个打印出来
        pass
    
    with open(r"files/readme.txt",'r+',encoding="utf-8") as fd:
        print("realine======\n",fd.readline())
        print("realine======\n",fd.readline(2)) #读取当前行 前两个字符
        
    with open(r"files/readme.txt",'r+',encoding="utf-8") as fd:
        print("----")
        # print(fd.readlines(12)) # 第二行在12个字符之前,所以读取前两行
        print(fd.readlines())

你好，
    realine======
     hello 你好，世界
    
    realine======
     I 
    ----
    ['hello 你好，世界\n', 'I love you.\n', 'How are you? aaaaablbjljlsa\n']

# 52 json 序列化日期类型 #

# json 序列化日期类型
    # 可以处理的数据类型 str int list tuple dict bool None
    # datatime不支持json序列化
    import json
    from datetime import datetime,date
    class Data2json(json.JSONEncoder):
        def default(self,obj):
            if isinstance(obj,datetime):
                return obj.strftime("%Y %m %d, %H %M %S")
            elif isinstance(obj,date):
                return obj.strftime("%Y %m %d")
            else:
                return json.JSONEncoder.default(self, obj)
    d = { 'name':"bill", "date":datetime.now()}
    print(json.dumps(d,cls = Data2json,ensure_ascii=False))

{"name": "bill", "date": "2020 02 05, 20 37 04"}

# 53 读文件,统计字符,得到最多 #

# 算法
    with open("files/readme.txt", 'r',encoding='utf-8') as fd:
        data = fd.read()
    print(data)
    
    d = { } # key 统计出现的字符 value统计总次数
    max_char = ""
    for c in data:
        if c.isspace():
            continue
        if d.get(c) is None:
            d[c] = 1
            if max_char == '':
                max_char = c
        else:
            d[c] += 1
            if d[max_char] < d[c]:
                max_char = c
    print(max_char, d[max_char])
        
    def get_max_char(data):
        d = { }
        max_char = ''
        for c in data:
            if c.isspace():
                continue
            if c not in d:
                d[c] = 1
                if max_char == '':
                    max_char = c
            else:
                d[c] += 1
                if d[max_char] < d[c]:
                    max_char = c
        print(f"最多的字符{max_char},有{d[max_char]}个")
    get_max_char(data)

hello 你好，世界
    I love you.
    How are you? aaaaablbjljlsa
    
    a 7
    最多的字符a,有7个

# 54 装饰器的作用 #

''' 装饰器是一个函数, 经常用于插入日志等功能,性能测试,缓存处理 '''
    
    # 自定义装饰器, 可以用来控制函数是否调用,完全控制函数
    from functools import wraps
    def log(lable,flag):
        def decorate(func):
            @wraps(func)
            def _wrap(*args,**kwargs):
                try:
                    if flag: func(*args,**kwargs) #为真时调用函数
                    print(f'name {func.__name__}')
                except Exception as e: print(e.args)
            return _wrap
        return decorate
    
    @log("info",False)
    def add(a,b,c):
        print(f"sum={a+b+c}")
    
    add(1,2,3)

name add

# 55 判断调用的是函数还是方法MethodType, FunctionType #

# 函数独立,但是方法需要类里定义
    # isinstance
    from types import MethodType, FunctionType
    
    class MyClass:
        def process(self):
            pass
    def process():
        pass
    print(type(MyClass().process).__name__ == FunctionType)
    print(type(MyClass().process))
    print(type(process))
    
    print(isinstance(MyClass().process, FunctionType))
    print(isinstance(MyClass().process, MethodType))
    print("-------")
    print(isinstance(process, FunctionType))
    print(isinstance(process, MethodType))

False
    <class 'method'>
    <class 'function'>
    False
    True
    -------
    True
    False

# 56 声明静态方法 @staticmethod@classmethod #

''' 共同点： 都是用来声明静态方法的。类名.方法名 1. @staticmethod不需要表示自身对象的self和自身类的cls参数，就像普通函数一样定义 2. @classmethod也不需要self参数，但第2个参数需要是表示自身的cls参数。避免硬编码。 '''
    class MyClass:
        bar = 1 #静态变量,不需要实例化就可以调用
        def __init__(self):
            self.count = 20
    
        def process(self):
            print('process:',self.count)
        @staticmethod
        def static_process():
            print('static_process')
            print(MyClass.bar) # 直接不需要实例化调用
        @classmethod
        def class_process(cls): # 第一个参数表示是类本身参数
            print('class_process')
            print("cls.bar",cls.bar)
            print("cls",cls)
            cls().process()
            print("cls().count",cls().count)
    
    print(MyClass.bar)
    MyClass.static_process()
    MyClass.class_process()
    MyClass.bar = 123
    MyClass.static_process()

1
    static_process
    1
    class_process
    cls.bar 1
    cls <class '__main__.MyClass'>
    process: 20
    cls().count 20
    static_process
    123

# 57 元类 #

# 元类
    # metaclass:元类, 创建类的魔板, 所有类都是通过他创建的,可以自由的控制类的创建过程
    # 单例模式
    class SingleTon(type):
        def __init__(self, *args, **kwargs):
            print('in __init__')
            self.__instance = None
            super(SingleTon, self).__init__(*args, **kwargs)
        def __call__(self, *args, **kwargs):
            print('in call')
            if self.__instance is None:
                self.__instance = super(SingleTon, self).__call__(*args, **kwargs)
                print(type(self.__instance))
            return self.__instance
    class MyClass(metaclass=SingleTon):
        pass
    my1 = MyClass()
    my2 = MyClass()
    print(my1 == my2)

in __init__
    in call
    <class '__main__.MyClass'>
    in call
    True

# 58 对象属性处理hasattr, getattr, setattr #

''' hasattr: 判断一个对象是否包含一个属性 getattr:获得一个对象属性值 setattr:设置 '''
    class Person:
        def __init__(self):
            self.name = 'bill'
            self.age = 12
        def show(self):
            print(self.name)
            print(self.age)
    if hasattr(Person, "show"):
        print("存在show方法")
        
    person = Person()
    setattr(person,"sex", '男')
    setattr(person,'age',23)
    print(getattr(person, "sex"))
    print(getattr(person, "age"))
    print(getattr(person, "name"))

存在show方法
    男
    23
    bill

# 59 lambda表达式 #

# lambda表达式, 就是一个匿名函数,可以作为参数值传给函数或者方法
    import re
    a = [('a',1),('b',2),('c',3),('d',4),('e',5)]
    a_1 = list(map(lambda x:x[0],a)) # map映射函数
    a_2 = list(map(lambda x:x[1],a))
    print(a_1)
    print(a_2)

['a', 'b', 'c', 'd', 'e']
    [1, 2, 3, 4, 5]

# 60 复制深层对象 copy与deepcopy的区别 #

# copy:复制深层对象引用
    # deepcopy:复制深层对象的本身
    
    import copy
    a = [12,3,4,5,['a','b']]
    c = copy.copy(a) #浅拷贝
    d = copy.deepcopy(a) # 深拷贝
    print(c,'\n',d)
    
    
    print("a增加一个数据,但是c,d不会有变化")
    a.append(23)
    print(a)
    print(c,'\n',d)
    
    a[4][0] = 'xafa'
    print("修改后,浅拷贝:",c) # 浅拷贝拷贝引用,当修改内值时,是会跟着源进行改变
    print("修改后,深拷贝:",d) # 深拷贝拷贝本身,但是

[12, 3, 4, 5, ['a', 'b']] 
     [12, 3, 4, 5, ['a', 'b']]
    a增加一个数据,但是c,d不会有变化
    [12, 3, 4, 5, ['a', 'b'], 23]
    [12, 3, 4, 5, ['a', 'b']] 
     [12, 3, 4, 5, ['a', 'b']]
    修改后,浅拷贝: [12, 3, 4, 5, ['xafa', 'b']]
    修改后,深拷贝: [12, 3, 4, 5, ['a', 'b']]

# 61 生成器,二维列表变成一维列表 #

''' 生成器yield '''
    def my_generator():
        num_list = [1,2,3,4,5,6]
        for num in num_list:
            yield num # 迭代
            
    for num in my_generator():
        print(num,)
    
    ''' [[1,2,3,4],[5,6,7,8],[9,10,11,12]] [1,2,3,4,5,6,7,8,9,10...] '''
    def enum_list(nested_list):
        for sub_list in nested_list:
            for element in sub_list:
                yield element
                
    list1 = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
    for num in enum_list(list1):
        print(num,end=" ")
    print()
    print(list(enum_list(list1)))

1
    2
    3
    4
    5
    6
    1 2 3 4 5 6 7 8 9 10 11 12 
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 62 递归生成器,多维转1维 #

from typing import List
    nested_list = [4,[1,2,[4,5,6,[2,3,5],23],[2,2,435]]]
    print(nested_list)
    def enum_list(nested_list:List):
        try:
            for sub_list in nested_list:
                for element in enum_list(sub_list):
                    yield element
        except TypeError:
            yield nested_list # 迭代单个
        pass
    
    print(list(enum_list(nested_list)))

[4, [1, 2, [4, 5, 6, [2, 3, 5], 23], [2, 2, 435]]]
    [4, 1, 2, 4, 5, 6, 2, 3, 5, 23, 2, 2, 435]

# 63 当前时间确定调用time.localtime(time.time()) #

import time
    localtime = time.localtime(time.time())
    print(localtime)
    print(localtime.tm_year)
    print(localtime.tm_mon)
    print(localtime.tm_mday)
    print(list(localtime))

time.struct_time(tm_year=2020, tm_mon=2, tm_mday=5, tm_hour=20, tm_min=37, tm_sec=4, tm_wday=2, tm_yday=36, tm_isdst=0)
    2020
    2
    5
    [2020, 2, 5, 20, 37, 4, 2, 36, 0]

# 64 保留字 #

import keyword
    print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 65 数字类型 #

int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
    bool (布尔), 如 True。
    float (浮点数), 如 1.23、3E-2
    complex (复数), 如 1 + 2j、 1.1 + 2.2j

# 66 空行 #

''' 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。 空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。 记住：空行也是程序代码的一部分。 '''

'\n函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。\n\n空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。\n\n记住：空行也是程序代码的一部分。\n'

# 67 map()内置函数 用于映射 #

# map() 会根据提供的函数对指定序列做映射
    c = list(map(chr, [66, 53, 0, 94]))
    print(c)
    
    def sq(x):
        return x**2
    a1 = list(map(sq,[1,3,5]))
    print(a1)

['B', '5', '\x00', '^']
    [1, 9, 25]

# 68 内置函数reduce()问题 #

from functools import reduce
    a = reduce (lambda x,y:x+y+2, [1,2,3,4,5])
    print(a)
    
    weights = [0.0 for i in range(3)]
    print(weights)
    
    weights = [0.0] * 5	# =>[0.0 ,0.0 ,0.0 ,0.0 ,0.0]
    print(weights)

23
    [0.0, 0.0, 0.0]
    [0.0, 0.0, 0.0, 0.0, 0.0]

# 69 zip()函数的使用 #

input_vecs = [[1,1], [1,0], [0,1], [0,0]];
    labels = [1,0,0,0];
    zip1 = zip(input_vecs,labels)
    #print (len(zip1))
    print(list(zip1))
    
    zip2 = zip(labels, input_vecs)
    print(dict(zip2))

[([1, 1], 1), ([1, 0], 0), ([0, 1], 0), ([0, 0], 0)]
    {1: [1, 1], 0: [0, 0]}

# 70 matplotlib画图 #

#首先插入matplotlib
    #命令是 pip install matplotlib
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    import numpy as np
    %matplotlib inline
    x = np.linspace(0,10,100)
    y_1 = x**3 + 10
    plt.plot(x,y_1)
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200205212542541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5,size_16,color_FFFFFF,t_70