python高级的一些细节用法

时间 2020-05-24 标签 python 高级的一些细节用法

list(range(1, 11))

zip（）函数的使用

zip（）函数
a = ["a1", "a2", "a3", "a4", "a5"]
b = ["b1", "b2", "b3", "b4", "b5"]

for i, j in zip(a, b):
	print(i,j)

[x * x for x in range(1, 11)]

[x * x for x in range(1, 11) if x % 2 == 0]

[m + n for m in 'ABC' for n in 'XYZ']`filter()`

items（）能够迭代多个对象html

d = {'x': 'A', 'y': 'B', 'z': 'C' }
for k, v in d.items():
     print(k, '=', v)

generator能够将列表生成式改为生成器（），必须经过next（）方法才能执行调用python

from collections import Iterable  # 判断是否可迭代先导包
isinstance([], Iterable)

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。mysql

Python的for循环本质上就是经过不断调用next()函数实现的。ios

filter() 传一个函数传一个数组

sorted() 对一个数组排序

map（）参数一个函数（表达式，算法），数组

高级写法nginx

def build(x, y):
    return lambda: x * x + y * y

函数对象有一个__name__属性，能够拿到函数的名字：git

call()方法，就能够直接对实例进行调用。github

先定义metaclass，就能够建立类，最后建立实例web

StringIO和BytesIO是在内存中操做str和bytes的方法，使得和读写文件具备一致的接口面试

Python的dict对象能够直接序列化为JSON的{}redis

json.dumps(s, default=student2dict)

分布式进程 https://www.liaoxuefeng.com/wiki/1016959663602400/1017631559645600

Base64是一种用64个字符来表示任意二进制数据的方法，Base64是一种最多见的二进制编码方法

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。
摘要算法不是加密算法

协程看上去也是子程序，但执行过程当中，在子程序内部可中断，而后转而执行别的子程序，在适当的时候再返回来接着执行。

由于子程序切换不是线程切换，而是由程序自身控制，所以，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优点就越明显。

第二大优点就是不须要多线程的锁机制，由于只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只须要判断状态就行了，因此执行效率比多线程高不少。

由于协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可得到极高的性能。

https://segmentfault.com/a/1190000017831088?utm_source=tag-newest session cookie token

sort（）和sorted
sorted是内置函数对全部可迭代的对象都能排序

https://www.yuanrenxue.com/sanic/sanic-start.html sanic框架教程

random的用法

import random

print(random.random())  # 生成0-1的随机浮点数

print(random.randint(1,20))  # 生成1-20的随机整数
print(random.uniform(1,10))  # 生成1-10的随机浮点数

a= ["黄焖鸡", "烤冷面", "麻辣拌", "炒菜"]

print(random.choice(a))  # 随机抽取
print(random.choices(a,[1,1,2,5]))  # 权重的写法
print(random.sample(a, 2))

集合的一些小知识点

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # 并集
print(a & b)  # 交集
print(a - b)  # 差集
print(b - a)
print(a ^ b)  # 对称差集(两个集合中不重合的部分)
# 若是给的是列表直接强转成集合就能够

python中可变参数是作引用传递，不可变类型参数是值传递
字符串的拼接

import time

a = ""
start = time.process_time()
for i in range(10000000):
	a += "a"
end = time.process_time()

print(end - start)
运行时间27s

import time

a = []


for i in range(10000000):
	a.append("a")
start = time.process_time()
"".join(a)
end = time.process_time()

print(end - start)
耗时0.3秒

分析，用join效率高太多了，由于字符串的是不可变对象，用+每次都会建立新的对象。
join一次性申请内存空间，而后直接复制过去，没有新的对象生成，因此效率高不少

来个好玩的，返回值是什么呢

print(False is False is False)

eval（）内置函数的使用

# eval()将str转化成内部的数据结构，应用于网络的数据包解开

a = "[[1,3],[4,6],9,89,242,22]"
print(eval(a))

https://www.cnblogs.com/ExMan/p/10374617.html
join和+在字符串拼接的效率问题

线程协程 IO

最大的IO是磁盘的IO和网络的IO
DMA：CPU不操做硬盘，CPU向DMA下达指令（包含磁盘设备信息和要读取的文件的位置）DMA告知硬盘进行文件的读取（将文件加载到内存中），完成后硬盘会给DMA一个反馈，DMA最终以中断的形式通知给CPU，最终CPU从内存中读取文件的内容，在这个过程当中CPU有处于闲置的状态，就能够用多线程。中断就是一个回调函数。
线程是操做系统的概念，切换用户态和内核态的转换。协程只在用户态。
DMA自己就是异步的。

