Python之“组合数据类型”

已于 2024-04-29 18:59:47 修改
阅读量723 收藏 21
点赞数 26
分类专栏： 今天你学Py了嘛 文章标签： python 开发语言
于 2024-04-09 01:24:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CH3_CH2_CHO/article/details/137479977
版权

一、序列

        1、定义：

一个用于存储多个值的连续空间

ps：（1）列表、元组、字符串、字典、集合均可视为序列

        2、索引：

        3、切片：

语法结构： 序列[start：end：step]

  • start：切片的开始索引（包含），若置空，则表示从头开始
  • end：切片的结束索引（不包含），若置空，则表示截取至结尾
  • step：若置空，则默认为1
s='HelloWorld'

s1=s[0:5:2] # 索引从0开始，到5结束（不包含5）步长为2
print(s1)
# 输出：Hlo

# 省略了开始位置，start默认从0开始
print(s[:5:1])
# 输出：Hello

# 省略开始位置start，省略不步长step
print(s[:5:])
# 输出：Hello

# 省略结束位置
print(s[0::1]) # stop，默认到序列的最后一个元素（包含最后一个元素)
# 输出：HelloWord

print(s[5::])
print(s[5:]) # 两行代码功能相同，省略了结束，省略了一个步长
# 输出：World

# 更改一下步长，步长更改为2
print(s[0:5:2])
# 输出：Hlo

# 省略开始位置，省略结束位置，只写步长
print(s[::2]) # 分别获取0，2，4，6，8索引位置上的元素
# 输出：Hlool

# 步长为负数
print(s[::-1]) # 可以使用哪句代码替换呢
print(s[-1:-11:-1]) 
# 输出：dlroWolleH

        4、常用操作：

（1）相加，相乘：

s='Hello'
s2='World'

# 序列的相加操作
print(s+s2) # 产生一个新的字符串序列
# 输出：HelloWorld

# 序列的相乘操作
print(s*5)
# 输出：HelloHelloHelloHelloHello

（2）相关方法：

s='helloworld'

# in的使用
print('e在helloworld中存在吗?',('e'in s))
# 输出：e在helloworld中存在吗? True
print('v在helloworld中存在吗?',('v'in s))
# 输出：v在helloworld中存在吗? False

# not in 的使用
print('e在helloworld中不存在吗?',('e'not in s))
# 输出：e在helloworld中不存在吗? False
print('v在helloworld中不存在吗?',('v'not in s))
# 输出：v在helloworld中不存在吗? True

# 内置函数的使用
print('len():',len(s)) # 输出：len(): 10
print('max():',max(s)) # 输出：max(): w
print('min():',min(s)) # 输出：min(): d

# 序列对象的方法，使用序列的名称，打点调用
print('s.index():',s.index('o')) # o在s中第一次出现的索引位置 4
#print('s.index():',s.index('v')) 
# ValueError: substring not found ,报错的原因是v在字符串中根本不存在，不存在所以找不到
print('s.count():',s.count('o')) # 统计o在字符串s中出现的次数 2

二、列表

        1、定义：

一系列的按特定顺序排列的元素组成

ps：（1）是Python中内置的可变序列

        （2）在Python中使用 [ ] 定义列表，元素与元素之间使用英文的逗号分隔

        （3）列表中的元素最多2^{63}-1，可混装，数据有序存储，允许有重复元素

        2、创建：

（1）使用 [ ]：

lst=['hello','world',98,100.5]
print(lst)
# 输出：['hello', 'world', 98, 100.5]

        语法结构：列表名=[element1,element2,......elementN]

lst=['hello','world',98,100.5]
print(lst)
# 输出：['hello', 'world', 98, 100.5]

（2）使用 list( )：

        语法结构：列表名=list(序列)

lst2=list('helloworld')
print(lst2)
# 输出：['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

lst3=list(range(1,10,2)) # 从1开始到10结束，步长为2，不包含10
print(lst3)
# 输出：[1, 3, 5, 7, 9]

        3、删除：

语法结构：del 列表名

        4、遍历：

（1）for 循环：

lst=['hello','world','python','php']

# 使用遍历循环for遍历列表元素
for item in lst:
    print(item)

