本章会从 Python 最基本的内置数据类型开始学习，这些类型包括：
• 布尔型(表示真假的类型，仅包含 True 和 False 两种取值)
• 整型(整数，例如 42 、 100000000 )
• 浮点型(小数，例如 3.14159 ，或用科学计数法表示的数字，例如 1.0e8 ，它表示 1 乘
以 10 的 8 次方，也可写作 100000000.0 )
• 字符串型(字符组成的序列)
2.1 变量/名字/对象
1. Python 里所有数据----布尔值/ 整数/ 浮点数/ 字符串, 甚至大型数据结构/ 函数以及程序----------都是以对象(object) 的形式存在的.
这使得 Python 具有很强的统一性
2. Python 是强类型(strongly typed), 你永远无法修改一个已有对象的类型, 即使它包含的值是可变的
3. Python 中的变量有一个非常重要的性质: 它仅仅是一个名字.赋值操作并不会实际复制值, 它只是为数据对象去一个相关的名字. 名字是对象的引用而不是对象本身.
4. 在Python 中,如果想知道一个对象 (例如一个变量或者一个字面值) 的类型, 可以使用语句: type(thing)
5. 最后注意, 不要使用 Python 的保留关键字
False class finally is returnNonecontinue for lambda tryTruedef from nonlocal while
and del global notwith
aselif if or yield
assert else import pass
break except in raise
2.2 数字
Python 本 身 支 持 整 数( 比 如 5 和 1000000000 ) 以 及 浮 点 数( 比 如 3.1416 、 14.99 和
1.87e4 )。你可以对这些数字进行下表中的计算。
2.2.1 整数
2.2.2 优先级
2.2.3 基数
在 Python 中，整数默认使用十进制数(以 10 为底)，除非你在数字前添加前缀，显式地指
定使用其他基数(base)。也许你永远都不会在自己的代码中用到其他基数，但你很有可能
在其他人编写的 Python 代码里见到它们。
在 Python 中，除十进制外你还可以使用其他三种进制的数字：
• 0b 或 0B 代表二进制(以 2 为底)
• 0o 或 0O 代表八进制(以 8 为底)
• 0x 或 0X 代表十六进制(以 16 为底)
>>> 10
10
>>>0b102
>>>0o108
>>> 0x10
16
>>>
2.2.4 类型转换
我们可以方便地使用 int() 函数将其他的 Python 数据类型转换为整型。它会保留传入数据
的整数部分并舍去小数部分
>>>int(True)1
>>>int(False)
0>>> int(89.3)89
>>> int(1.2e4)12000
>>> int('11')11
>>> int('-22')-22
>>> int(1234)1234如果你试图将一个与数字无关的类型转化为整数，会得到一个异常>>> int('this is a beer')
Traceback (most recent call last):
File"", line 1, in int('this is a beer')
ValueError: invalid literalfor int() with base 10: 'this is a beer'后面的内容不是纯数字，无法被 int() 函数识别，因此抛出异常
如果混合使用多种不同的数字类型进行计算，Python 会自动地进行类型转换：>>> 4 + 7.0
11.0
>>> True + 2
3
>>> False + 3.2
3.2
2.2.5 一个 int 型有多大
在 Python 2 里，一个 int 型包含 32 位，可以存储从 -2 147 483 648 到 2 147 483 647 的整数。
一个 long 型会占用更多的空间：64 位，可以存储从 -9 223 372 036 854 775 808 到 9 223
372 036 854 775 807 的整数。
到了 Python 3， long 类型已不复存在，而 int 类型变为可以存储任意大小的整数，甚至超
过 64 位。因此，你可以进行像下面一样计算( 10**100 被赋值给名为 googol 的变量，这是
Google 最初的名字，但由于其拼写困难而被现在的名字所取代)：
>>>
>>> googol = 10**100
>>> googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000
>>> googol * googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000
在许多其他编程语言中，进行类似上面的计算会造成整数溢出，这是因为计算中的数字或
结果需要的存储空间超过了计算机所提供的(例如 32 位或 64 位)。在程序编写中，溢出
会产生许多负面影响。而 Python 在处理超大数计算方面不会产生任何错误，这也是它的一个加分点。
2.2.6 浮点数
整数全部由数字组成，而浮点数(在 Python 里称为 float)包含非数字的小数点。浮点数与
整数很像：你可以使用运算符
+ - * / ** // % 以及 divmod()
函数进行计算。
>>>float(True)1.0
>>>float(False)0.0
>>> float(87)87.0
>>> float('99')99.0
>>> float('34.3')34.3
>>> float('1.0e4')10000.0
>>> divmod(34, 3)
(11, 1)
2.2.7 数学函数
Python 包含许多常用的数学函数，例如平方根、余弦函数，等等。这些内容被放到了附录
C，在那里我还会讨论 Python 的科学应用。
2.3 字符串
将一系列字符包裹在一对单引号或一对双引号中即可创建字符串，就像下面这样：
>>> 'Snap'
'Snap'
>>> "Snap"
'Snap'交互式解释器输出的字符串永远是用单引号包裹的，但无论使用哪种引号，Python 对字符
串的处理方式都是一样的，没有任何区别。
为什么要使用两种引号？这么做的好处是可以创建本身就包含引号的字符串，
而不用使用转义符。可以在双引号包裹的字符串中使用单引号，或者在单引号包裹的字符
串中使用双引号：
>>> "'Jim' said the naysayer."
"'Jim' said the naysayer."
还可以使用连续三个单引号 ''' ，或者三个双引号 """ 创建字符串：
>>> '''Boom'''
'Boom'
>>> """Bear"""
'Bear'
三元引号在创建短字符串时没有什么特殊用处。它多用于创建多行字符串。下面的例子
中，创建的字符串引用了 Edward Lear 的经典诗歌：
>>> poem = '''There was a Yound Lady,
... Who casually sat in a doorway;
... When the door squeezed her flat,
... She exclaimed, "What of that?"
... This courageous Young Lady of Norway.'''
>>>(上面这段代码是在交互式解释器里输入的，第一行的提示符为>>>，后面行的提示符
为 ... ，直到再次输入三元引号暗示赋值语句的完结，此时光标跳转到下一行并再次以>>>提示输入。)
如果你尝试通过单独的单双引号创建多行字符串，在你完成第一行并按下回车时，Python
会弹出错误提示：
>>> poem = 'There was a Yound Lady,
SyntaxError: EOL while scanning string literal
在三元引号包裹的字符串中，每行的换行符以及行首或行末的空格都会被保留：
值得注意的是， print() 函数的输出与交互式解释器的自动响应输出存在一些差异：
>>> print(poem)
There was a Yound Lady,
... Who casually satina doorway;
... When the door squeezed her flat,
... She exclaimed,"What of that?"... This courageous Young Lady of Norway.>>>poem'There was a Yound Lady,\n... Who casually sat in a doorway;\n... When the door squeezed her flat,\n... She exclaimed, "What of that?"\n... This courageous Young Lady of Norway.'
print() 会把包裹字符串的引号截去，仅输出其实际内容，易于阅读。它还会自动地在各
个输出部分之间添加空格，并在所有输出的最后添加换行符
最后要指出的是 Python 允许空串的存在，它不包含任何字符且完全合法。你可以使用前面
提到的任意一种方法创建一个空串：
>>> ''
''
>>> ""
''
>>> ''''''
''
>>> """"""
''
为什么会用到空字符串？有些时候你想要创建的字符串可能源自另一字符串的内容，这时
需要先创建一个空白的模板，也就是一个空字符串。
>>> bottles = 99
>>> base = ''
>>> base += 'current inventory:'
>>> base +=str(bottles)>>>base'current inventory:99'
2.3.2 使用 str() 进行类型转换
使用 str() 可以将其他 Python 数据类型转换为字符串：
>>> str(87.3)'87.3'
>>> str(1.0e4)'10000.0'
>>>str(True)'True'
2.3.3 使用 \ 转义
Python 允许你对某些字符进行转义操作，以此来实现一些难以单纯用字符描述的效果。在
字符的前面添加反斜线符号 \ 会使该字符的意义发生改变。最常见的转义符是 \n ，它代表
换行符，便于你在一行内创建多行字符串
>>> palindrome = 'A man,\nA plan,\nA canal:\nPanama.'
>>>palindrome'A man,\nA plan,\nA canal:\nPanama.'
>>> print(palindrome)
A man,
A plan,
A canal:
Panama.>>> print('\tabc')
abc>>> print('a\tbc')
a bc>>> print('abc\t')
abc
有时你可能还会用到 \'
和
\" 来表示单、双引号，尤其当该字符串由相同类型的引号包裹时：
>>> testimony = "\"I did nothing!\" he said. \"Not that either! Or the otherthing.\""
>>>testimony'"I did nothing!" he said. "Not that either! Or the otherthing."'
如果你需要输出一个反斜线字符，连续输入两个反斜线即可：
>>> speech = 'Today we honor our friend, the backslash: \\.'
>>>speech'Today we honor our friend, the backslash: \\.'
2.3.4 使用 + 拼接
在 Python 中，你可以使用 + 将多个字符串或字符串变量拼接起来，就像下面这样：
>>> 'Release the kraken!' + 'At once!'
'Release the kraken! At once!'
也可以直接将一个字面字符串(非字符串变量)放到另一个的后面直接实现拼接：
>>> "My word!" "A gentleman caller!"
'My word! A gentleman caller!'
进行字符串拼接时，Python 并不会自动为你添加空格，需要显示定义。但当我们调用
print() 进行打印时，Python 会在各个参数之间自动添加空格并在结尾添加换行符：
>>> a = 'Duck'
>>> b =a>>> c = 'Grey Duck'
>>> a + b +c'DuckDuckGrey Duck'
>>> print(a, b, c)
Duck Duck Grey Duck
2.3.5 使用 * 复制
使用 * 可以进行字符串复制。试着把下面这几行输入到交互式解释器里，看看结果是
什么：
>>> start = 'Na' * 4 + '\n'
>>> middle = 'Hey' * 3 + '\n'
>>> end = 'Goodbye'
>>> print(start + middle +end)
NaNaNaNa
HeyHeyHey
Goodbye
2.3.6 使用 [] 提取字符
在字符串名后面添加 [] ，并在括号里指定偏移量可以提取该位置的单个字符。第一个字符
(最左侧)的偏移量为 0，下一个是 1，以此类推。最后一个字符(最右侧)的偏移量也可
以用 -1 表示，这样就不必从头数到尾。偏移量从右到左紧接着为 -2、-3，以此类推。
>>> letters = 'abcdefghijklmnopqrstuvwxyz'
>>>letters[0]'a'
>>> letters[1]'b'
>>> letters[-1]'z'
>>> letters[-2]'y'
如果指定的偏移量超过了字符串的长度(记住，偏移量从 0 开始增加到字符串长度 -1)，
会得到一个异常提醒：
>>> letters[100]
Traceback (most recent call last):
File"", line 1, in letters[100]
IndexError: string index out of range
由于字符串是不可变的，因此你无法直接插入字符或改变指定位置的字符。看看当我们试
图将 'Henny' 改变为 'Penny' 时会发生什么：会报错!
>>> name = 'Henny'
>>> name[0] = 'P'Traceback (most recent call last):
File"", line 1, in name[0]= 'P'TypeError:'str' object does not support item assignment
为了改变字符串，我们需要组合使用一些字符串函数，例如 replace() ，以及分片操作
>>> name.replace('H', 'P')'Penny'
>>>name'Henny'
>>> 'P' + name[1:]'Penny'
2.3.7 使用 [start:end:step] 分片
分片操作(slice)可以从一个字符串中抽取子字符串(字符串的一部分)。我们使用一对方
括号、起始偏移量 start 、终止偏移量 end 以及可选的步长 step 来定义一个分片。其中一
些可以省略。分片得到的子串包含从 start 开始到 end 之前的全部字符。
• [:] 提取从开头到结尾的整个字符串
• [start:] 从 start 提取到结尾
• [:end] 从开头提取到 end - 1
• [start:end] 从 start 提取到 end - 1
• [start:end:step] 从 start 提取到 end - 1 ，每 step 个字符提取一个
与之前一样，偏移量从左至右从 0、1 开始，依次增加；从右至左从 -1、-2 开始，依次减
小。如果省略 start ，分片会默认使用偏移量 0(开头)；如果省略 end ，分片会默认使用
偏移量 -1(结尾)。
>>>letters'abcdefghijklmnopqrstuvwxyz'
>>>letters[:]'abcdefghijklmnopqrstuvwxyz'
>>> letters[20:]'uvwxyz'
>>> letters[10:20]'klmnopqrst'
>>> letters[-3:]'xyz'
>>> letters[18:-3]'stuvw'
>>> letters[-6:-2]'uvwx'
>>> letters[::7]'ahov'
>>> letters[4:20:3]'ehknqt'
>>> letters[19::4]'tx'
>>> letters[:21:6]'agms'
>>> letters[-1::-1]'zyxwvutsrqponmlkjihgfedcba'
>>> letters[::-1]'zyxwvutsrqponmlkjihgfedcba'
>>> letters[-100:]'abcdefghijklmnopqrstuvwxyz'
2.3.8 使用 len() 获得长度
>>>len(letters)26
>>> empty = ''
>>>len(empty)
0
2.3.9 使用 split() 分割
与广义函数 len() 不同，有些函数只适用于字符串类型。为了调用字符串函数，你需要输
入字符串的名称、一个点号，接着是需要调用的函数名，以及需要传入的参数： string.
function(arguments)
>>> todos = 'get gloves,get mask,give cat vitamins,call ambulance'
>>> todos.split(',')
['get gloves', 'get mask', 'give cat vitamins', 'call ambulance']
如果不指定分隔符，那么 split() 将默认使用空白字符——换行符、空格、制表符。>>>todos.split()
['get', 'gloves,get', 'mask,give', 'cat', 'vitamins,call', 'ambulance']
2.3.10 使用 join() 合并
可能你已经猜到了， join() 函数与 split() 函数正好相反：它将包含若干子串的列表分
解，并将这些子串合成一个完整的大的字符串。 join() 的调用顺序看起来有点别扭，与
split() 相反，你需要首先指定粘合用的字符串，然后再指定需要合并的列表： string.
join(list) 。因此，为了将列表 lines 中的多个子串合并成完整的字符串，我们应该使用语
句： '\n'.join(lines) 。
>>> crypto_list = ['Yeti', 'Bigfoot', 'Loch Ness Monster']>>> ','.join(crypto_list)'Yeti,Bigfoot,Loch Ness Monster'
2.3.11 熟悉字符串
>>> poem = '''All that doth flow we cannot liquid name
Or else would fire and water be the same;
But that is liquid which is moist and wet
Fire that property can never get.
Then 'tis not cold that doth the fire put out
But 'tis the wet that makes it die, no doubt.'''
>>> poem[:13]'All that doth'
这首诗有多少个字符呢？(计入空格和换行符。)
>>>len(poem)251
这首诗是不是以 All 开头呢？
>>> poem.startswith('All')
True
这首诗是不是以 no doubt. 结尾呢？>>> poem.endswith('no doubt.')
True
接下来，查一查诗中第一次出现单词 the 的位置(偏移量)
>>> word = 'the'
>>> poem.find(word)
73
以及最后一次出现 the 的偏移量 :
>>> poem.rfind(word)
215
the 在这首诗中出现了多少次？
>>> poem.count(word)
3
诗中出现的所有字符都是字母或数字吗？
>>> poem.isalnum()
False
2.3.12 大小写与对齐方式
>>> setup = 'a duck goes into a bar...'
将字符串收尾的 . 都删除掉：
>>> setup.strip('.')'a duck goes into a bar'
>>>
让字符串首字母变成大写：
>>>setup.capitalize()'A duck goes into a bar...'
让所有单词的开头字母变成大写
>>>setup.title()'A Duck Goes Into A Bar...'
让所有字母都变成大写
>>>setup.upper()'A DUCK GOES INTO A BAR...'
将所有字母转换成小写：
>>>setup.lower()'a duck goes into a bar...'
将所有字母的大小写转换：
>>>setup.swapcase()'A DUCK GOES INTO A BAR...'
在 30 个字符位居中：
>>> setup.center(30)'a duck goes into a bar...'
左对齐
>>> setup.ljust(30)'a duck goes into a bar...'
右对齐：
>>> setup.rjust(30)'a duck goes into a bar...'
2.3.13 使用 replace() 替换
使用 replace() 函数可以进行简单的子串替换。你需要传入的参数包括：需要被替换的子
串，用于替换的新子串，以及需要替换多少处。最后一个参数如果省略则默认只替换第一次出现的位置：
>>> setup.replace('duck', 'marmoset')'a marmoset goes into a bar...'
>>>setup'a duck goes into a bar...'
修改最多 100 处：
>>> setup.replace('a', 'a famous', 100)'a famous duck goes into a famous ba famous r...'
#python字符串函数用法大全 https://blog.csdn.net/qq_40678222/article/details/83032178#1.0%C2%A0%20capitalize()%E5%87%BD%E6%95%B0
'''1.0 capitalize()函数
2.0 title()函数
3.0 swapcase()函数
4.0 lower()函数
5.0 upper()函数
6.0 casefold()函数
7.0 center()函数
8.0 ljust()函数
9.0 rjust()函数
10.0 zfill()函数
11.0 count()函数
12.0 encode()函数
13.0 decode()函数
14.0 expandtabs()函数
15.0 find()函数
16.0 rfind()函数
17.0 index()函数
18.0 rindex()函数
19.0 format()函数
20.0 format_map()函数
21.0 endswith()函数
22.0 startswith()函数
23.0 isalnum()函数
24.0 isalpha()函数
25.0 isdecimal()函数
26.0 isdigit()函数
27.0 isidentifier()函数
28.0 islower()函数
29.0 isupper()函数
30.0 isnumeric()函数
31.0 isprintable()函数
32.0 isspace()函数
33.0 istitle()函数
34.0 strip()函数
35.0 lstrip()函数
36. rstrip()函数
37.0 maketrans()函数
38.0 translate()函数
39.0 partition()函数
40.0 rpartition()函数
41.0 split()函数
42.0 rsplit()函数
43.0 splitlines()函数
44.0 join()函数
45.0 replace()函数
'''
扫一扫
3485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
