path = r"aa/"
path1 = r'bb/'
# 如果path路径不加'/'的话,默认是从运行路径再加aa
os.getcwd() 
#'/home/python'
# 运行ipython的路径,如果是python3 /home/python/app1.6/runner.py
# 则是/home/python/app1.6
os.path.abspath(path) # path规范化的绝对路径
#'/home/python/aa'
os.path.join(os.getcwd(),path,path1)
#'/home/python/aa/bb/'
os.path.normpath(os.path.join(os.getcwd(),path,path1)) 
# path规范化的绝对路径
#'/home/python/aa/bb'
将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.join('/home/python','/','aa','/home/')
# '/home/'

os.path.exists(path)# 如果path存在,返回True;如果path不存在,返回False.
os.path.isabs(os.getcwd()) # 如果只要path是绝对路径,不管是不是存在,返回True
os.path.isfile(path) 
os.path.isdir(path)
'1.jpg'.endswith('.jpng') # False
# 计算此文件的大小 
(os.path.getsize(abspath))/1024/1024 # byte/k/M
#改变一个文件的文件名
os.rename(os.path.join('abspath','filename'), \
    os.path.join('abspath','new_name'))
# 如果没有则创建目录,有的话就没原来的,防止
os.makedirs('/home/python/1/1/1',exist_ok=True)

os.path.splitext(r'/home/python/22.json')
#('/home/python/22', '.json')
os.path.split('/home/python/app1.6/1.txt')
# 将path分割成目录和文件名二元组返回
#('/home/python/app1.6', '1.txt')
os.path.dirname('/home/python/app1.6/1.txt') 
# 相当于os.path.split(path)的第一元素
#'/home/python/app1.6'
os.path.basename('/home/python/app1.6/1.txt') 
# 相当于os.path.split(path)的第二元素
#'1.txt'

urljoin('https://femnyy.com/','VPS/xx') 
# 第一个路径必须要有最后一个'/'

d = {'k':1,'x':1}
u.items() # ==dict_items([('x', 1), ('k', 1)])

from operator import itemgetter
d = {'a':1,'c':3,'d':444,'b':2}
# 在签名时挺有用的
for k, v in sorted(d.items(),key=lambda x:x[0]):
    print(k,v)
sort_d  = sorted(d.items(),key = itemgetter(0),reverse=False)
a = {'x': 1,'y': 2,'z': 3}
b = {'w': 10,'x': 11,'y': 2}
sorted(zip(a.values(),a.keys()))
# [(1, 'x'), (2, 'y'), (3, 'z')]
max(zip(a.values(),a.keys()))
# (3, 'z')
min(zip(a.keys(),a.values()))
# ('x',1)

from operator import itemgetter
rows = [
    {'address': '5412 N CLARK', 'date': '07/01/2012'},
    {'address': '5412 NIKE SHIRT', 'date': '07/01/2012'},
    {'address': '5148 N CLARK', 'date': '07/04/2012'},
    {'address': '5800 E 58TH', 'date': '07/02/2012'},
        ]
rows.sort(key=itemgetter('date'))
rows = sorted(rows,key=itemgetter('date'))
rows = sorted(rows, key=lambda x: x.get('date') \
    if x.get('date') else '4000', reverse=False)
# 必須提供一個在排序过程中使用的函数,为每个元素创建一个key,然后按这个key来排序
a = ['femn','femn2014','fe','femnyy']
a.sort(key=len)
from itertools import groupby
# 按相同时间的值,进行分组
for date, items in groupby(rows, key=itemgetter('date')):
    print(date)
    for i in items:
        print(' ', i)
# 输出如下 
# 07/01/2012
# {'address': '5412 N CLARK', 'date': '07/01/2012'}
# {'address': '5412 NIKE SHIRT', 'date': '07/01/2012'}
# 07/04/2012
# {'address': '5148 N CLARK', 'date': '07/04/2012'}
# 07/02/2012
# {'address': '5800 E 58TH', 'date': '07/02/2012'}

