20220130

## 字符串 列表 元组 字典

### 字符串（String）

1. 字符串分两种索引方式，一种是记第一个字符为0位向后递增，另一种是记最后一位是-1位往前递减（负号计数的使用场景在哪呢

> https://www.py.cn/jishu/jichu/13443.html 
   >
   > 因为会涉及到执行效率的问题，所以需要根据情况灵活使用这两种索引方式截取字符串，比如：想快速获取最后一部分字符串，使用负索引是最快的。
   >
   > ```
   > >>> str='0123456789'
   > >>> print(str[0:3])#截取第一位到第三位的字符
   > 012
   > >>> print(str[:])#截取字符串的全部字符
   > 0123456789
   > >>> print(str[6:])#截取第七个字符到结尾
   > 6789
   > >>> print(str[:-3])#截取从头开始到倒数第三个字符之前
   > 0123456
   > >>> print(str[2])#截取第三个字符
   > 2
   > >>> print(str[-1])#截取倒数第一个字符
   > 9
   > >>> print(str[::-1])#创造一个与原字符串顺序相反的字符串
   > 9876543210
   > >>> print(str[-3:-1])#截取倒数第三位与倒数第一位之前的字符
   > 78
   > >>> print(str[-3:]) #截取倒数第三位到结尾
   > 789
   > >>> print(str[ : -5 :-3])#逆序截取
   > 96
   > ```
   ```python
   s='abcdef'
   s[1:5]->'bcde'
   s[1:]->'bcdef'
   s[1]->'b'
   s[1: 4:2]->'b','d' #第一位和第二位数字表示开始和结束的位置，而第三位则表示步长，b相隔两位的字符是d
   ```

2. for example

```python
   str = 'noobwei'
   
   print(str[1])
   print(str[1:3])
   print(str[1:])
   print(str[1:5 :2])
   print(str+'NOOB')
   print(str[-5:-1])   # 还是只能从前往后遍历
   
   # 结果
   # o
   # oo
   # oobwei
   # ob
   # noobweiNOOB
   # obwe
   # 
   # Process finished with exit code 0
   ```

### 列表（List）

List是python中使用最频繁的数据类型(类似于二维数组?)，而列表支持字符，数字，字符串，也可以嵌套列表

其计数和索引方式与字符串类似

```python
list=['noobwei','xdu',1,2,3,1.14514]
list0=['NOOBWEI','XDU']
print(list)     #print(list[])无法通过编译
print(list[1:3])
print(list[1:])
print(list*2)
print(list+list0)

# 结果
# ['noobwei', 'xdu', 1, 2, 3, 1.14514]
# ['xdu', 1]
# ['xdu', 1, 2, 3, 1.14514]
# ['noobwei', 'xdu', 1, 2, 3, 1.14514, 'noobwei', 'xdu', 1, 2, 3, 1.14514]
# ['noobwei', 'xdu', 1, 2, 3, 1.14514, 'NOOBWEI', 'XDU']
# 
# Process finished with exit code 0
```

### 元组（Tuple）

~~只读列表~~

试着直接把上面List全部替换成Tuple

```python
tuple=['noobwei','xdu',1,2,3,1.14514]
tuple1=['NOOBWEI','XDU']
print(tuple)
print(tuple[1:3])
print(tuple[1:])
print(tuple*2)
print(tuple+tuple1)
```

这个时候就想到了一个问题，python如何分辨元组和列表，难道是通过名称吗，那我前面一个命名为list，后面一个命名为tuple可以编译运行吗,结果是，可以

```python
list=['noobwei','xdu',1,2,3,1.14514]
tuple=['NOOBWEI','XDU']

print(list+tuple)
# ['noobwei', 'xdu', 1, 2, 3, 1.14514, 'NOOBWEI', 'XDU']
```

甚至...

```python
shit=['noobwei','xdu',1,2,3,1.14514]
shi=['NOOBWEI','XDU']

print(shit+shi)
# ['noobwei', 'xdu', 1, 2, 3, 1.14514, 'NOOBWEI', 'XDU']
```

> https://blog.csdn.net/lin_keys/article/details/114694491（随便一查就知道有多脑瘫，指上面的问题

看完才发现，元组是用<kbd>()</kbd>包裹的，而列表用<kbd>[]</kbd>包裹，和起什么名字没有勾八关系

### 发现介绍基本数据类型并不能学懂狗屁并且加上对List的处理