# 使用for循环,range()函数，len()函数，根据索引进行遍历
for i in range(0,len(lst)):
    print(i,'-->',lst[i])

（2）while 循环：

my_list = ['a','b','c']
index = 0
while index < len(my_list):
    element = my_list[index]
    print(f'列表元素：{element}')
    index += 1

（3）enumerate() 函数：

        语法结构：for index ,item in enumerate(lst)

lst=['hello','world','python','php']

for index,item in enumerate(lst):
    print(index,item) # index是序号，不是索引
# 输出：0 hello
#      1 world
#      2 python
#      3 php

# 手动修改序号的起始值
for index,item in enumerate(lst,start=1): 
    print(index,item)
# 省略start不写，直接写起始值
for index, item in enumerate(lst,1):  
    print(index, item)
# 输出：1 hello
#      2 world
#      3 python
#      4 php

        5、相关方法：

lst=['hello','world','python']
print('原列表：',lst,id(lst))
# 输出：原列表： ['hello', 'world', 'python'] 2270360490368

# 增加元素的操作
lst.append('sql')
print('增加元素之后：',lst,id(lst))
# 输出：增加元素之后： ['hello', 'world', 'python', 'sql'] 2270360490368

# 使用insert(index,x)在指定的index位置上插入元素x
lst.insert(1,100)
print(lst)
# 输出：['hello', 100, 'world', 'python', 'sql']

# 列表元素的删除操作
lst.remove('world')
print('删除元素之后的列表:',lst,id(lst))
# 输出：删除元素之后的列表: ['hello', 100, 'python', 'sql'] 2270360490368

#使用pop(index)根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)
# 输出：100
#      ['hello', 'python', 'sql']

# 清除列表中所有的元素clear()
# lst.clear()
# print(lst,id(lst))
# 输出：[] 2778922602880

# 列表的反向
lst.reverse() # 不会产生新的列表，在原列表的基础上进行的
print(lst)
# 输出：['sql', 'python', 'hello']

# 列表的拷贝，将产生一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))
# 输出：['sql', 'python', 'hello'] 2270360490368
#      ['sql', 'python', 'hello'] 2270362724864

        6、修改：

lst=['hello','world','python']
lst[1]='mysql'
print(lst)
# 输出：['hello', 'mysql', 'python']

        7、排序：

（1）sort() 方法：

        语法结构：lst.sort(key=None,reverse=False)

  • key：表示排序规则
  • reverse：表示排序方式，默认升序
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
# 输出：原列表: [4, 56, 3, 78, 40, 56, 89]

# 排序，默认是升序
lst.sort() # 排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序:',lst)
# 输出：升序: [3, 4, 40, 56, 56, 78, 89]

#排序，降序
lst.sort(reverse=True)
print('降序:',lst)
# 输出：降序: [89, 78, 56, 56, 40, 4, 3]

print('-----------------------------')

lst2=['banana','apple','Cat','Orange']
print('原列表：',lst2)
# 输出：原列表： ['banana', 'apple', 'Cat', 'Orange']

# 升序排序：先排大写，再排小写
lst2.sort()
print('升序:',lst2)
# 输出：升序: ['Cat', 'Orange', 'apple', 'banana']

# 降序排列：先排小写，后排大写
lst2.sort(reverse=True)
print('降序:',lst2)
# 输出：降序: ['banana', 'apple', 'Orange', 'Cat']

# 忽略大小写进行比较
lst2.sort(key=str.lower)
print(lst2)
# 输出：['apple', 'banana', 'Cat', 'Orange']

ps：（1）str.lower() ：Python 中字符串对象的一个方法，用于将字符串中的所有大写字符转换为小写字符。当对一个字符串对象调用该方法时，会返回一个新的字符串，其中的字符全部转换为小写，而原始的字符串对象本身不会发生变化。

        （2）sort() 方法是在原列表基础上进行改动，不会产生新的列表。

（2）sorted() 函数：

        语法结构：sorted(iterable,key=None,reverse=False)

  • iterable：表示排序的对象
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
# 输出：原列表: [4, 56, 3, 78, 40, 56, 89]

# 升序
asc_lst=sorted(lst)
print('升序:',asc_lst)
print('原列表:',lst)
# 输出：升序: [3, 4, 40, 56, 56, 78, 89]
#      原列表: [4, 56, 3, 78, 40, 56, 89]

