python笔记

如果改动docker.service 就需要执行systemctl daemon-reload。

插入一个空格 (non-breaking space)

  或   或  

插入两个空格 (en space)

  或   或  

插入四个空格 (em space)

  或   或  

插入细空格 (thin space)

  或   或  

变量

---

str()、int()和float()三种函数

变量名的定义：

1.只能是一个词

2.只能包含字母、数字和下划线

3.不能以数字开头

---

只能用+操作符加两个整数，或链接两个字符串。不能让一个整数和一个字符串相加。

print('I am'+ 29 + 'years old')                  //这样是错误的

正确应该是先定义一个变量等于29，然后进行输出

str(29)
print('I am'+ 29 + 'years old')  

整型值可以和浮点型相等，但不可以和字符型相等

---

表达式由什么构成？

表达式是值和运算符的结合。

---

所有表达式都做什么事？

所有表达式都求值为（即归约为）一个值

---

操作符	含义
= =	等于
！=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

布尔操作符

在python中，是对于布尔值来说是区分大小写的。

区分True和true，同样的

三个布尔操作符 and、for和not

and操作符  //两个都为真才为真

表达式	求值为
True and True	True
True and False	False
False and True	False
False and False	False

or操作符  //一个为真就是真

表达式	求值为
True or True	True
True or False	True
False or True	True
False or False	False

not操作符  //真是假，假是真

表达式	求值为
not True	False
not False	True

和算术操作符一样，布尔操作符也有操作顺序。在所有算术和比较操作符求值后，Python先求值not操作符，然后是and操作符，然后是or操作符。

>>>2+2==4 and not 2+2 ==5 and 2*2==2+2
True

代码块

代码块3条规则：

1.缩进增加时，代码块开始

2.代码块可以包含其他代码块。

3.缩进减少为零,或减少为外面包围代码块的缩进，代码块就结束了。

因为Python中没有分号来识别，所以使用代码块来进行识别每一条语句

name=input()
if name=='Alice':
    print('Hi Alice')
else:
    print('you not is Alice')

name=input()
if name=='Alice':
    print('Hi Alice')
    else:
    print('you not is Alice')

第一种遵循了代码块的标准所以会正常输出，而第二个没有遵循代码块的标准所以会提示语法错误

控制流

if语句

如果条件为True就执行子句，如果条件为False就跳过字句。

if语句包含以下部分：

• if关键字
• 条件（即求值为True）
• 冒号
• 在下一行开始，缩进的代码块（称为if子句）
  所有控制流语句都以冒号结尾，后面跟着一个新的代码块（子句）

else语句

可以和if语句连用，只有if语句的条件为False时，else的语句才会被执行。

else语句中包含以下部分：

• else关键字
• 冒号
• 在下一行开始，缩进的代码块

elif语句

elif语句是“否则如果”，总是跟在if或另一条elif语句后面。他提供了另一个条件，仅在前面的条件为False时才检查该条件。

elif关键字：

• elif关键字
• 条件
• 冒号
• 在下一行开始，缩进的代码块（称为elif字句）

while循环

• 关键字
• 条件
• 冒号
• 从新行开始，缩进的代码块（称为while字句）

break语句

如果执行遇到break语句，就直接跳出while循环字句

continue语句

如果执行遇到continue语句，就回到讯号开始处

for循环和range()函数

类真和类假

其他数据类型中的某些值，条件认为它们等价与True和False，在用于条件时，0、0.0和’’（空字符串）被认为是False，其他值被认为是True。

• for关键字
• 一个变量名
• in关键字
• 调用range()方法，最多传入三个3个参数
• 冒号
• 从下一行开始，缩进的代码块

从0加到100

total=0
for i in range(101):
    total=total+num
print(total)

等价的while循环

实际上可以用while循环来做for循环同样的事，for循环只是更加简洁。

和for循环等价的while循环

total=0
i=0
while i<100:
    i=i+1
    total=total+i
    print(total)

