python

range函数

range(start, stop[, step])
range（）的参数可以是一个、两个、三个，range(5)等价与range(0,5),默认0为缺省值，从0开始遍历，
range（1，30，2）第三位为步长打印出来为（1，3，5..）

字典的声明方法

字典包含两部分，即“键”+“值”，并且在键和值之间用冒号隔开（注意是英文状态下的冒号），相邻的两个元素用逗号隔开
， 所有元素放在一个大括号“{}”中
dictionary = {‘key1’:‘value1’,‘key2’:‘value2’,…,‘keyn’:‘valuen’}

dictionary为参数名
key1…keyn为键名，必须唯一且不可变，键名可以是字符串、数字或者元组
value1…valuen表示元素的值，可以是任何数据类型，不一定唯一

跟列表和元组一样，字典也可以用内置函数 dict() 创建

dictionary = dict()
1.通过映射函数创建字典
dictionary = dict(zip(list1,list2))
zip()函数用于将多个列表或者元组对应位置的元素组合为元组，并返回包含这些内容的zip对象
如果像得到元组，可以将zip对象使用tuple()函数转换为元组；如果想得到列表，可以用list(）函数将其转换为列表

 案例：根据姓名和星座创建一个字典

name = ['张三','李四','王五','刘柳']            # 作为键的列表
 sigh = ['水瓶座','处女座','天蝎座','射手座']     # 作为值的列表
 dictionary = dict(zip(name,sigh))                # 转换为字典
 print(dictionary)                                # 输出

  2.通过给定的“键-值对”创建字典
  语法如下

   dictionary =  dict(key1=value1,key2=value2...........)
 3.还可以利用dict对象的fromkeys()方法创建一个值为空的对象

例如

 name = ['张三','李四','王五','刘柳']            # 作为键的列表
   dictionary = dict.fromkeys(name)                # 转换为字典
   print(dictionary)                                # 输出

append()函数

用于在列表末尾添加新的对象。
语法
list.append(obj)
参数
list:列表对象；
obj:添加到列表末尾的对象。
返回值
append()函数无返回值，但是会修改原本的列表。

Python queue模块详解

queue 模块即队列，特别适合处理信息在多个线程间安全交换的多线程程序中。下面我们对 queue 模块进行一个详细的使用介绍。
1 queue 模块定义的类和异常
queue 模块定义了以下四种不同类型的队列，它们之间的区别在于数据入队列之后出队列的顺序不同。
1.1 queue.Queue(maxsize=0)
先进先出(First In First Out: FIFO)队列，最早进入队列的数据拥有出队列的优先权，就像看电影入场时排队一样，排在队伍前头的优先进入电影院。
入参 maxsize 是一个整数，用于设置队列的最大长度。一旦队列达到上限，插入数据将会被阻塞，直到有数据出队列之后才可以继续插入。如果 maxsize 设置为小于或等于零，则队列的长度没有限制。
示例如下：

import queue
q = queue.Queue()  # 创建 Queue 队列for i in range(3):
    q.put(i)  # 在队列中依次插入0、1、2元素for i in range(3):
    print(q.get())  # 依次从队列中取出插入的元素，数据元素输出顺序为0、1、2

1.2 queue.LifoQueue(maxsize=0)
后进先出(Last In First Out: LIFO)队列，最后进入队列的数据拥有出队列的优先权，就像栈一样。
入参 maxsize 与先进先出队列的定义一样。
示例如下：

import queue
q = queue.LifoQueue()  # 创建 LifoQueue 队列for i in range(3):
    q.put(i)  # 在队列中依次插入0、1、2元素for i in range(3):
    print(q.get())  # 依次从队列中取出插入的元素，数据元素输出顺序为2、1、0

1.3 PriorityQueue(maxsize=0)
优先级队列，比较队列中每个数据的大小，值最小的数据拥有出队列的优先权。数据一般以元组的形式插入，典型形式为(priority_number, data)。如果队列中的数据没有可比性，那么数据将被包装在一个类中，忽略数据值，仅仅比较优先级数字。
入参 maxsize 与先进先出队列的定义一样。
示例如下：

import queue
q = queue.PriorityQueue()  # 创建 PriorityQueue 队列
data1 = (1, 'python')
data2 = (2, '-')
data3 = (3, '100')
style = (data2, data3, data1)for i in style:
    q.put(i)  # 在队列中依次插入元素 data2、data3、data1for i in range(3):
    print(q.get())  # 依次从队列中取出插入的元素，数据元素输出顺序为 data1、data2、data3

1.4 queue.SimpleQueue
先进先出类型的简单队列，没有大小限制。由于它是简单队列，相比于 Queue 队列会缺少一些高级功能，下面第2-3小节将会介绍。
示例如下：

import queue
q = queue.SimpleQueue()  # 创建 SimpleQueue 队列for i in range(3):
    q.put(i)  # 在队列中依次插入0、1、2元素for i in range(3):
    print(q.get())  # 依次从队列中取出插入的元素，数据元素输出顺序为0、

1、2
1.5 queue.Empty 异常
当队列中没有数据元素时，取出队列中的数据会引发 queue.Empty 异常，主要是不正当使用 get() 和 get_nowait() 引起的。
示例如下：

import queuetry:
    q = queue.Queue(3)  # 设置队列上限为3
    q.put('python')  # 在队列中插入字符串 'python'
    q.put('-') # 在队列中插入字符串 '-'
    q.put('100') # 在队列中插入字符串 '100'
    for i in range(4):  # 从队列中取数据，取出次数为4次，引发 queue.Empty 异常
        print(q.get(block=False))except queue.Empty:
    print('queue.Empty')

1.6 queue.Full 异常
当队列数据元素容量达到上限时，继续往队列中放入数据会引发 queue.Empty 异常，主要是不正当使用 put() 和 put_nowait() 引起的。
示例如下：

import queuetry:
    q = queue.Queue(3)  # 设置队列上限为3
    q.put('python')  # 在队列中插入字符串 'python'
    q.put('-') # 在队列中插入字符串 '-'
    q.put('100') # 在队列中插入字符串 '100'
    q.put('stay hungry, stay foolish', block=False)  # 队列已满，继续往队列中放入数据，引发 queue.Full 异常except queue.Full:
    print('queue.Full')

2 Queue、LifoQueue、PriorityQueue 和 SimpleQueue 对象的基本使用方法
Queue、LifoQueue、PriorityQueue 和 SimpleQueue 四种队列定义的对象均提供了以下函数使用方法，下面以 Queue 队列为例进行介绍。
2.1 Queue.qsize()
返回队列中数据元素的个数。
示例如下：

import queue
q = queue.Queue()
q.put('python-100')  # 在队列中插入元素 'python-100'print(q.qsize())  # 输出队列中元素个数为1

2.2 Queue.empty()
如果队列为空，返回 True，否则返回 False。
示例如下：

import queue
q = queue.Queue()print(q.empty())  # 对列为空，返回 True
q.put('python-100')  # 在队列中插入元素 'python-100'print(q.empty())  # 对列不为空，返回 False

2.3 Queue.full()
如果队列中元素个数达到上限，返回 True，否则返回 False。
示例如下：

import queue
q = queue.Queue(3)  # 定义一个长度为3的队列print(q.full())  # 元素个数未达到上限，返回 False
q.put('python')  # 在队列中插入字符串 'python'
q.put('-') # 在队列中插入字符串 '-'
q.put('100') # 在队列中插入字符串 '100'print(q.full())  # 元素个数达到上限，返回 True

2.4 Queue.put(item, block=True, timeout=None)
item，放入队列中的数据元素。
block，当队列中元素个数达到上限继续往里放数据时：如果 block=False，直接引发 queue.Full 异常；如果 block=True，且 timeout=None，则一直等待直到有数据出队列后可以放入数据；如果 block=True，且 timeout=N，N 为某一正整数时，则等待 N 秒，如果队列中还没有位置放入数据就引发 queue.Full 异常。
timeout，设置超时时间。
示例如下：

import queuetry:

q = queue.Queue(2)  # 设置队列上限为2
q.put('python')  # 在队列中插入字符串 'python'
q.put('-') # 在队列中插入字符串 '-'
q.put('100', block = True, timeout = 5) # 队列已满，继续在队列中插入字符串 '100'，等待5秒后会引发 queue.Full 异常except queue.Full:
print('queue.Full')

2.5 Queue.put_nowait(item)
相当于 Queue.put(item, block=False)，当队列中元素个数达到上限继续往里放数据时直接引发 queue.Full 异常。

import queue
try:
    q = queue.Queue(2)  # 设置队列上限为2
    q.put_nowait('python')  # 在队列中插入字符串 'python'
    q.put_nowait('-') # 在队列中插入字符串 '-'
    q.put_nowait('100') # 队列已满，继续在队列中插入字符串 '100'，直接引发 queue.Full 异常
except queue.Full:
    print('queue.Full')

2.6 Queue.get(block=True, timeout=None)
从队列中取出数据并返回该数据内容。
block，当队列中没有数据元素继续取数据时：如果 block=False，直接引发 queue.Empty 异常；如果 block=True，且 timeout=None，则一直等待直到有数据入队列后可以取出数据；如果 block=True，且 timeout=N，N 为某一正整数时，则等待 N 秒，如果队列中还没有数据放入的话就引发 queue.Empty 异常。
timeout，设置超时时间。
示例如下：

import queuetry:
    q = queue.Queue()
    q.get(block = True, timeout = 5) # 队列为空，往队列中取数据时，等待5秒后会引发 queue.Empty 异常except queue.Empty:
    print('queue.Empty')

2.7 Queue.get_nowait()
相当于 Queue.get(block=False)block，当队列中没有数据元素继续取数据时直接引发 queue.Empty 异常。
示例如下：

import queuetry:
    q = queue.Queue()
    q.get_nowait() # 队列为空，往队列中取数据时直接引发 queue.Empty 异常except queue.Empty:
    print('queue.Empty')

3 Queue、LifoQueue 和 PriorityQueue 对象的高级使用方法
SimpleQueue 是 Python 3.7 版本中新加入的特性，与 Queue、LifoQueue 和 PriorityQueue 三种队列相比缺少了 task_done 和 join 的高级使用方法，所以才会取名叫 Simple 了，下面介绍一下 task_done 和 join 的使用方法。
task_done，表示队列内的数据元素已经被取出，即每个 get 用于获取一个数据元素， 后续调用 task_done 告诉队列，该数据的处理已经完成。如果被调用的次数多于放入队列中的元素个数，将引发 ValueError 异常。
join，一直阻塞直到队列中的所有数据元素都被取出和执行，只要有元素添加到 queue 中就会增加。当未完成任务的计数等于0，join 就不会阻塞。
示例如下：

import queue
q = queue.Queue()
q.put('python')
q.put('-')
q.put('100')for i in range(3):
    print(q.get())

q.task_done() # 如果不执行 task_done，join 会一直处于阻塞状态，等待 task_done 告知它数据的处理已经完成
q.join()
下面是一个经典示例，生产者和消费者线程分别生产数据和消费数据，先生产后消费。采用 task_done 和 join 确保处理信息在多个线程间安全交换，生产者生产的数据能够全部被消费者消费掉。

from queue import Queueimport randomimport threadingimport time
#生产者线程class Producer(threading.Thread):
    def __init__(self, t_name, queue):
        threading.Thread.__init__(self, name=t_name)
        self.data=queue
    def run(self):
        for i in range(5):
            print ("%s: %s is producing %d to the queue!" %(time.ctime(), self.getName(), i))
            self.data.put(i)  # 将生产的数据放入队列
            time.sleep(random.randrange(10)/5)
        print ("%s: %s finished!" %(time.ctime(), self.getName()))
#消费者线程class Consumer(threading.Thread):
    def __init__(self, t_name, queue):
        threading.Thread.__init__(self, name=t_name)
        self.data=queue
    def run(self):
        for i in range(5):
            val = self.data.get()  # 拿出已经生产好的数据
            print ("%s: %s is consuming. %d in the queue is consumed!" %(time.ctime(), self.getName(), val))
            time.sleep(random.randrange(5))
            self.data.task_done() # 告诉队列有关这个数据的任务已经处理完成
        print ("%s: %s finished!" %(time.ctime(), self.getName()))
#主线程def main():
    queue = Queue()
    producer = Producer('Pro.', queue)
    consumer = Consumer('Con.', queue)
    producer.start()
    consumer.start()
    queue.join()  # 阻塞，直到生产者生产的数据全都被消费掉
    producer.join() # 等待生产者线程结束
    consumer.join() # 等待消费者线程结束
    print ('All threads terminate!')
 if __name__ == '__main__':
    main()

面向对象编程

PY中一切皆对象，类对象也会在内存中开辟空间（有ID,TYPE(类型)，value值）
不同的数据类型属于不同的类（可以通过内置函数查看数据类型）
创建类的语法

class Student:
native_place='吉林'#类属性

#初始化方法
 def __init__(self,name,age)
 	self.name=name#self.name,self.age为实例属性,进行了一个将局部变量赋值给实例属性的操作
 	self.age=age


 #实例方法（）
 def info(self):
 	print("我的名字叫：",self.name,"年龄是："， self.age)
 
 #类方法
 @classmethod
 def cm(cls):
 	print('类方法')
 

#静态方法
 @staticmethod
 def sm():
 	print('静态方法')			

实例的创建
对象的创建又称为类的实例化

调用类方法

stu1=Student(' 张三'，20)
stu1.info()
#上下两种方法相同
Student.eat(stu1)

动态绑定属性和方法
python是动态语言，在创建对象之后，可以动态的绑定属性和方法

def show():
	print('我是一个函数')
stu=Student('jack',20)
stu.gender='男'#动态绑定性别
stu.show=show#动态绑定方法
stu.show

面向对象的三大特征
封装：提高程序安全性
将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无需关系方法内部具体实现细节，隔离复杂度
在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面使用两个“_”。但是可以在类的内部被使用。

class Student():
	def __init__(self,name,age):
		self.name=name
		self.__age=age
	def show(self):
		print(self.name,self.__age)
stu=Student('张三',20)
stu.show()
print(self.name)
print(self.__age)#不可执行
#可通过特殊方法访问
print(dir(stu))
print(stu._Student__age)

输出结果

张三 20
张三
['_Student__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'show']
20

继承：提高代码复用性
语法格式

 class 子类类名（父类1，父类2.....）
 	pass

如果一个类没有继承任何类，则默认继承object类
python支持多继承
定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object):
	def __init__(self,name,age)
		self.name=name
		self.name=age
	def info(self):
		print(self.name，self.name)
class Student(Person):
	def __init__(self,name,age,stu_no):
		super().__init__(name,age)
		self.stu_no 
stu=Student('lihua',20,20201314)
stu.info() 

方法重写
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行从重新编写
子类重写后，可以用super().xxx()调用之前未被重写的方法

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.name=age
	def info(self):
		print(self.name)
class Student(Person):
	def __init__(self,name,age,stu_no):
		super().__init__(name,age)
		self.stu_no=stu_no
	def info(self):
		print(self.stu_no)
	def ago(self):
		super().info()
		
stu = Student('张三', 20,2000000)
stu.info()
stu.ago()

object类
如python之继承及其实现方法这一节提到过的，object类是所有类的父类，因此所有类都有object类的属性和方法。
如python之封装及私有方法使用过的，内置函数dir()可以查看指定对象所有属性
object有一个_str_()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写

class Slowsnail(object):  # 这里的object可写可不写，不写就默认为object
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __str__(self):
        return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)
