一木.溪桥学Python-05: 字符串str、字节bytes、列表list、sort()、sorted()

最新推荐文章于 2022-03-28 10:11:47 发布

一木.溪桥

最新推荐文章于 2022-03-28 10:11:47 发布

阅读量301

点赞数

分类专栏： Python学习之路文章标签： python

本文链接：https://blog.csdn.net/FaFrFu/article/details/111753742

版权

Python学习之路专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一木.溪桥在Logic Education跟Amy学Python

12期：Python基础课
一木.溪桥学Python-05: 字符串str、字节bytes、列表list、sort()、sorted()
日期：2020年12月23日

学习目标：

字符串：str
字节：bytes
列表：list

学习内容：

字符串：str

字符串常见操作 ( 熟悉 )

S.find(sub) --> 返回该元素最小的索引
S.index(sub) --> 返回该元素最小的索引
S.replace(old, new[, count]) --> 替换
S.split(sep=None) --> 以 sep 来分割字符串 , 并返回列表。 sep 默认为 None, 分割默认为空格
S.startswith(prefix[, start[, end]]) --> 判断字符串是否以前缀开始，返回为 bool 值。
S.endswith(suffix[, start[, end]]) --> 判断字符串是否以尾缀结束，返回为 bool 值。
S.lower() --> 将字符串全部转为小写
S.upper() --> 将字符串全部转为大写
S.strip([chars]) --> 默认去掉字符串左右的空格
S.isalpha() --> 判断字符串是否全为字母，返回的是 bool 值
S.isdigit() --> 判断字符串是否全为数字，返回的是 bool 值
S.isalnum() --> 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是 bool 值
S.join(iterable) --> 将序列中的元素以指定的字符连接生成一个新的字符串

S.find(sub) -->返回的是sub的最小索引，如果S中没有sub值则返回-1.

s = "hello everyone !"

print(s.find("e"))   # 打印e的最小索引，返回1

print(s.find("E"))   # 没有E，返回-1，不报错

S.index(sub) -->返回的是sub的最小索引，如果S中没有sub值则报错.

s = "hello everyone !"

print(s.index("e"))   # 打印e的最小索引，返回1

print(s.index("E"))   # 没有E，报错

S.replace(old, new[, count]) --> 替换 replace(self, old, new, count=None)

s = "hello everyone !"

# print(s.replace("e","A"))   # 默认替换全部

print(s.replace("e","A",2))   # 指定替换次数为2；hAllo Averyone !

S.split(sep=None) --> 以 sep 来分割字符串 , 并返回列表。 sep 默认为 None, 分割默认为空格

s = "hello everyone !"

print(s.split(" "))   # 用空格分割字符串S，返回为列表：['hello', 'everyone', '!']

S.startswith(prefix[, start[, end]]) --> 判断字符串是否以前缀开始，返回为 bool 值。

s = "hello everyone !"

print(s.startswith("h"))   # 判断字符串S是否以h开始，返回为bool：True

S.endswith(suffix[, start[, end]]) --> 判断字符串是否以尾缀结束，返回为 bool 值。

s = "hello everyone !"

print(s.endswith("!"))   # 判断字符串S是否以!结束，返回为bool：True

S.lower() --> 将字符串全部转为小写

s = "hello everyone !"

s1 = s.upper()             # 字符串s转为大写：HELLO EVERYONE !

s2 = s1.lower()            # 字符串s1转为小写：hello everyone !

print(s2)                  

print(id(s))               # id(s):2677845944192

print(id(s2))              # id(s):2677845944408

S.upper() --> 将字符串全部转为大写

s = "hello everyone !"

print(s.upper())   # 字符串S转为大写：HELLO EVERYONE !

S.strip([chars]) --> 默认去掉字符串左右的空格

s = "  hello everyone !  "

print(s.strip())               # 去掉字符串S首尾的空格：hello everyone !

print(s.replace(" ", "*"))     # 也可用replace功能替换想替换的：**hello*everyone*!**

S.isalpha() --> 判断字符串是否全为字母，返回的是 bool 值

s = "helloeveryone"

print(s.isalpha())               # ：True