# 降序
desc_lst=sorted(lst,reverse=True)
print('降序:',desc_lst)
print('原列表:',lst)
# 输出：降序: [89, 78, 56, 56, 40, 4, 3]
#      原列表: [4, 56, 3, 78, 40, 56, 89]

lst2=['banana','apple','Cat','Orange']
print('原列表：',lst2)
# 输出：原列表： ['banana', 'apple', 'Cat', 'Orange']

# 忽略大小写进行排序
new_lst2=sorted(lst2,key=str.lower)
print('原列表:',lst2)
print('排序后的列表:',new_lst2)
# 输出：原列表: ['banana', 'apple', 'Cat', 'Orange']
#      排序后的列表: ['apple', 'banana', 'Cat', 'Orange']

ps：（1）sorted() 函数会返回一个新的列表，原列表不会改变。

        8、生成式：

语法结构：lst=[expression for item in range if condition]

import random

# 打印1-10的所有整数
lst=[item for item in range(1,11)]
print(lst)
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 随机生成10个1-100之间的整数
lst=[random.randint(1,100) for _ in range(10)] # 如果 item 在整个生成式中没有应用，可用下划线 "_" 代替
print(lst)
# 输出：[58, 56, 70, 10, 68, 7, 12, 82, 77, 36]

# 从列表中选择符合条件的元素组成新的列表
lst=[i for i in range(10) if i%2==0] # 此处的条件是：偶数输出
print(lst)
# 输出：[0, 2, 4, 6, 8]

        9、嵌套：

# 此处创建了一个二维列表
lst=[
    ['城市','环比','同比'],
    ['北京',102,103],
    ['上海',104,504],
    ['深圳',100,39]
]
print(lst)
# 输出：[['城市', '环比', '同比'], ['北京', 102, 103], ['上海', 104, 504], ['深圳', 100, 39]]

# 遍历二维列表使用双层for循环
for row in lst: # 行
    for item in row: # 列
        print(item,end='\t')
    print() # 换行
# 输出：城市	环比 同比	
#      北京	102	103	
#      上海	104	504	
#      深圳	100	39

三、元组

        1、定义：

（与列表类似）

ps：（1）是Python中内置的不可变序列

        （2）在Python中使用 ( ) 定义元组，元素与元素之间使用英文的逗号分隔

        （3）元组中只有一个元素的时候，逗号也不能省略

        （4）元组中的元素可混装，数据有序存储，允许有重复元素

        2、创建：

（1）使用 ( )：

        语法结构：元组名=(element1,element2,......elementN)

t=('hello',[10,20,30],'python','world')
print(t)
# 输出：('hello', [10, 20, 30], 'python', 'world')

（2）使用 tuple( )：

        语法结构：元组名=tuple(序列)

t=tuple('helloworld')
print(t)
# 输出：('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')

        3、删除：

语法结构：del 元组名

        4、遍历：

（1）for 循环：

t=('python','hello','world')

for item in t:
    print(item)
# 输出：python
#      hello
#      world

# for+range()+len()
for i in range(len(t)):
    print(i,t[i])
# 输出：0 python
#      1 hello
#      2 world

（2）while 循环：

t=('python','hello','world')
index = 0
while index < len(t):
    print(f"元组元素有：{t[index]}")
    index += 1
# 输出：元组元素有：python
#      元组元素有：hello
#      元组元素有：world

（3）enumerate() 函数：

t=('python','hello','world')
for index,item in enumerate(t):
    print(index,'---->',item)
# 输出：0 ----> python
#      1 ----> hello
#      2 ----> world

        5、生成式：

语法结构：tuple=(expression for item in range if condition)

ps：（1）元组生成式的结果是一个生成器对象，需要转换成元组或列表才能查看到元素内容

t=(i for i in range(1,4)) # 其结果是一个生成器对象
print(t)
# 输出：<generator object <genexpr> at 0x000001CF7C6E4E80>

# # 转换为元组查看
# t=tuple(t)
# print(t)
# # 输出：(1, 2, 3)
# # 遍历
# for item in t:
#     print(item)
# # 输出：1
# #      2
# #      3

