Python学习笔记（三）组合数据类型

最新推荐文章于 2022-10-08 22:13:16 发布
最新推荐文章于 2022-10-08 22:13:16 发布
阅读量755 收藏
点赞数 1
分类专栏： Python学习笔记 文章标签： python 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longrootchen/article/details/104199424
版权

“Life is short, You need Python” – Bruce Eckel

Environment

  • OS: macOS Mojave
  • Python version: 3.7
  • IDE: Jupyter Notebook

目录

0. 写在前面

Python 中的数据类型可分为基本数据类型和组合数据类型，基本数据类型包括整型、浮点型、复数类型、字符串、布尔类型，组合数据类型包括列表、元组、字典、集合，其中还有更细的分类，如整型包括不同进制，字典包括有序和无序等。本文记录了组合数据类型的常用操作、解析式以及一些底层实现的内容。

1. 列表

  • 使用方括号表示
  • 可以包含各种类型的变量
  • 序列类型
  • 可变的（可以增加、删除、修改）

1.1 创建

  • 直接用方括号定义
ls = [[True, False], 1, {'type': 'list', 'name': 'hello'}]
empty_list = [] # an empty list
  • 用 list(iterable=()) ，传入可迭代对象
list('string') # ['s', 't', 'r', 'i', 'n', 'g']
list(range(5)) # [0, 1, 2, 3, 4]
  • 列表生成式
ls = [i for i in range(5)]
print(ls) # [0, 1, 2, 3, 4]

1.2 访问

  • 索引
ls = [9, 5, 2, ['legal', 'healthy'], 7]
print(ls[0]) # 9
print(ls[-2]) # ['legal', 'healthy']
print(ls[3][0]) # legal

# 通过索引修改元素
ls[3] = 0
print(ls) # [9, 5, 2, 0, 7]
  • 切片，将返回新的列表对象
ls = [9, 5, 2, ['legal', 'healthy'], 7]

print(ls[1:3]) # 表示从ind=1 开始到ind=2，不包括ind=3
# [5, 2]

print(ls[:3]) # 从头开始到索引 2
# [9, 5, 2]

print(ls[3:]) # 从索引 3 开始到最后
# [['legal', 'healthy'], 7]

print(ls[:]) # 得到整个列表，是常用的列表拷贝方法
# [9, 5, 2, ['legal', 'healthy'], 7]

print(ls[1::2]) # 步长为 2
# [5, ['legal', 'healthy']]

print(ls[-1:-4:-2]) # 反向索引
# [7, 2]

print(ls[::-1]) # 得到反序排列的新列表对象
# [7, ['legal', 'healthy'], 2, 5, 9]

1.3 修改

  • list.append(object) 在列表末尾加上一个元素
ls = [9, 5, 2, ['legal', 'healthy']]
ls.append(7)
print(ls) # [9, 5, 2, ['legal', 'healthy'], 7]
  • list.extend(iterable) 在列表末尾加上多个元素
ls = [9, 5, 2, ['legal', 'healthy'], 7]
ls.extend(['a', 'b', 3])
print([9, 5, 2, ['legal', 'healthy'], 7, 'a', 'b', 3])
  • list.insert(index, object) 向列表指定位置插入元素，从该位置开始的元素向后移一个位置
ls = [9, 5, 2, ['legal', 'healthy'], 7]
ls.insert(3, 0)
print(ls) # [9, 5, 2, 0, ['legal', 'healthy'], 7]
  • list.pop(index=-1) 弹出指定索引的元素
ls = [9, 5, 2, ['legal', 'healthy'], 7]
ls.pop(-2) # ['legal', 'healthy']
print(ls) # [9, 5, 2, 7]
  • list.remove(value) 从列表中删除指定元素，传入需要删除的元素。对于重复元素，调用一次只删除索引最小的那一个。好又快地需要删除所有重复元素，可以使用迭代结构结合反向索引，参考Python基础（四）控制结构中for迭代的例子。
ls = [1, 1, 1, 1, 0, 0, 1]

ls.remove(1)
print(ls)
# [1, 1, 1, 0, 0, 1]
  • list.clear() 清空列表中的元素，使原列表对象称为空列表
ls = [9, 5, 2, ['legal', 'healthy'], 7]
ls.clear()
print(ls)

