Python（7）-Python基础数据类型

数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视

频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种

一 Number(数字)

1.1 数字类型的创建

1 a=10
2 b=a
3 b=666
4   
5 print(a)
6 ---->10
7 print(b)
8 ---->666

注意这里与C的不同：

 1 #include <stdio.h>
 2 void main(void)
 3 {
 4   
 5     int a = 1;
 6     int b = a;
 7     printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
 8     a = 3;
 9     printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
10   
11 }
12   
13 //打印结果：
14 topeet@ubuntu:~$ gcc test.c
15 topeet@ubuntu:~$ ./a.out
16 a:adr:0x7fff343a069c,val:1
17 b:adr:0x7fff343a0698,val:1
18 a:adr:0x7fff343a069c,val:3
19 b:adr:0x7fff343a0698,val:1

1.2 Number 类型转换

1 var1=3.14
2 var2=5
3 var3=int(var1)  # 取整数部分
4 var4=float(var2)  #保留小数点后的数
5   
6 print(var3,var4)
7 ---->3 5.0

python内置数学函数

 1 #abs(x)    　　　　    返回数字的绝对值，如abs(-10) 返回 10
 2 # ceil(x)    　　      返回数字的上入整数，如math.ceil(4.1) 返回 5
 3 # cmp(x, y)   　　     如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
 4 # exp(x)              返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
 5 # fabs(x)             返回数字的绝对值，如math.fabs(-10) 返回10.0
 6 # floor(x)            返回数字的下舍整数，如math.floor(4.9)返回 4
 7 # log(x)              如math.log(math.e)返回1.0,math.log(100,10)返回2.0
 8 # log10(x)            返回以10为基数的x的对数，如math.log10(100)返回 2.0
 9 # max(x1, x2,...)     返回给定参数的最大值，参数可以为序列。
10 # min(x1, x2,...)     返回给定参数的最小值，参数可以为序列。
11 # modf(x)             返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
12 # pow(x, y)           x**y 运算后的值。
13 # round(x [,n])       返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。python3中小数点一位为5，则返回离整数最近的偶数。
14 # sqrt(x)             返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

二字符串类型（string）

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"123"等等。

请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比

扫描二维码关注公众号，回复： 1948053 查看本文章

如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

2.1 创建字符串：

1 var1 = 'Hello World!'
2 var2 = "Python chenxiaomei"

字符串操作：

 1 #   * 重复输出字符串
 2 print('hello'*2)
 3 --->hellohello
 4   
 5 #  [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
 6 print('helloworld'[2:])
 7 --->lloworld
 8   
 9 # in  成员运算符 - 如果字符串中包含给定的字符返回 True
10 print('el' in 'hello')
11 --->True
12   
13 #  %   格式字符串
14 print('cxm is a good girl')
15 print('%s is a good girl'%'cxm')
16 --->cxm is a good girl
17   
18 #  +   字符串拼接
19 a='123'
20 b='abc'
21 c='789'
22 d1=a+b+c
23 print(d1)
24 --->123abc789
25  
26 # +效率低,占内存多，该用join
27 d2=''.join([a,b,c])
28 print(d2)
29 --->123abc789

python字符串内置方法

 1 # string.capitalize()                                  把字符串的第一个字符大写
 2 # string.center(width)                                 返回内容是原字符串居中,并使用空格填充至长度为 width 的新字符串
 3 # string.count(str, beg=0, end=len(string))            返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
 4 # string.decode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
 5 # string.encode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
 6 # string.endswith(obj, beg=0, end=len(string))         检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
 7 # string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
 8 # string.find(str, beg=0, end=len(string))             检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
 9 # string.index(str, beg=0, end=len(string))            跟find()方法一样，只不过如果str不在 string中会报一个异常.