data = ['ACME', 50, 91.1]
','.join(str(d) for d in data) # 'ACME,50,91.1'
(str(d) for d in data)  #是一个	generator

import random,string
v = [1, 2, 3, 4, 5, 6] # 一个序列或者 iterable 
# 随机选择一个,且只能是选一个
random.choice(v)
# 随机提取N个,保证不重复出现,并且N不能超过v的长度
random.sample(v,3)
# 只是想打乱序列中的顺序
random.shuffle(v) # 此时v值的顺序已经被改变
# 生成一个随机的整数
random.randint(0,10)
''.join(random.choice(string.ascii_letters + string.digits) for _ in range(32))
''.join([random.choice(string.ascii_letters+string.digits) for _ in range(43)])
''.join(random.sample(string.ascii_letters+string.digits, 15))

from socket import *
#IP协议(socket type)   TCP协议(数据包格式)
socketobj = socket(AF_INET,SOCK_STREAM)# 生成Socket对象
socketobj.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1)
socketobj.bind(('localhost',8080)) # 绑定IP和端口
socketobj.listen(128)# 监听连接数量
# 1
#客户端实例,客户端地址
# connection,address=socketobj.accept()
# 每个客户端一连接就会返回的结果
# 但只能连接一个客户端,只有当前客户端下线,下个客户端才能连上
# A,B客户端都运行 但A先连接 B后连接 B处于阻塞状态,没有生成connection 
# A断开之后,因为只有一个connection,所以执行了 socketobj.close(),
# 服务也跟着断了 B不会自动连上
while True:
    # 2
    connection,address=socketobj.accept()
    
    try:
        while True:
            data = connection.recv(1024) #服务器只接收1024个字节
            if len(data) > 0:
        # 当recv接收数据时,返回值为空,即没有返回数据,那么意味着客户端
        # 已经调用了close关闭了
                print('server端收到client端的信息:'+ str(data,encoding = "utf-8"))
                connection.sendall(bytes("hello client","utf-8"))
                #服务器返回给客户的信息
            else:
                print('[%s]客户端已经关闭'%str(address))
                break
    finally:
        connection.close()
socketobj.close()

from socket import *
socketobj = socket(AF_INET,SOCK_STREAM)
# socketobj.connect(('localhost',8080)) #绑定 阻塞的
socketobj.connect(('localhost',20000)) #asy
while True:
    user_input =input("msg to server:").strip()
    socketobj.send(bytes(user_input,'utf-8'))
#socketobj.sendall(bytes("hello server", 'utf-8'))
    data = socketobj.recv(1024)
    print("client端收到server端的信息 :"+str(data,encoding = "utf-8"))
socketobj.close()

from socket	import *
from multiprocessing import	*
from threading import Thread
from time import sleep
# 处理客户端的请求并为其服务
def	dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if	len(recvData)>0:
            print('recv[%s]:%s'%(str(destAddr),	recvData))
        else:
            print('[%s]客户端已经关闭'%str(destAddr))
            break
    newSocket.close()
def	main():
    serSocket=socket(AF_INET,	SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET,	SO_REUSEADDR		,	1)
    localAddr=('',	8080)
    serSocket.bind(localAddr)
    serSocket.listen(5)
    try:
        while	True:
            print('-----主进程,,等待新客户端的到来------')
            newSocket,destAddr = serSocket.accept()
            # 此时已经连接的客户端Socket=服务端的Socket等待新的客户端到来
            print('-----主进程,,接下来创建一个新的进程(线程)负责数据处理-----')
            client = Process(target=dealWithClient, args=(newSocket, destAddr))
            client.start()
            # 因为已经向子进程中copy了一份(引用),并且父进程中这个套接字也没有用处了
            # 所以关闭
            newSocket.close()
            # 多线程
            # client = Thread(target=dealWithClient, args=(newSocket, destAddr))
            # client.start()
            # # newSocket.close()
            # 因为线程中共享这个套接字, 如果关闭了会导致这个套接字不可用,
            # 但是此时在线程中这个套接字可能还在收数据,因此不能关闭
    finally:  # 当为所有的客户端服务完之后再进行关闭,表示不再接收新的客户端的链接
        serSocket.close()
