Python基础2—变量

一、数字

　　1、int 占32个字位4个字节，范围为-2^31~~~~2^31-1  定义

　　     定义方法：直接使用，如：num=2

　　2、long 长整数的大小与虚拟内存大小有关

　　　定义方法：直接使用，当整数超出int的范围时自动使用long

　　3、float 

　　　定义方法：直接使用，如：num=2.1

　　4、complex 复数

　　　定义方法：直接使用，如：num=2+3j（不能习惯性用i，否则会报错）

　　5、bool 布尔 非空非0为真，0或空为假

　　　定义方法：直接使用，如：judge=True（注意区分大小写，用true或者false会报错）

　　6、空值：None，空值与任何值比较永远都是False

二、字符

　　str（字符，python不分字符和字符串），但注意，字符不可变，如str4=’123456‘，则str4[2]=‘7’会报错，即字符一旦使用了只能重新赋值，不能通过索引改变其值

　　1、定义方法：直接使用，如：jstr1=‘hello’，python中使用字符时可以使用‘ ’和“ ”，两者语法上都是通过的，但如果字符变量中有其中一个，且又使用了其定义，可以使用转义字符

　　　  如 str2=“he say:"bye" and then leave” 定义和变量中都有双引号，因此定义时应该这样定义：“he say:\"bye\" and then leave”

　　2、索引：python索引可以从左到右，也可以从右到左，但注意的是，从左到右是从0开始，但从右到左是从-1开始，如str3=‘abcd’，则str3[2]表示c，str3[-1]表示d

　　3、切片：①str3[m:n]：取字符串从m到n（不取n，只取n-1），特殊情况：str3[:]：取整个字符，str3[0:]：从第0个取到最后一个

　　　　②str3[m:n:k]从m到n（同str3[m:n]，只取到n-1），每隔k个取一个（k包含所取的字符）如：str4=‘abcdefg’，则str4[0: :1]='abcdefg'，则str4[0: :2]='aceg'，k也课为负，负代表方向从右到左，如str4[0: :-1]='a'

三、列表（list）

　　①定义方法：用括号定义，mylist=[1,2，3，4，‘a’]

　　②列表中的元素的数据类型可以是不一样的，如mylist，有整数，又有字符，甚至列表中还可以有列表，有元组，可以多层嵌套使用|（多层嵌套时的索引用多个下标，如mylist2=[1,2，[1,2，3]]，则3的索引为mylist2[2]2[]）

　　③可变，可以用mylist[2]='b'，把mylist改成mylist=[1，2，'b'，4，‘a’]（列表的索引从0开始）

　　④获取列表长度：len（列表名），如：len（mylist），运行得到结果为：5

　　⑤访问列表元素：列表名[index] ，如：mylist[2]，运行得到结果为：b

　　⑥添加列表元素：列表名.append（新值），即可在列表尾部添加元素，如：mylist.append('c')

　　⑦插入元素：列表名.insert（index，新值），如：mylist.insert（2，3），则mylist变为：[1，2，3，'b'，4，‘a’]