python上下文

https://www.jianshu.com/p/d53449f9e7e0 好文

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False

python中isinstance（）的用法

python中property的用法：能够将类方法变成属性不用（）就能够取到值

# class XMeta(type):  # 继承了type元类
#     def __new__(cls, *args, **kwargs):
#         print("new")
#         print(cls)
#
# print(XMeta)
# print(type(XMeta))
#
# XMeta()
#
# import sys
# sys.setrecursionlimit(100000) #例如这里设置为十万
class Demo(object):
    def __init__(self):
        print("初始化")

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        if value:
            self.__name = value

    def run(self):
        print("run方法")


a = Demo()
a.name = "cui"

print(a.name)
# ！/usr/bin/env Python3
# -*- encoding:UTF-8 -*-

# class Student(object):
#
#     @property
#     def score(self):
#         return self.__score
#
#     @score.setter
#     def score(self, value):
#         # if value >= 0 and value <= 100:
#         #     self.__score = value  # 还记得__score吗？前面加一个双下划线，表示private私有属性
#         # else:
#         #     raise ValueError('score must between 0 ~ 100!')
#         if value:
#             self.__score = value
#     def age(self):
#         self.__age = 26
#         return self.__age
#
#
# s = Student()
# s.score = 90
# print(s.score)
# print(s.age())

代码练习，这里必需要是私有属性，要不会递归超出内置范围，改大了内存溢出
https://blog.csdn.net/Appleyk/article/details/77850120
https://blog.csdn.net/cliviabao/article/details/79927186

可是通常不用，用描述器

https://blog.csdn.net/junbujianwpl/article/details/79324814 今天python各类踩坑

要保证入口的惟一性在新建文件执行插入数据库会报错

DROP TABLE table_name ; 删除表通常不这么删除，直接可视化工具删除就能够，有的有外键约束，须要先删除关联才能将其余的删除

布隆过滤器：https://www.cnblogs.com/ExMan/p/11373838.html
python代码

import pymysql
import pymssql
import time
from bloompy import ScalableBloomFilter

def timenow():
    timestr = time.localtime(int(time.time()))
    now = time.strftime("%Y-%m-%d %H:%M:%S", timestr)
    return now 

#configure sql server connect
def mssql_conn(): 
    conn = pymssql.connect(
                server="***", 
                user="***", 
                password="***", 
                database="***")
    return conn     
    
#configure mysql connect
def mysql_conn(): 
    conn = pymysql.connect(
                host="***",
                port=3306,
                user="***", 
                password="***", 
                database="***")
    return conn 

def bloomf():
    bloom = ScalableBloomFilter(initial_capacity=100, error_rate=0.001, mode=ScalableBloomFilter.LARGE_SET_GROWTH) 
    conn = mysql_conn() 
    cur = conn.cursor()    
    print('*** Target table data add to BloomFilter ***\n...')
    try:
        cur.execute(t_sql)
        result = cur.fetchone()
        while result != None:
            bloom.add(result)
            result = cur.fetchone()
    except:
        print ("Error: unable to fetch data.")    
    finally:
        print('Finished add.\n')
        cur.close() 
        conn.close() 

    print(timenow(),'\n*** Compare source to target data ***\n...')        
    conn = mssql_conn() 
    cur = conn.cursor()        
    try:
        cur.execute(s_sql)
        num = 0
        result = cur.fetchone()
        while result != None:        
            if result in bloom:
                pass
            else:
                print('{} is not in the bloom filter,not in Target table {}.'.format(result,tab))
                num += 1
            result = cur.fetchone()
        if num == 0:
        
            print('Result: {} ==> Target table data matches source table data.'.format(tab))
        else:
            print('\nResult: Need to compare output to repair data.')
    except:
        print ("Error: unable to fetch data.")
    finally:
        cur.close() 
        conn.close() 
        

if __name__ == '__main__': 
    tab  ='***'
    t_sql='select concat(***, ***, ***, UpdateDate) from ***;'
    s_sql="select convert(varchar(20),***)+convert(varchar(20),***)+convert(varchar(20),***,20)+convert(varchar(25),UpdateDate,21)+'000' from ***"
    print('#Start:',timenow(),'\n')
    bloomf()
    print('\n#End:',timenow())

