python3编程基础之一：量的表示

　　计算机的操作最终表现是数据的操纵，为了表示和存储数据，都需要对数据进行引用，计算机可以直接从内存地址实现一步访问数据，但是编程的人却没有这种能力。就像人可能够不到在高处的氢气球，但是可以拉动邦在氢气球上的绳子，通过绳子最终实现拿到氢气球。也就是说在计算机中，每个数据都像氢气球一样具有左值，表明数据所在的地址和右值表明数据的具体内容，这就是变量的诞生记。程序员通过变量及变量的多种变化形式实现对内存数据的应用。编程语言中的变量都有自己的特征，例如：数据范围、占用内存的大小、数据在内存中的组织方式，甚至变量支持的操作等。

　　变量中的数据是可以根据需要变化的，变量中数据可以被读出，变量中可以写入新的数据。变量主要有：数字类型、字符串类型、列表类型、元组类型和字典类型。

1、数字类型：包括整数类型的简称整型和浮点类型的简称浮点型

　　整型变量中只能存储整数，没有小数点的数据；

　　浮点型可以存储包括小数点的数据，浮点型数据可以具有取整的操作，例如有如下定义

　　num1 = 10

　　num2 = 10.3

　　print(num1,  num2)或者print(num1, ' , ', num2)

　　printf(float(num1), int(num2))

2、字符串类型，就是一串字符，python中规定被一对单引号'或双引号"包括的字符集就是字符串，如果字符串中包括单引号，就必须将字符串用双引号包括

　　例如有如下定义：

　　name='zhang sanfeng'

　　age = 78

　　print(name, age)

　　结果：

　　zhang sanfeng 78

3、列表类型：

　　1）、一系列按照顺序排列的元素组成了列表，列表中可以包含字符、数字、字符串、甚至子列表

　　2）、和其他语言中的数组不同的是，列表中的数据类型可以不一样

　　3）、列表中的长度可以被修改

　　4）、列表中的元素也可以被修改

　　5）、python中列表用中括号表示[  ]

　　6）、列表支持读取、写入、删除、排序、获取长度、统计、获取最大/最小值、清空、复制、赋值、截取、遍历和拼接等操作

　　例如有如下定义：

　　list1 = [ ] 　　　　　　　　　　　　　　　　　　//空列表
　　list2 = [2, 3, 5, 7]  　　　　　　　　　　　　　　//数字型列表
　　list = ['a', 'b', 'c']
　　　　　　　　　　　　　　   //字符串型列表
　　list = [1, 4, 2, 'a', [2, 3, 4]]　　　　　　　　　　  //包括数字型数据、字符串型数据和列表型数据

　　mylist = [2, 3, 5, 7, 11, 13, 17, 19, 'integer', 'string', 'list', [123, 456]] 　　　　　　　　//这是我们操作的目标

　　列表的读取：获取列表中的元素方法：列表名[索引编号]，索引从0开始编号，最大值为size - 1，点运算完成获取索引对应的值

　　print(mylist[11][0] / mylist[1])  　　　　　　　　　　//获取mylist[11]的索引为11的元素，该元素是个列表，继续[0]表示列表中的第0个元素值，其实就是123

　　结果：41.0

　　print(mylist[8] + ' ' + mylist[9] )    　　　　　　　　   //+完成字符创的拼接

　　结果：integer string

　　列表的写入：修改mylist列表
　　mylist = [2, 3, 5, 7, 11]

　　print(mylist)

　　结果：[2, 3, 5, 7, 11]

　　或者：mylist[4] = 9
　　print(mylist)

　　结果：[2, 3, 5, 7, 9] 　　　　　　　　　　　　　　//列表中的元素可以随时被改变，元素的个数也可以被改变

　　列表添加元素：用append在列表末尾添加元素，用insert在制定位置添加新元素

　　有定义：mylist = [2, 3, 5, 7, 13, 17, 19]
　　用append添加元素：mylist.append(23)

　　输出列表：print(mylist)

　　结果：[2, 3, 5, 7, 13, 17, 19, 23]
　　
　　mylist.insert(4, 11)
　　输出列表：print(mylist)        
　　结果：[2, 3, 5, 7, 11, 13, 17, 19, 23]
　　列表删除元素：用remove删除指定值的元素，pop删除指定位置的元素，返回删除的元素值

　　mylist.remove(2) 　　　　　　　　　　　　　　//删除列表中第一个指定为2的元素
　　print(mylist)

　　结果：[3, 5, 7, 11, 13, 17, 19, 23]

　　mylist.pop(3)
　　　　　　　　　　　　　　　　//删除指定位置的元素，并返回删除元素的值
　　返回结果：11

　　print(mylist)

　　输出列表：[3, 5, 7, 13, 17, 19, 23]

　　del mylist[2] 　　　　　　　　　　　　　　　　//无返回的删除列表中指定索引的元素
　　print(mylist)

　　[3, 5, 13, 17, 19, 23]　

　　列表的排序：用sort函数排序，列表中的数据永久有序，reverse是倒序排序　
　　如有定义：names = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
　　输入列表内容：print(names)  　　　　　　　　　　//无序输出
　　结果：['zhangsan', 'lisi', 'wangwu', 'zhaoliu']

