Python基础入门自学——2

字符串类型

字符串类型变量的定义，使用单引号和双引号进行定义，单引号和双引号定义没有区别。字符串类型是一种非常重要的类型。

在Python中字符串是一个常量，不可修改，可以看成是一个字符序列的元组。可以使用切片进行操作：

重复输出字符串，使用乘法:

\

判断一个字符串是否在另一个字符串中存在，可以使用in关键字，in是用来在指定的序列中查找，找到值返回 True，否则返回 False

字符串的格式化输出前面讲过，即使用%

字符串的拼接，一种是使用加号“+”，但是这种方法效率非常低，一般使用字符串的方法.join（）。

str.capitalize()，返回原字符串的副本，其首个字符大写，其余为小写。
str.casefold()，返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。
str.center(width[, fillchar])，返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。
str.count(sub[, start[, end]])，反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
str.encode(encoding="utf-8", errors="strict")，返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过 codecs.register_error() 注册的值。

str.endswith(suffix[, start[, end]]) ，如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

str.expandtabs(tabsize=8)，返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。


str.find(sub[, start[, end]]),返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，使用 in 操作符。
str.format(*args, **kwargs) ，执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。

{0:3},代表替换的索引，即位置，3表示长度，如果长度小于3，在前面填空格。

str.format_map(mapping)，类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况。

 

str.index(sub[, start[, end]])，类似于 find()，但在找不到子类时会引发 ValueError。

tr.isalnum()，如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符``c``是字母或数字。
str.isalpha() ，如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。字母字符是指那些在 Unicode 字符数据库中定义为 "Letter" 的字符，即那些具有 "Lm"、"Lt"、"Lu"、"Ll" 或 "Lo" 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的"字母"属性不同。
str.isascii() ，如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。
str.isdecimal() ，如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。 严格地讲，十进制字符是 Unicode 通用类别 "Nd" 中的一个字符。
str.isdigit() ，如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成十进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

str.isidentifier() ，如果字符串是有效的标识符，返回 True ，依据语言定义， 标识符和关键字 节。
调用 keyword.iskeyword() 来检测字符串 s 是否为保留标识符，例如 def 和 class。

str.islower()，如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回 True ，否则返回 False 。

str.isnumeric() ，如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
str.isprintable() ，如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。 不可打印字符是在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）。
str.isspace() ，如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。空白 字符是指在 Unicode 字符数据库 (参见 unicodedata) 中主要类别为 Zs ("Separator, space") 或所属双向类为 WS, B 或 S 的字符。
str.istitle() ，如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。
str.isupper() ，如果字符串中至少有一个区分大小写的字符且此类字符均为大写则返回 True ，否则返回 False 。

str.ljust(width[, fillchar]) ，返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
str.lower() ，返回原字符串的副本，其所有区分大小写的字符均转换为小写。

str.lstrip([chars]) ，返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

注意第二种用法，带参数的，就是移除前导字符为参数值的所有组合，这里www是符合comwz中w的一种组合。符合一种组合，将前导符合的字符移除，然后接着重复这个过程，直到字符串的最左边不含有前导字符的所有组合为止，后面的不在处理范围。
static str.maketrans(x[, y[, z]])，此静态方法返回一个可供 str.translate() 使用的转换对照表。如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。

str.partition(sep) ，在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

str.replace(old, new[, count]) ，返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
str.rfind(sub[, start[, end]]) ，返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。str.rindex(sub[, start[, end]]) ，类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
str.rjust(width[, fillchar])，返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
str.rpartition(sep)，在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
str.rsplit(sep=None, maxsplit=-1)，返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。
str.rstrip([chars]) ，返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合

这里要注意的是rsplit的参数None和' '空格的区别。

str.split(sep=None, maxsplit=-1)，返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。

str.splitlines([keepends]) ，返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。个人感觉这是一个很重要的方法。
不同于 split()，当给出了分隔字符串 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增加额外的行。

表示符	描述
\n	换行
\r	回车
\r\n	回车 + 换行
\v 或 \x0b	行制表符
\f 或 \x0c	换表单
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行 (C1 控制码)
\u2028	行分隔符
\u2029	段分隔符

 

 

 

 

 

 

 

 

 

 

 