https://github.com/Qihoo360/Atlas 奇虎360团队开源mysql中间件

https://github.com/Meituan-Dianping/DBProxy/blob/master/doc/USER_GUIDE.md#1 美团点评在360基之上开发读写分离中间件

主要特性：读写分离，负载均衡，支持分表，IP过滤，sql语句黑名单DBA平滑下线DB，从库流量配置，动态加载配置项

https://www.cnblogs.com/zhoujinyi/p/6697141.html 环境搭建
https://www.cnblogs.com/ExMan/p/11351628.html 使用心得
https://www.cnblogs.com/ExMan/p/11351632.html 实践
https://www.cnblogs.com/ExMan/p/11351623.html 加上keepalived实现高可用

codis：分布式的redis解决方案 https://www.cnblogs.com/ExMan/p/11351621.html
使用codis-admin搭建集群https://www.cnblogs.com/ExMan/p/11351609.html

elasticsearch7.0安装及配置优化
https://www.cnblogs.com/ExMan/p/11351296.html
ELK安装部署
https://www.cnblogs.com/ExMan/p/11329115.html
filebeat日志收集
https://www.cnblogs.com/ExMan/p/11329057.html
手把手教你搭建一个 Elasticsearch 集群
https://www.cnblogs.com/ExMan/p/11329011.html
Elasticsearch如何关掉服务
https://www.cnblogs.com/ExMan/default.html?page=9
测算Redis处理实际生产请求的QPS/TPS
https://www.cnblogs.com/ExMan/p/11327394.html
filebeat直连elasticsearch利用pipeline提取message中的字段
https://www.cnblogs.com/ExMan/p/11324009.html

python链接 elasticsearch 查询数据，支持分页

https://www.cnblogs.com/ExMan/p/11324003.html
https://www.cnblogs.com/ExMan/p/11323984.html
https://www.cnblogs.com/ExMan/p/11323389.html

Linux iostat命令详解

Linux系统出现了性能问题，通常咱们能够经过top、iostat、free、vmstat等命令来查看初步定位问题。

https://www.cnblogs.com/ExMan/p/11311530.html

合理设置redis主从buffer
https://www.cnblogs.com/ExMan/p/11295160.html
Flink消费Kafka数据并把实时计算的结果导入到Redis
https://www.cnblogs.com/ExMan/p/11285146.html
Filebeat+Kafka+Logstash+ElasticSearch+Kibana搭建完整版
https://www.cnblogs.com/ExMan/default.html?page=11
Flink+kafka实现Wordcount实时计算
https://www.cnblogs.com/ExMan/p/11285143.html
API设计风格（RRC、REST、GraphQL、服务端驱动）
https://www.cnblogs.com/ExMan/p/11284863.html

API 设计风格是一个很重要的话题，开发后会有一份API文档供测试和联调

RPC

最多见的方式就是本地调用远程，面向的是过程

rpc形式的API组织形态是类和方法（领域和行为）
API的命名每每是一个动词，如：GetUserInfo，GreateUser
由于URI会很是多，并且每每没有一些约定的规范，因此须要有详细的文档

Rest

级别0：定义一个URI，对全部的操做都是发出POST请求
级别1：为各个资源单首创建URI
级别2：使用HTTP方法来定义对自愿的操做
级别3：使用超媒体（HATEOAS）

级别0就是类RPC 级别3才是真正的Rest

rest形式的API组织形态是资源和实体，一切都是围绕资源，设计流程包括：

肯定API提供的资源
肯定资源之间的关系
根据资源类型和关系肯定资源URI结构
肯定资源的结构体

HATEOAS是Hypertext as the Engine of Application State的缩写）。有了资源导航，客户端甚至可能不须要参阅文档就能够找到更多对本身有用的资源，不过HATEOAS没有固定的标准，好比：

{
    "content": [ {
        "price": 499.00,
        "description": "Apple tablet device",
        "name": "iPad",
        "links": [ {
            "rel": "self",
            "href": "http://localhost:8080/product/1"
        } ],
        "attributes": {
            "connector": "socket"
        }
    }, {
        "price": 49.00,
        "description": "Dock for iPhone/iPad",
        "name": "Dock",
        "links": [ {
            "rel": "self",
            "href": "http://localhost:8080/product/3"
        } ],
        "attributes": {
            "connector": "plug"
        }
    } ],
    "links": [ {
        "rel": "product.search",
        "href": "http://localhost:8080/product/search"
    } ]
}