range()的开始、停止和步长参数

某些函数可以用多个参数调用，参数之间用逗号隔开，range()就是其中之一。

for i in range(12,16):
    print(i)

输出的为12,13,14,15,16

第一个参数是for循环变量开始的值，第二个参数是上限，但不包含他，也就是循环停止的数字

for i in range(0,10,2):
    print(i)

输出的为0,2,4,6,8

前两个参数分别是起始值和终止值，第三个值是“步长”。步长是每次迭代后循环变量和增加的值。所以调用range(0,10,2)将从0数到8，间隔为2。

for i in range(100,-10-,10)
    print(i)

输出的为100,90,80,70,60,50,40,30,20,10,0

可以是使用负数来作为步长，让循环计数逐渐减少，而不是增加。

import语句

• import关键字
• 模块的名称
• 可选的更多模块名称，之间用逗号隔开

import random
for i in range(5)
    print(random.randint(1,10))

在1-10间随机输出5个数

random.randint()函数调用求值为船体给它的两个整数之间的一个随机整数。因为randint()属于random模块，必须在函数名称之前先加上random，告诉python在random模块中寻找这个函数<br/>

_{可以调用多个模块，用逗号来间隔}

import random,sys,os,math

from import语句

import语句的另一种呢形式包括from关键字，之后是模块名称，import关键字和一个型号，例如from random import *

使用这种形式的import语句，调用random模块中的函数时不需要random.前缀。但是，使用完整的名称会让代码更可读，所以最好是使用普通形式得到import语句

from random impoer*
for i in random(5)
    print(randint(1,10))

使用sys.exit()提前结束程序

通过调用sys.exit()函数，可以使程序终止或退出

import sys
while True:
    print('Type exit to exit')
    response=input()
    if response=='exit':
        sys.exit()
print('you rtped'+response+'.')

函数

def

def hello():
    print('Howdy!')
    print('Howdy!!!')
    print('Howdy there.')

hello()
hello()
hello()

意思为定义了一个函数hello，函数内容为三条print语句。最后调用三次hello函数，就相当于执行三遍hello函数中的语句。

返回值和return语句

用def语句创建函数时，可以用return语句指定应该返回什么值。

return语句包含以下部分

• return关键字
• 函数应该返回的值或表达式

import random
def getAnswer(answerNumber):
    if answerNumber==1:
        return 'it is certain'
    elif answerNumber==2:
        return 'it is decidedly so'
    elif answerNumber==3:
        return 'Yes'
    elif answerNumber==4:
        return 'Reply hazy try again'
    elif answerNumber==5:
        return 'Ask again later'
    elif answerNumber==6:
        return 'Concentrate and ask again'
    elif answerNumber==7:
        return 'My reply is no'
    elif answerNumber==8:
        return 'Outlook not so good'
    elif answerNumber==9:
        return 'Very doubtful'
r=random.randint(1,9)
print(r)
fortune=getAnswer(r)
print(fortune)

最后四句可以等价为print(getAnswer(random.randint(1,9)))  print®是为了自己看着方便 _) 😎

这段代码的意思就是定义了getAnswer函数中每个数字所return返回的代码，利用random随机数随机生成一个数向getAnswer传入随机数，最后输出这个随机数所代表的的结果

运行结果就为

3
Yes

表达式是值和操作符的组合。函数调用可以用在表达式中，因为它求值为它的返回值。

None值

它表示没有值。None是NoneType数据类型的唯一值。None必须大写首字母。

如果希望变量总存储的东西不会和一个真正的值混淆，这个没有值的值就可能有用。又一个使用None的地方就是print()的返回值。

关键字和print()

print()

print()函数有可选的的单元end和sep分别指定在参数末尾打印什么，以及在参数之间打印什么来隔开他们。

end关键字

print('Hello')
print('World')

这两个字符串出现在独立的两行中因为print()函数在传入的字符串末尾添加了换行符。

可以设置end关键字，将他变成一个字符串。

