【Python基础】2. 常量与变量

---

常量（Constant）

数据总是以数字、字母、字符等方式描述，在计算机中将那些不变的数据称为常量。常量是不可被修改的。

以下类似于C语言语法。

• 整数字面量（Integer）
  • 100 十进制字面量，无前缀
  • 0b100 二进制字面量，前缀0b
  • 0o100 八进制字面量，前缀0o
  • 0x100 十六进制字面量，前缀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\Desktop'或'C:\\User\\Desktop'可以消除转义。
• 布尔字面量（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 1e, f = 'a', 100 # 多变量赋不同值
print(e, f)     # a 100

---

数据类型（11种）

虽然Python定义变量时无需指明数据类型，但并不代表没有数据类型，常见的共11种。

---

1. 整型（int）

属于不可变类型。

a = 1

---

2. 浮点型（float）

属于不可变类型。

a = 3.14

---

3. 复数型（complex）

属于不可变类型。

a = 4 + 3j
b = complex(5, 2)   # 5 + 2j

此处j视为虚数单位，i在 Python 中不视为虚数。

---

4. 布尔型（bool）

bool类型是int类型的子类，属于不可变类型。

a = True
b = False

在参与运算时，True自动转换为1，False自动转换为0。

注意：True、False必须首字母大写，属于关键字。

---

5. 空类型（NoneType）

NoneType类型的实例为None，它是一个单例对象，即只能创建一个None实例，它们指向同一个地址。

• 在Python中，None是一个对象，表示空的含义，且具有唯一地址。
• 在C语言中，NULL是0的符号常量（定义在<stdio.h>中），表示空指针的宏，指向0X00000000。该地址为保留地址，不可用。
• 在Java中，null是一种特殊的值，可以赋值给任何引用类型，表示未知对象。

空类型判断推荐使用is、is not运算符。

a = None
print(a is None)  # True

注意：不应通过==和!=判断某个变量是否为None，该运算符检查的是对象的值是否相等，而is和is not直接检查两个变量是否指向内存中的同一个对象。

None对应的布尔值为False，与之类似的还有：

• 0 整数零
• 0.0 实数零
• [] 空列表
• {} 空字典
• () 空元组
• set() 空集合
• "" 空字符串

因此，如果需要判断变量是否为None，推荐采用if a is not None，而非if a，因为很多非None的对象也是False。

a = None
if a is not None:print("a is not None")
else:print("a is None") # a is None

---

6. 字符串（str）

字符串是 Python 中常用的数据类型，一般由单引号'、双引号"或三引号"""、'''包裹。

Python 不支持单字符类型，单字符在 Python 中也被视作字符串类型。

name = "abcdef"
print(type(name[1])) # <class 'str'>

字符串类型是不可变类型，因此没有相应的增加或删除方法，修改字符串会返回一个新的字符串对象，原字符串并不改变。

---

i. 创建字符串

Python 创建字符串非常简单，只要为变量分配一个值即可。

var1 = 'Hello World'
var2 = "Python"

可以创建一个空字符串。

str1 = ""    # 创建空字符串
str2 = ''    # 创建空字符串
str3 = str() # 创建空字符串

巧妙利用乘号*的复制特性，可以快速创建字符串。该技巧适用于字符串、列表、元组。

str4 = "-"*5  # -----
str5 = "a"*3  # aaa

---

ii. 字符串切片

切片是指对某个序列对象截取其中一部分进行操作。其语法描述为

序列名 [ 起始下标 ：结束下标 ：步长 ]

其中：

1. 各参数均可为正负整数；
2. 截取片段从起始下标开始，但不包含结束下标的对应元素（左开右闭）；
3. 步长可缺省，默认为1
4. 负步长代表逆序，负下标代表倒数第n个元素
5. 对于正序而言，起始下标应小于结束下标。逆序则反之
6. 当选取方向和步长方向冲突，则无法选取数据
7. 结束下标可超出最大索引范围，且解释器不会报错

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])   # 无输出，不能选取数据

---

iii. 字符串判断

成员运算符in、not in可以用于判断字符串中是否包含指定字符，并返回True、Flase。

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
    print(name.endswith(("x", "y", "z")))    # False，可检查多个后缀
    

• 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
    

---

iv. 字符串查找

通过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方法一致，但查找方向是从右开始，因此返回的也是右侧第一次出现的起始坐标（子串左侧第一个下标）。

---

v. 字符串修改

这里的修改一般指比较、合并、分割、替换、大小写转换等方面。

