Python笔记-备忘

一、向列表添加元素

　　x.append(y) #末尾添加一个元素
　　x.extend([y,z]) #末尾添加多个元素
　　x.insert(index，y)

二、向列表获取元素　　
　　x[index]

三、从列表删除元素
　　x.remove("y")
　　del x(index) # 删除整个列表 del x
　　x.pop() # 弹出列表最后一个元素 x.pop(index) 弹出index对应元素

四、列表分片 （创建副本）
　　x[x:y] #x为开始位置 ，y为结束位置 结束位置不包含
　　x[x：y：z] #z为步长 默认为1 z为-1，反转数列

五、列表
　　x.count(y) #计算x中出现多少次y
　　x.index(y) #返回y在x中的位置
　　x.reverse() #列表反转
　　x.sort（）#从小到大排序 sort(fun,key=None,reverse=False)

六、元组(1,)
　　x = (a,b,c,d,e,f,g,...)　　
　　访问元组： x[index]　　
　　分片复制元组 x2=x1[:]
　　间接删除第3个元素 x=x[:2]+x[3:]
　　删除元组 del x

七、fotmat格式化（012format参数为位置参数，abc为标签，format中将等值的参数替换进去，即为关键字参数，位置参数必须在关键字参数前）
　　"{0} love {1}.{2}".format("I","baidu","com")#即' I love baidu.com'
　　"{a} love {b}.{c}".format(a="I",b="baidu",c="com")#即 'I love baidu.com'
　　"{0}:{1:.2f}".format("圆周率",3.14159) #即为'圆周率：3.14' 位置参数1后加了:替换域中，冒号表示格式化的开始，.2表示四舍五入保留2位小数

八、导入计时
　　import datetime
　　start = datetime.datetime.now()
　　...
　　...
　　delta = (datetime.datetime.now - start).total_seconds( )
　　print(delta)

九、数字处理
　　import math 　　
　　math.floor() #地板 向下取整 int 　　
　　math.ceil() #天花板 向上取整 4.5 =5
　　math.trunc()# 向0的方向取
　　round()#元整 四舍六入 5 取最近的偶数　　

　　math.sqrt()#开方
　　pow(x,y) == x**y
　　bin()#二进制
　　oct()#八进制
　　hex()#十六进制
　　math.pi#  π
　　math.e

十、类型判断
　　type（） #返回type型
　　isinstance（int，str）# is int 是 str的实例？？

十一、列表 [list]
　　可以是任意对象（数字，字符串。对象，列表）
　　若干个元素 有序排列、可变
　　【】
　　查询、a[index]
　　　　时间复杂度 O(x) 遍历 x个元素
　　赋值：list[x] = value
　　删除：a.clear() #清除，剩下空列表
　　　　a.remove(value)# 移除一个值
　　　　a.pop([index]) #默认弹出最后一个值
　　其他操作：
　　　　a.reverse()->None# 就地更改 反转序列
　　　　a.sort(key=None,reverse=False)->None#   就地排序 默认升序 key 一个函数 指定key如何排序
　　列表复制：
　　　　== 比较值 （内容） ； is 比较内存地址
　　　　lst1 = lst0 没有赋值过程

　　　　A = [1,2,3]
　　　　B = A[:]

　　　　copy->list (shadow copy) x.copy() 依次重新创建
　　　　影子拷贝 及 浅拷贝 只是复制一个引用
　　　　深拷贝 deepcopy -> import copy

　　enumerate(iteralbe) #生成由二元组(元素数量为二的元组)构成的迭代对象
　　　　　　　　　　　　每个二元组由可迭代对象的索引及对应元素组成
　　　　普通的 for 循环
　　　　　　>>>i = 0
　　　　　　>>> seq = ['one', 'two', 'three']
　　　　　　>>> for element in seq:
　　　　　　... print i, seq[i]
　　　　　　... i +=1
　　　　　　...
　　　　　　0 one
　　　　　　1 two
　　　　　　2 three

　　　　　　for 循环使用 enumerate
　　　　　　>>>seq = ['one', 'two', 'three']
　　　　　　>>> for i, element in enumerate(seq):
　　　　　　... print i, element
　　　　　　...
　　　　　　0 one
　　　　　　1 two
　　　　　　2 three

　　zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
　　　　如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

