标签：rate img 集合 嵌套使用 name move 嵌套 href inpu
列表
一、列表基础
前言：
数组：把一堆同类型的数据挨个放在一起
列表：把一堆任意类型的数据挨个放在一起（基于变量没有类型，列表中的数据也没有类型的）
语法：
list名=[value1,value2,value3,.....]
1、中括号 ；2、数据间用逗号隔开;
特点：有序，数据可重复，数据类型可以不一致，可嵌套使用
示例：
list=[1，‘22‘,"龙猫",3.14] #各种数据类型
list=[1，‘22‘,"龙猫",3.14，[1，2，3]] #列表嵌套列表
list1=[] # 空列表
列表的基础操作：
1、元素的获取（索引、分片）
从左到右：0开始，从右到左边：-1开始
# -*- coding:utf-8 -*-
name=[1,‘a‘,‘json jk‘,3.5]
msg=[11,3]
print(name) #输出完整列表
print(name[0]) #输出列表第一元素
print(name[-1]) #输出列表最后一个元素
print(name[0:2]) #输出列表第一到第二个元素
print(name+msg) #连接列表
print(msg*2) #输出列表2次
#输出
[1, ‘a‘, ‘json jk‘, 3.5]
1
3.5
[1, ‘a‘]
[1, ‘a‘, ‘json jk‘, 3.5, 11, 3]
[11, 3, 11, 3]
list=[1,2,3,4,5,‘haha‘]
print(list[2:4])
print(list[2:])
print(list[:-1])
print(list[:])
#输出
[3, 4]
[3, 4, 5]
[3, 4, 5, ‘haha‘]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, ‘haha‘]
print(list[::2]) #第三个代表步长
print(list[::-1]) #步长为-1，直接反转
#输出
[1, 3, 5]
[‘haha‘, 5, 4, 3, 2, 1]
二、列表的方法：
增（appned 、insert、extand)
list=[1,2,3,4]
list.append(5) #追加最后一个元素后面
print(list)
#输出
[1, 2, 3, 4, 5]
list1=[1,2,3]
list1.insert(2，7) #在第二个元素后面插入
print(list)
#输出 [1, 2, 7, 5]
1 list1=[1,2]
2 list2=[7,8]
3 list1.extend(list2)
4 list2.extend(list1)
5 print(list1)
6 print(list2)
#输出
[1, 2, 7, 8]
[7, 8, 1, 2, 7, 8]
删（remove、del、pop）
1、 指定需要删除的内容，否则若删除的元素不存在，程序会报错
2、不能指定元素的位置
>>>remove
list=[1,2,3,4,5]
list.remove(2) #删除指定内容的元素
print (list)
#输出
[1, 3, 4, 5]
指定删除元素的索引位置(del是一个语句，不是list的方法)，删除整列 del list
list=[1,2,77]
del list[0]
print (list)
#输出
[2, 77]
1、默认删除最后一个
2、指定索引后，删除具体位置元素
>>> poplist.pop() #默认删除最后一个元素
print(list)
>>>list.pop(0) #删除第一元素
print(list)
#输出
[1, 3, 4]
[3, 4]
改
list1=[1,4]
list1[0]=2
print(list1)
#输出
[2, 4]
查（索引）
index() 通过元素值获取下标值
list=[8,‘a‘,1]
print(list.index(‘a‘))
>> 1
通过下标值获取元素
list=[8,‘a‘,1]
print(list[0])
>>
8
清空（clear）
list=[8,‘a‘,10]
print(list.clear())
#输出
None
反转（reverse）
排序（sort）
将用户输入的数从大到小排序，并输出
x=int(input("请输入x:"))
y=int(input("请输入y:"))
z=int(input("请输入z:"))
list=[x,y,z] print(list)
list.sort()
list.reverse()
for i in range(len(list)):
print(list[i])
i=i+1
# 输出
请输入x:3
请输入y:4
请输入z:1
4
3
1
三、列表常用操作符
list1=[133]
list2=[214]
print(list1>list2)
#
False
list3=[123,456] #第一个元素开始比较，只要一个pk赢了，整个列表就赢了
list4=[234,123]
print(list1>list2)
#
False
加号（+）代表连接，乘号（*）代表负责自身若干次
list1=[123,456]
list2=[234]
list3=list1+list2
print(list3)
#
[123, 456, 234]
list1=[123,456]
list2=[234]
list4=list2*2
print(list4)
#
[234, 234]
>>>list1=[123,456]
>>>123 in list1
True
元组
一、元组基础
写法：（小括号、逗号）
tuple1=(1,2,3)
tuple1=1,2,3
tuple2=(1,)
标志性符号的关键是逗号，不是小扩号，如下
>>>tuple1=(8)
>>>print(type(tuple1))
<class ‘int‘>
>>>tuple2=(8,)
>>>print(type(tuple2))
<class ‘tuple‘>
>>>c=1,2,3
>>>print(type(c))
<class ‘tuple‘>
元组元素的获取（索引、切片）
tuple = ( ‘abcd‘, 786 , 2.23, ‘runoob‘, 70.2 )
tinytuple = (123, ‘runoob‘)
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
以上实例输出结果：
(‘abcd‘, 786, 2.23, ‘runoob‘, 70.2)
abcd
(786, 2.23)
(2.23, ‘runoob‘, 70.2)
(123, ‘runoob‘, 123, ‘runoob‘)
(‘abcd‘, 786, 2.23, ‘runoob‘, 70.2, 123, ‘runoob‘)
二、元组的方法
元组不支持修改，所以列表中的 ：元素赋值，删除元素，分片赋值，append，extend，insert，pop，remove，reverse，sort,高级排序任何妄图修改元组的函数都不支持。
>>>tup = (1, 2, 3, 4, 5, 6)
>>> tup[0] = 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘tuple‘ object does not support item assignment
>>>
1、count（）查找某个元素出现的次数
x=(1,2,2)
print(x.count(2))
>> 2
2、index:找出某个元素的索引位置：
x=(1,2,2)
print(x.index(2))
=> 1
三、元组的常用操作符
和列表一样，支持算术操作（+、*），逻辑操作，成员关系操作(not in 、in）
乘法：
x=(1,2,3,4,5)
x*3
=>(1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
成员关系：
x=(1,2,3,4,5)
1 in x
=> True
6 in x
=> False
四、BIF元组相关内置方法
1、tuple（）将可迭代对象转换为元组
tuple(‘Hello‘)
=>(‘H‘,‘e‘,‘l‘,‘l‘,‘o‘)
2、min,max,len,sum:
x=(1,2,3,4,5)
min(x)
=>1
max(x)
=>5
len(x)
=>5
sum(x)
=>15
五、Python之“可变”的tuple
前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple：
>>> t = (‘a‘, ‘b‘, [‘A‘, ‘B‘])
注意到 t 有 3 个元素：‘a‘，‘b‘和一个list：[‘A‘, ‘B‘]。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：
>>> L = t[2]
然后，我们把list的两个元素改一改：
>>> L[0] = ‘X‘ >>> L[1] = ‘Y‘
再看看tuple的内容：
>>> print t (‘a‘, ‘b‘, [‘X‘, ‘Y‘])
不是说tuple一旦定义后就不可变了吗？怎么现在又变了？
别急，我们先看看定义的时候tuple包含的3个元素：
当我们把list的元素‘A‘和‘B‘修改为‘X‘和‘Y‘后，tuple变为：
表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。
tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向‘a‘，就不能改成指向‘b‘，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。
序列
python中有6种序列，常用的2种：列表、元组。列表和元组的区别：列表可以修改，元组不可以修改。
序列的通用操作
所有序列可以进行某些特定的操作，这些操作包含：
1、索引、分片、加、乘、成员资格（in 、not in）。
2、len（）、max（）、min（）
3、迭代
共同点：
1、都可以通过索引得到一个元素
2、从左到右0代表开始，从右到左-1代表开始
3、都可以通过切片/分片得到一个范围内的元素的集合
4、都有很多共同的操作符（算术操作符+、*）（成员关系操作符in、not in）（比较操作符> <）
序列的内置方法【BIF】
1、list()
list()把一个可迭代对象转换为列表
#字符串转换为列表
a="world" print (list(a)) #元组转换为列表
c=(1,‘w‘,33)
print(list(c))
#输出
[‘w‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘]
[1, ‘w‘, 33]
2、tuple（）
tuple（）把一个可迭代的对象转换为元组，和list（）一样
3、str（）、int（）、float（）
str（）把对象转换为字符串
4、len（）
返回参数长度
5、max（）、min（）
返回序列或者参数集中最大/最小的值
确保序列或者参数集中的数据类型一致，否则会出错
6、enumerate（）
作用：生成二元组构成的一个迭代对象，该二元组由迭代参数的索引号，以及对应的元素组成，如下：
a="we"
for i in enumerate(a):
print(i)
#输出
(0, ‘w‘)
(1, ‘e‘)
a="we"
for i in enumerate(a):
print(i[1])
#输出
w
e
字典dict
一、创建与访问：
1、创建：2种方式
x={} #空字典
x={‘a‘:1,‘b‘:2}
x=dict（） #空字典
方法一：
x=dict（a=1，b=2）
>>{‘a‘: 1, ‘b‘: 2}
方法二：
dict()函数的参数可以是一个序列，但不能多个，所以要打包成一个元组序列或者以列表
y=dict((("a",2),("b",2)))
print(y)
>>{‘a‘: 1, ‘b‘: 2}
x=dict({"a":2,"3":4})
print(x)
>>{‘a‘: 1, ‘b‘: 2}
2、访问：
1、序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
2、访问不存在的键会报错
x={‘a‘:1,‘b‘:2}
y=x[‘a‘]
print(y)
#输出
1
通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
要避免 KeyError 发生，有两个办法： 一是先判断一下 key 是否存在，用 in 操作符： if ‘Paul‘ in d: print d[‘Paul‘]
如果 ‘Paul‘ 不存在，if语句判断为False，自然不会执行 print d[‘Paul‘] ，从而避免了错误。 二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None： >>> print d.get(‘Bart‘) 59 >>> print d.get(‘Paul‘) None
3、字典特点：
1、无序 。存储的key-value序对是没有顺序的！这和list不一样
2、由于dict是按 key 查找，所以，在一个dict中，key不能重复。
键必须唯一，值可以取任何数据类型，但必须是不可以改变的（数字、字符串、元组），不能使用列表
二、字典内置的方法
1、增
x={‘a‘:1,‘b‘:2}
x["c"]=3
print(x)
#输出
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
2、删 pop() 、del() 、popitem()
pop
x={‘a‘:1,‘b‘:2}
print(x.pop("a"))
#输出
1
popitem()随机删除一个
del（）
x={‘a‘:1,‘b‘:2}
del x["a"]
print (x)
#输出
{‘b‘: 2}
3、改
x={‘a‘:1,‘b‘:2}
x["b"]=3
print (x)
#输出
{‘a‘: 1, ‘b‘: 3}
4、查
x={‘a‘:1,‘b‘:2}
（1）x[‘a‘] 不建议使用，若无该值会报错
(2) x.get(‘a‘) 若无该键，则返回none，不会报错
5、keys（）、values（）、items（）：返回字典中的键、返回字典中的所有值、返回字典中的所有键值对
6、update（）
合并2个字典，无交集的就新增，有交集（相同的键）就修改成更新的字典
x={‘a‘:1,‘b‘:2}
y={‘a‘:3,‘c‘:4}
x.update(y)
print (x)
#输出
{‘a‘: 3, ‘b‘: 2, ‘c‘: 4}
7、循环遍历
取键
x={‘a‘:1,‘b‘:2}
for i in x:
print (i)
#输出
a
b
取值
x={‘a‘:1,‘b‘:2}
for i in x:
print (x[i])
#输出
1
2
取键值
x={‘a‘:1,‘b‘:2}
for i in x:
print (i,x[i])
#输出
a 1
b 2
集合
1、创建集合：
法一：把元素用{}括起来，如：
num={1,"hello","你好"}
法二：set（）函数，如：
num=set([1,"hello","你好"]) print(num)
>>>{1, ‘hello‘, ‘你好‘}
2、集合的特点
集合的作用，两个字：唯一，如下：
num={1,2,2,3,3,4}
print(num)
>>>
{1, 2, 3, 4}
集合无序，所以无法通过索引获取值，否则报错。标签：rate img 集合 嵌套使用 name move 嵌套 href inpu
原文地址：http://www.cnblogs.com/wye2014/p/7028995.html