if __name__ == '__main__':
    main()

# 只适合用于少数用户,没有实际的运用
from socket import *
#1.创建socket
serSocket = socket(AF_INET, SOCK_STREAM)
#2. 绑定本地ip以及port
localAddr = ('', 8080)
serSocket.bind(localAddr)
#3. 让这个socket 变为非堵塞
serSocket.setblocking(False)
#4. 将socket变为监听(被动)套接字
serSocket.listen(100)
# 用来保存所有已经连接的客户端的信息
clientAddrList = []
while True:
    #等待一个新的客户端的到来(即完成3次握手的客户端)
    try:
        clientSocket,clientAddr = serSocket.accept()
    except:
        pass
    else:
        print("一个新的客户端到来:%s"%str(clientAddr))
        clientSocket.setblocking(False) # 设置recv为非阻塞
        clientAddrList.append((clientSocket,clientAddr))
    for clientSocket,clientAddr in clientAddrList:
        try:
            recvData = clientSocket.recv(1024)
        except:
            pass
        else:
            if len(recvData)>0:
                print("%s:%s"%(str(clientAddr), recvData))
            else:
                clientSocket.close()
                clientAddrList.remove((clientSocket, clientAddr))
                print("%s 已经下线"%str(clientAddr))

import socket
import select
# 创建套接字
s = socket.socket(socket.AF_INET,socket.SOCK_       STREAM)
# 设置可以重复使用绑定的信息
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind(("",8080))
s.listen(10)
# 创建一个epoll对象
epoll = select.epoll()
epoll.register(s.fileno(),select.EPOLLIN|select.EPOLLET)
# s.fileno() 得到文件描述符(套接字对应的数字编号)
# fd:sys.stdin.fileno()
connections= {}
addresses ==={}
#循环等待客户端的到来或者对方发数据
while True:
    # epoll进行fd扫描的地方--未指定超时时间则为阻塞等待
    epoll_list=epoll.poll() # 得到可用的socket
    # (包括等待客户端连接的Socket和连接上的客户端Socket,以及服务器的Socket )
    # 对事件进行判断,对上面检测出来的Socket进行收发数据的处理 
    forfd,events in epoll_list:
        # 如果是socket创建的套接字  被激活
        iffd==s.fileno():
            conn,addr=s.accept()            
            print('有新的客户端到来%s'%str(addr))
            #将conn和addr信息分别保存起来
            connections[conn.fileno()] = conn
            addresses[conn.fileno()] = addr
            #向epoll中注册连接socket的可读事件
            epoll.register(conn .fileno(),select.EPOLLIN|select.EPOLLET)
        # 判断事件是否æ¯接收数据的事件(客户端端发送信息)
        elif events == select.EPOLLIN:
            #从激活fd上接收
            recvData = connections[fd].recv(1024)
            if len(recvData)>0:
                print('recv:%s'%recvData)
            else:
                #从epoll中移除该连接fd
                epoll.unregister(fd)
                #server侧主动关闭该连接fd
                connections[fd].close()
                print("%s---offline---"%str(addresses[fd]))

from socketserver import BaseRequestHandler, TCPServer, ThreadingTCPServer
import os
# socketserver 可以让我们很容易的创建简单的TCP服务器,
# 巨大部分Python的高层网络模块(比如HTTP,XML-RPC等)都是建立在socketserver功能之上
class EchoHandler(BaseRequestHandler):
    def handle(self):#每个连接就会 调用此方法
        print('Got connection from', self.client_address)
        while True:
        # 循环去监听用户的连接,否则只能像单进程的阻塞一样,只能连接一个用户
            msg = self.request.recv(8192)
            if not msg:#如果用户退出,没有这句的话 就变成死循环
                print('connection close by', self.client_address)
                break
            print(msg)
            # self.request.send(str(msg,encoding = "utf-8"))
            self.request.send(msg)
