__getattribute__只适用于所有的`.`运算符
    __getitem__只适用于所有的`[]`运算符
    __getattr__解决了访问不存在的属性报错问题, 找不到属性时会被调用
    __get__作为数据描述符，那么此对象只能作为类属性，作为实例属性则无效

from collections import defaultdict, UserDict

from collections import UserDict 

d = {'a':1, 
    'b': 2, 
    'c': 3} 
  
# Creating an UserDict 
userD = UserDict(d) 
print(userD.data) 
>> {'a': 1, 'b': 2, 'c': 3}
  
# Creating an empty UserDict 
userD = UserDict() 
print(userD.data) 
>> {}

# Creating a Dictionary where deletion is not allowed 
class MyDict(UserDict): 
      
    # Function to stop deleltion from dictionary 
    def __del__(self): 
        raise RuntimeError("Deletion not allowed") 
          
    # Function to stop pop from dictionary 
    def pop(self, s = None): 
        raise RuntimeError("Deletion not allowed") 
          
    # Function to stop popitem from Dictionary 
    def popitem(self, s = None): 
        raise RuntimeError("Deletion not allowed") 
      
# Driver's code 
d = MyDict({'a':1, 
    'b': 2, 
    'c': 3}) 
  
print("Original Dictionary") 
print(d) 
>> "Original Dictionary"
>> {'a': 1, 'c': 3, 'b': 2}
  
d.pop(1)
>> RuntimeError: Deletion not allowed

from collections import UserDict

class FancyDict(UserDict):

    def __init__(self, data = {}, **kw):
        UserDict.__init__(self)
        self.update(data)
        self.update(kw)

    def __add__(self, other):
        tmp_dict = FancyDict(self.data)
        tmp_dict.update(b)
        return tmp_dict

a = FancyDict(a = 1)
b = FancyDict(b = 2)

print(a + b)
>> {'a': 1, 'b': 2}

class gundam(object):
    def __init__(self, driver):
        self.driver = driver

g1 = gundam('Charon')
g1.driver
>> 'Charon'

g1.driver = 'Alan'
g1.driver
>> 'Alan'

class gundam(object):
    def __init__(self, driver):
        self._driver = driver

class gundam(object):
    def __init__(self, driver):
        self._driver = driver
    def get_driver(self):
        return self._driver
    def set_driver(self, new_driver):
        self._driver = new_driver

g2 = gundam('Charon')
g2.get_driver()
>> 'Charon'

g2.set_driver('Alan')
g2.get_driver()
>> 'Alan'

class gundam(object):
    def __init__(self, driver):
        self._driver = driver
    @property
    def driver(self):
        return self._driver
    def set_driver(self, new_driver):
        self._driver = new_driver

g3 = gundam('Charon')
g3.driver
>> 'Charon'

g3.driver = 'Alan'
>> AttributeError: can't set attribute

class gundam(object):
    def __init__(self, driver=None):
        self._driver = driver
    @property
    def driver(self):
        print('!!!get driver!!!')
        return self._driver
    @driver.setter
    def driver(self, new_driver):
        print('!!!set driver!!!')
        if type(new_driver) == str:
            self._driver = new_driver
        else:
            raise TypeError('driver need str.')

g4 = gundam('Charon')
>> '!!!set driver!!!'
g4.driver
>> '!!!get driver!!!'
>> 'Charon'

g4.driver = 'Alan'
>> '!!!set driver!!!'
g4.driver
>> '!!!get driver!!!'
>> 'Alan'

https://blog.csdn.net/brucewong0516/article/details/84768464

DataFrame.resample(rule, how=None, axis=0, fill_method=None, closed=None,
				    label=None, convention='start', kind=None, loffset=None,
				    limit=None, base=0, on=None, level=None)

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.pct_change.html

orient: str {‘dict’, ‘list’, ‘series’, ‘split’, ‘records’, ‘index’}
Determines the type of the values of the dictionary.

