《Python零基础快乐学习之旅》学习笔记6——列表（list）

╰半夏微凉° 2022-12-29 06:39 351阅读 0赞

### 文章目录 ###

*  第6章 列表（list）
 *   *  6.1 认识列表（list）
     *   *  6.1.1 列表基本定义
         *  6.1.2 读取列表元素
         *  6.1.3 列表切片（list slices）
         *  6.1.4 列表统计资料、最大值max()、最小值min()、总和sum()
         *  6.1.5 列表个数len()
         *  6.1.6 更改列表元素的内容
         *  6.1.7 列表的相加
         *  6.1.8 删除列表元素
     *  6.2 Python简单的面向对象概念
     *   *  6.2.1 字符串的方法
     *  6.3 增加与删除列表元素
     *   *  6.3.1 在列表末端增加元素append()
         *  6.3.2 插入列表元素insert()
         *  6.3.3 删除列表元素pop()
         *  6.3.4 删除指定的元素remove()
     *  6.4 列表排序
     *   *  6.4.1 颠倒排序reverse()
         *  6.4.2 sort()排序
     *  6.5 进阶列表操作
     *   *  6.5.1 index()
         *  6.5.2 count()
     *  6.6 列表的赋值与复制
     *   *  6.6.1 列表赋值
         *  6.6.2 列表的复制
     *  6.7 再谈字符串
     *   *  6.7.1 字符串的索引
         *  6.7.2 字符串切片
         *  6.7.2 函数或方法
         *  6.7.4 字符串转列表
         *  6.7.5 使用split()处理字符串
         *  6.7.6 字符串的其他方法
     *  6.8 in和not in语句

# 第6章 列表（list） #

列表（List）是Python的一种可以更改内容的数据类型，是由一系列元素所组成的序列数据。

## 6.1 认识列表（list） ##

Python的列表功能除了可以存储相同数据类型，例如：整数、浮点数、字符串，通常称每一种数据为元素。
    一个列表也可以存储不同数据类型，例如：列表内同时含有整数、浮点数和字符串。

### 6.1.1 列表基本定义 ###

定义列表的语法格式如下：

name_list = [元素1,......,元素n,] # name_list是假设的列表名称

列表的每一组数据称为元素，这些元素放在中括号\[\]内，彼此之间用英文逗号“,”隔开（最后一个元素后可加可不加）。使用print()函数，将列表名称作为变量名，即可打印列表内容。

>>> fruits = ['apple', 'banana', 'orange', 'pear']
    >>> print(fruits)
    ['apple', 'banana', 'orange', 'pear']
    >>> heroes = ['关羽', '张飞', '赵云', '马超', '黄忠']
    >>> print(heroes)
    ['关羽', '张飞', '赵云', '马超', '黄忠']

列表内可以有不同的数据类型：

>>> list1 = ['Java', 'PHP', 'C/C++', 'Go', 1, 2, 3]
    >>> print(list1)
    ['Java', 'PHP', 'C/C++', 'Go', 1, 2, 3]

# ch6_1.py
    james = [23, 19, 22, 31, 18] # 定义james列表
    print("打印james列表", james)
    James = ['Lebron James', 23, 19, 22, 31, 18] # 定义James列表
    print("打印James列表", James)
    fruits = ['apple', 'banana', 'orange', 'pear'] # 定义fruits列表
    print("打印fruits列表", fruits)
    cfruits = ['菠萝', '榴莲', '芒果', '西瓜'] # 定义cfruits列表
    print("打印cfruits列表", cfruits)
    score = [80.5, 89.5, 59.5, 88.0, 90] # 定义score列表
    print("打印score列表", score)
    # 列表中有列表
    test = ['A', 'B', 'C', 'D',['Java', 'PHP', 'Python', 'C/C++', 'Go']]
    print("打印test列表", test)
    # 列出列表数据类型
    print("列表test的数据类型为：", type(test))

执行结果：

===================== RESTART: E:/Python-Files/ch6/ch6_1.py ====================
    打印james列表 [23, 19, 22, 31, 18]
    打印James列表 ['Lebron James', 23, 19, 22, 31, 18]
    打印fruits列表 ['apple', 'banana', 'orange', 'pear']
    打印cfruits列表 ['菠萝', '榴莲', '芒果', '西瓜']
    打印score列表 [80.5, 89.5, 59.5, 88.0, 90]
    打印test列表 ['A', 'B', 'C', 'D', ['Java', 'PHP', 'Python', 'C/C++', 'Go']]
    列表test的数据类型为： <class 'list'>
    >>>