• 字符串可以直接比较，基于字典序。但字符串和数值不能比较，或者做加减。
  • 示例

    a = "123f"
    b = "123g"
    c = 123
    print(a > b) # False
    print(a > c) # TypeError: '>' not supported between instances of 'str' and 'int'
    

• 字符串的拼接通过拼接符+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。
  • 示例

    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# 列表元素非字符串类型则需要通过str()转换
    joinList = [1, 2, 3, 4]
    listStr4 = ' '.join(str(e) for e in joinList)
    print(listStr4 )  # 1 2 3 4
    

• 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
    

---

7. 字节型（bytes）

bytes类型表示的是不可变的二进制序列（byte sequence），与字符串类似，但元素是整数（0 ~ 255）。通常用于处理二进制数据，比如图像文件、音频文件、视频文件或网络通信中的字节流。

字节型属于不可变类型。 具有和字符串类似的操作，不再赘述。

---

i. 创建字节对象

使用前缀b。限制输入为ASCII字符。

byte = b"hello"  # b'hello'

也可以使用bytes函数。编码方式默认使用 UTF-8 编码。

x = bytes("hello", encoding = "utf-8")

---

ii. 编码与解码

通过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'

---

8. 列表（list）

类似于C语言中的数组概念，可以一次性存储多个数据。但不同的是列表可以接受不同数据类型的数据，这比数组更加灵活。但实际工作中，我们更推荐一个列表中存储相同类型的数据，方便统一管理。

列表类型是可变类型，因此可以动态增加或删除列表中的数据，列表长度也会随之变化。

---

i. 创建列表

列表由中括号[]包裹。

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]

---

ii. 列表切片

列表与字符串、元组同属于序列（Sequence），都有切片操作。

name = [1, 2, 3, 4, 5]
print(name[1:4:1]) # [2, 3, 4], 不包含name[4]
print(name[1:4])   # [2, 3, 4], 步长为1时可缺省
print(name[:4])    # [1, 2, 3, 4], 默认从头开始截取
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])   # [], 空列表，不能选取数据

---

iii. 列表查找

通过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
    

---

iv. 列表判断

类似地，通过成员运算符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(list1)}, 最小{min(list1)}')   # 最大3, 最小1
print(f'最大{max(str1)}, 最小{min(str1)}')     # 最大c, 最小1
print(f'最大{max(tuple1)}, 最小{min(tuple1)}') # 最大3, 最小1
print(f'最大{max(set1)}, 最小{min(set1)}')     # 最大5, 最小1
print(f'最大{max(dict1)}, 最小{min(dict1)}')   # 最大name, 最小123

需要注意的是，字典比较的是键，而不是值。

---

v. 列表修改

这里的修改一般包含合并、更改、增加、删除、复制、去重、排序等方面。

1. 通过拼接符+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。

   print([1, 2] + [3, 4])  # [1, 2, 3, 4]            
   

2. 对列表数据的更改可以通过重新赋值实现。

   nameList = ['Potter', 'LiLy', 'Ronan', 'Potter']
   nameList[0] = "Hurry"
   print(nameList) # ['Hurry', 'LiLy', 'Ronan', 'Potter']
   

3. append方法，向已有列表末尾追加新数据。

   • 基本语法

     列表.append(数据)

   • 示例

     nameList = ['Potter', 'LiLy', 'Ronan', 'Potter']
     nameList.append("Hurry")
     print(nameList) # ['Potter', 'LiLy', 'Ronan', 'Potter', 'Hurry']
     

4. 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']
     

5. insert方法，向已有列表指定位置追加新数据。

   • 基本语法

     列表.insert(索引，数据)

   • 示例

     nameList = ['Potter','Tom']   
     nameList.insert(1, "Hurry")
     print(nameList)   # ['Potter', 'Hurry', 'Tom']
     

6. 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
     

7. pop方法，弹出已有列表中指定位置的数据。缺省则弹出列表末尾数据。返回该数据。

   • 基本语法

     delData = 列表.pop(索引)

   • 示例

     nameList = ['Potter', 'LiLy', 'Ronan']
     nameDel = nameList.pop()
     print(nameDel) # Ronan
     nameDel = nameList.pop(0)
     print(nameDel) # Potter
     

8. remove方法，删除已有列表中的指定数据。

   • 基本语法

     列表.remove(数据)

   • 示例

     nameList = ['Potter', 'LiLy', 'Ronan']
     nameList.remove('LiLy')
     print(nameList) # ['Potter', 'Ronan']
     