　　　　　　>>> a = [1,2,3]
　　　　　　>>> b = [4,5,6]
　　　　　　>>> c = [4,5,6,7,8]
　　　　　　>>> zipped = zip(a,b) # 打包为元组的列表
　　　　　　[(1, 4), (2, 5), (3, 6)]
　　　　　　>>> zip(a,c) # 元素个数与最短的列表一致
　　　　　　[(1, 4), (2, 5), (3, 6)]
　　　　　　>>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
　　　　　　[(1, 2, 3), (4, 5, 6)]

十二、随机数
　　import random
　　　　    random.randint(a,b) #返回【ab】间的整数
　　　　　random.choice(seq) #从非空列表中随机挑选一个数
　　　　　random.randrange([start,] stop) [,step] ) #按指定基数递增的集合中获取一个随机数， 基数缺省值为1
　　　　　random.shuffle(list)# 就地打乱列表元素

十三、元组(tuple) 不可变对象
　　tuple() -> empty tuple
　　t = (1,)
　　访问元组 通过index
　　查询 index(value,[start,[stop]])
　　count(value)计数

　　命名元组 namedtuple(typename,field_name,verbose=False,rename=False)
　　　　命名元组，返回一个元组的子类，并定义了字段
　　　　field_name 可以是空格或逗号分割的字段的字符串，可以是字段的列表
　　导入 from collections import namedtuple
　　　　例： Point = namedtuple('P[名字]','x,y')
　　　　p1 = Point(4,5)

　　删除：del tuple

十四、字典 {dict}
　　创建: {}
　　　　　　{keys:value}
　　　　　　dict(key=value)
　　　　　　dict([(key,value),(key,value),])
　　dict1 = dict((('F',70),('A，80')，('S',90))) // dict(F=70,A=90,S=90)
　　　　　　doct1 => {'F':70,'A':80,'S':90}

　　fromkeys()   #创建并返回一个新的字典 ： 两个参数 第一个为key [第二个为value]
　　　　dict1 = {}
　　　　keys =['name','age','job']
　　　　employ = dict.fromkeys(keys)
　　　　employ =>{'name0':None,'age':None,'job':None }

　　　　dict1.fromkeys((1,2,3)) => {1:None,2:None,3:None}
　　　　dict2.fromkeys((1,2,3),"Number") = > {1:"Numbwe",2:"Number",3:"Number"}

　　访问字典：keys()返回键,values()返回字典所有的值,items()返回所有的项
　　　　dict1 = {}
　　　　dict1 = dict1.fromkeys(range(3),'你好')
　　　　dict1.keys() => dict_keys([0,1,2])
　　　　dict1.values() => dict_values(['你好','你好','你好'])
　　　　dict1.items() => dict_items([(0,'你好'),(1,'你好'),(2,'你好')])

　　　　get() #当键不存在 。返回None
　　　　dict1.get(31) =>'你好' dict.get(32) =>
　　　　若找不到，可在第二个参数设置values
　　　　判断是否存在 ： index in dict1

　　　　setdefault() #当键不存在，自动添加None

　　更新字典：
　　　　data[key] = value
　　　　pets = {'米奇','老鼠','汤姆','波比'}
　　　　pets.update(米奇='酷奇')
　　　　pets => {'酷奇','老鼠','汤姆','波比'}

　　清空字典 ：
　　　　dict.clear()
　　复制：
　　　　dict2 = dict1.copy() id 1 != 2
　　合并：
　　　　data1.update(data2)

　　pop() popitem()
　　　　dict1.pop(2) #弹出对应的键值
　　　　dict2.popitem() #弹出一个简直想
　　删除值：
　　　　del data[key]

　　函数赋为值：行为方法
　　　　def say_hello():
　　　　　　print('welcome')

　　　　person = {'name':'Jerry','hello':say_hello}
　　　　person['hello']() -> welcome

十五、字符串 不可变对象 有序 可迭代

