Python学习笔记一：01数值类型以及数据类型

一、Python课程简介

  Python, 是一种面向对象的解释型计算机程序设计语言，由荷兰人Guido van Rossum于1989年发明，第一个公开发行版发行于1991年。
  Python是纯粹的自由软件， 源代码和解释器CPython遵循 GPL(GNU General Public License)协议。Python语法简洁清晰，特色之一是强制用空白符(white space)作为语句缩进。
  Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块(尤其是C/C++)很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型(有时甚至是程序的最终界面)，然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。
设计者开发时总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。
  Python的作者有意的设计限制性很强的语法，使得不好的编程习惯(例如if语句的下一行不向右缩进)都不能通过编译。其中很重要的一项就是Python的缩进规则。

• Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
• Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
• Python 是一种解释型语言(边解释边执行)： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
    如果对语言进行分类，那么python是一门强类型，动态类型的语言(弱类型：比如int可以变成float，python中数值类型不可变；动态类型：编译时不知道变量类型，python中变量无类型)。

二、数值类型

  数值类型就是我们平常用来做计算的数字类型，在python中有如下几种数值类型：
  Python3 中有六个标准的数据类型：

• Number(数字)
• String(字符串)
• List(列表)
• Tuple(元组)
• Sets(集合)
• Dictionary(字典)

1. Number(数字)

  Python3 支持 int(整型)、float(浮点型)、bool(布尔型)、complex(复数)。
  在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。像大多数语言一样，数值类型的赋值和计算都是很直观的。
  内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

  此外还可以用 isinstance 来判断：

>>>a = 111
>>> isinstance(a, int)		# returns True

  isinstance 和 type 的区别在于：

class A:
	pass

class B(A):
	pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是:
  type()不会认为子类是一种父类类型。
  isinstance()会认为子类是一种父类类型。

(1) int整型

>>> type(1)　　#b查看类型  int整型 结果为 <class 'int'>
>>> a=1
>>> type(a)

(2) float浮点型

  浮点型由整数部分和小数部分组成，也可以使用科学计数法表示

>>> type(1.1)　　#查看类型  int整型 结果为 <class 'float'>
>>> a=1.1
>>> type(a)
>>> a-1　　#0.10000000000009
>>> import decimal　　#十进制的浮点型
>>> d=decimal.Decimal('1.1')
>>> a=1
>>> d-a　　#0.1

(3) 布尔型

>>> c=True　　 #bool 值为1 橙色为关键字 得大写
>>> type(c)
>>> c2=False 　　 #值为0 可以数字相加
>>> type(c2)

(4) 复数型

  可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

>>> e=1+2j 　　#只能用j或者J表示虚部
>>> type(e)　　 #complex型

  Python没有专门表示虚数的类型，而将虚数视为实部为零的复数。

2. 补充：

(1) 基本数据类型

  Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建，因为python变量没有默认值。
  在 Python 中，变量就是变量，它没有类型，我们所说的＂类型＂是变量所指的内存中对象的类型。
  等号(=)用来给变量赋值。
  等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

(2) 多个变量赋值

  Python允许你同时为多个变量赋值。例如：

>>> a = b = c = 1　　#创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

  您也可以为多个对象指定多个变量。例如：

>>> a, b, c = 1, 2, ＂runoob＂　　#两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 ＂runoob＂ 分配给变量 c。
>>> a=1;b=2　　#两个整型对象1和2的分配给a和b

(3) 查看属性方法

>>> dir(__builtins__) #查看属性方法

(4) 查看所有关键字

①>>> import keyword 　　#导入关键字模块
  >>> keyword.kwlist 　　#调用属性
②>>> help('keywords')     #基础阶段重要的内置函数 查看关键字

(5) 保存及运行文件

①IDLE中file→new file
　　file→save(ctrl+s) 在弹窗中选择路径和填写文件名
②Run→Run Moudle(F5) 即可在IDLE中运行

