Python 数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。https://www.runoob.com/python3/python3-data-type.html 讲数据

类型的开篇第一行，个人觉得需要好好琢磨和理解。我个人的理解是Python的变量就类似于 C

的指针类型，指针本无类型，只是一个存放内存地址的空间，而Python的变量仅仅就是一个变

量，我把它看成是 name = &data 。只是具体怎样使用指针（指针指向的内存地址的内容），

由实际访问者决定；而Python的变量指向的类型，则由指向的内存标识，通过Python内部应该

是标识了这部分内存的类型，这算是面向对象和面向过程的区别吧，面向对象由对象本身提供

操作方法，面向过程则由使用者自己实现方法-扯得有点远了。

python 基本数据类型:

1.  数字类型

2.  字符串类型

3.  列表

4.  元组

5.  集合

6.  字典

其中

不可变类型(只读): 数字类型，字符串类型，元组类型 

可变类型(可读写): 列表类型，集合类型，字典类型

只读意思是变量指向的位置只读，而不是变量本身只读

通过id(变量名） 可以看到变量的地址

 

数字类型的使用与常用操作

数字类型变量的创建

test_number = 123.456

 

# 数字的类型转换函数

int(x)        #将x转换为一个整数

float(x)      #将x转换为一个浮点数

complex(x)    #将x转换为一个复数，实数部分为x,虚数部分为0

complex(x,y)  #将x和y转换到一个复数，实数部分为x,虚数部分为y

 

数字的数学计算函数，包含在模块 math中，有些函数需要import math,有些函数不需要

abs(x)        #返回 x 的绝对值

ceil(x)       #返回 x 的上入整数,比如 x 为 4.1 则返回5

cmp(x,y)      #Python3已废弃，使用(x>y)-(x<y) 替换

exp(x)        #返回 e 的 x 次幂 e^x，

fabs(x)       #返回 x 的绝对值，返回值为 浮点类型

floor(x)      #返回数字的下舍整数,比如 x 为 4.9 则返回4

log(x)        #返回 log(x,e) ,如 log(100,10)  返回 2

log10(x)      #

max(x1,x2...xn)   #返回给定参数的最大值

min(x1,x2...xn)   #返回给定参数的最小值

modf(x)       #返回x的整数部分与小数部分,测试了貌似不支持，待确认

pow(x,y)      #与c语言的pow 一样

round(x,[,n]) #返回x 的四舍五入值，如给出n值，表示摄入到小数点后的第n位

sqrt(x)       #返回x 的平方根

 

字符串类型使用与常用操作

字符串类型变量的创建

test_str = 'abcdefg'

 

#字符串函数

#字符串函数的调用方法:  

 

#将字符串的第一个字符转换成大写，并返回转换后的字符串,定义及使用如下:

定义: capitalize()        

tmpstr = 'i have a dream'

tmpstr.capitalize()

 

#将字符串扩展到 width 长度，并把原字符串置于中间，扩展的字符用fillchar 填充，

#定义及使用如下:

定义: center(width,fillchar)  

tmpstr.center(10,'*')   #没有任何变化，因为tmpstr 长度超过10，所以不需要扩展

tmpstr.center(30,'*')   #输出 '********i have a dream********' 

 

#返回指定字符串 str 在原字符串范围 beg - end 区间出现的次数,定义及使用如下:

定义: count(str,beg=0,end=len(string)) 

tmpstr.count('a')       #返回3

 

#把原字符串经过指定编码类型(encoding='xxx')后返回，其中原字符串类型为文件的默认

#编码类型（UTF-8类型) 的字符串，定义及使用如下:

定义: encode(encoding='UTF-8',errors='strict')    

tmpstr = '周杰伦'       #tmpstr 为 utf8编码的字符串

tmpgbk = tmpstr.encode(encoding='gbk')     #tmpgbk 为 tmpstr转换成gbk编码后的字符串

tmpgb2312 = tmpstr.encode(encoding='gb2312') #tmpstr转换成gb2312编码后返回

 

#通过参数encoding='UTF-8'告诉解码函数源字符串的编码类型为UTF-8类型，

#解码后，再编码成UTF-8返回；

定义: decode(encoding='UTF-8',errors='strict') 

#通过参数encoding='gb2312'告诉解码函数源字符串的编码类型为gb2312类型解码后，

#再编码成UTF-8返回,总之 decode 最后返回的字符串类型是文件的默认编码类型(UTF-8类型)

tmpstr.decode(encoding='gb2312',errors='strict) 

 

#检查区域string[beg,end]是否以suffix 结束,是返回true,否则返回false

endswith(suffix,beg=0,end=len(string))      

 

 #把字符串中的\t 字符用 空格代替，默认是8个空格

expandtabs(tabsize=8) 

 

#搜索区域string[beg,end]内是否包含字符串str,如果包含，则返回该

#str在string 的第一个字符的下标,否则返回-1

find(str,beg=0,end=len(string))             

 

#如果字符串至少包含一个字符，且所有的字符都是字母或数字则返回True,否则返回false

isalnum() 

isalpha()                #如果字符串至少包含一个字符，且所有的字符都是字母，则返回True

isdigit()/isnumeric() #如果字符串至少包含一个字符，且所有的字符都是数字，则返回True

islower(),isspace(),istitle(),isupper(),isdecimal()

len(string)              #返回字符串长度

 

#seq可以是列表，元组，集合，字典类型，把seq中的元素用原字符串

#串联成一个字符串，如下:

join(seq) 

seq = ['i','have','a','dream']

tmptest = '***'

tmptest.join(seq)

 

seq = {'0':'i','1':'have','2':'a','3':'dream'}

tmptest.join(seq)

 

#返回资格原字符串左/右对齐，并使用fillchar填充至长度width的新字符串(fillchar 填充

#在右/左边)，fillchar默认为空格

ljust(width[,fillchar]),rjust(width[,fillchar])     

 

tmptest ='i have a dream'

tmptest.ljust(30,'*')

 

lstrip(),rstrip(),strip() #删除字符串左边/右边/左右和右边的空格字符

 

#把原字符串按照 str 字符串分割成多个字符串,定义及使用如下:

split(str='',num=string.count(str)) 

tmptest = 'i have a dream'

tmptest.split(' ')      #则把tmptest分割成4个字符串的列表,返回值是列表类型

字符串的常用操作大概这些，可以解决大部分字符串处理的问题。

 

元组类型的使用与常用操作

创建元组变量

test_int_tuple = (1,3,2,5,4)

test_str_tuple = ('a','c','d','b','x','e')

test_merge_tuple = test_int_tuple + test_str_tuple

len(test_int_tuple)          #获取元组的元素个数

max(test_int_tuple)        #输出元组中元素的最大值，其中，只有同种元素才能输出，否则调用出错

min(test_int_tuple)         #输出元组中元素的最小值，。。。。。

注意，元组的元素不能修改，元组本身也不能修改，比如:

test_int_tuple[0] = test_int_tuple[1]            #这样是错误的

 

列表类型的使用与常用操作

创建列表变量

test_int_list = [1,2,3,4,5]

test_str_list = ['a','d','c','b']

test_merge_list = test_int_list + test_str_list,

其中，len(),min(),max() 方法与元组一样

另外列表增加了一些成员函数:

test_int_list.append(6)          #test_int_list 增加一个值为数字6的元素

test_str_list.append(6)          #test_str_list 增加一个值为数字6的元素

test_int_list.count(3)             #统计数字3 在列表中出现的次数

test_int_list.extend(test_int_tuple)    #把test_int_tuple 的元素组个添加到列表中,

test_int_list.index(3)   #从列表中找出某个值第一个匹配项的索引位置

test_int_list.insert(0,3)   #把元素3插入到列表中索引为0的位置处。

test_int_list.pop(index=-1) #移除列表的下标为index 的元素，默认index = -1

test_int_list.remove(3)   #移除列表中某个值的第一个匹配项

test_int_list.reverse()   #反向列表中元素

#key是一个函数，接受每个元素的输入，然后输出，reverse表示排序是否正向还是方向

test_int_list.sort(key=None,reverse = False)

test_int_list.clear()            #清空列表

test_int_list.copy()            #复制列表

 

字典类型： 字典可以看做是一个(键，值）对的列表，其中键的类型必须是不可变的，

字典内的每个键都是唯一的，值则不需要。

字典类型的使用与常用操作

创建字典变量

test_dict = {'a':333,'b':'zydk',0:232,1:332}

test_dict_empty = {}

test_dict['a' ] = 111 #修改字典中键为'a'的值为111

del test_dict['a']     #删除字典中的键值对

del test_dict   #删除字典

len(test_dict)    #返回字典中键值对的个数

str(test_dict)     #已字符串的形式返回字典

 

test_dict.clear()  #删除test_dict字典中的所有元素

test_dict.copy()  #返回test_dict 字典的浅层拷贝（第一层目录，第二层还是引用,可以说第一层如果是列表或者）

import copy

copy.deepcopy(test_dict) # 完全拷贝了父对象及其子对象