phython学习笔记.docx

phython学习笔记.docx

《phython学习笔记.docx》由会员分享，可在线阅读，更多相关《phython学习笔记.docx（28页珍藏版）》请在冰豆网上搜索。

phython学习笔记

Python

1.基础部分

1.1下载地址&学习地址

官网下载即可。

1.2作为计算器使用

>>>2+2

4

>>>50-5*6

20

>>>（50-5*6）/4

5.0

>>>8/5＃除法总是返回浮点数

1.6

>>>17/3＃经典分区返回一个浮点数

5.666666666666667

>>>

>>>17//3＃分区丢弃小数部分

5

>>>17％3＃％运算符返回分区的剩余部分

2

>>>5*3+2＃结果*除数+余数

17

>>>5**2＃5平方

25

>>>2**7＃27

128的幂

>>>width=20#等号（=）用于为变量赋值

>>>height=5*9

>>>width*height

900

>>>a=3+5j＃支持虚数

>>>tax=12.5/100

>>>price=100.50

>>>price*tax

12.5625

>>>price+_＃在交互模式下最后打印的表达式被分配给变量_（只读）

113.0625

>>>round（_，2）

113.06

1.3字符串

字符串的表示可以用单引号（'...'）或双引号（"..."）括起来，结果相同。

 \可以用来逃避引号：

（与其他语言不同，特殊字符（如\n单引号'...'和双"..."引号）具有相同的含义。

两者之间的唯一区别在于，在单引号内，您不需要转义"（但您必须转义\'），反之亦然。

）

>>>'spameggs'#singlequotes

'spameggs'

>>>'doesn\'t'#use\'toescapethesinglequote...

"doesn't"

>>>"doesn't"#...orusedoublequotesinstead

"doesn't"

>>>'"Yes,"hesaid.'

'"Yes,"hesaid.'

>>>"\"Yes,\"hesaid."

'"Yes,"hesaid.'

>>>'"Isn\'t,"shesaid.'

'"Isn\'t,"shesaid.'

在交互式解释器中，输出字符串用引号括起来，特殊字符用反斜线转义。

虽然这有时看起来不同于输入（封闭引号可能会改变），但这两个字符串是等价的。

如果字符串包含单引号且不带双引号，则该字符串将用双引号括起来，否则将用单引号括起来。

该print（）函数通过省略封闭引号并打印转义字符和特殊字符，产生更易读的输出：

>>>'"Isn\'t,"shesaid.'

'"Isn\'t,"shesaid.'

>>>print（'"Isn\'t,"shesaid.'）

"Isn't,"shesaid.

>>>s='Firstline.\nSecondline.'#\nmeansnewline

>>>s#withoutprint（）,\nisincludedintheoutput

'Firstline.\nSecondline.'

>>>print（s）#withprint（）,\nproducesanewline

Firstline.

Secondline.

如果您不希望以前缀的字符\被解释为特殊字符，则可以通过在第一个引号之前添加一个字符串来使用原始字符串r：

>>>print（'C:

\some\name'）#here\nmeansnewline!

C:

\some

ame

>>>print（r'C:

\some\name'）#notetherbeforethequote

C:

\some\name

字符串文字可以跨越多行。

一种方法是使用三引号：

 """..."""或'''...'''。

行尾自动包含在字符串中，但可以通过在行尾添加一个\来防止这种情况。

以下示例：

print（"""\

Usage:

thingy[OPTIONS]

-hDisplaythisusagemessage

-HhostnameHostnametoconnectto

"""）

产生以下输出（请注意，不包括初始换行符）：

Usage:

thingy[OPTIONS]

-hDisplaythisusagemessage

-HhostnameHostnametoconnectto

字符串可以与+操作员串接（粘合在一起），并重复以下操作*：

>>>#3times'un',followedby'ium'

>>>3*'un'+'ium'

'unununium'

两个或多个字符串文字（即引号之间的文字）彼此相邻，会自动连接在一起。

>>>'Py''thon'

'Python'

当您想要分隔长字符串时，此功能特别有用：

