python代码学习——列表、字典及元组、ipython

• 数据类型总结：
• 可变类型：list、dict、set
• 不可变类型：bool、str、int、float、tuple、None
• 数据类型的转换：int(),str(),float(),set()
• • 转换int，数字字符串，float可以转换为int
• • 转换str，所有的数据类型都可以转换，
• • 转换float：int，或者整数或者小数字符串可以转换为float
• • 转换list：元组转换列表
• 有序：str、list、tuple
• 无序：dict、set
• 可迭代：str、list、dict、tuple、set、range
• 不可迭代：int、float、bool

一、列表

列表的定义、格式及特点

列表：由一系列按照特定顺序排列元素组成的集合
格式：[元素a,元素b]
列表的定义：赋值即定义，列表不能一开始就定义大小
关键字：list，注意：list不能用于命名
特点：

• 可修改有序的，可变的
• 存在空列表
• 元素之间使用逗号隔开，使用[]括起来
• 什么元素都可已放进列表，整数，浮点数，；列表，元组，字符串，布尔值都可以
• 线性的数据结构

以下是列表的代码及输出运行结果

list_msg=[100,112.45,
'python','java',
{
   'dict_key':'dict_value'},
[2,5,'hdjhiaf'],
(78,'hajhjfa','C#')]
print(list_msg)

列表，链表，stack和queue的区别

• 列表时有序、可变的线性结构，可预知下一个元素偏移几个单位
• 链表是有序的非线性结构，零散放置，不能使用偏移的方式寻找，即不可使用索引的方式寻找
• queue，队列，有序的自定义结构方式，可线型也可非线型；先进先出，后进先出，可以从两头走
• stack 栈，后进先出，竖着放置，从上往下取值，先进的在底部，后进的在最上面，取值从最上面取

列表的取值、切片、嵌套取值

直接使用索引取值

• 列表的取值格式：列表名[索引值]
• 列表是有序的，因此列表的取值可根据列表的下标（索引值）来获取，列表的下标从0开始
• 列表的切片：列表名[元素头的位置：元素尾的位置+1：步长]，与字符串的切片类似，其默认步长为1

list_msg=[100,112.45,'python','java',
{
   'dict_key':'dict_value'},[2,5,'hdjhiaf'],
(78,'hajhjfa','C#')]
a=list_msg[4]
print("列表中索引为4的值为：",a)
b=list_msg[2:5:1]#存在步长
c=list_msg[2:5]#不取步长
d=list_msg[2:6:2]#步长为2
print("列表中第2-4个元素",b)
print("列表中第2-5个元素，默认步长取值：",c)
print("列表中第2和第4个元素：",d)

4.列表的嵌套取值，思考：如以下代码，如何取值404？

list_int=[100,[102,105,107],200,[205,209,[303,404]]]

列表的嵌套取值方法： 在索引值后面直接加上嵌套元素的下标即可，取值方式代码及运行结果如下：

list_int=[100,[102,105,107],200,[205,209,[303,404]]]
list_value=list_int[3][2][1]
print(list_value)

使用函数查找

index、count和len

1.index(value)

• 通过value，从指定区间查找列表中的元素是否匹配
• 如果匹配到第一个元素就立即返回索引
• 如果匹配不到，抛出异常ValueError
• 可以在value后加索引，查找的是指定索引之后的数值，返回的是从左至右的索引值

2.count(count)

• 返回列表中匹配value的次数

3.index和count的时间复杂度

• index和count方法的时间复杂度都是O(n)
• 随着列表数据规模的增大，效率会下降

4.len(列表名)

• 返回列表的长度
• 代码示例：

list_msg=['i love python','java','web',
          'ios',3,78,9,32,'yezi','love','java',78]
print("count，统计value的个数：",list_msg.count('java'))
print("index，从左至右取值：",list_msg.index(78,1))
print("index，从右至左取值：",list_msg.index(78,-2))
print("index，默认：",list_msg.index(78))
print("len，列表长度:",len(list_msg))

列表元素的增删改

列表元素的修改

• 格式：列表名[索引值]=value(要更新的值)
• 注意：索引不要越界
• 代码示例：

list_msg=['i love python','java','web',
          'ios',3,78,9,32,'yezi','love','java',78]
list_msg[-1]="haha"

列表元素添加(append、instert、+、*、extend)

列表元素的添加有5种方式，分别为append、instert、+、*和extend
1.列表名.append（添加值)

• 列表尾部追加，返回值为None
• 返回None意味着不能使用变量接收，在原列表中进行修改
• 其时间复杂度是O(1)，因为有固定索引，不需要改变列表的其他元素

2.列表名.insert（索引，添加值）

