Python私房菜——筑基篇（已完结）

1 Python私房菜【一】——（前置基础）

大白可直接跳转到：Python私房菜——高级篇

1.1 编码

就是把人类语言（文字）通过编码的形式一一映射成计算机认识的语言（二进制：0101…），即 将人类语言 通过某种形式 转换成计算机认识的二进制数。这种编码形式是人为定义的，因此就有多种不同的编码方式。
在不同编码表中，规定了每个字符在表中的唯一位置，这个位置称之为码点，如 “A” 在ASCII表中的位置【码点】是 65；因此，所谓编码，就是将 码点 按照一定规则转换成 字节串（一个字节表示8位二进制数），写法上，通常将每个字节的8位二进制数转成2位十六进制数，每个字节用 “\x” 隔开

1.1.1 ASCII码

是早期的编码方式之一，规定了大小写英文字母、数字及其他一些符号或字符与二进制数的映射关系，起初只定义了128个可映射的字符，即 1个字符可用7个二进制位表示（0000000 ~ 1111111 共128个），视为标准版ASCII。后来随之扩展，又引入了额外的128个字符或符号，这样一来，就使得ASCII码的映射范围扩大到了256个字符（2⁸个），即1个字符可用8个二进制位（00000000 ~ 11111111）表示，视为扩展版ASCII。

1.1.2 Unicode码

是继ASCII码后的另一种编码方式，又称万国码，因其可表示世界上各国的各语言而得名，且向下兼容了标准版ASCII码。起初它只是一个抽象概念，后面随之时间推移，推出了如UTF-8、UTF-16等具体的编码方案。
【1】UTF-8
是可变长的编码方式，可变长指的是根据不同文字对应不同位数（长度为8的倍数）的编码，在存储空间上可存放1或2或3或4个字节（1个字节=8个二进制位），总的来说，一个字符可用8 * 1 到 8 * 4 位二进制数表示，有效压缩了存储空间。
【2】UTF-16
也是一种可变长的编码方式，一个字符可用8 * 2 到 8 * 4 位二进制数表示。
【3】 UTF-32
是固定长度的编码方式，无论什么字符都是用32位二进制数进行存储，使得空间上造成浪费

• 注：中文占3个字节的长度 UTF-8使用较为广泛

1.1.3 其他