Spring框架也提供了相应的支持：https://spring.io/projects/spring-hateoas，好比以下的代码：

@RestController
public class GreetingController {

    private static final String TEMPLATE = "Hello, %s!";

    @RequestMapping("/greeting")
    public HttpEntity<Greeting> greeting(
            @RequestParam(value = "name", required = false, defaultValue = "World") String name) {

        Greeting greeting = new Greeting(String.format(TEMPLATE, name));
        greeting.add(linkTo(methodOn(GreetingController.class).greeting(name)).withSelfRel());

        return new ResponseEntity<>(greeting, HttpStatus.OK);
    }
}

rest api的设计还有一些小点：

必须是无状态的，互相独立，不区分顺序
API须要有一致性的接口来解耦客户端和服务端的实现
须要尽可能考虑缓存，版本控制，内容协商，部分响应等实现

HTTP/1.1中对幂等性的定义是：一次和屡次请求某一个资源对于资源自己应该具备一样的结果（网络超时等问题除外）。
https://www.jianshu.com/p/629f0f3481bf 深刻了解幂等

GraphQL

RPC面向过程，rest面向资源，那么GraphQL是面向数据查询。

采用GraphQL Playground（https://github.com/prisma/graphql-playground）来查看graphql端点能够看到全部支持的查询：
GraphQL就是经过Schema来明确数据的能力，服务端提供统一的惟一的API入口，而后客户端来告诉服务端我要的具体数据结构（基本能够说不须要有API文档），有点客户端驱动服务端的意思。

更多信息参见 https://github.com/chentsulin/awesome-graphql 。

在下列状况考虑RPC风格的API或说是RPC：
偏向内部的API
没有太多的时间考虑API的设计或没有架构师
提供的API很难进行资源、对象抽象
对性能有高要求
在下列状况考虑REST风格：
偏向外部API
提供的API天生围绕资源、对象、管理展开
不能耦合客户端实现
在下列状况考虑GraphQL：
客户端对于数据的需求多变
数据具备图的特色
在下列状况考虑服务端驱动：
客户端发版更新困难，须要极端的灵活性控制客户端
仅限私有API

-更多须要考虑的设计点
不少API设计指南都提到了下面这些设计考量点，也须要在设计的时候进行考虑：

版本控制，好比：
经过URI Path进行版本控制，好比https://adventure-works.com/v2/customers/3
经过QueryString进行版本控制，好比https://adventure-works.com/customers/3?version=2
经过Header进行版本控制，好比加一个请求头api-version=1
经过Media Type进行版本控制，好比Accept: application/vnd.adventure-works.v1+json
缓存策略，好比：
响应使用Cache-Control告知客户端缓存时间（max-age）、策略（private、public）
响应使用ETag来进行资源版本控制
部分响应：好比大的二进制文件须要考虑实现HEAD Method来代表资源容许分段下载，以及提供资源大小信息：

https://www.cnblogs.com/ExMan/p/11269041.html
python中5个json库的速度对比

python 递归，深度优先搜索与广度优先搜索算法模拟实现

https://www.cnblogs.com/ExMan/p/11172014.html

grpc应用于微服务的分析,基于python

https://www.cnblogs.com/ExMan/p/11135025.html

grpc对go语言支持度更好，使用ptyhon，grpc只作到rpc的数据传递，其它方面大部份还要自行再架构

python微服务

https://www.cnblogs.com/ExMan/p/11134966.html

x轴：水平复制，加实例
y轴：微服务拆分
z轴：分库分表

特色

使用sanic异步框架，简单，轻量，高效。
使用uvloop为核心引擎，使sanic在不少状况下单机并发甚至不亚于- Golang。
使用asyncpg为数据库驱动，进行数据库链接，执行sql语句执行。
使用aiohttp为Client，对其余微服务进行访问。
使用peewee为ORM，可是只是用来作模型设计和migration。
使用opentracing为分布式追踪系统。
使用unittest作单元测试，而且使用mock来避免访问其余微服务。
使用swagger作API标准，能自动生成API文档。

GridFS是一种在MongoDB中存储大二进制文件的机制
https://blog.csdn.net/weixin_33868027/article/details/91944478

