xxx

标签：ora   sql   表达   浅拷贝   eve   开始   关联   filter   服务   

‘‘‘
#提升python 程序的性能问题
使用 多进程,充分利用机器的多核性能
对与影响较大的部分代码,用c 或者c++ 编写
对于 io阻塞造成的性能影响,可以使用io多路复用来解决
尽量用python 的内建函数
尽量使用局部变量


#作用域
本地作用域>当前作用域嵌入本地作用域>全局/模块作用域>局部作用域

#什么是python?
是一门 编程语言,是一种解释性语言,声明变量不需要定义类型
是面向对象编程,通过组合和继承的方式定义类
代码优雅简洁 被称为胶水语言,帮助其他语言和组件改善运行状况

#python 自省
是python的一种功能,使程序员面向对象的语言所写的程序在运行时,能够获得
对象的类python 型
为程序员提供极大的灵活性和控制力

#python 的命名空间
在python中,所有的名字都存在于一个空间中,它们在该空间中的存在和被操作
就是命名空间.查询变量的时候,会在该盒子里面寻找相应的对象.

pep8规范
1.变量 私有变量前加_,常量 大写
 4个空格,语法严禁 对齐
 类用驼峰式命名,首字母大写
 验证pep8 安装一个pep8脚本

linux和git
区分文件还是文件夹  ls -F 文件后面加/  文件后面加*
日志是 .log  存放在 /var/log/

查看端口号 netstat -anp|service_name

grep是一种强大的文本搜索工具,能使用正则表达式搜索文本,并把匹配的行打印出来
使用权限是所有用户

find是在目录结构中搜索文件,并执行指定的操作,find在目录寻找条件操作
    递归搜索其各个子目录,查找满足寻找条件的文件并对之采取相关操作

grep是查找匹配条件的行, find 是搜索匹配条件的文件

重定向 >
    linux允许将命令执行结果重定向到一个文件,本应显示在终端上的内容保存到指定文件中
