python所有内置常量 python常用内置对象

一、列表

（1）定义

列表里面的元素可以使任何类型的对象
列表由一系列按特定顺序排列的元素组成，用[]表示列表，元素用’隔开
列表既可以说是一种序列，也可以说是一种容器。

>>> a_list=[2,3,3.14,"python",[]]
>>> type(a_list)
<class 'list'>
>>> b_list=[3,2,3.14,"python",[]]
>>> type(b_list)
<class 'list'>
>>> id(a_list)
2250644670144
>>> id(b_list)
2250644671104

（2）元素特点

列表中的元素可以重复
列表元素有一定的顺序
列表元素可以修改

（3）索引和切片

列表的索引与字符串的索引类似
不同点：

>>> lst=['a','b','c','d']
>>> lst[1]=100
>>> lst
['a', 100, 'c', 'd']

而字符串不能进行类似的操作
注：索引值既可以从0开始，也可以设置为负值表示列表的倒数第几个元素

（4）基本操作

>>> lst
['a', 100, 'c', 'd']
>>> lst2=[1,2,3]
>>> lst+lst2
['a', 100, 'c', 'd', 1, 2, 3]

>>> 'a'in lst
True

>>> lst*2
['a', 100, 'c', 'd', 'a', 100, 'c', 'd']

（5）修改、添加、删除列表元素

内置函数和列表方法之间的区别：内置函数得到的是新生成的，不影响原来的

>>> dir(list)
['__add__', '__class__', '__class_getitem__', '__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']

1.append()方法将指定元素添加到列表末尾

>>> lst=[1,2,3,4]
>>> lst.append(5)
>>> lst
[1, 2, 3, 4, 5]
>>> id(lst)
2250615650304
>>> lst.append(6)
>>> lst
[1, 2, 3, 4, 5, 6]
>>> id(lst)
2250615650304

注意：执行append操作没有返回值，列表作为容器在内存中的位置不会改变

2.insert(index,object)方法 在列表的任意位置插入元素
将object插入到索引为index的前面，此操作同样没有返回值。

>>> lst=[1,2,3,4]
>>> lst.insert(1,a)
>>> lst.insert(1,'a')
>>> lst
[1, 'a', 2, 3, 4]

3.extend(self,iterable,/)方法 用可迭代对象的元素来扩展列表
iterable 可迭代对象，而列表就是一个可迭代对象，字符串也是

>>> lst=[1,2,3,4,5]
>>> lst.extend("book")
>>> lst
[1, 2, 3, 4, 5, 'b', 'o', 'o', 'k']

4.del语句 删除指定索引的值
5.pop(index=-1,/)方法 删除指定索引对应的元素，默认值为最右边一个，且返回被删除的元素，以便你继续使用。比如飞机大战项目击败敌方飞机你可能会用到敌机的坐标值，以便添加一个爆炸效果。故del和pop的选择就在于你在删除元素时是否需要继续使用。

>>> lst=[1,2,3,4,5,"book","python"]
>>> lst.pop()
'python'
>>> lst
[1, 2, 3, 4, 5, 'book']
>>> lst.pop(0)
1
>>> lst
[2, 3, 4, 5, 'book']

6.remove(value,/)方法根据值来删除元素
注1：删除对应值的元素，如果有多个相同的值，会删除第一个。需要全部删除的话则需要使用循环来确保删除每个元素。
注2：想要使用值可以先把值赋给变量

>>> lst
[2, 3, 4, 5, 'book']
>>> lst.remove(2)
>>> lst
[3, 4, 5, 'book']
>>> lst.remove("book")
>>> lst
[3, 4, 5]

7.clear()方法

>>> lst=[1,2,3]
>>> lst
[1, 2, 3]
>>> lst.clear()
>>> lst
[]

a=[1,2,3]
a=[] #引用新列表，旧的列表被python当做垃圾自动回收了
a
[]

（6）组织列表

1.sort(*,key=None,reverse=False)方法 # reverse默认为False即从小到大排序，当为True的时候默认是从大到小进行排序.如果是字母的话，则是字母表顺序。对列表元素排列顺序的修改是永久性的。

>>> lst=[1,9,4,6,2,3,0,1]
>>> lst.sort()
>>> lst
[0, 1, 1, 2, 3, 4, 6, 9]
>>> lst.sort(reverse=True)
>>> lst
[9, 6, 4, 3, 2, 1, 1, 0]

>>> players=["blake","westbook","james","kobe"]
>>> players.sort()
>>> players
['blake', 'james', 'kobe', 'westbook']

在列表的切片中**lst[::-1]**中也可以实现反序，但这里得到的是新的对象

注意，不能将不同种类型的元素放在一起进行排序。

2.sorted()函数是对列表临时排序。让你能够以特定的顺序显示列表元素，同时不影响他们在列表中的原始排列顺序

>>> players=["blake","westbook","james","kobe"]
>>> sorted(players)
['blake', 'james', 'kobe', 'westbook']
>>> players
['blake', 'westbook', 'james', 'kobe']
>>> players=["blake","westbook","james","kobe"]
>>> sorted(players,reverse=True)
['westbook', 'kobe', 'james', 'blake']

