python

Python

先编译一个中间的字节码，然后再由解释器根据中间的字节码再次去解释执行

Python解释器在执行任何一个Python程序文件时，首先进行的动作都是先对文件中的Python源代码进行编译，编译的主要结果是产生的一组Python的字节码，然后将编译的结果交给Python虚拟机，由虚拟机按照顺序一条一条地执行字节码，从而完成对Python程序的执行动作。

# -*- coding: utf-8 -*-

python中一切皆是对象：不论是是变量还是字面量（直接量）

id Type Valua

格式输出:　　你想打印一个字符串加数字直接用字符串方式来解决

a = 'asdfasf'
b = 123
print(a+str(b))　#这样的代码不优雅,并且有时候忘了格式转换会出错　　　!!!!!只能将str（而不是“int”）连接到str

print('%s, %s' % (a,b))　　#如果用格式输出就好多了

pyc:

持久化：提升下次的执行效率
import中作为工具，不经常改
还可以保护源码
没import不会走pyc

　　　　手动持久化操作

Python 中的变量赋值不需要类型声明。

10**20 = 10²⁰

if 12>10:
    print("yes")
else:
    print("no")

for:

# 遍历 0 到 4
for i in range(5):
    print(i)

while：

a=1     
while a<10:     
    print a　　　　#输出1~9　　　　　　
    a+=1   　　　　#python中没有++ --

列表(List)：[]

删除列表：del list[2]

一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_index、step)，当只有一个“:”时，默认第三个参数step=1。

>>>a[:-6]
>>> [0, 1, 2, 3]
step=1，从左往右取值，从“起点”开始一直取到end_index=-6。

元祖(Tuple)：()　　类似列表，不可更改

元组中只包含一个元素时，需要在元素后面添加逗号：a=(50,)

元组 tuple() 函数将列表转换为元组　　字典返回键的值

字典(Dict)：{}　　　　键值

集合(Set)：{}　　无序、无重、不可变

输入：

name=input('请输入用户名字：')

print("a",end="a")
print("a")
#输出aaa
#默认end="
"　　改了就不换行了

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

a=" "
b=['a','b','c']
print (a.join(b))　　　　#输出 a b c

函数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict　　

加*表示接受一个tuple类型（元组）

加**表示接受一个dict类型（字典）

def f(**kargs):
    print(kargs)
f(a=1, b=2)

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

面向对象

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

类的私有属性:__private_attrs　　__(2个)　　　　　　注：实例不能访问私有变量

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName（对象名._类名__私有属性名）访问属性　前面1个_后面2个__

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

模块：一组功能的集合体，我们的程序可以导入模块来复用模块里的功能。

name

内置变量，用于表示当前模块的名字，同时还能反映一个包的结构。　　如：python -c "import asdasd.zx"

问题

data = [randint(-10,10) for _ in range(10)]     #生成随机数
d={x:randint(60,100) for x in range(1,21)}      #1~20   (不包括21)

乱七八糟

python中for _ in range(10)与for i in range(10)有何区别？

下划线表示临时变量，仅用一次，后面无需再用到

isinstance() 函数来判断一个对象是否是一个已知的类型

split() 通过指定分隔符对字符串进行切片

正则

. 匹配除换行符之外的任何单字符

d 等同于[0-9]

w 等同于[a-z0-9A-Z_]匹配大小写字母、数字和下划线

import re
key = r"chuxiuhong@hit.edu.cn"
p = r"@.+?."#我想匹配到@后面一直到“.”之间的，在这里是hit
pattern = re.compile(p)
print( pattern.findall(key))            #['@hit.']

import re
key = r"<html><body><h1>hello world</h1></body></html>"#这段是你要匹配的文本
p1 = r"(?<=<h1>).+?(?=</h1>)"#这是我们写的正则表达式规则，你现在可以不理解啥意思
pattern1 = re.compile(p1)#我们在编译这段正则表达式
matcher1 = re.search(pattern1,key)#在源文本中搜索符合正则表达式的部分
print(matcher1.group(0))
#第一个?<=表示在被匹配字符前必须得有<h1>，后面的?=表示被匹配字符后必须有</h1>
p1 = r"(?<=<h1>).+?(?=<h1>)"

正则表达式默认是“贪婪”的 +? 解决

子表达式：几个字符的组合形式看做一个大的“字符”

回溯引用

p1 = r"<h([1-6])>.*?</h1>"
原本那个位置应该是[1-6]，但是我们写的是1
转义符干的活就是把特殊的字符转成一般的字符，把一般的字符转成特殊字符。
普普通通的数字1被转移成什么了呢？
在这里1表示第一个子表达式，也就是说，它是动态的，是随着前面第一个子表达式的匹配到的东西而变化的。
比方说前面的子表达式内是[1-6]，在实际字符串中找到了1，那么后面的1就是1，如果前面的子表达式在实际字符串中找到了2，那么后面的1就是2。

python3

