python基础04

列表 list

创建列表的方式
　　[]
[1,2,3,4]
[1,2,[3,[4,5]],6]

构造函数
list()
list(可迭代对象)

追加数据　，换了虽然值一样　但是换了绑定对象



１０．１１　新内容！！！

列表的比较运算：
　　　运算符：
　　　< <= > >= == !=
说明：
　　　列表的比较规则与字符串的比较规则相同
　　　列表要求每俩个元素能依次进行比较，否则会出现类型
示例：
　　[1,2,3] < [1,2,4] # True
[1,2,3] != [1,2,4] #True
[“One”,“two”] < [“1”,“2”] #False
[1,‘Two’] > [‘Two’,1] #TypeError
比较第一个　相同的话比较下一个　一次决胜负

列表的 in / not in 运算符
　判断一个值是否存在与列表中，如果存在则返回True,否则返回Ｆalse
同字符串的　in 运算符类似

示例
　　x = [1,“Two”,3,“四”]
３ in x # True
“3” in x #False
10 not in x # True

序列：　字符串ｓｔｒ　列表list　元组tuple 字节组、、

列表的索引操作：
　　索引取值语法：
　　　x = 列表[整数表达式]
　用法：
　　　等同于字符串的索引（同样分为正向索引和反向索引）
　　　>>>x = [1,“Two”,3,“四”]
　　　>>>y = [0]
>>>print(y)
1

索引赋值
　列表是可改变的序列，可以通过索引赋值改变列表中的元素
　　语法：
　　　列表[1,2,3,4]
x[2] = 1 + 2.14 #改变了第三个元素

列表的切片取值操作　
　列表[起始索引：终止索引：步长]
　列表的切片取值是从原列表中取出想要的元素再次组成一个新的列表
　示例:
L ＝　[0,1,2,3,4,5,6,7,8,9]
y = L[1:10:2] # y =【１，３，５，７，９】

切片的赋值操作：
　　作用：
　　　可以改变原列表的排列，可以插入，和修改数据
　语法：
　　　列表[切片]　＝　可迭代对象
　说明：
　　　切片赋值的赋值运算符（＝）的右侧必须是一个可迭代对象
示例：
　　　 Ｌ＝[2,3,4]
L[0:1]

  切片的注意事项：
          对于步长不等于１的切片赋值，赋值运算符的右侧的可迭代对象提供的元素的个数，一定等于切片切出的段数

          L = [1,2,3,4,5,6]
          L[::2] = "ABC" #对的
          L[::2] = "abcd"#错的
          一个萝卜一个坑
          del 语句
          　可用于删除列表的元素
          　语法：
          　　del 列表（整数表达式）
             del 列表（切片）


        python3中常用于的序列函数
        len(x) 返回序列的长度
        max(x)  返回序列的最大元素
        min(x)  返回序列中的最小元素
        sum(x)  返回序列中所有元素的和（元素必须是数字类型）

any(x) 真值测试，如果列表中的一个值为真值则返回true
all(x) 真值测试，如果列表中的所有值为真值则返回true

        示例
        　　L = ['Beijing',1,123]
           print(len(L)) # 3

L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误

L.insert(index, obj) 将某个元素插放到列表中指定的位置
L.count(x) 返回列表中元素的个数
L.remove(x) 从列表中删除第一次出现在列表中的值
##[1, 5, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3]

L.remove(5)
L
[1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3]

L.copy() 复制此列表（只复制一层，不会复制深层对象)
#L2 = L.copy()
L.append(x) 向列表中追加单个元素
＃＃＃[1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6]
　　　>>> L.append(8)
　　　>>> L
　　　[1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6, 8]
　　　 放到最后面
[1, 2, 3, 4, 5, 6]

L.append([4,5,6])
L
[1, 2, 3, 4, 5, 6, [4, 5, 6]]
L.extend(lst) 向列表追加另一个列表
##L.extend(L)

L
[1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6, 8, 1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6, 8]

L.extend([8,5,2,9,6,3])
L
[1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6, 8, 1, 9, 8, 5, 4, 7, 9, 6, 5, 2, 3, 100, 6, 8, 8, 5, 2, 9, 6, 3]
L.clear() 清空列表,等同于 L[:] = []
L.sort(reverse=False) 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
##L.sort(reverse=True) :从大到小
L.reverse() 列表的反转，用来改变原列表的先后顺序
L.pop([index]) 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

深拷贝　deep copy 和　浅拷贝　shallow copy

浅拷贝
　　　浅拷贝是指在复制过程中，只复制一层变量，不含复制深层变量绑定的对象的复制过程
　　　如：
　　　　　L = [3.1,3.2]
L1 = [1,2,L]
L2 = L1.copy() #浅拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L2) #[1, 2, [3.14, 3.2]]
print(L1) #[1, 2, [3.14, 3.2]]

深拷贝　deep copy
　如：
import copy #导入复制模块
　　　　　L = [3.1,3.2]
L1 = [1,2,L]
L2 = L1.copy.deepcopy(L1) #深拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L2) #[1, 2, [3.1, 3.2]]
print(L1) #[1, 2, [3.14, 3.2]]

列表与字符串　比较
　列表和字符串都是序列，元素之间有先后顺序关系
　列表和字符串有相同的操作　：　＋　＋＝　＊　＊＝　> < in ..
 字符串是不可变化的序列，列表是可变的序列
 字符串的每个元素只能存储字符，而列表可以存储热任意的元素
 列表和字符串都是可迭代对象

 字符串的文本解析方法　split 和　join
 S.split(sep=None) 将字符串使用ｓｅｐ作为分隔符分割字符串
 返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符
 s.join(iterable) 用可迭代对象中的字符串生成一个中间用ｓ进行分割的字符串
 示例：
 　s = 'beijing is capital'
  l = s.split(" ")  #l = ['beijing', 'is', 'capital']
  s2 = " ".join(l) #s2 = "beijing##is##capital"

  split 是把字符串分割
  join 可以填充东西　可以分开
  >>> l = " ".join("chenhuaqi")

l
‘c h e n h u a q i’

l = “-”.join(“chenhuaqi”)
l
‘c-h-e-n-h-u-a-q-i’

列表推到式　list comprehesin
列表推到式是用可迭代对象创建列表的表达式
作用：
　　　创建列表
　语法：
　　　 [表达式　for 变量　in 可迭代表达式]　或【表达式　for 变量　in 可迭代表达式　ｉｆ　真值表达式】
示例：
　　　生成一个数值为１－９的平方的列表
　　Ｌ＝【Ｘ＊＊２　for x in range(1,10)】
#L = [1,4,9,16,…,64,81]

列表推到式的嵌套语法：
[表达式
　　for 变量１ in 可迭代对象１　if 真值表达式1
for 变量２　in 可迭代对象２ if 真值表达式２
　　．．．．]
如：
　　L = [x + y for x in “ABC” for y in “123”]
L = [‘A1’, ‘A2’, ‘A3’, ‘B1’, ‘B2’, ‘B3’, ‘C1’, ‘C2’, ‘C3’]