print('Hello',end='')
print('World')

输出之后就变成了

HelloWorld

sep关键字

sep关键字可以替换掉默认的分隔字符串。

print('cats','dogs','mice')

输出后就是

cats dogs mice

在代码中添加一个关键字sep后

print('cats','dogs','mice',sep=',')

输出后就是

cats,dogs,mice

sep=','就相当于在每一个字符串中自动添加了一个逗号分隔符。

局部和全局作用域

在被调用的函数内赋值的变元和变量，处于该函数的“全局作用域”。在所有函数之外赋值的变量，属于“全局作用域”。处于局部作用域的变量，被称为“局部变量”。处于全局作用域的变量，被称为“全局变量”。一个变量必是其中一种，不能既是局部的又是全局的。

可以将“作用域”看成是变量的容器。当作用域被销毁时，所有保存在该作用域内的变量的值就被丢弃了。只有一个全局作用域，它是在程序开始时创建的。如果程序终止，全局作用域就会被销毁，它的所有变量就被丢弃了。否则，下次你运行程序的时候，这些变量会记住上次运行的值。

一个函数被调用时，就创建了一个局部作用域。在这个函数内赋值的所有变量，存在于该局部作用域内。该函数返回时，这个局部作用域就被销毁了，这些变量就丢失了。下次调用这个函数，局部变量不会记得该函数航次被调用时它们保存的值。

 作用域很重要，理由如下：

• 全局作用域中的代码不能使用呢任何局部变量
• 但是，局部作用域可以访问全局变量
• 一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。
• 如果在不同的作用域中，你可以用相同的名字来命名不同的变量。也就是说，可以又一个名叫spam的局部变量，和一个名为spam的全局变量

global语句

如果需要在一个函数内修改全局变量，就使用global语句。

 有4条法则，来区分一个变量是处于局部作用域还是全局作用域：

1. 如果变量在全局作用域中使用（即在所有函数之外），它就是全局变量。
2. 如果在一个函数中，有针对性变量的global语句，它就是全局变量。
3. 否则，如果该变量用于函数中赋值的语句，它就是局部变量。
4. 但是，如果该变量没有用在赋值语句中，它就是全部变量。

def spam():
    global eggs
    eggs='spam'
def bacon():
    eggs='bacon'
def ham():
    print(eggs)
eggs=42
spam()
print(eggs)

 在spam函数中，eggs是全局eggs变量，因为在函数的开始处，有针对eggs变量的global语句。在bacon中，eggs是局部变量，因为在该函数中有针对它的赋值语句。在ham()中，eggs是全局变量，因为在这个函数中，既没有赋值语句，也没有针对它的global语句。

异常处理

在python程序中遇到错误，或“异常”，意味着整个程序崩溃。你不希望着发生在真实世界的终须中。相反，你希望程序能检测错误，处理他们，然后继续运行。

def spam(divideBy):
    return 42 / divideBy
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

输出后的结果为

21.0
3.5
Traceback (most recent call last):
  File "c:\Users\pc\Desktop\python file\test5.py", line 7, in <module>
    print(spam(0))
  File "c:\Users\pc\Desktop\python file\test5.py", line 3, in spam
    return 42 / divideBy
ZeroDivisionError: division by zero

当试图用一个数除以零时，就会发生ZeroDivisionError。

 错误可以使用try和except来处理。那些可能会出错的语句被放在try子句中。如果错误发生，程序执行就转到接下来的except子句开始处。

def spam(divideBy):
    try:
        return 42 / divideBy
    except ZeroDivisionError:
        print('Error:Invalid argument.')
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

输出后

21.0
3.5
Error:Invalid argument.
None
42.0

如果在try子句中的代码导致一个错误，程序执行就立即转到except子句的代码。在运行那些代码之后，执行照常继续。

 请注意，在函数调用中的try语句块中，发生的所有错错误都会被捕捉。如果将spam()调用放在语句块中，就会有不一样的输出。

