python3.5.2学习笔记

python标识符

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如
init() 代表类的构造函数。

数字

Python的除法（"/"）总是返回一个float浮点型的数字

ret = 10 / 5
print(ret)      # 打印值为2.0

做 floor 除法并且得到一个整数结果(返回商的整数部分) 可以使用 // 运算符

print(17 / 3)    # 打印结果小数：5.666666666666667
print(17 // 3)   # 打印结果整数：5

使用**做n次方运算

print(5 ** 2)       # 5的2次方，打印结果：25
print(2 ** 8)       # 2的8次方，打印结果：256

行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。同一个基本块内的每一行必须按相同的量缩进。如下所示：

if True:
    print "True"
else:
    print "False"

以下代码将提示错误：

if True:
    print "Answer"
    print "True"
else:
    print "Answer"
    # 没有严格缩进，在执行时会报错
  print "False"

多行语句

Python语句中一般以新行作为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

   total = item_one + \    
           item_two + \
           item_three

python注释

python中单行注释采用#开头
python中多行注释使用三个单引号或多个多引号，所示如下：

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

输入函数

python3的输入函数只有input()，所示如下：

name = input("请输入学生姓名：")
print(name)

print输出

print默认输出是换行的，如果实现不换行需要在变量末尾加上逗号。

x = "a"
y = "b"
# 换行输出
print(a)
print(b)
# 不换行输出
print(x,y)

字符串

字符串可以被括在单引号(’…’)或者双引号("…")中。字符串中的特殊字符用反斜杠()转义

name = 'python'
language = "python"

不想让 \ 被解释为特殊字符开头的字符，您可以通过添加 r 使用原始字符串

print('C:\some\name')     # here \n means newline!      
                          # 输出结果：C:\some
                                         ame
print(r'C:\some\name')    # note the r before the quote!
                          # 输出结果：C:\some\name

字符串可以用+操作符连接，也可用*操作符重复多次。
字符串可以索引，第一个字符的索引值为0.python没有字符类型，一个字符就是一个长度为1的字符串。索引可以是负数，此时从右侧开始计数。
除了索引，还支持切片。索引用于获得单个字符，切片用于获得子字符串（开始索引总包括在内，结束索引总排除在外）。切片索引具有非常有用的默认值;省略的第一个索引默认为零，省略第二个索引默认为切片字符串的长度。

str = 3 * 'un' + 'mmm'
print(str);          # 输出：unununmmm
print(str[0])        # 输出：u
print(str[-1])       # 输出str字符串的最后一个字符：m

# 切片
print(str[0:2])      # 输出子串：un
word = "Python"
print(word[0:2])     # 获取位置0（包括）到位置2（不包括）的字符串   打印结果：Py
print(word[:2] + word[2:])    #省略的第一个索引默认为零，省略第二个索引默认为切片字符串的长度。打印结果： Python

列表

Python 有几个复合数据类型，用来组合其他的值。最有用的是列表，可以写成中括号中的一列用逗号分隔的值。列表可以包含不同类型的元素，但是通常一个列表中的所有元素都拥有相同的类型。
与字符串（和所有其他内置序列类型）相似，列表可以被索引和切片︰

squares = [1, 4, 9, 16, 25]
print(squares)          # 打印结果：[1, 4, 9, 16, 25]
print(squares[0])       # 打印结果：1
print(squares[-1])      # 打印结果：25
print(squares[-3:])     # 打印结果：[9, 16, 25]

列表支持用"+"连接两个列表。与字符串的不可变特性不同，列表是可变的类型。
列表可以嵌套（创建包含其他列表的列表），例如：

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)               # 打印结果：[['a', 'b', 'c'], [1, 2, 3]]
print(x[0])            # 打印结果：['a', 'b', 'c']
print(x[0][1])         # 打印结果：b

一个赋值符号（"="）给多个变量赋值

示例：

a, b = 0, 1             # 变量 a 和 b 同时获得新值 0 和 1
while b < 10:
     print(b)
     a, b = b, a+b    # 等号右边的表达式在赋值之前首先被完全解析  首次进入循环体时：a,b = b, a+b  --解析--> a,b = 1, 0+1

if语句

可以有0个或多个 elif 块,，并且 else 块是可选的。

x = int(input("Please enter an integer: "))
if x < 0:
    x = 0
    print('Negative changed to zero')
elif x == 0:
    print('Zero')
elif x == 1:
    print('Single')
else:
    print('More')

for语句

Python 的 for 语句可以按照元素出现的顺序迭代任何序列（列表或字符串）。

words = ['cat', 'window', 'defenestrate']
for w in words:
    print(w, len(w))      # len()为内置函数
# 打印结果
cat 3
window 6
defenestrate 12

range()函数

如果需要遍历一个数字序列，内置函数 range() 会派上用场。它生成算术级数：