　　'[]'.join(str)
　　处理： ~ split 系列(切割) 将字符串o按分割符切成若干字符串 并返回列表
　　　　~ s.partition(sep) -> (head,sep,tail)系列 将字符串按分隔符割成2段，返回2段和分隔符的元组
　　　　　　从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分
　　　　　　如果没有找到分隔符，就返回头、2个空元素的三元组
　　　　　　sep分割字符串。必须指定
　　　　s.rpartition(sep) -> (head,sep,tail)
　　　　　　从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分
　　　　　　如果没有找到分隔符，就返2个空元素和尾的三元组
　　　　split(sep=None,maxsplit=-1) ->list of strings
　　　　　　从左至右 sep 指定分割字符串。缺省的情况下空白字符串作为分隔符
　　　　masxsplit 指定分割的次数，-1表示遍历整个字符串
　　　　　　分割* splitliness([keepends]) -> list of strings
　　　　　　　按照行来切字符串 keepends 指是否保留行分隔符(\n \t \r)

　　字符串大小写
　　　　s.upper()# 全大写
　　　　s.lower() #全小写
　　　　大小写，做判断的时候用 swapcase() 交互大小写

　　字符串排版
　　　　title() -> str 标题的每个单词都大写
　　　　s.capitalize() -> str 首个单词大写
　　　　s.center(width[,fillchar]) -> str width 打印宽度 fillchar 填充的字符
　　　　s.zfill(width) -> str width 打印宽度，居右，左边用 0 补充
　　　　s.ljust(width[,fillchar]) -> str 左对齐
　　　　s.rjust(width[,fillchar]) -> str 右对齐

　　字符串修改
　　　　s.replace(old,new[,count]) -> str 字符串找到匹配替换为新字串，返回新字符串 count 表示替代几次，默认全部替换
　　　　s.strip([chars]) ->str 从字符串两端去除指定的字符集chars中的所有字符 默认为去除空白

　　　　s.lstrip([chars]) ->从左开始
　　　　s.rstrip([chars]) ->从右开始

　　字符串查找 *
　　　　s.find(sub[,start,end]]) ->int 从左至右 查找sub(子串) 有返回索引 无，返回-1
　　　　s.rfind(sub[,start,end]]) ->int 从右至左 查找sub(子串) 有返回索引 无，返回-1

　　　　s.index(sub[,start[,end]]) -> int 从左至右 查找sub(子串) 有返回索引 无，抛异常
　　　　s.rindex(sub[,start[,end]]) -> int 从右至左 查找sub(子串) 有返回索引 无，抛异常

　　　　时间复杂度 O(n)
　　　　s.count(sub[,start[,end]]) ->int 在指定区间【)从左至右 统计sub出现的次数

　　字符串判断 *
　　　　endswith(suffix[,start[,end]]) -> bool 在指定区间，字符串是否suffix结尾
　　　　startwith(prefix[,start[,end]]) -> bool 在指定区间，字符串是否prefix开头

　　字符串判断 is 系列
　　　　isalnum() ->bool 是否是字母和数字组合
　　　　isalpha() ->bool 是否是字母
　　　　isdecimal() 是否只包含十进制数字
　　　　isdigit() 是否全部数字(0~9)
　　　　isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
　　　　islower() 是否都是小写
　　　　isupper() 是否全部大写
　　　　isspace() 是否只包含空白字符

　　字符串格式化 ***
　　　　+ 拼接字符串 非字符串先进行转化
　　　　join 拼接 只能使用分隔符 且被拼接的为可迭代对象
　　　　格式要求： 占位符 format % (values)(只能是一个对象，或数目相等的元组)

　　*** format
　　　　"{} {xxx}".format(*args,**kwargs) ->str args 位置参数，一个元组 kwargs 关键字参数，一个字典
　　　　花括号即占位符 {} 按位置匹配 {n} 表示位置参数索引为n的值
　　　　{{}} 打印{}

　　　　访问元素
　　　　　　"{0[0]}.{0[1]}".format(('magedu','com')) magedu','com==0 'magedu'=0[0]
　　　　对象属性访问
　　　　　　from collections import namedtuple
　　　　　　Point = namedtuple('Point','x,y')
　　　　　　p = Point(4,5)
　　　　　　"{{{0.x}.{0.y}}}".format(p)

　　　　对齐
　　　　　　'{:^30}'.format('centered') 居中
　　　　　　'{:*^30}'.format('centered') 居中 并用*填充

　　　　进制
　　　　　　"int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
　　　　　　输出为： 'int:42; hex:2a; oct:52;bin:101010'
　　　　　　"int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
　　　　　　输出为： 'int:42; hex:Ox2a; oct:Oo52;bin:Ob101010'

