python语言基本数据类型_python-基本数据类型

数据类型

1.数字

整型(int),python3没有长整型，统一为整型,并且没有限制大小

浮点型(float),python浮点型与C语言double的精度一样,能表示15-16位有效数字

2.布尔类型

True和False

3.字符串

1 myStr="CKZeng"　　#或:myStr='CKZeng' python单引号和双引号并没有什么区别

字符串的各种操作：下面所有操作并不会改变字符串自身，会返回调用方法后的值

myStr="CKZeng"

myStr.capitalize() #首字母改为大写并把其他字母改为小写

myStr.count("CK",bengin,end) #查询字符串指定的位置里有多少个"CK"，也可查单个字符，begin和end可省略

myStr.center(20,"=") #字符串总长度20，不够的在两边补"="

myStr.ljust(20,"=")　　　　　　 #右边补

myStr.rjust(20,"=")　　　　　 #左边补

myStr.encode() #编码,字符串转二进制

myStr.endswith("g") #字符串是否以某个子串或字符结尾，返回布尔值

myStr.find("C",bengin,end) #从bengin的位置开始往后找到第一个子串或字符的位置

myStr.rfind("C",bengin,end)#从(end-1)的位置开始往前找到第一个子串或字符的位置

myStr.format() #字符串格式化myStr.format_map()　#字符串格式化,参数为字典，key对应字符串{}里的参数名，value则是替换的值

1 myStr="Test:{}"

2 print(myStr.format("456"))3 #输出 Test:456

4 myStr="Test1:{param1},Test2 {param2}"

5 print(myStr.format(param2="456",param1=123))6 #输出 Test1:123,Test2 456

7 myStr="Test1:{1},Test2 {0}"

8 print(myStr.format("456",123))9 #输出 Test1:123,Test2 456

10 myStr="Test1:{param1},Test2 {param2}"

11 print(myStr.format_map({"param1":123,"param2":"456"}))12 #输出 Test1:123,Test2 456

myStr.join(list) #参数只能是字符串列表，将这个列表连成字符串，并在每个元素之间加上myStr

1 myStr="/"

2 print(myStr.join(['C:','dir1','dir2']))

输出结果：

C:/dir1/dir2

myStr.lower()　　　　　　　　　　 #大写的字母转小写

myStr.upper()　　　　　　　　　　 #小写的字母转大写

myStr.swapcase()　　　　 　　　 #小写转大写，大写转小写

myStr.replace(oldstr,newstr)　 #替换

myStr.strip(str) 　　　　 　　　 #去掉字符串两端的子串或字符,不传参数默认去空格

myStr.lstrip()　　　　　　　　　　 #只去掉左边的

myStr.rstrip()　　　　　　　　　　 #只去掉右边的

myStr.split()　　　　　　　　　　 #字符串根据某个字符或子串切割成字典

1 myStr="1+2+3+4"

2 print(myStr.split("+"))

输出结果:

['1', '2', '3', '4']

字符串切片：截取字符串的一部分,跟下面的列表切片一样

4.列表

python的列表跟C++的vector有点像,但是比vector方便很多,功能也强大一些

python的一个列表里可以存多种类型的数据,可以把整型\浮点型\字符串等类型的数据都放在同一个列表里,甚至还可以嵌套列表和字典等,如:

1 　myList=[1,2.12,'3','4',5,[456,789],{"a":123}]

索引:列表里数据的序号,从0开始,即在myList中0是1的索引,1是2.12的索引

元素:列表里的数据即为元素,每个索引对应一个元素,在myList中索引5对应的元素为[456,789]

增删改查:

1 #增

2 myList.append(value) #在尾部插入元素value

3 myList.insert(index,value) #在index的位置插入value,后面的元素往后移

4 #删

5 myList.remove(value) #删除列表中第一个值为value的元素

6 myList.pop(1) #删除列表中第一个值为value的元素,不传参数则默认删除最后一个元素

7 del myList[1] #删除索引为1的元素,后面的元素往前移

8 myList.clear() #清空列表里所有的元素

9 #改

10 myList[1]=2 #将索引为1的元素的值改为2

11 #查

12 myList[1] #获取索引为1的元素的值

切片:截取列表的部分元素

myList[begin:end] #截取索引为begin-end(不包括end)的元素，begin缺省值为0,end缺省值为列表最后一个索引+1(即返回值包括最后一个元素)

1 myList=[1,4,3,5,2]2 myList[1:3] 　　 　 　　 #返回[4,3]

3 myList[1:-1] 　 　　　　 #返回[4,3,5]，索引-1 表示列表最后一个元素的索引

4 myList[2:] 　　　 　　 #返回[3,5,2]

5 myList[:]或myList[0:]　 #获取所有元素

myList[begin::interval] #从索引begin开始(包括begin)每隔(interval-1)获取一个元素,begin缺省值为0

myList=[1,2,3,4,5,6,7,8,9]

myList[1::1] 　　　　　　　　#返回[1,2,3,4,5,6,7,8,9]

myList[1::2] 　　　　　　　　#返回[1,3,5,7,9]

其他操作:

myList.reverse() 　　#列表翻转

