翻到以前在大学坚持记录的Python学习笔记，花了一天的时间整理出来，整理时不经回忆起大学的时光，一眨眼几年就过去了，现在还在上学的你们，一定要珍惜现在，有个充实的校园生活。希望这次的分享对于你们有学习的作用。

一、创建第一个程序

第一个程序的创建、运行解释器和一些基本的调试。

Python 程序总是在解释器中运行。

解释器是一个“基于控制台的”应用程序，通常从命令外壳运行。

Python 3.6.1（v3.6.1:69c0db5050，2017 年 3 月 21 日，01:21:04）
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] 在达尔文
输入“ help ”、“ copyright ”、“ credits ”或“ license ” 以获取更多信息。
>>>

高手程序员用这种方式使用解释器通常是没有问题的，但是对于初学者来说就不太友好了。您可能正在使用为 Python 提供不同接口的环境。这很好，但是学习如何运行 Python 终端仍然是一项有用的技能。

当您启动 Python 时，您将获得一个交互模式，您可以在其中进行实验。

如果您开始输入语句，它们将立即运行。没有编辑/编译/运行/调试周期。

>> > 打印( 'hello world' )
 hello  world
>> >  37 * 42
1554
>> >  for  i  in  range ( 5 ):
...     打印（我）
...
0
1
2
3
4
>> >

这种所谓的read-eval-print-loop（或 REPL）对于调试和探索非常有用。

STOP：如果你不知道如何与 Python 交互，停止你正在做的事情并弄清楚如何去做。如果您使用的是 IDE，它可能隐藏在菜单选项或其他窗口后面。

让我们仔细看看 REPL 的元素：

• >>> 是开始新语句的解释器提示。
• ...是继续语句的解释器提示。输入一个空行以完成输入并运行您输入的内容。

该...提示可能还是取决于您的环境可能不会显示。在本课程中，它显示为空白，以便于剪切/粘贴代码示例。

下划线_保存最后的结果。

>> >  37  *  42
1554
>> >  _  *  2
3108
>> >  _  +  50
3158
>> >

这仅适用于交互模式。你永远不会_在程序中使用。

程序放在.py文件中。

# hello.py
打印（'你好世界'）

您可以使用您喜欢的文本编辑器创建这些文件。

要执行程序，请在终端中使用python命令运行它。例如，在命令行 Unix 中：

bash % python hello.py
你好，世界
重击%

或者从 Windows 外壳：

C:\SomeFolder>hello.py
hello world

C:\SomeFolder>c:\python36\python hello.py
hello world

注意：在 Windows 上，您可能需要指定 Python 解释器的完整路径，例如c:\python36\python. 但是，如果 Python 以通常的方式安装，您可能只需键入程序的名称，例如hello.py.

让我们解决以下问题：

一天早上，你出去在芝加哥西尔斯大厦旁的人行道上放一张美元钞票。此后的每一天，您出去的账单数量都会翻倍。一叠钞票超过塔的高度需要多长时间？

这是一个解决方案：

#sears.py
bill_thickness  =  0.11  *  0.001  # 米（0.11 毫米）
sears_height  =  442  # 高度（米）
num_bills  =  1
天 =  1

而 num_bills  *  bill_thickness  <  sears_height :
    打印( day , num_bills , num_bills  *  bill_thickness )
     day  =  day  +  1
    num_bills  =  num_bills  *  2

打印（'天数'，天）
打印（'账单数量'，num_bills）
打印（'最终高度'，num_bills  *  bill_thickness）

当你运行它时，你会得到以下输出：

bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
天数 23
票据数 4194304
最终高度 461.37344

使用此程序作为指南，您可以了解有关 Python 的许多重要核心概念。

一个python程序是一系列语句：

a  =  3  +  4
b  =  a  *  2
打印( b )

每条语句都以换行符结束。语句一个接一个地执行，直到控制到达文件的末尾。

注释是不会被执行的文本。

a  =  3  +  4
# 这是一条评论
b  =  a  *  2
打印( b )

注释由 表示#并延伸到行尾。

变量是值的名称。您可以使用从 a 到 z 的字母（小写和大写）。以及字符下划线_。数字也可以是变量名称的一部分，但作为第一个字符除外。

height  =  442  # 有效
_height  =  442  # 有效
height2  =  442  # 有效
2 height  =  442  # 无效

变量不需要用值的类型声明。类型与右侧的值相关联，而不是变量的名称。

height  =  442            # 一个整数
height  =  442.0          # 浮点
height  =  'Really high'  # 一个字符串

Python 是动态类型的。变量的感知“类型”可能会随着程序执行而改变，具体取决于分配给它的当前值。

Python 区分大小写。大写和小写字母被认为是不同的字母。这些都是不同的变量：

name  =  'Jake'
Name  =  'Elwood'
NAME  =  'Guido'

语言语句总是小写的。

而 X  <  0：    ＃行
WHILE  X  <  0：    ＃ERROR