### 6.1.2 读取列表元素 ###

可以通过列表名称与索引读取列表元素的内容，在Python中，元素的索引值是从0开始的。

读取列表元素的应用：

# ch6_2.py
    fruits = ['apple', 'orange', 'pear'] # 定义fruits列表
    print("打印fruits[0]",fruits[0]);
    print("打印fruits[1]",fruits[1]);
    print("打印fruits[2]",fruits[2]);

===================== RESTART: E:/Python-Files/ch6/ch6_2.py ====================
    打印fruits[0] apple
    打印fruits[1] orange
    打印fruits[2] pear
    >>>

传统处理列表元素内容方式与Python多重指定概念：

# ch6_2.py
    fruits = ['apple', 'orange', 'pear'] # 定义fruits列表
    print("打印fruits[0]",fruits[0]);
    print("打印fruits[1]",fruits[1]);
    print("打印fruits[2]",fruits[2]);
    
    # 传统设计方式
    fruit1 = fruits[0]
    fruit2 = fruits[1]
    fruit3 = fruits[2]
    print("打印fruits中的元素",fruit1,fruit2,fruit3)
    
    # Python多重指定
    fruit1, fruit2, fruit3 = fruits; # 多重指定变量的数量需与列表元素的个数相同
    print("打印fruits中的元素",fruit1,fruit2,fruit3)

===================== RESTART: E:/Python-Files/ch6/ch6_2.py ====================
    打印fruits[0] apple
    打印fruits[1] orange
    打印fruits[2] pear
    打印fruits中的元素 apple orange pear
    打印fruits中的元素 apple orange pear
    >>>

### 6.1.3 列表切片（list slices） ###

在设计程序时，常会需要取得列表前几个元素、后几个元素、某区间元素或是依照一定规则排序的元素，所取得的系列元素也可称子列表，这个概念称列表切片。

name_list[start:end] # 读取从索引start到（end-1）索引的列表元素
    name_list[:n] # 取得列表前n名
    name_list[n:] # 取得列表索引n到最后
    name_list[-n:] # 取得列表后n名
    name[:] # 取得所有元素

下列是读取区间，用step作为每隔多少区间再读取。

name_list[start:end:step] # 每隔step，读取从索引start到（end-1）索引的列表元素

===================== RESTART: E:/Python-Files/ch6/ch6_4.py ====================
    打印week第1-3个元素 ['Monday', 'Tuesday', 'Wednesday']
    打印week第2-5个元素 ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
    打印week第3,5,7元素 ['Monday', 'Wednesday', 'Friday']
    >>>

# ch6_4.py
    week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] # 定义week列表
    print("打印week第1-3个元素",week[0:3])
    print("打印week第2-5个元素",week[1:5])
    print("打印week第3,5,7元素",week[2:7:2])
    print("打印week前3个元素",week[:3])
    print("打印week后3个元素",week[-3:])
    print("打印week第3个元素至末尾",week[2:])
    print("打印week所有元素",week[:])
    print("打印week最后一个元素",week[-1])