1.4 常用操作符

  • 拼接 + ，连接两个列表，效果等价于 list.extend(iterable) 方法，但拼接返回连接后产生的新列表对象。总是首选使用 extend 方法而不是拼接 + 。
ls = [9, 5, 2] + [['legal', 'healthy'], 7]
print(ls) # [9, 5, 2, ['legal', 'healthy'], 7]
  • * 重复
ls = [1, 2, 'a'] * 3
print(ls) # [1, 2, 'a', 1, 2, 'a', 1, 2, 'a']

注意，使用 * 创建多维列表可能出现 bug！

例 使用 * 创建一个 4 x 3 的二维列表将失败

ls = [[0] * 3] * 4
ls
# [[0, 0, 0]
#  [0, 0, 0]
#  [0, 0, 0]
#  [0, 0, 0]]

# 改变 0, 0 为止的元素，却造成所有第一行元素的改变
ls[0][0] = 1
ls
# [1, 0, 0]
# [1, 0, 0]
# [1, 0, 0]
# [1, 0, 0]

原因是 ls * n 是将 n 份列表对象的浅拷贝连接（深浅拷贝问题参考Python基础（十） Part 1）。解决方法为，改用列表解析式（本文 Part 5.1）。

  • 关系操作符，对第一个元素进行比较
list1 = [1, 2, 3]
list2 = [4, 1, 3]
print(list1 > list2) # False

list3 = ['a', 'b', 'c']
print(list1 > list3) # 报错 TypeError
  • 成员资格符 in
ls = [123, ['xyz', 666], 456]
print(123 in ls) # True
print('xyz' in my_list) # False，因只能判断一级对象
print('xyz' not in my_list) # True
print('xyz' in my_list[-2]) # True

1.5 其他常用方法

  • list.count(value) 返回列表中某一元素值出现的次数
ls = [123, 456] * 6
print(ls.count(123)) # 6
  • list.index(value, start=0, stop=9223372036854775807) 返回待查找元素值在列表中第一次出现位置的索引，注意查找范围不包括 stop 索引