(6) 默认颜色说明

  紫色为内置函数，例如

dir,print,type,int,list,tuple,print

  橙色为关键字，例如

True

(7) 使用del语句删除一些对象引用

  可以通过使用del语句删除单个或多个对象。例如：

>>> del var
>>> del var_a,var_b

3. 数值运算

(1) 运算符

python支持以下七种运算符：

1. 算术运算符
2. 比较(关系)运算符
3. 赋值运算符
4. 逻辑运算符
5. 位运算符
6. 成员运算符
7. 身份运算符

① 算术运算符

  + 　　-　　 * 　　/(数值的除法的结果是浮点数)　　//(整除，向下取整，地板除法)　　%(取余)　　x**y(返回x的y次幂)

>>> q=5;w=2
>>> q//w #2 向下取整
>>> q/w #2.5
>>> a,b=9.0,2.0
>>> a//b=4.0
>>> import math　　#导入数学模块
>>> math.ceil(5/2) #3 向上取整
>>> dir(math)　　#查看math的方法
>>> 5%2 #取余运算 为1
>>> 2**4 #幂运算 2的4次方为16

② 比较运算符

  假设变量a为10，b为20

==	等于	(a==b)返回False
！=	不等于	(a!=b)返回Ture
>	大于	(a>b)返回False
<	小于	(a<b)返回Ture
>=	大于等于	(a>=b)返回False
<=	小于等于	(a<=b)返回Ture

  注意：python中支持连续比较，本质：通过编译器将连续比较拆分成多个比较

③ 赋值运算符

=　　+=　　-=　　*=　　/=　　%=　　**=　　//=

>>> a+=1　　#等价于a=a+1

  在混合计算时，Python会把整型转换成为浮点数。

④ 位运算符

  位运算符是把数字看作二进制进行计算的。
  假设a为60，b为13
  a:0011 1100　　b:0000 1101

• & 按位与运算符：若参与运算的两个值的两个相应位都为1，则该位的结果为1，否则为0 (a&b)输出结果12，二进制解释：0000 1100
• | 按位或运算符：只要对应的两个二进制位有一个为1，结果位就为1 (a|b)输出结果60，二进制解释：0011 1101
• ^ 按位异或运算符：当两个对应的二进制位相异时，结果为1 (a^b)输出结果49，二进制解释：0011 0001
• ~ 按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1 (a~b)输出结果-61，二进制解释：1100 0011
• << 左移动运算符：运算数的各个二进制位全部左移若干位，由<<<右边的数指定移动的位数，高位丢弃，低位补0 (a<<2)输出结果240，二进制解释：1111 0000
• > > 右移动运算符：运算数的各个二进制位全部右移若干位，由<<<右边的数指定移动的位数 (a>>2)输出结果15，二进制解释：0000 1111

⑤ 逻辑运算符

  假设a为10，b为20

• and 布尔＂与＂：如果x为False，x and y就返回False，否则返回y的计算值

(a and b)    返回20

• or 布尔＂或＂：如果是非0，就返回x的值，否则返回y的计算值

(a or b)返回10

• not 布尔＂非＂：如果x为True，就返回False，如果x为False，就返回True

not(a and b)    返回False

⑥ 成员运算符

  假设a为10，list=[1,2,3,4,5]

• in 如果在指定的序列中找到值，就返回True，否则返回False

print(a in list)    返回False

• not in 如果在指定的序列中没有找到值，就返回True，否则就返回False

print(a not in list)    返回True

⑦ 身份运算符

  假设a为10，b为10

• is is判断两个标识符是否引用自同一个对象 print(a is b)返回True
• not is is not 用来判断两个标识符是否引用自不同对象

print(a not is b)    返回False

(2) 运算符优先级

  表中列出了从最高到最低优先级的所有运算符

