一：序列

序列sequence是多个值组成的一个整体，Python中的序列包含列表list、元组tuple、范围range、字符串str，集合set不属于序列。

二：字符串str

2.1原始字符串

r表示原始字符串，表示把特殊字符串也当做普通的字符，常用于定义正则表达式(正则表达式经常使用到很多特殊字符)。

# Hello
#  Python
s = "Hello \n Python"
# Hello \n Python
s2 = r"Hello \n Python"import repattern = r'[0-9a-zA-Z.]+@[0-9a-zA-Z.]+?com'
match = re.match(pattern, '123@163.com')
if match:print(True)

repr(s): 使用print() 打印时会将特殊字符作为普通字符打印，并在两端加上单引号。

s = "物品\t单价\t数量\n包子\t1\t2"
# 物品    单价  数量
# 包子    1   2
print(s)# 物品\t单价\t数量\n包子\t1\t2
print(r'物品\t单价\t数量\n包子\t1\t2')# '物品\t单价\t数量\n包子\t1\t2'
print(repr(s))

2.2 转换大写upper()/转换小写lower()/首字符转大写capitalize()/所有单词首字符大写

line = 'this is line string'
# THIS IS LINE STRING
upper = line.upper()
# this is line string
lower = upper.lower()a = 'hello world'
# Hello world
print(a.capitalize())
# Hello World
print(a.title())

2.3 左对齐/右对齐/居中对齐

a = 'python'
b = 'java'
# python
# java
print(a.ljust(10))
print(b.ljust(10))
#     python
#       java
print(a.rjust(10))
print(b.rjust(10))# python____
# ______java
print(a.ljust(10, '_'))
print(b.rjust(10, '_'))a = 'python'
b = 'java'
# _______python_______
# ________java________
print(a.center(20, '_'))
print(b.center(20, '_'))

2.4 前缀startswith()和后缀endswith()

line = 'this is line string'
# True
yes = line.startswith('this')
# True
result = line.endswith('string')

2.5 替换 replace()

line = 'this is line string'
# this is line str
replace = line.replace('string', 'str')

2.6 分割 split()

line = 'this is line string'
# ['this', 'is', 'line', 'string']
items = line.split(' ')

2.7 索引 index()

查找字符串第一次出现的索引，如果找不到抛出异常ValueError。

line = 'this is line string'
# ValueError: substring not found
pos = line.index('line2')

2.8 查找 find()

与index()不同的是find()如果找不到返回-1而不会抛出异常ValueError。

line = 'this is line string'
# -1
pos = line.find('line2')

2.9 统计字符串出现的次数 count()

字符串对应的count()可以指定区间：开始索引，结束索引。

line = 'this is line string'
# 2
count = line.count('is')# 1
count = line.count("is", 4, len(line))

3.10去除首尾空格和换行符 strip() | lstrip() | rstrip()

line = ' \n this is line string\n '
strip = line.strip()
print(strip)lstrip = line.lstrip()
rstrip = line.rstrip()

3.11 是否为数字

# True
print("123".isnumeric())
# True
print("66".isdecimal())

3.11 格式化 format()

# 方式一
line = "1 {} 2 {} 3 {}"
print(line.format('a', 'b', 'c'))# 方式二
line = "1 %s 2 %d 3 %f"
print(line % ('张三', 18, 66.0))# 方式三
line = "姓名{name} 年龄 {age}".format(name='张无忌', age=28)
print(line)# 方式四
name = '张无忌'
age = 30
line = f"姓名{name} 年龄 {age}"
print(line)

3.12 字符串和二进制转换

如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes, 通过encode()方法将字符串转为字节。Python对bytes类型的数据用带b前缀的单引号或双引号表示。x = b"Hello"

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法；

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

str -> bytes
# b'Hello'
"Hello".encode('utf-8')bytes -> str
b'Hello'.decode('utf-8')
'Hello'

循环字符串

foorbar = 'foobar'
# f
print(foorbar[0])# f-o-o-b-a-r-
for i in foorbar:print(i, end='-')

三：列表list

字符串转列表list()

['a', 'b', 'c']
print(list('abc'))

正负索引

正索引：从0开始，方向从左到右。
负索引：从-1开始，方向从右到左。

chars = ['a', 'b', 'c', 'd', 'e', 'f']
# nums[0]=a, nums[-1]=f
print(f"chars[0]={nums[0]}, nums[-1]={chars[-1]}")

