Python 学习笔记补充1:字符(str)、元组(tuple)、列表(list)、字典(dict)、集合(set)

python自学之路-基础篇(二) 一.已知字符串 s = "i,am,lilei",请用两种办法取出之间的“am”字符。 s = "i,am,lilei" print (s[2:4]) s = "i,am,lilei" a=s.split(",")[1] print (a) 二.在python中,如何修改字符串? 字符串的replace方法。 info = 'abc' b=info.replace('c','d') ... 阅读详情

字符(str)

字符用于处理文本 (text) 数据,用「单引号 ’」和「双引号 “」来定义都可以。

字符中常见的内置方法 (可以用 dir(str) 来查) 有:

capitalize():大写句首的字母
split():把句子分成单词
find(x):找到给定词 x 在句中的索引,找不到返回 -1
replace(x, y):把句中 x 替代成 y
strip(x):删除句首或句末含 x 的部分

索引和切片:

  • 从 0 开始 (和 C 一样),不像 Matlab 从 1 开始。
  • 切片通常写成 start:end 这种形式,包括「start 索引」对应的元素,不包括「end索引」对应的元素。因此 s[2:4] 只获取字符串第 3 个到第 4 个元素。
  • 索引值可正可负,正索引从 0 开始,从左往右;负索引从 -1开始,从右往左。使用负数索引时,会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

在这里插入图片描述

元组(tuple)

创建元组可以用小括号 (),也可以什么都不用,为了可读性,建议还是用 ()。此外对于含单个元素的元组,务必记住要多加一个逗号,举例如下:

t1 = (1, 10.31, ‘python’)
t2 = 1, 10.31, ‘python’
print( t1, type(t1) )
print( t2, type(t2) )
#(1, 10.31, ‘python’) <class ‘tuple’>
#(1, 10.31, ‘python’) <class ‘tuple’>
print( type( (‘OK’) ) ) # 没有逗号 ,
print( type( (‘OK’,) ) ) # 有逗号 ,

元组中可以用整数来对它进行索引 (indexing) 和切片 (slicing),不严谨的讲,前者是获取单个元素,后者是获取一组元素。
元组有不可更改 (immutable) 的性质,因此不能直接给元组的元素赋值

内置方法

元组大小和内容都不可更改,因此只有 count 和 index 两种方法。

t = (1, 10.31, 'python')
print( t.count('python') )
print( t.index(10.31) )
#1
#1
  • count(‘python’) 是记录在元组 t 中该元素出现几次,显然是 1 次
  • index(10.31) 是找到该元素在元组 t 的索引,显然是 1
方法解释
cmp(tuple1, tuple2)比较两个元组元素。
len(tuple)计算元组元素个数。
max(tuple)返回元组中元素最大值。
min(tuple)返回元组中元素最小值。
tuple(seq)将列表转换为元组。

元组拼接

元组拼接 (concatenate) 有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。

(1, 10.31, 'python') + ('data', 11) + ('OK',)
(1, 10.31, 'python') * 2
#(1, 10.31, 'python', 'data', 11, 'OK')
#(1, 10.31, 'python', 1, 10.31, 'python')

解压元组

解压 (unpack) 一维元组 (有几个元素左边括号定义几个变量)

t = (1, 10.31, 'python')
(a, b, c) = t
print( a, b, c )
#1 10.31 python

解压二维元组 (按照元组里的元组结构来定义变量)

t = (1, 10.31, ('OK','python'))
(a, b, (c,d)) = t
print( a, b, c, d )
#1 10.31 OK python

如果你只想要元组其中几个元素,用通配符*,英文叫 wildcard,在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。如果你根本不在乎 rest 变量,那么就用通配符*加上下划线_

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print( a, b, c )
print( rest )
#1 2 5
#[3, 4]

a, b, *_ = t
print( a, b )
#1 2

优点缺点

  • 优点:占内存小,安全,创建遍历速度比列表快,可一赋多值。
  • 缺点:不能添加和更改元素。

列表(list) vs 元组(tuple)
1、创建

%timeit [1, 2, 3, 4, 5]
%timeit (1, 2, 3, 4, 5)

62 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
12.9 ns ± 1.94 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

创建速度,元组 (12.9ns) 碾压列表 (62ns)。
2、遍历