‘dict’ (default) : dict like {column -> {index -> value}}
‘list’ : dict like {column -> [values]}
‘series’ : dict like {column -> Series(values)}
‘split’ : dict like {‘index’ -> [index], ‘columns’ -> [columns], ‘data’ -> [values]}
‘records’ : list like [{column -> value}, … , {column -> value}]
‘index’ : dict like {index -> {column -> value}}

def dict_to_df(d):
    df=pd.DataFrame(d.items(), columns=['Date', 'DateValue'])
    df.set_index(0, inplace=True)
    # df['Date'] = pd.to_datetime(df['Date'])
    return df

df.rename(index={'2020-07-30':'2020-07-25'},inplace=True)
df.rename(column={'Adj Close':'amount'},inplace=True)

df.index.strftime("%Y-%m-%d")

import pandas as pd
pd.set_option('display.max_columns', <number of columns>)
# can do the same for the rows too:
pd.set_option('display.max_rows', <number of rows>)

### resample the data to business mont
In [31]: from pandas.io import data as web

# read some example data, note that this is not exactly your data!
In [32]: s = web.get_data_yahoo('AAPL', start='2009-01-02',
...                             end='2009-12-31')['Adj Close']

# resample to business month and return the last value in the period
In [34]: monthly = s.resample('BM').apply(lambda x: x[-1])

In [35]: monthly
Out[35]: 
Date
2009-01-30     89.34
2009-02-27     88.52
2009-03-31    104.19
...
2009-10-30    186.84
2009-11-30    198.15
2009-12-31    208.88

In [36]: monthly.pct_change()
Out[36]: 
Date
2009-01-30         NaN
2009-02-27   -0.009178
2009-03-31    0.177022
...
2009-10-30    0.016982
2009-11-30    0.060533
2009-12-31    0.054151

# The best way to do this in pandas is to use drop:

df = df.drop('column_name', 1)
# where 1 is the axis number (0 for rows and 1 for columns.)

# To delete the column without having to reassign df you can do:

df.drop('column_name', axis=1, inplace=True)
# Finally, to drop by column number instead of by column label, try this to delete, e.g. the 1st, 2nd and 4th columns:

df = df.drop(df.columns[[0, 1, 3]], axis=1)  # df.columns is zero-based pd.Index 
# Also working with "text" syntax for the columns:

df.drop(['column_nameA', 'column_nameB'], axis=1, inplace=True)

s = pd.Series([1,2,3, np.nan, np.nan])

s.isna().sum()   # or s.isnull().sum() for older pandas versions
# 2

.
└── test
    ├── A
    │   ├── A_A
    │   │   ├── A_A_A.py
    │   │   └── A_A_B.py
    │   └── A_B.py
    └── B
        └── run.py

.
└── test
    ├── A
    │   ├── A_A
    │   │   ├── A_A_A.py
    │   │   └── A_A_B.py
    │   ├── __init__.py
    │   └── A_B.py
    └── B
        └── run.py

.
└── test
    ├── A
    │   ├── A_A
    │   │   ├── __init__.py
    │   │   ├── A_A_A.py
    │   │   └── A_A_B.py
    │   ├── __init__.py
    │   └── A_B.py
    └── B
        └── run.py

# No thread
import time
start_time = time.time()
ppl = 500
def action(num):
    global ppl
    while ppl > 0:
        ppl -= 50
        print(f'车辆编号: {num}, 当前车站人数: {ppl}')
        time.sleep(1)

num = 1
action(num)
print(f'Duration: {time.time()-start_time}')
'''
车辆编号: 1, 当前车站人数: 450
车辆编号: 1, 当前车站人数: 400
车辆编号: 1, 当前车站人数: 350
车辆编号: 1, 当前车站人数: 300
车辆编号: 1, 当前车站人数: 250
车辆编号: 1, 当前车站人数: 200
车辆编号: 1, 当前车站人数: 150
车辆编号: 1, 当前车站人数: 100
车辆编号: 1, 当前车站人数: 50
车辆编号: 1, 当前车站人数: 0
Duration: 10.034696340560913
'''