切片

[开始索引:结束索引:步长]

开始索引: 可以是正索引也可以是负索引，如果省略开始索引默认从头开始。
结束索引：可以是正索引也可以是负索引，如果省略结束索引默认到列表的结尾，不包含结束索引元素。
步长：默认为1，大于1表示：包含第一个元素，然后每隔n -1 获取指定的元素。

切片获取

chars = ['a', 'b', 'c', 'd', 'e', 'f']
# ['c', 'd', 'e', 'f']
print(chars[2:])
# ['a', 'b'] 不包含index=2的元素
print(chars[:2])
# ['e', 'f'] 负索引，从右到左
print(chars[-2:])# ['b', 'c']
print(chars[1:3])
# ['d', 'e']
print(chars[-3:-1])
# ['b', 'c']
print(chars[1:-3])# ['b', 'c', 'd', 'e']
print(chars[1:5:1])
# ['b', 'd'] 从[1:5]获取的结果开始，每隔步长-1个获取一个元素
print(chars[1:5:2])
# ['a', 'c', 'e']
print(chars[::2])
# ['f', 'd']
print(chars[-1:-5:-2])

切片修改元素

nums = [1, 2, 3, 4, 5]
nums[1:4] = [22, 33, 44]
# [1, 22, 33, 44, 5]
print(nums)

切片添加元素

切片赋值时当开始索引等于结束索引时，此时是在该索引位置添加多个索引元素

nums = [1, 5]
# 5
print(nums[1])
# []：开始包含index=1，结束又不包含index=1，所以为[]
print(nums[1:1])
nums[1:1] = [2, 3, 4]
# [1, 2, 3, 4, 5]
print(nums)

切片删除元素

nums = [1, 2, 3, 4, 5]
nums[1:4] = []
# [1, 5]
print(nums)# 相当于del[1:4]
del nums[1:4]nums = [1, 2, 3, 4, 5]
nums[1:4] = ['b', 'c']
# [1, 'b', 'c', 5]
print(nums)

序列相加 +

# [1, 2, 3, 'a', 'b', 'c']
print([1, 2, 3] + ['a', 'b', 'c'])

序列相乘 *

序列相乘表示将列表中的所有元素追加到列表中几次。

# [1, 2, 3, 1, 2, 3, 1, 2, 3]
print([1, 2, 3] * 3)# 初始化3个空元素
# [None, None, None]
print([None] * 3)

成员资格 in

print(1 in [1, 'hello', 2.0, True])

长度len、最大值max、最小值min

nums = [0, 1, 2, 3, 4, 5]
# 6, 5, 0
print(f'{len(nums)}, {max(nums)}, {min(nums)}')

删除元素 remove()

删除指定元素的第一个，如果不存在则抛出异常ValueError。

chars = ['a', 'b', 'a', 'd', 'e']
chars.remove('a')
# ['b', 'a', 'd', 'e']
print(chars)# ValueError: list.remove(x): x not in list
chars.remove('f')# 根据索引删除
del chars[0]

删除元素 del()

lst = [1, 2, 3]
del(lst[0])
# [2, 3]
print(lst)d = {'k1': 'v1', 'k2': 'v2'}
del(d['k1'])
# {'k2': 'v2'}
print(d)

弹出元素 pop()

删除列表中指定索引的元素（如果没有指定则删除最后一个元素），并返回删除的元素。

chars = ['a', 'b', 'c', 'd', 'e']
# 根据索引删除，并返回删除的元素，pop=a
pop = chars.pop(0)
# pop=e
pop = chars.pop()

元素拼接成字符串

print(",".join(['a', 'b', 'c']))

追加 append()

将单个元素添加到列表的末尾。

nums = [1, 2]
nums.append(3)
print(nums)

拓展 extend()

将一个列表中的所有元素添加到另一个列表的末尾，和+的作用一样。

# 方式一：使用extend()函数
nums = [1, 2, 3]
nums.extend([4, 5, 6])
# [1, 2, 3, 4, 5, 6]
print(nums)# 方式二：使用➕运算符
# [1, 2, 3, 4, 5, 6]
print([1, 2, 3] + [4, 5, 6])# 方式三：切片
nums = [1, 2, 3]
nums[3:3] = [4, 5, 6]
# [1, 2, 3, 4, 5, 6]
print(nums)