lst = [i for i in range(65535)]
tup = tuple(i for i in range(65535))
%timeit for each in lst: pass
%timeit for each in tup: pass

507 µs ± 61.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
498 µs ± 18.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

遍历速度两者相当,元组 (498 µs) 险胜列表 (507 µs)。
3、占空间

from sys import getsizeof
print( getsizeof(lst) )
print( getsizeof(tup) )s

578936
524328

列表比元组稍微废点内存空间。

列表(list)

内置方法

不像元组,列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

1、附加(append、extend)

  • list.append(obj) 在列表末尾添加新的对象,只接受一个参数,参数可以是任何数据类型,被追加的元素在 list
    中保持着原结构类型。
  • list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
l.append([4, 3])
print( l )
l.extend([1.5, 2.0, 'OK'])
print( l )

[1, 10.31, 'python', [4, 3]]
[1, 10.31, 'python', [4, 3], 1.5, 2.0, 'OK']

严格来说 append 是追加,把一个东西整体添加在列表后,而 extend 是扩展,把一个东西里的所有元素添加在列表后。对着上面结果感受一下区别。

2、插入(insert)
insert(i, x) 在编号 i 位置前插入 x。

l.insert(1, 'abc') # insert object before the index position
l

[1, 'abc', 10.31, 'python', [4, 3], 1.5, 2.0, 'OK']

3、删除(remove, pop,del)
remove 和 pop 都可以删除元素

  • 前者是指定具体要删除的元素,比如 ‘python’
  • 后者是指定一个编号位置,比如 3,删除 l[3] 并返回出来
  • list.remove(obj) 移除列表中某个值的第一个匹配项
  • list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
l.remove('python') # remove first occurrence of object
l
[1, 'abc', 10.31, [4, 3], 1.5, 2.0, 'OK']

p = l.pop(3) # removes and returns object at index.only pop 1 index position at any time.
print( p )
print( l )
[4, 3]
[1, 'abc', 10.31, 1.5, 2.0, 'OK']
  • del var1[, var2 ……] 删除单个或多个对象。如果知道要删除的元素在列表中的位置,可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

切片索引

切片的通用写法为: start : stop : step
在这里插入图片描述
x = [a] * 4操作中,只是创建4个指向list的引用,所以一旦a改变,x中4个a也会随之改变。

x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

" : " : 复制列表中的所有元素(浅拷贝)。

列表拼接

和元组拼接一样, 列表拼接也有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。

[1, 10.31, 'python'] + ['data', 11] + ['OK']
[1, 10.31, 'python'] * 2

[1, 10.31, 'python', 'data', 11, 'OK']
[1, 10.31, 'python', 1, 10.31, 'python']

列表(list)的常用操作符

  • 等号操作符:==
  • 连接操作符 +
  • 重复操作符 *
  • 成员关系操作符 in、not in

「等号 ==」,只有成员、成员位置都相同时才返回True。

列表的其他方法

1、list.count(obj) 统计某个元素在列表中出现的次数

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

2、list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

list1 = [123, 456] * 5
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4

3、list.reverse() 反向列表中元素

x = [123, 456, 789]
x.reverse()
print(x)  # [789, 456, 123]
方法解释
list.append():追加成员
list.count(x):计算列表中参数x出现的次数
list.extend(L):向列表中追加另一个列表L
list.index(x):获得参数x在列表中的位置
list.insert():向列表中插入数据
list.pop():删除列表中的成员(通过下标删除)
list.remove():删除列表中的成员(直接删除)
list.reverse():将列表中成员的顺序颠倒
list.sort():将列表中成员排序

优点缺点

  • 优点:灵活好用,可索引、可切片、可更改、可附加、可插入、可删除。
  • 缺点:相比 tuple 创建和遍历速度慢,占内存。此外查找和插入时间较慢。

字典(dict)

内置方法

字典里最常用的三个内置方法就是 keys(), values() 和 items(),分别是获取字典的键、值、对。
example 2:

temp = input("不妨猜一下小哥哥现在心里想的是那个数字:")
guess = int(temp)
if guess > 8:
    print("大了,大了")
else:
    if guess == 8:
        print("你这么懂小哥哥的心思吗?")
        print("哼,猜对也没有奖励!")
    else:
        print("小了,小了")
print("游戏结束,不玩儿啦!")

此外在字典上也有添加、获取、更新、删除等操作。
1、添加