if __name__ == '__main__':
    # serv = TCPServer(('', 20000), EchoHandler)#单个线程
    serv = ThreadingTCPServer(('0.0.0.0', 20000), EchoHandler)
    serv.serve_forever()

l = [x*x for x in range(5)]
# [0, 1, 4, 9, 16] 直接返回列表而不是生成器
[i+1 if i>0 else 1 for i in l]
# [1, 2, 5, 10, 17]
[i+1 if i>0 else 2 for i in l]
# [2, 2, 5, 10, 17] # 说明 如果是取else的话,就不再去做更新的操作
[i for i in l if i >4 and i <=16] # [9,16]
vec = [[1,2,3], [4,5,6], [7,8,9]]
[num for elem in vec for num in elem]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```	
改变字典的值
```python 
l_d = [{'name':'femn','age':25},{'name':'femnyy','age':35}]
[i if i.get('age')> 25 else i for i in l_d]
# 虽然此时不能得到自己想要的改变 不能用i['name']='femnhh'去做改变
[i.update({'name':'femnhh'}) if i.get('age')> 25 else i for i in l_d]
# [{'age': 25, 'name': 'femn'}, None] # 相当于是匹配没有匹配成功则返回None
# 但此时l_d却已经是改变成想要的了
l_d
# [{'age': 25, 'name': 'femn'}, {'age': 35, 'name': 'femnhh'}]

g = (x*x for x in range(5)) # 'generator' object
next(g) #

prices = {'ACME': 45.23,'AAPL': 612.78,'IBM': 205.55,\
        'HPQ': 37.20,'FB': 10.75}
p1 = {key: value for key, value in prices.items() if value > 20}
# {'ACME': 45.23, 'IBM': 205.55, 'HPQ': 37.2, 'AAPL': 612.78}

a = 12
b = oct(a)
print(b) #0o14 
# 为了将整数转换为二进制,八进制或十六进制的文本串,可以分别使用bin(),oct()或hex()
# 如果你不想输出0b,0o或者0x的前缀的话
# 可以使用format()函数.比如:format(x, 'b') 'o' 'x'
# 编码 虽然没有用encode()方法
print([n for n in b'ahello'])#[97, 104, 101, 108, 108, 111]
# 索引和迭代动作返回的是字节的值而不是字节字符串
# 编码与解码	
print([int(n).to_bytes(1,'big').decode('utf-8') for n in b'ahello'])
# 成功 所以说再次证明 电脑最小的操作单位是字节 ,而不是字节的值这是人看得懂的
# ['a', 'h', 'e', 'l', 'l', 'o']

print(sys.getdefaultencoding())#utf-8
c ='严'.encode('utf-8')#b'\xe4\xb8\xa5'
print(b'\xe4\xb8\xa5'[0])#228
print(len(c))# 3个字节
print(c.decode())# 严
# 字节的低位高位排列方式 big从低到高 little从高到低
from idna import unicode
unicode(b'\xe4\xb8\xa5','utf-8')
# 解码
# 多个字节的解码转换出来的 数字不太理解 虽然也是十进制的
print(int().from_bytes(c, 'little')) #10860772
# 将字节byte转换为整数 并指定字节顺序
print(int().from_bytes(c, 'big')) # 14989477
print('--------------------') # 14989477
# 编码
print(int(10860772).to_bytes(3, 'little'))
# b'\xe4\xb8\xa5'
print(int(14989477).to_bytes(3, 'big').decode('utf-8'))
# b'\xe4\xb8\xa5'
# 为了将一个大整数转换为一个字节字符串,使用 int.to_bytes() 方法
# 并像下面这样指定字节数和字节顺序
print(int(14989477).to_bytes(3, 'big'))
# b'\xe4\xb8\xa5'
print(int(14989477).to_bytes(8, 'big'))
# b'\x00\x00\x00\x00\x00\xe4\xb8\xa5'