# 利用 __next__ 获取元素
# 特别注意：在使用 __next__ 获取元素时，一定要将上面的转换注释掉
print(t.__next__())
# 输出：1
print(t.__next__())
# 输出：2
print(t.__next__())
# 输出：3

t=tuple(t) # 此时所有元素已被 __next__ 取出，故 t 为一个空元组
print(t)
# 输出：()

四、列表与元组的区别

五、字典

         1、定义：

另一种可变容器模型，且可存储任意类型对象

ps：（1）键值对：表示索引用的键和对应的值构成的成对关系。每个键值 key-->value 对用冒号 (:) 分割，每个对之间用逗号 (,) 分割。key 是无序且不可变的（Python3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序“一致”）

        （2）字典中的元素可混装，可修改

        （3）不支持下标索引，都可以通过 key 获取所需数据 value

        （4）支持 for 循环，不支持 while 循环

        2、创建：

（1）使用 { }：

        语法结构：d={key1:value1,key2:value2......}

d={10:'cat',20:'dog',30:'pet',20:'zoo'} # key相同时，value值进行覆盖
print(d) 
# 输出：{10: 'cat', 20: 'zoo', 30: 'pet'}

（2）使用 dic()：

        语法结构：dict(key1=value1,key2=value2......)

d=dict(cat=10,dog=20) # 左侧cat是key ,右侧的是value
print(d)
# 输出：{'cat': 10, 'dog': 20}

（3）使用 zip()：

        语法结构：zip(lst1,lst2)

lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2) # 此时的 zipobj 是一个 zip 对象
print(zipobj)
# 输出：<zip object at 0x000001ECD5A24F00>

# 转换为列表输出
# print(list(zipobj))
# 输出：[(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]

# 转换为字典输出
d=dict(zipobj)
print(d)
# 输出：{10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}

ps：（1）元组可以作为字典的 key，而列表不可以

t=(10,20,30)
print({t:10}) # t是key,10是value ,元组是可以作为字典中的key
# 输出：{(10, 20, 30): 10}

lst=[10,20,30]
print({lst:10})
# 输出：TypeError: unhashable type: 'list'

         3、取值：

语法结构：d[key] 或 d.get(key)

d={'hello':10,'world':20,'python':30}

# (1)使用d[key]
print(d['hello'])
# 输出：10

# (2)d.get(key)
print(d.get('hello'))
# 输出：10

# 二者之间是有区别的，如果key不存在，d[key]报错d.get(key)可以指定默认值
# print(d['java'])
# 输出：KeyError: 'java'
print(d.get('java'))
# 输出：None
print(d.get('java','不存在'))
# 输出：不存在

        4、遍历：

语法结构：（1）for element in d.items():

                  （2）分别获取 key 和 value：for key,value in d.items():

d={'hello':10,'world':20,'python':30}

for item in d.items():
    print(item) # key=value组成的一个元素
# 输出：('hello', 10)
#      ('world', 20)
#      ('python', 30)

# 在使用for循环遍历时，分别获取key,value
for key,value in d.items():
    print(key,'--->',value)
# 输出：hello ---> 10
#      world ---> 20
#      python ---> 30

        5、相关方法：

d={1001:'李梅',1002:'王华',1003:'张峰'}
print(d)
# 输出：{1001: '李梅', 1002: '王华', 1003: '张峰'}

# 向字典中添加元素
d[1004]='张丽丽'  # 直接使用赋值运算符向字典中添加元素
print(d)
# 输出：{1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张丽丽'}

# 获取字典中所有的key
keys=d.keys()
print(keys)
# 输出：dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
# 输出：[1001, 1002, 1003, 1004]
print(tuple(keys))
# 输出：(1001, 1002, 1003, 1004)

# 获取字典中所有的value
values=d.values()
print(values)
# 输出：dict_values(['李梅', '王华', '张峰', '张丽丽'])
print(list(values))
# 输出：['李梅', '王华', '张峰', '张丽丽']
print(tuple(values))
# 输出：('李梅', '王华', '张峰', '张丽丽')

lst=list(d.items()) # 如果将字典中的数据转成key-value的形式,以元组的方式进行展现
print(lst)
# 输出：[(1001, '李梅'), (1002, '王华'), (1003, '张峰'), (1004, '张丽丽')]
d=dict(lst)
print(d)
# 输出：{1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张丽丽'}