还有诸如像 GBK / GB2312 的编码形式，其存储的是中文字符，也包含其他亚洲国家的文字且中文占2个字节。
编码规则 ：
ASCII码，就是将0~255个码点 转换成8位二进制数 进行编码 ——
"A"，码点是 65 ，转换规则是`将码点转换成8位二进制数，即 01000001，通常写成 0x41，或者可直接表示为 b'A'；
UTF-8，对于码点0-127（即 在标准版ASCII中的码点），编码结果与之相同，而在标准版ASCII外的码点，具体规则如下 ——

Unicode符号范围        | UTF-8编码方式
(十六进制)             | （二进制）
----------------------+---------------------------------------------
0000 0000 - 0000 007F | 0xxxxxxx
0000 0080 - 0000 07FF | 110xxxxx 10xxxxxx
0000 0800 - 0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000 - 0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

其中，x表示需要补的码点的二进制数，从最低位（最右边）开始依次填充最右边的字节到第一个字节，每个字节填充满8位二进制数 ——
"我" 码点是 25105(十进制) --> 110001000010001(二进制) --> 0000 6211(十六进制) 在上述范围第三行中 因此需要占3个字节，则从二进制数中取后6位数补齐到第三个字节 即 10 010001；再依次取出6位二进制数补齐到第二个字节 即 10 001000；最后取出剩下的4位补齐到第一个字节 ，不足4位的补0，即 1110 0110；因此，最终编码为 11100110 10001000 10010001，转成字节串：b'\xe6\x88\x91'

1.2 数据类型

1.2.1 数字类型（number）

又可细分为 整数型（int）和 浮点型（float）。
int型诸如 -1，-2,1，2，…形式的数字；
float型诸如 -1.0,2.0，…形式的数字。

1.2.2 字符串类型（str）

是一串文字，且是用一对英文引号“包起来”的文字。诸如 “aa”，‘bb’，“”“cc”“”,…的形式（引号包括单引号、双引号及三引号）

1.2.3 布尔类型（boolean）

是真假值，该类型只有 true 或 false 两个值，多用于判断语句。
对于其他数据类型，其中，0、0.0、None、“”、“0”、“false”，也表示布尔值false。

1.2.4 列表（list）

存放多个不同数据的容器，诸如 [1, “2”, false, “ok”] 的形式。
即 通过 [] 可定义一个 list 类型的容器，容器存放的数据称之为元素。

• 特点 ：有序 、可变、可重复。
  • 有序：即可以通过下标（索引）获取列表中的元素 诸如 li = [1, 2, 3] 那么 li[0] 则意味着可以获取li列表的第一个元素1；
  • 可变：即可以通过 增删改 等方法 操作列表或列表中的元素；
  • 可重复：即列表中的元素不是唯一的，而是可以重复存放的，诸如 li = [1, 1, 2, 3, 3]
• 空列表的定义：

   li = [] 
   li = list()
  

1.2.5 元组（tuple）

通过 () 定义的容器，也是可以存放不同类型的数据。诸如 (1, 2, “a”)。

• 特点：有序、不可变、可重复。
  • 有序：即可以通过下标（索引）获取元组中的元素 诸如 tu = (1, 2, 3) 那么 tu[0] 则意味着可以获取tu元组中的第一个元素1；
  • 不可变：意味着 不能通过 增删改 等方法去操作元组中的元素；
  • 可重复：即元组中的元素不是唯一的。
• 空元组的定义：

  tu = ()
  tu = tuple()
  

• 元组中只有一个元素的定义形式：

  tu = (1,)
  

注：根据 元组 不可变 的特性，可将其 作为 字典的 key。

1.2.6 集合（set）

通过 {} 定义的容器，也是可以存放不同类型的数据。诸如{1, 2, “a”}。

• 特点：无序、可变、不可重复。
  • 无序：意味着不能通过 下标 获取对应位置的元素；
  • 可变：意味着可以通过 增删改 等方法 操作集合中的元素；
  • 不可重复：意味着该容器的元素是唯一的。若出现多个相同元素，则只会保留一个。
• 空集合的定义：

  s = set()
  

• 注：根据集合 不可变 的特性，可利用其特性对列表或元组中的元素进行去重

  li = [1, 1, 2, 3, 4, 4]
  li = list( set( li ) )
  

1.2.7 字典（dict）

形如 {“a”: 1, “b”: “哈哈”} ，通过{}“包起来的”，里面的元素形式以键值对的方式式定义的容器。

• 特点：无序、可变、key不可重复。
  • 无序：意味着不能通过 下标 获取对应位置的元素；
  • 可变：意味着可以通过 增删改 等方法 操作字典中的元素；
  • key不可重复：意味着该容器的键（key）是唯一的。
• 空字典的定义：

  d = {
       }
  d = dict()
  

1.2.8 NoneType

是 None 这个值对应的数据类型

1.2.9 自定义类

除了内置的数据类型，还可以通过class关键字自行定义其他类型，如

class 类名:

	类属性 = 类属性值
	
	def __init__(self):
		pass
		
	def 实例方法名(self,参数列表):
		pass

1.3 运算符

1.3.1 算术运算符

诸如 ：+ 加、 - 减、 *乘、 /除、 //整除、 %取余
【1】+

• 通常用作数值间的加法操作，但需要注意以下几种情况：
  • int + float ：可以相加且值是float型，但是有可能会出现精度丢失的情况（浮点数底层转换成二进制数导致的）；
  • int + boolean ：可以相加且值是int型，其中boolean的true或false在底层实际上就是转换成1或0 ；
  • float + boolean ：可以相加但同样也可能出现精度丢失的情况；
  • str + str ：可以相加，字符串的拼接，且str若是和其他数据类型进行 + 操作，会报错；
  • list + list ：可以相加，列表的合并；
  • tuple + tuple ：可以相加，元组的合并；
  • set + set ：不能相加，若需合并，可采用 set | set 的形式；
  • dict + dict ：不能相加。

【2】*

• 通常用作数值间的乘法操作，但需要注意以下几种情况：
  • int * str ：可以相乘，表示int个str拼接在一起；
  • int * list、int * tuple ：可以相乘，表示int个list或int个tuple进行合并；
  • float * str ：不能相乘。

【3】/

• 通常用作int类型或float类型间的除法操作，但需要注意以下几种情况：
  • int / int ，结果值是float

【4】//

• 通常用作int类型或float类型间的整除操作，但需要注意以下几种情况：
  • int // int ，结果会向下取整；
  • int // float ，结果向下取整后会转换成float型

1.3.2 逻辑运算符

【1】and 逻辑与
相当于Java中的短路与，通常用于条件判断语句。
用法：表达式1 and 表达式2 and 表达式3 and…
若有一个表达式的值为false，则该表达式后面的表达式不再运算，直接返回该表达式的值；
若所有表达式都为true，则返回最后一个表达式的值。
【2】or 逻辑或
相当于Java中的短路或，通常用于条件判断语句。
用法：表达式1 or 表达式2 or 表达式3 or…
若有一个表达式的值为true，则该表达式后面的表达式不再运算，直接返回该表达式的值；
若所有表达式都为false，则返回最后一个表达式的值。
【3】not 取反
相当于Java中的 ! 操作符，通常用于条件判断语句。
**用法：not 表达式 **
当表达式的值为true 则该结果为false；反之为true

1.3.3 同一运算符

【1】is
判断两个值是否为同一个，比较的是地址，通常用于条件判断语句。
is 与 == 的区别：
is 比较的是地址，==比较的是值；但在比较数值类型以及字符串类型是否相同时，一般还是采用 == 进行比较。
【2】is not
判断两个值是否不是同一个，比较的是地址，通常用于条件判断语句。

1.3.4 成员关系运算符

【1】in
判断某个元素 / 值是否在某个容器中，这个容器可以是 字符串、列表、元组、集合、字典。
【2】not in
判断某个元素 / 值是否不在某个容器中。

注：对于字典而言，判断某个元素 / 值是否在字典中，是对 key 进行判断。

2 Python私房菜【二】——（字符串内置方法）

下面为大家介绍一些常见的字符串内置方法，首先需要定义几个变量方便后续调用相关方法的使用

str1 = "abc"
str2 = "ABC"
str3 = "aBcd"
str4 = "hello world"
str5 = "hello world. hello world."
str6 = "123"
str7 = "123abc"
str8 = "你！是！我的神！"
str9 = " "
str10 = "\n"
str11 = "\t"
str12 = """锄禾日当午
汗滴禾下土
谁知盘中餐
粒粒皆辛苦"""

为方便讲解，假设以下方法调用后的变量值，只针对当前讲解的方法时生效；讲解结束后以上变量值仍恢复为以上定义的值

【1】upper()
针对于英文字母，将小写字母转换为大写字母；且该方法会返回一个新的字符串

str1 = str1.upper()
print(str1)  # ABC

【2】lower()
针对于英文字母，将大写字母转换为小写字母；且该方法会返回一个新的字符串

str2 = str2.lower()
print(str2)  # abc

【3】swapcase()
针对于英文字母，将大小写字母互相转换；且该方法会返回一个新的字符串

str3 = str3.swapcase()
print(str3)  # AbCD

【4】title()
针对于英文语句，将每个单词的首字母变大写，其余字母变为小写；且该方法会返回一个新的字符串

str4 = str4.title()
print(str4)  # Hello World

【5】capitalize()
针对于英文语句，将该字符串的首个单词的首字母变大写，其余字母变为小写；且该方法会返回一个新的字符串

str5 = str5.capitalize()
print(str5)  # Hello world. hello world.

【6】isupper()
针对于英文字母，判断字符串中每个字符是否为小写字母；会返回一个布尔值，常用在判断语句

print(str2.isupper())  # true

【7】islower()
针对于英文字母，判断字符串中每个字符是否为大写字母；会返回一个布尔值，常用在判断语句

print(str1.islower())  # true

【8】istitle()
针对于英文语句，判断字符串中的每个单词的首字母是否为大写字母；会返回一个布尔值，常用在判断语句

print(str4.istitle())  # false

【9】isspace()
判断字符串是否为 " " 或 “\n” 或 “\t”；会返回一个布尔值，常用在判断语句

print(str9.isspace())  # true
print(str10.isspace())  # true
print(str11.isspace())  # true

【10】isalpha()
判断字符串是否为字母或文字【不包含数字及特殊字符】；会返回一个布尔值，常用在判断语句

print(str6.isalpha())  # false
print(str7.isalpha())  # false
print(str1.isalpha())  # true

【11】isdigit()
判断字符串中的每个字符是否都是数字；会返回一个布尔值，常用在判断语句

print(str6.isdigit())  # true
print(str7.isdigit())  # false

【12】isdecimal()
判断字符串中的每个字符是否都是数字；会返回一个布尔值，常用在判断语句

print(str6.isdecimal())  # true
print(str7.isdecimal())  # false

区别：isdecimal() 方法与 isdigit() 类似，但 isdecimal() 更为严格，它只接受 ASCII 的十进制字符，而 isdigit() 还接受其他数字字符（Unicode编码里的数字字符），如罗马数字。

【13】isalnum()
判断字符串是否只包含数字或字母（不包含特殊符号）

print(str7.isalnum())  # true
print(str8.isalnum())  # false

【14】isprintable()
判断字符串是否为可打印的（换行符、制表符不可打印）；会返回一个布尔值，常用在判断语句

print(str9.isprintable())	# true
print(str10.isprintable())	# false
print(str11.isprintable())	# false

【15】startswith(参数列表)
判断字符串是否以指定字符串开头；会返回一个布尔值，常用在判断语句

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行判断
若加上可选参数2，则会从参数2的位置开始判断
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行判断
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.startswith("hel"))	# true
print(str4.startswith("hello", 0))	# true
print(str4.startswith("hell", 1, 5))	# false

【16】endswith(参数列表)
判断字符串是否以指定字符串结尾；会返回一个布尔值，常用在判断语句

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行判断
若加上可选参数2，则会从参数2的位置开始判断
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行判断
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.endswith("d"))	# true
print(str4.endswith("ld", 0))	# true
print(str4.endswith("hell", 1, 5))	# false

【17】count(参数列表)
返回 指定字符串 在字符串中 出现的次数；查找到指定字符串返回出现的次数，没有查找到则返回 0

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.count("h"))	# 1
print(str4.count("l", 0))	# 3
print(str4.count("hell", 1, 5))	# 0

【18】find(参数列表)
返回 指定字符串 在字符串中 的下标值（从左往右第一个被查找到的位置）；若查找不到该指定字符串，则返回 -1

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.find("h"))	# 0
print(str4.find("l", 0))	# 1
print(str4.find("hell", 1, 5))	# -1

【19】rfind(参数列表)
返回 指定字符串 在字符串中 的下标值（从右往左第一个被查找到的位置）；若查找不到该指定字符串，则返回 -1

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.rfind("h"))	# 0
print(str4.rfind("l", 0))	# 9
print(str4.rfind("hell", 1, 5))	# -1

【20】index(参数列表)
返回 指定字符串 在字符串中 的下标值（从左往右第一个被查找到的位置）；若查找不到该指定字符串，则报错

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.index("h"))	# 0
print(str4.index("l", 0))	# 1
print(str4.index("hell", 1, 5))	# 报错！！！！

【21】rindex(参数列表)
返回 指定字符串 在字符串中 的下标值（从右往左第一个被查找到的位置）；若查找不到该指定字符串，则返回 报错

"""
参数列表：
	参数1：指定字符串
	可选参数2：起始位置，下标值
	可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.rfind("h"))	# 0
print(str4.rfind("l", 0))	# 9
print(str4.rfind("hell", 1, 5))	# 报错！！！！

【22】center(参数列表)
以指定长度对字符串进行填充，并让字符串居中显示；返回一个新字符串

"""
参数列表：
	参数1：指定长度
	可选参数2：指定字符串
若 指定字符串的长度 小于 原有字符串的长度 则还是返回原有字符串
若不填写 指定字符串 则默认以 空格 进行填充
"""
print