注：按字母顺序排列列表要复杂一点，并不是所有的值都是小写的。决定排列顺序的时候，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的要复杂。这里作者会随着学习的深入进行相应的补充。

3.reverse()方法。reversed函数。反转列表元素的排列顺序。

>>> lst
[9, 6, 4, 3, 2, 1, 1, 0]
>>> reversed(lst)
<list_reverseiterator object at 0x000001827CD3EC70> #得到的是一个迭代器对象
>>>list(reversed(lst))
[0, 1, 1, 2, 3, 4, 6, 9] #并没有影响原来的列表，而是新生成了一个对象

>>> lst=[9,6,4,3,2,1,1,0]
>>> lst.reverse()
>>> lst
[0, 1, 1, 2, 3, 4, 6, 9]

到这里是不是更清楚的明白了方法和内置函数的区别了呢
4.确定列表的长度len()函数
比如飞机大战项目需要确定敌方还有多少飞机没有被消灭

（7）列表和字符串的比较

1.都是序列
2.列表是容器类对象，列表可变
3.字符串不可变
列表和字符串的转化

>>> s="python"
>>> lst=list(s)
>>> lst
['p', 'y', 't', 'h', 'o', 'n']
>>> "".join(lst)
'python'

string.join(seq) 以string作为分隔符，将seq中的所有元素组合成一个新的字符串

（8）操作列表

1.遍历整个列表
你经常需要对列表的每个元素进行相同的操作。例如，在飞机大战游戏中，你需要所有的界面元素都平移相同的距离。而这可以使用Python的for循环。
例：打印NBA球员名单中的所有名字

>>> for player in NBAplayers:#让python获取列表NBAplayers中的第一个值Paul，并将它和变量player联系起来
...     print(player)
...
Paul
Griffin
Jordan
>>>

注：对列表中的每个元素，都将执行循环指定的步骤，而不管列表包含多少个元素。
2.创建数值列表
需要存储一组数的原因有很多，比如，在王者荣耀游戏中，你需要跟踪每个玩家的位置，在使命召唤手游中你需要跟踪几个玩家的得分。而列表非常适合存储数字集合。
（1）range函数
让python从你指定的第一个数开始，到第二个数结束，并且不包含第二个数。同时，可以使用list()来将range生成的数转换成数字列表。而且还可以指定第三个参数来指定步长。
（2）对数字列表的简单统计计算
min()
max()
sum()
（3）列表解析
当你不明白列表解析的方法，而让你要输出1-10的平方组成的数字列表。你会怎么做呢？

>>> squares=[]
>>> for value in range(1,11):
...     squares.append(value**2)
...
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

好的，那么列表解析就是对这种写法进行了优化，他把for循环和创建新元素的代码合并成了一行。

>>> squares=[value**2 for value in range(1,11)]
>>>
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

首先，指定一个描述性的列表名。定义一个表达式，用于生成要存储到列表中的值。再编写一个for循环来给表达式提供值。
注：这里for循环的结尾不需要加冒号

3.使用列表的一部分
学习了如何处理列表的所有元素，下面来看看如何处理列表的部分元素，Python称之为切片。
而切片的本质就是列表是一种序列，可以通过索引来对列表的部分元素进行处理。使用方法和上文的range函数较为类似。

• 复制列表
  friend_foods=my_foods的这种方法行不通。这只是将friend_foods这个变量关联到已经与my_foods关联的列表。这两个变量指向同一个列表。而不是将my_foods的副本赋值给friend_foods。
  而要复制列表，可以通过创建一个包含整个列表的切片。方法是同时省略起始索引和终止索引。

二、元组

定义：不能修改的值称为不可变，而不可变的列表被称为元组。它既可以用圆括号来定义，也可以用tuple函数来定义,定义完元组后，就可以通过索引来访问元素，就像列表一样。
注意：创建只有一个元素的元组必须加一个逗号，如果没有加逗号，它得到的是一个字符串。因为严格来说元组是由逗号标识的，圆括号只是让元组变得更加整洁和清晰。

>>> t=('a')
>>> t
'a'
>>> t=('a',)
>>> t
('a',)

元组是不可变对象
那么对元组进行改变的时候可以进行如下操作，即将元组转换成列表，进行修改后再转变成元组。

>>> t=(1,2,"python",[1,2,3])
>>> lst=list(t)
>>> lst
[1, 2, 'python', [1, 2, 3]]
>>> lst[1]=200
>>> lst
[1, 200, 'python', [1, 2, 3]]
>>> t=tuple(lst)
>>> t
(1, 200, 'python', [1, 2, 3])

元组也是一种序列，所以序列可以进行的索引切片以及一些基本操作同样适用。
元组的运算速度更快

（1）遍历元组中的所有值

可以类似列表一样使用for循环来遍历元组。

（2）修改元组变量

虽然不能修改元组的元素，但是给存储元组的变量重新赋值是合法的。

注：相比列表，元组是更为简单的数据结构。如果需要存储的一组值在程序的整个生命周期都不改变。那么就可以使用元组。