运算符	描述
**	指数(最高级)
~、+、-	按位翻转、一元加号和减号
*、/、%、//	乘、除、取模、取整除
+、-	加法、减法
>>、<<	右移、左移运算符
&	位与
^、	位运算符
<=、<、>、>=	比较运算符
<>、==、!=	等于运算符
=、&=、/=、//=、-=、+=、*=、**=	赋值运算符
Is、is not	身份运算符
In、not in	成员运算符
not、or、and	逻辑运算符

  计算顺序：默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。然而，如果你想要改变它们的计算顺序，你得使用圆括号。
注意：

1. 括号拥有最高优先级，可以强制表达式按照需要的顺序求值
2. 乘方拥有次高的优先级
3. 优先级相同的操作按照自左向右的顺序求值(乘方除外)

4. 序列类型

  数据结构是以某种方式(如通过编号)组合起来的数据元素(如数、字符乃至其他数据结构)集合。在Python中，最基本的数据结构为序列。
  Python包含6种内建序列,即列表、元组、字符串、Unicode字符串、buffer字符串、xrange对象

• 字符串　　str
• 列表　　list
• 元组　　tuple
  其中：
• 可变序列　　list
• 不可变序列　　tuple,str
    Python支持一种数据结构的概念，名为容器。容器基本上就是可包含其他对象的对象。两种主要的容器是序列(如列表和元组)和映射(如字典)。在序列中，每个元素都有编号，而在映射中，每个元素都有名称(也叫键)。有一种既不是序列也不是映射的容器，它就是集合。

(1) 字符串–string

① 单引号字符串

  Python中的字符串用单引号(’)或双引号(＂)括起来，同时使用反斜杠()转义特殊字符。

>>> s1='asljf123'     #'asljf123'
>>> s2='asljf' '123'  #'asljf123'

② 对引号转义

>>> s3=＂Hello,World!＂	#'Hello,World'

  在这个示例中，我们使用双引号将其括起和单引号有差别么？

>>>s4='Hello,World!'	#'Hello,World'

  其实，结果完全相同。为何同时支持单引号和双引号呢？

>>> s5=＂asd:'adffw'＂ 	#＂asd:'adffw'＂  引用某人说的话
>>> '＂Hello!＂she said'	#'＂Hello!＂she said'

  第一个字符串包含一个单引号，因此不能用单引号将整个字符串括起，否则解释器将报错。
  第二个字符串包含双引号，因此必须使用单引号将整个字符串括起。
也可以使用反斜杠()对引号进行转义。

>>> 'Let\'s go!'	#＂Let's go!＂

  这样Python将明白中间的引号是字符串的一部分，而不是字符串结束的标志。

>>> s6='''aaa　　　　	#可以跨行
>>> ggg'''　　　　#'aaa\ngggg'

③ 拼接字符串

>>> s2='asljf' '123'  #'asljf123'

  Python自动将它们拼接起来了。仅当你同时一次输入两个字符串时，这种机制才管用。
加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。

>>> str = 'Runoob'
>>> print (str * 2) # 输出字符串两次  RunoobRunoob
>>> print (str + ＂TEST＂) # 连接字符串  RunoobTEST

④ 字符串标识str和repr

  Python打印所有的字符串时，都用引号将其括起。这是因为Python打印值时，保留其在代码中的样子，而不是你希望用户看到的样子。但如果用print，结果将不同。

>>> ＂Hello,\nworld!＂	#'Hello,\nworld!'
>>> print(＂Hello,\nworld!＂)	
#'Hello,
world!'

  通过两种不同的机制将值转换成了字符串。你可通过使用函数str和repr直接使用这两种机制。使用str能以合理的方式将值转换为用户能够看懂的字符串。

>>> print(repr(＂Hello,\nworld!＂))		#'Hello,\nworld!'
>>> print(str(＂Hello,\nworld!＂))	
#'Hello,
world!'

⑤ 长字符串

  要表示很长的字符串(跨越多行的字符串)，可使用三引号。

