Python基础语法笔记（面向过程·中）

六、 列表

6.1 为什么需要列表

变量可以存储一个元素；列表是一个“大容器”，可以存储多个元素，方便程序对这些数据进行整体操作。

相当于其他语言中的数组

可以存储不同类型的对象。

变量存储的是一个对象的引用（id值）。

列表存储的是多个对象的引用。

6.2 列表对象的创建

1.使用中括号[]，元素之间用英文逗号‘,’分隔

2.使用内置函数list()

存储的实际上是这些对象的一个引用。

ls1 = ['hello','world']
ls2 = list(['hello','world'])

6.3 列表的特点

1.列表元素按顺序有序排序

2.索引映射唯一一个数据（有正向和反向两种索引序号）

3.列表可以存储重复数据

4.任意数据类型混存

5.根据需要动态分配和回收内存

6.4 列表的查询操作-获取指定元素的索引

index()方法的用法：

1.如果要查询的列表中存在n个相同元素，只返回相同元素中的第一个元素的索引

2.如果查询的元素在列表中不存在，则会有ValueError

3.还可以在指定的[start,stop)之间查找。

ls = ['hello','world',98,'hello']
print(ls.index('hello')) #输出0
print(ls.index('Python')) #ValueError
print(ls.index('hello',1,3)) #ValueError

6.5 列表的查询操作-获取列表中指定的元素

获取列表中的单个元素用索引：

1.正向索引：0到n-1 如：ls[0]

2.逆向索引：-n到-1 如：ls[-2]

3.如果指定的索引不存在（超出范围），程序报错：IndexError

6.6 列表的查询操作-获取列表中的多个元素_切片操作

语法格式：

列表名[start:stop(:step)]

1.切片的结果：原列表片段的拷贝(结果是一个新的列表对象，id与原列表不同)

2.切片的范围：[start,stop)

3.step可省，默认为1，省略后简写为：列表名[start,stop]或者：列表名[start,stop:]

4.step为正数时：start省略时默认从0开始；stop省略时默认切片到最后

5.step为负数时：start省略时默认从末尾开始；stop省略时默认切片到开头元素

step为负数时是逆序输出。

ls = [0,10,20,30,40,50,60,70]
print(ls[::-1])#列表的翻转
print(ls[7::-1])
print(ls[6:0:-2])

6.7 列表元素的判断及遍历

判断指定元素在列表中是否存在：

元素 in 列表名

元素 not in 列表名

列表元素的遍历：

for 迭代变量 in 列表名：

​ 操作

6.8 列表元素的添加操作

1.append()方法：在列表末尾添加一个元素，没有创建新的列表对象

ls.append(100)

2.extend()方法：在列表的末尾一次性至少添加一个元素

#请比较：
ls1 = [10,20,30]
ls2 = ['hello','world']
ls1.append(ls2)#结果为：[10, 20, 30, ['hello', 'world']]，也就是说，append()方法把ls2作为一个元素了
ls1.extend(ls2)#结果为：[10, 20, 30, 'hello', 'world']，也就是说，extend()方法把ls2的每个元素添加到ls1的末尾

3.insert(索引，待添加元素)方法：在列表的任意一个位置添加一个元素

ls.insert(1,90)

4.切片：在列表的任意位置添加至少一个元素

ls1 = [10,20,30]
ls2 = ['hello','world']
ls3 = [1,2,3]
ls[1:] = ls3 #相当于先切掉，再用新的去替换

最常用的是append()方法

6.9 列表元素的删除操作

1.remove(待移除的元素)方法：

一次删除一个元素

重复元素只删除第一个

元素不存在则报错：ValueError

ls = [10,20,30,40,50,60,30]
ls.remove(30) #只移除第一个30
ls.remove(100) #ValueError

2.pop(索引)方法：

删除一个指定位置上的元素

指定索引不存在则报错：IndexError

如果不指定索引，则删除列表中的最后一个元素

ls = [10,20,30,40,50,60,30]
ls.pop(1)#删除索引为1的元素
ls.pop(10)#IndexError
ls.pop()#删除最后一个30

3.切片：一次至少删除一个元素，但会产生一个新的列表对象

new_list = ls[1:3]

想要不产生新的列表对象？

ls[1:3]=[]