　　names.sort()
　　　　　　　　　　　　　　　　　　//正序排序
　　排序后的结果输出：print(names)

　　['lisi', 'wangwu', 'zhangsan', 'zhaoliu']
　　　　　　//已经有序了，而且是按照字母升降的顺序排序
　　names.re   tab　　　　　　　　　　　　　　　　//可以借助与tab的自动补全实现简化输入
　　names.remove(   names.reverse(   
　　倒序排序：names.reverse()

　　排序后的结果输出：print(names)

　　结果：['zhaoliu', 'zhangsan', 'wangwu', 'lisi']　　　//倒序后的结果，按照字母顺序

　　获取列表的长度：用len完成获取列表长度

　　print(len(names)) 　　　　　　　　　　　　　　//获取列表的长度，将列表作为参数传给len即可
　　列表长度：4

　　获取列表的最值：用max和min函数即可

　　print(max(names), min(names)) 　　　　　　　　//获取列表中最大值，最小值
　　返回结果：zhaoliu lisi 　　　　　　　　　　　　//最大值zhaoliu   最小值：lisi

　　获取列表的统计信息：用count函数即可

　　有定义：mylist = [2, 3, 5, 29, 13, 17, 19, 2, 2, 3]
　　获取2,3,29,99的统计信息：print(mylist.count(2), mylist.count(3), mylist.count(29), mylist.count(99))
　　　　//列表名.count(num)
　　结果：3 2 1 0
　　也可以：print(mylist.count(2), mylist.count(mylist[1]), mylist.count(29), mylist.count(99))
　　　　　　　　//元素不在，返回0
　　结果：3 2 1 0

　　获取指定值的列表（第一）索引：用index函数即可

　　print(mylist.index(19)) 　　　　　　　　　　　　　　//获取值为19的索引的值
　　返回结果：6　　　　　　　　　　　　　　　　　　//索引值从0开始

　　列表清空：用clear函数即可

　　mylist.clear() 　　　　　　　　　　　　　　　　　　//清空列表
　　输出清空后列表的元素：print(mylist)

　　结果：[ ]　　　　　　　　　　　　　　　　　　　　//列表已经为空

　　列表的复制：用直接赋值是浅复制，两个实际还是一个列表，用copy函数完成深复制，真正是独立的复制情况
　　src = [1, 3, 5, 7, 9, 11, 13] 　　　　　　　　　　　　//定义列表src
　　des = src
　　　　　　　　　　　　　　　　　　　//通过赋值符号复制列表，将src赋值并复制到des
　　print(src)
　　　　　　　　　　　　　　　　　　　//输出src列表
　　[1, 3, 5, 7, 9, 11, 13]
　　　　　　　　　　　　　　//内容没问题
　　print(des)
　　　　　　　　　　　　　　　　　　  //输出des列表
　　[1, 3, 5, 7, 9, 11, 13]
　　　　　　　　　　　　　　//内容没问题
　　des.pop()
　　　　　　　　　　　　　　　　　　  //删除des列表中最后一个元素
　　13  　　　　　　　　　　　　　　　　　　　　　//返回值13,表示将最后一个元素删除
　　print(src, des)  　　　　　　　　　　　　　　　　//输出src和des
　　[1, 3, 5, 7, 9, 11] [1, 3, 5, 7, 9, 11]　　　　　　　　//结果是src和des中两个列表中的13都被删除了

　　如果需要完全独立的复制，则须采用深复制：

　　src = [1, 3, 5, 7, 9, 11, 14] 　　　　　　　　　　　　//定义列表src
　　print(src) 　　　　　　　　　　　　　　　　　　　//输出src列表
　　[1, 3, 5, 7, 9, 11, 14] 　　　　　　　　　　　　　　//内容没问题
　　des = src.copy() 　　　　　　　  　　　　　　　　//通过函数复制列表，将src复制到des

　　print(src, des)  　　　　　　　　　　　　　　　　//输出src和des

　　[1, 3, 5, 7, 9, 11， 14] [1, 3, 5, 7, 9, 11, 14]　  　　//结果是src和des中两个列表完全一样

　　des.pop() 　　　　　　　　　　　　　　　　　　  //删除des列表中最后一个元素
　　14 　　　　　　　　　　　　　　　　　　　　　//返回值13,表示将最后一个元素删除
　　print(src, des)  　　　　　　　　　　　　　　　　//输出src和des
　　[1, 3, 5, 7, 9, 11, 14] [1, 3, 5, 7, 9, 11]　　　　　　//结果是src的14还在，而des中中的14都被删除了

　　列表的拼接：用+符号即可　　　　　　　　　　//可以先截取再拼接

　　print(src + des) 　　　　　　　　　　　　　　//将src和des拼接
　　[1, 3, 5, 7, 9, 11, 14, 1, 3, 5, 7, 9, 11]　

　　列表的截取：用：符号即可

　　print(src[1:], src[1:5], src[1:5:2]) 　　　　　　　　//截取是有多种表示方式，是开始位置：结束位置：索引距离
　　[3, 5, 7, 9, 11, 14] [3, 5, 7, 9] [3, 7]　　　　　　　//开始位置省略从0开始  结束位置缺失到最后一个索引，索引距离缺失表示间隔为1

4、元组类型：与列表很相似，但是元素中的元素不能更改，元组大小是固定的，用小括号表示元组，元组可以被重复赋值
　　元组支持的操作比列表少一些，有如下定义：

　　mytuple = (3, 5, 7, 9, 11, 13, 'a')

　　mytuple.count(3) 　　　　　　　　　　　　　　//统计3在元组中出现的次数
　　结果：1　　　　　　　　　　　　　　　　　　//结果为1次

　　mytuple.index('a') 　　　　　　　　　　　　　　//获取值为‘a’的索引
　　结果：6　　　　　　　　　　　　　　　　　　//结果为6

　　mytuple = (1, 2, 3, 4, 5, 6) 　　　　　　　　　　//元组内容不能该，可以被二次赋值
　　print(mytuple)
　　　　　　　　　　　　　　　　//输出元组内容
　　结果：(1, 2, 3, 4, 5, 6)　

　   print(mytuple * 2) 　　　　　　　　　　　　　　//两个元组进行合并了，单个元组内容不改变
　　结果：(1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6)

　　print(mytuple)
　　　　　　　　　　　　　　　　//单个元组内容还是一样的
　　结果：(1, 2, 3, 4, 5, 6)
　　print(mytuple[1:3]) 　　　　　　　　　　　　　　//元组的切片
　　结果：(2, 3)

　　print(mytuple[1:6:2])
　　　　　　　　　　　　　　//元组中指定幅度的切片
　　结果：(2, 4, 6)

　　mytuple1 = (1, 99, 88, 77)　　　　　　　　　　   //定义新的元组

　　print(mytuple1 + mytuple)
　　结果：(1, 99, 88, 77, 1, 2, 3, 4, 5, 6)　　　　　　//实现元组的合并

　　其实字符串就是只能存储字符的元组，同样无法修改，但是可以统计，返回索引，切片、合并等操作。

5、字典类型

　　1）、定义字典时使用大括号

　　2）、字典中的元素较键值对

　　3）、键值对用x:y的形式表示，x表示键值（关键字），y为元素的值，键在字典中必须唯一且不可改变，不同键值对应的值可以相同

　　4）、字典应用时，必须指定键值，返回元素值

　　例如有如下定义：

　　letters = {1:'a', 2:'b', 3:'c', 4:'d', 'a':123} 　　　　　　　　　　　　//定义字典类型的数据letters
　　print(letters)
　　　　　　　　　　　　　　　　　　　　　　　　//输出字典letters内容
　　结果：{1: 'a', 2: 'b', 3: 'c', 4: 'd', 'a': 123}

　　print(letters[2], letters[4], letters['a'])
　　　　　　　　　　　　//根据键找到值
　　结果：b d 123

　　print(letters[2], letters[4], letters["a"])
　　　　　　　　　　　　//字符串用单引号和双引号是一样的
　　结果：b d 123　　

　　letters[5] = 'e'　　　　　　　　　　　　　　　　　　　　　　//为字典letters添加元素，直接指定键和值即可

　　print(letters) 　　　　　　　　　　　　　　　　　　　　　　
　　结果：{1: 'a', 2: 'b', 3: 'c', 4: 'd', 'a': 123, 5: 'e'}

　　letters['abc']=32
　　　　　　　　　　　　　　　　　　　　//为字典letters添加元素，直接指定键和值即可
　　print(letters)    
　　结果：{1: 'a', 2: 'b', 3: 'c', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}　　　//添加元素成功　　　
　　print(len(letters)) 　　　　　　　　　　　　　　　　　　　 //获取字典的长度
　　结果：7

　　del letters[2]
　　　　　　　　　　　　　　　　　　　　　//删除键为2的元素
　　测试字典：print(letters)

　　结果：{1: 'a', 3: 'c', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　赋值复制--浅复制：letters1 = letters

　　测试字典：print(letters1)

　　结果：{1: 'a', 3: 'c', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　删除键为3的值：del letters1[3]

　　测试字典：print(letters1)

　　结果：{1: 'a', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　测试字典：print(letters)  
　　结果：{1: 'a', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　复制函数复制--深复制：letters2 = letters.copy()
　　测试字典：print(letters2)

　　结果：{1: 'a', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　删除键为5的值：del letters1[5]

　　测试字典：print(letters)

　　结果：{1: 'a', 4: 'd', 'a': 123, 'abc': 32}

　　测试字典：print(letters1)

　　结果：{1: 'a', 4: 'd', 'a': 123, 'abc': 32}

　　测试字典：print(letters2)

　　结果：{1: 'a', 4: 'd', 'a': 123, 5: 'e', 'abc': 32}

　　字典还有很多函数：

　　letters.clear( )      letters.get( )        letters.pop(  )       letters.update( )
　　letters.copy(  )      letters.items(   )    letters.popitem(     letters.values( )
　　letters.fromkeys(  )  letters.keys(   )     letters.setdefault(  )