Print

3的版本print要加(),2.7及以下版本不用

输出string要用’'单引号或双引号 print(‘helllo’)

string+string可以，string+数字不行，要将数字引起来或者str(4)#

数字运算符

平方要用** 。 2**2=4 2^2=0

取余%

取整// 9//4=2

自变量

存储自变量不用定义类型 a=4

while

condition =1
while condition<10:print(condition)condition=condition+1

True False为大写

Ctrl+C结束内容

注意要用:结束

for

重视程序结构的语言

example_list=[1,1,2,3,4,5,6]//list
for i in example_list:print(i)

ctrl+[ 或ctrl+]进行缩进

range电脑自动生成的迭代器注意包含头不含尾

range(1,3) 输出[1,2]

range(1,10,2) 1-9步长为2

if,ifelse

x=1;y=2;z=3
if x<y:#结果输出print('x<y')if x<y<z:#结果输出print('x<y<z')

if x<y:print('x<y')
else:print('x>y')

if x<y:print('x<y')
elif:print('x>y')else:print('x>y')

def

定义方程,不运行，调用才是考验

def wpc():print('this is a test-')
wpc()#函数的调用

函数参数

def wpc(a,b):c=a+bprint('this is a test-'+str(c))#this is a test-3print('this is a test-',c)#this is a test- 3
wpc(1,2)#函数的调用

当你使用含参数的函数时候呀，一定要传参不然报错呦！

函数默认参数

为解决参数过长问题，需要分行写

def sale_car(price,color='red',brand='camy',is_second_hand='true'):#默认参数print('price',price,'color', color,'brand', brand,'is_second_hand', is_second_hand,)
sale_car(1000,'red','camy',True)#覆盖
sale_car(13100)

注意：未被定义的函数参数放一块，定义的函数参数放一块

函数输出

def wpc(a,b):c=a+breturn c
wpc(1,2)#函数的调用
print(wpc(2,4))#函数值的输出

全局局部变量

一般用大写

APPLE=100#全局变量
def fun():global b#全局变量b=50a=APPLE#局部变量return a+100
print(APPLE)
print(fun())
print(b)
#print(a) 会报错因为a是一个局部变量

APPLE=100#全局变量
a=None
def fun():a=20return a+100
print(APPLE)
print('a past=',a)#None因为还是指第二行全局变量
print(fun())#120
print('a now =',a)#None因为还是指第二行全局变量，区别于fun中的局部变量a

模块安装

sudo pip3 install numpy //安装

sudo pip3 uninstall numpy //卸载

sudo pip3 install -U numpy //升级numpy

sudo是升级为管理员

文件读写

写操作

text = " this is my first test.\n this is next line .\n this is last line"
print(text)
my_file = open('myfile.txt','w')#第一个是文件名，第二个是怎么样的形式
my_file.write(text)#写什么东西
my_file.close()#记得关闭文件

附加操作

text = " this is my first test.\n this is next line .\n this is last line"
append_text='\n this is appended file'
print(text)
my_file = open('myfile.txt','a')#a是追加的意思
my_file.write(append_text)
my_file.close()

读操作

file=open('myfile.txt','r')#将文件保存到file中
content=file.read()#content才是内容
print(content)

file=open('myfile.txt','r')
content=file.readline()#逐行逐行的读
second=file.readline()
all=file.readlines()#将剩余的一次读出，以list形式存储 列表形式
print(content,second,all)
运行结果this is my first test.this is next line .[' this is last line\n', ' this is appended file']

类

和函数类似，变量以大写开头

class Calculator:#属性和方法name = 'good calculator'price =18def add(self,x,y):#self是自身即本类print(self.name)result=x+yprint(result)def minus(self,x,y):result = x-yprint(result)def times(self,x,y):print(x*y)def divid(self,x,y):print(x/y)
calcul =Calculator()#创建一个类
calcul.add(5,4)#使用类的方法

类init

类自己功能,经常用到

class Calculator:#属性和方法name = 'good calculator'price =18#共有属性def __init__(self,name,price,hight=3,width=4,weight=5):#初始化，定义的时候一定要输入参数，这里有默认参数self.name=name#给定的初始化self.price=priceself.h=hightself.w=widthself.we=weightdef add(self,x,y):#self是自身即本类print(self.name)result=x+yprint(result)def minus(self,x,y):result = x-yprint(result)def times(self,x,y):print(x*y)def divid(self,x,y):print(x/y)
calcul =Calculator()#创建一个类
calcul.add(5,4)#使用类的方法

input

a_input =input('give a number')
print('this number is:',a_input)

用户输入的是一个string类型哦！！