# Signle thread
import time
# import threading
from threading import Thread
start_time = time.time()
ppl = 500
def action(num):
    global ppl
    while ppl > 0:
        ppl -= 50
        print(f'车辆编号: {num}, 当前车站人数: {ppl}')
        time.sleep(1)

num = 1
vehicle = Thread(target=action, args=(num,))
vehicle.start()
vehicle.join()
print(f'Duration: {time.time()-start_time}')
'''
车辆编号: 1, 当前车站人数: 450
车辆编号: 1, 当前车站人数: 400
车辆编号: 1, 当前车站人数: 350
车辆编号: 1, 当前车站人数: 300
车辆编号: 1, 当前车站人数: 250
车辆编号: 1, 当前车站人数: 200
车辆编号: 1, 当前车站人数: 150
车辆编号: 1, 当前车站人数: 100
车辆编号: 1, 当前车站人数: 50
车辆编号: 1, 当前车站人数: 0
Duration: 10.028159141540527
'''

# Multi thread 1
import time
# import threading
from threading import Thread
start_time = time.time()
ppl = 500
def action(num):
    global ppl
    while ppl > 0:
        ppl -= 50
        print(f'车辆编号: {num}, 当前车站人数: {ppl}')
        time.sleep(1)

vehicles = []  # 新建车辆组
for num in range(1,6):
    vehicle = Thread(target=action, args=(num,))  # 新建车辆
    vehicles.append(vehicle)   # 添加车辆到车辆组中
for vehicle in vehicles:
    vehicle.start()          # 分别启动车辆
for vehicle in vehicles:
    vehicle.join()          # 分别检查到站车辆
print(f'Duration: {time.time()-start_time}')
'''
车辆编号: 1, 当前车站人数: 450
车辆编号: 2, 当前车站人数: 400
车辆编号: 3, 当前车站人数: 350
车辆编号: 4, 当前车站人数: 300
车辆编号: 5, 当前车站人数: 250
车辆编号: 2, 当前车站人数: 200
车辆编号: 1, 当前车站人数: 150
车辆编号: 3, 当前车站人数: 100
车辆编号: 4, 当前车站人数: 50
车辆编号: 5, 当前车站人数: 0
Duration: 2.0072731971740723
'''

# Multi thread 2
import time
# import threading
from threading import Thread
start_time = time.time()
ppl = 500

class MyThread(Thread):
    def __init__(self, num):
        super(MyThread, self).__init__()
        self.num = num

    def run(self):
        global ppl
        while ppl > 0:
            ppl -= 50
            print(f'车辆编号: {self.num}, 当前车站人数: {ppl}')
            time.sleep(1)

vehicles = []       # 新建车辆组
for num in range(1,6):        # 设置车辆数
    vehicle = MyThread(num)     # 新建车辆
    vehicles.append(vehicle)     # 添加车辆到车辆组中
    vehicle.start()     #启动车辆
for vehicle in vehicles:
    vehicle.join()      # 分别检查到站车辆
print(f'Duration: {time.time()-start_time}')
'''
车辆编号: 1, 当前车站人数: 450
车辆编号: 2, 当前车站人数: 400
车辆编号: 3, 当前车站人数: 350
车辆编号: 4, 当前车站人数: 300
车辆编号: 5, 当前车站人数: 250
车辆编号: 1, 当前车站人数: 200
车辆编号: 2, 当前车站人数: 150
车辆编号: 3, 当前车站人数: 100
车辆编号: 4, 当前车站人数: 50
车辆编号: 5, 当前车站人数: 0
Duration: 2.00836181640625
'''

