常量（Constant）
数据总是以数字、字母、字符等方式描述，在计算机中将那些不变的数据称为常量。常量是不可被修改的。
以下类似于C语言语法。
- 整数字面量（Integer）
100十进制字面量，无前缀0b100二进制字面量，前缀0b0o100八进制字面量，前缀0o0x100十六进制字面量，前缀0x
- 浮点字面量（Float）
1.1，小数形式1.5e2，指数形式
- 复数字面量（Complex）
1.5j + 1，j为虚数符号（不是i），通过属性imag、real可以分别输出虚部和实部。x = 1.5j + 1 print(x, type(x), x.imag, x.real) # (1+1.5j) <class 'complex'> 1.5 1.0
- 字符串字面量（String）
'Hello World!'、"Hello World!"，Python 中单引号'和双引号"等效。print('Hello World!') print("Hello World!") print('''Hello World!''') print("""Hello World!""") print("""Hello! Hi! I'm fine.""")- 单引号中如果需要显示单引号，需转义
\，双引号同理。 - 三引号可以多行输出。
- 在地址中常包含分隔符
\，r'C:\User\Destop'或'C:\\User\\Destop'可以消除转义。
- 布尔字面量（Boolean）
True、False，True 为1，False 为0。
- 空字面量（None）
None，表示空，属于NoneType 类型
不同于C语言的是， Python 没有常变量的概念，严格来说，Python 中没有有名字的不变量（即定义的常量依旧可以修改而不会报错）。Python 中只有字面量（没有名字的不变量）。
变量（Variable）
Python属于弱类型语言，即定义变量时无需声明数据类型，运行时才会确定。
定义格式为 变量名 = 初值。相比C语言要简约许多。变量名取法需符合标识符规则，以及遵守命名规范，这与C语言保持一致。
Python 允许多变量同时赋值。
a = b = c = 1 # 多变量赋相同值，从右至左
print(a, b, c) # 1 1 1
e, f = 'a', 100 # 多变量赋不同值
print(e, f) # a 100
数据类型（11种）
虽然Python定义变量时无需考虑数据类型，但并不代表没有数据类型，常见的共11种。
整型（int）
属于不可变类型。
a = 1
浮点型（float）
属于不可变类型。
a = 3.14
复数型（complex）
属于不可变类型。
a = 4 + 3j
b = complex(5, 2) # 5 + 2j
此处j视为虚数单位，i在 Python 中不视为虚数。
布尔型（bool）
bool类型是int类型的子类，属于不可变类型。
a = True
b = False
在参与运算时，True自动转换为1，False自动转换为0。
注意：True、False必须首字母大写，属于关键字。
空类型（NoneType）
NoneType类型的实例为None，它是一个单例对象，即只能创建一个None实例，它们指向同一个地址。
- 在Python中，
None是一个对象，表示空的含义，且具有唯一地址。 - 在C语言中，
NULL是0的符号常量，表示空指针的宏，指向0X00000000。该地址为保留地址，不可用。 - 在Java中，
null是一种特殊的值，可以赋值给任何引用类型，表示未知对象。
空类型判断
使用is、is not运算符。
a = None
print(a is None) # True
None对应的布尔值为False，因此在条件判断时不必显式写出。
a = None
if a:
print("a is not None")
else:
print("a is None")
与之类似的还有：
[]空列表{}空字典()空元组""空字符串
字符串（str）
字符串是 Python 中常用的数据类型，一般由单引号'、双引号"或三引号"""、'''包裹。需要注意的是：不同于C，Python 不支持单字符类型，单字符在 Python 中也被视作字符串类型。
name = "abcdef"
print(type(name[1])) # <class 'str'>
字符串类型是不可变类型，因此没有相应的增加或删除方法，修改字符串会返回一个新的字符串，原字符串并不改变。
创建字符串
Python 创建字符串非常简单，只要为变量分配一个值即可。
var1 = 'Hello World'
var2 = "Python"
可以创建一个空字符串。
str1 = "" # 创建空字符串
str2 = '' # 创建空字符串
str3 = str() # 创建空字符串
巧妙利用乘号*的复制特性，快速创建字符串。适用于字符串、列表、元组。
str4 = "-"*5 # -----
str5 = "a"*3 # aaa
字符串切片
切片是指对某个序列对象截取其中一部分进行操作。在 Matlab 中也有类似的切片操作。
其语法描述为
序列名[起始下标：结束下标：步长]
其中：
- 各参数均可为正负整数
- 截取片段从起始下标开始，但不包含结束下标的对应元素
- 步长可缺省，默认为1
- 负步长代表逆序，负下标代表倒数第n个元素
- 对于正序而言，起始下标应小于结束下标。逆序则反之
- 当选取方向和步长方向冲突，则无法选取数据
name = "abcdefgh"
print(name[1:5:1]) # bcde, 不包含name[5]
print(name[1:5]) # bcde, 步长为1时可缺省
print(name[:5]) # abcde, 默认从头开始截取
print(name[2:]) # cdefgh, 默认至结尾截取
print(name[:]) # abcdefgh, 默认从头至尾截取
print(name[::-1]) # hgfedcba, 倒序，从尾至头截取
print(name[-2:-1]) # g, 从倒数第2个元素至倒数第1个元素截取
print(name[2:1]) # 无输出，不能选取数据
字符串判断
判断字符串的组成，并返回True、Flase。
成员运算符in、not in可以用于判断字符串中是否包含指定字符。
name = "abcdef"
print("bc" in name) # True
print("h" in name) # False
print("ba" not in name) # True
除此之外，一些函数也可以实现字符串的判断。
startswith方法：检查某个子串是否为这个字符串的开头，返回True、Flase。类似地，endswith方法检查某个子串是否为这个字符串的结尾。-
基本语法
字符串.startswith(子串，起始下标，结束下标)
字符串.endswith(子串，起始下标，结束下标)其中，起始下标和结束下标指的是字符串的检查范围，缺省则从头开始检查。
-
示例
name = "abcd" print(name.startswith("a")) # True print(name.startswith("b",1,10)) # True，限制检查范围 print(name.endswith("d")) # True
-
isalpha方法：检查字符串是否只包含字母，返回True、Flase。类似地，isdigit方法检查字符串是否只包含数字。isalnum方法检查字符串是否只包含数字、字母或它们的组合。-
基本语法
字符串.isalpha(）
字符串.isdigit()
字符串.isalnum() -
示例
name1 = "abcd" name2 = "1234" name3 = "1234abc" print(name1.isalpha()) # True print(name2.isdigit()) # True print(name3.isalnum()) # True
-
isspace方法：检查字符串是否只包含空白字符，返回True、Flase。空白字符包含'\n'、'\t'、'\r'、\v、'\f'、' '。共6个，与C标准一致。-
基本语法
字符串.isspace(）
-
示例
print('\n'.isspace()) # True print('\r'.isspace()) # True print('\f'.isspace()) # True print('\v'.isspace()) # True print('\t'.isspace()) # True print(' '.isspace()) # True print("\n \t \v \r".isspace()) # True
-
字符串查找
通过len方法可以测量字符串长度。
var1 = 'Hello World'
print(len(var1)) # 11
对于指定字符或字符串，如何找到它在总字符串中的位置和重复次数。
-
find方法：检查某个子串是否包含在这个字符串中，返回左侧第一次出现时的起始下标，否则返回 -1-
基本语法
字符串.find(子串，起始下标，结束下标)
其中，起始下标和结束下标指的是字符串的搜索范围，缺省则全部搜索。
-
示例
name = "abcdefgh abcdefgh" print(name.find("bc")) # 1，仅返回第一次出现的起始下标 print(name.find("c",1,10)) # 2，限制搜索区间 print(name.find("B")) #-1，区分大小写
-
-
index方法：与find方法用法基本一致，唯一的区别是当字符串中不包含子串时，index会直接报错。-
基本语法
字符串.index(子串，起始下标，结束下标)
-
示例
name = "abcdefgh abcdefgh" print(name.index("bc")) # 1，仅返回第一次出现的起始下标 print(name.index("c",1,10)) # 2，限制搜索区间 print(name.index("B")) # error，区分大小写
-
-
count方法：检查某个子串在这个字符串中的重复次数。-
基本语法
字符串.count(子串，起始下标，结束下标)
-
示例
name = "abcdefgh abcdefgh" print(name.count("c")) # 2, 一共重复2次 print(name.count("c",1,10)) # 1, 同样可以指定区间 print(name.count("C")) # 0, 重复次数为0
-
-
rfind、rindex方法：用法与find、index方法一致，但查找方向是从右开始，因此返回的也是右侧第一次出现的起始坐标（子串左侧第一个下标）。
字符串修改
这里的修改一般包含合并、分割、替换、大小写转换等方面。
-
字符串的拼接通过拼接符
+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。- 示例
a = "你好" + "中国！" b = "我今年" + str(18) + "岁啦！" # 字符串与整型的拼接
- 示例
-
replace方法：替换字符串中的指定子串。返回新字符串，原有字符串不变。-
基本语法
newStr = oldStr.replace(旧子串，新子串，替换次数)
旧子串指需要被替换的字符串。新子串指替换成的字符串。替换次数指需要进行几次替换，当替换次数大于旧子串总重复次数，代表全部替换。
-
示例
oldStr = "ababab" newStr1 = oldStr.replace("a","2") newStr2 = oldStr.replace("a","2",1) print(newStr1) # 2b2b2b, 全部替换 print(newStr2) # 2babab, 仅替换了一次
-
-
split方法：按指定子串分割字符串。返回分割后字符串列表，原有字符串不变。-
基本语法
listStr = oldStr.split(指定子串，分割次数)
指定子串指用于分割的字符串标志。分割次数指需要进行几次分割，当分割次数大于字符串中指定子串的总重复次数，代表完全分割。返回列表长度为分割次数+1。
-
示例
oldStr = "1,2,3" listStr1 = oldStr.split(",") listStr2 = oldStr.split(",", 1) print(listStr1 ) # ['1', '2', '3'] print(listStr2 ) # ['1', '2,3']
-
-
join方法：将多个字符串按指定子串合并成一个字符串。返回合并后新字符串，原有字符串序列不变。-
基本语法
listStr = joinStr.join(字符串序列)
joinStr指用于合并的各字符串间的子串。字符串序列指多个字符串形成的序列。listStr指合并后的新字符串。 -
示例
joinStr = ['l','o','v','e'] listStr3 = '-'.join(joinStr) print(listStr3) # l-o-v-e
-
-
strip方法：删除字符串两侧的空白字符。返回新字符串。类似地，lstrip方法只删除左侧的空白字符；rstrip方法只删除右侧的空白字符。-
基本语法
newStr = oldStr.strip()
newStr = oldStr.lstrip()
newStr = oldStr.rstrip() -
示例
name = "\n\t\r a b c d " str1 = name.strip() # 去除两侧空白字符 str2 = name.lstrip() # 去除左侧空白字符 str3 = name.rstrip() # 去除右侧空白字符
-
-
center方法：使字符串居中对齐，并用指定字符填充至指定长度。返回新字符串。类似地，ljust使字符串左对齐，rjust使字符串右对齐。-
基本语法
newStr = oldStr.center(length, character)
newStr = oldStr.ljust(length, character)
newStr = oldStr.rjust(length, character)length指新字符串目标长度。character指填充字符，默认为空格。 -
示例
name = "abcd" str1 = name.center(10,'.') str2 = name.ljust(10) str3 = name.rjust(10, '*') print(str1) # ...abcd... print(str2) # abcd print(str3) # ******abcd
-
-
capitalize方法：将字符串的第一个字母转为大写，其他字母全部转为小写。返回新字符串。-
基本语法
newStr = oldStr.capitalize()
-
示例
name1 = "abcd" name2 = "ABCD" name3 = "?ABCD" str1 = name1.capitalize() str2 = name2.capitalize() str3 = name3.capitalize() print(str1) # Abcd print(str2) # Abcd print(str3) # ?abcd，第一个字符不是字母，无法转换
-
-
title方法：将字符串的每个单词首字母转为大写，其他字母全部转为小写。返回新字符串。-
基本语法
newStr = oldStr.title()
-
示例
name1 = "my name is john" name2 = "MY NAME IS JOHN" str1 = name1.title() str2 = name2.title() print(str1) # My Name Is John print(str2) # My Name Is John
-
-
lower方法：将字符串的每个字母大写转小写。返回新字符串。-
基本语法
newStr = oldStr.lower()
-
示例
name1 = "My name is John" name2 = "MY NAME IS JOHN" str1 = name1.lower() str2 = name2.lower() print(str1) # my name is john print(str2) # my name is john
-
-
upper方法：将字符串的每个字母小写转大写。返回新字符串。-
基本语法
newStr = oldStr.upper()
-
示例
name1 = "My name is John" name2 = "My Name Is JOHN" str1 = name1.upper() str2 = name2.upper() print(str1) # MY NAME IS JOHN print(str2) # MY NAME IS JOHN
-
字节型（bytes）
bytes类型表示的是不可变的二进制序列（byte sequence），与字符串类似，但元素是整数（0 ~ 255）。通常用于处理二进制数据，比如图像文件、音频文件、视频文件或网络通信中的字节流。
字节型属于不可变类型。 具有和字符串类似的操作，不再赘述。
创建字节对象
使用前缀b。限制输入为ASCII字符。
byte = b"hello" # b'hello'
也可以使用bytes函数。编码方式默认使用 UTF-8 编码。
x = bytes("hello", encoding = "utf-8")
编码与解码
通过decode方法可以将一个字节对象按指定编码方式解码。返回一个字符串对象。
byte = b'hello'
str1 = byte.decode(encoding='utf-8')
print(str1) # hello
同样，可以通过encode方法将一个字符串对象按指定编码方式编码。返回一个字节对象。
str1 = "hello"
byte = str1.encode(encoding = 'utf-8')
print(byte) # b'hello'
列表（list）
类似于C语言中的数组概念，可以一次性存储多个数据。但不同的是列表可以接受不同数据类型的数据，这比数组更加灵活。但实际工作中，我们更推荐一个列表中存储相同类型的数据，方便统一管理。
列表类型是可变类型，因此可以动态增加或删除列表中的数据，列表长度也会随之变化。
创建列表
列表由中括号[]包裹。
list1 = ['Tom', 'Potter', 'John']
也可以创建空列表。
list2 = [] # 创建空列表
list3 = list() # 创建空列表
巧妙利用乘号*的复制特性，快速创建列表。适用于字符串、列表、元组。
list4 = [1]*5 # [1, 1, 1, 1, 1]
list5 = ["a", "b"]*3 # ['a', 'b', 'a', 'b', 'a', 'b']
对于需要借助循环生成的规律列表，可以使用列表生成式，优美简洁。类似的还有字典生成式、元组生成式和集合生成式。
list1 = [i**2 for i in range(5)]
print(list1) # [0, 1, 4, 9, 16]
list2 = [i**2 for i in range(5) if i % 2 == 0] # 可以加判断
print(list2) # [0, 4, 16]
列表切片
列表与字符串、元组同属于序列（Sequence），都有切片操作。
name = [1, 2, 3, 4, 5]
print(name[1:5:1]) # [2, 3, 4, 5], 不包含name[5]
print(name[1:5]) # [2, 3, 4, 5], 步长为1时可缺省
print(name[:5]) # [1, 2, 3, 4, 5], 默认从头开始截取
print(name[2:]) # [3, 4, 5], 默认至结尾截取
print(name[:]) # [1, 2, 3, 4, 5], 默认从头至尾截取
print(name[::-1]) # [5, 4, 3, 2, 1], 倒序，从尾至头截取
print(name[-2:-1]) # [4], 从倒数第2个元素至倒数第1个元素截取
print(name[2:1]) # [], 空列表，不能选取数据
列表查找
通过len方法可以测量列表长度。它是一个公共方法。
nameList = ['Potter', 'LiLy', 'Ronan']
print(len(nameList )) # 3
如果已知数据在列表中的位置，可以直接按索引查找。
nameList = ['Potter', 'LiLy', 'Ronan']
print(nameList[1]) # LiLy
如果未知数据在列表中的位置，则需要借助函数按值查找。
-
index方法：与在字符串中用法一致。-
基本语法
列表.index(数据，起始下标，结束下标)
-
示例
nameList = ['Potter', 'LiLy', 'Ronan', 'Potter'] print(nameList.index("Potter")) # 0，仅返回第一次出现的起始下标 print(nameList.index("LiLy",1,2)) # 1，限制搜索区间 print(nameList.index("Hurry")) # error，不存在该数据
-
-
count方法：检查某个数据在这个列表中的重复次数。与在字符串中用法稍异，无法指定搜索区间。-
基本语法
列表.count(数据)
-
示例
nameList = ['Potter', 'LiLy', 'Ronan', 'Potter'] print(nameList .count("P")) # 0, 重复次数为0 print(nameList .count("Ronan")) # 1, 重复次数为1 print(nameList .count("Potter")) # 2, 重复次数为2
-
列表判断
类似地，通过成员运算符in、not in也可以用于判断列表中是否包含指定数据。
nameList = ['Potter', 'LiLy', 'Ronan', 'Potter']
print("LiLy" in nameList ) # True
print("potter" in nameList ) # False
print("Hurry" not in nameList ) # True
利用公共方法max、min可以得到列表中的最大值和最小值，对于字符串、元组等序列也适用。
list1 = [1,2,3]
str1 = "123abc456"
tuple1 = (1,2,3)
set1 = {
1,2,5,3}
dict1 = {
"name":2, "123":1,"gender":0}
print(f'最大{
max(tuple1)}, 最小{
min(tuple1)}') # 最大3, 最小1
print(f'最大{
max(list1)}, 最小{
min(list1)}') # 最大3, 最小1
print(f'最大{
max(str1)}, 最小{
min(str1)}') # 最大c, 最小1
print(f'最大{
max(set1)}, 最小{
min(set1)}') # 最大5, 最小1
print(f'最大{
max(dict1)}, 最小{
min(dict1)}') # 最大name, 最小123
需要注意的是，字典比较的是键，而不是值。
列表修改
这里的修改一般包含合并、更改、增加、删除、复制、去重、排序等方面。
-
通过拼接符
+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。print([1, 2] + [3, 4]) # [1, 2, 3, 4] -
对列表数据的更改可以通过重新赋值实现。
nameList = ['Potter', 'LiLy', 'Ronan', 'Potter'] nameList[0] = "Hurry" print(nameList) # ['Hurry', 'LiLy', 'Ronan', 'Potter'] -
append方法，向已有列表末尾追加新数据。-
基本语法
列表.append(数据)
-
示例
nameList = ['Potter', 'LiLy', 'Ronan', 'Potter'] nameList.append("Hurry") print(nameList) # ['Potter', 'LiLy', 'Ronan', 'Potter', 'Hurry']
-
-
extend方法，向已有列表末尾追加新数据。且当追加数据为序列时，拆开逐一追加。这与append方法不同。-
基本语法
列表.extend(数据)
-
示例
nameList = ['Potter'] nameList.append("Tom") print(nameList) # ['Potter', 'Tom']，append整体追加 nameList.extend("Tom") print(nameList) # ['Potter', 'Tom', 'T', 'o', 'm']，extend拆开追加 nameList.extend(["Hurry", "Ronan"]) print(nameList) # ['Potter', 'Tom', 'T', 'o', 'm', 'Hurry', 'Ronan']
-
-
insert方法，向已有列表指定位置追加新数据。-
基本语法
列表.insert(索引，数据)
-
示例
nameList = ['Potter','Tom'] nameList.insert(1, "Hurry") print(nameList) # ['Potter', 'Hurry', 'Tom']
-
-
del方法，删除已有列表中的指定数据，或删除整个列表。注意这里的数据应写成列表下标形式，直接写数据本身会报错。-
基本语法
del(列表[i])
del 列表[i] -
示例
nameList = ['Potter','Tom'] del nameList[0] print(nameList) # ['Tom'] del(nameList[0]) print(nameList) # [] del nameList print(nameList) # NameError: name 'nameList' is not defined
-
-
pop方法，弹出已有列表中指定位置的数据。缺省则弹出列表末尾数据。返回该数据。-
基本语法
delData = 列表.pop(索引)
-
示例
nameList = ['Potter', 'LiLy', 'Ronan'] nameDel = nameList.pop() print(nameDel) # Ronan nameDel = nameList.pop(0) print(nameDel) # Potter
-
-
remove方法，删除已有列表中的指定数据。-
基本语法
列表.remove(数据)
-
示例
nameList = ['Potter', 'LiLy', 'Ronan'] nameList.remove('LiLy') print(nameList) # ['Potter', 'Ronan']
-
-
clear方法，删除已有列表中的所有数据。-
基本语法
列表.clear()
-
示例
nameList = ['Potter', 'LiLy', 'Ronan'] nameList.clear() print(nameList) # [] 空列表
-
-
reverse方法，反转列表次序。-
基本语法
列表.reverse()
-
示例
nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry'] nameList.reverse() print(nameList) # ['Hurry', 'Ronan', 'LiLy', 'Potter']
-
-
sort方法，对列表次序永久排序。默认升序排序，按字母次序排序。sorted方法可以实现临时排序，即返回一个已排序的新列表，原有列表保持不变。sorted可以对所有可迭代对象进行排序。-
基本语法
列表.sort(key = None, reverse = False)
新列表 = sorted(列表, cmp = None, key = None, reverse = False) -
示例
nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry'] nameList.sort() # 默认升序 print(nameList) # ['Hurry', 'LiLy', 'Potter', 'Ronan'] 按字母排序 nameList.sort(reverse = True) # 降序 print(nameList) # ['Ronan', 'Potter', 'LiLy', 'Hurry'] newList = sorted(nameList) # 暂时排序 print(nameList) # ['Ronan', 'Potter', 'LiLy', 'Hurry']，不变 print(newList) # ['Hurry', 'LiLy', 'Potter', 'Ronan']
-
-
copy方法，对列表进行复制。返回一个复制的列表。深拷贝与浅拷贝。-
基本语法
新列表 = 列表.copy()
-
示例
# 两个列表不会互相影响 nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry'] newList = nameList.copy() # 复制一份列表 nameList.remove('Ronan') print(newList) # ['Potter', 'LiLy', 'Ronan', 'Hurry']，新列表没有改变 newList.remove('LiLy') print(nameList) # ['Potter', 'LiLy', 'Hurry']，原列表没有改变
-
列表遍历
一般使用for循环遍历列表，代码简洁。
nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry']
for i in nameList:
print(i) # Potter LiLy Ronan Hurry
列表嵌套
类似于C语言中的多维数组概念，即列表中的数据也是一个列表，每个子列表的长度可以不同，这比数组要灵活许多。
nameList = [['Potter', 'LiLy', 'Ronan', 'Hurry'], [100, 99, 3]]
print(nameList[1][2]) # 3
for name in nameList: # 遍历
for i in name:
print(i) # Potter LiLy Ronan Hurry 100 99 3
元组（tuple）
元组和列表比较类似，可以一次性存储多个数据，且原则上，应保证数据类型一致。但不同的是元组中存放的数据不允许修改。
不过也有一种特殊情况，当元组中嵌套列表时，列表中的数据可以修改
name= ('Potter', [1, 2, 3])
name[1][1] = 'a'
print(name) # ('Potter', [1, 'a', 3])
利用公共方法del可以删除整个元组，但不支持对元组数据单独操作。
# 1
tuple1 = (1,2,3)
del tuple1
print(tuple1) # NameError: name 'tuple1' is not defined.
# 2
tuple1 = (1,2,3)
del tuple1[1]
print(tuple1) # TypeError: 'tuple' object doesn't support item deletion
创建元组
元组由小括号()包裹。单个数据元组必须在数据后加逗号。
number = (15,) # 单个数据元组
name = ("John", "Potter", "Tom", 18) # 多个数据元组
也可以创建一个空元组。
tuple1 = () # 创建一个空元组
tuple2 = tuple() # 创建一个空元组
巧妙利用乘号*的复制特性，快速创建元组。适用于字符串、列表、元组。
tuple3 = (1)*5 # (1, 1, 1, 1, 1)
tuple4 = ("a", "b")*3 # ('a', 'b', 'a', 'b', 'a', 'b')
也可以使用元组生成式。与上述生成式稍有不同，元组生成式会返回一个生成器对象。
tuple1 = (i**2 for i in range(5))
print(tuple1 ) # <generator object <genexpr> at 0x00000168246AF1D0>
print(tuple(tuple1)) # (0, 1, 4, 9, 16)
使用tuple函数，可以直接将生成器对象转换成元组。
元组合并
通过拼接符+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。
print((1, 2) + (3, 4)) # (1, 2, 3, 4)
print({
1, 2} + {
3, 4}) # 集合不支持拼接符 +
print({
'a':1} + {
'b':2}) # 字典不支持拼接符 +
元组查找
元组不支持任何修改，只支持查找操作。
通过len方法可以测量元组长度。它是一个公共方法。
name = ('Potter', 'LiLy', 'Ronan')
print(len(name)) # 3
如果已知数据在元组中的位置，可以直接按索引查找。
name = ('Potter', 'LiLy', 'Ronan')
print(name[1]) # LiLy
如果未知数据在元组中的位置，则需要借助函数按值查找。
-
index方法：与在字符串、列表中用法一致。-
基本语法
元组.index(数据，起始下标，结束下标)
-
示例
name= ('Potter', 'LiLy', 'Ronan', 'Potter') print(name.index("Potter")) # 0，仅返回第一次出现的起始下标 print(name.index("LiLy",1,2)) # 1，限制搜索区间 print(name.index("Hurry")) # error，不存在该数据
-
-
count方法：检查某个数据在这个元组中的重复次数。无法指定搜索区间。-
基本语法
元组.count(数据)
-
示例
name = ('Potter', 'LiLy', 'Ronan', 'Potter') print(name.count("P")) # 0, 重复次数为0 print(name.count("Ronan")) # 1, 重复次数为1 print(name.count("Potter")) # 2, 重复次数为2
-
字典（dict）
列表虽然可以存储多类型数据，但对其处理并不擅长。对于无序的多类型数据，我们往往用字典进行存储。
同样地，字典也为可变类型。
创建字典
字典采用键值对的方式存储，键与值之间存在一一映射关系。其中，键必须是唯一的，且必须为不可变类型。字典由大括号{}包裹。
dict1 = {
'name': 'Tom', 'age': 18, 'gender': '男'}
也可以创建一个空字典。
dict2 = {
} # 创建一个空字典
dict3 = dict() # 创建一个空字典
字典生成式可以快速生成字典，或是将两个列表合并为一个字典。
dict1 = {
"num"+str(i):i**3 for i in range(3)}
print(dict1) # {'num0': 0, 'num1': 1, 'num2': 8}
# 两个列表合并为字典
key_list = ['name', 'age', 'gender']
val_list = ['Hurry', 20, '男']
dict2 = {
key_list[i]:val_list[i] for i in range(len(key_list))}
print(dict2) # {'name': 'Hurry', 'age': 20, 'gender': '男'}
字典修改
这里的修改一般包含增加、删除等方面。
- 新增或更改数据。如果字典中该键存在，则修改对应值；如果键不存在，则添加新的键值对。
-
基本语法
字典[key] = value
-
示例
dict1 = { 'name': 'Tom'} dict1['gender'] = '女' # 新增键 gender print(dict1) # {'name': 'Tom', 'gender': '女'} dict1['name'] = 'Hurry' # 更改键 name 的值 print(dict1) # {'name': 'Hurry', 'gender': '女'}
-
- 删除数据
-
基本语法
del 字典[key]
字典.clear() -
示例
dict1 = { 'name': 'Tom', 'gender': '女'} del dict1['name'] # 删除键值对 print(dict1) # {'gender': '女'} dict1.clear() # 清空字典 print(dict1) # {} del dict1 # 删除整个字典 print(dict1) # name 'dict1' is not defined
-
字典查找
字典不属于序列，而属于映射类型，因为它不能通过下标进行查找，而是根据键来查找。
- 已知键，可以直接返回对应值。若不存在则报错。
-
基本语法
value = 字典[key]
-
示例
dict1 = { 'name': 'Tom'} print(dict1['name']) # Tom print(dict1['age']) # KeyError: 'age'
-
get方法，返回键的对应值。-
基本语法
value = 字典.get(key, 默认值)
key指键。当键存在时，返回对应值；当键不存在时，返回自定义默认值；若默认值缺省，则返回None。 -
示例
dict1 = { 'name': 'Tom', 'gender': '女'} print(dict1.get('name')) # Tom print(dict1.get('age')) # None print(dict1.get('age', '不存在')) # 不存在
-
字典遍历
字典的遍历可以根据键遍历，或是根据值遍历，或是根据键值对遍历。
keys方法，返回所有键的可迭代对象。-
基本语法
dict_keys = 字典.keys()
dict_keys指所有键的可迭代对象。为dict_keys类型，可以循环遍历。 -
示例
dict1 = { 'name': 'Tom', 'gender': '女'} print(dict1.keys()) # dict_keys(['name', 'gender']) print(type(dict1.keys())) # <class 'dict_keys'> for key in dict1.keys(): # 遍历所有的 key print(key) # name gender
-
values方法，返回所有值的可迭代对象。-
基本语法
dict_values = 字典.values()
dict_values指所有值的可迭代对象。为dict_values类型，可以循环遍历。 -
示例
dict1 = { 'name': 'Tom', 'gender': '女'} print(dict1.keys()) # dict_values(['Tom', '女']) print(type(dict1.keys())) # <class 'dict_values'> for value in dict1.values(): # 遍历所有的 value print(value) # Tom 女
-
items方法，返回所有键值对的可迭代对象。-
基本语法
dict_items = 字典.items()
dict_items指所有键值对的可迭代对象。为dict_items类型，每个键值对组成一个元组，可以循环遍历。 -
示例
dict1 = { 'name': 'Tom', 'gender': '女'} print(dict1.items()) # dict_items([('name', 'Tom'), ('gender', '女')]) print(type(dict1.items())) # <class 'dict_items'> for item in dict1.items(): # 遍历所有的 item print(item) # ('name', 'Tom') ('gender', '女') for key, value in dict1.items(): # 遍历所有的 item，并拆包 print(f'{ key} = { value}') # name = Tom gender = 女
-
集合（set）
集合的特点是无序性、互异性。集合中存放的数据都是不重复的，且与自定义顺序无关。
集合也是可变类型。
创建集合
集合也是由大括号{}包裹，数据由逗号隔开。可以实现序列去重。
s1 = {
10, 20, 30, 40}
print(s1) # {40, 10, 20, 30} 体现无序性
s2 = set("hello world")
print(s2) # {' ', 'd', 'r', 'h', 'w', 'o', 'e', 'l'} 体现互异性
可以通过set方法创建空集合。
s3 = set()
集合生成式可以快速生成集合。
list1 = [1, 2, 3, 1]
set1 = {
i**2 for i in list1}
print(set1) # {1, 4, 9}
集合查找
由于集合的无序性，显然也不能通过下标查找，因此集合也非序列类型。
类似地，通过成员运算符in、not in也可以用于判断集合中是否包含指定数据。
nameSet = {
'Potter', 'LiLy', 'Ronan'}
print("LiLy" in nameSet) # True
print("potter" in nameSet) # False
print("Hurry" not in nameSet) # True
集合修改
这里的修改一般包含增加、删除等方面。
add方法，向集合中追加新数据。若该数据存在，则不进行任何操作。不可以追加可变类型数据。-
基本语法
集合.add(数据)
-
示例
s1 = { 1, 2, 3, 4} s1.add(5) print(s1) # {1, 2, 3, 4, 5} s1.add(2) print(s1) # {1, 2, 3, 4, 5}，不做任何操作 s1.add([1, 2]) print(s1) # unhashable type: 'list' 不可以追加可变类型数据 s1.add((6, 7)) print(s1) # {1, 2, 3, 4, 5, (6, 7)} 可以追加不可变类型数据（元组、字符串）
-
update方法，向集合中追加新序列拆分后的数据。存在的数据不重复添加。不可以追加单一数据。-
基本语法
集合.update(序列)
-
示例
s1 = { 1, 2, 3, 4} s1.update([1, 2, 5]) print(s1) # {1, 2, 3, 4, 5} s1.update((1, 2, 6)) print(s1) # {1, 2, 3, 4, 5, 6} s1.update(7) print(s1) # 'int' object is not iterable
-
remove方法，删除集合中的指定数据。若不存在则报错。-
基本语法
集合.remove(数据)
-
示例
s1 = { 1, 2, 3, 4} s1.remove(2) print(s1) # {1, 3, 4} s1.remove(5) # KeyError: 5
-
discard方法，删除集合中的指定数据。若不存在不进行任何操作。-
基本语法
集合.discard(数据)
-
示例
s1 = { 1, 2, 3, 4} s1.discard(2) print(s1) # {1, 3, 4} s1.discard(5) print(s1) # {1, 3, 4}
-
pop方法，删除集合中的随机数据。并返回该数据。-
基本语法
数据 = 集合.pop()
-
示例
s1 = { 1, 2, 3, 4} data = s1.pop() print(data) # 2，随机 print(s1) # {1, 3, 4}
-
集合运算
difference方法，返回集合差集。difference_update方法，更新为集合差集。原集合改变，无返回值。intersection方法，返回集合交集。intersection_update方法，更新为集合交集。原集合改变，无返回值。union方法，返回集合并集。symmetric_difference方法，返回集合中互异的元素。symmetric_difference_update方法，更新为集合中互异的元素。原集合改变，无返回值。issubset方法，判断该集合是否为指定集合的子集。
a = set('abcdefgh')
b = set('aceh')
# 差集 {'d', 'g', 'f', 'b'}
print(a - b)
print(a.difference(b))
a.difference_update(b)
print(a)
# 并集 {'a', 'f', 'h', 'd', 'b', 'c', 'e', 'g'}
print(a | b)
print(a.union(b))
# 交集 {'c', 'a', 'e', 'h'}
print(a & b)
print(a.intersection(b))
a.intersection_update(b)
print(a)
# 两个集合中不同时存在的元素 {'f', 'd', 'g', 'b'}
print(a ^ b)
print(a.symmetric_difference(b))
a.symmetric_difference_update(b)
print(a)
# 子集判断
print(a.issubset(b)) # False
判断数据类型
Python 有专门判断数据类型的方法type()，例如
a = "Hello World!"
print(type(a)) # <class 'str'>
除此之外，也可以用isinstance函数判断。它认为子类是一种父类类型，而type不将子类当作一种父类类型。关于类的概念见后续章节。
a = "Hello World!"
print(isinstance(a, str)) # True
数据类型转换
隐式转换
Python会自动进行一些数据类型转换，比如整型与浮点型运算时，自动转化为精度更高的数据类型（浮点型），避免数据丢失。
布尔（bool）< 整型（int） < 浮点型（float）< 复数（complex）
但整型与字符串不能直接运算，需要借助显式转换。
显式转换
| 函数 | 说明 |
|---|---|
| int(x, base = 10) | 转化为整型，默认输入为十进制 |
| float(x) | 转化为浮点型 |
| complex(a, b) | 创建一个复数 |
| str(x) | 转化为字符串 |
| eval(x) | 将字符串转化为原本类型 |
| tuple(x) | 转化为元组 |
| list(x) | 转化为列表 |
| set(x) | 转化为可变集合 |
| dict(x) | 创建一个字典，输入为 (key, value) 元组序列 |
| chr(x) | 将整数转化为Unicode字符 |
| ord(x) | 将字符转化为ASCII值 |
| hex(x) | 转化为十六进制字符串 |
| oct(x) | 转化为八进制字符串 |
注：set可用于去重
迭代器（iterator）
迭代器是一个可以记住遍历位置的对象。通过iter方法创建一个迭代器对象，从第一个元素开始访问，通过next方法指向下一个元素，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器对象可以被for循环遍历，故又称为可迭代对象（iterable）。例如上述的字符串、元组、列表等序列（Sequence），以及字典等非序列都属于可迭代对象。
range方法可以生成一组数值可迭代对象。一般用于for循环遍历。-
基本语法
range(初值，终值，步长)
与切片类似，左闭右开，不包含终值。步长可缺省，默认为
1。初值亦可缺省（需与步长同时缺省），默认从0开始。注意range所生成的类型不是列表。 -
示例
nums = range(1, 5, 2) for num in nums: print(num) # 1 3 nums = range(5) for num in nums: print(num) # 0 1 2 3 4
-
enumerate方法，返回可迭代对象与对应下标组成的元组。一般用于for循环遍历。优点是既可以取到数据，还可以取得对应下标。-
基本语法
（index, data）= enumerate(可迭代对象，计数器初值)
对于一个可迭代对象，如果我们既想得到数据，也想得到它的索引，往往需要另外设置一个计数器，而
enumerate可以同时取得数据和对应下标，以元组形式返回。计数器初值一般缺省，即从
0开始，与下标保持一致。 -
示例
list1 = ['a', 'b', 'c'] for i, char in enumerate(list1): # 会自动拆包 print(f'{ char}的下标为{ i}') # a的下标为0 b的下标为1 c的下标为2
-
生成器（generator）
包含关键字yield的函数被称为生成器。可以在迭代过程中逐步产生值，而不是一次性返回所有结果。只能用于迭代操作，返回一个迭代器对象。
在生成器函数中执行至yield语句时，函数的执行将会暂停，并将yield后面的表达式作为当前迭代值返回。
当调用生成器的next方法或使用for循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到yield语句。于是，生成器函数可以逐步产生值。
总结
重点需要掌握字符串、列表、字典的操作。
- 整型、浮点型、复数型、布尔型、字符串、元组均属于不可变类型（
immutable），而列表、字典、集合属于可变类型（mutable）。 - 字符串、元组和列表属于序列，可以通过下标访问，可以进行切片操作。非序列类型无切片操作。
- 列表、字典、集合、元组可以使用生成式（推导式），可以一行代码快速创建。
- 切片操作和
range函数都属于左闭右开型，即取不到终值。