解决方法是int(input())

元组和列表

有序的数列

#tupe元组 list列表 都是一连串有顺序的数字
a_tuple=(12,3,5,15,6)#用括号,或者把括号去掉
another_tuple=2,4,7,6a_list=[12,3,4,5]
for content in a_tuple:print(content)
for content in a_list:print(content)

#tupe元组 list列表 都是一连串有顺序的数字
a_tuple=(12,3,5,15,6)#用括号,或者把括号去掉
another_tuple=2,4,7,6a_list=[12,3,4,5]
for index in range(len(a_list)):#range(5)生成0,1,2,3,4的值,len()长度print(index)#0,1，2,3print(a_list[index])#list起始位0

a=[1,2,3,4,1,2,3,4]#列表
a.append(0)#.append可以添加值
print(a)#打印出列表
a.insert(1,0)#在1的位置添加一个0不是修改
print(a)#打印出列表
a.remove(2)#移除第一个出现的2
print(a)#打印出列表
print(a[-1])#从后往前是第一个为-1
print(a[0:3])#打印0,1,2为数字
print(a[:3])#省略0
print(a[-3:])#打印-3到最后一位 也就是-3，-2，-1位
print(a)
print(a.index(0))#打印第一次出现2的索引 index里面是值
print(a.count(1))#打印统计的值为1的数字有多少个？
a.sort()#从小到大进行排序，并覆盖原来的list
print(a)
a.sort(reverse=True)#从大到小进行排序，并覆盖原来的list
print(a)

多维列表

多维list，更高级的用numpy，pandas

a=[1,2,3,4,5]
mutil_dim_a=[ [1,2,3],[2,3,4],[3,4,5]]
print(a[1])#输出单list的第2个值2
print(mutil_dim_a[0][1])#输出2

字典

列表是按顺序的输出内容，字典是无序的