>>>text=（'Putseveralstringswithinparentheses'

...'tohavethemjoinedtogether.'）

>>>text

'Putseveralstringswithinparenthesestohavethemjoinedtogether.'

这只适用于两个文字，而不是变量或表达式：

>>>prefix='Py'

>>>prefix'thon'#can'tconcatenateavariableandastringliteral

...

SyntaxError:

invalidsyntax

>>>（'un'*3）'ium'

...

SyntaxError:

invalidsyntax

如果要连接变量或变量和文字，请使用+：

>>>prefix+'thon''Python'

字符串可以被索引（下标），第一个字符的索引为0.没有单独的字符类型; 一个字符只是一个大小为1的字符串：

>>>word='Python'

>>>word[0]#characterinposition0

'P'

>>>word[5]#characterinposition5

'n'

指数也可能是负数，从右边开始计算：

>>>word[-1]#lastcharacter

'n'

>>>word[-2]#second-lastcharacter

'o'

>>>word[-6]

'P'

请注意，由于-0与0相同，负指数从-1开始。

除了索引之外，还支持切片。

虽然索引用于获取单个字符，但切片允许您获取子字符串：

>>>word[0:

2]#charactersfromposition0（included）to2（excluded）

'Py'

>>>word[2:

5]#charactersfromposition2（included）to5（excluded）

'tho'

请注意始终包含开始，并始终排除结尾。

这可以确保始终等于：

s[:

i] + s[i:

]s

>>>word[:

2]+word[2:

]

'Python'

>>>word[:

4]+word[4:

]

'Python'

切片索引具有有用的默认值; 省略的第一个索引默认为零，省略的第二个索引默认为正在切片的字符串的大小。

>>>word[:

2]#characterfromthebeginningtoposition2（excluded）

'Py'

>>>word[4:

]#charactersfromposition4（included）totheend

'on'

>>>word[-2:

]#charactersfromthesecond-last（included）totheend

'on'

要记住片的工作是怎么想的指数作为指着一个方向 之间的字符，第一个字符的左边缘编号为0之后的字符串的最后一个字符的右边缘ñ字符具有指数ñ，例如：

+---+---+---+---+---+---+

|P|y|t|h|o|n|

+---+---+---+---+---+---+

0123456

-6-5-4-3-2-1

第一行数字给出字符串中索引0...6的位置; 第二行给出相应的负指数。

从i到 j的片段分别由标记为i和j的边缘之间的所有字符组成。

对于非负数指数，如果两者都在边界内，那么切片的长度就是指数的差值。

例如，长度word[1:

3]是2。

尝试使用太大的索引会导致错误：

>>>word[42]#thewordonlyhas6characters

Traceback（mostrecentcalllast）:

File"",line1,in

IndexError:

stringindexoutofrange

但是，超出范围的切片索引在用于切片时会优雅地处理：

>>>word[4:

42]

'on'

>>>word[42:

]

''

Python字符串不能改变-它们是不可变的。

因此，分配给字符串中的索引位置会导致错误：

>>>word[0]='J'

...

TypeError:

'str'objectdoesnotsupportitemassignment

>>>word[2:

]='py'

...

TypeError:

'str'objectdoesnotsupportitemassignment

如果你需要一个不同的字符串，你应该创建一个新的字符串：

>>>'J'+word[1:

]

'Jython'

>>>word[:

2]+'py'

'Pypy'

内置函数len（）返回一个字符串的长度：

>>>s='supercalifragilisticexpialidocious'

>>>len（s）

34

1.4列表

Python知道许多复合数据类型，用于将其他值组合在一起。

最通用的是该列表，其可以写成方括号之间的逗号分隔值（项目）列表。

列表可能包含不同类型的项目，但通常这些项目都具有相同的类型。

>>>squares=[1,4,9,16,25]

>>>squares

[1,4,9,16,25]

像字符串（以及所有其他内置序列类型），列表可以被索引和切片：

>>>squares[0]#indexingreturnstheitem

1

>>>squares[-1]

25

>>>squares[-3:

]#slicingreturnsanewlist

