笔记 | PYTHON

### 字符串
#### 使用字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( `'` 或 `"` )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'

#### 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

```python
str2 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[2]) # c
# 字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45
```

#### 字符串更新
可以截取字符串的一部分并与其他字段拼接

```python
var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Python')
```

#### 转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 `\` 转义字符。
![转义字符](/media/images/editor/python/string_20201226165257222094.png "转义字符")

#### 字符串运算符
| 操作符  | 描述  |
| ------------ | ------------ |
| +  | 字符串连接  |
| *  | 重复输出字符串  |
| []  | 通过索引获取字符串中字符  |
| [ : ]  | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。  |
| in  | 成员运算符 - 如果字符串中包含给定的字符返回 True  |
| not in  | 成员运算符 - 如果字符串中不包含给定的字符返回 True  |
| r/R  | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 `r`（可以大小写）以外，与普通字符串有着几乎完全相同的语法。  |
| %  | 格式字符串  |

```python
s1 = 'hello ' * 3
print(s1) # hello hello hello 
s2 = 'world'
s1 += s2
print(s1) # hello hello hello world
print('ll' in s1) # True
print('good' in s1) # False
```

#### 字符串格式化
| 符 号 | 描述 |
| :------------: | ------------ |
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |

也可以用字符串提供的方法来完成字符串的格式，代码如下所示

```python
a, b = 5, 10
print('{0} * {1} = {2}'.format(a, b, a * b))
```

Python 3.6以后，格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母`f`，我们可以使用下面的语法糖来简化上面的代码。

```python
a, b = 5, 10
print(f'{a} * {b} = {a * b}')
```

在Python中，我们还可以通过一系列的方法来完成对字符串的处理

| 方法  | 说明  | 示例  |
| ------------ | ------------ | ------------ |
| len(str)  | 计算字符串的长度  | print(len("hello, world!"))   # 13 |
| str.capitalize()  | 将字符串的第一个字符转换为大写  | "hello, world!".capitalize()  # 'Hello, world!'  |
| str.title()  | 所有单词都以大写开始  | "hello, world!".title()  # 'Hello, World!'  |
| str.upper()  | 转换字符串中的小写字母为大写  | "hello, world!".upper()  # 'HELLO, WORLD!'  |
| str.find()  | 检测 str 是否包含在字符串中  | "hello, world!".find("or")  # 8  |
| str.index()  | 与find类似但找不到子串时会引发异常  | "hello, world!".index("or")  # 8  |
| str.startswith()  | 检查字符串是否以指定的字符串开头  | "hello, world!".startswith("he")  # True  |
| str.endswith()  | 检查字符串是否以指定的字符串结尾  | "hello, world!".endswith("ld")  # False  |
| str.center()  | 将字符串以指定的宽度居中并在两侧填充指定的字符  | "hello".center(8, "\*")  # '\*hello\*\*'  |
| str.rjust()  | 将字符串以指定的宽度靠右放置左侧填充指定的字符  | "hello".rjust(8, "\*")   # '\*\*\*hello' |
| str.isdigit()  | 检查字符串是否由数字构成  | "123".isdigit()  # True  |
| str.isalpha()  | 检查字符串是否以字母构成  | "123".isalpha()  # False |
| str.isalnum()  | 检查字符串是否以数字和字母构成  | "123".isalnum()  # True  |
| str.strip()  | 获得字符串修剪左右两侧空格之后的拷贝  | " hello, world!".strip() # 'hello, world!'  |

### 列表
#### 使用列表
序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Python', 1997, 2000]
    list2 = [1, 2, 3, 4, 5 ]
    list3 = ["a", "b", "c", "d"]
    list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

#### 访问列表中的值
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。

```python
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
```

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

```python
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
```

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：

```python
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
```

下面的代码演示了如何向列表中添加元素以及如何从列表中移除元素。