#### 初始化列表

```python
a = list(range(1,6)) 
print(a)
# [1, 2, 3, 4, 5]
#
# Process finished with exit code 0
```

这里的()是因为调用了list函数，并不是直接创建，表示创建一个从1到5的list,可以看到输出的结果仍然是以[]包裹

下面是一个仅供看抬杠的问题，cv的

> 创建空的列表，是使用list()效率好还是[]？
>
> ```python
> (djangoDemo) MonitorCenter % python -m timeit 'x=list()'                
> 10000000 loops, best of 3: 0.087 usec per loop
> (djangoDemo) MonitorCenter % python -m timeit 'x=[]'    
> 100000000 loops, best of 3: 0.0177 usec per loop
> ```
>
> 通过上面的测试可以知道是[]快。list()函数调用，python中函数调用会创建stack并且会进行参数检查，[]是一个内置C函数，可以直接调用，因此效率更高。

#### 添加元素

##### append：在列表的尾部插入一个元素

```python
a = list(range(1,6))
a.append(7)
print(a)

# [1, 2, 3, 4, 5,7]
#
# Process finished with exit code 0
```

##### extend：理解为并入列表？

```python
a=list(range(1,6))
b=list(range(9,11))
a.extend(b)
b.extend(a)
print(a)
print(b)
b.sort() #顺带着把sort试了试
print(b)

# [1, 2, 3, 4, 5, 9, 10]
# [9, 10, 1, 2, 3, 4, 5, 9, 10]
# [1, 2, 3, 4, 5, 9, 9, 10, 10]
# 
# Process finished with exit code 0

```

##### insert:在给定的位置插入一个元素

第一个参数是要插入的元素的索引 用法为list_name`.insert(n, x)`

```python
a=list(range(1,6))
a.insert(1,100)
print(a)

# [1, 100, 2, 3, 4, 5]
```

#### 删除元素

```python
a=list(range(1,6))
a.insert(1,100)
print(a)
a.remove(100)
print(a)
a.pop(1)
print(a)
del a[1:3]
print(a)
a.clear() #del a[:]
print(a)

# [1, 100, 2, 3, 4, 5]
# [1, 2, 3, 4, 5]
# [1, 3, 4, 5]
# [1, 5]
# []
```

#### 修改元素

相当于覆盖之前的list？

~~直接用别人的例子了~~

```path
>>l = ["python", "go", "java"]
>>l[0] = "PYTHON"
>>l
['PYTHON', 'go', 'java']

>>l = ["python", "go", "java"]
>>l[0:2] = "PYTHON", "GO"
>>l
['PYTHON', 'GO', 'java']
>>l[0:2] = ["python", "go"]
>>l
['python', 'go', 'java']
```

#### 查询元素

```python
a=list(range(1,6))
print(a.index(2)) #查询元素位置，若valueerror
b=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
print(b.count(1)) #查询元素出现次数

# 1
# 16
```

#### reverse sort还有...?

```python
list_name.reverse()

list2_name=list1_name.copy()
```

**元组只能进行查询操作，不能对元素进行修改**

> 截止目前为止，我们可以简单总结列表和元组的区别有如下：
>
> 1. 元组使用tuple()或()初始化，列表使用list()或[]初始化
> 2. 元组是静态，而列表是动态
> 3. 列表需要更多内存，元组需要更少内存
> 4. 列表不可被hash，元组可以被hash
> 5. 元组初始化效率高于列表，但索引操作没有多大差距

### 字典（Dictionary）

用<kbd>{}</kbd>包裹，格式为d={key1:value,key:value2}

```python
d={'name':'noobwei','school':'xdu','major':'cyber security'}
print(d['name'])        #一个key只能对应一个value,如果两次赋值，将记住后面一个value
d['name']='NOOBWEI'     #修改字典
print(d['name'])
# noobwei
# NOOBWEI
```

```python
d={'name':'noobwei','school':'xdu','major':'cyber security'}
print(d['name'])
del d['name']           #删除字典，清空字典所有条目为d.clear(),删除整个字典（内存上抹去）del d
print(d['name'])
# noobwei
# Traceback (most recent call last):
#   File "/Users/weiwei/PycharmProjects/pythonProject1/main.py", line 4, in <module>
#     print(d['name'])
# KeyError: 'name'
```

##### 应用 利用字典对密码进行爆破（现在并不会