关于python:python基础入门

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元素，如果存在则删除；如果没找到，则什么也不做。

>>> sListset([1, 2, 3, 4, 5])>>> sList.discard(1)>>> sListset([2, 3, 4, 5])

s.pop()

s：为set类型的变量
函数作用：
删除并返回set类型的s中的一个不确定的元素，如果为空引发KeyError谬误。

>>> sListset([2, 3, 4, 5])>>> sList.pop()2

s.clear()

s：set类型的变量
函数作用：
清空s汇合中的所有元素

>>> sListset([3, 4, 5])>>> sList.clear()>>> sListset([])

6.1.3汇合的遍历

汇合的遍历跟序列的遍历办法齐全一样。

>>> s=set('one')>>> s{'e', 'o', 'n'}>>> for i in s:    print(i)... ... eon>>> 另一种遍历形式：>>> s=set('one')>>> s{'e', 'o', 'n'}>>> for idex,i in enumerate(s):        print (idex,i)... ... 0 e1 o2 n>>> 变量idex示意汇合中元素i的索引。

6.1.4汇合其余办法

6.1.5汇合的一些操作符

　　既然是汇合，那就会遵循汇合的一些操作方法，如求交加、并集、差集等。

交加

　　Python中求汇合的交加应用的符号是“&”，返回连个汇合的独特元素的汇合，即汇合的交加。

>>> st1 = set('python')>>> st1set(['h', 'o', 'n', 'p', 't', 'y'])>>> st2 = set('htc')>>> st2set(['h', 'c', 't'])>>> st1 & st2set(['h', 't'])

并集（合集）

　　Python中求汇合的并集用的是符号“|”，返回的是两个汇合所有的并去掉反复的元素的汇合。

>>> st1set(['h', 'o', 'n', 'p', 't', 'y'])>>> st3 = set('two')>>> st3set(['o', 't', 'w'])>>> st1 | st3set(['p', 't', 'w', 'y', 'h', 'o', 'n'])

差集

　　Python中差集应用的符号是减号“-”。

>>> st1set(['1', '3', '2', '5', '4', '7', '6'])>>> st2 = set('4589')>>> st2set(['9', '8', '5', '4'])>>> st1 - st2set(['1', '3', '2', '7', '6'])

　　返回的后果是在汇合st1中但不在汇合st2中的元素的汇合。

6.1.6汇合的不同

　　查看两个汇合的不同之处，应用的difference函数，等价于差集。如：
s1.difference(s3)
　　这种不同指的是汇合s3绝对于汇合s1，不同的中央，也就是所有在汇合s1中，而不再汇合s2中的的元素组成的新汇合。

>>> s1set([1, 2, 3, 4, 5])>>> s2set([1, 2, 3, 4])>>> s1.difference(s2)set([5])>>> s3set(['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 > s2True>>> s1 > s3False>>> s1 >= s2True　　示意右边汇合是否齐全蕴含左边汇合，如汇合s1是否齐全蕴含汇合s2。小于（<）或 小于等于（<=）>>> s2 < s1True>>> s1 < s3False>>> s3 < s1False　　示意右边的汇合是否齐全蕴含于左边的汇合，如汇合s1是否齐全蕴含于汇合s2。等于（==）、不等于（！=）>>> s1 == s2False>>> s2 == s3False>>> s1 != s2True　　判断两个汇合是否完全相同。

6.2不可变汇合frozenset

　　Python中还有一种不可扭转的汇合，那就是frozenset，不像set汇合，能够减少删除汇合中的元素，该汇合中的内容是不可扭转的，相似于字符串、元组。

>>> f = frozenset()>>> ffrozenset([])>>> f = frozenset('asdf')>>> ffrozenset(['a', 's', 'd', 'f'])>>> f = frozenset([1,2,3,4])>>> ffrozenset([1, 2, 3, 4])>>> f = frozenset((1,2,3,4))>>> ffrozenset([1, 2, 3, 4])>>> f = frozenset({1:2, 'a':2, 'c':3})>>> ffrozenset(['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 randomimport timefrom multiprocessing import Pooldef 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 randomimport threadingimport timels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]balance = 10lock = 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])# 新建线程并运行