10 # string.isalnum()                                     如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
11 # string.isalpha()                                     如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
12 # string.isdecimal()                                   如果 string 只包含十进制数字则返回 True 否则返回 False.
13 # string.isdigit()                                     如果 string 只包含数字则返回 True 否则返回 False.
14 # string.islower()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
15 # string.isnumeric()                                   如果 string 中只包含数字字符，则返回 True，否则返回 False
16 # string.isspace()                                     如果 string 中只包含空格，则返回 True，否则返回 False.
17 # string.istitle()                                     如果 string 是标题化的(见 title())则返回 True，否则返回 False
18 # string.isupper()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
19 # string.join(seq)                                     以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
20 # string.ljust(width)                                  返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
21 # string.lower()                                       转换 string 中所有大写字符为小写.
22 # string.lstrip()                                      截掉 string 左边的空格
23 # string.maketrans(intab, outtab])                     maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24 # max(str)                                             返回字符串 str 中最大的字母。
25 # min(str)                                             返回字符串 str 中最小的字母。
26 # string.partition(str)                                有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
27 # string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
28 # string.rfind(str, beg=0,end=len(string) )            类似于 find()函数，不过是从右边开始查找.
29 # string.rindex( str, beg=0,end=len(string))           类似于 index()，不过是从右边开始.
30 # string.rjust(width)                                  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
31 # string.rpartition(str)                               类似于 partition()函数,不过是从右边开始查找.
32 # string.rstrip()                                      删除 string 字符串末尾的空格.
33 # string.split(str="", num=string.count(str))          以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
34 # string.splitlines(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
35 # string.startswith(obj, beg=0,end=len(string))        检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
36 # string.strip([obj])                                  在 string 上执行 lstrip()和 rstrip()
37 # string.swapcase()                                    翻转 string 中的大小写
38 # string.title()                                       返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
39 # string.translate(str, del="")                        根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
40 # string.upper()                                       转换 string 中的小写字母为大写

三字节类型(bytes)

 1 # a=bytes('hello','utf8')
 2 # a=bytes('中国','utf8')
 3   
 4   
 5 a=bytes('中国','utf8')
 6 b=bytes('hello','gbk')
 7 #
 8 print(a)        #b'\xe4\xb8\xad\xe5\x9b\xbd'
 9 print(b)　　　　 #b'hello'
10 print(ord('h')) #其十进制 unicode 值为: 104
11 print(ord('中'))#其十进制 unicode 值为:20013
12   
13 #  h   e  l   l   o
14 # 104 101 108 108 111   编码后结果:与ASCII表对应
15   
16   
17 #     中                国
18 #   \xd6\xd0         \xb9\xfa       gbk编码后的字节结果
19 #\xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8编码后的字节结果
20 # 228 184 173      229 155  189        a[:]切片取
21   
22   
23 c=a.decode('utf8')
24 d=b.decode('gbk')
25 #c=a.decode('gbk') :很明显报错
26   
27 print(c) #中国
28 print(d) #hello

注意：对于 ASCII 字符串，因为无论哪种编码对应的结果都是一样的，所以可以直接使用 b'xxxx' 赋值创建 bytes 实例，但对于非 ASCII 编码的字符则不能通过这

种方式创建 bytes 实例，需要指明编码方式。

1 b1=b'123'
2 print(type(b1))
3 # b2=b'中国' #报错
4 # 所以得这样:
5 b2=bytes('中国','utf8')
6 print(b2)#b'\xe4\xb8\xad\xe5\x9b\xbd'

四布尔值

一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写）

1 print(True)
2 print(4>2)
3 print(bool([3,4]))
4 print(True+1)

与或非操作：

1 bool(1 and 0)
2 bool(1 and 1)
3 bool(1 or 0)
4 bool(not 0)

布尔值经常用在条件判断中:

1 age=18
2 if age>18:#bool(age>18)
3     print('old')
4 else:
5     print('young')

五 List（列表）

OK,现在我们知道了字符串和整型两个数据类型了，那需求来了，我想把某个班所有的名字存起来，怎么办？

