day06-字符串操作与列表-CSDN博客

本文链接：https://blog.csdn.net/zhx13469781541/article/details/131969060

作业

print()
"""
1、1-100之间的奇数累加求和并且奇数中是7的倍数要进行过滤不进行累加。 使用while循环
2、0,1,2,3,4能组成多少个各个位数都不重复的三位数 使用for循环进行输出 并统计个数
"""

# 1
# a = 0
# b = 0
# while a < 100:
#     a += 1
#     if a % 2 == 1 and a % 7 != 0:
#         print(a)
#         b += a
# print(b)  # 2157

# 2     123 T   234 T     012 F
count = 0
for i in range(1, 5):  # 1 2 3 4
    for j in range(0, 5):  # 0 1 2 3 4
        for k in range(0, 5):  # 0 1 2 3 4
            if i != j and i != k and j != k:
                num = f"{i}{j}{k}"
                print(int(num),type(int(num)))
                count += 1
print(f"总共符合的三位数有{count}个")
"""
缩进  tab 
多行缩进   选中多行 然后tab
取消缩进  shift tab


注释    ctrl + /
多行注释   选中多行  然后 ctrl+/ 
取消注释  选中一行或多行  然后再按一次2  ctrl+/
"""

102 <class 'int'>
103 <class 'int'>
104 <class 'int'>
120 <class 'int'>
123 <class 'int'>
124 <class 'int'>
130 <class 'int'>
132 <class 'int'>
134 <class 'int'>
140 <class 'int'>
142 <class 'int'>
143 <class 'int'>
201 <class 'int'>
203 <class 'int'>
204 <class 'int'>
210 <class 'int'>
213 <class 'int'>
214 <class 'int'>
230 <class 'int'>
231 <class 'int'>
234 <class 'int'>
240 <class 'int'>
241 <class 'int'>
243 <class 'int'>
301 <class 'int'>
302 <class 'int'>
304 <class 'int'>
310 <class 'int'>
312 <class 'int'>
314 <class 'int'>
320 <class 'int'>
321 <class 'int'>
324 <class 'int'>
340 <class 'int'>
341 <class 'int'>
342 <class 'int'>
401 <class 'int'>
402 <class 'int'>
403 <class 'int'>
410 <class 'int'>
412 <class 'int'>
413 <class 'int'>
420 <class 'int'>
421 <class 'int'>
423 <class 'int'>
430 <class 'int'>
431 <class 'int'>
432 <class 'int'>
总共符合的三位数有48个

进程已结束,退出代码0

列表与元组

<a name="d6c84792"></a>
## 列表的应用场景
> **思考：如果⼀个班级100位学⽣，每个⼈的姓名都要存储，应该如何书写程序？声明100个变量吗？**<br />**答：列表即可， 列表⼀次性可以存储多个数据。**

<a name="0868ba3c"></a>
## 列表的创建 
**列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。**
```python
使用 [ ] 直接创建列表
li = [1,2,3,4,"张三","李四"]
使用 list() 函数创建列表
li2 = list('123456789')
```
> **列表可以⼀次性存储多个数据，且可以为不同数据类型**

<a name="RSwpR"></a>
## 列表的常用操作
> **列表的作用是⼀次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查等等。**

<a name="ils4D"></a>
### 访问列表中的值
<a name="6bdc03f7"></a>
#### 根据索引访问列表元素
```python
使用索引访问列表元素的格式为:
listname[i]

name_list = ['张三', '李四', '王五','赵六']
print(name_list[0])
print(name_list[1])
print(name_list[2])
```
<a name="QJZan"></a>
#### 根据切片访问列表元素
```python
使用切片访问列表元素的格式为：
listname[start : end : step]
name_list = ['张三', '李四', '王五','赵六']
print(name_list[0:4:2])
```
<a name="870a51ba"></a>
#### 通过内置函数返回列表下标

- **index()：返回指定数据所在位置的下标 。**

**语法**
```python
# 列表序列.index(数据, 开始位置下标, 结束位置下标)
name_list = ['张三', '李四', '王五','赵六']
print(name_list.index('张三', 0, 2))
```
> **注意：如果查找的数据不存在则报错。**

- **count()：统计指定数据在当前列表中出现的次数。**
```python
name_list = ['张三', '李四', '王五','张三']
print(name_list.count('张三'))
```

- **len()：访问列表长度，即列表中数据的个数。**
```python
name_list = ['张三', '李四', '王五','赵六']
print(name_list.count('Tom'))
```
<a name="6f037ef5"></a>
#### in与not in
> **in：判断指定数据在某个列表序列，如果在返回True，否则返回False**
> **not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False**