uwsgi的一些问题
https://www.cnblogs.com/ExMan/p/10560431.html
gunicorn
https://www.cnblogs.com/ExMan/p/10560361.html
https://www.cnblogs.com/ExMan/p/10403814.html
用Python开发Zeroc Ice应用
https://www.cnblogs.com/ExMan/p/10548301.html
pycharm远程调试配置
https://www.cnblogs.com/ExMan/p/10547885.html
https://www.cnblogs.com/ExMan/p/10547881.html
机器学习
https://www.cnblogs.com/ExMan/p/10482496.html
分布式锁的几种实现方式
https://www.cnblogs.com/ExMan/p/10480761.htm

python面试常考数据结构和算法
https://www.cnblogs.com/ExMan/p/10453879.html

Python操做 RabbitMQ、Redis、Memcache、SQLAlchemy

https://www.cnblogs.com/ExMan/p/10438842.html
Django中提供了6种缓存方式
https://www.cnblogs.com/ExMan/p/10433086.html

celery

https://www.cnblogs.com/ExMan/p/10431451.html
https://www.cnblogs.com/ExMan/p/10431338.html
python中定时任务框架APScheduler

https://www.cnblogs.com/ExMan/p/10431069.html

多进程+协程

https://www.cnblogs.com/ExMan/p/10426777.html

python并发性能比较

https://www.cnblogs.com/ExMan/p/10426661.html
https://www.cnblogs.com/ExMan/p/10404000.html
https://www.cnblogs.com/ExMan/p/10403827.html

uwsgi配置理解

https://www.cnblogs.com/ExMan/p/10403916.html

uwsgi和gunicorn的区别

https://www.cnblogs.com/ExMan/p/10400149.html

爆肝python装饰器

装饰器是一道坎，无论跨不跨过去他都在那里

Python操做rabbitmq 实践笔记
https://www.cnblogs.com/ExMan/p/10346685.html
python logging使用方法

python的垃圾回收

https://www.cnblogs.com/ExMan/p/10187645.html

python数据库链接池

https://www.cnblogs.com/ExMan/p/10187633.html

DRF源码分析

https://www.cnblogs.com/ExMan/p/9825668.html

python实现简单的 LRU算法

https://www.cnblogs.com/ExMan/p/9777487.html

python利用mongodb上传图片数据 : GridFS 与 bson两种方式
https://www.cnblogs.com/ExMan/p/9712392.html
python定时任务对比
https://www.cnblogs.com/ExMan/p/9523729.html
https://www.cnblogs.com/ExMan/p/9523658.html

Django 发送email配置详解及各类错误类型
https://www.cnblogs.com/ExMan/p/9471097.html

让Django支持数据库长链接（能够提升很多性能哦）

https://www.cnblogs.com/ExMan/p/9373919.html

在生产系统使用Tornado WebServer来代替FastCGI加速你的Django应用
https://www.cnblogs.com/Alexander-Lee/archive/2011/05/02/tornado_host_django.html

django长链接https://www.cnblogs.com/ExMan/p/9373884.html

学习大牛笔记nginx + gunicorn + supervisor
https://www.cnblogs.com/ExMan/p/9371007.html

多版本Python共存时pip给指定版本的python安装package的方法

https://www.cnblogs.com/ExMan/p/9366649.html

如何自动生成和安装requirements.txt依赖
https://www.cnblogs.com/ExMan/p/9365166.html
https://www.cnblogs.com/ExMan/p/9304246.html

锁，事务
https://www.cnblogs.com/ExMan/p/9340398.html
https://www.cnblogs.com/ExMan/p/9340290.html
https://www.cnblogs.com/ExMan/p/9340215.html
https://www.cnblogs.com/ExMan/p/9340219.html

【python】与* 参数问题

https://www.cnblogs.com/ExMan/p/9338781.html

[转]django 日志logging的配置以及处理

https://www.cnblogs.com/ExMan/p/9338537.html

python时间模块time，时间戳，结构化时间，字符串时间，相互转换，datetime

https://www.cnblogs.com/ExMan/p/9295161.html

python对象销毁(垃圾回收)

https://www.cnblogs.com/ExMan/p/9264348.html

PyCharm 使用技巧

https://www.cnblogs.com/ExMan/p/9117774.html

Django框架效率问题的解决方法

https://www.cnblogs.com/ExMan/p/8118769.html https://www.cnblogs.com/ExMan/p/8118752.html