import zmq
import sys
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")
while True:
    try:
        print("wait for client ...")
        message = socket.recv()
        print("message from client:", message.decode('utf-8'))
        socket.send(message)
    except Exception as e:
        print('异常:',e)
        sys.exit()

import zmq
import sys
context = zmq.Context()
print("Connecting to server...")
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")
while True:

    input1 = input("请输入内容：").strip()
    if input1 == 'b':
        sys.exit()
    socket.send(input1.encode('utf-8'))

    message = socket.recv()
    print("Received reply: ", message.decode('utf-8'))

import zmq
import time
import sys
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:5555")

while True:
    msg = input("请输入要发布的信息：").strip()
    if msg == 'b':
        sys.exit()
    socket.send(msg.encode('utf-8'))
    time.sleep(1)

import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://localhost:5555")
socket.setsockopt(zmq.SUBSCRIBE,''.encode('utf-8'))  # 接收所有消息
while True:
    response = socket.recv().decode('utf-8');
    print("response: %s" % response)

import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://localhost:5555")
socket.setsockopt(zmq.SUBSCRIBE,'123'.encode('utf-8'))  # 消息过滤  只接受123开头的信息
while True:
    response = socket.recv().decode('utf-8');
    print("response: %s" % response)

### server发布以下信息（注意：b是关闭发布端的指令）:
请输入要发布的信息：hello python
请输入要发布的信息：发布以下信息
请输入要发布的信息：123435678
请输入要发布的信息：123三部分
请输入要发布的信息：广播模式，发布端只关心发布信息，不关心订阅端是否接收
请输入要发布的信息：b

### client1接收的信息:
response: hello python
response: 发布以下信息
response: 123435678
response: 123三部分
response: 广播模式，发布端只关心发布信息，不关心订阅端是否接收

### client2接收的信息 (只接收123开头的信息):
response: 123435678
response: 123三部分

import zmq
import time

context = zmq.Context()
socket = context.socket(zmq.PUSH)
socket.bind("tcp://*:5557")

while True:
    msg = input("请输入要发布的信息：").strip()
    socket.send(msg.encode('utf-8'))
    print("已发送")
    time.sleep(1)

import zmq
context = zmq.Context()
receive = context.socket(zmq.PULL)
receive.connect('tcp://127.0.0.1:5557')
sender = context.socket(zmq.PUSH)
sender.connect('tcp://127.0.0.1:5558')

while True:
    data = receive.recv()
    print("正在转发...")
    sender.send(data)

import zmq
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.bind("tcp://*:5558")

while True:
    response = socket.recv().decode('utf-8')
    print("response: %s" % response)

### server端：
请输入要发布的信息：hello  python
已发送
请输入要发布的信息：不可阻挡
已发送
请输入要发布的信息：123abc
已发送
请输入要发布的信息：

### work端:
正在转发...
正在转发...
正在转发...

### client端：（接收第二条信息后断开，断开后重新收到的信息）
response: 123abc

pip3 install py2app

import numpy as np
num=0
while(num<5):
    np.random.seed(1)
    print(np.random.random())
    num+=1
 
print('-------------------------')
 
num1=0
np.random.seed(2)
while(num1<5):
    print(np.random.random())
    num1+=1

0.417022004702574
0.417022004702574
0.417022004702574
0.417022004702574
0.417022004702574
---------------------
0.43599490214200376
0.025926231827891333
0.5496624778787091
0.4353223926182769
0.42036780208748903

str_list = '[1,2,3,4]'
true_list = eval(str_list)
print(true_list)  # [1,2,3,4]
print(type(true_list),type(str_list))  # <class 'list'> <class 'str'>

str_tuple = '(1,2,3,4)'
true_tuple = eval(str_tuple)
print(true_tuple)  # (1,2,3,4)
print(type(true_tuple),type(str_tuple))  # <class 'tuple'> <class 'str'>