d['Headquarter'] = 'Shen Zhen'

2、获取

print( d['Price'] )
print( d.get('Price') )

3、更新
4、删除

del d['Code']

或像列表里的 pop() 函数,删除行业 (industry) 并返回出来。

d = {'Name': 'Tencent',
'Country': 'China',
'Industry': 'Technology',
'Price': '359 HKD',
'Headquarter': 'Shen Zhen'}
print( d.pop('Industry') )

Technology

{'Name': 'Tencent',
'Country': 'China',
'Price': '359 HKD',
'Headquarter': 'Shen Zhen'}

不可更改键
字典里的键是不可更改的,因此只有那些不可更改的数据类型才能当键,比如整数 (虽然怪怪的)、浮点数 (虽然怪怪的)、布尔 (虽然怪怪的)、字符、元组 (虽然怪怪的),而列表却不行,因为它可更改。
有个地方要注意下,True 其实和整数 1 是一样的,由于键不能重复,当字典中有两个键Ture 和1时,你会发现字典只会取其中一个键。

d = {
2 : 'integer key',
10.31 : 'float key',
True  : 'boolean key',
('OK',3) : 'tuple key'
}

d = {
1 : 'integer key',
10.31 : 'float key',
True : 'boolean key',
('OK',3) : 'tuple key'
}
d
{1: 'boolean key',
 10.31: 'float key',
 ('OK', 3): 'tuple key'}

判断一个数据类型 X 是不是可更改的:

  • 麻烦方法:用 id(X) 函数,对 X 进行某种操作,比较操作前后的 id,如果不一样,则 X 不可更改,如果一样,则 X 可更改。
  • 便捷方法:用 hash(X),只要不报错,证明 X 可被哈希,即不可更改,反过来不可被哈希,即可更改。
方法解释
adict.keys()返回一个包含字典所有KEY的列表;
adict.values()返回一个包含字典所有value的列表;
adict.items()返回一个包含所有(键,值)元祖的列表;
adict.clear()删除字典中的所有项或元素;
adict.copy()返回一个字典浅拷贝的副本;
adict.fromkeys(seq, val=None)创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值(默认为None);
adict.get(key, default = None)返回字典中key对应的值,若key不存在字典中,则返回default的值(default默认为None);
adict.has_key(key)如果key在字典中,返回True,否则返回False。 现在用 in 、 not in;
adict.iteritems() adict.iterkeys() adict.itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表;
adict.pop(key[,default])和get方法相似。如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有给出default的值,则引发keyerror异常;
adict.setdefault(key, default=None)和set()方法相似,但如果字典中不存在Key键,由 adict[key] = default 为它赋值;
adict.update(bdict)将字典bdict的键值对添加到字典adict中。

优点缺点

  • 优点:查找和插入速度快
  • 缺点:占内存大

集合(set)

「集合」有两种定义语法,第一种是:{元素1, 元素2, …, 元素n};第二种是:第二种是用 set() 函数,把列表或元组转换成集合。set( 列表 或 元组 )

集合的两个特点:无序 (unordered) 和 唯一 (unique)。由于 set 存储的是无序集合,所以我们没法通过索引来访问,但是可以判断一个元素是否在集合中。

内置方法

用 set 的内置方法就把它当成是数学上的集,那么并集(or)、交集(and)、差集(-)都可以玩通了。

#并集
print( A.union(B) )     # All unique elements in A or B
print( A | B )          # A OR B
#交集
print( A.intersection(B) )   # All elements in both A and B
print( A & B )               # A AND B
#差集(A-B)
print( A.difference(B) )     # Elements in A but not in B
print( A - B )               # A MINUS B
#差集(B-A)
print( B.difference(A) )     # Elements in B but not in A
print( B - A )               # B MINUS A
#对称差集
print( A.symmetric_difference(B) )   # All elements in either A or B, but not both
print( A ^ B )                       # A XOR B
方法解释
s.issubset(t),s <= t测试是否 s 中的每一个元素都在 t 中
s.issuperset(t),s >= t测试是否 t 中的每一个元素都在 s 中
s.union(t),st
s.intersection(t),s & t返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t),s - t返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t),s ^ t返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()返回 set “s”的一个浅复制

优点缺点

  • 优点:不用判断重复的元素
  • 缺点:不能存储可变对象

参考文献