该while语句执行一个循环。

而 num_bills  *  bill_thickness  <  sears_height :
    打印( day , num_bills , num_bills  *  bill_thickness )
     day  =  day  +  1
    num_bills  =  num_bills  *  2

打印（'天数'，天）

缩进下面的发言while后，只要会执行的表达式while是true。

缩进用于表示组合在一起的语句组。考虑前面的例子：

而 num_bills  *  bill_thickness  <  sears_height :
    打印( day , num_bills , num_bills  *  bill_thickness )
     day  =  day  +  1
    num_bills  =  num_bills  *  2

打印（'天数'，天）

缩进将以下语句组合在一起作为重复的操作：

打印（天，num_bills，num_bills * bill_thickness）
day = day + 1
num_bills = num_bills * 2

因为最后的print()语句没有缩进，所以不属于循环。空行只是为了便于阅读。不影响执行。

Python 的唯一要求是同一块内的缩进保持一致。例如，这是一个错误：

而 num_bills  *  bill_thickness  <  sears_height :
    打印( day , num_bills , num_bills  *  bill_thickness )
         day  =  day  +  1  # 错误
    num_bills  =  num_bills  *  2

该if语句用于执行条件：

if  a  >  b :
     print ( '计算机说不' )
 else :
     print ( '计算机说是' )

您可以通过使用添加额外检查来检查多个条件elif。

if  a  >  b :
     print ( '计算机说不' )
 elif  a  ==  b :
     print ( '计算机说是' )
 else :
     print ( '计算机说可能' )

该print函数使用传递的值生成一行文本。

print ( 'Hello world!' ) # 打印文本 'Hello world!'

您可以使用变量。打印的文本将是变量的值，而不是名称。

x  =  100
print ( x ) # 打印文本 '100'

如果传递多个值给print它们，则它们用空格分隔。

name  =  'Jake'
print ( 'My name is' , name ) # 打印文本 'My name is Jake'

print() 总是在最后放一个换行符。

打印（'你好'）
打印（'我的名字是'，'杰克'）

这打印：

Hello
My name is Jake

可以抑制额外的换行符：

打印（'你好'，结束= ''）
打印（'我的名字是'，'杰克'）

此代码现在将打印：

Hello My name is Jake

要读取一行键入的用户输入，请使用以下input()函数：

name  =  input ( '输入你的名字：' )
 print ( '你的名字是' , name )

input向用户打印提示并返回他们的响应。这对于小程序、学习练习或简单的调试很有用。它并未广泛用于实际程序。

有时您需要指定一个空的代码块。关键字pass用于它。

if  a  >  b :
     pass
else :
     print ( '计算机说假' )

这也称为“无操作”语句。它什么都不做。它用作语句的占位符，以后可能会添加。

二、数字

主要讨论基础数学计算。

Python 有 4 种类型的数字：

布尔值有两个值：True, False.

a  = 真
b  = 假

在数值上，它们被评估为值为1, 的整数0。

c  =  4  +  True  # 5
d  =  False
if  d  ==  0 :
     print ( 'd is False' )

但是，不要写那样的代码。这会很奇怪。

整数 (int)
任意大小和基数的有符号值：

a  =  37
b  =  - 299392993727716627377128481812241231
c  =  0x7fa8       # 十六进制
d  =  0o253        # 八进制
e  =  0b10001111   # 二进制

常见操作：

x + y      Add
x - y      Subtract
x * y      Multiply
x / y      Divide (produces a float)
x // y     Floor Divide (produces an integer)
x % y      Modulo (remainder)
x ** y     Power
x << n     Bit shift left
x >> n     Bit shift right
x & y      Bit-wise AND
x | y      Bit-wise OR
x ^ y      Bit-wise XOR
~x         Bit-wise NOT
abs(x)     Absolute value

使用十进制或指数表示法指定浮点值：

a  =  37.45
b  =  4e5  # 4 x 10**5 或 400,000
c  =  - 1.345e-10

浮点数使用本机 CPU 表示IEEE 754表示为双精度。这double与编程语言 C 中的类型相同。

17 位精度
指数从 -308 到 308

请注意，在表示小数时，浮点数是不精确的。

>> >  a  =  2.1  +  4.2
>> >  a  ==  6.3
错误
>> >  a
6.300000000000001
>> >

这不是 Python 问题，而是 CPU 上的底层浮点硬件。

常见操作：

x + y      Add
x - y      Subtract
x * y      Multiply
x / y      Divide
x // y     Floor Divide
x % y      Modulo
x ** y     Power
abs(x)     Absolute Value

除了按位运算符之外，这些运算符与整数相同。在math模块中可以找到其他数学函数。

导入 数学
a  = 数学。sqrt ( x )
 b  = 数学。sin ( x )
 c  = 数学。cos ( x )
 d  = 数学。tan ( x )
 e  = 数学。日志( x )

以下比较/关系运算符适用于数字：