def spam(divideBy):
    return 42 / divideBy
try:
    print(spam(2))
    print(spam(12))
    print(spam(0))
    print(spam(1))
except ZeroDivisionError:
    print('Error: Invalid argument.')

输出后就是

21.0
3.5
Error: Invalid argument.

print(spam(1))从未被执行是因为，一旦跳到了except子句的代码，就不会回到try子句。他会继续照常向下执行。

一个猜数字小程序

# This is a guess the number game.
import random
secretNumber=random.randint(1,20)
print('I am thinking of a number between 1 and 20.')
for guessesTaken in range(1,7):
        print('Take a guess.')
        guess=int(input())
        if guess<secretNumber:
            print('your guess is too low.')
        elif guess>secretNumber:
            print('your guess is too high.')
        else:
            break
if guess==secretNumber:
    print('good job! you guessed my number in '+str(guessesTaken)+'guesses!')
else:
    print('Nope. The number I was thinking of was '+ str(secretNumber))

首先代码的顶部注释了这个程序做什么。然后，程序导入了模块random模块，以便能用random.randint()函数生成一个数字，让用户来猜。返回值是1到20之间的随机整数，保存在secretNumber中。

# This is a guess the number game.
import random
secretNumber=random.randint(1,20)
print('I am thinking of a number between 1 and 20.')

程序告诉玩家，它有了一个秘密数字，并且给玩家6次猜测机会。在for循环中，代码让玩家输入一个猜测，并检查该猜测。该循环最多迭代6此。循环中发生的第一件事情，是让玩家输入一个才猜测数字。因为input()返回一个字符串，所以它的返回值被直接传递给int()。它将字符串转变成整数。这保存在名为guess的变量中。

print('I am thinking of a number between 1 and 20.')
for guessesTaken in range(1,7):
        print('Take a guess.')
        guess=int(input())

这几行代码检查该猜测是小于还是大于那个秘密数字。不论哪种情况，都在屏幕上打印提示

if guess<secretNumber:
    print('your guess is too low.')
elif guess >secretNumber:
    print('your guess is too high.')

如果该猜测既不大于也不小于秘密数字，那么它就一定等于秘密数字，这时你希望程序跳出for循环。

else :
    break

在for循环后，前面的if…else语句检查玩家是否正确地猜到了改数字，并将响应的信息打印在屏幕上。不论哪种情况，程序都会打印一个包含整数值得到变量(guessesTaken和secretNumber)。因为必须将这些整数值连接成字符串，所以它将这些变量传递给str()函数，该函数返回这些数字的字符串形式。现在这些字符串可以用+操作符连接起来，最后传递给print()函数调用。

if guess==secretNumber:
    print('good job! you guessed my number in '+str(guessesTaken)+'guesses!')
else:
    print('Nope. The number I was thinking of was '+ str(secretNumber))

列表

列表数据类型

“列表”是一个值，它包含多个值构成的序列。术语“列表值”指的是列表本身（它作为一个值，可以保存在变量中，或传递的给函数，像所有其他值一样），列表值看起来像这样：['cat','bat','rat','elephant']。就像字符串值用引号来标记字符串的起止一样，列表用左方括号开始，有房括号结束，即[]。列表中的值也称为“表项。表项用逗号分隔”。

可以使用列表下标去得到列表中的某个值

spam=['1','2','4']
print(spam[2])

输出后的结果就是

4

因为下标是从0开始计数的，也就是说spam中的1,2,4编号是spam[0]=1,spam[1]=2,spam[2]=4。

下标只能是整数，不能是浮点数

列表也可以包含其他列表值。这些列表的列表中的值，可以使用多重下标来访问

spam=[['cat','bat'],[1,2,3,4,5]]
print(spam[0][1])

输出后

bat

或者输出spam[1][4]

结果就是

5

第一个下标表示使用哪个列表值，第二个下标表明该列表中的值。例如spam[0][1]打印出bat,即第一个列表中的第二个值。如果只是用一个下标，程序将打印出该下标处的完整列表值。

