一、序列（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))52.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)) # 22.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) # 40my_tuple = (10, 20, 30, 40)
a, *b, c = my_tuple
print("a=", a) # 10
print("b=", b) # [20,30]
print("c=", c) # 40my_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
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
