元祖()  无
列表[]
    增：append ,(追加) insert(通过索引插入指定位置) ,extend(迭代着添加)
    改：通过索引修改,通过切片去改。
    删：pop ,remove,clear,del
    查：按照切片去查，循环去查
字典{}
    增：dic['k']='v'（没有增加，有的话覆盖） , setdefault(有责不变，没有添加）
    改：dic['k']='v'（没有增加，有的话覆盖），updete(dic2.update(dic)#有则覆盖，没有就添加  将dic里面的所有键值对 覆盖添加到dic2中，dic不变)
    删：,pop(有返回值)，del,clear, popitem()（随机删除）
    查：print(dic.get('name1','没有此值'))#可以配置参数,循环
集合{}
    增：add
    改：update
    删：remove pop clear del

def g():
    yield 1
    yield 2
    yield 3

g1 = g()

print(next(g1))
print(next(g1))
print(next(g1))

li = (x ** 2 for x in range(1,11,2))
for i in li:
    print(i)

实例1
class Person:
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return self.__name
a = Person('abc')
print(a.name)


实例2
作用：属性伪装

class A:
    @property
    def name(self):
        print('光头你行不行！')

a = A()
a.name

def wrapper(func):
    def inner(*arg, **kwargs):
        func(*arg, **kwargs)

    return inner

def a(arg):
    print(arg)

a()

在a() 之前加入 a=wrapper(a),并且将a()改成a(6)；
在a() 之前加入 a=wrapper(a)，可以组成装饰器，def 函数需要传参数才能调用成功，所以需要在括号里面传个任意参数

def wrapper(f):
    def inner(*args,**kwargs):
        '''执行被装饰函数之前的操作'''
        ret = f(*args,**kwargs)
        """执行被装饰函数之后的操作"""
        return ret
    return inner


def f(func):
    def g(*args,**kwargs):
        ret = func(*args,**kwargs)
        return ret
    return g

def a(age):
    print(age)

print(a)

def login():
    print('登录成功!')


def registered():
    print('欢迎注册!')


def index():
    print('成功访问主页!')


import sys

web_list = [login, registered, index]
choice = input("请输入你要访问的url>>>：")
getattr(sys.modules['__main__'], choice)()  # 在自己所在的文件夹中反射全局变量

import test2

str_input = input("请输入你要访问的url>>>：")
try:
    getattr(test2,str_input)()
except Exception:
    print('输入错误！')

import random

def red_packet(money, count):
    l = random.sample(range(0, 100 * money), count - 1)  # 列表元素任意count-1个组合
    l.extend([0, 100 * money])  # 迭代着添加两个数
    l1 = sorted(l, reverse=True)  # 从大到小排序
    for i in range(len(l1) - 1):  # 节省内存
        yield (l1[i] - l1[i + 1]) / 100

obj = red_packet(10, 10)
red_packet(10, 10)
print(obj.__next__())  # 一个一个输出
print(obj.__next__())
for i in obj:  # 剩下的一次性输出完
    print(i)

def f（


    x, l = []）：
for i in range（x）：
l.append（i * i）
print
l

f(2)
f(3, [3, 2, 1])  # 将[3, 2, 1]传给l，会覆盖之前的列表 ，l = []是默认参数
f(3)


[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]

服务端
import socket
from multiprocessing import Process


def con(conn):
    while True:
        conn.send(b'hello')
        print(conn.recv(1024))
    conn.close()


if __name__ == '__main__':
    sk = socket.socket()

    sk.bind(('127.0.0.1', 8080))
    sk.listen(10)
    try:
        while True:
            conn, addr = sk.accept()
            Process(target=con, args=(conn,)).start()
            # 每过来一个客户端来连接，就开一个子进程来和客户沟通，可以实现同时和多个客户沟通
    finally:
        sk.close()  # 意外退出后可自动回收资源（端口等）
客户端
import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 8080))  # 一定要注意，里面是元祖形式
while True:
    ret = sk.recv(1024)
    print(ret)
    msg = input('>>>').encode('utf-8')
    sk.send(msg)
sk.close()

from gevent import monkey

monkey.patch_all()
import socket
import gevent


def talk(conn):
    while True:
        conn.send(b'hello')
        msg = conn.recv(1024)
        print(msg)
    conn.close()


sk = socket.socket()
sk.bind(('127.0.0.1', 9000))
sk.lieten(5)

while True:
    conn, addr = sk.accept()
    gevent.spawn(talk, conn)
sk.close()

客户端
import socket
from threading import Thread
def client():
    sk=socket.socket()
    sk.connect(('127.0.0.1',9000))
    while True:
        msg=sk.recv(1024)
        print(msg)
        ret=input('>>>').encode('utf-8')
        sk.send(ret)
    sk.close()
if __name__ == '__main__':
    for i in range(500):
        Thread(target=client).start()

class Person:
    def __init__(self, name, hp, weapon, sex):
        self.name = name
        self.hp = hp
        self.weapon = weapon
        self.sex = sex

class Police(Person):
    role = 'police'
    def attack1(self,terrorist):
        terrorist.hp = self.hp - self.weapon
        if terrorist.hp <= 0:
            print(" %s被%s击杀！！" % ( terrorist.name, self.name))
        else:
            print(" %s遭到%s攻击，还剩%s血量！" % (terrorist.name, self.name, terrorist.hp))

class Terrorist(Person):
    role = 'terrorist'
    def attack2(self,police):
        police.hp = self.hp - self.weapon
        if police.hp <= 0:
            print(" %s被%s击杀！！" % ( police.name, self.name))
        else:
            print(" %s遭到%s攻击，还剩%s血量！" % (police.name, self.name, police.hp))


police = Police("police", 300, 120, "male")

terrorist = Terrorist("terrorist", 200, 80, "male")

police.attack1(terrorist)
terrorist.attack2(police)

class Person:
    def __init__(self,name,hp,weapon,gender):
        self.name = name
        self.hp = hp
        self.weapon = weapon
        self.gender = gender


    def tattack(self,tk):
        if self.juese == tk.juese:
            print('队长，别开枪！')
        else:
            print(f'{self.name }攻击了{tk.name }!')
            if self.weapon > tk.hp:
                tk.hp = 0
                print(f'{tk.name }死亡,剩余血量{tk.hp}')
            else:
                tk.hp -= self.weapon
                print(f'{tk.name }剩余血量{tk.hp}')


class Police(Person):
    juese = 'police'

class Terrorist(Person):
    juese = 'terrorist'

t1 = Terrorist('恶匪001',100,10,'male')
p1 = Police('捕快001',100,10,'male')

while True:
    t1.tattack(p1)
    if p1.hp == 0 :
        print('恶匪气焰嚣张!')
        break
    p1.tattack(t1)
    if t1.hp == 0 :
        print('恶匪被消灭!')
        break

data = {"time": "2016-08-05T13:13:05",
        "some_id": "ID1234",
        "grp1": {"fld1": 1,"fld2": {'name':'xiaoming',"fld2":111}},
        "xxx2": {"fld3": 0,
                 "fld5": 0.4},
        "fld6": 11,
        "fld7": 7,
        "fld46": 8}
fields='fld2|fld3|fld7|fld19'

dic={}
def search(data,fields):
    # l1=fields.split('|')

    for k,v in data.items():
        if k in fields:
            dic[k]=v
        if type(v) == dict:
            search(v, fields)  # 递归
    return dic
print(search(data,fields))