```python
name_list = ['张三', '李四', '王五','赵六']
name = input('请输⼊您要搜索的名字：')
if name in name_list:
    print(f'您输⼊的名字是{name}, 名字已经存在')
else:
    print(f'您输⼊的名字是{name}, 名字不存在')
```
<a name="ZHtBM"></a>
### 列表添加元素
> **作⽤：增加指定数据到列表中。**

<a name="JbtN6"></a>
#### append()方法用于在列表的末尾追加元素
**语法**
```python
# 列表序列.append(数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.append('阿坤')
print(name_list)
```
> 如果append()追加的数据是⼀个序列，则追加整个序列到列表

```python
name_list = ['张三', '李四', '王五','赵六']
alist = ["唱","跳","rap","篮球"]
name_list.append(alist)
print(name_list)
# ['张三', '李四', '王五', '赵六', ['唱', '跳', 'rap', '篮球']]
```
<a name="PyMAW"></a>
#### extend()方法用于在列表的末尾追加或者扩展元素
> **列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。**

```python
name_list = ['张三', '李四', '王五','赵六']
name_list.extend('阿坤')
print(name_list)
# ['张三', '李四', '王五', '赵六', '阿', '坤']
```
> **如果添加一个序列，则会将序列里面每一个元素添加进去**

```python
name_list = ['张三', '李四', '王五','赵六']
alist = ["唱","跳","rap","篮球"]
name_list.extend(alist)
print(name_list)
```
<a name="jveYT"></a>
#### insert()指定位置新增数据。
**语法**
```python
# 列表序列.insert(位置下标, 数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.insert(1, '阿坤')
# 结果：['张三','阿坤', '李四', '王五','赵六']
print(name_list)
```
<a name="t16kP"></a>
### 删除列表元素
<a name="lIGya"></a>
#### del 

- **是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。**
```python
name_list = ['张三', '李四', '王五','赵六']
del name_list
print(name_list)
```
**删除指定数据**（根据索引删除）
```python
name_list = ['张三', '李四', '王五','赵六']
del name_list[1]
print(name_list)
# ['张三', '王五', '赵六']
```
<a name="oEfnE"></a>
#### pop()
**删除指定下标的数据(默认为最后⼀个)，并返回该数据。**
```python
name_list = ['张三', '李四', '王五','赵六']
name_list.pop(1)
print(name_list)
# ['张三', '王五', '赵六']
```
<a name="zdu2d"></a>
#### remove()
**根据元素值进行删除移除列表中某个数据的第⼀个匹配项。**
```python
# 列表序列.remove(数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.remove("张三")
print(name_list)
# ['李四', '王五', '赵六']
```
<a name="Jzmi0"></a>
#### clear()
**清空列表**
```python
name_list = ['张三', '李四', '王五','赵六']
name_list.clear()
print(name_list)
# []
```
<a name="8347a927"></a>
### 修改列表元素
**Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。**
<a name="tjmR5"></a>
####  修改单个与一组元素
```python
name_list = ['张三', '李四', '王五','赵六']
name_list[0] = '阿坤'
print(name_list)

nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)
```
<a name="c4jn8"></a>
#### reverse()函数的使用
**逆置**
```python
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
print(num_list)
# [8, 6, 3, 2, 5, 1]
```
<a name="V4KsU"></a>
#### sort()函数的使用
**排序**<br />**语法**
> **reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）**

```python
# 列表序列.sort(reverse=False)
li = [2,3,5,6,1,4,8]
li.sort(reverse=False)
print(li)
# [1, 2, 3, 4, 5, 6, 8]

li.sort(reverse=True)
print(li)
# [8, 6, 5, 4, 3, 2, 1]
```
<a name="9dcb6e51"></a>
### 列表的**复制**
<a name="WTTUL"></a>
#### copy()函数的使用
复制一个列表
```python
name_list = ['张三', '李四', '王五','赵六']
name_li2 = name_list.copy()
print(name_li2)
# ['张三', '李四', '王五','赵六']
```
<a name="332c51aa"></a>
## 列表的循环遍历
**依次打印列表中的各个数据**<br />**for循环**

```python
name_list = ['张三', '李四', '王五','赵六']
for i in name_list:
    print(i)
```
**while循环**
```python
i = 0
name_list = ['Tom', 'Lily', 'Rose']
while i < len(name_list):
    print(name_list[i])
    i += 1
```
<a name="379c1abe"></a>
## 列表的嵌套
> 所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表

