python数据类型和常用方法总结随笔

列表

　　a_list=[‘a’,’window’]

　　A_list=[] #空列表

　　List() 将有限长度的字符串，元组，range对象转变为列表

　　List(‘hello world’)--->[‘h’,’e’,’l’,’l’,’o’.......]

列表元素添加

　　1.+号

　　　　>>>alist[3,4,5]

　　　　>>>alist=alist+[7]

　　　　>>>alist[3,4,5,7]

　　2.Append() 方法 alist.append(9)

　　3.Extend()方法 将可迭代对象所有元素添加到该列表尾部

　　4.Insert()方法 将元素添加到指定位置，属于原地操作 alist.insert(3,6)将下标3位 置插入元素6

　　5.列表的*算

　　　　list=[3,5,6] 　

　　　　list*3 　　

　　　　>>>[3,5,6,3,5,6,3,5,6]

 

列表元素的删除

　　1.del del命令删除列表中指定位置上的元素，后面元素自动向前移动

　　　　　　>>>del alist[1] 删除下标1的元素

　　2.pop()方法 删除并返回指定（默认最后一个）位置上的元素，若所给索引超出范围则抛出 异常

　　　　list(1,2,3)

　　　　list.pop() 　　

　　　　>>>3

　　3.Remove() 删除首次出现的指定元素，如果列表不存在要删除的元素（空列表），则抛出 异常

　　　　list=[3,5,7,9,7]　　

　　　　list.remove(7) #删除第一个7

　　(不建议使用循环+remove来删除重复元素，因为内存自动管理机制可能会引 起奇怪的错误)

　　

列表元素访问和计数

　　1.下标访问 list=[3,4,5,6,7] >>>list[3] #访问下标3 的元素 >>>6

　　2.Index()方法 获取指定元素首次出现的下标，index(value,start,[stop]),start默认为0，stop 默认列表长度，若列表中不存在指定元素，则抛出异常

　　3.成员判断in 判断成员是否存在列表中

　　　　list=[3,4,5,5.5,7,9,11] 

　　　　>>>3 in list 

　　　　>>>True

 

列表的切片

　　切片适用于列表、元组、字符串、range对象

　　[start:stop:step] start是切片开始位置（默认0）；stop是切片截止（但不包含）位置 （默认列表长度）；step表示步长（默认为1）,可省略

　　　　List=[3,4,5,6,7,8,9,11,13,15,17]

　　　　>>>list[::-1] #步长负数，得到反向副本

 

　　　　[17,15,13,11,9,8,7,6,5,4,3]

　　　　>>>list[::2] #下标0开始每个一个元素取一个元素

 

　　　　[3,5,7,11,15]

　　　　>>>list[3::] #下标3后的所有元素

 

　　　　[6,7,9,11,13,15,17]

　　　　>>>list[:100:] #尾部截断，但不会抛出异常

 

　　　　以如下数组为例

　　　　[3,4,5,6,7,9,11,13,15,17]

　　　　切片作用于字符串和元组的时候，只能用来读取其中的部分元素，但作用于列表的时候却可以实现增删查改，且为原地操作并不影响对象在内存中的起始地址

　　　　>>>alist=[3,5,7]

　　　　>>>alist=[len(alist):]=[9] # 在尾部追加元素

　　　　[3,5,7,9]

 

　　　　>>>alist=[:3]=[1,2,3] #替换前三个元素

　　　　>>>alist

　　　　[1,2,3,9]

 

　　　　>>>alist[:3]=[] #删除前三个元素

　　　　>>>alist

　　　　[9]

 

　　　　>>>alist=list[range(10)] #

　　　　>>>alist

　　　　[0,1,2,3,4,5,7,8,9]

 