[9,16,25]

所有切片操作都会返回一个包含所请求元素的新列表。

这意味着下面的切片将返回列表的新（浅）副本：

>>>squares[:

]

[1,4,9,16,25]

列表还支持拼接等操作：

>>>squares+[36,49,64,81,100]

[1,4,9,16,25,36,49,64,81,100]

与不可变的字符串不同，列表是一种可变 类型，即可以更改它们的内容：

>>>cubes=[1,8,27,65,125]#something'swronghere

>>>4**3#thecubeof4is64,not65!

64

>>>cubes[3]=64#replacethewrongvalue

>>>cubes

[1,8,27,64,125]

您也可以使用该append（） 方法在列表末尾添加新项目（我们将在后面看到更多关于方法的信息）：

>>>cubes.append（216）#addthecubeof6

>>>cubes.append（7**3）#andthecubeof7

>>>cubes

[1,8,27,64,125,216,343]

对切​​片的分配也是可能的，这甚至可以改变列表的大小或完全清除它：

>>>letters=['a','b','c','d','e','f','g']

>>>letters

['a','b','c','d','e','f','g']

>>>#replacesomevalues

>>>letters[2:

5]=['C','D','E']

>>>letters

['a','b','C','D','E','f','g']

>>>#nowremovethem

>>>letters[2:

5]=[]

>>>letters

['a','b','f','g']

>>>#clearthelistbyreplacingalltheelementswithanemptylist

>>>letters[:

]=[]

>>>letters

[]

内置函数len（）也适用于列表：

>>>letters=['a','b','c','d']

>>>len（letters）

4

可以嵌套列表（创建包含其他列表的列表），例如：

>>>a=['a','b','c']

>>>n=[1,2,3]

>>>x=[a,n]

>>>x

[['a','b','c'],[1,2,3]]

>>>x[0]

['a','b','c']

>>>x[0][1]

'b'

1.5简单的例子

>>>#Fibonacciseries:

...#thesumoftwoelementsdefinesthenext

...a,b=0,1

>>>whileb<10:

...print（b）

...a,b=b,a+b

...

1

1

2

3

5

8

2.控制流程语句

2.1if

>>>x=int（input（"Pleaseenteraninteger:

"））

Pleaseenteraninteger:

42

>>>ifx<0:

...x=0

...print（'Negativechangedtozero'）

...elifx==0:

...print（'Zero'）

...elifx==1:

...print（'Single'）

...else:

...print（'More'）

...

More

2.2for

forPython中的语句与您在C或Pascal中习惯使用的语言有些不同。

Python的for语句并不总是迭代数字的算术级数（比如在Pascal中），或者让用户能够定义迭代步骤和停止条件（如C），Python 语句迭代任何序列的项目（一个列表或一个字符串），按顺序出现在序列中。

例如（没有双关意图）：

>>>#Measuresomestrings:

...words=['cat','window','defenestrate']

>>>forwinwords:

...print（w,len（w））

...

cat3

window6

defenestrate12

如果您需要修改在循环中迭代的序列（例如复制选定项目），建议您先制作一份副本。

遍历一个序列并不会隐式地创建一个副本。

切片符号使这特别方便：

>>>forwinwords[:

]:

#Loopoveraslicecopyoftheentirelist.

...iflen（w）>6:

...words.insert（0,w）

...

>>>words

['defenestrate','cat','window','defenestrate']

2.3 range（）

如果您确实需要迭代一系列数字，则内置函数 range（）将派上用场。

它生成算术级数：

>>>foriinrange（5）:

...print（i）

...

0

1

2

3

4

给定的终点不是生成的序列的一部分; range（10）生成10个值，即长度为10的序列的项目的合法索引。

可以让范围从另一个数字开始，或者指定一个不同的增量（甚至是负数;有时这称为“步骤”）：

range（5,10）

5,6,7,8,9

range（0,10,3）

0,3,6,9

range（-10,-100,-30）

-10,-40,-70

要遍历序列的指数，你可以结合range（）和 len（）如下：