　　⑧将一个列表的每个元素分别添加到另一个列表中：mylist_2=['k','p','l']，mylist.extens(mylist_2)，则mylist变为：[1，2，3，'b'，4，‘a’，'k'，'p'，‘l']

　　⑨合并列表：用'+'即可，如myli_3=mylist+mylist_2

　　⑩删除元素：del 列表名[index] 如：del mylist[8]，则[1，2，3，'b'，4，‘a’，'k'，'p']

　　⑾定位元素：列表名.index（vlaue），如：mylist.index（’1‘），得到的结果为0

　　⑿列表排序：列表名.sort（），如：mylist=[1，2，7，4，9，22]，mylist.sort（），即可对mylist进行升序排序（排序时列表的元素必须是同种类型，int和str不能进行排序）

　　　　　　　　列表名.reverse（），如mylist.reverse（），即可对mylist进行反序排序

　　　　　　　　若要对列表进行降序排序，可以先用sort方法然后再调用reverse方法即可

　　⒀产生一个树枝递增列表：range（start，end）start：起始元素，默认为0，取到这个元素；end截止元素，不取到这个元素

　　⒁遍历列表：

#for 语句和 range（）函数遍历列表
mylist_1=[1,2,3,'b',4,'a','k','p']
for i in range(len(mylist_1)):
    print(mylist_1[i])

#for语句和enumerate（）函数遍历元素索引和元素值
for index,value in enumerate(mylist_1):
    print('第%d个元素值是[%s]'%(index,value))
    
#遍历多维列表
mylist_2=[[1,2],[3,4,5]]
for index in range(len(mylist_2)):
    list1=mylist_2[index]
    for j in range(len(list1)):
        print(list1[j])

for index in range(len(mylist_2)):
    for j in range(len(mylist_2[index])):
        print(mylist_2[index][j])

　　⑮extend：原型：list.extend(seq)，用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

四、元组（tuple）

　　①定义方法：用括号定义，如：mytuple=（0,1,2）

　　②元组不可变，mytuple[0]=‘3’会报错

　　③元组可跟列表嵌套使用，但元组中的列表可变，列表中的元组不可变

　　④单个元素的元组回归元素类型，如mytuple=（1），则type（mytuple）的返回值为class‘int’，但mytuple=（1，）则type（mytuple）的返回值为class‘tuple’，mytuple=（）则type（mytuple）的返回值为class‘tuple’

　　⑤访问元组元素、获取长度、遍历元组均与列表一样

　　⑥排序：元组不可变，因此要对元组进行排序就必须将元组转换成列表，然后排序后再转换成元组

　　　　　　元组转换成列表：列表对象=list（元组对象）

　　　　　　列表转换成元组：列表对象=tuple（列表对象）　　

tuple_1=('apple','banana','pear','grape')
list_1=list(tuple_1)
list_1.sort();
tuple_1=tuple(list_1)
print(tuple_1)

五、字典（dict）

　　①定义方法：用大括号定义，如d1={‘name’：‘蔡昆杰’，‘age’：22，‘sex’：‘male’}

　　②字典的元素都有键（key）和值（value），可嵌套使用，如d2={’name‘:{'first'：’John‘，’last‘：'Lee’}，‘age’：30}，访问嵌套字典时同列表，用两个key即可，如d2['name']['first']

　　③打印、获取长度与列表相似

　　④访问元素：字典名[key]，如：d={'name':'coffee','price':10}，d['name']得到的结果为：coffee

　　⑤添加元素：字典名[key]=value；注意，如果key是字典原先已经有的，如：d['name']='tea'，则字典变为：{'name': 'tea', 'price': 10}

　　⑥合并字典：可用update（）函数，字典1.updat.（字典2），注意：如果字典2中有字典1中的键，则合并后的键值以字典2的为准，原理同⑤添加元素

　　⑦删除元素：字典名.pop（key），如：d.pop（'name'）

　　⑧判断元素是否在字典内：key in 字典名 ，返回的是bool值

　　⑨清空字典：字典名.clear（）

　　⑩遍历字典：可用for...in语句

d={'name':'coffee','price':10,'color':'gray'}
#用for...in遍历字典的键和值
for key in d.keys():
    print(key)#访问键
    print(d[key])#访问值
#遍历字典的值
for value in d.values():
    print(value)
#访问的是键还是值关键看是d.keys还是d.values

六、集合（set、frozenset）

　　①定义：使用set（）定义可变集合，如：s=set（‘python’）；用frozenset（）定义不可变集合，如s_2=frozenset（‘hello’），集合都是无序的

　　②可变集合是无序的，如print（s）得到的结果可能是：{'y', 'h', 't', 'o', 'p', 'n'}，也可能是：{'o', 'h', 'y', 't', 'p', 'n'}，有6！=720种可能；不可变集合也一样，但前面有frozenset，如：frozenset({'e', 'o', 'l', 'h'})

　　③获取长度：len（集合名），

　　④访问集合：集合无序，不能用索引访问，也不能用切片操作，只能用循环遍历集合元素

　　⑤元素增删：集合名.add（值）添加单个元素，集合名.update（值）添加多个元素；集合名.remove（值）删除元素，集合名.clear（）清空集合

s=set ([1,2,3])
print(s)
s.add(4)#s.add([4])和s.add([4,])会报错，会把内部的4当成一个列表
print(s)
s.update([4,5,6])
print(s)
s.remove(4)
print(s)
s.clear()

　　⑥判断元素是否存在集合：值 in 集合名，返回的值是bool

　　⑦遍历集合：可以用for...in遍历，如：for e in s：print（）

　　⑧子集超集：A中所有元素都是B的元素，则A是B的子集，B是A的超集

　　⑨集合的运算：Ⅰ并集：用 | 求并集，如：s=s1 | s2；或者用union（）函数，如：s=s1.（s2）

　　　　　　Ⅱ交集：&　，也可用 intersection（）函数　

　　　　　　Ⅲ差集：-（s=s1-s2，结果为s1除去s2中的元素），也可用difference（）函数　　

　　　　　　Ⅳ对称差分：︿（s=s1︿s2，s为s1和s2除去共有的元素剩下的元素的集） 也可用symmetric_difference（）函数

七、变量的共性

　　①变量不需要先定义，可直接赋值使用，至于数据的类型则取决于后面给变量所赋的值

　　②变量可重复存储不同的数据类型，如num=1，num=‘num’是可以的

　　③可同时为多个变量赋值

　　④变量名遵循C语言风格，可以由字母、数字、下划线组成，但不可以以数字开通，也不能使用下划线以外的符号

　　⑤变量不支持自增自减，如a++、a--是错误的，应写成a+=1，a-=1；++a和--a成立，但不是自增或者自减，前面的‘+’，’-‘只代表正负

　　⑥变量引用计数：把一个变量的值赋给另一个变量时，如a=1，b=a；则此时不会为b再开辟独立的值空间，只会把b的值的指针指向a的值空间，这导致在变量a和变量b是可变的时候变量b变的时候a也会变

　　　　#列表等可变变量的赋值要注意
　　　　list1=[1,2,3,4]
　　　　list2=[1,2,3,4]
　　　　#此时两个列表在内存中占的空间不同，任一改变不会影响另一个
　　　　list2=list1
　　　　#此时list2引用了list1的内存空间，任一改变会影响另一列表的值
　　　　list2=list1[:]
　　　　#只是切片复制，如果list1只是简单的数据，则list1改变，list2不改变
　　　　#但若list1里面有列表，则列表里面的列表改变，list2也改变
　　　　#完美拷贝
　　　　import copy
　　　　list2=copy.deepcopy(list1)

　　2018-04-14