一、python基本数据类型

python基本数据类型有：数字类型Number、字符串类型String、布尔类型Boolean、空值类型None、列表类型List、元组类型Tuple、字典类型Dictionary、集合类型Set。

• 布尔类型：True和False
• 空值类型：python中特殊的值，用None表示。空值并不是意味着它的值为0。
• python中的序列（sequence）包括字符串、列表、元组。
  不同序列的区别：列表可修改，元组和字符串不可修改；
  序列中的每个元素都有编号，即位置或索引；
  序列的公共操作包括：索引、切片、相加、相乘、成员资格检查、计算长度、获取最大值和最小值；

二、字符串

字符串是以单引号或双引号括起来的任意文本；
字符串是不可变的。
创建一个空字符串：str_name = ""

1. 字符串的创建

1.1. 字符串内容中不包含有单引号或双引号

创建字符串时可使用单引号或双引号直接括起内容，执行结果一样

s = "Hello, World!"
s = 'Hello, World!'
print(s)  # 结果：Hello, World!

1.2. 字符串内容中含有单引号

（1）创建字符串时，若使用单引号括起内容，则内容中含有单引号的字段需用反斜杠（\）进行转义；否则会出现字符串结束语判断异常错误；
（2）创建字符串时，若使用双引号括起内容，则无需对内容中的单引号转义即可直接使用；

s = "This's is a string!"
s = 'This\'s is a string!'
print(s)  # 结果：This's is a string!

1.3. 字符串内容中含有双引号

（1）创建字符串时，若使用双引号括起内容，则内容中含有双引号的字段需用反斜杠（\）进行转义；否则会出现字符串结束语判断异常错误；
（2）创建字符串时，若使用单引号括起内容，则无需对内容中的双引号转义即可直接使用；

s = "she said:\"Hello\""
s = 'she said:"Hello"'
print(s)    # 结果：she said:"Hello"

1.4. 创建一个长字符串

（1）对于长字符串，可使用三个引号（单引号或双引号）将字符串括起（若字符串本身中包含有单引号或双引号，则无需使用反斜杠进行转义）；
（2）多行显示的长字符串，若在行尾加上反斜杠（\），则反斜杠和换行符将被转义，不会进行换行操作，表示将上下行连接；若在行尾不加上反斜杠（\），则会进行换行操作；

s1 = '''111
      222'''
s2 = '''111\n222'''          # s1类似于s2，会换行
s3 = '''111\    
      222'''                # s3仅表示上下行连接，不会执行换行操作

1.5. 原始字符串

原始字符串用前缀 r 表示，以使原始字符串中包含任何字符；
若字符串中包含有特殊字符，若不使用r，则就需要对特殊字符进行转义才可输出所需结果；若不想转义，则需使用前缀r；

"""原始字符串"""
s1 = r'C:\name'
s2 = 'C:\\name'      # s1类似于s2，输出的是C盘name下的地址
s3 = 'C:\name'       # s3由于未添加原始字符和转义字符，字符串中会执行换行操作\n 

1.6. 字符串格式化

（1）最简单的方法：使用百分号运算符（%）来设置字符串格式，%左边指定一个格式字符串，%右边指定要设置其格式的值（可使用单个值，如字符串或数字；也使用元组来设置多个值）。

字符串常用的格式化符号：
%s：格式化字符串
%d：格式化整数
%f：格式化浮点数，默认是精确到小数点后6位，%.2f表示精确到小数点后2位且会四舍五入
%c：格式化字符
%e或%E：科学计数法格式化浮点数
%u：格式化无符号整型
%o：格式化无符号八进制数
%x或%X：格式化无符号十六进制数

format = "Hello, %s! Today is so %s."
values = ("Jenny", "Hot")
s1 = format % values
s2 = "Hello, %s! Today is so %s." % ("Jenny", "Hot")    # s1类似于s2
print(s1)   # 结果： Hello, Jenny! Today is so Hot.

（2）使用字符串方法format()传递字符串值，每个需替换的字段用花括号{}括起。花括号中的内容可以是空，也可以是索引值，也可以是名称

• format中替换的字段没有名称：
  字符串需替换的字段{}中无内容时，则代表将format的内容按顺序传递到字符串中；
  字符串中需替换的字段{}中内容为索引时，则代表将format中对应的索引值传递到字符串对应替换位置；
