[ python ] 列表和元组

列表

python内置的一种数据类型是列表：list。list 是一种有序集合，可以随时添加和删除其中的元素。

 

列表的增删改查

1. 增加

(A) append 在末尾追加元素

li = ['xiaofei', 'hkey']
li.append('zhangsan')
print(li)

# 执行结果：
# ['xiaofei', 'hkey', 'zhangsan']

 

(B) insert 在指定索引位置插入元素

li = ['xiaofei', 'hkey']
li.insert(1, 'zhangsan')	# 注意第一个参数是int类型的索引位置，第二个参数是插入的元素
print(li)

# 执行结果：
# ['xiaofei', 'zhangsan', 'hkey']

 

(C) extend(iterable) 等价于 for i in li.append(i) 在列表的最后追加一个可迭代对象

li = ['xiaofei', 'hkey']
li.extend('jack')  # 等价于 for i in 'jack': li.append(i) 参数是一个可迭代对象
print(li)

# 执行结果：
# ['xiaofei', 'hkey', 'j', 'a', 'c', 'k']

 

2. 删除

(A) pop(index=None) 返回删除的元素，默认删除最后一个

li = ['xiaofei', 'hkey']
name = li.pop() # 删除最后一个元素并获取到删除的元素
print(name) # 最后一个元素是 'hkey'
print(li)

# 执行结果：
# hkey
# ['xiaofei']

 

(B) remove(value)    按照元素删除

li = ['xiaofei', 'hkey']

li.remove('xiaofei')    # 参数为指定的元素，删除指定元素。
print(li)

# 执行结果：
# ['hkey']

 

(C) clear()     清空列表

li = ['xiaofei', 'hkey']
li.clear()
print(li)

# 执行结果：
# []

 

(D) del li 删除li列表

li = ['xiaofei', 'hkey']
del li  # 直接删除内存中的 li 列表

print(li)

# 执行结果：
# NameError: name 'li' is not defined

 

(E) del li[:2]    切片删除

li = ['xiaofei', 'hkey', 'zhangsan']

del li[:2]  # 删除索引位置 2 之前的元素 [0, 1, 2]，不包括 2
print(li)   

# 执行结果：
# ['zhangsan']

 

3. 修改 （对于列表来说，修改就是替换）

li = ['xiaofei', 'hkey', 'zhangsan']

li[2] = 'jay'   # 列表的修改操作，就直接通过索引修改元素内容
print(li)

# 执行结果：
# ['xiaofei', 'hkey', 'jay']

 

4. 查询

列表的查询可以直接通过切片或者索引直接查询，也可通过for循环遍历，能够被 for 循环遍历的类型都是可迭代对象；

 

5. 列表排序

(A) 正向排序：sort()

li = [6, 5, 3, 1, 2, 4]
li.sort()   # 先进行排序，然后在打印列表,正向排序
print(li)

# 执行结果：
# [1, 2, 3, 4, 5, 6]

 

(B) 逆向排序： sort(reverse=True)

li = [6, 5, 3, 1, 2, 4]
li.sort(reverse=True)   # 先进行排序，然后在打印列表,逆向排序
print(li)

# 执行结果：
# [6, 5, 4, 3, 2, 1]

 

(C) 反转： reverse()

li = [6, 5, 3, 1, 2, 4]
li.reverse()    # 反转排序，将元素倒过来。
print(li)

# 执行结果：
# [4, 2, 1, 3, 5, 6]

 

6. 公共方法

(A) len() 统计列表共有多少元素

li = ['xiaofei', 'hkey', 'jay']

print(len(li))

# 执行结果：
# 3

 

(B) count() 统计同一个元素，在列表中出现几次

li = ['xiaofei', 'hkey', 'jay', 'hkey']
print(li.count('hkey')) # 统计同一个元素，在列表中出现几次。

# 执行结果：
# 2

 

(C)  index() 通过索引查找元素信息

li = ['xiaofei', 'hkey', 'jay', 'hkey']

print(li.index('hkey')) # 通过元素信息查找索引位置，默认获取第一个匹配到的元素索引

# 执行结果：
# 1

 

元组

tuple 元组，只读列表，可循环查询，可切片

因为元组不可变，所以代码更安全。如果可能，能在元组代替列表的地方就尽量使用元组；

# 把 xiaofei 修改为大写

tu = (1,2,3,['xiaofei', 'kk'], 'hkey')

tu[3][0] = tu[3][0].upper()
print(tu)

# 执行结果：
# (1, 2, 3, ['XIAOFEI', 'kk'], 'hkey')

 

元组中的可变类型都是可以修改的，例如：list类型

 

字符串和列表之间的相互转换

列表 -- 字符串　　join() 方法

字符串 -- 列表　　split() 方法

name = ['xiaofei', 'hkey']
print(''.join(name))    # 以空为分隔符将列表连接成字符串类型
print('*'.join(name))   # 以*为分隔符将列表连接成字符串类型

# 执行结果：
# xiaofeihkey
# xiaofei*hkey

 

s1 = 'xiaofei hkey'
print(s1.split())

# 执行结果：
# ['xiaofei', 'hkey']

 

range() 的使用

　　第一个参数：int类型

　　第二个参数：int类型

　　第三个参数：int类型,步长

　　遵循取头不取尾的规则

 

（1）循环次数的控制

# 输出 3 次 hello, world
for i in range(3):
    print('hello, world')

# 执行结果：
# hello, world
# hello, world
# hello, world

 

（2）数字规则的输出

# 输出 10 以内的 奇数 或者 偶数

# 奇数
print(list(range(2, 10, 2)))

# 执行结果：
# [2, 4, 6, 8]


# 偶数
print(list(range(1, 10, 2)))

# 执行结果：
# [1, 3, 5, 7, 9]

 