ls = [123, 456, 789, 123, 'abc', 123]
print(ls.index(123)) # 0
print(ls.index(123, -2)) # 5
print(ls.index(123, 1, 4)) # 3
print(ls.index(123, 1, 3) # 若没有该值的元素，则报错ValueError
  • list.reverse() 将列表对象倒序
ls = [9, 5, 2, ['legal', 'healthy'], 7]
ls.reverse()
print(ls) # [7, ['legal', 'healthy'], 2, 5, 9]
  • list.sort(*, key=None, reverse=False) 将原列表对象按元素排序（默认为升序），支持仅包含 int 和（或） float 类型元素的列表，支持仅包含 int 和（或） float 类型元素的列表
ls.sort(reverse=True)
print(ls) # [93, 78, 58.0, 23.0, 15]
  • list.copy() ，和切片复制等价，均为浅拷贝
ls = [0, 1, [2, 3], 4]
ls_slide_copy = ls[:]
ls_copy = ls.copy()
print(id(ls), id(ls_slide_copy), id(ls_copy)) # 三者不同

# 为浅拷贝
ls[0], ls[2][0] = 666, 666
print(ls_slide_copy) # [0, 1, [666, 3], 4]
print(ls_copy) # [0, 1, [666, 3], 4]

2. 元组

  • 使用圆括号表示
  • 可以包含各种类型的变量
  • 序列类型
  • 不可变的（不可增加、删除、修改）

2.1 创建

  • 直接使用圆括号。当只有一个元素时，可以省略括号加上一个逗号
tp = (9, 5, 2, ['legal', 'health'], 7)
print(tp) # (9, 5, 2, ['legal', 'health'], 7)

# a tuple with a single element
number = (6)
tp_with_single_elem = 6, # 圆括号可省略
print(type(number), type(tp_with_single_elem)) # <class 'int'> <class 'tuple'>
  • 使用 tuple(iterable=()) 函数，传入可迭代对象
tp = [9, 5, 2, ['legal', 'health'], 7]
print(tp) # (9, 5, 2, ['legal', 'health'], 7)

2.2 访问

  • 解包。序列类型的可迭代对象都可以这样操作，但只有逗号而无括号时默认为元组，方便着来
def foo(x):
    return x * 2, x / 2, x ** 2 # 打包返回

res = foo(6)
print(type(res)) # <class 'tuple'>
res1, res2, res3 = res # 解包赋值
print(res1, res2, res3) # 12, 3.0, 36

# 遍历解包赋值
for loss, aux in [('loss1', 'aux1'), ('loss2', 'aux2')]:
	print(loss, aux)
  • 索引。同列表
# 虽然元组是不可变的，但是其中包含的列表中的元素是可变的
tp = (9, 5, 2, ['legal', 'healthy'], 7)
tp[-2][0] = 'illegal'
print(tp) # (9, 5, 2, ['illegal', 'healthy'], 7)
  • 切片。同列表

2.3 常用操作符

由于无法对元组添加、删除操作，因此元组对象没有像列表中的那些方法。但拼接、删除可以通过操作符实现，不过不是对原元组对象操作，而是返回结果的新对象。

  • 拼接 +
tp = (9, 5) + (2, ['legal', 'healthy']) + (7,)
print(tp) # (9, 5, 2, ['legal', 'healthy'], 7)
  • * 重复
print(6 * (6, 8)) # (6, 8, 6, 8, 6, 8, 6, 8, 6, 8, 6, 8)
print(6 * 6,) # 36,   这样无法实现重复
  • 关系操作符。同列表
  • 成员资格符。同列表

2.4 常用方法

  • tuple.count(value) 。同列表
  • tuple.index(value, start=0, stop=9223372036854775807) 。同列表
  • 没有tuple.copy()方法，元组只能通过切片复制（浅拷贝）
new_tp = tp[:]
tp[-2][0] = 'illegal'
print(tp) # (9, 5, 2, ['illegal', 'healthy'], 7)
print(new_tp) # (9, 5, 2, ['illegal', 'healthy'], 7)

3. 字典

  • 使用花括号表示
  • 通过“键”-“值”的映射实现数据存储和访问，键是不可重复的
  • 无序的，属于映射类型
  • 键是不可变的，必须是可哈希对象，如数字、字符串、元组
{(1, 2): 'one_two', 3: 'three'} # 可
{[1, 2]: 'one_two', 3: 'three'} # 报错 TypeError

3.1 创建

  • 直接使用花括号
# 当出现相同大小的整数和浮点数作为键，保留浮点数键，其对于的值以后传入的为准
dc = {(1, 2): 666, 3.0: 'hi', 3: 'legal', 'string': 'healthy'}
print(dc) # {(1, 2): 666, 3.0: 'legal', 'string': 'healthy'}
  • dict(self) 函数，传入一个以二元组为元素的元组
dc = dict((((1, 2), 666), (3.0, 'hi'), (3, 'legal'), ('string', 'healthy')))
print(dc) # {(1, 2): 666, 3.0: 'legal', 'string': 'healthy'}

3.2 访问

  • 以键为索引，获得值
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
print(dc[3]) # 'legal'
print(dc[0]) # 报错 KeyError
  • dict.get(key, default=None) ，若访问的键存在，则返回对于的值，若访问的键不存在，则向对象中添加相应的键，其对应的值为向 default 传入的值。不能以关键字参数形式传入
# 统计一个字符串中字符出现的频率
subject = 'ophthalmol'
dc = {}
for s in subject:
    dc[s] = dc.get(s, 0) + 1
print(dc) # {'o': 2, 'p': 1, 'h': 2, 't': 1, 'a': 1, 'l': 2, 'm': 1}
  • dict.setdefault(key, default=None) ，若访问的键存在，则返回对应的值；若访问的键不存在，则向对象中添加相应的键，其对应的值为向 default 传入的值，并和返回设定默认值。但不能以关键字参数形式传入
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
dc.setdefault('new_key', 'new_item')
print(dc) # {(1, 2): 666, 3: 'legal', 'string': 'healthy', 'new_key': 'new_item'}
  • dict.keys() 返回一个可迭代对象，为所有的键
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
print(dc.keys()) # dict_keys([(1, 2), 3, 'string'])
  • dict.values() 返回一个可迭代对象，内容为所有的值
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
print(dc.values()) # dict_values([666, 'legal', 'healthy'])
  • dict.items() 返回一个可迭代对象，为所有的键与值组成的二元组
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
print(dc.items()) # dict_items([((1, 2), 666), (3, 'legal'), ('string', 'healthy')])

3.3 修改

  • dict[key] = value 直接设定一个不存在的键，并赋一个值。（当键存在时，修改原有的值）
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
dc[-1] = 'zero'
print(dc) # {(1, 2): 666, 3: 'legal', 'string': 'healthy', -1: 'zero'}
  • dict.update() ，将其他字典或以二元组为元素的可迭代序列连接到原字典对象中
# 加入其他字典对象的内容
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
other_dc = {0: 'zero', 1: 'one'}
dc.update(other_dc)
print(dc) # {(1, 2): 666, 3: 'legal', 'string': 'healthy', 0: 'zero', 1: 'one'}

# 加入以二元组为元素的可迭代序列
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
other_dc = [(0, 'zero'), (1, 'one')]
dc.update(other_dc)
print(dc) # {(1, 2): 666, 3: 'legal', 'string': 'healthy', 0: 'zero', 1: 'one'}
  • dict.pop(k) ，传入需要弹出的键-值对中的键，弹出对应的键
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
pop_out = dc.pop(3)
print(pop_out) # legal
print(dc) # {(1, 2): 666, 'string': 'healthy'}
  • dict.popitem() ，随机弹出一个键值对，以元组形式返回
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
pop_out = dc.popitem()
print(pop_out) # ('string', 'healthy')
print(dc) # {(1, 2): 666, 3: 'legal'}
  • dict.clear() ，清空字典对象
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
dc.clear()
print(dc) # {}

3.4 常用操作符

  • 成员资格符，判断所给的键是否在字典中
dc = {(1, 2): 666, 3: 'legal', 'string': 'healthy'}
print((1, 2) in dc, 0 in dc) # True False

3.5 其他常用方法

  • dict.copy() ，浅拷贝
dc = {'number': 666, 0: 'zero', 'list': ['legal', 'healthy']}
new_dc = dc.copy()

dc['list'][0] = 'illegal'
print(new_dc) # {'number': 666, 0: 'zero', 'list': ['illegal', 'healthy']}

4. 集合

  • 用花括号表示
  • 一组互不相等的元素
  • 无序的
  • 元素是不可变的，必须是可哈希对象，如数字、字符串、元组，集合可以视为只有键没有值的字典

4.1 创建

  • 直接使用花括号
st = {(1, 2), 3, 'string'}
print(st) # {(1, 2), 3, 'string'}

# 注意，空集合无法直接创建
empty_st = {}
print(type(empty_st) # dict
  • set() 函数，空集合只能使用该函数创建
# 传入可迭代对象
st = set(((1, 2), 3, 'string'))
print(st) # {(1, 2), 3, 'string'}

# 创建空集合
empty_st = set()
print(empty_st) # set()

# 传入字典时，返回字典的键构成的集合
st = set({1:'one', 2:'two', 3:'three'})
print(st) # {1, 2, 3}

4.2 访问

无法索引，因此无法访问到指定元素

4.3 修改

  • set.add() 增加一个元素
st = {0, 1, 2, 3}
st.add(4)
print(st) # {0, 1, 2, 3, 4}
  • set.remove() 移除一个元素，若元素不存在，则报错
st = {0, 1, 2, 3}
st.remove(1) # 若元素不在集合中则报错 KeyError
print(st) # {0, 2, 3}
  • set.discard() 移除一个元素，若元素不存在，啥也不做
st = {0, 1, 2, 3}
st.discard(4)
print(st) # {0, 1, 2, 3}
  • set.pop() 移除并返回集合中的任意一个元素
st = {0, 1, 2, 3}
print(st.pop()) # 0
print(st) # {1, 2, 3}
  • set.clear() 清空集合，使之成为空集
st = {0, 1, 2, 3}
st.clear()
print(st) # set()

4.4 常用操作符

  • 交集
st1 = {0, 1, 2}
st2 = {1, 2, 3}
print(st1 & st2) # {1, 2}
  • 并集
st1 = {0, 1, 2}
st2 = {1, 2, 3}
print(st1 | st2) # {0, 1, 2, 3}
  • 差集
st1 = {0, 1, 2}
st2 = {1, 2, 3}
print(st1 - st2) # {0}
  • 对称差分
st1 = {0, 1, 2}
st2 = {1, 2, 3}
print(st1 ^ st2) # {0, 3}
  • <= 与 < 一个集合是另一个的子集，后者更严格（还要求两集合不相同）
st1 = {0, 1, 2, 3}
st2 = {0, 1, 2, 3}
st3 = {0, 1, 2, 3, 4}

print(st1 <= st2, st1 < st2) # True, False
print(st1 <= st3, st1 < st3) # True, True
  • >= 与 > 一个集合是另一个的超集，后者更严格（还要求两集合不相同）
st1 = {0, 1, 2, 3, 4}
st2 = {0, 1, 2, 3, 4}
st3 = {0, 1, 2, 3}

print(st1 >= st2, st1 > st2) # True, False
print(st1 >= st3, st1 > st3) # True, True

5. 解析式

解析式（comprehension），又称推导式，使生成列表、字典、集合的代码更加简洁。此外，还有生成器解析式。

5.1 列表解析式

又称列表推导式，其语法为 [expression for value in iterable if condition]，其中 if 条件为可选。（if 分支和 for 迭代结构参考 Python基础（四）控制结构）

  • 一维
# 生成一个列表，其元素为 10 以内的偶数的平方
[i**2 for i in range(10) if i % 2 == 0]
# [0, 4, 16, 36, 64]
  • 多维
# 创建 4 x 3 的二维列表
[[0] * 3 for _ in range(4)]
# [[0, 0, 0]
#  [0, 0, 0]
#  [0, 0, 0]
#  [0, 0, 0]]

5.2 字典解析式

语法为 {key: value for (key, value) in iterable if condition}，其中 if 条件为可选。

{i: i + 1 for i in range(3)}
# {0: 1, 1: 2, 2: 3}

5.3 集合解析式

语法为 {value for value in iterable if condition}，其中 if 条件为可选。

# 生成 10 以内的奇数的集合
{i for i in range(10) if i % 2 != 0}
# {1, 3, 5, 7, 9}

5.4 生成器解析式

解析式的创建是一个变化的过程，而元组是不可变的，因此没有元组推导式。尝试解析式的语法无法得到元组，而是将得到生成器（generator）。生成器的相关内容参考Python基础（十）深浅拷贝与三大器 Part 3

gen = (i for i in range(5))
type(gen) # <class 'generator'>

6. 数据存储方式

6.1 列表与元组的区别

列表与元组的相同之处为，其中的元素实际上是地址，引用的内容分散地存放在内存其他位置，保证了这些组合数据类型能够容纳不同类型的数据作为元素。

它们之间的区别之一为，同样的长度下，列表所需要的存储空间比元组更大（使用 sys.getsizeof 函数查看对象的占用的内存，以 byte 为单位）

import sys

ls = []
print(sys.getsizeof(ls)) # 64

tp = ()
print(sys.getsizeof(tp)) # 48

import sys

ls = [1, 'two', {3: 'three'}]
print(sys.getsizeof(ls)) # 88

tp = (1, 'two', {3: 'three'})
print(sys.getsizeof(tp)) # 72

原因在于，由于列表是可变的，系统总会为其额外分配一些内存（over-allocating），而对于元组并不会

ls = []
for i in range(10):
    print(sys.getsizeof(ls))
    ls.append(i)
# 64
# 96
# 96
# 96
# 96
# 128
# 128
# 128
# 128
# 192

tp = ()
for i in range(10):
    print(sys.getsizeof(tp))
    tp += (i,)
# 48
# 56
# 64
# 72
# 80
# 88
# 96
# 104
# 112
# 120

6.2 字典与列表的区别

字典较列表的索引速度更快，原因在于，字典中元素的存储是稀疏的，使用哈希函数的方式通过键对值进行索引，而列表中地址元素的存储是连续的，每次索引都需要从第一个元素开始。

例 列表和字典的索引速度差别

import time

ls = list(range(30000))
ls_ = list(range(30000))

since = time.time()

count = 0
for each in ls_:
    if each in ls:
        count += 1

print('time:', time.time() - since)
# time: 3.642605781555176

import time

dc = {i:i for i in range(30000)}
ls_ = list(range(30000))

since = time.time()

count = 0
for each in ls_:
    if each in dc:
        count += 1

print('time:', time.time() - since)
# time: 0.0056841373443603516

哈希函数的内容参考fishc的你知道 Python 的字典（Dict）是如何存储的吗。

所以

  • 字典是无序的，hash 值对应项的顺序与字典项显示的顺序可能不同

  • 字典需要的空间比列表大，实现了以空间换时间

ls = [1, 2, 3]
print(sys.getsizeof(ls)) # 88

dc = {0: 1, 1: 2, 2: 3}
print(sys.getsizeof(dc)) # 240
longrootchen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python基础总结（五） 组合数据类型
qq_58573822的博客
12-19 2102
目录 第五章：组合数据类型 一、列表： （一）列表元素查找： （二）列表元素添加： （三）列表元素排序： （四）列表元素修删： （五）列表生成式（推导式）： （六）：zip() 和enumerate() 函数 二、元祖： 三、集合： 四、字典： （一）创建字典： （二）访问字典： （三）元素的添加和修改： （四）字典元素的删除： （五）字典推导式： 五、组合数据类型与运算： 第五章：组合数据类型 一、列表： 由第一章，我们了解到Python列表的创建方式非常简单，既.
Python学习笔记--组合数据类型
奇点的博客
01-30 241
组合数据类型集合序列 集合 集合的定义 使用{}或set()函数。 如：A={“python”,“hello,world”,234}   B=set(“2020python3”) 操作符 功能 A∣B 返回一个新集合,包括在集合A和B中的所有元素 A-B 返回一个新集合,包括在集合A但不在B中的元素 A&B 返回一个新集合,包括同时在集合A和B中的元素 A^B...
笔记-4：python组合数据类型
dlp30158的博客
09-02 344
1.字符串（str） 字符串是字符的序列表示， 根据字符串的内容多少分为单行字符串和多行字符串。 单行字符串可以由一对单引号（'） 或双引号（"）作为边界来表示， 单引号和双引号作用相同。 多行字符串可以由一对三单引号（'''） 或三双引号（"""） 作为边界来表示， 两者作用相同。 print('这是"单行字符串"') print("这是'单行字符串'")...
Python学习笔记（3）——组合数据类型
Raines_01的博客
08-23 412
Python学习笔记（3）——组合数据类型
python组合数据类型详解——列表
白炎灵的博客
03-30 502
列表是包含0个或多个对象引用的有序序列，属于序列类型，没有长度限制，可自由增删元素，使用灵活。 既然列表属于序列类型，那么12个序列类型的操作符和函数就对列表适用，除此之外，还有14个列表类型特有的方法和函数，接下来，就让我们一起学习吧~~ 文章目录序列类型的通用操作符和函数列表类型特有的方法或函数列表推导式 序列类型的通用操作符和函数 操作符和函数 描述 x in s 如果x是s...
python学习笔记（一）数据类型
12-22
在开始Python的学习过程中，理解并掌握数据类型是非常关键的一步。数据类型决定了变量可以存储什么样的数据，以及如何处理这些数据。 （一）数字类型 Python支持四种基本数字类型：整型(int)、布尔型(bool)、浮点型...
Python学习笔记 .pdf
最新发布
12-21
这篇“Python学习笔记”详细介绍了Python的基本概念、语法和编程技巧。 首先，第一章介绍了编程的基础知识，包括程序的概念。程序是按照特定规则编写的指令集合，用于控制计算机执行特定任务。调试是找出并修复程序...
Python学习笔记(干货) 中文PDF完整版.pdf
05-23
这份"Python学习笔记"涵盖了从环境搭建到基础语法，再到数据类型和控制结构等关键知识点，旨在为初学者提供全面的学习指导。 首先，1.1章节介绍了Python的基础，包括Python的起源和历史。Python是由Guido van ...
python学习笔记-机器学习库numpy
08-19
3. 数组属性：`shape`返回数组的维度，`size`返回数组元素的总数，`dtype`返回数组元素的数据类型。 三、数组操作 1. 数组索引和切片：与Python列表类似，可以使用索引或切片访问数组元素。 2. 数组广播：当两个...
python学习笔记
04-24
Python是一种高级编程语言，以其简洁明了的语法和强大的功能深受程序员喜爱。...以上内容涵盖了Python的基础知识，从数据类型、控制流到文件操作、网络请求和异常处理，为Python初学者提供了全面的学习指南。
Python --- （数据类型）数值、布尔、字符串
享你所想
10-08 3122
数值、布尔、字符串、列表、元组、字典、集合本篇文章只涉及前三种数据类型，其余的在之后的文章中再说明！在 Python 程序中，如果需要对数据进行计算，则主要使用数值。数值主要包括 整数 、浮点数。整数主要分为正整数(如：666)、 负整数(如：-666)以及零。在 Python 中，使用 int 表示整数类型。>>>type(1)浮点数由 整数部分 与 小数部分 组成(如：3.1415)。在 Python 中，使用 float 表示浮点数类型。
tuple（元组）
qq_36685978的博客
10-15 233
tuple （元组） 可以理解成一个不允许更改的列表 help(tuple) Help on class tuple in module builtins: class tuple(object) | tuple(iterable=(), /) | | Built-in immutable sequence. | | If no argument is given,...
第四章 Python组合数据类型
一个小白的初心
02-25 384
第四章 组合数据类型 4.1 列表 4.1.1 列表的表达 序列类型：内部元素有位置关系，能通过位置序号访问其中元素 列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型 ls = ["Python", 1989, True, {"version": 3.7}] ls ['Python', 1989, True, {'version': 3.7}] 另一种产生方式：li...
六、Python 组合数据类型
Orz
03-06 1081
本文是网课：Python语言程序设计国家精品——（北京理工大学 嵩天 、 黄天羽 、 礼欣）的学习笔记。 目录 6.1 集合类型及操作 6.2 序列类型及操作 6.3 实例9：基本统计值计算 6.4 字典类型及操作 6.5 模块5：jieba库的使用 6.6 实例10：文本词频统计 6.1 集合类型及操作 集合类型定义 关于Python的元组： Python的元...
python复数类型的虚部通过_Python 复数数据类型详解（complex）[学习 Python 必备基础知识][看此一篇就够了]...
weixin_40000301的博客
11-23 928
您的“关注”和“点赞”，是信任，是认可，是支持，是动力......如意见相佐，可留言。本人必将竭尽全力试图做到准确和全面，终其一生进行修改补充更新。1 复数数据类型概述复数数据类型，简称复数类型。在 Python 中用complex表示。复数类型是 Python 的内置类型，直接书写即可。复数由实部（real part）和虚部（imaginary part）构成，分别以一个浮点数表示。在 Pyth...
6.组合数据类型(列表list,元组tuple,集合set,字典dict)
dong_A_lei的博客
11-27 1653
1、数据类型概述 ① 工程项目中根据数据类型的特点，将python中的数据类型，区分为基本数据类型、组合数据类型以及复杂数据类型； 基本数据类型中又区分为字符串str类型，用来描述信息；整数类型int以及浮点数类型float，用来描述数值；布尔类型bool，用来描述只有两种结果的数据。 组合数据类型又区分为列表list，可以存放有顺序的可以重复的可以是不同数据类型的多个数据； 元组tuple，和列表的特征相同，同时元组中的数据不能修改； 集合set中可以存放不能重复的没有顺序的可以是不同数据类型的
组合数据类型
热门推荐
u013005683的博客
10-29 1万+
一、组合数据类型 组合数据类型有3大类，分别是集合类型、序列类型、映射类型。 1、集合 2、序列类型 字符串、列表、元组都属于序列类型。 （1）列表 序列类型是一维元素向量，元素之间存在先后关系，通过序号访问。 访问时通过下标标出即可，正向递增序号、反向递减序号。 —操作符和函数 x in s x not in s s + t s * n 或 n * s s[i] s[i : j] s[i : ...
python相比于其他语言的优缺点分析
Python_fly的博客
05-03 6625
**优点** 简单 – Python 是一种代表简单主义思想的语言。阅读一个良好的 Python 程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python 的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。 易学 – 就如同你即将看到的一样，Python 极其容易上手。前面已经提到了，Python 有极其简单的语法。 免费、开源 – Python ...
python-组合数据类型（集合、序列及字典）
miko186的博客
12-13 1388
组合数据类型 1.集合类型 集合是多种元素的无序组合，(元素独一性) 集合用大括号{}表示，元素用，分隔。 用set函数建立：        A=set(“python123”)        {“p”,”y”,”t”,”h”,”o”,”n”,”1”,”2”,”3”} 集合操作符 集合有四种基础运算方法，并，交，差，补     S|T 并运算,返回一个新集合，包含在集合S和T中的...
python基础.docx
03-13
"这是一份关于Python基础的文档，包含了Python入门知识，开发环境，解释器，集成开发环境IDE，特别是PyCharm的设置，以及Python的数据类型，如数字、字符串、列表、元组、字典和集合。文档还提到了面向对象编程的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值