学习某培训教材的记录：
变量及赋值：
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
将一个值赋给变量的操作被称为赋值。如：
a = 101
b = 102
print(a+b)
多重赋值与多元赋值：
多重赋值：可以同时给多个变量赋予相同内容的操作。如：
a = b = c = 200
多元赋值：可同时给多个变量赋予不同内容的操作。如：
a,b,c = 1,2,3
标准数据类型：Python有5个标准的数据类型：
Numbers（数字）
String（字符串）
List (列表)
Tuple(元组)
Dictionary(字典)
数字：数字数据类型用于存储数值。其为不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
Python支持多种不同的数据类型：
int （有符号整型）：200，600
float（浮点型）： 0.2，69.8
complex(复数)：3.14j，0.897j
变量使用注意事项：
a：变量使用前需要对其进行赋值；
b：变量名可以包括字母，数字，下划线，但不能以数字开头；
变量命名原则：
a:模块名：小写字母，单词之间用下划线“_”分割。如：
ad_stats.py
b:类名：单词首字母大写。如：AdStats
c:普通变量：小写字母，单词之间用下划线“_”分割。如：
app_stats
d:实例变量(指跟类的具体实例相关联的变量)：以下划线“_”开头，小写字母，单词之间用下划线“_”分割。如：
_price
_instance_var
不会被语句"from module import *" 语句加载。
e:普通函数：小写字母，单词之间用下划线“_”分割。如：
get_age()
f：私有函数：
以两个下划线"_"开头，小写字母，单词之间用下划线“_”分割。如：
__get_age()
外部访问会报错。
函数：函数是一种方法，可以用来实现特定的功能。
内建函数：Python有很多函数，这种Python自带的函数称为内建函数。如：
input() 获取用户输入。
int(object) 将字符串和数字转换为整数。
str(object) 将值转换为字符串。
创建函数：是组织程序的关键，创建并使用函数可以减少程序中重复的代码，使主程序更抽象，结构更清晰。创建函数格式如下：
def 函数名称():
函数内的语句
如：
def say_hello():
print("hi")
print("My name is LiLei")
括号内可以填入参数，也可以不填，或填入多个参数，用逗号隔开即可。如果需要返回参数，可在需要返回的内容前加return。
def 函数名称(参数1,参数2,参数3,......):
函数内的语句
.........
return 返回内容
如：
def add(a,b):
sum_number = a+b
return sum_number
数据类型：
数字：Python提供了常用的数字类型：整数，浮点数，布尔型，复数：
整数：int，以十进制数字的字符串写法出现。
浮点数：实数在Python中称作浮点数（Float）。
布尔型：bool，仅有两个值：True 和 False，分别表示“真”和“假” 。
复数：Python的复数常量写成实部 + 虚部的写法，这里的虚部是以j或J结尾。
序列：在Python这包含6种内建序列，即列表，元组，字符串等；
列表:
列表的各个元素通过逗号分隔，写在方括号中。如：
test_ad = ['Abb',123]
序列中也可以包括其他序列：如：
test_ad = ['Abb',123]
test_ad2 = ['sd',456]
database = [test_ad,test_ad2 ]
print(database )
字符串：是由数字，字母，下划线组成的一串字符。它是编程语言中表示文本的数据类型。如下：
name = "ixusy"
字符串可以是文本或符号等。字符串可以用单引号'',双引号"",三引号''' '''括起来创建。加了引号的数字一定是字符 串
元组：
元组由简单的对象组构成，是一种不可变系列。元组与列表非常相似，只不过元组不能在原处修改，并且通常写成圆
括号"()"中的一系列项。虽然元祖不支持任何方法调用，但元祖与列表相同，可以嵌入到任何类别的对象中。
元组的意义在于：元组可以在映射（和集合的成员）中当作键来使用，列表不行。元组作为很多内建函数和
方法的返回值存在。如：
t = (1,2,3,4,"pass")
字典：字典是一种无序列表，用 "{}" 进行创建。字典中的每个成员由两部分组成：一部分是键，一部分是值；如：
grad = {"abc":"85","cc":"99"}
字典中的键是唯一的，但值不唯一。
集合：
在Python中,集合由内置的set类型定义。要创建集合，需要将所有项元素放在花括号“{}”内，以逗号","分隔,如：
a = {10,20,30,40,50,60}
b = {20,40,60}
在Python中,集合可以分成两类：一类是可变集合，及可以原地修改；一类是不可变集合，即不可原地修改。
集合可以有任意数量的元素，它们可以是不同的类型，例如：数字，元组，字符串等。但是，集合不能有可
变元素，例如：列表，集合，字典。如：
a = {10,20,30,40,50,60}
b = {20,40,60}
print(a - b)
程序输出结果是：
{10,30,50}
字符串：字符串是一个有序的字符的集合，用来存储和表现基于文本的信息。所有标准的序列操作都适用于字符串，但是字符串不可变。创建字符串可以使用单引号，双引号，这两种引号没有区别。三引号可以输出多行的长字符串，此功能是单引号和双引号不能实现的。
使用索引“[]”可以获取字符串中特定的元素。使用切片操作“[:]”可以提取子字符串。字符有2种提取顺序：
a:从左到右索引默认0开始的，最大范围是字符串长度少1；
b:从右到左索引默认-1开始，最大范围是字符串开头；
在Python中不能让字符串与数字相加。需要使用转换工具进行预处理：
int：把字符串转换为数字；
str：把数字转换为字符串；如下：
num = 15
int(num) #将字符串转换为数字
str(num) #将数字转换为字符串
修改字符串：
字符串是不可变的，因此不能在原处直接对其修改。可以使用通过分片与合并来建立新的字符串；如果是想替换字符串中的一个字符，可以使用字符串的replace方法实现。
字符串的使用：
访问字符串的值：
Python里面没有字符这个类型，而是用长度为1的字符串来表示这个概念，用方括号加一个或者多于一个索引的方式来 获得子串；
字符串的操作符：
a:检查符： in，not in ：可以用来判断一个字符或者一个子串是否出现在另一个字符串中，检验结果会以布尔值的形式返回，出现则返回True，否则返回False。
b:连接符：“+” 可以用来连接字符串，从而获得一个新的字符串。用“*”可以将一个系列重复n次；
c:长度，最小值，最大值：函数len()可以返回序列中所包含的数量，min函数和max函数可以分别返回序列中的最小值与最大值。
d:读取用户输入：input()：Python内建的input函数可以使用给定字符串提示用户输入并将这个输入返回。
条件判断：
if语句：可以用于判断结果真假的条件表达式，以布尔值的方式显示结果；
else 语句：else语句依附于if语句存在，为if语句提供了另外一种选择；
elif语句：如果需要检查多个条件，就可以使用elif语句，即else if的简写；
常用运算符：
算术运算符：（a = 10,b = 21）
+：加法运算，将运算符两边的操作数相加。(a + b = 31)
- ：减法运算，将运算符左边的操作数减去右边的操作数。(a - b = -11)
* ：乘法运算，将运算符两边的操作数相乘。(a * b = 210)
/ ：除法运算，用右操作数除左操作数。( b / a = 2.1) （取整使用 int(b/a)）
%：模运算，用右操作数除左操作数并返回余数。(b % a = 1)
** ：对运算符进行指数（幂）运算。（10**21 表示10的21次幂）
比较（关系）运算符：（a = 10,b = 21）
== ：如果两个操作数的值相等，则条件为真。 (a == b)求值结果为False
！= ：如果两个操作数的值不相等，则条件为真。 (a != b)求值结果为True
> ：如果左操作数的值大于右操作数的值，则条件为真。 (a > b)求值结果为False
< ：如果左操作数的值小于右操作数的值，则条件为真。 (a < b)求值结果为True
>= ：如果左操作数的值大于或等于右操作数的值，则条件为真。(a >= b)求值结果为False
<= ：如果左操作数的值小于或等右操作数的值，则条件为真。 (a <= b)求值结果为True
赋值运算符：（a = 10,b = 21）
= ：将右操作数的值分配给左操作数。
+=：将右操作数相加到左操作数，并将结果分配给左操作数。
-=： 从左操作数中减去右操作数，并将结果分配给左操作数。
*=：将右操作数与左操作数相乘，并将结果分配给左操作数。
/=：将左操作数除以右操作数，并将结果分配给左操作数。
%=：将左操作数除以右操作数的模数，并将结果分配给左操作数。
**=：执行指数（幂）计算，并将结果分配给左操作数。
//= ：运算符执行地板除运算，并将结果分配给左操作数。
逻辑运算符：
and： 如果两个操作数都为真，则条件成立。
or ： 如果两个操作数中的任何一个非零，则条件成为真。
not ： 用户反转操作数的逻辑状态。
身份运算符：
身份运算符比较两个对象的内存位置。
is ： 如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。
is not ： 如果运算符任一侧的变量指向相同的对象，则返回False，否则返回True。
运算符优先级：
| 序号 | 运算符 | 描述 |
| 1 | ** | 指数（次幂）运算 |
| 2 | ~ + - | 补码,一元加减（最后两个的方法名称是+@ 和 -@） |
| 3 | * / % // | 乘法，除法，模数和地板除 |
| 4 | + - | |
| 5 | >> << | 向右 和向左位移 |
| 6 | & | 按位与 |
| 7 | ^ | | 按位异或 和 常规的‘OR’ |
| 8 | < = < > >= | 比较运算符 |
| 9 | <> == != | 等于运算符 |
| 10 | = %= /= //= -= += *= **= | 赋值运算符 |
| 11 | is is not | 身份运算符 |
| 12 | in not in | 成员运算符 |
| 13 | not ir and | 逻辑运算符 |
循环：
while循环：
cnt = 0
while cnt < 10:
print("The Cnt is",cnt)
cnt += 1
print("end")
for循环：
for循环可以遍历然后系列和其他可迭代对象（可以按次序获取的对象）的集合，如一个列表或者一个字符串。其语法格式如下：
for 可重复变量 in 系列:
statements(s)
for i in "ixusy88":
print(i)
退出循环：
break 用户退出循环，
跳出循环：
continue，用户终止当前循环（即跳过循环当前剩下的语句），继续执行下一次循环
列表：
列表是Python中最具灵活性的有序集合对象类型。与字符串不同的是，列表可以包含任何种类的对象：数字，字符串甚至是其它列表。同样，与字符串不同，列表都是可变对象，它们都支持在原处修改的操作，可以通过指定的值和分片，列表方法调用，删除语句等方法来实现。
列表有以下几个特征：
1：是任意对象的有序集合；
2：可以进行分片和合并
3：可变长度，异构（可包含任意类型对象）以及任意嵌套
4：属于可变序列的分类
5：对象引用数组
通用列表操作：
| 表达式 | 描述 |
| L1=[] | 创建一个空列表 |
| L2=[1,2,3,4,5,6] | 创建一个有成员的列表 |
| L3=['abc',['def','ghi']] | 创建一个嵌套的子列表 |
| L2[i] | 索引 |
| L1+L2 | 合并 |
| L1*4 | 重复 |
更新列表：
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
list = []
list.append('1234')
list.append('4567')
print(list)
删除列表元素：
可以使用del语句来删除列表的元素：
list1 = ['a','b',1,2]
print(list1)
del list1[2]
print(list1)
Python列表脚本操作符：
列表对 + 和 * 的操作符与字符串相似。
使用方法如下所示：
| Python表达式 | 结果 | 描述 |
| len([1,2,3]) | 3 | 长度 |
| [1,2,3]+[4,5,6] | [1,2,3,4,5,6] | 组合 |
| ['Hi']*4 | ['Hi','Hi','Hi','Hi'] | 重复 |
| 3 in [1,2,3] | True | 元素是否存在于列表中 |
| for i in [1,2,3]: print(i) |
1 2 3 | 迭代 |
Python列表函数 和 方法
Python包含以下函数：
| 序号 | 函数 | 描述 |
| 1 | len(list) | 列表元素个数 |
| 2 | max(list) | 返回列表元素最大值 |
| 3 | min(list) | 返回列表元素最小值 |
| 4 | list(seq) | 将元祖转换为列表 |
Python包含以下方法：
| 序号 | 方法 | 描述 |
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index,obj) | 将对象插入列表 |
| 6 | list.pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中的元素 |
| 9 | list.sort([func]) | 对原列表进行排序 |
字典：
字典是另一种可变容器模型，且可存储任意类型对象，字典是Python中唯一内建的映射类型，映射是指通过名字来引用值的数据结构。
字典的每个键值对"key:value" 用冒号“:”分割，每个键值对之间用“,”分割，整个字典包括在花括号“{}”中，格式如下所示：
d={key1:value1,key2:value2}
键一般是唯一的，可以是数字，字符串甚至是元祖，如果重复最后的一个键值对会替换前面的，值不需要唯一，且可以是任何数据类型。字典中的值并没有特殊的顺序。
访问字典中的值：
可以直接使用print语句输出字典键对应的值，例如：
dict = {"Name":"zara"}
print("Name: ",dict['Name'])
修改字典：
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，例如：
dict = {'Name':'Zara','Age':7,'class':'First'}
dict['Age'] = 8
dict['Scholl'] = "DPS School"
print("dict['Age']:",dict['Age'])
print("dict['School']:",dict['School'])
删除字典元素：
能删单一的元素也能清空字典，清空只需一项操作。
student_dict = {'Name':'Zara','Age':7,'Class':'First'}
del student_dict['Name']
print(student_dict)
student_dict.clear()
print(student_dict)
字典键的特性：
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：
1：不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
2：键必须不可变，所以可以用数字，字符串或元祖充当，所以用列表就不行。
字典内置函数和方法：
Python字典包含了以下内置函数：
| 序号 | 方法 | 描述 |
| 1 | len(dict) | 计算字典元素个数，即键的总数 |
| 2 | str(dict) | 输出字典可打印的字符串表示 |
| 3 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
| 序号 | 函数 | 描述 |
| 1 | dict.clear() | 删除字典内所有元素 |
| 2 | dict.copy() | 返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq[,val]) | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | dict.get(key,default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.items() | 以列表返回可遍历的（键，值）元祖数组 |
| 6 | dict.keys() | 以列表返回一个字典所有的键 |
| 7 | dict.setdefault(key,default=None) | 和get()类似，但如果键不存在于字典中，将会添加键并将值设为default |
| 8 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| 9 | dict.values() | 以列表返回字典中的所有值 |
| 10 | dict.pop(key[,default]) | 删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。 |
| 11 | dict.popitem() | 随机返回并删除字典中的一对键和值 |
类：
类(Class)是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。所有的对象都属于某一个类，称为类的实例，对象是类的实例。
创建类：可以使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，例如：
class 类的名称(): #命名类时类名的单词首字母要大写，使用驼峰命名法
class Student():
def say_hi(self):
print("Hi!")
li = Student()
li.say_hi
创建实例对象：
在Python 中，类的实例化类似函数调用方式，通过__init__方法接收参数(init前后各有两个下划线)。例如：
class Student():
def __init__(self,name):
self.name = name
def say_hi(self):
print("Hi {} !".format(self.name))
li = Student("li")
li.say_hi()
han = Student("han")
han.say_hi()
Python内置类属性：
| 序号 | 名称 | 描述 |
| 1 | __dict__ | 类的属性（包含一个字典，由类的数据属性组成） |
| 2 | __doc__ | 类的文档字符串 |
| 3 | __name__ | 类名 |
| 4 | __module__ | 类定义所在的模块（类的全名是'__naib__.className',如果类位于一个导入模块mymod中，那么className.__module__等于mymod） |
| 5 | __bases__ | 类的所有父类构成元素（包含了一个由所有父类组成的元组） |
class Student():
StuCount = 0
def __init__(self,name,grade):
self.name = name
self.grade = grade
Student.StuCount += 1
def displayCount(self):
print("Total Student {}".format(Student.StuCount))
def displayStudent(self):
print("Name:{},grade:{}".format(self.name,self.grade))
print("Student.__doc__:",Student.__doc__)
print("Student.__name__:",Student.__name__)
print("Student.__module__:",Student.__module__)
print("Student.__bases__",Student.__bases__)
print("Student.__dict__",Student.__dict__)
类的继承：
继承完全可以理解成类之间的类型和子类型关系。如果你已经有了一个类，而又想建立一个非常类似的类，例如只想添加几个方法，而在编写新类时，又不想把旧类的代码全部复制过去，就可以用继承的方法。
继承语法：
class 子类名(父类名):
在python继承中的一些特点：
1：在继承中父类的构造(__init__()方法)不会被自动调用，它需要在其子类的构造中亲自专门调用。
2：在调用父类的方法时，需要加上父类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在子类中找到对应的方法，它才开始到父类中逐个查找。（先在本类中查找调用方法，找不到才去父类中找）。
如果在继承元组中有一个以上的类，那么它就被称作“多重继承”。
语法表示：
子类的声明，与他们的父类类似，继承的父类列表跟在类名之后，如下所示：
class 子类名(父类1[,父类2,......]):
'类文档字符串'
class_suite
例如：
class Parent():
"""docstring for Parent"""
parent_attr = 100
def __init__(self):
print("调用父类的构造函数")
def parent_method(self):
print("调用父类方法")
def set_attr(self,attr):
Parent.parent_attr = attr
def get_attr(self):
print("父类属性:",Parent.parent_attr)
class Child(Parent):
def __init__(self):
#Parent.__init__(self)
print("调用子类的构造函数")
def child_method(self):
print("调用子类方法")
li = Child()
li.parent_method()
li.child_method()
li.set_attr(50)
li.get_attr()