添加了新的文档
jackfrued
parent
87de712fb9
commit
cf0c47054f
Binary file not shown.
|
After Width: | Height: | Size: 173 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 218 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 98 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB After Width: | Height: | Size: 6.4 KiB |
BIN
res/qrcode.png
BIN
res/qrcode.png
Binary file not shown.
|
Before Width: | Height: | Size: 236 KiB After Width: | Height: | Size: 235 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.9 KiB |
|
|
@ -92,7 +92,7 @@ print('flag5 =', flag5) # flag5 = False
|
|||
|
||||
#### 例子1：华氏温度转换为摄氏温度。
|
||||
|
||||
> **提示**：华氏温度到摄氏温度的转换公式为：$C=(F - 32) \div 1.8$。
|
||||
> **提示**：华氏温度到摄氏温度的转换公式为：`C = (F - 32) / 1.8`。
|
||||
|
||||
```Python
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ else:
|
|||
print(f'f({x}) = {y}')
|
||||
```
|
||||
|
||||
> **说明：** 大家可以自己感受和评判一下这两种写法到底是哪一种更好。在**[Python之禅](https://zhuanlan.zhihu.com/p/111843067)**中有这么一句话：“Flat is better than nested”，之所以提倡代码“扁平化”是因为嵌套结构的嵌套层次如果很多，会严重的影响代码的可读性，所以能使用扁平化结构时就不要使用嵌套结构。
|
||||
> **说明：** 大家可以自己感受和评判一下这两种写法到底是哪一种更好。在[**Python之禅**](https://zhuanlan.zhihu.com/p/111843067)中有这么一句话：“**Flat is better than nested**”，之所以提倡代码“扁平化”是因为嵌套结构的嵌套层次如果很多，会严重的影响代码的可读性，所以能使用扁平化结构时就不要使用嵌套结构。
|
||||
|
||||
### 一些例子
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,277 @@
|
|||
## 第008课：函数和模块
|
||||
|
||||
在讲解本章节的内容之前，我们先来研究一道数学题，请说出下面的方程有多少组正整数解。
|
||||
|
||||
|
||||
|
||||
事实上，上面的问题等同于将8个苹果分成四组每组至少一个苹果有多少种方案，所以答案应该是$C_7^3=35$。组合数的计算公式如下所示。
|
||||
|
||||
|
||||
|
||||
根据我们前面学习的知识，可以用循环做累乘来计算阶乘，那么通过下面的Python代码我们就可以计算出组合数`C(M,N)`的值，代码如下所示。
|
||||
|
||||
```Python
|
||||
"""
|
||||
输入M和N计算C(M,N)
|
||||
|
||||
Version: 0.1
|
||||
Author: 骆昊
|
||||
"""
|
||||
m = int(input('m = '))
|
||||
n = int(input('n = '))
|
||||
# 计算m的阶乘
|
||||
fm = 1
|
||||
for num in range(1, m + 1):
|
||||
fm *= num
|
||||
# 计算n的阶乘
|
||||
fn = 1
|
||||
for num in range(1, n + 1):
|
||||
fn *= num
|
||||
# 计算m-n的阶乘
|
||||
fm_n = 1
|
||||
for num in range(1, m - n + 1):
|
||||
fm_n *= num
|
||||
# 计算C(M,N)的值
|
||||
print(fm // fn // fm_n)
|
||||
```
|
||||
|
||||
### 函数的作用
|
||||
|
||||
不知道大家是否注意到，上面的代码中我们做了三次求阶乘，虽然`m`、`n`、`m - n`的值各不相同，但是三段代码并没有实质性的区别，属于重复代码。世界级的编程大师*Martin Fowler*先生曾经说过：“**代码有很多种坏味道，重复是最坏的一种！**”。要写出高质量的代码首先要解决的就是重复代码的问题。对于上面的代码来说，我们可以将计算阶乘的功能封装到一个称之为“函数”的功能模块中，在需要计算阶乘的地方，我们只需要“调用”这个“函数”就可以了。
|
||||
|
||||
### 定义函数
|
||||
|
||||
数学上的函数通常形如`y = f(x)`或者`z = g(x, y)`这样的形式，在`y = f(x)`中，`f`是函数的名字，`x`是函数的自变量，`y`是函数的因变量；而`z = g(x, y)`中，`g`是函数名，`x`和`y`是函数的自变量，`z`是函数的因变量。Python中的函数跟这个结构是一致的，每个函数都有自己的名字、自变量和因变量。我们通常把Python中函数的自变量称为函数的参数，而因变量称为函数的返回值。
|
||||
|
||||
在Python中可以使用`def`关键字来定义函数，和变量一样每个函数也应该有一个漂亮的名字，命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，就是我们刚才说到的函数的自变量，而函数执行完成后我们会通过`return`关键字来返回函数的执行结果，就是我们刚才说的函数的因变量。
|
||||
|
||||
我们可以用函数的知识对上面的代码进行重构（不影响代码执行结果的前提下对代码的结构进行调整），重构之后的代码如下所示。
|
||||
|
||||
```Python
|
||||
"""
|
||||
输入M和N计算C(M,N)
|
||||
|
||||
Version: 0.1
|
||||
Author: 骆昊
|
||||
"""
|
||||
|
||||
|
||||
# 定义函数：def是定义函数的关键字、fac是函数名，num是参数（自变量）
|
||||
def fac(num):
|
||||
"""求阶乘"""
|
||||
result = 1
|
||||
for n in range(1, num + 1):
|
||||
result *= n
|
||||
# 返回num的阶乘（因变量）
|
||||
return result
|
||||
|
||||
|
||||
m = int(input('m = '))
|
||||
n = int(input('n = '))
|
||||
# 当需要计算阶乘的时候不用再写重复代码而是直接调用函数fac
|
||||
# 调用函数的语法是在函数名后面跟上圆括号并传入参数
|
||||
print(fac(m) // fac(n) // fac(m - n))
|
||||
```
|
||||
|
||||
### 函数的参数
|
||||
|
||||
#### 参数的默认值
|
||||
|
||||
在Python语言中，如果函数中没有`return`语句，那么函数默认返回代表空值的`None`。另外，在定义函数时，函数也可以没有自变量，但是函数名后面的圆括号是必须有的。Python中还允许函数的参数拥有默认值，例如我们把上一课中摇色子获得点数的功能定义到一个函数中，我们可以写出如下所示的代码。
|
||||
|
||||
```Python
|
||||
"""
|
||||
参数的默认值
|
||||
|
||||
Version: 0.1
|
||||
Author: 骆昊
|
||||
"""
|
||||
from random import randint
|
||||
|
||||
|
||||
# 定义摇色子的函数，n表示色子的个数，默认值为2
|
||||
def roll_dice(n=2):
|
||||
"""摇色子返回总的点数"""
|
||||
total = 0
|
||||
for _ in range(n):
|
||||
total += randint(1, 6)
|
||||
return total
|
||||
|
||||
|
||||
# 如果没有指定参数，那么n使用默认值2，表示摇两颗色子
|
||||
print(roll_dice())
|
||||
# 传入参数3，变量n被赋值为3，表示摇三颗色子获得点数
|
||||
print(roll_dice(3))
|
||||
```
|
||||
|
||||
我们再来看一个更为简单的例子。
|
||||
|
||||
```Python
|
||||
def add(a=0, b=0, c=0):
|
||||
"""三个数相加求和"""
|
||||
return a + b + c
|
||||
|
||||
|
||||
# 调用add函数，没有传入参数，那么a、b、c都使用默认值0
|
||||
print(add()) # 0
|
||||
# 调用add函数，传入一个参数，那么该参数赋值给变量a, 变量b和c使用默认值0
|
||||
print(add(1)) # 1
|
||||
# 调用add函数，传入两个参数，1和2分别赋值给变量a和b，变量c使用默认值0
|
||||
print(add(1, 2)) # 3
|
||||
# 调用add函数，传入三个参数，分别赋值给a、b、c三个变量
|
||||
print(add(1, 2, 3)) # 6
|
||||
# 传递参数时可以不按照设定的顺序进行传递
|
||||
print(add(c=50, a=100, b=200))
|
||||
```
|
||||
|
||||
#### 可变参数
|
||||
|
||||
接下来，我们还可以实现一个对任意多个数求和的`add`函数，因为Python语言中的函数支持可变参数，所谓可变参数指的是在调用函数时，可以向函数传入0个或任意多个参数。将来我们以团队协作开发的模式做商业项目时，可能需要去设计一个函数给其他人使用，但我们又不知道函数的调用者会向该函数传入多少个参数，这个时候可变参数就可以派上用场。下面的代码演示了用可变参数实现对任意多个数求和的`add`函数。
|
||||
|
||||
```Python
|
||||
"""
|
||||
可变参数
|
||||
|
||||
Version: 0.1
|
||||
Author: 骆昊
|
||||
"""
|
||||
|
||||
|
||||
# 在参数名前面的*表示args是一个可变参数
|
||||
def add(*args):
|
||||
total = 0
|
||||
# 可变参数可以放在for循环中取出每个参数的值
|
||||
for val in args:
|
||||
total += val
|
||||
return total
|
||||
|
||||
|
||||
# 在调用add函数时可以传入0个或任意多个参数
|
||||
print(add())
|
||||
print(add(1))
|
||||
print(add(1, 2))
|
||||
print(add(1, 2, 3))
|
||||
print(add(1, 3, 5, 7, 9))
|
||||
```
|
||||
|
||||
### 用模块管理函数
|
||||
|
||||
不管用什么样的编程语言来写代码，给变量、函数起名字都是一个让人头疼的问题，因为我们会遇到**命名冲突**这种尴尬的情况。最简单的场景就是在同一个`.py`文件中定义了两个同名的函数，如下所示。
|
||||
|
||||
```Python
|
||||
def foo():
|
||||
print('hello, world!')
|
||||
|
||||
|
||||
def foo():
|
||||
print('goodbye, world!')
|
||||
|
||||
|
||||
foo() # 大家猜猜调用foo函数会输出什么
|
||||
```
|
||||
|
||||
当然上面的这种情况我们很容易就能避免，但是如果项目是团队协作多人开发的时候，团队中可能有多个程序员都定义了名为`foo`的函数，这种情况下怎么解决命名冲突呢？答案其实很简单，Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过`import`关键字导入指定的模块再使用**完全限定名**的调用方式就可以区分到底要使用的是哪个模块中的`foo`函数，代码如下所示。
|
||||
|
||||
`module1.py`
|
||||
|
||||
```Python
|
||||
def foo():
|
||||
print('hello, world!')
|
||||
```
|
||||
|
||||
`module2.py`
|
||||
|
||||
```Python
|
||||
def foo():
|
||||
print('goodbye, world!')
|
||||
```
|
||||
|
||||
`test.py`
|
||||
|
||||
```Python
|
||||
import module1
|
||||
import module2
|
||||
|
||||
# 用“模块名.函数名”的方式（完全限定名）调用函数，
|
||||
module1.foo() # hello, world!
|
||||
module2.foo() # goodbye, world!
|
||||
```
|
||||
|
||||
在导入模块时，还可以使用`as`关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。
|
||||
|
||||
`test.py`
|
||||
|
||||
```Python
|
||||
import module1 as m1
|
||||
import module2 as m2
|
||||
|
||||
m1.foo() # hello, world!
|
||||
m2.foo() # goodbye, world!
|
||||
```
|
||||
|
||||
上面的代码我们导入了定义函数的模块，我们也可以使用`from...import...`语法从模块中直接导入需要使用的函数，代码如下所示。
|
||||
|
||||
`test.py`
|
||||
|
||||
```Python
|
||||
from module1 import foo
|
||||
|
||||
foo() # hello, world!
|
||||
|
||||
from module2 import foo
|
||||
|
||||
foo() # goodbye, world!
|
||||
```
|
||||
|
||||
但是，如果我们如果从两个不同的模块中导入了同名的函数，后导入的函数会覆盖掉先前的导入，就像下面的代码中，调用`foo`会输出`hello, world!`，因为我们先导入了`module2`的`foo`，后导入了`module1`的`foo` 。如果两个`from...import...`反过来写，就是另外一番光景了。
|
||||
|
||||
`test.py`
|
||||
|
||||
```Python
|
||||
from module2 import foo
|
||||
from module1 import foo
|
||||
|
||||
foo() # hello, world!
|
||||
```
|
||||
|
||||
如果想在上面的代码中同时使用来自两个模块中的`foo`函数也是有办法的，大家可能已经猜到了，还是用`as`关键字对导入的函数进行别名，代码如下所示。
|
||||
|
||||
`test.py`
|
||||
|
||||
```Python
|
||||
from module1 import foo as f1
|
||||
from module2 import foo as f2
|
||||
|
||||
f1() # hello, world!
|
||||
f2() # goodbye, world!
|
||||
```
|
||||
|
||||
### 标准库中的模块和函数
|
||||
|
||||
Python标准库中提供了大量的模块和函数来简化我们的开发工作，我们之前用过的`random`模块就为我们提供了生成随机数和进行随机抽样的函数；而`time`模块则提供了和时间操作相关的函数。随着我们进一步的学习Python编程知识，我们还会用到更多的模块和函数。Python标准库中还有一类函数是不需要`import`就能够直接使用的，我们将其称之为内置函数，这些内置函数都是很有用也是最常用的，下面的表格列出了一部分的内置函数。
|
||||
|
||||
| 函数 | 说明 |
|
||||
| ------- | ------------------------------------------------------------ |
|
||||
| `abs` | 返回一个数的绝对值，例如：`abs(-1.3)`会返回`1.3`。 |
|
||||
| `bin` | 把一个整数转换成以`'0b'`开头的二进制字符串，例如：`bin(123)`会返回`'0b1111011'`。 |
|
||||
| `chr` | 将Unicode编码转换成对应的字符，例如：`chr(8364)`会返回`'€'`。 |
|
||||
| `hex` | 将一个整数转换成以`'0x'`开头的十六进制字符串，例如：`hex(123)`会返回`'0x7b'`。 |
|
||||
| `input` | 从输入中读取一行，返回读到的字符串。 |
|
||||
| `len` | 获取字符串、列表等的长度。 |
|
||||
| `max` | 返回多个参数或一个可迭代对象（后面会讲）中的最大值，例如：`max(12, 95, 37)`会返回`95`。 |
|
||||
| `min` | 返回多个参数或一个可迭代对象（后面会讲）中的最小值，例如：`min(12, 95, 37)`会返回`12`。 |
|
||||
| `oct` | 把一个整数转换成以`'0o'`开头的八进制字符串，例如：`oct(123)`会返回`'0o173'`。 |
|
||||
| `open` | 打开一个文件并返回文件对象（后面会讲）。 |
|
||||
| `ord` | 将字符转换成对应的Unicode编码，例如：`ord('€')`会返回`8364`。 |
|
||||
| `pow` | 求幂运算，例如：`pow(2, 3)`会返回`8`；`pow(2, 0.5)`会返回`1.4142135623730951`。 |
|
||||
| `print` | 打印输出。 |
|
||||
| `range` | 构造一个范围序列，例如：`range(100)`会产生`0`到`99`的整数序列。 |
|
||||
| `round` | 按照指定的精度对数值进行四舍五入，例如：`round(1.23456, 4)`会返回`1.2346`。 |
|
||||
| `sum` | 对一个序列中的项从左到右进行求和运算，例如：`sum(range(1, 101))`会返回`5050`。 |
|
||||
| `type` | 返回对象的类型，例如：`type(10)`会返回`int`；而` type('hello')`会返回`str`。 |
|
||||
|
||||
### 简单的总结
|
||||
|
||||
**函数是功能相对独立且会重复使用的代码的封装**。学会使用定义和使用函数，就能够写出更为优质的代码。当然，Python语言的标准库中已经为我们提供了大量的模块和常用的函数，用好这些模块和函数就能够用更少的代码做更多的事情。
|
||||
|
||||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**，当然也可以看看我们为大家录制的入门视频，视频的链接地址：<https://pan.baidu.com/s/10y7sGM016YBM7gDdauGqLw>，密码：4s6r。
|
||||
|
|
@ -0,0 +1,329 @@
|
|||
## 第009课：字符串的使用
|
||||
|
||||
第二次世界大战促使了现代电子计算机的诞生，世界上的第一台通用电子计算机叫ENIAC（电子数值积分计算机），诞生于美国的宾夕法尼亚大学，占地167平米，重量27吨，每秒钟大约能够完成约5000次浮点运算，如下图所示。ENIAC诞生之后被应用于导弹弹道的计算，而数值计算也是现代电子计算机最为重要的一项功能。
|
||||
|
||||
|
||||
|
||||
随着时间的推移，虽然数值运算仍然是计算机日常工作中最为重要的组成部分，但是今天的计算机还要处理大量的以文本形式存在的信息。如果我们希望通过Python程序来操作本这些文本信息，就必须要先了解字符串这种数据类型以及与它相关的知识。
|
||||
|
||||
### 字符串的定义
|
||||
|
||||
所谓**字符串**，就是**由零个或多个字符组成的有限序列**，一般记为：
|
||||
|
||||
|
||||
|
||||
在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、[Emoji字符](<http://www.ruanyifeng.com/blog/2017/04/emoji.html>)等。
|
||||
|
||||
```Python
|
||||
s1 = 'hello, world!'
|
||||
s2 = "你好，世界！"
|
||||
print(s1, s2)
|
||||
# 以三个双引号或单引号开头的字符串可以折行
|
||||
s3 = '''
|
||||
hello,
|
||||
world!
|
||||
'''
|
||||
print(s3, end='')
|
||||
```
|
||||
|
||||
> **提示**：`print`函数中的`end=''`表示输出后不换行，即将默认的结束符`\n`（换行符）更换为`''`（空字符）。
|
||||
|
||||
### 转义字符和原始字符串
|
||||
|
||||
可以在字符串中使用`\`（反斜杠）来表示转义，也就是说`\`后面的字符不再是它原来的意义，例如：`\n`不是代表反斜杠和字符`n`，而是表示换行；`\t`也不是代表反斜杠和字符`t`，而是表示制表符。所以如果字符串本身又包含了`'`、`"`、`\`这些特殊的字符，必须要通过`\`进行转义处理。例如要输出一个带单引号或反斜杠的字符串，需要用如下所示的方法。
|
||||
|
||||
```Python
|
||||
s1 = '\'hello, world!\''
|
||||
print(s1)
|
||||
s2 = '\\hello, world!\\'
|
||||
print(s2)
|
||||
```
|
||||
|
||||
Python中的字符串可以`r`或`R`开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串`'hello\n'`中，`\n`表示换行；而在`r'hello\n'`中，`\n`不再表示换行，就是反斜杠和字符`n`。大家可以运行下面的代码，看看会输出什么。
|
||||
|
||||
```Python
|
||||
# 字符串s1中\t是制表符，\n是换行符
|
||||
s1 = '\time up \now'
|
||||
print(s1)
|
||||
# 字符串s2中没有转义字符，每个字符都是原始含义
|
||||
s2 = r'\time up \now'
|
||||
print(s2)
|
||||
```
|
||||
|
||||
Python中还允许在`\`后面还可以跟一个八进制或者十六进制数来表示字符，例如`\141`和`\x61`都代表小写字母`a`，前者是八进制的表示法，后者是十六进制的表示法。另外一种表示字符的方式是在`\u`后面跟Unicode字符编码，例如`\u9a86\u660a`代表的是中文“骆昊”。运行下面的代码，看看输出了什么。
|
||||
|
||||
```Python
|
||||
s1 = '\141\142\143\x61\x62\x63'
|
||||
s2 = '\u9a86\u660a'
|
||||
print(s1, s2)
|
||||
```
|
||||
|
||||
### 字符串的运算
|
||||
|
||||
Python为字符串类型提供了非常丰富的运算符，我们可以使用`+`运算符来实现字符串的拼接，可以使用`*`运算符来重复一个字符串的内容，可以使用`in`和`not in`来判断一个字符串是否包含另外一个字符串，我们也可以用`[]`和`[:]`运算符从字符串取出某个字符或某些字符。
|
||||
|
||||
#### 拼接和重复
|
||||
|
||||
下面的例子演示了使用`+`和`*`运算符来实现字符串的拼接和重复操作。
|
||||
|
||||
```Python
|
||||
s1 = 'hello' + ' ' + 'world'
|
||||
print(s1) # hello world
|
||||
s2 = '!' * 3
|
||||
print(s2) # !!!
|
||||
s1 += s2 # s1 = s1 + s2
|
||||
print(s1) # hello world!!!
|
||||
s1 *= 2 # s1 = s1 * 2
|
||||
print(s1) # hello world!!!hello world!!!
|
||||
```
|
||||
|
||||
用`*`实现字符串的重复是非常有意思的一个运算符，在很多编程语言中，要表示一个有10个`a`的字符串，你只能写成`"aaaaaaaaaa"`，但是在Python中，你可以写成`'a' * 10`。你可能觉得`"aaaaaaaaaa"`这种写法也没有什么不方便的，那么想一想，如果字符`a`要重复100次或者1000次又会如何呢？
|
||||
|
||||
#### 成员运算
|
||||
|
||||
Python中可以用`in`和`not in`判断一个字符串中是否存在另外一个字符或字符串，`in`和`not in`运算通常称为成员运算，会产生布尔值`True`或`False`，代码如下所示。
|
||||
|
||||
```Python
|
||||
s1 = 'hello, world'
|
||||
print('wo' in s1) # True
|
||||
s2 = 'goodbye'
|
||||
print(s2 in s1) # False
|
||||
```
|
||||
|
||||
#### 获取字符串长度
|
||||
|
||||
获取字符串长度没有直接的运算符，而是使用内置函数`len`，我们在上节课的提到过这个内置函数，代码如下所示。
|
||||
|
||||
```Python
|
||||
s = 'hello, world'
|
||||
print(len(s)) # 12
|
||||
print(len('goodbye, world')) # 14
|
||||
```
|
||||
|
||||
#### 索引和切片
|
||||
|
||||
如果希望从字符串中取出某个字符，我们可以对字符串进行索引运算，运算符是`[n]`，其中`n`是一个整数，假设字符串的长度为`N`，那么`n`可以是从`0`到`N-1`的整数，其中`0`是字符串中第一个字符的索引，而`N-1`是字符串中最后一个字符的索引，通常称之为正向索引；在Python中，字符串的索引也可以是从`-1`到`-N`的整数，其中`-1`是最后一个字符的索引，而`-N`则是第一个字符的索引，通常称之为负向索引。
|
||||
|
||||
```Python
|
||||
s = 'abc123456'
|
||||
N = len(s)
|
||||
|
||||
# 获取第一个字符
|
||||
print(s[0], s[-N]) # a a
|
||||
|
||||
# 获取最后一个字符
|
||||
print(s[N-1], s[-1]) # 6 6
|
||||
|
||||
# 获取索引为2或-7的字符
|
||||
print(s[2], s[-7]) # c c
|
||||
|
||||
# 获取索引为5和-4的字符
|
||||
print(s[5], s[-4]) # 3 3
|
||||
```
|
||||
|
||||
如果要从字符串中取出多个字符，我们可以对字符串进行切片，运算符是`[i:j:k]`，其中`i`是开始索引，索引对应的字符可以取到；`j`是结束索引，索引对应的字符不能取到；`k`是步长，默认值为`1`，表示从前向后获取相邻字符的连续切片，所以`:k`部分可以省略。假设字符串的长度为`N`，当`k > 0`时表示正向切片（从前向后获取字符），如果没有给出`i`和`j`的值，则`i`的默认值是`0`，`j`的默认值是`N`；当`k < 0`时表示负向切片（从后向前获取字符），如果没有给出`i`和`j`的值，则`i`的默认值是`-1`，j的默认值是`-N - 1`。如果不理解，直接看下面的例子，记住第一个字符的索引是`0`或`-N`，最后一个字符的索引是`N-1`或`-1`就行了。
|
||||
|
||||
```Python
|
||||
s = 'abc123456'
|
||||
|
||||
# i=2, j=5, k=1的正向切片操作
|
||||
print(s[2:5]) # c12
|
||||
|
||||
# i=-7, j=-4, k=1的正向切片操作
|
||||
print(s[-7:-4]) # c12
|
||||
|
||||
# i=2, j=9, k=1的正向切片操作
|
||||
print(s[2:]) # c123456
|
||||
|
||||
# i=-7, j=9, k=1的正向切片操作
|
||||
print(s[-7:]) # c123456
|
||||
|
||||
# i=2, j=9, k=2的正向切片操作
|
||||
print(s[2::2]) # c246
|
||||
|
||||
# i=-7, j=9, k=2的正向切片操作
|
||||
print(s[-7::2]) # c246
|
||||
|
||||
# i=0, j=9, k=2的正向切片操作
|
||||
print(s[::2]) # ac246
|
||||
|
||||
# i=1, j=-1, k=2的正向切片操作
|
||||
print(s[1:-1:2]) # b135
|
||||
|
||||
# i=7, j=1, k=-1的负向切片操作
|
||||
print(s[7:1:-1]) # 54321c
|
||||
|
||||
# i=-2, j=-8, k=-1的负向切片操作
|
||||
print(s[-2:-8:-1]) # 54321c
|
||||
|
||||
# i=7, j=-10, k=-1的负向切片操作
|
||||
print(s[7::-1]) # 54321cba
|
||||
|
||||
# i=-1, j=1, k=-1的负向切片操作
|
||||
print(s[:1:-1]) # 654321c
|
||||
|
||||
# i=0, j=9, k=1的正向切片
|
||||
print(s[:]) # abc123456
|
||||
|
||||
# i=0, j=9, k=2的正向切片
|
||||
print(s[::2]) # ac246
|
||||
|
||||
# i=-1, j=-10, k=-1的负向切片
|
||||
print(s[::-1]) # 654321cba
|
||||
|
||||
# i=-1, j=-10, k=-2的负向切片
|
||||
print(s[::-2]) # 642ca
|
||||
```
|
||||
|
||||
### 字符串的方法
|
||||
|
||||
在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用`变量名.方法名()`的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数，后面我们讲面向对象编程的时候还会对这一概念详加说明。
|
||||
|
||||
#### 大小写相关操作
|
||||
|
||||
下面的代码演示了和字符串大小写变换相关的方法。
|
||||
|
||||
```Python
|
||||
s1 = 'hello, world!'
|
||||
|
||||
# 使用capitalize方法获得字符串首字母大写后的字符串
|
||||
print(s1.capitalize()) # Hello, world!
|
||||
# 使用title方法获得字符串每个单词首字母大写后的字符串
|
||||
print(s1.title()) # Hello, World!
|
||||
# 使用upper方法获得字符串大写后的字符串
|
||||
print(s1.upper()) # HELLO, WORLD!
|
||||
|
||||
s2 = 'GOODBYE'
|
||||
# 使用lower方法获得字符串小写后的字符串
|
||||
print(s2.lower()) # goodbye
|
||||
```
|
||||
|
||||
#### 查找操作
|
||||
|
||||
如果想在一个字符串中从前向后查找有没有另外一个字符串，可以使用字符串的`find`或`index`方法。
|
||||
|
||||
```Python
|
||||
s = 'hello, world!'
|
||||
|
||||
# find方法从字符串中查找另一个字符串所在的位置
|
||||
# 找到了返回字符串中另一个字符串首字符的索引
|
||||
print(s.find('or')) # 8
|
||||
# 找不到返回-1
|
||||
print(s.find('shit')) # -1
|
||||
# index方法与find方法类似
|
||||
# 找到了返回字符串中另一个字符串首字符的索引
|
||||
print(s.index('or')) # 8
|
||||
# 找不到引发异常
|
||||
print(s.index('shit')) # ValueError: substring not found
|
||||
```
|
||||
|
||||
在使用`find`和`index`方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为`0`的位置开始。`find`和`index`方法还有逆向查找（从后向前查找）的版本，分别是`rfind`和`rindex`，代码如下所示。
|
||||
|
||||
```Python
|
||||
s = 'hello good world!'
|
||||
|
||||
# 从前向后查找字符o出现的位置(相当于第一次出现)
|
||||
print(s.find('o')) # 4
|
||||
# 从索引为5的位置开始查找字符o出现的位置
|
||||
print(s.find('o', 5)) # 7
|
||||
# 从后向前查找字符o出现的位置(相当于最后一次出现)
|
||||
print(s.rfind('o')) # 12
|
||||
```
|
||||
|
||||
#### 性质判断
|
||||
|
||||
可以通过字符串的`startswith`、`endswith`来判断字符串是否以某个字符串开头和结尾；还可以用`is`开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。
|
||||
|
||||
```Python
|
||||
s1 = 'hello, world!'
|
||||
|
||||
# startwith方法检查字符串是否以指定的字符串开头返回布尔值
|
||||
print(s1.startswith('He')) # False
|
||||
print(s1.startswith('hel')) # True
|
||||
# endswith方法检查字符串是否以指定的字符串结尾返回布尔值
|
||||
print(s1.endswith('!')) # True
|
||||
|
||||
s2 = 'abc123456'
|
||||
|
||||
# isdigit方法检查字符串是否由数字构成返回布尔值
|
||||
print(s2.isdigit()) # False
|
||||
# isalpha方法检查字符串是否以字母构成返回布尔值
|
||||
print(s2.isalpha()) # False
|
||||
# isalnum方法检查字符串是否以数字和字母构成返回布尔值
|
||||
print(s2.isalnum()) # True
|
||||
```
|
||||
|
||||
#### 格式化字符串
|
||||
|
||||
在Python中，字符串类型可以通过`center`、`ljust`、`rjust`方法做居中、左对齐和右对齐的处理。
|
||||
|
||||
```Python
|
||||
s = 'hello, world'
|
||||
|
||||
# center方法以宽度20将字符串居中并在两侧填充*
|
||||
print(s.center(20, '*')) # ****hello, world****
|
||||
# rjust方法以宽度20将字符串右对齐并在左侧填充空格
|
||||
print(s.rjust(20)) # hello, world
|
||||
# ljust方法以宽度20将字符串左对齐并在右侧填充~
|
||||
print(s.ljust(20, '~')) # hello, world~~~~~~~~
|
||||
```
|
||||
|
||||
我们之前讲过，在用`print`函数输出字符串时，可以用下面的方式对字符串进行格式化。
|
||||
|
||||
```Python
|
||||
a = 321
|
||||
b = 123
|
||||
print('%d * %d = %d' % (a, b, a * b))
|
||||
```
|
||||
|
||||
当然，我们也可以用字符串的方法来完成字符串的格式，代码如下所示。
|
||||
|
||||
```Python
|
||||
a = 321
|
||||
b = 123
|
||||
print('{0} * {1} = {2}'.format(a, b, a * b))
|
||||
```
|
||||
|
||||
从Python 3.6开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上`f`来格式化字符串，在这种以`f`打头的字符串中，`{变量名}`是一个占位符，会被变量对应的值将其替换掉，代码如下所示。
|
||||
|
||||
```Python
|
||||
a = 321
|
||||
b = 123
|
||||
print(f'{a} * {b} = {a * b}')
|
||||
```
|
||||
|
||||
如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。
|
||||
|
||||
| 变量值 | 占位符 | 格式化结果 | 说明 |
|
||||
| ----------- | ---------- | ------------- | ---- |
|
||||
| `3.1415926` | `{:.2f}` | `'3.14'` | 保留小数点后两位 |
|
||||
| `3.1415926` | `{:+.2f}` | `'+3.14'` | 带符号保留小数点后两位 |
|
||||
| `-1` | `{:+.2f}` | `'-1.00'` | 带符号保留小数点后两位 |
|
||||
| `3.1415926` | `{:.0f}` | `'3'` | 不带小数 |
|
||||
| `123` | `{:0>10d}` | `0000000123` | 左边补`0`，补够10位 |
|
||||
| `123` | `{:x<10d}` | `123xxxxxxx` | 右边补`x` ，补够10位 |
|
||||
| `123` | `{:>10d}` | `' 123'` | 左边补空格，补够10位 |
|
||||
| `123` | `{:<10d}` | `'123 '` | 右边补空格，补够10位 |
|
||||
| `123456789` | `{:,}` | `'123,456,789'` | 逗号分隔格式 |
|
||||
| `0.123` | `{:.2%}` | `'12.30%'` | 百分比格式 |
|
||||
| `123456789` | `{:.2e}` | `'1.23e+08'` | 科学计数法格式 |
|
||||
|
||||
#### 修剪操作
|
||||
|
||||
字符串的`strip`方法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个方法非常有实用价值，通常用来将用户输入中因为不小心键入的头尾空格去掉，`strip`方法还有`lstrip`和`rstrip`两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。
|
||||
|
||||
```Python
|
||||
s = ' jackfrued@126.com \t\r\n'
|
||||
# strip方法获得字符串修剪左右两侧空格之后的字符串
|
||||
print(s.strip()) # jackfrued@126.com
|
||||
```
|
||||
|
||||
#### 其他方法
|
||||
|
||||
字符串类型还有许多其他的方法，等我们用到这些方法的时候再为大家进行续点讲解。平常我们使用字符串类型的时候，还有一个经常用到的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫正则表达式，Python语言通过标准库中的`re`模块提供了对正则表达式的支持，我们会在后续的课程中为大家讲解这个知识点。
|
||||
|
||||
### 简单的总结
|
||||
|
||||
知道如何表示和操作字符串对程序员来说是非常重要的，因为我们需要处理文本信息，Python中操作字符串可以用拼接、切片等运算符，也可以使用字符串类型的方法。
|
||||
|
||||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**，当然也可以看看我们为大家录制的入门视频，视频的链接地址：<https://pan.baidu.com/s/10y7sGM016YBM7gDdauGqLw>，密码：4s6r。
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
## 第010课：函数和字符串的应用
|
||||
|
||||
前面的两节课，我们介绍了函数和字符串。接下来我们通过一些案例来为大家讲解函数和字符串的应用。
|
||||
|
||||
### 一些案例
|
||||
|
||||
#### 例子1：设计一个生成指定长度验证码的函数。
|
||||
|
||||
> **说明**：验证码由数字和英文大小写字母构成。
|
||||
|
||||
```Python
|
||||
import random
|
||||
|
||||
ALL_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
||||
|
||||
|
||||
def generate_code(code_len=4):
|
||||
"""生成指定长度的验证码
|
||||
:param code_len: 验证码的长度(默认4个字符)
|
||||
:return: 由大小写英文字母和数字构成的随机验证码字符串
|
||||
"""
|
||||
code = ''
|
||||
for _ in range(code_len):
|
||||
# 产生0到字符串长度减1范围的随机数作为索引
|
||||
index = random.randrange(0, len(ALL_CHARS))
|
||||
# 利用索引运算从字符串中取出字符并进行拼接
|
||||
code += ALL_CHARS[index]
|
||||
return code
|
||||
```
|
||||
|
||||
我们用下面的代码生成10组随机验证码来测试上面的函数。
|
||||
|
||||
```Python
|
||||
for _ in range(10):
|
||||
print(generate_code())
|
||||
```
|
||||
|
||||
上面的函数其实还有一种更为简单的写法，直接利用`random`模块的随机抽样函数从字符串中取出指定数量的字符，然后利用字符串的`join`方法将选中的那些字符拼接起来。
|
||||
|
||||
```Python
|
||||
import random
|
||||
|
||||
ALL_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
||||
|
||||
|
||||
def generate_code(code_len=4):
|
||||
"""生成指定长度的验证码
|
||||
:param code_len: 验证码的长度(默认4个字符)
|
||||
:return: 由大小写英文字母和数字构成的随机验证码字符串
|
||||
"""
|
||||
return ''.join(random.choices(ALL_CHARS, k=code_len))
|
||||
```
|
||||
|
||||
> **说明**：`random`模块的`sample`和`choices`函数都可以实现随机抽样，`sample`实现无放回抽样，这意味着抽样取出的字符是不重复的；`choices`实现有放回抽样，这意味着可能会重复选中某些字符。这两个函数的第一个参数代表抽样的总体，而参数`k`代表抽样的数量。
|
||||
|
||||
#### 例子2：设计一个函数返回给定文件名的后缀名。
|
||||
|
||||
> **说明**：文件名通常是一个字符串，而文件的后缀名指的是文件名中最后一个`.`后面的部分，也称为文件的扩展名，它是某些操作系统用来标记文件类型的一种机制，例如在Windows系统上，后缀名`exe`表示这是一个可执行程序，而后缀名`txt`表示这是一个纯文本文件。需要注意的是，在Linux和macOS系统上，文件名可以以`.`开头，表示这是一个隐藏文件，像`.gitignore`这样的文件名，`.`后面并不是后缀名，这个文件没有后缀名或者说后缀名为`''`。
|
||||
|
||||
```Python
|
||||
def get_suffix(filename):
|
||||
"""获取文件名的后缀名
|
||||
:param filename: 文件名
|
||||
:return: 文件的后缀名
|
||||
"""
|
||||
# 从字符串中逆向查找.出现的位置
|
||||
pos = filename.rfind('.')
|
||||
# 通过切片操作从文件名中取出后缀名
|
||||
return filename[pos + 1:] if pos > 0 else ''
|
||||
```
|
||||
|
||||
可以用下面的代码对上面的函数做一个简单的测验。
|
||||
|
||||
```Python
|
||||
print(get_suffix('readme.txt')) # txt
|
||||
print(get_suffix('readme.txt.md')) # md
|
||||
print(get_suffix('.readme')) #
|
||||
print(get_suffix('readme.')) #
|
||||
print(get_suffix('readme')) #
|
||||
```
|
||||
|
||||
这个函数也有一个便捷的实现方式，就是直接使用`os.path`模块的`splitext`函数，这个函数会返回一个二元组（下节课会讲到），二元组中的第二个元素就是文件的后缀名包含`.`，如果要去掉`.`可以做一个字符串的切片操作即可。
|
||||
|
||||
```Python
|
||||
from os.path import splitext
|
||||
|
||||
|
||||
def get_suffix(filename):
|
||||
return splitext(filename)[1][1:]
|
||||
```
|
||||
|
||||
#### 例子3：在终端中显示跑马灯（滚动）文字。
|
||||
|
||||
> **说明**：实现跑马灯文字的原理非常简单，把当前字符串的第一个字符放到要输出的内容的最后面，把从第二个字符开始后面的内容放到要输出的内容的最前面，通过循环重复这个操作，就可以看到滚动起来的文字。两次循环之间的间隔可以通过`time`模块的`sleep`函数来实现，而清除屏幕上之前的输出可以使用`os`模块的`system`函数调用系统清屏命令来实现。
|
||||
|
||||
```Python
|
||||
import os
|
||||
import time
|
||||
|
||||
content = '北 京 欢 迎 你 为 你 开 天 辟 地 '
|
||||
while True:
|
||||
# Windows清除屏幕上的输出
|
||||
# os.system('cls')
|
||||
# macOS清除屏幕上的输出
|
||||
os.system('clear')
|
||||
print(content)
|
||||
# 休眠0.2秒（200毫秒）
|
||||
time.sleep(0.2)
|
||||
content = content[1:] + content[0]
|
||||
```
|
||||
|
||||
> **提示**：我们之前建议大家暂时用VS Code来编写Python代码，在“命令行提示符”或“终端”中来运行Python程序。如果你已经提前开始使用PyCharm了，需要提醒一句：PyCharm的运行窗口无用上面的方式做清屏处理。想看到上面代码的运行效果，建议在“命令行提示符”或“终端”中运行程序。
|
||||
|
||||
### 简单的总结
|
||||
|
||||
在写代码尤其是开发商业项目的时候，一定要有意识的**将相对独立且重复出现的功能封装成函数**，这样不管是自己还是团队的其他成员都可以通过调用函数的方式来使用这些功能。字符串是非常重要的数据类型，**字符串的常用运算和方法需要掌握**，因为一般的商业项目中，处理字符串比处理数值的操作要更多。
|
||||
|
||||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**，当然也可以看看我们为大家录制的入门视频，视频的链接地址：<https://pan.baidu.com/s/10y7sGM016YBM7gDdauGqLw>，密码：4s6r。
|
||||
Loading…
Reference in New Issue