Python笔记

1.打印：print		c语言的输出是printf
2.单行注释#，多行注释“”“”“”
3.每句代码之后不需要加分号
4.运算符：/除   //除取整  %取余  **求幂
5.在解释器中可以直接输出字符串，双引号*数字可以输出该数量的字符串
6.可以直接定义变量然后赋值
7.输出一个变量时不需要加双引号，否则即为输出该变量名
8.True（1）和false（0）是布尔类型的变量
9.Type（）函数可以求出变量的类型
10.Input（）函数可以获得用户在键盘中输入的内容
11.A=input(“显示信息：”),把函数的返回值赋值给变量，类似输入,输入内容是字符串类型
12.类型转换函数：int（x），可以把变量x转换为整型，类似的还有float（x），需要重新赋值给一个变量
13.输入函数与转换函数可以叠加使用
14.name="66"	print("我是%s,你好呀" %name)，如果含有多个变量则需要%(变量1，变量2，变量3)		print("我是%d,你好呀" %（name*10）)
15.%06d可以让输出的变量是6位数
16.%%可以输出一个百分号
17.if else后需要加：
18.And 和/并且，or或者，not代表非，not通常与布尔型变量一起使用
19.在开发中通常希望某个条件不满足时，执行一些代码，可以使用not，另外如果需要拼接复杂的逻辑条件，同样也有可能用到not
20.elif代表else if
21.Python中可以直接用两个字符串变量进行比较
22.import random（导入工具包）		a=random.randint (1,3)可以随机生成一个1-3之间的整数数然后赋值给变量a
23.while循环与if用法类似
24.不希望print增加换行，可以在print中增加end=“”，内容与end用逗号隔开，单纯的换行print（“”）
25.\t 可以协助在输出文本时保持对齐，\n可以换行，\“”可以输出双引号
26.def可以用来定义函数，函数当中可以调用函数
27.return表示返回值，后续的代码不会被执行
28.列表名（数组）.index(具体的数据)可以表示数据在数组中的索引值（下标）
29.列表.append（在当前数组的最后追加一个元素），列表.insert（x,y在当前数组的x位置插入元素y），列表.extend（把另一个数组插入到当前数组的最后）
30.列表.remove(可以删除确定的元素,指定元素有多个时删除第一个) 列表.pop（不入参数可以删除列表的最后一个数据，传入下标可以删除下标元素）列表.clear（清空列表）
31.del 是删除内存中的数据
32.len(列表名)可以求出数组的长度，列表.count（具体元素）可以求出元素在数组中出现的次数
33.列表.sort()升序排序，列表.sort(reverse=True)降序，列表.reverse（）逆序排列
34.For 变量in 数组名（遍历数组），数组的每个元素临时储存在变量当中
35.print('%s 今年 %d 岁，身高 %d '%e)元组中的数据可以在输出中对应变量，元组内的数据不能被修改
36.list（元组）可以把元组转化为列表，tuple（列表）可以把列表转化为元组
37.在字典中取值用字典名[键的名字]
38.在字典中增加数据用字典名["新键"]=数据，如果键已经存在会修改已经存在的键值对
39.要从字典中删除数据用字典名.pop（键）
40.字典名1.update(字典名2)可以把两个字典合并，如果两个字典有重复的键值对，后者会覆盖前者
41.字典名.clear()可以清空字典，len（字典名）可以计算长度
42.用for in循环遍历字典时将键临时储存在变量中，数据储存在字典名【k】中
43.可以将多个字典放在一个列表中，再进行遍历，只需要输出列表名即可
44.Len(字符串名)可以统计字符串的长度，字符串.count(子字符串)可以统计字字符串出现的位置，字符串.index(子字符串)可以统计字符串出现的位置
45.字符串.isspace()可以判断字符串是否只有空白字符或者空格
46.字符串.isdecimal() isdigit  isnumeric()都能判断字符串是否只含有数字，并且范围越来越大
47.字符串.starswith(子字符串)判断是否以子字符串开始，字符串.endswitch(字字符串)判断是都以字字符串结束
48.字符串.replace(字符串1，字符串2)替换字符串，但是不会修改原来的字符串，字符串.find(子字符串)判断字符串中是否含有子字符串
49.字符串.center(数字)可以让字符串居中对齐		字符串.ljust向左对齐，rjust向右对齐
50.字符串strip（）可以去除空白字符，a=a.replace(" ", "")可以去掉字符串的空格
51.a=字符串.split（）可以拆分一个字符串为列表保存到a中
52.a=" ".join(字符串)可以用“ 	”合并字符串（在两个字符串中间插入“ ”）
53.字符串当中-1的下标代表最后一个值，a[0:2]代表从第一个数字开始取2-0个数，a[0:-1]代表从第一位到倒数第二位，
a[:]代表整个字符串，a[::2]2代表步长，每个一个数取一位，步长为正代表向右读取，步长为负代表向左读取
54.max(字符串) 和min(字符串)可以求出字符串中的最大值和最小值，max（字典）会返回最大值的key
55.字符串，元组，列表都能进行切片操作
56.a in 字符串可以判断元素a是否存在于字符串中，   if a in 列表 ：
57.for 变量 in 集合 ：else ：（遍历完成后执行else当中的代码）
58.while True和while 1代表无限循环
59.可以用append函数向列表中追加各种类型的数据
60.如果return后面没有任何的内容，表示会返回到调用函数的位置 
61.可以用for in遍历保存在列表中的字典，字典【key】代表键对应的值
62.一个列表可以同时保存不同类型的数据
63.id()函数可以求出地址
64.列表和字典在修改时不会更改内存地址，重新赋值会改变地址（可变类型）
65.不可变类型的数据才可以作为字典的key
66.希望修改全局变量用global 声明一下即可
67.元组可以包含多个数据，因此可以使用元组让函数一次返回多个值，小括号可以省略
68.可以使用多个变量一次接受函数的返回值，变量之间逗号分隔
69.交换两个变量的值a,b=(b,a)
70.调用函数时如果传入的参数如果是可变类型的，在函数内部修改了数据的内容，该数据会改变
71.列表变量调用+=本质上是在执行列表变量的extend方法
72.在给函数传入的参数赋值Ture，代表给他设置默认值，可以不用传入参数，有多个参数时可以利用参数名=  传入函数
73.多值参数：参数名前增加一个*可以接受元组，增加两个**可以接受字典
74.传入参数时可以使用拆包语法（*元组，**字典）可以帮我们去掉括号和花括号
75.递归出口会返回上一次调用的地方，执行下面的代码