十六、集合{set} 无序 {}内无映射关系
　　　　　　num = {1,2,3,4,5,5,6,5,4,3,1,1}
　　　　　　num = {1,2,3,4,5,6}
　　创建集合 ：
　　　　set1 = {xxxxxxxx}
　　　　set2.set([xxxxxxxxxx])

　　访问集合：
　　　　for each in set1：
　　　　print(each,end='')
　　操作：
　　　　set1.add(num) 增加num
　　　　set1.remove(num) 删除num

　　不可变集合：
　　　　set1.frozenset({1,2,3,4})
　　　　删除 del set1

十七、函数、参数即参数结构
　　分类：内建函数、库函数、
　　　　可变参数： 一个形参可以匹配任意个参数
　　　　可变位置参数：收集形成一个tuple
　　　　def add(*nums): nums这个形参可以接受任意个实参
　　　　　　sum = 0
　　　　　　for x in nums:
　　　　　　　　sum += x
　　　　　　return sum
　　　　　add(1,3,5) add(2,4,6) 收集多个实参为tuple

　　　　可变关键字参数：形参前用**符号，表示可接受多个关键字参数,收集的实参名和值组成dict
　　　　def showconfig(**kwargs):
　　　　　　for k,v in kwargs.items():
　　　　　　　　print('{} = {}'.format(k,v))

　　　　keywordonly-only 参数
　　　　　　def fun(*args,x,y,**kwargs);
　　　　　　　　print(x)
　　　　　　　　print(y)
　　　　　　　　print(args)
　　　　　　　　print(kwargs)
　　　　　　定义合法
　　　　　　fun(7,9,y=5,x=3,a=1,b='python')
　　　　　　=> 3
　　　　　　　　5
　　　　　　　　(7,9)
　　　　　　　　{'b':'python','a':1}

　　　　　　def fun(*args,x):
　　　　　　　　print(x)
　　　　　　　　print(args)
　　　　　　fun(3,5) 　　=>error
　　　　　　fun(3,5,7)　　 =>error
　　　　　　fun(3,5,x=7) 　　=> x=7, 3,5=args

　　　　　　def fn(*,x,y):
　　　　　　　　print(x,y)
　　　　　　fn(x=5,y=6) x y 必须keyword-only参数

　　　　可变参数和参数默认值：
　　　　　　def fn(*args,x=5):
　　　　　　　　print(x)
　　　　　　　　print(args)
　　　　　　fn() == fn(x=5) () 5
　　　　　　fn(5) == (5,) 5
　　　　　　fn(x=6) == () 6

　　　　　　def fn(y,*args,x=5):
　　　　　　　　print('x={},y={}.format(x,y)')
　　　　　　　　print(args)
　　　　　　n(5)、fn(1,2,3,x=10)、

　　　　　　def fn(x=5,**kwargs):
　　　　　　　　print('x={}'.format(x))
　　　　　　　　print(kwargs)
　　　　　　fn() => x = 5 {}
　　　　　　fn(6)=> x = 6 {}
　　　　　　fn(x=7,y=6) => x= 7 {'y':6}

　　函数参数：
　　　　参数规则一般顺序：普通参数、缺省参数、可变位置参数、keyword-only参数、可变关键字参数
　　　　　　def fn(x,y,z=3,*args,m=4,n,**kwargs):
　　　　　　　　print(x,y,z,m,n)
　　　　　　　　print(args)
　　　　　　　　print(kwargs)
　　　　　　fn(1,2,n=3) => 1,2,3,4,3 () {}
　　　　　　fn(1,2,10,11,t=7,n=5) =>1 2 10 4 5 (11,) {'t':7}

　　参数解构：
　　　　　def add(x,y:)
　　　　　　　　return x+y
　　　　　add(4,5)
　　　　　t=(4,5)
　　　　   add(t[0],t[1])
　　　　   add(*t) 解构： 非字典型 * 字典型 **

　　　　　d = {'x':5,'y':6}
　　　　   add(**d)

　　内嵌函数和闭包：
　　　　函数内部可以访问到全局变量 不要去改变
　　　　　　count = 5
　　　　　　def myFun():
　　　　　　global count
　　　　　　count = 10
　　　　　　print(count)
　　　　　　nuFun() => 10
　　　　　　count => 10