```python
# 找到篮球
name_list = [['张三', '李四', '阿坤'], ['唱', '跳', '篮球'], ['甲', '乙', '丙']]
# 第⼀步：按下标查找到篮球所在的列表
print(name_list[1])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[1][2])
```
<a name="cda9f200"></a>
# 元组
> **思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？**

<a name="15fde6a1"></a>
## 元组的创建
**Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。**<br />**元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。**
```python
使用 ( ) 直接创建
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
使用tuple()函数创建元组
tup1 = tuple("hello")
print(tup1)
```
> 注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型

<a name="93850362"></a>
## 元组的常⻅操作
> **元组数据不⽀持修改，只⽀持查找，具体如下**

- 根据下标查找
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])
```

- **index()：**

**查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。**
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))
```

- **count()：**

**统计某个数据在当前元组出现的次数。**
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))
```

- **len()：**

**统计元组中数据的个数。**
```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1))
```
**元组内的直接数据如果修改则⽴即报错**<br />**但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的。**
```python
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# ['aa', 'bb', 'cc']
tuple2[2][0] = 'aaaaa'
print(tuple2)
# (10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
```

- **del 同样支持**

**当创建的元组不再使用时，可以通过 del 关键字将其删除**
```python
tup = ("python"，"yyds")
print(tup)
del tup
print(tup)
```
<a name="HOtE0"></a>
# 列表与元组的区别

- **列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。**
- **元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。**
- **元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。**
- **可变与不可变性**
   - **列表：可变**
   - **元组：不可变**
<a name="UDgeQ"></a>
# 什么是可变类型与不可变类型？
**可变数据类型 ：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型。**<br />**不可变数据类型： 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。**

```python
"""数值"""
a = 1
print(a, id(a))
a = a + 1
print(a, id(a))
"""字符串"""
b = '1'
print(b, id(b))
b = b.upper()
print(b, id(b))
"""列表"""
li = [1, 2, 3, 4, 5]
print(li, id(li))
li.append(6)
print(li, id(li))
"""元组"""
tup = (1, 2, 3, [4, 5])
print(tup, id(tup))
tup[-1].append(6)
print(tup, id(tup))