x < y      Less than
x <= y     Less than or equal
x > y      Greater than
x >= y     Greater than or equal
x == y     Equal to
x != y     Not equal to

您可以使用形成更复杂的布尔表达式

and, or,not

这里有一些例子：

如果 b  >=  a 和 b  <=  c：
    打印（'b 在 a 和 c' 之间）

如果 不是（b  <  a 或 b  >  c）：
    打印（'b 仍然在 a 和 c' 之间）

类型名称可用于转换值：

a  =  int ( x )     # 将 x 转换为整数
b  =  float ( x )   # 将 x 转换为浮点数

试试看。

>> >  a  =  3.14159
>> >  int ( a )
 3
>> >  b  =  '3.14159'  # 它也适用于包含数字的字符串
>> >  float ( b )
 3.14159
>> >

三、字符串

介绍处理文本的方法。

字符串文字是用引号写在程序中的。

# 单引号
a  =  'Yeah but no but yes but...'

# 双引号
b  =  "计算机说不"

# 三重引号
c  =  '''
看着我的眼睛，看着我的眼睛，眼睛，眼睛，眼睛，
不要在眼睛周围
，不要在眼睛周围，
看着我的眼睛，你在下。
'''

通常字符串只能跨越一行。三重引号捕获包含在多行中的所有文本，包括所有格式。

