Python基础2

Python基础2

1.列表

• 列表是Python中最具有灵活性的有序集合对象类型。

• 可以包含任何种类的对象：数字、字符串甚至一塔列表

• 与字符串不同，列表都是可变对象（可以实时的增长或者缩短长度）

• 可以包含任何类型的对象而不仅仅是包含有单个字符的字符串（异构）

• 可任意嵌套（创建列表的子列表）

  常见列表常量和操作

L1=[] 空列表
L2=[0,1,2,3,4] 五项，索引从0到4
L3=['a','b',['ab']] 嵌套的子列表
L4=["sara","nancy","glory","frank","hello"]
L4[i] 索引
L4[i][j] 索引的索引
len(L4) 求长度
print("L1:",L1)
print("L2:",L2)
print("L4:",L4)
print("L4[1:3]",L4[1:3]) L4[i:j] 分片
print("L1+L2",L1+L2) L1+L2 合并
print("L2*3",L2*3) 重复
L4.append("cidy")追加元素
L2.extend([7,8,9])增长
L2.sort()排序
L2.index(1)搜索
L2.insert(A,B)插入
L2.reverse()反转
裁剪
del L2[3]
del L2[i:j]
L2.pop()
L2.remove(2)

2.直接复制、深浅拷贝

在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。

• 直接赋值：其实就是对象的引用（别名）。

  L4=["sara","nancy","glory","frank","hello"]
  L6=L4
  print("id(L4):",id(L4))
  print("id(L6):",id(L6))
  运行结果：
  id(L4): 2391896432008
  id(L6): 2391896432008
  

• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

  • 常见的浅拷贝有：切片操作、工厂函数、对象的copy()方法、copy模块中的copy函数。

  • 用 [:]或copy()

    import copy
    n1 = {"k1": "a", "k2": "b", "k3": ["c", "d"]}
    n3 = copy.copy(n1)  # 浅拷贝
    print("第一层字典的内存地址：")
    print(id(n1))
    print(id(n3))
    print("第二层嵌套的列表的内存地址：")
    print(id(n1["k3"]))
    print(id(n3["k3"]))
    运行结果：
    第一层字典的内存地址：
    2269704678424
    2269705275360
    第二层嵌套的列表的内存地址：
    2269702265992
    2269702265992
    

    通过以上结果可以看出，进行浅拷贝时，我们的字典第一层n1和n3指向的内存地址已经改变了，但是对于第二层里的列表并没有拷贝，它的内存地址还是一样的。

• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

  • copy 模块的 deepcopy 方法

    import copy
    n1 = {"k1": "a", "k2": "b", "k3": ["c", "d"]}
    n3 = copy.deepcopy(n1)  # 深拷贝
    print("第一层字典的内存地址：")
    print(id(n1))
    print(id(n3))
    print("第二层嵌套的列表的内存地址：")
    print(id(n1["k3"]))
    print(id(n3["k3"]))
    运行结果：
    第一层字典的内存地址：
    2076549442656
    2076550040312
    第二层嵌套的列表的内存地址：
    2076547030216
    2076547029832
    

    通过以上结果发现，进行深拷贝时，字典里面的第一层和里面嵌套的地址都已经变了。对于深拷贝，它会拷贝多层，将第二层的列表也拷贝一份，如果还有第三层嵌套，那么第三层的也会拷贝

3.元组（通常写成圆括号）

Python的元组和列表类似，不同之处在于元组中的元素不能修改(因此元组又称为只读列表)，且元组使用小括号而列表使用中括号

• 是不可变的，是一个位置有序的对象的集合
• 同字符串，列表一样，元素通过偏移来访问
• 固定长度
• 可以包含任何类型的对象而不仅仅是包含有单个字符的字符串（异构）
• 可任意嵌套（创建列表的子列表）
• 对象引用的数组，元组存储指向其他对象的存取点（引用），并且对元组进行索引操作的速度相对较快

()  空元组
t1=(0,)单个元素的元组
t2=0，'a','b',3,4 五个元素的元组
t3=('a',('ad','dg')) 嵌套元组

注意：

1、元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

t1=(1,)

2、元组中的元素值使不允许修改的，但可以对元组进行连接组合

>>> (1,2)+(3,4)
(1, 2, 3, 4) #合并
>>> (1,2)*4
(1, 2, 1, 2, 1, 2, 1, 2)  #重复

3、元组中的元素是不允许删除的，但可以使用del语句来删除整个元组

t2 = ('physics', 'chemistry', 1997, 2000)
print(t2)
del t2
print("After deleting tup : ")
print (t2)
运行结果：
('physics', 'chemistry', 1997, 2000)
After deleting tup : 
Traceback (most recent call last):
  File "E:/python/Class1.py", line 5, in <module>
    print (t2)
NameError: name 't2' is not defined

4、元组运行切片操作

>>> t1=(1,2,3,4,5,6)
>>> t1[0],t1[1:3]  #索引，切片
(1, (2, 3))
>>> len(t1)
6 

5、对元组进行操作的内建函数

cmp(t1,t2): 比较两个元组元素

len(t1): 返回元组中元素的个数

max(t1): 返回元组中元素最大的值

min(t1): 返回元组中元素最小的值

tuple(L4): 将列表转化为元组

L4=["sara","nancy","glory","frank","hello"]
print(tuple(L4))
运行结果：
('sara', 'nancy', 'glory', 'frank', 'hello')

8、元组的方法（元组没有列表中的增、删、改的操作，只有查的操作）

t1.index(obj)：从元组中找出某个值第一个匹配项的索引值

t2 = ('physics', 'chemistry', 1997, 2000)
print(t2.index('physics'))
运行结果：
0
print(t2.index('a'))
运行结果：
ValueError: tuple.index(x): x not in tuple

t2.count(obj)： 统计某个元素在元组中出现的次数

t2 = ('physics', 'chemistry', 1997, 2000)
print(t2.count(1997))

4.序列类型

序列：字符、列表、元组
所有序列都支持迭代
序列表示索引为非负整数的有序对象集合
字符和元组属于不可变序列，列表可变

序列之间的相互转换

字符串和列表

import string
str='abcdef'
list=list(str)
print(list)
str_convert="".join(list)
print(str_convert)
运行结果：
['a', 'b', 'c', 'd', 'e', 'f']
abcdef

元组和列表

L4=["sara","nancy","glory","frank","hello"]
t1=tuple(L4) #列表转换为元组
print(t1)
new_L4=list(t1) #元组转换为列表
print(new_L4)
('sara', 'nancy', 'glory', 'frank', 'hello')
['sara', 'nancy', 'glory', 'frank', 'hello']

字符串和元组

import string
str='abcdef'
tuple=tuple(str)
print(tuple)
str_convert="".join(tuple)
print(str_convert)
运行结果：
('a', 'b', 'c', 'd', 'e', 'f')
abcdef

5.定义一个列表，包含自己的家庭成员，并在指定位置插入给定元素，例如你的男女朋友名称等。再将男女朋友名字移除等操作。

L1=["aa","bb","cc","dd"]
#将sara和cidy分别加入到2和4的位置
L1.insert(1,"sara")
L1.insert(3,"cidy")
print("输出添加后的家庭成员：",L1)
#将sara和cidy移除
L1.remove("sara")
L1.remove("cidy")
print("输出移除后的家庭成员：",L1)

运行结果：
输出添加后的家庭成员： ['aa', 'sara', 'bb', 'cidy', 'cc', 'dd']
输出移除后的家庭成员： ['aa', 'bb', 'cc', 'dd']