layout: "post"
tags: 笔记 Python 教程 入门
categories: program

第 5 章 基础

5.3 字符串

• 单引号、双引号作用相同
• 三引号(''' 或 """)以指示一个多行的字符串
• 行末的单独一个反斜杠表示字符串在下一行继续
• 自然字符串：通过给字符串加上前缀r或R来指定，例如r"Newlines are indicated\n"
• Unicode字符串：在字符串前加上前缀u或U，文件含有非英语语言的文本时
• format 方法 一个字符串能使用确定的格式，随后，可以调用 format 方法来代替这些格式，参数要与 format 方法的参数保持一致。
• 一些str类的用法，用点号使用。。startwith 方法是用来测试字符串是否以给定字符串开始。in 操作符用来检验一个给定字符串是否为另一个字符串的一部分。find 方法用来找出给定字符串在另一个字符串中的位置，或者返回 -1 以表示找不到子字符串。str 类也有以一个作为分隔符的字符串 join 序列的项目的整洁的方法

age = 25
name = 'Swaroop'
print('{0} is {1} years old'.format(name, age)) # sg.1 {i}和.format(X_i)，i从零起
print('Why is {0} playing with that python?'.format(name))

print('{0:.5}'.format(1/3))  # sg.2 用:和.5保留5位小数，点号

print('{0:_^11}'.format('hello'))  # sg.3 用下划线填充

print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))  # sg.4 直接在format中赋值

5.17 逻辑行和物理行

物理行是你在编写程序时所看见的。逻辑行是 Python 看见的单个语句。 Python 假定每个物理行对应一个逻辑行。

在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）来特别地标明这种用法。分号表示一个逻辑行/语句的结束。

作者建议避免使用分号，使代码更易读

5.18 缩进

保持一致

对象

Python把在程序中用到的任何东西都称为对象 。这是从广义上说的。因此我们不会说“某某东西 ”，我们说“某个对象 ”。

第 6 章 操作符和表达式

数学和逻辑运算，见6.2和6.3 的表，不述

第 7 章 控制流

7.2 if

使用冒号和缩进
if:
elif:
else:

number = 23
guess = int(input('Enter an integer : '))

if guess == number:
    print('Congratulations, you guessed it.') # New block starts here
    print('(but you do not win any prizes!)') # New block ends here
elif guess < number:
    print('No, it is a little higher than that') # Another block  # You can do whatever you want in a block ...
else:
    print('No, it is a little lower than that')  # you must have guess > number to reach here
print('Done')  # This last statement is always executed, after the if statement is executed

7.3 while

只要在一个条件为真的情况下， while 语句允许你重复执行一块语句。 while 语句是所谓循环语句的一个例子。 while 语句有一个可选的 else 从句。

number = 23
running = True

while running:
    guess = int(input('Enter an integer : '))

    if guess == number:
        print('Congratulations, you guessed it.')
        running = False  #this causes the while loop to stop
    elif guess < number:
        print('No, it is a little higher than that')
    else:
        print('No, it is a little lower than that')
else:
    print("the while loop is over.")
    # Do anything else you want to do here    

print('Done')  

7.4 for

for..in 是另外一个循环语句，它在一序列的对象上迭代，即逐一使用序列中的每个项目。

else 部分是可选的。如果包含 else ，它总是在 for 循环结束后执行一次，除非遇到 break 语句。

for i in range ( 1 , 5 ):
    print (i)
else :
    print ( 'The for loop is over' )

第 8 章 函数

8.1 定义函数

函数用关键字 def 来定义。def 关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。可以在任何地方定义他们

def sayHello():
    print ('hello, world')

sayHello()

8.3 局部变量、全局变量、非局部变量

global 语句
nonlocal 语句

8.6 默认参数值

可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。

注意，默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的

只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如，def
func(a, b=5) 是有效的，但是 def func (a=5, b) 是无效的。

def say(message, times = 1):
    print(message * times)

say('Hello')
say('World', 5)

8.7 关键参数

如果你的某个函数有许多参数，调用时可以直接通过命名来为这些参数赋值 —— 这被称作关键参数 —— 我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。

def func(a, b=5, c=10):
    print('a is', a, 'and b is', b, 'and c is', c)

func(1,2,3)是一般调用，而用func( c= 3, a = 1)则是关键参数方法，这里顺序不再重要。

8.8 VarArgs 参数

有时，你或许想定义一个能获取任意个数参数的函数，这可通过使用 * 号来实现。

一个表明这是一个列表，两个*表明是字典。以下这个例子中，10被传入第一个参数initial，1,2,3被视为列表(1,2,3)传入第二个参数numbers， vegetables=50, fruits=100被视为字典传入第三个参数

def total(initial=5, *numbers, **keywords):
    count = initial
    for number in numbers:
        count += number
    for key in keywords:
        count += keywords[key]
    return count

print(total(10, 1, 2, 3, vegetables=50, fruits=100))

8.9 Keyword-only 参数（不明）

8.11 DocStrings

我理解为一个程序的说明文件，可以很容易的通过fun.__doc__来查看。 help(fun)调用的也是这个文件。

在函数的第一个逻辑行的字符串是这个函数的文档字符串，DocStrings 也适用于模块和类。

惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第
二行是空行，从第三行开始是详细的描述。强烈建议你在你的函数中使用文档字符串时遵循这个惯例。

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')

printMax(3, 5)
print(printMax.__doc__)

8.12 注解

函数有另外一个高级特性叫做注解，这是一个获取每个参数和返回值附加信息的漂亮的方式。由于 Python 语言本身不以任何方式解释这些注解（也即函数功能留给第三方库以他们想要的方式去解释），在我们的讨论中就跳过这一特性。如果你对阅读注解感兴趣，请看 Python Enhancement Proposal No. 3107 。

第 9 章 模块

• 使用import 导入模块，之后以mod.fun的方式调用模块中的函数
• 也可以用from mod import fun 语句把函数调入，直接用fun调用函数。但是可能会引起名称混乱。

9.5 创建自己的模块

每个 Python 程序也是一个模块，只要具有.py 扩展名

#!/usr/bin/python
# Filename: mymodule.py
def sayhi():
    print('Hi, this is mymodule speaking.')

__version__ = '0.1'
# End of mymodule.py

使用这个模块只需要

import mymodule

mymodule.sayhi()
print ('Version', mymodule.__version__)

9.6 dir 函数

你可以使用内建的 dir 函数来列出模块定义的标识符。标识符有函数、类和变量。

当你为 dir() 提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

9.7 包

程序的层次。

包world
 |---子包asia
 |       |---模块
 |       |---子包china
 |
 |---模块
       |---函数
       |      |---变量
       |
       |---全局变量

变量通常在函数内部运行。函数和全局变量通常在模块内部运行。如果你想自己组织模块呢？那" 包" 就会进入到你的视野中。包是模块的文件夹，有一个特殊的 __init__.py 文件，用来表明这个文件夹是特殊的因为其包含有 Python 模块。

第 10 章 数据结构

10.2 列表

列表中的项目应该包括在方括号中，每个项目之间用逗号分割。可以添加list.append('item')、删除del list[i]或是搜索列表中的项目。因此列表是可变的。

10.4 元组

元组用来将多样的对象集合到一起。它和列表十分类似，但不可变，即不能修改元组。元组通过圆括号中用逗号分割的项目定义。

含有 0 个或 1 个项目的元组：
一个空的元组由一对空的圆括号组成，如 myempty = ()。

含有单个元素的元组必须在第一个（唯一一个）项目后跟一个逗号，这样 Python 才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目 2 的元组的时候，你应该指明 singleton = (2 ,)。

10.5 字典

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。

10.8 引用

当你创建一个对象并给它赋一个变量的时候，这个变量仅仅引用那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。

例如，

list1 = [1,2,3,4]
list2 = list1[:]
del list1[0]

和

list1 = [1,2,3,4]
list2 = list1
del list1[0]

是不一样的，如果执行print('list1 is',list1); print('list2 is',list2)前者两个list都改变了，但后者list2没有变。

也就是说，如果你想要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单对象），那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名，两个名称都引用同一个对象，那么如果你不小心的话，可能会引来各种麻烦。

第 12 章 面向对象编程

12.1 简介

类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象是这个类的实例。这类似于你有一个 int 类型的变量，这存储整数的变量是 int 类的实例（对象）。

对象可以使用普通的属于对象的变量存储数据。属于一个对象或类的变量被称为 域。对象也可以使用属于类的函数来具有功能。这样的函数被称为 类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为 类的属性。

域有两种类型 —— 属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

类使用 class 关键字创建。类的域和方法被列在一个缩进块中。

12.2 self

类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python 会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是 self。

class Person:
    def sayHi(self):
        print('Hello, how are you?')

p = Person()
p.sayHi()

12.5 __init__ 方法

__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是 双下划线。

class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print('Hello, my name is',self.name)

p = Person('Ann')
p.sayHi()

这个例子中，__init__方法被定义为取一个参数 name（以及普通的参数 self）。这个 __init__方法创建了一个新的域name(self.name)，并被赋予了参数name的值。

没有专门调用 __init__方法，只是在创建一个类的新实例的时
候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。这是这种方法的重要之处。

12.6 类和对象变量

数据是类和对象的名称空间绑定的普通变量，即这些名称只在这些类与对象的前提下有效。

有两种类型的域 —— 类的变量和对象的变量，它们根据是类还是对象拥有这个变量而区分。

类的变量由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。

对象的变量由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。

class Robot:
    '''Represents a robot, with a name.

    you can add or delete robot'''
    population = 0
    def __init__(self,name):
        self.name = name        
        print('Robot',self.name,'is coming')  
        print('Hello! {0} is at your service'.format(self.name))
        Robot.population += 1

    def __del__(self):
        print('{0} is being destroyed!'.format(self.name))
        Robot.population -= 1

        if Robot.population == 0:
            print('{0} was the last one.'.format(self.name))
        else:
            print('There are {0} robots left'.format(Robot.population))

    def sayHi(self):
        print('Greetings, my master call me {0}.'.format(self.name))

    def howMany():
        print('We have {0:d} robots.'.format(Robot.population))

分别对应着这样几个调用

rob1 = Robot('T-800')
del rob1
rob1.sayHi()
Robot.howMany()

12.7 继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

例如，假设你想要写一个程序来记录学校之中的教师和学生情况。他们有共通属性也有单独属性。可以创建一个共同的类称为 SchoolMember 然后让教师和学生的类继承这个共同的类。即它们都是这个类型（类）的子类型，然后我们再为这些子类型添加专有的属性。

在上述的场合中，SchoolMember 类被称为基本类或超类。而 Teacher 和 Student类被称为导出类或子类。

一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。

以下是实例：

class SchoolMember:
    '''Represent any school member.'''
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print ('Initialoze school member {0}'.format(self.name))
    def tell(self):
        print ('Name:"{0}",Age:"{1}"'.format(self.name,self.age),end ='')

class Teacher(SchoolMember):
    '''Repressent a teacher.'''
    def __init__(self,name,age,salary):
        SchoolMember.__init__(self,name,age)
        self.salary = salary
        print('(Initialized Teacher:{0})'.format(self.name))
    def tell(self):
        SchoolMember.tell(self)
        print ('Salary:"{0}"'.format(self.salary))

class Student(SchoolMember):
    '''Repressent a teacher.'''
    def __init__(self,name,age,grade):
        SchoolMember.__init__(self,name,age)
        self.grade = grade
        print('(Initialized Student:{0})'.format(self.name))
    def tell(self):
        SchoolMember.tell(self)
        print ('Grade:"{0}"'.format(self.grade))

可以运行以下代码查看效果

t = Teacher('Mrs.Shrividya',30,30000)
s = Student('Swaroop',25,75)
members = [t,s]
for member in members:
    member.tell()

第 13 章 输入输出

13.2 用户输入imput

something = input('Enter text:')

13.3 文件file类

创建一个 file 类的对象来打开一个文件，分别使用 file 类的 read、readline 或 write 方法来恰当地读写文件；用 close 方法来完成文件操作

os.read()会一次性读入所有数据到内存中，若文件太大很不方便。可以加入参数n，只读入n个字符。也可以用os.readline()每次只读一行。

os.open()默认为'r'只读，可选参数有'w','a'等等

最后一定要os.close()

13.4 pickle 模块

Python 提供了一个叫做 pickle 的标准模块，使用该模块你可以将任意对象存储在文件中，之后你又可以将其完整地取出来。这被称为持久地存储对象。

第 14 章 异常

try..except 语句

每个 try 从句，至少都有一个相关联的 except 从句。还可以让 try..except 块关联上一个 else 从句。当没有异常发生的时候，else 从句将被执行。

try:
    text = input('Enter something --> ')
except EOFError:
    print('Why did you do an EOF on me?')
except KeyboardInterrupt:
    print('You cancelled the operation.')
else:
    print('You entered {0}'.format(text))

14.6 Try..Finally

在一个 try 块下，可以同时使用except 从句和 finally 块。如果你要同时使用它们的话，需要把一个嵌入另外一个。

try:
    code
except:
    code
finally:
    code

14.7 with 语句

在 try 块中获得资源，随后又在 finally 块中释放资源，这是一种常见的模式。今后，也有一种 with 语句能以清晰的方式完成这样的功能。

with open("poem.txt") as f:
    for line in f:
        print(line,end='')

输出与前面例子的输出应该一样。这里的区别就是用 with 语句使用 open 函数—— 用 with open 就能使得在结束的时候自动关闭文件。

在屏幕后面发生的事情就是 with 语句使用了一种协议。获得了 open 语句返回的对象，就叫做’thefile’ 好了。

在启动代码块之前，在后台总会调用 thefile.__enter__函数，在代码块结束后又会调用 thefile.__exit__函数。

用 finally 块写的代码应该自行注意 __exit__方法。这就能帮助我们避免反复使用显式的 try..finally 语句。

第 15 章 标准库

15.1 简介

Python 标准库是随 Python 附带安装的，它包含大量极其有用的模块。熟悉Python 标准库是十分重要的，因为如果你熟悉这些库中的模块，那么你的大多数问题都可以简单快捷地使用它们来解决。。你可以在 Python 附带安装的文档的“library”一节中了解 Python 标准库中所有模块的完整内容。

15.2 sys 模块
sys 模块包含了系统指定的函数功能。我们已经看到 sys.argv 列表包含命令行参数。 version_info 元组，它能给出版本的信息

warnings模块则能定义警告信息

import sys, warnings

if sys.version_info[0] < 3:
    warnings.warn("Need Python 3.0 for this program to run",RuntimeWarning)
else:
    print('Proceed as normal')

15.3 logging 模块

得到一些调试信息或重要信息并将其存储在某个地方，用来检查你的程序程序运行是否是你期望的那样.

处理存储在某处的这些信息可以用 logging 模块来实现。

15.4 urllib 和 json 模块

urllib 模块，可以用来从 internet 上取来一些网页。我们将使用 Yahoo！搜索引擎来得到搜索结果，它们能给出叫做 JSON 格
式的结果，我们就能很容易用在标准库中内建的模块来解析。

第 16 章 更多内容

16.2 传送元组

在一个函数中返回两个不同的值，只需要return (key1,key2)即可他们构成了一个元组返回。

16.3 特殊方法

有一些如 __init__ 和 __del__这样的确定方法，对类来说有重要意义。

特殊的方法用来模仿内置类型的确定动作。例如，如果你想对类使用 x[key] 角标操作（就像你在列表和元组中那样），那么你只需要实现 __getitem__() 方法就可以了。

下面这个表中列出了一些有用的特殊方法。如果你想要知道所有的特殊方法，你可以在参考手册(https://docs.python.org/dev/3.0/reference/datamodel.html#special-method-names)
中找到一个庞大的列表。

• __init__(self, ...) ： This method is called just before the newly created object is returned for usage.
• __del__(self)： Called just before the object is destroyed
• __str__(self)：Called when we use the print function or when str() is used.
• __lt__(self, other)：Called when the less than operator (<) is used. Similarly, there are special methods for all the operators (+, >, etc.)
• __getitem__(self, key)：Called when x[key] indexing operation is used.
• __len__(self)：Called when the built-in len() function is used for the sequence object.

16.5 Lambda 形式

lambda 语句被用来创建新的函数对象，并且在运行时返回它们。

16.6 列表综合

通过列表综合，可以从一个已有的列表导出一个新的列表。例如，你有一个数的列表，而你想要得到一个对应的列表，使其中所有大于 2 的数都是原来的 2 倍。对于这种应用，列表综合是最理想的方法。

listone = [2,3,4]
listtwo = [2*i for i in listone if i > 2]

16.8 exec 和 eval 语句

exec 语句用来执行储存在字符串或文件中的 Python 语句。例如，我们可以在运行时生成一个包含 Python 代码的字符串，然后使用 exec 语句执行这些语句：exec('print("Hello World")')

eval 函数用来执行存储在字符串中的 Python 表达式。

16.9 assert 语句

assert 语句用来声明某个条件是真的。例如，如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert 语句是应用在这种情形下的理想语句。当 assert 语句失败的时候，会引发一个AssertionError。
assert len(mylist) >= 1

16.10 repr 函数

repr 函数用来取得对象的规范字符串表示。注意，在大多数时候有 eval(repr(object))== object。

基本上，repr 函数用来获取对象的可打印的表示形式。你可以通过定义类的__repr__ 方法来控制你的对象在被 repr 函数调用的时候返回的内容。