a_list=[1,2,3,4,5,5,4]
d1={'apple':1,'pear':2,'orange':3}#需要一对键值
d2={1:'a','c':'d'}
print(d1['apple'])#输出Apple对应的值
print(d1)#输出d1这个字典
del d1['apple']#删除d1中的'apple'这个键值对
print(d1)#输出d1这个字典
d1['apple']=1#向字典加入一个键值对
print(d1)#输出d1这个字典
def fun():print('hello')
d3={'apple':[1,2,3],#字典里面加list'pear': {'a':1,'b':2 },#字典里面加字典'orange':fun}#字典里面加函数
print(d3)
print(d3['pear']['a'])#取出字典中的东西

载入模块

官方的模块

#第1种方法
#import time
#print(time.localtime())
#第2种方法
#import time as t#以后time都用t来代替了
#print(t.localtime())
#第3种方法
from time import *#引入time的所有功能
print(localtime())

自己模块

import m1
m1.printdata('hello!!')

continue&break

a=True
while a:b=input('type')if b=='1':# a=False#breakcontinueelse:pass#什么都不做print('still in run')
print('fininsh run')

错误处理

try:#file=open('eee','r')#出错的地方，进入Exceptionfile=open('eee','r+')#进入else无错误的情况，r+是读写操作
except Exception as e:#将错误存在e这个变量中，下面进行错误处理print('there is no file named eee')#打印错误信息response = input('do you want to create a new file?')if response=='y':file=open('eee','w')else:pass
else:#如果没有错误那就在这里处理file.write('sss')file.close()

zip,lambda,map

map就是功能+参数，lambda是简化功能，zip是为迭代器做的东西

zip

a=[1,3,4]
b=[0,7,8,9]
print(zip(a,b))
print(list(zip(a,b)))#输出[(1, 0), (3, 7), (4, 8)]
#进行迭代器的输出
for i,j in zip(a,b):print(i/2,j*2)
print(list(zip(a,a,b)))#可以输出更多的东西

lambda

def fun1(x,y):return (x+y)
print(fun1(2,3))
fun2=lambda x,y:x+y#用lambda定义一个简单的方程
print(fun2(2,3))

map

def fun1(x,y):return (x+y)
print(fun1(2,3))
fun2=lambda x,y:x+y#用lambda定义一个简单的方程
print(fun2(2,3))
print(map(fun1,[1],[2]))#输出一个对象,map(函数，输入的参数)
print(list(map(fun1,[1],[2])))
print(list(map(fun1,[1,3],[2,5])))#[1,3]表示x1,x2,[2,5]表示y1,y2

copy&deepcopy

import copy
a=[1,2,3]
b=a#指向同一个空间
print(id(a))#查a的索引
print(id(b))#查b的索引
b[0]=11#改变b，同时改变a
print(a)
print(id(a)==id(b))#返回true
c=copy.copy(a)#copy浅的copy，第一次不同，第二层以后的又指向同一个空间
print(id(a)==id(c))#返回false
c[1]=0
print(a)#不改变
print(c)
d=[1,2,[3,4]]
e=copy.copy(d)
print(id(d)==id(e))#返回false
print(id(e[2])==id(d[2]))#但是当list套list中时，却出现id相同
d[0]=11
print(e)#改变第一位
d[2][0]=666
print(e)#改变d中list中第一位，同时改变了e
#若想完完全全的copy
f=copy.deepcopy(d)#完全不会改变。两个完全不一样
print(id(f[2])==id(d[2]))

pickle

保存和提取功能

import pickle
a_dict= {'da':111,2:[23,1,4],'23':{1:2,'d':'sad'}}#字典
file=open('pickle_example.pickle','wb')#文件名的后缀为pickle，wb是用二进制
pickle.dump(a_dict,file)#像一个挖土车，把a_dict倒到file中
file.close()

import pickle
a_dict= {'da':111,2:[23,1,4],'23':{1:2,'d':'sad'}}#字典
# file=open('pickle_example.pickle','wb')#文件名的后缀为pickle，wb是用二进制
# pickle.dump(a_dict,file)#像一个挖土车，把a_dict倒到file中
# file.close()#第一种方法
# file= open('pickle_example.pickle','rb')#读
# a_dict1 = pickle.load(file)#装载文件
# file.close()
#第二种方法
#未解决可能忘记关文件的问题
with open('pickle_example.pickle','rb') as file:#自动帮你关文件a_dict1 = pickle.load(file)  # 装载文件print(a_dict1)#内容完全一样

set

帮你找不同

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#结果{'d', 'a', 'c', 'b'}不是字典，没有键值对

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#结果{'d', 'a', 'c', 'b'}不是字典，没有键值对
sentence='Welcome to world!'
print(set(sentence))#结果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#区分空格和大小写
#只能传列表或者元组的单一形式，不能列表+列表

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#结果{'d', 'a', 'c', 'b'}不是字典，没有键值对
sentence='Welcome to world!'
print(set(sentence))#结果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#区分空格和大小写
#只能传列表或者元组的单一形式，不能列表+列表
unique_char=set(char_list)
unique_char.add('x')#加入一个东西
# unique_char.clear()#清除set
unique_char.remove('x')#删除某一个特定值，没有东西会报错
unique_char.discard('z')#删除值，没有东西不报错
print(unique_char)

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#结果{'d', 'a', 'c', 'b'}不是字典，没有键值对
sentence='Welcome to world!'
print(set(sentence))#结果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#区分空格和大小写
#只能传列表或者元组的单一形式，不能列表+列表
unique_char=set(char_list)
unique_char.add('x')#加入一个东西
# # unique_char.clear()#清除set
# unique_char.remove('x')#删除某一个特定值，没有东西会报错
# unique_char.discard('z')#删除值，没有东西不报错
set1=unique_char
set2={'a','e','i'}
print(set1.difference(set2))#输出它有他没有东西 输出{'d', 'x', 'b', 'c'}
print(set1.intersection(set2))#输出它共有的东西

正则表达式

为以后爬虫用

import re
# matching string
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string)    # True
print(pattern2 in string)    # False
# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
# 可以看出, 如果 re.search() 找到了结果, 它会返回一个 match 的 object.
# 如果没有匹配到, 它会返回 None. 这个 re.search() 只是 re 中的一个功能
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  # None
print('\n')
# multiple patterns ("run" or "ran")
ptn = r"r[au]n"       # [表示有两个情况],前面需要加上一个 r 用来表示这是正则表达式, 而不是普通字符串
print(re.search(ptn, "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 7), match='run'>
#同样, 中括号 [] 中还可以是以下这些或者是这些的组合.
# 比如 [A-Z] 表示的就是所有大写的英文字母. [0-9a-z] 表示可以是数字也可以是任何小写字母.
print(re.search(r"r[A-Z]n", "dog runs to cat"))     # None
print(re.search(r"r[a-z]n", "dog runs to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog runs to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='run'>

匹配的规则

除了自己定义规则, 还有很多匹配的规则时提前就给你定义好了的. 下面有一些特殊的匹配类型给大家先总结一下, 然后再上一些例子.

• \d : 任何数字
• \D : 不是数字
• \s : 任何 white space, 如 [\t\n\r\f\v]
• \S : 不是 white space
• \w : 任何大小写字母, 数字和 “” [a-zA-Z0-9]
• \W : 不是 \w
• \b : 空白字符 (只在某个字的开头或结尾)
• \B : 空白字符 (不在某个字的开头或结尾)
• \ : 匹配 第一个\
• . : 匹配任何字符 (除了 \n)
• ^ : 匹配开头
• $ : 匹配结尾
• ? : 前面的字符可有可无

print(re.search(r"r\dn", "run r4n"))           
print(re.search(r"r\Dn", "run r4n"))           print(re.search(r"r\sn", "r\nn r4n"))       
print(re.search(r"r\Sn", "r\nn r4n"))       print(re.search(r"r\wn", "r\nn r4n"))          
print(re.search(r"r\Wn", "r\nn r4n"))          print(re.search(r"\bruns\b", "dog runs to cat"))   
print(re.search(r"\B runs \B", "dog   runs  to cat"))  print(re.search(r"runs\\", "runs\ to me"))     
print(re.search(r"r.n", "r[ns to me"))  print(re.search(r"^dog", "dog runs to cat"))   
print(re.search(r"cat$", "dog runs to cat"))   print(re.search(r"Mon(day)?", "Monday"))       
print(re.search(r"Mon(day)?", "Mon"))          

多行匹配

如果一个字符串有很多行, 我们想使用 ^ 形式来匹配行开头的字符, 如果用通常的形式是不成功的. 比如下面的 “I” 出现在第二行开头, 但是使用 r"^I" 却匹配不到第二行, 这时候, 我们要使用 另外一个参数, 让 re.search() 可以对每一行单独处理. 这个参数就是 flags=re.M, 或者这样写也行 flags=re.MULTILINE.

string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string))                 # None
print(re.search(r"^I", string, flags=re.M))     # <_sre.SRE_Match object; span=(18, 19), match='I'>

重复使用

如果我们想让某个规律被重复使用, 在正则里面也是可以实现的, 而且实现的方式还有很多. 具体可以分为这三种:

• * : 重复零次或多次
• + : 重复一次或多次
• {n, m} : 重复 n 至 m 次
• {n} : 重复 n 次

举例如下:

# * : occur 0 or more times
print(re.search(r"ab*", "a"))           
print(re.search(r"ab*", "abbbbb"))       # + : occur 1 or more times
print(re.search(r"ab+", "a"))             
print(re.search(r"ab+", "abbbbb"))      # {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))        
print(re.search(r"ab{2,10}", "abbbbb"))   

分组

我们甚至可以为找到的内容分组, 使用 () 能轻松实现这件事. 通过分组, 我们能轻松定位所找到的内容. 比如在这个 (\d+) 组里, 需要找到的是一些数字, 在 (.+) 这个组里, 我们会找到 “Date: “ 后面的所有内容. 当使用 match.group() 时, 他会返回所有组里的内容, 而如果给 .group(2) 里加一个数, 它就能定位你需要返回哪个组里的信息.

match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group())                   # 021523, Date: Feb/12/2017
print(match.group(1))                  # 021523
print(match.group(2))                  # Date: Feb/12/2017

有时候, 组会很多, 光用数字可能比较难找到自己想要的组, 这时候, 如果有一个名字当做索引, 会是一件很容易的事. 我们字需要在括号的开头写上这样的形式 ?P<名字> 就给这个组定义了一个名字. 然后就能用这个名字找到这个组的内容.

match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id'))                # 021523
print(match.group('date'))              # Date: Feb/12/2017

findall

前面我们说的都是只找到了最开始匹配上的一项而已, 如果需要找到全部的匹配项, 我们可以使用 findall 功能. 然后返回一个列表. 注意下面还有一个新的知识点, | 是 or 的意思, 要不是前者要不是后者.

# findall
print(re.findall(r"r[ua]n", "run ran ren"))    # ['run', 'ran']# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']

replace

我们还能通过正则表达式匹配上一些形式的字符串然后再替代掉这些字符串. 使用这种匹配 re.sub(), 将会比 python 自带的 string.replace() 要灵活多变.

print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))     # dog catches to cat

split

再来我们 Python 中有个字符串的分割功能, 比如想获取一句话中所有的单词. 比如 "a is b".split(" "), 这样它就会产生一个列表来保存所有单词. 但是在正则中, 这种普通的分割也可以做的淋漓精致.

print(re.split(r"[,;\.]", "a;b,c.d;e"))             # ['a', 'b', 'c', 'd', 'e']

compile

最后, 我们还能使用 compile 过后的正则, 来对这个正则重复使用. 先将正则 compile 进一个变量, 比如 compiled_re, 然后直接使用这个 compiled_re 来搜索.

compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='ran'>