S.isdigit() --> 判断字符串是否全为数字，返回的是 bool 值

s = "145632f"

print(s.isdigit())               # ：False

S.isalnum() --> 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是 bool 值

s = "145d"

print(s.isalnum())               # ：True

s = "145d!"

print(s.isalnum())               # ：False

S.join(iterable) --> 将序列中的元素以指定的字符连接生成一个新的字符串

s = "hello everyone !"

print("*".join(s))               # ：h*e*l*l*o* *e*v*e*r*y*o*n*e* *!

join()

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
join()方法语法：str.join(sequence)
sequence – 要连接的元素序列。
返回通过指定字符连接序列中元素后生成的新字符串。

s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))

Run:
r-u-n-o-o-b
runoob

字节：bytes

字节介绍 ( 掌握 )
在 Python3 以后，字符串和 bytes 类型彻底分开了。字符串是以字符为单位进行处
理的，bytes 类型是以字节为单位处理的。
bytes 数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是
不可变的序列对象。
Python3 中，bytes 通常用于网络数据传输、二进制图片和文件的保存等等。
字节创建 ( 掌握 )
可以通过调用 bytes() 生成 bytes 实例，其值形式为 b’xxxxx’ ，对于同一个字符串如
果采用不同的编码方式生成 bytes 对象，就会形成不同的值。

bt_1 = b"hello everyone !"

print(bt_1)               # b'hello everyone !'

print(type(bt_1))         # <class 'bytes'>
###

bt_2 = bytes("hello everyone !", encoding="utf_8")

print(bt_2)               # b'hello everyone !'

print(type(bt_2))         # <class 'bytes'>

字节与字符串转换
bytes to str --> .decode() 解码
str to bytes --> .encode() 编码

bt_2 = bytes("hello", encoding="utf")

s = bt_2.decode()

print(s)               # hello

print(type(s))         # <class 'str'>

bt_3 = s.encode()

print(bt_3)               # b'hello'

print(type(bt_3))         # <class 'bytes'>

列表：list

列表介绍 ( 掌握 )
列表是 Python 中最基本也是最常用的数据结构之一，它是一个有序可重复的元素
集合。从数据结构角度看，Python 的列表是一个可变长度的顺序存储结构，每一
个位置存放的都是对象的指针。
我们可对列表进行修改、切片、追加、删除、嵌套、迭代、成员判断等操作。

列表创建 ( 掌握 )
创建一个列表，只要把逗号分隔的不同的数据元素使用方括号括起来即可。

li = ["good",2,3,4,2,6.6]

print(li)                   # ['good', 2, 3, 4, 2, 6.6] 列表中的元素类型任意，元素可重复。

print(type(li))             # <class 'list'>

li = list("hello")

print(li)                   # ['h', 'e', 'l', 'l', 'o']  list(iterable) 可迭代

print(type(li))             # <class 'list'>

列表访问
列表从0开始为它的每一个元素顺序创建下标索引，直到总长度减一。要访问
它的某个元素，以方括号加下标值的方式即可。
注意要确保索引不越界，一旦访问的索引超过范围，会抛出异常。所以，一定要
记得最后一个元素的索引是 len(list)-1。

li = list("hellofarafaaaaaaaaaaahgjhkj")

li_max = len(li) - 1

print(li[li_max])        # 输出列表最后一个元素：j

修改列表内的元素 ( 掌握 )
直接取出元素进行重新赋值

li = list("hello")

li[1] = 'A'

print(li)        # 替换列表中元素['h', 'A', 'l', 'l', 'o']

删除列表内的元素 ( 掌握 )
直接取出元素，再通过 del 语句或者 list.remove() 或者 list.pop() 进行删除

li = list("hello")

del (li[1])

print(li)        # 删除列表中元素['h', 'l', 'l', 'o']

li = list("hello")

li.remove("e")   #改变的是li本身，没有返回值

print(li)        # 删除列表中元素['h', 'l', 'l', 'o']

li = list("hello")

li.pop()         # 默认删除列表最后一个元素

print(li)        # ['h', 'l', 'l', 'o'

li = list("hello")

li.pop(1)         # 指定删除列表中index元素:索引为1

