[ python ] 列表和元组

列表

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

 

列表的增删改查

1. 增加

(A) append 在末尾追加元素

1
2
3
4
5
6
li = ['xiaofei', 'hkey']
li.append('zhangsan')
print(li)
 
# 执行结果:
# ['xiaofei', 'hkey', 'zhangsan']

 

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

1
2
3
4
5
6
li = ['xiaofei', 'hkey']
li.insert(1, 'zhangsan')    # 注意第一个参数是int类型的索引位置,第二个参数是插入的元素
print(li)
 
# 执行结果:
# ['xiaofei', 'zhangsan', 'hkey']

 

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

1
2
3
4
5
6
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) 返回删除的元素,默认删除最后一个

1
2
3
4
5
6
7
8
li = ['xiaofei', 'hkey']
name = li.pop() # 删除最后一个元素并获取到删除的元素
print(name) # 最后一个元素是 'hkey'
print(li)
 
# 执行结果:
# hkey
# ['xiaofei']

 

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

1
2
3
4
5
6
7
li = ['xiaofei', 'hkey']
 
li.remove('xiaofei')    # 参数为指定的元素,删除指定元素。
print(li)
 
# 执行结果:
# ['hkey']

 

(C) clear()     清空列表

1
2
3
4
5
6
li = ['xiaofei', 'hkey']
li.clear()
print(li)
 
# 执行结果:
# []

 

(D) del li 删除li列表

1
2
3
4
5
6
7
li = ['xiaofei', 'hkey']
del li  # 直接删除内存中的 li 列表
 
print(li)
 
# 执行结果:
# NameError: name 'li' is not defined

 

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

1
2
3
4
5
6
7
li = ['xiaofei', 'hkey', 'zhangsan']
 
del li[:2# 删除索引位置 2 之前的元素 [0, 1, 2],不包括 2
print(li)  
 
# 执行结果:
# ['zhangsan']

 

3. 修改 (对于列表来说,修改就是替换)

1
2
3
4
5
6
7
li = ['xiaofei', 'hkey', 'zhangsan']
 
li[2] = 'jay'   # 列表的修改操作,就直接通过索引修改元素内容
print(li)
 
# 执行结果:
# ['xiaofei', 'hkey', 'jay']

 

4. 查询

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

 

5. 列表排序

(A) 正向排序:sort()

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

 

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

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

 

(C) 反转: reverse()

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

 

6. 公共方法

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

1
2
3
4
5
6
li = ['xiaofei', 'hkey', 'jay']
 
print(len(li))
 
# 执行结果:
# 3

 

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

1
2
3
4
5
li = ['xiaofei', 'hkey', 'jay', 'hkey']
print(li.count('hkey')) # 统计同一个元素,在列表中出现几次。
 
# 执行结果:
# 2

 

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

1
2
3
4
5
6
li = ['xiaofei', 'hkey', 'jay', 'hkey']
 
print(li.index('hkey')) # 通过元素信息查找索引位置,默认获取第一个匹配到的元素索引
 
# 执行结果:
# 1

 

元组

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

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

1
2
3
4
5
6
7
8
9
# 把 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() 方法

1
2
3
4
5
6
7
name = ['xiaofei', 'hkey']
print(''.join(name))    # 以空为分隔符将列表连接成字符串类型
print('*'.join(name))   # 以*为分隔符将列表连接成字符串类型
 
# 执行结果:
# xiaofeihkey
# xiaofei*hkey

 

1
2
3
4
5
s1 = 'xiaofei hkey'
print(s1.split())
 
# 执行结果:
# ['xiaofei', 'hkey']

 

range() 的使用

  第一个参数:int类型

  第二个参数:int类型

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

  遵循取头不取尾的规则

 

(1)循环次数的控制

1
2
3
4
5
6
7
8
# 输出 3 次 hello, world
for i in range(3):
    print('hello, world')
 
# 执行结果:
# hello, world
# hello, world
# hello, world

 

(2)数字规则的输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 输出 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. 使用 whilefor 循环分别打印字符串 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)
作业答案
复制代码

 

本文作者:hukey

本文链接:https://www.cnblogs.com/hukey/p/9619317.html

版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   hukey  阅读(921)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示
💬
评论
📌
收藏
💗
关注
👍
推荐
🚀
回顶
收起
  1. 1 彩虹 Jay
彩虹 - Jay
00:00 / 00:00
An audio error has occurred.

彩虹 + 轨迹 (Live) - 周杰伦 (Jay Chou)

彩虹

词:周杰伦

曲:周杰伦

哪里有彩虹告诉我

哪里有彩虹告诉我

能不能把我的愿望还给我

能不能把我的愿望还给我

为什么天这么安静

为什么天这么安静

所有的云都跑到我这里

有没有口罩一个给我

有没有口罩一个给我

释怀说了太多就成真不了

释怀说了太多就成真不了

也许时间是一种解药

也许时间是一种解药

也是我现在正服下的毒药

也是我现在正服下的毒药

看不见你的笑 我怎么睡得着

看不见你的笑 我怎么睡得着

你的声音这么近我却抱不到

你的声音这么近我却抱不到

没有地球太阳还是会绕

没有地球太阳还是会绕

没有理由我也能自己走

没有理由我也能自己走

你要离开 我知道很简单

你要离开 我知道很简单

你说依赖 是我们的阻碍

你说依赖 是我们的阻碍

就算放开 但能不能别没收我的爱

就算放开 但能不能别没收我的爱

当作我最后才明白

当作我最后才明白

看不见你的笑 要我怎么睡得着

看不见你的笑 要我怎么睡得着

你的声音这么近我却抱不到

没有地球太阳还是会绕 会绕

没有理由我也能自己走掉

释怀说了太多就成真不了

也许时间是一种解药 解药

也是我现在正服下的毒药

轨迹

词:黄俊郎

曲:周杰伦

我会发着呆然后忘记你

接着紧紧闭上眼

想着哪一天 会有人代替

想着哪一天 会有人代替

让我不再想念你

我会发着呆 然后微微笑

我会发着呆 然后微微笑

接着紧紧闭上眼

又想了一遍 你温柔的脸

又想了一遍 你温柔的脸

在我忘记之前