【python基础】——列表、元组、字典、函数、生成器

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