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)