一、序列(sequence)
- 序列是Python中最基本的一种数据结构。
- 数据结构指计算机中数据存储的方式。
- 序列用于保存一组有序的数据,所有的数据在序列当中都有一个唯一的位置(索引),并且序列中的数据会按照添加的顺序来分配索引。
- 序列的分类:
- 可变序列(序列中的元素可以改变)
- 列表(list)
- 不可变序列(序列中的元素不可以改变)
- 字符串(str)
- 元组(tuple)
- 可变序列(序列中的元素可以改变)
- 序列的通用操作:
- 切片
- +、*
- in、not in
- max()、min()
- index()
- count()
二、列表(list)
2.1 简介
列表可以保存多个有序(数据按添加的顺序存储)的数据,另外Python不用声明变量类型,所以列表可以直接存放不同类型的对象。
使用[]创建列表
my_list = [10, 2.2, "33", True, None]
但是如果Java想实现这一点,则要声明List的泛型为Object。
List list = new ArrayList<>();
可以通过索引获取列表中的元素,若索引超出长度,则报 list index out of range 异常。
my_list = [10, 20, 30, 40, 50]
print(my_list[2]) # 30
如果索引为负数,则表示倒序。-1表示倒数第一个,-2表示倒数第二个。
my_list = [10, 20, 30, 40, 50]
print(my_list[-1]) # 50
使用len()函数获取列表的长度。
my_list = [10, 20, 30, 40, 50]
print(len(my_list))
5
2.2 通用操作
切片
切片指从现有列表中,获取一个子列表。
- 语法:列表[起始位置:结束位置]
- 不包括结束的位置,左闭右开。
- 返回一个新列表,不影响原来的列表。
- 起始跟结束位置的索引可以省略:
- 若起始省略,表示从第一个开始。
- 若结束省略,表示截取到最后一个。
- 如果都省略,相当于复制了一份原来的列表。
names = ["tom", "jack", "amy", "bob", "ross"] subname = names[3:] print(subname) # ['bob', 'ross'] subname = names[:3] print(subname) # ['tom', 'jack', 'amy'] subname = names[:] print(subname) # ['tom', 'jack', 'amy', 'bob', 'ross']
- 语法:列表[起始位置:结束位置:步长]
- 步长表示每次获取元素的间隔。
- 步长可以是负数,但不能是0。
- 步长若是负数,表示倒序取元素
其他
- + 拼接、* 重复
names = ["tom", "jack", "amy"]
print(names + ["helloworld"])
print(names * 2)
['tom', 'jack', 'amy', 'helloworld']
['tom', 'jack', 'amy', 'tom', 'jack', 'amy']
- in、not in 判断元素是否在序列中
print("tom" in names) # True
print("tom" not in names) # False
print("jerry" in names) # False
print("jerry" not in names) # True
- max()、min() 最大最小值
num=[10,20,30,40,50]
print(max(num)) # 50
print(min(num)) # 10
- index() 获取指定元素的第一个索引位置,若元素不存在,抛异常。
- count() 统计指定元素出现的次数。
num = [10, 20, 30, 40, 30, 20, 10]
print(num.index(10)) # 0
print(num.count(20)) # 2
2.3 修改元素
通过索引修改
names = ["Bob", "Jack", "Jerry", "Tom"]
names[1] = "hello"
print(names)
['Bob', 'hello', 'Jerry', 'Tom']
通过切片修改
names = ["Bob", "Jack", "Jerry", "Tom"]
names[0:2]=["hello","world"]
print(names)
['hello', 'world', 'Jerry', 'Tom']
通过切片删除元素
names = ["Bob", "Jack", "Jerry", "Tom"]
del names[0:2]
print(names)
['Jerry', 'Tom']
需要注意的是,以上操作仅限于可变序列。
2.4 列表的方法
增加元素
- list.append(value) 在最后的位置添加元素。
- list.insert(value,index) 在指定索引位置插入元素。
- list.extend( list) 将新序列扩展到当前序列尾部。
删除元素
- list.clear() 清空所有元素。
- list.pop(index) 删除指定索引上的元素,并返回该元素。若index不传,默认删除最后一个元素。
- list.remove(value) 删除指定的元素,若存在多个,只会删除第一个。
排序
- list.reverse() 反转列表。
- list.sort() 对元素进行排序,默认是升序。如果需要降序,需要传递一个reverse=True作为参数。
names = ["Bob", "Jack", "Amy", "Tom"]
names.sort(reverse=True)
print(names)
['Tom', 'Jack', 'Bob', 'Amy']
2.5 列表的遍历
使用for循环遍历。(相当于Java中的fori循环)
for 变量 in 序列:
代码块
names = ["Bob", "Jack", "Jerry", "Tom", "Rose"]
for s in names:
print(s)
---------------------------------------
Bob
Jack
Jerry
Tom
Rose
2.6 range函数
range()用来生成一个自然数的序列。
- 该函数需要3个参数:
- 1.起始位置。可省略,默认为0。
- 2.结束位置。
- 3.步长。可以省略,默认为1。
- 通过range()可以创建一个执行指定次数的for循环。(相当于Java中的for循环)
for i in range(5):
print("helloworld")
二、元组(tuple)
- 元组是一个不可变的序列。
- 它的操作方式与列表基本一致。
- 一般来说,不希望数据被改变时,就使用元组。
使用()创建元组
my_tuple=(1,2,3,4)
- 当元组不是空元组时,括号可以被省略,但至少要有一个","
- my_tuple=10,20,30,40
my_tuple=10,
元组的解包(解构)
解包就是将元组当中每一个元素都赋值给一个变量。
my_tuple = (10, 20, 30, 40)
a, b, c, d = my_tuple
print(a)
print(b)
print(c)
print(d)
- 利用元组解包,可以轻松交换两个变量的值。
- =右边的b,a相当于(b,a) ,也就等价于a,b=(b,a)。
a = 100
b = 200
a, b = b, a
print("a=", a)
print("b=", b)
- 在对元组进行解包时,变量的数量必须和元组的数量一致。
- 也可以在变量前添加一个*,这样变量将会获取元素中所有剩余的元素。
- 但是不能出现2个及以上的带*变量(multiple starred expressions in assignment)
my_tuple = (10, 20, 30, 40)
*a, b, c = my_tuple
print("a=", a) # [10,20]
print("b=", b) # 30
print("c=", c) # 40
my_tuple = (10, 20, 30, 40)
a, *b, c = my_tuple
print("a=", a) # 10
print("b=", b) # [20,30]
print("c=", c) # 40
my_tuple = (10, 20, 30, 40)
a, b, *c = my_tuple
print("a=", a) # 10
print("b=", b) # 20
print("c=", c) # [30,40]
==和is
- ==、!= 比较的是对象的值是否相等。
- is、is not 比较的是对象的id(地址值)是否相等,也就是判断两个对象是否是同一个对象。
Java | Python | |
比较地址值 | == | is |
比较对象值 | equals() | == |
三、字典(dict)
3.1 概述
- 字典属于一种新的数据结构,称为映射(mapping)。
- 字典作用和列表类似,都是用来存储对象的容器。
- 字典是可变对象。
使用{}创建字典
{key:value,key:value,....}
- 列表存储数据的性能很好,但是查询数据的性能很差。
- 字典中存储的为键值对(key-value)
- 键可以是任意的不可变对象(int、str、bool、tuple.....)。
- 值可以是任意对象。
- 键是唯一,不可重复。若重复,后面的值替换前面的。
- 可以根据键来获取值。若键不存在,会报错(KeyError)
my_dict = {
"name": "Tom",
"age": 18,
"sex": "man"}
# 根据键获取值
print(my_dict["name"])
print(my_dict["age"])
print(my_dict["sex"])
3.2 字典的使用
使用dict()函数创建字典
- 参数为键值对:key=value
- 创建的字典,key都是字符串
#key=value
my_dict = dict(name="Tom", age=18, sex="man")
- 也可以将一个包含双值子序列的序列转换为字典
- 双值序列:序列中只有 2个值。[1,2]、(“a“,3),'ab'
- 子序列:序列中的元素也是序列。
- [(1,2),(3,4)]
# 双值子序列创建字典
my_dict = dict([("name", "Tom"), ("age", 18), ("sex", "man")])
长度
- len()函数
是否包含
- in、not in:检查字典中是否包含/不包含指定的键
获取值
- dict[ key ]:获取key对应的值。若key不存在,报异常。
- dict.get( key , default) :获取key对应的值。若key不存在,返回default。
更新
- dict[ key ] =value :如果key存在则覆盖,不存在则添加。
- dict.update( [other]) :将其他字典的key-value添加到当前字典,若有重复的key,则替换。
删除
- dict.popiteam():删除最后一个键值对并以元组的形式返回。
- dict.pop(key, default) :删除key对应的键值对,返回值。若key不存在,返回default。
- dict.clear() :清空所有元素。
复制
- dict.copy():对字典进行浅复制
- 复制以后的对象与原对象独立
- 注意:浅复制会简单地复制对象内部的值,如果值也是一个可变对象,这个可变对象不会被复制。
dict = {"data": {'name': 'Tom', 'age': 18, 'sex': 'man'}, "AAA": 123}
dict2 = dict.copy()
dict2["data"]["name"] = "Jack"
print(dict)
print(dict2)
打印结果:
{'data': {'name': 'Jack', 'age': 18, 'sex': 'man'}, 'AAA': 123}
{'data': {'name': 'Jack', 'age': 18, 'sex': 'man'}, 'AAA': 123}
3.3 字典的遍历
- dict.keys() :返回一个序列,保存字典所有的键。
- 通过keys来遍历字典:
my_dict = dict(name="Tom", age=18, sex="man")
# 通过所有的key遍历字典
for key in my_dict.keys():
print(key, "=", my_dict[key])
- dict.values() :返回一个序列,保存字典所有的值。
- dict.items() :返回一个序列,包含双值子序列,分别对应key和value,子序列的格式为元组。
for k, v in my_dict.items():
print(k, "=", v)
四、集合(set)
4.1 概述
- 集合和列表非常相似
- 不同点:
- 1.集合只能存储不可变对象
- 2.集合存储的对象是无序(不是按照元素的插入顺序保存)
- 3.集合不能出现重复的元素
4.2 集合的创建
使用{}来创建集合
s = {10, 3, 5, 1, 2, 1, 8}
使用set()来创建集合
- 可以通过set()来将序列和字典转换为集合。
- 当转换的是字典时,只会包含字典的键。
s = set([1, 2, 3, 4, 5, 1, 1, 3])
print(s) # {1, 2, 3, 4, 5}
s = set("hello")
print(s) # {'o', 'e', 'h', 'l'}
s = set({"name": "Tom", "age": 18, "sex": "man"})
print(s) # {'sex', 'name', 'age'}
4.3 集合的方法
判断是否存在
- in、not in
长度
- set.len()
增加
- set.add( element ) :添加元素至集合。
- set.update( ):将集合/序列/字典中的元素添加到当前集合。
s = {10, 3, 5, 1, 2, 1, 8}
s2 = set("abc")
s.update(s2)
s.update([99, 100])
s.update({"name": "Tom"})
print(s)
#{1, 2, 3, 'a', 5, 'b', 'c', 8, 99, 10, 100, 'name'}
删除
- set.pop() :随机删除一个集合元素。
- set.remove( element ):删除集合中指定的元素。
- set.clear() :清空
复制
- set.copy():浅复制。
4.4集合的运算
s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
& 交集运算
result = s1 & s2
print(result) # {3, 4, 5}
| 并集运算
result = s1 | s2
print(result) # {1, 2, 3, 4, 5, 6, 7}
- 差集运算
result = s1 - s2
print(result) #{1, 2}
^ 异或集
获取只在一个集合中出现的元素。
result = s1 ^ s2
print(result) # {1, 2, 6, 7}
<= 检查是否是子集
result = {3, 4, 5} <= {3, 4, 5, 6}
print(result) # True
result = {3, 4, 5} <= {3, 4}
print(result) # False
< 检查是否真子集
result = {1,2,3} < {1,2,3}
print(result) # False
result = {1,2,3} < {1,2,3,4,5}
print(result) # True
>= 检查是否是超集
result = {3, 4, 5} >= {3, 4, 5, 6}
print(result) # False
result = {3, 4, 5} >= {3, 4}
print(result) # True
> 检查是否真超集
result = {1, 2, 3} > {1, 2, 3}
print(result) # False
result = {1, 2, 3, 4, 5} > {1, 2, 3}
print(result) # True