一、语言元素
1.01 变量
1.0 Python 支持五种基本数字类型，其中有三种是整数类型。
int (有符号整数)
long (长整数)
bool (布尔值, 布尔值是特殊的整数)
float (浮点值)
complex (复数)
decimal (用于十进制浮点数, 必须先导入 decimal 模块才可以使用这种数值类型。)
2.0 字符串
Python 中字符串被定义为引号之间的字符集合。
Python 支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可以用来包含特殊字符。
使用索引运算符( [ ] )和切片运算符( [ : ] )可以得到子字符串。
字符串有其特有的索引规则：第一个字符的索引是 0， 最后一个字符的索引是 -1
3.0 Bool 值
所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔 True 或 False 值。
空对象、值为零的任何数字或者 Null 对象 None 的布尔值都是 False：
-- None
-- False (布尔类型)
-- 所有的值为零的数：
-- 0 (整型)
-- (浮点型)
-- 0L (长整型)
-- 0.0+0.0j (复数)
-- "" (空字符串)
-- [] (空列表)
-- () (空元组)
-- {} (空字典)
global：声明或定义全局变量
nonlocal：声明使用嵌套作用域的变量（嵌套作用域必须存在该变量，否则报错）。
1.02 运算符
1.0 Python和其他绝大多数的语言一样，加、减、乘、除和取余都是标准运算符:
+ - * / // % **
2.0 Python有两种除法运算符，
单斜杠 / 用作传统除法，
双斜杠 // 用作浮点除法（对结果进行四舍五入）
双星号 ** 乘方运算符
3.0 比较运算符， 根据表达式的值的真假返回布尔值：
< <= > >= == != ( <> 逐渐被淘汰)
4.0 逻辑运算符：
and or not
5.0 Python 不支持 C 语言中的自增 1 和自减 1 运算符，因为 + 和 － 也是单目运算符
1.03 变量赋值
链式赋值
>>> y = x = x + 1
增量赋值、
+= -= *= /= %= **= <<= >>= &= ^= |=
多重赋值
>>> x = y = z = 1
多元赋值
>>> x, y, z = 1, 2, 'a string'
1.04 Null类型
Python有一个特殊的类型， 被称作 Null 对象或者 NoneType， 它只有一个值， 那就是 None。
它不支持任何运算也没有任何内建方法。
None 没有什么有用的属性，它的布尔值总是 False。
1.05 列表、元组、字典
可以将列表和元组当成普通的“数组”，它能保存任意数量任意类型的 Python 对象。
1.0 列表元素用中括号 [ ] 包裹，元素的个数及元素的值可以改变。
2.0 元组元素用小括号( )包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。
3.0 字典元素用大括号{ }包裹。字典是 Python 中的映射数据类型，由键-值(key-value)对构成。
1.06 内建函数
1.01 从交互式解释器中获得帮助:得到一个函数的帮助说明，只需要对它调用内建函数help()。
>>> help(raw_input)
1.02 id(obj) 输出对象地址
1.03 cmp(obj1, obj2) 比较 obj1 和 obj2, obj1 小于 obj2, 则返回一个负整数，如果obj1大于obj2则返回一个正整数， 如果obj1等于obj2， 则返回0。
1.04 repr(obj) 或 `obj` 返回一个对象的字符串表示
1.05 str(obj) 返回对象适合可读性好的字符串表示
1.05 type(obj) 得到一个对象的类型，并返回相应的 type 对象
1.07 类型工厂函数
所谓内建转换函数象 int(), type(), list() 等等， 现在都成了工厂函数。虽然他们看上去有点象函数， 实质上他们是类。如：
int(), long(), float(), complex(), str(), unicode(),basestring(),list(), tuple(), type()
dict(), bool(), set(), frozenset(), object(), classmethod(), staticmethod(), super(), property(), file()
二、数据结构
2.01 列表
1. 一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在`[]`中，多个元素用`,`进行分隔，可以使用`for`循环对列表元素进行遍历，也可以使用`[]`或`[:]`运算符取出列表中的一个或多个元素。
list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]
# 乘号表示列表元素的重复
list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']
# 计算列表长度(元素个数)
print(len(list1)) # 5
# 下标(索引)运算
print(list1[0]) # 1
print(list1[-1]) # 100 倒序
# 通过循环用下标遍历列表元素
for index in range(len(list1)):
print(list1[index])
# 通过for循环遍历列表元素
for elem in list1:
print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
print(index, elem)
2. 生成式和生成器
创建的不是一个列表而是一个生成器对象；
通过生成器可以获取到数据但它不占用额外的空间存储数据；
每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)；
用列表的生成表达式语法创建列表容器,
f = [x for x in range(1, 10)]
print(f)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)
# ['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
for val in f:
print(val)
2.02 元组
一个变量（对象）来存储多个数据，元组的元素不能修改，多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。
已经有了列表这种数据结构，为什么还需要元组这样的类型呢？
- 元组中的元素是无法修改的，在[多线程]中是安全的，一个不变的对象要比可变的对象更加容易维护。一个不变对象可以方便的被共享访问。
- 元组在创建时间和占用的空间上面都优于列表。可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间。
定义元组
t = ('张三', 38, True, '四川')
print(t)
将元组转换成列表
person = list(t)
print(person)
列表是可以修改它的元素的
person[0] = '李四'
person[1] = 25
将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
2.03 集合
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。
创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # {1, 2, 3}
print('Length =', len(set1)) # 3
创建集合的构造器语法
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
集合的交集、并集、差集、对称差运算: |、-、^、<=、>=
print(set1 & set2)
2.04 字典
字典是另一种可变容器模型，可以存储任意类型对象,与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。
创建字典的字面量语法
scores = {'张三': 95, '李四': 78, '王五': 82}
通过键可以获取字典中对应的值
print(scores['张三'])
创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)
#{'one': 1, 'two': 2, 'three': 3, 'four': 4}
通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))
#{'a': '1', 'b': '2', 'c': '3'}
创建字典的推导式语法
items3 = {num: num ** 2 for num in range(1, 10)}
#{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
2.05 生成式（推导式）的用法
生成式（推导式）可以用来生成列表、集合和字典。
prices = {
'AAPL': 191.88,
'GOOG': 1186.96,
'IBM': 149.24,
'ORCL': 48.44,
'ACN': 166.89,
'FB': 208.09,
'SYMC': 21.29
}
# 用股票价格大于100元的股票构造一个新的字典
prices2 = {key: value for key, value in prices.items() if value > 100}
print(prices2)
三、类和对象
3.01 访问可见性问题
1.在Python中，属性和方法的访问权限只有两种，公开的和私有的。
_ 开头，属性是受保护的
__开头，属性是私有的
2.Python并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来妨碍对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们。
3.实际开发中，并不建议将属性设置为私有的，因为这会导致子类无法访问，所以大家会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。
3.02 @property装饰器
将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。就可以使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便.
class Person(object):
def __init__(self, name, age):
self._name = name
self._age = age
# 访问器 - getter方法
@property
def name(self):
return self._name
# 修改器 - setter方法
@age.setter
def age(self, age):
self._age = age
3.03 slots
__slots__变量来进行限定,限定只对当前类的对象生效，对子类并不起任何作用。
class Person(object):
// 限定Person对象只能绑定_name, _age和_gender属性
__slots__ = ('_name', '_age', '_gender')
3.04 类的静态方法
使用@staticmethod定义类的静态方法
class Triangle(object):
def __init__(self, a, b, c):
self._a = a
self._b = b
self._c = c
@staticmethod
def is_valid(a, b, c):
return a + b > c and b + c > a and a + c > b
通过类名调用
Triangle.is_valid(1,2,3)
3.05 cls约定
类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象, 通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象(通过自己创建一个新对象)
class Clock(object):
def __init__(self, hour=0, minute=0, second=0):
self._hour = hour
self._minute = minute
self._second = second
@classmethod
def now(cls):
ctime = localtime(time())
return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
clock = Clock.now()
3.06 抽象类
所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。
Python从语法层面并没有像Java或C++那样提供对抽象类的支持，但是我们可以通过`abc`模块的`ABCMeta`元类和`abstractmethod`包装器来达到抽象类的效果.
from abc import ABCMeta, abstractmethod
class Pet(object, metaclass=ABCMeta):
def __init__(self, nickname):
self._nickname = nickname
@abstractmethod
def make_voice(self):
pass
3.07 装饰器
装饰器是 Python 中的一种特殊语法结构，允许在运行时动态地修改或增强函数或方法的行为。它们通常用来添加功能，而不需要直接修改原始函数的代码。
@decorator_name 语法将装饰器应用到一个函数上，
等价于 say_hello = my_decorator(say_hello)。
简单的装饰器通常是一个接受一个函数作为参数，并返回一个新函数的函数。
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
Something is happening before the function is called.
Hello!
Something is happening after the function is called.