for i in range(8):
    print(i)            # 打印结果：0 1 2 3 4 5 6 7


for i in range(2,10)
    print(i)       # 打印结果：2 3 4 5 6 7 8 9   即，计数器2 <= i < 10,计数器i每次都是用 i + 1与 10比较大小，若小于10则i = i + 1,否则不执行赋值语句。

break和continue语句，以及循环中else子句

break语句和 C 中的类似，用于跳出最近的 for 或 while 循环。循环语句可以有一个 else 子句;当（for）循环迭代完整个列表或（while）循环条件变为假，而非由break语句终止时，就会执行这个else语句。下面循环搜索质数的代码例示了这一点：

for n in range(2, 10):
    for x in range(2, n):
         if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:                # else 子句属于 for 循环，而不是 和if 语句配对
         # loop fell through without finding a factor
         print(n, 'is a prime number')

pass语句

pass 语句什么也不做。当语法上需要语句但程序不需要动作时，可以使用它。

定义函数

def fib(n):  # return Fibonacci series up to n
     """Return a list containing the Fibonacci series up to n."""
     result = []
     a, b = 0, 1
     while a < n:
         result.append(a)    # result = result + [a]，但是它更高效
         a, b = b, a+b
     return result


# 默认参数值的函数
def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

// 重要的警告︰默认值只初始化一次。当默认值是一个可变对象（如列表，字典或大多数类的实例）时，默认值会不同。例如，下面的函数在后续调用过程中会累积传给它的参数：
def f(a, L=[]):
    L.append(a)
    return L
print(f(1))       # 打印结果：[1]
print(f(2))       # 打印结果：[1,2]
print(f(3))       # 打印结果：[1,2,3]
// 如果你不想默认值在随后的调用中共享，可以像这样编写函数：
def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

# 关键字参数
def func(a, b = 5, c = 8)
    pass
func(3, 7)           #  a = 3, b = 7, c = 8
func(25, c = 24)      # a = 25, b = 5, c = 8 
func(c = 50, a = 100)     # a = 100, b = 5, c = 50

# 可变参数
//想定义的函数里面能够有任意数量的变量，也就是参数数量是可变的，这可以通过使用星号来实现
def total(a=5, *numbers, **phonebook):   #当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数（Positional Arguments）都将被收集并汇集成一个称为“param”的元组（Tuple）。类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。
    print('a', a)

    #遍历元组中的所有项目
    for single_item in numbers:
        print('single_item', single_item)

    #遍历字典中的所有项目
    for first_part, second_part in phonebook.items():
        print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))
// 输出结果如下：
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None

关键字 def 引入函数的定义。其后必须跟有函数名和以括号标明的形式参数列表。组成函数体的语句从下一行开始，且必须缩进。

函数体的第一行可以是一个可选的字符串文本；此字符串是该函数的文档字符串，或称为docstring。有工具使用 docstrings 自动生成在线的或可打印的文档，或者让用户在代码中交互浏览；在编写的代码中包含 docstrings 是很好的做法。

数据结构

列表
列表是一种用于保存一系列有序项目的集合，也就是说，你可以利用列表保存一串项目的序列。项目的列表应该用方括号括起来，这样 Python 才能理解到你正在指定一张列表。一旦你创建了一张列表，你可以添加、移除或搜索列表中的项目。既然我们可以添加或删除项目，我们会说列表是一种可变的（Mutable）数据类型，意即，这种类型是可以被改变的。示例：shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] // shoplist为列表类型
元组
元组（Tuple）用于将多个对象保存到一起。你可以将它们近似地看作列表，但是元组不能提供列表类能够提供给你的广泛的功能。元组的一大特征类似于字符串，它们是不可变的，也就是说，你不能编辑或更改元组。元组是通过特别指定项目来定义的，在指定项目时，你可以给它们加上括号，并在括号内部用逗号进行分隔。元组通常用于保证某一语句或某一用户定义的函数可以安全地采用一组数值，意即元组内的数值不会改变。singleton = (2,) 此为包含一个项目的元组的写法。示例：zoo = (‘python’, ‘elephant’, ‘penguin’) // zoo为元组类型
字典
字典就像一本地址簿，如果你知道了他或她的姓名，你就可以在这里找到其地址或是能够联系上对方的更多详细信息，换言之，我们将键值（Keys）（即姓名）与（Values）（即地址等详细信息）联立到一起。在这里要注意到键值必须是唯一的，正如在现实中面对两个完全同名的人你没办法找出有关他们的正确信息。另外要注意的是你只能使用不可变的对象（如字符串）作为字典的键值，但是你可以使用可变或不可变的对象作为字典中的值。基本上这段话也可以翻译为你只能使用简单对象作为键值。在字典中，你可以通过使用符号构成 d = {key : value1 , key2 : value2} 这样的形式，来成对地指定键值与值。在这里要注意到成对的键值与值之间使用冒号分隔，而每一对键值与值则使用逗号进行区分，它们全都由一对花括号括起。
集合
集合（Set）是简单对象的无序集合（Collection）。当集合中的项目存在与否比起次序或其出现次数更加重要时，我们就会使用集合。示例：bri = set([‘brazil’, ‘russia’, ‘india’])
序列
列表、元组和字符串可以看作序列（Sequence）的某种表现形式，列表、元组与字符串，同样拥有一种切片（Slicing）运算符，它能够允许我们序列中的某段切片——也就是序列之中的一部分。可以在切片操作中提供第三个参数，这一参数将被视为切片的步长（Step）（在默认情况下，步长大小为 1）