>>> print('''This is a very long string.
It continues here.''')

  还可以使用三个双引号。请注意，这让解释器能够识别表示字符串开始和结束位置的引号，因此字符串本身可包含单引号和双引号，无需使用反斜杠进行转义。
  注意：常规字符串也可跨越多行。只要在行尾加上反斜杠，反斜杠和换行符将被转义。

>>> 1+2+\
+4+5

⑥ 原始字符串

  Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r或者添加一个\，表示原始字符串。

>>> print('Ru\noob')  #Ru   此处有换行     oob
>>> print('Ru\\noob')　　#Ru\noob
>>> print(r'Ru\noob')  #Ru\noob

  一个例外是，引号需要像通常那样进行转义，但这意味着用于执行转义的反斜杠也将包含在最终的字符串中。

>>> print(r(Let\'s go!'))		#Let\'s go

  另外，原始字符串不能以单个反斜杠结尾。

>>> print(r'C:\Program Files\foo\bar''\\')

  注意：Python 没有单独的字符类型即没有char，一个字符就是长度为1的字符串。
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0]='m’会导致错误。

(2) 列表–list

  列表的内容是可变的，即可修改其内容。

① 创建

  List(列表) 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号([])之间、用逗号分隔开的元素列表。列表中的元素类型也可以不相同。

>>> list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
>>> li=['a','b']  #list 写在方括号之间，元素用逗号隔开

② 操作

  与Python字符串，元组不一样的是，列表中的元素是可以改变的：

a. 修改列表：给元素赋值

  使用索引表示法给特定位置的元素赋值。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9　　　　#变为了a=[9,2,3,4,5,6]
>>> a[2:5] = []   # 将对应的元素值设置为 []  变为了[9, 2, 6]　　

  可以对一个列表中的元素赋不同类型的值。列表a中既有int类型的值，也有str 类型的值。

>>> a[1] = 'hello' 　#[1, 'hello', 3, 4, 5, 6]

  不能对一个不存在元素的位置赋值，因此如果列表的长度为2，就不能给索引为100 的元素赋值。

>>> a[7]=2		#IndexError: list assignment index out of range

  如果要赋值，可以用乘法来先进行初始化操作。

>>> b = [None]*5
>>> b = a + b	# [1, 2, 3, 4, 5, 6, None, None, None, None, None]
>>> b[7] = 2 	# [1, 2, 3, 4, 5, 6, None, 2, None, None, None]

b. 增加元素

  append()方法是一个用于在列表末尾添加新对象的方法。该方法的语法如下：

list.append(obj)

  append()方法不是简单地返回一个修改过的新列表，而是直接修改原来的列表。

>>> a.append('ww')　　#a = [1, 2, 3, 4, 5, 6,'ww']

  由示例可以得知：可以往数字序列中添加字符串，也可以往字符串序列中添加数字。

c. 删除元素

可以使用del删除元素

>>> del a[1]　　　　#a = [1, 3, 4, 5, 6,'ww']
>>> len(a) 	#6

d. 给切片赋值

  切片赋值是列表一个强大的特性。

>>> show=list('hi,boy')
>>> show[3:]=list('man')　　#['h', 'i', ',', 'm', 'a', 'n']

  这里运用了list()强制类型转换,将字符串转换为列表。List()函数的一个功能就 是根据字符串创建列表，并且所有类型都适用。这里可以同时给多个元素赋值。

>>> greeting=list('hi')
>>> greeting=list[1:]=list('hello')　　#['h','e','l','l','o']

  可将切片替换为长度与其不同的序列。

>>> field=list('ae')
>>> field[1:1]=list('bcd')　　#['a', 'b', 'c', 'd', 'e']

  可以在不替换任何原有元素的情况下在任意位置插入新元素。在这里，替换了一个 空切片，相当于插入了一个序列。你可以采取相反的措施来删除切片。