【1】: https://mp.weixin.qq.com/s/DZ589xEbOQ2QLtiq8mP1qQ

AI辅助Android开发:从传统到智能化的技术演进 AI辅助开发的核心在于利用算法模型自动化或优化传统任务。在Android开发中,AI可应用于需求分析、设计、编码、测试和维护各阶段。需求分析:AI工具如基于NLP的模型(例如GPT系列)可解析用户需求文档,自动生成用户故事和原型设计。假设产品需求为“开发一个航班查询应用”,AI能提取关键词,输出UML图或伪代码。代码生成:使用AI代码助手(如GitHub Copilot),工程师输入自然语言描述,AI生成Java/Kotlin代码片段。 阅读详情

相关推荐

TensorFlow_PyTorch实战:构建AI人工智能回归模型

回归分析是机器学习的核心任务之一,用于预测连续型目标变量(如房价、股票价格、用户留存时间等)。基础线性回归模型的数学原理与代码实现多项式回归模型的过拟合处理与正则化技巧自定义数据集加载与数据预处理流程动态图(PyTorch)与静态图(TensorFlow)的编程范式对比模型评估指标与可视化分析方法核心概念:对比两大框架的架构设计,解析回归模型核心组件数学原理:推导线性回归的假设函数、损失函数及优化算法算法实现:提供TensorFlow和PyTorch的完整代码示例项目实战。

AI天才研究院 1432

Python语法基础(二)

字符 #string s = "qwert" s[2:4] s = ['q','w','e','r','t'] s[2:4] list #def 方法 def how_many_days(month): days_in_month = [0,31,28,31,30,31,30,31,31,30,31,30,31] return days_in_month[month...

mxxxkuku的博客 996

三菱RJ71EIP91与SYSMAC Gateway通讯配置

三菱RJ71EIP91与SYSMAC Gateway通讯配置

zhang1270的博客 1531

Python期末考试题库

1.判断题(1分) 与元组和列表类似,集合中同样可以包含多个不同类型的元素,但集合中的各元素无序、不允许有相同元素且元素必须是可哈希的对象。 正确 错误 正确答案:正确 2.判断题(1分) 函数中的默认参数不能传递实际参数。 正确 错误 正确答案:错误 解析 :None 3.单选题(1分) 已知s=”Python语言程序设计”,则print(s[2:4])的输出结果为()。 Ayt Bth Cytho Dthon 正确答案:B ...

weixin_49647262的博客 1万+

银河麒麟V10搭建vsftpd

1、查看是否有安装过2、安装3、服务启动步骤设置开机启动并此次立即启动启动重启停止查看状态4、系统防火墙放行ftp服务如果没有重要的数据在服务器里面,或者在本地虚拟机中外网无法访问的情况下,建议直接关闭防火墙即可省略以上繁琐的步骤。

hhq850741642的博客 6488

信号完整性分析学习--16--传输线效应

传输线效应 说到传输线效应,大多数人都会想到一个经验法则,那就是: “当互连线的长度大于1/6倍的信号上升时间的空间延伸时,互连线就体现出传输线效应。” 上升时间越小越容易体现传输线效应。 由此可见,同一根互连线,它是否体现传输线效应,要看它要传输什么样的信号。下图所示,一根延时为15ps的互连线,当它传输上升时间为60ps的信号时就会体现传输线效应;当它传输上升时间为180ps的信号时就不体现传输线效应。

qq_29476769的博客 7285

3. Python 数据容器(列表、元组、字符串、集合、字典)

列表内的每一个数据,称为元素。列表以[]作为标识,其中的元素之间用,隔开。#字面量 [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义变量 变量名称 = [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义空列表 变量名称 = [ ] 变量名称 = 1ist()注意:列表可以一次存储多个数据,且可以为不同、任意的数据类型,支持嵌套。

qq_44378854的博客 3809

实战六十四:基于机器学习朴素贝叶斯的豆瓣Top250影评的情感分析与预测 附完整源码和数据

实战六十四:基于机器学习朴素贝叶斯的豆瓣Top250影评的情感分析与预测 附完整源码和数据

1568

第二章 关键技术介绍

关键技术介绍

qq_61398866的博客 274

手把手教你模拟登录豆瓣并爬取个人书影音数据:从Cookie解析到反爬攻防实战