负数下标

虽然下标从0开始并向上增长，但也可以用负整数作为下标。整数值-1指的是列表中的最后一个下标，-2指的是列表中倒数第二个下标，以此类推。

spam[1,2,3,4]
print(spam[-1])

输出就是

4

利用切片取得子列表

就像下标可以从列表中取得单个值一样，“切片”可以从列表中去得多个值，结果是一个新列表。切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数。

请注意下标和切片的不同

• spam[2]是一个列表和下标（一个整数）
• spam[1:4]是一个列表和切片（两个整数）
  在一个切片中，第一个整数是切片开始出的下标。第一个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。切片求值为一个新的列表值。

spam=[1,2,3,4,5,6]
print(spam[1:4])

输出后

[2,3,4]

有快捷方法，可以省略切片中冒号两边的一个下标或两个下标。省略第一个下标相当于使用0，或列表的开始。省略第二个下标相当于使用列表的长度，意味着切片直至列表的末尾。

spam=[1,2,3,4,5,6]
print(spam[:4])

输出后

[1,2,3,4]

或者

spam=[1,2,3,4,5,6]
print(spam[1:])

输出后

[2,3,4,5,6]

或者

spam=[1,2,3,4,5,6]
print(spam[:])

输出后

[1,2,3,4,5,6]

用del语句从列表中删除值

del语句将删除列表下标处的值，表中被删除值后面的所有值，都将向前移动一个下标。

示例

spam=[1,2,3,4]
del spam[2]
print(spam)

输出后就是

[1,2,4]

使用len()去得列表的长度

spam=[1,2,3,4]
print(len(spam))

输出后

4

使用列表

catNames=[]
while True:
    print('Enter the name of '+str(len(catNames)+1)+'(Or enter nothing to stop)')
    name=input()
    if name== '' :
        break
    catNames=catNames+[name]
print('The cat names are:')
for name in catNames:
    print(''+name)

运行后输入

11 enter

22 enter

33 enter

44 enter

enter
输出为

The cat names are:
11
22
33
44

可以在for循环中使用range(len(函数)),迭代列表的每一个下标

spam=[1,2,3,4,5]
for in i range(len(spam)):
    print(spam[i])

输出为

1
2
3
4
5

in和not in操作符

利用in和not in操作符，可以确定一个值是否在列表中。

myPets=['Zophie','Pooka','Fat-tail']
name=input('Enter a pet name:')
if name not in myPets:
    print('I do not have a pet named '+name)
else:
    print(name+'is my pet')

运行后随便输入一个不在列表中的名字

I do not have a pet named  '输入的名字'

增强的赋值操作

增强的赋值语句	等价的赋值语句
spam+=1	spam=spam+1
spam-=1	spam=spam-1
spam*=1	spam=spam*1
spam/=1	spam=spam/1
spam%=1	spam=spam%1

使用index()方法在列表中查找值

spam=['a','b','cc']
print(spam.index('b'))

输出后

1

b的在列表中的下标为1

如果列表中存在重复的值，那么它就返回第一次出现的下标

用append()和insert()方法在列表中添加值

spam=['a','b','cc']
spam.append('dd')
print(spam)

输出后

['a', 'b', 'cc', 'dd']

append是在列表末尾添加，而insert可以在列表的任意下标处插入一个值

insert方法的第一个参数是新值的下标，第二个参数是要插入的新值。

spam=['a','b','cc']
spam.insert(1,'dd')
print(spam)

输出后

['a', 'dd', 'b', 'cc']

方法属于单个数据类型。append()和insert()方法是列表方法，只能在列表上使用，不能在其他值上调用，例如字符串和整型

使用remove()方法从列表中删除值

spam=[1,2,3,4,5]
spam.remove(1)
print(spam)

输出后

[2, 3, 4, 5]

如果该值在列表中出现多次，只有第一次出现的值会被删除。

用sort()方法将列表中的值排序