```

字符串介绍

# 单引号
var1 = 'Hello World!'
# 双引号
var2 = "Python Runoob"
# 三引号
var3 = """hello world
		i love you	"""

"""
注意点 
不管是单引号 还是双引号 都是成对出现的 且是最近匹配  
一定是被单引号或者双引号所包裹的  
"""
var4 = "我很帅'是真的'ok"
print(var4)

我很帅'是真的'ok

进程已结束,退出代码0

字符串常用操作方法

print()
"""查找"""
# 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
# var = "hello and python and hello world"
#
# print(var.find("and"))          # 查找到and首字母下标
# print(var.find("and",8,20))     # 查找到下标为8-20，and首字母下标
# print(var.find("ors"))          # 查找ors，如果没有，则返回-1、
#
# # 字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
#
# var = "hello and python and hello world"
# print(var.index("and"))          # 查找到and首字母下标
# print(var.index("and",8,20))     # 查找到下标为8-20，and首字母下标
# print(var.index("ors"))          # 查找ors，如果没有，则报错


# 字符串序列.count(⼦串, 开始位置下标, 结束位置下标)

# var = "hello and python and hello world"
#
# print(var.count("and"))         # 查看在字符串var中，and出现了多少次
# print(var.count("ands"))        # 如果没有，则返回0次
# print(var.count("and",8,20))    # 在一个区间内查找and出现的次数


# li = [1, 2, 3, 4, 5, 6, 7, 6, 6, 8, 9, [6, 6, 6, 6, 6, 6]]
# print(li.count(6))
# print(li[-1].count(6))


"""修改
replace语法: 字符串序列.replace(旧⼦串, 新⼦串, 替换次数) 
"""
# var = "hello and python and hello world"
# new_var = var.replace("and", "和")  # 将里面所有的and替换为和
# """使用replace后，会生成副本，而不会改变原生字符串"""
# print(new_var)
# print(var)  # 原生字符串是没有变化的  从而证明了字符串是一个不可变的数据类型

# print(var.replace("and", "和", 3))  # 将and替换为和，只替换一次
# 注意：替换次数如果超出⼦串出现次数，则替换次数为该⼦串出现次数。

"""
split()：按照指定字符分割字符串。
返回是的一个列表的数据类型  
"""

# var = "hello and python and hello world"
# print(var.split("and"))         # 以and为界，分隔开其他字符串，返回一个列表
# print(var.split("and",maxsplit=1))       # 以and为界，分隔开其他字符串，只分割一次，返回一个列表

"""
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
语法：  'sep'.join(iterable)   
iterable  可迭代对象  
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
"""

# 字符或⼦串.join(多字符串组成的序列)

list1 = ["hello", "python", "i", "love", "you"]
"""
join是字符串的方法   一定要注意的是连接的是字符串 

"""
# print("".join(list1))     # 将列表转化为字符串，并且使用指定符号隔开
# list2 =['1','2','3','34','54']
# print("".join(list2))     # 将列表转化为字符串，并且使用指定符号隔开


"""
删除  
字符串.strip()

"""
var = "@@@hello and python@@@ and hello world@@@@"
print(var)
print(var.strip('@').replace('@',''))# 删除两侧空格


"""
replace join split  strip 
经常性的会在处理数据的时候用来   
清洗数据 达到目标数据 
"""

# 字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
# var = "hello and python and hello world"
#
# print(var.startswith("hello"))			# 开头是hello，返回True
# print(var.startswith("and"))			# 开头不是and，返回False
# print(var.startswith("and",6,20))		# 在索引6-20，开头是and，返回True



"""判断和其他方法 你可以不用去记忆 但是你还是要看一下 起码咱们要认识一下 """



print('你\n好')  # 换行 \n 特殊字符
print('你\\n好')  # 换行 \n 特殊字符 \
print(r'你\n好')  # 换行  转义(转义字符有很多):将特殊字符普通化

@@@hello and python@@@ and hello world@@@@
hello and python and hello world
你
好
你\n好
你\n好

进程已结束,退出代码0

字符串的输入输出

name = "TOM"
age = 18
heigth = 180.5

print("我的名字是%s"%name)
print("我今年%d岁了"%age)
print("我的身高是%.2f"%heigth)
print("大家好，我叫{},我今年{}岁，我的升高是{}".format(name,age,heigth))
print(f"大家好，我叫{name},我今年{age}岁，我的升高是{heigth}")
我的名字是TOM
我今年18岁了
我的身高是180.50
大家好，我叫TOM,我今年18岁，我的升高是180.5
大家好，我叫TOM,我今年18岁，我的升高是180.5

进程已结束,退出代码0

访问字符串中的值

print()
"""
注意点：下标从0开始进行计算
数据: h  e  l  l   o      p  y   t    h   o    n
索引: 0  1  2  3   4   5  6  7   8    9   10   11
索引:                           -4    -3  -2   -1

取值语法:  变量名[索引值]

切片的语法: 变量名[起始值索引:终止值索引:步长]   [start:stop:step]
切片范围:  左闭右开 
默认值: 起始索引值默认为0   终止值默认到结束  步长默认为1  

常见报错  IndexError: string index out of range  超出索引值了 

"""
# 取单个值
# print(a[11])
a = 'hello python'

# 取一段值       切片  hello

# print(a[-1])
# print(a[0:5:1])
# print(a[:5:1])
# print(a[0:5:])
# print(a[0::2])


name = "hellopython"
"""
数据: h  e  l  l  o  p  y  t  h  o   n
索引: 0  1  2  3  4  5  6  7  8  9   10
"""
# print(name[2:5])  # 从2开始，到5结束(不会拿到5本身)
# # llo
# print(name[2:5:1])  # 从2开始，到5结束，步长为1(不会拿到5本身)
# # llo
# print(name[:5])  # 从0开始，下表为5结束(不会拿到本身)
# # hello
# print(name[1:])  # 从1开始，一直到结束
# # ellopython
#
# print(name[:])  # 拿取所有
# # hellopython
#
# print(name[::2])  # 从0开始，步长为2，拿取所有
# # hloyhn
# print(name[:-1:1])  # 从0开始，到最后一个数结束(-1代表最后一个数，不包含-1本身)
# # hellopytho
#
# print(name[-4:-1])  # 从倒数第四个开始，到倒数第一个结束(不包含-1本身)
#
# print(name[::-1])  # 从-1开始，倒着打印字符串，步长为1
# # hellopython  反过来
# print(name[::-2])  # 从-1开始，倒着打印字符串，步长为2


# print(name[1:5:-1])  # olle
# print(name[1:5:1])  # olle
# print(name[1:-1:-1])
# print(name[-4:2:-2])
"""
获取数据的方向 一定要和步长的方向一致 否则拿不到数据  
"""