python——列表、元组、字典、函数、生成器
一、列表
1. 定义
- 按顺序排列的元素组成了列表,一个列表中可以包含字符,数字,字符串,子列表
- 表示:
[]
,list=[]
表示空列表
2. 列表是动态的
-
取一个元素
-
截取一段元素
-
列表的值可修改
-
列表增添一个元素
- 中间插入:
list.insert(index,元素)
在list[index]
的位置插入新元素 - 尾部插入:
list.append(元素)
在列表的最后位置添加一个新元素
索引 0 1 2 3 4 5 6 元素 a b c d e f g - 中间插入:
-
列表尾部插入多个元素:
list.extend(seq)
在原表上操作在list列表末尾添加另一个列表seq的元素 -
列表中移除元素
- 根据值移除:
list.remove(obj)
按照列表遍历的顺序(索引从小到大进行),在列表上移除一个值=obj的元素, - 根据索引移除:
list.pop(index)
对当前列表移除索引为index的元素,返回移除的元素的值.(print(list)元素已移除)
- 根据值移除:
3. 列表的顺序
- 按元素值的大小排序:
list.sort()
在原列表上操作(永久性),默认按升序排列.排列时元素必须一致.参数reverse=True降序排列 - 列表的反转操作:
list.reverse()
在原列表上操作(永久性),把整个列的元素的位置顺序全部反过来
4. 列表的常用函数
len(list)
返回列表中项的数目max(list)
返回列表中的最大值min(list)
返回列表中的最小值
5. 列表的其他内置函数help(list)
有clear(),copy(),index(),count()
,help(list.index)
list.clear()
清空列表list.copy()
复制列表list.index(某元素的值)
返回该元素的索引list.count(需要统计的某元素的值)
返回列表中某个元素值的频数- 注意:
list1=list2,与list3=list1.copy()的区别,前者存储单位一样,指针名不同;后者存储单位不一样
list1=[]
list2=[1,'2',[2,4],'hello']
print(list2)
print(list2[2])
print(list2[1:3])
print(list2)
list3=[2,15,29,17,23,6]
print(list3)
list3.sort(reverse=True)
print(list3)
list4=['a','A','c','g','K','Z']
list4.index('a')
#判断从101到200之间有多少个质数?请最后将这些素数按照从大到小输出.
#求素数的方法.如果n是101到200之间的数字,如果将2到n-1除n,如果能被整除,则不是素数,否则是素数.
s=[]
for i in range(101,201):
tick_i=1 #数据分为2类(是质数与不是质数,计数机没法判断,需要我们人工的判断分类).首先假设是质数,标记tick_i=1
#判断过程
j=2
while j<i:
if i%j==0: #True:i这个数据整除,不能要
tick_i=0 #改变i的标签
break #j后面的数字不用循环
j+=1 #j判断后,再用j+1去判断
#保存数据
if tick_i==1:
s.append(i)
s.reverse()
print(s)
6. 截取和拼接列表
#切片技术,取前不取后,用:表示
numlist=list('abcdegenggds')
print(len(numlist))
print(numlist[2:8],numlist[:4],numlist[9:])
#+拼接
newlist=numlist[:2]+numlist[10:]
newlist1=numlist[:2]*2
print(newlist,newlist1)
7. list
函数:在数据处理中常用与将迭代器或者生成器转化为列表
#将字符串转化为列表
str1='abdlcjo'
#将元组转化为列表
str1=(2,3,4)
list1=list(str1)
8.list的upback性质
list1=[1,2,3]
x,y,z=list1 #注意左侧变量与右侧列表元素数量相等
print(x,y,z)
#巧妙取列表元素
list2=[1]
x,=list2 #对返回的列表取第一个元素
二、元组(tuple)
- 元组用小括号来定义.
- 长度固定,不可以添加,修改,删除;可以拼接和截取.
numtuple=(2,4,6,8,10)
print(numtuple[1:4])
print(numtuple[1:4]*2)
2.1 元组拆包
tup=(3,4,5)
a,b,c=tup
b
Out[82]:4
2.2 元组-计算某个数值出现的次数count
tup=(1,2,2,2,3,4,2)
tup.count(2)
三、函数
3.1. python内建序列函数
enumerate
:遍历一个序列的同时追踪当前元素的索引
str1=(2,3,4)
for i,v in enumerate(str1):
print('index is '+str(i),', value is '+str(v))
3.1.1 sorted
返回一个根据任意序列中的元素新建的已排序列表。
sorted([2,3,1,7,4]) #对列表排序
sorted((2,3,1,7,4)) #对元组排序
sorted('23174') #对字符串排序
3.1.2 zip
将列表、元组或者其他序列的元组配对,新建一个元组构成的列表>
- zip()函数用于将可迭代的对象作为参数,将对象种对应的元素打包成一个元组,然后返回由这些元组组成的对象,好处在于节约内存。
- 可以使用list()函数转换来输出列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同。利用*号操作,可以将元组解压为列表。
- 用途:在for循环中可以用来迭代两个或者多个可迭代对象
#zip可以处理任意长度的序列,它生成列表长度由最短的序列决定:
seq1=['foo','bar','baz']
seq2=(2,3,4,5)
zipped=zip(seq1,seq2)
list(zipped)
#zip函数机智的“拆分”序列
seq1=[('foo', 2), ('bar', 3), ('baz', 4)]
p=zip(*seq1)
list(p)
p1,p2=zip(*seq1)
p1
3.1.3 *zip()
解压
reversed
将序列的元素倒叙排列,它是一个生成器,如果没有实例化,则不会产生一个倒叙了的列表
tup=(2,3,4) #对元组反序
tup=[2,3,4] #对列表反序
tup='2,3,4' #对字符串反序
reversed(tup) #生成器,不显示元素
list(reversed(tup))
3.2. 主函数与子函数
python 程序运行是只会运行不在函数内的代码和主函数内的代码段,不会运行子函数的代码段.子函数的代码段只有被调用的时才会运行.
可以查看help(list)
#定义主函数
if __name__=='__main__': #主函数名前后双英文状态下划线
print('Inside')
结果:Inside
#定义子函数
def sq(num): #num传进子函数的变量
print('乘积')
return num*num #return 后是传回的值
#调用子函数
f=sq(2) #子函数被调用
f
结果:
乘积
4
3.3. 返回多个值
#返回一个元组,利用元组的拆包特性
def f():
a=5
b=6
c=7
return a,b,c
a,b,c=f()
#返回一个字典,按键的方式查看
def f(a):
a=5
b=6
c=7
return {'a':a,'b':b,'c':c}
res=f(2)
res['a']
3. 4. 匿名函数lambda
匿名函数是一种通过单个语句生成函数的放hi,其结果是返回值。使用关键字lambda
定义,表达”我们声明一个匿名函数"d的意思。
#作为函数传参
def apply_to_list(some_list,f):
return [f(x) for x in some_list]
ints=[4,0,1,5,6]
apply_to_list(ints,lambda x:x*2)
#将一个匿名函数传给列表的sort的方法
strings=['foo','card','bar','aaaa','abab']
strings.sort(key=lambda x: len(set(list(x))))
strings
四、字典
dict(字典),又名哈希表或着关联数组。字典是拥有灵活尺寸的键值对集合,其中的键和值都是python对象,用大括号{}
是创建字典的一种方式,在字典中用都好将键值对分隔开。然而键值对并没有特定的顺序,输出的键、值都是按照相同的顺序。
4.1 字典的创建、修改、删除、更新
#方式一:大括号的方式
dict0={} #空字典
dic1={'a':1,'b':2}
#方式二:dict函数
#创建空字典
dict2=dict()
#映射(mapping)的方式创建字典
dict3=dict({'a':1,'b':2})
#传入关键字(**kwargs)的的方式
dict4=dict(one=1,two=2,three=3)
#传入可迭代对象(一)
dict5=dict([('one',1),('two',2)])
#传入可迭代对象(二)
dict5=dict(zip(['one','two'],[1,2]))
4.2 字典的访问、修改、插入
#字典可以访问,插入,修改
dict2={'a':'some value','b1':[1,2,3,4]}
print(dict2['a']) #访问取值
dict2[7]=(2,43) #原键不存在,则插入新的键对
dict2['a']='hello'#修改键对
dict2
#字典的del删除
del dict2['a'] #删除了键为'a'的键对
dict2
#字典的pop删除
ret=dict2.pop('a') #返回要删除的键对的值
print(dict2)
print(ret)
#字典的更新合并
dic1={'a':1,'b':2}
dict2={'a':'some value','b1':[1,2,3,4]}
dict2.update(dic1)
dict2
#=====结果=====
#{'a': 1, 'b1': [1, 2, 3, 4], 'b': 2}
4.3 查看字典的属性的函数
#查看字典的键(keys)
list(dict2.keys()) #keys提供字典键的迭代器,用list转化为列表
#查看子弹的值(values)
list(dict2.values()) #values提供字典值的迭代器,用list转化为列表
#注意到键、值的输出顺序相同的
#查看字典的视图,返回迭代器,list后的元素为元组
list(dict2.itmes())
4.4 字典的本质(2-元组)+利用dict
函数创建字典
#构建2-元组集合,用dict函数创建字典
c=[(1,'d'),(2,'f'),(3,'g')]
#c=((1,'d'),(2,'f'),(3,'g'))
cc=dict(c)
print(cc)
#利用zip函数将两个序列(元组,字符,列表)组成2-元组的集合
a="dfg"
b=[1,2,3]
ab=dict(zip(a,b))
print(ab)
4.5 某种集合(如:列表)通过设置,构造新的集合(字典)
#dict.setdefault(self, key, default=None, /)
#对字典self,如果键key不在字典中,则插入,且键对应的值默认为None;如果存在,保持不变
#以首字母相同的放在一起,其键为首字母
words=['apple','bat','bar','atom','book']
by_letter={}
for word in words:
letter=word[0]
by_letter.setdefault(letter,[]).append(word)
#字典中的键letter,如果不存在,则插入该键,并且键对应的值改为空列表[]
#.append(word),对于键letter所对应的列表在尾部插入word
by_letter
4.6 利用defaultdict
构建某种要求下的字典
from collections import defaultdict
#创建字符类型的字典
by_letter=defaultdict(str)
by_letter['a']='pd'
by_letter
#创建列表类型的字典
by_letter=defaultdict(list)
by_letter['a'].append('pd')
by_letter
4.7 利用defaultdict
和lambda
对默认字典初始化
from collections import defaultdict
a=defaultdict(lambda :(1,float("inf")))
print(a[1] )
out: (1, inf)
4.8 有效的字典键类型
字典的值可以是任何的python对象,但键必须是不可变对象(标量类型<整数,浮点数,字符串>或元组<元组内的对象也必须是不可变对象>).用到一个术语哈希化,通过hash
函数可以检车一个对象是否可以哈希化(即是否可以用作字典的键
hash('string') #可以
hash((1,2,(3,4))) #可以
hash((1,2,[3,4])) #不可以(列表是可变的)
五、集合
集合是一种无序且元素唯一的容器。通过set
函数或者用字面值与大括号的语法构建。
内置函数
help(set)
----
add() :添加一个元素到集合
clear() :从集合中移除所有的元素
copy():复制一个集合
difference():返回某集合与其他集合们不同的元素构成的集合
difference_update():从这个集合中移除其他集合的元素
discard():在这个集合中,如果一个元素属于这个集合,则移除这个元素,否则什么都不做
intersection():返回两个集合的交集作为一个新集合
intersection_update():一个集合用它与其他集合的交集更新(重新赋值)
isdisjoint():如果两个集合为空,则返回True
issubset():如果一个集合是另一个集合的子集,则返回True
issuperset():如果一个集合包含另一个集合,则返回True
pop():移除并返回集合中的任意一个元素,如果集合为空,则报错
remove():移除集合中的一个元素,如果不是集合中的元素,则报错
symmetric_difference():返回两个集合的对称差作为一个新集合
symmetric_difference_update():对一个集合用它与另一个集合的对称差更新
union(...):返回所有集合(多个)中元素的集合
update(...):对这个集合用其他集合的union更新
set([2,3,4,5,2,2,2])
{2,3,4,5,2,2,2}
#空集合:
b=set()
#空字典
a={}
a={'a','b'}
b={'1','2'}
c={'a','1'}
d={'a','b','c'}
a.difference(b,c)
a. symmetric_difference(c)
a.intersection_update(c)
a.discard('b')
a.issubset(b)
d.issuperset(a)
{1}.pop()
{1,2,4}.remove(2)
a.union(b,c)
a.update(b,{'3'})
#{}.update(b,{''}) 空集不可以
六、列表、集合、字典的推导式
七、生成器
查看《利用python进行数据分析》p77