《Python程序设计（第二版）》第三章冷门点

最新推荐文章于 2024-07-21 22:27:18 发布

云中君，泉中船（上官云泉）

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量1.1k

点赞数 29

文章标签： python windows 开发语言

本文链接：https://blog.csdn.net/weixin_70523540/article/details/139539449

版权

python小白考前复习

序列:一大类数据容器
字符串
列表
元组
random
- 练习题：随机生成8位密码，由数字和字母组成

序列:一大类数据容器

python内含6种内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象、range对象。
通用操作请添加图片描述

字符串

再看一遍格式化

一般格式如下

{[参数索引或键]：<填充字符><对齐方式><最小宽度.精度><数据类型>}
更多格式化看这章
请添加图片描述
当然还可以用print格式化输出

判断字符串是否为十进制数？得到一个布尔值

v1 = "1238871"
result = v1.isdecimal()
print(result) # True

# 案例,两个数相加。

v1 = input("请输入值：") # ”666“
v2 = input("请输入值：") # ”999“
if v1.isdecimal() and v2.isdecimal():
    data = int(v1) + int(v2)
    print(data)
else:
    print("请正确输入数字")

v1 = "123"
print(v1.isdecimal()) # True

v2 = "①"
print(v2.isdecimal()) # False

v3 = "123"
print(v3.isdigit()) # True

v4 = "①"
print(v4.isdigit()) # True

join字符串

可以理解为先对字符串list一遍再join

s="hello world"
print(":".join(s))#输出：h:e:l:l:o: :w:o:r:l:d

列表

`del`是一个语句而不是函数

大坑

切记，循环的过程中对数据进行删除会踩坑

# 错误方式， 有坑，结果不是你想要的。

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)

print(user_list)

# 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

基操(索引、切片跟字符串差不多)

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[30000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]

函数

Python中的列表（list）是一种非常灵活的数据结构，提供了丰富的内置函数和方法来进行操作。以下是一些常用的与列表相关的函数和方法：

.append(x):

在列表末尾添加一个元素 x。

lst = [1, 2, 3]
lst.append(4)
print(lst)  # 输出: [1, 2, 3, 4]

.extend(iterable):
- 将一个可迭代对象 iterable 中的元素添加到列表末尾。
```
lst.extend([4, 5])
print(lst)  # 输出: [1, 2, 3, 4, 5]
```

.insert(i, x):

将元素 x 插入列表的指定位置 i。

lst.insert(1, 0)
print(lst)  # 输出: [1, 0, 2, 3, 4, 5]

.remove(x):
- 移除列表中第一个值为 x 的元素。
  慎用，没有会报错
```
lst.remove(2)
print(lst)  # 输出: [1, 0, 3, 4, 5]
```

# 案例：自动抽奖程序
import random

data_list = ["iphone12", "二手车", "喵喵", "日本游玩一小时", "棒球"]

while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")

    # 随机从data_list抽取一个值出来
    value = random.choice(data_list) # "二手车"
    print( "恭喜{}，抽中{}.".format(name, value) )

    data_list.remove(value) # "二手车"

.pop([i]):
- 移除列表中指定位置 i 的元素，并返回该元素。如果不指定位置，默认移除并返回列表最后一个元素。
```
item = lst.pop()  # 默认移除并返回最后一个元素
print(item)  # 输出: 5
print(lst)  # 输出: [1, 0, 3, 4]
```

# 案例：排队买火车票

# ["alex","李杰","eric","武沛齐","老妖","肝胆"]
user_queue = []

while True:
  name = input("北京~上海火车票，购买请输入姓名排队(Q退出)：")
  if name == "Q":
      break
  user_queue.append(name)

ticket_count = 3
for i in range(ticket_count):
  username = user_queue.pop(0)
  message = "恭喜{},购买火车票成功。".format(username)
  print(message)

# user_queue = ["武沛齐","老妖","肝胆"]
faild_user = "、".join(user_queue) # "武沛齐、老妖、肝胆"
faild_message = "非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单：{}。".format(faild_user)
print(faild_message)