# 使用pop函数
print(d.pop(1001))
# 输出：李梅
print(d)
# 输出：{1002: '王华', 1003: '张峰', 1004: '张丽丽'}
print(d.pop(1008,'不存在'))
# 输出：不存在

# 随机删除
print(d.popitem())
# 输出：(1004, '张丽丽')
print(d)
# 输出：{1002: '王华', 1003: '张峰'}

# 清空字典中所有的元素
d.clear()
print(d)
# 输出：{}

# Python中一切皆对象，每个对象都有一个布尔值
print(bool(d)) # 空字典的布尔值为False
# 输出：False

        6、生成式：

语法结构：（1）d={  key:value for item in range  }

                  （2）d={key:value for key,value in zip(lst1,lst2)}

import random
d={item:random.randint(1,100) for item in range(4)}
print(d)
# 输出：{0: 71, 1: 88, 2: 12, 3: 16}

# 创建两个列表
lst=[1001,1002,1003]
lst2=['陈梅梅','王一一','李丽丽']
d={key:value for key,value in zip(lst,lst2)}
print(d)
# 输出：{1001: '陈梅梅', 1002: '王一一', 1003: '李丽丽'}

        7、合并运算符 |：

d1={'a':10,'b':20}
d2={'c':30,'d':40,'e':50}
merged_dict=d1|d2
print(merged_dict)
# 输出：{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}

六、集合

        1、定义：

（与数学中集合的概念一致）

ps：（1）Python中的集合是一个无序且可修改序列

        （2）集合只能存储不可变数据类型，且存储的元素可混装、不可重复

        （3）使用大括号 { } 创建集合，元素之间用逗号 (,) 分隔

        （4）支持 for 循环，不支持 while 循环（即不支持下标索引）

        2、创建：

（1）使用 { }：

        语法结构：s={element1,element2,......elementN}

s={10,20,30,40}
print(s)
# 输出：{40, 10, 20, 30}

# 集合只能存储不可变数据类型
s={[10,20],[30,40]} 
# 输出：TypeError: unhashable type: 'list'

（2）使用 set( )：

        语法结构：s=set(可迭代对象)

# 创建了一个空集合,空集合的布尔值是False
s=set() 
print(s)
# 输出：set()

s={} # 创建的是集合还是字典呢？
print(s,type(s)) 
# 输出：{} <class 'dict'>

s=set('helloworld')
print(s)
# 输出：{'o', 'l', 'w', 'r', 'd', 'h', 'e'}
s2=set([10,20,30])
print(s2)
# 输出：{10, 20, 30}

        3、删除：

语法结构：del 集合名

        4、操作符：

A={10,20,30,40,50}
B={30,50,88,76,20}
# 交集操作
print(A&B)
# 输出：{50, 20, 30}

# 并集操作
print(A|B)
# 输出：{40, 10, 76, 50, 20, 88, 30}

# 差集操作
print(A-B)
# 输出：{40, 10}

# 补集操作
print(A^B)
# 输出：{10, 88, 40, 76}

        5、相关方法：

（1）修改：

        1）set.add() —— 增加元素。若与原集合中的元素重复，则无效。
             set.update() —— 增加元素。该方法的参数可以是列表，元组，字典等。
s = {10,20,30}
print(s)
# 输出：{10, 20, 30}

# （1）使用 set.add()
s.add(40)
print(s)
# 输出：{40, 10, 20, 30}
s.add(10)
print(s)
# 输出：{40, 10, 20, 30}
# （2）使用 set.update
s.update([50,60,70])
print(s)
# 输出：{70, 40, 10, 50, 20, 60, 30}
        2）set.remove() ——  删除元素。若原集合中不存在该元素，则报错。
              set.discard() —— 删除元素。若原集合中不存在该元素，不会报错。
s = {10,20,30}
print(s)
# 输出：{10, 20, 30}

# （1）使用 set.remove()
s.remove(10)
print(s)
# 输出：{20, 30}
# s.remove(40)
# 输出：KeyError: 40
# （2）使用 set.discard()
s.discard(20)
print(s)
# 输出：{30}
s.discard(40)
print(s)
# 输出：{30}
        3）set.pop() —— 随机取出一个元素，此时原集合将会删除该元素。