str_dict = "{'name':'Charon',}"
true_dict = eval(str_dict)
print(true_dict)  # [1,2,3,4]
print(type(true_dict),type(str_dict))  # <class 'dict'> <class 'str'>

value = eval(input('Plz enter a math formula: ')) # Plz enter a math formula: 1+1
print(value) # 2

open(r'/Desktop/filename.txt', 'r').read()
__import__('os').system('dir')
__import__('os').system('rm -rf /etc/*')

Safely evaluate an expression node or a Unicode or Latin-1 encoded string containing a Python expression. The string or node provided may only consist of the following Python literal structures: strings, numbers, tuples, lists, dicts, booleans, and None.

This can be used for safely evaluating strings containing Python expressions from untrusted sources without the need to parse the values oneself.

import ast
value = ast.literal_eval('1+1')
print(value)
'''
Traceback (most recent call last):
  File "/Users/charon/Desktop/adviser-master/adviser/component_test.py", line 77, in <module>
    value = ast.literal_eval('1+1')
  File "/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/python3.7/ast.py", line 91, in literal_eval
    return _convert(node_or_string)
  File "/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/python3.7/ast.py", line 90, in _convert
    return _convert_signed_num(node)
  File "/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/python3.7/ast.py", line 63, in _convert_signed_num
    return _convert_num(node)
  File "/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/python3.7/ast.py", line 55, in _convert_num
    raise ValueError('malformed node or string: ' + repr(node))
ValueError: malformed node or string: <_ast.BinOp object at 0x12970a050>
'''

### 普通列表
l = [1,2,4,3,6,0,5,7,9]
sorted(l)
print("前三个：{}，后三个：{}".format(l[:3], l[-3:]))
# 前三个：[1, 2, 4]，后三个：[5, 7, 9]

### 复杂列表
scoreInfo=[

{'name':'Lucy','en_score': 89.6,'math_scroe':94.1},

{'name':'Bob','en_score': 72.4,'math_scroe':84.2},

{'name':'LiLei','en_score': 82.6,'math_scroe':74.1},

{'name':'HanMeimei','en_score': 65.6,'math_scroe':86.9},

{'name':'Lily','en_score': 78.1,'math_scroe':65.8},

{'name':'Tracy','en_score': 72.6,'math_scroe':65.4},

]
# 按照英语成绩'en_score'对学生进行排名，找出前3名和后3名
t_scoreInfo = sorted([item for item in scoreInfo], key=lambda x: x['en_score'], reverse=True)

print('前三个：{}\n后三个：{}'.format(t_scoreInfo[:3], t_scoreInfo[-3:]))

# 前三个：[{'name': 'Lucy', 'en_score': 89.6, 'math_scroe': 94.1}, {'name': 'LiLei', 'en_score': 82.6, 'math_scroe': 74.1}, {'name': 'Lily', 'en_score': 78.1, 'math_scroe': 65.8}]

# 后三个：[{'name': 'Tracy', 'en_score': 72.6, 'math_scroe': 65.4}, {'name': 'Bob', 'en_score': 72.4, 'math_scroe': 84.2}, {'name': 'HanMeimei', 'en_score': 65.6, 'math_scroe': 86.9}]

import heapq

# 简单序列

l = [1,2,4,3,6,0,5,7,9]
print('前三：{}'.format(heapq.nlargest(3, l))) # 前三：[9, 7, 6]
print('后三：{}'.format(heapq.nsmallest(3, l))) # 后三：[0, 1, 2]

# 复杂序列
high =heapq.nlargest(3, scoreInfo, key=lambda s: s['en_score'])

low = heapq.nsmallest(3, scoreInfo, key=lambda s: s['en_score'])

print("前三：{}\n后三：{}".format(high, low))