.clear():
- 清空列表中的所有元素。
```
lst.clear()
print(lst)  # 输出: []
```
.index(x[, start[, end]]):
- 返回列表中第一个值为 x 的元素的索引，可以指定搜索的起始和结束位置。慎用，没有会报错
```
idx = lst.index(3)
print(idx)  # 输出: 2
```

.count(x):

返回列表中元素 x 出现的次数。

count = lst.count(3)
print(count)  # 输出: 1

.sort(key=None, reverse=False):
- 对列表中的元素进行排序。key 为一个函数，用于从列表元素中提取一个用于比较的值。reverse 为布尔值，决定是否降序排序。注意列表内的元素必须可以比较才可以用sort,否则会报错
```
lst = [3, 1, 4, 1, 5, 9]
lst.sort()
print(lst)  # 输出: [1, 1, 3, 4, 5, 9]
 lst.sort(reverse=True)
print(lst)  # 输出: [9,5,4,3,1,1]
```

.reverse():

反转列表中的元素顺序。

lst.reverse()
print(lst)  # 输出: [9, 5, 4, 3, 1, 1]

.copy():

返回列表的浅拷贝。

copy_lst = lst.copy()
print(copy_lst)  # 输出: [9, 5, 4, 3, 1, 1]

len(lst):

返回列表 lst 的长度。

length = len(lst)
print(length)  # 输出: 6

min(lst):

返回列表 lst 中的最小值。

min_value = min(lst)
print(min_value)  # 输出: 1

max(lst):

返回列表 lst 中的最大值。

max_value = max(lst)
print(max_value)  # 输出: 9

sum(lst):
- 返回列表 lst 中所有元素的总和。
```
total = sum(lst)
print(total)  # 输出: 25
```

这些是Python列表中一些常用的方法。列表还支持多种操作，如切片、连接等，以及可以与 +、* 等运算符一起使用来进行合并和重复。Python的列表是可变的，这意味着它们的内容可以在创建后被更改。

案例

welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)

user_count = 0
while True:
    count = input("请输入游戏人数：")
    if count.isdecimal():
        user_count = int(count)
        break
    else:
        print("输入格式错误，人数必须是数字。")

元组

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

如何体现不可变呢？
记住一句话：《“我儿子永远不能换成是别人，但我儿子可以长大”》
也就是元组里元素不能换成其它的，但对于可变的列表来说，如果元组的某个元素是列表，可以对列表的元素进行修改

大坑

v1 = (11,22,33)
v2 = ("李杰","Alex")
v3 = (True,123,"Alex",[11,22,33,44])

# 建议：议在元组的最后多加一个逗v3 = ("李杰","Alex",)

d1 = (1)  # python会把它当作整型1
d2 = (1,) # (1,)

d3 = (1,2)
d4 = (1,2)

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
2. 比较值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么区别？
              (1,2,3)

函数

Python中的元组（tuple）是一种不可变序列类型，与列表类似，但一旦创建就不能更改。由于元组的不可变性，元组相比列表有一些限制，但它们仍然是处理有序数据集合的有用工具。以下是一些常用的元组操作和方法：

创建元组:
- 可以通过圆括号 () 或直接通过逗号分隔的值来创建元组。
```
t = (1, 2, 3)
t_with_empty = (1,)
```
访问元组元素:
- 使用索引来访问元组中的元素。
```
print(t[1])  # 输出: 2
```
元组切片:
- 可以对元组进行切片操作，获取元组的一部分。
```
print(t[1:])  # 输出: (2, 3)
```
len(t):
- 返回元组 t 的长度。
```
print(len(t))  # 输出: 3
```
min(t):
- 返回元组 t 中的最小值。
```
print(min(t))  # 输出: 1
```
max(t):
- 返回元组 t 中的最大值。
```
print(max(t))  # 输出: 3
```
sum(t):
- 返回元组 t 中所有元素的总和。
```
print(sum(t))  # 输出: 6
```
t.count(x):
- 返回元组 t 中元素 x 出现的次数。
```
print(t.count(2))  # 输出: 1
```
t.index(x):
- 返回元组 t 中第一个匹配元素 x 的索引。
```
print(t.index(3))  # 输出: 2
```
不可变操作:
- 由于元组是不可变的，没有提供修改元组内容的方法，如 append()、extend() 或 remove() 等。