================================== RESTART: E:/Python-Files/ch6/ch6_4.py =================================
    打印week第1-3个元素 ['Monday', 'Tuesday', 'Wednesday']
    打印week第2-5个元素 ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
    打印week第3,5,7元素 ['Wednesday', 'Friday', 'Sunday']
    打印week前3个元素 ['Monday', 'Tuesday', 'Wednesday']
    打印week后3个元素 ['Friday', 'Saturday', 'Sunday']
    打印week第3个元素至末尾 ['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    打印week所有元素 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    打印week最后一个元素 Sunday
    >>>

### 6.1.4 列表统计资料、最大值max()、最小值min()、总和sum() ###

Python有内建一些执行统计运算的函数。

*  如果列表内容全部是数值，则可以使用\*\*max()\*\*函数获得列表的最大值，\*\*min()\*\*函数可以获得列表的最小值，\*\*sum()\*\*函数可以获得列表的总和。
 *  如果列表内容全部是字符或字符串，则可以使用max()函数获得列表的Unicode码值的最大值，min()函数可以获得列表的Unicode码值最小值。sum()函数不可以在列表元素为非数值的情况下使用。

# ch6_7.py
    scores = [59, 87, 89, 63, 74, 98]
    print("最高分：",max(scores))
    print("最低分：",min(scores))
    print("总分：",sum(scores))
    
    scores = ['Jack', 89, 92, 103, 68, 77, 88]
    # 列表中元素有字符串，可使用切片方式处理
    print("最高分：",max(scores[1:])) # 读取索引1到最后
    print("最低分：",min(scores[-6:])) # 读取列表后6个元素
    print("总分：",sum(scores[1:7]))   # 读取从索引1到索引6的列表元素

执行结果：

===================== RESTART: E:/Python-Files/ch6/ch6_7.py ====================
    最高分： 98
    最低分： 59
    总分： 470
    最高分： 103
    最低分： 68
    总分： 517
    >>>

### 6.1.5 列表个数len() ###

使用len()函数可以获取列表的元素个数。

scores = [89, 92, 103, 68, 77, 88]
    len = len(scores);
    print("共记录了%d科成绩" % len) # 打印列表元素个数

===================== RESTART: E:/Python-Files/ch6/ch6_7.py ====================
    共记录了6科成绩
    >>>

### 6.1.6 更改列表元素的内容 ###

可以使用列表名称和索引值更改列表元素的内容。

# ch6_9.py
    fruits = ['apple', 'orange', 'pear', 'banana']
    print("水果列表：",fruits)
    fruits[2] = 'peach';
    print("水果列表：",fruits)

===================== RESTART: E:/Python-Files/ch6/ch6_9.py ====================
    水果列表： ['apple', 'orange', 'pear', 'banana']
    水果列表： ['apple', 'orange', 'peach', 'banana']
    >>>

### 6.1.7 列表的相加 ###

Python允许列表相加，相当于将列表结合。

# ch6_11.py
    cars1 = ['Toyota', 'Nissan', 'Honda']
    print("汽车销售品牌",cars1)
    cars2 = ['Audi', 'BMW']
    cars1 += cars2;
    print("汽车销售品牌",cars1)

==================== RESTART: E:/Python-Files/ch6/ch6_11.py ====================
    汽车销售品牌 ['Toyota', 'Nissan', 'Honda']
    汽车销售品牌 ['Toyota', 'Nissan', 'Honda', 'Audi', 'BMW']
    >>>

### 6.1.8 删除列表元素 ###

可以使用下列方式删除指定索引的列表元素：

del name_list[i] # 删除索引i的列表元素

# ch6_11.py
    cars1 = ['Toyota', 'Nissan', 'Honda']
    print("汽车销售品牌",cars1)
    cars2 = ['Audi', 'BMW']
    cars1 += cars2;
    print("汽车销售品牌",cars1)
    del cars1[1] # 删除索引1的列表元素
    print("汽车销售品牌",cars1)

以这种方式删除列表元素最大的缺点是，元素删除后，我们无法得知删除的是什么内容。

## 6.2 Python简单的面向对象概念 ##

在面向对象的程序设计概念中，所有数据都是一个对象（Object）。目前Python为一些基本对象提供默认的方法，使用这些方法的格式为：对象.方法()

### 6.2.1 字符串的方法 ###

字符串操作常用的几个方法如下：

*  lower()：将字符串转成小写。
 *  upper()：将字符串转成大写。
 *  title()：将字符串第一个字母转大写，其他的小写。
 *  rstrip()：删除字符串尾端（右端）多余的空白。
 *  lstrip()：删掉字符串开始端（左端）多余的空白。
 *  strip()：删除字符串头尾两端多余的空白。

# ch6_14.py
    strN = "Hello World"
    strU = strN.upper() # 字符串转成大写
    strL = strN.lower() # 字符串转成小写
    strT = strN.title() # 首字母大写，其它小写
    print("大写输出：",strU,"\n小写输出：",strL,"\n首字母大写：",strT)
    
    strN = " java php python ";
    strL = strN.lstrip() # 去除字符串左边多余空白
    strR = strN.rstrip() # 删除字符串右边多余空白
    strO = strN.strip() # 删除字符串首尾两端多于空白
    print("/%s/" % strN)
    print("/%s/" % strL)
    print("/%s/" % strR)
    print("/%s/" % strO)

执行结果：

==================== RESTART: E:/Python-Files/ch6/ch6_14.py ====================
    大写输出： HELLO WORLD 
    小写输出： hello world 
    首字母大写： Hello World
    / java php python /
    /java php python /
    / java php python/
    /java php python/
    >>>

## 6.3 增加与删除列表元素 ##

### 6.3.1 在列表末端增加元素append() ###

Python为列表内建了新增元素的方法append()，该方法可在列表**末端**直接新增元素。

name_list.append('新增元素')

执行结果：

### 6.3.2 插入列表元素insert() ###

append()方法是固定在列表末端插入元素，insert()方法则可以在任意位置插入元素。

insert(索引,元素内容)

执行结果：

### 6.3.3 删除列表元素pop() ###

使用pop()方法删除元素最大的优点是，删除后将弹出所删除的值。使用pop()时，若未指明所删除元素的位置，一律删除列表末端的元素。pop()的使用方式如下：

value = name_list.pop() # 没有索引则删除列表末端元素
    value = name_list.pop(i) # 删除指定索引值的列表元素

# ch6_17.py
    fruits = [] # 定义空列表
    print("当前列表内容：",fruits)
    fruits.append('Apple')
    print("当前列表内容：",fruits)
    fruits.append('Banana')
    print("当前列表内容：",fruits)
    fruits.append('Orange')
    print("当前列表内容：",fruits)
    fruits.insert(2, 'peach')
    print("当前列表内容：",fruits)
    fruits.insert(0,'pear')
    print("当前列表内容：",fruits)
    fruits.insert(6,'pear')
    print("当前列表内容：",fruits)
    popped_fruit = fruits.pop() # 删除列表末端值
    print("所删除的列表内容为：",popped_fruit)
    print("新的列表内容：",fruits)
    popped_fruit = fruits.pop(2) # 删除列表索引为2的值
    print("所删除的列表内容为：",popped_fruit)
    print("新的列表内容：",fruits)

==================== RESTART: E:/Python-Files/ch6/ch6_17.py ====================
    当前列表内容： []
    当前列表内容： ['Apple']
    当前列表内容： ['Apple', 'Banana']
    当前列表内容： ['Apple', 'Banana', 'Orange']
    当前列表内容： ['Apple', 'Banana', 'peach', 'Orange']
    当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange']
    当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange', 'pear']
    所删除的列表内容为： pear
    新的列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange']
    所删除的列表内容为： Banana
    新的列表内容： ['pear', 'Apple', 'peach', 'Orange']
    >>>

### 6.3.4 删除指定的元素remove() ###

在删除列表元素时，有时可能不知道元素在列表内的位置，此时可以使用remove()方法删除指定的元素，它的使用方式如下：

name_list.remove(想删除的元素内容)

如果列表内有相同的元素，则只删除第一个出现的元素，如果想要删除所有相同的元素，必须使用循环。

# ch6_20.py
    cars = ['Honda', 'bmw', 'Toyota', 'bmw']
    cars.remove('bmw')
    print(cars)

==================== RESTART: E:/Python-Files/ch6/ch6_20.py ====================
    ['Honda', 'Toyota', 'bmw']
    >>>

## 6.4 列表排序 ##

### 6.4.1 颠倒排序reverse() ###

reverse()可以颠倒排序列表元素，它的使用方式如下：

name_list.reverse() # 颠倒排序name_list列表元素

# ch6_21.py
    weekday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    print("当前列表内容：",weekday)
    
    # 倒排
    weekday.reverse()
    print("当前列表内容：",weekday)

==================== RESTART: E:/Python-Files/ch6/ch6_21.py ====================
    当前列表内容： ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    当前列表内容： ['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
    >>>

列表经过颠倒排序后，就算是永久性更改了，复原需要再次执行reverse()方法。

### 6.4.2 sort()排序 ###

sort()方法可以对列表元素由小到大进行排序，对于纯数值和纯英文字符串元素排序有非常好的效果。经排序后，原列表的元素顺序会被永久更改。sort()方法的使用格式如下：

name_list.sort()

如果是对英文字符串进行排序，建议先将字符串英文字符全部转成小写或全部转成大写。

==================== RESTART: E:/Python-Files/ch6/ch6_22.py ====================
    目前列表内容： ['java', 'php', 'python', 'c/c++', 'go']
    目前列表内容： ['c/c++', 'go', 'java', 'php', 'python']
    目前列表内容： [3, 2, 1, 9, 8, 6]
    目前列表内容： [1, 2, 3, 6, 8, 9]
    >>>

# ch6_22.py
    languages = ['java', 'php', 'python', 'c/c++', 'go']
    print("目前列表内容：",languages)
    # 使用sort()排序
    languages.sort()
    print("目前列表内容：",languages)
    
    nums = [3, 2, 1, 9, 8, 6]
    print("目前列表内容：",nums)
    # 使用sort()排序
    nums.sort()
    print("目前列表内容：",nums)
    # sort()方法允许由大到小排序，只需在sort()内添加参数“reverse=True"即可
    nums.sort(reverse=True)
    print("目前列表内容：",nums)

## 6.5 进阶列表操作 ##

### 6.5.1 index() ###

这个方法可以返回特定元素内容第一次出现的索引值，它的使用格式如下：

索引值 = 列表名称.index(搜索值)

# ch6_24.py
    city = ['beijing', 'shanghai', 'nanjing', 'guangzhou', 'chongqin', 'chengdu']
    search_str = 'guangzhou'
    i = city.index(search_str)
    print("所搜寻元素 %s 第一次出现位置的索引为 %d" % (search_str, i))
    
    nums = [3, 8, 4, 6, 1024]
    search_val = 8
    j = nums.index(search_val)
    print("所搜寻元素 %d 第一次出现在列表中位置的索引为 %d" % (search_val, j))

==================== RESTART: E:/Python-Files/ch6/ch6_24.py ====================
    所搜寻元素 guangzhou 第一次出现位置的索引为 3
    所搜寻元素 8 第一次出现在列表中位置的索引为 1
    >>>

### 6.5.2 count() ###

该方法可以返回特定元素内容出现的次数。使用格式如下：

次数 = 列表名称.count(搜寻值)

nums = [3, 8, 4, 6, 10, 2, 4]
    search_val = 8
    num = nums.count(search_val)
    print("所搜寻元素 %d 在列表中出现的次数为 %d" % (search_val, num))

所搜寻元素 8 在列表中出现的次数为 1

## 6.6 列表的赋值与复制 ##

### 6.6.1 列表赋值 ###

# ch6_26.py
    sports = ['basketball', 'baseball', 'football']
    sports2 = sports
    print(sports)
    print(sports2)
    
    # 添加元素
    sports.append('table tennis')
    sports2.append('badminton')
    print(sports)
    print(sports2)

==================== RESTART: E:/Python-Files/ch6/ch6_26.py ====================
    ['basketball', 'baseball', 'football']
    ['basketball', 'baseball', 'football']
    ['basketball', 'baseball', 'football', 'table tennis', 'badminton']
    ['basketball', 'baseball', 'football', 'table tennis', 'badminton']
    >>>

使用这种方式，只要其中一个列表发生改变，同时也会影响到另一个列表同步更改。

### 6.6.2 列表的复制 ###

复制的概念是，执行复制后，产生新的列表对象，当一个列表改变时，不会影响到另一个列表的内容（相当于副本）。

# ch6_26.py
    sports = ['basketball', 'baseball', 'football']
    # 复制列表
    sports2 = sports[:]
    print(sports)
    print(sports2)
    
    # 添加元素
    sports.append('table tennis')
    sports2.append('badminton')
    print(sports)
    print(sports2)

==================== RESTART: E:/Python-Files/ch6/ch6_26.py ====================
    ['basketball', 'baseball', 'football']
    ['basketball', 'baseball', 'football']
    ['basketball', 'baseball', 'football', 'table tennis']
    ['basketball', 'baseball', 'football', 'badminton']
    >>>

## 6.7 再谈字符串 ##

在Python的应用中，可以将单一字符串当作是一个序列，这个序列由字符所组成，可想成字符序列。但**与列表不同的是：字符串内的单一元素内容是不可更改的。**

### 6.7.1 字符串的索引 ###

可以使用索引值的方式取得字符串内容，索引方式则与列表相同。

使用正负值索引列车字符串元素内容：

# ch6_29.py
    string = "Python"
    # 正值索引
    print(" string[0] = ", string[0],
          "\n string[1] = ", string[1],
          "\n string[2] = ", string[2],
          "\n string[3] = ", string[3],
          "\n string[4] = ", string[4],
          "\n string[5] = ", string[5])
    
    # 负值索引
    print(" string[-1] = ", string[-1],
          "\n string[-2] = ", string[-2],
          "\n string[-3] = ", string[-3],
          "\n string[-4] = ", string[-4],
          "\n string[-5] = ", string[-5],
          "\n string[-6] = ", string[-6])
    
    # 多重指定概念
    s1, s2, s3, s4, s5, s6 = string
    print("多重指定概念的输出测试：",s1,s2,s3,s4,s5,s6)

==================== RESTART: E:/Python-Files/ch6/ch6_29.py ====================
     string[0] =  P 
     string[1] =  y 
     string[2] =  t 
     string[3] =  h 
     string[4] =  o 
     string[5] =  n
     string[-1] =  n 
     string[-2] =  o 
     string[-3] =  h 
     string[-4] =  t 
     string[-5] =  y 
     string[-6] =  P
    多重指定概念的输出测试： P y t h o n
    >>>

### 6.7.2 字符串切片 ###

### 6.7.2 函数或方法 ###

# ch6_30.py
    string = "Deep Learning" # 定义字符串
    print("打印string第0-2元素：", string[0:3])
    print("打印string第1-3元素：", string[1:4])
    print("打印string第1,3,5元素：", string[1:6:2])
    print("打印string第1到最后元素：", string[1:])
    print("打印string前3元素：", string[0:3])
    print("打印string后3元素：", string[-3:])
    
    # 计算字符串长度
    strlen = len(string)
    print("字符串长度：",strlen)
    # 最大值
    maxstr = max(string)
    print("字符串中最大的unicode码值和字符", ord(maxstr), maxstr)
    # 最小值
    minstr = min(string)
    print("字符串中最小的unicode码值和字符", ord(minstr), minstr)

==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
    打印string第0-2元素： Dee
    打印string第1-3元素： eep
    打印string第1,3,5元素： epL
    打印string第1到最后元素： eep Learning
    打印string前3元素： Dee
    打印string后3元素： ing
    字符串长度： 13
    字符串中最大的unicode码值和字符 114 r
    字符串中最小的unicode码值和字符 32  
    >>>

### 6.7.4 字符串转列表 ###

list()函数可以将参数内的对象转成列表。

### 6.7.5 使用split()处理字符串 ###

split()方法可以将字符串以空格或其他符号为分隔符，将字符串拆开，变成一个列表。

str1.split() # 以空为分隔符将字符串拆分成列表
    str2.split(ch) # 以指定字符为分隔符将字符串拆分成列表

### 6.7.6 字符串的其他方法 ###

*  startswith()：可列出字符串起始文字是否为特定子字符串，是则返回True，否则返回False。
 *  endswith()：列出字符串结束文字是否为特定子字符串，是则返回True，否则返回False。
 *  replace(ch1,ch2)：将ch1字符串由另一字符串替换。
 *  join()：将字符串内的元素以特定字符连接，成为一个字符串。

## 6.8 in和not in语句 ##

主要用于判断一个对象是否属于另一个对象，对象可以是字符串、列表、元组、字典。其语法格式如下：

boolean_value = obj1 in obj2 # 对象obj1在对象obj2内会返回True
    boolean_value = obj1 not in obj2 # 对象obj1不在对象obj2内会返回True

该功能常用于查询某元素是否存在列表中，如果不存在，则将它加入列表内。

# ch6_38.py
    fruits = ['apple', 'banana', 'watermelon', 'pear']
    fruit = input("请输入水果名称：")
    if fruit in fruits:
        print("该水果已存在！")
    else:
        fruits.append(fruit)
        print("已成功将 %s 加入水果清单！" % fruit, fruits)

==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
    请输入水果名称：peach
    已成功将 peach 加入水果清单！ ['apple', 'banana', 'watermelon', 'pear', 'peach']
    >>>

--------------------

**往期文章：**

*  [《Python零基础快乐学习之旅》学习笔记2——认识变量与基本数学运算][Python_2]
 *  [《Python零基础快乐学习之旅》学习笔记3——Python的基本数据类型][Python_3_Python]
 *  [《Python零基础快乐学习之旅》学习笔记4——基本输入与输出][Python_4]
 *  [《Python零基础快乐学习之旅》学习笔记5——程序的流程控制使用if语句][Python_5_if]

[Python_2]: https://blog.csdn.net/username666/article/details/108984204
[Python_3_Python]: https://blog.csdn.net/username666/article/details/108984226
[Python_4]: https://blog.csdn.net/username666/article/details/110963905
[Python_5_if]: https://blog.csdn.net/username666/article/details/111089216