76.class 可以定义类名，类中可以用def 函数名（）：定义多个函数 例：先用a=类，再用a.函数（）
77.%d可以以十进制输出数字，%x可以输出以十六进制的数字
78.变量.name=” ”可以给变量或者类名起名字 可以再通过a.name 使用（不推荐使用）
79.__del__在对象中设置会对象删除前自动调用里面的函数
80.一个对象的属性可以是另外一个类创建的对象
81.is用于判断两个变量的地址是否相同，==用于判断变量的值是否相同
82.继承：子类可以拥有父类(爷爷)的所有方法和属性，继承的语法class 子类名(父类)
83.子类的方法实现和父类的不一样，只需要在子类重新定义一个和父亲相同名字的方法即可
84.多继承：子类继续父亲和母亲  class子类名（父亲名，母亲名）:
85.pass可以作为函数的占位符，无功能
86.多态：不同的子类对象调用相同的父类方法，产生不同的执行结果
87.如果使用对象.类属性=值，只会给对象添加一个属性，而不会影响到类属性的值，因此推荐用类名.属性访问类属性
88.定义一个类方法 @classmethod 
89.@staticmethod可以定义一个静态方法
90.在程序开发中，如果对某些代码的执行不能确定是否正确可以用try:代码1  except：代码2
91.针对不同类型的异常做出不同的反应：try代码1  except报错的 第一个字母
92.except Exception as reslut:可以捕获未知的错误，把错误的类型赋值给result
93.try : 代码1 except 错误类型 else:没有异常才会执行的代码 finally:无论是否有异常，都会执行的代码
94.Random是随机数模块，random.randint(10,20)可以产生10<=x&&x<=20之间的随机数
95.Range(1,3)代表从1.2,range(3)代表0,1,2
96.Random.choice(对象)可以在对象中随机选择其中一个
97.a ,b=map(int,input().split())实现一行输入多个数字，并以空格隔开
98.a ,b=map(str,input().split(‘,’))实现一行输入多个单词，每个单词以逗号隔开
99.用Print()输出多个变量时可以使用sep=‘’来改变分隔符，end=‘ ’可以去掉输出自带的换行功能
100.在print前加一个r会原样输出字符串，转义字符不会产生效果
101.三引号用于一大段字符串，可以原样输出文本内容
102.+可以拼接字符串和变量，使他们重新变成一个字符串
103.Str（int）可以把整型转化成字符串类型
104.format可以不用考虑变量的类型，用{}代替变量
105.两个字符串可以用来进行==比较
106.两个相同的变量如果数字很大在交互式（终端）的地址不同，如果在【-5,256】范围内不会被回收
107.Bin（x）可以把十进制数x转化为二进制数
108.在Python中0o开头的都是八进制数里面的数字不能超过8，0b开头的都是二进制数，里面数字不能超过2 0x开头为十六进制
109.等号比较的是内容，is比较的是地址
110.in为在...里面返回值是布尔类型not in为不在
111.a[::-1]倒叙，第三个值为-1代表方向向左，步长为1，不加或1为向右，步长代表隔着跳
112.b=a.capitalize()：把字符串a的首字母大写再赋值给b
113.b=a.title()：把字符串a的每个单词首字母大写再赋值给b
114.a.istitle判断字符串a的每个单词首字母是不是大写
115.a.upper把字符串a的每一个单词转化为大写，a.isupper（可以判断a是否为大写）
116.a.lower将字符串a的每一个单词转为小写，a.islower（）可以判断a是否为小写
117.len(a)可以计算字符串a的长度
118.a .find(‘q’)：在字符串a中寻找q，如果有q则返回q的位置，没有则返回-1，a.find(‘q’,10):从第十个位置之后查找q ,a.find(‘q’,1,10)代表在1-9的范围内找q
119.a.rfind()表示从右往左找
120.a.replace(' ！',’ #’)代表把字符串中的！全部替换为#，a.replace（‘#’,’’）代表去掉字符串a中的#
121.字符串内建函数：a.encode 编码 decode解码 字符串a先通过编码的方式上传到网络，再通过解码的方式传给用户
122.a.startswith（）：判断字符串a是否以xxx开头 endswith（）判断是否以xxx结尾
123.a.isalpha（）判断字符串a是否全是字母 a.isdigit（）是否全是数字
124.a.join（‘b’）：字符串b的每个字符 用字符串a连接，join类似于拼接
125.a.lstrip():去除左边的空格  a.rstrip():去除右边的空格 a.strip（）：除去字符串a全部的空格
126.a.split(‘b’) 将字符串a以字符串b分割字符串，将分割后的字符串保存在列表中，如果在括号中加数字可以表示切几刀
127.a.count（‘ b’）求字符串a中b的个数
128.Max（a）可以求出a中的最大值
129.Sum（a）可以求出a的和
130.A.remove(b)删除列表a中第一次出现的b，且返回值是none，如果没有找到删除元素，则报出异常
131.A.pop()弹栈，默认是移除列表中的最后一个元素，但是也可以是指定下标删除，返回值是删除的那个元素，
132.A.clear（）清空列表
133.A.reverse()将列表a反转，改变原列表，而a【：：-1】不会改变原列表
134.A.count（b）可以统计列表a中b的数量
135.For	 index,value	 in	 enumerate（a）： print(index,value)可以先打印列表a的下标再打印下标对应的内容
136.可变类型的变量是相同的地址，不可变的变量是不同的地址
137.如果形式参数为*args，调用时即可以传无限多实际参数，或者不传参数，为一个空元组，想要同时传入*args和其他参数，其他参数必须放在*agrs前面
140.元组不能进行增删改操作，可以用列表转化为元组，a.tuple(b)
141.可以用多个变量来接收元组里面的值
142.如果要用少个变量接受一个元组，可以在最后一个变量前带一个*，元组剩余的元组会变成列表，保存在此变量中（拆装包）
143.dict([('name','lucky')])这种办法可以把元素转化为字典（列表里面套元组），字典里面一次性是两个元素，只有列表当中嵌套一个两个元素的元组，就能转化
144.字典的增加：dict[key]=value 如果字典中原来有一个相同的key就会替换内容（字典当中的key是字符串形式）
145.修改列表元素：a[index]=newvalue
146.字典取值用key，列表和元组用下标
147.字典里面的函数：items() values() keys()
148.a.items（）能把字典转化为列表嵌套有2个元素的元组，可用 for   key,value   in a.items（）遍历字典,key和value分别接收元组的两个元素
149.a.values()可以取出字典当中全部的value保存在一个列表当中
150.a.keys()可以取出字典当中全部的key保存在一个列表当中
151.a.[key]可以打印value
152.a.get（key）可以判断是否字典中key，没有则返回None
153.a.get(key,default)如果字典中没有key则返回默认值
154.del a.[key]	可以删除字典中的元素 
155.a.pop（key）删除字典中的键值对，删除成功返回值是key对应的value
156.a.pop('key','value') 没有此键则返回value
157.a.popitem（）随机删除字典中其中一个元素，大部分都是最后一个
158.a.clear（）清空字典
159.a.updata(b)把两个字典加在一起
160.fromkeys（seq，value）把seq转为字典的形式，如果没有指定默认值的value则为None
161.set：声明集合  set（a）把列表a转化为集合，（无序，不重复）
162.a.add（b）把b添加到集合a中
163.a.update（b）把两个集合合并
164.a.remove（‘b’）在集合a中移除b，存在则删除，不存在则报错                 
165.a.pop（）不指定则删除第一个元素
166.a.discard(b)删除集合a中的b
167.a==b可以判断两个集合内容是否相等，返回值是布尔值
168.两个集合不能用加号合并和乘号重复，可以用减号
169.a&b可以求两个集合的交集，a.intersection（b）也可以求交集
170.a|b可以求两个集合的并集，a.union（b）也可以求交集
171.a^b可以找两个集合不一样的元素
172.字符串转化为列表会把字符串的每个字符拆开
173.Isinstance(a,int)可以判断a是否为int类型，返回值是布尔类型
174.add（a，b=10）此时b为关键字参数，只传a时b为默认值，在有新传b时会覆盖默认值，也可也用（a，b=2）传入函数
175.形式参数定义为**kwargs时，传入的参数必须为a=1，b=2类型，函数会讲a，b变成字典的形式保存，
或者传入**a，a为一个完整的字典（一个*为元组，可以传入任何形式的值，**为字典）
176.函数的返回值可以是多个，此时会以元组的形式返回，函数的返回值也能用多个变量接收
177.定义的全局变量想要在函数内部修改时必须在函数内部声明global+变量
178.内部函数想要修改外部函数的不可变变量需要用nonlocal，但是可以直接打印全局变量和外部函数的变量
179.Locals（）可以查看本地变量有哪些，globals（）可以查看全局变量有哪些
180.闭包：定义在函数内部的函数可以通过返回值接收，但是不能加括号
181.装饰器：定义一个函数，将函数名传入该函数，在内部定义一个新的函数，新的函数用来完善传入的函数，
再用return 将它返回（不用接收），再调用传入的函数前用@+装饰器（decorate）就能实现已经装饰完的效果，但是没有改变函数的名字，
自动将下一行的函数传入到装饰器中。调用原函数时即为装饰好的函数
182.Import time   time.sleep(2)可以使运行结果停止2秒
183.需要对有参数的函数进行装饰器装饰时，在装饰器新定义的函数和在新定义的函数内使用原函数时都需要带一个参数
184.万能装饰器（可以传入不确定个数的参数）：在装饰器内定义的新参数的形式参数为*args和**awargs
185.可以用多个装饰器给一个函数装饰，离得近的先装饰
186.若装饰器@+装饰器名称带参数则需要有3层函数，第一层为参数，不需要有返回值，第二层形式参数为函数名，且返回函数名，第三层为新定义的函数，且返回函数名
187.定义匿名函数；a=lambda 参数：返回值 调用匿名函数：s=a(参数)  
188. list2 = [{'a': 10, 'b': 20}, {'a': 20, 'b': 12}, {'a': 30, 'b': 30}]
n = max(list2, key=lambda x: x['a'])（用max函数比较列表当中的字典，参数只能用key）
189.给列表的奇数都+1： result = map(lambda x: x if x % 2 == 0 else x + 1, list1)，
map函数可以代替for循环，对元组和列表进行操作，lambda x: x if x % 2 == 0 else x + 1（传入一个参数x，如果是偶数则返回x，否则返回x+1）
190.reduce（）：对列表或元组中的元素进行加减乘除操作，要先从from functools import reduce  用法：reduce（lambda x,y:x+y ,list1）
191.filter(lambda x:x[‘age’]>20,students)：可以找出学生字典中年龄大于20岁的学生，输出时必须转化为列表
192.students=sorted（students,key=lambda x:x[‘age’]）:将学生字典按年龄排序，必须接收
193.总结：max（）、min（）、sorted（）要和key一起用
Ctrl可以打开函数的源代码
在字符串最前方加一个r可以让转义\失效
文件操作：
读：
stream=open(‘绝对路径’)，默认是读取txt文本（D:\Python\代码\666.txt）
a=stream.read():可以读出文件中的内容，把它赋值给a
stream.readable()：判断文件是不是可以读的，返回值是布尔值
stream.readline():只读取一行（可以通过循环判断是否为空来取全部内容）
stream.readlines()：读取多行保存在一个列表当中
读取图片用open（‘绝对路径’，‘rb’），写图片用‘wb’
stream.close()关闭开辟的文件传输的通道，在管道不关闭时才能读或写文件
写（修改）：
stream=open(‘绝对路径’，‘w’)，每次（开通管道再关闭管道为1次）操作都会把原来的内容清空，再写新的内容，如果把’w’换成’a’即为追加内容
stream.write（s）：将变量s保存的东西写到文件当中写入的内容默认是跟在上一行的末尾，不会进行换行操作，需要自己加\n
stream.writelines(列表)：把列表中的每个元素写入到文件当中
with open(‘绝对路径’) as stream:可以帮助我们自动释放资源（关闭管道）

文件内容的复制：读取文件的内容保存在一个变量当中，再把这个变量写给另一个文件
对整个文件夹的操作：
import os （先引入os模块）
a=os.path.dirname(__file__):可以显示当前文件夹所在的文件目录（绝对路径）
os .path .join(a,’b’)把b这个文件保存到文件夹a下，返回的是一个拼接后的路径
用stream.name可以得到获取的文件的路径和名字，再用切片就可以得到文件的名字
os.path.split(路径)：可以把路径和文件名分开，保存在一个元组当中
os.path.splitext(路径)：可以分割路径和扩展名
os.getcwd():可以获得当前文件所在的目录
os.listdir(绝对路径):返回指定目录下全部的文件夹和文件，以列表的形式保存


创建文件夹：os.mkdir(绝对路径+文件夹名称)（没有返回值）
os.rmdir(文件夹的绝对路径):删除空文件夹
os.path.exists(文件夹的绝对路径):判断文件夹是否存在
os.remove(该文件完整的绝对路径):删除文件
on.chdir():切换目录
isfile()判断是否是文件
isabs()判断是否是绝对路径
isdir()判断是否是文件夹

想要删除文件夹必须先用删除文件夹当中全部的内容，再删除文件夹（取得目录下全部的文件和该文件夹的路径拼接在一起，用循环删除）

1.把一个旧文件当中的文件复制到新文件夹当中，需要先获取旧文件的文件列表，就用循环拼接旧的文件夹和文件的路径，
再把旧的文件夹当中的文件读入，保存在一个变量中，再把新的文件夹和该文件通过os.path.jion（）把两个路径拼接在一起，然后再用重命名变量.write（变量）把内容写入文件中。
2.如果一个文件夹当中有子类文件夹，可以通过os.chdir(到父级的路径)进入这个子类文件夹
3.因为不知道一个文件夹当中是否还有新的文件夹，所以可以通过递归的形式找到最底层的文件夹，再依次删除每个文件
4.把一个文件夹里面的内容复制到另一个文件夹当中，只能复制文件，不能复制文件夹
5.文件操作open（路径，模式）模式最好选择rb或者wb能读写图片和文本内容
6.相对路径返回上级目录:    ../  进入下级目录:   /      ./：当前目录

异常：如果代码当中含有异常，则异常之后的部分不会运行，如果用try和except之后异常之后的代码依旧可以运行
用法：try：代码1 except 错误类型：解决方案
try :可能出现问题的代码  except 错误类型:解决问题的代码  
except Exception as arr:遇到未知的错误类型的解决方案，错误的类型为arr（这个要放在代码的最后，代码的运行顺序是从上到下）

try :可能出现问题的代码代码 else:代码（当没有出现问题时才执行的代码）
try: 可能出现问题的代码  else: 代码  finally:代码（无论是否出现问题都会执行的代码）
函数中如果出现return 就会终止后面的代码，但是如果是finally则会继续执行finally中的代码


raise Exception（'错误的内容’）:主动抛出异常(满足某个条件时抛出异常)，主动抛出异常需要使用except Exception as arr来接收才能打印出错误
列表推导式格式：新列表=[表达式（这个值为要添加到新列表里面的值） for 变量 in 旧列表 if 条件 ]
例：newlist=[i for i in range(1,101) if i % 3 == 0] :把1-100内能整除3的数组成一个列表

（class为定义对象，不需要加括号，把类赋值给一个变量时为创建对象，需要加括号）
在类当中创建一个函数，这个函数的参数是self，把类赋值给一个变量，这个变量调用该函数时不需要传入参数，系统会把该变量当做参数。
在类当中有一个__init__(self)函数时，在创建对象时就会调用init函数，可以在init函数当中创建该对象的具体的东西（比如姓名，价格）

在类里面的init当中如果还有其他的参数，需要在把对象赋值给变量时传入对应的参数
用@classmethod定义的函数的参数默认是cls（类方法），是一个对象，在调用该函数时，会将调用者当做参数传入函数当中
类方法中只可以使用类属性,在类当中定义的函数调用另一个函数时需要使用self.函数名（）
类方法作用：因为只能访问类属性和类方法，所以可以在对象创建之前，完成一些动作或者功能（不依赖于对象）
在类中创建的__属性（非函数）不能直接用对象方法更改，需要使用类方法更改
在类当中用@staticmethod定义的函数为静态方法（可以不传递参数），在函数里面调用类的属性需要使用类名.对应的属性，也只能访问类的属性和方法
类中定义的普通函数只能依赖对象，只要创建了对象才可以调用
如果在类中定义__new__（cls）则会先执行__new__中的动作，要有返回值，再执行__init__当中的代码
在类中__new__中object.__new__(cls)可以求类的地址

在class当中有一个__call__函数时，把类名赋值给一个变量，使用变量（带上括号传入参数）即可调用call函数（对象当成函数使用）
一个类名给3个变量赋值，此时三个变量的地址相同，更改一个变量的数据，其他的也会变化
__def__的作用是删除相同地址的变量
__str__的作用是返回一个字符串 ，这个字符串由开发者自行定义
在类中定义的私有化属性不能在外部更改
想要更改私有化的属性必须在类当中定义setxxx(参数)函数（xxx为函数名，set为固定值，想要更改的数据当做参数传入函数）
想要得到类当中私有化的属性可以用getxxx（函数），该函数有返回值

is a代表的是类之间的继承关系，has a代表的是对象和它的成员的从属关系
在Python中想要子类继承父类只需要在子类后加括号，括号里面写父类的名称
父类和子类都有定义init，想要子类的init调用父类的init则需要使用super（）.__init__(参数)如果父类的init有参数，则也需要传入对应的参数
如果子类和父类有一样名称的函数，只用子类的功能
在Python中可以多继承，格式：子类（父类1，父类2），如果父类1和父类2有相同的功能会先继承父类1的功能
a继承b，b继承c，a也能使用c的功能（孙子可以用爷爷的功能）

在不同的类当中相互调用需要使用类名.属性
isinstance(对象，类):可以判断某个对象是不是这个类或者它的子类
子类会继承父类init当中普通的属性，但是不能继承私有的属性
一个函数的形式参数为*argus时，可以利用len（argus）求得传入参数的长度
包：包含多个py文件
如果包和当前的py文件是同级，想要从包中倒入包中的py文件要使用from 包名 import py文件名，然后才能使用py文件名.文件中的功能。
或者用from 包名.py文件 import 功能名称，第一种是倒入py文件，第二种是直接导入功能
在py文件中设置__all__=[]列表中写想要py文件中功能，没有写在该列表当中的功能不能使用import导入
import可以导入自己定义的模块，并且执行里面调用的函数，如果不希望其进行调用则可以使用if __name__=‘__main__’(导入时不满足条件)
在包中的一个文件想要导入这个包中的另一个文件也需要使用包名.文件名
如果包当中含有__init__.py文件时，在导入包的时候就会自行调用该文件

求当前时间的代码：
import time
t=time.time()
t1=time.ctime(t)
print(t1)
t2=time.strftime('%Y %m %d %H %M $S')：用数字表示年月日小时分钟秒数
print(t2)

random.randrange(1,10,2):随机生成一个在1-10范围之内的单数（步长为2）
random.choice（列表，元组）：可以在给定的列表或者元组中随机生成一个数


搜索网页的代码方法：
import requests
response = requests.get('http://www.12306.cn/')
print(response.text)

在字符串中搜索内容，搜索不到返回空：
import re
msg = '特别帅的蘑菇头'
result = re.search('蘑菇头',msg)
print(result)
result.span():返回搜索内容的位置

搜索字符串中0-9任意的数字
import re
msg = 'cabndvchdvj4avsns7dghf'
result = re.search('[0-9][a-z]',msg):result为＜re.Match object; span=(11, 13), match='4a'>
print(result)
a=result.group():a为4a
"""
[]表示的是一个范围，可以是数字也可以是字母,search只能找到第一个满足的条件，找到了就不找了，re.findall会找到所有满足条件的字符串，保存在一个列表里
"""

正则符号：
在搜索中*表示>=0,+表示>=1,必须要跟在[]当前之后，例：[a-z][0-9]+[a-z]：代表选出一个字母+多个字符+一个字母的字符串
^用于比较字符串的开始，$用于比较字符串的结尾，{n}表示比较的次数，例如[1-9][0-9]{4}为1-9的数字开头加4个任意的数字,但是没有限制字符串的长度   
^[1-9][0-9]{4}$代表字符串的长度只能为5，n[0-9]代表只能以n开头
{n,}代表次数为>=n次，{n,m}代表次数为大于等于n，小于等于m
[a-zA-Z]代表任意一个字母
\d匹配任意数字，等价于[0-9]
\D匹配任意非数字字符，等价于[^\d]
\w匹配任意字母数字及下划线，等价于[a-zA-Z0-9]
大写是小写的取反
不转义的方法：在字符串前加r或者\\
在正则中.代表任意字符，需要固定是.的话必须使用\.（并且要防止转义）
？代表可以有也可以没有，跟在[]之后
|代表或者
（word|word|word）代表匹配三个单词其中的一个
[0-35-689]:代表不匹配4和7  [135]代表匹配1或者3或者5
分组提取：（）-（）取到两个字符串中间以-分割，例：035-45641563 		
group()可以获取搜索到的内容,group（1）只能获取括号里面的内容，group（1）可以得到035，group（2）可以得到45641563
爬虫爬取标签：r'<[0-9a-zA-Z]+>(.+)'，被搜索的字符串当中不能有换行，必须先用repla（‘\n’,''）去掉换行
r'（
）(.+)':\1代表匹配和第一组（）一样的东西
?P：取名为name1 再用?p=name1来匹配
Python里数量词默认是贪婪的，总是尝试匹配尽可能把多的字符，非贪婪则相反，在*，？，+，{m，n}后面加上？，使贪婪变成非贪婪，匹配到第一个对应的结果就结束匹配


爬虫：
import requests
responese=requests.get('图片的路径')：在百度搜索该文件的路径
with open('aa.jpg','wb') as wstream:
    wstream.write(responese.content)：新建文件，保存从网上下载的图片，response.content为二进制的文本流（图片），.text为文本

import requests
responese=requests.get('http://jspace.host3v.com')#用变量必须url=url，更改头信息必须headers=headers
result = responese.content.decode('utf-8')#将二进制的文本流转化成utf-8的形式，不会使中文乱码
print(result)
responese.request.headers:请求的头信息
responese.headers:响应头信息
responese.status_code为状态代码，为200代表没有问题
    with open('./666.html', 'w',encoding='utf-8') as text1:#使用utf-8的形式保存到当前目录的文件
        text1.write(a)

如果服务器不让爬虫程序进行访问必须定义头信息：
headers={
	'User-Agent':浏览器中network中查找
}

如果想要访问需要登录后才能操作的网页必须在头信息当中增加cookie：浏览器中networ中查找或者可以使用a=request.session()来获得再用a.post或者a.get来访问网站


多进程：
fork()函数通过os模块导入
功能：为当前进程创建一个子进程
返回值：
<0:子进程创建失败
=0：在子进程中的返回值
>0：在父进程中的返回值
os.getpid（）：可以获得当前进程的编号


多进程的创建：（此时任务1和任务2在同时进行）
from multiprocessing import Process
def task():
    while 1:
        print(1111)
def task2():
    while 1:
        print(22222)
if __name__ == '__main__':
    p = Process(target=task,name='任务1')（target表示要执行的任务，name表示给任务起名字）
    p.start()（p.start（）表示创建一个子进程开始执行程序）
    p1 = Process(target=task2，name='任务2')
    p1.start()
定义的全局变量不能在多进程当中同步，每个进程都有属于自己的变量

time.sleep(2):可以让程序延迟2秒之后再运行

阻塞式：全部都添加到队列中，在添加任务的时候堵塞，不能让多个任务同时进行，添加一个任务，执行一个任务，上一个任务没有结束不能执行下一个
非阻塞式：按照开辟空间的大小（进程池大小）添加任务，在上一个任务结束之后才能继续下一个任务
from multiprocessing import Pool
def task(taskname):
    print('开始做任务')
if __name__ == '__main__':
    pool = Pool(5)：创建5个进程池的对象
    tasks = ['1', '2', '3', '4', '5', '6', '7']
    for i in tasks:
        pool.apply_async(task,args=(tasks,))#开始添加任务当进程中。只能同时允许5个任务同时进行，在一个任务结束之后才能有空间给下一个任务
		#pool.apply表示阻塞式添加任务，在循环当中添加一个任务执行一个任务，一次只能执行一个任务，这个任务执行完之后才能执行别的任务
    pool.close() #添加任务结束
    pool.join() #让主进程堵住

from multiprocessing import Queue：引入队列
q=Queue(5):代表开辟一个大小为5的队列，只能往队列当中加入5个东西
q.put（a）:代表往队列当中增加一个a元素，put（）方法有一个阻塞，超过大小的时候要等上一个任务结束才能重新添加
put（a，timeout=3）代表如果3秒之后不能添加成功则会报出异常
q.qsize（）：可以获取队列的长度
q.full（）可以判断队列是不是满的 q.empty（）可以判断队列是不是空的
q.get():可以获取队列的值

进程通信：
当函数作为参数传入的时候加括号代表调用函数，传入该函数的返回值，不加括号代表传入函数
两个平行的函数可以通过队列来共同执行任务：
例：
from multiprocessing import Process, Queue
import time
def download(q):#下载任务，传入一个队列
    images = ['a.jpg', 'b.jpg', 'c.jpg']
    for i in images:
        print('正在下载', i)
        q.put(i)#把文件保存在队列当中
def getfile(q):#获取文件任务，传入一个队列
    while True:
        try:
            file = q.get(timeout=5)#获取文件并且时间不能超过5s，否则报错，如果没有这个则会发生阻塞，使程序不能执行完毕
            print('{}保存成功'.format(file))
        except:
            print('全部保存完毕')
            break
if __name__ == '__main__':
    q = Queue(5)
    p1 = Process(target=download, args=(q,))#target表示传入的任务，arg表示传入函数的参数，可以是变量或者队列
    p2 = Process(target=getfile, args=(q,))
    p1.start()#开始任务
    p1.join()
    p2.start()
    p2.join()

一个软件可以看作是一个进程，这个软件里面的多个功能可以看作线程
进程的模块：from multiprocessing import Process 线程的模块：import threading   线程：threading.Thread()
import threading
t=threading.Thread(target=功能,name='a',args=())#创建线程的对象
t.start()#开始执行线程的功能
不同的线程可以共享同一个全局变量
线程同步（Python底层自带全局解释器锁GIL）：完成一个任务才能执行下一个任务（进来一个任务就锁住CPU，等他出去之后才解锁，
如果数据够大则会自动解锁，解锁之后计算容易出错，所以计算量大的时候适合用进程，进行爬虫或者文件操作的时候适合使用线程）

自定义进程：
class MyProcess(Process):
    def run(self):
        pass
p=MyProcess()
p.start()

进程数据共享：
n=0 每个进程都有一个n,互不影响