• format中替换的字段有名称：
  通过在字符串需替换的字段{}中添加对应的名称的方式来替换字符

format()方法格式化数字时特殊格式
{:.2f}：表示仅两位小数点，数字跟随保留的小数点位数而变化且会执行四舍五入操作，若不保留小数点则数字为0
{:.2e}：表示保留两位小数点的指数，数字2可变
{:.2%}：表示保留两位小数点的百分比，数字2可变
{:,}：表示以常规的逗号分隔数字，如10,222,222
{:x>5d}：表示用x补充数字，使用其宽度为5，>为左填充，数字5和填充物x可变。print("{:*>5d}".format(2))输出为****2
{:x<5d}：表示用x补充数字，使用其宽度为5，<为右填充，数字5和填充物x可变。print("{:*<5d}".format(2))输出为2****
{:5d}：表示右对齐，宽度为5，数字可变
{:<5d}：表示左对齐，宽度为5，数字可变
{:^5d}：表示居中对齐，宽度为5，数字可变
{:b}：二进制数，若想输出结果时前加格式0b，则格式化为{:#b}
{:d}：十进制数
{:o}：八进制数，若想输出结果时前加格式0o，则格式化为{:#o}
{:x}：十六进制数，若想输出结果时前加格式0x，则格式化为{:#x}

s2 = "{}, {} and {}".format("first", "second", "third")
print(s2)       # 结果：first, second and third
s3 = "{2}, {1} {0} and {0}".format("first", "second", "third")
print(s3)       # 结果：third, second first and first
from math import pi
s4 = "{name} is {value}.".format(value=pi, name="pai")
print(s4)        # 结果：pai is 3.141592653589793.
s5 = "{name} is {value:.2f}.".format(value=pi, name="pai")
print(s5)       # 结果：pai is 3.14.
s5 = f"pai is {pi}."  # 替换的字段与变量同名，通过在字符串前面加f的方式传递值
print(s5)       # 结果：pai is 3.141592653589793.

2. 强制转化为字符串

• print()函数：输出时它会省去引号并打印；
• str()函数：将值转化为字符串，若本身已是字符串，加与不加str效果一样；
• repr()函数：将值原样转化为字符串，即在原值的基础上使用引号括起来，保留值原来的样子；

# 不带转义字符的字符串
print("Hello, World")          # Hello, World
print(str("Hello, World"))     # Hello, World
print(repr("Hello, World"))    # 'Hello, World'
# 带转义字符的字符串  
print("Hello, \nWorld")            # 遇到\n时会换行
print(str("Hello, \nWorld"))       # 遇到\n时会换行
print(repr("Hello, \nWorld"))      # 将字符串整体输出，即'Hello, \nWorld'
# 将列表转化为字符串
temp= [1, 2, 3]
s1 = repr(temp)
s2 = str(temp)
print(temp, type(temp))    # [1, 2, 3] <class 'list'>
print(s1, type(s1))        # [1, 2, 3] <class 'str'>
print(s2, type(s2))        # [1, 2, 3] <class 'str'>

3. 字符串的操作

3.1. 返回字符串的长度

• len(str)

print(len(""))              # 空的字符串，长度为0
print(len(" "))             # 字符串的空格也算长度，1
print(len("aaa bbb"))       # 7

3.2. 获取字符串中的字符

• str[索引]：索引用于获取元素的下标
  当索引从左向右开始取值时，字符串的索引范围为[0, len(str)-1]，[0]指向第一个元素；
  当索引从右向左开始取值时，字符串的索引范围为[-1, -len(str)]，[-1]为最后一个元素。

s = "hello world"
print(s[1])             # e
print(s[-1])            # d

3.3. 字符串的切片

• str[index1: index2]
  切片slicing用来访问特定范围内的元素，索引之间用冒号分隔。
  切片内容包括第一个索引index1，不包括第二个索引index2。
  index2的位置需位于index1的位置之后，否则获取的结果为空。
• str[index1: index2: 步长]
  切片中添加有步长，默认为1。步长表示从索引1到索引2所提取的元素之间的间隔。步长不能为0，可为负数，负数表示从右向左提取元素。

s = "hello world"
print(s[6:11])          # world
print(s[6:11:2])        # wrd
print(s[-1:-9:-2])      # drwo

3.4. 字符串的相加

• str1 + str2：两个字符串连接组成新的字符串

3.5. 字符串的相乘

• str * n：输出n个重复的字符串

s1 = "hello"
s2 = "123"
# 相加
s3 = s1 + s2
print(s3)       # hello123
# 相乘
s4 = s1 * 3
print(s4)       # hellohellohello

3.6. 字符串的成员判断

• sub in str：判断字符串str中是否包含有字符串sub，若是返回True，否则返回False。
• sub not in str：判断字符串str中是否不包含有字符串sub，若是返回True，否则返回False。

print("e" in "hello")       # True
print("llo" in "hello")      # True
print("a" in "hello")      # False
print("a" not in "hello")      # True

3.7. 字符串的比较

两个字符串比较大小：从第一个字符开始比较，哪个的ASCII值大哪个字符串大；第一个字符相等时，再比较下一个字符的ASCII值，依次类推。

• max(str1, str2, ...)：获取字符串的最大值
  若仅有一个字符串，则是字符串中的字符进行对比，获取的是该字符串中最大的字符；
  若有多个字符串，则是字符串之间进行对比，获取的是最大的字符串。
• min(str1, str2, ...)：获取字符串的最小值
  若仅有一个字符串，则是字符串中的字符进行对比，获取的是该字符串中最小的字符；
  若有多个字符串，则是字符串之间进行对比，获取的是最小的字符串。

print("amb" < "bam")    # True
print("am" > "abb")    # True
print("amb" > "am")    # True
print(max("abcdefg"))   # g
print(min("abcdefg"))   # a
print(max("abc", "aac", "bca"))     # bca
print(min("abc", "aac", "bca"))     # aac

4. 字符串的基本函数

4.1. 连接序列中的元素成为新的字符串

• str.join(iterable)：通过str来将序列的元素连接为新的字符串
  iterable：序列，但注意序列中的元素必须为字符串

4.2. 分隔字符串

• str.split([sep, maxsplit])：以sep为分隔符，将字符串str拆分为序列
  sep：分隔符，若未指定分隔符，则默认在空白字符、空格、制表符、换行符之间进行拆分；
  maxsplit：最大分隔次数，默认为-1表示分隔所有；

# join连接列表成新的字符串
list1 = ['1', '2', '3', '4', '5']
s = '+'
print(s.join(list1))    # 结果： 1+2+3+4+5
d = 'data', 'local', 'tmp'
print('\\'.join(d))     # 结果： data\local\tmp
# split分隔字符串
s = "A B C D E"
print(s.split(" "))         # 结果：['A', 'B', 'C', 'D', 'E']
print(s.split())            # 结果：['A', 'B', 'C', 'D', 'E']
print(s.split("C"))         # 结果：['A B ', ' D E']

4.3. 删除字符串中内容

• str.strip([chars])：删除字符串中的chars内容，并返回删除后的结果
  chars：删除的字符串内容，非必需参数。
  不添加chars时，则代表仅删除字符串开头和结尾的空格（但不包括中间的空格）；也可添加指定需删除的字符，但并非可删除任意的字符，需从头或从尾逐步添加删除的值。
• str.lstrip([chars])：删除字符串左侧指定的字符，并返回删除后的结果，默认为空格
• str.rstrip([chars])：删除字符串右侧指定的字符，并返回删除后的结果，默认为空格

# strip删除字符串中指定字符
s = "    hello   world!   "
print(s.strip(), "*")           # 结果：hello   world! *
print(s.strip(" !d"))           # 结果：hello   worl
# lstrip删除字符串中左侧字符
print(s.lstrip(), "*")          # 结果：hello   world!    *
# rstrip删除字符串中右侧字符
print(s.rstrip())               # 结果：    hello   world!

4.4. 字符串居中、左对齐、右对齐

• str.center(width[, fillchar=None])：返回一个指定宽度width的居中字符串，通过在字符串两边添加填充字符让字符串居中
  width：字符串的长度+填充字符的长度
  fillchar：填充的字符，默认为空格
• str.ljust(width[, fillchar])：返回一个指定宽度的左对齐字符串
• str.rjust(width[, fillchar])：返回一个指定宽度的右对齐字符串
• str.zfill(width)：返回一个指定宽度的字符串，原字符串右对齐，前面补0

# center字符串居中
s = "Hello, World!"
print(s.center(20))         # 结果：   Hello, World!
print(s.center(20, "*"))    # 结果：***Hello, World!****
# ljust字符串左对齐
print(s.ljust(20, "*"))     # 结果：Hello, World!*******
# rjust字符串右对齐
print(s.rjust(20, "*"))     # 结果:*******Hello, World!
# zfill字符串右对齐,0补齐
print(s.zfill(20))          # 结果:0000000Hello, World!

4.5. 字符串中查找子字符串

• str.find(sub[, start[, end]])：在某个范围中，字符串str从左向右查找子字符串sub，默认从头到尾。
  若找到，则返回从左向右第一次出现子字符串的第一个字符的索引；否则返回-1。
  sub：子字符串；start：范围的起始位置；end：范围的结束位置
• str.rfind(sub[, start[, end]])：在某个范围中，字符串str从右向左查找子字符串sub，默认从头到尾。
  若找到，则返回从右向左第一次出现子字符串的第一个字符的索引；否则返回-1。
• str.index(sub[, start, end])：子字符串sub存在时与str.find()方法一样，区别是子字符串sub不存在时会报错ValueError: substring not found。
• str.rindex(sub[, start, end])：子字符串sub存在时与str.rfind()方法一样，区别是子字符串sub不存在时会报错ValueError: substring not found。

4.6. 字符串中子字符串出现的次数

• str.count(sub[, start, end])：返回字符串str在某个范围中子字符串sub出现的次数，默认从头到尾
  sub：子字符串；start：范围的起始位置；end：范围的结束位置

s = "The package name is com.android.settings. please tell me the package and activity!"
# 查找子字符串
print(s.find("package"))    # 结果： 4
print(s.rfind("package"))   # 结果: 61
print(s.index("package"))   # 结果： 4
print(s.rindex("package"))  # 结果： 61
# 计算子字符串个数
print(s.count("package"))   # 结果：2

4.7. 替换字符串

• str.replace(old, new[, count])：将字符串中子字符串old替换成新的子字符串new
• str.translate(table)：将字符串的单字符进行替换，可同时替换多个字符。
  使用translate前需创建一个转换表，可使用字符串的调用方法str.maketrans来创建转换表，maketrans的前两个必选参数长度必须相同，表示将第一个字符串中的每个字符均替换成第二个字符串中对应的字符，第三个可选参数为需删除的字符。

# replace
s = "Hello, Jimmy!"
print(s.replace('Jimmy', 'Tom'))    # 结果： Hello, Tom!
# translate（将字符串中c和s分别替换成k和z）
s = "This is an cup."
table = str.maketrans('cs', 'kz')
print(s.translate(table))               # 结果：Thiz iz an kup.
table1 = str.maketrans('cs', 'kz', ' ')
print(s.translate(table1))              # 结果：Thizizankup.

4.8. 字符串大小写转换

• str.lower()：将字符串全部小写；
• str.title()：将字符串转化为词首大写，其他字母小写；
• str.upper()：将字符串全部大写；
• str.swapcase()：将字符串中小写字母大写，大写字母小写；

4.9. 字符串判断方法

判断字符串是否满足特定的条件，若满足返回True，若不满足返回False

• str.isalnum()：检测字符串是否由字母或数字组成；
• str.isalpha()：检测字符串是否只由字母组成；
• str.isdigit()： 检测字符串是否只由数字组成；
• str.islower()：检测字符串是否由小写字母组成；
• str.isspace() ：检测字符串是否只由空格组成；
• str.istitle() ：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写；
• str.isupper() ：检测字符串中所有的字母是否都为大写；
• str.isnumeric() ：检测字符串是否只由数字组成，只针对unicode对象（定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀）；

# lower， title， upper
s = "Hello, WORLD!"
print(s.lower())        # 结果： hello, world!
print(s.title())        # 结果： Hello, World!
print(s.upper())        # 结果： HELLO, WORLD!
print(s.swapcase())     # 结果:  hELLO, world!
# 判断字符串是否满足特定的条件
s = "Hello"
print(s.islower(), s.isalnum(), s.isalpha(), s.isdecimal())     # 结果： False True True False

三、列表

列表list是一种有序的集合，列表是可变的。

• 创建列表：列表名 = [列表选项1, 列表选项2, ...]
  列表中的元素数据可以是不同的类型（支持数字、字符串和嵌套列表）
  用[ ]标识，元素之间用逗号分隔；

1. 列表操作

1.1. 返回列表的长度

• len(list)

1.2. 访问列表

• 访问列表元素：列表名[下标]
  下标不要超过列表的范围
  从左向右访问列表时，下标的范围是0 ~ len(列表名)-1
  从右向左访问列表时，下标的范围是-1 ~ -len(列表名)

1.3. 列表切片

• list[index1: index2]
  切片slicing用来访问特定范围内的元素，索引之间用冒号分隔。
  切片内容包括第一个索引index1，不包括第二个索引index2。
  index2的位置需位于index1的位置之后，否则获取的结果为空。
  index2为空，则表示取值从index1的位置到尾；
  index1为空，则表示取值从头到index2的位置；
• list[index1: index2: 步长]
  切片中添加有步长，默认为1。
  步长表示从索引1到索引2所提取的元素之间的间隔。步长不能为0，可为负数，负数表示从右向左提取元素。

1.4. 修改列表的值

• 列表名[下标] = 新值
  通过赋值的方式修改列表对应下标的值
• 列表名[下标1: 下标2] = 新值
  修改列表下标1到下标2的位置的值

1.5. 合并列表

• list1 + list2：两个列表合并组成新的列表

1.6. 列表的相乘

• list * n：输出n个重复的列表

1.7. 多维列表

多维列表：列表中嵌套多个列表。

1.8. 列表最大值和最小值

• max(list)：获取列表中的最大值
• min(list)：获取列表中的最小值

# 创建一个空列表
list1 = []
# 创建一个含多数据类型的列表
list2 = [1, "sub", 33]
list3 = [1, 2, [3, 4]]
# 列表的长度
print(len(list2))       # 3
# 访问列表的某个值
print(list2[1])     # sub
print(list2[-1])    # 33
# 切片
print(list2[1:])    # ['sub', 'aaa']
print(list2[:])     # [1, 'sub', 'aaa']
print(list2[:2])    # [1, 'sub']
print(list2[1:2])   # ['sub']
print(list2[::2])   # [1, 'aaa']
# 替换列表值
print(list2)        # [1, 'sub', 33]
list2[2] = "aaa"
print(list2)        # [1, 'sub', 'aaa']
list2[2:] = ['c', 'd', 'e']
print(list2)        # [1, 'sub', 'c', 'd', 'e']
list2[3:] = []      # 替换一个空切片，即相当于删除
print(list2)        # [1, 'sub', 'c']
# 合并列表
list4 = list2 + list3
print(list4)        # [1, 'sub', 'aaa', 1, 2, [3, 4]]
# 重复列表
list5 = list2 * 3
print(list5)        # [1, 'sub', 'aaa', 1, 'sub', 'aaa', 1, 'sub', 'aaa']
# 二维列表
list6 = [[1, 2, 3], [4, 5, 6]]
print(list6[1][0])  # 4
# 列表中的最大值和最小值
print(max([1, 2, 3, 2]))    # 3
print(min([1, 2, 3, 2]))    # 1

2. 列表基本函数

2.1. 列表后追加1个或多个元素

• list.append(object)：在列表的末尾追加新的元素
  object：元素对象
• list.extend(iterable)：在列表的末尾一次追加另一个序列的多个值
  iterable：可迭代的对象（字符串、列表、元组、集合），注意不可以是数字（数字不是可迭代的对象）

# 列表后追加一个元素
list7 = [1, 2, 3, 4, 5]
list7.append(6)
list7.append("123")
list7.append([8, 9])
list7.append((10, 11))
print(list7)    # [1, 2, 3, 4, 5, 6, '123', [8, 9], (10, 11)]
# 列表后同时追加多个元素
list8 = [1, 2, 3, 4, 5]
list8.extend([6, 7, 8])
list8.extend((9, 10))
list8.extend("1234")
list8.extend({"a", "b"})
print(list8)    # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, '1', '2', '3', '4', 'a', 'b']

2.2. 列表中插入一个元素

• list.insert(index, object)：在下标index处添加一个元素，不覆盖原数据，原数据向后顺延
  index：添加元素的下标
  object：元素对象

list9 = [1, 2, 3]
list9.insert(1, 5)
list9.insert(1, ['a', 'b'])
print(list9)    # [1, ['a', 'b'], 5, 2, 3]

2.3. 删除列表中元素

• list.pop(index=None)：移除列表中指定下标index处的元素，同时返回删除的数据。
  默认删除移除最后一个元素
• list.remove(value)：移除列表中第一个匹配的元素value
• list.clear()：移动列表中所有元素

# 删除列表中某个位置的元素
list10 = ['a', 'b', 'c', 'b', 'b']
print(list10.pop())     # b
list10.pop(1)
print(list10)           # ['a', 'c', 'b']
# 移除列表中第一个指定元素
list11 = ['a', 'b', 'c', 'b', 'b']
list11.remove('b')
print(list11)           # ['a', 'c', 'b', 'b']
# 移除列表中所有元素
list11.clear()
print(list11)           # []

2.4. 查找元素

• list.index(value[, start=None, stop=None])：
  查找列表中指定范围内的第一个匹配的元素value的索引值
  value：查找的元素
  start和stop：查找的起始范围，默认是从头到尾

list12 = ['a', 'b', 'c', 'b', 'b']
print(list12.index('b'))    # 1
print(list12.index('b', 2, 10))     # 3

2.4. 查看元素出现的次数

• list.count(value)：
  查看元素value在列表中出现的次数

list13 = ['a', 'b', 'c', 'b', 'b']
e_counts = list13.count('b')    # 3
for i in range(0, e_counts):
    list13.remove('b')
print(list13)       # ['a', 'c']

2.5. 列表倒序

按相反的顺序排列列表中的元素

• list.reverse()：列表倒序，但不返回任何值
• reversed(object)：将对象倒序，返回值是一个对象
  若想获得倒序后的列表，则需使用list强制转化输出

list14 = [1, 2, 4, 3, 7, 2]
# 第一种倒序方法:reverse()
list14.reverse()
print(list14)       # [2, 7, 3, 4, 2, 1]
# 第二种倒序方法:reversed()
list14_1 = list(reversed(list14))
print(list14_1)     # [1, 2, 4, 3, 7, 2]

2.6. 列表排序

• list.sort(key=None, reverse=False)：对列表就地排序，但不返回任何值
• sorted(iterable, key, reverse)：对列表排序，同时将排序结果返回
  iterable：可迭代的序列
  key：列表排序的参照（如，key=len表示通过元素长度排序）
  reverse：True表示按相反的顺序排序；
  不添加key和reverse参数，使用sort()或sorted()，默认为按名称排序（升序）。

list15 = [1, 2, 4, 3, 7, 2]
list15.sort()       # 默认为升序
print(list15)       # [1, 2, 2, 3, 4, 7]
list15_1 = sorted(list15)
print(list15_1)     # [1, 2, 2, 3, 4, 7]
# 高级排序
list16 = ['heel', 'aaaaa', 'bb', 'heea']
list16.sort(key=len)
print(list16)           # ['bb', 'heel', 'heea', 'aaaaa']
list16.sort(reverse=True)
print(list16)           # ['heel', 'heea', 'bb', 'aaaaa']

2.7. 拷贝

• 浅拷贝：常规的通过赋值方式复制列表，则只是将另一个名称关联到列表，一旦更改其中一个列表内容，则另一列表也会跟随变化。【赋值的方式，两个变量的地址一样】
• 深拷贝：通过copy复制列表，则对一个列表操作另一列表互不干扰。【通过copy方式，两个变量的地址不一样】

list17 = [1, 2, 3]
# 浅拷贝
list18 = list17
list17[1] = 5
print(list17, list18)           # [1, 5, 3] [1, 5, 3]
print(id(list17), id(list18))   # 变量的地址是一样的
# 深拷贝
list19 = list17.copy()
list17[1] = 6
print(list17, list19)           # [1, 6, 3] [1, 5, 3]
print(id(list17), id(list19))   # 变量的地址不一样