```python
list1 = [1, 3, 5, 7, 100]

# 添加元素
list1.append(200)
list1.insert(1, 400)

# 合并两个列表
# list1.extend([1000, 2000])
list1 += [1000, 2000]
print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
print(len(list1)) # 9

# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list1:
	list1.remove(3)
if 1234 in list1:
    list1.remove(1234)
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]

# 从指定的位置删除元素
list1.pop(0)
list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]

# 清空列表元素
list1.clear()
print(list1) # []
```

#### 生成式和生成器
我们还可以使用列表的生成式语法来创建列表，代码如下所示。

```python
f = [x for x in range(1, 10)]
print(f)
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)

# 用列表的生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f = [x ** 2 for x in range(1, 1000)]
print(sys.getsizeof(f))  # 查看对象占用内存的字节数
print(f)

# 请注意下面的代码创建的不是一个列表而是一个生成器对象
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
f = (x ** 2 for x in range(1, 1000))
print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
    print(val)
```

### 元组
#### 使用元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 `( )`，列表使用方括号 `[ ]`。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

```python
# 定义元组
t = ('test', 38, True, '四川成都')
print(t)
# 获取元组中的元素
print(t[0])
print(t[3])
# 遍历元组中的值
for member in t:
    print(member)
# 重新给元组赋值
# t[0] = 'lisi'  # TypeError
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('lisi', 20, True, '云南昆明')
print(t)
# 将元组转换成列表
person = list(t)
print(person)
# 列表是可以修改它的元素的
person[0] = '李小龙'
person[1] = 25
print(person)
# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)
```

### 集合
#### 使用集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合
- 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

```python
# 创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1)
print('Length =', len(set1))
# 创建集合的构造器语法(面向对象部分会进行详细讲解)
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)
# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)
```

向集合添加元素和从集合删除元素。

```python
set1.add(4)
set1.add(5)
set2.update([11, 12])
set2.discard(5)
if 4 in set2:
    set2.remove(4)
print(set1, set2)
print(set3.pop())
print(set3)
```

集合的成员、交集、并集、差集等运算。

```python
# 集合的交集、并集、差集、对称差运算
print(set1 & set2)
# print(set1.intersection(set2))
print(set1 | set2)
# print(set1.union(set2))
print(set1 - set2)
# print(set1.difference(set2))
print(set1 ^ set2)
# print(set1.symmetric_difference(set2))
# 判断子集和超集
print(set2 <= set1)
# print(set2.issubset(set1))
print(set3 <= set1)
# print(set3.issubset(set1))
print(set1 >= set2)
# print(set1.issuperset(set2))
print(set1 >= set3)
# print(set1.issuperset(set3))
```

### 字典
#### 使用字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

```python
# 创建字典的字面量语法
scores = {'小白': 95, '白元芳': 78, '狄仁杰': 82}
print(scores)
# 创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)
# 通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))
# 创建字典的推导式语法
items3 = {num: num ** 2 for num in range(1, 10)}
print(items1, items2, items3)
# 通过键可以获取字典中对应的值
print(scores['小白'])
print(scores['狄仁杰'])
# 对字典中所有键值对进行遍历
for key in scores:
    print(f'{key}: {scores[key]}')
# 更新字典中的元素
scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)
print(scores)
if '武则天' in scores:
    print(scores['武则天'])
print(scores.get('武则天'))
# get方法也是通过键获取对应的值但是可以设置默认值
print(scores.get('武则天', 60))
# 删除字典中的元素
print(scores.popitem())
print(scores.popitem())
print(scores.pop('小白', 100))
# 清空字典
scores.clear()
print(scores)
```

晓松

Python 字符串和常用数据结构

Python 字符串、列表、元组、集合、字典的使用

晓松

Python 字符串和常用数据结构 Python 字符串、列表、元组、集合、字典的使用

Python 字符串和常用数据结构

Python 字符串、列表、元组、集合、字典的使用