python之列表 元组 字典 字符串

列表

列表是一种有序可重复的序列，可以随意的增/删/改/查，每个元素的位置都分配了一个数字索引，从0 开始，依次递增。

××通过位置索引操作list××

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1，2，3，4]
list1[0]    #访问
list2[1:4]  #访问，包含1不包含4
list1[-1]   #访问倒数第一个元素
list[-4:]   #访问从倒数第四个元素开始到最后一个元素
list[2] = 2001  #更新
del list[2]     #删除

××list操作符××

list1+list2     #列表拼接
list3+=list1    #列表拼接
len(list1)      #列表元素的个数
min(list)   #返回列表最小值
max(list)   #返回列表最大追值
list(元祖)   #将元组转化成列表
['Hi!'] * 4     #结果['Hi!', 'Hi!', 'Hi!', 'Hi!']
3 in list       #元素3是否存在于list中，存在返回True，否则返回False,经常那个用在if或while的条件判断中
for x in list1: print(x, end=" ")  #迭代，x一次取值list1中元素的值

××list操作方法××

list.append(”abc“) #在列表末尾追加新的对象，对象可以是任意类型，比如列表，元组，字典等都可
list.count('Google') #统计元素'Google'在列表中出现的次数
list.extend(seq)     #跟符号 + 的功能类似，将seq的元素依次拼接到list的末尾
list.index('Google')  #返回'Google'第一次  出现的索引位置  
list.insert(3, "abc") #将元素"abc"插入到位置3处
list.pop()  #移除列表中的最后一个元素，并返回该元素
list.remove(obj) #移除值obj的第一次匹配
list.clear()  #清空列表list
list.copy()   #复制列表list

元组

元组和列表类似，不同之处在于元组的元素不能修改，但访问，拼接，清空都还是可以的

tup1 = ('Google', 'Runoob', 1997, 2000)   #创建元组
tup2 = "a", "b", "c", "d"       #   创建元组时可以不加括号
tup13= (50,)        #元组只有一个元素时，元素后使用逗号

访问元组跟list一样，tuple[1] tuple[-1] tuple[1:5]
元组中的元素是不能被修改的，但是我们可以拼接，tup1 + tup2
元组中的元素是不能被删除的，但是我们可以清空，del tup

元组运算符

运算符	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	元组拼接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	判断元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

**内置函数**
len(tuple)      #元组元素的个数
 max()          #最大值
 min()          #最小值
 tuple(seq) #将列表转化为元组

字典

字典是一种非序列集合，即字典是无序的，可存储任意类型对象。键必须是唯一的且不可改变，但值可以相同，也可改变。

**通过下标访问，修改，增加字典**

dict={'name': 'czz', 'age': 32, 'class': 'first', 1: 'number', (1, 2, 3): 'tuple'}      #定义字典,字典的键类型可以是字符串/数字/元组，但是不能为list
dict['name']                      #使用键值访问字典元素
dict['love']="money"        #键名不存在，则增加元素
dict['name']='tjy'          #键名存在，则修改元素的值为"tjy"
 ```
 **内置函数**

dict={'name': 'czz', 'age': 32, 'class': 'first'} 
len(dict)               #键值对的个数，结果为3
str(dict)               #以字符串形式输出字典，“dict”
type(dict)              #查看字典的类型，输出<class 'dict'>

**内置方法**
dict={'name': 'czz', 'age': 32, 'class': 'first'} 
dict.copy()
dict.fromkeys()
dict.get(’name‘)/dict.get(’name‘,"111")#返回指定键的值，如果键不存在，返回默认值“111”
dict.setdefault('111','111')#如果键存在，返回指定键的值，如果键不存在,将键值对写入字典，并返回对应的值；跟get()类似
key in dict     #判断键值知否在dict中，如果存在返回True，不存在返回False

dict.update(dict2) #将字典dict2内容更新到dict中

dict.items() #python3中，返回的是迭代器，dict_items([('name', 'czz'), ('age', 32), ('class', 'first')]),使用list()获取列表形式的键值对;python3中没有iteritems()函数
dict.keys() #返回一个迭代器，dict_keys(['name', 'age', 'class'])，使用list()可获得字典的所有键
dict.values()   #返回一个迭代器，dict_values(['czz', 32, 'first'])使用list()可获得字典的所有值

dict.pop(”name“)        #删除给定键的对应的值
dict.popitem()          #随机返回并删除字典中的一个键值对
dict.clear()        #清空字典

字典的遍历

 dict={'name': 'czz', 'age': 32, 'class': 'first'}
 for (key,value) in dict.items():   #字典遍历键-值
     print(key,value)
结果为：
name czz
age 32
class first

    >>> for items in dict.items():#遍历字典的项
...     print (items)
...
('name', 'czz')
('age', 32)
('class', 'first')

>>> for key in dict:    #遍历字典的键
...     print(key)
...
name
age
class
>>> for key in dict.keys(): #遍历字典的键
...     print(key)
...
name
age
class

>>> for value in dict.values():    #遍历字典的值
...     print(value)
...
czz
32
first

字符串

hahah=

###sort和sorted
Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列。

sorted(iterable,key=None,reverse=False)，返回新的列表，对所有可迭代的对象均有效
sort(key=None,reverse=False) 就地改变列表 reverse：True反序；False 正序

>>> a=[5,4,3,2,1]
>>> sorted(a)
[1, 2, 3, 4, 5]   #产生一个新的排序列表
>>> print(a)
[5, 4, 3, 2, 1]   #sorted()函数，没有改变a的顺序，说明sorted()不是修改的原list
>>> a.sort()
>>> print(a)
[1, 2, 3, 4, 5]  #sort（）函数修改了a的顺序,说明是在原来列表上直接修改的顺序
>>> sorted(a,reverse=True)#对列表降序排序
[5, 4, 3, 2, 1]
#当list中的元素是元组时，上面的方法就处理不了了，我们需要用到参数key，也就是关键词，看下面这句命令，lambda是一个隐函数，是固定写法，不要写成别的单词；x表示列表中的一个元素，在这里，表示一个元组，x只是临时起的一个名字，你可以使用任意的名字；x[0]表示元组里的第一个元素，当然第二个元素就是x[1]；
>>> a={('b',4),('a',0),('c',2),('d',3)}
>>> sorted(a,key=lambda x:x[1])
[('a', 0), ('c', 2), ('d', 3), ('b', 4)]
>>> sorted(a,key=lambda x:x[1],reverse=True
[('b', 4), ('d', 3), ('c', 2), ('a', 0)]