>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
一、基本格式
Python根据缩进进行代码块的划分，但不考虑空行；
注释为#；
变量可由字母、数字、下划线组成，只能由字母、下划线开头；
条件、循环语句前注意加冒号；
二、字符串
1、定义
将变量赋值为”string”或’string’，该变量为字符串。
s = "string"
2、操作
（1）大小写
s = "heLLo"
print (s.title())
# 首字母大写，其他字母小写
print (s.upper())
# 大写
print (s.lower())
# 小写
输出结果：
Hello
HELLO
hello
------------------
(program exited with code: 0)
（2）空格清除
s = " hello python "
print ('"' + s + '"')
# 无操作
print ('"' + s.strip() + '"')
# 删除两端空格
print ('"' + s.lstrip() + '"')
# 删除左端空格
print ('"' + s.rstrip() + '"')
# 删除右端空格
输出结果：
" hello python "
"hello python"
"hello python "
" hello python"
------------------
(program exited with code: 0)
（3）分割
split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
str.split(str="", num=string.count(str))
- str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
- num – 分割次数。默认为 -1, 即分隔所有。
- 返回分割后的字符串列表。
str = "this is string example"
s = str.split()
（4）替换
replace() 把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
str.replace(old, new[, max])
- old – 将被替换的子字符串。
- new – 新字符串，用于替换old子字符串。
- max – 可选字符串, 替换不超过 max 次
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串。
三、数字
1、整型
i = 123
2、浮点型
f = 1.23
3、操作
（1）运算
A**B # 乘方
在python2中，int与float在运算时不会进行自动类型转换
（2）字符、数值相互转换
var = int ( 变量 )
var = str ( 变量 )
f = 123
s = str(f)
print(s)
var = int (s)
print(var+2)
输出结果：
123
125
------------------
(program exited with code: 0)
四、列表
由一系列按照特定顺序排列的元素组成（可理解为数组，但数据类型可以不同）
1、定义、访问、部分访问
定义格式：var = [ elem1 , elem2 , ...]
元素可以为变量；
可用下标索引访问：var[n]
切片（部分访问）：var[ begin : end]
其中不包括end所索引元素；负数索引为倒数第k个元素（从-1开始）；空值时，默认从列表头/尾开始。
A = 3
s = [1,"2",A,4,5]
print(s)
print(s[0])
print(s[-2:])
输出结果：
[1, '2', 3, 4, 5]
1
[4, 5]
------------------
(program exited with code: 0)
2、增加、删除
A = 3
s = [1,"2",A]
print(s)
s.append(4)
# 插入元素到末尾
print(s)
s.insert(0,"zero")
# 插入元素到第0个元素
print(s)
d = s.pop(3)
# 删除第3个元素
print(d)
del s[1]
# 删除第1个元素
print(s)
s.remove("zero")
# 根据值删除元素
print(s)
输出结果：
[1, '2', 3]
[1, '2', 3, 4]
['zero', 1, '2', 3, 4]
3
['zero', '2', 4]
['2', 4]
------------------
(program exited with code: 0)
3、列表管理
（1）排序
var.sort()可用于完成列表var的排序，改变var本身，var的元素需要均为数字或字符串；（成员函数）
sorted(var)可得到列表的排序结果，不改变var本身；（函数）
（2）翻转
var.reverse()翻转列表var元素的排列顺序；（成员函数）
（3）列表长度
len(var)返回列表长度；（函数）
（4）元素个数
list.count(obj)统计某个元素在列表中出现的次数；
l = [3,6,4,8,4,7]
print(sorted(l))
# 临时排序
print(l)
l.reverse()
# 翻转
print(l)
l.sort()
# 永久排序
print(l)
print(len(l))
print(l.count(4))
输出结果：
[3, 4, 4, 6, 7, 8]
[3, 6, 4, 8, 4, 7]
[7, 4, 8, 4, 6, 3]
[3, 4, 4, 6, 7, 8]
6
2
------------------
(program exited with code: 0)
4、列表操作
（1）生成数值列表
range(start, stop[, step])函数可创建一个数值列表，一般用在 for 循环中。
- start: 计数从 start 开始。默认是从 0 开始。
- stop: 计数到 stop 结束，但不包括 stop。
- step：步长，默认为1。
var = list( range() )可将数值列表赋值给变量 。
（2）操作数值列表
v = [1,2,3,4,5,6,7,8,9]
print ( min(v) )
print ( max(v) )
print ( sum(v) )
输出结果：
1
9
45
------------------
(program exited with code: 0)
（3）列表解析
var = [ 表达式 for 变量 in 列表]，根据for循环得到表达式的值，该值作为列表var的元素。
v = [var**2 for var in range(1,11)]
print ( v )
输出结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
------------------
(program exited with code: 0)
（4）列表比较
可以用比较运算符比较两个列表的元素。
比较时按顺序依次比较每一元素：若两元素不相等，返回比较结果；若两元素相等，比较下一元素；
如果比较的元素是同类型的，则比较其值，返回结果。
如果两个元素不是同一种类型，则检查它们是否是数字。
- 如果是数字，执行必要的数字强制类型转换，然后比较。
- 如果有一方的元素是数字，则另一方的元素”大”(数字是”最小的”)
- 否则，通过类型名字的字母顺序进行比较。
如果有一个列表首先到达末尾，则另一个长一点的列表”大”。
5、列表复制
浅复制：var2 = var1
深复制：var2 = var1[ : ]
五、元组
1、定义
元组与列表类似，元素不能修改；
元组使用小括号定义，只需要在括号中添加元素，并使用逗号隔开即可。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以通过下标进行访问，可以截取索引中的一段元素（切片）。
2、操作
元组元素不能修改，但可以重新向元组变量赋值，即重新定义整个元组；
可以对元组进行连接组合；
可以使用del语句来删除整个元组；
tup = ('physics', 'chemistry', 1997, 2000)
del tup
tup = (1,2,3)
var = (4,5,6)
tup = tup + var
六、字典
1、定义
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ，格式如下：
d = {key1 : value1, key2 : value2 }
键一般是唯一的，如果重复，后的一个键值对会替换前面的，值不需要唯一；
字典不考虑元素排列顺序，只考虑key=>value 映射关系；
dict = {
'a': 1,
'b': 2,
'b': '3'
}
# dict {'a': 1, 'b': '3'}
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
访问元素：dict[key]
2、操作元素
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加
del dict['Name'] #删除元素
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
print (dict)
del dict # 删除字典
输出结果：
dict['Age']: 8
dict['School']: RUNOOB
{'Age': 8, 'Class': 'First', 'School': 'RUNOOB'}
------------------
(program exited with code: 0)
3、元素列表
dict.keys()
在Python2里，keys()会返回一个列表，而在Python3中则会返回dict_keys()，它是键的迭代形式。
这种返回形式对于大型字典非常有用，因为它不需要时间和空间来创建返回的列表。
在Python3中，可以调用list()将dict_keys转换为列表类型。list(dict.keys())
dict.values()同理；
dict.values()可能含有重复值，可以调用set()将其转化为集合类型。set(dict.values())