在开始写代码之前,先明确我们需要的工具。:建议用3.10以上版本,方便使用一些新特性(如match语句)httpx:比requests更现代,支持HTTP/2,异步性能强,连接池复用好:解析HTML,语法简单,容错性强selenium:仅用于处理登录时的滑块验证(模拟真人)pandas:最终数据清洗和导出Excel/CSVretrying:自动重试机制,应对临时封禁:随机UA,降低特征lxml:作为BeautifulSoup的解析器,速度快为什么不只用requests?

2201_76125261的博客 579

基于唤醒音频的目标说话人语音识别系统设计报告

摘要 本报告设计了一套基于唤醒音频的目标说话人语音识别系统,通过五级流水线架构(唤醒检测→声纹注册→语音分离→目标ASR→拒识决策)解决复杂声学场景下的目标说话人识别问题。系统整合ECAPA-TDNN声纹模型、Conv-TasNet语音分离网络和Whisper ASR引擎,在L20 GPU上实现高效端到端推理,支持-5dB~5dB SNR范围和0~100%重叠率的双人语音场景处理。系统在目标说话人CER、拒识率和推理效率等关键指标上均达到设计目标,为智能语音交互提供了有效的身份感知解决方案。

huanghm88的专栏 77

python 字符串(str)、列表(list)、元组(tuple)、字典(dict)

在现实生活中,我们知道容器是用来存放东西的,比如实验室里的烧杯等。类似的,在Python中的容器是用来存放数据的。与此同时,为了操作方便,Python给我们提供了对容器中数据处理的方法,例如增加、删除、修改、查询等。变量名.函数(x)在Python中,常见容器有:(1)字符串:str(2)列表:list(3)元组:tuple(4)字典:dict(1)字符串:使用双引号引起来的内容;(2)列表:使用[ ]表示的内容;(可变数据类型)(3)元组:使用( )表示的内容;

m0_74051333的博客 1788

华为OD面试手撕真题 - 最大数

华为OD面试手撕真题 最大的数 提供Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解

qq_45776114的博客 345

Python学习笔记(五):list(列表)、tuple(元组)、str(字符串)、切片、set(集合)、dict(字典、映射)

1.数据容器分类数据容器可以从以下视角进行简单的分类:是否支持下标索引支持:列表、元组、字符串序列类型不支持:集合、字典非序列类型支持:列表、元组、字符串序列类型不支持:集合、字典非序列类型是否可以修改支持:列表、集合、字典不支持:元组、字符串2.数据容器特点对比列表:一批数据,可修改、可重复的存储场景元组:一批数据,不可修改、可重复的存储场景字符串:一串字符串的存储场景集合:一批数据,去重存储场景字典:一批数据,可用Key检索Value的存储场景。

weixin_62764364的博客 1890

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Python 列表、元组、字典、集合 完整区别对比

列表:有序可改,通用数组;元组:有序不可改,安全固定数据;字典:键值映射,按键快速查找;集合:无序自动去重,用于数据对比、去重。

可涵的博客 1026

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Python数据类型:序列(str、list、tuple、dict、range) 、集合set

序列sequence是多个值组成的一个整体,Python中的序列包含列表list、元组tuple、字符串str等。

人不风流枉少年 1658

5.Python 数据容器(list 列表、tuple 元组、str 字符串、set 集合、dict(字典)、序列切片)

5.Python 数据容器(list 列表、tuple 元组、str 字符串、set 集合、dict(字典)、序列切片)

weixin_52173250的博客 1592

Python中列表(List)、元组(Tuple)、字符串(Str)、集合(Set)和字典(Dict)的区别

1.四种数据结构之间的关系 列表 元组 集合 字典 英文 List Tuple Set Dict 可否读写 读写 只读 读写 读写 可否重复 是 是 否 是 存储方式 值 值 键(键唯一) 键值对(键唯一) 是否有序 有序 有序 无序 无序(自动正序) 初始化 [value1, value2] (value1, value2) {value1, value2} {key1 : value1, key2 : value2 } 增 list.append(value)

qq_41189226的博客 4865

Python 基础:字符串、列表、元组、集合、字典

本文系统介绍了Python中str字符串与list列表的基本操作。字符串支持创建、切片(左闭右开)、查找(如find、index)、修改(如replace、split、join)及判断(如startswith、isdigit等),且为不可变类型;列表则为可变类型,支持增删改查、索引、in判断等操作。内容涵盖常用方法语法与示例,适用于初学者掌握基础数据类型操作。