9. clear方法，删除已有列表中的所有数据。

   • 基本语法

     列表.clear()

   • 示例

     nameList = ['Potter', 'LiLy', 'Ronan']
     nameList.clear()
     print(nameList) # [] 空列表
     

10. reverse方法，反转列表自身次序（原地操作）。reversed方法返回给定序列的反向迭代器，并不改变序列本身次序，一般通过list方法转换为列表。

    • 基本语法

      列表.reverse()
      reversed(列表)

    • 示例

      nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry']
      newList = reversed(nameList)
      print(nameList, newList) #  ['Potter', 'LiLy', 'Ronan', 'Hurry']  ['Hurry', 'Ronan', 'LiLy', 'Potter']
      nameList.reverse()
      print(nameList) # ['Hurry', 'Ronan', 'LiLy', 'Potter']
      

11. 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'] 
      

12. 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']，原列表没有改变
      

---

vi. 列表遍历

一般使用for循环遍历列表，代码简洁。

nameList = ['Potter', 'LiLy', 'Ronan', 'Hurry']
for i in nameList:print(i) # Potter  LiLy  Ronan  Hurry

---

vii. 列表嵌套

类似于C语言中的多维数组概念，即列表中的数据也是一个列表，每个子列表的长度可以不同，这比数组要灵活许多。

nameList = [['Potter', 'LiLy', 'Ronan', 'Hurry'], [100, 99, 3]]
print(nameList[1][2]) # 3for name in nameList: # 遍历for i in name:print(i)      # Potter  LiLy  Ronan  Hurry  100  99  3

---

9. 元组（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

---

i. 创建元组

元组由小括号()包裹。单个数据元组必须在数据后加逗号。

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函数，可以直接将生成器对象转换成元组。

---

ii. 元组合并

通过拼接符+，这是一个公共操作，适用于字符串、列表、元组等。只能连接同类型数据。

print((1, 2) + (3, 4))    # (1, 2, 3, 4)    
print({1, 2} + {3, 4})    # 集合不支持拼接符 +   
print({'a':1} + {'b':2})  # 字典不支持拼接符 +

---

iii. 元组查找

元组不支持任何修改，只支持查找操作。

通过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
    

---

10. 字典（dict）

列表虽然可以存储多类型数据，但对其处理并不擅长。对于无序的多类型数据，我们往往用字典进行存储。

同样地，字典也为可变类型。

---

i. 创建字典

字典采用键值对的方式存储，键与值之间存在一一映射关系。其中，键必须是唯一的，且必须为不可变类型。

字典由大括号{}包裹。

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': '男'}

---

ii. 字典修改

这里的修改一般包含增加、删除等方面。

1. 新增或更改数据。如果字典中该键存在，则修改对应值；如果键不存在，则添加新的键值对。

   • 基本语法

     字典[key] = value

   • 示例

     dict1 = {'name': 'Tom'}dict1['gender'] = '女'    # 新增键 gender
     print(dict1)              # {'name': 'Tom', 'gender': '女'}dict1['name'] = 'Hurry'   # 更改键 name 的值
     print(dict1)              # {'name': 'Hurry', 'gender': '女'}
     

2. 删除数据

   • 基本语法

     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
     

---

iii. 字典查找

字典不属于序列，它是无序的，属于映射类型，因此不能通过下标进行查找，而是根据键来查找。

1. 已知键，可以直接返回对应值。若不存在则报错。

   • 基本语法

     value = 字典[key]

   • 示例

     dict1 = {'name': 'Tom'}
     print(dict1['name'])  # Tom
     print(dict1['age'])   # KeyError: 'age'
     

2. get方法，返回键的对应值。

   • 基本语法

     value = 字典.get(key, 默认值)

     key指键。当键存在时，返回对应值；当键不存在时，返回自定义默认值；若默认值缺省，则返回None。

   • 示例

     dict1 = {'name': 'Tom', 'gender': '女'}print(dict1.get('name'))           # Tom
     print(dict1.get('age'))            # None
     print(dict1.get('age', '不存在'))   # 不存在
     

---

iv. 字典遍历

字典的遍历可以根据键遍历，或是根据值遍历，或是根据键值对遍历。

1. 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():   # 遍历所有的 keyprint(key)             # name  gender
     

2. 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():   # 遍历所有的 valueprint(value)               # Tom  女
     

3. 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():        # 遍历所有的 itemprint(item)                   # ('name', 'Tom')  ('gender', '女')for key, value in dict1.items():  # 遍历所有的 item，并拆包print(f'{key} = {value}')     # name = Tom  gender = 女
     

---

11. 集合（set）