sws_1 = Slowsnail('慢蜗牛', 20)
print(dir(sws_1))
print(sws_1)

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是慢蜗牛，今年20岁了

多态
多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数

class Animal(): #同一类事物:动物
    def talk(self):
        pass

class Cat(Animal): #动物的形态之一:猫
    def talk(self):
        print('say miaomiao')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

c = Cat()
d = Dog()
p = Pig()

def func(obj):
    obj.talk()

func(c)
func(d)
func(p)

>>> say miaomiao
>>> say wangwang
>>> say aoao

多态性的好处:

增加了程序的灵活性,以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(obj)
增加了程序额可扩展性,通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(obj)去调用
鸭子类型
调用不同的子类将会产生不同的行为，而无须明确知道这个子类实际上是什么，这是多态的重要应用场景。而在python中，因为鸭子类型(duck typing)使得其多态不是那么酷。

鸭子类型是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定。
在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为"鸭子"的对象，并调用它的"走"和"叫"方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的"走"和"叫"方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的"走"和"叫"方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

鸭子类型通常得益于不测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用

class Duck():
    def walk(self):
         print('I walk like a duck')
    def swim(self):
         print('i swim like a duck')
 
class Person():
    def walk(self):
     　　print('this one walk like a duck') 
    def swim(self):
     　　print('this man swim like a duck')

可以很明显的看出，Person类拥有跟Duck类一样的方法，当有一个函数调用Duck类，并利用到了两个方法walk()和swim()。我们传入Person类也一样可以运行，函数并不会检查对象的类型是不是Duck，只要他拥有walk()和swim()方法，就可以正确的被调用。

再举例，如果一个对象实现了__getitem__方法，那python的解释器就会把它当做一个collection，就可以在这个对象上使用切片，获取子项等方法；如果一个对象实现了__iter__和next方法，python就会认为它是一个iterator，就可以在这个对象上通过循环来获取各个子项。

特殊属性与特殊方法
特殊方法（特殊成员）：这类方法名字特殊，有特殊用途，会自动调用。
因为特殊又会自动调用，大家也叫做魔术方法（魔法方法）。
特殊方法组成：固定命名-开头结尾都是双下划线
常用特殊方法详解