s = '\u6211'
s = s.encode('utf-8').strip().decode()

l[4]= 1

del l[4]
remove('h')
# 用于移除列表中某个值的第一个匹配元素.
pop()
# 会移除列表中的一个元素(默认是最后 一个)并返回该元素的值.
# 后进先出(LIFO)唯一个修改了列表以返回元素值的列表方法.(出栈)
l[1:5] = []
['h', 'e', 'l', 'l']

insert(索引位置,要插入的对象) # 将对象插入到列表中,(累加)
l.insert(4,'four')
l.append(5)
# 在列表末尾追加新的对象,它不是简单的返回一个修改过的新列表,
# 而是直接修改的原来的列表.(入栈)
l.extend()
# 可用新的列表来扩展原有的列表,只是修改(扩展)了原有的列表.
# 而原始的连接操作(+),则会返回一个新的列表.
l.extend(list('o femn'))

l[1:1] = list('femn')
['h', 'f', 'e', 'm', 'n', 'e', 'l', 'l']

y=x[:] # y=x 错误,这样会让x,y都指向同一个列表.
y.sort()

d = dict(host='1',name = 'femn')
d = dict([('name','femn'),('age',18)])
u = dict({'love':'sport'},**d) 
for l in d.items() 
# 将字典中所有项以列表的方式返回,但返回时并没有特定的次序(dict_items)
for k,v in d.items()
d.iteritmes() # 返回的是一个迭代器对象,而不是列表.
d.keys()
# 将字典中所有的K(dict_keys),以列表形式返回d.values() (dict_values)
d.iterkeys() # 返回针对键的迭代器 d.itervalues()

len(d) # 键值对的数量

d['name'] # 返回k对应的v
d.get('name','femn')

d['name'] = 'femnyy'

del d['name'] # 删除K为name的那一个项
d.pop('name') # 用来取得给定K的V,并将K-V移除.
d.clear() # 清除字典中所有的项

d[x] = y 
# 若键x存在,则修改x对应的值为y,若键x不存在,则在字典d中增加键值对x:y
# 利用一个字典项更新另一个字典
d1.update(d) 
# 将字典x所有键值对添加到字典d中(不重复,重复的键值对用字典x中的键值对替代字典d中)
# update可以使用与调用dict函数(或者类型构造函数)同样的方式进行调用
# 这意味着update可以和映射,拥有键值对的队列(或者其它可迭代对象)以及关键字参数一起调用.

d.has_key('name') # 返回True 或 False

a = {'x': 1,'y': 2,'z': 3}
b = {'w': 10,'x': 11,'y': 2}
a.keys() & b.keys()  # {'x', 'y'}
a.keys() - b.keys() # {'z'}
a.items() & b.items() # {('y', 2)}
{key: a[key] for key in a.keys() - ['z', 'w']} # {'y': 2, 'x': 1}

x = {'username':'admin', 'machines':['foo', 'bar', 'baz']}
y = x.copy()
y['username'] = 'mlh'
y # {'machines': ['foo', 'bar', 'baz'], 'username': 'mlh'}
y['machines'].remove('bar')
y # {'machines': ['foo', 'baz'], 'username': 'mlh'}
x # {'machines': ['foo', 'baz'], 'username': 'admin'}

from copy import deepcopy
d={}
d['names'] = ['Alfred', 'Bertrand']
c = d.copy()
dc = deepcopy(d)
d['names'].append('Clive')
c # {'names': ['Alfred', 'Bertrand', 'Clive']}
dc # {'names': ['Alfred', 'Bertrand']}

name = ['femn','femnyy','femnhh']
age = [18,25]
zip(name,age) # [('femn', 18), ('femnyy', 25)]