Python基础
python属于解释性的高级语言
6个标准数据类型
1、Numbers（数字）
int：整数 eg：1，2，-3，4，……
float：小数 eg：0.1，1.0，……
2、String（字符串）
用双引号、单引号、三引号界定。三引号界定可以跨行，一般用于说明注释
eg：'a','"python"',"基础"
3、List（列表）
列表由方括号界定，元素间用逗号分隔
eg：[0,'python','入门',['p','y','t']] 、 [1]
4、Tuple（元组）
元组由圆括号界定，元素间用逗号分隔，当只有一个元素时元素后逗号必须加上。
eg：(1,) 、(1,2,3)
5、Dictionary（字典）
字典由大括号界定，元素是键值对形式，逗号分隔.
eg:{'ID':'9527','name':'华安'}
6、Set（集合）(由于之前接触较少，就稍微写多了一点笔记)
与数学上的集合一样，集合内每一个值都是唯一的。
eg：{1, 2, 3, 4, 5}
6.1集合的操作
6.1.1集合添加
集合的添加有两种方式，分别是add和update。但是它们在添加元素时是由区别的：
add()方法
把要传入的元素作为一个整体添加到集合中，如：
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.add('two')
>>> s
{'e', 'two', 'o', 'n'}update()方法
是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的字符。可以一次添加多个值，如：
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.update('two')
>>> s
{'e', 'n', 't', 'w', 'o'}6.1.2集合删除
集合的删除操作使用的方法跟列表是一样的，使用的也是remove方法。如：
setVar.remove(element)
setVar :为一个set类型的变量
element :表示要查找并删除的元素
函数作用：
在集合setVar中查找element元素，如果存在则删除；如果没找到，则报错。
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.remove('e')
>>> s
{'n', 'o'}setVar.discard(element)
setVar :为一个set类型的变量
element :表示要查找并删除的元素
函数作用：
在集合setVar中查找element元素，如果存在则删除；如果没找到，则什么也不做。
>>> sList
set([1, 2, 3, 4, 5])
>>> sList.discard(1)
>>> sList
set([2, 3, 4, 5])s.pop()
s：为set类型的变量
函数作用：
删除并返回set类型的s中的一个不确定的元素，如果为空引发KeyError错误。
>>> sList
set([2, 3, 4, 5])
>>> sList.pop()
2s.clear()
s：set类型的变量
函数作用：
清空s集合中的所有元素
>>> sList
set([3, 4, 5])
>>> sList.clear()
>>> sList
set([])6.1.3集合的遍历
集合的遍历跟序列的遍历方法完全一样。
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for i in s:
print(i)
... ...
e
o
n
>>>
另一种遍历方式：
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for idex,i in enumerate(s):
print (idex,i)
... ...
0 e
1 o
2 n
>>>
变量idex表示集合中元素i的索引。
6.1.4集合其他方法
| 函数 | 说明 |
|---|---|
| len(s) | set的长度 |
| x in s | 测试 x 是否是 s 的成员 |
| x not in s | 测试 x 是否不是 s 的成员 |
| s.issubset(t) | 测试是否 s 中的每一个元素都在 t 中 |
| s.issuperset(t) | 测试是否 t 中的每一个元素都在 s 中 |
| s.union(t) | 返回一个新的 set 包含 s 和 t 中的每一个元素 |
| s.intersection(t) | 返回一个新的 set 包含 s 和 t 中的公共元素 |
| s.difference(t) | 返回一个新的 set 包含 s 中有但是 t 中没有的元素 |
| s.symmetric_difference(t) | 返回一个新的 set 包含 s 和 t 中不重复的元素 |
| s.copy() | 返回 set “s”的一个浅复制 |
6.1.5集合的一些操作符
既然是集合，那就会遵循集合的一些操作方法，如求交集、并集、差集等。
交集
Python中求集合的交集使用的符号是“&”，返回连个集合的共同元素的集合，即集合的交集。
>>> st1 = set('python')
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st2 = set('htc')
>>> st2
set(['h', 'c', 't'])
>>> st1 & st2
set(['h', 't'])并集（合集）
Python中求集合的并集用的是符号“|”，返回的是两个集合所有的并去掉重复的元素的集合。
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st3 = set('two')
>>> st3
set(['o', 't', 'w'])
>>> st1 | st3
set(['p', 't', 'w', 'y', 'h', 'o', 'n'])差集
Python中差集使用的符号是减号“-”。
>>> st1
set(['1', '3', '2', '5', '4', '7', '6'])
>>> st2 = set('4589')
>>> st2
set(['9', '8', '5', '4'])
>>> st1 - st2
set(['1', '3', '2', '7', '6'])返回的结果是在集合st1中但不在集合st2中的元素的集合。
6.1.6集合的不同
查看两个集合的不同之处，使用的difference函数，等价于差集。如：
s1.difference(s3)
这种不同指的是集合s3相对于集合s1，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素组成的新集合。
>>> s1
set([1, 2, 3, 4, 5])
>>> s2
set([1, 2, 3, 4])
>>> s1.difference(s2)
set([5])
>>> s3
set(['1', '8', '9', '5'])
>>> s1.difference(s3)
set([1, 2, 3, 4, 5])6.1.7集合的范围判断
集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（！=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。
定义三个集合s1，s2，s3：
>>> s1＝set([1, 2, 3, 4, 5])
>>> s2＝set([1, 2, 3, 4])
>>> s3＝set(['1', '8', '9', '5'])
大于（>）或大于等于（>=）
>>> s1 > s2
True
>>> s1 > s3
False
>>> s1 >= s2
True
表示左边集合是否完全包含右边集合，如集合s1是否完全包含集合s2。
小于（<）或 小于等于（<=）
>>> s2 < s1
True
>>> s1 < s3
False
>>> s3 < s1
False
表示左边的集合是否完全包含于右边的集合，如集合s1是否完全包含于集合s2。
等于（==）、不等于（！=）
>>> s1 == s2
False
>>> s2 == s3
False
>>> s1 != s2
True
判断两个集合是否完全相同。6.2不可变集合frozenset
Python中还有一种不可改变的集合，那就是frozenset，不像set集合，可以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、元组。
>>> f = frozenset()
>>> f
frozenset([])
>>> f = frozenset('asdf')
>>> f
frozenset(['a', 's', 'd', 'f'])
>>> f = frozenset([1,2,3,4])
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset((1,2,3,4))
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset({1:2, 'a':2, 'c':3})
>>> f
frozenset(['a', 1, 'c'])7.数据类型汇总
list、tuple、dict,set 这四种数据类型的元素可以是任意类型
有序序列：list、tuple、string，可以用索引
不可变类型：Numbers、String、tuple
set虽然是可变类型，但是不能更改set中不可变类型数据
循环
for
while
条件语句
==：恒等
！=：不等于
'>' :大于
‘<’ ：小于
'>=' ：大于等于
'<='：小于等于
not ：非
and ：与
or ：或
文件I/O
权限：r、w、a
open()：操作文件
异常
try：执行正常代码
except：发生异常，执行此处代码
else：（可不加），无异常，则执行此处代码
导包
import…… 导入
from……import…… 从……导入
面向过程编程
定义方法：
def func_name()：
return # 可省略
面向对象编程
两个概念：class（类）和 Instance（实例）
可以继承多个基类
线程跟进程
进程间变量独立互不影响。一个进程中的多个线程共用一套变量，因此需要引入线程锁机制（Lock），保证线程间在操作过程中，不能同时对同一变量进行操作。
进程
进程池（Pool）
进程池默认参数是CPU核数
import random
import time
from multiprocessing import Pool
def random_time_task(name):
print(f'执行任务-{name}')
start_time = time.time()
time.sleep(random.random() * 5)
end_time = time.time()
print(f'任务-{name} 执行时间：{end_time - start_time}')
if __name__ == '__main__':
pool = Pool(4)
for i in range(6):
pool.map_async(random_time_task, (i,))
pool.close()
pool.join()
print('所有进程完成')线程
开启一个新线程并返回其标识。 线程执行函数 function 并附带参数列表 args (必须是元组)。 可选的 kwargs 参数指定一个关键字参数字典。
import random
import threading
import time
ls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
balance = 10
lock = threading.Lock()
def operation2balance(money):
global ls
global balance
ls.append(30)
balance = balance + money
balance = balance - money
time.sleep(random.random())
ls.remove(30)
print(len(ls))
def new_thread(n):
for i in range(20):
# operation2balance(n) # 验证没有加锁两个线程同时访问一个变量的情况
# 操作前先获得锁
lock.acquire()
try:
operation2balance(n)
finally:
# 操作后释放锁
lock.release()
if __name__ == '__main__':
t1 = threading.Thread(target=new_thread, args=(29,))
t2 = threading.Thread(target=new_thread, args=(18,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)_thread
_thread.start_new_thread(function,args[kwargs])
# 新建线程并运行