Python学习
数组
array模块中定义。
array 和 list的区别：
array可以紧凑的表示一个基本值得数组（字符、整数、浮点），类似list序列，有区别：
array只能保存一种类型，初始化决定。list可以存放任何类型。如果只存放数字，array更高效。
array的数据类型
| Type code | Python Type | size |
|---|---|---|
| 'b''B' | int | 1 |
| 'u' | Unicode char | 2 |
| 'h''H''i' | int | 2 |
| 'L' | int | 4 |
| 'Q' | int | 8 |
| 'f' | float | 4 |
| 'd' | float | 8 |
- 常用方法
append() #末尾添加
buffer_info() #内存信息tuple（地址，长度）
byteswap() #根据CPU架构不同，有的以小端存储（最小有效位存在小地址中）或大端（最小有效字节在最大地址中）
count() #统计给定数字重复出现的次数
extend() # 添加多个元素 数组或迭代都可以
fromfile() #从文件中读取 指定读取数量超过length报错
tofile() #写入文件对象
fromlist() #从list中添加元素
frombytes() #从bytes对象中添加元素
index()#返回第一个匹配的索引
insert()#在指定位置添加元素
pop() #移除并返回指定位置元素（缺省i=-1最后一个）
remove() #删除匹配的第一个元素
reverse（）#翻转顺序
tolist() #转为list
tobytes() #转为bytes对象
#构造
from array import array
arr = array('i') #空int类型
arr = array('i',[0,1,2,3,4])
arr = array('f',[random.randrange(-10,10) for _ in range(5)])#5个随机元素
arr.typecode #'f' typecodes 返回所有可用类型
#二进制文件打开读写
with open('arr.bin','wb') as f:
arr.tofile(f)
Python数组分为三种类型：
-
list：普通链表，初始化后可以动态添加元素。arr=[元素] -
Tuple：固定数组，一旦定义长度不能修改。arr=(元素) -
Dictionary：词典类型，即 Hash数组。arr={元素K:V}
#append(v) insert(index,v) extend(list) lst[n] count(v)
#pop([n=-1]) remove(v) del lst[n]
#reverse() sort(reverse=True)
#len(lst） max（lst） min(lst) list(tuple)
#copylist:L1=L(地址复制) L1=L[:]（克隆另一个拷贝）
enumerate(lst) 返回 index - vlue //for i ,v in enumerate(lst) print('index=%s value=%s' %(i,v))
lst = [1,2,[3,4]]
lst = []
lst = [i for i in range(10),1,[]]
数据类型
变量不需要声明，每个变量使用前必须赋值，赋值后被创建。
int、float bool complex
String
List
Tuple
Dictionary
Set
#赋值
a = '123'
a=b=c=1
a,b,c,d=1,2.5,'123',True
#String
Str = '123456'
Str[2:4] # '345'
Str[2:] #'3456'
Str[0:-1] #'12345'
Str+'789' #'123456789'
#List
List = ['ab',1,3.2,True] #元素可修改
tuple = ('ab',1,3.2,True) #元素不能修改
dic={'name':'jack','age':19,3:'True'}
dic['name']
dic[3]
#keys() values()
全局变量
函数内部定义的都是局部变量，要使用全局变量，要在函数内部的用global关键字。对于内嵌函数要用父级函数的变量要用nonlocal关键字
如
count=0
def modify():
do=0
global count # use global var
count= count+1
def x():
nonlocal do
do=10 #use not local var
自定义函数
def 函数名(参数列表）->返回值: #多个参数用 , 隔开
···
函数文档 （一段字符串，三个单引号包围的一段文本）
···
//do
[return[返回值]]
#参数
#1 默认参数(name,age=10)
#2 可变参数，不是传入list或tuple。(* names)
def sum(* nums): #调用sum(1,2,3,4)
sum=0
for n in nums:
sum= sum+n
return sum
#3 关键字参数，参数带名字
def x(** n):
print(n)
print(n['age'])
x(name='tom',age=10)
# {'name':'tom','age':10}
# 10
列表推导式
list=[exp for var in iterable if condition]
list=[n+1 for n in range(10) if n%2==0]
生成器表达式
在循环中如果基于列表而数量巨大会一次生成一个占用大量内存的列表，而循环操作每次只会用一个元素，这时可用生成器表达式，按给定的规则依次生成每个元素。
generator=(exp for var in iterable if condition)
跟列表推导式的差别：列表元素一次生成，生成器表达式随着next()的调用(隐式调用)实时生成，直到没有元素可以生成，抛出StopIteration错误。
生成器函数
除了生成器表达式可以生成generator，函数也可以生成generator，比如要生成一个平方序列square(n)
如果用return list方式，生成整个列表然后返回列表序列，会一次生成所有元素，用生成器函数更好，关键是返回用yield。
#列表方式
def square(n):
list=[]
for i in range(n):
list.append(i*i)
return list #按顺序执行完遇到return返回
#生成器函数
def square(n):
for i in range(n):
yield i*i #遇到yield返回一次，下次接着执行
for x in square(10):
print(x)
迭代器
可用于for循环的种类：
- 集合类 str list tuple dict set : 是可迭代类型Iterable
- 生成器 生成器表达式 和 生成器函数：是迭代器Iterator，可以被next()函数不断调用生成下一个值。
区别：都是Iterable，后者是Iterator前者不是，前者可以用iter()函数转变为后者。
都是可迭代对象Iterable，判断isinstance([],Iterable), isinstance((n for n in range(10)),Iterable)
高阶函数
函数名也是变量所以函数名也可以作为函数的参数。
将函数作为参数的函数称为高阶函数
def x(a,b,fun):
return fun(a)*fun(b)
- 内置高阶函数
map(f, iterable):将函数f依次作用到可迭代对象上。返回值是迭代器，是惰性序列。
def f(x):
return x*x
l=map(f,[1,2,3,4])
print(list(l))# 通过list计算迭代序列
reduce(f, iterable):将函数f依次作用到可迭代对象上。返回值是迭代器，是惰性序列。使用跟map()类似，区别是f需传入两个参数
def f(x,y):
return x*y #计算连乘
l=reduce(f,[1,2,3,4]) #计算顺序为f(1,2) f(2,3) f(6,4)
print(l)
#24
filter(f, iterable)`:将函数f依次作用到可迭代对象上,判断为true保留，false丢弃。返回值是迭代器，是惰性序列。
def f(x):
return x%2==1
l=filter(f,[1,2,3,4])
print(list(l))# 通过list计算迭代序列
#[1,3]
sorted(序列, key=fun, reverse=true)
sorted(list,key=str.lower,reverse=true)
闭包closure
引用自由变量的函数。被引用的自由变量与函数一同存在，即使已经离开了创造它的函数。
- 闭包函数必须有内嵌函数
- 内嵌函数要引用上一级函数的变量
- 闭包函数返回内嵌函数
def f(x):
def ff(y):
print(x+1+y)
return ff
A=f(5)
B=f(2)
A(1) #7
A(2) #8
B(1) #4
B(3) #6