取消xrange

取消iteritems() 用 items()替换iteritems()

items() 将字典中的所有项，以列表方式返回

扩展功能

[(x,y)for x in [1,2]for y in [3,4]]
#[(1, 3), (1, 4), (2, 3), (2, 4)]

M = [[x, x+1, x+2] for x in [1, 4, 7]]  
#[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

a={x ** 2 for x in [1, 2, 2]}
#{1, 4}             for前面是输出的格式

随机数

import random
random.randrange(100, 1000, 2)  # 输出 100 <= number < 1000 间的偶数

列表，字典，集合中根据条件筛选数据

列表

data = [randint(-10,10) for _ in range(10)]

通用：迭代

filter(lambda x:x>0,data)       #filter函数
[x for x in data if x > 0]      #列表解析   更快

方法：

迭代
filter函数
列表解析

字典

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

字典解析：

d={x:randint(60,100) for x in range(1,21)}
{k:v for k,v in d.items() if v >90}     #在Python 3.x 里面，iteritems()方法已经废除了

集合

date =  [randint(-10,10) for _ in range(10)]    #[-6, -2, 2, -8, -7, -7, -10, 1, -10, -8]
s = set(date)                                   #{1, 2, -10, -8, -7, -6, -2}
{x for x in s if x % 3 == 0}                    #{-6}

元组命名

元组：存储空间小，访问速度快

类似其他语言枚举

#NAME=0
#AGE=1
#SEX=2
#EMAIL=3

NAME,AGE,SEX,EMAIL = range(4)
student=('Jim','19','male','jim8721.@gmain.com')
print(student[NAME])
print(student[AGE])
print(student[SEX])
print(student[EMAIL])

collections.namedtuple替代内置tuple

from collections import namedtuple
Student = namedtuple('Student',['name','age','sex','email'])
s=Student('Jim','19','male','jim8721.@gmain.com')
print(s)        #Student(name='Jim', age='19', sex='male', email='jim8721.@gmain.com')
print(s.name)   #Jim
print(s.age)    #19
print(isinstance(s,tuple)）  #True

如何统计序列中元素出现的频率

列表变为字典的形式

from random import randint
data=[randint(0,20) for _ in range(10)]         #生成10个0~20的随机数
print(data)         #[1, 3, 7, 19, 17, 11, 14, 14, 16, 16]
c = dict.fromkeys(data,0)
print(c)            #{1: 0, 3: 0, 7: 0, 19: 0, 17: 0, 11: 0, 14: 0, 16: 0}
for x in data:
    c[x] += 1       #data中的数字的字典形式的键值+1（原来键值为0）
print(c)            #{1: 1, 3: 1, 7: 1, 19: 1, 17: 1, 11: 1, 14: 2, 16: 2}

筛选字典中的值

{k:v for k,v in c.items() if v >1}          #{14: 2, 16: 2}     字典解析

from collections import Counter         #函数
c2 = Counter(data)
c2.most_common(3)           #most_common    出现频度最高

对某文章单词词频统计

from collections import Counter
a = open('navicat.txt').read()
b= re.split('W+',a)
c = Counter(b)
d=c.most_common(3)

字典排序

将字典转化为元组 list(iter(d))

d = { x:randint(60,100) for x in 'xyzabc'}
#{'x': 79, 'y': 62, 'z': 62, 'a': 84, 'b': 83, 'c': 95}
q=list(iter(d))         #['x', 'y', 'z', 'a', 'b', 'c']
sorted(zip(d.values(),d.keys()))
#[(62, 'y'), (62, 'z'), (79, 'x'), (83, 'b'), (84, 'a'), (95, 'c')]

dprint(d) #             {'x': 89, 'y': 69, 'z': 96, 'a': 69, 'b': 92, 'c': 78}  
d.item()  #dict_items([('x', 89), ('y', 69), ('z', 96), ('a', 69), ('b', 92), ('c', 78)])
sorted(d.items(),key=lambda x:x[1])         #将字典中的所有项，以列表方式返回,第二项做键值

多个字典的公共键

from random import randint,sample
sample('abcdefg',randint(3,6))      #随机取样
s1={x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
s2={x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
s3={x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
res = []
for k in s1:
    if k in s2 and k in s3:
        res.append(k)
print(res)

Lambda

lambda argument_list: expression

匿名
有输入和输出
单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。

add=lambda x, y: x+y
print(add(1,2))         #3

历史纪录

from collections import deque
history = deque([],5)
...
history.append(k)
...
if line == 'history':
    print(list(history))

多进程

def main():
    look_process = multiprocessing.Process(target=look)
    walk_process = multiprocessing.Process(target=walk)
    look_process.start()
    walk_process.start()
if __name__ == '__main__':
    main()

str转bytes

b=str1.encode()

bytes转换成str

b.decode()

pickle

文件读写

写

追加

读

file.readline()　　一行一行的读　　全部后面加s　　放在python列表中