标签：__ name temp Python list1 列表 元祖

部分内容整理来自《零基础入门学习Python》–小甲鱼 编著

一、列表:打了激素的数组
数组这个概念呢，就是把一大堆同种类型的数据挨个排放在一起，然后通过数组下标进行索引。但数组有一个基本要求，就是你所放在一起的数据必须类型一致。由于Python的变量没有数据类型，也就是说，Python是没有数组的。但是呢，Python加入了更为强大的列表。

• 创建列表
  创建列表和创建普通变量一样，用中括号括起来一堆数据就可以了，数据之间用逗号隔开，这样一个普普通通的列表就创建成功了：

>>> number = [1, 2, 3, 4, 5]
>>> list1 = [1, "kugua", 3.14, [1, 2, 3]]
>>> empty = []  #创建一个空列表

说数组是打了激素的列表是不无道理的，可以创建一个鱼龙混杂的列表，列表里可以有整型、字符串、浮点型，甚至列表里面包含另一个列表，如果实在想不到往列表里面塞什么数据的时候，可以创建一个空列表。

• 列表中的小伙伴

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', 
'__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', 
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 
'remove', 'reverse', 'sort']

• 向列表中添加元素
  append( ) 方法用于在列表后面追加一个元素，多个元素会报错。
  extend( ) 方法使用一个列表拓展另一个列表，所以它的参数是一个列表。
  insert( ) 方法可以在列表任意位置插入元素。insert（ ）方法有两个参数：第一个参数代表在列表中的位置，第二个参数是在这个位置处插入的一个元素。

>>> number = [1, 2, 3, 4, 5]
>>> number.append(6)  #列表末尾追加元素“6”
>>> number
[1, 2, 3, 4, 5, 6]

>>> number.extend([7, 8])
>>> number
[1, 2, 3, 4, 5, 6, 7, 8]
>>> number.insert(1,0)
[1, 0，2, 3, 4, 5, 6, 7, 8]
>>> number.insert(0, 0)  #在列表最开头位置插入元素“0”
[0，1, 0，2, 3, 4, 5, 6, 7, 8]

• 从列表中获取元素

跟数组一样，可以通过元素的索引值（index）从列表中获取单个元素，注意，列表索引值是从0开始的：

>>> name =["鸡蛋","鸭蛋","鹅蛋","狗蛋"]
>>> name[0]
'鸡蛋'
>>> name[3]
'狗蛋'

按照这个方法可以让“狗蛋”和“鸭蛋”的位置互调：

>>> name[1],name[3] = name[3],name[1]
>>> name
['鸡蛋', '狗蛋', '鹅蛋', '鸭蛋']

• 从列表删除元素

remove( )方法移除列表中的元素（给定内容）
del 语句删除列表某个元素（给定索引）、删除整个列表、切片删除
clear()方法可以清空列表

>>> name = ["鸡蛋", "狗蛋", "鹅蛋", "鸭蛋"]
>>> name.remove("狗蛋")  #移除列表中的元素
>>> name
['鸡蛋', '鹅蛋', '鸭蛋']

>>> del name[2:]
>>> name
['鸡蛋', '鹅蛋']
>>> name.clear()
>>> name
[]

>>> name = ['鸡蛋', '鹅蛋', '鸭蛋']
>>> del name[1] 
>>> name
['鸡蛋', '鸭蛋']

>>> del name  #删除整个列表
>>> name
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    name
NameError: name 'name' is not defined

pop( )方法默认“弹出”列表中的最后一个元素。
当给它加上一个索引值作为参数的时候，弹出这个索引值对应的元素。

>>> name = ["鸡蛋", "狗蛋", "鹅蛋", "鸭蛋"]
>>> name.pop()
'鸭蛋'
>>> name.pop()
'鹅蛋'
>>> name
['鸡蛋', '狗蛋']


>>> name = ["鸡蛋", "狗蛋", "鹅蛋", "鸭蛋"]
>>> name.pop(2)  #弹出列表中索引为2的元素（第三个元素）
'鹅蛋'
>>> name
['鸡蛋', '狗蛋', '鸭蛋']

- 其他常见小伙伴