作为行结束符，回车换行作为一个的话必须是\r\n，而不能是\n\r。

关于回车和换行：
1. 由来
在计算机还没有出现之前，有一种叫做电传打字机（Teletype Model 33）的机械打字机，每秒钟可以打10个字符。但是它有一个问题，就是打完一行换行的时候，要用去0.2秒，正好可以打两个字符。要是在这0.2秒里面，又有新的字符传过来，那么这个字符将丢失。于是，研制人员想了个办法解决这个问题，就是在每行后面加两个表示结束的字符。一个叫做“回车”，告诉打字机把打印头定位在左边界，不卷动滚筒；另一个叫做“换行”，告诉打字机把滚筒卷一格，不改变水平位置。这就是“换行”和“回车”的由来。
2. 使用
后来，计算机发明了，这两个概念也就被般到了计算机上。那时，存储器很贵，一些科学家认为在每行结尾加两个字符太浪费了，加一个就可以。于是，就出现了分歧。
回车 \r 本义是光标重新回到本行开头，r的英文return，控制字符可以写成CR，即Carriage Return
换行 \n 本义是光标往下一行（不一定到下一行行首），n的英文newline，控制字符可以写成LF，即Line Feed。或是NL（NewLine）

符号    ASCII码      意义
\n        10        换行NL
\r        13        回车CR

在不同的操作系统这几个字符表现不同，比如在WIN系统下，这两个字符就是表现的本义，在UNIX类系统，换行\n就表现为光标下一行并回到行首，在MAC上，\r就表现为回到本行开头并往下一行，至于ENTER键的定义是与操作系统有关的。通常用的Enter是两个加起来。

不同操作系统下的含义：
\n:  UNIX 系统行末结束符
\r\n: window 系统行末结束符
\r:  MAC OS 系统行末结束符

我们经常遇到的一个问题就是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号。

str.startswith(prefix[, start[, end]])，如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
str.strip([chars])，返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合。最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。

str.swapcase()，返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
str.title()，返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果。
str.translate(table)，返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。
str.upper()，返回原字符串的副本，其中所有区分大小写的字符均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
str.zfill(width)，返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。

数据类型汇总：

Python中，现在已经学到了如下的数据类型：整数型、浮点型、字符串、布尔型、空值（即None，这是一个特殊的类型），列表list[]，元组tuple()，字典{}，集合set{}，这是系统规定的常用的类型，是内置类型，另外还有各种具体对象类型。那是外置类型

其实前面说的那些常用类型，也是属于对象类型。

还有集中内置类型：复数类型complex——3+4j形式，range类型，产生一个序列，还有bytes, bytearray, memoryview，是字节形式各种序列，迭代器类型。

对数据类型的分类：

frozenset是不可变的集合类型，set可变。还有一个很重要的迭代器类型。

前面没太接触的有range类型：

range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。
class range(stop)
class range(start, stop[, step]) 
range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）。 如果省略 step 参数，其默认值为 1。 如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。
如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。
如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.
如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。
元素绝对值大于 sys.maxsize 的 range 对象是被允许的，但某些特性 (例如 len()) 可能引发 OverflowError。

range 对象实现了一般序列的所有操作，但拼接和重复除外（这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式）。
主要操作如下表：
 

运算	结果：	注释
x in s	如果 s 中的某项等于 x 则结果为 True，否则为 False	(1)
x not in s	如果 s 中的某项等于 x 则结果为 False，否则为 True	(1)
s + t	s 与 t 相拼接	(6)(7)
s * n 或 n * s	相当于 s 与自身进行 n 次拼接	(2)(7)
s[i]	s 的第 i 项，起始为 0	(3)
s[i:j]	s 从 i 到 j 的切片	(3)(4)
s[i:j:k]	s 从 i 到 j 步长为 k 的切片	(3)(5)
len(s)	s 的长度
min(s)	s 的最小项
max(s)	s 的最大项
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）	(8)
s.count(x)	x 在 s 中出现的总次数

参数说明：
start：start 形参的值 (如果该形参未提供则为 0)
stop：stop 形参的值
step：step 形参的值 (如果该形参未提供则为 1)
range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值）。
range 对象实现了 collections.abc.Sequence ABC，提供如包含检测、元素索引查找、切片等特性，并支持负索引 :

