python 3 笔记

一、python基础I

1. python3 打印使用

   print (var)               #默认是换行的
   print (var, end = "" )    #不换行
   print (var1,var2,var3, sep='@')  #插入分隔符
   

2. 原始字符串

   r"c:\user"
   

3. 在 python 中，类型属于对象，变量是没有类型的：

   a=[1,2,3]
   
   a="Runoob"
   

4. 保留字

   >>> import keyword
   >>> keyword.kwlist
   

5. 导入

   在 python 用 import 或者 from...import 来导入相应的模块。
   将整个模块(somemodule)导入，格式为： import somemodule
   从某个模块中导入某个函数,格式为： from somemodule import somefunction
   从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
   将某个模块中的全部函数导入，格式为： from somemodule import *

6. 注释

   行注释#
   较长注释 ''' ''' 或者 """ """
   

7. 帮助信息

   help(max)
   print(max.__doc__)
   

8. 标准数据类型（6个）

   • Number（数字）
   • String（字符串）
   • List（列表）
   • Tuple（元组）
   • Sets（集合）
   • Dictionary（字典）

9. Number
   【int、float、bool、complex】
   【使用type()函数来查看类型】
   【type()不会认为子类是一种父类类型。
   isinstance()会认为子类是一种父类类型。】

10. String
    Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
    Python中的字符串不能改变。

11. List
    列表是写在方括号([])之间、用逗号分隔开的元素列表。
    加号（+）是列表连接运算符，星号（*）是重复操作
    List中的元素是可以改变的。

12. Tuple
    元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。
    string、list和tuple都属于sequence（序列）。

13. Sets
    集合（set）是一个无序不重复元素的序列。
    基本功能是进行成员关系测试和删除重复元素。
    可以使用大括号 { } 或者 set() 函数创建集合。
    注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

    print(a - b)     # a和b的差集
    
    print(a | b)     # a和b的并集
    
    print(a & b)     # a和b的交集
    
    print(a ^ b)     # a和b中不同时存在的元素
    

14. Dictionary（字典）
    字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。
    键(key)必须使用不可变类型。
    在同一个字典中，键(key)必须是唯一的。

15. 小拓展

元组：

    一般来说，函数的返回值一般为一个。
    而函数返回多个值的时候，是以元组的方式返回的。
    def example(a,b):
        return (a,b)

    python中的函数还可以接收可变长参数
    def test(*args):
        print(args)

字典：

如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：
for c in dict:
    print(c,':',dict[c])

输入 dict 的键值对，可直接用 items() 函数：
for k,v in dict1.items():
    print(k,":",v)

列表：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[1:3])       # 输出下标1，2的元素

类型：

type 主要用于判断未知数据类型，
isinstance 主要用于判断 A 类是否继承于 B 类。

二、python基础II

1. 运算符

   + - * / %
   ** 幂 - 返回x的y次幂
   // 取整除 - 返回商的整数部分
   
   **=
   //=
   

   逻辑运算符：

   运算符	逻辑表达式	描述
   and	x and y	与
   or	x or y	或
   not	not x	非

   成员运算符：

   运算符	描述
   in	如果在指定的序列中找到值返回 True，否则返回 False。
   not in	如果在指定的序列中没有找到值返回 True，否则返回 False。

   身份运算符：

   运算符	描述
   is	is 是判断两个标识符是不是引用自一个对象。
   is not	is not 是判断两个标识符是不是引用自不同对象。

   优先级：
   

2. and和or的返回值

   and 和 or 的描述：

   The expression "x and y" first evaluates *x*; if *x* is false, its value is returned; otherwise, *y* is evaluated and the resulting value is returned.
   
   The expression "x or y" first evaluates *x*; if *x* is true, its value is returned; otherwise, *y* is evaluated and the resulting value is returned.
   

   从左到右：
   and会返回遇到的第一个假值。若没有，则返回最后一个值。
   or会返回遇到的第一个真值。若没有，则返回最后一个值。

3. 进制

   2 进制是以 0b 开头的
   8 进制是以 0o 开头的
   16 进制是以 0x 开头的

4. is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

5. 在交互模式中，最后被输出的表达式结果被赋值给变量 _

6. Python 所谓的奇进偶弃，因为浮点数的表示在计算机中并不准确。

   >>> round(10.5)
   10
   >>> round(11.5)
   12
   

7. python 不支持复数转换为整数或浮点数

8. 随机

   random.randint(x,y)　#随机生一个整数int类型，可以指定这个整数的范围
   >>> random.randint(1000,9999)
   8449
   
   random.sample(sequence,length) 可以从指定的序列中，随机的抽取length个元素。
   

9. 格式化字符串
   

   