4.clear()方法：请空列表

ls.clear()
print(ls) #得到一个空列表

5.del：删除整个列表对象

del ls
print(ls) #返回NameError:name 'ls' is not defined

6.10 列表元素的修改操作

1.指定索引的元素，赋予其一个新值（一次修改一个值）

ls = [10,20,30,40]
ls[2] = 100
print(ls) #结果：[10,100,30,40]

实质是引用的改变。

2.为指定的切片赋予一个新值（一次修改一或多的值）

ls[1:3] = [300,400,500,600]

遵循多增少减的原则。

6.11 列表元素的排序操作

1.sort()方法：所有元素默认按从小到大顺序进行排序；可以指定reverse=True进行降序排序，没有产生新列表。

ls.sort() #默认升序，也可以写成ls.sort(reverse=False)
ls.sort(reverse=True) #降序

2.内置函数sorted()：默认升序，可以指定reverse=True进行降序排序，原列表不发生改变，会产生一个新的列表对象。

new_list = sorted(ls) #默认升序
new_list = sorted(ls,reverse=True) #降序

6.12 列表生成式

列表生成式：生成列表的公式

语法格式：

[ i for i in range(1,10) ]

i 为表示列表元素的表达式（生成的列表的每个元素的值）

ls = [i for i in range(1,10)]#结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
ls = [i*i for i in range(1,10)]#结果：[1, 4, 9, 16, 25, 36, 49, 64, 81]
ls = [i*2 for i in range(1,6)]#结果：[2,4,6,8,10]

七、 字典

7.1 什么是字典

Python内置数据结构之一，和列表一样是一个可变序列（可以增删改）。用{}定义

以键值对的方式存储数据。是一个无序序列（需要经过哈希函数计算存储位置，并不是根据存放的顺序）。

字典名 = {‘键1’:值1, ‘键2’:值2, ‘键3’:值3}

元素中间使用英文逗号分隔

键必须是不可变的数据类型，如字符串（不可进行增删改）

7.2 字典的实现原理

通过哈希函数计算key来查找value的位置

查找效率高。

7.3 字典的创建

1.最常用：使用{}

scores = {‘张三’:100,‘李四’:98}

2.使用内置函数dict()

student = dict(name = ‘Jack’, age = 20)

等号赋值，键name是不用加引号的。

3.空字典：{}

dict = {}

7.4 字典元素的获取

1.用中括号[键]

scores['张三']

2.get(键)方法

scores.get('张三')

两者区别：

[]查找时，如果查找的键不存在，会报错：KeyError

get()查找时，返回默认值None。

get(键,值):如果键不存在，会返回提供的值，默认是None

7.5 字典元素的增、删、改操作

key的判断：

1.in 指定的key存在则返回True，否则False

2.not in 指定的key不存在则返回True，否则False

字典元素的删除：

1.del 字典名[键]（删除指定的键值对）

del scores['张三']

2.clear()方法：清空字典中的元素

scores.clear()

字典元素的新增：

直接通过索引来新增（以前没有的）或者修改（已有的）键值对

scores['陈六'] = 98
scores['李四'] = 70

7.6 获取字典视图

1.keys()方法：获取字典中所有key

keys = scores.keys()
print(keys) #结果为dict_keys(['张三', '李四'])
print(type(keys)) #结果为<class 'dict_keys'>类型

可以用list()将键视图转成列表

print(list(keys)) #结果为：['张三', '李四']

2.values()方法：获取字典中所有value

类型为dict_values

3.items()方法：获取字典中所有key,value对