　　闭包：
　　　　def funX(x):
　　　　　　def funY(y):
　　　　　　　　return x+y
　　　　　　return funY
　　　　i = funX(8)
　　　　i(5) => 13 // funX(8)(5)

　　nonlocal :在内部函数中可以移动外部函数中局部变量的值
　　　　def funX():
　　　　　　x = 5
　　　　　　def funY():
　　　　　　　　nonlocal x
　　　　　　　　x *= x
　　　　　　　　return x
　　　　　　return funY
　　　　funX()() => 25

　　lambda 创建匿名函数 ：
　　　　g = lambda x : 2 * x + 1
　　　　g (5) => 11

　　filter()、map()
　　　　filter有两个参数，第一个参数可以是函数或者None， 如果是函数，则将第二个可迭代数据里的每一个元素作为函数参数进行计算，将返回为True的值
　　　　　　如果是None，则直接将第二个参数中为True的值筛选出来
　　　　例：奇数过滤器
　　　　def odd(x):
　　　　　　return x % 2

　　　　temp = filter(odd,range(10)) // list(filter(lambda x : x % 2 ,range(10)))
　　　　list(temp) => [1,3,5,7,9]

　　map() 映射 两个参数，一个函数加一个可迭代序列，将系列里的每一个元素作为函数的参数进行运算加工，知道可迭代序列每个元素都加工完毕，返回新序列

　　　　list(map(lambda x: x * 2,range(10)) => [,2,4,6,8,10,12,14,16,18,20]

十八、高阶函数 （函数作为返回值，一个或多个函数作为参数，往往形成闭包）
　　y=f(g(x))
　　def counter(base):
　　　　def inc(step=1):
　　　　　　nonlocal base
　　　　　　base += step
　　　　　　return base
　　　　return inc

　　柯里化：原来接受两个参数的函数变成接受一个参数的函数的过程，新的函数返回一个以原有第二个参数的函数
　　　　z=f(x,y) => z=f(x)(y)
　　例子: 　　 def add(x,y):
　　　　　　　  　return x + y
　　　　　　　print(add(4,5))

　　　　=>   　def new_add(x):
　　　　　　　　   def inner(y):
　　　　　　　　　　  return x + y
　　　　　　　　　return inner

　　装饰器 *：本质是高阶函数，

十九、文件读写
　　声明：open('路径'，'模式'，encoding='编码')
　　　　路径： 'c:\\path\\data.txe'
　　　　　　　 r'c:\path\data.txt'
　　　　模式：文本：'r'读 'w'写 'rw' 读写 'a' 打开，追加
　　　　　　　　二进制：'*b'
　　　　f = open(r'E:\pythonfile\date.txt','r')
　　　　f.read() #读取所有信息 指针移动至末尾
　　　　f.seek(0)# 指针移动开头 ，可重新读取
　　　　f.tell() #告诉指针位置
　　　　f.close() #关闭文件对象
　　读写：
　　　　f.read(n) #读取n位字符的信息
　　　　f.readlines() #读取所有行信息
　　　　f.readline() #读取下一行

　　　　for line in f.readlines():// for line in f:
　　　　　　print(line)

　　查询当前操作目录 　   import os
　　　　　　　　　　　　os.getcwd()
　　　　　　　　　　　　os.chdir(r'xxxxxx') 切换目录

　　文件写入：
　　　　f = open('路径'，'模式'，encoding='编码')
　　　　f.write('xxxxxxxxx')
　　　　f.close()
　　　　f.writelines()# 一次写入多行
　　　　f.flush() #直接将内存缓存操作显示在文件上

　　自动释放资源
　　　　with open('路径'，'r'，encoding='编码') as f:
　　　　　　for line in f:
　　　　　　　　print(line)

　　pickle模块：
　　　　import pickle
　　　　my_list = [123,123.4,'你好'，[another list]]
　　　　pickle_file = open(r'E:\pythonfile\my_list.pkl','wb') 二进制写入
　　　　pickle.dump(my_list,my_list.file) dump方法保存数据
　　　　pickle_file.close()

　　打开：
　　　　import pickle
　　　　pickle_file = open(r'E:\pythonfile\my_list.pkl','rb')二进制读
　　　　my_list = pickle.load(pickle_file) load 加载数据
　　　　print(my_list)