python基础数据类型二

元祖 tupe

概念

元祖被称为只读列表，即数据只可以被查询，不可以被修改。

元祖的修改（不可被修改）

元祖不可被修改。那么为什么还要说元祖的修改呢?

对于一个元祖，它的子辈不可被修改但是它的孙辈可以修改

tu = (1,2,3,[4,5,6])
# 对于tu 1 2 3 list 为它的 子辈
# [4，5，6]         为它的 孙辈
tu[3][1] = 9
-----------
tu = (1,2,3,[9,5,6])

元祖的查询

查找

>>> tu = (1, 2, 3, 4)
>>> tu[1]

2

切片

>>> tu = (1,2,3,4)
>>> tu[:2]

(1, 2)

迭代

>>> tu = (1,2,3,4)
>>> for i in tu:
...     print(i)
...

1
2
3
4

列表 list

概念

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元
素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = ['asd', 12, 34, [1,2,3], {'name':'CharmNight'}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

用法

列表的增加

• append 在列表最后进行追加
• insert 跟据索引添加
• extend 在列表最后进行迭代追加

append

li = [1,'a','b',2,3,'a']
li.append('d')
----------
[1,'a','b',2,3,'a','d']

append()            将元素添加到列表的最后

insert

li = [1,2,3,4]
li.insert(0,5)  # 把5这个元素插入到下标0的前面
--------
[5,1,2,3,4]

insert(index, p_object)     将元素插入到索引的前面

extend

li = [1,2,3,4]
li.extend([5,6])
-------
[1,2,3,4,5,6]

extend(iterable)        将元素迭代插入列表后面

类似于
for i in [5,6]:
    li.append(i)
如果插入列表，会将列表迭代。如果插入字符串，会将字符串迭代

列表的删除

• pop 根据索引删除元素，有返回值
• remove 根据元素删除
• clear 清空列表
• del 从内存中删除列表

pop

唯一一个有返回值的方法

li = [1,2,3,4]
li.pop()            # 删除列表的最后一个元素
---------
4
[1,2,3]

li.pop(1)           # 删除索引为1的元素
--------
2
[1,3,4]

pop(index=None)     #根据索引删除元素，默认为删除最后一个元素
这个方法有返回值      Return 删除的元素

remove

li = [1,2,3,4]
li.remove(1)        # 根据元素删除元素
---------
[2,3,4]

remove(value)       # 根据元素删除

clear

li = [1,2,3,4]
li.clear()
--------
[]

clear()             # 清空列表中的所有元素

del

用法一 从内存中删除列表

li = [1,2,3,4]
del li
print(li)
--------
Traceback (most recent call last):
  File "D:/untitled/demo.py", line 3, in <module>
    print(li)
NameError: name 'li' is not defined

del             从内存中释放列表。 所以再次调用的时候会报错

用法二 切片删除

li = [1,2,3,4,5]
del li[:3]
-------
[4,5]

列表的修改

修改

li = [1,2,3,4]
li[0] = 'CharmNight'

切片修改 所修改的必须为可迭代对象

li = [1,2,3,4]
li[:3] = ['a','b','c','d']
------------
['a', 'b', 'c', 'd', 4]

li[:3] = '你好，再见'
-------------
['你', '好', '，', '再', '见', 4]

由上述可以发现：列表的切片修改是 先将切片的内容删除，在将修改的内容进行迭代添加进去，与个数无关。

列表的查询

通过迭代查询

li = [1,2,3,4,5]
for i in li:
    print(i)   

通过切片查询

li = [1,2,3,4]
# 切片查询
li[0:2]

其他方法

len() 返回列表的长度

>>> li = [1,2,3,4]
>>> len(li)
4

count( sub, start=None, end=None) 返回列表中某个元素重复的次数

可以进行切片操作

>>> li = [1,2,3,1,1,1]
>>> li.count(1)
4

index() 返回元素的索引

找到元素返回元素索引，找不到报错

>>> li = [1,2,3,1,1,1]
>>> li.index(1)
0

sort 排序

sort( key=None, reverse=False)

正序排序

li = [1,3,2,5,4]
li.sort()
print(li)

[1, 2, 3, 4, 5]

倒叙排序

li = [1,3,2,5,4]
li.sort(reverse=True)
print(li)

[5, 4, 3, 2, 1]

reverse() 反转

li = [1,3,2,5,4]
li.reverse()
print(li)

[4, 5, 2, 3, 1]

与 [::-1]的作用相同

列表的嵌套

遍历嵌套的列表

li = [1,2,3,5,'night',[2,3,4,5,'taibai'],'afds']
for i in li:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

or

li = [1, 2, 3, 5, 'night', [2, 3, 4, 5, 'taibai'], 'afds']
for i in li:
    if (isinstance(i,list)):
        for j in i:
            print(j)
    else:
        print(i)

join

拼接字符串、列表

>>> '-'.join('你好')
'你-好'

>>> '-'.jion([1,2,3])
'1-2-3'

list——>str