>>>a=['Mary','had','a','little','lamb']

>>>foriinrange（len（a））:

...print（i,a[i]）

...

0Mary

1had

2a

3little

4lamb

如果您只打印一个范围，会发生一件奇怪的事情：

>>>print（range（10））

range（0,10）

在许多方面，返回的对象的range（）行为就好像它是一个列表，但事实上并非如此。

它是一个对象，它在您迭代时返回所需序列的连续项，但它并不真正生成列表，从而节省空间。

我们说这样一个对象是可迭代的，也就是说，适合作为函数和构造的目标，期望它们可以从中获得连续的项目，直到耗尽。

我们已经看到这个for陈述是这样一个迭代器。

该功能list（） 是另一个; 它会根据迭代创建列表：

>>>list（range（5））

[0,1,2,3,4]

2.4break，continue&else

break和在c语言里面一样，用于跳出for和while循环。

循环语句可能有一个else子句; 当循环通过用尽列表（with for）或当条件变为false（with while）时终止时执行，但当循环由break语句终止时不执行。

这由以下循环来举例说明，该循环搜索素数：

>>>forninrange（2,10）:

...forxinrange（2,n）:

...ifn%x==0:

...print（n,'equals',x,'*',n//x）

...break

...else:

...#loopfellthroughwithoutfindingafactor

...print（n,'isaprimenumber'）

...

2isaprimenumber

3isaprimenumber

4equals2*2

5isaprimenumber

6equals2*3

7isaprimenumber

8equals2*4

9equals3*3

上述的else属于for,而不是if

continue语句也从C中借用，继续循环的下一次迭代：

>>>fornuminrange（2,10）:

...ifnum%2==0:

...print（"Foundanevennumber",num）

...continue

...print（"Foundanumber",num）

Foundanevennumber2

Foundanumber3

Foundanevennumber4

Foundanumber5

Foundanevennumber6

Foundanumber7

Foundanevennumber8

Foundanumber9

2.5pass

该pass语句什么也不做。

当语句需要语法时可以使用它，但程序不需要任何操作。

例如：

>>>whileTrue:

...pass#Busy-waitforkeyboardinterrupt（Ctrl+C）

...

这通常用于创建最小类：

>>>classMyEmptyClass:

...pass

...

另一个地方pass可以作为一个函数或条件体的占位符，当你在处理新的代码时，允许你继续思考一个更抽象的层次。

这pass是默默的忽略：

>>>definitlog（*args）:

...pass#Remembertoimplementthis!

...

2.6定义函数

我们可以创建一个将斐波那契数列写入任意边界的函数：

>>>deffib（n）:

#writeFibonacciseriesupton

..."""PrintaFibonacciseriesupton."""

...a,b=0,1

...whilea

...print（a,end=''）

...a,b=b,a+b

...print（）

...

>>>#Nowcallthefunctionwejustdefined:

...fib（2000）

011235813213455891442333776109871597

关键字def引入了一个函数定义。

它必须跟随函数名称和形式参数的括号括起来的列表。

构成函数主体的语句从下一行开始，并且必须缩进。

函数体的第一个语句可以可选地是一个字符串文字; 此字符串文字是函数的文档字符串或docstring。

（关于文档字符串的更多信息可以在文档字符串部分找到。

）有一些工具可以使用文档自动生成在线或打印文档，或让用户交互式浏览代码; 在您编写的代码中包含文档字符串是一种很好的做法，请养成习惯。

函数的执行引入了一个用于函数局部变量的新符号表。

更确切地说，函数中的所有变量赋值都将值存储在本地符号表中; 而变量引用首先在本地符号表中查找，然后在封闭函数的本地符号表中，然后在全局符号表中，最后在内置名称表中查找。

因此，全局变量不能直接在函数内赋值（除非在global语句中命名），尽管它们可能被引用。

函数调用的实际参数（参数）在被调用函数的本地符号表中引入时被调用; 因此，参数通过值调用传递（其中值始终是对象引用，而不是对象的值）。

[1]当函数调用另一个函数时，为该