>>> field1=list('abcde')
>>> field1[1:4]=[]　　　　#['a','e']

  使用了前面插入操作的逆操作，可以对序列中任意位置的元素进行删除。上述代码 与del field1[1:4]等效。

f. 嵌套列表

>>> field2=['a','b','c']
>>> num=[1,2,3]
>>> mix=[field2,num] 	#[['a','b','c'], [1,2,3]]
>>> mix[0]　　#['a','b','c']
>>> mix[0][0]　　#'a'

  在列表中可以嵌套列表，嵌套的列表取出后还是列表。

(3) 元组–tuple

  与列表一样，元组也是序列，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。元组中的元素类型也可以不相同。
  因为元组不可变，所以代码更安全，如果可能，能用元组代替列表就尽量用元组

① 创建

  元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

>>> tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
>>> tu=1,2,3 　　 #也是元组
>>> tu=(1,2,3) 　　#tuple

  元组还可用圆括号括起(这也是通常采用的做法)

>>> tup1 = ()    

  空元组用两个不包含任何内容的圆括号表示

>>> (1)　　 #变为整型了 1
>>> 42，		#(42,)　　 

  包含一个值的元组的实现方式有一些奇特，必须在括号中的元素后面加一个逗号。

>>> tuple([1,2,3])	#(1,2,3)
>>> tuple('abc')	#('a','b','c')
>>> tuple((1,2,3))	#(1,2,3)

  函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

② 操作

a. 访问元组

  使用下标索引访问

>>> mix = ('hello',1220)
>>> mix[0]	#('hello')
>>> mix[0:2]	#('hello',1220)

b. 修改元组

  元组中的元素值不允许修改，但可以对元组进行连接组合

>>> field = (112,333)
>>> tu = ('hello')
>>> field + tu	#(112,333, 'hello')

c. 删除元组

  元组中的元素值不允许删除，但可以使用del语句删除整个元组

>>> del field
>>> print(field)	#NameError: name 'field' is not defined

d. 元组截取

  用索引截取一段元素

>>> num = (1,2,3,4)
>>> num[1:]	#(2,3,4)

③ 为何要熟悉元组呢？

1. 它们用作映射中的键(以及集合的成员)，而列表不行。
2. 有些内置函数数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组打交道通常意味着像处理列表一样处理它们(需要使用元组没有的index和count等方法时例外)。

④ 指向不变

