本笔记为阿里云天池龙珠计划SQL训练营的学习内容，链接为：https://tianchi.aliyun.com/specials/promotion/aicampsql
数据结构
Number(数字)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pe9NiOnG-1690041183248)(F:\subject\python\image-20230722000850272-16899890713182.png)]
variable
在 Python 中，创建一个变量很简单，无需显式声明变量的类型。变量在首次赋值时会被自动创建，并根据赋值的内容确定其数据类型。
在 Python 中，“var” 并不是一个特定的关键字或内置对象。在编程中，“var” 通常被用作一个通用的简写或缩写，表示"variable"，即变量。变量是用于存储和表示数据的名称，它们在程序中可以被赋值和修改，允许我们在代码中操作和处理数据。
简单数据类型
浮点float
整数int
布尔bool
容器数据类型
列表list
元组tuple
集合set
字典dict
字符串str
Python有6个序列*(序列是以连续的整数为索引)*的内置类型
Python3包含6中内建的序列:即列表、元组、字符串、Unicode字符串、buffer对象和 xrange 对象。
序列通用的操作包括：索引、长度、组合（序列相加）、重复（乘法）、分片、检查成员、遍历、最小值和最大值。
字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。
列表
定义
列表是有序集合，没有固定大小，能够保存任意数量 任意类型 的Python 对象，
语法为 [元素1, 元素2, …, 元素n] 。
- 关键点是「 中括号 [ ] 」和「 逗号 , 」
- 中括号 把所有元素绑在一起
- 逗号 将每个元素一一分开
索引值以 0 为开始值，-1 为从末尾的开始位置。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示:
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
创建空列表
x = []
用推导式创建
x = [i for i in range(10)] # 1, 2, 3, 4, 5, 6, 7, 8, 9]
用range()创建
x = list(range(1,10,2)) # [1, 3, 5, 7, 9]
增
1.list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
2.list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
区别：此元素如果是一个 list，那么这个 list 将作为一个整体进行追加
x = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
y = ['saturday', 'sunday']
x.append(y)
print(x) # ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', ['saturday', 'sunday']]
x.extend(y)
print(x)
# ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', ['saturday', 'sunday'], 'saturday', 'sunday']
3.list.insert(index, obj) 在编号 index 位置前插入 obj 。
x = ['monday', 'tuesday', 'thursday', 'friday']
x.insert(2, 'wednesday')
print(x)
# ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
删
1.list.remove(obj) 移除列表中某个值的第一个匹配项
x = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
x.remove('wednesday')
print(x)
# ['monday', 'tuesday', 'thursday', 'friday']
2.list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
print(x.pop(1)) # 给出删除下标为1的元素。 默认值为-1，即最后一个
print(x)
# tuesday
# ['monday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
3.del var1[, var2 ……] 删除单个或多个对象。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
del x[1:2] # 只删除了 下标为 1 元素
print(x)
改 查
使用下标，直接操作元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
切片
在 Python 中，切片（Slicing）是一种用于从序列（例如字符串、列表、元组等）中获取子序列的方法。切片操作返回一个新的序列，其中包含了原始序列中从 start 到 stop - 1的元素，并按照 step 指定的步长进行间隔
切片使用的语法是 start:stop:step，其中：
start：表示切片的起始位置（包含在切片内）。stop：表示切片的结束位置（不包含在切片内）。step：表示切片的步长（可选，表示从起始位置到结束位置的元素之间的间隔，默认值为1）。- 步长为正，起始位置应该在结束位置之前。
- 步长为负，起始位置应该在结束位置之后。且起始位置到结束位置
- 如果起始位置在结束位置之后（对于正步长）或者在结束位置之前（对于负步长），那么结果将会是一个空列表，因为没有满足条件的元素。
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result1 = my_list[2:9:1]
print(result1) # [3, 4, 5, 6, 7, 8, 9]
result1 = my_list[2:9:2]
print(result1) # [3, 5, 7, 9]
result1 = my_list[2:9:3]
print(result1) # [3, 6, 9]
result1 = my_list[9:2:-1]
print(result1) # [9, 8, 7, 6, 5, 4]
列表的常用操作符
- 等号操作符：==
- 「等号 ==」，只有成员、成员位置都相同时才返回True。
- 连接操作符 +
- 重复操作符 *
- 和元组拼接一样， 列表拼接也有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
- 成员关系操作符 in 、 not in
列表的其它方法
-
list.count(obj) 统计某个元素在列表中出现的次数
-
list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
-
list.reverse() 反向列表中元素
-
list.sort(key=None, reverse=False) 对原列表进行排序。
-
key – 主要是用来进行比较的元素，只有一个参数，使用具体的函数参数
指定可迭代对象 中的一个元素来进行排序。 默认为
None，表示使用元素本身进行排序。 -
reverse – 排序规则， reverse = True 降序， reverse = False 升序（默认）。
-
该方法没有返回值，但是会对列表的对象进行排序。
-
students = [ {'name': 'John', 'age': 20}, {'name': 'Alice', 'age': 18}, {'name': 'Bob', 'age': 22} ] # 按照学生的年龄进行升序排序 students.sort(key=lambda student: student['age']) print(students) # 输出 [{'name': 'Alice', 'age': 18}, {'name': 'John', 'age': 20}, {'name': 'Bob', 'age': 22}] # lambda student: student['age']使用了 lambda 函数作为 key 参数，按照学生的年龄进行排序。
-
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!' var2 = "Runoob"
Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CQGIS2Qm-1690041183250)(https://static.runoob.com/wp-content/uploads/123456-20200923-1.svg)]
如下实例：
实例(Python 3.0+)
var1 = 'Hello World!'
var2 = "Runoob"
print("var1[0]: ", var1[0])
print("var1[-1]: ", var1[-1])
print("var1[-3]: ", var1[-3])
print("var1[-4:-1]: ", var1[-4:-1])
print("var1[-4:]: ", var1[-4:])
print("var2[1:5]: ", var2[1:5])
以上实例执行结果：
var1[0]: H
var1[-1]: !
var1[-3]: l
var1[-4:-1]: rld
var1[-4:]: rld!
var2[1:5]: unoo
Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接，如下实例：
实例(Python 3.0+)
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')
以上实例执行结果
已更新字符串 : Hello Runoob!
Python 转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 \* 转义字符。如下表：
| 转义字符 | 描述 | 实例 |
|---|---|---|
| (在行尾时) | 续行符 | >>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>> |
| \ | 反斜杠符号 | >>> print("\\") \ |
| ’ | 单引号 | >>> print('\'') ' |
| " | 双引号 | >>> print("\"") " |
| \a | 响铃 | >>> print("\a")执行后电脑有响声。 |
| \b | 退格(Backspace) | >>> print("Hello \b World!") Hello World! |
| \000 | 空 | >>> print("\000") >>> |
| \n | 换行 | >>> print("\n") >>> |
| \v | 纵向制表符 | >>> print("Hello \v World!") Hello World! >>> |
| \t | 横向制表符 | >>> print("Hello \t World!") Hello World! >>> |
| \r | 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 | >>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao |
| \f | 换页 | >>> print("Hello \f World!") Hello World! >>> |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 | >>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World! |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 | >>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World! |
| \other | 其它的字符以普通格式输出 |
使用 \r 实现百分比精度：
实例
import time
for i in range(101):
print("\r{:3}%".format(i), end=' ')
time.sleep(0.05)
'''
import time: 这行代码引入了 Python 的标准库 time 模块。time 模块提供了一些与时间相关的功能，比如延时操作 sleep。
for i in range(101):: 这是一个循环，range(101) 会生成从 0 到 100（包括 0 和 100）的整数序列。变量 i 在每次循环中取这些整数值。
print("\r{:3}%".format(i), end=' '): 这行代码用于输出进度条效果。"\r" 是回车符，它使得输出的内容回到行首，即每次输出都覆盖了上一次的输出。"{:3}%" 是一个格式化字符串，其中的 {:3} 表示输出一个宽度为 3 的整数，% 是一个百分号。
在每次循环中，进度条会显示当前的进度，从 0% 到 100%。由于使用了回车符 \r，所以每次输出都会覆盖上一次的输出，形成一个动态变化的进度条效果。
time.sleep(0.05): 这是一个延时操作，它使得程序每次循环后都会暂停 0.05 秒。这样做是为了控制进度条的速度，使其显示得不会过快，让用户可以观察到进度条的变化。
综合起来，这段代码会输出一个简单的进度条，从 0% 开始，每次循环增加 1%，最终到达 100%。每次输出都会覆盖上一次输出，形成一个动态的进度条效果，并且每次输出之间会有短暂的暂停，使进度条的变化看起来更平滑。这种进度条通常在需要长时间运行的任务中使用，以显示任务的进展情况。
'''
以下实例，我们使用了不同的转义字符来演示单引号、换行符、制表符、退格符、换页符、ASCII、二进制、八进制数和十六进制数的效果：
实例
print('\'Hello, world!\'') # 输出：'Hello, world!'
print("Hello, world!\nHow are you?") # 输出：Hello, world!
# How are you?
print("Hello, world!\tHow are you?") # 输出：Hello, world! How are you?
print("Hello,\b world!") # 输出：Hello world!
print("Hello,\f world!") # 输出：
# Hello,
# world!
print("A 对应的 ASCII 值为：", ord('A')) # 输出：A 对应的 ASCII 值为： 65
print("\x41 为 A 的 ASCII 代码") # 输出：A 为 A 的 ASCII 代码
decimal_number = 42
binary_number = bin(decimal_number) # 十进制转换为二进制
print('转换为二进制:', binary_number) # 转换为二进制: 0b101010
octal_number = oct(decimal_number) # 十进制转换为八进制
print('转换为八进制:', octal_number) # 转换为八进制: 0o52
hexadecimal_number = hex(decimal_number) # 十进制转换为十六进制
print('转换为十六进制:', hexadecimal_number) # 转换为十六进制: 0x2a
Python 字符串运算符
下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | ‘H’ in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | ‘M’ not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
| % | 格式字符串 | 请看下一节内容。 |
实例(Python 3.0+)
#!/usr/bin/python3
a = "Hello"
b = "Python"
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
if( "H" in a) :
print("H 在变量 a 中")
else :
print("H 不在变量 a 中")
if( "M" not in a) :
print("M 不在变量 a 中")
else :
print("M 在变量 a 中")
print (r'\n')
print (R'\n')
以上实例输出结果为：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
实例(Python 3.0+)
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
以上实例输出结果：
我叫 小明 今年 10 岁!
python字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 | |
| # | 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) |
| 0 | 显示的数字前面填充’0’而不是默认的空格 |
| % | ‘%%‘输出一个单一的’%’ |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
Python三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
实例(Python 3.0+)
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符 TAB ( \t )。
也可以使用换行符 [ \n ]。 """
print(para_str)
以上实例执行结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得 what you see is what you get）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%):
实例
>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，
f' '
实例
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
实例
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2
Unicode 字符串
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。
Python 的字符串内建函数
Python 的字符串常用内建函数如下：
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize() 将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding=“utf-8”, errors=“strict”) Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding=‘UTF-8’,errors=‘strict’) 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
| 6 | endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。 |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。 |
| 10 | isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| 11 | isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| 12 | isdigit() 如果字符串只包含数字则返回 True 否则返回 False… |
| 13 | islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() 如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 | istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string) 返回字符串长度 |
| 20 | [ljust(width, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower() 转换字符串中所有大写字符为小写. |
| 22 | lstrip() 截掉字符串左边的空格或指定字符。 |
| 23 | maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | [replace(old, new , max]) 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 | [rjust(width,, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip() 删除字符串末尾的空格或指定字符。 |
| 31 | split(str=“”, num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| 32 | [splitlines(keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | [strip(chars]) 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars=“”) 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() 转换字符串中的小写字母为大写 |
| 39 | zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