有同学说，不是学变量存储了吗，我就用变量存储呗，呵呵，不嫌累吗，同学，如班里有一百个人，你就得创建一百个变量啊，消耗大，效率低。

又有同学说，我用个大字符串不可以吗，没问题，你的确存起来了，但是，你对这个数据的操作（增删改查）将变得非常艰难，不是吗，我想知道张三的位置，你怎么办？

在这种需求下，编程语言有了一个重要的数据类型－－－－列表（list）

什么是列表：

列表（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。

对应操作：

1 查（［］）

 1 names_class2=['张三','李四','王五','赵六']
 2  
 3 # print(names_class2[2])
 4 # print(names_class2[0:3])
 5 # print(names_class2[0:7])
 6 # print(names_class2[-1])
 7 # print(names_class2[2:3])
 8 # print(names_class2[0:3:1])
 9 # print(names_class2[3:0:-1])
10 # print(names_class2[:])

2 增（append，insert）

insert 方法用于将对象插入到列表中，而append方法则用于在列表末尾追加新的对象

1 names_class2.append('xuyaping')
2 names_class2.insert(2,'alvin')
3 print(names_class2)

3 改（重新赋值）

1 names_class2=['张三','李四','王五','赵六']
2  
3 names_class2[3]='赵七'
4 names_class2[0:2]=['wusir','alvin']
5 print(names_class2)

4 删（remove，del，pop）

1 names_class2.remove('xuyaping')
2 del names_class2[0]
3 del names_class2
4 names_class2.pop()#注意,pop是有一个返回值的

5 其他操作

5.1 count

count 方法统计某个元素在列表中出现的次数：

1 >>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 
2 2 
3 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] 
4 >>> x.count(1) 
5 2 
6 >>> x.count([1,2]) 
7 1

5.2 extend

extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

1 >>> a = [1, 2, 3] 
2 >>> b = [4, 5, 6] 
3 >>> a.extend(b) 
4 >>> a 
5 [1, 2, 3, 4, 5, 6]

extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

 1 >>> a = [1, 2, 3] 
 2 >>> b = [4, 5, 6] 
 3 >>> a.extend(b) 
 4 >>> a 
 5 [1, 2, 3, 4, 5, 6] 
 6 >>> 
 7 >>> a + b 
 8 [1, 2, 3, 4, 5, 6, 4, 5, 6] 
 9 >>> a 
10 [1, 2, 3, 4, 5, 6]

5.3 index

index 方法用于从列表中找出某个值第一个匹配项的索引位置：　

1 names_class2.index('李四')

5.4 reverse

reverse 方法将列表中的元素反向存放。

1 names_class2.reverse()
2 print(names_class2)

5.5 sort

sort 方法用于在原位置对列表进行排序。

1 x = [4, 6, 2, 1, 7, 9]
2 x.sort()#x.sort(reverse=True)
3 print(x)  # [1, 2, 4, 6, 7, 9]

5.6 深浅拷贝

现在，大家先不要理会什么是深浅拷贝，听我说，对于一个列表，我想复制一份怎么办呢？

肯定会有同学说，重新赋值呗：

1 names_class1=['张三','李四','王五','赵六']
2 names_class1_copy=['张三','李四','王五','赵六']

这是两块独立的内存空间

这也没问题，还是那句话，如果列表内容做够大，你真的可以要每一个元素都重新写一遍吗？当然不啦，所以列表里为我们内置了copy方法：

 1 names_class1=['张三','李四','王五','赵六',[1,2,3]]
 2 names_class1_copy=names_class1.copy()
 3  
 4 names_class1[0]='zhangsan'
 5 print(names_class1)　　　　　　# ['zhangsan', '李四', '王五', '赵六', [1, 2, 3]]
 6 print(names_class1_copy)　　　# ['张三', '李四', '王五', '赵六', [1, 2, 3]]
 7  
 8 ############
 9 names_class1[4][2]=5