插入 insert()

items = ['a', 'c', 'd']
items.insert(1, 'b')
# ['a', 'b', 'c', 'd']
print(items)

清空 clear()

清空列表中的所有元素。

chars = ['a', 'b', 'c', 'd', 'e']# 清空列表 chars=[]
chars.clear()

数量 count()

获取元素在列表中出现的次数。

nums = ['a', 'a', 'a', 'b']
# 3
count = nums.count('a')
print(count)

索引 index()

获取元素中第一次出现的索引位置，如果找不到会抛出异常 ValueError。

items = ['a', 'b', 'c', 'a']
index = items.index('a')
# 0
print(index)items = ['a', 'b', 'c', 'a']
# ValueError: 'd' is not in list
index = items.index('d')

反转 reverse()

chars = ['a', 'b', 'c', 'd', 'e']
chars.reverse()
# ['e', 'd', 'c', 'b', 'a']
print(chars)

赋值 copy()

copy()方法是深拷贝。

chars = ['a', 'b', 'c']
chars_copy = chars.copy()chars.append('d')
chars_copy.append('e')
# ['a', 'b', 'c', 'd'] ['a', 'b', 'c', 'e']
print(chars, chars_copy)

排序 sort()

排序会修改原来的值，sort()方法没有返回值。

nums = [5, 1, 8, 6, 9]
nums.sort()
print(nums)

排序 sorted()

sorted()函数有返回值，返回排序后的值。

nums = [5, 1, 8, 6, 9]
nums_sort = sorted(nums)
# [5, 1, 8, 6, 9] [1, 5, 6, 8, 9]
print(nums, nums_sort)

map()

lst = [1, 2, 3, 4, 5]# [2, 4, 6, 8, 10]
print(list(map(lambda x: x * 2, lst)))

filter()

lst = [1, 2, 3, 4, 5]
# [2, 4]
print(list(filter(lambda x: x % 2 == 0, lst)))

reduce()

from functools import reducelst = [1, 2, 3, 4, 5]# 累加示例：15
print(reduce(lambda x, y: x + y, lst, 0))

循环

nums = [5, 1, 8, 6, 9]
for i in nums:print(i)

四：元组tuple

元组tuple和列表list最大的不同是元组不可以修改，其它的和列表没什么区别。

# 当元组中只有一个元素，元素后面的逗号是不能省略的，因为如果没有逗号那么(1)和1是完全一样，此时()只是用来表示优先级。
t = (1,)# 可以使用函数tuple()将list转为tuple
nums = tuple([1, 2, 3])
# 注意：5下标虽然超出实际值，但不报错
print(nums[1:5])

t = (1, 2, 3, 4)# 拆包的变量个数必须和元组的长度相同
a, b, c, d = t
# _表示占位符
a, b, _, d = t# 可以将最后的多个元素拆成一个列表，使用*来表示列表
# 2 [2, 3, 4]
a, *lst = t

压缩zip（难女搭配，干活不累）

zip可以将两个列表将相同的位置的元素组合成一个整体。

boys = ['杨过', '虚竹', '张无忌']
girls = ['小龙女', '梦姑', '小昭']# [('杨过', '小龙女'), ('虚竹', '梦姑'), ('张无忌', '小昭')]
bg = list(zip(boys, girls))# (('杨过', '小龙女'), ('虚竹', '梦姑'), ('张无忌', '小昭'))
bg = tuple(zip(boys, girls))# {'杨过': '小龙女', '虚竹': '梦姑', '张无忌': '小昭'}
bg = dict(zip(boys, girls)){('虚竹', '梦姑'), ('杨过', '小龙女'), ('张无忌', '小昭')}
bg = set(zip(boys, girls))

枚举函数 enumerate()

循环时同时访问索引和元素。

girls = ['小龙女', '梦姑', '小昭']
# 0 小龙女
# 1 梦姑
# 2 小昭
for i in range(0, len(girls)):print(i, girls[i])

girls = ['小龙女', '梦姑', '小昭']
# 0 小龙女
# 1 梦姑
# 2 小昭
for index, value in enumerate(girls):print(index, value)

序列转换

列表转字典

列表中的每个元素必须有两个值。