使用单 (’) 和双 (") 引号之间没有区别。但是，必须使用用于开始字符串的相同类型的引号来终止它。

转义码用于表示控制字符和无法直接在键盘上轻松输入的字符。以下是一些常见的转义码：

'\n'      Line feed
'\r'      Carriage return
'\t'      Tab
'\''      Literal single quote
'\"'      Literal double quote
'\\'      Literal backslash

字符串中的每个字符在内部存储为所谓的 Unicode“代码点”，它是一个整数。您可以使用以下转义序列指定确切的代码点值：

a = ’ \xf1 ’ # a = ‘ñ’
b = ’ \u2200 ’ # b = ‘∀’
c = ’ \U0001D122 ’ # c = ‘’
d = ‘\N{FOR ALL}’ # d = ’ ∀’
在Unicode字符数据库是所有可用的字符代码的参考。

字符串就像访问单个字符的数组一样工作。您使用从 0 开始的整数索引。负索引指定相对于字符串末尾的位置。

a  =  'Hello world'
b  =  a [ 0 ]           # 'H'
c  =  a [ 4 ]           # 'o'
d  =  a [ - 1 ]          # 'd'（字符串结束）

您还可以切片或选择指定索引范围的子字符串:。

d  =  a [: 5 ]      # 'Hello'
e  =  a [ 6 :]      # 'world'
f  =  a [ 3 : 8 ]     # 'lo wo'
g  =  a [ - 5 :]     # 'world'

不包括结束索引处的字符。缺少索引假定字符串的开头或结尾。

串联、长度、成员资格和复制。

# 连接 (+)
a  =  'Hello'  +  'World'    # 'HelloWorld'
b  =  'Say '  +  a           # 'Say HelloWorld'

# 长度 (len)
s  =  '你好'
len ( s )                   # 5

# 成员资格测试 (`in`, `not in`)
t  =  'e'  in  s             # True
f  =  'x'  in  s             # False
g  =  'hi'  not  in  s        # True

# 复制 (s * n)
rep  =  s  *  5              # 'HelloHelloHelloHelloHello'

字符串具有对字符串数据执行各种操作的方法。

示例：剥离任何前导/尾随空格。

s  =  '你好'
t  =  s。strip ()      #'你好'

示例：大小写转换。

s  =  '你好'
l  =  s。下()      # '你好'
u  =  s . 上()      #'你好'

示例：替换文本。

s  =  '你好世界'
t  =  s。replace ( 'Hello' , 'Hallo' )    # '你好世界'

更多字符串方法：

字符串有多种其他方法用于测试和操作文本数据。这是一个小方法示例：

小号。Endswith ( suffix )      # 检查字符串是否以后缀
s结尾。find ( t )               # 在 s
s中第一次出现 t。index ( t )              # t 在 s
s中第一次出现。isalpha ()             # 检查字符是否为字母
s . isdigit ()             # 检查字符是否为数字
s . islower ()             # 检查字符是否为小写
s . 上层()             # 检查字符是否为大写
s . join ( slist )           # 使用 s 作为分隔符
s加入字符串列表。lower ()               # 转换为小写
s。replace ( old , new )      # 替换文本
s。rfind ( t )              # 从字符串
s 的末尾搜索 t。rindex ( t )             # 从字符串
s 的末尾搜索 t。拆分([delim ])        # 将字符串拆分为子字符串列表
s . startswith ( prefix )    # 检查字符串是否以前缀
s开头。strip ()               # 去除前导/尾随空格
s。upper ()               # 转换为大写

字符串是“不可变的”或只读的。一旦创建，该值就无法更改。

>> > 小号 =  '的Hello World'
>> > 小号[ 1 ] =  'A'
回溯（最 近期 呼叫 最后）：
文件 “<标准输入>” ，线 1，在 <模块>
类型错误：'STR' 对象 确实 不 支持 项目 分配
>> >

所有操作字符串数据的操作和方法，总是创建新的字符串。

使用str()任何值转换为字符串。结果是一个字符串，其中包含与print()语句生成的文本相同的文本。

>> >  x  =  42
>> >  str ( x )
 '42'
>> >

一串 8 位字节，通常在低级 I/O 中遇到，写成如下：

data  =  b'Hello World \r \n '

通过在第一个引号前加上一点 b，您可以指定它是一个字节字符串而不是文本字符串。

大多数通常的字符串操作都有效。

len ( data )                          # 13
data [ 0 : 5 ]                          # b'Hello'
data . 替换( b'Hello' , b'Cruel' )   # b'Cruel World\r\n'

索引有点不同，因为它以整数形式返回字节值。

数据[ 0 ]    # 72（'H' 的 ASCII 码）

与文本字符串之间的转换。

文本 = 数据。decode ( 'utf-8' ) # bytes -> text
data  =  text . 编码( 'utf-8' ) # 文本 -> 字节

所述'utf-8'参数指定的字符编码。其他常见值包括'ascii'和'latin1'。

原始字符串是带有未解释反斜杠的字符串文字。它们通过在初始引号前加上小写的“r”来指定。

>> >  rs  =  r'c:\newdata\test'  # 原始（未解释的反斜杠）
>> >  rs
'c: \\ newdata \\ test'

该字符串是包含在其中的文字文本，与键入的完全相同。这在反斜杠具有特殊意义的情况下很有用。例如：文件名、正则表达式等。

带有格式化表达式替换的字符串。

>> > 名称 =  'IBM'
>> > 股 =  100
>> > 价格 =  91.1
>> > 一个 =  F” {名称：> 10秒}  {股：10D }  {价格：10.2f } '
>> > 一个
' IBM 100 91.10'
>> >  b  =  f'Cost = $ {股份*价格:0.2f } '
>> > 乙
'成本 = $9110.00'
>> >

注意：这需要 Python 3.6 或更新版本。

四、列表

介绍列表，这是 Python 用于保存有序值集合的主要类型。

使用方括号定义列表文字：

名称 = [ 'Elwood' , 'Jake' , 'Curtis' ]
 nums  = [ 39 , 38 , 42 , 65 , 111 ]

有时列表是由其他方法创建的。例如，可以使用以下split()方法将字符串拆分为列表：

>> > 行 =  'GOOG,100,490.10'
>> > 行 = 行。拆分( ',' )
 >> > 行
[ 'GOOG' , '100' , '490.10' ]
 >> >

列表可以包含任何类型的项目。添加一个新项目使用append()：

名字。append ( 'Murphy' )     # 添加到结尾
名称。insert ( 2 , 'Aretha' ) # 在中间插入

使用+来连接列表：

s  = [ 1 , 2 , 3 ]
 t  = [ 'a' , 'b' ]
 s  +  t            # [1, 2, 3, 'a', 'b']

列表由整数索引。从 0 开始。

姓名 = [ '埃尔伍德'、'杰克'、'柯蒂斯' ]

名称[ 0 ]   # 'Elwood'
名称[ 1 ]   # 'Jake'
名称[ 2 ]   # 'Curtis'

负指数从最后开始计数。

名称[ - 1 ] # '柯蒂斯'

您可以更改列表中的任何项目。

名字[ 1 ] =  'Joliet Jake'
名字                     # ['Elwood', 'Joliet Jake', 'Curtis']

列表的长度。

名称 = [ 'Elwood' , 'Jake' , 'Curtis' ]
 len (名称)   # 3

成员资格测试 ( in, not in)。

“埃尔伍德” 在 名称       ＃真
“布兰妮 不是 在 名称  ＃真

复制 ( s * n)。

s  = [ 1 , 2 , 3 ]
 s  *  3    # [1, 2, 3, 1, 2, 3, 1, 2, 3]

使用for遍历列表内容。

for  name  in  names :
     # use name
    # eg print(name)
    ...

这类似于foreach其他编程语言的声明。

要快速找到某物的位置，请使用index()。

姓名 = [ 'Elwood' , 'Jake' , 'Curtis' ]
姓名。索引（'柯蒂斯'）    #2

如果元素出现多次，index()将返回第一次出现的索引。

如果未找到该元素，则会引发ValueError异常。

您可以通过元素值或索引删除项目：

# 使用值
名称。删除（'柯蒂斯'）

# 使用索引
删除 名称[ 1 ]

移除一个项目不会产生一个洞。其他物品将向下移动以填充空出的空间。如果元素出现多次，remove()则只删除第一次出现。

列表可以“就地”排序。

s  = [ 10 , 1 , 7 , 3 ]
 s。排序()                     # [1, 3, 7, 10]

# 倒序
s  = [ 10 , 1 , 7 , 3 ]
 s . sort ( reverse = True )         # [10, 7, 3, 1]

# 它适用于任何有序数据
s  = [ 'foo' , 'bar' , 'spam' ]
 s。sort ()                     # ['bar', 'foo', 'spam']

使用sorted()，如果你想使一个新的列表，而不是：

t  =  sorted ( s )                # s 不变，t 保存排序值

注意：列表不是为数学运算设计的。

>> >  nums  = [ 1 , 2 , 3 , 4 , 5 ]
 >> >  nums  *  2
[ 1 , 2 , 3 , 4 , 5 , 1 , 2 , 3 , 4 , 5 ]
 >> >  nums  + [ 10 , 11 , 12 , 13 , 14 ]
[ 1 , 2 , 3 , 4 , 5 , 10 , 11 , 12 , 13 , 14 ]

具体来说，列表不像在 MATLAB、Octave、R 等中那样表示向量/矩阵。但是，有一些包可以帮助您解决这个问题（例如numpy）。

五、文件管理

大多数程序需要从某处读取输入。本节主要学习文件访问。

打开一个文件。

f  =  open ( 'foo.txt' , 'rt' )      # 打开阅读（文本）
g  =  open ( 'bar.txt' , 'wt' )      # 打开写作（文本）

读取所有数据。

数据 =  f。读()

# 最多只读取 'maxbytes' 个字节
data  =  f . 读取([ maxbytes ])

写一些文字。

克。写（'一些文字'）

完成后关闭。

f . 关闭()
 g。关闭()

文件应该正确关闭，这是一个容易忘记的步骤。因此，首选方法是使用这样的with语句。

with  open ( filename , 'rt' ) as  file :
     # 使用文件`file`
    ...
    # 无需显式关闭
...语句

当控制离开缩进的代码块时，这会自动关闭文件。

一次性读取整个文件作为字符串。

以 open ( 'foo.txt' , 'rt' )作为 文件：
     data  =  file。read ()
     # `data` 是一个字符串，包含 `foo.txt` 中的所有文本

通过迭代逐行读取文件。

with  open ( filename , 'rt' ) as  file :
     for  line  in  file :
         # 处理该行

写入字符串数据。

使用 open ( 'outfile' , 'wt' )作为 out :
     out。写（'你好世界\n '）
    ...

重定向打印功能。

使用 open ( 'outfile' , 'wt' )作为 out：
     print ( 'Hello World' , file = out )
    ...

六、功能

随着您的程序开始变大，您将需要组织起来。简要介绍函数和库模块。还引入了异常的错误处理。

对要重用的代码使用函数。下面是一个函数定义：

def  sumcount ( n ):
     '''
    返回前 n 个整数的总和
    '''
    total  =  0
    而 n  >  0 :
         total  +=  n
        n  -=  1
    return  total

调用一个函数。

a  =  sumcount ( 100 )

函数是执行某些任务并返回结果的一系列语句。在return需要的关键字明确指定函数的返回值。

Python 附带了一个大型标准库。库模块使用import. 例如：

导入 数学
x  = 数学。sqrt ( 10 )导入urllib。请求u = urllib。请求。urlopen ( 'http://www.python.org/' )
数据= u。读()

稍后我们将更详细地介绍库和模块。

函数将错误报告为异常。异常会导致函数中止，如果未经处理，可能会导致整个程序停止。

在你的 python REPL 中试试这个。

>> >  INT（'N / A' ）
回溯（最 近期 呼叫 最后）：
文件 “<标准输入>” ，线 1，在 <模块>
ValueError异常：无效 字面 为 INT（）与 碱 10：'N / A'
>> >

出于调试目的，该消息描述了发生的情况、错误发生的位置以及显示导致失败的其他函数调用的回溯。

异常可以被捕获和处理。

要捕获，请使用该try - except语句。

用于 线 在 ˚F：
    字段 = 线。split ()
    尝试：
         shares  =  int ( fields [ 1 ])
    除了 ValueError：
         print ( "Couldn't parse" , line )
    ...

该名称ValueError必须与您尝试捕获的错误类型相匹配。

根据正在执行的操作，通常很难准确地提前知道可能发生哪些类型的错误。不管是好是坏，异常处理通常是在程序意外崩溃后添加的（即，“哦，我们忘记捕获那个错误。我们应该处理它！”）。

要引发异常，请使用该raise语句。

提高 RuntimeError（“这是一个乱哄哄”）

这将导致程序因异常回溯而中止。除非被try-except方块抓住。

% python3 foo.py
Traceback（最近一次调用最后一次）：
  文件“ foo.py ”，第 21 行，在 < module > 中
    raise RuntimeError( “ What a kerfuffle ” )
RuntimeError: What a kerfuffle

感谢观看，关注我持续为您分享干货内容，你的收藏、评论、点赞就是对我最大的支持! 需要领取我之前学习资料的可以私信我，告诉我你具体需要的资料。

x < y      Less than
x <= y     Less than or equal
x > y      Greater than
x >= y     Greater than or equal
x == y     Equal to
x != y     Not equal to

您可以使用形成更复杂的布尔表达式

and, or,not

这里有一些例子：

如果 b  >=  a 和 b  <=  c：
    打印（'b 在 a 和 c' 之间）

如果 不是（b  <  a 或 b  >  c）：
    打印（'b 仍然在 a 和 c' 之间）

类型名称可用于转换值：

a  =  int ( x )     # 将 x 转换为整数
b  =  float ( x )   # 将 x 转换为浮点数

试试看。

>> >  a  =  3.14159
>> >  int ( a )
 3
>> >  b  =  '3.14159'  # 它也适用于包含数字的字符串
>> >  float ( b )
 3.14159
>> >

三、字符串

介绍处理文本的方法。

字符串文字是用引号写在程序中的。

# 单引号
a  =  'Yeah but no but yes but...'

# 双引号
b  =  "计算机说不"

# 三重引号
c  =  '''
看着我的眼睛，看着我的眼睛，眼睛，眼睛，眼睛，
不要在眼睛周围
，不要在眼睛周围，
看着我的眼睛，你在下。
'''

通常字符串只能跨越一行。三重引号捕获包含在多行中的所有文本，包括所有格式。

使用单 (’) 和双 (") 引号之间没有区别。但是，必须使用用于开始字符串的相同类型的引号来终止它。

转义码用于表示控制字符和无法直接在键盘上轻松输入的字符。以下是一些常见的转义码：

'\n'      Line feed
'\r'      Carriage return
'\t'      Tab
'\''      Literal single quote
'\"'      Literal double quote
'\\'      Literal backslash

字符串中的每个字符在内部存储为所谓的 Unicode“代码点”，它是一个整数。您可以使用以下转义序列指定确切的代码点值：

a = ’ \xf1 ’ # a = ‘ñ’
b = ’ \u2200 ’ # b = ‘∀’
c = ’ \U0001D122 ’ # c = ‘’
d = ‘\N{FOR ALL}’ # d = ’ ∀’
在Unicode字符数据库是所有可用的字符代码的参考。

字符串就像访问单个字符的数组一样工作。您使用从 0 开始的整数索引。负索引指定相对于字符串末尾的位置。

a  =  'Hello world'
b  =  a [ 0 ]           # 'H'
c  =  a [ 4 ]           # 'o'
d  =  a [ - 1 ]          # 'd'（字符串结束）

您还可以切片或选择指定索引范围的子字符串:。

d  =  a [: 5 ]      # 'Hello'
e  =  a [ 6 :]      # 'world'
f  =  a [ 3 : 8 ]     # 'lo wo'
g  =  a [ - 5 :]     # 'world'

不包括结束索引处的字符。缺少索引假定字符串的开头或结尾。

串联、长度、成员资格和复制。

# 连接 (+)
a  =  'Hello'  +  'World'    # 'HelloWorld'
b  =  'Say '  +  a           # 'Say HelloWorld'

# 长度 (len)
s  =  '你好'
len ( s )                   # 5

# 成员资格测试 (`in`, `not in`)
t  =  'e'  in  s             # True
f  =  'x'  in  s             # False
g  =  'hi'  not  in  s        # True

# 复制 (s * n)
rep  =  s  *  5              # 'HelloHelloHelloHelloHello'

字符串具有对字符串数据执行各种操作的方法。

示例：剥离任何前导/尾随空格。

s  =  '你好'
t  =  s。strip ()      #'你好'

示例：大小写转换。

s  =  '你好'
l  =  s。下()      # '你好'
u  =  s . 上()      #'你好'

示例：替换文本。

s  =  '你好世界'
t  =  s。replace ( 'Hello' , 'Hallo' )    # '你好世界'

更多字符串方法：

字符串有多种其他方法用于测试和操作文本数据。这是一个小方法示例：

小号。Endswith ( suffix )      # 检查字符串是否以后缀
s结尾。find ( t )               # 在 s
s中第一次出现 t。index ( t )              # t 在 s
s中第一次出现。isalpha ()             # 检查字符是否为字母
s . isdigit ()             # 检查字符是否为数字
s . islower ()             # 检查字符是否为小写
s . 上层()             # 检查字符是否为大写
s . join ( slist )           # 使用 s 作为分隔符
s加入字符串列表。lower ()               # 转换为小写
s。replace ( old , new )      # 替换文本
s。rfind ( t )              # 从字符串
s 的末尾搜索 t。rindex ( t )             # 从字符串
s 的末尾搜索 t。拆分([delim ])        # 将字符串拆分为子字符串列表
s . startswith ( prefix )    # 检查字符串是否以前缀
s开头。strip ()               # 去除前导/尾随空格
s。upper ()               # 转换为大写

字符串是“不可变的”或只读的。一旦创建，该值就无法更改。

>> > 小号 =  '的Hello World'
>> > 小号[ 1 ] =  'A'
回溯（最 近期 呼叫 最后）：
文件 “<标准输入>” ，线 1，在 <模块>
类型错误：'STR' 对象 确实 不 支持 项目 分配
>> >

所有操作字符串数据的操作和方法，总是创建新的字符串。

使用str()任何值转换为字符串。结果是一个字符串，其中包含与print()语句生成的文本相同的文本。

>> >  x  =  42
>> >  str ( x )
 '42'
>> >

一串 8 位字节，通常在低级 I/O 中遇到，写成如下：

data  =  b'Hello World \r \n '

通过在第一个引号前加上一点 b，您可以指定它是一个字节字符串而不是文本字符串。

大多数通常的字符串操作都有效。

len ( data )                          # 13
data [ 0 : 5 ]                          # b'Hello'
data . 替换( b'Hello' , b'Cruel' )   # b'Cruel World\r\n'

索引有点不同，因为它以整数形式返回字节值。

数据[ 0 ]    # 72（'H' 的 ASCII 码）

与文本字符串之间的转换。

文本 = 数据。decode ( 'utf-8' ) # bytes -> text
data  =  text . 编码( 'utf-8' ) # 文本 -> 字节

所述'utf-8'参数指定的字符编码。其他常见值包括'ascii'和'latin1'。

原始字符串是带有未解释反斜杠的字符串文字。它们通过在初始引号前加上小写的“r”来指定。

>> >  rs  =  r'c:\newdata\test'  # 原始（未解释的反斜杠）
>> >  rs
'c: \\ newdata \\ test'

该字符串是包含在其中的文字文本，与键入的完全相同。这在反斜杠具有特殊意义的情况下很有用。例如：文件名、正则表达式等。

带有格式化表达式替换的字符串。

>> > 名称 =  'IBM'
>> > 股 =  100
>> > 价格 =  91.1
>> > 一个 =  F” {名称：> 10秒}  {股：10D }  {价格：10.2f } '
>> > 一个
' IBM 100 91.10'
>> >  b  =  f'Cost = $ {股份*价格:0.2f } '
>> > 乙
'成本 = $9110.00'
>> >

注意：这需要 Python 3.6 或更新版本。

四、列表

介绍列表，这是 Python 用于保存有序值集合的主要类型。

使用方括号定义列表文字：

名称 = [ 'Elwood' , 'Jake' , 'Curtis' ]
 nums  = [ 39 , 38 , 42 , 65 , 111 ]

有时列表是由其他方法创建的。例如，可以使用以下split()方法将字符串拆分为列表：

>> > 行 =  'GOOG,100,490.10'
>> > 行 = 行。拆分( ',' )
 >> > 行
[ 'GOOG' , '100' , '490.10' ]
 >> >

列表可以包含任何类型的项目。添加一个新项目使用append()：

名字。append ( 'Murphy' )     # 添加到结尾
名称。insert ( 2 , 'Aretha' ) # 在中间插入

使用+来连接列表：

s  = [ 1 , 2 , 3 ]
 t  = [ 'a' , 'b' ]
 s  +  t            # [1, 2, 3, 'a', 'b']

列表由整数索引。从 0 开始。

姓名 = [ '埃尔伍德'、'杰克'、'柯蒂斯' ]

名称[ 0 ]   # 'Elwood'
名称[ 1 ]   # 'Jake'
名称[ 2 ]   # 'Curtis'

负指数从最后开始计数。

名称[ - 1 ] # '柯蒂斯'

您可以更改列表中的任何项目。

名字[ 1 ] =  'Joliet Jake'
名字                     # ['Elwood', 'Joliet Jake', 'Curtis']

列表的长度。

名称 = [ 'Elwood' , 'Jake' , 'Curtis' ]
 len (名称)   # 3

成员资格测试 ( in, not in)。

“埃尔伍德” 在 名称       ＃真
“布兰妮 不是 在 名称  ＃真

复制 ( s * n)。

s  = [ 1 , 2 , 3 ]
 s  *  3    # [1, 2, 3, 1, 2, 3, 1, 2, 3]

使用for遍历列表内容。

for  name  in  names :
     # use name
    # eg print(name)
    ...

这类似于foreach其他编程语言的声明。

要快速找到某物的位置，请使用index()。

姓名 = [ 'Elwood' , 'Jake' , 'Curtis' ]
姓名。索引（'柯蒂斯'）    #2

如果元素出现多次，index()将返回第一次出现的索引。

如果未找到该元素，则会引发ValueError异常。

您可以通过元素值或索引删除项目：

# 使用值
名称。删除（'柯蒂斯'）

# 使用索引
删除 名称[ 1 ]

移除一个项目不会产生一个洞。其他物品将向下移动以填充空出的空间。如果元素出现多次，remove()则只删除第一次出现。

列表可以“就地”排序。

s  = [ 10 , 1 , 7 , 3 ]
 s。排序()                     # [1, 3, 7, 10]

# 倒序
s  = [ 10 , 1 , 7 , 3 ]
 s . sort ( reverse = True )         # [10, 7, 3, 1]

# 它适用于任何有序数据
s  = [ 'foo' , 'bar' , 'spam' ]
 s。sort ()                     # ['bar', 'foo', 'spam']

使用sorted()，如果你想使一个新的列表，而不是：

t  =  sorted ( s )                # s 不变，t 保存排序值

注意：列表不是为数学运算设计的。

>> >  nums  = [ 1 , 2 , 3 , 4 , 5 ]
 >> >  nums  *  2
[ 1 , 2 , 3 , 4 , 5 , 1 , 2 , 3 , 4 , 5 ]
 >> >  nums  + [ 10 , 11 , 12 , 13 , 14 ]
[ 1 , 2 , 3 , 4 , 5 , 10 , 11 , 12 , 13 , 14 ]

具体来说，列表不像在 MATLAB、Octave、R 等中那样表示向量/矩阵。但是，有一些包可以帮助您解决这个问题（例如numpy）。

五、文件管理

大多数程序需要从某处读取输入。本节主要学习文件访问。

打开一个文件。

f  =  open ( 'foo.txt' , 'rt' )      # 打开阅读（文本）
g  =  open ( 'bar.txt' , 'wt' )      # 打开写作（文本）

读取所有数据。

数据 =  f。读()

# 最多只读取 'maxbytes' 个字节
data  =  f . 读取([ maxbytes ])

写一些文字。

克。写（'一些文字'）

完成后关闭。

f . 关闭()
 g。关闭()

文件应该正确关闭，这是一个容易忘记的步骤。因此，首选方法是使用这样的with语句。

with  open ( filename , 'rt' ) as  file :
     # 使用文件`file`
    ...
    # 无需显式关闭
...语句

当控制离开缩进的代码块时，这会自动关闭文件。

一次性读取整个文件作为字符串。

以 open ( 'foo.txt' , 'rt' )作为 文件：
     data  =  file。read ()
     # `data` 是一个字符串，包含 `foo.txt` 中的所有文本

通过迭代逐行读取文件。

with  open ( filename , 'rt' ) as  file :
     for  line  in  file :
         # 处理该行

写入字符串数据。

使用 open ( 'outfile' , 'wt' )作为 out :
     out。写（'你好世界\n '）
    ...

重定向打印功能。

使用 open ( 'outfile' , 'wt' )作为 out：
     print ( 'Hello World' , file = out )
    ...

六、功能

随着您的程序开始变大，您将需要组织起来。简要介绍函数和库模块。还引入了异常的错误处理。

对要重用的代码使用函数。下面是一个函数定义：

def  sumcount ( n ):
     '''
    返回前 n 个整数的总和
    '''
    total  =  0
    而 n  >  0 :
         total  +=  n
        n  -=  1
    return  total

调用一个函数。

a  =  sumcount ( 100 )

函数是执行某些任务并返回结果的一系列语句。在return需要的关键字明确指定函数的返回值。

Python 附带了一个大型标准库。库模块使用import. 例如：

导入 数学
x  = 数学。sqrt ( 10 )导入urllib。请求u = urllib。请求。urlopen ( 'http://www.python.org/' )
数据= u。读()

稍后我们将更详细地介绍库和模块。

函数将错误报告为异常。异常会导致函数中止，如果未经处理，可能会导致整个程序停止。

在你的 python REPL 中试试这个。

>> >  INT（'N / A' ）
回溯（最 近期 呼叫 最后）：
文件 “<标准输入>” ，线 1，在 <模块>
ValueError异常：无效 字面 为 INT（）与 碱 10：'N / A'
>> >

出于调试目的，该消息描述了发生的情况、错误发生的位置以及显示导致失败的其他函数调用的回溯。

异常可以被捕获和处理。

要捕获，请使用该try - except语句。

用于 线 在 ˚F：
    字段 = 线。split ()
    尝试：
         shares  =  int ( fields [ 1 ])
    除了 ValueError：
         print ( "Couldn't parse" , line )
    ...

该名称ValueError必须与您尝试捕获的错误类型相匹配。

根据正在执行的操作，通常很难准确地提前知道可能发生哪些类型的错误。不管是好是坏，异常处理通常是在程序意外崩溃后添加的（即，“哦，我们忘记捕获那个错误。我们应该处理它！”）。

要引发异常，请使用该raise语句。

提高 RuntimeError（“这是一个乱哄哄”）

这将导致程序因异常回溯而中止。除非被try-except方块抓住。

% python3 foo.py
Traceback（最近一次调用最后一次）：
  文件“ foo.py ”，第 21 行，在 < module > 中
    raise RuntimeError( “ What a kerfuffle ” )
RuntimeError: What a kerfuffle

感谢观看，关注我持续为您分享干货内容，你的收藏、评论、点赞就是对我最大的支持! 需要领取我之前学习资料的可以私信我，告诉我你具体需要的资料。