• count ( )方法用于计算它的参数在列表中出现的次数
• index( )这个方法会返回它的参数在列表中的位置。index( )有3个参数，第一个是要查找的参数，后面两个参数用于限定参数查找范围
• copy()方法可以用来复制一个列表（深copy）

>>> list1 = [1, 1, 2, 3, 5, 8, 13, 21]
>>> list1.count(1)
2
>>> list1.index(1)
0

#查找第二个目标在list1中的位置
>>> start = list1.index(1) + 1
>>> stop = len(list1)
>>> list1.index(1, start, stop)
1

• reverse( )方法的作用是将整个列表原地翻转。

>>> list1 = [1, 2, 3, 4, 5, 6, 7, 8]
>>> list1.reverse()  
>>> list1
[8, 7, 6, 5, 4, 3, 2, 1]

• sort( ) 方法是以指定的方式对列表成员进行排序，默认不需要参数，从小到大排序。 sort(func, key, reverse)
  func:算法 key：关键字
  reverse：默认值sort(reverse=False)表示颠倒顺序，如果要实现从大到小排序，可以将reverse重新赋值为True。

>>> list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
>>> list1.sort()
>>> list1
[0, 1, 2, 3, 5, 6, 8, 9, 10]

>>> list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
>>> list1.sort(reverse =  True)   #指定逆序的方式排序（从大到小）
>>> list1
[10, 9, 8, 6, 5, 3, 2, 1, 0]

列表分片：[起始:结束:步长] ，列表切片起始位置上的元素是包含的，结束位置上的元素是不包含的。利用列表分片，得到一个原来列表的拷贝，原来的列表没有发生变化。

>>> name = ["鸡蛋", "狗蛋", "鹅蛋", "鸭蛋"]
>>> name[0:2]      #取前两个元素
['鸡蛋', '狗蛋']
>>> name[:2]       #取前两个元素
['鸡蛋', '狗蛋']
>>> name[1:]       #取第一个元素到最后
['狗蛋', '鹅蛋', '鸭蛋'] 
>>> name[:]      #复制一个列表
['鸡蛋', '狗蛋', '鹅蛋', '鸭蛋']

>>> list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1[0:9:2]     #以步长为2取元素组合成一个新的列表
[1, 3, 5, 7, 9]

>>> list1[::-1]      #步长设置为-1，相当于复制一个反转的列表
[9, 8, 7, 6, 5, 4, 3, 2, 1]

• 列表拷贝概念补充
  上面提到使用分片创建拷贝的列表：

>>> list1 = [1, 3, 2, 9, 7, 8]
>>> list2 = list1[:]   #拷贝列表
>>> list2
[1, 3, 2, 9, 7, 8]

>>> list3 = list1   #给储存空间中的[1, 3, 2, 9, 7, 8]另起一个名字叫做list3
>>> list3
[1, 3, 2, 9, 7, 8]

利用列表里面的小伙伴做以下修改，大家看看差别：

>>> list1.sort()
>>> list1
[1, 2, 3, 7, 8, 9]
>>> list2
[1, 3, 2, 9, 7, 8]
>>> list3   #也跟着变
[1, 2, 3, 7, 8, 9]

不知道大家还记不记得前面变量里面的内容，Python的变量就像一个标签，就一个名字而已…看下图理解

这下大家应该明白了吧，为列表指定一个名字的做法，只是向列表增加一个新的标签而已，真正的拷贝是要使用分片的方法。这个也是初学者最容易混淆的地方，大家以后写代码一定要注意哦。

• 列表推导式（列表解析）
  列表推导式（List comprehensions）也叫列表解析，灵感取自函数式编程语言Haskell。Ta是一个非常有用和灵活的工具，可以用来动态地创建列表，语法：
  [有关A的表达式 for A in B]