使用 == 和 != 检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认为它们是相等的。 （请注意比较结果相等的两个 range 对象可能会具有不同的 start, stop 和 step 属性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2)。）

迭代器类型：
Python 支持在容器中进行迭代的概念。 通过使用两个单独方法来实现的；它们被用于允许用户自定义类对迭代的支持。 序列总是支持迭代方法。

容器对象要提供迭代支持，必须定义一个方法:
container.__iter__()：返回一个迭代器对象。 该对象需要支持迭代器协议。 如果容器支持不同的迭代类型，则可以提供额外的方法来专门地请求不同迭代类型的迭代器。 （支持多种迭代形式的对象的例子有同时支持广度优先和深度优先遍历的树结构。）

迭代器对象自身需要支持以下两个方法，它们共同组成了 迭代器协议:

iterator.__iter__()：返回迭代器对象本身。 这是同时允许容器和迭代器配合 for 和 in 语句使用所必须的。 此方法对应于 Python/C API 中 Python 对象类型结构体的 tp_iter 槽位。
iterator.__next__()：从容器中返回下一项。 如果已经没有项可返回，则会引发 StopIteration 异常。 此方法对应于 Python/C API 中 Python 对象类型结构体的 tp_iternext 槽位。

Python 定义了几种迭代器对象以支持对一般和特定序列类型、字典和其他更特别的形式进行迭代。 除了迭代器协议的实现，特定类型的其他性质对迭代操作来说都不重要。

一旦迭代器的 __next__() 方法引发了 StopIteration，它必须一直对后续调用引发同样的异常。 不遵循此行为特性的实现将无法正常使用。

生成器类型：
Python 的 generator 提供了一种实现迭代器协议的便捷方式。 如果容器对象 __iter__() 方法被实现为一个生成器，它将自动返回一个迭代器对象（从技术上说是一个生成器对象），该对象提供 __iter__() 和 __next__() 方法。 

很晦涩难懂的说明，看实际操作：

iter（obj）方法就是返回一个迭代器对象，参数是是和生成迭代器的对象，如序列。这里的iter（）是否就是容器的__iter__()方法呢？不管是不是，他都生成了一个迭代器对象。

生成的迭代器对象都要至少有两个方法，就是__iter__()和__next__()，这里要注意，这里的__iter__()是迭代器对象的方法，而不是上面说的容器的方法，这里是没有参数的，返回自身。

可以看到，__iter__()返回的就是自身。再看__next__()方法，他是依次返回序列中的每一个元素。没有元素可取时，返回StopIteration异常。

实际上，就是在iter迭代器对象中有一个指针指示器，一开始指在开始位置，每次调用__next__()，指针加1，且指针只能前进，即只能一直加，不能往回走，即不能减。

对于变量的赋值，有值语义和指针（或引用）语义，python中是指针语义，即赋给变量的是对象的指针，而不是对象的内容，而C语言中是值语义，传递的是内容。

上面是python的测试，s一开始被赋值为C，它的地址是38688688，修改他的值为G，地址变了，为40173104，在定义一个变量x=‘X'，其地址为39920688，将x值赋给s，即s = x，s的地址变为x的地址了。实际的过程是先生成一个对象，然后将此对象的地址传给变量。变量保存的都是对象的地址。变量之间的赋值，也是将一个变量所保存的对象的地址赋给了另一个变量。

而象C语言是传值的：

一开始s和x的地址不同，值不同，修改s的值，结果其地址没有改变，值变化了，这就是传值。将变量x赋给s，s的地址不变，内容改变，传递还是值，而不是地址。

实际上，对于C语言，变量名只对编译系统有意义，在实际的可运行二进制代码中是没有变量名的，都是内存的地址。定义一个变量，就是开辟一块内存，所要赋的值就保存在这块内存中。所以C需要提前定义变量类型，就是确定内存的大小。

Python是先生成要赋值的对象，然后取生成对象的地址赋给变量名，每赋一个新值，就生成一个对象，原来的对象如果没有被其他变量引用，就应该尽可能快的销毁，以释放内存；Python的变量都是保存对象的地址，所以不需要提前定义变量的类型（实际上都是地址类型）。