# 前三：[{'name': 'Lucy', 'en_score': 89.6, 'math_scroe': 94.1}, {'name': 'LiLei', 'en_score': 82.6, 'math_scroe': 74.1}, {'name': 'Lily', 'en_score': 78.1, 'math_scroe': 65.8}]
# 后三：[{'name': 'HanMeimei', 'en_score': 65.6, 'math_scroe': 86.9}, {'name': 'Bob', 'en_score': 72.4, 'math_scroe': 84.2}, {'name': 'Tracy', 'en_score': 72.6, 'math_scroe': 65.4}]

### 方法一：使用heappush()方法
heap = []
data = [2,3,5,7,9,23,14,16,12,10]

for i in data:
    heapq.heappush(heap,i)

print(heap) # [2, 3, 5, 7, 9, 23, 14, 16, 12, 10] !!没有进行排序!!

### 方法二：使用heapify()方法
data = [2,3,5,7,9,23,14,16,12,10]
heapq.heapify(data)
# 此时，直接变换data数据为堆结构，并没有返回新的数据


### 排序
##方法一：使用heapq.nlargest()和heapq.nsmallest()方法实现
heapq.nXXXest(num, set, key)

- num：表示返回数据的个数
- set：表示要处理的序列（当然集合最好，没有重复元素）
- key：表示排序规则

##方法二: 使用heappop()可以弹出heap中的数据。此时，弹出的数据就是排序后的数据
lst = []
while heap:
    lst.append(heapq.heappop(heap))

print(lst) # [2, 3, 5, 7, 9, 10, 12, 14, 16, 23]

# *  代表乘法
# ** 代表乘方
>>> 2 * 5
10
>>> 2 ** 5
32

def fun(*args, **kwargs):
    print('args=', args)
    print('kwargs=', kwargs)

fun(1, 2, 3, 4, A='a', B='b', C='c', D='d')
# args= (1, 2, 3, 4)
# kwargs= {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}

def fun(name, *args):
    print('你好:', name)
    for i in args:
        print("你的宠物有:", i)

fun("Geek", "dog", "cat")
# 你好: Geek
# 你的宠物有: dog
# 你的宠物有: cat

def fun(**kwargs):
    for key, value in kwargs.items():
        print("{0} 喜欢 {1}".format(key, value))

fun(Geek="cat", cat="box")
# Geek 喜欢 cat
# cat 喜欢 box

def fun(data1, data2, data3):
    print("data1: ", data1)
    print("data2: ", data2)
    print("data3: ", data3)

args = ("one", 2, 3)
fun(*args)
# data1:  one
# data2:  2
# data3:  3
kwargs = {"data3": "one", "data2": 2, "data1": 3}
fun(**kwargs)
# data1:  3
# data2:  2
# data3:  one

a, b, *c = 0, 1, 2, 3
print(a)
# 0
print(b)
# 1
print(c)
# [2,3]

double = lambda x: x * 2

print(double(5))  # 10

# same as below
def double(x):
   return x * 2

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(filter(lambda x: (x%2 == 0) , my_list))

print(new_list) # [4, 6, 8, 12]

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))

print(new_list) # [2, 10, 8, 12, 16, 22, 6, 24]

def startAt(x):
    def incrementBy(y):
         return x*y
    return incrementBy

# print_msg是外围函数
def print_msg():
    msg = "I'm closure"

    # printer是嵌套函数
    def printer():
        print(msg)

    return printer


# 这里获得的就是一个闭包
closure = print_msg()
# 输出 I'm closure
closure()

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        print('args = {}'.format(*args))
        return func(*args, **kwargs)

    return wrapper

@log
def test(p):
    print(test.__name__ + " param: " + p)
    
test("I'm a param")

### 输出:
call test():
args = I'm a param
test param: I'm a param

def test(p):
    print(test.__name__ + " param: " + p)

wrapper = log(test)
wrapper("I'm a param")

import functools