spam=[1,2,3,4,5,]
spam.sort()
print(spam)

输出后

[1, 2, 3, 4, 5]

可以使用reverse关键字参数为True，让sort()按逆序排序。

spam=[6,5,42,1,3,5]
spam.sort(reverse=True)
print(spam)

输出后

[42, 6, 5, 5, 3, 1]

关于sort()方法，三个要点：

1. sort()方法当场对列表进行排序。不要写出spam=spam.sort()这样的代码来试图记录返回值
2. 不能对既有数字又有字符串值的列表排序，因为python不知道他们。
3. sort()方法对字符串排序时，使用“ASCII字符顺序”，而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时，小写的a在大写的Z之后。

如果需要按照普通的字典顺序来排序，就在sort()方法调用时，将关键字参数key设置为str.lower

spam=['a','Z','C','c']
spam.sort(key=str.lower)
spam.sort(reverse=True)
print(spam)

输出后

['c', 'a', 'Z', 'C']

既按照了字典排序又按照了逆向的顺序进行排序

例子程序：神奇8球

import random
messages=['It is certain','Itis decidedly so','Yes definitely','Reply hazy try again','My reply is no ','Outlook not so good','Very doubtful']
zz=random.randint(0,len(messages)-1)
print(zz)
print(messages[zz])

类似列表的类型：字符串和元祖

列表并不是唯一表示序列值的数据类型，例如，字符串和列表实际上很相似，只要你认为字符串是单个文本字符的列表。对列表的许多操作，也可以作用于字符串；按下标取值、切片、用于for循环、用于len()，以及用于in和not in操作符

name='Zophie'
for i in name:
    print('* * * '+i+'* * * ')

输出后

* * * Z* * * 
* * * o* * *
* * * p* * *
* * * h* * *
* * * i* * *
* * * e* * *

可变和不可变数据类型

列表是“可变的”数据类型，它的值可以添加、删除或者改变。但，字符串是“不可变的”，它不能被更改

name='Zophie a cat'
nameName=name[0:7]+'the'+name[8:12]
print(name)
print(nameName)

输出后

Zophie a cat
Zophie the cat

我们用[0:7]和[8:12]来指那些不想替换的字符，请注意，原来的'Zophie a cat'字符串没有被修改，因为字符串是不可变的。

eggs=[1,2,3]
eggs=[4,5,6]
print(eggs)

输出后

[4,5,6]

尽管列表值是可变的，但这里eggs中的列表值并没有改变，而是整个新的不同的列表值([4,5,6]),覆写了老的列表值。

如果希望修改eggs中原来的列表值，让他包含[4,5,6]，就要使用append()来做

eggs=[1,2,3]
del eggs[2]
del eggs[1]
del eggs[0]
eggs.append(4)
eggs.append(5)
eggs.append(6)
print(eggs)

输出后

[4,5,6]

改变一个可变数据类型的值(就像前面例子中del语句和append()所做的事)，当场改变了该值，因为该变量的值没有被一个新的列表取代。

使用可变参数和不可变参数调用时函数时产生的不同行为。

元组数据类型

除了两个方面，“元组”数据类型几乎于列表数据类型一样。首先，元组输入时用圆括号()，而不是用方括号[]。

eggs=('hello',42,0.5)

第二个区别在于，元组像字符串一样，是不可变的。元组不能让他们的值被修改、添加和删除。

eggs=('hello',42,0.5)
eggs[1]=99

运行就会发生报错

用list()和tuple()函数来转换类型

正如str(42)将返回'42'，即整数42的字符串表示形式，函数list()和tuple()将返回传递给它们的值的序列。

引用

spam=42
cheese=spam
spam=100
print(spam,cheese)

输出后

100 42

你将42赋给spam变量，然后拷贝spam中的值，将它赋给变量cheese，当稍后将spam中的值改变为100时，这不会影响cheese中的值。这是因为spam和cheese是不同的变量，保存了不同的值。

传递引用