items = scores.items()
print(items) #结果为dict_items([('张三', 100), ('李四',98)]),每个键值对用元组表示
print(type(items) #结果为<class 'dict_items'>类型
print(list(items)) #转换后的列表元素是由元组组成的

7.7 字典元素的遍历

for item in 字典名:

​ 操作

获取的item实际上是字典中的键

遍历字典中的值：

for item in 字典名:

​ item.字典名[item] 或者 字典名.get(item)

7.8 字典的特点

1.字典中所有元素都是一个键值对，键不能重复（一旦重复会出现覆盖情况），值可以重复。

2.字典中的元素是无序的，不能手动使它在某个位置插入元素

3.字典中的键必须是不可变对象。如整数、字符串、元组

4.字典也可以根据需要动态地伸缩

5.字典会浪费较大内存，但查找速度很快，是一种以空间换时间的数据结构。

7.9 字典生成式

将第一个列表的元素作为键，第二个列表的元素作为值，生成字典，用内置函数zip()。

zip()用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回这些元组组成的列表。

字典生成式：{key:value for key,value in zip(keys,values) }

(其中，keys和valus均为列表)

如果两个列表元素个数不等，会按短的那个列表的元素个数为准。

八、 元组与集合

8.1 什么是元组

元组是Python内置结构之一，是一个不可变序列。

不可变序列：字符串、元组–没有增删改操作，连接操作后内存地址更改了

可变序列：列表、字典–可以对序列执行增删改操作并且对象地址不发生更改

元组名 = (‘python’, ‘hello’, 90) 各元素之间用逗号连接

使用小括号定义，可存储的元素与列表相似。

8.2 元组的创建方式

1.直接用小括号（英文的）

t1 = ('python','hello',90)
#小括号可以省略不写：
t2 = 'python','hello',90
#元组中只有一个元素时，需要使用逗号和小括号，逗号不能省略
t3 = ('python')#类型是str
t3 = ('python',)#类型是tuple

2.内置函数tuple()

t4 = tuple(('python','hello',90))

3.空元组：

空列表：ls = list() 或 ls = []

空字典：d = {} 或 d = dict()

空元组：t = () 或 t = tuple()

8.3 为什么要将元组设计成不可变序列

在多任务环境（如多人同时操作）下，同时操作对象时不需要加锁。

因此，程序中尽量使用不可变序列。

注意：元组中存储的是对象的引用

1.如果元组中对象本身是不可变对象，则不能再引用其他对象

2.如果元组中对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。（就是说，不能指向别的对象，但是可变对象内部数据可以改）

8.4 元组的遍历

for item in 元组名：

​ 操作

获取元组元素的方式：索引

但是要知道元组的长度，否则越界报错。

8.5 集合的概述与创建

属于可变类型序列，是Python提供的内置数据结构

集合是没有value的序列。（与字典比较，只有键，没有值）

也用了哈希表，因此是无序的。

用{}表示

集合中的元素不允许重复–去重

创建方式：

1.直接用花括号{}，元素之间用逗号分隔

2.内置函数set()

set(range(6))
set([1,2,3,4,5])
set((33,44,55,66))
set('python')
set({124,3,4,5})

3.定义空集合：不能使用{}(字典)；要用set()

8.6 集合的相关操作

集合元素的判断操作：in 或 not in

集合元素的新增操作：

1.add()方法：一次添加一个元素

2.update()方法：一次至少添加一个元素，参数可以是集合、列表、元组

s.update({10,20,30})
s.update([10,20,30])
s.update((10,20,30))

集合元素的删除操作：

1.remove(待删除元素)方法：一次删除一个指定元素，如果指定元素不存在则报错：KeyError

2.discard(待删除元素)方法：一次删除一个指定元素，如果指定元素不存在不报错

3.pop()方法：一次只删除一个任意元素–无参数

4.clear()方法：清空集合

8.7 集合间的关系

1.是否相等（元素相同）：用==和!=判断

2.一个集合是否是另一个集合的子集：issubset()方法

s2.issubset(s1)

3.一个集合是否是另一个集合的超集：issuperset()方法

s2.issuperset(s1)

4.两个集合是否没有交集：isdisjoint()方法

无交集返回True，有交集返回False

8.8 集合的数据操作

集合的数学操作：（操作后，原集合没有发生变化，产生的是新的集合）

1.交集：s1.intersection(s2)方法或者s1&s2

2.并集：s1.union(s2)方法或者s1|s2

3.差集：s1.difference(s2)方法或者s1-s2

4.对称差集：s1.symmetric_difference(s2)

8.9 集合生成式

{i for i in range(1,10)}

元组没有生成式（不可变序列）

总结一下四种组合数据结构：

数据结构	是否可变	是否重复	是否有序	定义符号
列表list	可变	可重复	有序	[ ]
元组tuple	不可变	可重复	有序	( )
字典dict	可变	key不可重复，value可重复	无序	{key:value}
集合set	可变	不可重复	无序	{ }