重定向 >>
    这个是将输出内容追加到目标文件中,如果文件不存在,就创建文件,如果文件存在,则
    将新的内容追加到哪个文件的末尾,该文件中的原有文件内容不会受影响



                        `as         a‘c‘v
‘‘‘

"""
字典是一组组键值对的组合,通过key找value,是无须的.,使用{},
dict 使用键值对进行关联的数据


字典是一中数据结构,json是一种数据的表现形式,字典的key值只能是hash,json必须是字符串

什么是可变,不可变类型?
可变的有列表,字典
不可变的有数组,字符串,元组

存入字典的数据是没有先后顺序,不会自动排序,可以使用sort函数对字典进行排序

字典推导式 

a={1:2,3:4}
d={k for k in a }
print(d)


d={‘a‘:24,‘g‘:52,‘l‘:12,‘k‘:33}
print(sorted(d.items(),key=lambda x:x[1]))


"""

"""
str 是python 中最常用的数据类型. 我们可以使用引号(‘或‘)来创建字符串

字符串的\字符:1.转义字符 2.路径名中用来连接路径名 3.编写太长代码手动软换行

a=‘astr‘ #字符反转
print(a[::-1])

2.3将字符串"k:1|k1:2|k2:3|k3:4"，处理成Python字典：{k:1， k1:2， ...}# 字
典里的K作为字符串处理(2018-3-30-lxy)

b={}
a="k:1|k1:2|k2:3|k3:4"
for i in a.split(‘|‘):
    k,v=i.split(‘:‘)
    b[k]=v
print(b)


alist=[{‘name‘: ‘a‘,‘age‘: 20},{‘name‘: ‘b‘,‘age‘: 30},{‘name‘: ‘c‘,‘age‘: 25}]
print(sorted(alist,key=lambda x:x[‘age‘],reverse=True))

"""

"""
name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]

name_list.insert(0,‘xxx‘)
name_list.append(‘ooo‘)

print(name_list)

a=[]
for i in range(10):
    a.append(i)
print(a[::-3]) #[9, 6, 3, 0]


a=range(10)
print(a[::-3]) #range(9,-1,-3)


url的解析过程:域名->dns解析->ip地址->服务端->返回消息->浏览器

http默认端口 80
https默认端口 443
django 默认端口 8000
mysql 默认端口 3306
redis 默认端口  6379
mongodb 默认端口  27017
oracle  默认端口  1521




python manage.py makemigrations 
python manage.py migrate

mvc 是一种软件架构模式,分为模型,视图,控制器  
    耦合性低,重复性高,生命周期成本低  






"""

‘‘‘
# 冒泡排序
a = [5, 2, 45, 6, 8, 2, 1]

for i in range(len(a) - 1):
    for j in range(len(a) - i - 1):
        if a[j] > a[j + 1]:
            a[j], a[j + 1] = a[j + 1], a[j]
# print(a)

for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        if a[i] > a[j]:
            a[i], a[j] = a[j], a[i]
# print(a)

# 二分查找  列表必须是有序的

b = [11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 11111]


def func(left, right, n):
    middle = (left + right) // 2
    if left > right:  # 列表为空
        return -1
    if n > b[middle]:
        left = middle + 1  # 左往右挪
    elif n < b[middle]:
        right = middle - 1  # 右往左挪
    else:
        return middle
    return func(left, right, n)


# print(func(0,len(b)-1,33))


# 斐波那契数列

lis = []
for i in range(20):
    if i == 0 or i == 1:  # 第1,2项 都为1
        lis.append(1)
    else:
        lis.append(lis[i - 2] + lis[i - 1])  # 从第3项开始每项值为前两项值之和  索引的和


# print(lis)

# 递归算斐波那契数列
def fu(n):
    if n == 0 or n == 1:
        return 1
    else:
        return fu(n - 2) + fu(n - 1)  # 前2项是后面一个值
# print(fu(5))


#快排

def quick_sort(li, left, right):
    i = left
    j = right
    if i >= j:
        return li
    tmp = li[i]
    while i < j:
        while i < j and li[j] >= tmp:
            j -= 1
        li[i] = li[j]
        while i < j and li[i] <= tmp:
            i += 1
        li[j] = li[i]
    li[i] = tmp
    quick_sort(li, left, j-1)
    quick_sort(li, i+1, right)
    return li

data = list(range(10))
random.shuffle(data)
quick_sort(data, 0, len(data)-1)
print(data)

#单例模式 (一个类只有一个实例对象)
class A():
    __b=None
    def __new__(cls, *args, **kwargs):
        if not cls.__b:
            cls.__b=object.__new__(cls)
        return cls.__b
    def __init__(self,name):
        self.name=name

a=A(‘11‘)
b=A(‘22‘)
print(a.name,b.name) # 22  22

#装饰器
def wrapper(fn):

    def inner(*args,**kwargs):
        print(123)
        ret= fn(*args,**kwargs)
        print(333)
        return ret
    return inner
@wrapper
def yue(aaa):
    print(‘xxxx‘)
    return ‘ok‘

print(yue(‘xxx‘))


#根据字典值排序
d={‘a‘:24,‘g‘:52,‘l‘:12,‘k‘:33}
for k,v in d.items():
    print(k,v)
print(sorted(d.items(),key=lambda x:x[1]))

#9*9 代码
for i in range(1,10):
    for ii in range(1,i+1):
        print(‘%d*%d=%d ‘% (i,ii,i*ii),end=‘‘)
    print(‘‘)

#9*9 一行代码
print(‘\n‘.join(‘\t‘.join([‘%d*%d=%d‘% (i,ii,i*ii) for ii in range(1,i+1)]) for i in range(1,10)))




#Python输出由1,2,3,4,5组成的互不相同且无重复的三位数 有多少个
 #三位数循环 3次
l=[]
for i in range(1,6):
    for ii in range(1,6):
        for iii in range(1,6):
            if i != ii and i !=iii and ii != iii:
                l.append(i)
                l.append(ii)
                l.append(iii)
print(l)
print(len(l)/3)





##########


a=dict.fromkeys([‘k1‘,‘k2‘],[])  #fromkeys  #给每一个值都已字典形式 赋值
#print(a) #{‘k1‘: [], ‘k2‘: []}
a[‘k1‘].append(111)
#print(a) #{‘k1‘: [111], ‘k2‘: [111]}
a[‘k1‘]=222   #创新给字典赋值
#print(a) #{‘k1‘: 222, ‘k2‘: [111]}

a=[1,22,33,22,33,4,5]
print(set(a))


a=‘1,2,3‘
print(a.split(‘,‘))  #[‘1‘, ‘2‘, ‘3‘]

a=[‘1‘,‘2‘,‘3‘]
b=[]
for i in a:
    b.append(int(i))
print(b)  #[1, 2, 3]

b=[int(i) for i in [‘1‘,‘2‘,‘3‘]]
print(b)




seq=[1,2,3,4]
print(seq[:2])
print(seq[-2:])

print(seq[10:])
#print(seq[10])  #报错
print(seq[::-1])
print(seq[:])
print(id(seq[:])==id(seq))

l=[[]]*5
print(l)
l[0].append(10)
print(l)
l[1].append(20)
print(l)
l.append(30)
print(l)

a=[1,2,3,4]
print(sum([(a[i]+3) for i in range(len(a)) if i%2==0 ]))


def a():
    return [lambda x:i*x for i in range(4)]
print([b(2) for b in a()])



def wrapper(fn):

    def inner(*args,**kwargs):
        print(123)
        ret= fn(*args,**kwargs)
        print(333)
        return ret

    return inner

@wrapper
def yue(aaa):
    print(‘xxxx‘)
    return ‘ok‘

print(yue(‘xxx‘))


a=[2,4,5,6,7,8,10,12,14]
for i in a:
    if i%2==0:
        a.remove(i)
print(a)


#浅拷贝 只拷贝第一层
a = [0, [1,2], [12]]
b = a[:] #b=a 相等于赋值  内存指向一个地方 ,b = a[:] 相等与浅拷贝
a[0] = 8
a[1][1]=3
b[1] = 9
print(a,b)  #a=[8, [1, 3], [12]]  b=[0, 9, [12]]


a=[1,2,3]
b=[(1),(2),(3)]
c=[(1,),(2,),(3,)]
print(a,b,c) #[1, 2, 3] [1, 2, 3] [(1,), (2,), (3,)]


#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print([i*i for i in range(1,11)])


a=range(10)
print(a[::-3])  #range(9, -1, -3)


c=[7,-8,5,4,0,-2,-5]
print(list(sorted(c,key=lambda x:(x<0,abs(x)))))

import math
print(math.floor(5.5))


ll=[[1,2,3],[4,5,6],[7,8,9]]
lll=[]
for i in ll:
    for ii in i:
        lll.append(ii)
print(lll)


ww=1
def ab():
    global ww
    for i in (1,2,3):
        ww +=1
ab()
print(ww)


# 给2个列表,找到相同,不同的元素
lst1 = [1,2,3,4]
lst2 = [2,3,4,5,6]

tong=[]
bt=[]
for i in lst1:
    if i in lst2:
        tong.append(i)
    else:
        bt.append(i)

for i in lst2:
    if i in lst1:
        tong.append(i)
    else:
        bt.append(i)

print([set(tong)],bt)

#set 方法做
s1=set(lst1)
s2=set(lst2)

print(s1^s2)
print(s1&s2)

二叉树是数据结构

#100个 取10个 不重复的数
import random
print(random.sample([i for i in range(100)],10))

代码检测工具
pylint 默认检测 pep8
flasks  1）PyFlakes：静态检查Python代码逻辑错误的工具。
        2）Pep8： 静态检查PEP8编码风格的工具。
        3）NedBatchelder’s McCabe script：静态分析Python代码复杂度         的工具。
        
        
ll=[‘This‘,‘is‘,‘a‘,‘Boy‘,‘!‘]
print(sorted(ll))

#绝对值 
ss=[3,1,-4,-2]
print([sorted(ss,key=lambda x:abs(x))])

#保证原有顺序 去重
ls=[12,1,2,3,4,4,43,3,2]
l=[]
for i in ls:
    if not i in l:
        l.append(i)
print(l)

#根据 age 排序
aa=[{‘name‘:‘a‘,‘age‘:20},{‘name‘:‘a‘,‘age‘:10},{‘name‘:‘a‘,‘age‘:22}]
print([sorted(aa,key=lambda x:x[‘age‘])])

#key:aa,c,qqq,dddd   
d={1:111,2:22,3:3,4:4444}
dd=d.keys()
ff=d.values()
print(set(dd))
print(set(ff))

#2-10  int  #8-10  int
#10-2  bin
#print(oct(99))
#10-8  oct
#10-16 hex
#16-10  int
v=‘0b1111011‘
print(int(v,2)) #123

v=18
print(bin(int(v))) #0b10010

v=‘011‘
print(int(v)) #11

v=30
print(oct(int(v))) #0o36

v=‘0x12‘
print(int(v,16)) #18

v=87
print(hex(int(v))) #0x57

#按奇数找索引
list_a = [12, 232, 22, 2, 2, 2, 22, 2,2, 32]
print(list(filter(lambda x:list_a.index(x)%2==1,list_a)))

#不重复的求和
from collections import Counter
aa=[3,4,1,2,5,6,6,5,4,3,3]
c=Counter(aa)
print(c)
sum=0
for k,v in c.items():
    if v==1:
        sum +=k
print(sum)

#线程
import threading
import time
def _wait():
    time.sleep(2)
print(1)
t=threading.Thread(target=_wait,daemon=False)
t.start()
print(2)


#将列表内的元素,根据位数合并字典
lst=[1,2,3,4,45,45,45,123,123,123,1234,123456,123456,1234567]

dic={}
for i in lst:
    l=len(str(i))
    dic.setdefault(l,[])
    dic[l].append(i)
print(dic)

#遍历代码
A=[1,2,[3,4,[‘433‘]]]
def fun(a):
    for i in a:
        if type(i)==list:
            fun(i)
        else:
            print(i)
fun(A)


##压缩 a3b2c3d1
cc=‘aaabbcccd‘
ccc=‘‘
for i in sorted(list(set(cc)),key=cc.index):
    ccc=ccc+i+str(cc.count(i))
print(ccc)

#输入日期， 判断这一天是这一年的第几天？
import datetime
def a():
    year=int(input(‘年‘))
    month=int(input(‘yue‘))
    day=int(input(‘ri‘))
    date1=datetime.date(year=year,month=month,day=day)
    date2=datetime.date(year=year,month=1,day=1)
    return (date1-date2).days+1

print(a())


如何提升爬虫的效率
线程池
scrapy配置文件相关配置（禁用cookie，禁止重试，减小下载超时，增加并发，日志等级）
scrapy核心组件工作流程
scrapy中如何设置代理（两种方法）
中间件
环境变量（os.environ[‘HTTPS_PROXY‘] = ‘https://ip:port‘）
scrapy如何实现限速
DOWNLOAD_DELAY = 1
scrapy如何实现暂停爬虫
JOBDIR=‘sharejs.com‘
control-C
pipeline如何丢弃一个item对象
scrapy-redis组件作用
实现深度和广度优先:默认为深度优先。
DEPTH_PRIORITY = 1
SCHEDULER_DISK_QUEUE = ‘scrapy.squeues.PickleFifoDiskQueue‘
SCHEDULER_MEMORY_QUEUE = ‘scrapy.squeues.FifoMemoryQueue‘
广度度优先：不全部保留结点，占用空间少；运行速度慢
深度优先：保留全部结点，占用空间大；运行速度快

# 正则
邮箱 \w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\.)[a-zA-Z]{2,14}
手机号  0?(13|15|17|18|19)[0-9]{9}


#类装饰器
class D:
    def __call__(self,cls):
        class a(cls):
            def f(self):
                print(123)

        return a

@D()
class C:
    def f(self):
        print(456)
c=C()
c.f()


#根据c b排序
lst = [{‘a‘:1,‘b‘:2,‘c‘:4},{‘a‘:1,‘b‘:2,‘c‘:3},{‘a‘:1,‘b‘:1,‘c‘:3}]
print(list(sorted(lst,key=lambda x:(x[‘c‘],x[‘b‘]))))


#素数

a=[]
for i in range(100,201):
    for j in range(2,i):
        if i%j==0:
            break
    else:
        a.append(i)

print(a)
#先用sort 排序,再从最后一个去重
a=[1,2,4,2,5,7,10,55,7,8,9,0,3]
a.sort()

b=a[-1]
for i in range(len(a)-2,-1,-1):
    if b==a[i]:
        del a[i]
    else:
        b=a[i]
print(a)

xxx

标签：ora   sql   表达   浅拷贝   eve   开始   关联   filter   服务   

原文地址：https://www.cnblogs.com/xdlzs/p/10581328.html