>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> [i**2 for i in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

#上面的列表生成式相当于：
>>> list1 = []
>>> for x in range(10):
	list1.append(x)
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

- 一些常用操作符

• 列表也可以比较大小（列表第一个元素第一个字符ASIIC码，相等则比较下一个）
• 可以用加号（+）来拼接字符，用（*）号来复制自身若干次
• 复合赋值运算符也可用于列表
• 成员关系运算符 in 和 not in （只能判断一个层次的成员关系，如果需要判断列表中的元素，应该先进入一层列表）

>>> list1 = [123]
>>> list2 = [234]
>>> list1 > list2
False

>>> list1 = [123, 456]
>>> list2 = [234, 123]
>>> list3 = list1 + list2
>>> list3
[123, 456, 234, 123]

>>> list1 = [123]
>>> list1 *=3
>>> list1
[123, 123, 123]

>>> list1 = ["小猪", "小猫", ["小鱼","小鸟"],"小狗"]
>>> "小猫" in list1
True
>>> "小熊猫" not in list1
True
>>> "小鱼" not in list1
True
>>> "小鱼" not in list1[2]
False

二、元祖：戴上了枷锁的列表
元祖和列表最大的区别就是你可任意任意修改列表中的元素，可以任意插入或者删除一个元素，而对元祖是不行的，元祖是不可以改变的（想字符串一样），所以你也别指望对元祖进行原地排序等高级操作了。
ps ：元祖里面的列表里面的内容可以修改（理解：用内存空间理解）

• 创建和访问一个元祖
  创建列表用的是中括号，而创建元祖大部分用的是小括号。

>>> tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)

访问元祖的方式与列表无异，也可以使用分片来复制一个元祖：

>>> tuple1[1]
2
>>> tuple1[5:]
(6, 7, 8)
>>> tuple1[:5]
(1, 2, 3, 4, 5)

>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8)

• 列表的标志符号是中括号（[ ]）,而元祖的标志符号是逗号（,）,不是小括号（）:

>>> temp = (1)
>>> type(temp)
<class 'int'>
>>> temp = 1, 2, 3
>>> type(temp)
<class 'tuple'>

创建一个空元祖，直接用小括号即可；如果创建的元祖只有一个元素，请在它的后面加上一个逗号（,）这样可以明确告诉Python你要的是一个元祖，不要拿什么整型、浮点型来忽悠你。

>>> temp = ()
>>> type(temp)
<class 'tuple'>
>>> temp = (1,)
>>> type(temp)
<class 'tuple'>

>>> 8 * (8)  
64
>>> 8 * (8,)   #逗号起到了决定性作用
(8, 8, 8, 8, 8, 8, 8, 8)

• 更新和删除列表 （委屈求全）
  和字符串一样，通过拷贝现有的字符串片段构造一个新的字符串可以更新一个字符串，对元祖也是使用同样的方法：（狸猫换太子，让变量指向一个新构造出来的元祖以实现更新）

>>> temp = ("小鱼", "小鸟", "小狗")
>>> temp = temp[:2] + ("小杰",) + temp[2:]
>>> temp
('小鱼', '小鸟', '小杰', '小狗')

#间接删除元祖中的元素
>>> temp = temp[:2] + temp[3:]
>>> temp
('小鱼', '小鸟', '小狗')
>>> del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    temp
NameError: name 'temp' is not defined

作业：
1.查找列表li中的元素，移除每个元素的空格，
并找出以’A’或者’a’开头，并以’c’结尾的所有元素，
并添加到一个新列表中,最后循环打印这个新列表。
li = [‘taibai ’,’alexC’,’AbC ’,’egon’,’ Ritian’,’ Wusir’,’ aqc’]

#方法一
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir','  aqc']   jiexin
b = []

for ls in li:
    ls = ls.strip()
    if (ls.startswith("A") or ls.startswith("a")) and ls.endswith('c'):
        b.append(ls)
print(b)

#方法二
for i in li:
    s=i.strip()
    if s[0].upper() == 'A' and s[-1] == 'c':
        b.append(s)
for x in b:
    print(x)

2.
开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
敏感词列表 li = ["Python,"Java,”c#”,”PHP”]
则将用户输入的内容中的敏感词汇替换成***，并添加到一个列表中；
如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中。

li = ["Python,"Java,”c#”,”PHP”]
new_list = []
mes = input("Please make your coment:")
for each_invid_name in li:    #对于每一个敏感词
    if each_invid_name in mes:     #如果该敏感词包含在用户评论中
        length = len(each_invid_name)
        mes = mes.replace(each_invid_name, "*" * length)    #替换敏感词
new_list.append(mes)
print(new_list)

标签：__,name,temp,Python,list1,列表,元祖
来源： https://blog.csdn.net/qq_41823444/article/details/89196901

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。