10 print(names_class1)　　　　　　# ['zhangsan', '李四', '王五', '赵六', [1, 2, 5]]
11 print(names_class1_copy) 　　 # ['张三','李四','王五','赵六',[1,2,5]]
12 #问题来了,为什么names_class1_copy,从这一点我们可以断定,这两个变量并不是完全独立的,那他们的关系是什么呢?为什么有的改变,有的不改变呢?

这里就涉及到我们要讲的深浅拷贝了：

 1 #不可变数据类型:数字,字符串,元组         可变类型:列表,字典
 2 l=[2,2,3]
 3 print(id(l))  # 35557064
 4 l[0]=5
 5 print(id(l))  # 35557064  # 当你对可变类型进行修改时,比如这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
 6                # this is the most important
 7 
 8 s='alex'
 9 print(id(s))   #像字符串,列表,数字这些不可变数据类型,,是不能修改的,比如我想要一个'Alex'的字符串,只能重新创建一个'Alex'的对象,然后让指针只想这个新对象
10 
11 s[0]='e'       #报错
12 print(id(s))
13 
14 #重点:浅拷贝
15 a=[[1,2],3,4]
16 b=a[:]#b=a.copy()
17 
18 # id地址全相同
19 print(a,b)  # [[1, 2], 3, 4] [[1, 2], 3, 4]
20 print(id(a),id(b))  # 41848776 41869448
21 print('*************')
22 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))  # a[0]: 41848712 b[0]: 41848712
23 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))  # a[0][0]: 2006304432 b[0][0]: 2006304432
24 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
25 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
26 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528
27 
28 
29 print('___________________________________________')
30 b[0][0]=8  #[1, 2]--》[8, 2]
31 
32 
33 print(a,b)  # [[8, 2], 3, 4] [[8, 2], 3, 4]
34 print(id(a),id(b))  # 35893576 35893704
35 print('*************')
36 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))  # a[0]: 35893512 b[0]: 35893512
37 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))  # a[0][0]: 2006304656 b[0][0]: 2006304656
38 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
39 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
40 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528

 1 #不可变数据类型:数字,字符串,元组         可变类型:列表,字典
 2 l=[2,2,3]
 3 print(id(l))  # 35557064
 4 l[0]=5
 5 print(id(l))  # 35557064  # 当你对可变类型进行修改时,比如这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
 6                # this is the most important
 7 
 8 s='alex'
 9 print(id(s))   #像字符串,列表,数字这些不可变数据类型,,是不能修改的,比如我想要一个'Alex'的字符串,只能重新创建一个'Alex'的对象,然后让指针只想这个新对象
10 
11 s[0]='e'       #报错
12 print(id(s))
13 
14 #重点:浅拷贝
15 a=[[1,2],3,4]
16 b=a[:]#b=a.copy()
17 
18 # id地址全相同
19 print(a,b)  # [[1, 2], 3, 4] [[1, 2], 3, 4]
20 print(id(a),id(b))  # 41848776 41869448
21 print('*************')
22 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))  # a[0]: 41848712 b[0]: 41848712
23 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))  # a[0][0]: 2006304432 b[0][0]: 2006304432
24 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
25 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
26 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528
27 
28 
29 print('___________________________________________')
30 b[0][0]=8  #[1, 2]--》[8, 2]
31 
32 
33 print(a,b)  # [[8, 2], 3, 4] [[8, 2], 3, 4]
34 print(id(a),id(b))  # 35893576 35893704
35 print('*************')
36 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))  # a[0]: 35893512 b[0]: 35893512
37 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))  # a[0][0]: 2006304656 b[0][0]: 2006304656
38 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))  # a[0][1]: 2006304464 b[0][1]: 2006304464
39 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))  # a[1]: 2006304496 b[1]: 2006304496
40 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))  # a[2]: 2006304528 b[2]: 2006304528

那么怎么解释这样的一个结果呢？