秀岩的博客 1963

【Python】数据容器——list、tuple、str、set、dict

1. 列表 list(可变序列) 2. 元组 tuple(不可变序列) 3. 字符串 str(不可变字符序列) 4. 索引和切片 5. 通用序列操作 6. 可变序列操作 5. 集合 set(可变集合) 6. 字典 dict(可变映射)

Qiuhan_909的博客 1207

Python的数据类型str、set、list、dict、tuple、Array、DataFrame等整理

目录杂记排序问题:strSet:ZipListTupledictArray:Dataframe 杂记 1)iterable类型在切片时,没有越界问题。 2)判断数据类型使用: isinstance(code, float) #判断code是否为float类型 3)浮点数问题:保留小数点后两位: format(loadedAvg_sheet1, '.2f') #对loadedAvg_sheet1保留小数点后两位 排序问题: sorted(agrs1,key=) 1)实现通过lis的第三个元素进行升序排序

lucky_chaichai的博客 3091

Python数据容器(列表list、元组tuple、字符串str、字典dict、集合set)详解

Python数据容器(列表list、元组tuple、字符串str、字典dict、集合set)详解

wlc_1216的博客 2016

python中的str、list、tuple、dict

01 str 字符串 str是不可变的,双引号或者单引号中的数据,就是字符串 str可进行的操作:下表索引、切片 下标索引 name = &quot;abcdef&quot; print(name[0]) print(name[1]) 切片 切片的语法:[ 起始:结束:步长 ] 注意:选取的区间属于左闭右开型,即从”起始”位开始,到”结束”位的前一位结束(不包含结束位本身) name = 'abcde...

windows下搭建virtualenv、virtualenvwrapper虚拟环境 1444

python怎么把list变成str_Python list和str互转的实现示例

一、list转字符串命令:''.join(list)其中,引号中是字符之间的分割符,如“,”,“;”,“\t”等等如:list = [1, 2, 3, 4, 5]''.join(list) 结果即为:12345','.join(list) 结果即为:1,2,3,4,5二、字符串转listprint list('12345')输出: ['1', '2', '3', '4', '5']print li...

weixin_39985472的博客 8444

Python入门——数据容器(list( 列表 ) 、 tuple( 元组 ) 、 str( 字符串 ) 、 set( 集合 ) 、 dict( 字典 ))

并通过 for 循环,对所有级别为 13级的员工,级别上升 1 级,薪水增加 1000 元。如果需要在程序内封装数据,又不希望封装的数据被篡改,那么元组就非常合适了,因为元组一旦定义完成,就不可修改。多数特性和 list 一致,不同点在于不可修改的特性(但可以修改内部 list 的内部元素)注意:查找特定字符串的下标时,查找的是一个单词,显示的下标时单词第一个字母的下标。字典同集合一样,不可用下标索引,但字典可通过 Key 值来取得对应的 Value。的一类数据容器列表、元组、字符串,均可以可以视为序列。

qq_68087137的博客 1518

【Python str-list-dict-tuple】——字符串、列表、字典、元组 互转集合

点个赞留个关注吧!! 列表:list 可读写 可重复 以值进行存储 有序 初始 ['a',1] 添加方式append 元组:tuple 仅读取 可重复 以值进行存储 有序 初始 ('a',1) 不可添加 字典: dict 可读写 可重复 键对值(键不可重复) 无序 初始 {‘a’:1,'b':2} 添加 c[...

₰₯₮ 的博客 7万+

python中type、str、list、tuple、set、dict

一、变量和常量 1、常量 其值不会发生变化不能被改变的两就是常量 整形常量:2 浮点型常量:2.2 字符串常量:‘abcde’ 布尔值常量:False、True 2、变量 python中其值是会发生变化,就是变量 python的变量是不用声明的 定义变量的时候要初始化就是给一个具体的值 变量完成初始化后才能定义 =:赋值运算符 可以多变量同时定义 二、python数据类型 Number 数字类型 String 字符型 List 列表类型 Tuple 元组类型 Dict 字典类型 Set 集合类型

王大兴的王兴的博客 2848
上一篇: Python 学习笔记3:循环语句
下一篇: Python 学习笔记4:异常处理
Codewith_jing
博客等级 码龄8年 3粉丝 12原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值