s = set(("Google", "Runoob", "Taobao", "Facebook"))
print(s)
# 输出：{'Facebook', 'Google', 'Taobao', 'Runoob'}

x = s.pop()
print(x)
# 输出：Facebook
print(s)
# 输出：{'Google', 'Taobao', 'Runoob'}
        4）set.clear() —— 清空集合。

（2）与操作符相关：

        1）差集：set.difference() —— 不改变原集合
                        set.difference_update() —— 改变原集合
set1 = {1,2,3}
set2 = {1,5,6}

set3 = set1.difference(set2)
print(set3)
# 输出：{2, 3}

set1.difference_update(set3)
print(set1)
# 输出：{1}
        2）并集：set.union()
set1 = {1,2,3}
set2 = {1,5,6}

set3 = set1.union(set2)
print(set3)
# 输出：{1, 2, 3, 5, 6}

        6、遍历：

（1）for 循环：

        语法结构：for element in set:

set1 = {1,2,3}
for i in set1:
    print(f'{i}')
# 输出：1
#      2
#      3

（2）enumerate() 函数：

s={10,20,30}
for index,item in enumerate(s):
    print(index,'-->',item)
# 输出：0 --> 10
#      1 --> 20
#      2 --> 30

        7、生成式：

语法结构：set={expression for item in range if condition}

s={i for i in range(1,10) if i%2==1}
print(s)
# 输出：{1, 3, 5, 7, 9}

七、列表、元组、字典、集合的区别

 八、Python3.11新特性

        1、模式匹配：

语法结构：match data:      

                        case {}:

                                pass      

                        case []:

                                pass      

                        case():

                                pass      

                        case_:

                                pass

data=eval(input('请输入要匹配的数据:'))
match data:
    case {'name':'ysj','age':20}:
        print('字典')
    case [10,20,30]:
        print('列表')
    case (10,20,40):
        print('元组')
    case _:
        print('相当于多重if中的else')

        2、同步迭代

语法结构：match data1,data2:

                        case data1,dat2:

                                pass

fruits=['apple','orange','pear','grape']
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
    match f,c:
        case 'apple',10:
            print('10个苹果')
        case 'orange',3:
            print('3个桔子')
        case 'pear',4:
            print('4个梨')
        case 'grape',5:
            print('5串葡萄')
# 输出：10个苹果
#      3个桔子
#      4个梨
#      5串葡萄

fruits={'apple','orange','pear','grape'} # 此处改为集合
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
    match f,c:
        case 'apple',10:
            print('10个苹果')
        case 'orange',3:
            print('3个桔子')
        case 'pear',4:
            print('4个梨')
        case 'grape',5:
            print('5串葡萄')
# 输出1：3个桔子
# 输出2：5串葡萄
# 输出3：（空）

微语：且行且忘且随风，且行且看且从容。