myList.sort() 　　 #列表从小到大排序,列表里的元素需是同种类型,字符串按首字母ascii码排序,第一个字符相同,则根据第二个字符排序,列表里嵌套列表排序规则跟字符串排序一致

myList.extend(myList2) #在myList中并入myList2

1 myList=[1,2,3]2 myList2=[4,5,6]3 print(myList)4 myList.extend(myList2)5 print(myList)

程序执行结果:

[1, 2, 3]

[1, 2, 3, 4, 5, 6]

复制:

直接用"="

其实直接用"="并不是复制，只是把列表的地址赋值给另一个变量而已，跟C语言的指针一样，并不会复制多一份数据。

1 myList1=[1,2,3,4,5]2 myList2=myList13 print(myList1)4 print(myList2)5 #上面两个print的结果都是[1,2,3,4,5]

6 #修改数据之后再打印

7 myList1[1]=08 print(myList1)9 print(myList2)10 #myList1和myList2都变成了[1,0,2,3,4,5]

用列表自带的copy()方法

1 list1=[12,456,789,3658,45]2 list2=list1.copy() #复制list1到list2

3 print(list1)4 print(list2) #可以看到打印结果是一样的

5 list1[2]=0 #修改list1索引为2的元素,即将789改为0

6 list2[2]=1　　　　　 #修改list1索引为2的元素,即将789改为1

7 print(list1)8 print(list2) #分别打印list1和list2

程序执行结果:

[12, 456, 789, 3658, 45]

[12, 456, 789, 3658, 45]

[12, 456, 0, 3658, 45]

[12, 456, 1, 3658, 45]

从执行结果看list1和list2里是独立的数据，修改其中一个列表的数据并不会影响到另一个列表的数据。但是这也并不是完全复制，只能复制列表的第一层，如果列表里嵌套列表了，那就不一样了。

例如:

list1=[12,456,789,[123,456,789],3658,45] #在list1里嵌套列表[123,456,789]

list2=list1.copy()print(list1)print(list2)

list1[3][1]=0 #将list[3][1]即456改为0

print(list1)print(list2)

程序执行结果:

[12, 456, 789, [123, 456, 789], 3658, 45]

[12, 456, 789, [123, 456, 789], 3658, 45]

[12, 456, 789, [123, 0, 789], 3658, 45]

[12, 456, 789, [123, 0, 789], 3658, 45]

可以看到只是改变了list1里的数据，但是list2里的数据还是变了，因为复制时只复制了里面这个列表的地址，所以在修改里面这个列表的值的时候，两个列表都会改变。

copy模块

模块:模块就是别人写好的功能，导入模块之后就能用别人写好的功能了，其实就跟c++的类库一样，就是导入别人写好的函数和类，然后就可以用了

copy.copy() #这个跟列表自带的copy()方法一样，也是只能复制一层的数据，用法如下：

1 import copy #导入模块：import 模块名

2 list1=[12,456,789,3658,45]3 list2=copy.copy(list1) #复制list1的数据

copy.deepcopy() #这个就是完全复制了，无论列表里嵌套了多少列表都会将数据复制多一份，用法与copy.copy()一样

list2=list1[:] #用列表切片的方法来复制,浅复制

list2=list(list1) #list方法，不传参数则返回一个空列表,浅复制

5.元组

myTuple=(1,2,3,4,5) #元组就是不能修改的列表

6.字典

跟C语言的map类似，每一个key对应一个value

myDict={"name":"博客园","url":"https://home.cnblogs.com/blog/"}

"name"和"url"是key,"博客园"和"https://home.cnblogs.com/blog/"是value,通过key获取对应的value

增删改查:

1 #查:

2 myDict["name"]　　　　　　　　 #直接获取,不存在则报错

3 myDict.get("name"，value)　 　　　#不存在这个key则返回value,value缺省值为None

4 myDict.setdefault("name") 　　 #不存在这个key则创建,value为None

5 #增:

6 myDict["ID"]=5　　　　　　　　　　　#直接通过新key赋值

7 #改:

8 myDict["name"]="bokeyuan"　　　　 #通过key进行赋值

9 myDict.update(key=value)　　　　 #key存在则修改,不存在则创建

10 #删:

11 myDict.pop(key)12 delmyDict[key]13 myDict.popitem()　　　　　　　　　 #随机删除一个

7.集合

创建集合

mySet1={1,2,3,4,5}

mySet2=set([3,4,5,6])

操作:

1 mySet1.intersection(mySet2) #求交集

2 mySet1.union(mySet2) #求并集

3 mySet1.difference(mySet2) #求差集

4 mySet1.issubset(mySet2) #判断mySet1是否是mySet2子集

5 mySet1.issuperset(mySet2) #判断mySet1是否是mySet2补集

6 mySet1.isdisjoint(mySet2) #判断是否没有交集,没有交集返回True

7 mySet1.symmetric_difference(mySet2) #去掉交集,剩下的组成一个集合

8 mySet1.add(element) #增加元素

9 mySet1.update(set) #批量增加元素,参数可以是列表、元组、集合

10 mySet1.remove(element) #删除一个元素