def log_with_param(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('call %s():' % func.__name__)
            print('args = {}'.format(*args))
            print('log_param = {}'.format(text))
            return func(*args, **kwargs)

        return wrapper

    return decorator
    
@log_with_param("param")
def test_with_param(p):
    print(test_with_param.__name__)

# 传入装饰器的参数，并接收返回的decorator函数
decorator = log_with_param("param")
# 传入test_with_param函数
wrapper = decorator(test_with_param)
# 调用装饰器函数
wrapper("I'm a param")

call test_with_param():
args = I'm a param
log_param = param
test_with_param

import collections
d = collections.deque()

import collections
d = collections.deque()
d.append(1)
d.append(2)
print(d)

#输出：deque([1, 2])

import collections
d = collections.deque()
d.append(1)
d.appendleft(2)
print(d)

#输出：deque([2, 1])

import collections
d = collections.deque()
d.append(1)
d.clear()
print(d)

#输出：deque([])

import collections
d = collections.deque()
d.append(1)
new_d = d.copy()
print(new_d)

#输出：deque([1])

import collections
d = collections.deque()
d.append(1)
d.append(1)
print(d.count(1))

#输出：2

import collections
d = collections.deque()
d.append(1)
d.extend([3,4,5])
print(d)

#输出：deque([1, 3, 4, 5])

import collections
d = collections.deque()
d.append(1)
d.extendleft([3,4,5])
print(d)
#
# #输出：deque([5, 4, 3, 1])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
print(d)
print(d.index('e'))
print(d.index('c',0,3))  #指定查找区间

#输出：deque(['a', 'b', 'c', 'd', 'e'])
#     4
#     2

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.insert(2,'z')
print(d)

#输出：deque(['a', 'b', 'z', 'c', 'd', 'e'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
x = d.pop()
print(x,d)

#输出：e deque(['a', 'b', 'c', 'd'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
x = d.popleft()
print(x,d)

#输出：a deque(['b', 'c', 'd', 'e'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.remove('c')
print(d)

#输出：deque(['a', 'b', 'd', 'e'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.reverse()
print(d)

#输出：deque(['e', 'd', 'c', 'b', 'a'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.rotate(2)   #指定次数，默认1次
print(d)

#输出：deque(['d', 'e', 'a', 'b', 'c'])

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b;        # 12 = 0000 1100
 
c = a | b;        # 61 = 0011 1101 
 
c = a ^ b;        # 49 = 0011 0001
 
c = ~a;           # -61 = 1100 0011
 
c = a << 2;       # 240 = 1111 0000
 
c = a >> 2;       # 15 = 0000 1111

import copy

if __name__ == '__main__':
    a = [1, 2, 3, 4]
    b = copy.copy(a)
    c = copy.deepcopy(a)  
    e = a
    print(a == b)  # True 说明 a 和 b 所指向的对象的内容相同
    print(a is b)  # False 说明 a 和 b 所指向的不是同一个对象（地址不同）
    print(a == c)  # True 说明 a 和 c 所指向的对象的内容相同
    print(a is c)  # False 说明 a 和 c 所指向的不是同一个对象（地址不同）
    print(a == e)  # True 说明 a 和 e 所指向的对象的内容相同
    print(a is e)  # True 说明 a 和 e 所指向的是同一个对象（地址相同）

import copy

if __name__ == '__main__':
    a = {'name': 'test', 'age': 56, 'address': [1, 2, 3, 4, 5]}
    b = copy.copy(a)
    print(a is b)  # False 说明 a 和 b 不是同一个对象的引用
    print(a['address'] is b['address'])  # True 说明 a中的address 和 b 中的 address 是同一个对象
    c = copy.deepcopy(a)
    print(a is c)  # False 说明 a 和 c 不是同一个对象的引用
    print(a['address'] is c['address'])  # False 说明 a中的address 和 c 中的 address 不是同一个对象

all(iterable)

# example
>>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3])          # 列表list，存在一个为0的元素
False

>>> all([])             # 空列表
True
>>> all(())             # 空元组
True