集合的特点是无序性、互异性。集合中存放的数据都是不重复的，且与自定义顺序无关。

集合也是可变类型。

---

i. 创建集合

集合也是由大括号{}包裹，数据由逗号隔开。可以实现序列去重。

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}

---

ii. 集合查找

由于集合的无序性，故也是非序列类型，显然不能通过下标查找。

类似地，通过成员运算符in、not in也可以用于判断集合中是否包含指定数据。

nameSet = {'Potter', 'LiLy', 'Ronan'}
print("LiLy" in nameSet)      # True
print("potter" in nameSet)    # False
print("Hurry" not in nameSet) # True

---

iii. 集合修改

这里的修改一般包含增加、删除等方面。

1. 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)}  可以追加不可变类型数据（元组、字符串）
     

2. 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
     

3. remove方法，删除集合中的指定数据。若不存在则报错。

   • 基本语法

     集合.remove(数据)

   • 示例

     s1 = {1, 2, 3, 4}
     s1.remove(2)
     print(s1)     # {1, 3, 4}
     s1.remove(5)  # KeyError: 5
     

4. discard方法，删除集合中的指定数据。若不存在不进行任何操作。

   • 基本语法

     集合.discard(数据)

   • 示例

     s1 = {1, 2, 3, 4}
     s1.discard(2)
     print(s1)     # {1, 3, 4}
     s1.discard(5)  
     print(s1)     # {1, 3, 4}
     

5. pop方法，删除集合中的随机数据。并返回该数据。

   • 基本语法

     数据 = 集合.pop()

   • 示例

     s1 = {1, 2, 3, 4}
     data = s1.pop()
     print(data)   # 2，随机
     print(s1)     # {1, 3, 4}
     

---

iv. 集合运算

• 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）

但整型与字符串不能直接运算，需要借助显式转换。

字符串不支持算术运算，试图通过'c'-'a'计算两个字符之间的距离是非法的（这在C语言中属于合法操作），而应该使用ord('c')-ord('a')。

---

显式转换

函数	说明
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)	转化为八进制字符串
bin(x)	转化为二进制字符串

注：set可用于去重

编程时通常会遇到数值与字符串之间的转换，以及与字节对象之间的转换。

# 1. 字符串转数值（十进制、十六进制、二进制）
str_num1 = "6"
str_num2 = "ff"
str_num3 = "1010"
dec_num = int(str_num1)
hex_num = int(str_num2, 16)
bin_num = int(str_num3, 2)
print(dec_num, type(dec_num)) # 6 <class 'int'>
print(hex_num, type(hex_num)) # 255 <class 'int'>
print(bin_num, type(bin_num)) # 10 <class 'int'># 2. 数值转十六进制字符串（包含前缀0x）
dec_num = 10
hex_num = hex(dec_num)
print(hex_num, type(hex_num)) # 0xa <class 'str'># 3. 数值转二进制字符串（包含前缀0b）
dec_num = 10
bin_num = bin(dec_num)
print(bin_num, type(bin_num)) # 0b1010 <class 'str'># 4. 字节对象转十六进制字符串（不含前缀）
byte_data = b'\x48\xf5'
hex_string = byte_data.hex()
print(hex_string)  # 48f5# 5. 十六进制字符串（不含前缀）转字节对象
hex_with_spaces = "ff aa 00 12 c4"
byte_data = bytes.fromhex(hex_with_spaces)
print(byte_data)  # b'\xff\xaa\x00\x12\xc4'# 6. 字节对象转数值
byte_data = b'\x00\xFF'
num1 = int.from_bytes(byte_data, byteorder='big')
num2 = int.from_bytes(byte_data, byteorder='little')
print(num1) # 255, 0x00FF
print(num2) # 65280, 0xFF00# 7. 数值转字节对象
number = 255
byte_data1 = number.to_bytes(2, byteorder='big')  # 指定字节长度
byte_data2 = number.to_bytes(2, byteorder='little')  # 指定字节长度
print(byte_data1) # b'\x00\xff'
print(byte_data2) # b'\xff\x00'

---

总结

重点需要掌握字符串、列表、字典的操作。

1. 整型、浮点型、复数型、布尔型、字符串、元组均属于不可变类型（immutable），而列表、字典、集合属于可变类型（mutable）。
2. 字符串、元组和列表属于序列，可以通过下标访问，可以进行切片操作。非序列类型无切片操作。
3. 列表、字典、集合、元组可以使用生成式（推导式），可以一行代码快速创建。
4. 切片操作和range函数都属于左闭右开型，即取不到终值。