元组打包和解包:

可以使用星号 * 来打包或解包元组。

# 打包
a, b, *rest = (1, 2, 3, 4)
print(a, b, rest)  # 输出: 1 2 [3, 4]

# 解包
x, y = 1, 2
x, y = y, x
print(x, y)  # 输出: 2 1

生成元组:

使用生成器表达式可以创建元组。

squares = (x**2 for x in range(5))
print(list(squares))  # 输出: [0, 1, 4, 9, 16]

元组的不可变性使得它们在某些情况下比列表更安全，特别是在需要确保数据不被修改的情况下。此外，元组通常在内存使用和性能方面比列表更高效。

练习题

1：记住一句话：《“我儿子永远不能换成是别人，但我儿子可以长大”》

data = ("123",666,[11,22,33], ("alex","李杰",[999,666,(5,6,7)]) )

# 1.将 “123” 替换成 9   报错

# 2.将 [11,22,33] 换成 "武沛齐"    报错

# 3.将 11 换成 99
data[2][0] = 99
print(data)  # ("123",666,[99,22,33], ("alex","李杰",[999,666,(5,6,7)]) )

# 4.在列表 [11,22,33] 追加一个44
data[2].append(44)
print(data) # ("123",666,[11,22,33,44], ("alex","李杰",[999,666,(5,6,7)]) )

2：动态的创建用户并添加到用户列表中。

# 创建用户 5个
# user_list = [] # 用户信息
user_list = [ ("alex","132"),("admin","123"),("eric","123") ]

while True:
    user = input("请输入用户名：")
    if user == "Q":
        brek
    pwd = input("请输入密码：")
    item = (user,pwd,)
    user_list.append(item)

# 实现：用户登录案例
print("登录程序")
username = input("请输入用户名：")
password = input("请输入密码：")

is_success = False

for item in user_list:
    # item = ("alex","132")   ("admin","123")    ("eric","123")
    if username == item[0] and password == item[1]:
        is_success = True
        break

if is_success:
    print("登录成功")
else:
    print("登录失败")

random

请添加图片描述

练习题：随机生成8位密码，由数字和字母组成

import random

# 生成数字字符的列表
digits = [chr(i) for i in range(48, 58)]
# 生成大写字母和小写字母的列表
ascii_letters = [chr(i) for i in range(65, 91)] + [chr(i) for i in range(97, 123)]

# 数字的个数随机产生
num_of_numeric = random.randint(1, 7)
# 剩下的都是字母
num_of_letter = 8 - num_of_numeric

# 随机生成数字
numerics = [random.choice(digits) for i in range(num_of_numeric)]

# 随机生成字母
letters = [random.choice(ascii_letters) for i in range(num_of_letter)]

# 结合两者
all_chars = numerics + letters

# 重新排列
random.shuffle(all_chars)

# 生成最终字符串
result = "".join([i for i in all_chars])

print(result)

云中君，泉中船（上官云泉）

关注

29
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
《Python程序设计（第二版）》第三章冷门点

Python中的元组（tuple）是一种不可变序列类型，与列表类似，但一旦创建就不能更改。由于元组的不可变性，元组相比列表有一些限制，但它们仍然是处理有序数据集合的有用工具。Python中的列表（list）是一种非常灵活的数据结构，提供了丰富的内置函数和方法来进行操作。也就是元组里元素不能换成其它的，但对于可变的列表来说，如果元组的某个元素是列表，可以对列表的元素进行修改。Python的列表是可变的，这意味着它们的内容可以在创建后被更改。注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。
复制链接

扫一扫