CH3_CH2_CHO
关注
  • 26
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python之组合数据类型
weixin_44182650的博客
07-15 586
集合数据类型 集合数据类型的定义 --集合是多个元素的无序组合 --集合用大括号{}表示，元素间用逗号分隔 --建立集合类型用{}或set() --建立空集合类型，必须使用set() A = {"python",123,("python",123)} print (A) #{('python', 123), 123, 'python'} B = set("pypy123") print(...
Python组合数据类型
SXX___SXX的博客
05-16 541
Python组合数据类型 Python组合数据类型 元组 元组的元素是固定的，一旦创建就不能修改，（用圆括号表示，tuple()函数创建）；表达固定数据项，函数多返回值，多变量同步赋值，循环遍历等情况下十分有用，由于Python的实现，元组比列表的效率更高。 序列类型的通用操作符和函数 操作符 描述 s[i] 索引，返回序列的第i个元素 s[i: j] 分片，返回包含序列s第...
Python | 排列与组合
MissMango0820的博客
11-21 4724
本文简要总结在Python中实现排列与组合的方法。
python学习（四）组合
laner__gg的博客
07-19 647
1、组合：把类的实例化放到新类中，即组合。（具有横向关系的类放到一起需要组合，具有纵向关系的类放到一起需要继承） class Turtle: # 不实例化则不需要加括号 def __init__(self, x): self.num = x class Fish: def __init__(self, x): self.num = x class pool: def __init__(self, x, y
python排列组合
热门推荐
m0_75106254的博客
02-09 1万+
排列组合
Python类的组合
Python热爱者的博客
12-31 885
组合就是一个对象具有一个属性，这个属性的指是另外一个类的对象
Python常用组合数据类型详解
qq_54037316的博客
04-25 1805
本文详细阐述了Python中四种常用组合数据类型：列表（list）、元组（tuple）、集合（set）和字典（dict）。列表和元组均为有序数据类型，前者可变，后者不可变。集合具有无序且元素不重复的特点，适用于集合运算如并集、交集和差集等。字典则以键值对的形式存储数据，便于快速查找。文章深入讲解了这些数据类型的创建方法、访问方式以及常用操作，对于掌握Python编程具有重要意义。
python组合数据类型
06-08
Python 组合数据类型 Python 中的组合数据类型主要包括集合、列表、元组和字典四种。这些数据类型都是 Python 中的内置类型，广泛应用于数据处理和存储。 集合类型 集合类型是无序、唯一性元素的组合，可以是数字...
Python组合数据类型.pptx
04-15
"Python 组合数据类型" Python 组合数据类型是 Python 编程语言中的一种基本数据类型，它包括列表、元组、字典和集合四种类型。组合数据类型可以存储多个元素，并提供了多种操作和处理方法，非常有利于数据处理和...
Python入门——组合数据类型
12-21
【Python入门——组合数据类型】 Python 是一门高级编程语言，其强大的数据结构使得它易于学习和使用。在Python中，组合数据类型是指可以容纳多个不同类型数据的容器，主要包括列表（List）、元组（Tuple）、字典...
3Python组合数据类型.pptx
07-09
在Python编程语言中，组合数据类型是指能够存储多个值的数据结构。这些数据类型包括列表、元组、字典和集合，它们各自具有独特的特性和用途。本篇将深入讲解其中的列表与元组。 首先，**序列类型** 是Python中最...
实验7 Python组合数据类型.pdf
05-25
python实验
Python的组合数据类型
m0_63997099的博客
01-11 1194
Python的组合数据类型——序列，包括列表、元组、字典。集合四种类型，字符串类型在另外文章中。本文基于B站视频记录基础 https://www.bilibili.com/video/BV1wD4y1o7AS?p=57&spm_id_from=pageDriver&vd_source=541ccdf13b275290c43166e1762b6954
Python-组合数据类型
记录学习路上的一些拙见
08-11 642
主要针对初学程序设计的读者，具体讲解了程序设计语言的基本概念，理解程序开发的IPO编写方法，配置Python开发环境的具体步骤，以及Python语言和Python程序特点等内容，进一步给出了5个简单Python实例代码，帮助读者测试Python开发环境，对该语言有一个直观认识。
Pyhton的组合数据类型
一个正在学习C/C++的博主
02-29 763
Pyhton的组合数据类型 一、序列类型： 二、列表： 三、元组： 四、字典： 五、集合：
python中的排列和组合_python 排列组合
tingting11232的博客
11-30 1236
python中的排列和组合_python 排列组合
Python学习（三）组合数据类型
m0_73597306的博客
08-20 397
1）概念：python语言中的内置数据结构之一，是没有值的字典，与列表、字典一样都属于可变序列类型2）集合的创建方式：1.直接使用{ }创建 2.使用内置函数set( )创建：set( )函数也可以将其他类型的元素转换成集合类型的元素 3.若要定义空集合，则不能直接用{ },直接用会产生新字典，而不是空集合，所以要定义空集合只能用set( )函数。3）集合的特点：元素不能重复，若有重复元素，则只存储一个，且元素是无序的。
使用Python的Turtle库绘制动态风车
最新发布
爱写代码的小朋友
07-20 396
python绘制风车
python之组合数据类型（列表、元组、集合、字典）
06-28
Python 作为一门面向对象的编程语言，支持许多不同的数据类型，这些数据类型可以分为四个主要的类别：列表(list)、元组(tuple)、集合(set)和字典(dictionary)。 1. 列表(list) 列表是一组有序的元素，可以包含任何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值