print(li)        # ['h', 'l', 'l', 'o']

列表的特殊操作
list可以相加（拼接），不能相* /和相减。

li_1 = list("hello")

li_2 = list("everyone")

print(li_1 + li_2)        # ['h', 'e', 'l', 'l', 'o', 'e', 'v', 'e', 'r', 'y', 'o', 'n', 'e']

li_1 = list("hello")

for i in li_1:      # 快速取出li_1中所有元素

    print(i)
"""
h
e
l
l
o
"""

list的内置函数：len()、max()、min()

li = list("hello")

print(len(li))               # 列表长度 5

print(max(li))               # 列表中最大元素o

print(min(li))               # 列表中最小元素e

llist 排序.sort()

li = list("hello")

li.sort()               # 调用.sort() 排序

print(li)               # ['e', 'h', 'l', 'l', 'o']

llist 反转.reverse()

li = list("hello")

li.reverse()            # 调用.reverse() 反转

print(li)               # ['o', 'l', 'l', 'e', 'h']

列表的切片
切片模式：a[start:stop:step]

li = list("hello")

print(li[1::1])               # ['e', 'l', 'l', 'o']

列表常见操作

L.append(object) --> 在列表末尾添加新的对象

li = list("hello")

li.append(list("everyone"))

print(li)               # ['h', 'e', 'l', 'l', 'o', ['e', 'v', 'e', 'r', 'y', 'o', 'n', 'e']]

L.count(object) --> 统计某个元素在列表中出现的次数

li = list("hello everyone !")

li.count("e")

print(li.count("e"))               # 4

L.extend(iterable) --> 用新列表扩展原来的列表

li = list("hello")

li.extend("大家好！")

print(li)               # ['h', 'e', 'l', 'l', 'o', '大', '家', '好', '！']

L.index(value ） --> 从列表中找出某个值第一个匹配项的索引位置

li = list("hello everyone")

li.index("o")

print(li.index("o"))               # 4

L.insert(index, object)–> 将对象插入列表

li = list("hello everyone")

li.insert(3,"大家好！")

print(li)               # ['h', 'e', 'l', '大家好！', 'l', 'o', ' ', 'e', 'v', 'e', 'r', 'y', 'o', 'n', 'e']

L.pop([index]) --> 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

li = list("hello")

li.pop(3)

print(li)               # ['h', 'e', 'l', 'o']

L.remove(value) --> 移除列表中某个值的第一个匹配项

li = list("hello")

li.remove("e")

print(li)               # ['h', 'l', 'l', 'o']

L.reverse() --> 反向列表中元素

li = list("hello")

li.reverse()               # 调用.reverse() 反向

print(li)               # ['o', 'l', 'l', 'e', 'h']

sort()函数

描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
sort()方法语法：
list.sort(cmp=None, key=None, reverse=False)
参数
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。
L.sort(reverse=False) --> 对原列表进行排序

li = list("1234996789")

li.sort(reverse=False)               # 调用.sort() 排序，reverse=False升序。

print(li)               # ['1', '2', '3', '4', '6', '7', '8', '9', '9', '9']

sorted() 函数

描述
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法
sorted 语法：

sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
返回重新排序的列表。
实例
以下实例展示了 sorted 的使用方法：

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

L.copy() --> 复制列表

li = list("1234996789")

li.copy()

print(li.copy())           # ['1', '2', '3', '4', '9', '9', '6', '7', '8', '9']

print(type(li.copy()))     # <class 'list'>

L.clear() --> 清空列表

li = list("1234996789")

li.clear()              

print(li)               # []

作业：

在这里插入图片描述

作业答案：…

一木.溪桥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
一木.溪桥学Python-05: 字符串str、字节bytes、列表list、sort()、sorted()

一木.溪桥在Logic Education跟Amy学Python 12期：Python基础课一木.溪桥学Python-05: str、list、bytes日期：2020年12月23日学习目标：字符串：str字节：bytes列表：list学习内容：字符串：str字符串常见操作 ( 熟悉 )S.find(sub) --> 返回该元素最小的索引S.index(sub) --> 返回该元素最小的索引S.replace(old, new[, count]) -..
复制链接

扫一扫