记录我的 python 学习历程-Day03 列表/元组/rang

一、列表初识

列表是 Python 的基础数据类型之一，它是以‘‘[ ]’’的形式括起来的，每个元素用“，”隔开，属于容器型数据类型，他可以存放大量的、各种类型的数据。

基本格式
```
li = ['Dylan', 'yaoyao', 1234, True, (1212, '中文'), ['列表'， 'qiantao', {'name':'Dylan'}]]
```
- 可以看到，列表内可以存放多种数据类型，或以嵌套列表，元组，字典，布尔值等。
- 列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。
- 而且列表是有序的，有索引值，可切片，方便取值。

列表的创建

方式一:（常用）
```
l1 = [1, 33, 'Dylan']
```

方式二:（不常用）

l1 = list()	# 默认是空列表
#l1 = list(iterable) # 括号里是一个可迭代对象
l1 = list('12345')
print(l1) # ['1', '2', '3', '4','5']

方式三: 列表推导式（后面会讲到）

l1 = [i for i in range(1, 5)]
print(l1) # [1, 2, 3, 4]  注意看 列表内的数据类型是 int 型

二、列表的索引和切片

索引

l1 = ['a', 'b', 'c', 'd', 'e', 'f']
索引    0    1    2    3    4    5(-1)
# 打印列表中索引0 的值并改回该值的数据类型
print(l1[0], type(l1[0])) # a <class 'str'>
# 打印列表中最后一个索引的值,在不知道列表长度时,一般用 -1 找到列表中最后一个索引的值。
print(l1[-1])  # 等价于 print(l1[5])

切片

切片就是通过索引（索引：索引：步长）截取列表的一段，形成新的列表（原则就是顾头不顾尾）

# 正取  切片规则:顾头不顾尾  格式:l1 = l[首:尾:步长]
l = ['a', 'b', 'c', 'd', 'e', 'f']
l1 = [1:3] # 取了'b','c' 并赋值给新列表 l1
print(l1) # ['b', 'c']
# 倒取  切片规则:顾头不顾尾  格式:l1 = l[首:尾:-步长]
l = ['a', 'b', 'c', 'd', 'e', 'f']
l1 = [4:1:-1] # 取了'e', 'd' ,'c' 并赋值给新列表 l1 注意:反取 步长为负数
print(l1) # ['e', 'd', 'c']

三、列表的增/删/改/查

列表的增删改查是对列表的一系列常用操作，非常重要。

列表的增

l.append( 要插入的数据 ) 插入新元素到列表索引最后一位

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.append('Dylan')
print(l)	# ['a', 'b', 'c', 'd', 'e', 'f', 'Dylan']

举例：人员录入程序,将人员名单录入列表,按 Q 退出录入

hr = []		# 建立一个空列表
while 1:
    username = input("请输入你要录入的人员(退出请按'Q'):")
    if username.strip().upper() == 'Q':
        break
    else:
        hr.append(username)
print(hr)

l.insert( 索引, 要插入的数据 ) 根据索引插入

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.insert(2,'Dylan')		#插入位置=索引位置,原索引位置数据后移一位
print(l)	# ['a', 'b', 'Dylan', 'c', 'd', 'e', 'f']

l.extend( 可迭代对象 ) 迭代插入

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.extend('这是一个可迭代对象')
# l.extend([1,2,3])   #会将列表拆分成单个元素,分别插入
print(l) 	#['a', 'b', 'c', 'd', 'e', 'f', '这', '是', '一', '个', '可', '迭', '代', '对', '象']

列表的删

l.pop( 索引 ) 按索引删除并返回所删除的元素

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.pop(2) 	# 括号里写索引,可以将对应索引的元素删除,并可以反回给一个变量
print(l) 	# ['a', 'b', 'd', 'e', 'f']
print(l.pop(2)) 	# d
l.pop() 	# 括号里不写索引,默认是删除最后一个,并可以将删除的元素反回给一个变量
print(l)	# ['a', 'b', 'd', 'e', 'f']
print(l.pop()) 		# e

l.remove( 元素 ) 按元素删除如果有重名元素，默认删除从左数第一个

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.remove('f')
print(l)	# ['a', 'b', 'c', 'd', 'e',]

l.clear() 清空列表

l = ['a', 'b', 'c', 'd', 'e', 'f']
l.clear()	# 清空列表,但列表还在,只不过是个空列表
print(l)	# []

del 删除列表

l = ['a', 'b', 'c', 'd', 'e', 'f']
# 删除整个列表
del l 	# 将整个列表删除了
# 按照索引删除
del l[-1]
print(l)	# ['a', 'b', 'c', 'd', 'e']
# 按照切片(步长)删除
del l[::2]
print(l)	 # ['a', 'c', 'e']

列表的改

直接改

s = [1,2,3,'fjdkaj','fdsaeddd',1234,'ffdsaecc']
s[0] = 'one'    #直接改,找到对应的索引,直接替换
s[1] = ['one',1,2,3]    #还可以改成列表 list ,直接替换
print(s)

切片改

s = [1,2,3,'fjdkaj','fdsaeddd',1234,'ffdsaecc']
s[0:3] = 'one'    #把0到3拿出来,填上你改的,但是,是迭代的去改,以最小元素为单位
s[0:3] = [1,2,3,8,8,] ##把0到3拿出来,迭代的填上你列表的最小元素,但是,是迭代的去改,以最小元素为单位
print(s)    #打印内容:['o', 'n', 'e', 'fjdkaj', 'fdsaeddd', 1234, 'ffdsaecc']

列表的查

按索引查

l = ['a', 'b', 'c', 'd', 'e', 'f']
print(l[3]) 	# d

按切片(步长)查

l = ['a', 'b', 'c', 'd', 'e', 'f']
print(l[1:4:2]) 	# b d

for i in 迭代查

s = [1,2,3,'fjdkaj','fdsaeddd',1234,'ffdsaecc']
for i in s:     #迭代查
    print(i)

四、列表的嵌套

嵌套形式

l = [1, 2, 3, '1A', ['Dylan', 33],66]
# 列表中的列表称之为嵌套列表，增删改查的方式与列表的相同，同样可以切片可以查改删增。

五、元组

元组又被称为只读列表，可以存储大量的数据，可以索引，切片（步长）。
列表的基本格式与列表相同，不同的是：元组是以圆括号包起来的，而列表是方括号包起来的。
格式如下：
```
t = (1, 2, 'Dylan', [1, 2, 3, 'a', 'b', 'c'])
```
需要注意的是:元组中的数据可查不可增删改，但有个例外就是，元组内如果嵌套了列表，这个列表是可以进行增删改的，方法同列表的增删改查。

元组的拆包

元组通常用于拆包，比如：

a, b = (1, 2)	# 多一个,少一个都不行。
print(a, b) # 1 2

六、range

类似于列表，自定制数字范围的数字列表

r = range(10) # [0,1,2,3,4,5,6,7,8,9]
print(r) 	# range(0, 10)
for i in r:
    print(i)	# 依次打印0到9的数字

l = [1, 2, 3, '1A', ['Dylan', 33],66]
for i in range(len(l)):	# 将列表的索引依次赋值给变量 i
	print(i) # 打印 i (也就是列表的索引)
# len()	获取数据的元素个数