Python基础(三)列表、元组、字典、集合

一、序列(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(地址值)是否相等,也就是判断两个对象是否是同一个对象。
JavaPython
比较地址值==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

  • 2
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值