作业：

1. 有变量 name = 'aleX leNb' 完成如下操作：
    （1）移除 name 变量对应的值两边的空格，并输出处理结果；
    （2）移除 name 变量左边的 'al' 并输出结果；
    （3）移除 name 变量右边的 'Nb'，并输出结果；
    （4）移除 name 变量开头的 'a' 与最后的 'b'，并输出处理结果；
    （5）判断 name 变量是否以 'al' 结尾，并输出结果；
    （6）判断 name 变量是否以 'Nb' 结尾，并输出结果；
    （7）将 name 变量对应的值中的第一个'I' 替换成 'p'，并输出结果；
    （8）将 name 变量对应的值中的一个'i'替换成'p'，并输出结果；
    （9）将 name 变量对应的值根据所有的 'I' 分隔，并输出结果；
    （10）将 name 变量对应的值变大写，并输出结果；
    （11）将 name 变量对应的值变小写，并输出结果；
    （12）将 name 变量对应的值变小写，并输出结果；
    （13）将 name 变量对应的值首字母'a'大写，并输出结果；
    （14）判断 name 变量对应的值字母'i'出现几次，并输出结果；
    （15）如果判断 name 变量对应的值前四位'I'出现几次，并输出结果；
    （16）从 name 变量对应的值中找到 'N' 对应的索引（如果找不到则报错，并输出结果）
    （17）从 name 变量对应的值中找到 'N' 对应的索引（如果找不到则返回-1）输出结果；
    （18）从 name 变量对应的值中找到 'X le'对应的索引，并输出结果；
    （19）请输出 name 变量对应的值的第 2 个字符；
    （20）请输出 name 变量对应的值的前 3 个字符；
    （21）请输出 name 变量对应值的后 2个字符；
    （22）请输出 name 变量对应的值中 'e'所在索引位置；
        
2. 使用 while 和 for 循环分别打印字符串 s='asdfer'中的每个元素；
3. 实现一个整数加法计算器；
如：content = input('输入内容：') # 如用户输入 1+1 2+8 5+
4. 计算用户输入的内容中有几个整数；
如 content=input('请输入内容：') 如；asdfasdf234asdf12sdf

 

name = 'aleX leNb'
# 1. 有变量 name = 'aleX leNb' 完成如下操作：
#     （1）移除 name 变量对应的值两边的空格，并输出处理结果；
print(name.strip())

#     （2）移除 name 变量左边的 'al' 并输出结果；
print(name[2:])

#     （3）移除 name 变量右边的 'Nb'，并输出结果；
print(name[:-3])

#     （4）移除 name 变量开头的 'a' 与最后的 'b'，并输出处理结果；
print(name[1:-1])

#     （5）判断 name 变量是否以 'al' 结尾，并输出结果；
print(name.endswith('al'))

#     （6）判断 name 变量是否以 'Nb' 结尾，并输出结果；
print(name.endswith('Nb'))

#     （7）将 name 变量对应的值中的第一个'l' 替换成 'p'，并输出结果；
name1 = name.replace('l', 'p', 1)
print(name1)

#     （8）将 name 变量对应的值中的一个'l'替换成'p'，并输出结果；
name1 = name.replace('i', 'p', 1)

#     （9）将 name 变量对应的值根据所有的 'l' 分隔，并输出结果；
print(name.split('l'))

#     （10）将 name 变量对应的值变大写，并输出结果；
print(name.upper())

#     （11）将 name 变量对应的值变小写，并输出结果；
print(name.lower())

#     （12）将 name 变量对应的值变小写，并输出结果；
print(name.lower())

#     （13）将 name 变量对应的值首字母'a'大写，并输出结果；
print(name.capitalize())

#     （14）判断 name 变量对应的值字母'l'出现几次，并输出结果；
print(name.count('l'))

#     （15）如果判断 name 变量对应的值前四位'l'出现几次，并输出结果；
print(name[0:5].count('l'))

#     （16）从 name 变量对应的值中找到 'N' 对应的索引（如果找不到则报错，并输出结果）
print(name.index('N'))

#     （17）从 name 变量对应的值中找到 'N' 对应的索引（如果找不到则返回-1）输出结果；
print(name.find('N'))

#     （18）从 name 变量对应的值中找到 'X le'对应的索引，并输出结果；
print(name.find('X le'))

#     （19）请输出 name 变量对应的值的第 2 个字符；
print(name[1])

#     （20）请输出 name 变量对应的值的前 3 个字符；
print(name[2])

#     （21）请输出 name 变量对应值的后 2个字符；
print(name[-2:])

#     （22）请输出 name 变量对应的值中 'e'所在索引位置；
print(name.find('e'))


2. 使用 while 和 for 循环分别打印字符串 s='asdfer'中的每个元素；

s='asdfer'
for i in s:
    print(i)

ite = iter(s)   # 转换为可迭代对象

while True:
    try:
        each = next(ite)    # 使用next循环调用，直到抓到报错退出.
    except StopIteration:
        break
    print(each)


3. 实现一个整数加法计算器；
如：content = input('输入内容：') # 如用户输入 1+1 2+8 5+

content = input('输入内容：')
li = content.split('+')
count = 0
if li[-1] == '':
    li.pop()
    for i in li:
        count += int(i)
print(count)



4. 计算用户输入的内容中有几个整数；
如 content=input('请输入内容：') 如；asdfasdf234asdf12sdf

content=input('请输入内容：')
count = 0
for i in content:
    if i.isdigit():
        count += 1

print(count)


5. 打印li中所有元素，包括list中的元素，逐个打印出来。

li = [1,2,3,4, 'hkey',[5,6,7,8,'xiaobai'], 'abc']

for i in li:
    if isinstance(i, list):
        for j in i:
            print(j)
        continue
    print(i)