>>> t = ('a','b',['A','B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t	#('a','b',['X','Y'])

  表面上看，元组的元素确实变了，其实变的不是元组的元素，而是list列表的元素。元组一开始指向的list列表并没有改成别的list列表，所以元组的不变是指每个元素的指向永远不变，如指向’a’就不能改成指向’b’指向一个list就不能改成指向其它对象，但指向的list列表本身是可变的。

5. 序列的通用操作

  Python中所有序列都可以进行一些特定操作，包括索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中的长度、最小值和最大值。
  索引和步长都有正负之分

(1)索引

  序列中的每个元素都分配一个数字(即编号)，代表它在序列中的位置(索引)，第一个索引为0，第二个是1，以此类推，-1为末尾的开始位置。
  序列中可以通过编号分别对序列的元素进行访问。
  获取元素的方式为：在变量后加中括号[]，在中括号中输入所取元素的索引(编号值)。

>>> greeting='Hello'
>>> greeting[0]   #H
>>> greeting[1]   #e
>>> greeting[-1]  #o

  字符串是由字符组成的序列，索引0指向第一个元素。Python没有专门用于表示字符的类型，因此一个字符就是只包含一个元素的字符串。
  在Python中，从左向右索引称为正数索引，从右向左索引称为负数索引。
  对于字符串字面量(以及其他的序列字面量)，可直接对其执行索引操作，无需先将其赋给变量。

>>> 'Hello'[0]		#H

  如果函数调用返回一个序列，可直接对其执行索引操作。

>>> thirdt=input()[0]   

  索引既可以对变量的引用操作，也可以直接操作序列，还可以操作函数的返回序列。
  当索引超出范围时，Python会报一个IndexError错误，即索引越界错误。要确保索引不越界，记得最后一个元素的索引是len(str)-1。

(2) 切片

  索引用来对单个元素进行访问，使用切片可以对一定范围内的元素进行访问，切片通过冒号相隔的两个索引实现。
  序列的截取(序列被截取后返回一个包含所需元素的新序列。)的语法格式如下：
变量[头下标:尾下标]
  第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。

>>> li=['a','b','c','d','e']
>>> len(li)   #计算长度
>>> li[3]     #为'd'
>>> li[0:3]   #为['a', 'b', 'c'] 切片 左闭右开的　　

  分片操作既支持正数索引，也支持负数索引。　　
  分片操作的实现需要提供两个索引作为边界，第一个索引的元素包含在分片内，第二个索引的元素不包含在分片内，即左闭右开。

① 绝妙的简写

  假设要访问列表中的最后两个元素：

>>> number[3:5]　　   #['d','e']
>>> number[-100:-1]　　#[1, 2, 3, 4, 5, 6, 7, 8, 9]

  在这里，索引为5指的是第6个元素：它并不存在，但确实是到达最后一个元素后再前进一步所处的位置。
  分片操作不存在索引越界的问题，分片操作对不存在的编号返回空值，存在的就返回对应值。

>>> li[-3:0]   #[]

  执行切片操作时，如果第一个索引指定的元素位于第二个索引指定的元素后面(在这里，倒数第3个元素位于第1个元素后面)，结果就是一个空序列。

>>> li[2:]    #['c', 'd', 'e'] 输出从第三个元素开始的所有元素

  如果切片结束于序列末尾，可省略第二个索引。

>>> li[:2]     #['a','b']

  同样，如果切片始于序列开头，可省略第一个索引。

>>> li[:]

  要复制整个序列，可将两个索引都省略。

② 步长

  进行切片时，切片的开始和结束点都需要指定(无论是直接还是间接)，用这种方式取连续的元素没有问题，但若要取序列中不连续的元素就比较麻烦，或者直接不能操作。
  所以，Python提供了另一个参数–步长，该参数通常是隐式设置的。在普通切片中，步长是1，步长不能为0。切片操作就是按照这个步长逐个遍历序列的元素，因此切片包含起点和终点之间的所有元素。

>>> number=[1,2,3,4,5,6,7,8,9,10]
>>> number[0:10:2]　　#[1,3,5,7,9]  设置步长为2时，得到奇数序列，其中这个2就是步长的显示设置
>>> li[::]   #['a', 'b', 'c', 'd', 'e'] 第二个：后为步长 默认为1
>>> li[::2]  #['a', 'c', 'e'] 两个走一步　　

  使用负数步长，即从右向左提取元素。

>>> li[5:0:-1]  #['e', 'd', 'c', 'b']
>>> li[0:5:-1]  #[]  拿不到东西
>>> li[-1:-6:-1]  #['e', 'd', 'c', 'b', 'a']
>>> li[-3:-5:-1]  #['c', 'b']

  对于正数步长，Python会从序列的头部开始向右提取元素，直到最后一个元素；
  对于负数步长，则是从序列的尾部开始向左提取元素，直到第一个元素。
  正数步长必须让开始点小于结束点，而负数步长必须让开始点大于结束点。

>>> li[5:0:-1]  #['e', 'd', 'c', 'b']  #设置第二个索引为0，取不到序列中的第一个元素
>>> li[5::-1]  #['e', 'd', 'c', 'b', 'a']　　

  使用负数步长时，设置第二个索引为空才可以取到序列的第一个元素。

(3) 序列相加

  使用加号可以进行序列的连接操作。

>>> [1,2,4]+[4,5,6]　　#[1,2,4,4,5,6]
>>> 'sssdd'+'qqqeee'　　#'sssddqqqeee'
>>> [1]+ 'a'	#TypeError: can only concatenate list (not "str") to list

  只有类型相同的序列才能通过加号进行序列连接操作，不同类型的序列不能通过加号进行序列连接操作。

(4) 乘法

 将序列与数x相乘时，将重复这个序列x次来创建一个新序列。

>>> 'h'*5　　#'hhhhh'
>>> [1]*3　　#[1,1,1]

  如果要创建一个重复序列，就可以像上面的示例一样乘以一个想要得到的序列长度的数字，这样就可以快速得到需要的列表，非常方便。
  空列表是使用不包含任何内容的两个方括号([])表示的，表示里面什么东西都没有。如果创建一个占用10个或更多元素的空间，却不包括任何有用内容的列表，该怎么办呢？做法是使用[0]*10，浙江创建一个包含10个0的列表。
  如果要初始化一个长度为x的序列，就需要让每个编码位置上都是空值，此时需要一个值代表空值，即里面没有任何元素，可以使用None。None是Python的內建值，表示什么都没有。因此，要将列表的长度初始化成5，可以这样做。

>>> sq=[None]*5　　#[None, None, None, None, None]

  Python中的序列惩罚可以帮助我们快速做一些初始化操作。

(5) 成员资格

  要检查特定的值是否包含在序列中，可使用运算符in和not in。
  in运算符用于检验某个条件是否为真，并返回检验结果，满足时返回True，不满足时返回False。这种运算符称作布尔运算符，返回的值叫布尔值。

>>> li='lucky' 
>>> 'lucky' in li    #Ture 
>>> 'lucky' not in   #False
>>> number=[1,2,3,4,5]
>>> 'a' in number　　#False
>>> 3 in li         #TypeError: 'in <string>' requires string as left operand, not int

  数字类型不能在字符串类型中通过in进行成员资格检测，而字符串类型可以在数字列表中通过in进行成员资格检测。

>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject	#True

  检查字符串变量subject是否包含字符串’$$$’,这可用于垃圾邮件过滤器中。

(6) 长度、最小值和最大值

  对应的内建函数分别是len、max和min，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素。

>>> len(number)　　#5
>>> max(1,1,2,3,4)　　#4

  max和min函数的参数可以是多个数字直接作为参数。

(7) 数据类型的转换

  有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

>>> a=int(1.1) 　　#a为1
>>> list('abc') 　　#['a', 'b', 'c']

6. 变量命名规则

  变量命名由字母，数字，下划线组成。不能以数字开头。不能用关键字。

>>> import keyword
>>> keyword.kwlist
>>> ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 
　　'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

7. 编码来源

  由于计算机最早是美国人发明的，因此最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码
  要处理中文，显然一个字节是不够的，至少需要两个字节，而且不能和ASCII编码冲突，所以中国指定了GB2312编码，用来把中文编进去
  所以各国有各国的标准，Unicode把所有语言都统一到一套编码里，这样就不会有乱码问题了
  下面我们来看ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是两个字节
  新的问题又出现了，如果统一成Unicode编码，乱码问题从此消失了。但是写的文本基本上全部是英文时，用Unicode编码比ASCII编码多一倍存储空间，在存储和传输上十分不划算
  所以出现了把Unicode编码转化为＂可变长编码＂的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1_{6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4}6个字节
  UTF-8编码有一个额外的好处，就是ASCII编码实际上可以看成是UTF-8的一部分
  现在我们可以总结一下现在计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或需要传输时，可以转换为UTF-8编码
  python用的就是UTF-8的

8. 注释

  注释必须以＂#＂符号开始，在代码中，井号后面到行尾的所有内容都将被忽略。
  注释可以独占一行，也可以放在语句行的末尾。
  注释最重要的用途在于解释代码并不显而易见的特性