面向对象编程

self

类方法与普通函数只有一种特定的区别——前者必须多加一个参数在参数列表开头，这个名字必须添加到参数列表的开头，但是你不用在你调用这个功能时为这个参数赋值，Python 会为它提供。这种特定的变量引用的是对象本身，按照惯例，它被赋予 self 这一名称。该self类似于Java中的this引用。

类

最简单的类（Class）可以通过下面的案例来展示：

class Person:
    pass      # 一个空的代码块

p = Person()     # 实例化对象
print(p)

init 方法

_init_ 方法是Python类中的构造函数，在对象被实例化时由系统调用。在下例中，population 属于 Person 类，因此它是一个类变量。name 变量属于一个对象（通过使用 self 分配），因此它是一个对象变量。

class Person:
    # 这是一个类变量
    population = 0
   
    # name变量是一个对象变量，通过self分配，不同于Java不需要在类定义时先声明对象变量。
    def __init__(self, name):
        self.name = name
        
        
    # 静态方法
    @classmethod
    def how_many(cls):
        print("{} persons".format(cls.population))


p = Person("czy")
print(p)

类中属性的私有化

使用数据成员并在其名字中使用双下划线作为前缀，形成诸如 __privatevar 这样的形式，Python 会使用名称调整（Name-mangling）来使其有效地成为一个私有变量。

继承

class SchoolMember:
    '''代表任何学校里的成员。'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('(Initialized SchoolMember: {})'.format(self.name))

    def tell(self):
        '''告诉我有关我的细节。'''
        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")


class Teacher(SchoolMember):
    '''代表一位老师。'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print('(Initialized Teacher: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)
        print('Salary: "{:d}"'.format(self.salary))


class Student(SchoolMember):
    '''代表一位学生。'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print('(Initialized Student: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)
        print('Marks: "{:d}"'.format(self.marks))

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)

# 打印一行空白行
print()

members = [t, s]
for member in members:
    # 对全体师生工作
    member.tell()

由上式看出，使用继承，在定义类时我们需要在类后面跟一个包含基类名称的元组。
在 Teacher 和 Student 子类中定义了 init 方法，Python 不会自动调用基类 SchoolMember 的构造函数，你必须自己显式地调用它。相反，如果我们没有在一个子类中定义一个 init 方法，Python 将会自动调用基类的构造函数。
Python支持多继承

Pickle，持久化存储对象

Python 提供了一个叫作 Pickle 的标准模块，通过它你可以将任何纯 Python 对象存储到一个文件中，并在稍后将其取回。这叫作持久地（Persistently）存储对象。

import pickle

# 我们存储相关对象的文件的名称
shoplistfile = 'shoplist.data'
# 需要购买的物品清单
shoplist = ['apple', 'mango', 'carrot']

# 准备写入文件
f = open(shoplistfile, 'wb')
# 转储对象至文件
pickle.dump(shoplist, f)      # 调用dump函数，这被叫做封装
f.close()

# 清除 shoplist 变量
del shoplist

# 重新打开存储文件
f = open(shoplistfile, 'rb')
# 从文件中载入对象
storedlist = pickle.load(f)         #load函数，接收返回的对象，这被叫做拆封
print(storedlist)

assert语句

assert 语句用以断言（Assert）某事是真的。例如说你非常确定你正在使用的列表中至少包含一个元素，并想确认这一点，如果其不是真的，就抛出一个错误，assert 语句就是这种情况下的理想选择。当语句断言失败时，将会抛出 AssertionError。

Python入门书籍参考资料

python3.5.2学习笔记

python标识符

数字

行和缩进

多行语句

python注释

输入函数

print输出

字符串

列表

一个赋值符号（"="）给多个变量赋值

if语句

for语句

range()函数

break和continue语句，以及循环中else子句

pass语句

定义函数

数据结构

面向对象编程

self

类

__init__ 方法

类中属性的私有化

继承

Pickle，持久化存储对象

assert语句

init 方法