　　　　>>>alist[::2]=[0]*(len(alist)//2) #切片不连续，要求等号两侧元素数量一样

　　　　>>>alist

　　　　[0,1,0,3,0,5,0,7,0,9]

 

列表排序和逆序

　　1.sort()方法 列表对象自身提供的方法，原地排序，返回空值none

　　　　>>>alist=[3,4,5,15,11]

　　　　>>>alist.sort()

　　　　>>>alist=[3,4,5,11,15]

　　　　>>>alist.sort(reverse=True) #降序排列

　　

　　2.Sorted()方法 同样排序功能，但是返回新的列表，并不对原来的列表进行修改

 

　　3.Reverse()方法 原地逆序，首尾交换

　　　　>>>alist=[87,79,52,80,53,79]

　　　　>>>alist.reverse()

　　　　>>>alist=[79,53,80,52,79,87]

　　

　　4.reversed() 逆序排列，不对原列表做任何修改，返回一个逆序排列后的迭代器对象

　　　　>>>alist=[3,4,5,6,7]

　　　　>>>newlist=alist.reversed()

　　　　>>>list(newlist) #可以将reversed对象转化为列表

 

列表常用内置函数

1. len(列表) 返回列表的元素个数，适用于元组，字典，集合，字符串，range对象
2. max(列表)、min(列表), 返回列表中的最大或最小元素，适用对象同上
3. Sum(列表)，对数值型列表元素进行求和运算，对非数值型列表则需指定第二个参 数，适用对象同上
4. Zip(*iterables),将多个可迭代对象对应位置的元素组合为元组，并返回包含这些元 组的zip对象

 

元组

元组可视为轻量级列表，属于有序不可变序列

元组与列表的区别是元素用（）包裹

　　>>>a_tuple(‘a’,’b’,’mpilgrim’)

　　>>>x = ()

 

建立一个元素的元组，需要在元素后面添加逗号

　　>>>a=3,

　　>>>a

　　(3,)

 

　　>>>a=1,2

　　>>>a

　　(1,2)

 

可以使用tuple()函数将列表，字符串，字典、集合、map对象等其他类型优先长度的可 迭代对象转换为元组

　　>>>print(tuple(‘abcdrfg’))

　　(‘a’,’b’,’c’,’d’,’e’,’f’,’g’)

 

　　>>>s=tuple() #空元组

 

只能使用del命令删除整个元组对象，不能只删除元组中的部分元素，因为元组属于不 可变序列

 

列表属于可变序列（不可哈希），可以随意修改列表中的元素值；元组属于不可变序列，元组一旦定义就不允许通过任何方式更改，也即是说没有append(),extend(),insert(),remove(),pop()等方法，del()方法不能删除元素，只能删除整个元组。

但是元组是可以切片，只是不能通过切片增减元素。

 

序列解包

这是一种py的赋值语法技巧，它可以将可迭代对象解开，然后赋值到一系列变量中

 

字典

字典是包括若干“键，值”对的无序可变序列，字典中的每个元素包含两个部分：“键”和“值”。定义字典时候，每个元素的“键”和“值”用冒号分隔，相邻元素用逗号分割，所有的元素都放在一对大括号{ }中

“键”是py中任意不可变或可哈希数据，如整数、实数、复数、字符串、元组等，不能使用列表，集合，字典作为“键”，包含列表、集合、字典的元组也不能作为字典的“键”。

“键”不可以重复，但“值”可以。

 

字典创建：

　　　　>>>a_dict={‘server’:’db.x.org’,’database’:’mysql’}

 

　　1.可以通过内置函数dict()快速创建字典：

　　　　>>>key=[‘a’,’b’,’c’,’d’]

　　　　>>>value=[1,2,3,4]

　　　　>>>dictionary=dict(zip(keys,values)) #创建字典

　　　　{'a': 1, 'b': 2, 'c': 3, 'd': 4}

 

　　　　>>>d=dict(name='done',age=37)

　　　　>>>d

　　　　{'name': 'done', 'age': 37}

 

　　　　>>>x=dict()

　　　　>>>x={} #创建空字典

 

　　补充：zip()：将参数打包成元组然后将元组作为元素，以列表方式返回

　　　　但在py3.0中返回的是一个对象，需要使用list()转换

　　　　>>>a=[1,2,3]

　　　　>>>b=[4,5,6]

　　　　>>>zipped=zip(a,b)

　　　　　　Py2.0中

　　　　　　　　>>>zipped

　　　　　　　　[(1,4),(2,5),(3,6)]

　　　　　　Py3.0 中

　　　　　　　　>>>zipped

　　　　　　　　<zip object at 0x111111111>

　　　　　　　　>>>list(zipped) #手动list转换

　　　　　　　　>>>[(1,4),(2,5),(3,6)]

 

　　2.或是只创建“键”，“值”为空或特定值的字典：

　　　　>>>adict=dict.fromkeys([‘name’,’age’,’sex’])

　　　　>>>adict

　　　　{‘name’:none,’age’:none,’sex’:none}

 

字典元素读取

　　1.使用字典的“键”作为下标来访问“值”，若指定的“键”不存在就会抛出异常

　　　　>>>adict={‘name’:’dog’}

　　　　>>>adict[‘name’]

　　　　‘dog’

　　2.使用字典的get()方法，获得指定“键”的值，若键不存在则默认返回none

　　3.Keys()方法，返回字典的键

　　4.Values()方法，返回字典的值

　　5.Items()方法，返回字典的所有键值对

 

字典元素添加和修改

1. 指定“键”为下标为字典元素赋值，若“键”存在，则表示修改该“键”的值，若 不存在则表示新添加键值对

　　　　>>>a_dict={‘name’:’dog’,’sex’:’male’,’age’:37}

　　　　>>>a_dict[‘address’]=‘moon’

　　　　>>>a_dict[‘age’]=40

　　　　>>>a_dict

　　　　>>>{‘name’:’dog’,’sex’:’male’,’age’:40,’address’:’moon’}

　　2.Update()方法，会将另一个字典的键值对全部添加到当前字典对象，若有相同的 “键”，则会对原字典进行更新

 

字典元素的删除

　　1.del 删除字典中指定“键”的元素

　　2.Clear() 删除字典中所有元素

　　3.Pop() 删除并返回指定“键”的元素

　　4.Popitem() 删除并返回字典中最后一个键值对，字典为空时候调用则抛出异常

 

集合

集合是无序可变的容器对象，与字典一样使用一对大括号作为界定符，同一个集合的元素之间不允许重复，每个元素是唯一的

 

集合的创建

　　1.直接集合赋值

　　　　>>>a={3,5,}

　　2.Set()函数将列表、元组、等其他长度有限的可迭代对象转换为集合，当元素里面存 在重复，则只保留一个

　　　　>>>alist=[1,2,3,3]

　　　　>>>aset=set(alist)

　　　　>>>aset

　　　　{1,2,3}

 

集合元素的添加和删除（皆为集合对象方法）

1. add() 添加元素
2. Pop() 返回第一位元素，不接受参数
3. Remove() 删除指定位置参数，接收参数为下标
4. Discard() 删除指定元素，元素不存在时候也不标错，参数为元素值
5. Clear() 清空集合删除所有元素

 

集合支持交，并，差，子集运算

　　>>> aset | bset #并集

　　>>> aset & bset #交集

　　>>> aset - bset #差集

　　>>> aset > bset #比较集合

　　aset是bset 真子集 返回true，否则返回false