• 在指定的索引(index)中插入元素，返回值也是None
• 返回None意味着不能使用变量接收，在原列表中进行修改
• 时间复杂度不确定，如果索引为-1，其时间复杂度为O(1)，如果在中间插入元素，需要修改添加索引之后的元素的内存排序，会消耗一定的效率
• 当索引超越上界时，在尾部追加；索引超越下界时，在头部追加

3.列表名.extend（iteratable）

• iteratable指的是可迭代的对象，将其追加进来，返回值为None
• 返回None意味着不能使用变量接收，在原列表中进行修改
• 可迭代的对象，可以是列表，可以是字典,可以是字符串，可以是元组
• 可迭代的元素，如果是字典，默认迭代字典的key值，value值可以使用字典.values()添加

4.列表+列表

• 两个列表的拼接
• 有返回值，可用变量接收

5.列表*数值

• 重复操作，将列表中的元素重复n次
• 有返回值，可用变量接收

6.代码示例：

list_1,list_2=[1,2,3,4,5],[1,2,3]
a=list_1+list_2
print("列表1和列表2拼接，+",a)
b=list_2*3
print("列表2重复3次",b)
list_1.append(6)
print("列表1末尾追加6",list_1)
list_2.insert(1,7)
print("列表2在第一个索引上插入7:",list_2)
list_1.insert(100,10)
print("列表1超越上届插入:",list_1)
list_2.insert(-100,50)
print("列表2超越下界插入:",list_2)
list_1.extend(list_2)
print("列表1和列表2拼接，extend",list_1)

list_1 = [1,2,3]
dict_1 = {
   "name":2}
str_1 = "app"
tuple_1 = (1,2,3)
list_1.extend(dict_1)#添加字典key
list_1.extend(dict_1.values())#添加字典values
list_1.extend(dict_1.items())#添加字典的所有元素，样式为元组
list_1.extend(str_1)
list_1.extend(tuple_1)
print(list_1)

========运行结果==============
列表1和列表2拼接，+ [1, 2, 3, 4, 5, 1, 2, 3]
列表2重复3次 [1, 2, 3, 1, 2, 3, 1, 2, 3]
列表1末尾追加6 [1, 2, 3, 4, 5, 6]
列表2在第一个索引上插入7: [1, 7, 2, 3]
列表1超越上届插入: [1, 2, 3, 4, 5, 6, 10]
列表2超越下界插入: [50, 1, 7, 2, 3]
列表1和列表2拼接，extend [1, 2, 3, 4, 5, 6, 10, 50, 1, 7, 2, 3]

[1, 2, 3, 'name', 2, ('name', 2), 'a', 'p', 'p', 1, 2, 3]

列表元素的删除和清空(remove、pop、clear、del)

列表元素的删除有5种方式，分别为remove、pop、clear、del
1.列表名.remove（列表元素)

• 从左至右删除第一个匹配到元素列表的值，移除该元素后，返回None
• 返回None意味着不能使用变量接收，在原列表中进行修改
• 移除元素后，其他的元素要进行补位，会引起比较大的效率问题，因此尽可能的少用

2.列表名.pop()

• 不指定索引index，就从列表尾部弹出一个元素
• 指定索引，就从索引出弹出一个元素，索引超界抛出IndexError的错误
• 删除元素后**，返回被删除的元素，可使用变量接收后进行下一步操作**
• 不指定索引，时间复杂度为O(1),指定索引后，相当于remove，时间复杂度较高

3.列表名.clear()

• 清空列表中的所有元素，剩下一个空列表
• 清空元素过多，且没有对元素元素进行再处理的情况下，易引起垃圾回收，会带来一定的效率问题

4.del 列表名[索引]

• 没有索引的情况下，删除的是整个列表
• 存在索引的情况下，删除的是指定索引的值
• 可使用切片删除列表中的值

代码及运行结果如下：

list_1,list_2=[1,2,3,4,5],[1,2,3]
list_2.remove(1)
print("remove删除某个元素后的列表：",list_2)
a=list_1.pop()
print("pop删除最后一个元素：",a,"列表：",list_1)
b=list_1.pop(2)
print("pop删除第二个索引的元素：",b,"列表：",list_1)
list_2.clear()
print("清空列表：",list_2)
del list_1[2:]
print("del删除第二个索引之后的元素",list_1)
del list_2
print(list_2) #列表已经删除，再次打印时报错
=================run result===========
Traceback (most recent call last):
  File "/Users/practice_3.py", line 157, in <module>
    print(list_2)
NameError: name 'list_2' is not defined. Did you mean: 'list_1'?
remove删除某个元素后的列表： [2, 3]
pop删除最后一个元素： 5 列表： [1, 2, 3, 4]
pop删除第二个索引的元素： 3 列表： [1, 2, 4