lst = [['k1', 'v1'], ['k2', 'v2']]
# {'k1': 'v1', 'k2': 'v2'}
print(dict(lst))lst = [('k1', 'v1'), ('k2', 'v2')]
# {'k1': 'v1', 'k2': 'v2'}
print(dict(lst))

列表转元组

lst = [1, 2, 3]
# (1, 2, 3)
print(tuple(lst))

元组转列表

tpl = (1, 2, 3)
# [1, 2, 3]
print(list(tpl))

字符串转列表

foobar = 'foobar'
# ['f', 'o', 'o', 'b', 'a', 'r']
print(list(foobar))

列表和元组的区别

元组是不可以修改的，这就导致在多线程下是安全的。如果不需要对元素进行修改应优先使用元组。
同样的元素列表要比元组更占用内存，并且创建也更耗时。

import syslst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
tpl = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 136
print(sys.getsizeof(lst))
# 112
print(sys.getsizeof(tpl))

%timeit 属于魔法指令，只能在ipython模式下才可以使用，用于计算平均耗时时间。

五：range

# 产生0~100的整数序列
range(101)# 产生0~99 的整数序列
range(1, 100)# 产生0~10的偶数：0 2 4 6 8 10
range(0, 11, 2)# 产生0~10的奇数：1 3 5 7 9
range(1, 11, 2)

集合set

Python数据类型：序列(字符串str、列表list、元组tuple、字典dict、范围range) 和集合set相关推荐

Python学习笔记——字符串、列表、元组、字典
字符串介绍想一想: 当打来浏览器登录某些网站的时候,需要输入密码,浏览器把密码传送到服务器后,服务器会对密码进行验证,其验证过程是把之前保存的密码与本次传递过去的密码进行对比,如果相等,那么就认为密 ...
Day2 Python基础学习——字符串、列表、元组、字典、集合
Python中文学习大本营:http://www.pythondoc.com/ 一.字符串操作一.用途:名字,性格,地址 name = 'wzs' #name = str('wzs')print(i ...
python中for语句涉及的序列可以是字符串吗_用for循环,可以遍历字符串、列表、元组、字典、数字序列、文件(TXT、excel)。...
[单选题]以上代码输出的结果是( ) if None: print("Hello") [单选题]在循环语句中,_______语句的作用是提前进入下一次循环. [单选题]在循环语句中 ...
Python中高级变量类型（列表，元组，字典，字符串，公共方法...）
高级变量类型目标列表元组字典字符串公共方法变量高级知识点回顾 Python 中数据类型可以分为数字型和非数字型数字型整型 (int) 浮点型(float) 布尔型(bool) ...
Python高级变量类型【列表、元组、字典、字符串】
这里写目录标题高级变量类型知识点回顾 1. 列表 1.1 列表的定义 1.2 列表常用操作 1.3 循环遍历 1.4 应用场景 2. 元组 2.1 元组的定义 2.2 元组常用操作 2.3 循环遍 ...
Python基础之 3. 容器：字符串、列表、元组、字典
0. 下标和切片 1. 下标索引所谓"下标",就是编号,就好比超市中的存储柜的编号,通过这个编号就能找到相应的存储空间字符串中"下标"的使用列表与元组支持 ...
python字典内存分析_python--序列，字符串，列表，元组，字典，集合内存分析
一,什么是序列. 序列是一种数据存储方式,用来存储一系列的数据,在内存(堆内存)中,序列是一块用来存放多个值的连续的内存空间,其存储的值为所指向对象的地址.比如说a = [ 10 , 20 , 30 ...
python字符串，列表，元组，字典的基本操作
python字符串,列表,元组,字典的基本操作文章目录 python字符串,列表,元组,字典的基本操作一.字符串 1.1字符串的输出 1.2字符串的输入 1.3下标和切片 1.4 字符串常见操作 ...
附加集合数据_最全的实例详解：Python字符串、列表、元组、字典、集合的补充...
本文内容主要介绍了Python字符串.列表.元组.字典.集合,结合实例形式详细分析了Python字符串.列表.元组.字典.集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下!!! 附加: p ...
python学习之函数，列表和元组，字典
目录函数默认参数关键字参数整理列表一.创建列表二.访问下标三.切片操作四.遍历五.插入六.查找七.删除八.拼接元组 1.创建元组 2.支持列表的一些操作 3.当进行多元赋值 ...

Python数据类型：序列(字符串str、列表list、元组tuple、字典dict、范围range) 和集合set