10. python三引号"""允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

11. Unicode 字符串
    在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

    在Python3中，所有的字符串都是Unicode字符串。

12. Python 的字符串内建函数
    

13. [::2] 表示的是从头到尾，步长为2。第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。

    >>> L=['a','b','c','d','e','f','g']
    >>> print(L[::2]) 
    ['a', 'c', 'e', 'g']
    

14. 字符串的分割还有partition()这种方式。

    partition(sep)  --> (head,sep,tail)
    从左向右遇到分隔符把字符串分割成两部分，返回头、分割符、尾三部分的三元组。如果没有找到分割符，就返回头、尾两个空元素的三元组。
    

三、python基础III

1. 条件语句

   if condition_1:
       statement_block_1
   elif condition_2:
       statement_block_2
   else:
       statement_block_3
       ...
   

2. 条件语句

   while condition :
       ...
   
   for variable in sequence:
       statements
   else:
       statements
   

3. range()函数

   for i in range(5):
       print(i)
   
   for i in range(5, 9):
       print(i)
   
   for i in range(0, 10, 3):
       print(i)
   
   for i in range(-10, -100, -30):
       print(i)
   
   list(range(5))
   

4. break和continue

5. pass语句

   Python pass是空语句，是为了保持程序结构的完整性。
   pass 不做任何事情，一般用做占位语句

6. 小拓展

   使用内置 enumerate 函数进行遍历:

   sequence = [12, 34, 34, 23, 45, 76, 89]
   for i, j in enumerate(sequence):
       print(i, j)
   

四、python基础IV

• 迭代器：两个基本的方法：iter() 和 next()。

  dict = {1 : "one", 
          2 : "two",
          3 : "three"}
  
  it = iter(dict)
  for item in it :
      print (item, end = " ")
      print (dict[item])
  

• 生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

  在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。

  import sys
  
  def fibonacci(n): # 生成器函数 - 斐波那契
      a, b, counter = 0, 1, 0
      while True:
          if (counter > n): 
              return
          yield a
          a, b = b, a + b
          counter += 1
  f = fibonacci(100) # f 是一个迭代器，由生成器返回生成
  
  while True:
      try:
          print (next(f), end=" ")
      except StopIteration:
          sys.exit()
  

• 函数

  def 函数名（参数列表）:
      函数体
  

• 可更改(mutable)与不可更改(immutable)对象

  在 python 中，类型属于对象，变量是没有类型的.
  在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

  python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

以下是调用函数时可使用的正式参数类型：

必需参数

关键字参数
    def func(str) :
        print (str)
    func(str = "abcd")

默认参数
    def func(str = "xyz") :
        print (str)
    func()

不定长参数
    def printinfo( arg1, *vartuple ):
       print (arg1)
       for var in vartuple:
          print (var)
       return;
    printinfo( 70, 60, 50 );

5 . 匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda [arg1 [,arg2,…..argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2;
print ("相加后的值为 : ", sum( 10, 20 ))

6 . 变量作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

<font color = blue>**变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。**</font>Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问.

7 . 全局变量和局部变量

**定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。**

**局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。**

8 . global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到`global`和`nonlocal`关键字了。
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了.

9 . 列表方法：

将列表当堆栈使用：append()、pop()

将列表当队列使用：deque()、append()、popleft()

列表推导式：

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

10 . del 语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）

11 . 集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号{}创建集合。注意：如果要创建一个空集合，你必须用set()而不是{}；

集合也支持推导式.

12 . 字典
一对大括号创建一个空的字典：{}。

13 . 遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
        print(k, v)

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
        print(i, v)

同时遍历两个或更多的序列，可以使用 zip()组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
        print('What is your {0}?  It is {1}.'.format(q, a))

要反向遍历一个序列，首先指定这个序列，然后调用 reversed()函数：

>>> for i in reversed(range(1, 10, 2)):
    print(i)

要按顺序遍历一个序列，使用 sorted()函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
    print(f)

五、python基础V

1. Python3 模块

   import 语句
   一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
   这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

   这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

   搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码：

   >>>import sys
   >>>sys.path
   

2. from … import 语句

3. from … import * 语句

4. __name__属性

   if __name__ == '__main__':
       print('程序自身在运行')
   else:
       print('我来自另一模块')
   

5. dir() 函数

   内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

   如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

6. 包

   在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

   目录只有包含一个叫做__init__.py 的文件才会被认作是一个包，

7. 从一个包中导入*

   如果包定义文件 __init__.py 存在一个叫做 __all__的列表变量，那么在使用from package import *的时候就把这个列表中的所有名字作为包内容导入。

8. 输入和输出

   Python两种输出值的方式: 表达式语句和 print() 函数。

   第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

   如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

   如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

   • str()： 函数返回一个用户易读的表达形式。
   • repr()： 产生一个解释器易读的表达形式。

   Python提供了input()函数从标准输入读入一行文本，默认的标准输入是键盘。

   input 可以接收一个Python表达式作为输入，并将运算结果返回。

9. 读写文件

   open(filename, mode)
   

   • filename：filename 变量是一个包含了你要访问的文件名称的字符串值。

   • mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

     read(size)
     write(str)

   为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

   size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

   f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

   f.readlines() 将返回该文件中包含的所有行。
   如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

   f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

   如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

   from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

   seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
   seek(x,1) ： 表示从当前位置往后移动x个字符
   seek(-x,2)：表示从文件的结尾往前移动x个字符
   

   你处理完一个文件后, 调用 f.close()来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

10. 文件对象还有其他方法, 如 isatty()和 trucate()

11. pickle 模块

    python的pickle模块实现了基本的数据序列和反序列化。

    通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

    通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

    基本接口：

    pickle.dump(obj, file, [,protocol])
    

    有了 pickle 这个对象, 就能对 file 以读取的形式打开:

    x = pickle.load(file)
    

12 . file方法

Python 3 中的 File 对象不支持 next() 方法。 Python 3 的内置函数 next() 通过迭代器调用 __next__()方法返回下一项。 在循环中，next()方法会在每次循环中调用，该方法返回文件的下一行，如果到达结尾(EOF),则触发 StopIteration

13 . OS模块

14 . 异常处理

    while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")

也可以处理多个异常：

    except (RuntimeError, TypeError, NameError):

或者

    try：
        ...
    except OSError as err:
        ...
    except ValueError:
        ...
    except:

抛出异常

raise NameError('HiThere')

自定义异常

class MyError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

try:
    raise MyError(2*2)
except MyError as e:
    print('My exception occurred, value:', e.value)

定义清理行为：

try:
    raise KeyboardInterrupt
finally:
    print('Goodbye, world!')

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

预定义清理行为：

with open("myfile.txt") as f:
for line in f:
    print(line, end="")

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法,就算在处理过程中出问题了，文件 f 总是会关闭。

六、python基础VI

1 . 面向对象

class ClassName:
<statement-1>
.
.
.
<statement-N>

构造方法：

def __init__(self, realpart, imagpart):
    self.r = realpart
    self.i = imagpart

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

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

类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

继承：

class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>

多继承：

class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>

方法重写：

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。

类属性与方法：
__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__: 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __div__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

运算符重载：

class Vector:
    def __add__(self,other):
        return Vector(self.a + other.a, self.b + other.b)

2 . 标准库概览

针对日常的文件和目录管理任务，shutil模块提供了一个易于使用的高级接口

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys模块的 argv 变量.sys 还有 stdin，stdout 和 stderr 属性.

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案

math模块为浮点运算提供了对底层C函数库的访问.

有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request以及用于发送电子邮件的 smtplib.

datetime模块为日期和时间处理同时提供了简单和复杂的方法.

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试.
doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。
unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集.

3 . 正则表达式
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0)

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

re.search 扫描整个字符串并返回第一个成功的匹配。

re.search(pattern, string, flags=0)

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, count=0)

正则表达式修饰符 - 可选标志

正则表达式模式

4 . CGI编程
CGI(Common Gateway Interface),通用网关接口。
CGI程序可以是Python脚本，PERL脚本，SHELL脚本，C或者C++程序等。

CGI架构图

七、python基础VII

1 . 网络编程

Python 提供了两个级别访问的网络服务。：

• 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。
• 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

Python 中，我们用 socket（）函数来创建套接字：

socket.socket([family[, type[, proto]]])

Socket 对象(内建)方法：

Python 网络编程的一些重要模块：

2 . 多线程

Python3 线程中常用的两个模块为：

• _thread（thread 模块已被废弃。用户可以使用 threading 模块代替，所以，在 Python3 中不能再使用”thread” 模块。为了兼容性，Python3 将 thread 重命名为 “_thread”）
• threading(推荐使用)

Python中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:

_thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
  除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。

• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• IsAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

我们可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法.

线程同步：
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有acquire方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

threadLock = threading.Lock()
threadLock.acquire()
...
threadLock.release()

线程优先级队列（ Queue）:
Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

• Queue 模块中的常用方法:
• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

补充：

1 . 查看docs时，
函数参数最后一个斜线表示该函数只接收位置参数而不接收关键参数，但是在Python中并不允许定义这样的函数，这样的函数一般是用C语言开发的内置函数或特定对象的方法，更加详细的资料可以查阅“Argument Clinic”有关资料。